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

pytest_jsonschema_snapshot/__init__.py

@@ -0,0 +1,12 @@
+"""
+pytest-typed-schema-shot
+========================
+
+Плагин для pytest, который автоматически генерирует JSON Schema
+на основе примеров данных и проверяет соответствие данных сохраненным схемам.
+"""
+
+from .core import SchemaShot
+
+__version__ = "0.2.0"
+__all__ = ["SchemaShot"]

pytest_jsonschema_snapshot/core.py

@@ -0,0 +1,260 @@
+"""
+Core logic of the plugin.
+"""
+
+import json
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Callable, Optional, Set
+
+import pathvalidate
+
+if TYPE_CHECKING:
+    from jsonschema_diff import JsonSchemaDiff
+
+import pytest
+from jsonschema import FormatChecker, ValidationError, validate
+
+from .stats import GLOBAL_STATS
+from .tools import JsonToSchemaConverter, NameMaker
+
+
+class SchemaShot:
+    def __init__(
+        self,
+        root_dir: Path,
+        differ: "JsonSchemaDiff",
+        callable_regex: str = "{class_method=.}",
+        update_mode: bool = False,
+        save_original: bool = False,
+        debug_mode: bool = False,
+        snapshot_dir_name: str = "__snapshots__",
+    ):
+        """
+        Initializes SchemaShot.
+
+        Args:
+            root_dir: Project root directory
+            update_mode: Update mode (--schema-update)
+            snapshot_dir_name: Name of the directory for snapshots
+        """
+        self.root_dir: Path = root_dir
+        self.differ: "JsonSchemaDiff" = differ
+        self.callable_regex: str = callable_regex
+        self.update_mode: bool = update_mode
+        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.logger = logging.getLogger(__name__)
+        # добавляем вывод в stderr
+        handler = logging.StreamHandler()
+        handler.setFormatter(logging.Formatter("%(levelname)s %(name)s: %(message)s"))
+        self.logger.addHandler(handler)
+        # и поднимаем уровень, чтобы INFO/DEBUG прошли через handler
+        self.logger.setLevel(logging.INFO)
+
+        # Создаем директорию для снэпшотов, если её нет
+        if not self.snapshot_dir.exists():
+            self.snapshot_dir.mkdir(parents=True)
+
+    def _process_name(self, name: str | int | Callable | list[str | int | Callable]) -> str:
+        """
+        1. Converts callable to string
+        2. Checks for validity
+
+        Returns:
+            str
+        Raises:
+            ValueError
+        """
+
+        __tracebackhide__ = not self.debug_mode  # прячем из стека pytest
+
+        def process_name_part(part: str | int | Callable) -> str:
+            if callable(part):
+                return NameMaker.format(part, self.callable_regex)
+            else:
+                return str(part)
+
+        if isinstance(name, (list, tuple)):
+            name = ".".join([process_name_part(part) for part in name])
+        else:
+            name = process_name_part(name)
+
+        if not isinstance(name, str) or not name:
+            raise ValueError("Schema name must be a non-empty string")
+
+        try:
+            # auto подберёт правила под текущую ОС
+            pathvalidate.validate_filename(
+                name, platform="auto"
+            )  # allow_reserved=False по умолчанию
+        except ValidationError as e:
+            raise ValueError(f"Invalid schema name: {e}") from None
+
+        return name
+
+    def _save_process_original(self, real_name: str, status: Optional[bool], data: dict) -> None:
+        json_name = f"{real_name}.json"
+        json_path = self.snapshot_dir / json_name
+
+        if self.save_original:
+            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:
+                with open(json_path, "w", encoding="utf-8") as f:
+                    json.dump(data, f, indent=2, ensure_ascii=False)
+
+                if available_to_create:
+                    GLOBAL_STATS.add_created(json_name)
+                elif available_to_update:
+                    GLOBAL_STATS.add_updated(json_name)
+                else:
+                    raise ValueError(f"Unexpected status: {status}")
+        elif json_path.exists():
+            # удаляем
+            json_path.unlink()
+            GLOBAL_STATS.add_deleted(json_name)
+
+    def assert_json_match(
+        self,
+        data: dict,
+        name: str | int | Callable | list[str | int | Callable],
+    ) -> Optional[bool]:
+        """
+        Asserts for JSON, converts it to schema and then compares.
+
+        Returns:
+            True  – the schema has been updated,
+            False – the schema has not changed,
+            None  – a new schema has been created.
+        """
+
+        real_name = self._process_name(name)
+
+        builder = JsonToSchemaConverter()
+        builder.add_object(data)
+        current_schema = builder.to_schema()
+
+        real_name, status = self._base_match(data, current_schema, real_name)
+
+        if self.update_mode:
+            self._save_process_original(real_name=real_name, status=status, data=data)
+
+        return status
+
+    def assert_schema_match(
+        self,
+        schema: dict[str, Any],
+        name: str | int | Callable | list[str | int | Callable],
+        *,
+        data: Optional[dict] = None,
+    ) -> Optional[bool]:
+        """
+        Accepts a JSON-schema directly and compares it immediately.
+
+        Returns:
+            True  – the schema has been updated,
+            False – the schema has not changed,
+            None  – a new schema has been created.
+        """
+
+        real_name = self._process_name(name)
+
+        real_name, status = self._base_match(data, schema, real_name)
+
+        if self.update_mode and data is not None:
+            self._save_process_original(real_name=real_name, status=status, data=data)
+
+        return status
+
+    def _base_match(
+        self,
+        data: Optional[dict],
+        current_schema: dict,
+        name: str,
+    ) -> tuple[str, Optional[bool]]:
+        """
+        Checks if data matches the JSON schema, creates/updates it if needed,
+        and writes statistics to GLOBAL_STATS.
+
+        Returns:
+            True  – the schema has been updated,
+            False – the schema has not changed,
+            None  – a new schema has been created.
+        """
+        __tracebackhide__ = not self.debug_mode  # прячем из стека pytest
+
+        # Проверка имени
+        name = self._process_name(name)
+
+        schema_path = self.snapshot_dir / f"{name}.schema.json"
+        self.used_schemas.add(schema_path.name)
+
+        # --- состояние ДО проверки ---
+        schema_exists_before = schema_path.exists()
+
+        # --- когда схемы ещё нет ---
+        if not schema_exists_before:
+            if not self.update_mode:
+                raise pytest.fail.Exception(
+                    f"Schema `{name}` not found."
+                    "Run the test with the --schema-update option to create it."
+                )
+
+            with open(schema_path, "w", encoding="utf-8") as f:
+                json.dump(current_schema, f, indent=2, ensure_ascii=False)
+
+            self.logger.info(f"New schema `{name}` has been created.")
+            GLOBAL_STATS.add_created(schema_path.name)  # статистика «создана»
+            return name, None
+        else:
+            with open(schema_path, "r", encoding="utf-8") as f:
+                existing_schema = json.load(f)
+
+            # --- схема уже была: сравнение и валидация --------------------------------
+            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)
+
+                    # обновляем файл
+                    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}")
+                    schema_updated = True
+                elif data is not None:
+                    GLOBAL_STATS.add_uncommitted(schema_path.name, differences)
+
+                    # только валидируем по старой схеме
+                    try:
+                        validate(
+                            instance=data,
+                            schema=existing_schema,
+                            format_checker=FormatChecker(),
+                        )
+                    except ValidationError as e:
+                        pytest.fail(
+                            f"\n\n{differences}\n\nValidation error in `{name}`: {e.message}"
+                        )
+            elif data is not None:
+                # схемы совпали – всё равно валидируем на случай формальных ошибок
+                try:
+                    validate(
+                        instance=data,
+                        schema=existing_schema,
+                        format_checker=FormatChecker(),
+                    )
+                except ValidationError as e:
+                    differences = self.differ.compare(
+                        dict(existing_schema), current_schema
+                    ).render()
+                    pytest.fail(f"\n\n{differences}\n\nValidation error in `{name}`: {e.message}")
+
+            return name, schema_updated

