pytest-jsonschema-snapshot 0.2.4__py3-none-any.whl → 0.2.6__py3-none-any.whl

pytest_jsonschema_snapshot/__init__.py

@@ -8,5 +8,5 @@ pytest-typed-schema-shot
 
 from .core import SchemaShot
 
-__version__ = "0.2.4"
+__version__ = "0.2.6"
 __all__ = ["SchemaShot"]

pytest_jsonschema_snapshot/core.py

@@ -5,7 +5,7 @@ Core logic of the plugin.
 import json
 import logging
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, Optional, Set
+from typing import TYPE_CHECKING, Any, Callable, Literal, Optional
 
 import pathvalidate
 
@@ -13,10 +13,17 @@ if TYPE_CHECKING:
     from jsonschema_diff import JsonSchemaDiff
 
 import pytest
+from genschema import Converter, PseudoArrayHandler
+from genschema.comparators import (
+    DeleteElement,
+    FormatComparator,
+    RequiredComparator,
+    SchemaVersionComparator,
+)
 from jsonschema import FormatChecker, ValidationError, validate
 
 from .stats import GLOBAL_STATS
-from .tools import JsonToSchemaConverter, NameMaker
+from .tools import NameMaker
 
 
 class SchemaShot:
@@ -52,7 +59,18 @@ class SchemaShot:
         self.save_original: bool = save_original
         self.debug_mode: bool = debug_mode
         self.snapshot_dir: Path = root_dir / snapshot_dir_name
-        self.used_schemas: Set[str] = set()
+        self.used_schemas: set[str] = set()
+
+        self.conv = Converter(
+            pseudo_handler=PseudoArrayHandler(),
+            base_of="anyOf",
+        )
+        self.conv.register(FormatComparator())
+        self.conv.register(RequiredComparator())
+        # self.conv.register(EmptyComparator())
+        self.conv.register(SchemaVersionComparator())
+        self.conv.register(DeleteElement())
+        self.conv.register(DeleteElement("isPseudoArray"))
 
         self.logger = logging.getLogger(__name__)
         # добавляем вывод в stderr
@@ -144,13 +162,7 @@ class SchemaShot:
 
         real_name = self._process_name(name)
 
-        builder = JsonToSchemaConverter(
-            format_mode=self.format_mode  # type: ignore[arg-type]
-        )  # , examples=self.examples_limit)
-        builder.add_object(data)
-        current_schema = builder.to_schema()
-
-        real_name, status = self._base_match(data, current_schema, real_name)
+        real_name, status = self._base_match(data, data, "json", real_name)
 
         if self.update_mode or self.reset_mode:
             self._save_process_original(real_name=real_name, status=status, data=data)
@@ -175,7 +187,7 @@ class SchemaShot:
 
         real_name = self._process_name(name)
 
-        real_name, status = self._base_match(data, schema, real_name)
+        real_name, status = self._base_match(data, schema, "schema", real_name)
 
         if self.update_mode and data is not None:
             self._save_process_original(real_name=real_name, status=status, data=data)
