xmlgenerator 0.2.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

xmlgenerator/arguments.py

@@ -39,6 +39,12 @@ def _get_parser():
         dest="config_yaml",
         help="pass yaml configuration file"
     )
+    parser.add_argument(
+        "-l", "--locale",
+        metavar="<locale>",
+        default="en_US",
+        help="randomizer locale (default: %(default)s)"
+    )
     output_arg = parser.add_argument(
         "-o", "--output",
         metavar="<output.xml>",
@@ -71,7 +77,7 @@ def _get_parser():
         help="output XML encoding (utf-8, windows-1251, default is utf-8)"
     )
     parser.add_argument(
-        "--seed",
+        "-s", "--seed",
         metavar="<seed>",
         help="set randomization seed"
     )

xmlgenerator/bootstrap.py

@@ -42,14 +42,15 @@ def _main():
 
     config = load_config(args.config_yaml)
 
-    randomizer = Randomizer(args.seed)
+    randomizer = Randomizer(args.seed, args.locale)
     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:
-        logger.info('processing schema: %s', xsd_file.name)
+    total_count = len(xsd_files)
+    logger.debug('found %s schemas', total_count)
+    for index, xsd_file in enumerate(xsd_files):
+        logger.info('processing schema %s of %s: %s', index + 1, total_count, xsd_file.name)
 
         # get configuration override for current schema
         local_config = config.get_for_file(xsd_file.name)
@@ -88,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/configuration.py

@@ -13,6 +13,7 @@ logger = logging.getLogger(__name__)
 @dataclass
 class RandomizationConfig:
     probability: float = field(default=None)
+    min_occurs: int = field(default=None)
     max_occurs: int = field(default=None)
     min_length: int = field(default=None)
     max_length: int = field(default=None)
@@ -36,7 +37,7 @@ class GeneratorConfig:
 @dataclass
 class GlobalGeneratorConfig(GeneratorConfig):
     source_filename: str = field(default='(?P<extracted>.*).(xsd|XSD)')
-    output_filename: str = field(default='{{ source_filename }}_{{ uuid }}')
+    output_filename: str = field(default='{{ source_extracted }}_{{ uuid }}')
     randomization: GlobalRandomizationConfig = field(default_factory=lambda: GlobalRandomizationConfig())
 
 

xmlgenerator/generator.py

@@ -1,7 +1,6 @@
 import logging
-import re
+from decimal import Decimal
 
-import xmlschema
 from lxml import etree
 from xmlschema.validators import XsdComplexType, XsdAtomicRestriction, XsdTotalDigitsFacet, XsdElement, \
     XsdGroup, XsdFractionDigitsFacet, XsdLengthFacet, XsdMaxLengthFacet, XsdMinExclusiveFacet, XsdMinInclusiveFacet, \
@@ -19,124 +18,162 @@ class XmlGenerator:
         self.randomizer = randomizer
         self.substitutor = substitutor
 
-    def generate_xml(self, xsd_schema: xmlschema.XMLSchema, local_config: GeneratorConfig) -> etree.Element:
+    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)
-        self._add_elements(xml_root_element, xsd_root_element, local_config)
+        xml_root_element = etree.Element(xsd_root_element.name, nsmap=ns_map)
+        xml_tree = etree.ElementTree(xml_root_element)
+        self._add_elements(xml_tree, 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)
-        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:
-                        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)
+    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):
-            if isinstance(xsd_element_type, XsdAtomicRestriction):
+            element_xpath = xml_tree.getpath(xml_element)
+            logger.debug('element: %s [created]', element_xpath)
+
+            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():
+                    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)
+                        continue
+                    elif use == 'optional':
+                        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)
+                    if attr_value is not None:
+                        xml_element.set(attr_name, str(attr_value))
+                        logger.debug('element: %s; attribute: "%s" = "%s"', element_xpath, attr_name, attr_value)
+
+            if isinstance(xsd_element_type, XsdAtomicBuiltin):
                 text = self._generate_value(xsd_element_type, xsd_element.name, local_config)
                 xml_element.text = text
-                return
+                logger.debug('element: %s = "%s"', element_xpath, text)
+
+            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)
+
             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)
+                    self._add_elements(xml_tree, 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)
+            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
-                        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)
+                        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_child_element, xsd_child_element_type, local_config)
-                return
+                            self._add_elements(xml_tree, xml_child_element, xsd_child_element_type, local_config)
 
             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
