JSONSchemata 0.0.0.dev62__tar.gz → 0.1.1__tar.gz

jsonschemata-0.1.1/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: JSONSchemata
+Version: 0.1.1
+Requires-Python: >=3.10
+Requires-Dist: referencing<0.37,>=0.35
+Requires-Dist: PkgData<0.2,>=0.1
+Requires-Dist: PySerials<0.2,>=0.1
+Requires-Dist: PyLinks<0.2,>=0.1

{jsonschemata-0.0.0.dev62 → jsonschemata-0.1.1}/pyproject.toml

@@ -17,12 +17,12 @@ namespaces = true
 # ----------------------------------------- Project Metadata -------------------------------------
 #
 [project]
-version = "0.0.0.dev62"
+version = "0.1.1"
 name = "JSONSchemata"
 dependencies = [
-    "referencing >= 0.35.1",
-    "PkgData == 0.0.0.dev5",
-    "PySerials == 0.0.0.dev66",
-    "PyLinks == 0.0.0.dev76",
+    "referencing >=0.35,<0.37",
+    "PkgData >=0.1,<0.2",
+    "PySerials >=0.1,<0.2",
+    "PyLinks >=0.1,<0.2",
 ]
 requires-python = ">=3.10"

jsonschemata-0.1.1/src/JSONSchemata.egg-info/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: JSONSchemata
+Version: 0.1.1
+Requires-Python: >=3.10
+Requires-Dist: referencing<0.37,>=0.35
+Requires-Dist: PkgData<0.2,>=0.1
+Requires-Dist: PySerials<0.2,>=0.1
+Requires-Dist: PyLinks<0.2,>=0.1

jsonschemata-0.1.1/src/JSONSchemata.egg-info/requires.txt

@@ -0,0 +1,4 @@
+referencing<0.37,>=0.35
+PkgData<0.2,>=0.1
+PySerials<0.2,>=0.1
+PyLinks<0.2,>=0.1

jsonschemata-0.1.1/src/jsonschemata/__init__.py

@@ -0,0 +1,5 @@
+"""JSONSchemata: JSON Schema registry and utilities."""
+
+from jsonschemata import edit, registry
+
+__all__ = ["edit", "registry"]

jsonschemata-0.1.1/src/jsonschemata/edit.py

