pytest-jsonschema-snapshot 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

pytest_jsonschema_snapshot/__init__.py

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

pytest_jsonschema_snapshot/core.py

@@ -25,7 +25,10 @@ class SchemaShot:
         root_dir: Path,
         differ: "JsonSchemaDiff",
         callable_regex: str = "{class_method=.}",
+        format_mode: str = "on",
         update_mode: bool = False,
+        reset_mode: bool = False,
+        update_actions: dict[str, bool] = {},
         save_original: bool = False,
         debug_mode: bool = False,
         snapshot_dir_name: str = "__snapshots__",
@@ -41,7 +44,11 @@ class SchemaShot:
         self.root_dir: Path = root_dir
         self.differ: "JsonSchemaDiff" = differ
         self.callable_regex: str = callable_regex
+        self.format_mode: str = format_mode
+        # self.examples_limit: int = examples_limit
         self.update_mode: bool = update_mode
+        self.reset_mode: bool = reset_mode
+        self.update_actions: dict[str, bool] = update_actions
         self.save_original: bool = save_original
         self.debug_mode: bool = debug_mode
         self.snapshot_dir: Path = root_dir / snapshot_dir_name
@@ -104,7 +111,9 @@ class SchemaShot:
             available_to_create = not json_path.exists() or status is None
             available_to_update = status is True
 
-            if available_to_create or available_to_update:
+            if (available_to_create and self.update_actions.get("add")) or (
+                available_to_update and self.update_actions.get("update")
+            ):
                 with open(json_path, "w", encoding="utf-8") as f:
                     json.dump(data, f, indent=2, ensure_ascii=False)
 
@@ -114,7 +123,7 @@ class SchemaShot:
                     GLOBAL_STATS.add_updated(json_name)
                 else:
                     raise ValueError(f"Unexpected status: {status}")
-        elif json_path.exists():
+        elif json_path.exists() and self.update_actions.get("delete"):
             # удаляем
             json_path.unlink()
             GLOBAL_STATS.add_deleted(json_name)
@@ -135,13 +144,15 @@ class SchemaShot:
 
         real_name = self._process_name(name)
 
-        builder = JsonToSchemaConverter()
+        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)
 
-        if self.update_mode:
+        if self.update_mode or self.reset_mode:
             self._save_process_original(real_name=real_name, status=status, data=data)
 
         return status
@@ -199,11 +210,15 @@ class SchemaShot:
 
         # --- когда схемы ещё нет ---
         if not schema_exists_before:
-            if not self.update_mode:
+            if not self.update_mode and not self.reset_mode:
                 raise pytest.fail.Exception(
                     f"Schema `{name}` not found."
                     "Run the test with the --schema-update option to create it."
                 )
+            elif not self.update_actions.get("add"):
+                raise pytest.fail.Exception(
+                    f"Schema `{name}` not found and adding new schemas is disabled."
+                )
 
             with open(schema_path, "w", encoding="utf-8") as f:
                 json.dump(current_schema, f, indent=2, ensure_ascii=False)
@@ -221,13 +236,30 @@ class SchemaShot:
             if existing_schema != current_schema:  # есть отличия
                 differences = self.differ.compare(dict(existing_schema), current_schema).render()
 
-                if self.update_mode:
+                if (self.update_mode or self.reset_mode) and self.update_actions.get("update"):
                     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.\n\n{differences}")
+                    if self.reset_mode and not self.update_mode:
+                        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}")
+                    elif self.update_mode and not self.reset_mode:
+                        builder = JsonToSchemaConverter(
+                            format_mode=self.format_mode  # type: ignore[arg-type]
+                        )  # , examples=self.examples_limit)
+                        builder.add_schema(existing_schema)
+                        builder.add_schema(current_schema)
+                        merged_schema = builder.to_schema()
+
+                        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}")
+                    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:
                     GLOBAL_STATS.add_uncommitted(schema_path.name, differences)

pytest_jsonschema_snapshot/plugin.py

@@ -22,7 +22,16 @@ def pytest_addoption(parser: pytest.Parser) -> None:
     parser.addoption(
         "--schema-update",
         action="store_true",
-        help="Update or create JSON Schema files based on current data",
+        help=(
+            "Augmenting mode for updating schemas. "
+            "If something is valid for the old schema, then it is valid "
+            "for the new one (and vice versa)."
+        ),
+    )
+    parser.addoption(
+        "--schema-reset",
+        action="store_true",
+        help="New schema does not take into account the old one during update.",
     )
     parser.addoption(
         "--save-original",
@@ -35,6 +44,22 @@ def pytest_addoption(parser: pytest.Parser) -> None:
         help="Show internal exception stack (stops hiding them)",
     )
 
