xmlgenerator 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

xmlgenerator/arguments.py

@@ -33,7 +33,7 @@ def _get_parser():
         dest="source_paths",
         help="paths to xsd schema(s) or directory with xsd schemas"
     )
-    parser.add_argument(
+    config_arg = parser.add_argument(
         "-c", "--config",
         metavar="<config.yml>",
         dest="config_yaml",
@@ -94,6 +94,7 @@ def _get_parser():
     )
 
     # add shell completions
+    config_arg.complete = shtab.FILE
     source_arg.complete = shtab.FILE
     output_arg.complete = shtab.FILE
     shtab.add_argument_to(parser, ["-C", "--completion"], "print shell completion script (bash, zsh, tcsh)")

xmlgenerator/bootstrap.py

@@ -12,7 +12,6 @@ from xmlgenerator.randomization import Randomizer
 from xmlgenerator.substitution import Substitutor
 from xmlgenerator.validation import XmlValidator
 
-# TODO конфигурация ограничений - occurs
 # TODO Generator - обработка стандартных xsd типов
 # TODO кастомные переменные для локального контекста
 # TODO валидация по Schematron
@@ -90,6 +89,7 @@ def _main():
 
 
 def _setup_loggers(args):
+    logging.addLevelName(logging.WARNING, 'WARN')
     log_level = logging.DEBUG if args.debug else logging.INFO
     logger.setLevel(log_level)
     configuration.logger.setLevel(log_level)

xmlgenerator/generator.py

@@ -1,6 +1,8 @@
 import logging
+from dataclasses import dataclass, replace
+from decimal import Decimal
+from typing import Optional, Any, Callable, Dict
 
-import xmlschema
 from lxml import etree
 from xmlschema.validators import XsdComplexType, XsdAtomicRestriction, XsdTotalDigitsFacet, XsdElement, \
     XsdGroup, XsdFractionDigitsFacet, XsdLengthFacet, XsdMaxLengthFacet, XsdMinExclusiveFacet, XsdMinInclusiveFacet, \
@@ -13,12 +15,78 @@ from xmlgenerator.substitution import Substitutor
 logger = logging.getLogger(__name__)
 
 
+@dataclass
+class TypeConstraints:
+    min_length: Optional[int] = None
+    max_length: Optional[int] = None
+    min_value: Optional[Any] = None
+    max_value: Optional[Any] = None
+    total_digits: Optional[int] = None
+    fraction_digits: Optional[int] = None
+    patterns: Optional[list] = None
+    rand_config: Optional[Any] = None
+
+
 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:
+        self.generators: Dict[str, Callable[[TypeConstraints], str]] = {
+            # primitive
+            'boolean': self._generate_boolean,
+            'string': self._generate_string,
+            'decimal': self._generate_decimal,
+            'float': self._generate_float,
+            'double': self._generate_double,
+            'duration': self._generate_duration,
+            'dateTime': self._generate_datetime,
+            'date': self._generate_date,
+            'time': self._generate_time,
+            'gYearMonth': self._generate_gyearmonth,
+            'gYear': self._generate_gyear,
+            'gMonthDay': self._generate_gmonthday,
+            'gDay': self._generate_gday,
+            'gMonth': self._generate_gmonth,
+            'hexBinary': self._generate_hex_binary,
+            'base64Binary': self._generate_base64_binary,
+            'anyURI': self._generate_any_uri,
+            'QName': self._generate_qname,
+            'NOTATION': self._generate_notation,
+
+            # derived - from decimal
+            'byte': self._generate_byte,
+            'short': self._generate_short,
+            'int': self._generate_int,
+            'integer': self._generate_integer,
+            'long': self._generate_long,
+
+            'unsignedByte': self._generate_unsigned_byte,
+            'unsignedShort': self._generate_unsigned_short,
+            'unsignedInt': self._generate_unsigned_int,
+            'unsignedLong': self._generate_unsigned_long,
+
+            'positiveInteger': self._generate_positive_integer,
+            'negativeInteger': self._generate_negative_integer,
+            'nonPositiveInteger': self._generate_non_positive_integer,
+            'nonNegativeInteger': self._generate_non_negative_integer,
+
+            # derived - from string
+            'language': lambda c: (_ for _ in ()).throw(Exception('not yet implemented')),
+            'Name': lambda c: (_ for _ in ()).throw(Exception('not yet implemented')),
+            'NCName': lambda c: (_ for _ in ()).throw(Exception('not yet implemented')),
+            'normalizedString': lambda c: (_ for _ in ()).throw(Exception('not yet implemented')),
+            'token': lambda c: (_ for _ in ()).throw(Exception('not yet implemented')),
+            'ID': lambda c: (_ for _ in ()).throw(Exception('not yet implemented')),
+            'IDREF': lambda c: (_ for _ in ()).throw(Exception('not yet implemented')),
+            'IDREFS': lambda c: (_ for _ in ()).throw(Exception('not yet implemented')),
+            'ENTITY': lambda c: (_ for _ in ()).throw(Exception('not yet implemented')),
+            'ENTITIES': lambda c: (_ for _ in ()).throw(Exception('not yet implemented')),
+            'NMTOKEN': lambda c: (_ for _ in ()).throw(Exception('not yet implemented')),
+            'NMTOKENS': lambda c: (_ for _ in ()).throw(Exception('not yet implemented')),
+        }
+
+    def generate_xml(self, xsd_schema, local_config: GeneratorConfig) -> etree.Element:
+        logger.debug('generate xml document...')
         ns_map = {None if k == '' else k: v for k, v in xsd_schema.namespaces.items() if v != ''}
         xsd_root_element = xsd_schema.root_elements[0]
         xml_root_element = etree.Element(xsd_root_element.name, nsmap=ns_map)
@@ -26,7 +94,11 @@ class XmlGenerator:
         self._add_elements(xml_tree, xml_root_element, xsd_root_element, local_config)
         return xml_root_element
 
-    def _add_elements(self, xml_tree, xml_element: etree.Element, xsd_element, local_config: GeneratorConfig) -> None:
+    def _add_elements(self, xml_tree, xml_element, xsd_element, local_config: GeneratorConfig) -> None:
+        rand_config = local_config.randomization
+        min_occurs_conf = rand_config.min_occurs
+        max_occurs_conf = rand_config.max_occurs
+
         # Process child elements --------------------------------------------------------------------------------------
         if isinstance(xsd_element, XsdElement):
             element_xpath = xml_tree.getpath(xml_element)
@@ -38,14 +110,14 @@ class XmlGenerator:
             attributes = getattr(xsd_element, 'attributes', dict())
             if len(attributes) > 0 and xsd_element_type.local_name != 'anyType':
                 for attr_name, attr in attributes.items():
-                    logger.debug('element: %s; attribute "%s" [processing]', element_xpath, attr_name)
+                    logger.debug('element: %s; attribute: "%s" - [processing]', element_xpath, attr_name)
                     use = attr.use  # optional | required | prohibited
                     if use == 'prohibited':
-                        logger.debug('element: %s; attribute: "%s" [skipped]', element_xpath, attr_name)
+                        logger.debug('element: %s; attribute: "%s" - [skipped]', element_xpath, attr_name)
                         continue
                     elif use == 'optional':
-                        if self.randomizer.random() > local_config.randomization.probability:
-                            logger.debug('element: %s; attribute: "%s" [skipped]', element_xpath, attr_name)
+                        if self.randomizer.random() > rand_config.probability:
+                            logger.debug('element: %s; attribute: "%s" - [skipped]', element_xpath, attr_name)
                             continue
 
                     attr_value = self._generate_value(attr.type, attr_name, local_config)
@@ -57,58 +129,82 @@ class XmlGenerator:
                 text = self._generate_value(xsd_element_type, xsd_element.name, local_config)
                 xml_element.text = text
                 logger.debug('element: %s = "%s"', element_xpath, text)
-                return
+
             elif isinstance(xsd_element_type, XsdAtomicRestriction):
                 text = self._generate_value(xsd_element_type, xsd_element.name, local_config)
                 xml_element.text = text
                 logger.debug('element: %s = "%s"', element_xpath, 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_tree, xml_element, xsd_element_type_content, local_config)
                 else:
                     raise RuntimeError()
+
             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  # TODO externalize
-            group_max_occurs = group_max_occurs if group_max_occurs is not None else 10  # TODO externalize
-            group_occurs = self.randomizer.integer(group_min_occurs, group_max_occurs)
+            min_occurs = getattr(xsd_element, 'min_occurs', None)
+            max_occurs = getattr(xsd_element, 'max_occurs', None)
+            min_occurs, max_occurs = merge_constraints(
+                schema_min=min_occurs,
+                schema_max=max_occurs,
+                config_min=min_occurs_conf,
+                config_max=max_occurs_conf
+            )
+            if max_occurs is None:
+                max_occurs = 10
+            group_occurs = self.randomizer.integer(min_occurs, max_occurs)
+            logger.debug('add %s (random between %s and %s) groups of type "%s"',
+                         group_occurs, min_occurs, max_occurs, model)
 
             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  # TODO externalize
-                        element_max_occurs = element_max_occurs if element_max_occurs is not None else 10  # TODO externalize
-                        element_occurs = self.randomizer.integer(element_min_occurs, element_max_occurs)
+                        min_occurs = getattr(xsd_child_element_type, 'min_occurs', None)
+                        max_occurs = getattr(xsd_child_element_type, 'max_occurs', None)
+                        min_occurs, max_occurs = merge_constraints(
+                            schema_min=min_occurs,
+                            schema_max=max_occurs,
+                            config_min=min_occurs_conf,
+                            config_max=max_occurs_conf
+                        )
+                        if max_occurs is None:
+                            max_occurs = 10
+                        element_occurs = self.randomizer.integer(min_occurs, max_occurs)
+                        logger.debug('element_occurs: %s (random between %s and %s)', element_occurs, min_occurs,
+                                     max_occurs)
 
                         for _ in range(element_occurs):
                             xml_child_element = etree.SubElement(xml_element, xsd_child_element_type.name)
                             self._add_elements(xml_tree, 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:
+                        if isinstance(xsd_child_element_type, XsdElement):
 
-                        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  # TODO externalize
-                        element_max_occurs = element_max_occurs if element_max_occurs is not None else 10  # TODO externalize
-                        element_occurs = self.randomizer.integer(element_min_occurs, element_max_occurs)
+                            min_occurs = getattr(xsd_child_element_type, 'min_occurs', None)
+                            max_occurs = getattr(xsd_child_element_type, 'max_occurs', None)
+                            min_occurs, max_occurs = merge_constraints(
+                                schema_min=min_occurs,
+                                schema_max=max_occurs,
+                                config_min=min_occurs_conf,
+                                config_max=max_occurs_conf
+                            )
+                            if max_occurs is None:
+                                max_occurs = 10
+                            element_occurs = self.randomizer.integer(min_occurs, max_occurs)
+                            logger.debug('element_occurs: %s (random between %s and %s)', element_occurs, min_occurs,
+                                         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_tree, xml_child_element, xsd_child_element_type, local_config)
@@ -123,22 +219,28 @@ class XmlGenerator:
 
                         else:
                             raise RuntimeError(xsd_child_element_type)
-                return
 
             elif model == 'choice':
                 for _ in range(group_occurs):
                     xsd_child_element_type = self.randomizer.any(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  # TODO externalize
-                    element_max_occurs = element_max_occurs if element_max_occurs is not None else 10  # TODO externalize
-                    element_occurs = self.randomizer.integer(element_min_occurs, element_max_occurs)
+                    min_occurs = getattr(xsd_child_element_type, 'min_occurs', None)
+                    max_occurs = getattr(xsd_child_element_type, 'max_occurs', None)
+                    min_occurs, max_occurs = merge_constraints(
+                        schema_min=min_occurs,
+                        schema_max=max_occurs,
+                        config_min=min_occurs_conf,
+                        config_max=max_occurs_conf
+                    )
+                    if max_occurs is None:
+                        max_occurs = 10
+                    element_occurs = self.randomizer.integer(min_occurs, max_occurs)
+                    logger.debug('element_occurs: %s (random between %s and %s)', element_occurs, min_occurs,
+                                 max_occurs)
 
                     for _ in range(element_occurs):
                         xml_child_element = etree.SubElement(xml_element, xsd_child_element_type.name)
                         self._add_elements(xml_tree, xml_child_element, xsd_child_element_type, local_config)
-                return
 
             else:
                 raise RuntimeError()
@@ -176,71 +278,14 @@ class XmlGenerator:
         # -------------------------------------------------------------------------------------------------------------
         # Генерируем значения для стандартных типов и типов с ограничениями
         if isinstance(xsd_type, XsdAtomicBuiltin) or isinstance(xsd_type, XsdAtomicRestriction):
-            # Выясняем ограничения
-            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
-            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):
-                    pass
-                elif callable(validator):
-                    pass
-                else:
-                    raise RuntimeError(f"Unhandled validator: {validator}")
+            constraints = extract_type_constraints(xsd_type, local_config)
+            type_id = xsd_type.id or xsd_type.base_type.id or xsd_type.root_type.id
+            logger.debug('generate value for type: "%s"', type_id)
+            generator = self.generators.get(type_id)
+            if generator is None:
+                raise RuntimeError(f"Generator not found for type: {type_id}")
+            generated_value = generator(constraints)
 
-            rand_config = local_config.randomization
-
-            logger.debug(
-                'restrictions before override: min_length: %4s; max_length: %4s; min_value: %4s; max_value: %4s',
-                min_length, max_length, min_value, max_value
-            )
-
-            min_length, max_length = calculate_bounds_1(
-                min_length, max_length, rand_config.min_length, rand_config.max_length
-            )
-
-            min_value, max_value = calculate_bounds_1(
-                min_value, max_value, rand_config.min_inclusive, rand_config.max_inclusive
-            )
-
-            logger.debug(
-                'restrictions after  override: min_length: %4s; max_length: %4s; min_value: %4s; max_value: %4s',
-                min_length, max_length, min_value, max_value
-            )
-
-            generated_value = self._generate_value_by_type(
-                xsd_type, patterns,
-                min_length, max_length,
-                min_value, max_value,
-                total_digits, fraction_digits
-            )
             logger.debug('value generated: "%s"', generated_value)
             return generated_value
 
@@ -254,83 +299,27 @@ class XmlGenerator:
 
         raise RuntimeError(f"Can't generate value - unhandled type. Target name: {target_name}")
 
-    def _generate_value_by_type(self, xsd_type, 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
-
-        logger.debug('generate value for type: "%s"', type_id)
-
-        match type_id:
-            case 'string':
-                return self._generate_string(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, patterns, min_length, max_length):
-        if patterns is not None:
+    # noinspection PyUnusedLocal
+    def _generate_boolean(self, constraints: TypeConstraints):
+        return self.randomizer.any(['true', 'false'])
+
+    def _generate_string(self, constraints: TypeConstraints):
+        if constraints.patterns is not None:
             # Генерация строки по regex
-            random_enum = self.randomizer.any(patterns)
+            random_enum = self.randomizer.any(constraints.patterns)
             random_pattern = random_enum.attrib['value']
             return self.randomizer.regex(random_pattern)
 
         # Иначе генерируем случайную строку
-        return self.randomizer.ascii_string(min_length, max_length)
-
-    def _generate_boolean(self):
-        return self.randomizer.any(['true', 'false'])
+        return self.randomizer.ascii_string(constraints.min_length, constraints.max_length)
 
-    def _generate_integer(self, total_digits, min_value, max_value):
-        if total_digits:
-            min_value = 10 ** (total_digits - 1)
-            max_value = (10 ** total_digits) - 1
-        rnd_int = self.randomizer.integer(min_value, max_value)
-        return str(rnd_int)
+    def _generate_decimal(self, constraints: TypeConstraints):
+        rand_config = constraints.rand_config
+        min_value = constraints.min_value
+        max_value = constraints.max_value
+        total_digits = constraints.total_digits
+        fraction_digits = constraints.fraction_digits
 
-    def _generate_decimal(self, total_digits, fraction_digits, min_value, max_value):
         if fraction_digits is None:
             fraction_digits = self.randomizer.integer(1, 3)
 
@@ -345,112 +334,263 @@ class XmlGenerator:
 
         integer_digits = total_digits - fraction_digits
 
-        # negative
-        min_value_fact = -(10 ** integer_digits - 1)
-
-        # positive
-        max_value_fact = 10 ** integer_digits - 1
-
-        min_value_fact, max_value_fact = calculate_bounds_2(min_value_fact, max_value_fact, min_value, max_value)
-
-        random_float = self.randomizer.float(min_value_fact, max_value_fact)
-        return f"{random_float:.{fraction_digits}f}"
+        # negative bound
+        digit_min = -(10 ** integer_digits - 1)
+        # positive bound
+        digit_max = 10 ** integer_digits - 1
+        logger.debug("integer digits: %s; digit_min: %s; digit_max: %s", integer_digits, digit_min, digit_max)
+
+        logger.debug('bounds before adjust: min_value: %4s; max_value: %4s', min_value, max_value)
+        config_min = rand_config.min_inclusive
+        config_max = rand_config.max_inclusive
+        effective_min, effective_max \
+            = merge_constraints(digit_min, digit_max, min_value, max_value, config_min, config_max)
+        logger.debug('bounds after  adjust: min_value: %4s; max_value: %4s', effective_min, effective_max)
+
+        if fraction_digits == 0:
+            random_int = self.randomizer.integer(min_value, max_value)
+            return str(random_int)
+        else:
+            random_float = self.randomizer.float(effective_min, effective_max)
+            return f"{random_float:.{fraction_digits}f}"
 
-    def _generate_float(self, min_value, max_value):
-        return self._generate_double(min_value, max_value)
+    def _generate_float(self, constraints: TypeConstraints):
+        decimal_constraints = replace(constraints, fraction_digits=2)
+        return self._generate_decimal(decimal_constraints)
 
-    def _generate_double(self, min_value, max_value):
-        return self._generate_decimal(None, 2, min_value, max_value)
+    def _generate_double(self, constraints: TypeConstraints):
+        decimal_constraints = replace(constraints, fraction_digits=2)
+        return self._generate_decimal(decimal_constraints)
 
-    def _generate_duration(self):
+    def _generate_duration(self, constraints: TypeConstraints):
         raise RuntimeError("not yet implemented")
 
-    def _generate_datetime(self):
+    # noinspection PyUnusedLocal
+    def _generate_datetime(self, constraints: TypeConstraints):
         random_datetime = self.randomizer.random_datetime()
         formatted = random_datetime.isoformat()
         return formatted
 
-    def _generate_date(self):
+    # noinspection PyUnusedLocal
+    def _generate_date(self, constraints: TypeConstraints):
         random_date = self.randomizer.random_date()
         formatted = random_date.isoformat()
         return formatted
 
-    def _generate_time(self):
+    # noinspection PyUnusedLocal
+    def _generate_time(self, constraints: TypeConstraints):
         random_time = self.randomizer.random_time()
         formatted = random_time.isoformat()
         return formatted
 
-    def _generate_gyearmonth(self):
+    # noinspection PyUnusedLocal
+    def _generate_gyearmonth(self, constraints: TypeConstraints):
         random_date = self.randomizer.random_date()
         formatted = random_date.strftime('%Y-%m')
         return formatted
 
-    def _generate_gyear(self):
+    # noinspection PyUnusedLocal
+    def _generate_gyear(self, constraints: TypeConstraints):
         return str(self.randomizer.integer(2000, 2050))
 
-    def _generate_gmonthday(self):
+    # noinspection PyUnusedLocal
+    def _generate_gmonthday(self, constraints: TypeConstraints):
         random_date = self.randomizer.random_date()
         formatted = random_date.strftime('--%m-%d')
         return formatted
 
-    def _generate_gday(self):
+    # noinspection PyUnusedLocal
+    def _generate_gday(self, constraints: TypeConstraints):
         random_date = self.randomizer.random_date()
         formatted = random_date.strftime('---%d')
         return formatted
 
-    def _generate_gmonth(self):
+    # noinspection PyUnusedLocal
+    def _generate_gmonth(self, constraints: TypeConstraints):
         random_date = self.randomizer.random_date()
         formatted = random_date.strftime('--%m--')
         return formatted
 
-    def _generate_hex_binary(self):
-        raise RuntimeError("not yet implemented")
+    def _generate_hex_binary(self, constraints: TypeConstraints):
+        return self.randomizer.hex_string(constraints.min_length, constraints.max_length)
 
-    def _generate_base64_binary(self):
+    # noinspection PyUnusedLocal
+    def _generate_base64_binary(self, constraints: TypeConstraints):
         raise RuntimeError("not yet implemented")
 
-    def _generate_any_uri(self):
+    # noinspection PyUnusedLocal
+    def _generate_any_uri(self, constraints: TypeConstraints):
         raise RuntimeError("not yet implemented")
 
-    def _generate_qname(self):
+    # noinspection PyUnusedLocal
+    def _generate_qname(self, constraints: TypeConstraints):
         raise RuntimeError("not yet implemented")
 
-    def _generate_notation(self):
+    # noinspection PyUnusedLocal
+    def _generate_notation(self, constraints: TypeConstraints):
         raise RuntimeError("not yet implemented")
 
-
-def calculate_bounds_1(fact_min, fact_max, config_min, config_max):
-    if config_min:
-        if fact_min is None:
-            fact_min = config_min
-        else:
-            new_min = max(fact_min, config_min)
-            if fact_max and new_min <= fact_max:
-                fact_min = new_min
-
-    if config_max:
-        if fact_max is None:
-            fact_max = config_max
+    def _generate_byte(self, constraints: TypeConstraints):
+        constraints = replace(constraints, fraction_digits=0)
+        return self._generate_decimal(constraints)
+
+    def _generate_short(self, constraints: TypeConstraints):
+        constraints = replace(constraints, fraction_digits=0)
+        return self._generate_decimal(constraints)
+
+    def _generate_int(self, constraints: TypeConstraints):
+        constraints = replace(constraints, fraction_digits=0)
+        return self._generate_decimal(constraints)
+
+    def _generate_integer(self, constraints: TypeConstraints):
+        min_value = constraints.min_value if constraints.min_value is not None else -2147483648
+        max_value = constraints.max_value if constraints.max_value is not None else 2147483647
+        constraints = replace(constraints, min_value=min_value, max_value=max_value, fraction_digits=0)
+        return self._generate_decimal(constraints)
+
+    def _generate_long(self, constraints: TypeConstraints):
+        constraints = replace(constraints, fraction_digits=0)
+        return self._generate_decimal(constraints)
+
+    def _generate_unsigned_byte(self, constraints: TypeConstraints):
+        constraints = replace(constraints, fraction_digits=0)
+        return self._generate_decimal(constraints)
+
+    def _generate_unsigned_short(self, constraints: TypeConstraints):
+        constraints = replace(constraints, fraction_digits=0)
+        return self._generate_decimal(constraints)
+
+    def _generate_unsigned_int(self, constraints: TypeConstraints):
+        constraints = replace(constraints, fraction_digits=0)
+        return self._generate_decimal(constraints)
+
+    def _generate_unsigned_long(self, constraints: TypeConstraints):
+        constraints = replace(constraints, fraction_digits=0)
+        return self._generate_decimal(constraints)
+
+    def _generate_positive_integer(self, constraints: TypeConstraints):
+        min_value = constraints.min_value if constraints.min_value is not None else 1
+        max_value = constraints.max_value if constraints.max_value is not None else 2 ** 31 - 1
+        constraints = replace(constraints, min_value=min_value, max_value=max_value, fraction_digits=0)
+        return self._generate_decimal(constraints)
+
+    def _generate_negative_integer(self, constraints: TypeConstraints):
+        min_value = constraints.min_value if constraints.min_value is not None else -2 ** 31
+        max_value = constraints.max_value if constraints.max_value is not None else -1
+        constraints = replace(constraints, min_value=min_value, max_value=max_value, fraction_digits=0)
+        return self._generate_decimal(constraints)
+
+    def _generate_non_positive_integer(self, constraints: TypeConstraints):
+        min_value = constraints.min_value if constraints.min_value is not None else -2 ** 31
+        max_value = constraints.max_value if constraints.max_value is not None else 0
+        constraints = replace(constraints, min_value=min_value, max_value=max_value, fraction_digits=0)
+        return self._generate_decimal(constraints)
+
+    def _generate_non_negative_integer(self, constraints: TypeConstraints):
+        min_value = constraints.min_value if constraints.min_value is not None else 0
+        max_value = constraints.max_value if constraints.max_value is not None else 2 ** 31 - 1
+        constraints = replace(constraints, min_value=min_value, max_value=max_value, fraction_digits=0)
+        return self._generate_decimal(constraints)
+
+
+def extract_type_constraints(xsd_type, local_config: GeneratorConfig) -> TypeConstraints:
+    min_length = getattr(xsd_type, 'min_length', None)
+    max_length = getattr(xsd_type, 'max_length', None)
+    min_value = getattr(xsd_type, 'min_value', None)
+    max_value = getattr(xsd_type, 'max_value', None)
+    total_digits = None
+    fraction_digits = 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):
+            pass
+        elif callable(validator):
+            pass
         else:
-            new_max = min(fact_max, config_max)
-            if new_max >= fact_min:
-                fact_max = new_max
-
-    if fact_max and fact_min and fact_max < fact_min:
-        fact_max = fact_min = min(fact_max, fact_min)
-
-    return fact_min, fact_max
-
-
-def calculate_bounds_2(fact_min, fact_max, config_min, config_max):
+            raise RuntimeError(f"Unhandled validator: {validator}")
+
+    if isinstance(min_value, Decimal):
+        min_value = float(min_value)
+    if isinstance(max_value, Decimal):
+        max_value = float(max_value)
+
+    rand_config = local_config.randomization
+
+    logger.debug('bounds before adjust: min_length: %4s; max_length: %4s', min_length, max_length)
+    min_length, max_length = merge_constraints(
+        schema_min=min_length,
+        schema_max=max_length,
+        config_min=rand_config.min_length,
+        config_max=rand_config.max_length
+    )
+    logger.debug('bounds after  adjust: min_length: %4s; max_length: %4s', min_length, max_length)
+
+    return TypeConstraints(
+        min_length=min_length,
+        max_length=max_length,
+        min_value=min_value,
+        max_value=max_value,
+        total_digits=total_digits,
+        fraction_digits=fraction_digits,
+        patterns=patterns,
+        rand_config=rand_config
+    )
+
+
+def merge_constraints(digit_min=None, digit_max=None, schema_min=None, schema_max=None, config_min=None, config_max=None):
+    logger.debug(
+        "merge numeric constraints: "
+        "digit_min: %s, digit_max: %s, schema_min: %s, schema_max: %s, config_min: %s, config_max: %s",
+        digit_min, digit_max, schema_min, schema_max, config_min, config_max)
+
+    # За основу берем цифровые ограничения (они самые нестрогие)
+    effective_min, effective_max = digit_min, digit_max
+
+    # Применяем схемные ограничения
+    if schema_min is not None:
+        effective_min = max(effective_min, schema_min) if effective_min is not None else schema_min
+    if schema_max is not None:
+        effective_max = min(effective_max, schema_max) if effective_max is not None else schema_max
+
+    # Применяем конфигурационные ограничения с проверкой на конфликт
     if config_min is not None:
-        new_min = max(fact_min, config_min)
-        if fact_max and new_min <= fact_max:
-            fact_min = new_min
+        if effective_max is not None and config_min > effective_max:
+            logger.warning("can't apply bound from configuration: config_min (%s) > effective_max (%s)",
+                           config_min, effective_max)
+        else:
+            effective_min = max(effective_min, config_min) if effective_min is not None else config_min
 
     if config_max is not None:
-        new_max = min(fact_max, config_max)
-        if new_max >= fact_min:
-            fact_max = new_max
+        if effective_min is not None and config_max < effective_min:
+            logger.warning("can't apply bound from configuration: config_max (%s) < effective_min (%s)",
+                           config_max, effective_min)
+        else:
+            effective_max = min(effective_max, config_max) if effective_max is not None else config_max
+
+    # Проверяем на конфликт
+    if effective_min is not None and effective_max is not None and effective_min > effective_max:
+        logger.warning("constrains conflict: effective_min (%s) > effective_max (%s). Swap values.",
+                       effective_min, effective_max)
+        effective_min, effective_max = effective_max, effective_min
 
-    return fact_min, fact_max
+    return effective_min, effective_max

xmlgenerator/randomization.py

@@ -4,7 +4,6 @@ import re
 import string
 import sys
 from datetime import datetime, date, time, timedelta
-from decimal import Decimal
 
 import rstr
 from faker import Faker
@@ -42,10 +41,6 @@ class Randomizer:
         return self._rnd.randint(min_value, max_value)
 
     def float(self, min_value, max_value):
-        if isinstance(min_value, Decimal):
-            min_value = float(min_value)
-        if isinstance(max_value, Decimal):
-            max_value = float(max_value)
         return self._rnd.uniform(min_value, max_value)
 
     def ascii_string(self, min_length, max_length):
@@ -58,6 +53,16 @@ class Randomizer:
         letters = string.ascii_lowercase
         return ''.join(self._rnd.choice(letters) for _ in range(length)).capitalize()
 
+    def hex_string(self, min_length, max_length):
+        if min_length is None:
+            min_length = 1
+        if max_length is None:
+            max_length = 20
+
+        length = self._rnd.randint(min_length, max_length)
+        circumflexes = ''.join('^' for _ in range(length))
+        return self._fake.hexify(text=circumflexes, upper=True)
+
     def random_date(self, start_date: str = '1990-01-01', end_date: str = '2025-12-31') -> date:
         start = date.fromisoformat(start_date)
         end = date.fromisoformat(end_date)
@@ -138,3 +143,6 @@ class Randomizer:
     def snils_formatted(self):
         snils = self._fake.snils()
         return f"{snils[:3]}-{snils[3:6]}-{snils[6:9]} {snils[9:]}"
+
+    def email(self):
+        return self._fake.email()

xmlgenerator/substitution.py

@@ -46,6 +46,7 @@ class Substitutor:
             'ogrn_fl': lambda args: self.randomizer.ogrn_fl(),
             'kpp': lambda args: self.randomizer.kpp(),
             'snils_formatted': lambda args: self.randomizer.snils_formatted(),
+            'email': lambda args: self.randomizer.email(),
         }
 
     def reset_context(self, xsd_filename, config_local):
@@ -61,7 +62,7 @@ class Substitutor:
         resolved_value = self._process_expression(output_filename)
         self._local_context['output_filename'] = resolved_value
 
-        logger.debug('local_context reset')
+        logger.debug('reset local context...')
         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)