@@ -0,0 +1,192 @@
+"""Utilities for modifying JSON schemas."""
+
+from __future__ import annotations as _annotations
+
+from typing import TYPE_CHECKING as _TYPE_CHECKING
+
+if _TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+def required_last(schema: dict) -> dict:
+    """Recursively move ``required`` fields to the end of their schema dict.
+
+    Some JSON Schema validators (e.g. ``jsonschema`` with a default-filling extension)
+    process keywords in the order they appear in the schema dict.
+    When ``required`` is encountered *before* ``default`` values have been filled in,
+    validation fails even though the missing keys
+    would have been supplied by the defaults.
+    Moving ``required`` to the end of every schema dict
+    ensures that defaults are applied before presence is checked.
+
+    The function traverses the full schema tree,
+    following all standard JSON Schema locations
+    that can contain subschemas:
+
+    * **Single subschemas**: ``if``, ``then``, ``else``, ``not``, ``items``,
+      ``unevaluatedItems``, ``contains``, ``additionalProperties``,
+      ``unevaluatedProperties``.
+    * **Lists of subschemas**: ``anyOf``, ``allOf``, ``oneOf``, ``prefixItems``.
+    * **Dicts of subschemas**: ``properties``, ``patternProperties``,
+      ``dependentSchemas``.
+
+    Parameters
+    ----------
+    schema : dict
+        The JSON schema to modify.  Modified **in-place**.
+
+    Returns
+    -------
+    dict
+        The same (now modified) schema dict that was passed in.
+    """
+    if "required" in schema:
+        schema["required"] = schema.pop("required")
+    for key in ["anyOf", "allOf", "oneOf", "prefixItems"]:
+        if key in schema:
+            for subschema in schema[key]:
+                required_last(subschema)
+    for key in [
+        "if",
+        "then",
+        "else",
+        "not",
+        "items",
+        "unevaluatedItems",
+        "contains",
+        "additionalProperties",
+        "unevaluatedProperties",
+    ]:
+        if key in schema and isinstance(schema[key], dict):
+            required_last(schema[key])
+    for key in ["properties", "patternProperties", "dependentSchemas"]:
+        if key in schema and isinstance(schema[key], dict):
+            for subschema in schema[key].values():
+                required_last(subschema)
+    return schema
+
+
+def add_property(
+    schema: dict,
+    prop: str,
+    value: dict,
+    conditioner: Callable[[dict, list], bool] | None = None,
+    current_path: list[str] | None = None,
+) -> dict:
+    """Inject a property into every ``properties`` block in a JSON schema tree.
+
+    The function walks the entire schema tree and,
+    at each node whose ``properties`` mapping passes the optional ``conditioner``,
+    adds ``prop: value`` to that mapping.
+    This makes it possible to, for example,
+    allow a sentinel key everywhere in a schema
+    that would otherwise reject unknown keys
+    via ``additionalProperties: false``.
+
+    Injection rule
+    --------------
+    ``prop`` is added to ``schema["properties"]``
+    at a given node when **both** of the following hold:
+
+    1. The current schema dict contains a ``"properties"`` key.
+    2. Either no ``conditioner`` was supplied, or
+       ``conditioner(schema, current_path)`` returns ``True``.
+
+    Traversal
+    ---------
+    After the (optional) injection at the current node, the function recurses into every
+    standard JSON Schema location that may contain nested subschemas:
+
+    * **Single subschemas** — ``if``, ``then``, ``else``, ``not``, ``items``,
+      ``unevaluatedItems``, ``contains``, ``additionalProperties``,
+      ``unevaluatedProperties``.
+    * **Lists of subschemas** — ``anyOf``, ``allOf``, ``oneOf``, ``prefixItems``:
+      each element is visited individually.
+    * **Dicts of subschemas** — ``properties``, ``patternProperties``,
+      ``dependentSchemas``: each *value* is visited individually (the values are the
+      subschemas; the dict itself is not).
+
+    Parameters
+    ----------
+    schema : dict
+        The root JSON schema to modify.  Modified **in-place**.
+    prop : str
+        Name of the property to inject (e.g. ``"__temp__"``).
+    value : dict
+        The subschema to assign to the injected property
+        (e.g. ``{}`` to accept any value).
+    conditioner : Callable[[dict, list[str]], bool] | None, optional
+        A callable invoked before each potential injection with two arguments:
+
+        * ``schema`` — the candidate schema dict at the current traversal node.
+        * ``current_path`` — a list of strings tracing the path from the root schema
+          to the current node (e.g.
+          ``["properties[foo]", "anyOf[0]", "patternProperties[^bar_]"]``).
+          Useful for context-sensitive decisions such as skipping injection under
+          certain branches.
+
+        Return ``True`` to allow the injection at this node; ``False`` to skip it.
+        Recursion into child nodes continues regardless of the return value.
+        When ``None``, the property is injected at every node that has
+        a ``"properties"`` key.
+    current_path : list[str] | None, optional
+        Path from the schema root to the current node, used internally during
+        recursion and forwarded to ``conditioner``.  Callers should leave this as
+        ``None``; it is initialised to ``[]`` automatically on the first call.
+
+    Returns
+    -------
+    dict
+        The same (now modified) schema dict that was passed in.
+    """
+    if current_path is None:
+        current_path = []
+
+    # Add the property to the current schema
+    # if it has a "properties" field and passes the conditioner (if any).
+    if "properties" in schema and (
+        not conditioner or conditioner(schema, current_path)
+    ):
+        schema["properties"][prop] = value
+
+    # Recurse into subschemas
+
+    # Single subschemas
+    for key in [
+        "if",
+        "then",
+        "else",
+        "not",
+        "items",
+        "unevaluatedItems",
+        "contains",
+        "additionalProperties",
+        "unevaluatedProperties",
+    ]:
+        if key in schema and isinstance(schema[key], dict):
+            add_property(schema[key], prop, value, conditioner, [*current_path, key])
+
+    # List of subschemas
+    for key in ["anyOf", "allOf", "oneOf", "prefixItems"]:
+        for idx, subschema in enumerate(schema.get(key, [])):
+            add_property(
+                subschema,
+                prop,
+                value,
+                conditioner,
+                [*current_path, f"{key}[{idx}]"],
+            )
+
+    # Dict of subschemas
+    for key in ["properties", "patternProperties", "dependentSchemas"]:
+        if key in schema and isinstance(schema[key], dict):
+            for property_name, subschema in schema[key].items():
+                add_property(
+                    subschema,
+                    prop,
+                    value,
+                    conditioner,
+                    [*current_path, f"{key}[{property_name}]"],
+                )
+
+    return schema

