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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Schema-First
-Version: 0.4.0
+Version: 0.11.0
 Summary: OpenAPI specification validator and converter to Marshmallow schemas.
 Author-email: Konstantin Fadeev <fadeev@legalact.pro>
 License: MIT License
@@ -30,20 +30,20 @@ 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
+Requires-Dist: PyYAML>=6.0.3
 Provides-Extra: dev
-Requires-Dist: bandit==1.8.6; 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"
-Requires-Dist: pytest-cov==6.2.1; extra == "dev"
-Requires-Dist: python-dotenv==1.1.1; extra == "dev"
-Requires-Dist: twine==6.1.0; extra == "dev"
+Requires-Dist: bandit>=1.9.3; extra == "dev"
+Requires-Dist: build>=1.4.0; extra == "dev"
+Requires-Dist: openapi-spec-validator>=0.7.1; extra == "dev"
+Requires-Dist: pre-commit>=4.5.1; extra == "dev"
+Requires-Dist: pytest>=9.0.2; extra == "dev"
+Requires-Dist: pytest-cov>=7.0.0; extra == "dev"
+Requires-Dist: python-dotenv>=1.2.1; extra == "dev"
+Requires-Dist: twine==6.2.0; extra == "dev"
 Dynamic: license-file
 
 # Schema-First

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

@@ -13,25 +13,25 @@ classifiers = [
 ]
 dependencies = [
   'marshmallow>=4.0.0',
-  'PyYAML>=6.0.2'
+  'PyYAML>=6.0.3'
 ]
 description = "OpenAPI specification validator and converter to Marshmallow schemas."
 license = {file = "LICENSE"}
 name = "Schema-First"
 readme = "README.md"
-requires-python = ">=3.14"
-version = "0.4.0"
+requires-python = ">=3.13"
+version = "0.11.0"
 
 [project.optional-dependencies]
 dev = [
-  "bandit==1.8.6",
-  "build==1.3.0",
-  'openapi-spec-validator>=0.5.0',
-  "pre-commit==4.2.0",
-  "pytest==8.4.1",
-  "pytest-cov==6.2.1",
-  "python-dotenv==1.1.1",
-  "twine==6.1.0"
+  "bandit>=1.9.3",
+  "build>=1.4.0",
+  'openapi-spec-validator>=0.7.1',
+  "pre-commit>=4.5.1",
+  "pytest>=9.0.2",
+  "pytest-cov>=7.0.0",
+  "python-dotenv>=1.2.1",
+  "twine==6.2.0"
 ]
 
 [project.urls]

