Schema-First 0.4.0__tar.gz → 0.5.0__tar.gz

{schema_first-0.4.0/src/Schema_First.egg-info → schema_first-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Schema-First
-Version: 0.4.0
+Version: 0.5.0
 Summary: OpenAPI specification validator and converter to Marshmallow schemas.
 Author-email: Konstantin Fadeev <fadeev@legalact.pro>
 License: MIT License
@@ -30,7 +30,7 @@ Project-URL: repository, https://github.com/flask-pro/schema-first
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.14
+Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: marshmallow>=4.0.0

{schema_first-0.4.0 → schema_first-0.5.0}/pyproject.toml

@@ -19,8 +19,8 @@ description = "OpenAPI specification validator and converter to Marshmallow sche
 license = {file = "LICENSE"}
 name = "Schema-First"
 readme = "README.md"
-requires-python = ">=3.14"
-version = "0.4.0"
+requires-python = ">=3.13"
+version = "0.5.0"
 
 [project.optional-dependencies]
 dev = [

{schema_first-0.4.0 → schema_first-0.5.0/src/Schema_First.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Schema-First
-Version: 0.4.0
+Version: 0.5.0
 Summary: OpenAPI specification validator and converter to Marshmallow schemas.
 Author-email: Konstantin Fadeev <fadeev@legalact.pro>
 License: MIT License
@@ -30,7 +30,7 @@ Project-URL: repository, https://github.com/flask-pro/schema-first
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.14
+Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: marshmallow>=4.0.0

{schema_first-0.4.0 → schema_first-0.5.0}/src/schema_first/openapi/schemas/v3_1_1/schema_object_schema.py

@@ -1,6 +1,9 @@
+from collections.abc import Mapping, Sequence
 import re
+import typing
 
 from marshmallow import fields
+from marshmallow import types
 from marshmallow import validate
 from marshmallow import validates
 from marshmallow import validates_schema
@@ -12,6 +15,12 @@ from ..constants import TYPES
 from ..fields import DESCRIPTION_FIELD
 
 
+class BaseSchemaField(BaseSchema):
+    type = fields.String(required=True, validate=validate.OneOf(TYPES))
+    description = DESCRIPTION_FIELD
+    nullable = fields.Boolean()
+
+
 class FormatBinarySchema(BaseSchema):
     default = fields.String()
 
@@ -61,11 +70,12 @@ format_schemas = {
 }
 
 
-class StringFieldSchema(BaseSchema):
+class StringFieldSchema(BaseSchemaField):
     format = fields.String(validate=validate.OneOf(FORMATS))
     minLength = fields.Integer(validate=[validate.Range(min=0)])
     maxLength = fields.Integer(validate=[validate.Range(min=0)])
     pattern = fields.String()
+    default = fields.String()
 
     @validates('pattern')
     def validate_pattern(self, value: str, data_key: str) -> None:
@@ -93,15 +103,11 @@ class StringFieldSchema(BaseSchema):
         if 'minLength' in data and 'maxLength' in data:
             if data['minLength'] > data['maxLength']:
                 raise ValidationError(
-                    f'<{data['minLength']}> cannot be greater than <{data['maxLength']}>'
+                    f'<{data["minLength"]}> cannot be greater than <{data["maxLength"]}>'
                 )
 
 
-class SchemaObjectSchema(StringFieldSchema):
-    type = fields.String(required=True, validate=validate.OneOf(TYPES))
-    default = fields.String()
-    description = DESCRIPTION_FIELD
-    nullable = fields.Boolean()
+class ObjectFieldSchema(BaseSchemaField):
     required = fields.List(fields.String())
     additionalProperties = fields.Boolean()
 
@@ -118,3 +124,39 @@ class SchemaObjectSchema(StringFieldSchema):
                     raise ValidationError(
                         f'Required field <{field_name}> not in <data["properties"]>'
                     )
+
+
+class BooleanFieldSchema(BaseSchemaField):
+    default = fields.Boolean(truthy=[True], falsy=[False])
+
+    @validates_schema
+    def validate_default(self, data, **kwargs):
+        if 'default' in data:
+            if not isinstance(data['default'], bool):
+                raise ValidationError(f'<{data["default"]}> is not boolean.')
+
+
+field_schemas = {
+    'boolean': BooleanFieldSchema,
+    'object': ObjectFieldSchema,
+    'string': StringFieldSchema,
+}
+
+
+class SchemaObjectSchema(BaseSchema):
+    type = fields.String(required=True, validate=validate.OneOf(TYPES))
+
+    def load(
+        self,
+        data: Mapping[str, typing.Any] | Sequence[Mapping[str, typing.Any]],
+        *,
+        many: bool | None = None,
+        partial: bool | types.StrSequenceOrSet | None = None,
+        unknown: types.UnknownOption | None = None,
+    ):
+        try:
+            return field_schemas[data['type']]().load(
+                data, many=many, partial=partial, unknown=unknown
+            )
+        except KeyError:
+            raise ValidationError(f'Data type <{data["type"]}> not supported.')

{schema_first-0.4.0 → schema_first-0.5.0}/src/schema_first/specification/__init__.py

@@ -71,11 +71,32 @@ class Specification:
         initialized_schema.required = required
         return initialized_schema
 
-    def _convert_field_any_type(self, field_schema: dict, required: bool = False) -> dict:
-        if field_schema['type'] == 'string':
-            converted_field_schema = self._convert_string_field(field_schema, required=required)
-        else:
-            raise NotImplementedError(field_schema)
+    def _convert_boolean_field(self, field_schema: dict, required: bool = False):
+        try:
+            schema = FIELDS_VIA_TYPES[field_schema['type']]
+        except KeyError:
+            raise NotImplementedError(
+                f'Schema <{field_schema}> for type <{field_schema["type"]}> not implemented.'
+            )
+
+        initialized_schema = schema()
+        initialized_schema.allow_none = field_schema.get('nullable', False)
+        initialized_schema.required = required
+        return initialized_schema
+
+    def _convert_field_any_type(self, field_schema: dict, required: bool = False):
+        field_schema_converters = {
+            'string': self._convert_string_field,
+            'boolean': self._convert_boolean_field,
+        }
+        try:
+            converted_field_schema = field_schema_converters[field_schema['type']](
+                field_schema, required=required
+            )
+        except KeyError:
+            raise NotImplementedError(
+                f'Schema <{field_schema}> for type <{field_schema["type"]}> not be converted.'
+            )
 
         return converted_field_schema
 

{schema_first-0.4.0 → schema_first-0.5.0}/tests/test_specification.py

@@ -1,13 +1,15 @@
 from marshmallow import fields
 from marshmallow import Schema
+import pytest
 
 from src.schema_first.openapi import OpenAPI
 from src.schema_first.specification import Specification
 from tests.utils import get_schema_from_request
 
 
-def test_specification__required(fx_spec_required, fx_spec_as_file):
-    spec_file = fx_spec_as_file(fx_spec_required)
+@pytest.mark.parametrize('fx', ['fx_spec_required', 'fx_spec_full'])
+def test_specification(request, fx, fx_spec_as_file):
+    spec_file = fx_spec_as_file(request.getfixturevalue(fx))
     spec = Specification(spec_file)
 
     assert isinstance(spec.openapi, OpenAPI)
@@ -16,18 +18,6 @@ def test_specification__required(fx_spec_required, fx_spec_as_file):
     spec.load()
 
     request_schema = get_schema_from_request(spec.reassembly_spec, '/endpoint', '200')
+    assert isinstance(request_schema(), Schema)
     assert isinstance(request_schema().fields['message'], fields.String)
     assert request_schema().load({'message': 'Valid string'})
-
-
-def test_specification__full(fx_spec_full, fx_spec_as_file):
-    spec_file = fx_spec_as_file(fx_spec_full)
-    spec = Specification(spec_file)
-
-    assert isinstance(spec.openapi, OpenAPI)
-    assert spec.reassembly_spec is None
-
-    spec.load()
-
-    request_schema = get_schema_from_request(spec.reassembly_spec, '/endpoint', '200')
-    assert isinstance(request_schema(), Schema)