xmlgenerator 0.1.0__py3-none-any.whl

xmlgenerator/arguments.py

@@ -0,0 +1,138 @@
+import sys
+from argparse import ArgumentParser, HelpFormatter
+from pathlib import Path
+
+import shtab
+
+
+class MyParser(ArgumentParser):
+    def error(self, message):
+        sys.stderr.write('error: %s\n' % message)
+        self.print_help()
+        sys.exit(2)
+
+
+class CustomHelpFormatter(HelpFormatter):
+    def __init__(self, prog):
+        super().__init__(prog, max_help_position=36, width=120)
+
+
+def _get_parser():
+    parser = MyParser(
+        prog='xmlgenerator',
+        description='Generates XML documents from XSD schemas',
+        formatter_class=CustomHelpFormatter
+    )
+
+    source_arg = parser.add_argument(
+        nargs='+',
+        metavar="xsd",
+        dest="source_paths",
+        help="paths to xsd schema(s) or directory with xsd schemas"
+    )
+    parser.add_argument(
+        "-c", "--config",
+        metavar="<config.yml>",
+        dest="config_yaml",
+        help="pass yaml configuration file"
+    )
+    output_arg = parser.add_argument(
+        "-o", "--output",
+        metavar="<output.xml>",
+        dest="output_path",
+        help="save output to dir or file"
+    )
+    parser.add_argument(
+        "-p", "--pretty",
+        action="store_true",
+        help="prettify output XML"
+    )
+    parser.add_argument(
+        "-v", "--validation",
+        metavar="<validation>",
+        choices=["none", "schema", "schematron"],
+        default="schema",
+        help="validate generated XML document (none, schema, schematron, default is schema)"
+    )
+    parser.add_argument(
+        "-ff", "--fail-fast",
+        action="store_true",
+        default="true",
+        help="terminate execution on validation error (default is true)"
+    )
+    parser.add_argument(
+        "-e", "--encoding",
+        metavar="<encoding>",
+        choices=["utf-8", "windows-1251"],
+        default="utf-8",
+        help="output XML encoding (utf-8, windows-1251, default is utf-8)"
+    )
+    parser.add_argument(
+        "--seed",
+        metavar="<seed>",
+        help="set randomization seed"
+    )
+    parser.add_argument(
+        "-d", "--debug",
+        action="store_true",
+        help="enable debug mode"
+    )
+    parser.add_argument(
+        "-V", "--version",
+        action='version',
+        version='%(prog)s 0.1.0',
+        help="shows current version"
+    )
+
+    # add shell completions
+    source_arg.complete = shtab.FILE
+    output_arg.complete = shtab.FILE
+    shtab.add_argument_to(parser, ["-C", "--completion"], "print shell completion script (bash, zsh, tcsh)")
+    completion_act = [a for a in parser._actions if a.dest == 'completion']
+    if completion_act:
+        completion_act[0].metavar = '<shell>'
+
+    return parser
+
+
+def parse_args():
+    parser = _get_parser()
+    args = parser.parse_args()
+
+    if args.config_yaml:
+        config_path = Path(args.config_yaml)
+        if not config_path.exists() or not config_path.is_file():
+            parser.error(f"configuration file {config_path} does not exist.")
+
+    # Собираем все .xsd файлы
+    xsd_files = _collect_xsd_files(args.source_paths, parser)
+
+    # Обработка пути вывода
+    output_path = Path(args.output_path) if args.output_path else None
+
+    # Проверка: если несколько XSD файлов, то output должен быть директорией
+    if len(xsd_files) > 1 and output_path and not (output_path.is_dir() or args.output_path.endswith(('/', '\\'))):
+        parser.error("option -o/--output must be a directory when multiple source xsd schemas are provided.")
+
+    # Создание директории, если output указан как директория
+    if output_path and (output_path.is_dir() or args.output_path.endswith(('/', '\\'))):
+        output_path.mkdir(parents=True, exist_ok=True)
+
+    return args, xsd_files, output_path
+
+
+def _collect_xsd_files(source_paths, parser):
+    xsd_files = []
+    for source_path in source_paths:
+        path = Path(source_path).resolve()
+        if path.is_dir():
+            xsd_files.extend(path.glob('*.[xX][sS][dD]'))
+        elif path.is_file() and path.suffix.lower() == '.xsd':
+            xsd_files.append(path)
+        elif not path.exists() and path.suffix.lower() == '.xsd':
+            parser.error(f"file {source_path} doesn't exists.")
+    if not xsd_files:
+        parser.error("no source xsd schemas provided.")
+    xsd_files = list(set(xsd_files))
+    xsd_files.sort()
+    return xsd_files

xmlgenerator/bootstrap.py

@@ -0,0 +1,73 @@
+from lxml import etree
+from xmlgenerator.arguments import parse_args
+from xmlgenerator.configuration import load_config
+from xmlgenerator.generator import XmlGenerator
+from xmlgenerator.randomization import Randomizer
+from xmlgenerator.substitution import Substitutor
+from xmlgenerator.validation import XmlValidator
+from xmlschema import XMLSchema
+
+
+# TODO Generator - обработка стандартных xsd типов
+# TODO кастомные переменные для локального контекста
+# TODO валидация по Schematron
+# TODO debug logging
+# TODO типизировать
+# TODO Почистить и перевести комментарии
+# TODO Дописать тесты
+# TODO нативная сборка
+# TODO выкладка на github releases
+# TODO опубликовать https://pypi.org/
+
+
+def main():
+    args, xsd_files, output_path = parse_args()
+
+    config = load_config(args.config_yaml)
+
+    print(f"Найдено схем: {len(xsd_files)}")
+
+    randomizer = Randomizer(args.seed)
+    substitutor = Substitutor(randomizer)
+    generator = XmlGenerator(randomizer, substitutor)
+    validator = XmlValidator(args.validation, args.fail_fast)
+
+    for xsd_file in xsd_files:
+        print(f"Processing schema: {xsd_file.name}")
+
+        # get configuration override for current schema
+        local_config = config.get_for_file(xsd_file.name)
+
+        # Reset context for current schema
+        substitutor.reset_context(xsd_file.name, local_config)
+
+        # Load XSD schema
+        xsd_schema = XMLSchema(xsd_file)  # loglevel='DEBUG'
+        # Generate XML document
+        xml_root = generator.generate_xml(xsd_schema, local_config)
+
+        # Marshall to string
+        xml_str = etree.tostring(xml_root, encoding=args.encoding, pretty_print=args.pretty)
+        decoded = xml_str.decode('cp1251' if args.encoding == 'windows-1251' else args.encoding)
+
+        # Print out to console
+        if not output_path:
+            print(decoded)
+
+        # Validation (if enabled)
+        validator.validate(xsd_schema, decoded)
+
+        # Get output filename for current schema (without extension)
+        xml_filename = substitutor.get_output_filename()
+
+        # Export XML to file
+        if output_path:
+            output_file = output_path
+            if output_path.is_dir():
+                output_file = output_path / f'{xml_filename}.xml'
+            with open(output_file, 'wb') as f:
+                f.write(xml_str)
+            print(f"Saved document: {output_file.name}")
+
+if __name__ == "__main__":
+    main()