-                        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)
+                            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_child_element, xsd_child_element_type, local_config)
+                                self._add_elements(xml_tree, 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)
+                            self._add_elements(xml_tree, 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)
+                            self._add_elements(xml_tree, 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)
+                    xsd_child_element_type = self.randomizer.any(xsd_element)
+
+                    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_child_element, xsd_child_element_type, local_config)
-                return
+                        self._add_elements(xml_tree, xml_child_element, xsd_child_element_type, local_config)
 
             else:
                 raise RuntimeError()
@@ -155,79 +192,129 @@ class XmlGenerator:
         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:
+            logger.debug('value resolved: "%s"', overridden_value)
             return overridden_value
 
         # -------------------------------------------------------------------------------------------------------------
         # If there is an enumeration, select a random value from it
-
+        enumeration = getattr(xsd_type, 'enumeration', None)
         if enumeration is not None:
-            return rnd.choice(enumeration)
+            random_enum = self.randomizer.any(enumeration)
+            logger.debug('use random value from enumeration: "%s" %s', random_enum, enumeration)
+            return str(random_enum)
 
-        # -------------------------------------------------------------------------------------------------------------\
+        # -------------------------------------------------------------------------------------------------------------
         # Генерируем значения для стандартных типов и типов с ограничениями
         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
+            # Выясняем ограничения
+            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}")
+
+            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)
+
+            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)
+
+            match type_id:
+                case 'boolean':
+                    result = self._generate_boolean()
+                case 'string':
+                    result = self._generate_string(min_length, max_length, patterns)
+                case 'integer':
+                    result = self._generate_integer(min_value, max_value, total_digits)
+                case 'decimal':
+                    result = self._generate_decimal(rand_config, min_value, max_value, total_digits, fraction_digits)
+                case 'float':
+                    result = self._generate_float(rand_config, min_value, max_value)
+                case 'double':
+                    result = self._generate_double(rand_config, min_value, max_value)
+                case 'duration':
+                    result = self._generate_duration()
+                case 'dateTime':
+                    result = self._generate_datetime()
+                case 'date':
+                    result = self._generate_date()
+                case 'time':
+                    result = self._generate_time()
+                case 'gYearMonth':
+                    result = self._generate_gyearmonth()
+                case 'gYear':
+                    result = self._generate_gyear()
+                case 'gMonthDay':
+                    result = self._generate_gmonthday()
+                case 'gDay':
+                    result = self._generate_gday()
+                case 'gMonth':
+                    result = self._generate_gmonth()
+                case 'hexBinary':
+                    result = self._generate_hex_binary()
+                case 'base64Binary':
+                    result = self._generate_base64_binary()
+                case 'anyURI':
+                    result = self._generate_any_uri()
+                case 'QName':
+                    result = self._generate_qname()
+                case 'NOTATION':
+                    result = self._generate_notation()
+                case _:
+                    raise RuntimeError(type_id)
+            generated_value = result
+            logger.debug('value generated: "%s"', generated_value)
+            return generated_value
 
         # -------------------------------------------------------------------------------------------------------------
         # Проверяем базовый тип
@@ -239,120 +326,62 @@ 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:
-
-        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
-        re_gen = self.randomizer.re_gen
+    def _generate_boolean(self):
+        return self.randomizer.any(['true', 'false'])
+
+    def _generate_string(self, min_length, max_length, patterns):
         if patterns is not None:
             # Генерация строки по regex
-            random_pattern = rnd.choice(patterns)
-            xeger = re_gen.xeger(random_pattern.attrib['value'])
-            xeger = re.sub(r'\s', ' ', xeger)
-            if min_length > -1 and len(xeger) < min_length:
-                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):
-                logger.warning(
-                    "Possible mistake in schema: %s generated value '%s' can't be longer than %s",
-                    target_name, xeger, max_length
-                )
-            return xeger
+            random_enum = self.randomizer.any(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):
-        rnd = self.randomizer.rnd
-        return rnd.choice(['true', 'false'])
-
-    def _generate_integer(self, total_digits, min_value, max_value):
-        rnd = self.randomizer.rnd
+    def _generate_integer(self, min_value, max_value, total_digits):
         if total_digits:
             min_value = 10 ** (total_digits - 1)
             max_value = (10 ** total_digits) - 1
