xmlgenerator 0.1.0__tar.gz → 0.2.1__tar.gz

{xmlgenerator-0.1.0/xmlgenerator.egg-info → xmlgenerator-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xmlgenerator
-Version: 0.1.0
+Version: 0.2.1
 Summary: Generates XML documents from XSD schemas
 Home-page: https://github.com/lexakimov/xmlgenerator
 Author: Alexey Akimov
@@ -247,6 +247,7 @@ In the `value_override` sections, you can specify either a string value or speci
 | `output_filename`                  | String described by the `output_filename_template` configuration parameter                                 |
 | `uuid`                             | Random UUIDv4                                                                                              |
 | `regex("pattern")`                 | Random string value matching the specified regular expression                                              |
+| `any('A', "B", C)`                 | Random value from enumeration                                                                              |
 | `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                                                                                                  |

{xmlgenerator-0.1.0 → xmlgenerator-0.2.1}/README.md

@@ -218,6 +218,7 @@ In the `value_override` sections, you can specify either a string value or speci
 | `output_filename`                  | String described by the `output_filename_template` configuration parameter                                 |
 | `uuid`                             | Random UUIDv4                                                                                              |
 | `regex("pattern")`                 | Random string value matching the specified regular expression                                              |
+| `any('A', "B", C)`                 | Random value from enumeration                                                                              |
 | `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                                                                                                  |

{xmlgenerator-0.1.0 → xmlgenerator-0.2.1}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='xmlgenerator',
-    version='0.1.0',
+    version='0.2.1',
     packages=find_packages(exclude=("tests", "tests.*")),
     entry_points={
         'console_scripts': [

{xmlgenerator-0.1.0 → xmlgenerator-0.2.1}/xmlgenerator/arguments.py

@@ -1,9 +1,12 @@
+import logging
 import sys
 from argparse import ArgumentParser, HelpFormatter
 from pathlib import Path
 
 import shtab
 
+logger = logging.getLogger(__name__)
+
 
 class MyParser(ArgumentParser):
     def error(self, message):
@@ -99,6 +102,10 @@ def parse_args():
     parser = _get_parser()
     args = parser.parse_args()
 
+    # setup logger
+    log_level = logging.DEBUG if args.debug else logging.INFO
+    logger.setLevel(log_level)
+
     if args.config_yaml:
         config_path = Path(args.config_yaml)
         if not config_path.exists() or not config_path.is_file():

{xmlgenerator-0.1.0 → xmlgenerator-0.2.1}/xmlgenerator/bootstrap.py

@@ -1,39 +1,55 @@
+import logging
+
 from lxml import etree
+from xmlschema import XMLSchema
+
+import xmlgenerator
+from xmlgenerator import configuration, validation, randomization, substitution, generator
 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/
+
+logging.basicConfig(level=logging.WARN, format='%(asctime)s [%(name)-26s] %(levelname)-6s - %(message)s')
+
+logger = logging.getLogger('xmlgenerator.bootstrap')
 
 
 def main():
+    try:
+        _main()
+    except KeyboardInterrupt as ex:
+        logger.info('processing interrupted')
+
+
+def _main():
     args, xsd_files, output_path = parse_args()
+    _setup_loggers(args)
 
-    config = load_config(args.config_yaml)
+    if output_path:
+        logger.debug('specified output path: %s', output_path.absolute())
+    else:
+        logger.debug('output path is not specified. Generated xml will be written to stdout')
 
-    print(f"Найдено схем: {len(xsd_files)}")
+    config = load_config(args.config_yaml)
 
     randomizer = Randomizer(args.seed)
     substitutor = Substitutor(randomizer)
     generator = XmlGenerator(randomizer, substitutor)
     validator = XmlValidator(args.validation, args.fail_fast)
 
+    logger.debug('found %s schemas', len(xsd_files))
     for xsd_file in xsd_files:
-        print(f"Processing schema: {xsd_file.name}")
+        logger.info('processing schema: %s', xsd_file.name)
 
         # get configuration override for current schema
         local_config = config.get_for_file(xsd_file.name)
@@ -52,6 +68,7 @@ def main():
 
         # Print out to console
         if not output_path:
+            logger.debug('print xml document to stdout')
             print(decoded)
 
         # Validation (if enabled)
@@ -65,9 +82,20 @@ def main():
             output_file = output_path
             if output_path.is_dir():
                 output_file = output_path / f'{xml_filename}.xml'
+            logger.debug('save xml document as %s', output_file.absolute())
             with open(output_file, 'wb') as f:
                 f.write(xml_str)
-            print(f"Saved document: {output_file.name}")
+
+
+def _setup_loggers(args):
+    log_level = logging.DEBUG if args.debug else logging.INFO
+    logger.setLevel(log_level)
+    configuration.logger.setLevel(log_level)
+    validation.logger.setLevel(log_level)
+    xmlgenerator.generator.logger.setLevel(log_level)
+    substitution.logger.setLevel(log_level)
+    randomization.logger.setLevel(log_level)
+
 
 if __name__ == "__main__":
     main()

{xmlgenerator-0.1.0 → xmlgenerator-0.2.1}/xmlgenerator/configuration.py

@@ -1,4 +1,5 @@
 import dataclasses
+import logging
 import re
 import sys
 from dataclasses import dataclass, field, Field
@@ -6,6 +7,8 @@ from typing import Dict, get_args, get_origin, Any
 
 import yaml
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass
 class RandomizationConfig:
@@ -45,6 +48,7 @@ class Config:
     def get_for_file(self, xsd_name):
         for pattern, conf in self.specific.items():
             if re.match(pattern, xsd_name):
+                logger.debug("resolved configration with pattern '%s'", pattern)
                 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)
@@ -52,17 +56,23 @@ class Config:
                 local_override = conf.value_override
                 global_override = self.global_.value_override
                 merged_config.value_override = _merge_dicts(local_override, global_override)
+                _log_configration('using specific configuration:', merged_config)
                 return merged_config
 
+        _log_configration('using global configration:', self.global_)
         return self.global_
 
 
 def load_config(file_path: str | None) -> "Config":
     if not file_path:
-        return Config()
+        config = Config()
+        _log_configration("created default configuration:", config)
+        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, "")
+        config = _map_to_class(config_data, Config, "")
+        _log_configration(f"configuration loaded from {file_path}:", config)
+        return config
 
 
 def _map_to_class(data_dict: dict, cls, parent_path: str):
@@ -80,7 +90,7 @@ def _map_to_class(data_dict: dict, cls, parent_path: str):
             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)