pytest_jsonschema_snapshot/plugin.py

@@ -0,0 +1,180 @@
+from pathlib import Path
+from typing import Dict, Generator, Optional
+
+import pytest
+from jsonschema_diff import ConfigMaker, JsonSchemaDiff
+from jsonschema_diff.color import HighlighterPipeline
+from jsonschema_diff.color.stages import (
+    MonoLinesHighlighter,
+    PathHighlighter,
+    ReplaceGenericHighlighter,
+)
+
+from .core import SchemaShot
+from .stats import GLOBAL_STATS, SchemaStats
+
+# Global storage of SchemaShot instances for different directories
+_schema_managers: Dict[Path, SchemaShot] = {}
+
+
+def pytest_addoption(parser: pytest.Parser) -> None:
+    """Adds --schema-update option to pytest."""
+    parser.addoption(
+        "--schema-update",
+        action="store_true",
+        help="Update or create JSON Schema files based on current data",
+    )
+    parser.addoption(
+        "--save-original",
+        action="store_true",
+        help="Save original JSON alongside schema (same name, but without `.schema` prefix)",
+    )
+    parser.addoption(
+        "--jsss-debug",
+        action="store_true",
+        help="Show internal exception stack (stops hiding them)",
+    )
+
+    parser.addini(
+        "jsss_dir",
+        default="__snapshots__",
+        help="Directory for storing schemas (default: __snapshots__)",
+    )
+    parser.addini(
+        "jsss_callable_regex",
+        default="{class_method=.}",
+        help="Regex for saving callable part of path",
+    )
+
+
+@pytest.fixture(scope="function")
+def schemashot(request: pytest.FixtureRequest) -> Generator[SchemaShot, None, None]:
+    """
+    Fixture providing a SchemaShot instance and gathering used schemas.
+    """
+
+    # Получаем путь к тестовому файлу
+    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"))
+    save_original = bool(request.config.getoption("--save-original"))
+    debug_mode = bool(request.config.getoption("--jsss-debug"))
+
+    # Получаем настраиваемую директорию для схем
+    schema_dir_name = str(request.config.getini("jsss_dir"))
+    callable_regex = str(request.config.getini("jsss_callable_regex"))
+
+    differ = JsonSchemaDiff(
+        ConfigMaker.make(),
+        HighlighterPipeline(
+            [MonoLinesHighlighter(), PathHighlighter(), ReplaceGenericHighlighter()]
+        ),
+    )
+
+    # Создаем или получаем экземпляр SchemaShot для этой директории
+    if root_dir not in _schema_managers:
+        _schema_managers[root_dir] = SchemaShot(
+            root_dir,
+            differ,
+            callable_regex,
+            update_mode,
+            save_original,
+            debug_mode,
+            schema_dir_name,
+        )
+
+    # Создаем локальный экземпляр для теста
+    yield _schema_managers[root_dir]
+
+
+@pytest.hookimpl(trylast=True)
+def pytest_unconfigure(config: pytest.Config) -> None:
+    """
+    Hook that runs after all tests have finished.
+    Clears global variables.
+    """
+    global GLOBAL_STATS
+
+    # Clear the dictionary
+    _schema_managers.clear()
+    # Reset stats for next run
+    GLOBAL_STATS = SchemaStats()
+
+
+@pytest.hookimpl(trylast=True)
+def pytest_terminal_summary(terminalreporter: pytest.TerminalReporter, exitstatus: int) -> None:
+    """
+    Adds a summary about schemas to the final pytest report in the terminal.
+    """
+    # Выполняем cleanup перед показом summary
+    if _schema_managers:
+        update_mode = bool(terminalreporter.config.getoption("--schema-update"))
+
+        # Вызываем метод очистки неиспользованных схем для каждого экземпляра
+        for _root_dir, manager in _schema_managers.items():
+            cleanup_unused_schemas(manager, update_mode, GLOBAL_STATS)
+
+    # Используем новую функцию для вывода статистики
+    update_mode = bool(terminalreporter.config.getoption("--schema-update"))
+    GLOBAL_STATS.print_summary(terminalreporter, update_mode)
+
+
+def cleanup_unused_schemas(
+    manager: SchemaShot, update_mode: bool, stats: Optional[SchemaStats] = None
+) -> None:
+    """
+    Deletes unused schemas in update mode and collects statistics.
+    Additionally, deletes the pair file `<name>.json` if it exists.
+
+    Args:
+        manager: SchemaShot instance
+        update_mode: Update mode
+        stats: Optional object for collecting statistics
+    """
+    # Если директория снимков не существует, ничего не делаем
+    if not manager.snapshot_dir.exists():
+        return
+
+    # Перебираем все файлы схем
+    all_schemas = list(manager.snapshot_dir.glob("*.schema.json"))
+
+    for schema_file in all_schemas:
+        if schema_file.name not in manager.used_schemas:
+            if update_mode:
+                try:
+                    # Удаляем саму схему
+                    schema_file.unlink()
+                    if stats:
+                        stats.add_deleted(schema_file.name)
+
+                    # Пытаемся удалить парный JSON: <name>.json
+                    # Преобразуем "<name>.schema.json" -> "<name>.json"
+                    base_name = schema_file.name[: -len(".schema.json")]
+                    paired_json = schema_file.with_name(f"{base_name}.json")
+                    if paired_json.exists():
+                        try:
+                            paired_json.unlink()
+                            if stats:
+                                stats.add_deleted(paired_json.name)
+                        except OSError as e:
+                            manager.logger.warning(
+                                f"Failed to delete paired JSON for {schema_file.name}: {e}"
+                            )
+                        except Exception as e:
+                            manager.logger.error(
+                                f"Unexpected error deleting paired JSON for {schema_file.name}: {e}"
+                            )
+
+                except OSError as e:
+                    # Логируем ошибки удаления, но не прерываем работу
+                    manager.logger.warning(
+                        f"Failed to delete unused schema {schema_file.name}: {e}"
+                    )
+                except Exception as e:
+                    # Неожиданные ошибки тоже логируем
+                    manager.logger.error(
+                        f"Unexpected error deleting schema {schema_file.name}: {e}"
+                    )
+            else:
+                if stats:
+                    stats.add_unused(schema_file.name)