{schema_first-0.4.0 → schema_first-0.11.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.11.0
 Summary: OpenAPI specification validator and converter to Marshmallow schemas.
 Author-email: Konstantin Fadeev <fadeev@legalact.pro>
 License: MIT License
@@ -30,20 +30,20 @@ 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
+Requires-Dist: PyYAML>=6.0.3
 Provides-Extra: dev
-Requires-Dist: bandit==1.8.6; 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"
-Requires-Dist: pytest-cov==6.2.1; extra == "dev"
-Requires-Dist: python-dotenv==1.1.1; extra == "dev"
-Requires-Dist: twine==6.1.0; extra == "dev"
+Requires-Dist: bandit>=1.9.3; extra == "dev"
+Requires-Dist: build>=1.4.0; extra == "dev"
+Requires-Dist: openapi-spec-validator>=0.7.1; extra == "dev"
+Requires-Dist: pre-commit>=4.5.1; extra == "dev"
+Requires-Dist: pytest>=9.0.2; extra == "dev"
+Requires-Dist: pytest-cov>=7.0.0; extra == "dev"
+Requires-Dist: python-dotenv>=1.2.1; extra == "dev"
+Requires-Dist: twine==6.2.0; extra == "dev"
 Dynamic: license-file
 
 # Schema-First

{schema_first-0.4.0 → schema_first-0.11.0}/src/Schema_First.egg-info/SOURCES.txt

@@ -17,20 +17,25 @@ src/schema_first/openapi/schemas/__init__.py
 src/schema_first/openapi/schemas/base.py
 src/schema_first/openapi/schemas/constants.py
 src/schema_first/openapi/schemas/fields.py
+src/schema_first/openapi/schemas/validators.py
 src/schema_first/openapi/schemas/v3_1_1/components_object_schema.py
-src/schema_first/openapi/schemas/v3_1_1/contact_schema.py
-src/schema_first/openapi/schemas/v3_1_1/info_schema.py
-src/schema_first/openapi/schemas/v3_1_1/license_schema.py
+src/schema_first/openapi/schemas/v3_1_1/contact_object_schema.py
+src/schema_first/openapi/schemas/v3_1_1/example_object_schema.py
+src/schema_first/openapi/schemas/v3_1_1/external_docs_object_schema.py
+src/schema_first/openapi/schemas/v3_1_1/info_object_schema.py
+src/schema_first/openapi/schemas/v3_1_1/license_object_schema.py
 src/schema_first/openapi/schemas/v3_1_1/media_type_object_schema.py
+src/schema_first/openapi/schemas/v3_1_1/openapi_object_schema.py
 src/schema_first/openapi/schemas/v3_1_1/operation_object_schema.py
+src/schema_first/openapi/schemas/v3_1_1/parameter_object_schema.py
 src/schema_first/openapi/schemas/v3_1_1/path_item_object_schema.py
 src/schema_first/openapi/schemas/v3_1_1/reference_object_schema.py
 src/schema_first/openapi/schemas/v3_1_1/request_body_object_schema.py
 src/schema_first/openapi/schemas/v3_1_1/responses_object_schema.py
-src/schema_first/openapi/schemas/v3_1_1/root_schema.py
 src/schema_first/openapi/schemas/v3_1_1/schema_object_schema.py
-src/schema_first/openapi/schemas/v3_1_1/server_schema.py
+src/schema_first/openapi/schemas/v3_1_1/server_object_schema.py
 src/schema_first/openapi/schemas/v3_1_1/server_variable_object_schema.py
+src/schema_first/openapi/schemas/v3_1_1/tag_object_schema.py
 src/schema_first/specification/__init__.py
 tests/test_specification.py
 tests/test_validator.py

schema_first-0.11.0/src/Schema_First.egg-info/requires.txt

@@ -0,0 +1,12 @@
+marshmallow>=4.0.0
+PyYAML>=6.0.3
+
+[dev]
+bandit>=1.9.3
+build>=1.4.0
+openapi-spec-validator>=0.7.1
+pre-commit>=4.5.1
+pytest>=9.0.2
+pytest-cov>=7.0.0
+python-dotenv>=1.2.1
+twine==6.2.0

{schema_first-0.4.0 → schema_first-0.11.0}/src/schema_first/openapi/__init__.py

@@ -5,7 +5,7 @@ from marshmallow import ValidationError
 
 from ..loaders.yaml_loader import load_from_yaml
 from .exc import OpenAPIValidationError
-from .schemas.v3_1_1.root_schema import RootSchema
+from .schemas.v3_1_1.openapi_object_schema import OpenAPIObjectSchema
 
 
 class OpenAPI:
@@ -15,6 +15,6 @@ class OpenAPI:
 
     def load(self) -> dict:
         try:
-            return RootSchema().load(self.raw_spec)
+            return OpenAPIObjectSchema().load(self.raw_spec)
         except ValidationError as e:
             raise OpenAPIValidationError(f'\n{pformat(e.messages)}')

{schema_first-0.4.0 → schema_first-0.11.0}/src/schema_first/openapi/schemas/base.py

@@ -3,6 +3,9 @@ from marshmallow import Schema
 from marshmallow import validates_schema
 from marshmallow import ValidationError
 
+from .fields import DESCRIPTION_FIELD
+from .fields import SUMMARY_FIELD
+
 
 class BaseSchema(Schema):
     class Meta:
@@ -18,3 +21,8 @@ class BaseSchema(Schema):
                     f"If there is a <'ref'> field, then only <{ALLOWED_FIELDS}>,"
                     f" but set <{ALL_FIELDS}>"
                 )
+
+
+class DocStringFields(Schema):
+    summary = SUMMARY_FIELD
+    description = DESCRIPTION_FIELD

{schema_first-0.4.0 → schema_first-0.11.0}/src/schema_first/openapi/schemas/constants.py

@@ -1,5 +1,8 @@
-OPENAPI_VERSION = '3.1.1'
+OPENAPI_VERSION_3_2 = '3.2'
 TYPES = ('array', 'boolean', 'integer', 'number', 'object', 'string')
 FORMATS = ('uuid', 'date-time', 'date', 'time', 'email', 'ipv4', 'ipv6', 'uri', 'binary')
+INT_FORMATS = ('int32', 'int64')
+FLOAT_FORMATS = ('float', 'double')
 RE_VERSION = r'^[0-9]+.[0-9]+.[0-9]+$'
 RE_SERVER_URL = r'^((http|https)://)|(/)*$'
+LOCATION_PARAMETER = ('query', 'querystring', 'header', 'path', 'cookie')