xmlgenerator/configuration.py

@@ -0,0 +1,135 @@
+import dataclasses
+import re
+import sys
+from dataclasses import dataclass, field, Field
+from typing import Dict, get_args, get_origin, Any
+
+import yaml
+
+
+@dataclass
+class RandomizationConfig:
+    probability: float = field(default=None)
+    max_occurs: int = field(default=None)
+    min_length: int = field(default=None)
+    max_length: int = field(default=None)
+    min_inclusive: int = field(default=None)
+    max_inclusive: int = field(default=None)
+
+
+@dataclass
+class GlobalRandomizationConfig(RandomizationConfig):
+    probability: float = field(default=0.5)
+
+
+@dataclass
+class GeneratorConfig:
+    source_filename: str = None
+    output_filename: str = None
+    randomization: RandomizationConfig = field(default_factory=lambda: RandomizationConfig())
+    value_override: Dict[str, str] = field(default_factory=lambda: {})
+
+
+@dataclass
+class GlobalGeneratorConfig(GeneratorConfig):
+    source_filename: str = field(default='(?P<extracted>.*).(xsd|XSD)')
+    output_filename: str = field(default='{{ source_filename }}_{{ uuid }}')
+    randomization: GlobalRandomizationConfig = field(default_factory=lambda: GlobalRandomizationConfig())
+
+
+@dataclass
+class Config:
+    global_: GlobalGeneratorConfig = field(default_factory=lambda: GlobalGeneratorConfig())
+    specific: Dict[str, GeneratorConfig] = field(default_factory=lambda: {})
+
+    def get_for_file(self, xsd_name):
+        for pattern, conf in self.specific.items():
+            if re.match(pattern, xsd_name):
+                base_dict = dataclasses.asdict(self.global_)
+                override_dict = dataclasses.asdict(conf, dict_factory=lambda x: {k: v for (k, v) in x if v is not None})
+                updated_dict = _recursive_update(base_dict, override_dict)
+                merged_config = _map_to_class(updated_dict, GeneratorConfig, "")
+                local_override = conf.value_override
+                global_override = self.global_.value_override
+                merged_config.value_override = _merge_dicts(local_override, global_override)
+                return merged_config
+
+        return self.global_
+
+
+def load_config(file_path: str | None) -> "Config":
+    if not file_path:
+        return Config()
+    with open(file_path, 'r') as file:
+        config_data: dict[str, str] = yaml.safe_load(file) or {}
+        return _map_to_class(config_data, Config, "")
+
+
+def _map_to_class(data_dict: dict, cls, parent_path: str):
+    # Обработка dataclass
+    if dataclasses.is_dataclass(cls):
+        class_fields: dict[str, Field] = cls.__dataclass_fields__
+        required_fields: list[str] = []
+        yaml_items: dict[str, Any] = {}
+
+        for name, class_field in class_fields.items():
+            if class_field.default is dataclasses.MISSING and class_field.default_factory is dataclasses.MISSING:
+                required_fields.append(name)
+
+        if data_dict:
+            for yaml_name, value in data_dict.items():
+                class_field_name = yaml_name if yaml_name != "global" else "global_"
+                if class_field_name not in class_fields:
+                    print(f"YAML parse error: unexpected property: {parent_path}.{yaml_name}", file=sys.stderr)
+                    sys.exit(1)
+
+                # Определяем тип поля
+                field_type = class_fields[class_field_name].type
+                yaml_items[class_field_name] = _map_to_class(value, field_type, f"{parent_path}.{yaml_name}")
+
+        # Проверка на отсутствие обязательных полей
+        missing_fields = required_fields - yaml_items.keys()
+        if missing_fields:
+            print(f"YAML parse error: missing required properties in {parent_path}:", file=sys.stderr)
+            for missing_field in missing_fields:
+                yaml_field_name = missing_field if missing_field != "global_" else "global"
+                print(yaml_field_name, file=sys.stderr)
+            sys.exit(1)
+
+        return cls(**yaml_items)
+
+    # Обработка словарей
+    elif get_origin(cls) is dict:
+        key_type, value_type = get_args(cls)
+        if not data_dict:
+            data_dict = {}
+        return {
+            k: _map_to_class(v, value_type, f"{parent_path}.{k}")
+            for k, v in data_dict.items()
+        }
+
+    # Обработка списков
+    elif get_origin(cls) is list:
+        item_type = get_args(cls)[0]
+        return [_map_to_class(item, item_type, f"{parent_path}[{i}]") for i, item in enumerate(data_dict)]
+
+    # Базовые типы (int, str, bool и т.д.)
+    else:
+        return data_dict
+
+
+def _recursive_update(original, updates):
+    for key, value in updates.items():
+        if key in original and isinstance(original[key], dict) and isinstance(value, dict):
+            _recursive_update(original[key], value)
+        else:
+            original[key] = value
+    return original
+
+
+def _merge_dicts(base_dict, extra_dict):
+    merged_dict = dict(base_dict)
+    for key, value in extra_dict.items():
+        if key not in merged_dict:
+            merged_dict[key] = value
+    return merged_dict