-        rnd_int = rnd.randint(min_value, max_value)
+        rnd_int = self.randomizer.integer(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_decimal(self, rand_config, schema_min, schema_max, total_digits, fraction_digits):
+        if fraction_digits is None:
+            fraction_digits = self.randomizer.integer(1, 3)
+
+        if fraction_digits > 4:
+            fraction_digits = self.randomizer.integer(1, 4)
+
+        if total_digits is None:
+            total_digits = 10 + fraction_digits
+
+        if total_digits > 10:
+            total_digits = self.randomizer.integer(6, total_digits - 2)
+
+        integer_digits = total_digits - fraction_digits
+
+        # 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)
 
-    def _generate_double(self, min_value, max_value):
-        return self._generate_float(min_value, max_value)
+        logger.debug('bounds before adjust: min_value: %4s; max_value: %4s', schema_min, schema_max)
+        config_min = rand_config.min_inclusive
+        config_max = rand_config.max_inclusive
+        effective_min, effective_max \
+            = merge_constraints(digit_min, digit_max, schema_min, schema_max, config_min, config_max)
+        logger.debug('bounds after  adjust: min_value: %4s; max_value: %4s', effective_min, effective_max)
+
+        random_float = self.randomizer.float(effective_min, effective_max)
+        return f"{random_float:.{fraction_digits}f}"
+
+    def _generate_float(self, rand_config, min_value, max_value):
+        return self._generate_decimal(rand_config, min_value, max_value, None, 2)
+
+    def _generate_double(self, rand_config, min_value, max_value):
+        return self._generate_decimal(rand_config, min_value, max_value, None, 2)
 
     def _generate_duration(self):
         raise RuntimeError("not yet implemented")
@@ -378,8 +407,7 @@ class XmlGenerator:
         return formatted
 
     def _generate_gyear(self):
-        rnd = self.randomizer.rnd
-        return str(rnd.randint(2000, 2050))
+        return str(self.randomizer.integer(2000, 2050))
 
     def _generate_gmonthday(self):
         random_date = self.randomizer.random_date()
@@ -410,3 +438,43 @@ class XmlGenerator:
 
     def _generate_notation(self):
         raise RuntimeError("not yet implemented")
+
+
+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:
+        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:
+        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 effective_min, effective_max

xmlgenerator/randomization.py

@@ -1,5 +1,6 @@
 import logging
 import random
+import re
 import string
 import sys
 from datetime import datetime, date, time, timedelta
@@ -11,66 +12,124 @@ logger = logging.getLogger(__name__)
 
 
 class Randomizer:
-    def __init__(self, seed=None):
+    def __init__(self, seed=None, locale='ru_RU'):
         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))
+        self._rnd = random.Random(seed)
+        self._fake = Faker(locale=locale)
+        self._fake.seed_instance(seed)
+        self._rstr = rstr.Rstr(self._rnd)
+
+    def random(self):
+        return self._rnd.random()
+
+    def any(self, options):
+        return self._rnd.choice(options)
+
+    def regex(self, pattern):
+        xeger = self._rstr.xeger(pattern)
+        return re.sub(r'\s', ' ', xeger)
+
+    def uuid(self):
+        return self._fake.uuid4()
+
+    def integer(self, min_value, max_value):
+        return self._rnd.randint(min_value, max_value)
+
+    def float(self, min_value, max_value):
+        return self._rnd.uniform(min_value, max_value)
+
+    def ascii_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)
+        letters = string.ascii_lowercase
+        return ''.join(self._rnd.choice(letters) for _ in range(length)).capitalize()
 
     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)
-
-        # Добавляем случайное количество дней к начальной дате
+        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)
+        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)
-
-        # Добавляем случайное количество дней к начальной дате
+        random_days = self._rnd.randint(0, delta)
         return start + timedelta(days=random_days)
 
+    def last_name(self):
+        return self._fake.last_name_male()
+    
+    def first_name(self):
+        return self._fake.first_name_male()
+    
+    def middle_name(self):
+        return self._fake.middle_name_male()
+    
+    def address_text(self):
+        return self._fake.address()
+    
+    def administrative_unit(self):
+        return self._fake.administrative_unit()
+    
+    def house_number(self):
+        return self._fake.building_number()
+    
+    def city_name(self):
+        return self._fake.city_name() if hasattr(self._fake, 'city_name') else self._fake.city()
+
+    def country(self):
+        return self._fake.country()
+    
+    def postcode(self):
+        return self._fake.postcode()
+    
+    def company_name(self):
+        return self._fake.company()
+    
+    def bank_name(self):
+        return self._fake.bank()
+    
+    def phone_number(self):
+        return self._fake.phone_number()
+    
+    def inn_fl(self):
+        return self._fake.individuals_inn()
+    
+    def inn_ul(self):
+        return self._fake.businesses_inn()
+    
+    def ogrn_ip(self):
+        return self._fake.individuals_ogrn()
+    
+    def ogrn_fl(self):
+        return self._fake.businesses_ogrn()
+    
+    def kpp(self):
+        return self._fake.kpp()
+
     def snils_formatted(self):
