intersect-sdk 0.9.1__tar.gz → 0.9.3__tar.gz

{intersect_sdk-0.9.1 → intersect_sdk-0.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: intersect-sdk
-Version: 0.9.1
+Version: 0.9.3
 Summary: Python SDK to interact with INTERSECT
 Keywords: intersect
 Author: Lance Drane, Marshall McDonnell, Seth Hitefield, Andrew Ayres, Gregory Cage, Jesse McGaha, Robert Smith, Gavin Wiggins, Michael Brim, Rick Archibald, Addi Malviya Thakur

{intersect_sdk-0.9.1 → intersect_sdk-0.9.3}/pyproject.toml

@@ -14,7 +14,7 @@ authors = [
   { name = "Rick Archibald", email = "archibaldrk@ornl.gov" },
   { name = "Addi Malviya Thakur", email = "malviyaa@ornl.gov" },
 ]
-version = "0.9.1"
+version = "0.9.3"
 readme = "README.md"
 license = { text = "BSD-3-Clause" }
 requires-python = ">=3.10,<4.0"
@@ -51,7 +51,8 @@ dev = [
   "codespell>=2.3.0",
   "pytest>=7.3.2",
   "pytest-cov>=4.1.0",
-  "httpretty>=1.1.4",
+  "fastapi",
+  "uvicorn",
 ]
 
 [build-system]

{intersect_sdk-0.9.1 → intersect_sdk-0.9.3}/src/intersect_sdk/_internal/pydantic_schema_generator.py

@@ -3,6 +3,7 @@
 See: https://docs.pydantic.dev/latest/api/json_schema/#pydantic.json_schema.GenerateJsonSchema
 """
 
+import collections
 from typing import (
     Any,
 )
@@ -10,14 +11,24 @@ from typing import (
 from jsonschema import Draft202012Validator as SchemaValidator
 from jsonschema import ValidationError as SchemaValidationError
 from jsonschema.validators import validator_for
-from pydantic import PydanticInvalidForJsonSchema, PydanticSchemaGenerationError, TypeAdapter
+from pydantic import (
+    PydanticInvalidForJsonSchema,
+    PydanticSchemaGenerationError,
+    TypeAdapter,
+)
 from pydantic.json_schema import (
     GenerateJsonSchema,
     JsonSchemaMode,
     JsonSchemaValue,
 )
 from pydantic.type_adapter import _type_has_config
-from pydantic_core import CoreSchema, PydanticSerializationError, core_schema, to_jsonable_python
+from pydantic_core import (
+    CoreSchema,
+    PydanticSerializationError,
+    core_schema,
+    to_jsonable_python,
+)
+from referencing.exceptions import Unresolvable
 
 
 # build nested dictionary from list of keys. i.e. if keys = ['one', 'two', 'three']
@@ -73,7 +84,8 @@ def validate_schema(json_schema: Any) -> list[str]:
     # custom impl. of check_schema() , gather all errors instead of throwing on first error
     validator_cls = validator_for(SchemaValidator.META_SCHEMA, default=SchemaValidator)
     metavalidator: SchemaValidator = validator_cls(
-        SchemaValidator.META_SCHEMA, format_checker=SchemaValidator.FORMAT_CHECKER
+        SchemaValidator.META_SCHEMA,
+        format_checker=SchemaValidator.FORMAT_CHECKER,
     )
     return [
         f'{error.json_path} : {error.message}' for error in metavalidator.iter_errors(json_schema)
@@ -120,7 +132,10 @@ class GenerateTypedJsonSchema(GenerateJsonSchema):
             ref_parts = self.ref_template.split('/')[1:-1]
             defs_schema = build_nested_dict(ref_parts, defs)
 
-            for default, inner_schema in self.intersect_sdk_postgeneration_defaults:
+            for (
+                default,
+                inner_schema,
+            ) in self.intersect_sdk_postgeneration_defaults:
                 final_schema = {**defs_schema, **inner_schema}
                 try:
                     validate_against_schema(final_schema, default)
@@ -146,7 +161,8 @@ class GenerateTypedJsonSchema(GenerateJsonSchema):
             The generated JSON schema.
         """
         return self.handle_invalid_for_json_schema(
-            schema, 'Any or object : dynamic typing is not allowed for INTERSECT schemas'
+            schema,
+            'Any or object : dynamic typing is not allowed for INTERSECT schemas',
         )
 
     def is_subclass_schema(self, schema: core_schema.IsSubclassSchema) -> JsonSchemaValue:
@@ -249,12 +265,14 @@ class GenerateTypedJsonSchema(GenerateJsonSchema):
         """
         if not schema.get('items_schema'):
             return self.handle_invalid_for_json_schema(
-                schema, 'generator yield subtyping (first argument) may not be dynamic in INTERSECT'
+                schema,
+                'generator yield subtyping (first argument) may not be dynamic in INTERSECT',
             )
         json_schema = super().generator_schema(schema)
         if not json_schema.get('items'):
             return self.handle_invalid_for_json_schema(
-                schema, 'generator yield subtyping (first argument) may not be dynamic in INTERSECT'
+                schema,
+                'generator yield subtyping (first argument) may not be dynamic in INTERSECT',
             )
         return json_schema
 
@@ -281,7 +299,8 @@ class GenerateTypedJsonSchema(GenerateJsonSchema):
             )
         if 'values_schema' not in schema:
             return self.handle_invalid_for_json_schema(
-                schema, 'dict or mapping: value type cannot be Any/object for INTERSECT'
+                schema,
+                'dict or mapping: value type cannot be Any/object for INTERSECT',
             )
         keys_schema = self.generate_inner(schema['keys_schema']).copy()
         values_schema = self.generate_inner(schema['values_schema']).copy()
@@ -343,6 +362,19 @@ class GenerateTypedJsonSchema(GenerateJsonSchema):
             return json_schema
         default = schema['default']
 
+        # Sort set/frozenset defaults to ensure deterministic JSON schema generation
+        # We only sort if len > 1 because sets of size 0 or 1 are already deterministic
+        if isinstance(default, collections.abc.Set) and len(default) > 1:
+            try:
+                default = sorted(default)
+            except TypeError:
+                # If items aren't comparable (e.g. mixed types), we can't sort them.
+                # Unlike Pydantic, we will actually raise an error here, as we want to force deterministic schema generation
+                err_msg = (
+                    f'Do not use "{default}" as a default value: sets must contain the same types'
+                )
+                raise PydanticInvalidForJsonSchema(err_msg)  # noqa: B904 (TypeError provides indirection)
+
         try:
             encoded_default = self.encode_default(default)
         except PydanticSerializationError:
@@ -352,17 +384,22 @@ class GenerateTypedJsonSchema(GenerateJsonSchema):
                 f"Default value '{default}' is not JSON serializable; use pydantic.Field's 'default_factory' argument for this.",
             )
 
-        if '$ref' in json_schema:
-            # TODO - not best way to handle this
-            # validate this default later, when all $refs have been resolved
-            # IMPORTANT!!! You must send the "json_schema" object itself, it will be modified later internally by Pydantic
+        def postpone_default_validation(json_schema: Any, encoded_default: Any) -> dict[str, Any]:
             self.intersect_sdk_postgeneration_defaults.append((encoded_default, json_schema))
             # Since reference schemas do not support child keys, we wrap the reference schema in a single-case allOf:
             return {'allOf': [json_schema], 'default': encoded_default}
 
-        # if this schema does not have a $ref, we should instead validate immediately
+        # check if the schema has $ref in it directly
+        # if it does, we must validate this during $ref construction
+        if '$ref' in json_schema:
+            return postpone_default_validation(json_schema, encoded_default)
+
         try:
             validate_against_schema(json_schema, encoded_default)
+        except Unresolvable:
+            # this will sometimes happen with boolean schema composition keywords, i.e. oneOf or anyOf, IF these contain $ref keywords themselves
+            # we can recover from this by postponing validation
+            return postpone_default_validation(json_schema, encoded_default)
         except SchemaValidationError as e:
             err_msg = f"Default value '{default}' does not validate against schema\n{e}"
             raise PydanticInvalidForJsonSchema(err_msg) from e
@@ -479,7 +516,9 @@ class GenerateTypedJsonSchema(GenerateJsonSchema):
         return super().kw_arguments_schema(arguments, var_kwargs_schema)
 
     def p_arguments_schema(
-        self, arguments: list[core_schema.ArgumentsParameter], var_args_schema: CoreSchema | None
+        self,
+        arguments: list[core_schema.ArgumentsParameter],
+        var_args_schema: CoreSchema | None,
     ) -> JsonSchemaValue:
         """Generates a JSON schema that matches a schema that defines a function's positional arguments.