clear-skies 2.0.5__py3-none-any.whl → 2.0.6__py3-none-any.whl

clearskies/autodoc/formats/oai3_json/parameter.py

@@ -0,0 +1,35 @@
+from typing import Any
+
+
+class Parameter:
+    name: str = ""
+    parameter: Any = None
+    required: bool = False
+    location_map = {
+        "url_parameter": "query",
+        "header": "header",
+        "url_path": "path",
+    }
+
+    def __init__(self, oai3_schema_resolver):
+        self.oai3_schema_resolver = oai3_schema_resolver
+
+    def set_parameter(self, parameter):
+        self.parameter = parameter
+        self.name = self.parameter.definition.name
+        self.required = self.parameter.required
+
+    def convert(self):
+        if self.parameter.location not in self.location_map:
+            raise ValueError(
+                f"Parameter of class {self.parameter.__class__} declares "
+                + f"an unsupported location: '{self.parameter.location}'"
+            )
+
+        return {
+            "name": self.parameter.definition.name,
+            "description": self.parameter.description,
+            "required": self.required,
+            "in": self.location_map[self.parameter.location],
+            "schema": self.oai3_schema_resolver(self.parameter.definition).convert(),
+        }

clearskies/autodoc/formats/oai3_json/request.py

@@ -0,0 +1,68 @@
+from typing import Any
+
+from ...schema import Array, Object
+from .parameter import Parameter
+from .response import Response
+
+
+class Request:
+    formatted_responses: Any = None
+    request: Any = None
+    relative_path: str = ""
+
+    def __init__(self, oai3_schema_resolver):
+        self.oai3_schema_resolver = oai3_schema_resolver
+
+    def set_request(self, request):
+        self.request = request
+        self.formatted_responses = [self.format_response(response) for response in self.request.responses]
+        self.formatted_parameters = [
+            self.format_parameter(parameter) for parameter in self.request.parameters if not parameter.in_body
+        ]
+        self.json_body_parameters = [parameter for parameter in self.request.parameters if parameter.in_body]
+        self.relative_path = self.request.relative_path
+
+    def format_response(self, response):
+        formatted = Response(self.oai3_schema_resolver)
+        formatted.set_response(response)
+        return formatted
+
+    def format_parameter(self, parameter):
+        formatted = Parameter(self.oai3_schema_resolver)
+        formatted.set_parameter(parameter)
+        return formatted
+
+    def convert(self):
+        data = {}
+        for request_method in self.request.request_methods:
+            data[request_method.lower()] = {
+                "summary": self.request.description,
+                "parameters": [parameter.convert() for parameter in self.formatted_parameters],
+                "responses": {str(response.status_code): response.convert() for response in self.formatted_responses},
+            }
+
+            if self.request.root_properties:
+                data[request_method.lower()] = {**data[request_method.lower()], **self.request.root_properties}
+
+            if self.json_body_parameters:
+                # For OAI3, there should only be one JSON body root parameter, so it should either be an
+                # object or an array.  If we have an array then wrap it in an object
+                if type(self.json_body_parameters) == list:
+                    definitions = [parameter.definition for parameter in self.json_body_parameters]
+                    json_body = Object("body", definitions)
+                    is_required = len([1 for param in self.json_body_parameters if param.required]) >= 1
+                else:
+                    json_body = self.json_body_parameters[0].definition
+                    is_required = len([1 for param in json_body.definition.children if param.required]) >= 1
+
+                data[request_method.lower()]["requestBody"] = {
+                    "description": self.request.description,
+                    "required": is_required,
+                    "content": {
+                        "application/json": {
+                            "schema": self.oai3_schema_resolver(json_body).convert(),
+                        },
+                    },
+                }
+
+        return data

clearskies/autodoc/formats/oai3_json/response.py

@@ -0,0 +1,28 @@
+from typing import Any
+
+
+class Response:
+    response: Any = None
+    formatted_schema: Any = None
+    oai3_schema_resolver: Any = None
+    status_code: Any = None
+
+    def __init__(self, oai3_schema_resolver):
+        self.oai3_schema_resolver = oai3_schema_resolver
+
+    def set_response(self, response):
+        self.response = response
+        self.status_code = self.response.status
+        self.formatted_schema = self.oai3_schema_resolver(response.schema)
+
+    def convert(self):
+        schema = {
+            "description": self.response.description,
+            "content": {
+                "application/json": {
+                    "schema": self.oai3_schema_resolver(self.response.schema).convert(),
+                }
+            },
+        }
+
+        return schema

clearskies/autodoc/formats/oai3_json/schema/__init__.py

@@ -0,0 +1,11 @@
+from .array import Array
+from .default import Default
+from .enum import Enum
+from .object import Object
+
+__all__ = [
+    "Array",
+    "Default",
+    "Enum",
+    "Object",
+]

clearskies/autodoc/formats/oai3_json/schema/array.py

@@ -0,0 +1,9 @@
+class Array:
+    def __init__(self, schema, oai3_schema_resolver):
+        self.schema = schema
+        self.oai3_schema_resolver = oai3_schema_resolver
+
+    def convert(self):
+        schema = {"type": "array", "items": self.oai3_schema_resolver(self.schema.item_definition).convert()}
+
+        return schema

clearskies/autodoc/formats/oai3_json/schema/default.py

@@ -0,0 +1,13 @@
+class Default:
+    def __init__(self, schema):
+        self.schema = schema
+
+    def convert(self):
+        schema = {"type": self.schema._type}
+        if self.schema._format:
+            schema["format"] = self.schema._format
+        if hasattr(self.schema, "example") and self.schema.example:
+            schema["example"] = self.schema.example
+        if hasattr(self.schema, "value") and self.schema.value:
+            schema["example"] = self.schema.value
+        return schema

clearskies/autodoc/formats/oai3_json/schema/enum.py

@@ -0,0 +1,7 @@
+class Enum:
+    def __init__(self, schema, oai3_schema_resolver):
+        self.schema = schema
+        self.oai3_schema_resolver = oai3_schema_resolver
+
+    def convert(self):
+        return {"nullable": True, "type": "string", "enum": [*self.schema.values, None]}

clearskies/autodoc/formats/oai3_json/schema/object.py

@@ -0,0 +1,35 @@
+from typing import Any
+
+
+class Object:
+    def __init__(self, schema, oai3_schema_resolver):
+        self.schema = schema
+        # shhhh
+        self.schema.children = [
+            child[0] if (isinstance(child, tuple) or isinstance(child, list)) else child
+            for child in self.schema.children
+        ]
+
+        self.oai3_schema_resolver = oai3_schema_resolver
+
+    def convert(self, include_required=False):
+        schema: dict[str, Any] = {
+            "type": "object",
+        }
+
+        if self.schema.model_name:
+            schema["$ref"] = f"#/components/schemas/{self.schema.model_name}"
+        else:
+            schema["properties"] = {
+                schematic.name: self.oai3_schema_resolver(schematic).convert() for schematic in self.schema.children
+            }
+
+        if include_required:
+            required = self.required()
+            if required:
+                schema["required"] = required
+
+        return schema
+
+    def required(self):
+        return [schematic.name for schematic in self.schema.children if schematic.required]