+                    logger.error('YAML parse error: unexpected property: %s.%s', parent_path, yaml_name)
                     sys.exit(1)
 
                 # Определяем тип поля
@@ -90,10 +100,10 @@ def _map_to_class(data_dict: dict, cls, parent_path: str):
         # Проверка на отсутствие обязательных полей
         missing_fields = required_fields - yaml_items.keys()
         if missing_fields:
-            print(f"YAML parse error: missing required properties in {parent_path}:", file=sys.stderr)
+            logger.error('YAML parse error: missing required properties in %s:', parent_path)
             for missing_field in missing_fields:
                 yaml_field_name = missing_field if missing_field != "global_" else "global"
-                print(yaml_field_name, file=sys.stderr)
+                logger.error(yaml_field_name)
             sys.exit(1)
 
         return cls(**yaml_items)
@@ -133,3 +143,12 @@ def _merge_dicts(base_dict, extra_dict):
         if key not in merged_dict:
             merged_dict[key] = value
     return merged_dict
+
+
+def _log_configration(message, config):
+    if logger.isEnabledFor(logging.DEBUG):
+        logger.debug(message)
+        as_dict = dataclasses.asdict(config)
+        dumped = yaml.safe_dump(as_dict, allow_unicode=True, width=float("inf"), sort_keys=False, indent=4)
+        for line in dumped.splitlines():
+            logger.debug('|\t%s', line)