xmlgenerator/generator.py

@@ -0,0 +1,387 @@
+import re
+import sys
+
+import rstr
+import xmlschema
+from lxml import etree
+from xmlschema.validators import XsdComplexType, XsdAtomicRestriction, XsdTotalDigitsFacet, XsdElement, \
+    XsdGroup, XsdFractionDigitsFacet, XsdLengthFacet, XsdMaxLengthFacet, XsdMinExclusiveFacet, XsdMinInclusiveFacet, \
+    XsdMinLengthFacet, XsdAnyElement, XsdAtomicBuiltin, XsdEnumerationFacets, XsdMaxExclusiveFacet, XsdMaxInclusiveFacet
+
+from xmlgenerator.configuration import GeneratorConfig
+from xmlgenerator.randomization import Randomizer
+from xmlgenerator.substitution import Substitutor
+
+
+class XmlGenerator:
+    def __init__(self, randomizer: Randomizer, substitutor: Substitutor):
+        self.randomizer = randomizer
+        self.substitutor = substitutor
+
+    def generate_xml(self, xsd_schema: xmlschema.XMLSchema, local_config: GeneratorConfig) -> etree.Element:
+        xsd_root_element = xsd_schema.root_elements[0]
+        xml_root_element = etree.Element(xsd_root_element.name)
+        self._add_elements(xml_root_element, xsd_root_element, local_config)
+        return xml_root_element
+
+    def _add_elements(self, xml_element: etree.Element, xsd_element, local_config: GeneratorConfig) -> None:
+        rnd = self.randomizer.rnd
+
+        xsd_element_type = getattr(xsd_element, 'type', None)
+
+        # Add attributes if they are
+        attributes = getattr(xsd_element, 'attributes', dict())
+        if len(attributes) > 0 and xsd_element_type.local_name != 'anyType':
+            for attr_name, attr in attributes.items():
+                use = attr.use  # optional | required | prohibited
+                if use == 'prohibited':
+                    continue
+                elif use == 'optional':
+                    if rnd.random() > local_config.randomization.probability:
+                        continue    # skip optional attribute
+
+                attr_value = self._generate_value(attr.type, attr_name, local_config)
+                if attr_value is not None:
+                    xml_element.set(attr_name, str(attr_value))
+
+        # Process child elements --------------------------------------------------------------------------------------
+        if isinstance(xsd_element, XsdElement):
+            if isinstance(xsd_element_type, XsdAtomicRestriction):
+                text = self._generate_value(xsd_element_type, xsd_element.name, local_config)
+                xml_element.text = text
+                return
+            elif isinstance(xsd_element_type, XsdComplexType):
+                xsd_element_type_content = xsd_element_type.content
+                if isinstance(xsd_element_type_content, XsdGroup):
+                    self._add_elements(xml_element, xsd_element_type_content, local_config)
+                else:
+                    raise RuntimeError()
+            elif isinstance(xsd_element_type, XsdAtomicBuiltin):
+                text = self._generate_value(xsd_element_type, xsd_element.name, local_config)
+                xml_element.text = text
+                return
+            else:
+                raise RuntimeError()
+
+        elif isinstance(xsd_element, XsdGroup):
+            model = xsd_element.model
+
+            group_min_occurs = getattr(xsd_element, 'min_occurs', None)
+            group_max_occurs = getattr(xsd_element, 'max_occurs', None)
+            group_min_occurs = group_min_occurs if group_min_occurs is not None else 0
+            group_max_occurs = group_max_occurs if group_max_occurs is not None else 10 # TODO externalize
+            group_occurs = rnd.randint(group_min_occurs, group_max_occurs)
+
+            if model == 'all':
+                for _ in range(group_occurs):
+                    xsd_group_content = xsd_element.content
+                    for xsd_child_element_type in xsd_group_content:
+
+                        element_min_occurs = getattr(xsd_child_element_type, 'min_occurs', None)
+                        element_max_occurs = getattr(xsd_child_element_type, 'max_occurs', None)
+                        element_min_occurs = element_min_occurs if element_min_occurs is not None else 0
+                        element_max_occurs = element_max_occurs if element_max_occurs is not None else 10 # TODO externalize
+                        element_occurs = rnd.randint(element_min_occurs, element_max_occurs)
+
+                        for _ in range(element_occurs):
+                            xml_child_element = etree.SubElement(xml_element, xsd_child_element_type.name)
+                            self._add_elements(xml_child_element, xsd_child_element_type, local_config)
+                return
+
+            elif model == 'sequence':
+                for _ in range(group_occurs):
+                    xsd_group_content = xsd_element.content
+                    for xsd_child_element_type in xsd_group_content:
+
+                        element_min_occurs = getattr(xsd_child_element_type, 'min_occurs', None)
+                        element_max_occurs = getattr(xsd_child_element_type, 'max_occurs', None)
+                        element_min_occurs = element_min_occurs if element_min_occurs is not None else 0
+                        element_max_occurs = element_max_occurs if element_max_occurs is not None else 10 # TODO externalize
+                        element_occurs = rnd.randint(element_min_occurs, element_max_occurs)
+
+                        if isinstance(xsd_child_element_type, XsdElement):
+                            for _ in range(element_occurs):
+                                xml_child_element = etree.SubElement(xml_element, xsd_child_element_type.name)
+                                self._add_elements(xml_child_element, xsd_child_element_type, local_config)
+
+                        elif isinstance(xsd_child_element_type, XsdGroup):
+                            xml_child_element = xml_element
+                            self._add_elements(xml_child_element, xsd_child_element_type, local_config)
+
+                        elif isinstance(xsd_child_element_type, XsdAnyElement):
+                            xml_child_element = etree.SubElement(xml_element, "Any")
+                            self._add_elements(xml_child_element, xsd_child_element_type, local_config)
+
+                        else:
+                            raise RuntimeError(xsd_child_element_type)
+                return
+
+            elif model == 'choice':
+                for _ in range(group_occurs):
+                    xsd_child_element_type = rnd.choice(xsd_element)
+
+                    element_min_occurs = getattr(xsd_child_element_type, 'min_occurs', None)
+                    element_max_occurs = getattr(xsd_child_element_type, 'max_occurs', None)
+                    element_min_occurs = element_min_occurs if element_min_occurs is not None else 0
+                    element_max_occurs = element_max_occurs if element_max_occurs is not None else 10 # TODO externalize
+                    element_occurs = rnd.randint(element_min_occurs, element_max_occurs)
+
+                    for _ in range(element_occurs):
+                        xml_child_element = etree.SubElement(xml_element, xsd_child_element_type.name)
+                        self._add_elements(xml_child_element, xsd_child_element_type, local_config)
+                return
+
+            else:
+                raise RuntimeError()
+
+        elif isinstance(xsd_element, XsdAnyElement):
+            # для any не добавляем никаких дочерних тегов и атрибутов
+            pass
+
+        else:
+            raise RuntimeError()
+
+    def _generate_value(self, xsd_type, target_name, local_config: GeneratorConfig) -> str | None:
+        if xsd_type is None:
+            raise RuntimeError(f"xsd_type is None. Target name: {target_name}")
+
+        if isinstance(xsd_type, XsdComplexType):
+            return None
+
+        rnd = self.randomizer.rnd
+
+        # -------------------------------------------------------------------------------------------------------------
+        # Выясняем ограничения
+        min_length = getattr(xsd_type, 'min_length', None)  # None | int
+        max_length = getattr(xsd_type, 'max_length', None)  # None | int
+
+        min_value = getattr(xsd_type, 'min_value', None)  # None | int
+        max_value = getattr(xsd_type, 'max_value', None)  # None
+
+        total_digits = None
+        fraction_digits = None
+        enumeration = getattr(xsd_type, 'enumeration', None)
+        patterns = getattr(xsd_type, 'patterns', None)
+
+        validators = getattr(xsd_type, 'validators', None)
+        for validator in validators:
+            if isinstance(validator, XsdMinExclusiveFacet):
+                min_value = validator.value
+            elif isinstance(validator, XsdMinInclusiveFacet):
+                min_value = validator.value
+            elif isinstance(validator, XsdMaxExclusiveFacet):
+                max_value = validator.value
+            elif isinstance(validator, XsdMaxInclusiveFacet):
+                max_value = validator.value
+            elif isinstance(validator, XsdLengthFacet):
+                min_length = validator.value
+                max_length = validator.value
+            elif isinstance(validator, XsdMinLengthFacet):
+                min_length = validator.value
+            elif isinstance(validator, XsdMaxLengthFacet):
+                max_length = validator.value
+            elif isinstance(validator, XsdTotalDigitsFacet):
+                total_digits = validator.value
+            elif isinstance(validator, XsdFractionDigitsFacet):
+                fraction_digits = validator.value
+            elif isinstance(validator, XsdEnumerationFacets):
+                enumeration = validator.enumeration
+            elif callable(validator):
+                pass
+            else:
+                raise RuntimeError(f"Unhandled validator: {validator}")
+
+        min_length = min_length or -1
+        max_length = max_length or -1
+
+        min_value = min_value or 0
+        max_value = max_value or 100000
+
+        # -------------------------------------------------------------------------------------------------------------
+        # Ищем переопределение значения в конфигурации
+
+        value_override = local_config.value_override
+        is_found, overridden_value = self.substitutor.substitute_value(target_name, value_override.items())
+        if is_found:
+            return overridden_value
+
+        # -------------------------------------------------------------------------------------------------------------
+        # If there is an enumeration, select a random value from it
+
+        if enumeration is not None:
+            return rnd.choice(enumeration)
+
+        # -------------------------------------------------------------------------------------------------------------\
+        # Генерируем значения для стандартных типов и типов с ограничениями
+        if isinstance(xsd_type, XsdAtomicBuiltin) or isinstance(xsd_type, XsdAtomicRestriction):
+            return self._generate_value_by_type(
+                xsd_type, target_name,
+                patterns,
+                min_length, max_length,
+                min_value, max_value,
+                total_digits, fraction_digits
+            )
+
+        # -------------------------------------------------------------------------------------------------------------
+        # Проверяем базовый тип
+        base_type = getattr(xsd_type, 'base_type', None)
+
+        # невозможный кейс (только если попался комплексный тип)
+        if base_type is None:
+            raise RuntimeError(f"base_type is None. Target name: {target_name}")
+
+        raise RuntimeError(f"Can't generate value - unhandled type. Target name: {target_name}")
+
+
+    def _generate_value_by_type(self, xsd_type, target_name, patterns, min_length, max_length, min_value, max_value,
+                                total_digits, fraction_digits) -> str | None:
+
+        type_id = xsd_type.id
+        base_type = xsd_type.base_type
+        if not type_id:
+            type_id = base_type.id
+            if not type_id:
+                type_id = xsd_type.root_type.id
+
+        match type_id:
+            case 'string':
+                return self._generate_string(target_name, patterns, min_length, max_length)
+            case 'boolean':
+                return self._generate_boolean()
+            case 'integer':
+                return self._generate_integer(total_digits, min_value, max_value)
+            case 'decimal':
+                return self._generate_decimal(total_digits, fraction_digits, min_value, max_value)
+            case 'float':
+                return self._generate_float(min_value, max_value)
+            case 'double':
+                return self._generate_double(min_value, max_value)
+            case 'duration':
+                return self._generate_duration()
+            case 'dateTime':
+                return self._generate_datetime()
+            case 'date':
+                return self._generate_date()
+            case 'time':
+                return self._generate_time()
+            case 'gYearMonth':
+                return self._generate_gyearmonth()
+            case 'gYear':
+                return self._generate_gyear()
+            case 'gMonthDay':
+                return self._generate_gmonthday()
+            case 'gDay':
+                return self._generate_gday()
+            case 'gMonth':
+                return self._generate_gmonth()
+            case 'hexBinary':
+                return self._generate_hex_binary()
+            case 'base64Binary':
+                return self._generate_base64_binary()
+            case 'anyURI':
+                return self._generate_any_uri()
+            case 'QName':
+                return self._generate_qname()
+            case 'NOTATION':
+                return self._generate_notation()
+            case _:
+                raise RuntimeError(type_id)
+
+    def _generate_string(self, target_name, patterns, min_length, max_length):
+        rnd = self.randomizer.rnd
+        if patterns is not None:
+            # Генерация строки по regex
+            random_pattern = rnd.choice(patterns)
+            xeger = rstr.xeger(random_pattern.attrib['value'])
+            xeger = re.sub(r'\s', ' ', xeger)
+            if min_length > -1 and len(xeger) < min_length:
+                print(
+                    f"Possible mistake in schema: {target_name} generated value '{xeger}' can't be shorter than {min_length}",
+                    file=sys.stderr)
+            if -1 < max_length < len(xeger):
+                print(f"Possible mistake in schema: {target_name} generated value '{xeger}' can't be longer than {max_length}", file=sys.stderr)
+            return xeger
+
+        # Иначе генерируем случайную строку
+        return self.randomizer.ascii_string(min_length, max_length)
+
+    def _generate_boolean(self):
+        rnd = self.randomizer.rnd
+        return rnd.choice(['true', 'false'])
+
+    def _generate_integer(self, total_digits, min_value, max_value):
+        rnd = self.randomizer.rnd
+        if total_digits:
+            min_value = 10 ** (total_digits - 1)
+            max_value = (10 ** total_digits) - 1
+        rnd_int = rnd.randint(min_value, max_value)
+        return str(rnd_int)
+
+    def _generate_decimal(self, total_digits, fraction_digits, min_value, max_value):
+        rnd = self.randomizer.rnd
+        if total_digits:
+            if fraction_digits and fraction_digits > 0:
+                integer_digits = total_digits - fraction_digits
+                integer_part = rnd.randint(10 ** (integer_digits - 1), (10 ** integer_digits) - 1)
+                fractional_part = rnd.randint(0, (10 ** fraction_digits) - 1)
+                return f"{integer_part}.{fractional_part:0{fraction_digits}}"
+            else:
+                min_value = 10 ** (total_digits - 1)
+                max_value = (10 ** total_digits) - 1
+                rnd_int = rnd.randint(min_value, max_value)
+                return str(rnd_int)
+
+        rnd_int = rnd.randint(min_value, max_value)
+        return f"{int(rnd_int / 100)}.{rnd_int % 100:02}"
+
+    def _generate_float(self, min_value, max_value):
+        rnd = self.randomizer.rnd
+        rnd_int = rnd.uniform(min_value, max_value)
+        rnd_int = round(rnd_int, 2)
+        return str(rnd_int)
+
+    def _generate_double(self, min_value, max_value):
+        return self._generate_float(min_value, max_value)
+
+    def _generate_duration(self):
+        raise RuntimeError("not yet implemented")
+
+    def _generate_datetime(self):
+        raise RuntimeError("not yet implemented")
+
+    def _generate_date(self):
+        raise RuntimeError("not yet implemented")
+
+    def _generate_time(self):
+        raise RuntimeError("not yet implemented")
+
+    def _generate_gyearmonth(self):
+        raise RuntimeError("not yet implemented")
+
+    def _generate_gyear(self):
+        rnd = self.randomizer.rnd
+        return rnd.randint(2000, 2050)
+
+    def _generate_gmonthday(self):
+        raise RuntimeError("not yet implemented")
+
+    def _generate_gday(self):
+        raise RuntimeError("not yet implemented")
+
+    def _generate_gmonth(self):
+        raise RuntimeError("not yet implemented")
+
+    def _generate_hex_binary(self):
+        raise RuntimeError("not yet implemented")
+
+    def _generate_base64_binary(self):
+        raise RuntimeError("not yet implemented")
+
+    def _generate_any_uri(self):
+        raise RuntimeError("not yet implemented")
+
+    def _generate_qname(self):
+        raise RuntimeError("not yet implemented")
+
+    def _generate_notation(self):
+        raise RuntimeError("not yet implemented")

