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

clearskies/autodoc/formats/oai3_json/parameter.py

@@ -1,35 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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]