{xmlgenerator-0.1.0 → xmlgenerator-0.2.1}/xmlgenerator/generator.py

@@ -1,7 +1,6 @@
+import logging
 import re
-import sys
 
-import rstr
 import xmlschema
 from lxml import etree
 from xmlschema.validators import XsdComplexType, XsdAtomicRestriction, XsdTotalDigitsFacet, XsdElement, \
@@ -12,6 +11,8 @@ from xmlgenerator.configuration import GeneratorConfig
 from xmlgenerator.randomization import Randomizer
 from xmlgenerator.substitution import Substitutor
 
+logger = logging.getLogger(__name__)
+
 
 class XmlGenerator:
     def __init__(self, randomizer: Randomizer, substitutor: Substitutor):
@@ -28,21 +29,27 @@ class XmlGenerator:
         rnd = self.randomizer.rnd
 
         xsd_element_type = getattr(xsd_element, 'type', None)
+        logger.debug('fill down element "%s" with type %s', xsd_element.name, type(xsd_element_type).__name__)
 
         # Add attributes if they are
         attributes = getattr(xsd_element, 'attributes', dict())
         if len(attributes) > 0 and xsd_element_type.local_name != 'anyType':
+            logger.debug('add attributes to element %s', xsd_element.name)
             for attr_name, attr in attributes.items():
+                logger.debug('attribute: %s', attr_name)
                 use = attr.use  # optional | required | prohibited
                 if use == 'prohibited':
+                    logger.debug('skipped')
                     continue
                 elif use == 'optional':
                     if rnd.random() > local_config.randomization.probability:
-                        continue    # skip optional attribute
+                        logger.debug('skipped')
+                        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))
+                    logger.debug(f'attribute %s set with value %s', attr_name, attr_value)
 
         # Process child elements --------------------------------------------------------------------------------------
         if isinstance(xsd_element, XsdElement):
@@ -69,7 +76,7 @@ class XmlGenerator:
             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_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':
@@ -80,7 +87,7 @@ class XmlGenerator:
                         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_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):
@@ -96,7 +103,7 @@ class XmlGenerator:
                         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_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):
@@ -123,7 +130,7 @@ class XmlGenerator:
                     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_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):
@@ -232,7 +239,6 @@ class XmlGenerator:
 
         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:
 
@@ -289,17 +295,22 @@ class XmlGenerator:
 
     def _generate_string(self, target_name, patterns, min_length, max_length):
         rnd = self.randomizer.rnd
+        re_gen = self.randomizer.re_gen
         if patterns is not None:
             # Генерация строки по regex
             random_pattern = rnd.choice(patterns)
-            xeger = rstr.xeger(random_pattern.attrib['value'])
+            xeger = re_gen.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)
+                logger.warning(
+                    "Possible mistake in schema: %s generated value '%s' can't be shorter than %s",
+                    target_name, xeger, min_length
+                )
             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)
+                logger.warning(
+                    "Possible mistake in schema: %s generated value '%s' can't be longer than %s",
+                    target_name, xeger, max_length
+                )
             return xeger
 
         # Иначе генерируем случайную строку
@@ -347,29 +358,43 @@ class XmlGenerator:
         raise RuntimeError("not yet implemented")
 
     def _generate_datetime(self):
-        raise RuntimeError("not yet implemented")
+        random_datetime = self.randomizer.random_datetime()
+        formatted = random_datetime.isoformat()
+        return formatted
 
     def _generate_date(self):
-        raise RuntimeError("not yet implemented")
+        random_date = self.randomizer.random_date()
+        formatted = random_date.isoformat()
+        return formatted
 
     def _generate_time(self):