xmlgenerator/randomization.py

@@ -0,0 +1,40 @@
+import random
+import string
+from datetime import datetime, timedelta
+
+from faker import Faker
+
+
+class Randomizer:
+    def __init__(self, seed=None):
+        self.rnd = random.Random(seed)
+        self.fake = Faker(locale='ru_RU')
+        self.fake.seed_instance(seed)
+
+    def ascii_string(self, min_length=-1, max_length=-1):
+        min_length = min_length if min_length and min_length > -1 else 1
+        max_length = max_length if max_length and max_length >= min_length else 20
+        if max_length > 50:
+            max_length = 50
+        length = self.rnd.randint(min_length, max_length)
+        # Генерация случайной строки из букв латиницы
+        letters = string.ascii_letters  # Все буквы латиницы (a-z, A-Z)
+        return ''.join(self.rnd.choice(letters) for _ in range(length))
+
+    def random_date(self, start_date: str, end_date: str) -> datetime:
+        # Преобразуем строки в объекты datetime
+        start = datetime.strptime(start_date, "%Y-%m-%d")
+        end = datetime.strptime(end_date, "%Y-%m-%d")
+
+        # Вычисляем разницу в днях между начальной и конечной датой
+        delta = (end - start).days
+
+        # Генерируем случайное количество дней в пределах delta
+        random_days = self.rnd.randint(0, delta)
+
+        # Добавляем случайное количество дней к начальной дате
+        return start + timedelta(days=random_days)
+
+    def snils_formatted(self):
+        snils = self.fake.snils()
+        return f"{snils[:3]}-{snils[3:6]}-{snils[6:9]} {snils[9:]}"

