xmlgenerator 0.2.0__py3-none-any.whl → 0.3.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

@@ -12,6 +12,7 @@ from xmlgenerator.randomization import Randomizer
 from xmlgenerator.substitution import Substitutor
 from xmlgenerator.validation import XmlValidator
 
+# TODO конфигурация ограничений - occurs
 # TODO Generator - обработка стандартных xsd типов
 # TODO кастомные переменные для локального контекста
 # TODO валидация по Schematron
@@ -42,14 +43,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.debug('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)

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,5 @@
 import logging
-import re
 
-import rstr
 import xmlschema
 from lxml import etree
 from xmlschema.validators import XsdComplexType, XsdAtomicRestriction, XsdTotalDigitsFacet, XsdElement, \
@@ -21,53 +19,56 @@ class XmlGenerator:
         self.substitutor = substitutor
 
     def generate_xml(self, xsd_schema: xmlschema.XMLSchema, local_config: GeneratorConfig) -> etree.Element:
+        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: etree.Element, xsd_element, local_config: GeneratorConfig) -> None:
         # 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() > local_config.randomization.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
+                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_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()
 
@@ -76,9 +77,9 @@ class XmlGenerator:
 
             group_min_occurs = getattr(xsd_element, 'min_occurs', None)
             group_max_occurs = getattr(xsd_element, 'max_occurs', None)
-            group_min_occurs = group_min_occurs if group_min_occurs is not None else 0
+            group_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 = rnd.randint(group_min_occurs, group_max_occurs)
+            group_occurs = self.randomizer.integer(group_min_occurs, group_max_occurs)
 
             if model == 'all':
                 for _ in range(group_occurs):
@@ -87,13 +88,13 @@ class XmlGenerator:
 
                         element_min_occurs = getattr(xsd_child_element_type, 'min_occurs', None)
                         element_max_occurs = getattr(xsd_child_element_type, 'max_occurs', None)
-                        element_min_occurs = element_min_occurs if element_min_occurs is not None else 0
+                        element_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 = rnd.randint(element_min_occurs, element_max_occurs)
+                        element_occurs = self.randomizer.integer(element_min_occurs, element_max_occurs)
 
                         for _ in range(element_occurs):
                             xml_child_element = etree.SubElement(xml_element, xsd_child_element_type.name)
-                            self._add_elements(xml_child_element, xsd_child_element_type, local_config)
+                            self._add_elements(xml_tree, xml_child_element, xsd_child_element_type, local_config)
                 return
 
             elif model == 'sequence':
@@ -103,22 +104,22 @@ class XmlGenerator:
 
                         element_min_occurs = getattr(xsd_child_element_type, 'min_occurs', None)
                         element_max_occurs = getattr(xsd_child_element_type, 'max_occurs', None)
-                        element_min_occurs = element_min_occurs if element_min_occurs is not None else 0
+                        element_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 = rnd.randint(element_min_occurs, element_max_occurs)
+                        element_occurs = self.randomizer.integer(element_min_occurs, element_max_occurs)
 
                         if isinstance(xsd_child_element_type, XsdElement):
                             for _ in range(element_occurs):
                                 xml_child_element = etree.SubElement(xml_element, xsd_child_element_type.name)
-                                self._add_elements(xml_child_element, xsd_child_element_type, local_config)
+                                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)
@@ -126,17 +127,17 @@ class XmlGenerator:
 
             elif model == 'choice':
                 for _ in range(group_occurs):
-                    xsd_child_element_type = rnd.choice(xsd_element)
+                    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
+                    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 = rnd.randint(element_min_occurs, element_max_occurs)
+                    element_occurs = self.randomizer.integer(element_min_occurs, element_max_occurs)
 
                     for _ in range(element_occurs):
                         xml_child_element = etree.SubElement(xml_element, xsd_child_element_type.name)
-                        self._add_elements(xml_child_element, xsd_child_element_type, local_config)
+                        self._add_elements(xml_tree, xml_child_element, xsd_child_element_type, local_config)
                 return
 
             else:
@@ -156,79 +157,92 @@ 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 = 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}")
+
+            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
 
         # -------------------------------------------------------------------------------------------------------------
         # Проверяем базовый тип
@@ -240,7 +254,7 @@ 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,
+    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
@@ -250,9 +264,11 @@ class XmlGenerator:
             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(target_name, patterns, min_length, max_length)
+                return self._generate_string(patterns, min_length, max_length)
             case 'boolean':
                 return self._generate_boolean()
             case 'integer':
@@ -294,93 +310,98 @@ class XmlGenerator:
             case _:
                 raise RuntimeError(type_id)
 
-    def _generate_string(self, target_name, patterns, min_length, max_length):
-        rnd = self.randomizer.rnd
+    def _generate_string(self, patterns, min_length, max_length):
         if patterns is not None:
             # Генерация строки по regex
-            random_pattern = rnd.choice(patterns)
-            xeger = rstr.xeger(random_pattern.attrib['value'])
-            xeger = re.sub(r'\s', ' ', xeger)
-            if min_length > -1 and len(xeger) < min_length:
-                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'])
+        return self.randomizer.any(['true', 'false'])
 
     def _generate_integer(self, total_digits, min_value, max_value):
-        rnd = self.randomizer.rnd
         if total_digits:
             min_value = 10 ** (total_digits - 1)
             max_value = (10 ** total_digits) - 1
-        rnd_int = rnd.randint(min_value, max_value)
+        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)
+        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
 
-        rnd_int = rnd.randint(min_value, max_value)
-        return f"{int(rnd_int / 100)}.{rnd_int % 100:02}"
+        # 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}"
 
     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)
+        return self._generate_double(min_value, max_value)
 
     def _generate_double(self, min_value, max_value):
-        return self._generate_float(min_value, max_value)
+        return self._generate_decimal(None, 2, min_value, max_value)
 
     def _generate_duration(self):
         raise RuntimeError("not yet implemented")
 
     def _generate_datetime(self):
-        raise RuntimeError("not yet implemented")
+        random_datetime = self.randomizer.random_datetime()
+        formatted = random_datetime.isoformat()
+        return formatted
 
     def _generate_date(self):
-        raise RuntimeError("not yet implemented")
+        random_date = self.randomizer.random_date()
+        formatted = random_date.isoformat()
+        return formatted
 
     def _generate_time(self):
-        raise RuntimeError("not yet implemented")
+        random_time = self.randomizer.random_time()
+        formatted = random_time.isoformat()
+        return formatted
 
     def _generate_gyearmonth(self):
-        raise RuntimeError("not yet implemented")
+        random_date = self.randomizer.random_date()
+        formatted = random_date.strftime('%Y-%m')
+        return formatted
 
     def _generate_gyear(self):
-        rnd = self.randomizer.rnd
-        return rnd.randint(2000, 2050)
+        return str(self.randomizer.integer(2000, 2050))
 
     def _generate_gmonthday(self):
-        raise RuntimeError("not yet implemented")
+        random_date = self.randomizer.random_date()
+        formatted = random_date.strftime('--%m-%d')
+        return formatted
 
     def _generate_gday(self):
-        raise RuntimeError("not yet implemented")
+        random_date = self.randomizer.random_date()
+        formatted = random_date.strftime('---%d')
+        return formatted
 
     def _generate_gmonth(self):
-        raise RuntimeError("not yet implemented")
+        random_date = self.randomizer.random_date()
+        formatted = random_date.strftime('--%m--')
+        return formatted
 
     def _generate_hex_binary(self):
         raise RuntimeError("not yet implemented")
@@ -396,3 +417,40 @@ class XmlGenerator:
 
     def _generate_notation(self):
         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
+        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):
+    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 config_max is not None:
+        new_max = min(fact_max, config_max)
+        if new_max >= fact_min:
+            fact_max = new_max
+
+    return fact_min, fact_max