-        raise RuntimeError("not yet implemented")
+        random_time = self.randomizer.random_time()
+        formatted = random_time.isoformat()
+        return formatted
 
     def _generate_gyearmonth(self):
-        raise RuntimeError("not yet implemented")
+        random_date = self.randomizer.random_date()
+        formatted = random_date.strftime('%Y-%m')
+        return formatted
 
     def _generate_gyear(self):
         rnd = self.randomizer.rnd
-        return rnd.randint(2000, 2050)
+        return str(rnd.randint(2000, 2050))
 
     def _generate_gmonthday(self):
-        raise RuntimeError("not yet implemented")
+        random_date = self.randomizer.random_date()
+        formatted = random_date.strftime('--%m-%d')
+        return formatted
 
     def _generate_gday(self):
-        raise RuntimeError("not yet implemented")
+        random_date = self.randomizer.random_date()
+        formatted = random_date.strftime('---%d')
+        return formatted
 
     def _generate_gmonth(self):
-        raise RuntimeError("not yet implemented")
+        random_date = self.randomizer.random_date()
+        formatted = random_date.strftime('--%m--')
+        return formatted
 
     def _generate_hex_binary(self):
         raise RuntimeError("not yet implemented")

xmlgenerator-0.2.1/xmlgenerator/randomization.py

@@ -0,0 +1,76 @@
+import logging
+import random
+import string
+import sys
+from datetime import datetime, date, time, timedelta
+
+import rstr
+from faker import Faker
+
+logger = logging.getLogger(__name__)
+
+
+class Randomizer:
+    def __init__(self, seed=None):
+        if not seed:
+            seed = random.randrange(sys.maxsize)
+            logger.debug('initialize with random seed: %s', seed)
+        else:
+            logger.debug('initialize with provided seed: %s', seed)
+
+        self.rnd = random.Random(seed)
+        self.fake = Faker(locale='ru_RU')
+        self.fake.seed_instance(seed)
+        self.re_gen = rstr.Rstr(self.rnd)
+
+    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 = '1990-01-01', end_date: str = '2025-12-31') -> date:
+        # Преобразуем строки в объекты datetime
+        start = date.fromisoformat(start_date)
+        end = date.fromisoformat(end_date)
+
+        # Вычисляем разницу в днях между начальной и конечной датой
+        delta = (end - start).days
+
+        # Генерируем случайное количество дней в пределах delta
+        random_days = self.rnd.randint(0, delta)
+
+        # Добавляем случайное количество дней к начальной дате
+        return start + timedelta(days=random_days)
+
+    def random_time(self, start_time: str = '00:00:00', end_time: str = '23:59:59') -> time:
+        start = time.fromisoformat(start_time)
+        end = time.fromisoformat(end_time)
+
+        random_h = self.rnd.randint(start.hour, end.hour)
+        random_m = self.rnd.randint(start.minute, end.minute)
+        random_s = self.rnd.randint(start.second, end.second)
+
+        return time(hour=random_h, minute=random_m, second=random_s)
+
+    def random_datetime(self, start_date: str = '1990-01-01', end_date: str = '2025-12-31') -> 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-0.1.0 → xmlgenerator-0.2.1}/xmlgenerator/substitution.py

@@ -1,13 +1,15 @@
+import logging
 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*}}')
+_pattern = re.compile(
+    r'\{\{\s*(?:(?P<function>\S*?)(?:\(\s*(?P<argument>[^)]*)\s*\))?\s*(?:\|\s*(?P<modifier>.*?))?)?\s*}}')
+
+logger = logging.getLogger(__name__)
+
 
 class Substitutor:
     def __init__(self, randomizer: Randomizer):
@@ -17,18 +19,19 @@ class Substitutor:
         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,
+            '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: fake.uuid4(),
+            'regex': self._rand_regex,
+            'any': self._rand_any,
+            '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,
@@ -45,6 +48,16 @@ class Substitutor:
             'snils_formatted': randomizer.snils_formatted,
         }
 
