pyRegRep 13__tar.gz → 14__tar.gz

{pyregrep-13 → pyregrep-14}/PKG-INFO

@@ -1,15 +1,25 @@
 Metadata-Version: 2.4
 Name: pyRegRep
-Version: 13
-Summary: Your package description
-Author: Andrey Shapovalov
-Author-email: mt.andrey@gmail.com
+Version: 14
+Summary: Бібліотека для роботи з реєстрами та репозитаріями в Україні
+Author-email: Andrii Shapovalov <mt.andrey@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/AndreyShapovalovVN/pyRegRep
+Project-URL: Repository, https://github.com/AndreyShapovalovVN/pyRegRep.git
+Project-URL: Issues, https://github.com/AndreyShapovalovVN/pyRegRep/issues
+Keywords: registry,repositories,ukraine
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: lxml>=5.2.1
 Requires-Dist: xmltodict>=0.13.0
-Dynamic: author-email
 Dynamic: license-file
 
 # pyRegRep

{pyregrep-13 → pyregrep-14}/pyRegRep.egg-info/PKG-INFO

@@ -1,15 +1,25 @@
 Metadata-Version: 2.4
 Name: pyRegRep
-Version: 13
-Summary: Your package description
-Author: Andrey Shapovalov
-Author-email: mt.andrey@gmail.com
+Version: 14
+Summary: Бібліотека для роботи з реєстрами та репозитаріями в Україні
+Author-email: Andrii Shapovalov <mt.andrey@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/AndreyShapovalovVN/pyRegRep
+Project-URL: Repository, https://github.com/AndreyShapovalovVN/pyRegRep.git
+Project-URL: Issues, https://github.com/AndreyShapovalovVN/pyRegRep/issues
+Keywords: registry,repositories,ukraine
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: lxml>=5.2.1
 Requires-Dist: xmltodict>=0.13.0
-Dynamic: author-email
 Dynamic: license-file
 
 # pyRegRep

{pyregrep-13 → pyregrep-14}/pyRegRep.egg-info/SOURCES.txt

@@ -1,7 +1,6 @@
 LICENSE
 README.md
 pyproject.toml
-setup.py
 pyRegRep.egg-info/PKG-INFO
 pyRegRep.egg-info/SOURCES.txt
 pyRegRep.egg-info/dependency_links.txt

{pyregrep-13 → pyregrep-14}/pyRegRep4/NS.py

@@ -1,6 +1,5 @@
 """Namespace management for RIM/ebXML documents."""
 
-from typing import Dict
 
 
 class NS:
@@ -19,7 +18,7 @@ class NS:
 
     def __init__(self):
         """Initialize namespace handling."""
-        self._ns: Dict[str, str] = self.DEFAULT_NAMESPACES.copy()  # type: ignore
+        self._ns: dict[str, str] = self.DEFAULT_NAMESPACES.copy()  # type: ignore
 
     def _tname(self, prefix: str, localname: str) -> str:
         """
@@ -37,7 +36,7 @@ class NS:
 
         return f"{{{self._ns[prefix]}}}{localname}"
 
-    def _extract_namespaces(self) -> Dict[str, str]:
+    def _extract_namespaces(self) -> dict[str, str]:
         """
         Extract namespaces from the document.
         Override this method in subclasses if needed.
@@ -48,7 +47,7 @@ class NS:
         return self._ns.copy()
 
     @property
-    def ns(self) -> Dict[str, str]:
+    def ns(self) -> dict[str, str]:
         """Get the namespace mappings."""
         return self._ns.copy()
 

{pyregrep-13 → pyregrep-14}/pyRegRep4/RIMElement.py

@@ -1,7 +1,8 @@
 import datetime
 import logging
 from abc import ABC, abstractmethod
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any, cast
 
 from lxml import etree
 
@@ -33,7 +34,7 @@ class _ElementContainer(NS):
 
     @property
     def text(self) -> bytes:
-        return etree.tostring(self.element)
+        return cast(bytes, etree.tostring(self.element, encoding="utf-8"))
 
 
 class Xml(ABC, _ElementContainer):
@@ -163,7 +164,10 @@ class _InternationalStringValueType(Xml):
                     if element is not None:
                         v.append(element)
                 else:
-                    _logger.warning(f"Unsupported item type in InternationalStringValueType: {type(item)}")
+                    _logger.warning(
+                        "Unsupported item type in InternationalStringValueType: %s",
+                        type(item),
+                    )
         else:
             if isinstance(self.value, etree._Element):
                 v.append(self.value)
@@ -256,7 +260,10 @@ def get_slot(name: str, slot_type: str, value: Any) -> Xml:
 
     slot_class = slot_type_map.get(slot_type)
     if slot_class is None:
-        raise ValueError(f"Невідомий тип слота: {slot_type}. Підтримувані типи: {list(slot_type_map.keys())}")
+        supported_types = list(slot_type_map.keys())
+        raise ValueError(
+            f"Невідомий тип слота: {slot_type}. Підтримувані типи: {supported_types}"
+        )
 
     slot = slot_class(value)
     slot.name = name

pyregrep-14/pyRegRep4/RIMParsing.py

