amati 0.3.13__tar.gz → 0.3.15__tar.gz

{amati-0.3.13 → amati-0.3.15}/.github/workflows/checks.yaml

@@ -77,7 +77,7 @@ jobs:
       - name: Coverage comment
         if: steps.check_changes.outputs.relevant == 'true'
         id: coverage_comment
-        uses: py-cov-action/python-coverage-comment-action@39ffc771120970de615612f01a030260bcb45443 # v3
+        uses: py-cov-action/python-coverage-comment-action@14efb884fd6f322dca843a946ce2125a55c12e1d # v3
         with:
           GITHUB_TOKEN: ${{ secrets.BOT_COMMENT_TOKEN }}
         continue-on-error: true

{amati-0.3.13 → amati-0.3.15}/.github/workflows/codeql.yml

@@ -73,7 +73,7 @@ jobs:
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@e12f0178983d466f2f6028f5cc7a6d786fd97f4b # v4.31.4
+      uses: github/codeql-action/init@fdbfb4d2750291e159f0156def62b853c2798ca2 # v4.31.5
       with:
         languages: ${{ matrix.language }}
         build-mode: ${{ matrix.build-mode }}
@@ -101,6 +101,6 @@ jobs:
         exit 1
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@e12f0178983d466f2f6028f5cc7a6d786fd97f4b # v4.31.4
+      uses: github/codeql-action/analyze@fdbfb4d2750291e159f0156def62b853c2798ca2 # v4.31.5
       with:
         category: "/language:${{matrix.language}}"

{amati-0.3.13 → amati-0.3.15}/.github/workflows/coverage.yaml

@@ -24,7 +24,7 @@ jobs:
           egress-policy: audit
 
       - name: Post comment
-        uses: py-cov-action/python-coverage-comment-action@39ffc771120970de615612f01a030260bcb45443 # v3
+        uses: py-cov-action/python-coverage-comment-action@14efb884fd6f322dca843a946ce2125a55c12e1d # v3
         with:
           GITHUB_TOKEN: ${{ secrets.BOT_COMMENT_TOKEN }}
           GITHUB_PR_RUN_ID: ${{ github.event.workflow_run.id }}

{amati-0.3.13 → amati-0.3.15}/.github/workflows/data-refresh.yaml

@@ -25,7 +25,7 @@ jobs:
         token: ${{ secrets.BOT_TOKEN }}
 
     - name: Set up uv
-      uses: astral-sh/setup-uv@5a7eac68fb9809dea845d802897dc5c723910fa3 # v7.1.3
+      uses: astral-sh/setup-uv@1e862dfacbd1d6d858c55d9b792c756523627244 # v7.1.4
       with:
         version: "latest"
 

{amati-0.3.13 → amati-0.3.15}/.github/workflows/publish.yaml

@@ -24,7 +24,7 @@ jobs:
 
       - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       - name: Install uv
-        uses: astral-sh/setup-uv@5a7eac68fb9809dea845d802897dc5c723910fa3 # v7.1.3
+        uses: astral-sh/setup-uv@1e862dfacbd1d6d858c55d9b792c756523627244 # v7.1.4
       - name: Set up Python
         uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
         with:

{amati-0.3.13 → amati-0.3.15}/.github/workflows/scorecards.yml

@@ -80,6 +80,6 @@ jobs:
 
       # Upload the results to GitHub's code scanning dashboard.
       - name: "Upload to code-scanning"
-        uses: github/codeql-action/upload-sarif@e12f0178983d466f2f6028f5cc7a6d786fd97f4b # v4.31.4
+        uses: github/codeql-action/upload-sarif@fdbfb4d2750291e159f0156def62b853c2798ca2 # v4.31.5
         with:
           sarif_file: results.sarif

{amati-0.3.13 → amati-0.3.15}/.github/workflows/tag-and-create-release.yaml

@@ -34,7 +34,7 @@ jobs:
           fetch-depth: 0  # Fetch all history for proper tag creation
           token: ${{ secrets.BOT_TOKEN }}
       - name: Install uv