+    def _rand_regex(self, a):
+        pattern = a.strip("'").strip('"')
+        return self.randomizer.re_gen.xeger(pattern)
+
+    def _rand_any(self, a):
+        args = str(a).split(sep=",")
+        value = self.randomizer.rnd.choice(args)
+        value = value.strip(' ').strip("'").strip('"')
+        return value
+
     def _rand_int(self, a):
         args = str(a).split(sep=",")
         return str(self.randomizer.rnd.randint(int(args[0]), int(args[1])))
@@ -53,8 +66,8 @@ class Substitutor:
         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
+        random_date = self.randomizer.random_datetime(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()
@@ -69,6 +82,11 @@ class Substitutor:
         resolved_value = self._process_expression(output_filename)
         self._local_context['output_filename'] = resolved_value
 
+        logger.debug('local_context reset')
+        logger.debug('local_context["source_filename"]  = %s', xsd_filename)
+        logger.debug('local_context["source_extracted"] = %s (extracted with regexp %s)', source_extracted, source_filename)
+        logger.debug('local_context["output_filename"]  = %s', resolved_value)
+
     def get_output_filename(self):
         return self._local_context.get("output_filename")
 
@@ -83,6 +101,7 @@ class Substitutor:
         return False, None
 
     def _process_expression(self, expression):
+        logger.debug('processing expression: %s', expression)
         global_context = self._global_context
         local_context = self._local_context
         result_value: str = expression
@@ -115,4 +134,5 @@ class Substitutor:
         for span, replacement in reversed(list(span_to_replacement.items())):
             result_value = result_value[:span[0]] + replacement + result_value[span[1]:]
 
+        logger.debug('expression resolved to value: %s', result_value)
         return result_value

{xmlgenerator-0.1.0 → xmlgenerator-0.2.1}/xmlgenerator/validation.py

@@ -1,7 +1,10 @@
+import logging
 import sys
 
 from xmlschema import XMLSchemaValidationError
 
+logger = logging.getLogger(__name__)
+
 
 class XmlValidator:
     def __init__(self, post_validate: str, fail_fast: bool):
@@ -11,11 +14,13 @@ class XmlValidator:
                 self.validation_func = self._validate_with_schema
             case 'schematron':
                 self.validation_func = self._validate_with_schematron
+        logger.debug("post validation: %s, fail fast: %s", post_validate, fail_fast)
 
     def validate(self, xsd_schema, document):
         self.validation_func(xsd_schema, document)
 
     def _validate_with_schema(self, xsd_schema, document):
+        logger.debug("validate generated xml with xsd schema")
         try:
             xsd_schema.validate(document)
         except XMLSchemaValidationError as err:
@@ -24,6 +29,7 @@ class XmlValidator:
                 sys.exit(1)
 
     def _validate_with_schematron(self, xsd_schema, document):
+        logger.debug("validate generated xml with xsd schematron")
         raise RuntimeError("not yet implemented")
 
 # TODO

{xmlgenerator-0.1.0 → xmlgenerator-0.2.1/xmlgenerator.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xmlgenerator
-Version: 0.1.0
+Version: 0.2.1
 Summary: Generates XML documents from XSD schemas
 Home-page: https://github.com/lexakimov/xmlgenerator
 Author: Alexey Akimov
@@ -247,6 +247,7 @@ In the `value_override` sections, you can specify either a string value or speci
 | `output_filename`                  | String described by the `output_filename_template` configuration parameter                                 |
 | `uuid`                             | Random UUIDv4                                                                                              |
 | `regex("pattern")`                 | Random string value matching the specified regular expression                                              |
+| `any('A', "B", C)`                 | Random value from enumeration                                                                              |
 | `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                                                                                                  |

xmlgenerator-0.1.0/xmlgenerator/randomization.py

@@ -1,40 +0,0 @@
-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:]}"