@@ -0,0 +1,377 @@
+import logging
+from enum import Enum
+from typing import Any
+
+import xmltodict
+from lxml import etree
+
+_logger = logging.getLogger(__name__)
+
+
+def serialize_any_value_type(value: Any) -> Any:
+    """Convert XML elements from AnyValueType into plain dictionaries."""
+    if isinstance(value, etree._Element):
+        try:
+            xml_bytes = etree.tostring(value, encoding="utf-8")
+            return xmltodict.parse(xml_bytes)
+        except Exception as e:
+            _logger.warning(f"Не вдалося серіалізувати AnyValueType через xmltodict: {e}")
+            return etree.tostring(value, encoding="unicode")
+    return value
+
+
+class ValueTypes(str, Enum):
+    """Типи значень у RIM документах."""
+    STRING = "StringValueType"
+    BOOLEAN = "BooleanValueType"
+    INTEGER = "IntegerValueType"
+    DATETIME = "DateTimeValueType"
+    INTERNATIONAL_STRING = "InternationalStringValueType"
+    COLLECTION = "CollectionValueType"
+    ANY = "AnyValueType"
+
+
+class ParsingError(Exception):
+    """Базовий клас для помилок парсування."""
+    pass
+
+
+class Parsing:
+    """
+    Парсер RIM/ebXML документів.
+
+    Автоматично обробляє namespace, витягує запити, винятки та об'єкти реєстру.
+
+    Attributes:
+        xml: Декодований XML як рядок
+        doc: Распарсений XML документ (etree._Element)
+        query: Розташування Query елемента у документі або None
+        exception: Розташування Exception елемента у документі або None
+        objects: Список RegistryObject елементів
+        slots: Кешований словник усіх слотів з документу
+    """
+
+    def __init__(self, doc: bytes | str):
+
+        if isinstance(doc, bytes):
+            self.xml = doc.decode("utf-8")
+        elif isinstance(doc, str):
+            self.xml = doc
+            doc = doc.encode("utf-8")  # Конвертуємо назад в bytes для lxml
+        else:
+            raise ParsingError(
+                f"Невалідний тип даних для парсування: {type(doc)}. "
+                "Очікується bytes або str."
+            )
+
+        try:
+            parser = etree.XMLParser(remove_comments=True)
+            self.doc = etree.fromstring(doc, parser)
+        except etree.XMLSyntaxError as e:
+            raise ParsingError(f"Помилка парсування XML: {e}") from e
+
+        # Обробка namespace
+        self._ns = self._extract_namespaces()
+
+        # Витягування основних елементів
+        try:
+            self.query = self.doc.find(".//query:Query", namespaces=self._ns)
+        except Exception as e:
+            _logger.warning(f"Namespace не знайдено: {e}")
+            self.query = None
+
+        try:
+            self.exception = self.doc.find(".//rs:Exception", namespaces=self._ns)
+        except Exception as e:
+            _logger.warning(f"Namespace не знайдено: {e}")
+            self.exception = None
+
+        try:
+            self.objects = self.doc.findall(".//rim:RegistryObject", namespaces=self._ns)
+        except Exception as e:
+            _logger.warning(f"Namespace не знайдено: {e}")
+            self.objects = []
+
+        # Кешований результат
+        self._slots_cache: dict[str, Any] | None = None
+        self.slots = self.__list_slots()
+
+    def _extract_namespaces(self) -> dict[str, str]:
+        """
+        Витягти всі namespace з кореневого елемента XML.
+
+        Returns:
+            Словник у форматі {префікс: URI}
+        """
+        ns = {}
+        for k, v in self.doc.nsmap.items():
+            if k is not None and v is not None:
+                ns[k] = v
+                _logger.debug(f"Знайдено namespace: {k} -> {v}")
+            else:
+                _logger.warning(f"Пропущено некоректний namespace: {k} -> {v}")
+        return ns
+
+    def __safe_add_slot(
+        self,
+        target: dict[str, tuple[str, Any]],
+        slot: etree._Element,
+        context: str,
+    ) -> None:
+        name = slot.get("name")
+        if not name:
+            return
+
+        try:
+            target[name] = self.__value(slot)
+        except ParsingError as e:
+            _logger.exception(f"Помилка парсування слота '{context}/{name}': {e}")
+
+    def __tname(self, ns: str, tag: str) -> str:
+        """
+        Побудувати повне ім'я тега з namespace.
+
+        Args:
+            ns: Префікс namespace
+            tag: Локальне ім'я тега
+
+        Returns:
+            Повне ім'я тега у форматі {namespace_uri}tag
+        """
+        if not ns or ns not in self._ns:
+            _logger.warning(f"Namespace '{ns}' не знайдено, повертаємо просто тег '{tag}'")
+            return tag
+        return f"{{{self._ns[ns]}}}{tag}"
+
+    def __extract_type(self, type_attr: str) -> str:
+        """
+        Витягти тип значення з атрибута xsi:type.
+
+        Args:
+            type_attr: Атрибут у форматі "префікс:Тип"
+
+        Returns:
+            Само значення типу без префіксу
+
+        Raises:
+            ParsingError: Якщо формат типу невалідний
+        """
+        if not type_attr:
+            raise ParsingError("Атрибут xsi:type не знайдено")
+
+        if ':' not in type_attr:
+            raise ParsingError(f"Невалідний формат типу: {type_attr}. Очікується 'префікс:Тип'")
+
+        type_value = type_attr.split(":")[1].strip()
+        if not type_value:
+            raise ParsingError(f"Тип значення не можна витягти з: {type_attr}")
+
+        return type_value
+
+    def __get_slot_value(self, slot: etree._Element) -> etree._Element:
+        if len(slot) == 0:
+            raise ParsingError(f"Слот '{slot.get('name')}' не має дочірніх елементів")
+
+        return slot[0]
+
+    def __get_slot_value_type(self, slot_value: etree._Element) -> str:
+        type_attr = slot_value.get(self.__tname("xsi", "type"), "")
+
+        try:
+            return self.__extract_type(type_attr)
+        except ParsingError as e:
+            _logger.exception(f"Помилка витягування типу для слота: {e}")
+            raise
+
+    def __parse_slot_value(self, type_: str, slot_value: etree._Element) -> Any:
+        if ValueTypes.ANY.value in type_:
+            return self.__parse_any_value(slot_value)
+
+        if ValueTypes.INTERNATIONAL_STRING.value in type_:
+            return self.__parse_international_string(slot_value)
+
+        if ValueTypes.COLLECTION.value in type_:
+            return self.__parse_collection(slot_value)
+
+        return self.__parse_simple_value(slot_value)
+
+    def __parse_any_value(self, slot_value: etree._Element) -> Any:
+        return slot_value[0] if len(slot_value) > 0 else None
+
+    def __parse_international_string(self, slot_value: etree._Element) -> list[dict[str, Any]]:
+        values: list[dict[str, Any]] = []
+
+        if len(slot_value) == 0:
+            return values
+
+        for item in slot_value[0]:
+            values.append(
+                {
+                    "lang": item.get(self.__tname("xsi", "lang")),
+                    "value": item.get("value"),
+                }
+            )
+
+        return values
+
+    def __parse_collection(self, slot_value: etree._Element) -> list[tuple[str, Any]]:
+        values = []
+
+        for item in slot_value:
+            wrapper = etree.Element("wrapper")
+            wrapper.append(item)
+            values.append(self.__value(wrapper))
+
+        return values
+
+    def __parse_simple_value(self, slot_value: etree._Element) -> Any:
+        if len(slot_value) > 0 and len(slot_value[0]) > 0:
+            return slot_value[0][0].text
+
+        if len(slot_value) > 0:
+            return slot_value[0].text
+
+        return None
+
+    def __value(self, slot: etree._Element) -> tuple[str, Any]:
+        slot_value = self.__get_slot_value(slot)
+        type_ = self.__get_slot_value_type(slot_value)
+
+        try:
+            return type_, self.__parse_slot_value(type_, slot_value)
+        except (IndexError, AttributeError) as e:
+            _logger.exception(f"Помилка обробки значення типу {type_}: {e}")
+            raise ParsingError(f"Помилка обробки значення: {e}") from e
+
+    def __process_root_element(
+        self,
+        element: etree._Element,
+        slots: dict[str, dict[str, Any]],
+    ) -> None:
+        if element.tag == self.__tname("rim", "Slot"):
+            self.__safe_add_slot(slots["doc"], element, "doc")
+            return
+
+        if element.tag == self.__tname("query", "Query"):
+            self.__process_slot_container(element, slots["query"], "query")
+            return
+
+        if element.tag == self.__tname("rs", "Exception"):
+            self.__process_slot_container(element, slots["exception"], "exception")
+            return
+
+        if element.tag == self.__tname("rim", "RegistryObjectList"):
+            self.__process_registry_object_list(element, slots["object"])
+
+    def __process_slot_container(
+        self,
+        container: etree._Element,
+        target: dict[str, Any],
+        context: str,
+    ) -> None:
+        for item in container:
+            self.__safe_add_slot(target, item, context)
+
+    def __process_registry_object_list(
+        self,
+        registry_object_list: etree._Element,
+        target: dict[str, Any],
+    ) -> None:
+        for registry_object in registry_object_list:
+            obj_data = self.__process_registry_object(registry_object)
+
+            if obj_data:
+                target.update(obj_data)
+
+    def __process_registry_object(
+        self,
+        registry_object: etree._Element,
+    ) -> dict[str, Any]:
+        obj_data: dict[str, Any] = {}
+
+        for child in registry_object:
+            if child.tag == self.__tname("rim", "Slot"):
+                self.__safe_add_slot(obj_data, child, "object")
+
+            elif child.tag == self.__tname("rim", "RepositoryItemRef"):
+                obj_data["RepositoryItemRef"] = self.__repository_item_ref(child)
+
+        return obj_data
+
+    def __repository_item_ref(self, element: etree._Element) -> dict[str, str | None]:
+        return {
+            "xlink": element.get(self.__tname("xlink", "href")),
+            "title": element.get(self.__tname("xlink", "title")),
+        }
+
+    def __list_slots(self) -> dict[str, dict[str, Any]]:
+        slots: dict[str, dict[str, Any]] = {
+            "doc": {},
+            "query": {},
+            "exception": {},
+            "object": {},
+        }
+
+        for element in self.doc:
+            try:
+                self.__process_root_element(element, slots)
+            except Exception as e:
+                _logger.exception(f"Неочікувана помилка при обробці елемента: {e}")
+
+        return slots
+
+    def __transform_serialized_value(self, data: Any, any_type: bool) -> Any:
+        if isinstance(data, list):
+            return [self.__transform_serialized_value(item, any_type) for item in data]
+
+        if isinstance(data, dict):
+            return {
+                key: self.__transform_serialized_value(value, any_type)
+                for key, value in data.items()
+            }
+
+        if not isinstance(data, tuple) or len(data) != 2:
+            return data
+
+        data_type, value = data
+        return self.__transform_value_by_type(data_type, value, any_type)
+
+    def __transform_value_by_type(
+        self,
+        data_type: str,
+        value: Any,
+        any_type: bool,
+    ) -> Any:
+        if data_type == ValueTypes.BOOLEAN.value:
+            return value.lower() == "true" if isinstance(value, str) else bool(value)
+
+        if data_type in {
+            ValueTypes.STRING.value,
+            ValueTypes.DATETIME.value,
+        }:
+            return value.strip() if isinstance(value, str) else value
+
+        if data_type == ValueTypes.INTEGER.value:
+            return int(value) if value else None
+
+        if data_type == ValueTypes.COLLECTION.value:
+            return self.__transform_serialized_value(value, any_type)
+
+        if data_type == ValueTypes.ANY.value:
+            return serialize_any_value_type(value) if any_type else value
+
+        if data_type == ValueTypes.INTERNATIONAL_STRING.value:
+            return self.__transform_serialized_value(value, any_type)
+
+        _logger.warning(f"Невідомий тип значення: {data_type}")
+        return (
+            self.__transform_serialized_value(value, any_type)
+            if isinstance(value, (list, dict))
+            else value
+        )
+
+    def serialize(self, any_type: bool = False) -> dict[str, Any]:
+        serialized = self.__transform_serialized_value(self.slots, any_type)
+        if isinstance(serialized, dict):
+            return serialized
+        raise ParsingError("Очікувався словник після серіалізації слотів")