xmlgenerator/substitution.py

@@ -0,0 +1,118 @@
+import re
+import uuid
+
+import rstr
+
+from xmlgenerator.randomization import Randomizer
+
+__all__ = ['Substitutor']
+
+_pattern = re.compile(pattern=r'\{\{\s*(?:(?P<function>\S*?)(?:\(\s*(?P<argument>[^)]*)\s*\))?\s*(?:\|\s*(?P<modifier>.*?))?)?\s*}}')
+
+class Substitutor:
+    def __init__(self, randomizer: Randomizer):
+        fake = randomizer.fake
+        self.randomizer = randomizer
+        self._local_context = {}
+        self._global_context = {}
+        self.providers_dict = {
+            # Функции локального контекста
+            "source_filename": lambda: self._local_context["source_filename"],
+            "source_extracted": lambda: self._local_context["source_extracted"],
+            "output_filename": lambda: self.get_output_filename(),
+
+            'uuid': lambda: str(uuid.uuid4()),
+            "regex": lambda a: rstr.xeger(a),
+            "number": self._rand_int,
+            "date": self._rand_date,
+
+            "last_name": fake.last_name_male,
+            "first_name": fake.first_name_male,
+            "middle_name": fake.middle_name_male,
+            'address_text': fake.address,
+            'administrative_unit': fake.administrative_unit,
+            'house_number': fake.building_number,
+            'city_name': fake.city_name,
+            'postcode': fake.postcode,
+            'company_name': fake.company,
+            'bank_name': fake.bank,
+            'phone_number': fake.phone_number,
+            'inn_fl': fake.individuals_inn,
+            'inn_ul': fake.businesses_inn,
+            'ogrn_ip': fake.individuals_ogrn,
+            'ogrn_fl': fake.businesses_ogrn,
+            'kpp': fake.kpp,
+            'snils_formatted': randomizer.snils_formatted,
+        }
+
+    def _rand_int(self, a):
+        args = str(a).split(sep=",")
+        return str(self.randomizer.rnd.randint(int(args[0]), int(args[1])))
+
+    def _rand_date(self, a):
+        args = str(a).split(sep=",")
+        date_from = args[0].strip(' ').strip("'").strip('"')
+        date_until = args[1].strip(' ').strip("'").strip('"')
+        random_date = self.randomizer.random_date(date_from, date_until)
+        return random_date.strftime('%Y%m%d') # TODO externalize pattern
+
+    def reset_context(self, xsd_filename, config_local):
+        self._local_context.clear()
+        self._local_context["source_filename"] = xsd_filename
+
+        source_filename = config_local.source_filename
+        matches = re.search(source_filename, xsd_filename).groupdict()
+        source_extracted = matches['extracted']
+        self._local_context["source_extracted"] = source_extracted
+
+        output_filename = config_local.output_filename
+        resolved_value = self._process_expression(output_filename)
+        self._local_context['output_filename'] = resolved_value
+
+    def get_output_filename(self):
+        return self._local_context.get("output_filename")
+
+    def substitute_value(self, target_name, items):
+        for target_name_pattern, expression in items:
+            if re.search(target_name_pattern, target_name, re.IGNORECASE):
+                if expression:
+                    result_value = self._process_expression(expression)
+                    return True, result_value
+                else:
+                    return False, None
+        return False, None
+
+    def _process_expression(self, expression):
+        global_context = self._global_context
+        local_context = self._local_context
+        result_value: str = expression
+        span_to_replacement = {}
+        matches = _pattern.finditer(expression)
+        for match in matches:
+            func_name = match[1]
+            func_args = match[2]
+            func_mod = match[3]
+            func_lambda = self.providers_dict[func_name]
+            if not func_lambda:
+                raise RuntimeError(f"Unknown function {func_name}")
+
+            provider_func = lambda: func_lambda() if not func_args else func_lambda(func_args)
+
+            match func_mod:
+                case None:
+                    resolved_value = provider_func()
+                case 'global':
+                    resolved_value = global_context.get(func_name) or provider_func()
+                    global_context[func_name] = resolved_value
+                case 'local':
+                    resolved_value = local_context.get(func_name) or provider_func()
+                    local_context[func_name] = resolved_value
+                case _:
+                    raise RuntimeError(f"Unknown modifier: {func_mod}")
+
+            span_to_replacement[match.span()] = resolved_value
+
+        for span, replacement in reversed(list(span_to_replacement.items())):
+            result_value = result_value[:span[0]] + replacement + result_value[span[1]:]
+
+        return result_value