{schema_first-0.4.0 → schema_first-0.11.0}/src/schema_first/openapi/schemas/fields.py

@@ -3,8 +3,8 @@ from marshmallow import validate
 
 ENDPOINT_FIELD = fields.String(required=True, validate=validate.Regexp(r'^[/][0-9a-z-{}/]*[^/]$'))
 HTTP_CODE_FIELD = fields.String(required=True, validate=validate.Regexp(r'^[1-5]{1}\d{2}|default$'))
-SUMMARY_FIELD = fields.String()
-DESCRIPTION_FIELD = fields.String()
+SUMMARY_FIELD = fields.String(validate=validate.Length(min=1, max=150))
+DESCRIPTION_FIELD = fields.String(validate=validate.Length(min=1))
 REQUIRED_DESCRIPTION_FIELD = fields.String(required=True)
 MEDIA_TYPE_FIELD = fields.String(required=True)
 REF_FIELD = fields.String(

{schema_first-0.4.0 → schema_first-0.11.0}/src/schema_first/openapi/schemas/v3_1_1/components_object_schema.py

@@ -1,13 +1,13 @@
 from marshmallow import fields
 
 from ..base import BaseSchema
-from .responses_object_schema import ResponsesObjectSchema
+from .responses_object_schema import ResponseObjectSchema
 from .schema_object_schema import SchemaObjectSchema
 
 
 class ComponentsObjectSchema(BaseSchema):
     responses = fields.Dict(
-        keys=fields.String(), values=fields.Nested(ResponsesObjectSchema, required=True)
+        keys=fields.String(), values=fields.Nested(ResponseObjectSchema, required=True)
     )
     schemas = fields.Dict(
         keys=fields.String(), values=fields.Nested(SchemaObjectSchema, required=True)

schema_first-0.4.0/src/schema_first/openapi/schemas/v3_1_1/contact_schema.py → schema_first-0.11.0/src/schema_first/openapi/schemas/v3_1_1/contact_object_schema.py

@@ -3,7 +3,7 @@ from marshmallow import fields
 from ..base import BaseSchema
 
 
-class ContactSchema(BaseSchema):
+class ContactObjectSchema(BaseSchema):
     name = fields.String()
     url = fields.URL()
     email = fields.Email()

schema_first-0.11.0/src/schema_first/openapi/schemas/v3_1_1/example_object_schema.py

@@ -0,0 +1,21 @@
+from marshmallow import fields
+from marshmallow import validate
+from marshmallow import validates_schema
+from marshmallow import ValidationError
+
+from ..base import BaseSchema
+from ..base import DocStringFields
+from .schema_object_schema import SchemaObjectSchema
+
+
+class ExampleObjectSchema(DocStringFields, BaseSchema):
+    dataValue = fields.Nested(SchemaObjectSchema)
+    serializedValue = fields.String(validate=validate.Length(min=1))
+    externalValue = fields.String(validate=validate.Length(min=1))
+
+    @validates_schema
+    def validate_exclusive(self, data, **kwargs) -> None:
+        if 'serializedValue' in data and 'externalValue' in data:
+            raise ValidationError(
+                'The <serializedValue> field is mutually exclusive of the <externalValue> field.'
+            )

schema_first-0.11.0/src/schema_first/openapi/schemas/v3_1_1/external_docs_object_schema.py

@@ -0,0 +1,13 @@
+from marshmallow import fields
+from marshmallow import validate
+
+from ..base import BaseSchema
+from ..constants import RE_SERVER_URL
+from ..fields import DESCRIPTION_FIELD
+
+
+class ExternalDocsObjectSchema(BaseSchema):
+    url = fields.String(
+        required=True, validate=[validate.Regexp(RE_SERVER_URL), validate.Length(min=1)]
+    )
+    description = DESCRIPTION_FIELD

schema_first-0.11.0/src/schema_first/openapi/schemas/v3_1_1/info_object_schema.py

@@ -0,0 +1,18 @@
+from marshmallow import fields
+from marshmallow import validate
+
+from ..base import BaseSchema
+from ..base import DocStringFields
+from ..constants import RE_VERSION
+from .contact_object_schema import ContactObjectSchema
+from .license_object_schema import LicenseObjectSchema
+
+
+class InfoObjectSchema(DocStringFields, BaseSchema):
+    title = fields.String(required=True)
+    version = fields.String(required=True, validate=validate.Regexp(RE_VERSION))
+
+    termsOfService = fields.String()
+
+    contact = fields.Nested(ContactObjectSchema)
+    license = fields.Nested(LicenseObjectSchema)

schema_first-0.4.0/src/schema_first/openapi/schemas/v3_1_1/license_schema.py → schema_first-0.11.0/src/schema_first/openapi/schemas/v3_1_1/license_object_schema.py

@@ -5,7 +5,7 @@ from marshmallow import ValidationError
 from ..base import BaseSchema
 
 
-class LicenseSchema(BaseSchema):
+class LicenseObjectSchema(BaseSchema):
     name = fields.String(required=True)
 
     identifier = fields.String()

{schema_first-0.4.0 → schema_first-0.11.0}/src/schema_first/openapi/schemas/v3_1_1/media_type_object_schema.py

@@ -1,8 +1,11 @@
 from marshmallow import fields
 
 from ..base import BaseSchema
+from .example_object_schema import ExampleObjectSchema
 from .schema_object_schema import SchemaObjectSchema
 
 
 class MediaTypeObjectSchema(BaseSchema):
     schema = fields.Nested(SchemaObjectSchema)
+    itemSchema = fields.Nested(SchemaObjectSchema)
+    examples = fields.Dict(keys=fields.String(), values=fields.Nested(ExampleObjectSchema))

schema_first-0.11.0/src/schema_first/openapi/schemas/v3_1_1/openapi_object_schema.py

@@ -0,0 +1,57 @@
+from marshmallow import fields
+from marshmallow import post_load
+from marshmallow import validates_schema
+from marshmallow import ValidationError
+
+from ..base import BaseSchema
+from ..constants import OPENAPI_VERSION_3_2
+from ..fields import ENDPOINT_FIELD
+from ..validators import VersionMatch
+from .components_object_schema import ComponentsObjectSchema
+from .external_docs_object_schema import ExternalDocsObjectSchema
+from .info_object_schema import InfoObjectSchema
+from .path_item_object_schema import PathItemObjectSchema
+from .server_object_schema import ServerObjectSchema
+from .tag_object_schema import TagObjectSchema
+
+
+class OpenAPIObjectSchema(BaseSchema):
+    openapi = fields.String(required=True, validate=VersionMatch(OPENAPI_VERSION_3_2))
+    info = fields.Nested(InfoObjectSchema, required=True)
+    paths = fields.Dict(
+        required=True,
+        keys=ENDPOINT_FIELD,
+        values=fields.Nested(PathItemObjectSchema, required=True),
+    )
+
+    jsonSchemaDialect = fields.URL()
+
+    servers = fields.Nested(ServerObjectSchema, many=True)
+    components = fields.Nested(ComponentsObjectSchema)
+    tags = fields.Nested(TagObjectSchema, many=True)
+    externalDocs = fields.Nested(ExternalDocsObjectSchema)
+
+    @validates_schema
+    def validate_tags(self, data, **kwargs):
+        if tags := data.get('tags'):
+            names = []
+            parents = []
+
+            for tag in tags:
+                names.append(tag['name'])
+
+                if parent := tag.get('parent'):
+                    parents.append(parent)
+
+            parents_not_in_names = [parent for parent in parents if parent not in names]
+            if parents_not_in_names:
+                raise ValidationError(f'Parents <{names}> not exist in names tags <{names}>.')
+
+    @post_load
+    def validate_path_parameter(self, data, **kwargs) -> None:
+        endpoints = data['paths'].keys()
+        for endpoint in endpoints:
+            if '{' in endpoint or '}' in endpoint:
+                raise NotImplementedError(
+                    'Need check path-parameters template in "parameters" key.'
+                )

schema_first-0.11.0/src/schema_first/openapi/schemas/v3_1_1/operation_object_schema.py

@@ -0,0 +1,21 @@
+from marshmallow import fields
+
+from ..base import BaseSchema
+from ..base import DocStringFields
+from ..fields import HTTP_CODE_FIELD
+from .external_docs_object_schema import ExternalDocsObjectSchema
+from .parameter_object_schema import ParameterObjectSchema
+from .request_body_object_schema import RequestBodyObject
+from .responses_object_schema import ResponseObjectSchema
+from .server_object_schema import ServerObjectSchema
+
+
+class OperationObjectSchema(DocStringFields, BaseSchema):
+    tags = fields.List(fields.String)
+    externalDocs = fields.Nested(ExternalDocsObjectSchema)
+    operationId = fields.String()
+    requestBody = fields.Nested(RequestBodyObject)
+    responses = fields.Dict(keys=HTTP_CODE_FIELD, values=fields.Nested(ResponseObjectSchema))
+    deprecated = fields.Boolean()
+    servers = fields.Nested(ServerObjectSchema, many=True)
+    parameters = fields.Nested(ParameterObjectSchema, many=True)

schema_first-0.11.0/src/schema_first/openapi/schemas/v3_1_1/parameter_object_schema.py

@@ -0,0 +1,17 @@
+from marshmallow import fields
+from marshmallow import validate
+
+from ..base import BaseSchema
+from ..constants import LOCATION_PARAMETER
+from ..fields import DESCRIPTION_FIELD
+from .example_object_schema import ExampleObjectSchema
+
+
+class ParameterObjectSchema(BaseSchema):
+    name = fields.String(required=True)
+    in_ = fields.String(required=True, data_key='in', validate=validate.OneOf(LOCATION_PARAMETER))
+
+    description = DESCRIPTION_FIELD
+    required = fields.Boolean()
+    deprecated = fields.Boolean()
+    examples = fields.Dict(keys=fields.String(), values=fields.Nested(ExampleObjectSchema))

schema_first-0.11.0/src/schema_first/openapi/schemas/v3_1_1/path_item_object_schema.py

@@ -0,0 +1,21 @@
+from marshmallow import fields
+
+from ..base import BaseSchema
+from ..base import DocStringFields
+from .operation_object_schema import OperationObjectSchema
+from .parameter_object_schema import ParameterObjectSchema
+from .server_object_schema import ServerObjectSchema
+
+
+class PathItemObjectSchema(DocStringFields, BaseSchema):
+    get = fields.Nested(OperationObjectSchema)
+    put = fields.Nested(OperationObjectSchema)
+    post = fields.Nested(OperationObjectSchema)
+    delete = fields.Nested(OperationObjectSchema)
+    options = fields.Nested(OperationObjectSchema)
+    head = fields.Nested(OperationObjectSchema)
+    patch = fields.Nested(OperationObjectSchema)
+    trace = fields.Nested(OperationObjectSchema)
+    query = fields.Nested(OperationObjectSchema)
+    servers = fields.Nested(ServerObjectSchema, many=True)
+    parameters = fields.Nested(ParameterObjectSchema, many=True)

schema_first-0.11.0/src/schema_first/openapi/schemas/v3_1_1/reference_object_schema.py

@@ -0,0 +1,7 @@
+from ..base import BaseSchema
+from ..base import DocStringFields
+from ..fields import REF_FIELD
+
+
+class ReferenceObjectSchema(DocStringFields, BaseSchema):
+    ref = REF_FIELD

{schema_first-0.4.0 → schema_first-0.11.0}/src/schema_first/openapi/schemas/v3_1_1/responses_object_schema.py

@@ -1,11 +1,10 @@
 from marshmallow import fields
 
 from ..base import BaseSchema
-from ..fields import DESCRIPTION_FIELD
+from ..base import DocStringFields
 from ..fields import MEDIA_TYPE_FIELD
 from .media_type_object_schema import MediaTypeObjectSchema
 
 
-class ResponsesObjectSchema(BaseSchema):
-    description = DESCRIPTION_FIELD
+class ResponseObjectSchema(DocStringFields, BaseSchema):
     content = fields.Dict(keys=MEDIA_TYPE_FIELD, values=fields.Nested(MediaTypeObjectSchema))

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

@@ -0,0 +1,242 @@
+from collections.abc import Mapping, Sequence
+import math
+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 schema_first.openapi.schemas.constants import FLOAT_FORMATS
+from schema_first.openapi.schemas.constants import INT_FORMATS
+
+from ..base import BaseSchema
+from ..base import DocStringFields
+from ..constants import FORMATS
+from ..constants import TYPES
+
+
+class BaseSchemaField(DocStringFields, BaseSchema):
+    type = fields.String(required=True, validate=validate.OneOf(TYPES))
+    nullable = fields.Boolean()
+
+    @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))
+
+
+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()
+
+
+class FormatINT32Schema(BaseSchema):
+    default = fields.Integer(validate=validate.Range(min=-2_147_483_648, max=2_147_483_647))
+
+
+class FormatINT64Schema(BaseSchema):
+    default = fields.Integer(
+        validate=validate.Range(min=-9_223_372_036_854_775_808, max=9_223_372_036_854_775_807)
+    )
+
+
+class FormatFloatSchema(BaseSchema):
+    default = fields.Float(validate=validate.Range(min=3.4e-38, max=3.4e38))
+
+
+class FormatDoubleSchema(BaseSchema):
+    default = fields.Float(validate=validate.Range(min=1.7e-308, max=1.7e308))
+
+
+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_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.')
+
+
+class NumberFieldSchema(BaseSchemaField):
+    format = fields.String(validate=validate.OneOf(FLOAT_FORMATS))
+    minimum = fields.Float()
+    maximum = fields.Float()
+    exclusiveMinimum = fields.Float()
+    exclusiveMaximum = fields.Float()
+    multipleOf = fields.Float(validate=[validate.Range(min=0, min_inclusive=False)])
+    default = fields.Float()
+
+    @validates_schema
+    def validate_default(self, data, **kwargs):
+        if 'default' in data:
+            default = data['default']
+
+            minimum = data.get('minimum', -math.inf)
+            maximum = data.get('maximum', math.inf)
+            if not minimum <= default <= maximum:
+                raise ValidationError(
+                    f'Value <{default}> must be greater than or equal to <{minimum}>'
+                    f' and less than or equal to <{maximum}>.'
+                )
+
+            exclusive_minimum = data.get('exclusiveMinimum', -math.inf)
+            exclusive_maximum = data.get('exclusiveMaximum', math.inf)
+            if not exclusive_minimum < default < exclusive_maximum:
+                raise ValidationError(
+                    f'Value <{default}> must be greater to <{minimum}> and less to <{maximum}>.'
+                )
+
+    @validates_schema
+    def validate_min_max(self, data, **kwargs):
+        if 'exclusiveMinimum' in data and 'exclusiveMaximum' in data:
+            exclusive_min = data['exclusiveMinimum']
+            exclusive_max = data['exclusiveMaximum']
+            if exclusive_min > exclusive_max:
+                raise ValidationError(f'<{exclusive_min}> cannot be greater than <{exclusive_max}>')
+
+        if 'minimum' in data and 'maximum' in data:
+            minimum = data['minimum']
+            maximum = data['maximum']
+            if minimum > maximum:
+                raise ValidationError(f'<{minimum}> cannot be greater than <{maximum}>')
+
+
+class IntegerFieldSchema(NumberFieldSchema):
+    format = fields.String(validate=validate.OneOf(INT_FORMATS))
+    minimum = fields.Integer()
+    maximum = fields.Integer()
+    exclusiveMinimum = fields.Integer()
+    exclusiveMaximum = fields.Integer()
+    multipleOf = fields.Integer(validate=[validate.Range(min=0, min_inclusive=False)])
+    default = fields.Integer()
+
+
+field_schemas = {
+    'boolean': BooleanFieldSchema,
+    'integer': IntegerFieldSchema,
+    'number': NumberFieldSchema,
+    'object': ObjectFieldSchema,
+    'string': StringFieldSchema,
+}
+
+format_schemas = {
+    'binary': FormatBinarySchema,
+    'date': FormatDateSchema,
+    'date-time': FormatDateTimeSchema,
+    'email': FormatEmailSchema,
+    'ipv4': FormatIPv4Schema,
+    'ipv6': FormatIPv6Schema,
+    'time': FormatTimeSchema,
+    'uri': FormatURISchema,
+    'uuid': FormatUUIDSchema,
+    'int32': FormatINT32Schema,
+    'int64': FormatINT64Schema,
+    'float': FormatFloatSchema,
+    'double': FormatDoubleSchema,
+}
+
+
+class SchemaObjectSchema(BaseSchemaField):
+    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 in <{data}> not exist.')