{pyregrep-13 → pyregrep-14}/pyRegRep4/utils.py

@@ -9,7 +9,8 @@ def deep_get(data: dict[Any, Any], *keys: str, default: Any = None) -> Any:
     Args:
         data: Source dictionary.
         *keys: Sequence of keys to traverse.
-        default: Value returned when the key path is missing or the intermediate value is not a dict.
+        default: Value returned when the key path is missing or the
+            intermediate value is not a dict.
 
     Returns:
         Value by key path or "default" when the path cannot be resolved.
@@ -20,4 +21,3 @@ def deep_get(data: dict[Any, Any], *keys: str, default: Any = None) -> Any:
             return default
         current = current.get(key)
     return current if current is not None else default
-

pyregrep-14/pyproject.toml

@@ -0,0 +1,76 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyRegRep"
+version = "14"
+description = "Бібліотека для роботи з реєстрами та репозитаріями в Україні"
+authors = [
+    { name = "Andrii Shapovalov", email = "mt.andrey@gmail.com" }
+]
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+dependencies = [
+    "lxml>=5.2.1",
+    "xmltodict>=0.13.0",
+]
+keywords = ["registry", "repositories", "ukraine"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+[project.urls]
+Homepage = "https://github.com/AndreyShapovalovVN/pyRegRep"
+Repository = "https://github.com/AndreyShapovalovVN/pyRegRep.git"
+Issues = "https://github.com/AndreyShapovalovVN/pyRegRep/issues"
+
+[tool.setuptools]
+packages = ["pyRegRep4"]
+include-package-data = true
+
+[tool.pytest.ini_options]
+pythonpath = ["."]
+testpaths = ["tests"]
+addopts = "-v"
+
+[tool.coverage.run]
+source = ["pyRegRep4"]
+omit = ["*/tests/*", "*/test_*.py"]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "if __name__ == .__main__.:",
+    "raise AssertionError",
+    "raise NotImplementedError",
+]
+
+[tool.mypy]
+python_version = "3.10"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = false
+disallow_incomplete_defs = false
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "UP"]
+
+[dependency-groups]
+dev = [
+    "mypy>=1.10.0",
+    "pytest>=8.2.0",
+    "ruff>=0.4.0",
+]