xmlgenerator/validation.py

@@ -0,0 +1,52 @@
+import sys
+
+from xmlschema import XMLSchemaValidationError
+
+
+class XmlValidator:
+    def __init__(self, post_validate: str, fail_fast: bool):
+        self.fail_fast = fail_fast
+        match post_validate:
+            case 'schema':
+                self.validation_func = self._validate_with_schema
+            case 'schematron':
+                self.validation_func = self._validate_with_schematron
+
+    def validate(self, xsd_schema, document):
+        self.validation_func(xsd_schema, document)
+
+    def _validate_with_schema(self, xsd_schema, document):
+        try:
+            xsd_schema.validate(document)
+        except XMLSchemaValidationError as err:
+            print(err, file=sys.stderr)
+            if self.fail_fast:
+                sys.exit(1)
+
+    def _validate_with_schematron(self, xsd_schema, document):
+        raise RuntimeError("not yet implemented")
+
+# TODO
+# def validate_xml_with_schematron(xml_file, schematron_file):
+#     # Загрузка Schematron-схемы
+#     with open(schematron_file, 'rb') as f:
+#         schematron_doc = etree.parse(f)
+#
+#     # Преобразование Schematron в XSLT
+#     schematron = etree.Schematron(schematron_doc)
+#
+#     # Загрузка XML-документа
+#     with open(xml_file, 'rb') as f:
+#         xml_doc = etree.parse(f)
+#
+#     # Валидация XML-документа
+#     is_valid = schematron.validate(xml_doc)
+#
+#     if is_valid:
+#         print("XML документ валиден по Schematron-схеме.")
+#     else:
+#         print("XML документ не валиден по Schematron-схеме.")
+#         print(schematron.error_log)
+
+# Пример использования
+# validate_xml_with_schematron('example.xml', 'schema.sch')

xmlgenerator-0.1.0.dist-info/METADATA