-        uses: astral-sh/setup-uv@5a7eac68fb9809dea845d802897dc5c723910fa3 # v7.1.3
+        uses: astral-sh/setup-uv@1e862dfacbd1d6d858c55d9b792c756523627244 # v7.1.4
 
       - name: Current version
         id: current_version

{amati-0.3.13 → amati-0.3.15}/.pre-commit-config.yaml

@@ -1,7 +1,7 @@
 repos:
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.14.6
+  rev: v0.14.8
   hooks:
     # Run the linter.
     - id: ruff-check
@@ -16,4 +16,4 @@ repos:
   rev: v0.7.2
   hooks:
     - id: shellcheck
-      args: [-x]
+      args: [-x]

{amati-0.3.13 → amati-0.3.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amati
-Version: 0.3.13
+Version: 0.3.15
 Summary: Validates that a .yaml or .json file conforms to the OpenAPI Specifications 3.x.
 Project-URL: Homepage, https://github.com/gwyli/amati
 Project-URL: Issues, https://github.com/gwyli/amati/issues

{amati-0.3.13 → amati-0.3.15}/amati/_data/files/spdx-licences.json

@@ -283,6 +283,15 @@
     "isOsiApproved": false,
     "isFsfLibre": false
   },
+  {
+    "reference": "https://spdx.org/licenses/ALGLIB-Documentation.html",
+    "isDeprecatedLicenseId": false,
+    "detailsUrl": "https://spdx.org/licenses/ALGLIB-Documentation.json",
+    "name": "ALGLIB Documentation License",
+    "licenseId": "ALGLIB-Documentation",
+    "seeAlso": [],
+    "isOsiApproved": true
+  },
   {
     "reference": "https://spdx.org/licenses/AMD-newlib.html",
     "isDeprecatedLicenseId": false,
@@ -4357,6 +4366,18 @@
     ],
     "isOsiApproved": false
   },