{pyregrep-13 → pyregrep-14}/tests/test_get_slot_simple.py

@@ -3,14 +3,16 @@
 Simple test script to verify get_slot() functionality.
 """
 
-import sys
 import datetime
+import sys
+
 from lxml import etree
 
 # Add the project root to the path
 sys.path.insert(0, '/home/andrey/OOTS/pyRegRep')
 
-from pyRegRep4.RIMElement import get_slot, _StringValueType, _AnyValueType
+from pyRegRep4.RIMElement import _AnyValueType, _StringValueType, get_slot
+
 
 def test_basic_functionality():
     """Test basic get_slot() functionality."""

{pyregrep-13 → pyregrep-14}/tests/test_rim_element.py

@@ -8,20 +8,22 @@ Tests cover:
 """
 
 import datetime
+
 import pytest
 from lxml import etree
+
 from pyRegRep4.RIMElement import (
-    get_slot,
-    _StringValueType,
+    Classification,
+    QueryResponse,
+    RegistryObject,
+    RepositoryItemRef,
+    _AnyValueType,
     _BooleanValueType,
-    _TimeStamp,
     _CollectionValueType,
-    _AnyValueType,
     _InternationalStringValueType,
-    RegistryObject,
-    RepositoryItemRef,
-    QueryResponse,
-    Classification,
+    _StringValueType,
+    _TimeStamp,
+    get_slot,
 )
 
 