{xmlgenerator-0.3.0.dist-info → xmlgenerator-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xmlgenerator
-Version: 0.3.0
+Version: 0.5.0
 Summary: Generates XML documents from XSD schemas
 Home-page: https://github.com/lexakimov/xmlgenerator
 Author: Alexey Akimov
@@ -173,6 +173,8 @@ global:
     # Probability of adding optional elements (0.0-1.0)
     # Default value: 0.5
     probability: 1
+    # Limit for the minimal number of elements
+    min_occurs: 0
     # Limit for the maximum number of elements
     max_occurs: 5
     # Minimum string length
@@ -268,6 +270,7 @@ In the `value_override` sections, you can specify either a string value or speci
 | `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`                                   |
+| `email`                            | Random email address                                                                                       |
 
 **Configuration Examples:**
 

xmlgenerator-0.5.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+xmlgenerator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xmlgenerator/arguments.py,sha256=Pf7Bccan0FeO6v5INpBkhLlGfJg-FGMRX5pG8E2KVgo,4834
+xmlgenerator/bootstrap.py,sha256=T_Xy5PElb75EuyKIwXUGkQ2mntt3v2RwC1ulFI-CZnM,3654
+xmlgenerator/configuration.py,sha256=JYhz_lONxd0faUiZHG-TVEs6yocn0s__Ulwtcvq9eDs,5946
+xmlgenerator/generator.py,sha256=vECUZZ5VlMq3Mpam3_ZUsWmzHr402nqxDRKzLNAqNiU,29237
+xmlgenerator/randomization.py,sha256=azXW1SxKSA9_lw1IBQDPOwSUXFEXo8IGWFD0an-eVF0,4416
+xmlgenerator/substitution.py,sha256=v4rzqnF1p1yN0VKRDFwQM5zQbpdg9ebbrh65cnh9qxw,6078
+xmlgenerator/validation.py,sha256=uCJjS5YmRDlAp9C-5Rd4E2Brh6_3WOG2-dSGxDiaH14,2023
+xmlgenerator-0.5.0.dist-info/licenses/LICENSE,sha256=QlXK8O3UcoAYUYwVJNgB9MSM7O94ogNo_1hd9GzznUQ,1070
+xmlgenerator-0.5.0.dist-info/METADATA,sha256=-zApCcYPrg5A8nC2CLwBHWFEwMOwBDni21AnFhIEd1I,13083
+xmlgenerator-0.5.0.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+xmlgenerator-0.5.0.dist-info/entry_points.txt,sha256=ly9hKr3o4AzFUkelBZNRzyKYf-Ld4kfcffvBu1oHq54,61
+xmlgenerator-0.5.0.dist-info/top_level.txt,sha256=jr7FbMBm8MQ6j8I_-nWzQQEseXzwSCZNXgrkWuk9P4E,13
+xmlgenerator-0.5.0.dist-info/RECORD,,

xmlgenerator-0.3.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-xmlgenerator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-xmlgenerator/arguments.py,sha256=0WHKt7eOS7M3_R-rYdp_52Q8rgArCF9VlIDkPVP_8dk,4784
-xmlgenerator/bootstrap.py,sha256=7ONv9Eh46z6xd8w_V7FO1156FonAX-LHYpRrQ44PrBU,3668
-xmlgenerator/configuration.py,sha256=JYhz_lONxd0faUiZHG-TVEs6yocn0s__Ulwtcvq9eDs,5946
-xmlgenerator/generator.py,sha256=eBW8UlY8Bu8xh4oo5jp4_yo6OKz9T3xvQeZYC66lui4,20814
-xmlgenerator/randomization.py,sha256=ekNQJYgcmDCf6uCYiZnWat7u_9kO6TAQQ8qZFIpiB7o,4205
-xmlgenerator/substitution.py,sha256=1nvjQLSUS9Yo8r2T3f420Upbwm6iikUQG3lG5TQUSDU,6016
-xmlgenerator/validation.py,sha256=uCJjS5YmRDlAp9C-5Rd4E2Brh6_3WOG2-dSGxDiaH14,2023
-xmlgenerator-0.3.0.dist-info/licenses/LICENSE,sha256=QlXK8O3UcoAYUYwVJNgB9MSM7O94ogNo_1hd9GzznUQ,1070
-xmlgenerator-0.3.0.dist-info/METADATA,sha256=ONyx3zcbuX1zQTnt-5ORWcxU1shJDYbgsyFBlEWx8E4,12870
-xmlgenerator-0.3.0.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-xmlgenerator-0.3.0.dist-info/entry_points.txt,sha256=ly9hKr3o4AzFUkelBZNRzyKYf-Ld4kfcffvBu1oHq54,61
-xmlgenerator-0.3.0.dist-info/top_level.txt,sha256=jr7FbMBm8MQ6j8I_-nWzQQEseXzwSCZNXgrkWuk9P4E,13
-xmlgenerator-0.3.0.dist-info/RECORD,,