+    parser.addoption(
+        "--without-delete",
+        action="store_true",
+        help="Disable deleting unused schemas",
+    )
+    parser.addoption(
+        "--without-update",
+        action="store_true",
+        help="Disable updating schemas",
+    )
+    parser.addoption(
+        "--without-add",
+        action="store_true",
+        help="Disable adding new schemas",
+    )
+
     parser.addini(
         "jsss_dir",
         default="__snapshots__",
@@ -45,6 +70,11 @@ def pytest_addoption(parser: pytest.Parser) -> None:
         default="{class_method=.}",
         help="Regex for saving callable part of path",
     )
+    parser.addini(
+        "jsss_format_mode",
+        default="on",
+        help="Format mode: 'on' (annotate and validate), 'safe' (annotate), 'off' (disable)",
+    )
 
 
 @pytest.fixture(scope="function")
@@ -56,13 +86,26 @@ def schemashot(request: pytest.FixtureRequest) -> Generator[SchemaShot, None, No
     # Получаем путь к тестовому файлу
     test_path = Path(request.node.path if hasattr(request.node, "path") else request.node.fspath)
     root_dir = test_path.parent
+
     update_mode = bool(request.config.getoption("--schema-update"))
+    reset_mode = bool(request.config.getoption("--schema-reset"))
+    if update_mode and reset_mode:
+        raise ValueError("Options --schema-update and --schema-reset are mutually exclusive.")
+
     save_original = bool(request.config.getoption("--save-original"))
     debug_mode = bool(request.config.getoption("--jsss-debug"))
 
+    actions = {
+        "delete": not request.config.getoption("--without-delete"),
+        "update": not request.config.getoption("--without-update"),
+        "add": not request.config.getoption("--without-add"),
+    }
+
     # Получаем настраиваемую директорию для схем
     schema_dir_name = str(request.config.getini("jsss_dir"))
     callable_regex = str(request.config.getini("jsss_callable_regex"))
+    format_mode = str(request.config.getini("jsss_format_mode")).lower()
+    # examples_limit = int(request.config.getini("jsss_examples_limit"))
 
     differ = JsonSchemaDiff(
         ConfigMaker.make(),
@@ -77,7 +120,11 @@ def schemashot(request: pytest.FixtureRequest) -> Generator[SchemaShot, None, No
             root_dir,
             differ,
             callable_regex,
+            format_mode,
+            # examples_limit,
             update_mode,
+            reset_mode,
+            actions,
             save_original,
             debug_mode,
             schema_dir_name,
@@ -108,11 +155,21 @@ def pytest_terminal_summary(terminalreporter: pytest.TerminalReporter, exitstatu
     """
     # Выполняем cleanup перед показом summary
     if _schema_managers:
-        update_mode = bool(terminalreporter.config.getoption("--schema-update"))
+
+        def get_opt(opt: str) -> bool:
+            return bool(terminalreporter.config.getoption(opt))
+
+        update_mode = get_opt("--schema-update")
+
+        actions = {
+            "delete": not get_opt("--without-delete"),
+            "update": not get_opt("--without-update"),
+            "add": not get_opt("--without-add"),
+        }
 
         # Вызываем метод очистки неиспользованных схем для каждого экземпляра
         for _root_dir, manager in _schema_managers.items():
-            cleanup_unused_schemas(manager, update_mode, GLOBAL_STATS)
+            cleanup_unused_schemas(manager, update_mode, actions, GLOBAL_STATS)
 
     # Используем новую функцию для вывода статистики
     update_mode = bool(terminalreporter.config.getoption("--schema-update"))
@@ -120,7 +177,10 @@ def pytest_terminal_summary(terminalreporter: pytest.TerminalReporter, exitstatu
 
 
 def cleanup_unused_schemas(
-    manager: SchemaShot, update_mode: bool, stats: Optional[SchemaStats] = None
+    manager: SchemaShot,
+    update_mode: bool,
+    actions: dict[str, bool],
+    stats: Optional[SchemaStats] = None,
 ) -> None:
     """
     Deletes unused schemas in update mode and collects statistics.
@@ -140,7 +200,7 @@ def cleanup_unused_schemas(
 
     for schema_file in all_schemas:
         if schema_file.name not in manager.used_schemas:
-            if update_mode:
+            if update_mode and actions.get("delete"):
                 try:
                     # Удаляем саму схему
                     schema_file.unlink()

pytest_jsonschema_snapshot/tools/genson_addon/to_schema_converter.py

@@ -1,119 +1,100 @@
-"""
-Module for advanced JSON Schema generation with format detection support.
+"""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, Optional
+from typing import Any, Dict, Literal
 
 from genson import SchemaBuilder  # type: ignore[import-untyped]
 
 from .format_detector import FormatDetector
 
-
-class FormatAwareString:
-    """Strategy for strings with format detection"""
-
-    def __init__(self) -> None:
-        self.formats: set = set()
-
-    def match_schema(self, obj: Any) -> bool:
-        """Checks if the object matches this strategy"""
-        return isinstance(obj, str)
-
-    def match_object(self, obj: Any) -> bool:
-        """Checks if the object matches this strategy"""
-        return isinstance(obj, str)
-
-    def add_object(self, obj: Any) -> None:
-        """Adds an object for analysis"""
-        if isinstance(obj, str):
-            detected_format = FormatDetector.detect_format(obj)
-            if detected_format:
-                self.formats.add(detected_format)
-
-    def to_schema(self) -> Dict[str, Any]:
-        """Generates a schema for the string"""
-        schema = {"type": "string"}
-
-        # If all strings have the same format, add it to the schema
-        if len(self.formats) == 1:
-            schema["format"] = list(self.formats)[0]
-
-        return schema
+_FormatMode = Literal["on", "off", "safe"]
 
 
 class JsonToSchemaConverter(SchemaBuilder):
-    """Extended SchemaBuilder with format detection support"""
-
-    def __init__(self, schema_uri: Optional[str] = None):
-        if schema_uri:
-            super().__init__(schema_uri)
-        else:
-            super().__init__()
-        self._format_cache: Dict[str, set] = {}
-
+    """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:
-        """
-        Adds an object to the builder with format detection.
-
-        Args:
-            obj: Object to add
-            path: Path to the object (for internal use)
-        """
-        # Call the parent method first
         super().add_object(obj)
+        if self._format_mode != "off":
+            self._collect_formats(obj, path)
 
-        # Then process the formats
-        self._process_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,
+                    },
+                )
 
-    def _process_formats(self, obj: Any, path: str) -> None:
-        """Recursively processes the object for format detection"""
+        return schema
+
+    # ------------------------------------------------------------------
+    # Internals
+    # ------------------------------------------------------------------
+    def _collect_formats(self, obj: Any, path: str) -> None:
         if isinstance(obj, str):
-            # Detect the format of the string
-            detected_format = FormatDetector.detect_format(obj)
-            if detected_format:
-                if path not in self._format_cache:
-                    self._format_cache[path] = set()
-                self._format_cache[path].add(detected_format)
+            fmt = FormatDetector.detect_format(obj)
+            if fmt:
+                self._format_cache.setdefault(path, set()).add(fmt)
         elif isinstance(obj, dict):
-            # Recursively process the dictionary
-            for key, value in obj.items():
-                self._process_formats(value, f"{path}.{key}")
+            for k, v in obj.items():
+                self._collect_formats(v, f"{path}.{k}")
         elif isinstance(obj, (list, tuple)):
-            # Recursively process the list
             for i, item in enumerate(obj):
-                self._process_formats(item, f"{path}[{i}]")
-
-    def to_schema(self) -> Dict:
-        """Generates the schema with format detection"""
-        # Get the base schema
-        schema = dict(super().to_schema())
-
-        # Add the formats
-        self._add_formats_to_schema(schema, "root")
-
-        return schema
-
-    def _add_formats_to_schema(self, schema: Dict[str, Any], path: str) -> None:
-        """Recursively adds formats to the schema"""
-        if schema.get("type") == "string":
-            # If there is only one format for this path
-            if path in self._format_cache and len(self._format_cache[path]) == 1:
-                schema["format"] = list(self._format_cache[path])[0]
-
-        elif schema.get("type") == "object" and "properties" in schema:
-            # Recursively process the object properties
-            for prop_name, prop_schema in schema["properties"].items():
-                self._add_formats_to_schema(prop_schema, f"{path}.{prop_name}")
-
-        elif schema.get("type") == "array" and "items" in schema:
-            # Process the array items
-            if isinstance(schema["items"], dict):
-                self._add_formats_to_schema(schema["items"], f"{path}[0]")
-            elif isinstance(schema["items"], list):
-                for i, item_schema in enumerate(schema["items"]):
-                    self._add_formats_to_schema(item_schema, f"{path}[{i}]")
-
+                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:
-            # Process the anyOf schemas
-            for i, sub_schema in enumerate(schema["anyOf"]):
-                self._add_formats_to_schema(sub_schema, path)
+            for subschema in schema["anyOf"]:
+                self._inject_formats(subschema, path)

{pytest_jsonschema_snapshot-0.2.0.dist-info → pytest_jsonschema_snapshot-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-jsonschema-snapshot
-Version: 0.2.0
+Version: 0.2.1
 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
@@ -117,12 +117,12 @@ pip install pytest-jsonschema-snapshot
       )
   ```
 
-2. On first run, generate schemas with the `--schema-update` flag
+2. On first run, generate schemas with the `--schema-update` or `--schema-reset` (what is the difference? see the documentation) flag
    ```bash
    pytest --schema-update --save-original
    ```
 
-   **--save-original**: save the original data on which the validation was performed. Saving occurs when `--schema-update`, if you run the schema update without this attribute, the old original data will be deleted without saving new ones.
+   **--save-original**: save the original data on which the validation was performed. Saving occurs when `--schema-update` or `--schema-reset`, if you run the schema update without this attribute, the old original data will be deleted without saving new ones.
 
 3. On subsequent runs, tests will validate data against saved schemas
    ```bash

{pytest_jsonschema_snapshot-0.2.0.dist-info → pytest_jsonschema_snapshot-0.2.1.dist-info}/RECORD

@@ -1,15 +1,15 @@
-pytest_jsonschema_snapshot/__init__.py,sha256=_DWc4aUyqwppG2WR6nwnao8wmt2PYdkPmf9jjoYSSLM,385
-pytest_jsonschema_snapshot/core.py,sha256=DoFQtphueFy-lkVuZ6tNJ146QqPskpLZm2EDcy5HDDw,9498
-pytest_jsonschema_snapshot/plugin.py,sha256=_NUXU7RdKeVltzSnYkru5MSrbm7auHeepuCEpJ2FN3Q,6829
+pytest_jsonschema_snapshot/__init__.py,sha256=A3cUmyPftYWT68KRDu3V6WNGuIKdkqCtxYQS3eyPwbk,385
+pytest_jsonschema_snapshot/core.py,sha256=951wNZ6BiVToaK8l-l5hgj8WPePBTSK5bDZqFOAZztg,11399
+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=XGGzHY0ytMFOkFpnqNAK1DpV9iI0_fZPWrVvHFNFL3g,7943
 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=cMjvTydaD1xLnGpby1Mlp3LVzZgZLXdCCUKYcU4y4TU,4364
-pytest_jsonschema_snapshot-0.2.0.dist-info/METADATA,sha256=hJWbUjB-N1dwj8XeAOmnycurpDKdBXJPwLkYijVn6qw,7569
-pytest_jsonschema_snapshot-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pytest_jsonschema_snapshot-0.2.0.dist-info/entry_points.txt,sha256=eJ1x4TMmhcc8YtM7IoCsUJO4-rLeTrGy8tPgkrojjKs,58
-pytest_jsonschema_snapshot-0.2.0.dist-info/licenses/LICENSE,sha256=1HRFdSzlJ4BtHv6U7tZun3iCArjbCnm5NUowE9hZpNs,1071
-pytest_jsonschema_snapshot-0.2.0.dist-info/RECORD,,
+pytest_jsonschema_snapshot/tools/genson_addon/to_schema_converter.py,sha256=UdQIkZhMrTJNHwI1B1dv3aEwx41B1B_lLyr4KWiUpNY,4168
+pytest_jsonschema_snapshot-0.2.1.dist-info/METADATA,sha256=sKa-GvRU2__0rk-bOFpPhaIT7_gnZvkJX15AWRvkkl4,7657
+pytest_jsonschema_snapshot-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pytest_jsonschema_snapshot-0.2.1.dist-info/entry_points.txt,sha256=eJ1x4TMmhcc8YtM7IoCsUJO4-rLeTrGy8tPgkrojjKs,58
+pytest_jsonschema_snapshot-0.2.1.dist-info/licenses/LICENSE,sha256=1HRFdSzlJ4BtHv6U7tZun3iCArjbCnm5NUowE9hZpNs,1071
+pytest_jsonschema_snapshot-0.2.1.dist-info/RECORD,,