{pyregrep-13 → pyregrep-14}/tests/test_rim_parsing.py

@@ -9,11 +9,12 @@ Tests cover:
 """
 
 import inspect
+from pathlib import Path
+
 import pytest
 from lxml import etree
-from pathlib import Path
-from pyRegRep4.RIMParsing import Parsing
 
+from pyRegRep4.RIMParsing import Parsing
 
 # Test data directory
 TEST_DATA_DIR = Path(__file__).parent
@@ -53,7 +54,11 @@ class TestParsingBasics:
         assert first_request._ns is not None
         assert isinstance(first_request._ns, dict)
         # Common namespaces in RIM documents
-        assert any(ns for ns in first_request._ns.values() if "rim" in ns.lower() or "regrep" in ns.lower())
+        assert any(
+            ns
+            for ns in first_request._ns.values()
+            if "rim" in ns.lower() or "regrep" in ns.lower()
+        )
 
     def test_slots_structure(self, first_request):
         """Test that slots dictionary has expected structure."""
@@ -140,7 +145,7 @@ class TestValueTypeParsing:
         preview = doc_slots.get("PossibilityForPreview")
 
         assert preview is not None
-        type_name, value = preview
+        type_name, _ = preview
         assert "BooleanValueType" in type_name
 
     def test_international_string_value_type(self, request_doc):
@@ -194,7 +199,11 @@ class TestSerialization:
         for key, value in doc_slots.items():
             if value is not None:
                 # Should not be (type, value) tuples anymore
-                assert not (isinstance(value, tuple) and len(value) == 2 and isinstance(value[0], str))
+                assert not (
+                    isinstance(value, tuple)
+                    and len(value) == 2
+                    and isinstance(value[0], str)
+                )
 
     def test_serialize_string_value(self, request_doc):
         """Test serialization of string values."""
@@ -238,7 +247,10 @@ class TestSerialization:
     def test_serialize_any_value_type_to_dict(self, request_doc):
         """AnyValueType with any_type=True should be serialized to a plain dictionary."""
         if not _supports_any_type_argument(request_doc):
-            pytest.skip("serialize(any_type=...) is not supported in the current Parsing implementation")
+            pytest.skip(
+                "serialize(any_type=...) is not supported "
+                "in the current Parsing implementation"
+            )
 
         serialized = request_doc.serialize(any_type=True)
         evidence_provider = serialized.get("doc", {}).get("EvidenceProvider")
@@ -262,7 +274,10 @@ class TestSerialization:
     def test_serialize_collection_with_any_value_type(self, request_doc):
         """CollectionValueType with AnyValueType items (any_type=True) should serialize to dicts."""
         if not _supports_any_type_argument(request_doc):
-            pytest.skip("serialize(any_type=...) is not supported in the current Parsing implementation")
+            pytest.skip(
+                "serialize(any_type=...) is not supported "
+                "in the current Parsing implementation"
+            )
 
         serialized = request_doc.serialize(any_type=True)
         requirements = serialized.get("doc", {}).get("Requirements")
@@ -290,7 +305,6 @@ class TestMultipleFiles:
         with open(xml_file, "rb") as f:
             parsing = Parsing(f.read())
 
-        assert parsing is not None
         assert parsing.slots is not None
         assert isinstance(parsing.slots, dict)
 
@@ -329,7 +343,6 @@ class TestEdgeCases:
                     xmlns:rs="urn:oasis:names:tc:ebxml-regrep:xsd:rs:4.0">
 </query:QueryRequest>'''
         parsing = Parsing(minimal_xml)
-        assert parsing is not None
         assert isinstance(parsing.slots, dict)
 
     @pytest.fixture
@@ -375,9 +388,12 @@ class TestAnyValueTypeSerialization:
         assert isinstance(evidence_requester, etree._Element)
 
     def test_any_value_type_single_element_serialized(self, second_response_doc):
-        """Single AnyValueType element (any_type=True) should be dict with namespace-aware keys."""
+        """Single AnyValueType element (any_type=True) should be namespace-aware dict."""
         if not _supports_any_type_argument(second_response_doc):
-            pytest.skip("serialize(any_type=...) is not supported in the current Parsing implementation")
+            pytest.skip(
+                "serialize(any_type=...) is not supported "
+                "in the current Parsing implementation"
+            )
 
         serialized = second_response_doc.serialize(any_type=True)
         evidence_requester = serialized.get("doc", {}).get("EvidenceRequester")
@@ -389,7 +405,10 @@ class TestAnyValueTypeSerialization:
     def test_any_value_type_preserves_xml_structure(self, second_response_doc):
         """Serialized AnyValueType should preserve XML structure and content."""
         if not _supports_any_type_argument(second_response_doc):
-            pytest.skip("serialize(any_type=...) is not supported in the current Parsing implementation")
+            pytest.skip(
+                "serialize(any_type=...) is not supported "
+                "in the current Parsing implementation"
+            )
 
         serialized = second_response_doc.serialize(any_type=True)
         evidence_requester = serialized.get("doc", {}).get("EvidenceRequester")
@@ -405,7 +424,10 @@ class TestAnyValueTypeSerialization:
     def test_any_value_type_in_objects_section(self, second_response_doc):
         """AnyValueType in RegistryObject slots should serialize correctly."""
         if not _supports_any_type_argument(second_response_doc):
-            pytest.skip("serialize(any_type=...) is not supported in the current Parsing implementation")
+            pytest.skip(
+                "serialize(any_type=...) is not supported "
+                "in the current Parsing implementation"
+            )
 
         serialized = second_response_doc.serialize(any_type=True)
         object_slots = serialized.get("object", {})
@@ -415,9 +437,12 @@ class TestAnyValueTypeSerialization:
             assert isinstance(evidence_metadata, dict)
 
     def test_serialize_consistency_across_calls(self, second_response_doc):
-        """Multiple serialize(any_type=True) calls should produce identical results."""
+        """Multiple serialize(any_type=True) calls should return identical results."""
         if not _supports_any_type_argument(second_response_doc):
-            pytest.skip("serialize(any_type=...) is not supported in the current Parsing implementation")
+            pytest.skip(
+                "serialize(any_type=...) is not supported "
+                "in the current Parsing implementation"
+            )
 
         result1 = second_response_doc.serialize(any_type=True)
         result2 = second_response_doc.serialize(any_type=True)
@@ -427,7 +452,10 @@ class TestAnyValueTypeSerialization:
     def test_any_type_parameter_does_not_affect_other_types(self, second_response_doc):
         """Setting any_type=True should not affect serialization of other types."""
         if not _supports_any_type_argument(second_response_doc):
-            pytest.skip("serialize(any_type=...) is not supported in the current Parsing implementation")
+            pytest.skip(
+                "serialize(any_type=...) is not supported "
+                "in the current Parsing implementation"
+            )
 
         serialized_with_any = second_response_doc.serialize(any_type=True)
         serialized_without_any = second_response_doc.serialize(any_type=False)
@@ -436,4 +464,3 @@ class TestAnyValueTypeSerialization:
             for key, val in serialized_with_any.get(section, {}).items():
                 if key not in ["EvidenceRequester", "EvidenceProvider", "EvidenceMetadata"]:
                     assert key in serialized_without_any.get(section, {})
-

pyregrep-13/pyRegRep4/RIMParsing.py

@@ -1,350 +0,0 @@
-import logging
-from enum import Enum
-from typing import Any, Dict, Optional, Tuple
-
-import xmltodict
-from lxml import etree
-
-_logger = logging.getLogger(__name__)
-
-
-def serialize_any_value_type(value: Any) -> Any:
-    """Convert XML elements from AnyValueType into plain dictionaries."""
-    if isinstance(value, etree._Element):
-        try:
-            xml_bytes = etree.tostring(value, encoding="utf-8")
-            return xmltodict.parse(xml_bytes)
-        except Exception as e:
-            _logger.warning(f"Не вдалося серіалізувати AnyValueType через xmltodict: {e}")
-            return etree.tostring(value, encoding="unicode")
-    return value
-
-
-class ValueTypes(str, Enum):
-    """Типи значень у RIM документах."""
-    STRING = "StringValueType"
-    BOOLEAN = "BooleanValueType"
-    INTEGER = "IntegerValueType"
-    DATETIME = "DateTimeValueType"
-    INTERNATIONAL_STRING = "InternationalStringValueType"
-    COLLECTION = "CollectionValueType"
-    ANY = "AnyValueType"
-
-
-class ParsingError(Exception):
-    """Базовий клас для помилок парсування."""
-    pass
-
-
-class Parsing:
-    """
-    Парсер RIM/ebXML документів.
-
-    Автоматично обробляє namespace, витягує запити, винятки та об'єкти реєстру.
-
-    Attributes:
-        xml: Декодований XML як рядок
-        doc: Распарсений XML документ (etree._Element)
-        query: Розташування Query елемента у документі або None
-        exception: Розташування Exception елемента у документі або None
-        objects: Список RegistryObject елементів
-        slots: Кешований словник усіх слотів з документу
-    """
-
-    def __init__(self, doc: bytes | str):
-
-        if isinstance(doc, bytes):
-            self.xml = doc.decode("utf-8")
-        elif isinstance(doc, str):
-            self.xml = doc
-            doc = doc.encode("utf-8")  # Конвертуємо назад в bytes для lxml
-        else:
-            raise ParsingError(f"Невалідний тип даних для парсування: {type(doc)}. Очікується bytes або str.")
-
-        try:
-            parser = etree.XMLParser(remove_comments=True)
-            self.doc = etree.fromstring(doc, parser)
-        except etree.XMLSyntaxError as e:
-            raise ParsingError(f"Помилка парсування XML: {e}") from e
-
-        # Обробка namespace
-        self._ns = self._extract_namespaces()
-
-        # Витягування основних елементів
-        try:
-            self.query = self.doc.find(".//query:Query", namespaces=self._ns)
-        except Exception as e:
-            _logger.warning(f"Namespace не знайдено: {e}")
-            self.query = None
-
-        try:
-            self.exception = self.doc.find(".//rs:Exception", namespaces=self._ns)
-        except Exception as e:
-            _logger.warning(f"Namespace не знайдено: {e}")
-            self.exception = None
-
-        try:
-            self.objects = self.doc.findall(".//rim:RegistryObject", namespaces=self._ns)
-        except Exception as e:
-            _logger.warning(f"Namespace не знайдено: {e}")
-            self.objects = []
-
-        # Кешований результат
-        self._slots_cache: Optional[Dict[str, Any]] = None
-        self.slots = self.__list_slots()
-
-    def _extract_namespaces(self) -> Dict[str, str]:
-        """
-        Витягти всі namespace з кореневого елемента XML.
-
-        Returns:
-            Словник у форматі {префікс: URI}
-        """
-        ns = {}
-        for k, v in self.doc.nsmap.items():
-            if k is not None and v is not None:
-                ns[k] = v
-                _logger.debug(f"Знайдено namespace: {k} -> {v}")
-            else:
-                _logger.warning(f"Пропущено некоректний namespace: {k} -> {v}")
-        return ns
-
-    def __tname(self, ns: str, tag: str) -> str:
-        """
-        Побудувати повне ім'я тега з namespace.
-
-        Args:
-            ns: Префікс namespace
-            tag: Локальне ім'я тега
-
-        Returns:
-            Повне ім'я тега у форматі {namespace_uri}tag
-        """
-        if not ns or ns not in self._ns:
-            _logger.warning(f"Namespace '{ns}' не знайдено, повертаємо просто тег '{tag}'")
-            return tag
-        return f"{{{self._ns[ns]}}}{tag}"
-
-    def __extract_type(self, type_attr: str) -> str:
-        """
-        Витягти тип значення з атрибута xsi:type.
-
-        Args:
-            type_attr: Атрибут у форматі "префікс:Тип"
-
-        Returns:
-            Само значення типу без префіксу
-
-        Raises:
-            ParsingError: Якщо формат типу невалідний
-        """
-        if not type_attr:
-            raise ParsingError("Атрибут xsi:type не знайдено")
-
-        if ':' not in type_attr:
-            raise ParsingError(f"Невалідний формат типу: {type_attr}. Очікується 'префікс:Тип'")
-
-        type_value = type_attr.split(":")[1].strip()
-        if not type_value:
-            raise ParsingError(f"Тип значення не можна витягти з: {type_attr}")
-
-        return type_value
-
-    def __value(self, slot: etree._Element) -> Tuple[str, Any]:
-        """
-        Витягти значення зі слота з його типом.
-
-        Args:
-            slot: XML елемент слота
-
-        Returns:
-            Кортеж (тип_значення, значення)
-
-        Raises:
-            ParsingError: Якщо слот має неправильну структуру
-        """
-        if len(slot) == 0:
-            raise ParsingError(f"Слот '{slot.get('name')}' не має дочірніх елементів")
-
-        slot_value = slot[0]  # Отримати SlotValue елемент
-        type_attr = slot_value.get(self.__tname("xsi", "type"), '')
-
-        try:
-            type_ = self.__extract_type(type_attr)
-        except ParsingError as e:
-            _logger.error(f"Помилка витягування типу для слота: {e}")
-            raise
-
-        # Обробка різних типів значень
-        try:
-            if ValueTypes.ANY.value in type_:
-                return type_, slot_value[0] if len(slot_value) > 0 else None
-
-            elif ValueTypes.INTERNATIONAL_STRING.value in type_:
-                values = []
-                for item in slot_value[0]:
-                    value = {
-                        "lang": item.get(self.__tname("xsi", "lang")),
-                        "value": item.get("value"),
-                    }
-                    values.append(value)
-                return type_, values
-
-            elif ValueTypes.COLLECTION.value in type_:
-                values = []
-                for item in slot_value:
-                    wrapper = etree.Element("wrapper")
-                    wrapper.append(item)
-                    values.append(self.__value(wrapper))  # type: ignore
-                return type_, values
-
-            else:
-                # Прості типи: String, Boolean, DateTime тощо
-                if len(slot_value) > 0 and len(slot_value[0]) > 0:
-                    return type_, slot_value[0][0].text
-                elif len(slot_value) > 0:
-                    return type_, slot_value[0].text
-                else:
-                    return type_, None
-        except (IndexError, AttributeError) as e:
-            _logger.error(f"Помилка обробки значення типу {type_}: {e}")
-            raise ParsingError(f"Помилка обробки значення: {e}") from e
-
-    def __list_slots(self) -> Dict[str, Dict[str, Tuple[str, Any]]]:
-        """
-        Витягти всі слоти з документу та організувати їх за категоріями.
-
-        Returns:
-            Словник структури: {категорія: {ім'я_слота: (тип, значення)}}
-        """
-        slots: Dict[str, Dict[str, Tuple[str, Any]]] = {
-            "doc": {},
-            "query": {},
-            "exception": {},
-            "object": {}
-        }
-
-        for element in self.doc:
-            try:
-                # Слоти на рівні документу
-                if element.tag == self.__tname("rim", "Slot"):
-                    name = element.get("name")
-                    if name:
-                        try:
-                            slots["doc"][name] = self.__value(element)
-                        except ParsingError as e:
-                            _logger.error(f"Помилка парсування слота 'doc/{name}': {e}")
-
-                # Query елементи
-                elif element.tag == self.__tname("query", "Query"):
-                    for query_item in element:
-                        name = query_item.get("name")
-                        if name:
-                            try:
-                                slots["query"][name] = self.__value(query_item)
-                            except ParsingError as e:
-                                _logger.error(f"Помилка парсування слота 'query/{name}': {e}")
-
-                # Exception елементи
-                elif element.tag == self.__tname("rs", "Exception"):
-                    for exc_item in element:
-                        name = exc_item.get("name")
-                        if name:
-                            try:
-                                slots["exception"][name] = self.__value(exc_item)
-                            except ParsingError as e:
-                                _logger.error(f"Помилка парсування слота 'exception/{name}': {e}")
-
-                # RegistryObject елементи
-                elif element.tag == self.__tname("rim", "RegistryObjectList"):
-                    for registry_object in element:
-                        obj_data: Dict[str, Any] = {}
-                        for child_element in registry_object:
-                            if child_element.tag == self.__tname("rim", "Slot"):
-                                name = child_element.get("name")
-                                if name:
-                                    try:
-                                        obj_data[name] = self.__value(child_element)
-                                    except ParsingError as e:
-                                        _logger.error(f"Помилка парсування слота 'object/{name}': {e}")
-
-                            elif child_element.tag == self.__tname("rim", "RepositoryItemRef"):
-                                obj_data["RepositoryItemRef"] = {
-                                    "xlink": child_element.get(self.__tname("xlink", "href")),
-                                    "title": child_element.get(self.__tname("xlink", "title")),
-                                }
-
-                        if obj_data:
-                            slots["object"].update(obj_data)
-
-            except Exception as e:
-                _logger.error(f"Неочікувана помилка при обробці елемента: {e}")
-                continue
-
-        return slots
-
-    def serialize(self, any_type: bool = False) -> Dict[str, Any]:
-        """
-        Серіалізувати слоти, перетворюючи типізовані значення на Python об'єкти.
-
-        Перетворює:
-        - BooleanValueType -> bool
-        - StringValueType -> str
-        - DateTimeValueType -> str (ISO format)
-        - InternationalStringValueType -> list[dict]
-        - CollectionValueType -> list
-        - AnyValueType -> Element (default) або dict (якщо any_type=True)
-
-        Args:
-            any_type: Якщо True, перетворює AnyValueType елементи в dict через xmltodict.
-                     Якщо False (за замовчуванням), повертає lxml Element.
-
-        Returns:
-            Серіалізований словник без типової інформації
-        """
-
-        def transform_data(data: Any) -> Any:
-            """Рекурсивно трансформувати дані, видаляючи тип-інформацію."""
-            if isinstance(data, list):
-                return [transform_data(item) for item in data]
-
-            elif isinstance(data, dict):
-                return {k: transform_data(v) for k, v in data.items()}
-
-            elif isinstance(data, tuple) and len(data) == 2:
-                data_type, value = data
-
-                # Перетворення типів значень
-                if data_type == ValueTypes.BOOLEAN.value:
-                    if isinstance(value, str):
-                        return value.lower() == 'true'
-                    return bool(value)
-
-                elif data_type == ValueTypes.STRING.value:
-                    return value.strip() if isinstance(value, str) else value
-
-                elif data_type == ValueTypes.DATETIME.value:
-                    return value.strip() if isinstance(value, str) else value
-
-                elif data_type == ValueTypes.COLLECTION.value:
-                    return transform_data(value)
-
-                elif data_type == ValueTypes.ANY.value:
-                    if any_type:
-                        return serialize_any_value_type(value)
-                    return value
-
-                elif data_type == ValueTypes.INTERNATIONAL_STRING.value:
-                    return transform_data(value)
-
-                elif data_type == ValueTypes.INTEGER.value:
-                    return int(value) if value else None
-
-                # Невідомий тип - повернути значення як є
-                else:
-                    _logger.warning(f"Невідомий тип значення: {data_type}")
-                    return transform_data(value) if isinstance(value, (list, dict)) else value
-
-            return data
-
-        return transform_data(self.slots)

pyregrep-13/pyproject.toml

@@ -1,18 +0,0 @@
-[build-system]
-requires = ["setuptools>=61.0"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "pyRegRep"
-version = "13"
-description = "Your package description"
-authors = [{ name="Andrey Shapovalov" }]
-readme = "README.md"
-requires-python = ">=3.10"
-dependencies = [
-	"lxml>=5.2.1",
-	"xmltodict>=0.13.0",
-]
-
-[tool.pytest.ini_options]
-pythonpath = ["."]

pyregrep-13/setup.py

@@ -1,16 +0,0 @@
-from setuptools import setup, find_packages
-
-setup(
-    name="pyRegRep",
-    version="13",
-    description="Бібліотека для роботи з реєстрами та репозитаріями в Україні",
-    packages=find_packages(),
-    license="MIT",
-    author="Andrii Shapovalov",
-    author_email="mt.andrey@gmail.com",
-    include_package_data=True,
-    install_requires=[
-        "lxml>=5.2.1",
-        "xmltodict>=0.13.0",
-    ],
-)

{pyregrep-13 → pyregrep-14}/pyRegRep4/__init__.py

@@ -16,8 +16,8 @@ from pyRegRep4.RIMElement import (
     RepositoryItemRef,
     get_slot,
 )
-from pyRegRep4.utils import deep_get
 from pyRegRep4.RIMParsing import Parsing, serialize_any_value_type
+from pyRegRep4.utils import deep_get
 
 __all__ = [
     "get_slot",