pytest_jsonschema_snapshot/stats.py

@@ -0,0 +1,185 @@
+"""
+Module for collecting and displaying statistics about schemas.
+"""
+
+from typing import Dict, Generator, List, Optional
+
+import pytest
+
+
+class SchemaStats:
+    """Class for collecting and displaying statistics about schemas"""
+
+    def __init__(self) -> None:
+        self.created: List[str] = []
+        self.updated: List[str] = []
+        self.updated_diffs: Dict[str, str] = {}  # schema_name -> diff
+        self.uncommitted: List[str] = []  # New category for uncommitted changes
+        self.uncommitted_diffs: Dict[str, str] = {}  # schema_name -> diff
+        self.deleted: List[str] = []
+        self.unused: List[str] = []
+
+    def add_created(self, schema_name: str) -> None:
+        """Adds created schema"""
+        self.created.append(schema_name)
+
+    def add_updated(self, schema_name: str, diff: Optional[str] = None) -> None:
+        """Adds updated schema"""
+        # Generate diff if both schemas are provided
+        if diff and diff.strip():
+            self.updated.append(schema_name)
+            self.updated_diffs[schema_name] = diff
+        else:
+            # If schemas are not provided, assume it was an update
+            self.updated.append(schema_name)
+
+    def add_uncommitted(self, schema_name: str, diff: Optional[str] = None) -> None:
+        """Adds schema with uncommitted changes"""
+        # Add only if there are real changes
+        if diff and diff.strip():
+            self.uncommitted.append(schema_name)
+            self.uncommitted_diffs[schema_name] = diff
+
+    def add_deleted(self, schema_name: str) -> None:
+        """Adds deleted schema"""
+        self.deleted.append(schema_name)
+
+    def add_unused(self, schema_name: str) -> None:
+        """Adds unused schema"""
+        self.unused.append(schema_name)
+
+    def has_changes(self) -> bool:
+        """Returns True if any schema has changes"""
+        return bool(self.created or self.updated or self.deleted)
+
+    def has_any_info(self) -> bool:
+        """Is there any information about schemas"""
+        return bool(self.created or self.updated or self.deleted or self.unused or self.uncommitted)
+
+    def __str__(self) -> str:
+        parts = []
+        if self.created:
+            parts.append(
+                f"Created schemas ({len(self.created)}): "
+                + ", ".join(f"`{s}`" for s in self.created)
+            )
+        if self.updated:
+            parts.append(
+                f"Updated schemas ({len(self.updated)}): "
+                + ", ".join(f"`{s}`" for s in self.updated)
+            )
+        if self.deleted:
+            parts.append(
+                f"Deleted schemas ({len(self.deleted)}): "
+                + ", ".join(f"`{s}`" for s in self.deleted)
+            )
+        if self.unused:
+            parts.append(
+                f"Unused schemas ({len(self.unused)}): " + ", ".join(f"`{s}`" for s in self.unused)
+            )
+
+        return "\n".join(parts)
+
+    def print_summary(self, terminalreporter: pytest.TerminalReporter, update_mode: bool) -> None:
+        """
+        Prints schema summary to pytest terminal output.
+        Pairs of "<name>.schema.json" + "<name>.json" are merged into one line:
+        "<name>.schema.json + original" (if original is present).
+        """
+
+        def _iter_merged(names: List[str]) -> Generator[tuple[str, Optional[str]], None, None]:
+            """
+            Iterates over (display, schema_key):
+            - display: string to display (may have " + original")
+            - schema_key: file name of the schema (<name>.schema.json) to find diffs,
+                or None if it's not a schema.
+            Preserves the original list order: merging happens at .schema.json
+            position; single .json outputs are left as is.
+            """
+            names = list(names)  # порядок важен
+            schema_sfx = ".schema.json"
+            json_sfx = ".json"
+
+            # множество баз, где имеются схемы/оригиналы
+            bases_with_schema = {n[: -len(schema_sfx)] for n in names if n.endswith(schema_sfx)}
+            bases_with_original = {
+                n[: -len(json_sfx)]
+                for n in names
+                if n.endswith(json_sfx) and not n.endswith(schema_sfx)
+            }
+
+            for n in names:
+                if n.endswith(schema_sfx):
+                    base = n[: -len(schema_sfx)]
+                    if base in bases_with_original:
+                        yield f"{n} + original", n  # display, schema_key
+                    else:
+                        yield n, n
+                elif n.endswith(json_sfx) and not n.endswith(schema_sfx):
+                    base = n[: -len(json_sfx)]
+                    # если есть парная схема — .json не выводим отдельно
+                    if base in bases_with_schema:
+                        continue
+                    yield n, None
+                else:
+                    # на всякий случай — прочие имена
+                    yield n, n
+
+        if not self.has_any_info():
+            return
+
+        terminalreporter.write_sep("=", "Schema Summary")
+
+        # Created
+        if self.created:
+            terminalreporter.write_line(f"Created schemas ({len(self.created)}):", green=True)
+            for display, _key in _iter_merged(self.created):
+                terminalreporter.write_line(f"  - {display}", green=True)
+
+        # Updated
+        if self.updated:
+            terminalreporter.write_line(f"Updated schemas ({len(self.updated)}):", yellow=True)
+            for display, key in _iter_merged(self.updated):
+                terminalreporter.write_line(f"  - {display}", yellow=True)
+                # Показываем diff, если он есть под ключом схемы (.schema.json)
+                if key and key in self.updated_diffs:
+                    terminalreporter.write_line("    Changes:", yellow=True)
+                    for line in self.updated_diffs[key].split("\n"):
+                        if line.strip():
+                            terminalreporter.write_line(f"      {line}")
+                    terminalreporter.write_line("")  # разделение
+                elif key:
+                    terminalreporter.write_line(
+                        "    (Schema unchanged - no differences detected)", cyan=True
+                    )
+
+        # Uncommitted
+        if self.uncommitted:
+            terminalreporter.write_line(
+                f"Uncommitted minor updates ({len(self.uncommitted)}):", bold=True
+            )
+            for display, key in _iter_merged(self.uncommitted):
+                terminalreporter.write_line(f"  - {display}", cyan=True)
+                if key and key in self.uncommitted_diffs:
+                    terminalreporter.write_line("    Detected changes:", cyan=True)
+                    for line in self.uncommitted_diffs[key].split("\n"):
+                        if line.strip():
+                            terminalreporter.write_line(f"      {line}")
+                    terminalreporter.write_line("")  # разделение
+            terminalreporter.write_line("Use --schema-update to commit these changes", cyan=True)
+
+        # Deleted
+        if self.deleted:
+            terminalreporter.write_line(f"Deleted schemas ({len(self.deleted)}):", red=True)
+            for display, _key in _iter_merged(self.deleted):
+                terminalreporter.write_line(f"  - {display}", red=True)
+
+        # Unused (только если не update_mode)
+        if self.unused and not update_mode:
+            terminalreporter.write_line(f"Unused schemas ({len(self.unused)}):")
+            for display, _key in _iter_merged(self.unused):
+                terminalreporter.write_line(f"  - {display}")
+            terminalreporter.write_line("Use --schema-update to delete unused schemas", yellow=True)
+
+
+GLOBAL_STATS = SchemaStats()