schema_first-0.4.0/src/schema_first/openapi/schemas/v3_1_1/server_schema.py → schema_first-0.11.0/src/schema_first/openapi/schemas/v3_1_1/server_object_schema.py

@@ -7,13 +7,12 @@ from ..fields import DESCRIPTION_FIELD
 from .server_variable_object_schema import ServerVariableObjectSchema
 
 
-class ServerSchema(BaseSchema):
+class ServerObjectSchema(BaseSchema):
     url = fields.String(
         required=True, validate=[validate.Regexp(RE_SERVER_URL), validate.Length(min=1)]
     )
-
     description = DESCRIPTION_FIELD
-
+    name = fields.String(validate=[validate.Length(min=1)])
     variables = fields.Dict(
         keys=fields.String(), values=fields.Nested(ServerVariableObjectSchema, required=True)
     )

schema_first-0.11.0/src/schema_first/openapi/schemas/v3_1_1/tag_object_schema.py

@@ -0,0 +1,15 @@
+from marshmallow import fields
+from marshmallow import validate
+
+from ..base import BaseSchema
+from ..base import DocStringFields
+from .external_docs_object_schema import ExternalDocsObjectSchema
+
+kinds = ['audience', 'badge', 'nav']
+
+
+class TagObjectSchema(DocStringFields, BaseSchema):
+    name = fields.String(required=True)
+    externalDocs = fields.Nested(ExternalDocsObjectSchema)
+    parent = fields.String()
+    kind = fields.String(validate=validate.OneOf(choices=kinds))

