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

{schema_first-0.3.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.3.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,14 +30,14 @@ 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
 Requires-Dist: PyYAML>=6.0.2
 Provides-Extra: dev
 Requires-Dist: bandit==1.8.6; extra == "dev"
-Requires-Dist: build==1.2.1; extra == "dev"
+Requires-Dist: build==1.3.0; extra == "dev"
 Requires-Dist: openapi-spec-validator>=0.5.0; extra == "dev"
 Requires-Dist: pre-commit==4.2.0; extra == "dev"
 Requires-Dist: pytest==8.4.1; extra == "dev"

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

@@ -19,13 +19,13 @@ description = "OpenAPI specification validator and converter to Marshmallow sche
 license = {file = "LICENSE"}
 name = "Schema-First"
 readme = "README.md"
-requires-python = ">=3.14"
-version = "0.3.0"
+requires-python = ">=3.13"
+version = "0.5.0"
 
 [project.optional-dependencies]
 dev = [
   "bandit==1.8.6",
-  "build==1.2.1",
+  "build==1.3.0",
   'openapi-spec-validator>=0.5.0',
   "pre-commit==4.2.0",
   "pytest==8.4.1",
@@ -53,10 +53,6 @@ target-version = ['py313']
 profile = "google"
 src_paths = ["src", "tests"]
 
-[tool.pycln]
-all = true
-silence = true
-
 [tool.setuptools.packages.find]
 include = ["schema_first*"]
 where = ["src"]

{schema_first-0.3.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.3.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,14 +30,14 @@ 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
 Requires-Dist: PyYAML>=6.0.2
 Provides-Extra: dev
 Requires-Dist: bandit==1.8.6; extra == "dev"
-Requires-Dist: build==1.2.1; extra == "dev"
+Requires-Dist: build==1.3.0; extra == "dev"
 Requires-Dist: openapi-spec-validator>=0.5.0; extra == "dev"
 Requires-Dist: pre-commit==4.2.0; extra == "dev"
 Requires-Dist: pytest==8.4.1; extra == "dev"

{schema_first-0.3.0 → schema_first-0.5.0}/src/Schema_First.egg-info/requires.txt

@@ -3,7 +3,7 @@ PyYAML>=6.0.2
 
 [dev]
 bandit==1.8.6
-build==1.2.1
+build==1.3.0
 openapi-spec-validator>=0.5.0
 pre-commit==4.2.0
 pytest==8.4.1

{schema_first-0.3.0 → schema_first-0.5.0}/src/schema_first/openapi/__init__.py

@@ -1,4 +1,5 @@
 from pathlib import Path
+from pprint import pformat
 
 from marshmallow import ValidationError
 
@@ -16,4 +17,4 @@ class OpenAPI:
         try:
             return RootSchema().load(self.raw_spec)
         except ValidationError as e:
-            raise OpenAPIValidationError(e)
+            raise OpenAPIValidationError(f'\n{pformat(e.messages)}')

schema_first-0.5.0/src/schema_first/openapi/schemas/v3_1_1/schema_object_schema.py

@@ -0,0 +1,162 @@
+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
+from marshmallow import ValidationError
+
+from ..base import BaseSchema
+from ..constants import FORMATS
+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()
+
+
+class FormatEmailSchema(BaseSchema):
+    default = fields.Email()
+
+
+class FormatDateSchema(BaseSchema):
+    default = fields.Date()
+
+
+class FormatDateTimeSchema(BaseSchema):
+    default = fields.AwareDateTime(format='iso', default_timezone=None)
+
+
+class FormatIPv4Schema(BaseSchema):
+    default = fields.IPv4()
+
+
+class FormatIPv6Schema(BaseSchema):
+    default = fields.IPv6()
+
+
+class FormatTimeSchema(BaseSchema):
+    default = fields.Time(format='iso')
+
+
+class FormatURISchema(BaseSchema):
+    default = fields.URL()
+
+
+class FormatUUIDSchema(BaseSchema):
+    default = fields.UUID()
+
+
+format_schemas = {
+    'binary': FormatBinarySchema,
+    'date': FormatDateSchema,
+    'date-time': FormatDateTimeSchema,
+    'email': FormatEmailSchema,
+    'ipv4': FormatIPv4Schema,
+    'ipv6': FormatIPv6Schema,
+    'time': FormatTimeSchema,
+    'uri': FormatURISchema,
+    'uuid': FormatUUIDSchema,
+}
+
+
+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:
+        try:
+            re.compile(value)
+        except re.PatternError as e:
+            raise ValidationError(f"Pattern <{value}> is error <{repr(e)}>.")
+
+    @validates_schema
+    def validate_default(self, data, **kwargs):
+        if 'default' in data and 'pattern' in data:
+            result = re.match(data['pattern'], data['default'])
+            if result is None:
+                raise ValidationError(f'<{data["default"]}> does not match <{data["pattern"]}>')
+
+    @validates_schema
+    def validate_default_via_format(self, data, **kwargs):
+        if 'default' in data and 'format' in data:
+            error = format_schemas[data['format']]().validate({'default': data['default']})
+            if error:
+                raise ValidationError(str(error))
+
+    @validates_schema
+    def validate_length(self, data, **kwargs):
+        if 'minLength' in data and 'maxLength' in data:
+            if data['minLength'] > data['maxLength']:
+                raise ValidationError(
+                    f'<{data["minLength"]}> cannot be greater than <{data["maxLength"]}>'
+                )
+
+
+class ObjectFieldSchema(BaseSchemaField):
+    required = fields.List(fields.String())
+    additionalProperties = fields.Boolean()
+
+    properties = fields.Dict(
+        keys=fields.String(required=True, validate=validate.Length(min=1)),
+        values=fields.Nested(lambda: SchemaObjectSchema()),
+    )
+
+    @validates_schema
+    def validate_required(self, data, **kwargs):
+        if 'required' in data:
+            for field_name in data['required']:
+                if field_name not in data['properties']:
+                    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.5.0/src/schema_first/specification/__init__.py

@@ -0,0 +1,139 @@
+from copy import deepcopy
+from pathlib import Path
+from typing import Any
+
+from marshmallow import fields
+from marshmallow import INCLUDE
+from marshmallow import RAISE
+from marshmallow import Schema
+from marshmallow import validate
+
+from ..openapi import OpenAPI
+
+FIELDS_VIA_TYPES = {
+    'boolean': fields.Boolean,
+    'number': fields.Float,
+    'string': fields.String,
+    'integer': fields.Integer,
+}
+
+FIELDS_VIA_FORMATS = {
+    'uuid': fields.UUID,
+    'date-time': fields.AwareDateTime,
+    'date': fields.Date,
+    'time': fields.Time,
+    'email': fields.Email,
+    'ipv4': fields.IPv4,
+    'ipv6': fields.IPv6,
+    'uri': fields.Url,
+    'binary': fields.String,
+    'string': fields.String,
+}
+
+
+class Specification:
+    def __init__(self, spec_file: Path | str):
+        self.openapi = OpenAPI(spec_file)
+        self.reassembly_spec = None
+
+    @staticmethod
+    def _make_field_validators(schema: dict) -> list[validate.Validator]:
+        validators = []
+
+        if schema['type'] in ['string']:
+            validators.append(
+                validate.Length(min=schema.get('minLength'), max=schema.get('maxLength'))
+            )
+            if schema.get('pattern'):
+                validators.append(validate.Regexp(schema['pattern']))
+
+        if schema['type'] in ['integer', 'number']:
+            validators.append(validate.Range(min=schema.get('minimum'), max=schema.get('maximum')))
+
+        required_values = schema.get('enum')
+        if required_values:
+            validators.append(validate.OneOf(required_values))
+
+        return validators
+
+    def _convert_string_field(self, field_schema: dict, required: bool = False):
+        format_string = field_schema.get('format', 'string')
+        try:
+            schema = FIELDS_VIA_FORMATS[format_string]
+        except KeyError:
+            raise NotImplementedError(
+                f'Schema <{field_schema}> for format <{format_string}> not implemented.'
+            )
+
+        initialized_schema = schema()
+        initialized_schema.validate = self._make_field_validators(field_schema)
+        initialized_schema.allow_none = field_schema.get('nullable', False)
+        initialized_schema.required = required
+        return initialized_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
+
+    def _convert_from_openapi_to_marshmallow_schema(self, open_api_schema: dict) -> type[Schema]:
+        marshmallow_schema = {}
+        for field_name, field_schema in open_api_schema['properties'].items():
+            required_fields = open_api_schema.get('required', [])
+
+            if field_name in required_fields:
+                is_required = True
+            else:
+                is_required = False
+
+            marshmallow_schema[field_name] = self._convert_field_any_type(
+                field_schema, required=is_required
+            )
+
+        additionalProperties = open_api_schema.get('additionalProperties', True)
+        if additionalProperties is False:
+            marshmallow_schema['unknown'] = RAISE
+        else:
+            marshmallow_schema['unknown'] = INCLUDE
+
+        return Schema.from_dict(marshmallow_schema)
+
+    def _reassembly_of_schemas(self, obj: Any) -> Any:
+        if isinstance(obj, dict):
+            for k, v in obj.items():
+                if k == 'schema':
+                    obj[k] = self._convert_from_openapi_to_marshmallow_schema(v)
+                else:
+                    self._reassembly_of_schemas(v)
+
+    def load(self) -> 'Specification':
+        self.openapi.load()
+        self.reassembly_spec = deepcopy(self.openapi.raw_spec)
+
+        self._reassembly_of_schemas(self.reassembly_spec)
+
+        return self

schema_first-0.5.0/tests/test_specification.py

@@ -0,0 +1,23 @@
+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
+
+
+@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)
+    assert spec.reassembly_spec is None
+
+    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'})

{schema_first-0.3.0 → schema_first-0.5.0}/tests/test_validator.py

@@ -4,11 +4,11 @@ from src.schema_first.openapi import OpenAPI
 from src.schema_first.openapi import OpenAPIValidationError
 
 
-def test_validator_minimal(fx_spec_minimal, fx_spec_as_file):
-    spec_file = fx_spec_as_file(fx_spec_minimal)
+def test_validator_required(fx_spec_required, fx_spec_as_file):
+    spec_file = fx_spec_as_file(fx_spec_required)
     open_api_spec = OpenAPI(spec_file)
     open_api_spec.load()
-    assert open_api_spec.raw_spec == fx_spec_minimal
+    assert open_api_spec.raw_spec == fx_spec_required
 
 
 def test_validator__full(fx_spec_full, fx_spec_as_file):
@@ -18,8 +18,8 @@ def test_validator__full(fx_spec_full, fx_spec_as_file):
     assert open_api_spec.raw_spec == fx_spec_full
 
 
-def test_validator__minimal__external_validator(fx_spec_minimal, fx_spec_as_file):
-    spec_file = fx_spec_as_file(fx_spec_minimal, external_validator=True)
+def test_validator__required__external_validator(fx_spec_required, fx_spec_as_file):
+    spec_file = fx_spec_as_file(fx_spec_required, external_validator=True)
     open_api_spec = OpenAPI(spec_file)
     open_api_spec.load()
 
@@ -30,10 +30,10 @@ def test_validator__full__external_validator(fx_spec_full, fx_spec_as_file):
     open_api_spec.load()
 
 
-def test_validator__wrong_field_name(fx_spec_minimal, fx_spec_as_file):
-    fx_spec_minimal['wrong_field_name'] = 'wrong'
+def test_validator__wrong_field_name(fx_spec_required, fx_spec_as_file):
+    fx_spec_required['wrong_field_name'] = 'wrong'
 
-    spec_file = fx_spec_as_file(fx_spec_minimal)
+    spec_file = fx_spec_as_file(fx_spec_required)
 
     open_api_spec = OpenAPI(spec_file)
 

schema_first-0.3.0/src/schema_first/openapi/schemas/v3_1_1/schema_object_schema.py

@@ -1,17 +0,0 @@
-from marshmallow import fields
-from marshmallow import validate
-
-from ..base import BaseSchema
-from ..constants import FORMATS
-from ..constants import TYPES
-
-
-class SchemaObjectSchema(BaseSchema):
-    type = fields.String(required=True, validate=validate.OneOf(TYPES))
-
-    format = fields.String(validate=validate.OneOf(FORMATS))
-    pattern = fields.String()
-
-    properties = fields.Dict(
-        keys=fields.String(required=True), values=fields.Nested(lambda: SchemaObjectSchema())
-    )

schema_first-0.3.0/src/schema_first/specification/__init__.py

@@ -1,47 +0,0 @@
-from copy import deepcopy
-from pathlib import Path
-from typing import Any
-
-from marshmallow import fields
-from marshmallow import Schema
-
-from ..openapi import OpenAPI
-
-FIELDS_VIA_TYPES = {
-    'boolean': fields.Boolean,
-    'number': fields.Float,
-    'string': fields.String,
-    'integer': fields.Integer,
-}
-
-
-class Specification:
-    def __init__(self, spec_file: Path | str):
-        self.openapi = OpenAPI(spec_file)
-        self.reassembly_spec = None
-
-    def _convert_from_openapi_to_marshmallow_schema(self, open_api_schema: dict) -> type[Schema]:
-        if open_api_schema['type'] == 'object':
-            marshmallow_schema = {}
-            for field_name, field in open_api_schema['properties'].items():
-                marshmallow_schema[field_name] = FIELDS_VIA_TYPES[field['type']]()
-        else:
-            raise NotImplementedError(open_api_schema)
-
-        return Schema.from_dict(marshmallow_schema)
-
-    def _reassembly_of_schemas(self, obj: Any) -> Any:
-        if isinstance(obj, dict):
-            for k, v in obj.items():
-                if k == 'schema':
-                    obj[k] = self._convert_from_openapi_to_marshmallow_schema(v)
-                else:
-                    self._reassembly_of_schemas(v)
-
-    def load(self) -> 'Specification':
-        self.openapi.load()
-        self.reassembly_spec = deepcopy(self.openapi.raw_spec)
-
-        self._reassembly_of_schemas(self.reassembly_spec)
-
-        return self

schema_first-0.3.0/tests/test_specification.py

@@ -1,33 +0,0 @@
-from marshmallow import fields
-
-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__minimal(fx_spec_minimal, fx_spec_as_file):
-    spec_file = fx_spec_as_file(fx_spec_minimal)
-    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().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().fields['message'], fields.String)
-    assert request_schema().load({'message': 'Valid string'})