* Fix parameters generate schema.

* Fix array generate schema.

Author: flask-pro

.pre-commit-config.yaml

@@ -32,7 +32,7 @@ repos:
   rev: v3.21.2
   hooks:
   - id: pyupgrade
-    args: [--py313-plus]
+    args: [--py314-plus]
 - repo: https://github.com/hauntsaninja/no_implicit_optional
   rev: '1.4'
   hooks:

.python-version

@@ -1 +1 @@
-3.13
+3.14

CHANGES.md

@@ -1,3 +1,8 @@
+## Version 0.14.2
+
+* Fix parameters generate schema.
+* Fix array generate schema.
+
 ## Version 0.14.1
 
 * Add few small fixes.

Makefile

@@ -1,5 +1,5 @@
 VENV_DIR = venv
-PYTHON = python3.13
+PYTHON = python3.14
 PIP = $(VENV_DIR)/bin/pip
 PYTHON_VENV = $(VENV_DIR)/bin/python
 PRE_COMMIT = $(VENV_DIR)/bin/pre-commit

pyproject.toml

@@ -19,8 +19,8 @@ license = "LGPL-2.1-only"
 license-files = ["LICENSE.txt"]
 name = "Schema-First"
 readme = "README.md"
-requires-python = ">=3.13"
-version = "0.14.1"
+requires-python = ">=3.14"
+version = "0.14.2"
 
 [project.optional-dependencies]
 dev = [

src/schema_first/loaders/yaml_loader.py

@@ -58,7 +58,7 @@ def search_file(self, obj: dict or list) -> None:
         else:
             return
 
-    def load(self) -> 'YAMLReader':
+    def load(self) -> YAMLReader:
         root_file = self._yaml_to_dict(self.path)
         self.store[self.root_file_name] = root_file
         self.search_file(root_file)
@@ -130,7 +130,7 @@ def _resolving_all_refs(self, file_path: str, obj: Any) -> Any:
 
         return obj
 
-    def resolving(self) -> 'RefResolver':
+    def resolving(self) -> RefResolver:
         root_file_path = self.yaml_reader.root_file_name
         root_spec = self.yaml_reader.store[root_file_path]
         self.resolved_spec = self._resolving_all_refs(root_file_path, root_spec)

src/schema_first/openapi/schemas/v3_2/openapi_object_schema.py

@@ -57,7 +57,7 @@ def validate_path_parameter(self, data, **kwargs) -> None:
             if param_names:
                 params_from_components = data['components'].get('parameters')
                 if params_from_components:
-                    param_names_from_components = params_from_components.key()
+                    param_names_from_components = params_from_components.keys()
 
                     if not set(param_names).issubset(set(param_names_from_components)):
                         raise ValidationError(

src/schema_first/specification/__init__.py

@@ -1,4 +1,3 @@
-from copy import deepcopy
 from pathlib import Path
 from typing import Any
 
@@ -7,8 +6,10 @@
 from marshmallow import RAISE
 from marshmallow import Schema
 from marshmallow import validate
+from marshmallow.fields import Field
 
-from ..openapi import OpenAPI
+from schema_first.openapi import OpenAPI
+from schema_first.specification.spilli_api import ConverterOpenAPIToSpilliAPI
 
 FIELDS_VIA_TYPES = {
     'boolean': fields.Boolean,
@@ -34,6 +35,7 @@
 class Specification:
     def __init__(self, spec_file: Path | str):
         self.openapi = OpenAPI(spec_file)
+        self.spilli_api = None
         self.reassembly_spec = None
 
     @staticmethod
@@ -132,13 +134,17 @@ def _convert_object_field(self, open_api_schema: dict) -> type[Schema]:
 
         return Schema.from_dict(marshmallow_schema)
 
-    def _convert_array_field(self, open_api_schema: dict) -> type[Schema]:
+    def _convert_array_field(self, open_api_schema: dict) -> Field:
         array_item_schema = open_api_schema['items']
-        array_schema = self._convert_object_field(array_item_schema)
-        array_schema.opts.many = True
-        return array_schema
+        if array_item_schema['type'] == 'object':
+            nested_field = self._convert_object_field(array_item_schema)
+            array_field = fields.Nested(nested_field, many=True)
+        else:
+            nested_field = FIELDS_VIA_TYPES[array_item_schema['type']]()
+            array_field = fields.List(nested_field)
+        return array_field
 
-    def _reassembly_of_schemas(self, obj: Any) -> Any:
+    def _reassembly_of_schemas(self, obj: Any) -> None:
         if isinstance(obj, dict):
             for k, v in obj.items():
                 # Checking for object type is needed to skip already resolved schemes.
@@ -148,10 +154,10 @@ def _reassembly_of_schemas(self, obj: Any) -> Any:
                 else:
                     self._reassembly_of_schemas(v)
 
-    def load(self) -> 'Specification':
+    def load(self) -> Specification:
         self.openapi.load()
-        self.reassembly_spec = deepcopy(self.openapi.raw_spec)
 
+        self.reassembly_spec = ConverterOpenAPIToSpilliAPI(self.openapi.raw_spec).convert()
         self._reassembly_of_schemas(self.reassembly_spec)
 
         return self

src/schema_first/specification/spilli_api.py

@@ -0,0 +1,65 @@
+import json
+from typing import Any
+import typing as t
+
+
+class ConverterOpenAPIToSpilliAPI:
+    def __init__(self, open_api_spec: dict) -> None:
+        self.open_api_spec = open_api_spec
+        self.spilli_api_spec = None
+
+    def _convert_params_to_schema(
+        self, params: list[dict], place: t.Literal['header', 'cookie', 'path', 'query']
+    ) -> Any | None:
+        schema = {
+            'type': 'object',
+            'additionalProperties': True,
+        }
+
+        required = []
+        properties = {}
+        for param in params:
+            if param['in'] == place:
+                if param.get('required', False):
+                    required.append(param['name'])
+                properties[param['name']] = param['schema']
+
+        if not properties:
+            return None
+        else:
+            schema['properties'] = properties
+
+        if required:
+            schema['required'] = required
+
+        return schema
+
+    def _params_list_to_dict(self, params: list[dict]) -> dict:
+        params_as_dict = {}
+        if headers := self._convert_params_to_schema(params, 'header'):
+            params_as_dict['headers'] = {'schema': headers}
+        if cookies := self._convert_params_to_schema(params, 'cookie'):
+            params_as_dict['cookies'] = {'schema': cookies}
+        if paths := self._convert_params_to_schema(params, 'path'):
+            params_as_dict['paths'] = {'schema': paths}
+        if queries := self._convert_params_to_schema(params, 'query'):
+            params_as_dict['queries'] = {'schema': queries}
+
+        return params_as_dict
+
+    def _make_to_spilli_api_format(self) -> None:
+        self.spilli_api_spec = json.loads(json.dumps(self.open_api_spec))
+
+        for _, methods in self.spilli_api_spec['paths'].items():
+            common_params = []
+            if 'parameters' in methods:
+                common_params = methods.pop('parameters', [])
+
+            for _, operation_obj in methods.items():
+                if 'parameters' in operation_obj:
+                    method_params = common_params + operation_obj.pop('parameters', [])
+                    operation_obj['parameters'] = self._params_list_to_dict(method_params)
+
+    def convert(self) -> dict:
+        self._make_to_spilli_api_format()
+        return self.spilli_api_spec

tests/_contrib/specs/v3.2/array/all.yaml

@@ -0,0 +1,34 @@
+openapi: 3.2.0
+info:
+  title: Mini API for testing Flask-First
+  version: 1.0.0
+paths:
+  /mini_endpoint:
+    post:
+      operationId: mini_endpoint
+      requestBody:
+        description: Request item.
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                array:
+                  type: array
+                  items:
+                    type: string
+      responses:
+        '201':
+          description: Response item.
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  array:
+                    type: array
+                    items:
+                      type: object
+                      properties:
+                        field:
+                          type: string