+  {
+    "reference": "https://spdx.org/licenses/ISO-permission.html",
+    "isDeprecatedLicenseId": false,
+    "detailsUrl": "https://spdx.org/licenses/ISO-permission.json",
+    "name": "ISO permission notice",
+    "licenseId": "ISO-permission",
+    "seeAlso": [
+      "https://gitlab.com/agmartin/linuxdoc-tools/-/blob/master/iso-entities/COPYING?ref_type=heads",
+      "https://www.itu.int/ITU-T/formal-language/itu-t/t/t173/1997/ISOMHEG-sir.html"
+    ],
+    "isOsiApproved": false
+  },
   {
     "reference": "https://spdx.org/licenses/Jam.html",
     "isDeprecatedLicenseId": false,

{amati-0.3.13 → amati-0.3.15}/amati/_data/files/tlds.json

@@ -1416,6 +1416,7 @@
   ".\u516b\u5366",
   "\u200f.\u05d9\u05e9\u05e8\u05d0\u05dc\u200e",
   "\u200f.\u0645\u0648\u0642\u0639\u200e",
+  ".\u4e00\u53f7\u5e97",
   ".\u09ac\u09be\u0982\u09b2\u09be",
   ".\u516c\u76ca",
   ".\u516c\u53f8",

amati-0.3.15/amati/_error_handler.py

@@ -0,0 +1,48 @@
+"""
+Handles Pydantic errors and amati logs to provide a consistent view to the user.
+"""
+
+import json
+from typing import cast
+
+from amati._logging import Log
+
+type JSONPrimitive = str | int | float | bool | None
+type JSONArray = list["JSONValue"]
+type JSONObject = dict[str, "JSONValue"]
+type JSONValue = JSONPrimitive | JSONArray | JSONObject
+
+
+class ErrorHandler:
+    def __init__(self) -> None:
+        self._errors: list[JSONObject] = []
+
+    def register_logs(self, logs: list[Log]):
+        self._errors.extend(cast(list[JSONObject], logs))
+
+    def register_log(self, log: Log):
+        self._errors.append(cast(JSONObject, log))
+
+    def register_errors(self, errors: list[JSONObject]):
+        self._errors.extend(errors)
+
+    def deduplicate(self):
+        """
+        Remove duplicates by converting each dict to a JSON string for comparison.
+        """
+        seen: set[str] = set()
+        unique_data: list[JSONObject] = []
+
+        item: JSONObject
+        for item in self._errors:
+            # Convert to JSON string with sorted keys for consistent hashing
+            item_json = json.dumps(item, sort_keys=True, separators=(",", ":"))
+            if item_json not in seen:
+                seen.add(item_json)
+                unique_data.append(item)
+
+        self._errors = unique_data
+
+    @property
+    def errors(self) -> list[JSONObject]:
+        return self._errors

amati-0.3.15/amati/_references.py

@@ -0,0 +1,226 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel
+
+from amati.fields import URI, URIType
+
+
+@dataclass(frozen=True)
+class URIReference:
+    """Immutable record of a URI found during validation"""
+
+    uri: URI
+    source_document: Path
+    source_model_name: str  # Just the string name for error reporting
+    source_field: str
+    target_model: type[BaseModel]  # The model type to validate with
+
+    def resolve(self) -> Path:
+        """Resolve URI relative to source document, see
+        https://spec.openapis.org/oas/v3.1.1.html#relative-references-in-api-description-uris
+        """
+
+        if self.uri.scheme == "file":
+            if not self.uri.path:
+                raise ValueError("File URI must have a path component")
+
+            netloc: Path | None = (
+                Path(self.uri.authority)
+                if self.uri.authority
+                else Path(self.uri.host)
+                if self.uri.host
+                else None
+            )
+
+            return (
+                (netloc / self.uri.path).resolve()
+                if netloc
+                else Path(self.uri.path).resolve()
+            )
+
+        if self.uri.type == URIType.ABSOLUTE:
+            raise NotImplementedError("Absolute URI resolution not implemented")
+
+        if self.uri.type == URIType.NETWORK_PATH:
+            return Path(self.uri).resolve()
+
+        if self.uri.type == URIType.RELATIVE:
+            path: Path = self.source_document.parent / self.uri.lstrip("/")
+            return path.resolve()
+
+        if self.uri.type == URIType.JSON_POINTER:
+            path: Path = self.source_document.parent / self.uri.lstrip("#/")
+            return path.resolve()
+
+        # Guard against future changes
+        raise ValueError(f"Unknown URI type: {self.uri.type}")  # pragma: no cover
+
+
+class URIRegistry:
+    """Registry for discovered URIs using the Singleton pattern.
+
+    This class maintains a central registry of all URI references discovered
+    during document validation. It tracks both the URIs themselves and which
+    documents have already been processed to avoid duplicate validation.
+
+    Attributes:
+        _instance: Class-level singleton instance.
+        _uris: List of all registered URI references.
+        _processed: Set of file paths that have been validated.
+    """
+
+    _instance = None
+
+    def __init__(self):
+        """Initialize a new URIRegistry instance.
+
+        Note:
+            This should not be called directly. Use get_instance() instead
+            to obtain the singleton instance.
+        """
+        self._uris: list[URIReference] = []
+        self._processed: set[Path] = set()
+
+    @classmethod
+    def get_instance(cls) -> URIRegistry:
+        """Get or create the singleton instance of URIRegistry.
+
+        Returns:
+            URIRegistry: The singleton instance of the registry.
+        """
+        if cls._instance is None:
+            cls._instance = cls()
+
+        return cls._instance
+
+    def register(self, ref: URIReference):
+        """Register a discovered URI reference.
+
+        Args:
+            ref (URIReference): The URI reference to register, including
+                source document, and target model.
+        """
+
+        if not isinstance(ref, URIReference):  # pyright: ignore[reportUnnecessaryIsInstance]
+            raise TypeError("ref must be an instance of URIReference")
+
+        self._uris.append(ref)
+
+    def mark_processed(self, path: Path):
+        """Mark a document as having been validated.
+
+        The path is resolved to an absolute path before storage to ensure
+        consistent tracking regardless of how the path was specified.
+
+        Args:
+            path (Path): The file path of the document that has been processed.
+        """
+        self._processed.add(path.resolve())
+
+    def is_processed(self, path: Path) -> bool:
+        """Check if a document has already been validated.
+
+        Args:
+            path (Path): The file path to check.
+
+        Returns:
+            bool: True if the document has been processed, False otherwise.
+        """
+        return path.resolve() in self._processed
+
+    def get_all_references(self) -> list[URIReference]:
+        """Get all discovered URI references.
+
+        Returns:
+            list[URIReference]: A copy of the list of all registered URI
+                references. Returns a copy to prevent external modification
+                of the internal registry.
+        """
+        return self._uris.copy()
+
+    def resolvable(self, path: Path) -> bool:
+        """Check if the file referenced by a URI exists.
+
+        Args:
+            path (Path): The file path to verify.
+
+        Returns:
+            bool: True if the path points to an existing file, False otherwise.
+        """
+        return path.is_file()
+
+    def reset(self):
+        """Reset the registry for a new validation run.
+
+        Clears all registered URIs and processed document records. This is
+        typically called at the beginning of a new validation session.
+        """
+        self._uris.clear()
+        self._processed.clear()
+
+
+class URICollectorMixin(BaseModel):
+    """Mixin for Pydantic models to automatically collect URIs during validation.
+
+    This mixin hooks into the Pydantic model lifecycle to automatically
+    discover and register URI fields during model instantiation. It inspects
+    all fields after validation and registers any URI-type fields with the
+    URIRegistry for subsequent processing.
+
+    The mixin expects a 'current_document' key in the validation context
+    to track the source document for each URI reference.
+    """
+
+    def model_post_init(self, __context: dict[str, Any]) -> None:
+        """Post-initialization hook to collect URI references from model fields.
+
+        This method is automatically called by Pydantic after model validation
+        is complete. It inspects all fields for URI types and registers them
+        with the singleton URIRegistry.
+
+        Args:
+            __context (dict[str, Any]): Validation context dictionary. Expected
+                to contain a 'current_document' key with the path to the source
+                document being validated.
+
+        Note:
+            This method calls super().model_post_init() to ensure compatibility
+            with other mixins and the base model's initialization process.
+
+        Example:
+            Context should be passed during model instantiation:
+            >>> class MyModel(URICollectorMixin, BaseModel):
+            ...     ref: URI
+            >>> model = MyModel.model_validate(
+            ...     {"ref": "http://example.com/resource"},
+            ...     context={"current_document": "/path/to/doc.json"}
+            ... )
+        """
+        super().model_post_init(__context)
+
+        if not __context:
+            return
+
+        current_doc = __context.get("current_document")
+        if not current_doc:
+            return
+
+        # Inspect all fields for URI types
+        for field_name, field_value in self.model_dump().items():
+            if field_value is None:
+                continue
+
+            # Check if this field contains a URI
+            # Adjust this check based on your URI type implementation
+            if isinstance(field_value, URI):
+                ref = URIReference(
+                    uri=field_value,
+                    source_document=Path(current_doc),
+                    source_model_name=self.__class__.__name__,
+                    source_field=field_name,
+                    # The linked document should be validated with the same model type
+                    target_model=self.__class__,
+                )
+                URIRegistry.get_instance().register(ref)

{amati-0.3.13 → amati-0.3.15}/amati/_resolve_forward_references.py

@@ -5,6 +5,7 @@ without all its dependencies. This module rebuilds all models in a module.
 
 import inspect
 import sys
+import typing
 from collections import defaultdict
 from types import ModuleType
 
@@ -26,20 +27,46 @@ class ModelDependencyResolver:
         """Register a Pydantic model for dependency analysis."""
         self.models[model.__name__] = model
 
-    def register_models(self, models: list[type[BaseModel]]) -> None:
-        """Register multiple Pydantic models."""
-        for model in models:
-            self.register_model(model)
+    @staticmethod
+    def extract_all_references(annotation: typing.Any, refs: set[str] | None = None):
+        """
+        Recursively extract all ForwardRef and type references from an annotation.
+
+        Args:
+            annotation: A type annotation (potentially deeply nested)
+            refs: Set to accumulate references (used internally for recursion)
+
+        Returns:
+            Set of either ForwardRef objects or actual type/class objects
+        """
+        if refs is None:
+            refs = set()
+
+        # Direct ForwardRef
+        if isinstance(annotation, typing.ForwardRef):
+            refs.add(annotation.__forward_arg__)
+            return refs
+
+        # Direct class reference
+        if isinstance(annotation, type):
+            refs.add(annotation.__name__)
+            return refs
+
+        for origin in typing.get_args(annotation):
+            ModelDependencyResolver.extract_all_references(origin, refs)
+
+        return refs
 
     def _analyze_model_dependencies(self, model: type[BaseModel]) -> set[str]:
         """Analyze a single model's dependencies from its annotations."""
         dependencies: set[str] = set()
 
         for field_info in model.model_fields.values():
-            # Use a magic value that's an invalid class name for getattr so if
-            # there is no __name__ attribute it won't appear in self.models
-            if (name := getattr(field_info.annotation, "__name__", "!")) in self.models:
-                dependencies.update(name)
+            references = ModelDependencyResolver.extract_all_references(
+                field_info.annotation
+            )
+
+            dependencies.update(ref for ref in references if ref in self.models)
 
         return dependencies
 
@@ -48,18 +75,10 @@ class ModelDependencyResolver:
         self.dependencies.clear()
         self.graph.clear()
 
-        # First pass: collect all dependencies
         for model_name, model in self.models.items():
             deps = self._analyze_model_dependencies(model)
             self.dependencies[model_name] = deps
 
-        # Second pass: build directed graph
-        for model_name, deps in self.dependencies.items():
-            for dep in deps:
-                if dep in self.models:
-                    # Build forward graph (dependency -> dependent)
-                    self.graph[dep].append(model_name)
-
     def _tarjan_scc(self) -> list[list[str]]:
         """Find strongly connected components using Tarjan's algorithm."""
         index_counter = [0]
@@ -76,13 +95,6 @@ class ModelDependencyResolver:
             stack.append(node)
             on_stack[node] = True
 
-            for successor in self.graph[node]:
-                if successor not in index:
-                    strongconnect(successor)
-                    lowlinks[node] = min(lowlinks[node], lowlinks[successor])
-                elif on_stack[successor]:
-                    lowlinks[node] = min(lowlinks[node], index[successor])
-
             if lowlinks[node] == index[node]:
                 component: list[str] = []
                 while True:
@@ -99,41 +111,6 @@ class ModelDependencyResolver:
 
         return sccs
 
-    def _topological_sort_sccs(self, sccs: list[list[str]]) -> list[list[str]]:
-        """Topologically sort the strongly connected components."""
-        # Map each node to its SCC index
-        node_to_scc = {node: i for i, scc in enumerate(sccs) for node in scc}
-
-        # Find dependencies between SCCs
-        dependencies: set[tuple[int, ...]] = set()
-        for node in self.models:
-            for neighbor in self.graph[node]:
-                src_scc, dst_scc = node_to_scc[node], node_to_scc[neighbor]
-                if src_scc != dst_scc:
-                    dependencies.add((src_scc, dst_scc))
-
-        # Count incoming edges for each SCC
-        in_degree = [0] * len(sccs)
-        for _, dst in dependencies:
-            in_degree[dst] += 1
-
-        # Process SCCs with no dependencies first
-        ready = [i for i, deg in enumerate(in_degree) if deg == 0]
-        result: list[list[str]] = []
-
-        while ready:
-            current = ready.pop()
-            result.append(sccs[current])
-
-            # Remove this SCC and update in-degrees
-            for src, dst in dependencies:
-                if src == current:
-                    in_degree[dst] -= 1
-                    if in_degree[dst] == 0:
-                        ready.append(dst)
-
-        return result
-
     def get_rebuild_order(self) -> list[list[str]]:
         """
         Get the order in which models should be rebuilt.
@@ -141,8 +118,7 @@ class ModelDependencyResolver:
         rebuilt together.
         """
         self.build_dependency_graph()
-        sccs = self._tarjan_scc()
-        return self._topological_sort_sccs(sccs)
+        return self._tarjan_scc()
 
     def rebuild_models(self) -> None:
         """Rebuild all registered models in the correct dependency order."""