{jsonschemata-0.0.0.dev62 → jsonschemata-0.1.1}/src/jsonschemata/registry.py

@@ -1,34 +1,41 @@
+"""Utilities for creating and managing JSON Schema registries."""
+
 from __future__ import annotations as _annotations
 
 from typing import TYPE_CHECKING as _TYPE_CHECKING
 
-import referencing as _referencing
-from referencing import jsonschema as _ref_jsonschema, retrieval as _ref_retrieval
 import pkgdata as _pkgdata
-import pyserials as _ps
 import pylinks as _pl
+import pyserials as _ps
+import referencing as _referencing
+from referencing import jsonschema as _ref_jsonschema
+from referencing import retrieval as _ref_retrieval
 
 from jsonschemata import edit as _edit
 
 if _TYPE_CHECKING:
-    from typing import Callable, Sequence
+    from collections.abc import Callable, Sequence
 
 
 def make(
-    resources: Sequence[dict | _referencing.Resource | tuple[str, dict | _referencing.Resource]] | None = None,
+    resources: Sequence[
+        dict | _referencing.Resource | tuple[str, dict | _referencing.Resource]
+    ]
+    | None = None,
     default_specification: _referencing.Specification = _ref_jsonschema.DRAFT202012,
+    *,
     crawl: bool = True,
     clean: bool = False,
     dynamic: bool = True,
-    retrieval_function: Callable[[str], str | _referencing.Resource] = None,
+    retrieval_function: Callable[[str], str | _referencing.Resource] | None = None,
 ) -> _referencing.Registry:
     """Create a JSON Schema registry.
 
     Parameters
     ----------
     resources
-        A list of schema resources to add to the registry. Each resource can be a dictionary or
-        a [`referencing.Resource`](https://referencing.readthedocs.io/en/stable/api/#referencing.Resource)
+        A list of schema resources to add to the registry. Each resource can be
+        a dictionary or a [`referencing.Resource`](https://referencing.readthedocs.io/en/stable/api/#referencing.Resource)
         object. If a schema does not have an "$id",
         the ID must be provided along with the resource as a tuple of (ID, schema).
     default_specification
@@ -45,8 +52,10 @@ def make(
         [Dynamically retrieve](https://referencing.readthedocs.io/en/stable/intro/#dynamically-retrieving-resources)
         and [cache](https://referencing.readthedocs.io/en/stable/intro/#caching)
         references that are not found in the registry.
-        If set to True, the default behaviour is as follows (see `retrieval_function` for customization):
-        If the reference URI starts with "http" or "https", the URI is fetched using an HTTP GET request.
+        If set to True, the default behaviour is as follows
+        (see `retrieval_function` for customization):
+        If the reference URI starts with "http" or "https",
+        the URI is fetched using an HTTP GET request.
         Otherwise, the URI is assumed to be a local filepath,
         which can be either absolute or relative to the current working directory.
     retrieval_function: Callable[[str], str | referencing.Resource], optional
@@ -55,57 +64,68 @@ def make(
         If you want the retrieval function to also cache the retrieved references,
         the function must be decorated with the
         [`@referencing.retrieval.to_cached_resource`](https://referencing.readthedocs.io/en/stable/api/#referencing.retrieval.to_cached_resource)
-        decorator, in which case the function must return the reference schema as a JSON string
+        decorator, in which case the function must return the reference schema as
+        a JSON string
         (cf. [Referencing Docs](https://referencing.readthedocs.io/en/stable/intro/#caching)).
-        If the decorator is not used, the function must return the schema as a `referencing.Resource` instead.
+        If the decorator is not used, the function must return the schema as a
+        `referencing.Resource` instead.
+
     Returns
     -------
     referencing.Registry
         A [`referencing.Registry`](https://referencing.readthedocs.io/en/stable/api/#referencing.Registry)
         object containing all resources.
     """