-        snils = self.fake.snils()
+        snils = self._fake.snils()
         return f"{snils[:3]}-{snils[3:6]}-{snils[6:9]} {snils[9:]}"

xmlgenerator/substitution.py

@@ -13,62 +13,41 @@ logger = logging.getLogger(__name__)
 
 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: 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,
-            '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,
+            # local scope functions
+            'source_filename': lambda args: self._local_context["source_filename"],
+            'source_extracted': lambda args: self._local_context["source_extracted"],
+            'output_filename': lambda args: self.get_output_filename(),
+
+            'any': lambda args: self._any(args),
+            'regex': lambda args: self._regex(args),
+            'uuid': lambda args: self.randomizer.uuid(),
+            'number': lambda args: self._number(args),
+            'date': lambda args: self._date_formatted(args),
+
+            'last_name': lambda args: self.randomizer.last_name(),
+            'first_name': lambda args: self.randomizer.first_name(),
+            'middle_name': lambda args: self.randomizer.middle_name(),
+            'address_text': lambda args: self.randomizer.address_text(),
+            'administrative_unit': lambda args: self.randomizer.administrative_unit(),
+            'house_number': lambda args: self.randomizer.house_number(),
+            'city_name': lambda args: self.randomizer.city_name(),
+            'country': lambda args: self.randomizer.country(),
+            'postcode': lambda args: self.randomizer.postcode(),
+            'company_name': lambda args: self.randomizer.company_name(),
+            'bank_name': lambda args: self.randomizer.bank_name(),
+            'phone_number': lambda args: self.randomizer.phone_number(),
+            'inn_fl': lambda args: self.randomizer.inn_fl(),
+            'inn_ul': lambda args: self.randomizer.inn_ul(),
+            'ogrn_ip': lambda args: self.randomizer.ogrn_ip(),
+            'ogrn_fl': lambda args: self.randomizer.ogrn_fl(),
+            'kpp': lambda args: self.randomizer.kpp(),
+            'snils_formatted': lambda args: self.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])))
-
-    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_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()
         self._local_context["source_filename"] = xsd_filename
@@ -82,7 +61,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)
@@ -115,7 +94,7 @@ class Substitutor:
             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)
+            provider_func = lambda: func_lambda(func_args)
 
             match func_mod:
                 case None:
@@ -136,3 +115,21 @@ class Substitutor:
 
         logger.debug('expression resolved to value: %s', result_value)
         return result_value
+
+    def _any(self, args):
+        separated_args = str(args).split(sep=",")
+        options = [i.strip(' ').strip("'").strip('"') for i in separated_args]
+        return self.randomizer.any(options)
+
+    def _regex(self, args):
+        pattern = args.strip("'").strip('"')
+        return self.randomizer.regex(pattern)
+
+    def _number(self, args):
+        left_bound, right_bound = (int(i) for i in str(args).split(sep=","))
+        return str(self.randomizer.integer(left_bound, right_bound))
+
+    def _date_formatted(self, args):
+        date_from, date_until = (i.strip(' ').strip("'").strip('"') for i in str(args).split(sep=","))
+        random_date = self.randomizer.random_datetime(date_from, date_until)
+        return random_date.strftime("%Y%m%d")

{xmlgenerator-0.2.1.dist-info → xmlgenerator-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xmlgenerator
-Version: 0.2.1
+Version: 0.4.0
 Summary: Generates XML documents from XSD schemas
 Home-page: https://github.com/lexakimov/xmlgenerator
 Author: Alexey Akimov
@@ -136,12 +136,13 @@ positional arguments:
 options:
   -h, --help                     show this help message and exit
   -c, --config <config.yml>      pass yaml configuration file
+  -l, --locale <locale>          randomizer locale (default: en_US)
   -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
+  -s, --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)
@@ -164,7 +165,7 @@ global:
   source_filename: ...
 
   # Filename template for saving the generated document.