@@ -185,7 +197,8 @@ class SchemaShot:
     def _base_match(
         self,
         data: Optional[dict],
-        current_schema: dict,
+        current_data: dict,
+        type_data: Literal["json", "schema"],
         name: str,
     ) -> tuple[str, Optional[bool]]:
         """
@@ -208,6 +221,16 @@ class SchemaShot:
         # --- состояние ДО проверки ---
         schema_exists_before = schema_path.exists()
 
+        def make_schema(value: dict | list, type: Literal["json", "schema"]) -> dict:
+            if type_data == "schema":
+                return current_data
+            elif type_data == "json":
+                self.conv.clear_data()
+                self.conv.add_json(current_data)
+                return self.conv.run()
+            else:
+                raise ValueError("Not correct type argument")
+
         # --- когда схемы ещё нет ---
         if not schema_exists_before:
             if not self.update_mode and not self.reset_mode:
@@ -220,6 +243,8 @@ class SchemaShot:
                     f"Schema `{name}` not found and adding new schemas is disabled."
                 )
 
+            current_schema = make_schema(current_data, type_data)
+
             with open(schema_path, "w", encoding="utf-8") as f:
                 json.dump(current_schema, f, indent=2, ensure_ascii=False)
 
@@ -233,45 +258,59 @@ class SchemaShot:
             # --- схема уже была: сравнение и валидация --------------------------------
             schema_updated = False
 
-            def merge_schemas(old: dict, new: dict) -> dict:
-                builder = JsonToSchemaConverter(
-                    format_mode=self.format_mode  # type: ignore[arg-type]
-                )  # , examples=self.examples_limit)
-                builder.add_schema(old)
-                builder.add_schema(new)
-                return builder.to_schema()
+            def merge_schemas(
+                old: dict, new: dict | list, type_data: Literal["json", "schema"]
+            ) -> dict:
+                self.conv.clear_data()
+                self.conv.add_schema(old)
+                if type_data == "schema":
+                    self.conv.add_schema(dict(new))
+                elif type_data == "json":
+                    self.conv.add_json(new)
+                else:
+                    raise ValueError("Not correct type argument")
+                result = self.conv.run()
+                return result
 
-            if existing_schema != current_schema:  # есть отличия
+            if (
+                type_data == "json" or existing_schema != current_data
+            ):  # есть отличия или могут быть
                 if (self.update_mode or self.reset_mode) and self.update_actions.get("update"):
                     # обновляем файл
                     if self.reset_mode and not self.update_mode:
+                        current_schema = make_schema(current_data, type_data)
+
                         differences = self.differ.compare(
                             dict(existing_schema), current_schema
                         ).render()
-                        GLOBAL_STATS.add_updated(schema_path.name, differences)
+                        diff_count = self.differ.property.calc_diff()
+                        if any(diff_count[key] > 0 for key in diff_count if key != "UNKNOWN"):
+                            GLOBAL_STATS.add_updated(schema_path.name, differences)
 
-                        with open(schema_path, "w", encoding="utf-8") as f:
-                            json.dump(current_schema, f, indent=2, ensure_ascii=False)
-                        self.logger.warning(f"Schema `{name}` updated (reset).\n\n{differences}")
+                            with open(schema_path, "w", encoding="utf-8") as f:
+                                json.dump(current_schema, f, indent=2, ensure_ascii=False)
+                            self.logger.warning(f"Schema `{name}` reseted.\n\n{differences}")
                     elif self.update_mode and not self.reset_mode:
-                        merged_schema = merge_schemas(existing_schema, current_schema)
+                        merged_schema = merge_schemas(existing_schema, current_data, type_data)
 
                         differences = self.differ.compare(
                             dict(existing_schema), merged_schema
                         ).render()
-                        GLOBAL_STATS.add_updated(schema_path.name, differences)
+                        diff_count = self.differ.property.calc_diff()
+                        if any(diff_count[key] > 0 for key in diff_count if key != "UNKNOWN"):
+                            GLOBAL_STATS.add_updated(schema_path.name, differences)
 
-                        with open(schema_path, "w", encoding="utf-8") as f:
-                            json.dump(merged_schema, f, indent=2, ensure_ascii=False)
+                            with open(schema_path, "w", encoding="utf-8") as f:
+                                json.dump(merged_schema, f, indent=2, ensure_ascii=False)
 
-                        self.logger.warning(f"Schema `{name}` updated (update).\n\n{differences}")
+                            self.logger.warning(f"Schema `{name}` updated.\n\n{differences}")
                     else:  # both update_mode and reset_mode are True
                         raise ValueError(
                             "Both update_mode and reset_mode cannot be True at the same time."
                         )
                     schema_updated = True
                 elif data is not None:
-                    merged_schema = merge_schemas(existing_schema, current_schema)
+                    merged_schema = merge_schemas(existing_schema, current_data, type_data)
 
                     differences = self.differ.compare(dict(existing_schema), merged_schema).render()
                     GLOBAL_STATS.add_uncommitted(schema_path.name, differences)
@@ -287,7 +326,7 @@ class SchemaShot:
                         pytest.fail(
                             f"\n\n{differences}\n\nValidation error in `{name}`: {e.message}"
                         )
-            elif data is not None:
+            elif data is not None and type_data == "schema":
                 # схемы совпали – всё равно валидируем на случай формальных ошибок
                 try:
                     validate(
@@ -296,7 +335,7 @@ class SchemaShot:
                         format_checker=FormatChecker(),
                     )
                 except ValidationError as e:
-                    merged_schema = merge_schemas(existing_schema, current_schema)
+                    merged_schema = merge_schemas(existing_schema, current_data, type_data)
 
                     differences = self.differ.compare(dict(existing_schema), merged_schema).render()
                     pytest.fail(f"\n\n{differences}\n\nValidation error in `{name}`: {e.message}")

pytest_jsonschema_snapshot/tools/__init__.py

@@ -1,4 +1,3 @@
-from .genson_addon import JsonToSchemaConverter
 from .name_maker import NameMaker
 
-__all__ = ["JsonToSchemaConverter", "NameMaker"]
+__all__ = ["NameMaker"]

{pytest_jsonschema_snapshot-0.2.4.dist-info → pytest_jsonschema_snapshot-0.2.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-jsonschema-snapshot
-Version: 0.2.4
+Version: 0.2.6
 Summary: Pytest plugin for automatic JSON Schema generation and validation from examples
 Project-URL: Homepage, https://miskler.github.io/pytest-jsonschema-snapshot/basic/quick_start.html
 Project-URL: Repository, https://github.com/Miskler/pytest-jsonschema-snapshot
@@ -22,7 +22,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Utilities
 Requires-Python: >=3.10
-Requires-Dist: genson
+Requires-Dist: genschema
 Requires-Dist: jsonschema
 Requires-Dist: jsonschema-diff
 Requires-Dist: pathvalidate

pytest_jsonschema_snapshot-0.2.6.dist-info/RECORD

@@ -0,0 +1,12 @@
+pytest_jsonschema_snapshot/__init__.py,sha256=9iA0WeeAywctgadSMJXWRwTkwUnidnkw11x_OjlZxTM,385
+pytest_jsonschema_snapshot/core.py,sha256=4zcUHHzPNEusPDHCCXSO7mAMS8mGygtnKaRwqSmQizA,13626
+pytest_jsonschema_snapshot/plugin.py,sha256=nvAfxtLSX_B5FzaWu7DfsiWRxFjxDvnQNNOhkRrRnbw,8677
+pytest_jsonschema_snapshot/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytest_jsonschema_snapshot/stats.py,sha256=BfhfMoSkRq6Q8BwhVfrpcFl5TP9OzpgpLwnKf1Kslkw,9593
+pytest_jsonschema_snapshot/tools/__init__.py,sha256=WeD2EVrQpKIoFW1s43QAqsJmartqZ3Irwckt814P1bs,59
+pytest_jsonschema_snapshot/tools/name_maker.py,sha256=tqss8NCGSo2aQX_-RkCJzy3NJx_TDA-xrn8qsblecf0,5799
+pytest_jsonschema_snapshot-0.2.6.dist-info/METADATA,sha256=ev3dFAmfD66Q7epmri2Nqj1C4VDKpA8yFhEk15yemGY,7798
+pytest_jsonschema_snapshot-0.2.6.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+pytest_jsonschema_snapshot-0.2.6.dist-info/entry_points.txt,sha256=eJ1x4TMmhcc8YtM7IoCsUJO4-rLeTrGy8tPgkrojjKs,58
+pytest_jsonschema_snapshot-0.2.6.dist-info/licenses/LICENSE,sha256=1HRFdSzlJ4BtHv6U7tZun3iCArjbCnm5NUowE9hZpNs,1071
+pytest_jsonschema_snapshot-0.2.6.dist-info/RECORD,,

{pytest_jsonschema_snapshot-0.2.4.dist-info → pytest_jsonschema_snapshot-0.2.6.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

pytest_jsonschema_snapshot/tools/genson_addon/__init__.py

@@ -1,3 +0,0 @@
-from .to_schema_converter import JsonToSchemaConverter
-
-__all__ = ["JsonToSchemaConverter"]

pytest_jsonschema_snapshot/tools/genson_addon/format_detector.py

@@ -1,52 +0,0 @@
-import re
-from typing import Optional
-
-
-class FormatDetector:
-    """Class for detecting string formats"""
-
-    # Regular expressions for various formats
-    EMAIL_PATTERN = re.compile(r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$")
-    UUID_PATTERN = re.compile(
-        r"^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$",
-        re.I,
-    )
-    DATE_PATTERN = re.compile(r"^\d{4}-\d{2}-\d{2}$")
-    DATETIME_PATTERN = re.compile(
-        r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$"
-    )
-    URI_PATTERN = re.compile(r"^https?://[^\s/$.?#].[^\s]*$", re.I)
-    IPV4_PATTERN = re.compile(
-        r"^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}"
-        r"(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$"
-    )
-
-    @classmethod
-    def detect_format(cls, value: str) -> Optional[str]:
-        """
-        Detects the format of a string.
-
-        Args:
-            value: The string to analyze
-
-        Returns:
-            The name of the format or None if the format is not defined
-        """
-        if not isinstance(value, str) or not value:
-            return None
-
-        # Check formats from more specific to less specific
-        if cls.EMAIL_PATTERN.match(value):
-            return "email"
-        elif cls.UUID_PATTERN.match(value):
-            return "uuid"
-        elif cls.DATETIME_PATTERN.match(value):
-            return "date-time"
-        elif cls.DATE_PATTERN.match(value):
-            return "date"
-        elif cls.URI_PATTERN.match(value):
-            return "uri"
-        elif cls.IPV4_PATTERN.match(value):
-            return "ipv4"
-
-        return None

pytest_jsonschema_snapshot/tools/genson_addon/to_schema_converter.py

@@ -1,100 +0,0 @@
-"""Json → Schema with optional format handling.
-
-`format_mode` options
----------------------
-* ``"on"``   – detect formats and let validators assert them (default).
-* ``"off"``  – ignore formats entirely.
-* ``"safe"`` – keep the annotations but embed a ``$vocabulary`` block that
-                **disables** the draft‑2020‑12 *format‑assertion* vocabulary.
-                This makes every ``format`` purely informational, regardless
-                of validator settings.
-"""
-
-from typing import Any, Dict, Literal
-
-from genson import SchemaBuilder  # type: ignore[import-untyped]
-
-from .format_detector import FormatDetector
-
-_FormatMode = Literal["on", "off", "safe"]
-
-
-class JsonToSchemaConverter(SchemaBuilder):
-    """A thin wrapper around :class:`genson.SchemaBuilder`."""
-
-    # ------------------------------------------------------------------
-    # Construction
-    # ------------------------------------------------------------------
-    def __init__(
-        self,
-        schema_uri: str = "https://json-schema.org/draft/2020-12/schema",
-        *,
-        format_mode: _FormatMode = "on",
-    ):
-        super().__init__(schema_uri) if schema_uri else super().__init__()
-        if format_mode not in {"on", "off", "safe"}:
-            raise ValueError("format_mode must be 'on', 'off', or 'safe'.")
-        self._format_mode: _FormatMode = format_mode
-        self._format_cache: Dict[str, set[str]] = {}
-
-    # ------------------------------------------------------------------
-    # Public API (overrides)
-    # ------------------------------------------------------------------
-    def add_object(self, obj: Any, path: str = "root") -> None:
-        super().add_object(obj)
-        if self._format_mode != "off":
-            self._collect_formats(obj, path)
-
-    def to_schema(self) -> Dict[str, Any]:
-        schema = dict(super().to_schema())  # shallow‑copy
-
-        if self._format_mode != "off":
-            self._inject_formats(schema, "root")
-
-            if self._format_mode == "safe":
-                schema.setdefault(
-                    "$vocabulary",
-                    {
-                        "https://json-schema.org/draft/2020-12/vocab/core": True,
-                        "https://json-schema.org/draft/2020-12/vocab/applicator": True,
-                        "https://json-schema.org/draft/2020-12/vocab/format-annotation": True,
-                        "https://json-schema.org/draft/2020-12/vocab/format-assertion": False,
-                    },
-                )
-
-        return schema
-
-    # ------------------------------------------------------------------
-    # Internals
-    # ------------------------------------------------------------------
-    def _collect_formats(self, obj: Any, path: str) -> None:
-        if isinstance(obj, str):
-            fmt = FormatDetector.detect_format(obj)
-            if fmt:
-                self._format_cache.setdefault(path, set()).add(fmt)
-        elif isinstance(obj, dict):
-            for k, v in obj.items():
-                self._collect_formats(v, f"{path}.{k}")
-        elif isinstance(obj, (list, tuple)):
-            for i, item in enumerate(obj):
-                self._collect_formats(item, f"{path}[{i}]")
-
-    def _inject_formats(self, schema: Dict[str, Any], path: str) -> None:
-        t = schema.get("type")
-        if t == "string":
-            fmts = self._format_cache.get(path)
-            if fmts and len(fmts) == 1:
-                schema["format"] = next(iter(fmts))
-        elif t == "object" and "properties" in schema:
-            for name, subschema in schema["properties"].items():
-                self._inject_formats(subschema, f"{path}.{name}")
-        elif t == "array" and "items" in schema:
-            items_schema = schema["items"]
-            if isinstance(items_schema, dict):
-                self._inject_formats(items_schema, f"{path}[0]")
-            else:
-                for idx, subschema in enumerate(items_schema):
-                    self._inject_formats(subschema, f"{path}[{idx}]")
-        elif "anyOf" in schema:
-            for subschema in schema["anyOf"]:
-                self._inject_formats(subschema, path)

pytest_jsonschema_snapshot-0.2.4.dist-info/RECORD

@@ -1,15 +0,0 @@
-pytest_jsonschema_snapshot/__init__.py,sha256=rUBgKVh7nCLEwfO0XZS-TewnM5eTXpBEI7NaC5p4qLg,385
-pytest_jsonschema_snapshot/core.py,sha256=CoL_W-u6o3N7XDwv-MbePJiZaGX0LtGS6BLbj9MHROU,11995
-pytest_jsonschema_snapshot/plugin.py,sha256=nvAfxtLSX_B5FzaWu7DfsiWRxFjxDvnQNNOhkRrRnbw,8677
-pytest_jsonschema_snapshot/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pytest_jsonschema_snapshot/stats.py,sha256=BfhfMoSkRq6Q8BwhVfrpcFl5TP9OzpgpLwnKf1Kslkw,9593
-pytest_jsonschema_snapshot/tools/__init__.py,sha256=WMS6PdgMABBfTRhPGuoUOXB-R2PcqcadwH8pG1C6MFU,132
-pytest_jsonschema_snapshot/tools/name_maker.py,sha256=tqss8NCGSo2aQX_-RkCJzy3NJx_TDA-xrn8qsblecf0,5799
-pytest_jsonschema_snapshot/tools/genson_addon/__init__.py,sha256=nANkqHTaWTZPwBDztsnQvObHUZLSeHenJS--oWfep8c,92
-pytest_jsonschema_snapshot/tools/genson_addon/format_detector.py,sha256=Wc5pB_xstyr4OtjwJ2qqmV62xET63cN7Nb0gxkrYyW0,1636
-pytest_jsonschema_snapshot/tools/genson_addon/to_schema_converter.py,sha256=UdQIkZhMrTJNHwI1B1dv3aEwx41B1B_lLyr4KWiUpNY,4168
-pytest_jsonschema_snapshot-0.2.4.dist-info/METADATA,sha256=iiGeO3N83BH1griTvads-RUawss1rw_9NIlFEdK6mkM,7795
-pytest_jsonschema_snapshot-0.2.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pytest_jsonschema_snapshot-0.2.4.dist-info/entry_points.txt,sha256=eJ1x4TMmhcc8YtM7IoCsUJO4-rLeTrGy8tPgkrojjKs,58
-pytest_jsonschema_snapshot-0.2.4.dist-info/licenses/LICENSE,sha256=1HRFdSzlJ4BtHv6U7tZun3iCArjbCnm5NUowE9hZpNs,1071
-pytest_jsonschema_snapshot-0.2.4.dist-info/RECORD,,