@@ -0,0 +1,314 @@
+Metadata-Version: 2.4
+Name: xmlgenerator
+Version: 0.1.0
+Summary: Generates XML documents from XSD schemas
+Home-page: https://github.com/lexakimov/xmlgenerator
+Author: Alexey Akimov
+Author-email: lex.akimov23@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: lxml
+Requires-Dist: xmlschema
+Requires-Dist: Faker
+Requires-Dist: rstr
+Requires-Dist: PyYAML
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# XML Generator
+
+- [Русский 🇷🇺](README_RU.md)
+- [English 🇺🇸](README.md)
+
+Generates XML documents based on XSD schemas with the ability to customize data through a YAML configuration file.
+Simplifies the creation of test or demonstration XML data for complex schemas.
+
+## Features
+
+- Generation of XML documents based on XSD schemas
+- Customization of generated values via a YAML configuration file
+- Validation of generated documents
+- Command-line interface for convenient use
+
+## Installation
+
+### Installation via pip
+
+```bash
+pip install xmlgenerator
+```
+
+### Build from source
+
+1. **Clone the repository:**
+   ```bash
+   git clone https://github.com/lexakimov/xmlgenerator.git
+   cd xmlgenerator
+   ```
+
+2. **Create and activate a virtual environment (recommended):**
+   ```bash
+   python -m venv .venv
+   ```
+    * **For Linux/macOS:**
+      ```bash
+      source .venv/bin/activate
+      ```
+    * **For Windows (Command Prompt/PowerShell):**
+      ```bash
+      .\.venv\Scripts\activate
+      ```
+
+3. **Install dependencies:**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+4.1. **Install the package:**
+   ```bash
+   pip install .
+   # or for development mode (code changes will be immediately reflected)
+   # pip install -e .
+   ```
+
+4.2. **Otherwise, build single executable:**
+   ```bash
+   python build_native.py
+   ```
+
+## CLI Usage
+
+The main command to run the generator is `xmlgenerator`.
+
+**Examples:**
+
+- Generate XML from a single schema and print to console:
+  ```bash
+  xmlgenerator path/to/your/schema.xsd
+  ```
+
+- Generate XML from all schemas in a directory and save to the `output` folder using a configuration file:
+  ```bash
+  xmlgenerator -c config.yml -o output/ path/to/schemas/
+  ```
+
+- Generate XML from a specific schema, save to a file with pretty formatting and windows-1251 encoding:
+  ```bash
+  xmlgenerator -o output.xml -p -e windows-1251 path/to/your/schema.xsd
+  ```
+
+- Generate XML with validation disabled:
+  ```bash
+  xmlgenerator -v none path/to/your/schema.xsd
+  ```
+
+**Install shell completions:**
+
+```shell
+# also available: zsh, tcsh
+xmlgenerator -C bash | sudo tee /etc/bash_completion.d/xmlgenerator
+```
+
+**Detailed CLI Usage:**
+
+```
+usage: xmlgenerator [-h] [-c <config.yml>] [-o <output.xml>] [-p] [-v <validation>] [-ff] [-e <encoding>]
+                    [--seed <seed>] [-d] [-V]
+                    xsd [xsd ...]
+
+Generates XML documents from XSD schemas
+
+positional arguments:
+  xsd                            paths to xsd schema(s) or directory with xsd schemas
+
+options:
+  -h, --help                     show this help message and exit
+  -c, --config <config.yml>      pass yaml configuration file
+  -o, --output <output.xml>      save output to dir or file
+  -p, --pretty                   prettify output XML
+  -v, --validation <validation>  validate generated XML document (none, schema, schematron, default is schema)
+  -ff, --fail-fast               terminate execution on validation error (default is true)
+  -e, --encoding <encoding>      output XML encoding (utf-8, windows-1251, default is utf-8)
+      --seed <seed>              set randomization seed
+  -d, --debug                    enable debug mode
+  -V, --version                  shows current version
+  -C, --completion <shell>       print shell completion script (bash, zsh, tcsh)
+```
+
+## Configuration
+
+The generator can be configured using a YAML file passed via the `-c` or `--config` option.
+
+**Configuration File Structure:**
+
+```yaml
+# Global settings (apply to all schemas)
+global:
+
+  # Regular expression to extract a substring from the source xsd schema filename.
+  # The extracted substring can be used via the `source_extracted` function.
+  # The regular expression must contain the group `extracted`.
+  # Default value: `(?P<extracted>.*).(xsd|XSD)` (extracts the filename without extension).
+  source_filename: ...
+
+  # Filename template for saving the generated document.
+  # Default value: `{{ source_filename }}_{{ uuid }}` (xsd schema filename + random UUID)
+  output_filename: ...
+
+  # Random value generator settings
+  randomization:
+    # Probability of adding optional elements (0.0-1.0)
+    # Default value: 0.5
+    probability: 1
+    # Limit for the maximum number of elements
+    max_occurs: 5
+    # Minimum string length
+    min_length: 5
+    # Maximum string length
+    max_length: 20
+    # Minimum numeric value
+    min_inclusive: 10
+    # Maximum numeric value
+    max_inclusive: 1000000
+
+  # Override generated values for tags and attributes.
+  # Key - string or regular expression to match the tag/attribute name.
+  # Value - string with optional use of placeholders:
+  # `{{ function }}` - substitutes the value provided by the predefined function.
+  # `{{ function | modifier }}` - same, but with a modifier [ global | local ].
+  # - `global` - a single value will be used along all generation.
+  # - `local` - a single value will be used in context of current document.
+  #
+  # The list of available functions is below.
+  # The order of entries matters; the first matching override will be selected.
+  # Key matching is case-insensitive.
+  value_override:
+    name_regexp_1: "static value"
+    name_regexp_2: "{{ function_call }}"
+    "name_regexp_\d": "static-text-and-{{ function_call }}"
+    name: "static-text-and-{{ function_call }}-{{ another_function_call }}"
+
+# Extend/override global settings for specific files.
+# Key - string or regular expression to match the xsd filename(s).
+# The order of entries matters; the first matching override will be selected.
+# Key matching is case-insensitive.
+specific:
+  # Each value can have the same set of parameters as the global section
+  "SCHEM.*":
+    # for schemas named "SCHEM.*", xml document names will only contain UUIDv4 + '.xml'
+    output_filename: "{{ uuid }}"
+    # Random value generator settings for schemas named "SCHEM.*"
+    randomization:
+      # for schemas named "SCHEM.*", the probability of adding optional elements will be 30%
+      probability: 0.3
+    value_override:
+      # override the value set by the global configuration
+      name_regexp_1: "static value"
+      # reset overrides for tags/attributes containing 'name' set by the global configuration
+      name:
+```
+
+Configuration Priority:
+
+- specific settings
+- global settings
+- default settings
+
+### Placeholder Functions
+
+In the `value_override` sections, you can specify either a string value or special placeholders:
+
+- `{{ function }}` - Substitutes the value provided by the predefined function.
+- `{{ function | modifier }}` - Same, but with a modifier `[ global | local ]`, where:
+    - `global`: The function will generate and use *the same single value* throughout the *entire generation process*
+      for all documents.
+    - `local`: The function will generate and use *the same single value* within the scope of *a single generated
+      document*.
+    - No modifier: A new value is generated each time the function is called.
+
+**List of Placeholder Functions:**
+
+| Function                           | Description                                                                                                |
+|------------------------------------|------------------------------------------------------------------------------------------------------------|
+| `source_filename`                  | Filename of the source xsd schema with extension (e.g., `schema.xsd`)                                      |
+| `source_extracted`                 | String extracted from the source xsd filename using the regex specified in `source_filename_extract_regex` |
+| `output_filename`                  | String described by the `output_filename_template` configuration parameter                                 |
+| `uuid`                             | Random UUIDv4                                                                                              |
+| `regex("pattern")`                 | Random string value matching the specified regular expression                                              |
+| `number(A, B)`                     | Random number between A and B                                                                              |
+| `date("2010-01-01", "2025-01-01")` | Random date within the specified range                                                                     |
+| `last_name`                        | Last Name                                                                                                  |
+| `first_name`                       | First Name                                                                                                 |
+| `middle_name`                      | Middle Name                                                                                                |
+| `address_text`                     | Address                                                                                                    |
+| `administrative_unit`              | Administrative Unit (e.g., District)                                                                       |
+| `house_number`                     | House Number                                                                                               |
+| `city_name`                        | City Name                                                                                                  |
+| `postcode`                         | Postal Code                                                                                                |
+| `company_name`                     | Company Name                                                                                               |
+| `bank_name`                        | Bank Name                                                                                                  |
+| `phone_number`                     | Phone Number                                                                                               |
+| `inn_fl`                           | Individual Taxpayer Number (Physical Person)                                                               |
+| `inn_ul`                           | Taxpayer Identification Number (Legal Entity)                                                              |
+| `ogrn_ip`                          | Primary State Registration Number (Individual Entrepreneur)                                                |
+| `ogrn_fl`                          | Primary State Registration Number (Physical Person)                                                        |
+| `kpp`                              | Reason Code for Registration                                                                               |
+| `snils_formatted`                  | SNILS (Personal Insurance Account Number) in the format `123-456-789 90`                                   |
+
+**Configuration Examples:**
+
+```yaml
+# TODO Add configuration examples.
+```
+
+---
+
+## Validation
+
+Generated XML documents are checked for conformance against the schema used for generation.
+By default, validation against the source XSD schema is used.
+
+If a document does not conform to the schema, execution stops immediately.
+This behavior can be disabled using the flag `-ff false` or `--fail-fast false`.
+
+To disable validation, use the flag `-v none` or `--validation none`.
+
+## Contribution
+
+Contributions are welcome! Please open an issue or submit a pull request on GitHub.
+
+### Project Structure
+
+- `xmlgenerator/` - main project code
+- `tests/` - tests
+
+### Running Tests
+
+```bash
+pytest
+```
+
+---
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
+
+## Contacts
+
+For any questions or issues, please contact [lex.akimov23@gmail.com].
+
+You can also create an [Issue on GitHub](https://github.com/lexakimov/xmlgenerator/issues) to report bugs or suggest
+improvements.

xmlgenerator-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+xmlgenerator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xmlgenerator/arguments.py,sha256=0hbWgXOTj5GhXL3wHms8kHk5QAEzzN-1fBAc-lKAkBk,4446
+xmlgenerator/bootstrap.py,sha256=X5bN3jn6iWBtigzeGGgSzbVG0MGrHzdFrNOEf3MhHuQ,2598
+xmlgenerator/configuration.py,sha256=z3qbIL_2Lafp2bGTVWYPAAXzp-FuU_whQ7cz0RmbBKk,5101
+xmlgenerator/generator.py,sha256=QAKI36zqIYMjlrphKA8LlC0WWnF8M_6G-ZPWeZn31W4,17768
+xmlgenerator/randomization.py,sha256=_-PoMwSxAxI18x0_arQz0QkyZNUHtH8MB1tlgI3iOAE,1710
+xmlgenerator/substitution.py,sha256=Al4XFXdx8RI6V7nYDjfc2JEYFPbfmw5Mwet4sMCWdCU,4765
+xmlgenerator/validation.py,sha256=Q6sbIPqCargQ0YOJPuvcNdIohcR4yo8tJBLbuceQaag,1755
+xmlgenerator-0.1.0.dist-info/licenses/LICENSE,sha256=QlXK8O3UcoAYUYwVJNgB9MSM7O94ogNo_1hd9GzznUQ,1070
+xmlgenerator-0.1.0.dist-info/METADATA,sha256=6PqKFVwvR3NAOQUEQ8YRk1NN5n5ltHkxgIZp2RMRr8M,12653
+xmlgenerator-0.1.0.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+xmlgenerator-0.1.0.dist-info/entry_points.txt,sha256=ly9hKr3o4AzFUkelBZNRzyKYf-Ld4kfcffvBu1oHq54,61
+xmlgenerator-0.1.0.dist-info/top_level.txt,sha256=jr7FbMBm8MQ6j8I_-nWzQQEseXzwSCZNXgrkWuk9P4E,13
+xmlgenerator-0.1.0.dist-info/RECORD,,

xmlgenerator-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (77.0.3)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

xmlgenerator-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+xmlgenerator = xmlgenerator.bootstrap:main

xmlgenerator-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Alexey Akimov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

xmlgenerator-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+xmlgenerator