pytest-jsonschema-snapshot 0.2.0__tar.gz → 0.2.2__tar.gz

{pytest_jsonschema_snapshot-0.2.0 → pytest_jsonschema_snapshot-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-jsonschema-snapshot
-Version: 0.2.0
+Version: 0.2.2
 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 → pytest_jsonschema_snapshot-0.2.2}/README.md

@@ -72,12 +72,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 → pytest_jsonschema_snapshot-0.2.2}/docs/source/basic/quick_start.rst

@@ -19,6 +19,7 @@ Choose the option that best suits your project:
     [pytest]
     jsss_dir = __snapshots__               # where to put the schemas
     jsss_callable_regex = {class_method=.} # rule for the callable part
+    jsss_format_mode = on
 
 .. code-block:: python
 
@@ -26,6 +27,7 @@ Choose the option that best suits your project:
     [tool.pytest.ini_options]
     jsss_dir = "__snapshots__"
     jsss_callable_regex = "{class_method=.}"
+    jsss_format_mode = "on"
 
 .. code-block:: ini
 
@@ -33,9 +35,11 @@ Choose the option that best suits your project:
     [tool:pytest]
     jsss_dir = __snapshots__
     jsss_callable_regex = {class_method=.}
+    jsss_format_mode = on
 
 * **jsss_dir**: the name of the folder where the library will save the schemas/originals *(always in the same directory as the test that called it)*.
 * **jsss_callable_regex**: the rule for interpreting the callable name.
+* **jsss_format_mode**: "on" (annotate and validate), "safe" (annotate), "off" (disable).
 
 Next, you can use the fixture in your tests:
 --------------------------------------------
@@ -84,8 +88,15 @@ Run
 
 * **--jsss-debug**: by default, the library hides its part of the call stack when raising. This is convenient for debugging your tests, but if the problem is in PJSSS itself - you can pass.
 * **--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.
-* **--schema-update**: update the schema - without this attribute, the library will only report changes in the schemas and fail the tests, with it, the tests (and the originals, if requested) will be updated.
 
+Modes of operation
+* **--schema-update**: when updating **merges** two schemas. Works by principle: "what is valid for the old one, is valid for the new one, and vice versa"
+* **--schema-reset**: when updating **replaces** the old schema with the new one.
+
+Disabling update mechanisms
+* **--without-delete**: disables deletion of old schemas
+* **--without-update**: disables updating of existing schemas
+* **--without-add**: disables adding new schemas
 
 .. code-block:: console
 

{pytest_jsonschema_snapshot-0.2.0 → pytest_jsonschema_snapshot-0.2.2}/pytest_jsonschema_snapshot/__init__.py

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

{pytest_jsonschema_snapshot-0.2.0 → pytest_jsonschema_snapshot-0.2.2}/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)
@@ -219,17 +234,43 @@ class SchemaShot:
             schema_updated = False
 
             if existing_schema != current_schema:  # есть отличия
-                differences = self.differ.compare(dict(existing_schema), current_schema).render()
-
-                if self.update_mode:
-                    GLOBAL_STATS.add_updated(schema_path.name, differences)
-
+                if (self.update_mode or self.reset_mode) and self.update_actions.get("update"):
                     # обновляем файл
-                    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:
+                        differences = self.differ.compare(
+                            dict(existing_schema), current_schema
+                        ).render()
+                        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}")
+                    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()
+
+                        differences = self.differ.compare(
+                            dict(existing_schema), merged_schema
+                        ).render()
+                        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)
+
+                        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:
+                    differences = self.differ.compare(
+                        dict(existing_schema), current_schema
+                    ).render()
                     GLOBAL_STATS.add_uncommitted(schema_path.name, differences)
 
                     # только валидируем по старой схеме

{pytest_jsonschema_snapshot-0.2.0 → pytest_jsonschema_snapshot-0.2.2}/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-0.2.2/pytest_jsonschema_snapshot/tools/genson_addon/to_schema_converter.py