-
-    @_ref_retrieval.to_cached_resource()
-    def retrieve_url(uri: str) -> str:
-        if uri.startswith(("http://", "https://")):
-            return _pl.http.request(url=uri, response_type="str")
-        return _ps.write.to_json_string(_ps.read.from_file(path=uri, toml_as_dict=True), sort_keys=False)
-
     full_resources = []
     id_resources: list[tuple[str, _referencing.Resource]] = []
 
     if not clean:
-        schema_dir_path = _pkgdata.get_package_path_from_caller(top_level=True) / "_data"
+        pkg_path = _pkgdata.get_package_path_from_caller(top_level=True)
+        schema_dir_path = pkg_path / "_data"
         for schema_filepath in schema_dir_path.glob("**/*.yaml"):
             schema_dict = _ps.read.yaml_from_file(path=schema_filepath)
             _edit.required_last(schema_dict)
             schema = _referencing.Resource.from_contents(
-                schema_dict, default_specification=_ref_jsonschema.DRAFT202012
+                schema_dict,
+                default_specification=_ref_jsonschema.DRAFT202012,
             )
             full_resources.append(schema)
     for add_resource in resources or []:
         resource_id = None
+        resource = add_resource
         if isinstance(add_resource, dict):
-            add_resource = _referencing.Resource.from_contents(
-                add_resource, default_specification=default_specification
+            resource = _referencing.Resource.from_contents(
+                add_resource,
+                default_specification=default_specification,
             )
         elif isinstance(add_resource, (list, tuple)):
             resource_id, resource_dict = add_resource
-            add_resource = _referencing.Resource.from_contents(
-                resource_dict, default_specification=default_specification,
+            resource = _referencing.Resource.from_contents(
+                resource_dict,
+                default_specification=default_specification,
             )
         if resource_id:
-            id_resources.append((resource_id, add_resource))
+            id_resources.append((resource_id, resource))
         else:
-            full_resources.append(add_resource)
+            full_resources.append(resource)
 
-    registry = _referencing.Registry(
-        retrieve=retrieval_function or retrieve_url
-    ) if dynamic else _referencing.Registry()
+    registry = (
+        _referencing.Registry(retrieve=retrieval_function or _retrieve_url)
+        if dynamic
+        else _referencing.Registry()
+    )
     if full_resources:
         registry = full_resources @ registry
     if id_resources:
         registry = registry.with_resources(id_resources)
     if crawl:
-        registry.crawl()
+        registry = registry.crawl()
     return registry
+
+
+@_ref_retrieval.to_cached_resource()
+def _retrieve_url(uri: str) -> str:
+    if uri.startswith(("http://", "https://")):
+        return _pl.http.request(url=uri, response_type="str")
+    file_schema = _ps.read.from_file(path=uri, toml_as_dict=True)
+    return _ps.write.to_json_string(file_schema, sort_keys=False)

jsonschemata-0.0.0.dev62/PKG-INFO

@@ -1,8 +0,0 @@
-Metadata-Version: 2.2
-Name: JSONSchemata
-Version: 0.0.0.dev62
-Requires-Python: >=3.10
-Requires-Dist: referencing>=0.35.1
-Requires-Dist: PkgData==0.0.0.dev5
-Requires-Dist: PySerials==0.0.0.dev66
-Requires-Dist: PyLinks==0.0.0.dev76

jsonschemata-0.0.0.dev62/src/JSONSchemata.egg-info/PKG-INFO

@@ -1,8 +0,0 @@
-Metadata-Version: 2.2
-Name: JSONSchemata
-Version: 0.0.0.dev62
-Requires-Python: >=3.10
-Requires-Dist: referencing>=0.35.1
-Requires-Dist: PkgData==0.0.0.dev5
-Requires-Dist: PySerials==0.0.0.dev66
-Requires-Dist: PyLinks==0.0.0.dev76

jsonschemata-0.0.0.dev62/src/JSONSchemata.egg-info/requires.txt

@@ -1,4 +0,0 @@
-referencing>=0.35.1
-PkgData==0.0.0.dev5
-PySerials==0.0.0.dev66
-PyLinks==0.0.0.dev76

jsonschemata-0.0.0.dev62/src/jsonschemata/__init__.py

@@ -1 +0,0 @@
-from jsonschemata import edit, registry

jsonschemata-0.0.0.dev62/src/jsonschemata/edit.py

@@ -1,80 +0,0 @@
-from __future__ import annotations as _annotations
-
-from typing import TYPE_CHECKING as _TYPE_CHECKING
-
-if _TYPE_CHECKING:
-    from typing import Callable
-
-
-def required_last(schema: dict) -> dict:
-    """Modify JSON schema to recursively put all 'required' fields at the end of the schema.
-
-    This is done because otherwise the 'required' fields
-    are checked by jsonschema before filling the defaults,
-    which can cause the validation to fail.
-
-    Returns
-    -------
-    dict
-        Modified schema.
-        Note that the input schema is modified in-place,
-        so the return value is a reference to the (now modified) input schema.
-    """
-    if "required" in schema:
-        schema["required"] = schema.pop("required")
-    for key in ["anyOf", "allOf", "oneOf", "prefixItems"]:
-        if key in schema:
-            for subschema in schema[key]:
-                required_last(subschema)
-    for key in ["if", "then", "else", "not", "items", "unevaluatedItems", "contains", "additionalProperties", "unevaluatedProperties"]:
-        if key in schema and isinstance(schema[key], dict):
-            required_last(schema[key])
-    for key in ["properties", "patternProperties"]:
-        if key in schema and isinstance(schema[key], dict):
-            for subschema in schema[key].values():
-                required_last(subschema)
-    return schema
-
-
-def add_property(
-    schema: dict,
-    prop: str,
-    value: dict,
-    conditioner: Callable[[dict, list], bool] | None = None,
-    current_path: list[str] | None = None,
-) -> dict:
-    """Recursively add a property to a JSON schema.
-
-    Parameters
-    ----------
-    schema : dict
-        The JSON schema to modify.
-    prop : str
-        The name of the property to add.
-    value : Any
-        The value of the property to add.
-    conditioner : Callable[[dict, list], bool], optional
-        A function that takes a schema and the path to the current schema as arguments
-        and returns a boolean indicating whether to add the property to the schema.
-    current_path : list[str], optional
-        The path to the current schema in the JSON schema hierarchy.
-    Returns
-    -------
-    dict
-        The modified schema.
-    """
-    if current_path is None:
-        current_path = []
-    for key in ["anyOf", "allOf", "oneOf", "prefixItems"]:
-        if key in schema:
-            for idx, subschema in enumerate(schema[key]):
-                add_property(subschema, prop, value, conditioner, current_path + [f"{key}[{idx}]"])
-    for key in ["if", "then", "else", "not", "items", "unevaluatedItems", "contains", "additionalProperties", "patternProperties", "unevaluatedProperties"]:
-        if key in schema and isinstance(schema[key], dict):
-            add_property(schema[key], prop, value, conditioner, current_path + [key])
-    if "properties" in schema:
-        for property_name, subschema in schema["properties"].items():
-            add_property(subschema, prop, value, conditioner, current_path + [f"properties[{property_name}]"])
-        if not conditioner or conditioner(schema, current_path):
-            schema["properties"][prop] = value
-    return schema