From a2971e7ee2c5775777f16b2f14a176fd6195b8ec Mon Sep 17 00:00:00 2001 From: Daniel Rojas Date: Sun, 24 May 2020 21:46:02 +0200 Subject: [PATCH 01/11] Improve handling of single connections in Cable.connect() --- src/wireviz.py | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/src/wireviz.py b/src/wireviz.py index 5116933..d39282b 100644 --- a/src/wireviz.py +++ b/src/wireviz.py @@ -191,6 +191,8 @@ class Node: self.loops = [] if pinout is None: + if num_pins is None: + num_pins = 1 self.pinout = ('',) * num_pins else: if num_pins is None: @@ -252,6 +254,9 @@ class Cable: via = tuple(x+1 for x in range(len(self.colors))) if to_pin == 'auto': to_pin = tuple(x+1 for x in range(len(self.colors))) + from_pin = int2tuple(from_pin) + via = int2tuple(via) + to_pin = int2tuple(to_pin) if len(from_pin) != len(to_pin): raise Exception('from_pin must have the same number of elements as to_pin') for i, x in enumerate(from_pin): @@ -275,6 +280,13 @@ def nested(input): s = '|'.join(l) return s +def int2tuple(input): + if isinstance(input, tuple): + output = input + else: + output = (input,) + return output + def translate_color(input, color_mode): if input == '': output = '' From 841dd6efcf2bbdbf32efe5f23a2b1ceb0f17a596 Mon Sep 17 00:00:00 2001 From: Daniel Rojas Date: Sun, 24 May 2020 21:47:58 +0200 Subject: [PATCH 02/11] Add .txt exension to LICENSE file --- LICENSE => LICENSE.txt | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename LICENSE => LICENSE.txt (100%) diff --git a/LICENSE b/LICENSE.txt similarity index 100% rename from LICENSE rename to LICENSE.txt From 6b2da96865b2b7a01eab9b96ad02dfb8689ce1b5 Mon Sep 17 00:00:00 2001 From: Daniel Rojas Date: Mon, 25 May 2020 19:18:49 +0200 Subject: [PATCH 03/11] Add pyyaml module --- src/yaml/__init__.py | 427 ++++++++++++ src/yaml/composer.py | 139 ++++ src/yaml/constructor.py | 748 ++++++++++++++++++++ src/yaml/cyaml.py | 101 +++ src/yaml/dumper.py | 62 ++ src/yaml/emitter.py | 1137 +++++++++++++++++++++++++++++++ src/yaml/error.py | 75 ++ src/yaml/events.py | 86 +++ src/yaml/loader.py | 63 ++ src/yaml/nodes.py | 49 ++ src/yaml/parser.py | 589 ++++++++++++++++ src/yaml/reader.py | 185 +++++ src/yaml/representer.py | 389 +++++++++++ src/yaml/resolver.py | 227 +++++++ src/yaml/scanner.py | 1435 +++++++++++++++++++++++++++++++++++++++ src/yaml/serializer.py | 111 +++ src/yaml/tokens.py | 104 +++ 17 files changed, 5927 insertions(+) create mode 100644 src/yaml/__init__.py create mode 100644 src/yaml/composer.py create mode 100644 src/yaml/constructor.py create mode 100644 src/yaml/cyaml.py create mode 100644 src/yaml/dumper.py create mode 100644 src/yaml/emitter.py create mode 100644 src/yaml/error.py create mode 100644 src/yaml/events.py create mode 100644 src/yaml/loader.py create mode 100644 src/yaml/nodes.py create mode 100644 src/yaml/parser.py create mode 100644 src/yaml/reader.py create mode 100644 src/yaml/representer.py create mode 100644 src/yaml/resolver.py create mode 100644 src/yaml/scanner.py create mode 100644 src/yaml/serializer.py create mode 100644 src/yaml/tokens.py diff --git a/src/yaml/__init__.py b/src/yaml/__init__.py new file mode 100644 index 0000000..13d687c --- /dev/null +++ b/src/yaml/__init__.py @@ -0,0 +1,427 @@ + +from .error import * + +from .tokens import * +from .events import * +from .nodes import * + +from .loader import * +from .dumper import * + +__version__ = '5.3.1' +try: + from .cyaml import * + __with_libyaml__ = True +except ImportError: + __with_libyaml__ = False + +import io + +#------------------------------------------------------------------------------ +# Warnings control +#------------------------------------------------------------------------------ + +# 'Global' warnings state: +_warnings_enabled = { + 'YAMLLoadWarning': True, +} + +# Get or set global warnings' state +def warnings(settings=None): + if settings is None: + return _warnings_enabled + + if type(settings) is dict: + for key in settings: + if key in _warnings_enabled: + _warnings_enabled[key] = settings[key] + +# Warn when load() is called without Loader=... +class YAMLLoadWarning(RuntimeWarning): + pass + +def load_warning(method): + if _warnings_enabled['YAMLLoadWarning'] is False: + return + + import warnings + + message = ( + "calling yaml.%s() without Loader=... is deprecated, as the " + "default Loader is unsafe. Please read " + "https://msg.pyyaml.org/load for full details." + ) % method + + warnings.warn(message, YAMLLoadWarning, stacklevel=3) + +#------------------------------------------------------------------------------ +def scan(stream, Loader=Loader): + """ + Scan a YAML stream and produce scanning tokens. + """ + loader = Loader(stream) + try: + while loader.check_token(): + yield loader.get_token() + finally: + loader.dispose() + +def parse(stream, Loader=Loader): + """ + Parse a YAML stream and produce parsing events. + """ + loader = Loader(stream) + try: + while loader.check_event(): + yield loader.get_event() + finally: + loader.dispose() + +def compose(stream, Loader=Loader): + """ + Parse the first YAML document in a stream + and produce the corresponding representation tree. + """ + loader = Loader(stream) + try: + return loader.get_single_node() + finally: + loader.dispose() + +def compose_all(stream, Loader=Loader): + """ + Parse all YAML documents in a stream + and produce corresponding representation trees. + """ + loader = Loader(stream) + try: + while loader.check_node(): + yield loader.get_node() + finally: + loader.dispose() + +def load(stream, Loader=None): + """ + Parse the first YAML document in a stream + and produce the corresponding Python object. + """ + if Loader is None: + load_warning('load') + Loader = FullLoader + + loader = Loader(stream) + try: + return loader.get_single_data() + finally: + loader.dispose() + +def load_all(stream, Loader=None): + """ + Parse all YAML documents in a stream + and produce corresponding Python objects. + """ + if Loader is None: + load_warning('load_all') + Loader = FullLoader + + loader = Loader(stream) + try: + while loader.check_data(): + yield loader.get_data() + finally: + loader.dispose() + +def full_load(stream): + """ + Parse the first YAML document in a stream + and produce the corresponding Python object. + + Resolve all tags except those known to be + unsafe on untrusted input. + """ + return load(stream, FullLoader) + +def full_load_all(stream): + """ + Parse all YAML documents in a stream + and produce corresponding Python objects. + + Resolve all tags except those known to be + unsafe on untrusted input. + """ + return load_all(stream, FullLoader) + +def safe_load(stream): + """ + Parse the first YAML document in a stream + and produce the corresponding Python object. + + Resolve only basic YAML tags. This is known + to be safe for untrusted input. + """ + return load(stream, SafeLoader) + +def safe_load_all(stream): + """ + Parse all YAML documents in a stream + and produce corresponding Python objects. + + Resolve only basic YAML tags. This is known + to be safe for untrusted input. + """ + return load_all(stream, SafeLoader) + +def unsafe_load(stream): + """ + Parse the first YAML document in a stream + and produce the corresponding Python object. + + Resolve all tags, even those known to be + unsafe on untrusted input. + """ + return load(stream, UnsafeLoader) + +def unsafe_load_all(stream): + """ + Parse all YAML documents in a stream + and produce corresponding Python objects. + + Resolve all tags, even those known to be + unsafe on untrusted input. + """ + return load_all(stream, UnsafeLoader) + +def emit(events, stream=None, Dumper=Dumper, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None): + """ + Emit YAML parsing events into a stream. + If stream is None, return the produced string instead. + """ + getvalue = None + if stream is None: + stream = io.StringIO() + getvalue = stream.getvalue + dumper = Dumper(stream, canonical=canonical, indent=indent, width=width, + allow_unicode=allow_unicode, line_break=line_break) + try: + for event in events: + dumper.emit(event) + finally: + dumper.dispose() + if getvalue: + return getvalue() + +def serialize_all(nodes, stream=None, Dumper=Dumper, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding=None, explicit_start=None, explicit_end=None, + version=None, tags=None): + """ + Serialize a sequence of representation trees into a YAML stream. + If stream is None, return the produced string instead. + """ + getvalue = None + if stream is None: + if encoding is None: + stream = io.StringIO() + else: + stream = io.BytesIO() + getvalue = stream.getvalue + dumper = Dumper(stream, canonical=canonical, indent=indent, width=width, + allow_unicode=allow_unicode, line_break=line_break, + encoding=encoding, version=version, tags=tags, + explicit_start=explicit_start, explicit_end=explicit_end) + try: + dumper.open() + for node in nodes: + dumper.serialize(node) + dumper.close() + finally: + dumper.dispose() + if getvalue: + return getvalue() + +def serialize(node, stream=None, Dumper=Dumper, **kwds): + """ + Serialize a representation tree into a YAML stream. + If stream is None, return the produced string instead. + """ + return serialize_all([node], stream, Dumper=Dumper, **kwds) + +def dump_all(documents, stream=None, Dumper=Dumper, + default_style=None, default_flow_style=False, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding=None, explicit_start=None, explicit_end=None, + version=None, tags=None, sort_keys=True): + """ + Serialize a sequence of Python objects into a YAML stream. + If stream is None, return the produced string instead. + """ + getvalue = None + if stream is None: + if encoding is None: + stream = io.StringIO() + else: + stream = io.BytesIO() + getvalue = stream.getvalue + dumper = Dumper(stream, default_style=default_style, + default_flow_style=default_flow_style, + canonical=canonical, indent=indent, width=width, + allow_unicode=allow_unicode, line_break=line_break, + encoding=encoding, version=version, tags=tags, + explicit_start=explicit_start, explicit_end=explicit_end, sort_keys=sort_keys) + try: + dumper.open() + for data in documents: + dumper.represent(data) + dumper.close() + finally: + dumper.dispose() + if getvalue: + return getvalue() + +def dump(data, stream=None, Dumper=Dumper, **kwds): + """ + Serialize a Python object into a YAML stream. + If stream is None, return the produced string instead. + """ + return dump_all([data], stream, Dumper=Dumper, **kwds) + +def safe_dump_all(documents, stream=None, **kwds): + """ + Serialize a sequence of Python objects into a YAML stream. + Produce only basic YAML tags. + If stream is None, return the produced string instead. + """ + return dump_all(documents, stream, Dumper=SafeDumper, **kwds) + +def safe_dump(data, stream=None, **kwds): + """ + Serialize a Python object into a YAML stream. + Produce only basic YAML tags. + If stream is None, return the produced string instead. + """ + return dump_all([data], stream, Dumper=SafeDumper, **kwds) + +def add_implicit_resolver(tag, regexp, first=None, + Loader=None, Dumper=Dumper): + """ + Add an implicit scalar detector. + If an implicit scalar value matches the given regexp, + the corresponding tag is assigned to the scalar. + first is a sequence of possible initial characters or None. + """ + if Loader is None: + loader.Loader.add_implicit_resolver(tag, regexp, first) + loader.FullLoader.add_implicit_resolver(tag, regexp, first) + loader.UnsafeLoader.add_implicit_resolver(tag, regexp, first) + else: + Loader.add_implicit_resolver(tag, regexp, first) + Dumper.add_implicit_resolver(tag, regexp, first) + +def add_path_resolver(tag, path, kind=None, Loader=None, Dumper=Dumper): + """ + Add a path based resolver for the given tag. + A path is a list of keys that forms a path + to a node in the representation tree. + Keys can be string values, integers, or None. + """ + if Loader is None: + loader.Loader.add_path_resolver(tag, path, kind) + loader.FullLoader.add_path_resolver(tag, path, kind) + loader.UnsafeLoader.add_path_resolver(tag, path, kind) + else: + Loader.add_path_resolver(tag, path, kind) + Dumper.add_path_resolver(tag, path, kind) + +def add_constructor(tag, constructor, Loader=None): + """ + Add a constructor for the given tag. + Constructor is a function that accepts a Loader instance + and a node object and produces the corresponding Python object. + """ + if Loader is None: + loader.Loader.add_constructor(tag, constructor) + loader.FullLoader.add_constructor(tag, constructor) + loader.UnsafeLoader.add_constructor(tag, constructor) + else: + Loader.add_constructor(tag, constructor) + +def add_multi_constructor(tag_prefix, multi_constructor, Loader=None): + """ + Add a multi-constructor for the given tag prefix. + Multi-constructor is called for a node if its tag starts with tag_prefix. + Multi-constructor accepts a Loader instance, a tag suffix, + and a node object and produces the corresponding Python object. + """ + if Loader is None: + loader.Loader.add_multi_constructor(tag_prefix, multi_constructor) + loader.FullLoader.add_multi_constructor(tag_prefix, multi_constructor) + loader.UnsafeLoader.add_multi_constructor(tag_prefix, multi_constructor) + else: + Loader.add_multi_constructor(tag_prefix, multi_constructor) + +def add_representer(data_type, representer, Dumper=Dumper): + """ + Add a representer for the given type. + Representer is a function accepting a Dumper instance + and an instance of the given data type + and producing the corresponding representation node. + """ + Dumper.add_representer(data_type, representer) + +def add_multi_representer(data_type, multi_representer, Dumper=Dumper): + """ + Add a representer for the given type. + Multi-representer is a function accepting a Dumper instance + and an instance of the given data type or subtype + and producing the corresponding representation node. + """ + Dumper.add_multi_representer(data_type, multi_representer) + +class YAMLObjectMetaclass(type): + """ + The metaclass for YAMLObject. + """ + def __init__(cls, name, bases, kwds): + super(YAMLObjectMetaclass, cls).__init__(name, bases, kwds) + if 'yaml_tag' in kwds and kwds['yaml_tag'] is not None: + if isinstance(cls.yaml_loader, list): + for loader in cls.yaml_loader: + loader.add_constructor(cls.yaml_tag, cls.from_yaml) + else: + cls.yaml_loader.add_constructor(cls.yaml_tag, cls.from_yaml) + + cls.yaml_dumper.add_representer(cls, cls.to_yaml) + +class YAMLObject(metaclass=YAMLObjectMetaclass): + """ + An object that can dump itself to a YAML stream + and load itself from a YAML stream. + """ + + __slots__ = () # no direct instantiation, so allow immutable subclasses + + yaml_loader = [Loader, FullLoader, UnsafeLoader] + yaml_dumper = Dumper + + yaml_tag = None + yaml_flow_style = None + + @classmethod + def from_yaml(cls, loader, node): + """ + Convert a representation node to a Python object. + """ + return loader.construct_yaml_object(node, cls) + + @classmethod + def to_yaml(cls, dumper, data): + """ + Convert a Python object to a representation node. + """ + return dumper.represent_yaml_object(cls.yaml_tag, data, cls, + flow_style=cls.yaml_flow_style) + diff --git a/src/yaml/composer.py b/src/yaml/composer.py new file mode 100644 index 0000000..6d15cb4 --- /dev/null +++ b/src/yaml/composer.py @@ -0,0 +1,139 @@ + +__all__ = ['Composer', 'ComposerError'] + +from .error import MarkedYAMLError +from .events import * +from .nodes import * + +class ComposerError(MarkedYAMLError): + pass + +class Composer: + + def __init__(self): + self.anchors = {} + + def check_node(self): + # Drop the STREAM-START event. + if self.check_event(StreamStartEvent): + self.get_event() + + # If there are more documents available? + return not self.check_event(StreamEndEvent) + + def get_node(self): + # Get the root node of the next document. + if not self.check_event(StreamEndEvent): + return self.compose_document() + + def get_single_node(self): + # Drop the STREAM-START event. + self.get_event() + + # Compose a document if the stream is not empty. + document = None + if not self.check_event(StreamEndEvent): + document = self.compose_document() + + # Ensure that the stream contains no more documents. + if not self.check_event(StreamEndEvent): + event = self.get_event() + raise ComposerError("expected a single document in the stream", + document.start_mark, "but found another document", + event.start_mark) + + # Drop the STREAM-END event. + self.get_event() + + return document + + def compose_document(self): + # Drop the DOCUMENT-START event. + self.get_event() + + # Compose the root node. + node = self.compose_node(None, None) + + # Drop the DOCUMENT-END event. + self.get_event() + + self.anchors = {} + return node + + def compose_node(self, parent, index): + if self.check_event(AliasEvent): + event = self.get_event() + anchor = event.anchor + if anchor not in self.anchors: + raise ComposerError(None, None, "found undefined alias %r" + % anchor, event.start_mark) + return self.anchors[anchor] + event = self.peek_event() + anchor = event.anchor + if anchor is not None: + if anchor in self.anchors: + raise ComposerError("found duplicate anchor %r; first occurrence" + % anchor, self.anchors[anchor].start_mark, + "second occurrence", event.start_mark) + self.descend_resolver(parent, index) + if self.check_event(ScalarEvent): + node = self.compose_scalar_node(anchor) + elif self.check_event(SequenceStartEvent): + node = self.compose_sequence_node(anchor) + elif self.check_event(MappingStartEvent): + node = self.compose_mapping_node(anchor) + self.ascend_resolver() + return node + + def compose_scalar_node(self, anchor): + event = self.get_event() + tag = event.tag + if tag is None or tag == '!': + tag = self.resolve(ScalarNode, event.value, event.implicit) + node = ScalarNode(tag, event.value, + event.start_mark, event.end_mark, style=event.style) + if anchor is not None: + self.anchors[anchor] = node + return node + + def compose_sequence_node(self, anchor): + start_event = self.get_event() + tag = start_event.tag + if tag is None or tag == '!': + tag = self.resolve(SequenceNode, None, start_event.implicit) + node = SequenceNode(tag, [], + start_event.start_mark, None, + flow_style=start_event.flow_style) + if anchor is not None: + self.anchors[anchor] = node + index = 0 + while not self.check_event(SequenceEndEvent): + node.value.append(self.compose_node(node, index)) + index += 1 + end_event = self.get_event() + node.end_mark = end_event.end_mark + return node + + def compose_mapping_node(self, anchor): + start_event = self.get_event() + tag = start_event.tag + if tag is None or tag == '!': + tag = self.resolve(MappingNode, None, start_event.implicit) + node = MappingNode(tag, [], + start_event.start_mark, None, + flow_style=start_event.flow_style) + if anchor is not None: + self.anchors[anchor] = node + while not self.check_event(MappingEndEvent): + #key_event = self.peek_event() + item_key = self.compose_node(node, None) + #if item_key in node.value: + # raise ComposerError("while composing a mapping", start_event.start_mark, + # "found duplicate key", key_event.start_mark) + item_value = self.compose_node(node, item_key) + #node.value[item_key] = item_value + node.value.append((item_key, item_value)) + end_event = self.get_event() + node.end_mark = end_event.end_mark + return node + diff --git a/src/yaml/constructor.py b/src/yaml/constructor.py new file mode 100644 index 0000000..1948b12 --- /dev/null +++ b/src/yaml/constructor.py @@ -0,0 +1,748 @@ + +__all__ = [ + 'BaseConstructor', + 'SafeConstructor', + 'FullConstructor', + 'UnsafeConstructor', + 'Constructor', + 'ConstructorError' +] + +from .error import * +from .nodes import * + +import collections.abc, datetime, base64, binascii, re, sys, types + +class ConstructorError(MarkedYAMLError): + pass + +class BaseConstructor: + + yaml_constructors = {} + yaml_multi_constructors = {} + + def __init__(self): + self.constructed_objects = {} + self.recursive_objects = {} + self.state_generators = [] + self.deep_construct = False + + def check_data(self): + # If there are more documents available? + return self.check_node() + + def check_state_key(self, key): + """Block special attributes/methods from being set in a newly created + object, to prevent user-controlled methods from being called during + deserialization""" + if self.get_state_keys_blacklist_regexp().match(key): + raise ConstructorError(None, None, + "blacklisted key '%s' in instance state found" % (key,), None) + + def get_data(self): + # Construct and return the next document. + if self.check_node(): + return self.construct_document(self.get_node()) + + def get_single_data(self): + # Ensure that the stream contains a single document and construct it. + node = self.get_single_node() + if node is not None: + return self.construct_document(node) + return None + + def construct_document(self, node): + data = self.construct_object(node) + while self.state_generators: + state_generators = self.state_generators + self.state_generators = [] + for generator in state_generators: + for dummy in generator: + pass + self.constructed_objects = {} + self.recursive_objects = {} + self.deep_construct = False + return data + + def construct_object(self, node, deep=False): + if node in self.constructed_objects: + return self.constructed_objects[node] + if deep: + old_deep = self.deep_construct + self.deep_construct = True + if node in self.recursive_objects: + raise ConstructorError(None, None, + "found unconstructable recursive node", node.start_mark) + self.recursive_objects[node] = None + constructor = None + tag_suffix = None + if node.tag in self.yaml_constructors: + constructor = self.yaml_constructors[node.tag] + else: + for tag_prefix in self.yaml_multi_constructors: + if tag_prefix is not None and node.tag.startswith(tag_prefix): + tag_suffix = node.tag[len(tag_prefix):] + constructor = self.yaml_multi_constructors[tag_prefix] + break + else: + if None in self.yaml_multi_constructors: + tag_suffix = node.tag + constructor = self.yaml_multi_constructors[None] + elif None in self.yaml_constructors: + constructor = self.yaml_constructors[None] + elif isinstance(node, ScalarNode): + constructor = self.__class__.construct_scalar + elif isinstance(node, SequenceNode): + constructor = self.__class__.construct_sequence + elif isinstance(node, MappingNode): + constructor = self.__class__.construct_mapping + if tag_suffix is None: + data = constructor(self, node) + else: + data = constructor(self, tag_suffix, node) + if isinstance(data, types.GeneratorType): + generator = data + data = next(generator) + if self.deep_construct: + for dummy in generator: + pass + else: + self.state_generators.append(generator) + self.constructed_objects[node] = data + del self.recursive_objects[node] + if deep: + self.deep_construct = old_deep + return data + + def construct_scalar(self, node): + if not isinstance(node, ScalarNode): + raise ConstructorError(None, None, + "expected a scalar node, but found %s" % node.id, + node.start_mark) + return node.value + + def construct_sequence(self, node, deep=False): + if not isinstance(node, SequenceNode): + raise ConstructorError(None, None, + "expected a sequence node, but found %s" % node.id, + node.start_mark) + return [self.construct_object(child, deep=deep) + for child in node.value] + + def construct_mapping(self, node, deep=False): + if not isinstance(node, MappingNode): + raise ConstructorError(None, None, + "expected a mapping node, but found %s" % node.id, + node.start_mark) + mapping = {} + for key_node, value_node in node.value: + key = self.construct_object(key_node, deep=deep) + if not isinstance(key, collections.abc.Hashable): + raise ConstructorError("while constructing a mapping", node.start_mark, + "found unhashable key", key_node.start_mark) + value = self.construct_object(value_node, deep=deep) + mapping[key] = value + return mapping + + def construct_pairs(self, node, deep=False): + if not isinstance(node, MappingNode): + raise ConstructorError(None, None, + "expected a mapping node, but found %s" % node.id, + node.start_mark) + pairs = [] + for key_node, value_node in node.value: + key = self.construct_object(key_node, deep=deep) + value = self.construct_object(value_node, deep=deep) + pairs.append((key, value)) + return pairs + + @classmethod + def add_constructor(cls, tag, constructor): + if not 'yaml_constructors' in cls.__dict__: + cls.yaml_constructors = cls.yaml_constructors.copy() + cls.yaml_constructors[tag] = constructor + + @classmethod + def add_multi_constructor(cls, tag_prefix, multi_constructor): + if not 'yaml_multi_constructors' in cls.__dict__: + cls.yaml_multi_constructors = cls.yaml_multi_constructors.copy() + cls.yaml_multi_constructors[tag_prefix] = multi_constructor + +class SafeConstructor(BaseConstructor): + + def construct_scalar(self, node): + if isinstance(node, MappingNode): + for key_node, value_node in node.value: + if key_node.tag == 'tag:yaml.org,2002:value': + return self.construct_scalar(value_node) + return super().construct_scalar(node) + + def flatten_mapping(self, node): + merge = [] + index = 0 + while index < len(node.value): + key_node, value_node = node.value[index] + if key_node.tag == 'tag:yaml.org,2002:merge': + del node.value[index] + if isinstance(value_node, MappingNode): + self.flatten_mapping(value_node) + merge.extend(value_node.value) + elif isinstance(value_node, SequenceNode): + submerge = [] + for subnode in value_node.value: + if not isinstance(subnode, MappingNode): + raise ConstructorError("while constructing a mapping", + node.start_mark, + "expected a mapping for merging, but found %s" + % subnode.id, subnode.start_mark) + self.flatten_mapping(subnode) + submerge.append(subnode.value) + submerge.reverse() + for value in submerge: + merge.extend(value) + else: + raise ConstructorError("while constructing a mapping", node.start_mark, + "expected a mapping or list of mappings for merging, but found %s" + % value_node.id, value_node.start_mark) + elif key_node.tag == 'tag:yaml.org,2002:value': + key_node.tag = 'tag:yaml.org,2002:str' + index += 1 + else: + index += 1 + if merge: + node.value = merge + node.value + + def construct_mapping(self, node, deep=False): + if isinstance(node, MappingNode): + self.flatten_mapping(node) + return super().construct_mapping(node, deep=deep) + + def construct_yaml_null(self, node): + self.construct_scalar(node) + return None + + bool_values = { + 'yes': True, + 'no': False, + 'true': True, + 'false': False, + 'on': True, + 'off': False, + } + + def construct_yaml_bool(self, node): + value = self.construct_scalar(node) + return self.bool_values[value.lower()] + + def construct_yaml_int(self, node): + value = self.construct_scalar(node) + value = value.replace('_', '') + sign = +1 + if value[0] == '-': + sign = -1 + if value[0] in '+-': + value = value[1:] + if value == '0': + return 0 + elif value.startswith('0b'): + return sign*int(value[2:], 2) + elif value.startswith('0x'): + return sign*int(value[2:], 16) + elif value[0] == '0': + return sign*int(value, 8) + elif ':' in value: + digits = [int(part) for part in value.split(':')] + digits.reverse() + base = 1 + value = 0 + for digit in digits: + value += digit*base + base *= 60 + return sign*value + else: + return sign*int(value) + + inf_value = 1e300 + while inf_value != inf_value*inf_value: + inf_value *= inf_value + nan_value = -inf_value/inf_value # Trying to make a quiet NaN (like C99). + + def construct_yaml_float(self, node): + value = self.construct_scalar(node) + value = value.replace('_', '').lower() + sign = +1 + if value[0] == '-': + sign = -1 + if value[0] in '+-': + value = value[1:] + if value == '.inf': + return sign*self.inf_value + elif value == '.nan': + return self.nan_value + elif ':' in value: + digits = [float(part) for part in value.split(':')] + digits.reverse() + base = 1 + value = 0.0 + for digit in digits: + value += digit*base + base *= 60 + return sign*value + else: + return sign*float(value) + + def construct_yaml_binary(self, node): + try: + value = self.construct_scalar(node).encode('ascii') + except UnicodeEncodeError as exc: + raise ConstructorError(None, None, + "failed to convert base64 data into ascii: %s" % exc, + node.start_mark) + try: + if hasattr(base64, 'decodebytes'): + return base64.decodebytes(value) + else: + return base64.decodestring(value) + except binascii.Error as exc: + raise ConstructorError(None, None, + "failed to decode base64 data: %s" % exc, node.start_mark) + + timestamp_regexp = re.compile( + r'''^(?P[0-9][0-9][0-9][0-9]) + -(?P[0-9][0-9]?) + -(?P[0-9][0-9]?) + (?:(?:[Tt]|[ \t]+) + (?P[0-9][0-9]?) + :(?P[0-9][0-9]) + :(?P[0-9][0-9]) + (?:\.(?P[0-9]*))? + (?:[ \t]*(?PZ|(?P[-+])(?P[0-9][0-9]?) + (?::(?P[0-9][0-9]))?))?)?$''', re.X) + + def construct_yaml_timestamp(self, node): + value = self.construct_scalar(node) + match = self.timestamp_regexp.match(node.value) + values = match.groupdict() + year = int(values['year']) + month = int(values['month']) + day = int(values['day']) + if not values['hour']: + return datetime.date(year, month, day) + hour = int(values['hour']) + minute = int(values['minute']) + second = int(values['second']) + fraction = 0 + tzinfo = None + if values['fraction']: + fraction = values['fraction'][:6] + while len(fraction) < 6: + fraction += '0' + fraction = int(fraction) + if values['tz_sign']: + tz_hour = int(values['tz_hour']) + tz_minute = int(values['tz_minute'] or 0) + delta = datetime.timedelta(hours=tz_hour, minutes=tz_minute) + if values['tz_sign'] == '-': + delta = -delta + tzinfo = datetime.timezone(delta) + elif values['tz']: + tzinfo = datetime.timezone.utc + return datetime.datetime(year, month, day, hour, minute, second, fraction, + tzinfo=tzinfo) + + def construct_yaml_omap(self, node): + # Note: we do not check for duplicate keys, because it's too + # CPU-expensive. + omap = [] + yield omap + if not isinstance(node, SequenceNode): + raise ConstructorError("while constructing an ordered map", node.start_mark, + "expected a sequence, but found %s" % node.id, node.start_mark) + for subnode in node.value: + if not isinstance(subnode, MappingNode): + raise ConstructorError("while constructing an ordered map", node.start_mark, + "expected a mapping of length 1, but found %s" % subnode.id, + subnode.start_mark) + if len(subnode.value) != 1: + raise ConstructorError("while constructing an ordered map", node.start_mark, + "expected a single mapping item, but found %d items" % len(subnode.value), + subnode.start_mark) + key_node, value_node = subnode.value[0] + key = self.construct_object(key_node) + value = self.construct_object(value_node) + omap.append((key, value)) + + def construct_yaml_pairs(self, node): + # Note: the same code as `construct_yaml_omap`. + pairs = [] + yield pairs + if not isinstance(node, SequenceNode): + raise ConstructorError("while constructing pairs", node.start_mark, + "expected a sequence, but found %s" % node.id, node.start_mark) + for subnode in node.value: + if not isinstance(subnode, MappingNode): + raise ConstructorError("while constructing pairs", node.start_mark, + "expected a mapping of length 1, but found %s" % subnode.id, + subnode.start_mark) + if len(subnode.value) != 1: + raise ConstructorError("while constructing pairs", node.start_mark, + "expected a single mapping item, but found %d items" % len(subnode.value), + subnode.start_mark) + key_node, value_node = subnode.value[0] + key = self.construct_object(key_node) + value = self.construct_object(value_node) + pairs.append((key, value)) + + def construct_yaml_set(self, node): + data = set() + yield data + value = self.construct_mapping(node) + data.update(value) + + def construct_yaml_str(self, node): + return self.construct_scalar(node) + + def construct_yaml_seq(self, node): + data = [] + yield data + data.extend(self.construct_sequence(node)) + + def construct_yaml_map(self, node): + data = {} + yield data + value = self.construct_mapping(node) + data.update(value) + + def construct_yaml_object(self, node, cls): + data = cls.__new__(cls) + yield data + if hasattr(data, '__setstate__'): + state = self.construct_mapping(node, deep=True) + data.__setstate__(state) + else: + state = self.construct_mapping(node) + data.__dict__.update(state) + + def construct_undefined(self, node): + raise ConstructorError(None, None, + "could not determine a constructor for the tag %r" % node.tag, + node.start_mark) + +SafeConstructor.add_constructor( + 'tag:yaml.org,2002:null', + SafeConstructor.construct_yaml_null) + +SafeConstructor.add_constructor( + 'tag:yaml.org,2002:bool', + SafeConstructor.construct_yaml_bool) + +SafeConstructor.add_constructor( + 'tag:yaml.org,2002:int', + SafeConstructor.construct_yaml_int) + +SafeConstructor.add_constructor( + 'tag:yaml.org,2002:float', + SafeConstructor.construct_yaml_float) + +SafeConstructor.add_constructor( + 'tag:yaml.org,2002:binary', + SafeConstructor.construct_yaml_binary) + +SafeConstructor.add_constructor( + 'tag:yaml.org,2002:timestamp', + SafeConstructor.construct_yaml_timestamp) + +SafeConstructor.add_constructor( + 'tag:yaml.org,2002:omap', + SafeConstructor.construct_yaml_omap) + +SafeConstructor.add_constructor( + 'tag:yaml.org,2002:pairs', + SafeConstructor.construct_yaml_pairs) + +SafeConstructor.add_constructor( + 'tag:yaml.org,2002:set', + SafeConstructor.construct_yaml_set) + +SafeConstructor.add_constructor( + 'tag:yaml.org,2002:str', + SafeConstructor.construct_yaml_str) + +SafeConstructor.add_constructor( + 'tag:yaml.org,2002:seq', + SafeConstructor.construct_yaml_seq) + +SafeConstructor.add_constructor( + 'tag:yaml.org,2002:map', + SafeConstructor.construct_yaml_map) + +SafeConstructor.add_constructor(None, + SafeConstructor.construct_undefined) + +class FullConstructor(SafeConstructor): + # 'extend' is blacklisted because it is used by + # construct_python_object_apply to add `listitems` to a newly generate + # python instance + def get_state_keys_blacklist(self): + return ['^extend$', '^__.*__$'] + + def get_state_keys_blacklist_regexp(self): + if not hasattr(self, 'state_keys_blacklist_regexp'): + self.state_keys_blacklist_regexp = re.compile('(' + '|'.join(self.get_state_keys_blacklist()) + ')') + return self.state_keys_blacklist_regexp + + def construct_python_str(self, node): + return self.construct_scalar(node) + + def construct_python_unicode(self, node): + return self.construct_scalar(node) + + def construct_python_bytes(self, node): + try: + value = self.construct_scalar(node).encode('ascii') + except UnicodeEncodeError as exc: + raise ConstructorError(None, None, + "failed to convert base64 data into ascii: %s" % exc, + node.start_mark) + try: + if hasattr(base64, 'decodebytes'): + return base64.decodebytes(value) + else: + return base64.decodestring(value) + except binascii.Error as exc: + raise ConstructorError(None, None, + "failed to decode base64 data: %s" % exc, node.start_mark) + + def construct_python_long(self, node): + return self.construct_yaml_int(node) + + def construct_python_complex(self, node): + return complex(self.construct_scalar(node)) + + def construct_python_tuple(self, node): + return tuple(self.construct_sequence(node)) + + def find_python_module(self, name, mark, unsafe=False): + if not name: + raise ConstructorError("while constructing a Python module", mark, + "expected non-empty name appended to the tag", mark) + if unsafe: + try: + __import__(name) + except ImportError as exc: + raise ConstructorError("while constructing a Python module", mark, + "cannot find module %r (%s)" % (name, exc), mark) + if name not in sys.modules: + raise ConstructorError("while constructing a Python module", mark, + "module %r is not imported" % name, mark) + return sys.modules[name] + + def find_python_name(self, name, mark, unsafe=False): + if not name: + raise ConstructorError("while constructing a Python object", mark, + "expected non-empty name appended to the tag", mark) + if '.' in name: + module_name, object_name = name.rsplit('.', 1) + else: + module_name = 'builtins' + object_name = name + if unsafe: + try: + __import__(module_name) + except ImportError as exc: + raise ConstructorError("while constructing a Python object", mark, + "cannot find module %r (%s)" % (module_name, exc), mark) + if module_name not in sys.modules: + raise ConstructorError("while constructing a Python object", mark, + "module %r is not imported" % module_name, mark) + module = sys.modules[module_name] + if not hasattr(module, object_name): + raise ConstructorError("while constructing a Python object", mark, + "cannot find %r in the module %r" + % (object_name, module.__name__), mark) + return getattr(module, object_name) + + def construct_python_name(self, suffix, node): + value = self.construct_scalar(node) + if value: + raise ConstructorError("while constructing a Python name", node.start_mark, + "expected the empty value, but found %r" % value, node.start_mark) + return self.find_python_name(suffix, node.start_mark) + + def construct_python_module(self, suffix, node): + value = self.construct_scalar(node) + if value: + raise ConstructorError("while constructing a Python module", node.start_mark, + "expected the empty value, but found %r" % value, node.start_mark) + return self.find_python_module(suffix, node.start_mark) + + def make_python_instance(self, suffix, node, + args=None, kwds=None, newobj=False, unsafe=False): + if not args: + args = [] + if not kwds: + kwds = {} + cls = self.find_python_name(suffix, node.start_mark) + if not (unsafe or isinstance(cls, type)): + raise ConstructorError("while constructing a Python instance", node.start_mark, + "expected a class, but found %r" % type(cls), + node.start_mark) + if newobj and isinstance(cls, type): + return cls.__new__(cls, *args, **kwds) + else: + return cls(*args, **kwds) + + def set_python_instance_state(self, instance, state, unsafe=False): + if hasattr(instance, '__setstate__'): + instance.__setstate__(state) + else: + slotstate = {} + if isinstance(state, tuple) and len(state) == 2: + state, slotstate = state + if hasattr(instance, '__dict__'): + if not unsafe and state: + for key in state.keys(): + self.check_state_key(key) + instance.__dict__.update(state) + elif state: + slotstate.update(state) + for key, value in slotstate.items(): + if not unsafe: + self.check_state_key(key) + setattr(instance, key, value) + + def construct_python_object(self, suffix, node): + # Format: + # !!python/object:module.name { ... state ... } + instance = self.make_python_instance(suffix, node, newobj=True) + yield instance + deep = hasattr(instance, '__setstate__') + state = self.construct_mapping(node, deep=deep) + self.set_python_instance_state(instance, state) + + def construct_python_object_apply(self, suffix, node, newobj=False): + # Format: + # !!python/object/apply # (or !!python/object/new) + # args: [ ... arguments ... ] + # kwds: { ... keywords ... } + # state: ... state ... + # listitems: [ ... listitems ... ] + # dictitems: { ... dictitems ... } + # or short format: + # !!python/object/apply [ ... arguments ... ] + # The difference between !!python/object/apply and !!python/object/new + # is how an object is created, check make_python_instance for details. + if isinstance(node, SequenceNode): + args = self.construct_sequence(node, deep=True) + kwds = {} + state = {} + listitems = [] + dictitems = {} + else: + value = self.construct_mapping(node, deep=True) + args = value.get('args', []) + kwds = value.get('kwds', {}) + state = value.get('state', {}) + listitems = value.get('listitems', []) + dictitems = value.get('dictitems', {}) + instance = self.make_python_instance(suffix, node, args, kwds, newobj) + if state: + self.set_python_instance_state(instance, state) + if listitems: + instance.extend(listitems) + if dictitems: + for key in dictitems: + instance[key] = dictitems[key] + return instance + + def construct_python_object_new(self, suffix, node): + return self.construct_python_object_apply(suffix, node, newobj=True) + +FullConstructor.add_constructor( + 'tag:yaml.org,2002:python/none', + FullConstructor.construct_yaml_null) + +FullConstructor.add_constructor( + 'tag:yaml.org,2002:python/bool', + FullConstructor.construct_yaml_bool) + +FullConstructor.add_constructor( + 'tag:yaml.org,2002:python/str', + FullConstructor.construct_python_str) + +FullConstructor.add_constructor( + 'tag:yaml.org,2002:python/unicode', + FullConstructor.construct_python_unicode) + +FullConstructor.add_constructor( + 'tag:yaml.org,2002:python/bytes', + FullConstructor.construct_python_bytes) + +FullConstructor.add_constructor( + 'tag:yaml.org,2002:python/int', + FullConstructor.construct_yaml_int) + +FullConstructor.add_constructor( + 'tag:yaml.org,2002:python/long', + FullConstructor.construct_python_long) + +FullConstructor.add_constructor( + 'tag:yaml.org,2002:python/float', + FullConstructor.construct_yaml_float) + +FullConstructor.add_constructor( + 'tag:yaml.org,2002:python/complex', + FullConstructor.construct_python_complex) + +FullConstructor.add_constructor( + 'tag:yaml.org,2002:python/list', + FullConstructor.construct_yaml_seq) + +FullConstructor.add_constructor( + 'tag:yaml.org,2002:python/tuple', + FullConstructor.construct_python_tuple) + +FullConstructor.add_constructor( + 'tag:yaml.org,2002:python/dict', + FullConstructor.construct_yaml_map) + +FullConstructor.add_multi_constructor( + 'tag:yaml.org,2002:python/name:', + FullConstructor.construct_python_name) + +FullConstructor.add_multi_constructor( + 'tag:yaml.org,2002:python/module:', + FullConstructor.construct_python_module) + +FullConstructor.add_multi_constructor( + 'tag:yaml.org,2002:python/object:', + FullConstructor.construct_python_object) + +FullConstructor.add_multi_constructor( + 'tag:yaml.org,2002:python/object/new:', + FullConstructor.construct_python_object_new) + +class UnsafeConstructor(FullConstructor): + + def find_python_module(self, name, mark): + return super(UnsafeConstructor, self).find_python_module(name, mark, unsafe=True) + + def find_python_name(self, name, mark): + return super(UnsafeConstructor, self).find_python_name(name, mark, unsafe=True) + + def make_python_instance(self, suffix, node, args=None, kwds=None, newobj=False): + return super(UnsafeConstructor, self).make_python_instance( + suffix, node, args, kwds, newobj, unsafe=True) + + def set_python_instance_state(self, instance, state): + return super(UnsafeConstructor, self).set_python_instance_state( + instance, state, unsafe=True) + +UnsafeConstructor.add_multi_constructor( + 'tag:yaml.org,2002:python/object/apply:', + UnsafeConstructor.construct_python_object_apply) + +# Constructor is same as UnsafeConstructor. Need to leave this in place in case +# people have extended it directly. +class Constructor(UnsafeConstructor): + pass diff --git a/src/yaml/cyaml.py b/src/yaml/cyaml.py new file mode 100644 index 0000000..1e606c7 --- /dev/null +++ b/src/yaml/cyaml.py @@ -0,0 +1,101 @@ + +__all__ = [ + 'CBaseLoader', 'CSafeLoader', 'CFullLoader', 'CUnsafeLoader', 'CLoader', + 'CBaseDumper', 'CSafeDumper', 'CDumper' +] + +from _yaml import CParser, CEmitter + +from .constructor import * + +from .serializer import * +from .representer import * + +from .resolver import * + +class CBaseLoader(CParser, BaseConstructor, BaseResolver): + + def __init__(self, stream): + CParser.__init__(self, stream) + BaseConstructor.__init__(self) + BaseResolver.__init__(self) + +class CSafeLoader(CParser, SafeConstructor, Resolver): + + def __init__(self, stream): + CParser.__init__(self, stream) + SafeConstructor.__init__(self) + Resolver.__init__(self) + +class CFullLoader(CParser, FullConstructor, Resolver): + + def __init__(self, stream): + CParser.__init__(self, stream) + FullConstructor.__init__(self) + Resolver.__init__(self) + +class CUnsafeLoader(CParser, UnsafeConstructor, Resolver): + + def __init__(self, stream): + CParser.__init__(self, stream) + UnsafeConstructor.__init__(self) + Resolver.__init__(self) + +class CLoader(CParser, Constructor, Resolver): + + def __init__(self, stream): + CParser.__init__(self, stream) + Constructor.__init__(self) + Resolver.__init__(self) + +class CBaseDumper(CEmitter, BaseRepresenter, BaseResolver): + + def __init__(self, stream, + default_style=None, default_flow_style=False, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding=None, explicit_start=None, explicit_end=None, + version=None, tags=None, sort_keys=True): + CEmitter.__init__(self, stream, canonical=canonical, + indent=indent, width=width, encoding=encoding, + allow_unicode=allow_unicode, line_break=line_break, + explicit_start=explicit_start, explicit_end=explicit_end, + version=version, tags=tags) + Representer.__init__(self, default_style=default_style, + default_flow_style=default_flow_style, sort_keys=sort_keys) + Resolver.__init__(self) + +class CSafeDumper(CEmitter, SafeRepresenter, Resolver): + + def __init__(self, stream, + default_style=None, default_flow_style=False, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding=None, explicit_start=None, explicit_end=None, + version=None, tags=None, sort_keys=True): + CEmitter.__init__(self, stream, canonical=canonical, + indent=indent, width=width, encoding=encoding, + allow_unicode=allow_unicode, line_break=line_break, + explicit_start=explicit_start, explicit_end=explicit_end, + version=version, tags=tags) + SafeRepresenter.__init__(self, default_style=default_style, + default_flow_style=default_flow_style, sort_keys=sort_keys) + Resolver.__init__(self) + +class CDumper(CEmitter, Serializer, Representer, Resolver): + + def __init__(self, stream, + default_style=None, default_flow_style=False, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding=None, explicit_start=None, explicit_end=None, + version=None, tags=None, sort_keys=True): + CEmitter.__init__(self, stream, canonical=canonical, + indent=indent, width=width, encoding=encoding, + allow_unicode=allow_unicode, line_break=line_break, + explicit_start=explicit_start, explicit_end=explicit_end, + version=version, tags=tags) + Representer.__init__(self, default_style=default_style, + default_flow_style=default_flow_style, sort_keys=sort_keys) + Resolver.__init__(self) + diff --git a/src/yaml/dumper.py b/src/yaml/dumper.py new file mode 100644 index 0000000..6aadba5 --- /dev/null +++ b/src/yaml/dumper.py @@ -0,0 +1,62 @@ + +__all__ = ['BaseDumper', 'SafeDumper', 'Dumper'] + +from .emitter import * +from .serializer import * +from .representer import * +from .resolver import * + +class BaseDumper(Emitter, Serializer, BaseRepresenter, BaseResolver): + + def __init__(self, stream, + default_style=None, default_flow_style=False, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding=None, explicit_start=None, explicit_end=None, + version=None, tags=None, sort_keys=True): + Emitter.__init__(self, stream, canonical=canonical, + indent=indent, width=width, + allow_unicode=allow_unicode, line_break=line_break) + Serializer.__init__(self, encoding=encoding, + explicit_start=explicit_start, explicit_end=explicit_end, + version=version, tags=tags) + Representer.__init__(self, default_style=default_style, + default_flow_style=default_flow_style, sort_keys=sort_keys) + Resolver.__init__(self) + +class SafeDumper(Emitter, Serializer, SafeRepresenter, Resolver): + + def __init__(self, stream, + default_style=None, default_flow_style=False, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding=None, explicit_start=None, explicit_end=None, + version=None, tags=None, sort_keys=True): + Emitter.__init__(self, stream, canonical=canonical, + indent=indent, width=width, + allow_unicode=allow_unicode, line_break=line_break) + Serializer.__init__(self, encoding=encoding, + explicit_start=explicit_start, explicit_end=explicit_end, + version=version, tags=tags) + SafeRepresenter.__init__(self, default_style=default_style, + default_flow_style=default_flow_style, sort_keys=sort_keys) + Resolver.__init__(self) + +class Dumper(Emitter, Serializer, Representer, Resolver): + + def __init__(self, stream, + default_style=None, default_flow_style=False, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding=None, explicit_start=None, explicit_end=None, + version=None, tags=None, sort_keys=True): + Emitter.__init__(self, stream, canonical=canonical, + indent=indent, width=width, + allow_unicode=allow_unicode, line_break=line_break) + Serializer.__init__(self, encoding=encoding, + explicit_start=explicit_start, explicit_end=explicit_end, + version=version, tags=tags) + Representer.__init__(self, default_style=default_style, + default_flow_style=default_flow_style, sort_keys=sort_keys) + Resolver.__init__(self) + diff --git a/src/yaml/emitter.py b/src/yaml/emitter.py new file mode 100644 index 0000000..a664d01 --- /dev/null +++ b/src/yaml/emitter.py @@ -0,0 +1,1137 @@ + +# Emitter expects events obeying the following grammar: +# stream ::= STREAM-START document* STREAM-END +# document ::= DOCUMENT-START node DOCUMENT-END +# node ::= SCALAR | sequence | mapping +# sequence ::= SEQUENCE-START node* SEQUENCE-END +# mapping ::= MAPPING-START (node node)* MAPPING-END + +__all__ = ['Emitter', 'EmitterError'] + +from .error import YAMLError +from .events import * + +class EmitterError(YAMLError): + pass + +class ScalarAnalysis: + def __init__(self, scalar, empty, multiline, + allow_flow_plain, allow_block_plain, + allow_single_quoted, allow_double_quoted, + allow_block): + self.scalar = scalar + self.empty = empty + self.multiline = multiline + self.allow_flow_plain = allow_flow_plain + self.allow_block_plain = allow_block_plain + self.allow_single_quoted = allow_single_quoted + self.allow_double_quoted = allow_double_quoted + self.allow_block = allow_block + +class Emitter: + + DEFAULT_TAG_PREFIXES = { + '!' : '!', + 'tag:yaml.org,2002:' : '!!', + } + + def __init__(self, stream, canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None): + + # The stream should have the methods `write` and possibly `flush`. + self.stream = stream + + # Encoding can be overridden by STREAM-START. + self.encoding = None + + # Emitter is a state machine with a stack of states to handle nested + # structures. + self.states = [] + self.state = self.expect_stream_start + + # Current event and the event queue. + self.events = [] + self.event = None + + # The current indentation level and the stack of previous indents. + self.indents = [] + self.indent = None + + # Flow level. + self.flow_level = 0 + + # Contexts. + self.root_context = False + self.sequence_context = False + self.mapping_context = False + self.simple_key_context = False + + # Characteristics of the last emitted character: + # - current position. + # - is it a whitespace? + # - is it an indention character + # (indentation space, '-', '?', or ':')? + self.line = 0 + self.column = 0 + self.whitespace = True + self.indention = True + + # Whether the document requires an explicit document indicator + self.open_ended = False + + # Formatting details. + self.canonical = canonical + self.allow_unicode = allow_unicode + self.best_indent = 2 + if indent and 1 < indent < 10: + self.best_indent = indent + self.best_width = 80 + if width and width > self.best_indent*2: + self.best_width = width + self.best_line_break = '\n' + if line_break in ['\r', '\n', '\r\n']: + self.best_line_break = line_break + + # Tag prefixes. + self.tag_prefixes = None + + # Prepared anchor and tag. + self.prepared_anchor = None + self.prepared_tag = None + + # Scalar analysis and style. + self.analysis = None + self.style = None + + def dispose(self): + # Reset the state attributes (to clear self-references) + self.states = [] + self.state = None + + def emit(self, event): + self.events.append(event) + while not self.need_more_events(): + self.event = self.events.pop(0) + self.state() + self.event = None + + # In some cases, we wait for a few next events before emitting. + + def need_more_events(self): + if not self.events: + return True + event = self.events[0] + if isinstance(event, DocumentStartEvent): + return self.need_events(1) + elif isinstance(event, SequenceStartEvent): + return self.need_events(2) + elif isinstance(event, MappingStartEvent): + return self.need_events(3) + else: + return False + + def need_events(self, count): + level = 0 + for event in self.events[1:]: + if isinstance(event, (DocumentStartEvent, CollectionStartEvent)): + level += 1 + elif isinstance(event, (DocumentEndEvent, CollectionEndEvent)): + level -= 1 + elif isinstance(event, StreamEndEvent): + level = -1 + if level < 0: + return False + return (len(self.events) < count+1) + + def increase_indent(self, flow=False, indentless=False): + self.indents.append(self.indent) + if self.indent is None: + if flow: + self.indent = self.best_indent + else: + self.indent = 0 + elif not indentless: + self.indent += self.best_indent + + # States. + + # Stream handlers. + + def expect_stream_start(self): + if isinstance(self.event, StreamStartEvent): + if self.event.encoding and not hasattr(self.stream, 'encoding'): + self.encoding = self.event.encoding + self.write_stream_start() + self.state = self.expect_first_document_start + else: + raise EmitterError("expected StreamStartEvent, but got %s" + % self.event) + + def expect_nothing(self): + raise EmitterError("expected nothing, but got %s" % self.event) + + # Document handlers. + + def expect_first_document_start(self): + return self.expect_document_start(first=True) + + def expect_document_start(self, first=False): + if isinstance(self.event, DocumentStartEvent): + if (self.event.version or self.event.tags) and self.open_ended: + self.write_indicator('...', True) + self.write_indent() + if self.event.version: + version_text = self.prepare_version(self.event.version) + self.write_version_directive(version_text) + self.tag_prefixes = self.DEFAULT_TAG_PREFIXES.copy() + if self.event.tags: + handles = sorted(self.event.tags.keys()) + for handle in handles: + prefix = self.event.tags[handle] + self.tag_prefixes[prefix] = handle + handle_text = self.prepare_tag_handle(handle) + prefix_text = self.prepare_tag_prefix(prefix) + self.write_tag_directive(handle_text, prefix_text) + implicit = (first and not self.event.explicit and not self.canonical + and not self.event.version and not self.event.tags + and not self.check_empty_document()) + if not implicit: + self.write_indent() + self.write_indicator('---', True) + if self.canonical: + self.write_indent() + self.state = self.expect_document_root + elif isinstance(self.event, StreamEndEvent): + if self.open_ended: + self.write_indicator('...', True) + self.write_indent() + self.write_stream_end() + self.state = self.expect_nothing + else: + raise EmitterError("expected DocumentStartEvent, but got %s" + % self.event) + + def expect_document_end(self): + if isinstance(self.event, DocumentEndEvent): + self.write_indent() + if self.event.explicit: + self.write_indicator('...', True) + self.write_indent() + self.flush_stream() + self.state = self.expect_document_start + else: + raise EmitterError("expected DocumentEndEvent, but got %s" + % self.event) + + def expect_document_root(self): + self.states.append(self.expect_document_end) + self.expect_node(root=True) + + # Node handlers. + + def expect_node(self, root=False, sequence=False, mapping=False, + simple_key=False): + self.root_context = root + self.sequence_context = sequence + self.mapping_context = mapping + self.simple_key_context = simple_key + if isinstance(self.event, AliasEvent): + self.expect_alias() + elif isinstance(self.event, (ScalarEvent, CollectionStartEvent)): + self.process_anchor('&') + self.process_tag() + if isinstance(self.event, ScalarEvent): + self.expect_scalar() + elif isinstance(self.event, SequenceStartEvent): + if self.flow_level or self.canonical or self.event.flow_style \ + or self.check_empty_sequence(): + self.expect_flow_sequence() + else: + self.expect_block_sequence() + elif isinstance(self.event, MappingStartEvent): + if self.flow_level or self.canonical or self.event.flow_style \ + or self.check_empty_mapping(): + self.expect_flow_mapping() + else: + self.expect_block_mapping() + else: + raise EmitterError("expected NodeEvent, but got %s" % self.event) + + def expect_alias(self): + if self.event.anchor is None: + raise EmitterError("anchor is not specified for alias") + self.process_anchor('*') + self.state = self.states.pop() + + def expect_scalar(self): + self.increase_indent(flow=True) + self.process_scalar() + self.indent = self.indents.pop() + self.state = self.states.pop() + + # Flow sequence handlers. + + def expect_flow_sequence(self): + self.write_indicator('[', True, whitespace=True) + self.flow_level += 1 + self.increase_indent(flow=True) + self.state = self.expect_first_flow_sequence_item + + def expect_first_flow_sequence_item(self): + if isinstance(self.event, SequenceEndEvent): + self.indent = self.indents.pop() + self.flow_level -= 1 + self.write_indicator(']', False) + self.state = self.states.pop() + else: + if self.canonical or self.column > self.best_width: + self.write_indent() + self.states.append(self.expect_flow_sequence_item) + self.expect_node(sequence=True) + + def expect_flow_sequence_item(self): + if isinstance(self.event, SequenceEndEvent): + self.indent = self.indents.pop() + self.flow_level -= 1 + if self.canonical: + self.write_indicator(',', False) + self.write_indent() + self.write_indicator(']', False) + self.state = self.states.pop() + else: + self.write_indicator(',', False) + if self.canonical or self.column > self.best_width: + self.write_indent() + self.states.append(self.expect_flow_sequence_item) + self.expect_node(sequence=True) + + # Flow mapping handlers. + + def expect_flow_mapping(self): + self.write_indicator('{', True, whitespace=True) + self.flow_level += 1 + self.increase_indent(flow=True) + self.state = self.expect_first_flow_mapping_key + + def expect_first_flow_mapping_key(self): + if isinstance(self.event, MappingEndEvent): + self.indent = self.indents.pop() + self.flow_level -= 1 + self.write_indicator('}', False) + self.state = self.states.pop() + else: + if self.canonical or self.column > self.best_width: + self.write_indent() + if not self.canonical and self.check_simple_key(): + self.states.append(self.expect_flow_mapping_simple_value) + self.expect_node(mapping=True, simple_key=True) + else: + self.write_indicator('?', True) + self.states.append(self.expect_flow_mapping_value) + self.expect_node(mapping=True) + + def expect_flow_mapping_key(self): + if isinstance(self.event, MappingEndEvent): + self.indent = self.indents.pop() + self.flow_level -= 1 + if self.canonical: + self.write_indicator(',', False) + self.write_indent() + self.write_indicator('}', False) + self.state = self.states.pop() + else: + self.write_indicator(',', False) + if self.canonical or self.column > self.best_width: + self.write_indent() + if not self.canonical and self.check_simple_key(): + self.states.append(self.expect_flow_mapping_simple_value) + self.expect_node(mapping=True, simple_key=True) + else: + self.write_indicator('?', True) + self.states.append(self.expect_flow_mapping_value) + self.expect_node(mapping=True) + + def expect_flow_mapping_simple_value(self): + self.write_indicator(':', False) + self.states.append(self.expect_flow_mapping_key) + self.expect_node(mapping=True) + + def expect_flow_mapping_value(self): + if self.canonical or self.column > self.best_width: + self.write_indent() + self.write_indicator(':', True) + self.states.append(self.expect_flow_mapping_key) + self.expect_node(mapping=True) + + # Block sequence handlers. + + def expect_block_sequence(self): + indentless = (self.mapping_context and not self.indention) + self.increase_indent(flow=False, indentless=indentless) + self.state = self.expect_first_block_sequence_item + + def expect_first_block_sequence_item(self): + return self.expect_block_sequence_item(first=True) + + def expect_block_sequence_item(self, first=False): + if not first and isinstance(self.event, SequenceEndEvent): + self.indent = self.indents.pop() + self.state = self.states.pop() + else: + self.write_indent() + self.write_indicator('-', True, indention=True) + self.states.append(self.expect_block_sequence_item) + self.expect_node(sequence=True) + + # Block mapping handlers. + + def expect_block_mapping(self): + self.increase_indent(flow=False) + self.state = self.expect_first_block_mapping_key + + def expect_first_block_mapping_key(self): + return self.expect_block_mapping_key(first=True) + + def expect_block_mapping_key(self, first=False): + if not first and isinstance(self.event, MappingEndEvent): + self.indent = self.indents.pop() + self.state = self.states.pop() + else: + self.write_indent() + if self.check_simple_key(): + self.states.append(self.expect_block_mapping_simple_value) + self.expect_node(mapping=True, simple_key=True) + else: + self.write_indicator('?', True, indention=True) + self.states.append(self.expect_block_mapping_value) + self.expect_node(mapping=True) + + def expect_block_mapping_simple_value(self): + self.write_indicator(':', False) + self.states.append(self.expect_block_mapping_key) + self.expect_node(mapping=True) + + def expect_block_mapping_value(self): + self.write_indent() + self.write_indicator(':', True, indention=True) + self.states.append(self.expect_block_mapping_key) + self.expect_node(mapping=True) + + # Checkers. + + def check_empty_sequence(self): + return (isinstance(self.event, SequenceStartEvent) and self.events + and isinstance(self.events[0], SequenceEndEvent)) + + def check_empty_mapping(self): + return (isinstance(self.event, MappingStartEvent) and self.events + and isinstance(self.events[0], MappingEndEvent)) + + def check_empty_document(self): + if not isinstance(self.event, DocumentStartEvent) or not self.events: + return False + event = self.events[0] + return (isinstance(event, ScalarEvent) and event.anchor is None + and event.tag is None and event.implicit and event.value == '') + + def check_simple_key(self): + length = 0 + if isinstance(self.event, NodeEvent) and self.event.anchor is not None: + if self.prepared_anchor is None: + self.prepared_anchor = self.prepare_anchor(self.event.anchor) + length += len(self.prepared_anchor) + if isinstance(self.event, (ScalarEvent, CollectionStartEvent)) \ + and self.event.tag is not None: + if self.prepared_tag is None: + self.prepared_tag = self.prepare_tag(self.event.tag) + length += len(self.prepared_tag) + if isinstance(self.event, ScalarEvent): + if self.analysis is None: + self.analysis = self.analyze_scalar(self.event.value) + length += len(self.analysis.scalar) + return (length < 128 and (isinstance(self.event, AliasEvent) + or (isinstance(self.event, ScalarEvent) + and not self.analysis.empty and not self.analysis.multiline) + or self.check_empty_sequence() or self.check_empty_mapping())) + + # Anchor, Tag, and Scalar processors. + + def process_anchor(self, indicator): + if self.event.anchor is None: + self.prepared_anchor = None + return + if self.prepared_anchor is None: + self.prepared_anchor = self.prepare_anchor(self.event.anchor) + if self.prepared_anchor: + self.write_indicator(indicator+self.prepared_anchor, True) + self.prepared_anchor = None + + def process_tag(self): + tag = self.event.tag + if isinstance(self.event, ScalarEvent): + if self.style is None: + self.style = self.choose_scalar_style() + if ((not self.canonical or tag is None) and + ((self.style == '' and self.event.implicit[0]) + or (self.style != '' and self.event.implicit[1]))): + self.prepared_tag = None + return + if self.event.implicit[0] and tag is None: + tag = '!' + self.prepared_tag = None + else: + if (not self.canonical or tag is None) and self.event.implicit: + self.prepared_tag = None + return + if tag is None: + raise EmitterError("tag is not specified") + if self.prepared_tag is None: + self.prepared_tag = self.prepare_tag(tag) + if self.prepared_tag: + self.write_indicator(self.prepared_tag, True) + self.prepared_tag = None + + def choose_scalar_style(self): + if self.analysis is None: + self.analysis = self.analyze_scalar(self.event.value) + if self.event.style == '"' or self.canonical: + return '"' + if not self.event.style and self.event.implicit[0]: + if (not (self.simple_key_context and + (self.analysis.empty or self.analysis.multiline)) + and (self.flow_level and self.analysis.allow_flow_plain + or (not self.flow_level and self.analysis.allow_block_plain))): + return '' + if self.event.style and self.event.style in '|>': + if (not self.flow_level and not self.simple_key_context + and self.analysis.allow_block): + return self.event.style + if not self.event.style or self.event.style == '\'': + if (self.analysis.allow_single_quoted and + not (self.simple_key_context and self.analysis.multiline)): + return '\'' + return '"' + + def process_scalar(self): + if self.analysis is None: + self.analysis = self.analyze_scalar(self.event.value) + if self.style is None: + self.style = self.choose_scalar_style() + split = (not self.simple_key_context) + #if self.analysis.multiline and split \ + # and (not self.style or self.style in '\'\"'): + # self.write_indent() + if self.style == '"': + self.write_double_quoted(self.analysis.scalar, split) + elif self.style == '\'': + self.write_single_quoted(self.analysis.scalar, split) + elif self.style == '>': + self.write_folded(self.analysis.scalar) + elif self.style == '|': + self.write_literal(self.analysis.scalar) + else: + self.write_plain(self.analysis.scalar, split) + self.analysis = None + self.style = None + + # Analyzers. + + def prepare_version(self, version): + major, minor = version + if major != 1: + raise EmitterError("unsupported YAML version: %d.%d" % (major, minor)) + return '%d.%d' % (major, minor) + + def prepare_tag_handle(self, handle): + if not handle: + raise EmitterError("tag handle must not be empty") + if handle[0] != '!' or handle[-1] != '!': + raise EmitterError("tag handle must start and end with '!': %r" % handle) + for ch in handle[1:-1]: + if not ('0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \ + or ch in '-_'): + raise EmitterError("invalid character %r in the tag handle: %r" + % (ch, handle)) + return handle + + def prepare_tag_prefix(self, prefix): + if not prefix: + raise EmitterError("tag prefix must not be empty") + chunks = [] + start = end = 0 + if prefix[0] == '!': + end = 1 + while end < len(prefix): + ch = prefix[end] + if '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \ + or ch in '-;/?!:@&=+$,_.~*\'()[]': + end += 1 + else: + if start < end: + chunks.append(prefix[start:end]) + start = end = end+1 + data = ch.encode('utf-8') + for ch in data: + chunks.append('%%%02X' % ord(ch)) + if start < end: + chunks.append(prefix[start:end]) + return ''.join(chunks) + + def prepare_tag(self, tag): + if not tag: + raise EmitterError("tag must not be empty") + if tag == '!': + return tag + handle = None + suffix = tag + prefixes = sorted(self.tag_prefixes.keys()) + for prefix in prefixes: + if tag.startswith(prefix) \ + and (prefix == '!' or len(prefix) < len(tag)): + handle = self.tag_prefixes[prefix] + suffix = tag[len(prefix):] + chunks = [] + start = end = 0 + while end < len(suffix): + ch = suffix[end] + if '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \ + or ch in '-;/?:@&=+$,_.~*\'()[]' \ + or (ch == '!' and handle != '!'): + end += 1 + else: + if start < end: + chunks.append(suffix[start:end]) + start = end = end+1 + data = ch.encode('utf-8') + for ch in data: + chunks.append('%%%02X' % ch) + if start < end: + chunks.append(suffix[start:end]) + suffix_text = ''.join(chunks) + if handle: + return '%s%s' % (handle, suffix_text) + else: + return '!<%s>' % suffix_text + + def prepare_anchor(self, anchor): + if not anchor: + raise EmitterError("anchor must not be empty") + for ch in anchor: + if not ('0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \ + or ch in '-_'): + raise EmitterError("invalid character %r in the anchor: %r" + % (ch, anchor)) + return anchor + + def analyze_scalar(self, scalar): + + # Empty scalar is a special case. + if not scalar: + return ScalarAnalysis(scalar=scalar, empty=True, multiline=False, + allow_flow_plain=False, allow_block_plain=True, + allow_single_quoted=True, allow_double_quoted=True, + allow_block=False) + + # Indicators and special characters. + block_indicators = False + flow_indicators = False + line_breaks = False + special_characters = False + + # Important whitespace combinations. + leading_space = False + leading_break = False + trailing_space = False + trailing_break = False + break_space = False + space_break = False + + # Check document indicators. + if scalar.startswith('---') or scalar.startswith('...'): + block_indicators = True + flow_indicators = True + + # First character or preceded by a whitespace. + preceded_by_whitespace = True + + # Last character or followed by a whitespace. + followed_by_whitespace = (len(scalar) == 1 or + scalar[1] in '\0 \t\r\n\x85\u2028\u2029') + + # The previous character is a space. + previous_space = False + + # The previous character is a break. + previous_break = False + + index = 0 + while index < len(scalar): + ch = scalar[index] + + # Check for indicators. + if index == 0: + # Leading indicators are special characters. + if ch in '#,[]{}&*!|>\'\"%@`': + flow_indicators = True + block_indicators = True + if ch in '?:': + flow_indicators = True + if followed_by_whitespace: + block_indicators = True + if ch == '-' and followed_by_whitespace: + flow_indicators = True + block_indicators = True + else: + # Some indicators cannot appear within a scalar as well. + if ch in ',?[]{}': + flow_indicators = True + if ch == ':': + flow_indicators = True + if followed_by_whitespace: + block_indicators = True + if ch == '#' and preceded_by_whitespace: + flow_indicators = True + block_indicators = True + + # Check for line breaks, special, and unicode characters. + if ch in '\n\x85\u2028\u2029': + line_breaks = True + if not (ch == '\n' or '\x20' <= ch <= '\x7E'): + if (ch == '\x85' or '\xA0' <= ch <= '\uD7FF' + or '\uE000' <= ch <= '\uFFFD' + or '\U00010000' <= ch < '\U0010ffff') and ch != '\uFEFF': + unicode_characters = True + if not self.allow_unicode: + special_characters = True + else: + special_characters = True + + # Detect important whitespace combinations. + if ch == ' ': + if index == 0: + leading_space = True + if index == len(scalar)-1: + trailing_space = True + if previous_break: + break_space = True + previous_space = True + previous_break = False + elif ch in '\n\x85\u2028\u2029': + if index == 0: + leading_break = True + if index == len(scalar)-1: + trailing_break = True + if previous_space: + space_break = True + previous_space = False + previous_break = True + else: + previous_space = False + previous_break = False + + # Prepare for the next character. + index += 1 + preceded_by_whitespace = (ch in '\0 \t\r\n\x85\u2028\u2029') + followed_by_whitespace = (index+1 >= len(scalar) or + scalar[index+1] in '\0 \t\r\n\x85\u2028\u2029') + + # Let's decide what styles are allowed. + allow_flow_plain = True + allow_block_plain = True + allow_single_quoted = True + allow_double_quoted = True + allow_block = True + + # Leading and trailing whitespaces are bad for plain scalars. + if (leading_space or leading_break + or trailing_space or trailing_break): + allow_flow_plain = allow_block_plain = False + + # We do not permit trailing spaces for block scalars. + if trailing_space: + allow_block = False + + # Spaces at the beginning of a new line are only acceptable for block + # scalars. + if break_space: + allow_flow_plain = allow_block_plain = allow_single_quoted = False + + # Spaces followed by breaks, as well as special character are only + # allowed for double quoted scalars. + if space_break or special_characters: + allow_flow_plain = allow_block_plain = \ + allow_single_quoted = allow_block = False + + # Although the plain scalar writer supports breaks, we never emit + # multiline plain scalars. + if line_breaks: + allow_flow_plain = allow_block_plain = False + + # Flow indicators are forbidden for flow plain scalars. + if flow_indicators: + allow_flow_plain = False + + # Block indicators are forbidden for block plain scalars. + if block_indicators: + allow_block_plain = False + + return ScalarAnalysis(scalar=scalar, + empty=False, multiline=line_breaks, + allow_flow_plain=allow_flow_plain, + allow_block_plain=allow_block_plain, + allow_single_quoted=allow_single_quoted, + allow_double_quoted=allow_double_quoted, + allow_block=allow_block) + + # Writers. + + def flush_stream(self): + if hasattr(self.stream, 'flush'): + self.stream.flush() + + def write_stream_start(self): + # Write BOM if needed. + if self.encoding and self.encoding.startswith('utf-16'): + self.stream.write('\uFEFF'.encode(self.encoding)) + + def write_stream_end(self): + self.flush_stream() + + def write_indicator(self, indicator, need_whitespace, + whitespace=False, indention=False): + if self.whitespace or not need_whitespace: + data = indicator + else: + data = ' '+indicator + self.whitespace = whitespace + self.indention = self.indention and indention + self.column += len(data) + self.open_ended = False + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + + def write_indent(self): + indent = self.indent or 0 + if not self.indention or self.column > indent \ + or (self.column == indent and not self.whitespace): + self.write_line_break() + if self.column < indent: + self.whitespace = True + data = ' '*(indent-self.column) + self.column = indent + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + + def write_line_break(self, data=None): + if data is None: + data = self.best_line_break + self.whitespace = True + self.indention = True + self.line += 1 + self.column = 0 + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + + def write_version_directive(self, version_text): + data = '%%YAML %s' % version_text + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + self.write_line_break() + + def write_tag_directive(self, handle_text, prefix_text): + data = '%%TAG %s %s' % (handle_text, prefix_text) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + self.write_line_break() + + # Scalar streams. + + def write_single_quoted(self, text, split=True): + self.write_indicator('\'', True) + spaces = False + breaks = False + start = end = 0 + while end <= len(text): + ch = None + if end < len(text): + ch = text[end] + if spaces: + if ch is None or ch != ' ': + if start+1 == end and self.column > self.best_width and split \ + and start != 0 and end != len(text): + self.write_indent() + else: + data = text[start:end] + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end + elif breaks: + if ch is None or ch not in '\n\x85\u2028\u2029': + if text[start] == '\n': + self.write_line_break() + for br in text[start:end]: + if br == '\n': + self.write_line_break() + else: + self.write_line_break(br) + self.write_indent() + start = end + else: + if ch is None or ch in ' \n\x85\u2028\u2029' or ch == '\'': + if start < end: + data = text[start:end] + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end + if ch == '\'': + data = '\'\'' + self.column += 2 + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end + 1 + if ch is not None: + spaces = (ch == ' ') + breaks = (ch in '\n\x85\u2028\u2029') + end += 1 + self.write_indicator('\'', False) + + ESCAPE_REPLACEMENTS = { + '\0': '0', + '\x07': 'a', + '\x08': 'b', + '\x09': 't', + '\x0A': 'n', + '\x0B': 'v', + '\x0C': 'f', + '\x0D': 'r', + '\x1B': 'e', + '\"': '\"', + '\\': '\\', + '\x85': 'N', + '\xA0': '_', + '\u2028': 'L', + '\u2029': 'P', + } + + def write_double_quoted(self, text, split=True): + self.write_indicator('"', True) + start = end = 0 + while end <= len(text): + ch = None + if end < len(text): + ch = text[end] + if ch is None or ch in '"\\\x85\u2028\u2029\uFEFF' \ + or not ('\x20' <= ch <= '\x7E' + or (self.allow_unicode + and ('\xA0' <= ch <= '\uD7FF' + or '\uE000' <= ch <= '\uFFFD'))): + if start < end: + data = text[start:end] + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end + if ch is not None: + if ch in self.ESCAPE_REPLACEMENTS: + data = '\\'+self.ESCAPE_REPLACEMENTS[ch] + elif ch <= '\xFF': + data = '\\x%02X' % ord(ch) + elif ch <= '\uFFFF': + data = '\\u%04X' % ord(ch) + else: + data = '\\U%08X' % ord(ch) + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end+1 + if 0 < end < len(text)-1 and (ch == ' ' or start >= end) \ + and self.column+(end-start) > self.best_width and split: + data = text[start:end]+'\\' + if start < end: + start = end + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + self.write_indent() + self.whitespace = False + self.indention = False + if text[start] == ' ': + data = '\\' + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + end += 1 + self.write_indicator('"', False) + + def determine_block_hints(self, text): + hints = '' + if text: + if text[0] in ' \n\x85\u2028\u2029': + hints += str(self.best_indent) + if text[-1] not in '\n\x85\u2028\u2029': + hints += '-' + elif len(text) == 1 or text[-2] in '\n\x85\u2028\u2029': + hints += '+' + return hints + + def write_folded(self, text): + hints = self.determine_block_hints(text) + self.write_indicator('>'+hints, True) + if hints[-1:] == '+': + self.open_ended = True + self.write_line_break() + leading_space = True + spaces = False + breaks = True + start = end = 0 + while end <= len(text): + ch = None + if end < len(text): + ch = text[end] + if breaks: + if ch is None or ch not in '\n\x85\u2028\u2029': + if not leading_space and ch is not None and ch != ' ' \ + and text[start] == '\n': + self.write_line_break() + leading_space = (ch == ' ') + for br in text[start:end]: + if br == '\n': + self.write_line_break() + else: + self.write_line_break(br) + if ch is not None: + self.write_indent() + start = end + elif spaces: + if ch != ' ': + if start+1 == end and self.column > self.best_width: + self.write_indent() + else: + data = text[start:end] + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end + else: + if ch is None or ch in ' \n\x85\u2028\u2029': + data = text[start:end] + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + if ch is None: + self.write_line_break() + start = end + if ch is not None: + breaks = (ch in '\n\x85\u2028\u2029') + spaces = (ch == ' ') + end += 1 + + def write_literal(self, text): + hints = self.determine_block_hints(text) + self.write_indicator('|'+hints, True) + if hints[-1:] == '+': + self.open_ended = True + self.write_line_break() + breaks = True + start = end = 0 + while end <= len(text): + ch = None + if end < len(text): + ch = text[end] + if breaks: + if ch is None or ch not in '\n\x85\u2028\u2029': + for br in text[start:end]: + if br == '\n': + self.write_line_break() + else: + self.write_line_break(br) + if ch is not None: + self.write_indent() + start = end + else: + if ch is None or ch in '\n\x85\u2028\u2029': + data = text[start:end] + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + if ch is None: + self.write_line_break() + start = end + if ch is not None: + breaks = (ch in '\n\x85\u2028\u2029') + end += 1 + + def write_plain(self, text, split=True): + if self.root_context: + self.open_ended = True + if not text: + return + if not self.whitespace: + data = ' ' + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + self.whitespace = False + self.indention = False + spaces = False + breaks = False + start = end = 0 + while end <= len(text): + ch = None + if end < len(text): + ch = text[end] + if spaces: + if ch != ' ': + if start+1 == end and self.column > self.best_width and split: + self.write_indent() + self.whitespace = False + self.indention = False + else: + data = text[start:end] + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end + elif breaks: + if ch not in '\n\x85\u2028\u2029': + if text[start] == '\n': + self.write_line_break() + for br in text[start:end]: + if br == '\n': + self.write_line_break() + else: + self.write_line_break(br) + self.write_indent() + self.whitespace = False + self.indention = False + start = end + else: + if ch is None or ch in ' \n\x85\u2028\u2029': + data = text[start:end] + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end + if ch is not None: + spaces = (ch == ' ') + breaks = (ch in '\n\x85\u2028\u2029') + end += 1 diff --git a/src/yaml/error.py b/src/yaml/error.py new file mode 100644 index 0000000..b796b4d --- /dev/null +++ b/src/yaml/error.py @@ -0,0 +1,75 @@ + +__all__ = ['Mark', 'YAMLError', 'MarkedYAMLError'] + +class Mark: + + def __init__(self, name, index, line, column, buffer, pointer): + self.name = name + self.index = index + self.line = line + self.column = column + self.buffer = buffer + self.pointer = pointer + + def get_snippet(self, indent=4, max_length=75): + if self.buffer is None: + return None + head = '' + start = self.pointer + while start > 0 and self.buffer[start-1] not in '\0\r\n\x85\u2028\u2029': + start -= 1 + if self.pointer-start > max_length/2-1: + head = ' ... ' + start += 5 + break + tail = '' + end = self.pointer + while end < len(self.buffer) and self.buffer[end] not in '\0\r\n\x85\u2028\u2029': + end += 1 + if end-self.pointer > max_length/2-1: + tail = ' ... ' + end -= 5 + break + snippet = self.buffer[start:end] + return ' '*indent + head + snippet + tail + '\n' \ + + ' '*(indent+self.pointer-start+len(head)) + '^' + + def __str__(self): + snippet = self.get_snippet() + where = " in \"%s\", line %d, column %d" \ + % (self.name, self.line+1, self.column+1) + if snippet is not None: + where += ":\n"+snippet + return where + +class YAMLError(Exception): + pass + +class MarkedYAMLError(YAMLError): + + def __init__(self, context=None, context_mark=None, + problem=None, problem_mark=None, note=None): + self.context = context + self.context_mark = context_mark + self.problem = problem + self.problem_mark = problem_mark + self.note = note + + def __str__(self): + lines = [] + if self.context is not None: + lines.append(self.context) + if self.context_mark is not None \ + and (self.problem is None or self.problem_mark is None + or self.context_mark.name != self.problem_mark.name + or self.context_mark.line != self.problem_mark.line + or self.context_mark.column != self.problem_mark.column): + lines.append(str(self.context_mark)) + if self.problem is not None: + lines.append(self.problem) + if self.problem_mark is not None: + lines.append(str(self.problem_mark)) + if self.note is not None: + lines.append(self.note) + return '\n'.join(lines) + diff --git a/src/yaml/events.py b/src/yaml/events.py new file mode 100644 index 0000000..f79ad38 --- /dev/null +++ b/src/yaml/events.py @@ -0,0 +1,86 @@ + +# Abstract classes. + +class Event(object): + def __init__(self, start_mark=None, end_mark=None): + self.start_mark = start_mark + self.end_mark = end_mark + def __repr__(self): + attributes = [key for key in ['anchor', 'tag', 'implicit', 'value'] + if hasattr(self, key)] + arguments = ', '.join(['%s=%r' % (key, getattr(self, key)) + for key in attributes]) + return '%s(%s)' % (self.__class__.__name__, arguments) + +class NodeEvent(Event): + def __init__(self, anchor, start_mark=None, end_mark=None): + self.anchor = anchor + self.start_mark = start_mark + self.end_mark = end_mark + +class CollectionStartEvent(NodeEvent): + def __init__(self, anchor, tag, implicit, start_mark=None, end_mark=None, + flow_style=None): + self.anchor = anchor + self.tag = tag + self.implicit = implicit + self.start_mark = start_mark + self.end_mark = end_mark + self.flow_style = flow_style + +class CollectionEndEvent(Event): + pass + +# Implementations. + +class StreamStartEvent(Event): + def __init__(self, start_mark=None, end_mark=None, encoding=None): + self.start_mark = start_mark + self.end_mark = end_mark + self.encoding = encoding + +class StreamEndEvent(Event): + pass + +class DocumentStartEvent(Event): + def __init__(self, start_mark=None, end_mark=None, + explicit=None, version=None, tags=None): + self.start_mark = start_mark + self.end_mark = end_mark + self.explicit = explicit + self.version = version + self.tags = tags + +class DocumentEndEvent(Event): + def __init__(self, start_mark=None, end_mark=None, + explicit=None): + self.start_mark = start_mark + self.end_mark = end_mark + self.explicit = explicit + +class AliasEvent(NodeEvent): + pass + +class ScalarEvent(NodeEvent): + def __init__(self, anchor, tag, implicit, value, + start_mark=None, end_mark=None, style=None): + self.anchor = anchor + self.tag = tag + self.implicit = implicit + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + self.style = style + +class SequenceStartEvent(CollectionStartEvent): + pass + +class SequenceEndEvent(CollectionEndEvent): + pass + +class MappingStartEvent(CollectionStartEvent): + pass + +class MappingEndEvent(CollectionEndEvent): + pass + diff --git a/src/yaml/loader.py b/src/yaml/loader.py new file mode 100644 index 0000000..e90c112 --- /dev/null +++ b/src/yaml/loader.py @@ -0,0 +1,63 @@ + +__all__ = ['BaseLoader', 'FullLoader', 'SafeLoader', 'Loader', 'UnsafeLoader'] + +from .reader import * +from .scanner import * +from .parser import * +from .composer import * +from .constructor import * +from .resolver import * + +class BaseLoader(Reader, Scanner, Parser, Composer, BaseConstructor, BaseResolver): + + def __init__(self, stream): + Reader.__init__(self, stream) + Scanner.__init__(self) + Parser.__init__(self) + Composer.__init__(self) + BaseConstructor.__init__(self) + BaseResolver.__init__(self) + +class FullLoader(Reader, Scanner, Parser, Composer, FullConstructor, Resolver): + + def __init__(self, stream): + Reader.__init__(self, stream) + Scanner.__init__(self) + Parser.__init__(self) + Composer.__init__(self) + FullConstructor.__init__(self) + Resolver.__init__(self) + +class SafeLoader(Reader, Scanner, Parser, Composer, SafeConstructor, Resolver): + + def __init__(self, stream): + Reader.__init__(self, stream) + Scanner.__init__(self) + Parser.__init__(self) + Composer.__init__(self) + SafeConstructor.__init__(self) + Resolver.__init__(self) + +class Loader(Reader, Scanner, Parser, Composer, Constructor, Resolver): + + def __init__(self, stream): + Reader.__init__(self, stream) + Scanner.__init__(self) + Parser.__init__(self) + Composer.__init__(self) + Constructor.__init__(self) + Resolver.__init__(self) + +# UnsafeLoader is the same as Loader (which is and was always unsafe on +# untrusted input). Use of either Loader or UnsafeLoader should be rare, since +# FullLoad should be able to load almost all YAML safely. Loader is left intact +# to ensure backwards compatibility. +class UnsafeLoader(Reader, Scanner, Parser, Composer, Constructor, Resolver): + + def __init__(self, stream): + Reader.__init__(self, stream) + Scanner.__init__(self) + Parser.__init__(self) + Composer.__init__(self) + Constructor.__init__(self) + Resolver.__init__(self) diff --git a/src/yaml/nodes.py b/src/yaml/nodes.py new file mode 100644 index 0000000..c4f070c --- /dev/null +++ b/src/yaml/nodes.py @@ -0,0 +1,49 @@ + +class Node(object): + def __init__(self, tag, value, start_mark, end_mark): + self.tag = tag + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + def __repr__(self): + value = self.value + #if isinstance(value, list): + # if len(value) == 0: + # value = '' + # elif len(value) == 1: + # value = '<1 item>' + # else: + # value = '<%d items>' % len(value) + #else: + # if len(value) > 75: + # value = repr(value[:70]+u' ... ') + # else: + # value = repr(value) + value = repr(value) + return '%s(tag=%r, value=%s)' % (self.__class__.__name__, self.tag, value) + +class ScalarNode(Node): + id = 'scalar' + def __init__(self, tag, value, + start_mark=None, end_mark=None, style=None): + self.tag = tag + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + self.style = style + +class CollectionNode(Node): + def __init__(self, tag, value, + start_mark=None, end_mark=None, flow_style=None): + self.tag = tag + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + self.flow_style = flow_style + +class SequenceNode(CollectionNode): + id = 'sequence' + +class MappingNode(CollectionNode): + id = 'mapping' + diff --git a/src/yaml/parser.py b/src/yaml/parser.py new file mode 100644 index 0000000..13a5995 --- /dev/null +++ b/src/yaml/parser.py @@ -0,0 +1,589 @@ + +# The following YAML grammar is LL(1) and is parsed by a recursive descent +# parser. +# +# stream ::= STREAM-START implicit_document? explicit_document* STREAM-END +# implicit_document ::= block_node DOCUMENT-END* +# explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* +# block_node_or_indentless_sequence ::= +# ALIAS +# | properties (block_content | indentless_block_sequence)? +# | block_content +# | indentless_block_sequence +# block_node ::= ALIAS +# | properties block_content? +# | block_content +# flow_node ::= ALIAS +# | properties flow_content? +# | flow_content +# properties ::= TAG ANCHOR? | ANCHOR TAG? +# block_content ::= block_collection | flow_collection | SCALAR +# flow_content ::= flow_collection | SCALAR +# block_collection ::= block_sequence | block_mapping +# flow_collection ::= flow_sequence | flow_mapping +# block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END +# indentless_sequence ::= (BLOCK-ENTRY block_node?)+ +# block_mapping ::= BLOCK-MAPPING_START +# ((KEY block_node_or_indentless_sequence?)? +# (VALUE block_node_or_indentless_sequence?)?)* +# BLOCK-END +# flow_sequence ::= FLOW-SEQUENCE-START +# (flow_sequence_entry FLOW-ENTRY)* +# flow_sequence_entry? +# FLOW-SEQUENCE-END +# flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? +# flow_mapping ::= FLOW-MAPPING-START +# (flow_mapping_entry FLOW-ENTRY)* +# flow_mapping_entry? +# FLOW-MAPPING-END +# flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? +# +# FIRST sets: +# +# stream: { STREAM-START } +# explicit_document: { DIRECTIVE DOCUMENT-START } +# implicit_document: FIRST(block_node) +# block_node: { ALIAS TAG ANCHOR SCALAR BLOCK-SEQUENCE-START BLOCK-MAPPING-START FLOW-SEQUENCE-START FLOW-MAPPING-START } +# flow_node: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START } +# block_content: { BLOCK-SEQUENCE-START BLOCK-MAPPING-START FLOW-SEQUENCE-START FLOW-MAPPING-START SCALAR } +# flow_content: { FLOW-SEQUENCE-START FLOW-MAPPING-START SCALAR } +# block_collection: { BLOCK-SEQUENCE-START BLOCK-MAPPING-START } +# flow_collection: { FLOW-SEQUENCE-START FLOW-MAPPING-START } +# block_sequence: { BLOCK-SEQUENCE-START } +# block_mapping: { BLOCK-MAPPING-START } +# block_node_or_indentless_sequence: { ALIAS ANCHOR TAG SCALAR BLOCK-SEQUENCE-START BLOCK-MAPPING-START FLOW-SEQUENCE-START FLOW-MAPPING-START BLOCK-ENTRY } +# indentless_sequence: { ENTRY } +# flow_collection: { FLOW-SEQUENCE-START FLOW-MAPPING-START } +# flow_sequence: { FLOW-SEQUENCE-START } +# flow_mapping: { FLOW-MAPPING-START } +# flow_sequence_entry: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START KEY } +# flow_mapping_entry: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START KEY } + +__all__ = ['Parser', 'ParserError'] + +from .error import MarkedYAMLError +from .tokens import * +from .events import * +from .scanner import * + +class ParserError(MarkedYAMLError): + pass + +class Parser: + # Since writing a recursive-descendant parser is a straightforward task, we + # do not give many comments here. + + DEFAULT_TAGS = { + '!': '!', + '!!': 'tag:yaml.org,2002:', + } + + def __init__(self): + self.current_event = None + self.yaml_version = None + self.tag_handles = {} + self.states = [] + self.marks = [] + self.state = self.parse_stream_start + + def dispose(self): + # Reset the state attributes (to clear self-references) + self.states = [] + self.state = None + + def check_event(self, *choices): + # Check the type of the next event. + if self.current_event is None: + if self.state: + self.current_event = self.state() + if self.current_event is not None: + if not choices: + return True + for choice in choices: + if isinstance(self.current_event, choice): + return True + return False + + def peek_event(self): + # Get the next event. + if self.current_event is None: + if self.state: + self.current_event = self.state() + return self.current_event + + def get_event(self): + # Get the next event and proceed further. + if self.current_event is None: + if self.state: + self.current_event = self.state() + value = self.current_event + self.current_event = None + return value + + # stream ::= STREAM-START implicit_document? explicit_document* STREAM-END + # implicit_document ::= block_node DOCUMENT-END* + # explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* + + def parse_stream_start(self): + + # Parse the stream start. + token = self.get_token() + event = StreamStartEvent(token.start_mark, token.end_mark, + encoding=token.encoding) + + # Prepare the next state. + self.state = self.parse_implicit_document_start + + return event + + def parse_implicit_document_start(self): + + # Parse an implicit document. + if not self.check_token(DirectiveToken, DocumentStartToken, + StreamEndToken): + self.tag_handles = self.DEFAULT_TAGS + token = self.peek_token() + start_mark = end_mark = token.start_mark + event = DocumentStartEvent(start_mark, end_mark, + explicit=False) + + # Prepare the next state. + self.states.append(self.parse_document_end) + self.state = self.parse_block_node + + return event + + else: + return self.parse_document_start() + + def parse_document_start(self): + + # Parse any extra document end indicators. + while self.check_token(DocumentEndToken): + self.get_token() + + # Parse an explicit document. + if not self.check_token(StreamEndToken): + token = self.peek_token() + start_mark = token.start_mark + version, tags = self.process_directives() + if not self.check_token(DocumentStartToken): + raise ParserError(None, None, + "expected '', but found %r" + % self.peek_token().id, + self.peek_token().start_mark) + token = self.get_token() + end_mark = token.end_mark + event = DocumentStartEvent(start_mark, end_mark, + explicit=True, version=version, tags=tags) + self.states.append(self.parse_document_end) + self.state = self.parse_document_content + else: + # Parse the end of the stream. + token = self.get_token() + event = StreamEndEvent(token.start_mark, token.end_mark) + assert not self.states + assert not self.marks + self.state = None + return event + + def parse_document_end(self): + + # Parse the document end. + token = self.peek_token() + start_mark = end_mark = token.start_mark + explicit = False + if self.check_token(DocumentEndToken): + token = self.get_token() + end_mark = token.end_mark + explicit = True + event = DocumentEndEvent(start_mark, end_mark, + explicit=explicit) + + # Prepare the next state. + self.state = self.parse_document_start + + return event + + def parse_document_content(self): + if self.check_token(DirectiveToken, + DocumentStartToken, DocumentEndToken, StreamEndToken): + event = self.process_empty_scalar(self.peek_token().start_mark) + self.state = self.states.pop() + return event + else: + return self.parse_block_node() + + def process_directives(self): + self.yaml_version = None + self.tag_handles = {} + while self.check_token(DirectiveToken): + token = self.get_token() + if token.name == 'YAML': + if self.yaml_version is not None: + raise ParserError(None, None, + "found duplicate YAML directive", token.start_mark) + major, minor = token.value + if major != 1: + raise ParserError(None, None, + "found incompatible YAML document (version 1.* is required)", + token.start_mark) + self.yaml_version = token.value + elif token.name == 'TAG': + handle, prefix = token.value + if handle in self.tag_handles: + raise ParserError(None, None, + "duplicate tag handle %r" % handle, + token.start_mark) + self.tag_handles[handle] = prefix + if self.tag_handles: + value = self.yaml_version, self.tag_handles.copy() + else: + value = self.yaml_version, None + for key in self.DEFAULT_TAGS: + if key not in self.tag_handles: + self.tag_handles[key] = self.DEFAULT_TAGS[key] + return value + + # block_node_or_indentless_sequence ::= ALIAS + # | properties (block_content | indentless_block_sequence)? + # | block_content + # | indentless_block_sequence + # block_node ::= ALIAS + # | properties block_content? + # | block_content + # flow_node ::= ALIAS + # | properties flow_content? + # | flow_content + # properties ::= TAG ANCHOR? | ANCHOR TAG? + # block_content ::= block_collection | flow_collection | SCALAR + # flow_content ::= flow_collection | SCALAR + # block_collection ::= block_sequence | block_mapping + # flow_collection ::= flow_sequence | flow_mapping + + def parse_block_node(self): + return self.parse_node(block=True) + + def parse_flow_node(self): + return self.parse_node() + + def parse_block_node_or_indentless_sequence(self): + return self.parse_node(block=True, indentless_sequence=True) + + def parse_node(self, block=False, indentless_sequence=False): + if self.check_token(AliasToken): + token = self.get_token() + event = AliasEvent(token.value, token.start_mark, token.end_mark) + self.state = self.states.pop() + else: + anchor = None + tag = None + start_mark = end_mark = tag_mark = None + if self.check_token(AnchorToken): + token = self.get_token() + start_mark = token.start_mark + end_mark = token.end_mark + anchor = token.value + if self.check_token(TagToken): + token = self.get_token() + tag_mark = token.start_mark + end_mark = token.end_mark + tag = token.value + elif self.check_token(TagToken): + token = self.get_token() + start_mark = tag_mark = token.start_mark + end_mark = token.end_mark + tag = token.value + if self.check_token(AnchorToken): + token = self.get_token() + end_mark = token.end_mark + anchor = token.value + if tag is not None: + handle, suffix = tag + if handle is not None: + if handle not in self.tag_handles: + raise ParserError("while parsing a node", start_mark, + "found undefined tag handle %r" % handle, + tag_mark) + tag = self.tag_handles[handle]+suffix + else: + tag = suffix + #if tag == '!': + # raise ParserError("while parsing a node", start_mark, + # "found non-specific tag '!'", tag_mark, + # "Please check 'http://pyyaml.org/wiki/YAMLNonSpecificTag' and share your opinion.") + if start_mark is None: + start_mark = end_mark = self.peek_token().start_mark + event = None + implicit = (tag is None or tag == '!') + if indentless_sequence and self.check_token(BlockEntryToken): + end_mark = self.peek_token().end_mark + event = SequenceStartEvent(anchor, tag, implicit, + start_mark, end_mark) + self.state = self.parse_indentless_sequence_entry + else: + if self.check_token(ScalarToken): + token = self.get_token() + end_mark = token.end_mark + if (token.plain and tag is None) or tag == '!': + implicit = (True, False) + elif tag is None: + implicit = (False, True) + else: + implicit = (False, False) + event = ScalarEvent(anchor, tag, implicit, token.value, + start_mark, end_mark, style=token.style) + self.state = self.states.pop() + elif self.check_token(FlowSequenceStartToken): + end_mark = self.peek_token().end_mark + event = SequenceStartEvent(anchor, tag, implicit, + start_mark, end_mark, flow_style=True) + self.state = self.parse_flow_sequence_first_entry + elif self.check_token(FlowMappingStartToken): + end_mark = self.peek_token().end_mark + event = MappingStartEvent(anchor, tag, implicit, + start_mark, end_mark, flow_style=True) + self.state = self.parse_flow_mapping_first_key + elif block and self.check_token(BlockSequenceStartToken): + end_mark = self.peek_token().start_mark + event = SequenceStartEvent(anchor, tag, implicit, + start_mark, end_mark, flow_style=False) + self.state = self.parse_block_sequence_first_entry + elif block and self.check_token(BlockMappingStartToken): + end_mark = self.peek_token().start_mark + event = MappingStartEvent(anchor, tag, implicit, + start_mark, end_mark, flow_style=False) + self.state = self.parse_block_mapping_first_key + elif anchor is not None or tag is not None: + # Empty scalars are allowed even if a tag or an anchor is + # specified. + event = ScalarEvent(anchor, tag, (implicit, False), '', + start_mark, end_mark) + self.state = self.states.pop() + else: + if block: + node = 'block' + else: + node = 'flow' + token = self.peek_token() + raise ParserError("while parsing a %s node" % node, start_mark, + "expected the node content, but found %r" % token.id, + token.start_mark) + return event + + # block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END + + def parse_block_sequence_first_entry(self): + token = self.get_token() + self.marks.append(token.start_mark) + return self.parse_block_sequence_entry() + + def parse_block_sequence_entry(self): + if self.check_token(BlockEntryToken): + token = self.get_token() + if not self.check_token(BlockEntryToken, BlockEndToken): + self.states.append(self.parse_block_sequence_entry) + return self.parse_block_node() + else: + self.state = self.parse_block_sequence_entry + return self.process_empty_scalar(token.end_mark) + if not self.check_token(BlockEndToken): + token = self.peek_token() + raise ParserError("while parsing a block collection", self.marks[-1], + "expected , but found %r" % token.id, token.start_mark) + token = self.get_token() + event = SequenceEndEvent(token.start_mark, token.end_mark) + self.state = self.states.pop() + self.marks.pop() + return event + + # indentless_sequence ::= (BLOCK-ENTRY block_node?)+ + + def parse_indentless_sequence_entry(self): + if self.check_token(BlockEntryToken): + token = self.get_token() + if not self.check_token(BlockEntryToken, + KeyToken, ValueToken, BlockEndToken): + self.states.append(self.parse_indentless_sequence_entry) + return self.parse_block_node() + else: + self.state = self.parse_indentless_sequence_entry + return self.process_empty_scalar(token.end_mark) + token = self.peek_token() + event = SequenceEndEvent(token.start_mark, token.start_mark) + self.state = self.states.pop() + return event + + # block_mapping ::= BLOCK-MAPPING_START + # ((KEY block_node_or_indentless_sequence?)? + # (VALUE block_node_or_indentless_sequence?)?)* + # BLOCK-END + + def parse_block_mapping_first_key(self): + token = self.get_token() + self.marks.append(token.start_mark) + return self.parse_block_mapping_key() + + def parse_block_mapping_key(self): + if self.check_token(KeyToken): + token = self.get_token() + if not self.check_token(KeyToken, ValueToken, BlockEndToken): + self.states.append(self.parse_block_mapping_value) + return self.parse_block_node_or_indentless_sequence() + else: + self.state = self.parse_block_mapping_value + return self.process_empty_scalar(token.end_mark) + if not self.check_token(BlockEndToken): + token = self.peek_token() + raise ParserError("while parsing a block mapping", self.marks[-1], + "expected , but found %r" % token.id, token.start_mark) + token = self.get_token() + event = MappingEndEvent(token.start_mark, token.end_mark) + self.state = self.states.pop() + self.marks.pop() + return event + + def parse_block_mapping_value(self): + if self.check_token(ValueToken): + token = self.get_token() + if not self.check_token(KeyToken, ValueToken, BlockEndToken): + self.states.append(self.parse_block_mapping_key) + return self.parse_block_node_or_indentless_sequence() + else: + self.state = self.parse_block_mapping_key + return self.process_empty_scalar(token.end_mark) + else: + self.state = self.parse_block_mapping_key + token = self.peek_token() + return self.process_empty_scalar(token.start_mark) + + # flow_sequence ::= FLOW-SEQUENCE-START + # (flow_sequence_entry FLOW-ENTRY)* + # flow_sequence_entry? + # FLOW-SEQUENCE-END + # flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? + # + # Note that while production rules for both flow_sequence_entry and + # flow_mapping_entry are equal, their interpretations are different. + # For `flow_sequence_entry`, the part `KEY flow_node? (VALUE flow_node?)?` + # generate an inline mapping (set syntax). + + def parse_flow_sequence_first_entry(self): + token = self.get_token() + self.marks.append(token.start_mark) + return self.parse_flow_sequence_entry(first=True) + + def parse_flow_sequence_entry(self, first=False): + if not self.check_token(FlowSequenceEndToken): + if not first: + if self.check_token(FlowEntryToken): + self.get_token() + else: + token = self.peek_token() + raise ParserError("while parsing a flow sequence", self.marks[-1], + "expected ',' or ']', but got %r" % token.id, token.start_mark) + + if self.check_token(KeyToken): + token = self.peek_token() + event = MappingStartEvent(None, None, True, + token.start_mark, token.end_mark, + flow_style=True) + self.state = self.parse_flow_sequence_entry_mapping_key + return event + elif not self.check_token(FlowSequenceEndToken): + self.states.append(self.parse_flow_sequence_entry) + return self.parse_flow_node() + token = self.get_token() + event = SequenceEndEvent(token.start_mark, token.end_mark) + self.state = self.states.pop() + self.marks.pop() + return event + + def parse_flow_sequence_entry_mapping_key(self): + token = self.get_token() + if not self.check_token(ValueToken, + FlowEntryToken, FlowSequenceEndToken): + self.states.append(self.parse_flow_sequence_entry_mapping_value) + return self.parse_flow_node() + else: + self.state = self.parse_flow_sequence_entry_mapping_value + return self.process_empty_scalar(token.end_mark) + + def parse_flow_sequence_entry_mapping_value(self): + if self.check_token(ValueToken): + token = self.get_token() + if not self.check_token(FlowEntryToken, FlowSequenceEndToken): + self.states.append(self.parse_flow_sequence_entry_mapping_end) + return self.parse_flow_node() + else: + self.state = self.parse_flow_sequence_entry_mapping_end + return self.process_empty_scalar(token.end_mark) + else: + self.state = self.parse_flow_sequence_entry_mapping_end + token = self.peek_token() + return self.process_empty_scalar(token.start_mark) + + def parse_flow_sequence_entry_mapping_end(self): + self.state = self.parse_flow_sequence_entry + token = self.peek_token() + return MappingEndEvent(token.start_mark, token.start_mark) + + # flow_mapping ::= FLOW-MAPPING-START + # (flow_mapping_entry FLOW-ENTRY)* + # flow_mapping_entry? + # FLOW-MAPPING-END + # flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? + + def parse_flow_mapping_first_key(self): + token = self.get_token() + self.marks.append(token.start_mark) + return self.parse_flow_mapping_key(first=True) + + def parse_flow_mapping_key(self, first=False): + if not self.check_token(FlowMappingEndToken): + if not first: + if self.check_token(FlowEntryToken): + self.get_token() + else: + token = self.peek_token() + raise ParserError("while parsing a flow mapping", self.marks[-1], + "expected ',' or '}', but got %r" % token.id, token.start_mark) + if self.check_token(KeyToken): + token = self.get_token() + if not self.check_token(ValueToken, + FlowEntryToken, FlowMappingEndToken): + self.states.append(self.parse_flow_mapping_value) + return self.parse_flow_node() + else: + self.state = self.parse_flow_mapping_value + return self.process_empty_scalar(token.end_mark) + elif not self.check_token(FlowMappingEndToken): + self.states.append(self.parse_flow_mapping_empty_value) + return self.parse_flow_node() + token = self.get_token() + event = MappingEndEvent(token.start_mark, token.end_mark) + self.state = self.states.pop() + self.marks.pop() + return event + + def parse_flow_mapping_value(self): + if self.check_token(ValueToken): + token = self.get_token() + if not self.check_token(FlowEntryToken, FlowMappingEndToken): + self.states.append(self.parse_flow_mapping_key) + return self.parse_flow_node() + else: + self.state = self.parse_flow_mapping_key + return self.process_empty_scalar(token.end_mark) + else: + self.state = self.parse_flow_mapping_key + token = self.peek_token() + return self.process_empty_scalar(token.start_mark) + + def parse_flow_mapping_empty_value(self): + self.state = self.parse_flow_mapping_key + return self.process_empty_scalar(self.peek_token().start_mark) + + def process_empty_scalar(self, mark): + return ScalarEvent(None, None, (True, False), '', mark, mark) + diff --git a/src/yaml/reader.py b/src/yaml/reader.py new file mode 100644 index 0000000..774b021 --- /dev/null +++ b/src/yaml/reader.py @@ -0,0 +1,185 @@ +# This module contains abstractions for the input stream. You don't have to +# looks further, there are no pretty code. +# +# We define two classes here. +# +# Mark(source, line, column) +# It's just a record and its only use is producing nice error messages. +# Parser does not use it for any other purposes. +# +# Reader(source, data) +# Reader determines the encoding of `data` and converts it to unicode. +# Reader provides the following methods and attributes: +# reader.peek(length=1) - return the next `length` characters +# reader.forward(length=1) - move the current position to `length` characters. +# reader.index - the number of the current character. +# reader.line, stream.column - the line and the column of the current character. + +__all__ = ['Reader', 'ReaderError'] + +from .error import YAMLError, Mark + +import codecs, re + +class ReaderError(YAMLError): + + def __init__(self, name, position, character, encoding, reason): + self.name = name + self.character = character + self.position = position + self.encoding = encoding + self.reason = reason + + def __str__(self): + if isinstance(self.character, bytes): + return "'%s' codec can't decode byte #x%02x: %s\n" \ + " in \"%s\", position %d" \ + % (self.encoding, ord(self.character), self.reason, + self.name, self.position) + else: + return "unacceptable character #x%04x: %s\n" \ + " in \"%s\", position %d" \ + % (self.character, self.reason, + self.name, self.position) + +class Reader(object): + # Reader: + # - determines the data encoding and converts it to a unicode string, + # - checks if characters are in allowed range, + # - adds '\0' to the end. + + # Reader accepts + # - a `bytes` object, + # - a `str` object, + # - a file-like object with its `read` method returning `str`, + # - a file-like object with its `read` method returning `unicode`. + + # Yeah, it's ugly and slow. + + def __init__(self, stream): + self.name = None + self.stream = None + self.stream_pointer = 0 + self.eof = True + self.buffer = '' + self.pointer = 0 + self.raw_buffer = None + self.raw_decode = None + self.encoding = None + self.index = 0 + self.line = 0 + self.column = 0 + if isinstance(stream, str): + self.name = "" + self.check_printable(stream) + self.buffer = stream+'\0' + elif isinstance(stream, bytes): + self.name = "" + self.raw_buffer = stream + self.determine_encoding() + else: + self.stream = stream + self.name = getattr(stream, 'name', "") + self.eof = False + self.raw_buffer = None + self.determine_encoding() + + def peek(self, index=0): + try: + return self.buffer[self.pointer+index] + except IndexError: + self.update(index+1) + return self.buffer[self.pointer+index] + + def prefix(self, length=1): + if self.pointer+length >= len(self.buffer): + self.update(length) + return self.buffer[self.pointer:self.pointer+length] + + def forward(self, length=1): + if self.pointer+length+1 >= len(self.buffer): + self.update(length+1) + while length: + ch = self.buffer[self.pointer] + self.pointer += 1 + self.index += 1 + if ch in '\n\x85\u2028\u2029' \ + or (ch == '\r' and self.buffer[self.pointer] != '\n'): + self.line += 1 + self.column = 0 + elif ch != '\uFEFF': + self.column += 1 + length -= 1 + + def get_mark(self): + if self.stream is None: + return Mark(self.name, self.index, self.line, self.column, + self.buffer, self.pointer) + else: + return Mark(self.name, self.index, self.line, self.column, + None, None) + + def determine_encoding(self): + while not self.eof and (self.raw_buffer is None or len(self.raw_buffer) < 2): + self.update_raw() + if isinstance(self.raw_buffer, bytes): + if self.raw_buffer.startswith(codecs.BOM_UTF16_LE): + self.raw_decode = codecs.utf_16_le_decode + self.encoding = 'utf-16-le' + elif self.raw_buffer.startswith(codecs.BOM_UTF16_BE): + self.raw_decode = codecs.utf_16_be_decode + self.encoding = 'utf-16-be' + else: + self.raw_decode = codecs.utf_8_decode + self.encoding = 'utf-8' + self.update(1) + + NON_PRINTABLE = re.compile('[^\x09\x0A\x0D\x20-\x7E\x85\xA0-\uD7FF\uE000-\uFFFD\U00010000-\U0010ffff]') + def check_printable(self, data): + match = self.NON_PRINTABLE.search(data) + if match: + character = match.group() + position = self.index+(len(self.buffer)-self.pointer)+match.start() + raise ReaderError(self.name, position, ord(character), + 'unicode', "special characters are not allowed") + + def update(self, length): + if self.raw_buffer is None: + return + self.buffer = self.buffer[self.pointer:] + self.pointer = 0 + while len(self.buffer) < length: + if not self.eof: + self.update_raw() + if self.raw_decode is not None: + try: + data, converted = self.raw_decode(self.raw_buffer, + 'strict', self.eof) + except UnicodeDecodeError as exc: + character = self.raw_buffer[exc.start] + if self.stream is not None: + position = self.stream_pointer-len(self.raw_buffer)+exc.start + else: + position = exc.start + raise ReaderError(self.name, position, character, + exc.encoding, exc.reason) + else: + data = self.raw_buffer + converted = len(data) + self.check_printable(data) + self.buffer += data + self.raw_buffer = self.raw_buffer[converted:] + if self.eof: + self.buffer += '\0' + self.raw_buffer = None + break + + def update_raw(self, size=4096): + data = self.stream.read(size) + if self.raw_buffer is None: + self.raw_buffer = data + else: + self.raw_buffer += data + self.stream_pointer += len(data) + if not data: + self.eof = True diff --git a/src/yaml/representer.py b/src/yaml/representer.py new file mode 100644 index 0000000..3b0b192 --- /dev/null +++ b/src/yaml/representer.py @@ -0,0 +1,389 @@ + +__all__ = ['BaseRepresenter', 'SafeRepresenter', 'Representer', + 'RepresenterError'] + +from .error import * +from .nodes import * + +import datetime, copyreg, types, base64, collections + +class RepresenterError(YAMLError): + pass + +class BaseRepresenter: + + yaml_representers = {} + yaml_multi_representers = {} + + def __init__(self, default_style=None, default_flow_style=False, sort_keys=True): + self.default_style = default_style + self.sort_keys = sort_keys + self.default_flow_style = default_flow_style + self.represented_objects = {} + self.object_keeper = [] + self.alias_key = None + + def represent(self, data): + node = self.represent_data(data) + self.serialize(node) + self.represented_objects = {} + self.object_keeper = [] + self.alias_key = None + + def represent_data(self, data): + if self.ignore_aliases(data): + self.alias_key = None + else: + self.alias_key = id(data) + if self.alias_key is not None: + if self.alias_key in self.represented_objects: + node = self.represented_objects[self.alias_key] + #if node is None: + # raise RepresenterError("recursive objects are not allowed: %r" % data) + return node + #self.represented_objects[alias_key] = None + self.object_keeper.append(data) + data_types = type(data).__mro__ + if data_types[0] in self.yaml_representers: + node = self.yaml_representers[data_types[0]](self, data) + else: + for data_type in data_types: + if data_type in self.yaml_multi_representers: + node = self.yaml_multi_representers[data_type](self, data) + break + else: + if None in self.yaml_multi_representers: + node = self.yaml_multi_representers[None](self, data) + elif None in self.yaml_representers: + node = self.yaml_representers[None](self, data) + else: + node = ScalarNode(None, str(data)) + #if alias_key is not None: + # self.represented_objects[alias_key] = node + return node + + @classmethod + def add_representer(cls, data_type, representer): + if not 'yaml_representers' in cls.__dict__: + cls.yaml_representers = cls.yaml_representers.copy() + cls.yaml_representers[data_type] = representer + + @classmethod + def add_multi_representer(cls, data_type, representer): + if not 'yaml_multi_representers' in cls.__dict__: + cls.yaml_multi_representers = cls.yaml_multi_representers.copy() + cls.yaml_multi_representers[data_type] = representer + + def represent_scalar(self, tag, value, style=None): + if style is None: + style = self.default_style + node = ScalarNode(tag, value, style=style) + if self.alias_key is not None: + self.represented_objects[self.alias_key] = node + return node + + def represent_sequence(self, tag, sequence, flow_style=None): + value = [] + node = SequenceNode(tag, value, flow_style=flow_style) + if self.alias_key is not None: + self.represented_objects[self.alias_key] = node + best_style = True + for item in sequence: + node_item = self.represent_data(item) + if not (isinstance(node_item, ScalarNode) and not node_item.style): + best_style = False + value.append(node_item) + if flow_style is None: + if self.default_flow_style is not None: + node.flow_style = self.default_flow_style + else: + node.flow_style = best_style + return node + + def represent_mapping(self, tag, mapping, flow_style=None): + value = [] + node = MappingNode(tag, value, flow_style=flow_style) + if self.alias_key is not None: + self.represented_objects[self.alias_key] = node + best_style = True + if hasattr(mapping, 'items'): + mapping = list(mapping.items()) + if self.sort_keys: + try: + mapping = sorted(mapping) + except TypeError: + pass + for item_key, item_value in mapping: + node_key = self.represent_data(item_key) + node_value = self.represent_data(item_value) + if not (isinstance(node_key, ScalarNode) and not node_key.style): + best_style = False + if not (isinstance(node_value, ScalarNode) and not node_value.style): + best_style = False + value.append((node_key, node_value)) + if flow_style is None: + if self.default_flow_style is not None: + node.flow_style = self.default_flow_style + else: + node.flow_style = best_style + return node + + def ignore_aliases(self, data): + return False + +class SafeRepresenter(BaseRepresenter): + + def ignore_aliases(self, data): + if data is None: + return True + if isinstance(data, tuple) and data == (): + return True + if isinstance(data, (str, bytes, bool, int, float)): + return True + + def represent_none(self, data): + return self.represent_scalar('tag:yaml.org,2002:null', 'null') + + def represent_str(self, data): + return self.represent_scalar('tag:yaml.org,2002:str', data) + + def represent_binary(self, data): + if hasattr(base64, 'encodebytes'): + data = base64.encodebytes(data).decode('ascii') + else: + data = base64.encodestring(data).decode('ascii') + return self.represent_scalar('tag:yaml.org,2002:binary', data, style='|') + + def represent_bool(self, data): + if data: + value = 'true' + else: + value = 'false' + return self.represent_scalar('tag:yaml.org,2002:bool', value) + + def represent_int(self, data): + return self.represent_scalar('tag:yaml.org,2002:int', str(data)) + + inf_value = 1e300 + while repr(inf_value) != repr(inf_value*inf_value): + inf_value *= inf_value + + def represent_float(self, data): + if data != data or (data == 0.0 and data == 1.0): + value = '.nan' + elif data == self.inf_value: + value = '.inf' + elif data == -self.inf_value: + value = '-.inf' + else: + value = repr(data).lower() + # Note that in some cases `repr(data)` represents a float number + # without the decimal parts. For instance: + # >>> repr(1e17) + # '1e17' + # Unfortunately, this is not a valid float representation according + # to the definition of the `!!float` tag. We fix this by adding + # '.0' before the 'e' symbol. + if '.' not in value and 'e' in value: + value = value.replace('e', '.0e', 1) + return self.represent_scalar('tag:yaml.org,2002:float', value) + + def represent_list(self, data): + #pairs = (len(data) > 0 and isinstance(data, list)) + #if pairs: + # for item in data: + # if not isinstance(item, tuple) or len(item) != 2: + # pairs = False + # break + #if not pairs: + return self.represent_sequence('tag:yaml.org,2002:seq', data) + #value = [] + #for item_key, item_value in data: + # value.append(self.represent_mapping(u'tag:yaml.org,2002:map', + # [(item_key, item_value)])) + #return SequenceNode(u'tag:yaml.org,2002:pairs', value) + + def represent_dict(self, data): + return self.represent_mapping('tag:yaml.org,2002:map', data) + + def represent_set(self, data): + value = {} + for key in data: + value[key] = None + return self.represent_mapping('tag:yaml.org,2002:set', value) + + def represent_date(self, data): + value = data.isoformat() + return self.represent_scalar('tag:yaml.org,2002:timestamp', value) + + def represent_datetime(self, data): + value = data.isoformat(' ') + return self.represent_scalar('tag:yaml.org,2002:timestamp', value) + + def represent_yaml_object(self, tag, data, cls, flow_style=None): + if hasattr(data, '__getstate__'): + state = data.__getstate__() + else: + state = data.__dict__.copy() + return self.represent_mapping(tag, state, flow_style=flow_style) + + def represent_undefined(self, data): + raise RepresenterError("cannot represent an object", data) + +SafeRepresenter.add_representer(type(None), + SafeRepresenter.represent_none) + +SafeRepresenter.add_representer(str, + SafeRepresenter.represent_str) + +SafeRepresenter.add_representer(bytes, + SafeRepresenter.represent_binary) + +SafeRepresenter.add_representer(bool, + SafeRepresenter.represent_bool) + +SafeRepresenter.add_representer(int, + SafeRepresenter.represent_int) + +SafeRepresenter.add_representer(float, + SafeRepresenter.represent_float) + +SafeRepresenter.add_representer(list, + SafeRepresenter.represent_list) + +SafeRepresenter.add_representer(tuple, + SafeRepresenter.represent_list) + +SafeRepresenter.add_representer(dict, + SafeRepresenter.represent_dict) + +SafeRepresenter.add_representer(set, + SafeRepresenter.represent_set) + +SafeRepresenter.add_representer(datetime.date, + SafeRepresenter.represent_date) + +SafeRepresenter.add_representer(datetime.datetime, + SafeRepresenter.represent_datetime) + +SafeRepresenter.add_representer(None, + SafeRepresenter.represent_undefined) + +class Representer(SafeRepresenter): + + def represent_complex(self, data): + if data.imag == 0.0: + data = '%r' % data.real + elif data.real == 0.0: + data = '%rj' % data.imag + elif data.imag > 0: + data = '%r+%rj' % (data.real, data.imag) + else: + data = '%r%rj' % (data.real, data.imag) + return self.represent_scalar('tag:yaml.org,2002:python/complex', data) + + def represent_tuple(self, data): + return self.represent_sequence('tag:yaml.org,2002:python/tuple', data) + + def represent_name(self, data): + name = '%s.%s' % (data.__module__, data.__name__) + return self.represent_scalar('tag:yaml.org,2002:python/name:'+name, '') + + def represent_module(self, data): + return self.represent_scalar( + 'tag:yaml.org,2002:python/module:'+data.__name__, '') + + def represent_object(self, data): + # We use __reduce__ API to save the data. data.__reduce__ returns + # a tuple of length 2-5: + # (function, args, state, listitems, dictitems) + + # For reconstructing, we calls function(*args), then set its state, + # listitems, and dictitems if they are not None. + + # A special case is when function.__name__ == '__newobj__'. In this + # case we create the object with args[0].__new__(*args). + + # Another special case is when __reduce__ returns a string - we don't + # support it. + + # We produce a !!python/object, !!python/object/new or + # !!python/object/apply node. + + cls = type(data) + if cls in copyreg.dispatch_table: + reduce = copyreg.dispatch_table[cls](data) + elif hasattr(data, '__reduce_ex__'): + reduce = data.__reduce_ex__(2) + elif hasattr(data, '__reduce__'): + reduce = data.__reduce__() + else: + raise RepresenterError("cannot represent an object", data) + reduce = (list(reduce)+[None]*5)[:5] + function, args, state, listitems, dictitems = reduce + args = list(args) + if state is None: + state = {} + if listitems is not None: + listitems = list(listitems) + if dictitems is not None: + dictitems = dict(dictitems) + if function.__name__ == '__newobj__': + function = args[0] + args = args[1:] + tag = 'tag:yaml.org,2002:python/object/new:' + newobj = True + else: + tag = 'tag:yaml.org,2002:python/object/apply:' + newobj = False + function_name = '%s.%s' % (function.__module__, function.__name__) + if not args and not listitems and not dictitems \ + and isinstance(state, dict) and newobj: + return self.represent_mapping( + 'tag:yaml.org,2002:python/object:'+function_name, state) + if not listitems and not dictitems \ + and isinstance(state, dict) and not state: + return self.represent_sequence(tag+function_name, args) + value = {} + if args: + value['args'] = args + if state or not isinstance(state, dict): + value['state'] = state + if listitems: + value['listitems'] = listitems + if dictitems: + value['dictitems'] = dictitems + return self.represent_mapping(tag+function_name, value) + + def represent_ordered_dict(self, data): + # Provide uniform representation across different Python versions. + data_type = type(data) + tag = 'tag:yaml.org,2002:python/object/apply:%s.%s' \ + % (data_type.__module__, data_type.__name__) + items = [[key, value] for key, value in data.items()] + return self.represent_sequence(tag, [items]) + +Representer.add_representer(complex, + Representer.represent_complex) + +Representer.add_representer(tuple, + Representer.represent_tuple) + +Representer.add_representer(type, + Representer.represent_name) + +Representer.add_representer(collections.OrderedDict, + Representer.represent_ordered_dict) + +Representer.add_representer(types.FunctionType, + Representer.represent_name) + +Representer.add_representer(types.BuiltinFunctionType, + Representer.represent_name) + +Representer.add_representer(types.ModuleType, + Representer.represent_module) + +Representer.add_multi_representer(object, + Representer.represent_object) + diff --git a/src/yaml/resolver.py b/src/yaml/resolver.py new file mode 100644 index 0000000..02b82e7 --- /dev/null +++ b/src/yaml/resolver.py @@ -0,0 +1,227 @@ + +__all__ = ['BaseResolver', 'Resolver'] + +from .error import * +from .nodes import * + +import re + +class ResolverError(YAMLError): + pass + +class BaseResolver: + + DEFAULT_SCALAR_TAG = 'tag:yaml.org,2002:str' + DEFAULT_SEQUENCE_TAG = 'tag:yaml.org,2002:seq' + DEFAULT_MAPPING_TAG = 'tag:yaml.org,2002:map' + + yaml_implicit_resolvers = {} + yaml_path_resolvers = {} + + def __init__(self): + self.resolver_exact_paths = [] + self.resolver_prefix_paths = [] + + @classmethod + def add_implicit_resolver(cls, tag, regexp, first): + if not 'yaml_implicit_resolvers' in cls.__dict__: + implicit_resolvers = {} + for key in cls.yaml_implicit_resolvers: + implicit_resolvers[key] = cls.yaml_implicit_resolvers[key][:] + cls.yaml_implicit_resolvers = implicit_resolvers + if first is None: + first = [None] + for ch in first: + cls.yaml_implicit_resolvers.setdefault(ch, []).append((tag, regexp)) + + @classmethod + def add_path_resolver(cls, tag, path, kind=None): + # Note: `add_path_resolver` is experimental. The API could be changed. + # `new_path` is a pattern that is matched against the path from the + # root to the node that is being considered. `node_path` elements are + # tuples `(node_check, index_check)`. `node_check` is a node class: + # `ScalarNode`, `SequenceNode`, `MappingNode` or `None`. `None` + # matches any kind of a node. `index_check` could be `None`, a boolean + # value, a string value, or a number. `None` and `False` match against + # any _value_ of sequence and mapping nodes. `True` matches against + # any _key_ of a mapping node. A string `index_check` matches against + # a mapping value that corresponds to a scalar key which content is + # equal to the `index_check` value. An integer `index_check` matches + # against a sequence value with the index equal to `index_check`. + if not 'yaml_path_resolvers' in cls.__dict__: + cls.yaml_path_resolvers = cls.yaml_path_resolvers.copy() + new_path = [] + for element in path: + if isinstance(element, (list, tuple)): + if len(element) == 2: + node_check, index_check = element + elif len(element) == 1: + node_check = element[0] + index_check = True + else: + raise ResolverError("Invalid path element: %s" % element) + else: + node_check = None + index_check = element + if node_check is str: + node_check = ScalarNode + elif node_check is list: + node_check = SequenceNode + elif node_check is dict: + node_check = MappingNode + elif node_check not in [ScalarNode, SequenceNode, MappingNode] \ + and not isinstance(node_check, str) \ + and node_check is not None: + raise ResolverError("Invalid node checker: %s" % node_check) + if not isinstance(index_check, (str, int)) \ + and index_check is not None: + raise ResolverError("Invalid index checker: %s" % index_check) + new_path.append((node_check, index_check)) + if kind is str: + kind = ScalarNode + elif kind is list: + kind = SequenceNode + elif kind is dict: + kind = MappingNode + elif kind not in [ScalarNode, SequenceNode, MappingNode] \ + and kind is not None: + raise ResolverError("Invalid node kind: %s" % kind) + cls.yaml_path_resolvers[tuple(new_path), kind] = tag + + def descend_resolver(self, current_node, current_index): + if not self.yaml_path_resolvers: + return + exact_paths = {} + prefix_paths = [] + if current_node: + depth = len(self.resolver_prefix_paths) + for path, kind in self.resolver_prefix_paths[-1]: + if self.check_resolver_prefix(depth, path, kind, + current_node, current_index): + if len(path) > depth: + prefix_paths.append((path, kind)) + else: + exact_paths[kind] = self.yaml_path_resolvers[path, kind] + else: + for path, kind in self.yaml_path_resolvers: + if not path: + exact_paths[kind] = self.yaml_path_resolvers[path, kind] + else: + prefix_paths.append((path, kind)) + self.resolver_exact_paths.append(exact_paths) + self.resolver_prefix_paths.append(prefix_paths) + + def ascend_resolver(self): + if not self.yaml_path_resolvers: + return + self.resolver_exact_paths.pop() + self.resolver_prefix_paths.pop() + + def check_resolver_prefix(self, depth, path, kind, + current_node, current_index): + node_check, index_check = path[depth-1] + if isinstance(node_check, str): + if current_node.tag != node_check: + return + elif node_check is not None: + if not isinstance(current_node, node_check): + return + if index_check is True and current_index is not None: + return + if (index_check is False or index_check is None) \ + and current_index is None: + return + if isinstance(index_check, str): + if not (isinstance(current_index, ScalarNode) + and index_check == current_index.value): + return + elif isinstance(index_check, int) and not isinstance(index_check, bool): + if index_check != current_index: + return + return True + + def resolve(self, kind, value, implicit): + if kind is ScalarNode and implicit[0]: + if value == '': + resolvers = self.yaml_implicit_resolvers.get('', []) + else: + resolvers = self.yaml_implicit_resolvers.get(value[0], []) + resolvers += self.yaml_implicit_resolvers.get(None, []) + for tag, regexp in resolvers: + if regexp.match(value): + return tag + implicit = implicit[1] + if self.yaml_path_resolvers: + exact_paths = self.resolver_exact_paths[-1] + if kind in exact_paths: + return exact_paths[kind] + if None in exact_paths: + return exact_paths[None] + if kind is ScalarNode: + return self.DEFAULT_SCALAR_TAG + elif kind is SequenceNode: + return self.DEFAULT_SEQUENCE_TAG + elif kind is MappingNode: + return self.DEFAULT_MAPPING_TAG + +class Resolver(BaseResolver): + pass + +Resolver.add_implicit_resolver( + 'tag:yaml.org,2002:bool', + re.compile(r'''^(?:yes|Yes|YES|no|No|NO + |true|True|TRUE|false|False|FALSE + |on|On|ON|off|Off|OFF)$''', re.X), + list('yYnNtTfFoO')) + +Resolver.add_implicit_resolver( + 'tag:yaml.org,2002:float', + re.compile(r'''^(?:[-+]?(?:[0-9][0-9_]*)\.[0-9_]*(?:[eE][-+][0-9]+)? + |\.[0-9_]+(?:[eE][-+][0-9]+)? + |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]* + |[-+]?\.(?:inf|Inf|INF) + |\.(?:nan|NaN|NAN))$''', re.X), + list('-+0123456789.')) + +Resolver.add_implicit_resolver( + 'tag:yaml.org,2002:int', + re.compile(r'''^(?:[-+]?0b[0-1_]+ + |[-+]?0[0-7_]+ + |[-+]?(?:0|[1-9][0-9_]*) + |[-+]?0x[0-9a-fA-F_]+ + |[-+]?[1-9][0-9_]*(?::[0-5]?[0-9])+)$''', re.X), + list('-+0123456789')) + +Resolver.add_implicit_resolver( + 'tag:yaml.org,2002:merge', + re.compile(r'^(?:<<)$'), + ['<']) + +Resolver.add_implicit_resolver( + 'tag:yaml.org,2002:null', + re.compile(r'''^(?: ~ + |null|Null|NULL + | )$''', re.X), + ['~', 'n', 'N', '']) + +Resolver.add_implicit_resolver( + 'tag:yaml.org,2002:timestamp', + re.compile(r'''^(?:[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9] + |[0-9][0-9][0-9][0-9] -[0-9][0-9]? -[0-9][0-9]? + (?:[Tt]|[ \t]+)[0-9][0-9]? + :[0-9][0-9] :[0-9][0-9] (?:\.[0-9]*)? + (?:[ \t]*(?:Z|[-+][0-9][0-9]?(?::[0-9][0-9])?))?)$''', re.X), + list('0123456789')) + +Resolver.add_implicit_resolver( + 'tag:yaml.org,2002:value', + re.compile(r'^(?:=)$'), + ['=']) + +# The following resolver is only for documentation purposes. It cannot work +# because plain scalars cannot start with '!', '&', or '*'. +Resolver.add_implicit_resolver( + 'tag:yaml.org,2002:yaml', + re.compile(r'^(?:!|&|\*)$'), + list('!&*')) + diff --git a/src/yaml/scanner.py b/src/yaml/scanner.py new file mode 100644 index 0000000..7437ede --- /dev/null +++ b/src/yaml/scanner.py @@ -0,0 +1,1435 @@ + +# Scanner produces tokens of the following types: +# STREAM-START +# STREAM-END +# DIRECTIVE(name, value) +# DOCUMENT-START +# DOCUMENT-END +# BLOCK-SEQUENCE-START +# BLOCK-MAPPING-START +# BLOCK-END +# FLOW-SEQUENCE-START +# FLOW-MAPPING-START +# FLOW-SEQUENCE-END +# FLOW-MAPPING-END +# BLOCK-ENTRY +# FLOW-ENTRY +# KEY +# VALUE +# ALIAS(value) +# ANCHOR(value) +# TAG(value) +# SCALAR(value, plain, style) +# +# Read comments in the Scanner code for more details. +# + +__all__ = ['Scanner', 'ScannerError'] + +from .error import MarkedYAMLError +from .tokens import * + +class ScannerError(MarkedYAMLError): + pass + +class SimpleKey: + # See below simple keys treatment. + + def __init__(self, token_number, required, index, line, column, mark): + self.token_number = token_number + self.required = required + self.index = index + self.line = line + self.column = column + self.mark = mark + +class Scanner: + + def __init__(self): + """Initialize the scanner.""" + # It is assumed that Scanner and Reader will have a common descendant. + # Reader do the dirty work of checking for BOM and converting the + # input data to Unicode. It also adds NUL to the end. + # + # Reader supports the following methods + # self.peek(i=0) # peek the next i-th character + # self.prefix(l=1) # peek the next l characters + # self.forward(l=1) # read the next l characters and move the pointer. + + # Had we reached the end of the stream? + self.done = False + + # The number of unclosed '{' and '['. `flow_level == 0` means block + # context. + self.flow_level = 0 + + # List of processed tokens that are not yet emitted. + self.tokens = [] + + # Add the STREAM-START token. + self.fetch_stream_start() + + # Number of tokens that were emitted through the `get_token` method. + self.tokens_taken = 0 + + # The current indentation level. + self.indent = -1 + + # Past indentation levels. + self.indents = [] + + # Variables related to simple keys treatment. + + # A simple key is a key that is not denoted by the '?' indicator. + # Example of simple keys: + # --- + # block simple key: value + # ? not a simple key: + # : { flow simple key: value } + # We emit the KEY token before all keys, so when we find a potential + # simple key, we try to locate the corresponding ':' indicator. + # Simple keys should be limited to a single line and 1024 characters. + + # Can a simple key start at the current position? A simple key may + # start: + # - at the beginning of the line, not counting indentation spaces + # (in block context), + # - after '{', '[', ',' (in the flow context), + # - after '?', ':', '-' (in the block context). + # In the block context, this flag also signifies if a block collection + # may start at the current position. + self.allow_simple_key = True + + # Keep track of possible simple keys. This is a dictionary. The key + # is `flow_level`; there can be no more that one possible simple key + # for each level. The value is a SimpleKey record: + # (token_number, required, index, line, column, mark) + # A simple key may start with ALIAS, ANCHOR, TAG, SCALAR(flow), + # '[', or '{' tokens. + self.possible_simple_keys = {} + + # Public methods. + + def check_token(self, *choices): + # Check if the next token is one of the given types. + while self.need_more_tokens(): + self.fetch_more_tokens() + if self.tokens: + if not choices: + return True + for choice in choices: + if isinstance(self.tokens[0], choice): + return True + return False + + def peek_token(self): + # Return the next token, but do not delete if from the queue. + # Return None if no more tokens. + while self.need_more_tokens(): + self.fetch_more_tokens() + if self.tokens: + return self.tokens[0] + else: + return None + + def get_token(self): + # Return the next token. + while self.need_more_tokens(): + self.fetch_more_tokens() + if self.tokens: + self.tokens_taken += 1 + return self.tokens.pop(0) + + # Private methods. + + def need_more_tokens(self): + if self.done: + return False + if not self.tokens: + return True + # The current token may be a potential simple key, so we + # need to look further. + self.stale_possible_simple_keys() + if self.next_possible_simple_key() == self.tokens_taken: + return True + + def fetch_more_tokens(self): + + # Eat whitespaces and comments until we reach the next token. + self.scan_to_next_token() + + # Remove obsolete possible simple keys. + self.stale_possible_simple_keys() + + # Compare the current indentation and column. It may add some tokens + # and decrease the current indentation level. + self.unwind_indent(self.column) + + # Peek the next character. + ch = self.peek() + + # Is it the end of stream? + if ch == '\0': + return self.fetch_stream_end() + + # Is it a directive? + if ch == '%' and self.check_directive(): + return self.fetch_directive() + + # Is it the document start? + if ch == '-' and self.check_document_start(): + return self.fetch_document_start() + + # Is it the document end? + if ch == '.' and self.check_document_end(): + return self.fetch_document_end() + + # TODO: support for BOM within a stream. + #if ch == '\uFEFF': + # return self.fetch_bom() <-- issue BOMToken + + # Note: the order of the following checks is NOT significant. + + # Is it the flow sequence start indicator? + if ch == '[': + return self.fetch_flow_sequence_start() + + # Is it the flow mapping start indicator? + if ch == '{': + return self.fetch_flow_mapping_start() + + # Is it the flow sequence end indicator? + if ch == ']': + return self.fetch_flow_sequence_end() + + # Is it the flow mapping end indicator? + if ch == '}': + return self.fetch_flow_mapping_end() + + # Is it the flow entry indicator? + if ch == ',': + return self.fetch_flow_entry() + + # Is it the block entry indicator? + if ch == '-' and self.check_block_entry(): + return self.fetch_block_entry() + + # Is it the key indicator? + if ch == '?' and self.check_key(): + return self.fetch_key() + + # Is it the value indicator? + if ch == ':' and self.check_value(): + return self.fetch_value() + + # Is it an alias? + if ch == '*': + return self.fetch_alias() + + # Is it an anchor? + if ch == '&': + return self.fetch_anchor() + + # Is it a tag? + if ch == '!': + return self.fetch_tag() + + # Is it a literal scalar? + if ch == '|' and not self.flow_level: + return self.fetch_literal() + + # Is it a folded scalar? + if ch == '>' and not self.flow_level: + return self.fetch_folded() + + # Is it a single quoted scalar? + if ch == '\'': + return self.fetch_single() + + # Is it a double quoted scalar? + if ch == '\"': + return self.fetch_double() + + # It must be a plain scalar then. + if self.check_plain(): + return self.fetch_plain() + + # No? It's an error. Let's produce a nice error message. + raise ScannerError("while scanning for the next token", None, + "found character %r that cannot start any token" % ch, + self.get_mark()) + + # Simple keys treatment. + + def next_possible_simple_key(self): + # Return the number of the nearest possible simple key. Actually we + # don't need to loop through the whole dictionary. We may replace it + # with the following code: + # if not self.possible_simple_keys: + # return None + # return self.possible_simple_keys[ + # min(self.possible_simple_keys.keys())].token_number + min_token_number = None + for level in self.possible_simple_keys: + key = self.possible_simple_keys[level] + if min_token_number is None or key.token_number < min_token_number: + min_token_number = key.token_number + return min_token_number + + def stale_possible_simple_keys(self): + # Remove entries that are no longer possible simple keys. According to + # the YAML specification, simple keys + # - should be limited to a single line, + # - should be no longer than 1024 characters. + # Disabling this procedure will allow simple keys of any length and + # height (may cause problems if indentation is broken though). + for level in list(self.possible_simple_keys): + key = self.possible_simple_keys[level] + if key.line != self.line \ + or self.index-key.index > 1024: + if key.required: + raise ScannerError("while scanning a simple key", key.mark, + "could not find expected ':'", self.get_mark()) + del self.possible_simple_keys[level] + + def save_possible_simple_key(self): + # The next token may start a simple key. We check if it's possible + # and save its position. This function is called for + # ALIAS, ANCHOR, TAG, SCALAR(flow), '[', and '{'. + + # Check if a simple key is required at the current position. + required = not self.flow_level and self.indent == self.column + + # The next token might be a simple key. Let's save it's number and + # position. + if self.allow_simple_key: + self.remove_possible_simple_key() + token_number = self.tokens_taken+len(self.tokens) + key = SimpleKey(token_number, required, + self.index, self.line, self.column, self.get_mark()) + self.possible_simple_keys[self.flow_level] = key + + def remove_possible_simple_key(self): + # Remove the saved possible key position at the current flow level. + if self.flow_level in self.possible_simple_keys: + key = self.possible_simple_keys[self.flow_level] + + if key.required: + raise ScannerError("while scanning a simple key", key.mark, + "could not find expected ':'", self.get_mark()) + + del self.possible_simple_keys[self.flow_level] + + # Indentation functions. + + def unwind_indent(self, column): + + ## In flow context, tokens should respect indentation. + ## Actually the condition should be `self.indent >= column` according to + ## the spec. But this condition will prohibit intuitively correct + ## constructions such as + ## key : { + ## } + #if self.flow_level and self.indent > column: + # raise ScannerError(None, None, + # "invalid indentation or unclosed '[' or '{'", + # self.get_mark()) + + # In the flow context, indentation is ignored. We make the scanner less + # restrictive then specification requires. + if self.flow_level: + return + + # In block context, we may need to issue the BLOCK-END tokens. + while self.indent > column: + mark = self.get_mark() + self.indent = self.indents.pop() + self.tokens.append(BlockEndToken(mark, mark)) + + def add_indent(self, column): + # Check if we need to increase indentation. + if self.indent < column: + self.indents.append(self.indent) + self.indent = column + return True + return False + + # Fetchers. + + def fetch_stream_start(self): + # We always add STREAM-START as the first token and STREAM-END as the + # last token. + + # Read the token. + mark = self.get_mark() + + # Add STREAM-START. + self.tokens.append(StreamStartToken(mark, mark, + encoding=self.encoding)) + + + def fetch_stream_end(self): + + # Set the current indentation to -1. + self.unwind_indent(-1) + + # Reset simple keys. + self.remove_possible_simple_key() + self.allow_simple_key = False + self.possible_simple_keys = {} + + # Read the token. + mark = self.get_mark() + + # Add STREAM-END. + self.tokens.append(StreamEndToken(mark, mark)) + + # The steam is finished. + self.done = True + + def fetch_directive(self): + + # Set the current indentation to -1. + self.unwind_indent(-1) + + # Reset simple keys. + self.remove_possible_simple_key() + self.allow_simple_key = False + + # Scan and add DIRECTIVE. + self.tokens.append(self.scan_directive()) + + def fetch_document_start(self): + self.fetch_document_indicator(DocumentStartToken) + + def fetch_document_end(self): + self.fetch_document_indicator(DocumentEndToken) + + def fetch_document_indicator(self, TokenClass): + + # Set the current indentation to -1. + self.unwind_indent(-1) + + # Reset simple keys. Note that there could not be a block collection + # after '---'. + self.remove_possible_simple_key() + self.allow_simple_key = False + + # Add DOCUMENT-START or DOCUMENT-END. + start_mark = self.get_mark() + self.forward(3) + end_mark = self.get_mark() + self.tokens.append(TokenClass(start_mark, end_mark)) + + def fetch_flow_sequence_start(self): + self.fetch_flow_collection_start(FlowSequenceStartToken) + + def fetch_flow_mapping_start(self): + self.fetch_flow_collection_start(FlowMappingStartToken) + + def fetch_flow_collection_start(self, TokenClass): + + # '[' and '{' may start a simple key. + self.save_possible_simple_key() + + # Increase the flow level. + self.flow_level += 1 + + # Simple keys are allowed after '[' and '{'. + self.allow_simple_key = True + + # Add FLOW-SEQUENCE-START or FLOW-MAPPING-START. + start_mark = self.get_mark() + self.forward() + end_mark = self.get_mark() + self.tokens.append(TokenClass(start_mark, end_mark)) + + def fetch_flow_sequence_end(self): + self.fetch_flow_collection_end(FlowSequenceEndToken) + + def fetch_flow_mapping_end(self): + self.fetch_flow_collection_end(FlowMappingEndToken) + + def fetch_flow_collection_end(self, TokenClass): + + # Reset possible simple key on the current level. + self.remove_possible_simple_key() + + # Decrease the flow level. + self.flow_level -= 1 + + # No simple keys after ']' or '}'. + self.allow_simple_key = False + + # Add FLOW-SEQUENCE-END or FLOW-MAPPING-END. + start_mark = self.get_mark() + self.forward() + end_mark = self.get_mark() + self.tokens.append(TokenClass(start_mark, end_mark)) + + def fetch_flow_entry(self): + + # Simple keys are allowed after ','. + self.allow_simple_key = True + + # Reset possible simple key on the current level. + self.remove_possible_simple_key() + + # Add FLOW-ENTRY. + start_mark = self.get_mark() + self.forward() + end_mark = self.get_mark() + self.tokens.append(FlowEntryToken(start_mark, end_mark)) + + def fetch_block_entry(self): + + # Block context needs additional checks. + if not self.flow_level: + + # Are we allowed to start a new entry? + if not self.allow_simple_key: + raise ScannerError(None, None, + "sequence entries are not allowed here", + self.get_mark()) + + # We may need to add BLOCK-SEQUENCE-START. + if self.add_indent(self.column): + mark = self.get_mark() + self.tokens.append(BlockSequenceStartToken(mark, mark)) + + # It's an error for the block entry to occur in the flow context, + # but we let the parser detect this. + else: + pass + + # Simple keys are allowed after '-'. + self.allow_simple_key = True + + # Reset possible simple key on the current level. + self.remove_possible_simple_key() + + # Add BLOCK-ENTRY. + start_mark = self.get_mark() + self.forward() + end_mark = self.get_mark() + self.tokens.append(BlockEntryToken(start_mark, end_mark)) + + def fetch_key(self): + + # Block context needs additional checks. + if not self.flow_level: + + # Are we allowed to start a key (not necessary a simple)? + if not self.allow_simple_key: + raise ScannerError(None, None, + "mapping keys are not allowed here", + self.get_mark()) + + # We may need to add BLOCK-MAPPING-START. + if self.add_indent(self.column): + mark = self.get_mark() + self.tokens.append(BlockMappingStartToken(mark, mark)) + + # Simple keys are allowed after '?' in the block context. + self.allow_simple_key = not self.flow_level + + # Reset possible simple key on the current level. + self.remove_possible_simple_key() + + # Add KEY. + start_mark = self.get_mark() + self.forward() + end_mark = self.get_mark() + self.tokens.append(KeyToken(start_mark, end_mark)) + + def fetch_value(self): + + # Do we determine a simple key? + if self.flow_level in self.possible_simple_keys: + + # Add KEY. + key = self.possible_simple_keys[self.flow_level] + del self.possible_simple_keys[self.flow_level] + self.tokens.insert(key.token_number-self.tokens_taken, + KeyToken(key.mark, key.mark)) + + # If this key starts a new block mapping, we need to add + # BLOCK-MAPPING-START. + if not self.flow_level: + if self.add_indent(key.column): + self.tokens.insert(key.token_number-self.tokens_taken, + BlockMappingStartToken(key.mark, key.mark)) + + # There cannot be two simple keys one after another. + self.allow_simple_key = False + + # It must be a part of a complex key. + else: + + # Block context needs additional checks. + # (Do we really need them? They will be caught by the parser + # anyway.) + if not self.flow_level: + + # We are allowed to start a complex value if and only if + # we can start a simple key. + if not self.allow_simple_key: + raise ScannerError(None, None, + "mapping values are not allowed here", + self.get_mark()) + + # If this value starts a new block mapping, we need to add + # BLOCK-MAPPING-START. It will be detected as an error later by + # the parser. + if not self.flow_level: + if self.add_indent(self.column): + mark = self.get_mark() + self.tokens.append(BlockMappingStartToken(mark, mark)) + + # Simple keys are allowed after ':' in the block context. + self.allow_simple_key = not self.flow_level + + # Reset possible simple key on the current level. + self.remove_possible_simple_key() + + # Add VALUE. + start_mark = self.get_mark() + self.forward() + end_mark = self.get_mark() + self.tokens.append(ValueToken(start_mark, end_mark)) + + def fetch_alias(self): + + # ALIAS could be a simple key. + self.save_possible_simple_key() + + # No simple keys after ALIAS. + self.allow_simple_key = False + + # Scan and add ALIAS. + self.tokens.append(self.scan_anchor(AliasToken)) + + def fetch_anchor(self): + + # ANCHOR could start a simple key. + self.save_possible_simple_key() + + # No simple keys after ANCHOR. + self.allow_simple_key = False + + # Scan and add ANCHOR. + self.tokens.append(self.scan_anchor(AnchorToken)) + + def fetch_tag(self): + + # TAG could start a simple key. + self.save_possible_simple_key() + + # No simple keys after TAG. + self.allow_simple_key = False + + # Scan and add TAG. + self.tokens.append(self.scan_tag()) + + def fetch_literal(self): + self.fetch_block_scalar(style='|') + + def fetch_folded(self): + self.fetch_block_scalar(style='>') + + def fetch_block_scalar(self, style): + + # A simple key may follow a block scalar. + self.allow_simple_key = True + + # Reset possible simple key on the current level. + self.remove_possible_simple_key() + + # Scan and add SCALAR. + self.tokens.append(self.scan_block_scalar(style)) + + def fetch_single(self): + self.fetch_flow_scalar(style='\'') + + def fetch_double(self): + self.fetch_flow_scalar(style='"') + + def fetch_flow_scalar(self, style): + + # A flow scalar could be a simple key. + self.save_possible_simple_key() + + # No simple keys after flow scalars. + self.allow_simple_key = False + + # Scan and add SCALAR. + self.tokens.append(self.scan_flow_scalar(style)) + + def fetch_plain(self): + + # A plain scalar could be a simple key. + self.save_possible_simple_key() + + # No simple keys after plain scalars. But note that `scan_plain` will + # change this flag if the scan is finished at the beginning of the + # line. + self.allow_simple_key = False + + # Scan and add SCALAR. May change `allow_simple_key`. + self.tokens.append(self.scan_plain()) + + # Checkers. + + def check_directive(self): + + # DIRECTIVE: ^ '%' ... + # The '%' indicator is already checked. + if self.column == 0: + return True + + def check_document_start(self): + + # DOCUMENT-START: ^ '---' (' '|'\n') + if self.column == 0: + if self.prefix(3) == '---' \ + and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029': + return True + + def check_document_end(self): + + # DOCUMENT-END: ^ '...' (' '|'\n') + if self.column == 0: + if self.prefix(3) == '...' \ + and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029': + return True + + def check_block_entry(self): + + # BLOCK-ENTRY: '-' (' '|'\n') + return self.peek(1) in '\0 \t\r\n\x85\u2028\u2029' + + def check_key(self): + + # KEY(flow context): '?' + if self.flow_level: + return True + + # KEY(block context): '?' (' '|'\n') + else: + return self.peek(1) in '\0 \t\r\n\x85\u2028\u2029' + + def check_value(self): + + # VALUE(flow context): ':' + if self.flow_level: + return True + + # VALUE(block context): ':' (' '|'\n') + else: + return self.peek(1) in '\0 \t\r\n\x85\u2028\u2029' + + def check_plain(self): + + # A plain scalar may start with any non-space character except: + # '-', '?', ':', ',', '[', ']', '{', '}', + # '#', '&', '*', '!', '|', '>', '\'', '\"', + # '%', '@', '`'. + # + # It may also start with + # '-', '?', ':' + # if it is followed by a non-space character. + # + # Note that we limit the last rule to the block context (except the + # '-' character) because we want the flow context to be space + # independent. + ch = self.peek() + return ch not in '\0 \t\r\n\x85\u2028\u2029-?:,[]{}#&*!|>\'\"%@`' \ + or (self.peek(1) not in '\0 \t\r\n\x85\u2028\u2029' + and (ch == '-' or (not self.flow_level and ch in '?:'))) + + # Scanners. + + def scan_to_next_token(self): + # We ignore spaces, line breaks and comments. + # If we find a line break in the block context, we set the flag + # `allow_simple_key` on. + # The byte order mark is stripped if it's the first character in the + # stream. We do not yet support BOM inside the stream as the + # specification requires. Any such mark will be considered as a part + # of the document. + # + # TODO: We need to make tab handling rules more sane. A good rule is + # Tabs cannot precede tokens + # BLOCK-SEQUENCE-START, BLOCK-MAPPING-START, BLOCK-END, + # KEY(block), VALUE(block), BLOCK-ENTRY + # So the checking code is + # if : + # self.allow_simple_keys = False + # We also need to add the check for `allow_simple_keys == True` to + # `unwind_indent` before issuing BLOCK-END. + # Scanners for block, flow, and plain scalars need to be modified. + + if self.index == 0 and self.peek() == '\uFEFF': + self.forward() + found = False + while not found: + while self.peek() == ' ': + self.forward() + if self.peek() == '#': + while self.peek() not in '\0\r\n\x85\u2028\u2029': + self.forward() + if self.scan_line_break(): + if not self.flow_level: + self.allow_simple_key = True + else: + found = True + + def scan_directive(self): + # See the specification for details. + start_mark = self.get_mark() + self.forward() + name = self.scan_directive_name(start_mark) + value = None + if name == 'YAML': + value = self.scan_yaml_directive_value(start_mark) + end_mark = self.get_mark() + elif name == 'TAG': + value = self.scan_tag_directive_value(start_mark) + end_mark = self.get_mark() + else: + end_mark = self.get_mark() + while self.peek() not in '\0\r\n\x85\u2028\u2029': + self.forward() + self.scan_directive_ignored_line(start_mark) + return DirectiveToken(name, value, start_mark, end_mark) + + def scan_directive_name(self, start_mark): + # See the specification for details. + length = 0 + ch = self.peek(length) + while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \ + or ch in '-_': + length += 1 + ch = self.peek(length) + if not length: + raise ScannerError("while scanning a directive", start_mark, + "expected alphabetic or numeric character, but found %r" + % ch, self.get_mark()) + value = self.prefix(length) + self.forward(length) + ch = self.peek() + if ch not in '\0 \r\n\x85\u2028\u2029': + raise ScannerError("while scanning a directive", start_mark, + "expected alphabetic or numeric character, but found %r" + % ch, self.get_mark()) + return value + + def scan_yaml_directive_value(self, start_mark): + # See the specification for details. + while self.peek() == ' ': + self.forward() + major = self.scan_yaml_directive_number(start_mark) + if self.peek() != '.': + raise ScannerError("while scanning a directive", start_mark, + "expected a digit or '.', but found %r" % self.peek(), + self.get_mark()) + self.forward() + minor = self.scan_yaml_directive_number(start_mark) + if self.peek() not in '\0 \r\n\x85\u2028\u2029': + raise ScannerError("while scanning a directive", start_mark, + "expected a digit or ' ', but found %r" % self.peek(), + self.get_mark()) + return (major, minor) + + def scan_yaml_directive_number(self, start_mark): + # See the specification for details. + ch = self.peek() + if not ('0' <= ch <= '9'): + raise ScannerError("while scanning a directive", start_mark, + "expected a digit, but found %r" % ch, self.get_mark()) + length = 0 + while '0' <= self.peek(length) <= '9': + length += 1 + value = int(self.prefix(length)) + self.forward(length) + return value + + def scan_tag_directive_value(self, start_mark): + # See the specification for details. + while self.peek() == ' ': + self.forward() + handle = self.scan_tag_directive_handle(start_mark) + while self.peek() == ' ': + self.forward() + prefix = self.scan_tag_directive_prefix(start_mark) + return (handle, prefix) + + def scan_tag_directive_handle(self, start_mark): + # See the specification for details. + value = self.scan_tag_handle('directive', start_mark) + ch = self.peek() + if ch != ' ': + raise ScannerError("while scanning a directive", start_mark, + "expected ' ', but found %r" % ch, self.get_mark()) + return value + + def scan_tag_directive_prefix(self, start_mark): + # See the specification for details. + value = self.scan_tag_uri('directive', start_mark) + ch = self.peek() + if ch not in '\0 \r\n\x85\u2028\u2029': + raise ScannerError("while scanning a directive", start_mark, + "expected ' ', but found %r" % ch, self.get_mark()) + return value + + def scan_directive_ignored_line(self, start_mark): + # See the specification for details. + while self.peek() == ' ': + self.forward() + if self.peek() == '#': + while self.peek() not in '\0\r\n\x85\u2028\u2029': + self.forward() + ch = self.peek() + if ch not in '\0\r\n\x85\u2028\u2029': + raise ScannerError("while scanning a directive", start_mark, + "expected a comment or a line break, but found %r" + % ch, self.get_mark()) + self.scan_line_break() + + def scan_anchor(self, TokenClass): + # The specification does not restrict characters for anchors and + # aliases. This may lead to problems, for instance, the document: + # [ *alias, value ] + # can be interpreted in two ways, as + # [ "value" ] + # and + # [ *alias , "value" ] + # Therefore we restrict aliases to numbers and ASCII letters. + start_mark = self.get_mark() + indicator = self.peek() + if indicator == '*': + name = 'alias' + else: + name = 'anchor' + self.forward() + length = 0 + ch = self.peek(length) + while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \ + or ch in '-_': + length += 1 + ch = self.peek(length) + if not length: + raise ScannerError("while scanning an %s" % name, start_mark, + "expected alphabetic or numeric character, but found %r" + % ch, self.get_mark()) + value = self.prefix(length) + self.forward(length) + ch = self.peek() + if ch not in '\0 \t\r\n\x85\u2028\u2029?:,]}%@`': + raise ScannerError("while scanning an %s" % name, start_mark, + "expected alphabetic or numeric character, but found %r" + % ch, self.get_mark()) + end_mark = self.get_mark() + return TokenClass(value, start_mark, end_mark) + + def scan_tag(self): + # See the specification for details. + start_mark = self.get_mark() + ch = self.peek(1) + if ch == '<': + handle = None + self.forward(2) + suffix = self.scan_tag_uri('tag', start_mark) + if self.peek() != '>': + raise ScannerError("while parsing a tag", start_mark, + "expected '>', but found %r" % self.peek(), + self.get_mark()) + self.forward() + elif ch in '\0 \t\r\n\x85\u2028\u2029': + handle = None + suffix = '!' + self.forward() + else: + length = 1 + use_handle = False + while ch not in '\0 \r\n\x85\u2028\u2029': + if ch == '!': + use_handle = True + break + length += 1 + ch = self.peek(length) + handle = '!' + if use_handle: + handle = self.scan_tag_handle('tag', start_mark) + else: + handle = '!' + self.forward() + suffix = self.scan_tag_uri('tag', start_mark) + ch = self.peek() + if ch not in '\0 \r\n\x85\u2028\u2029': + raise ScannerError("while scanning a tag", start_mark, + "expected ' ', but found %r" % ch, self.get_mark()) + value = (handle, suffix) + end_mark = self.get_mark() + return TagToken(value, start_mark, end_mark) + + def scan_block_scalar(self, style): + # See the specification for details. + + if style == '>': + folded = True + else: + folded = False + + chunks = [] + start_mark = self.get_mark() + + # Scan the header. + self.forward() + chomping, increment = self.scan_block_scalar_indicators(start_mark) + self.scan_block_scalar_ignored_line(start_mark) + + # Determine the indentation level and go to the first non-empty line. + min_indent = self.indent+1 + if min_indent < 1: + min_indent = 1 + if increment is None: + breaks, max_indent, end_mark = self.scan_block_scalar_indentation() + indent = max(min_indent, max_indent) + else: + indent = min_indent+increment-1 + breaks, end_mark = self.scan_block_scalar_breaks(indent) + line_break = '' + + # Scan the inner part of the block scalar. + while self.column == indent and self.peek() != '\0': + chunks.extend(breaks) + leading_non_space = self.peek() not in ' \t' + length = 0 + while self.peek(length) not in '\0\r\n\x85\u2028\u2029': + length += 1 + chunks.append(self.prefix(length)) + self.forward(length) + line_break = self.scan_line_break() + breaks, end_mark = self.scan_block_scalar_breaks(indent) + if self.column == indent and self.peek() != '\0': + + # Unfortunately, folding rules are ambiguous. + # + # This is the folding according to the specification: + + if folded and line_break == '\n' \ + and leading_non_space and self.peek() not in ' \t': + if not breaks: + chunks.append(' ') + else: + chunks.append(line_break) + + # This is Clark Evans's interpretation (also in the spec + # examples): + # + #if folded and line_break == '\n': + # if not breaks: + # if self.peek() not in ' \t': + # chunks.append(' ') + # else: + # chunks.append(line_break) + #else: + # chunks.append(line_break) + else: + break + + # Chomp the tail. + if chomping is not False: + chunks.append(line_break) + if chomping is True: + chunks.extend(breaks) + + # We are done. + return ScalarToken(''.join(chunks), False, start_mark, end_mark, + style) + + def scan_block_scalar_indicators(self, start_mark): + # See the specification for details. + chomping = None + increment = None + ch = self.peek() + if ch in '+-': + if ch == '+': + chomping = True + else: + chomping = False + self.forward() + ch = self.peek() + if ch in '0123456789': + increment = int(ch) + if increment == 0: + raise ScannerError("while scanning a block scalar", start_mark, + "expected indentation indicator in the range 1-9, but found 0", + self.get_mark()) + self.forward() + elif ch in '0123456789': + increment = int(ch) + if increment == 0: + raise ScannerError("while scanning a block scalar", start_mark, + "expected indentation indicator in the range 1-9, but found 0", + self.get_mark()) + self.forward() + ch = self.peek() + if ch in '+-': + if ch == '+': + chomping = True + else: + chomping = False + self.forward() + ch = self.peek() + if ch not in '\0 \r\n\x85\u2028\u2029': + raise ScannerError("while scanning a block scalar", start_mark, + "expected chomping or indentation indicators, but found %r" + % ch, self.get_mark()) + return chomping, increment + + def scan_block_scalar_ignored_line(self, start_mark): + # See the specification for details. + while self.peek() == ' ': + self.forward() + if self.peek() == '#': + while self.peek() not in '\0\r\n\x85\u2028\u2029': + self.forward() + ch = self.peek() + if ch not in '\0\r\n\x85\u2028\u2029': + raise ScannerError("while scanning a block scalar", start_mark, + "expected a comment or a line break, but found %r" % ch, + self.get_mark()) + self.scan_line_break() + + def scan_block_scalar_indentation(self): + # See the specification for details. + chunks = [] + max_indent = 0 + end_mark = self.get_mark() + while self.peek() in ' \r\n\x85\u2028\u2029': + if self.peek() != ' ': + chunks.append(self.scan_line_break()) + end_mark = self.get_mark() + else: + self.forward() + if self.column > max_indent: + max_indent = self.column + return chunks, max_indent, end_mark + + def scan_block_scalar_breaks(self, indent): + # See the specification for details. + chunks = [] + end_mark = self.get_mark() + while self.column < indent and self.peek() == ' ': + self.forward() + while self.peek() in '\r\n\x85\u2028\u2029': + chunks.append(self.scan_line_break()) + end_mark = self.get_mark() + while self.column < indent and self.peek() == ' ': + self.forward() + return chunks, end_mark + + def scan_flow_scalar(self, style): + # See the specification for details. + # Note that we loose indentation rules for quoted scalars. Quoted + # scalars don't need to adhere indentation because " and ' clearly + # mark the beginning and the end of them. Therefore we are less + # restrictive then the specification requires. We only need to check + # that document separators are not included in scalars. + if style == '"': + double = True + else: + double = False + chunks = [] + start_mark = self.get_mark() + quote = self.peek() + self.forward() + chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark)) + while self.peek() != quote: + chunks.extend(self.scan_flow_scalar_spaces(double, start_mark)) + chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark)) + self.forward() + end_mark = self.get_mark() + return ScalarToken(''.join(chunks), False, start_mark, end_mark, + style) + + ESCAPE_REPLACEMENTS = { + '0': '\0', + 'a': '\x07', + 'b': '\x08', + 't': '\x09', + '\t': '\x09', + 'n': '\x0A', + 'v': '\x0B', + 'f': '\x0C', + 'r': '\x0D', + 'e': '\x1B', + ' ': '\x20', + '\"': '\"', + '\\': '\\', + '/': '/', + 'N': '\x85', + '_': '\xA0', + 'L': '\u2028', + 'P': '\u2029', + } + + ESCAPE_CODES = { + 'x': 2, + 'u': 4, + 'U': 8, + } + + def scan_flow_scalar_non_spaces(self, double, start_mark): + # See the specification for details. + chunks = [] + while True: + length = 0 + while self.peek(length) not in '\'\"\\\0 \t\r\n\x85\u2028\u2029': + length += 1 + if length: + chunks.append(self.prefix(length)) + self.forward(length) + ch = self.peek() + if not double and ch == '\'' and self.peek(1) == '\'': + chunks.append('\'') + self.forward(2) + elif (double and ch == '\'') or (not double and ch in '\"\\'): + chunks.append(ch) + self.forward() + elif double and ch == '\\': + self.forward() + ch = self.peek() + if ch in self.ESCAPE_REPLACEMENTS: + chunks.append(self.ESCAPE_REPLACEMENTS[ch]) + self.forward() + elif ch in self.ESCAPE_CODES: + length = self.ESCAPE_CODES[ch] + self.forward() + for k in range(length): + if self.peek(k) not in '0123456789ABCDEFabcdef': + raise ScannerError("while scanning a double-quoted scalar", start_mark, + "expected escape sequence of %d hexdecimal numbers, but found %r" % + (length, self.peek(k)), self.get_mark()) + code = int(self.prefix(length), 16) + chunks.append(chr(code)) + self.forward(length) + elif ch in '\r\n\x85\u2028\u2029': + self.scan_line_break() + chunks.extend(self.scan_flow_scalar_breaks(double, start_mark)) + else: + raise ScannerError("while scanning a double-quoted scalar", start_mark, + "found unknown escape character %r" % ch, self.get_mark()) + else: + return chunks + + def scan_flow_scalar_spaces(self, double, start_mark): + # See the specification for details. + chunks = [] + length = 0 + while self.peek(length) in ' \t': + length += 1 + whitespaces = self.prefix(length) + self.forward(length) + ch = self.peek() + if ch == '\0': + raise ScannerError("while scanning a quoted scalar", start_mark, + "found unexpected end of stream", self.get_mark()) + elif ch in '\r\n\x85\u2028\u2029': + line_break = self.scan_line_break() + breaks = self.scan_flow_scalar_breaks(double, start_mark) + if line_break != '\n': + chunks.append(line_break) + elif not breaks: + chunks.append(' ') + chunks.extend(breaks) + else: + chunks.append(whitespaces) + return chunks + + def scan_flow_scalar_breaks(self, double, start_mark): + # See the specification for details. + chunks = [] + while True: + # Instead of checking indentation, we check for document + # separators. + prefix = self.prefix(3) + if (prefix == '---' or prefix == '...') \ + and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029': + raise ScannerError("while scanning a quoted scalar", start_mark, + "found unexpected document separator", self.get_mark()) + while self.peek() in ' \t': + self.forward() + if self.peek() in '\r\n\x85\u2028\u2029': + chunks.append(self.scan_line_break()) + else: + return chunks + + def scan_plain(self): + # See the specification for details. + # We add an additional restriction for the flow context: + # plain scalars in the flow context cannot contain ',' or '?'. + # We also keep track of the `allow_simple_key` flag here. + # Indentation rules are loosed for the flow context. + chunks = [] + start_mark = self.get_mark() + end_mark = start_mark + indent = self.indent+1 + # We allow zero indentation for scalars, but then we need to check for + # document separators at the beginning of the line. + #if indent == 0: + # indent = 1 + spaces = [] + while True: + length = 0 + if self.peek() == '#': + break + while True: + ch = self.peek(length) + if ch in '\0 \t\r\n\x85\u2028\u2029' \ + or (ch == ':' and + self.peek(length+1) in '\0 \t\r\n\x85\u2028\u2029' + + (u',[]{}' if self.flow_level else u''))\ + or (self.flow_level and ch in ',?[]{}'): + break + length += 1 + if length == 0: + break + self.allow_simple_key = False + chunks.extend(spaces) + chunks.append(self.prefix(length)) + self.forward(length) + end_mark = self.get_mark() + spaces = self.scan_plain_spaces(indent, start_mark) + if not spaces or self.peek() == '#' \ + or (not self.flow_level and self.column < indent): + break + return ScalarToken(''.join(chunks), True, start_mark, end_mark) + + def scan_plain_spaces(self, indent, start_mark): + # See the specification for details. + # The specification is really confusing about tabs in plain scalars. + # We just forbid them completely. Do not use tabs in YAML! + chunks = [] + length = 0 + while self.peek(length) in ' ': + length += 1 + whitespaces = self.prefix(length) + self.forward(length) + ch = self.peek() + if ch in '\r\n\x85\u2028\u2029': + line_break = self.scan_line_break() + self.allow_simple_key = True + prefix = self.prefix(3) + if (prefix == '---' or prefix == '...') \ + and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029': + return + breaks = [] + while self.peek() in ' \r\n\x85\u2028\u2029': + if self.peek() == ' ': + self.forward() + else: + breaks.append(self.scan_line_break()) + prefix = self.prefix(3) + if (prefix == '---' or prefix == '...') \ + and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029': + return + if line_break != '\n': + chunks.append(line_break) + elif not breaks: + chunks.append(' ') + chunks.extend(breaks) + elif whitespaces: + chunks.append(whitespaces) + return chunks + + def scan_tag_handle(self, name, start_mark): + # See the specification for details. + # For some strange reasons, the specification does not allow '_' in + # tag handles. I have allowed it anyway. + ch = self.peek() + if ch != '!': + raise ScannerError("while scanning a %s" % name, start_mark, + "expected '!', but found %r" % ch, self.get_mark()) + length = 1 + ch = self.peek(length) + if ch != ' ': + while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \ + or ch in '-_': + length += 1 + ch = self.peek(length) + if ch != '!': + self.forward(length) + raise ScannerError("while scanning a %s" % name, start_mark, + "expected '!', but found %r" % ch, self.get_mark()) + length += 1 + value = self.prefix(length) + self.forward(length) + return value + + def scan_tag_uri(self, name, start_mark): + # See the specification for details. + # Note: we do not check if URI is well-formed. + chunks = [] + length = 0 + ch = self.peek(length) + while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \ + or ch in '-;/?:@&=+$,_.!~*\'()[]%': + if ch == '%': + chunks.append(self.prefix(length)) + self.forward(length) + length = 0 + chunks.append(self.scan_uri_escapes(name, start_mark)) + else: + length += 1 + ch = self.peek(length) + if length: + chunks.append(self.prefix(length)) + self.forward(length) + length = 0 + if not chunks: + raise ScannerError("while parsing a %s" % name, start_mark, + "expected URI, but found %r" % ch, self.get_mark()) + return ''.join(chunks) + + def scan_uri_escapes(self, name, start_mark): + # See the specification for details. + codes = [] + mark = self.get_mark() + while self.peek() == '%': + self.forward() + for k in range(2): + if self.peek(k) not in '0123456789ABCDEFabcdef': + raise ScannerError("while scanning a %s" % name, start_mark, + "expected URI escape sequence of 2 hexdecimal numbers, but found %r" + % self.peek(k), self.get_mark()) + codes.append(int(self.prefix(2), 16)) + self.forward(2) + try: + value = bytes(codes).decode('utf-8') + except UnicodeDecodeError as exc: + raise ScannerError("while scanning a %s" % name, start_mark, str(exc), mark) + return value + + def scan_line_break(self): + # Transforms: + # '\r\n' : '\n' + # '\r' : '\n' + # '\n' : '\n' + # '\x85' : '\n' + # '\u2028' : '\u2028' + # '\u2029 : '\u2029' + # default : '' + ch = self.peek() + if ch in '\r\n\x85': + if self.prefix(2) == '\r\n': + self.forward(2) + else: + self.forward() + return '\n' + elif ch in '\u2028\u2029': + self.forward() + return ch + return '' diff --git a/src/yaml/serializer.py b/src/yaml/serializer.py new file mode 100644 index 0000000..fe911e6 --- /dev/null +++ b/src/yaml/serializer.py @@ -0,0 +1,111 @@ + +__all__ = ['Serializer', 'SerializerError'] + +from .error import YAMLError +from .events import * +from .nodes import * + +class SerializerError(YAMLError): + pass + +class Serializer: + + ANCHOR_TEMPLATE = 'id%03d' + + def __init__(self, encoding=None, + explicit_start=None, explicit_end=None, version=None, tags=None): + self.use_encoding = encoding + self.use_explicit_start = explicit_start + self.use_explicit_end = explicit_end + self.use_version = version + self.use_tags = tags + self.serialized_nodes = {} + self.anchors = {} + self.last_anchor_id = 0 + self.closed = None + + def open(self): + if self.closed is None: + self.emit(StreamStartEvent(encoding=self.use_encoding)) + self.closed = False + elif self.closed: + raise SerializerError("serializer is closed") + else: + raise SerializerError("serializer is already opened") + + def close(self): + if self.closed is None: + raise SerializerError("serializer is not opened") + elif not self.closed: + self.emit(StreamEndEvent()) + self.closed = True + + #def __del__(self): + # self.close() + + def serialize(self, node): + if self.closed is None: + raise SerializerError("serializer is not opened") + elif self.closed: + raise SerializerError("serializer is closed") + self.emit(DocumentStartEvent(explicit=self.use_explicit_start, + version=self.use_version, tags=self.use_tags)) + self.anchor_node(node) + self.serialize_node(node, None, None) + self.emit(DocumentEndEvent(explicit=self.use_explicit_end)) + self.serialized_nodes = {} + self.anchors = {} + self.last_anchor_id = 0 + + def anchor_node(self, node): + if node in self.anchors: + if self.anchors[node] is None: + self.anchors[node] = self.generate_anchor(node) + else: + self.anchors[node] = None + if isinstance(node, SequenceNode): + for item in node.value: + self.anchor_node(item) + elif isinstance(node, MappingNode): + for key, value in node.value: + self.anchor_node(key) + self.anchor_node(value) + + def generate_anchor(self, node): + self.last_anchor_id += 1 + return self.ANCHOR_TEMPLATE % self.last_anchor_id + + def serialize_node(self, node, parent, index): + alias = self.anchors[node] + if node in self.serialized_nodes: + self.emit(AliasEvent(alias)) + else: + self.serialized_nodes[node] = True + self.descend_resolver(parent, index) + if isinstance(node, ScalarNode): + detected_tag = self.resolve(ScalarNode, node.value, (True, False)) + default_tag = self.resolve(ScalarNode, node.value, (False, True)) + implicit = (node.tag == detected_tag), (node.tag == default_tag) + self.emit(ScalarEvent(alias, node.tag, implicit, node.value, + style=node.style)) + elif isinstance(node, SequenceNode): + implicit = (node.tag + == self.resolve(SequenceNode, node.value, True)) + self.emit(SequenceStartEvent(alias, node.tag, implicit, + flow_style=node.flow_style)) + index = 0 + for item in node.value: + self.serialize_node(item, node, index) + index += 1 + self.emit(SequenceEndEvent()) + elif isinstance(node, MappingNode): + implicit = (node.tag + == self.resolve(MappingNode, node.value, True)) + self.emit(MappingStartEvent(alias, node.tag, implicit, + flow_style=node.flow_style)) + for key, value in node.value: + self.serialize_node(key, node, None) + self.serialize_node(value, node, key) + self.emit(MappingEndEvent()) + self.ascend_resolver() + diff --git a/src/yaml/tokens.py b/src/yaml/tokens.py new file mode 100644 index 0000000..4d0b48a --- /dev/null +++ b/src/yaml/tokens.py @@ -0,0 +1,104 @@ + +class Token(object): + def __init__(self, start_mark, end_mark): + self.start_mark = start_mark + self.end_mark = end_mark + def __repr__(self): + attributes = [key for key in self.__dict__ + if not key.endswith('_mark')] + attributes.sort() + arguments = ', '.join(['%s=%r' % (key, getattr(self, key)) + for key in attributes]) + return '%s(%s)' % (self.__class__.__name__, arguments) + +#class BOMToken(Token): +# id = '' + +class DirectiveToken(Token): + id = '' + def __init__(self, name, value, start_mark, end_mark): + self.name = name + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + +class DocumentStartToken(Token): + id = '' + +class DocumentEndToken(Token): + id = '' + +class StreamStartToken(Token): + id = '' + def __init__(self, start_mark=None, end_mark=None, + encoding=None): + self.start_mark = start_mark + self.end_mark = end_mark + self.encoding = encoding + +class StreamEndToken(Token): + id = '' + +class BlockSequenceStartToken(Token): + id = '' + +class BlockMappingStartToken(Token): + id = '' + +class BlockEndToken(Token): + id = '' + +class FlowSequenceStartToken(Token): + id = '[' + +class FlowMappingStartToken(Token): + id = '{' + +class FlowSequenceEndToken(Token): + id = ']' + +class FlowMappingEndToken(Token): + id = '}' + +class KeyToken(Token): + id = '?' + +class ValueToken(Token): + id = ':' + +class BlockEntryToken(Token): + id = '-' + +class FlowEntryToken(Token): + id = ',' + +class AliasToken(Token): + id = '' + def __init__(self, value, start_mark, end_mark): + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + +class AnchorToken(Token): + id = '' + def __init__(self, value, start_mark, end_mark): + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + +class TagToken(Token): + id = '' + def __init__(self, value, start_mark, end_mark): + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + +class ScalarToken(Token): + id = '' + def __init__(self, value, plain, start_mark, end_mark, style=None): + self.value = value + self.plain = plain + self.start_mark = start_mark + self.end_mark = end_mark + self.style = style + From e0286b2f51aa7a6e43db0d030b27c14eeeb922e5 Mon Sep 17 00:00:00 2001 From: Daniel Rojas Date: Mon, 25 May 2020 19:19:16 +0200 Subject: [PATCH 04/11] Implement first proof of concept --- src/example1.yml | 50 +++++++++++++++++++++++++++++++++++++++++++++ src/yaml2wireviz.py | 43 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 93 insertions(+) create mode 100644 src/example1.yml create mode 100644 src/yaml2wireviz.py diff --git a/src/example1.yml b/src/example1.yml new file mode 100644 index 0000000..f0c0270 --- /dev/null +++ b/src/example1.yml @@ -0,0 +1,50 @@ +nodes: + X1: + type: D-Sub + gender: female + pinout: [DCD,RX,TX,DTR,GND,DSR,RTS,CTS,RI] + random: yes + X2: + type: Molex KK 254 + gender: female + pinout: [GND, RX, TX, N/C, OUT, IN] + +wires: + W1: + mm2: 0.25 + length: 0.2 + color_code: DIN + num_wires: 3 + shield: true + +connections: + - + items: [X1,W1,X2] + X1: 5 # [5,2,3] + W1: 1 # [1,2,3] + X2: 1 # [1,3,2] + - + items: [X1,W1,X2] + X1: 2 # [5,2,3] + W1: 2 # [1,2,3] + X2: 3 # [1,3,2] + - + items: [X1,W1,X2] + X1: 3 # [5,2,3] + W1: 3 # [1,2,3] + X2: 2 # [1,3,2] + - + items: [X1,W1,X2] + X1: 5 + W1: s + X2: ~ + +options: + # for connectors + show_connector_name: true + show_num_pins: true + # for wires + show_wire_name: true + show_num_wires: true + show_wire_pinout: true + show awg_equiv: true diff --git a/src/yaml2wireviz.py b/src/yaml2wireviz.py new file mode 100644 index 0000000..292cab8 --- /dev/null +++ b/src/yaml2wireviz.py @@ -0,0 +1,43 @@ +import yaml +import wireviz + +filename = 'example1.yml' + +with open(filename, 'r') as stream: + try: + input = yaml.safe_load(stream) + except yaml.YAMLError as exc: + print(exc) + +# print(input) + +sections = ('options','nodes','wires') + +for s in sections: + print(s + ':') + for k in input[s]: + print(k + ': ', end='') + print(input[s][k]) + print() + +print('connections:') +for s in input['connections']: + print(s) +print() + +h = wireviz.Harness() +for k in input['nodes']: + n = input['nodes'][k] + h.add_node(k, type=n['type'], gender=n['gender'], pinout=n['pinout']) + +for k in input['wires']: + c = input['wires'][k] + h.add_cable(k, mm2=c['mm2'], length=c['length'], num_wires=c['num_wires'], color_code=c['color_code'], shield=c['shield']) + +for o in input['connections']: + c1 = o['items'][0] + w = o['items'][1] + c2 = o['items'][2] + h.connect(w,c1,o[c1],o[w],c2,o[c2]) + +h.output(filename='output', format=('png',), view=False) From 517cba48638b5ccd0c38fb9750134acc6cc56afe Mon Sep 17 00:00:00 2001 From: Daniel Rojas Date: Tue, 26 May 2020 22:07:39 +0200 Subject: [PATCH 05/11] Implement YAML to WireViz converter --- readme.md | 2 + src/example1.yml | 42 ++++--------- src/testconnections.yml | 43 ++++++++++++++ src/wireviz.py | 10 +--- src/yaml2wireviz.py | 129 +++++++++++++++++++++++++++++++--------- 5 files changed, 160 insertions(+), 66 deletions(-) create mode 100644 src/testconnections.yml diff --git a/readme.md b/readme.md index bc46641..f25e63a 100644 --- a/readme.md +++ b/readme.md @@ -23,6 +23,8 @@ It is based on [GraphViz](https://www.graphviz.org/) and designed as an "extensi * Allows more than one connector per side, as well as loopbacks * Allows for easy-autorouting for 1-to-1 wiring +_Note_: WireViz is not designed to represent the complete wiring of a system. Its main aim is to document the construction of individual wires and harnesses. + ## Example WireViz input file: diff --git a/src/example1.yml b/src/example1.yml index f0c0270..05a5877 100644 --- a/src/example1.yml +++ b/src/example1.yml @@ -2,7 +2,7 @@ nodes: X1: type: D-Sub gender: female - pinout: [DCD,RX,TX,DTR,GND,DSR,RTS,CTS,RI] + pinout: [DCD, RX, TX, DTR, GND, DSR, RTS, CTS, RI] random: yes X2: type: Molex KK 254 @@ -18,33 +18,13 @@ wires: shield: true connections: - - - items: [X1,W1,X2] - X1: 5 # [5,2,3] - W1: 1 # [1,2,3] - X2: 1 # [1,3,2] - - - items: [X1,W1,X2] - X1: 2 # [5,2,3] - W1: 2 # [1,2,3] - X2: 3 # [1,3,2] - - - items: [X1,W1,X2] - X1: 3 # [5,2,3] - W1: 3 # [1,2,3] - X2: 2 # [1,3,2] - - - items: [X1,W1,X2] - X1: 5 - W1: s - X2: ~ - -options: - # for connectors - show_connector_name: true - show_num_pins: true - # for wires - show_wire_name: true - show_num_wires: true - show_wire_pinout: true - show awg_equiv: true + - # format: connector->wire->connector + - X1: [5,2,1] + - W1: [1,2,3] + - X2: [1,3,2] + - # format: connector->wire or wire->connector + - X1: 5 + - W1: s + - # loop: connector-connector + - X2: 5 + - X2: 6 diff --git a/src/testconnections.yml b/src/testconnections.yml new file mode 100644 index 0000000..ac0f9bc --- /dev/null +++ b/src/testconnections.yml @@ -0,0 +1,43 @@ +nodes: + X1: + # type: D-Sub + # gender: female + num_pins: 15 + X2: + type: Molex KK 254 + gender: female + num_pins: 10 + +wires: + W1: + mm2: 0.25 + length: 0.2 + color_code: DIN + num_wires: 15 + shield: true + +connections: + - + - X1: 1 + - W1: 1 + - X2: 1 + - + - X1: [2,3,4] + - W1: [2,3,4] + - X2: [4,3,2] + - + - X1: [5-10] + - W1: [5-7,10,9,8] + - X2: [10-5] + - + - X1: 11 + - W1: s + - + - X1: [1-5] + - W1: [11-15] + - + - W1: [12-15] + - X2: [2-5] + - + - X1: [12,14] + - X1: [13,15] diff --git a/src/wireviz.py b/src/wireviz.py index d39282b..d228297 100644 --- a/src/wireviz.py +++ b/src/wireviz.py @@ -248,15 +248,9 @@ class Cable: self.colors = cc[:n] def connect(self, from_name, from_pin, via, to_name, to_pin): - if from_pin == 'auto': - from_pin = tuple(x+1 for x in range(len(self.colors))) - if via == 'auto': - via = tuple(x+1 for x in range(len(self.colors))) - if to_pin == 'auto': - to_pin = tuple(x+1 for x in range(len(self.colors))) from_pin = int2tuple(from_pin) - via = int2tuple(via) - to_pin = int2tuple(to_pin) + via = int2tuple(via) + to_pin = int2tuple(to_pin) if len(from_pin) != len(to_pin): raise Exception('from_pin must have the same number of elements as to_pin') for i, x in enumerate(from_pin): diff --git a/src/yaml2wireviz.py b/src/yaml2wireviz.py index 292cab8..6ceeda4 100644 --- a/src/yaml2wireviz.py +++ b/src/yaml2wireviz.py @@ -3,41 +3,116 @@ import wireviz filename = 'example1.yml' +def check_designators(what, where): + for i,x in enumerate(what): + # print('Looking for {} in {}'.format(x,where[i])) + if x not in input[where[i]]: + return False + return True + +def expand(input): + # input can be: + # - a singleton (normally str or int) + # - a list of str or int + # if str is of the format '#-#', it is treated as a range (inclusive) and expanded + output = [] + if not isinstance(input, list): + input = [input,] + for e in input: + e = str(e) + if '-' in e: # list of pins + a, b = tuple(map(int, e.split('-'))) + if a < b: + for x in range(a,b+1): + output.append(x) + elif a > b: + for x in range(a,b-1,-1): + output.append(x) + elif a == b: + output.append(a) + else: + try: + x = int(e) + except: + x = e + output.append(x) + return output + with open(filename, 'r') as stream: try: input = yaml.safe_load(stream) except yaml.YAMLError as exc: print(exc) -# print(input) - -sections = ('options','nodes','wires') - -for s in sections: - print(s + ':') - for k in input[s]: - print(k + ': ', end='') - print(input[s][k]) - print() - -print('connections:') -for s in input['connections']: - print(s) -print() - h = wireviz.Harness() -for k in input['nodes']: - n = input['nodes'][k] - h.add_node(k, type=n['type'], gender=n['gender'], pinout=n['pinout']) +# add nodes +for k, o in input['nodes'].items(): + h.add_node(k, type=o.get('type'), gender=o.get('gender'), num_pins=o.get('num_pins'), pinout=o.get('pinout')) +# add wires +for k, o in input['wires'].items(): + h.add_cable(k, mm2=o.get('mm2'), length=o.get('length'), num_wires=o.get('num_wires'), color_code=o.get('color_code'), shield=o.get('shield')) +# add connections +conlist = input['connections'] +for con in conlist: + if len(con) == 3: # format: connector -- wire -- conector -for k in input['wires']: - c = input['wires'][k] - h.add_cable(k, mm2=c['mm2'], length=c['length'], num_wires=c['num_wires'], color_code=c['color_code'], shield=c['shield']) + for c in con: + if len(list(c.keys())) != 1: # check that each entry in con has only one key, which is the designator + raise Exception('Too many keys') -for o in input['connections']: - c1 = o['items'][0] - w = o['items'][1] - c2 = o['items'][2] - h.connect(w,c1,o[c1],o[w],c2,o[c2]) + from_name = list(con[0].keys())[0] + via_name = list(con[1].keys())[0] + to_name = list(con[2].keys())[0] + + if not check_designators([from_name,via_name,to_name],('nodes','wires','nodes')): + raise Exception('Bad connection definition (3)') + + from_pins = expand(con[0][from_name]) + via_pins = expand(con[1][via_name]) + to_pins = expand(con[2][to_name]) + + if len(from_pins) != len(via_pins) or len(via_pins) != len(to_pins): + raise Exception('List length mismatch') + + for (from_pin, via_pin, to_pin) in zip(from_pins, via_pins, to_pins): + h.connect(via_name, from_name, from_pin, via_pin, to_name, to_pin) + + elif len(con) == 2: + + for c in con: + if len(list(c.keys())) != 1: # check that each entry in con has only one key, which is the designator + raise Exception('Too many keys') + + from_name = list(con[0].keys())[0] + to_name = list(con[1].keys())[0] + + n_w = check_designators([from_name, to_name],('nodes','wires')) + w_n = check_designators([from_name, to_name],('wires','nodes')) + n_n = check_designators([from_name, to_name],('nodes','nodes')) + + if not n_w and not w_n and not n_n: + raise Exception('Wrong designators') + + from_pins = expand(con[0][from_name]) + to_pins = expand(con[1][to_name]) + + if len(from_pins) != len(to_pins): + raise Exception('List length mismatch') + + if n_w == True or w_n == True: + for (from_pin, to_pin) in zip(from_pins, to_pins): + if n_w: + h.connect(to_name, from_name, from_pin, to_pin, None, None) + else: # w_n + h.connect(from_name, None, None, from_pin, to_name, to_pin) + elif n_n == True: + con_name = list(con[0].keys())[0] + from_pins = expand(con[0][from_name]) + to_pins = expand(con[1][to_name]) + + for (from_pin, to_pin) in zip(from_pins, to_pins): + h.loop(con_name, from_pin, to_pin) + else: + raise Exception('Wrong number of connection parameters') h.output(filename='output', format=('png',), view=False) From 544e009bcbf6dccc7a6a4fe50db733a881d307d3 Mon Sep 17 00:00:00 2001 From: Daniel Rojas Date: Wed, 27 May 2020 18:49:57 +0200 Subject: [PATCH 06/11] Change order of arguments in wire..connect() squash --- src/example1.py | 2 +- src/example2.py | 6 +++--- src/wireviz.py | 10 +++++----- src/yaml2wireviz.py | 6 +++--- 4 files changed, 12 insertions(+), 12 deletions(-) diff --git a/src/example1.py b/src/example1.py index 98c9818..d7fd876 100644 --- a/src/example1.py +++ b/src/example1.py @@ -6,7 +6,7 @@ h.add_cable('W1', mm2=0.25, length=0.2, show_name=True, show_pinout=True, num_wi h.add_node('X1', type='D-Sub', gender='female', pinout=('DCD','RX','TX','DTR','GND','DSR','RTS','CTS','RI')) h.add_node('X2', type='Molex KK 254', gender='female', pinout=('GND','RX','TX','NC','OUT','IN')) # Option 1: define wires and shield in one line -h.connect('W1','X1',(5,2,3,5),(1,2,3,'s'),'X2',(1,3,2,None)) +h.connect('X1',(5,2,3,5),'W1',(1,2,3,'s'),'X2',(1,3,2,None)) h.loop('X2', 5, 6) # Option 2: define wires and shield separately # Harness.objects['W1'].connect('X1',(5,2,3),'auto','X2',(1,3,2)) # wires diff --git a/src/example2.py b/src/example2.py index 5af74f1..8806c87 100644 --- a/src/example2.py +++ b/src/example2.py @@ -23,9 +23,9 @@ h.add_cable('W1', mm2=0.14, show_equiv=True, length=0.2, colors=COLORS_I2C, show h.add_cable('W2', mm2=0.14, show_equiv=True, length=0.2, colors=COLORS_I2C, show_name=False) h.add_cable('W3', mm2=0.14, show_equiv=True, length=0.2, colors=('BK','BU','OG','VT'), show_name=False) h.add_cable('W4', mm2=0.5, show_equiv=True, length=0.35, colors=('BK','RD'), show_name=False) -h.connect('W1','X1',(1,2,3,4),'auto','X2','auto') -h.connect('W2','X1',(1,2,3,4),'auto','X3','auto') -h.connect('W3','X1',(1,5,6,7),'auto','X4',(1,3,4,5)) +h.connect('X1',(1,2,3,4),'W1','auto','X2','auto') +h.connect('X1',(1,2,3,4),'W2','auto','X3','auto') +h.connect('X1',(1,5,6,7),'W3','auto','X4',(1,3,4,5)) h.connect_all_straight('W4','X5','X4') h.output(filename='output', format=('png','svg'), view=False) diff --git a/src/wireviz.py b/src/wireviz.py index d228297..55b5d0a 100644 --- a/src/wireviz.py +++ b/src/wireviz.py @@ -66,8 +66,8 @@ class Harness: def loop(self, node_name, from_pin, to_pin): self.nodes[node_name].loop(from_pin, to_pin) - def connect(self, cable_name, from_name, from_pin, via, to_name, to_pin): - self.cables[cable_name].connect(from_name, from_pin, via, to_name, to_pin) + def connect(self, from_name, from_pin, via_name, via_pin, to_name, to_pin): + self.cables[via_name].connect(from_name, from_pin, via_pin, to_name, to_pin) def connect_all_straight(self, cable_name, from_name, to_name): self.cables[cable_name].connect_all_straight(from_name, to_name) @@ -247,14 +247,14 @@ class Cable: cc = cc * int(m) self.colors = cc[:n] - def connect(self, from_name, from_pin, via, to_name, to_pin): + def connect(self, from_name, from_pin, via_pin, to_name, to_pin): from_pin = int2tuple(from_pin) - via = int2tuple(via) + via_pin = int2tuple(via_pin) to_pin = int2tuple(to_pin) if len(from_pin) != len(to_pin): raise Exception('from_pin must have the same number of elements as to_pin') for i, x in enumerate(from_pin): - self.connections.append((from_name, from_pin[i], via[i], to_name, to_pin[i])) + self.connections.append((from_name, from_pin[i], via_pin[i], to_name, to_pin[i])) def connect_all_straight(self, from_name, to_name): self.connect(from_name, 'auto', 'auto', to_name, 'auto') diff --git a/src/yaml2wireviz.py b/src/yaml2wireviz.py index 6ceeda4..60dbaa9 100644 --- a/src/yaml2wireviz.py +++ b/src/yaml2wireviz.py @@ -75,7 +75,7 @@ for con in conlist: raise Exception('List length mismatch') for (from_pin, via_pin, to_pin) in zip(from_pins, via_pins, to_pins): - h.connect(via_name, from_name, from_pin, via_pin, to_name, to_pin) + h.connect(from_name, from_pin, via_name, via_pin, to_name, to_pin) elif len(con) == 2: @@ -102,9 +102,9 @@ for con in conlist: if n_w == True or w_n == True: for (from_pin, to_pin) in zip(from_pins, to_pins): if n_w: - h.connect(to_name, from_name, from_pin, to_pin, None, None) + h.connect(from_name, from_pin, to_name, to_pin, None, None) else: # w_n - h.connect(from_name, None, None, from_pin, to_name, to_pin) + h.connect(None, None, from_name, from_pin, to_name, to_pin) elif n_n == True: con_name = list(con[0].keys())[0] from_pins = expand(con[0][from_name]) From eaf57a81bc4637c0df4c0321c9ac3d1eee5e8482 Mon Sep 17 00:00:00 2001 From: Daniel Rojas Date: Wed, 27 May 2020 18:50:27 +0200 Subject: [PATCH 07/11] Re-format code oops --- src/yaml2wireviz.py | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/src/yaml2wireviz.py b/src/yaml2wireviz.py index 60dbaa9..01a452c 100644 --- a/src/yaml2wireviz.py +++ b/src/yaml2wireviz.py @@ -47,10 +47,19 @@ with open(filename, 'r') as stream: h = wireviz.Harness() # add nodes for k, o in input['nodes'].items(): - h.add_node(k, type=o.get('type'), gender=o.get('gender'), num_pins=o.get('num_pins'), pinout=o.get('pinout')) + h.add_node(k, type=o.get('type'), + gender=o.get('gender'), + num_pins=o.get('num_pins'), + pinout=o.get('pinout')) # add wires for k, o in input['wires'].items(): - h.add_cable(k, mm2=o.get('mm2'), length=o.get('length'), num_wires=o.get('num_wires'), color_code=o.get('color_code'), shield=o.get('shield')) + h.add_cable(k, mm2=o.get('mm2'), + awg=o.get('awg'), + length=o.get('length'), + num_wires=o.get('num_wires'), + colors=o.get('colors'), + color_code=o.get('color_code'), + shield=o.get('shield')) # add connections conlist = input['connections'] for con in conlist: From e829294c70ce1fc2b97b19bb9f65a48cbabc3ff8 Mon Sep 17 00:00:00 2001 From: Daniel Rojas Date: Wed, 27 May 2020 18:50:44 +0200 Subject: [PATCH 08/11] Add example 2 as YAML file --- src/example2.yml | 85 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 85 insertions(+) create mode 100644 src/example2.yml diff --git a/src/example2.yml b/src/example2.yml new file mode 100644 index 0000000..9b854ed --- /dev/null +++ b/src/example2.yml @@ -0,0 +1,85 @@ +templates: + - &molex_f + type: Molex KK 254 + gender: female + - &con_i2c + pinout: [GND, +5V, SCL, SDA] + - &wire_i2c + mm2: 0.14 + length: 0.2 + colors: [BK, RD, YE, GN] + +nodes: + X1: + <<: *molex_f + pinout: [GND, +5V, SCL, SDA, MISO, MOSI, SCK, N/C] + X2: + <<: *molex_f + <<: *con_i2c + X3: + <<: *molex_f + <<: *con_i2c + X4: + <<: *molex_f + pinout: [GND, +12V, MISO, MOSI, flachstecker] + X5: + type: Molex Micro-Fit + gender: male + pinout: [GND, +12V] + +wires: + W1: + <<: *wire_i2c + W2: + <<: *wire_i2c + W3: + mm2: 0.14 + length: 0.2 + colors: [BK, BU, OG, VT] + W4: + mm2: 0.5 + length: 0.35 + colors: [BK, RD] + +connections: + - + - X1: [1-4] + - W1: [1-4] + - X2: [1-4] + - + - X1: [1-4] + - W2: [1-4] + - X3: [1-4] + - + - X1: [1,5-7] + - W3: [1-4] + - X4: [1,3-5] + - + - X5: [1,2] + - W4: [1,2] + - X4: [1,2] + +# - +# - X1: 1 +# - W1: 1 +# - X2: 1 +# - +# - X1: [2,3,4] +# - W1: [2,3,4] +# - X2: [4,3,2] +# - +# - X1: [5-10] +# - W1: [5-7,10,9,8] +# - X2: [10-5] +# - +# - X1: 11 +# - W1: s +# - +# - X1: [1-5] +# - W1: [11-15] +# - +# - W1: [12-15] +# - X2: [2-5] +# - +# - X1: [12,14] +# - X1: [13,15] From 346dd7251090e31acd6c0ac6a61bc002e922c7cf Mon Sep 17 00:00:00 2001 From: Daniel Rojas Date: Wed, 27 May 2020 18:57:58 +0200 Subject: [PATCH 09/11] Add to-do list --- todo.md | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 todo.md diff --git a/todo.md b/todo.md new file mode 100644 index 0000000..70d3d83 --- /dev/null +++ b/todo.md @@ -0,0 +1,19 @@ +* Generic connectors + * ferrules + * blade terminals + * loose ends +* new wire look? + * distinguish between cables and wire bundles +* improve nomenclature + * terminal (connector, ferrule, blade, loose) + * link (cable, wire bundle) +* show from/to inside wire node +* export to PDF with frame, title block, ... +* make "unit tests" for different features/situations + * missing parameters + * connection formats + * single wire 1 + * multiple wires [1,2,3] + * wire ranges [1-10] + * loops + * ... From c38d2b1876e56613193b0d82156e81c274570fa5 Mon Sep 17 00:00:00 2001 From: Daniel Rojas Date: Wed, 27 May 2020 19:55:29 +0200 Subject: [PATCH 10/11] Move examples --- examples/example1.gv | 20 - examples/example1.png | Bin 57078 -> 0 bytes {src => examples}/example1.py | 0 examples/example1.svg | 185 ---- {src => examples}/example1.yml | 0 examples/example2.gv | 56 -- examples/example2.png | Bin 149467 -> 0 bytes {src => examples}/example2.py | 0 examples/example2.svg | 427 --------- {src => examples}/example2.yml | 0 examples/example3.gv | 185 ---- examples/example3.png | Bin 150154 -> 0 bytes {src => examples}/example3.py | 0 examples/example3.svg | 1227 ------------------------- {src => examples}/example4.py | 0 {src => examples}/testconnections.yml | 0 src/yaml2wireviz.py | 4 +- 17 files changed, 2 insertions(+), 2102 deletions(-) delete mode 100644 examples/example1.gv delete mode 100644 examples/example1.png rename {src => examples}/example1.py (100%) delete mode 100644 examples/example1.svg rename {src => examples}/example1.yml (100%) delete mode 100644 examples/example2.gv delete mode 100644 examples/example2.png rename {src => examples}/example2.py (100%) delete mode 100644 examples/example2.svg rename {src => examples}/example2.yml (100%) delete mode 100644 examples/example3.gv delete mode 100644 examples/example3.png rename {src => examples}/example3.py (100%) delete mode 100644 examples/example3.svg rename {src => examples}/example4.py (100%) rename {src => examples}/testconnections.yml (100%) diff --git a/examples/example1.gv b/examples/example1.gv deleted file mode 100644 index 4c36ab6..0000000 --- a/examples/example1.gv +++ /dev/null @@ -1,20 +0,0 @@ -graph { - graph [bgcolor=transparent fontname=arial rankdir=LR ranksep=2] - node [fillcolor=white fontname=arial shape=record style="rounded,filled"] - edge [fontname=arial style=bold] - X1 [label="X1|{D-Sub|female|9-pin}|{{DCD|RX|TX|DTR|GND|DSR|RTS|CTS|RI}|{1|2|3|4|5|6|7|8|9}}"] - X2 [label="X2|{Molex KK 254|female|6-pin}|{{1|2|3|4|5|6}|{GND|RX|TX|NC|OUT|IN}}"] - X2:p5:w -- X2:p6:w - W1 [label="W1|{3x|0.25 mm²|+ S|0.2 m}|{{1|2|3|}|{WH|BN|GN|Shield}|{1|2|3|}}"] - edge [color="#000000:#ffffff:#000000"] - X1:p5 -- W1:w1i - W1:w1o -- X2:p1 - edge [color="#000000:#666600:#000000"] - X1:p2 -- W1:w2i - W1:w2o -- X2:p3 - edge [color="#000000:#00ff00:#000000"] - X1:p3 -- W1:w3i - W1:w3o -- X2:p2 - edge [color="#000000"] - X1:p5 -- W1:wsi -} diff --git a/examples/example1.png b/examples/example1.png deleted file mode 100644 index 8fcfd59b811d907a075484eba559b1a790a972a4..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 57078 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 W^I5F5sH^BGKiqG1;r{^ZXUNh3 diff --git a/src/example1.py b/examples/example1.py similarity index 100% rename from src/example1.py rename to examples/example1.py diff --git a/examples/example1.svg b/examples/example1.svg deleted file mode 100644 index 5a39842..0000000 --- a/examples/example1.svg +++ /dev/null @@ -1,185 +0,0 @@ - - - - - - - - -X1 - -X1 - -D-Sub - -female - -9-pin - -DCD - -RX - -TX - -DTR - -GND - -DSR - -RTS - -CTS - -RI - -1 - -2 - -3 - -4 - -5 - -6 - -7 - -8 - -9 - - - -W1 - -W1 - -3x - -0.25 mm² - -+ S - -0.2 m - -1 - -2 - -3 - - - -WH - -BN - -GN - -Shield - -1 - -2 - -3 - - - - - -X1:p5--W1:w1i - - - - - - -X1:p2--W1:w2i - - - - - - -X1:p3--W1:w3i - - - - - - -X1:p5--W1:wsi - - - - -X2 - -X2 - -Molex KK 254 - -female - -6-pin - -1 - -2 - -3 - -4 - -5 - -6 - -GND - -RX - -TX - -NC - -OUT - -IN - - - -X2:w--X2:w - - - - -W1:w1o--X2:p1 - - - - - - -W1:w2o--X2:p3 - - - - - - -W1:w3o--X2:p2 - - - - - - diff --git a/src/example1.yml b/examples/example1.yml similarity index 100% rename from src/example1.yml rename to examples/example1.yml diff --git a/examples/example2.gv b/examples/example2.gv deleted file mode 100644 index 8cb99aa..0000000 --- a/examples/example2.gv +++ /dev/null @@ -1,56 +0,0 @@ -graph { - graph [bgcolor=transparent fontname=arial rankdir=LR ranksep=2] - node [fillcolor=white fontname=arial shape=record style="rounded,filled"] - edge [fontname=arial style=bold] - X1 [label="X1|{Molex KK 254|female|8-pin}|{{GND|+5V|SCL|SDA|MISO|MOSI|SCK|N/C}|{1|2|3|4|5|6|7|8}}"] - X2 [label="X2|{Molex KK 254|female|4-pin}|{{1|2|3|4}|{GND|+5V|SCL|SDA}}"] - X3 [label="X3|{Molex KK 254|female|4-pin}|{{1|2|3|4}|{GND|+5V|SCL|SDA}}"] - X4 [label="X4|{Molex KK 254|female|5-pin}|{{1|2|3|4|5}|{GND|+12V|MISO|MOSI|SCK}}"] - X5 [label="X5|{Molex Micro-Fit|male|2-pin}|{{GND|+12V}|{1|2}}"] - W1 [label="{4x|0.14 mm² (26 AWG)|0.2 m}|{{BK|RD|YE|GN}}"] - edge [color="#000000:#000000:#000000"] - X1:p1 -- W1:w1 - W1:w1 -- X2:p1 - edge [color="#000000:#ff0000:#000000"] - X1:p2 -- W1:w2 - W1:w2 -- X2:p2 - edge [color="#000000:#ffff00:#000000"] - X1:p3 -- W1:w3 - W1:w3 -- X2:p3 - edge [color="#000000:#00ff00:#000000"] - X1:p4 -- W1:w4 - W1:w4 -- X2:p4 - W2 [label="{4x|0.14 mm² (26 AWG)|0.2 m}|{{BK|RD|YE|GN}}"] - edge [color="#000000:#000000:#000000"] - X1:p1 -- W2:w1 - W2:w1 -- X3:p1 - edge [color="#000000:#ff0000:#000000"] - X1:p2 -- W2:w2 - W2:w2 -- X3:p2 - edge [color="#000000:#ffff00:#000000"] - X1:p3 -- W2:w3 - W2:w3 -- X3:p3 - edge [color="#000000:#00ff00:#000000"] - X1:p4 -- W2:w4 - W2:w4 -- X3:p4 - W3 [label="{4x|0.14 mm² (26 AWG)|0.2 m}|{{BK|BU|OG|VT}}"] - edge [color="#000000:#000000:#000000"] - X1:p1 -- W3:w1 - W3:w1 -- X4:p1 - edge [color="#000000:#0000ff:#000000"] - X1:p5 -- W3:w2 - W3:w2 -- X4:p3 - edge [color="#000000:#ff8000:#000000"] - X1:p6 -- W3:w3 - W3:w3 -- X4:p4 - edge [color="#000000:#8000ff:#000000"] - X1:p7 -- W3:w4 - W3:w4 -- X4:p5 - W4 [label="{2x|0.5 mm² (21 AWG)|0.35 m}|{{BK|RD}}"] - edge [color="#000000:#000000:#000000"] - X5:p1 -- W4:w1 - W4:w1 -- X4:p1 - edge [color="#000000:#ff0000:#000000"] - X5:p2 -- W4:w2 - W4:w2 -- X4:p2 -} diff --git a/examples/example2.png b/examples/example2.png deleted file mode 100644 index 8303d9ca2ca3c05f27eccd73768312555767a97a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 149467 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