schema_first-0.11.0/src/schema_first/openapi/schemas/validators.py

@@ -0,0 +1,29 @@
+from marshmallow.exceptions import ValidationError
+from marshmallow.validate import Validator
+
+
+class VersionMatch(Validator):
+    """Version specification validator check minor and major parts from string.
+     The patch part is not meaningful.
+
+    :param comparable: The object to compare to.
+    :param error: Error message to raise in case of a validation error.
+        Can be interpolated with `{input}` and `{other}`.
+    """
+
+    default_message = 'Version {input} must be start with {other}.'
+
+    def __init__(self, comparable, *, error: str | None = None):
+        self.comparable = comparable
+        self.error: str = error or self.default_message
+
+    def _repr_args(self) -> str:
+        return f"comparable={self.comparable!r}"
+
+    def _format_error(self, value: str) -> str:
+        return self.error.format(input=value, other=self.comparable)
+
+    def __call__(self, value: str) -> str:
+        if not value.startswith(f'{self.comparable}.'):
+            raise ValidationError(self._format_error(value))
+        return value

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

@@ -50,8 +50,7 @@ class Specification:
         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:
+        if required_values := schema.get('enum'):
             validators.append(validate.OneOf(required_values))
 
         return validators
@@ -71,11 +70,48 @@ 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_number_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.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_field_any_type(self, field_schema: dict, required: bool = False):
+        field_schema_converters = {
+            'string': self._convert_string_field,
+            'boolean': self._convert_boolean_field,
+            'number': self._convert_number_field,
+            'integer': self._convert_number_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
 
@@ -104,7 +140,9 @@ class Specification:
     def _reassembly_of_schemas(self, obj: Any) -> Any:
         if isinstance(obj, dict):
             for k, v in obj.items():
-                if k == 'schema':
+                # Checking for object type is needed to skip already resolved schemes.
+                # This is necessary because of passing variables by reference in Python.
+                if k == 'schema' and isinstance(v, dict):
                     obj[k] = self._convert_from_openapi_to_marshmallow_schema(v)
                 else:
                     self._reassembly_of_schemas(v)

schema_first-0.11.0/tests/test_specification.py

@@ -0,0 +1,43 @@
+from pathlib import Path
+
+from marshmallow import fields
+from marshmallow import Schema
+from openapi_spec_validator import validate as osv_validate
+from openapi_spec_validator.readers import read_from_filename
+import pytest
+
+from src.schema_first.openapi import OpenAPI
+from src.schema_first.specification import Specification
+from tests.conftest import tests_dir_abspath
+from tests.utils import get_schema_from_request
+
+specs_base_dir = Path(tests_dir_abspath, '_contrib', 'specs')
+spec_file_paths = list(Path(specs_base_dir, 'v3.0').iterdir())
+spec_file_paths.extend(list(Path(specs_base_dir, 'v3.1').iterdir()))
+spec_file_paths.extend(list(Path(specs_base_dir, 'v3.2').iterdir()))
+
+
+@pytest.mark.parametrize('fx', ['fx_spec_required', 'fx_spec_full'])
+def test_specification(request, fx_spec_as_file, fx):
+    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, '/required-endpoint', '200')
+    assert isinstance(request_schema(), Schema)
+    assert isinstance(request_schema().fields['message'], fields.String)
+    assert request_schema().load({'message': 'Valid string'})
+
+
+@pytest.mark.xfail(reason='Schema specification not fully realisation.')
+@pytest.mark.parametrize('file_path', spec_file_paths, ids=map(str, spec_file_paths))
+def test_specification_from_file(file_path):
+    spec_as_dict, _ = read_from_filename(file_path)
+    osv_validate(spec_as_dict)
+
+    spec = Specification(file_path)
+    spec.load()