xmlgenerator/randomization.py

@@ -1,50 +1,140 @@
 import logging
 import random
+import re
 import string
 import sys
-from datetime import datetime, timedelta
+from datetime import datetime, date, time, timedelta
+from decimal import Decimal
 
+import rstr
 from faker import Faker
 
 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)
-
-    def ascii_string(self, min_length=-1, max_length=-1):
-        min_length = min_length if min_length and min_length > -1 else 1
-        max_length = max_length if max_length and max_length >= min_length else 20
-        if max_length > 50:
-            max_length = 50
-        length = self.rnd.randint(min_length, max_length)
-        # Генерация случайной строки из букв латиницы
-        letters = string.ascii_letters  # Все буквы латиницы (a-z, A-Z)
-        return ''.join(self.rnd.choice(letters) for _ in range(length))
-
-    def random_date(self, start_date: str, end_date: str) -> datetime:
-        # Преобразуем строки в объекты datetime
+        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):
+        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):
+        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:
+        start = date.fromisoformat(start_date)
+        end = date.fromisoformat(end_date)
+
+        delta = (end - start).days
+        random_days = self._rnd.randint(0, delta)
+        return start + timedelta(days=random_days)
+
+    def random_time(self, start_time: str = '00:00:00', end_time: str = '23:59:59') -> time:
+        start = time.fromisoformat(start_time)
+        end = time.fromisoformat(end_time)
+
+        random_h = self._rnd.randint(start.hour, end.hour)
+        random_m = self._rnd.randint(start.minute, end.minute)
+        random_s = self._rnd.randint(start.second, end.second)
+
+        return time(hour=random_h, minute=random_m, second=random_s)
+
+    def random_datetime(self, start_date: str = '1990-01-01', end_date: str = '2025-12-31') -> datetime:
         start = datetime.strptime(start_date, "%Y-%m-%d")
         end = datetime.strptime(end_date, "%Y-%m-%d")
 
-        # Вычисляем разницу в днях между начальной и конечной датой
         delta = (end - start).days
+        random_days = self._rnd.randint(0, delta)
+        return start + timedelta(days=random_days)
 
-        # Генерируем случайное количество дней в пределах delta
-        random_days = self.rnd.randint(0, delta)
+    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()
 
-        # Добавляем случайное количество дней к начальной дате
-        return start + timedelta(days=random_days)
+    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

@@ -1,64 +1,53 @@
 import logging
 import re
-import uuid
-
-import rstr
 
 from xmlgenerator.randomization import Randomizer
 
 __all__ = ['Substitutor']
 
-_pattern = re.compile(pattern=r'\{\{\s*(?:(?P<function>\S*?)(?:\(\s*(?P<argument>[^)]*)\s*\))?\s*(?:\|\s*(?P<modifier>.*?))?)?\s*}}')
+_pattern = re.compile(
+    r'\{\{\s*(?:(?P<function>\S*?)(?:\(\s*(?P<argument>[^)]*)\s*\))?\s*(?:\|\s*(?P<modifier>.*?))?)?\s*}}')
 
 logger = logging.getLogger(__name__)
 
+
 class Substitutor:
     def __init__(self, randomizer: Randomizer):