@@ -0,0 +1,100 @@
+"""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.2/tests/tools/genson_addon/test_format_safe.py

@@ -0,0 +1,82 @@
+"""Pytest suite for ``JsonToSchemaConverter`` using generic ``jsonschema.validate``.
+
+We use two JSON samples (``SOURCE`` and ``SOURCE_INVALID``) to check that
+*format* handling behaves as intended under three modes.
+
+Expectation matrix
+==================  =================  =========================
+format_mode          call to validate   Expected result
+==================  =================  =========================
+"on"                 validate + FC      ValidationError raised
+"safe"               validate           passes OK
+"off"                validate           passes OK
+==================  =================  =========================
+Where **FC** = ``FormatChecker``.
+
+Why this matters?
+-----------------
+*User requested*: «должно проходить на обычном validate».  Therefore we
+avoid draft‑specific classes like ``Draft202012Validator`` and rely on
+``jsonschema.validate`` selecting a validator based on the ``$schema``
+keyword embedded by *genson* (currently `http://json-schema.org/schema#`).
+
+In python‑jsonschema, *format* assertions only run when a
+``FormatChecker`` is provided, regardless of the *format-assertion*
+vocabulary.  Hence, supplying ``FormatChecker`` only in **on** mode gives
+us the desired behaviour.
+"""
+
+from __future__ import annotations
+
+import jsonschema
+import pytest
+
+from pytest_jsonschema_snapshot.tools import JsonToSchemaConverter
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+SOURCE = {
+    "email": "alice@example.com",
+    "website": "https://example.com",
+}
+
+SOURCE_INVALID = {
+    "email": "not-an-email",
+    "website": "notaurl",
+}
+
+PARAMS = [
+    ("on", False, True),  # должен упасть (ValidationError)
+    ("safe", True, True),  # должен пройти
+    ("off", True, False),  # должен пройти
+]
+
+
+# ---------------------------------------------------------------------------
+# Tests
+# ---------------------------------------------------------------------------
+@pytest.mark.parametrize("mode, should_pass, have_formats", PARAMS)
+def test_format_handling(mode: str, should_pass: bool, have_formats: bool) -> None:
+    """Validate *SOURCE_INVALID* against schema generated from *SOURCE*."""
+
+    # 1. Generate schema
+    conv = JsonToSchemaConverter(format_mode=mode)
+    conv.add_object(SOURCE)
+    schema = conv.to_schema()
+
+    # 2. Prepare kwargs for jsonschema.validate
+    kwargs: dict[str, object] = {}
+    if mode == "on":
+        kwargs["format_checker"] = jsonschema.FormatChecker()
+
+    # 3. Validate and assert outcome
+    if should_pass:
+        jsonschema.validate(SOURCE_INVALID, schema, **kwargs)
+    else:
+        with pytest.raises(jsonschema.ValidationError):
+            jsonschema.validate(SOURCE_INVALID, schema, **kwargs)
+
+    # 4. Ensure presence/absence of "format" matches the mode
+    has_format = schema["properties"]["email"].get("format") is not None
+    assert has_format == have_formats

{pytest_jsonschema_snapshot-0.2.0 → pytest_jsonschema_snapshot-0.2.2}/tests/usage/__snapshots__/TestDataClass.get_data.first.schema.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "http://json-schema.org/schema#",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {
     "обязательная": {

{pytest_jsonschema_snapshot-0.2.0 → pytest_jsonschema_snapshot-0.2.2}/tests/usage/__snapshots__/TestDataClass.get_data.schema.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "http://json-schema.org/schema#",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {
     "обязательная": {

{pytest_jsonschema_snapshot-0.2.0 → pytest_jsonschema_snapshot-0.2.2}/tests/usage/__snapshots__/array_formats_test.schema.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "http://json-schema.org/schema#",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {
     "emails": {

{pytest_jsonschema_snapshot-0.2.0 → pytest_jsonschema_snapshot-0.2.2}/tests/usage/__snapshots__/date_test.schema.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "http://json-schema.org/schema#",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {
     "birth_date": {

{pytest_jsonschema_snapshot-0.2.0 → pytest_jsonschema_snapshot-0.2.2}/tests/usage/__snapshots__/datetime_test.schema.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "http://json-schema.org/schema#",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {
     "created_at": {

{pytest_jsonschema_snapshot-0.2.0 → pytest_jsonschema_snapshot-0.2.2}/tests/usage/__snapshots__/email_test.schema.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "http://json-schema.org/schema#",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {
     "user_email": {

{pytest_jsonschema_snapshot-0.2.0 → pytest_jsonschema_snapshot-0.2.2}/tests/usage/__snapshots__/get_data.first.schema.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "http://json-schema.org/schema#",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {
     "обязательная": {

{pytest_jsonschema_snapshot-0.2.0 → pytest_jsonschema_snapshot-0.2.2}/tests/usage/__snapshots__/get_data.schema.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "http://json-schema.org/schema#",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {
     "обязательная": {

{pytest_jsonschema_snapshot-0.2.0 → pytest_jsonschema_snapshot-0.2.2}/tests/usage/__snapshots__/ipv4_test.schema.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "http://json-schema.org/schema#",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {
     "server_ip": {

{pytest_jsonschema_snapshot-0.2.0 → pytest_jsonschema_snapshot-0.2.2}/tests/usage/__snapshots__/mixed_formats_test.schema.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "http://json-schema.org/schema#",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {
     "id": {

{pytest_jsonschema_snapshot-0.2.0 → pytest_jsonschema_snapshot-0.2.2}/tests/usage/__snapshots__/regular_strings_test.schema.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "http://json-schema.org/schema#",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {
     "name": {

{pytest_jsonschema_snapshot-0.2.0 → pytest_jsonschema_snapshot-0.2.2}/tests/usage/__snapshots__/some_schema.schema.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "http://json-schema.org/schema#",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {
     "обязательная": {

{pytest_jsonschema_snapshot-0.2.0 → pytest_jsonschema_snapshot-0.2.2}/tests/usage/__snapshots__/strict_email_validation_test.schema.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "http://json-schema.org/schema#",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {
     "user_email": {

{pytest_jsonschema_snapshot-0.2.0 → pytest_jsonschema_snapshot-0.2.2}/tests/usage/__snapshots__/uri_test.schema.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "http://json-schema.org/schema#",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {
     "website": {

{pytest_jsonschema_snapshot-0.2.0 → pytest_jsonschema_snapshot-0.2.2}/tests/usage/__snapshots__/uuid_test.schema.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "http://json-schema.org/schema#",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {
     "id": {

{pytest_jsonschema_snapshot-0.2.0 → pytest_jsonschema_snapshot-0.2.2}/tests/usage/test_multiple_schema_creation.py

@@ -5,8 +5,10 @@ import pytest
 
 def test_multiple_schema_creation(schemashot, pytestconfig):
     """Ensure multiple schemas can be created sequentially."""
-    if not pytestconfig.getoption("--schema-update"):
-        pytest.skip("requires --schema-update")
+    if not pytestconfig.getoption("--schema-reset") and not pytestconfig.getoption(
+        "--schema-update"
+    ):
+        pytest.skip("requires --schema-reset or --schema-update")
 
     snapshot_dir = Path(__file__).parent / "__snapshots__"
     names = ["multi_schema_one", "multi_schema_two", "multi_schema_three"]

pytest_jsonschema_snapshot-0.2.0/pytest_jsonschema_snapshot/tools/genson_addon/to_schema_converter.py

@@ -1,119 +0,0 @@
-"""
-Module for advanced JSON Schema generation with format detection support.
-"""
-
-from typing import Any, Dict, Optional
-
-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
-
-
-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] = {}
-
-    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)
-
-        # Then process the formats
-        self._process_formats(obj, path)
-
-    def _process_formats(self, obj: Any, path: str) -> None:
-        """Recursively processes the object for format detection"""
-        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)
-        elif isinstance(obj, dict):
-            # Recursively process the dictionary
-            for key, value in obj.items():
-                self._process_formats(value, f"{path}.{key}")
-        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}]")
-
-        elif "anyOf" in schema:
-            # Process the anyOf schemas
-            for i, sub_schema in enumerate(schema["anyOf"]):
-                self._add_formats_to_schema(sub_schema, path)