{schema_first-0.4.0 → schema_first-0.11.0}/tests/test_validator.py

@@ -18,12 +18,14 @@ def test_validator__full(fx_spec_full, fx_spec_as_file):
     assert open_api_spec.raw_spec == fx_spec_full
 
 
+@pytest.mark.xfail(reason='External validator not support version 3.2.0.')
 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()
 
 
+@pytest.mark.xfail(reason='External validator not support version 3.2.0.')
 def test_validator__full__external_validator(fx_spec_full, fx_spec_as_file):
     spec_file = fx_spec_as_file(fx_spec_full, external_validator=True)
     open_api_spec = OpenAPI(spec_file)

schema_first-0.4.0/src/Schema_First.egg-info/requires.txt

@@ -1,12 +0,0 @@
-marshmallow>=4.0.0
-PyYAML>=6.0.2
-
-[dev]
-bandit==1.8.6
-build==1.3.0
-openapi-spec-validator>=0.5.0
-pre-commit==4.2.0
-pytest==8.4.1
-pytest-cov==6.2.1
-python-dotenv==1.1.1
-twine==6.1.0

schema_first-0.4.0/src/schema_first/openapi/schemas/v3_1_1/info_schema.py

@@ -1,21 +0,0 @@
-from marshmallow import fields
-from marshmallow import validate
-
-from ..base import BaseSchema
-from ..constants import RE_VERSION
-from ..fields import DESCRIPTION_FIELD
-from ..fields import SUMMARY_FIELD
-from .contact_schema import ContactSchema
-from .license_schema import LicenseSchema
-
-
-class InfoSchema(BaseSchema):
-    title = fields.String(required=True)
-    version = fields.String(required=True, validate=validate.Regexp(RE_VERSION))
-
-    summary = SUMMARY_FIELD
-    description = DESCRIPTION_FIELD
-    terms_of_service = fields.String(data_key='termsOfService')
-
-    contact = fields.Nested(ContactSchema)
-    license = fields.Nested(LicenseSchema)