-  # Default value: `{{ source_filename }}_{{ uuid }}` (xsd schema filename + random UUID)
+  # Default value: `{{ source_extracted }}_{{ uuid }}` (xsd schema filename + random UUID)
   output_filename: ...
 
   # Random value generator settings
@@ -172,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

xmlgenerator-0.4.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+xmlgenerator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xmlgenerator/arguments.py,sha256=0WHKt7eOS7M3_R-rYdp_52Q8rgArCF9VlIDkPVP_8dk,4784
+xmlgenerator/bootstrap.py,sha256=T_Xy5PElb75EuyKIwXUGkQ2mntt3v2RwC1ulFI-CZnM,3654
+xmlgenerator/configuration.py,sha256=JYhz_lONxd0faUiZHG-TVEs6yocn0s__Ulwtcvq9eDs,5946
+xmlgenerator/generator.py,sha256=0hVlvod26PhR3-O2zEi-Tzdq4uCU13Xjeco5Srte5tQ,23228
+xmlgenerator/randomization.py,sha256=OXh8ZmOKEU6AieGDl67d19i9MhobJKShONT19gDOFyo,4009
+xmlgenerator/substitution.py,sha256=gaNcVqdDt3vbcBR8Pxf1mxo_qp8tTcd09VvVKnwlIA0,6019
+xmlgenerator/validation.py,sha256=uCJjS5YmRDlAp9C-5Rd4E2Brh6_3WOG2-dSGxDiaH14,2023
+xmlgenerator-0.4.0.dist-info/licenses/LICENSE,sha256=QlXK8O3UcoAYUYwVJNgB9MSM7O94ogNo_1hd9GzznUQ,1070
+xmlgenerator-0.4.0.dist-info/METADATA,sha256=0Hi7lAhUvXxo7nXcOcxIFZ1ufmxFli5Hn4ROEt1eZHU,12935
+xmlgenerator-0.4.0.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+xmlgenerator-0.4.0.dist-info/entry_points.txt,sha256=ly9hKr3o4AzFUkelBZNRzyKYf-Ld4kfcffvBu1oHq54,61
+xmlgenerator-0.4.0.dist-info/top_level.txt,sha256=jr7FbMBm8MQ6j8I_-nWzQQEseXzwSCZNXgrkWuk9P4E,13
+xmlgenerator-0.4.0.dist-info/RECORD,,

xmlgenerator-0.2.1.dist-info/RECORD

@@ -1,14 +0,0 @@
-xmlgenerator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-xmlgenerator/arguments.py,sha256=E0b5ndlGAxu39OgRatqmPdWSkS5EvCTLUEMKFgezi7c,4612
-xmlgenerator/bootstrap.py,sha256=bPVHugpMSkv54_8Kxe0RPqyvIxC3cci-1yehntZm_YY,3510
-xmlgenerator/configuration.py,sha256=DiYUpNCjkerjr73yD209q8FJwGWgipbwWXuLkt25rQM,5903
-xmlgenerator/generator.py,sha256=Ci3xuOoG2jpTcoRa2c1BEDI_4hIfEd3iU05tcgB0paM,18877
-xmlgenerator/randomization.py,sha256=LK4ZwSZdyks7qV0OOxKsGyKA0q660ID7x2DeU9gvL_I,3261
-xmlgenerator/substitution.py,sha256=mD827EbgYg2mTp-PNcvsERJtVUKaLvaoOoQmGnq5zBo,5595
-xmlgenerator/validation.py,sha256=uCJjS5YmRDlAp9C-5Rd4E2Brh6_3WOG2-dSGxDiaH14,2023
-xmlgenerator-0.2.1.dist-info/licenses/LICENSE,sha256=QlXK8O3UcoAYUYwVJNgB9MSM7O94ogNo_1hd9GzznUQ,1070
-xmlgenerator-0.2.1.dist-info/METADATA,sha256=zfA1y1vFm58sX2tRolF6G8LngaBGViSPp8C2Xp7_PvY,12801
-xmlgenerator-0.2.1.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-xmlgenerator-0.2.1.dist-info/entry_points.txt,sha256=ly9hKr3o4AzFUkelBZNRzyKYf-Ld4kfcffvBu1oHq54,61
-xmlgenerator-0.2.1.dist-info/top_level.txt,sha256=jr7FbMBm8MQ6j8I_-nWzQQEseXzwSCZNXgrkWuk9P4E,13
-xmlgenerator-0.2.1.dist-info/RECORD,,