pytest_jsonschema_snapshot/tools/__init__.py

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

pytest_jsonschema_snapshot/tools/genson_addon/__init__.py

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

pytest_jsonschema_snapshot/tools/genson_addon/format_detector.py

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,119 @@
+"""
+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)

pytest_jsonschema_snapshot/tools/name_maker.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import inspect
+import re
+import types
+from functools import partial
+from typing import Callable, List, Optional, TypedDict
+
+# ──────────────────────────── Типы ────────────────────────────
+_Meta = TypedDict(
+    "_Meta",
+    {
+        "package": str,
+        "package_full": str,
+        "path_parts": List[str],
+        "class": Optional[str],
+        "method": str,
+    },
+)
+
+
+# ──────────────────────────── Класс ───────────────────────────
+class NameMaker:
+    """
+    Lightweight helper that converts a callable into a string identifier
+    using a tiny placeholder-based template language (keeps backward
+    compatibility with the original test-suite).
+
+    Supported placeholders
+    ----------------------
+
+    `{package}`                  – full module path (``tests.test_mod``)
+
+    `{package_full=SEP}`         – same but with custom separator (default “.”)
+
+    `{path} / {path=SEP}`        – module path *without* the first segment
+
+    `{class}`                    – class name or empty string
+
+    `{method}`                   – function / method name
+
+    `{class_method} / {...=SEP}` – ``Class{SEP}method`` or just ``method``
+
+    Unknown placeholders collapse to an empty string.
+
+    After substitution:
+      * “//”, “..”, “--” are collapsed to “/”, “.”, “-” respectively;
+      * double underscores **are preserved** so ``__call__`` stays intact.
+    """
+
+    _RE_PLHDR = re.compile(r"\{([^{}]+)\}")
+
+    # ───────────────────────────── PUBLIC ──────────────────────────────
+    @staticmethod
+    def format(obj: Callable[..., object], rule: str) -> str:
+        """
+        Render *rule* using metadata extracted from *obj*.
+        """
+        meta: _Meta = NameMaker._meta(obj)
+
+        def _sub(match: re.Match[str]) -> str:  # noqa: N802
+            token: str | None = match.group(1)
+            name: str = token.split("=", 1)[0] if token else ""
+            joiner: str | None = token.split("=", 1)[1] if token and "=" in token else None
+            return NameMaker._expand(name, joiner, meta)
+
+        out = NameMaker._RE_PLHDR.sub(_sub, rule)
+        return NameMaker._collapse(out)
+
+    # ──────────────────────────── INTERNAL ────────────────────────────
+    # metadata ----------------------------------------------------------
+    @staticmethod
+    def _unwrap(obj: Callable[..., object]) -> Callable[..., object]:
+        """Strip functools.partial and @functools.wraps wrappers."""
+        while True:
+            if isinstance(obj, partial):
+                obj = obj.func
+                continue
+            if hasattr(obj, "__wrapped__"):
+                obj = obj.__wrapped__
+                continue
+            break
+        return obj
+
+    @staticmethod
+    def _meta(obj: Callable[..., object]) -> _Meta:
+        """Return mapping used during placeholder substitution."""
+        obj = NameMaker._unwrap(obj)
+
+        # 1) built-in function (len, sum, …)
+        if inspect.isbuiltin(obj) or isinstance(obj, types.BuiltinFunctionType):
+            qualname = obj.__name__
+            module = obj.__module__ or "builtins"
+
+        # 2) callable instance (defines __call__)
+        elif not (inspect.isfunction(obj) or inspect.ismethod(obj)):
+            qualname = f"{obj.__class__.__qualname__}.__call__"
+            module = obj.__class__.__module__
+
+        # 3) regular function / bound or unbound method
+        else:
+            qualname = obj.__qualname__
+            module = obj.__module__
+
+        parts: List[str] = qualname.split(".")
+        cls: Optional[str] = None
+        if len(parts) > 1 and parts[-2] != "<locals>":
+            cls = parts[-2]
+        method = parts[-1]
+
+        mod_parts = (module or "").split(".")
+        return {
+            "package": module,
+            "package_full": module,
+            "path_parts": mod_parts[1:] if len(mod_parts) > 1 else [],
+            "class": cls,
+            "method": method,
+        }
+
+    # placeholders ------------------------------------------------------
+    @staticmethod
+    def _expand(name: str, joiner: Optional[str], m: _Meta) -> str:
+        if name == "package":
+            return m["package"]
+        if name == "package_full":
+            sep = joiner if joiner is not None else "."
+            return sep.join(m["package_full"].split("."))
+        if name == "path":
+            if not m["path_parts"]:
+                return ""
+            sep = joiner if joiner is not None else "/"
+            return sep.join(m["path_parts"])
+        if name == "class":
+            return m["class"] or ""
+        if name == "method":
+            return m["method"]
+        if name == "class_method":
+            sep = joiner if joiner is not None else "."
+            cls_name = m["class"]
+            if cls_name:
+                return sep.join([cls_name, m["method"]])
+            return m["method"]
+        # unknown placeholder → empty
+        return ""
+
+    # post-processing ---------------------------------------------------
+    @staticmethod
+    def _collapse(s: str) -> str:
+        # collapse critical duplicates but keep double underscores
+        s = re.sub(r"/{2,}", "/", s)  # '//' → '/'
+        s = re.sub(r"\.{2,}", ".", s)  # '..' → '.'
+        s = re.sub(r"-{2,}", "-", s)  # '--' → '-'
+        return s

pytest_jsonschema_snapshot-0.2.0.dist-info/METADATA

@@ -0,0 +1,195 @@
+Metadata-Version: 2.4
+Name: pytest-jsonschema-snapshot
+Version: 0.2.0
+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
+Project-URL: Documentation, https://miskler.github.io/pytest-jsonschema-snapshot/basic/quick_start.html
+Project-URL: Issues, https://github.com/Miskler/pytest-jsonschema-snapshot/issues
+Author: Miskler
+License: MIT
+License-File: LICENSE
+Keywords: genson,json,pytest,rich,schema,validation
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+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: jsonschema
+Requires-Dist: jsonschema-diff
+Requires-Dist: pathvalidate
+Requires-Dist: pytest
+Provides-Extra: dev
+Requires-Dist: black; extra == 'dev'
+Requires-Dist: docutils; extra == 'dev'
+Requires-Dist: flake8; extra == 'dev'
+Requires-Dist: furo; extra == 'dev'
+Requires-Dist: isort; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest-asyncio; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest-xdist; extra == 'dev'
+Requires-Dist: sphinx; extra == 'dev'
+Requires-Dist: sphinx-autoapi; extra == 'dev'
+Requires-Dist: types-docutils; extra == 'dev'
+Requires-Dist: types-jsonschema; extra == 'dev'
+Description-Content-Type: text/markdown
+
+
+<div align="center">
+
+# 🔍 Pytest JsonSchema SnapShot (JSSS)
+
+<img src="https://raw.githubusercontent.com/Miskler/pytest-jsonschema-snapshot/refs/heads/main/assets/logo.png" width="70%" alt="logo.png" />
+
+***Plugin for pytest that automatically / manually generates JSON Schemas tests with validates data.***
+
+[![Tests](https://miskler.github.io/pytest-jsonschema-snapshot/tests-badge.svg)](https://miskler.github.io/pytest-jsonschema-snapshot/tests/tests-report.html)
+[![Coverage](https://miskler.github.io/pytest-jsonschema-snapshot/coverage.svg)](https://miskler.github.io/pytest-jsonschema-snapshot/coverage/)
+[![Python](https://img.shields.io/badge/python-3.10+-blue)](https://python.org)
+[![PyPI - Package Version](https://img.shields.io/pypi/v/pytest-jsonschema-snapshot?color=blue)](https://pypi.org/project/pytest-jsonschema-snapshot/)
+[![License](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
+[![BlackCode](https://img.shields.io/badge/code%20style-black-black)](https://github.com/psf/black)
+[![mypy](https://img.shields.io/badge/type--checked-mypy-blue?logo=python)](https://mypy.readthedocs.io/en/stable/index.html)
+[![Discord](https://img.shields.io/discord/792572437292253224?label=Discord&labelColor=%232c2f33&color=%237289da)](https://discord.gg/UnJnGHNbBp)
+[![Telegram](https://img.shields.io/badge/Telegram-24A1DE)](https://t.me/miskler_dev)
+
+
+**[⭐ Star us on GitHub](https://github.com/Miskler/pytest-jsonschema-snapshot)** | **[📚 Read the Docs](https://miskler.github.io/pytest-jsonschema-snapshot/basic/quick_start.html)** | **[🐛 Report Bug](https://github.com/Miskler/pytest-jsonschema-snapshot/issues)**
+
+## ✨ Features
+
+</div>
+
+![image](https://github.com/user-attachments/assets/2faa2548-5af2-4dc9-8d8d-b32db1d87be8)
+
+* Automatic JSON Schema generation from data examples (using the `genson` library).
+* **Format detection**: Automatic detection and validation of string formats (email, UUID, date, date-time, URI, IPv4).
+* Schema storage and management.
+* Validation of data against saved schemas.
+* Schema update via `--schema-update` (create new schemas, remove unused ones, update existing).
+* Support for both `async` and synchronous functions.
+* Support for `Union` types and optional fields.
+* Built-in diff comparison of changes via [jsonschema-diff](https://github.com/Miskler/jsonschema-diff).
+
+<div align="center">
+
+## 🚀 Quick Start
+
+</div>
+
+### Installation
+
+```bash
+pip install pytest-jsonschema-snapshot
+```
+
+### Usage
+
+1. Use the `schemashot` fixture in your tests
+  ```python
+  from you_lib import API
+  from typed_schema_shot import SchemaShot
+
+  @pytest.mark.asyncio
+  async def test_something(schemashot: SchemaShot):
+      data = await API.get_data()
+      # There are data - need to validate through the schema
+      schemashot.assert_json_match(
+          data, # data for validation / convert to schema
+          "test_name"       # name of the schema
+      )
+
+      schema = await API.get_schema()
+      # There is a schema (data is optional) - validate by what is
+      schemashot.assert_schema_match(
+          schema,
+          (API.get_schema, "test_name", 1) # == `API.get_schema.test_name.1` filename
+          data=data # data for validation (optional)
+      )
+  ```
+
+2. On first run, generate schemas with the `--schema-update` 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.
+
+3. On subsequent runs, tests will validate data against saved schemas
+   ```bash
+   pytest
+   ```
+
+<div align="center">
+
+## 👀 Key Capabilities
+
+</div>
+
+* **Union Types**: support multiple possible types for fields
+* **Optional Fields**: automatic detection of required and optional fields
+* **Format Detection**: automatic detection of string formats including:
+
+  | Format | Example | JSON Schema |
+  | --- | --- | --- |
+  | Email | `user@example.com` | `{"format": "email"}` |
+  | UUID | `550e8400-e29b-41d4-a716-446655440000` | `{"format": "uuid"}` |
+  | Date | `2023-01-15` | `{"format": "date"}` |
+  | Date-Time | `2023-01-01T12:00:00Z` | `{"format": "date-time"}` |
+  | URI | `https://example.com` | `{"format": "uri"}` |
+  | IPv4 | `192.168.1.1` | `{"format": "ipv4"}` |
+* **Cleanup**: automatic removal of unused schemas when running in update mode
+* **Schema Summary**: colored terminal output showing created, updated, deleted and unused schemas
+
+## Advanced Usage? Check the [docs](https://miskler.github.io/pytest-jsonschema-snapshot/basic/quick_start.html#then-you-need-to-configure-the-library)!
+
+### Best Practices
+
+1. **Commit schemas to version control**: Schemas should be part of your repository
+2. **Review schema changes**: When schemas change, review the diffs carefully without `--schema-update` resets.
+3. **Clean up regularly**: Use `--schema-update` periodically to remove unused schemas
+4. **Descriptive names**: Use clear, descriptive names for your schemas
+
+
+<div align="center">
+
+## 🤝 Contributing
+
+### ***We welcome contributions!***
+
+### Quick Contribution Setup
+
+</div>
+
+```bash
+# Fork the repo, then:
+git clone https://github.com/Miskler/pytest-jsonschema-snapshot.git
+cd jsonschema-diff
+# Install
+make reinstall
+# Ensure everything works
+make test
+make lint
+make type-check
+# After code editing
+make format
+```
+
+<div align="center">
+
+## 📄 License
+
+MIT License - see [LICENSE](LICENSE) file for details.
+
+*Made with ❤️ for developers working with evolving JSON schemas*
+
+</div>

pytest_jsonschema_snapshot-0.2.0.dist-info/RECORD

@@ -0,0 +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/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-0.2.0.dist-info/WHEEL

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

pytest_jsonschema_snapshot-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+schemashot = pytest_jsonschema_snapshot.plugin

pytest_jsonschema_snapshot-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Open Inflation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.