schema_first-0.4.0/src/schema_first/openapi/schemas/v3_1_1/operation_object_schema.py

@@ -1,12 +0,0 @@
-from marshmallow import fields
-
-from ..base import BaseSchema
-from ..fields import HTTP_CODE_FIELD
-from .request_body_object_schema import RequestBodyObject
-from .responses_object_schema import ResponsesObjectSchema
-
-
-class OperationObjectSchema(BaseSchema):
-    operation_id = fields.String(data_key='operationId')
-    requestBody = fields.Nested(RequestBodyObject)
-    responses = fields.Dict(keys=HTTP_CODE_FIELD, values=fields.Nested(ResponsesObjectSchema))

schema_first-0.4.0/src/schema_first/openapi/schemas/v3_1_1/path_item_object_schema.py

@@ -1,9 +0,0 @@
-from marshmallow import fields
-
-from ..base import BaseSchema
-from .operation_object_schema import OperationObjectSchema
-
-
-class PathItemObjectSchema(BaseSchema):
-    get = fields.Nested(OperationObjectSchema)
-    post = fields.Nested(OperationObjectSchema)

schema_first-0.4.0/src/schema_first/openapi/schemas/v3_1_1/reference_object_schema.py

@@ -1,8 +0,0 @@
-from schema_first.openapi.schemas._base import BaseSchema
-from schema_first.openapi.schemas._fields import DESCRIPTION_FIELD
-from schema_first.openapi.schemas._fields import REF_FIELD
-
-
-class ReferenceObjectSchema(BaseSchema):
-    description = DESCRIPTION_FIELD
-    ref = REF_FIELD