E_4!S5%9hF-V;8E^y|0HSV{mfqZF(YA?)B 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%0AR5(wa>G4_Tf4IdBZVH? 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 D68piW diff --git a/src/example2.py b/examples/example2.py similarity index 100% rename from src/example2.py rename to examples/example2.py diff --git a/examples/example2.svg b/examples/example2.svg deleted file mode 100644 index 0a6c23d..0000000 --- a/examples/example2.svg +++ /dev/null @@ -1,427 +0,0 @@ - - - - - - - - -X1 - -X1 - -Molex KK 254 - -female - -8-pin - -GND - -+5V - -SCL - -SDA - -MISO - -MOSI - -SCK - -N/C - -1 - -2 - -3 - -4 - -5 - -6 - -7 - -8 - - - -W1 - -4x - -0.14 mm² (26 AWG) - -0.2 m - -BK - -RD - -YE - -GN - - - -X1:p1--W1:w1 - - - - - - -X1:p2--W1:w2 - - - - - - -X1:p3--W1:w3 - - - - - - -X1:p4--W1:w4 - - - - - - -W2 - -4x - -0.14 mm² (26 AWG) - -0.2 m - -BK - -RD - -YE - -GN - - - -X1:p1--W2:w1 - - - - - - -X1:p2--W2:w2 - - - - - - -X1:p3--W2:w3 - - - - - - -X1:p4--W2:w4 - - - - - - -W3 - -4x - -0.14 mm² (26 AWG) - -0.2 m - -BK - -BU - -OG - -VT - - - -X1:p1--W3:w1 - - - - - - -X1:p5--W3:w2 - - - - - - -X1:p6--W3:w3 - - - - - - -X1:p7--W3:w4 - - - - - - -X2 - -X2 - -Molex KK 254 - -female - -4-pin - -1 - -2 - -3 - -4 - -GND - -+5V - -SCL - -SDA - - - -X3 - -X3 - -Molex KK 254 - -female - -4-pin - -1 - -2 - -3 - -4 - -GND - -+5V - -SCL - -SDA - - - -X4 - -X4 - -Molex KK 254 - -female - -5-pin - -1 - -2 - -3 - -4 - -5 - -GND - -+12V - -MISO - -MOSI - -SCK - - - -X5 - -X5 - -Molex Micro-Fit - -male - -2-pin - -GND - -+12V - -1 - -2 - - - -W4 - -2x - -0.5 mm² (21 AWG) - -0.35 m - -BK - -RD - - - -X5:p1--W4:w1 - - - - - - -X5:p2--W4:w2 - - - - - - -W1:w1--X2:p1 - - - - - - -W1:w2--X2:p2 - - - - - - -W1:w3--X2:p3 - - - - - - -W1:w4--X2:p4 - - - - - - -W2:w1--X3:p1 - - - - - - -W2:w2--X3:p2 - - - - - - -W2:w3--X3:p3 - - - - - - -W2:w4--X3:p4 - - - - - - -W3:w1--X4:p1 - - - - - - -W3:w2--X4:p3 - - - - - - -W3:w3--X4:p4 - - - - - - -W3:w4--X4:p5 - - - - - - -W4:w1--X4:p1 - - - - - - -W4:w2--X4:p2 - - - - - - diff --git a/src/example2.yml b/examples/example2.yml similarity index 100% rename from src/example2.yml rename to examples/example2.yml diff --git a/examples/example3.gv b/examples/example3.gv deleted file mode 100644 index 843338e..0000000 --- a/examples/example3.gv +++ /dev/null @@ -1,185 +0,0 @@ -graph { - graph [bgcolor=transparent fontname=arial rankdir=LR ranksep=2] - node [fillcolor=white fontname=arial shape=record style="rounded,filled"] - edge [fontname=arial style=bold] - X1 [label="X1|{10-pin}|{{}|{1|2|3|4|5|6|7|8|9|10}}"] - X2 [label="X2|{10-pin}|{{1|2|3|4|5|6|7|8|9|10}|{}}"] - X3 [label="X3|{20-pin}|{{}|{1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20}}"] - X4 [label="X4|{20-pin}|{{1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20}|{}}"] - X5 [label="X5|{20-pin}|{{}|{1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20}}"] - X6 [label="X6|{20-pin}|{{1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20}|{}}"] - X7 [label="X7|{6-pin}|{{}|{1|2|3|4|5|6}}"] - X8 [label="X8|{6-pin}|{{1|2|3|4|5|6}|{}}"] - W1 [label="{10x|None mm²|0 m}|{{brown|red|orange|yellow|green|blue|violet|grey|white|black}}"] - edge [color="#000000:#666600:#000000"] - X1:p1 -- W1:w1 - W1:w1 -- X2:p1 - edge [color="#000000:#ff0000:#000000"] - X1:p2 -- W1:w2 - W1:w2 -- X2:p2 - edge [color="#000000:#ff8000:#000000"] - X1:p3 -- W1:w3 - W1:w3 -- X2:p3 - edge [color="#000000:#ffff00:#000000"] - X1:p4 -- W1:w4 - W1:w4 -- X2:p4 - edge [color="#000000:#00ff00:#000000"] - X1:p5 -- W1:w5 - W1:w5 -- X2:p5 - edge [color="#000000:#0000ff:#000000"] - X1:p6 -- W1:w6 - W1:w6 -- X2:p6 - edge [color="#000000:#8000ff:#000000"] - X1:p7 -- W1:w7 - W1:w7 -- X2:p7 - edge [color="#000000:#808080:#000000"] - X1:p8 -- W1:w8 - W1:w8 -- X2:p8 - edge [color="#000000:#ffffff:#000000"] - X1:p9 -- W1:w9 - W1:w9 -- X2:p9 - edge [color="#000000:#000000:#000000"] - X1:p10 -- W1:w10 - W1:w10 -- X2:p10 - W2 [label="{20x|None mm²|0 m}|{{white|brown|green|yellow|grey|pink|blue|red|black|violet|white|brown|green|yellow|grey|pink|blue|red|black|violet}}"] - edge [color="#000000:#ffffff:#000000"] - X3:p1 -- W2:w1 - W2:w1 -- X4:p1 - edge [color="#000000:#666600:#000000"] - X3:p2 -- W2:w2 - W2:w2 -- X4:p2 - edge [color="#000000:#00ff00:#000000"] - X3:p3 -- W2:w3 - W2:w3 -- X4:p3 - edge [color="#000000:#ffff00:#000000"] - X3:p4 -- W2:w4 - W2:w4 -- X4:p4 - edge [color="#000000:#808080:#000000"] - X3:p5 -- W2:w5 - W2:w5 -- X4:p5 - edge [color="#000000:#ff80c0:#000000"] - X3:p6 -- W2:w6 - W2:w6 -- X4:p6 - edge [color="#000000:#0000ff:#000000"] - X3:p7 -- W2:w7 - W2:w7 -- X4:p7 - edge [color="#000000:#ff0000:#000000"] - X3:p8 -- W2:w8 - W2:w8 -- X4:p8 - edge [color="#000000:#000000:#000000"] - X3:p9 -- W2:w9 - W2:w9 -- X4:p9 - edge [color="#000000:#8000ff:#000000"] - X3:p10 -- W2:w10 - W2:w10 -- X4:p10 - edge [color="#000000:#ffffff:#000000"] - X3:p11 -- W2:w11 - W2:w11 -- X4:p11 - edge [color="#000000:#666600:#000000"] - X3:p12 -- W2:w12 - W2:w12 -- X4:p12 - edge [color="#000000:#00ff00:#000000"] - X3:p13 -- W2:w13 - W2:w13 -- X4:p13 - edge [color="#000000:#ffff00:#000000"] - X3:p14 -- W2:w14 - W2:w14 -- X4:p14 - edge [color="#000000:#808080:#000000"] - X3:p15 -- W2:w15 - W2:w15 -- X4:p15 - edge [color="#000000:#ff80c0:#000000"] - X3:p16 -- W2:w16 - W2:w16 -- X4:p16 - edge [color="#000000:#0000ff:#000000"] - X3:p17 -- W2:w17 - W2:w17 -- X4:p17 - edge [color="#000000:#ff0000:#000000"] - X3:p18 -- W2:w18 - W2:w18 -- X4:p18 - edge [color="#000000:#000000:#000000"] - X3:p19 -- W2:w19 - W2:w19 -- X4:p19 - edge [color="#000000:#8000ff:#000000"] - X3:p20 -- W2:w20 - W2:w20 -- X4:p20 - W3 [label="{20x|None mm²|0 m}|{{red|yellow|blue|red|yellow|blue|red|yellow|blue|red|yellow|blue|red|yellow|blue|red|yellow|blue|red|yellow}}"] - edge [color="#000000:#ff0000:#000000"] - X5:p1 -- W3:w1 - W3:w1 -- X6:p1 - edge [color="#000000:#ffff00:#000000"] - X5:p2 -- W3:w2 - W3:w2 -- X6:p2 - edge [color="#000000:#0000ff:#000000"] - X5:p3 -- W3:w3 - W3:w3 -- X6:p3 - edge [color="#000000:#ff0000:#000000"] - X5:p4 -- W3:w4 - W3:w4 -- X6:p4 - edge [color="#000000:#ffff00:#000000"] - X5:p5 -- W3:w5 - W3:w5 -- X6:p5 - edge [color="#000000:#0000ff:#000000"] - X5:p6 -- W3:w6 - W3:w6 -- X6:p6 - edge [color="#000000:#ff0000:#000000"] - X5:p7 -- W3:w7 - W3:w7 -- X6:p7 - edge [color="#000000:#ffff00:#000000"] - X5:p8 -- W3:w8 - W3:w8 -- X6:p8 - edge [color="#000000:#0000ff:#000000"] - X5:p9 -- W3:w9 - W3:w9 -- X6:p9 - edge [color="#000000:#ff0000:#000000"] - X5:p10 -- W3:w10 - W3:w10 -- X6:p10 - edge [color="#000000:#ffff00:#000000"] - X5:p11 -- W3:w11 - W3:w11 -- X6:p11 - edge [color="#000000:#0000ff:#000000"] - X5:p12 -- W3:w12 - W3:w12 -- X6:p12 - edge [color="#000000:#ff0000:#000000"] - X5:p13 -- W3:w13 - W3:w13 -- X6:p13 - edge [color="#000000:#ffff00:#000000"] - X5:p14 -- W3:w14 - W3:w14 -- X6:p14 - edge [color="#000000:#0000ff:#000000"] - X5:p15 -- W3:w15 - W3:w15 -- X6:p15 - edge [color="#000000:#ff0000:#000000"] - X5:p16 -- W3:w16 - W3:w16 -- X6:p16 - edge [color="#000000:#ffff00:#000000"] - X5:p17 -- W3:w17 - W3:w17 -- X6:p17 - edge [color="#000000:#0000ff:#000000"] - X5:p18 -- W3:w18 - W3:w18 -- X6:p18 - edge [color="#000000:#ff0000:#000000"] - X5:p19 -- W3:w19 - W3:w19 -- X6:p19 - edge [color="#000000:#ffff00:#000000"] - X5:p20 -- W3:w20 - W3:w20 -- X6:p20 - W4 [label="{6x|1 mm²|1 m}|{{|||||}}"] - edge [color="#000000"] - X7:p1 -- W4:w1 - W4:w1 -- X8:p1 - edge [color="#000000"] - X7:p2 -- W4:w2 - W4:w2 -- X8:p2 - edge [color="#000000"] - X7:p3 -- W4:w3 - W4:w3 -- X8:p3 - edge [color="#000000"] - X7:p4 -- W4:w4 - W4:w4 -- X8:p4 - edge [color="#000000"] - X7:p5 -- W4:w5 - W4:w5 -- X8:p5 - edge [color="#000000"] - X7:p6 -- W4:w6 - W4:w6 -- X8:p6 -} diff --git a/examples/example3.png b/examples/example3.png deleted file mode 100644 index 00b6e28459c8d083844204b9577ff8eb215af64f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 150154 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

SuF6g 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%0D>%6!KxcxehaEYFQ(gJ@$~>{0wm{VD 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 - - - - - - - -X1 - -X1 - -10-pin - - - -1 - -2 - -3 - -4 - -5 - -6 - -7 - -8 - -9 - -10 - - - -W1 - -10x - -None mm² - -0 m - -brown - -red - -orange - -yellow - -green - -blue - -violet - -grey - -white - -black - - - -X1:p1--W1:w1 - - - - - - -X1:p2--W1:w2 - - - - - - -X1:p3--W1:w3 - - - - - - -X1:p4--W1:w4 - - - - - - -X1:p5--W1:w5 - - - - - - -X1:p6--W1:w6 - - - - - - -X1:p7--W1:w7 - - - - - - -X1:p8--W1:w8 - - - - - - -X1:p9--W1:w9 - - - - - - -X1:p10--W1:w10 - - - - - - -X2 - -X2 - -10-pin - -1 - -2 - -3 - -4 - -5 - -6 - -7 - -8 - -9 - -10 - - - - - -X3 - -X3 - -20-pin - - - -1 - -2 - -3 - -4 - -5 - -6 - -7 - -8 - -9 - -10 - -11 - -12 - -13 - -14 - -15 - -16 - -17 - -18 - -19 - -20 - - - -W2 - -20x - -None mm² - -0 m - -white - -brown - -green - -yellow - -grey - -pink - -blue - -red - -black - -violet - -white - -brown - -green - -yellow - -grey - -pink - -blue - -red - -black - -violet - - - -X3:p1--W2:w1 - - - - - - -X3:p2--W2:w2 - - - - - - -X3:p3--W2:w3 - - - - - - -X3:p4--W2:w4 - - - - - - -X3:p5--W2:w5 - - - - - - -X3:p6--W2:w6 - - - - - - -X3:p7--W2:w7 - - - - - - -X3:p8--W2:w8 - - - - - - -X3:p9--W2:w9 - - - - - - -X3:p10--W2:w10 - - - - - - -X3:p11--W2:w11 - - - - - - -X3:p12--W2:w12 - - - - - - -X3:p13--W2:w13 - - - - - - -X3:p14--W2:w14 - - - - - - -X3:p15--W2:w15 - - - - - - -X3:p16--W2:w16 - - - - - - -X3:p17--W2:w17 - - - - - - -X3:p18--W2:w18 - - - - - - -X3:p19--W2:w19 - - - - - - -X3:p20--W2:w20 - - - - - - -X4 - -X4 - -20-pin - -1 - -2 - -3 - -4 - -5 - -6 - -7 - -8 - -9 - -10 - -11 - -12 - -13 - -14 - -15 - -16 - -17 - -18 - -19 - -20 - - - - - -X5 - -X5 - -20-pin - - - -1 - -2 - -3 - -4 - -5 - -6 - -7 - -8 - -9 - -10 - -11 - -12 - -13 - -14 - -15 - -16 - -17 - -18 - -19 - -20 - - - -W3 - -20x - -None mm² - -0 m - -red - -yellow - -blue - -red - -yellow - -blue - -red - -yellow - -blue - -red - -yellow - -blue - -red - -yellow - -blue - -red - -yellow - -blue - -red - -yellow - - - -X5:p1--W3:w1 - - - - - - -X5:p2--W3:w2 - - - - - - -X5:p3--W3:w3 - - - - - - -X5:p4--W3:w4 - - - - - - -X5:p5--W3:w5 - - - - - - -X5:p6--W3:w6 - - - - - - -X5:p7--W3:w7 - - - - - - -X5:p8--W3:w8 - - - - - - -X5:p9--W3:w9 - - - - - - -X5:p10--W3:w10 - - - - - - -X5:p11--W3:w11 - - - - - - -X5:p12--W3:w12 - - - - - - -X5:p13--W3:w13 - - - - - - -X5:p14--W3:w14 - - - - - - -X5:p15--W3:w15 - - - - - - -X5:p16--W3:w16 - - - - - - -X5:p17--W3:w17 - - - - - - -X5:p18--W3:w18 - - - - - - -X5:p19--W3:w19 - - - - - - -X5:p20--W3:w20 - - - - - - -X6 - -X6 - -20-pin - -1 - -2 - -3 - -4 - -5 - -6 - -7 - -8 - -9 - -10 - -11 - -12 - -13 - -14 - -15 - -16 - -17 - -18 - -19 - -20 - - - - - -X7 - -X7 - -6-pin - - - -1 - -2 - -3 - -4 - -5 - -6 - - - -W4 - -6x - -1 mm² - -1 m - - - - - - - - - - - - - - - -X7:p1--W4:w1 - - - - -X7:p2--W4:w2 - - - - -X7:p3--W4:w3 - - - - -X7:p4--W4:w4 - - - - -X7:p5--W4:w5 - - - - -X7:p6--W4:w6 - - - - -X8 - -X8 - -6-pin - -1 - -2 - -3 - -4 - -5 - -6 - - - - - -W1:w1--X2:p1 - - - - - - -W1:w2--X2:p2 - - - - - - -W1:w3--X2:p3 - - - - - - -W1:w4--X2:p4 - - - - - - -W1:w5--X2:p5 - - - - - - -W1:w6--X2:p6 - - - - - - -W1:w7--X2:p7 - - - - - - -W1:w8--X2:p8 - - - - - - -W1:w9--X2:p9 - - - - - - -W1:w10--X2:p10 - - - - - - -W2:w1--X4:p1 - - - - - - -W2:w2--X4:p2 - - - - - - -W2:w3--X4:p3 - - - - - - -W2:w4--X4:p4 - - - - - - -W2:w5--X4:p5 - - - - - - -W2:w6--X4:p6 - - - - - - -W2:w7--X4:p7 - - - - - - -W2:w8--X4:p8 - - - - - - -W2:w9--X4:p9 - - - - - - -W2:w10--X4:p10 - - - - - - -W2:w11--X4:p11 - - - - - - -W2:w12--X4:p12 - - - - - - -W2:w13--X4:p13 - - - - - - -W2:w14--X4:p14 - - - - - - -W2:w15--X4:p15 - - - - - - -W2:w16--X4:p16 - - - - - - -W2:w17--X4:p17 - - - - - - -W2:w18--X4:p18 - - - - - - -W2:w19--X4:p19 - - - - - - -W2:w20--X4:p20 - - - - - - -W3:w1--X6:p1 - - - - - - -W3:w2--X6:p2 - - - - - - -W3:w3--X6:p3 - - - - - - -W3:w4--X6:p4 - - - - - - -W3:w5--X6:p5 - - - - - - -W3:w6--X6:p6 - - - - - - -W3:w7--X6:p7 - - - - - - -W3:w8--X6:p8 - - - - - - -W3:w9--X6:p9 - - - - - - -W3:w10--X6:p10 - - - - - - -W3:w11--X6:p11 - - - - - - -W3:w12--X6:p12 - - - - - - -W3:w13--X6:p13 - - - - - - -W3:w14--X6:p14 - - - - - - -W3:w15--X6:p15 - - - - - - -W3:w16--X6:p16 - - - - - - -W3:w17--X6:p17 - - - - - - -W3:w18--X6:p18 - - - - - - -W3:w19--X6:p19 - - - - - - -W3:w20--X6:p20 - - - - - - -W4:w1--X8:p1 - - - - -W4:w2--X8:p2 - - - - -W4:w3--X8:p3 - - - - -W4:w4--X8:p4 - - - - -W4:w5--X8:p5 - - - - -W4:w6--X8:p6 - - - - diff --git a/src/example4.py b/examples/example4.py similarity index 100% rename from src/example4.py rename to examples/example4.py diff --git a/src/testconnections.yml b/examples/testconnections.yml similarity index 100% rename from src/testconnections.yml rename to examples/testconnections.yml diff --git a/src/yaml2wireviz.py b/src/yaml2wireviz.py index 01a452c..6da74f1 100644 --- a/src/yaml2wireviz.py +++ b/src/yaml2wireviz.py @@ -1,7 +1,7 @@ import yaml import wireviz -filename = 'example1.yml' +filename = '../examples/example2.yml' def check_designators(what, where): for i,x in enumerate(what): @@ -124,4 +124,4 @@ for con in conlist: else: raise Exception('Wrong number of connection parameters') -h.output(filename='output', format=('png',), view=False) +h.output(filename='output', format=('png','svg'), view=False) From c58cda04b1c9b92793826f6d956ed8f9df210c71 Mon Sep 17 00:00:00 2001 From: Daniel Rojas Date: Wed, 27 May 2020 19:55:37 +0200 Subject: [PATCH 11/11] Update readme + todo --- examples/example1.png | Bin 0 -> 58609 bytes examples/example2.png | Bin 0 -> 141730 bytes examples/example2.yml | 6 +-- readme.md | 111 ++++++++++++++---------------------------- todo.md | 9 ++++ 5 files changed, 48 insertions(+), 78 deletions(-) create mode 100644 examples/example1.png create mode 100644 examples/example2.png diff --git a/examples/example1.png b/examples/example1.png new file mode 100644 index 0000000000000000000000000000000000000000..ac10d2f9ed2945ce6b66eb558870b3902e11cf11 GIT binary patch literal 58609 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℞}FS`t(iji|E|0x_I9TGe3QIZ&fTh& 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 z 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 literal 0 HcmV?d00001 diff --git a/examples/example2.yml b/examples/example2.yml index 9b854ed..54adfaf 100644 --- a/examples/example2.yml +++ b/examples/example2.yml @@ -1,4 +1,4 @@ -templates: +templates: # defining templates to be used later on - &molex_f type: Molex KK 254 gender: female @@ -11,11 +11,11 @@ templates: nodes: X1: - <<: *molex_f + <<: *molex_f # copying items from the template pinout: [GND, +5V, SCL, SDA, MISO, MOSI, SCK, N/C] X2: <<: *molex_f - <<: *con_i2c + <<: *con_i2c # it is possible to copy from more than one template X3: <<: *molex_f <<: *con_i2c diff --git a/readme.md b/readme.md index f25e63a..b9bdd78 100644 --- a/readme.md +++ b/readme.md @@ -2,17 +2,15 @@ ## Summary -WireViz is a simple yet flexible markup language for documenting cables, wiring harnesses and connector pinouts with beautiful graphical output. - -It is based on [GraphViz](https://www.graphviz.org/) and designed as an "extension" of it. A parser reads a WireViz file and generates valid GraphViz output, which can instantly be rendered to SVG/PNG. +WireViz is a simple yet flexible, YAML-based markup language for documenting cables, wiring harnesses and connector pinouts with beautiful graphical output (SVG, PNG, ...) thanks to [GraphViz](https://www.graphviz.org/). ## Features -* WireViz is fully text based +* WireViz input files are fully text based * No special editor required * Human readable * Easy version control - * GraphViz-like syntax + * YAML syntax * Understands and uses color abbreviations as per [IEC 60757](https://en.wikipedia.org/wiki/Electronic_color_code#Color_band_system) (black=BK, red=RD, ...) * Optionally outputs colors as abbreviation (e.g. 'YE'), full name (e.g. 'yellow') or hex value (e.g. '#ffff00'), with choice of UPPER or lower case * Auto-generates standard wire color schemes and allows custom ones if needed @@ -27,87 +25,50 @@ _Note_: WireViz is not designed to represent the complete wiring of a system. It ## Example -WireViz input file: +[WireViz input file](examples/example1.yml): - // define connectors + nodes: + X1: + type: D-Sub + gender: female + pinout: [DCD, RX, TX, DTR, GND, DSR, RTS, CTS, RI] + random: yes + X2: + type: Molex KK 254 + gender: female + pinout: [GND, RX, TX, N/C, OUT, IN] - X1 [type="D-Sub", - gender="female", - pin_labels="DCD|RX|TX|DTR|GND|DSR|RTS|CTS|RI", - ] + wires: + W1: + mm2: 0.25 + length: 0.2 + color_code: DIN + num_wires: 3 + shield: true - X2 [type="Molex KK 254", - gender="female", - pin_labels="GND|RX|TX|NC|OUT|IN", - ] - - // define wire - - W1 [mm2=0.25, - length=0.2, - num_wires=3, - colors="din47100", - shield=true - ] - - // define connections - - X1:5 -> W1:1 -> X2:1 // GND - X1:2 -> W1:2 -> X2:3 // TX-RX - X1:3 -> W1:3 -> X2:2 // RX-TX - X1:5 -> W1:S // shield - X2:5 -> X2:6 // loop + connections: + - # format: connector->wire->connector + - X1: [5,2,1] + - W1: [1,2,3] + - X2: [1,3,2] + - # format: connector->wire or wire->connector + - X1: 5 + - W1: s + - # loop: connector-connector + - X2: 5 + - X2: 6 Output file: -![Sample output diagram](idea/example1.png) +![Sample output diagram](examples/example1.png) -GraphViz code generated by parser: +[Example 2](examples/example2.yml) - digraph G { - graph [rankdir = LR, ranksep=2, fontname = "arial"]; - edge [arrowhead=none, fontname = "arial"]; - node [shape=record, style=rounded, fontname = "arial"]; - - X1[label="X1 | {D-Sub DE-9|female|9-pin} | {{DCD|RX|TX|DTR|GND|DSR|RTS|CTS|RI} | {1|2|3|4|5|6|7|8|9}}}"] - - X2[label="X2 | {Molex KK 254|female|6-pin} | {{1|2|3|4|5|6} | {|||||}}}"] - - {edge[style=bold] - X2:p5:w -> X2:p6:w - } - - W1[label="W1 | {3x|0.25 mm²| + S|0.2 m} | {{1|2|3|} | {WH|BN|GN|Shield} | {1|2|3|}}}"] - - {edge[style=bold] - {edge[color="#000000:#ffffff:#000000"] X1:p5 -> W1:w1i; W1:w1o -> X2:p1} - {edge[color="#000000:#666600:#000000"] X1:p2 -> W1:w2i; W1:w2o -> X2:p3} - {edge[color="#000000:#00ff00:#000000"] X1:p3 -> W1:w3i; W1:w3o -> X2:p2} - {X1:p5 -> W1:wsi; } - } - - - } - -[Example 2](idea/example2.dot) - -![](idea/example2.png) +![](examples/example2.png) ## Status -This is very much a work in progress. -A Python module and test scripts are available. Running the test script will generate GraphViz output. -The parser will follow later; contributions are welcome! - -## To do - -* Add simple connectors (ferrules, cable lugs) - * no pinout - * graphical representation? -* Add support for cable splicing (as connector type) -* Display picture of connector underneath (including pin 1 location) -* Create parser (to make WireViz work as a GraphViz extension) -* Automatic BOM generation +This is very much a [work in progress](todo.md). ## License diff --git a/todo.md b/todo.md index 70d3d83..f27e892 100644 --- a/todo.md +++ b/todo.md @@ -1,14 +1,23 @@ +# To-do: + +* Set global parameters (show_pins, ...) and allow override on per-item basis * Generic connectors * ferrules * blade terminals * loose ends + * graphical representation? +* Support for cable splicing (as connector type) * new wire look? * distinguish between cables and wire bundles * improve nomenclature * terminal (connector, ferrule, blade, loose) * link (cable, wire bundle) * show from/to inside wire node +* Allow custom GraphViz code before/after WireViz-generated code +* Display picture of connector underneath (including pin 1 location) * export to PDF with frame, title block, ... +* Automatic BOM generation +* Allow * make "unit tests" for different features/situations * missing parameters * connection formats