-        fake = randomizer.fake
         self.randomizer = randomizer
         self._local_context = {}
         self._global_context = {}
         self.providers_dict = {
-            # Функции локального контекста
-            "source_filename": lambda: self._local_context["source_filename"],
-            "source_extracted": lambda: self._local_context["source_extracted"],
-            "output_filename": lambda: self.get_output_filename(),
-
-            'uuid': lambda: str(uuid.uuid4()),
-            "regex": lambda a: rstr.xeger(a),
-            "number": self._rand_int,
-            "date": self._rand_date,
-
-            "last_name": fake.last_name_male,
-            "first_name": fake.first_name_male,
-            "middle_name": fake.middle_name_male,
-            'address_text': fake.address,
-            'administrative_unit': fake.administrative_unit,
-            'house_number': fake.building_number,
-            'city_name': fake.city_name,
-            'postcode': fake.postcode,
-            'company_name': fake.company,
-            'bank_name': fake.bank,
-            'phone_number': fake.phone_number,
-            'inn_fl': fake.individuals_inn,
-            'inn_ul': fake.businesses_inn,
-            'ogrn_ip': fake.individuals_ogrn,
-            'ogrn_fl': fake.businesses_ogrn,
-            'kpp': fake.kpp,
-            'snils_formatted': randomizer.snils_formatted,
+            # 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_int(self, a):
-        args = str(a).split(sep=",")
-        return str(self.randomizer.rnd.randint(int(args[0]), int(args[1])))
-
-    def _rand_date(self, a):
-        args = str(a).split(sep=",")
-        date_from = args[0].strip(' ').strip("'").strip('"')
-        date_until = args[1].strip(' ').strip("'").strip('"')
-        random_date = self.randomizer.random_date(date_from, date_until)
-        return random_date.strftime('%Y%m%d') # TODO externalize pattern
-
     def reset_context(self, xsd_filename, config_local):
         self._local_context.clear()
         self._local_context["source_filename"] = xsd_filename
@@ -105,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:
@@ -126,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.0.dist-info → xmlgenerator-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xmlgenerator
-Version: 0.2.0
+Version: 0.3.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
@@ -247,6 +248,7 @@ In the `value_override` sections, you can specify either a string value or speci
 | `output_filename`                  | String described by the `output_filename_template` configuration parameter                                 |
 | `uuid`                             | Random UUIDv4                                                                                              |
 | `regex("pattern")`                 | Random string value matching the specified regular expression                                              |
+| `any('A', "B", C)`                 | Random value from enumeration                                                                              |
 | `number(A, B)`                     | Random number between A and B                                                                              |
 | `date("2010-01-01", "2025-01-01")` | Random date within the specified range                                                                     |
 | `last_name`                        | Last Name                                                                                                  |

xmlgenerator-0.3.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=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,,

xmlgenerator-0.2.0.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=FW1wyWRLY9LFFWFTV0XNycFWMfkXP2jwfcfIapzFGUA,3511
-xmlgenerator/configuration.py,sha256=DiYUpNCjkerjr73yD209q8FJwGWgipbwWXuLkt25rQM,5903
-xmlgenerator/generator.py,sha256=aAXGyiqzkU5eWiOaixMs9sPvm9EZZjQVZBdQvqtyB_A,18306
-xmlgenerator/randomization.py,sha256=cPnUWrvylIw2GH1FAW2SvyqdQQJDcoU8AgEmakPfB-I,1993
-xmlgenerator/substitution.py,sha256=p0j5QXhNHBJPlDJAQ33dV8wlnWVdO05cOvh9ggP9uFY,5277
-xmlgenerator/validation.py,sha256=uCJjS5YmRDlAp9C-5Rd4E2Brh6_3WOG2-dSGxDiaH14,2023
-xmlgenerator-0.2.0.dist-info/licenses/LICENSE,sha256=QlXK8O3UcoAYUYwVJNgB9MSM7O94ogNo_1hd9GzznUQ,1070
-xmlgenerator-0.2.0.dist-info/METADATA,sha256=rLtz6c0Oosz79qqZvR5A7l5ZBjcnHJr2m6wWLn327CY,12653
-xmlgenerator-0.2.0.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-xmlgenerator-0.2.0.dist-info/entry_points.txt,sha256=ly9hKr3o4AzFUkelBZNRzyKYf-Ld4kfcffvBu1oHq54,61
-xmlgenerator-0.2.0.dist-info/top_level.txt,sha256=jr7FbMBm8MQ6j8I_-nWzQQEseXzwSCZNXgrkWuk9P4E,13
-xmlgenerator-0.2.0.dist-info/RECORD,,