schema_first-0.4.0/src/schema_first/openapi/schemas/v3_1_1/root_schema.py

@@ -1,25 +0,0 @@
-from marshmallow import fields
-from marshmallow import validate
-
-from ..base import BaseSchema
-from ..constants import OPENAPI_VERSION
-from ..fields import ENDPOINT_FIELD
-from .components_object_schema import ComponentsObjectSchema
-from .info_schema import InfoSchema
-from .path_item_object_schema import PathItemObjectSchema
-from .server_schema import ServerSchema
-
-
-class RootSchema(BaseSchema):
-    openapi = fields.String(required=True, validate=validate.Equal(OPENAPI_VERSION))
-    info = fields.Nested(InfoSchema, required=True)
-    paths = fields.Dict(
-        required=True,
-        keys=ENDPOINT_FIELD,
-        values=fields.Nested(PathItemObjectSchema, required=True),
-    )
-
-    jsonSchemaDialect = fields.URL()
-
-    servers = fields.Nested(ServerSchema, many=True)
-    components = fields.Nested(ComponentsObjectSchema)

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

@@ -1,120 +0,0 @@
-import re
-
-from marshmallow import fields
-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 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(BaseSchema):
-    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()
-
-    @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 SchemaObjectSchema(StringFieldSchema):
-    type = fields.String(required=True, validate=validate.OneOf(TYPES))
-    default = fields.String()
-    description = DESCRIPTION_FIELD
-    nullable = fields.Boolean()
-    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"]>'
-                    )

schema_first-0.4.0/tests/test_specification.py

@@ -1,33 +0,0 @@
-from marshmallow import fields
-from marshmallow import Schema
-
-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)
-    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(), Schema)