clear-skies 2.0.27__py3-none-any.whl

clearskies/autodoc/request/__init__.py

@@ -0,0 +1,15 @@
+from .header import Header
+from .json_body import JSONBody
+from .parameter import Parameter
+from .request import Request
+from .url_parameter import URLParameter
+from .url_path import URLPath
+
+__all__ = [
+    "Header",
+    "JSONBody",
+    "Parameter",
+    "Request",
+    "URLParameter",
+    "URLPath",
+]

clearskies/autodoc/request/header.py

@@ -0,0 +1,6 @@
+from .parameter import Parameter
+
+
+class Header(Parameter):
+    location = "header"
+    in_body = False

clearskies/autodoc/request/json_body.py

@@ -0,0 +1,6 @@
+from .parameter import Parameter
+
+
+class JSONBody(Parameter):
+    location = "json_body"
+    in_body = True

clearskies/autodoc/request/parameter.py

@@ -0,0 +1,8 @@
+class Parameter:
+    location = ""
+    in_body = False
+
+    def __init__(self, definition, description="", required=False):
+        self.definition = definition
+        self.description = description
+        self.required = required

clearskies/autodoc/request/request.py

@@ -0,0 +1,47 @@
+import re
+from typing import Any
+
+
+class Request:
+    description: str = ""
+    relative_path: str = ""
+    request_methods: list[str] = []
+    parameters: list[Any] = []
+    responses = None
+    root_properties = None
+
+    def __init__(
+        self, description, responses, relative_path="", request_methods="GET", parameters=None, root_properties=None
+    ):
+        # clearskies supports path parameters via {parameter} and :parameter but we want to normalize to {paramter} for
+        # autodoc purposes
+        if ":" in relative_path:
+            relative_path = "/" + relative_path.strip("/") + "/"
+            for match in re.findall("/(:[^/]+)/", relative_path):
+                name = match[1:]
+                relative_path = relative_path.replace(f"/:{name}/", "/{" + name + "}/")
+
+        self.description = description
+        self.responses = responses
+        self.relative_path = relative_path.lstrip("/")
+        self.request_methods = [request_methods] if type(request_methods) == str else request_methods
+        self.set_parameters(parameters)
+        self.root_properties = root_properties if root_properties is not None else {}
+
+    def set_request_methods(self, request_methods):
+        self.request_methods = [request_methods] if type(request_methods) == str else request_methods
+        return self
+
+    def prepend_relative_path(self, path):
+        self.relative_path = path.rstrip("/") + "/" + self.relative_path.lstrip("/")
+        return self
+
+    def append_relative_path(self, path):
+        self.relative_path = self.relative_path.rstrip("/") + "/" + path.lstrip("/")
+        return self
+
+    def set_parameters(self, parameters=None):
+        self.parameters = parameters if parameters else []
+
+    def add_parameter(self, parameter):
+        self.parameters.append(parameter)

clearskies/autodoc/request/url_parameter.py

@@ -0,0 +1,6 @@
+from .parameter import Parameter
+
+
+class URLParameter(Parameter):
+    location = "url_parameter"
+    in_body = False

clearskies/autodoc/request/url_path.py

@@ -0,0 +1,6 @@
+from .parameter import Parameter
+
+
+class URLPath(Parameter):
+    location = "url_path"
+    in_body = False

clearskies/autodoc/response/__init__.py

@@ -0,0 +1,5 @@
+from .response import Response
+
+__all__ = [
+    "Response",
+]

clearskies/autodoc/response/response.py

@@ -0,0 +1,9 @@
+class Response:
+    status = None
+    schema = None
+    description = None
+
+    def __init__(self, status, schema, description=None):
+        self.status = status
+        self.schema = schema
+        self.description = description if description is not None else ""

clearskies/autodoc/schema/__init__.py

@@ -0,0 +1,31 @@
+from .array import Array
+from .base64 import Base64
+from .boolean import Boolean
+from .date import Date
+from .datetime import Datetime
+from .double import Double
+from .enum import Enum
+from .integer import Integer
+from .long import Long
+from .number import Number
+from .object import Object
+from .password import Password
+from .schema import Schema
+from .string import String
+
+__all__ = [
+    "Array",
+    "Base64",
+    "Boolean",
+    "Date",
+    "Datetime",
+    "Double",
+    "Enum",
+    "Integer",
+    "Long",
+    "Number",
+    "Object",
+    "Password",
+    "Schema",
+    "String",
+]

clearskies/autodoc/schema/array.py

@@ -0,0 +1,10 @@
+from .schema import Schema
+
+
+class Array(Schema):
+    item_definition = None
+    _type = "array"
+
+    def __init__(self, name, item_definition, value=None):
+        super().__init__(name, example=None, value=value)
+        self.item_definition = item_definition

clearskies/autodoc/schema/base64.py

@@ -0,0 +1,8 @@
+from .string import String
+
+
+class Base64(String):
+    _format = "byte"
+
+    def __init__(self, name, example=None, value=None):
+        super().__init__(name, example=example, value=value)

clearskies/autodoc/schema/boolean.py

@@ -0,0 +1,5 @@
+from .schema import Schema
+
+
+class Boolean(Schema):
+    _type = "boolean"

clearskies/autodoc/schema/date.py

@@ -0,0 +1,5 @@
+from .string import String
+
+
+class Date(String):
+    _format = "date"

clearskies/autodoc/schema/datetime.py

@@ -0,0 +1,5 @@
+from .string import String
+
+
+class Datetime(String):
+    _format = "date-time"

clearskies/autodoc/schema/double.py

@@ -0,0 +1,5 @@
+from .number import Number
+
+
+class Double(Number):
+    _format = "double"

clearskies/autodoc/schema/enum.py

@@ -0,0 +1,17 @@
+from .schema import Schema
+
+
+class Enum(Schema):
+    values = None
+    value_type = None
+    example = None
+    _type = "string"
+    _format = ""
+
+    def __init__(self, name, values, value_type, example=None):
+        self.name = name
+        self.values = values
+        self.value_type = value_type
+        self._type = value_type._type
+        self._format = value_type._format
+        self.example = example

clearskies/autodoc/schema/integer.py

@@ -0,0 +1,6 @@
+from .schema import Schema
+
+
+class Integer(Schema):
+    _type = "integer"
+    _format = "int32"

clearskies/autodoc/schema/long.py

@@ -0,0 +1,5 @@
+from .integer import Integer
+
+
+class Long(Integer):
+    _format = "int64"

clearskies/autodoc/schema/number.py

@@ -0,0 +1,6 @@
+from .schema import Schema
+
+
+class Number(Schema):
+    _type = "number"
+    _format = "float"

clearskies/autodoc/schema/object.py

@@ -0,0 +1,13 @@
+from .schema import Schema
+
+
+class Object(Schema):
+    children = None
+    model_name = None
+    _type = "object"
+    _format = ""
+
+    def __init__(self, name, children, value=None, example=None, model_name=None):
+        super().__init__(name, example=example, value=value)
+        self.children = children
+        self.model_name = model_name

clearskies/autodoc/schema/password.py

@@ -0,0 +1,5 @@
+from .string import String
+
+
+class Password(String):
+    _format = "password"

clearskies/autodoc/schema/schema.py

@@ -0,0 +1,11 @@
+class Schema:
+    name: str
+    example = None
+    value = None
+    _type = "string"
+    _format = ""
+
+    def __init__(self, name, example=None, value=None):
+        self.name = name
+        self.example = example
+        self.value = value

clearskies/autodoc/schema/string.py

@@ -0,0 +1,5 @@
+from .schema import Schema
+
+
+class String(Schema):
+    pass

clearskies/backends/__init__.py

@@ -0,0 +1,67 @@
+"""
+The backend system provides a layer of abstraction between a clearskies model and the place where it stores its data.
+
+## Motivation
+
+The goal of the backend system is to create a standard way to interact with external systems, whether those are
+databases, APIs, cloud resources, etc...  For comparison, models in other frameworks typically interact exclusively
+with SQL databases.  Therefore, building integrations with other data stores or 3rd party systems requires the
+creation of bespoke SDKs, which results in time spent integrating and learning how to use them.  Clearskies models
+work with different backends to normalize the process of integrating with data stores and external systems.
+This ability to switch backends turns the models, in essence, into a standardized SDK.  The details of how to
+interact with some other system are abstracted away into the backend, and then developers can interact with the
+system using models in the standard way.
+
+Of course, no abstraction layer is perfect, and not all datastores can fit into the backend system provided by
+clearskies.  That's okay!  Like every abstraction layer in clearskies, you should use it when it works for
+you and forget about it otherwise.  So, for instance, it is not possible to build arbitrarily complex SQL
+queries with the query system provided by models, but you can always inject the cursor and use it directly.
+If some arbitrary data store just works in a completely different way, such that the backend system doesn't
+work for it, it's still fine to build an SDK the "old school" way and use it in a clearskies application.
+
+## Backends
+
+There are four primary kinds of backends built into clearskies, with a few sub-types.  Those are:
+
+ 1. CursorBackend: Store data in an SQL-like database
+ 2. MemoryBackend: Store data in-memory
+ 3. ApiBackend: Use an API to fetch and store data
+    1. ApiGetOnlyBackend: Only supports fetching individual records from the API by id.
+    2. RestfulApiAdvancedSearchBackend: Automatically integrates with APIs built using clearskies.endpoints.RestfulApi
+ 4. SecretsBackend - Store data directly in a secrets manager
+
+See the documentation for each backend to understand how to configure and use it.  In all cases though, you specify
+the backend by instantiating the backend and attaching it to the model class via the `backend` attribute:
+
+```python
+import clearskies
+
+
+class MyModel(clearskies.model):
+    backend = clearskies.backends.MemoryBackend()
+```
+"""
+
+# from .api_backend import ApiBackend
+# from .api_get_only_backend import ApiGetOnlyBackend
+from clearskies.backends.api_backend import ApiBackend
+from clearskies.backends.backend import Backend
+from clearskies.backends.cursor_backend import CursorBackend
+from clearskies.backends.graphql_backend import GraphqlBackend
+from clearskies.backends.memory_backend import MemoryBackend
+
+# from .memory_backend import MemoryBackend
+# from .restful_api_advanced_search_backend import RestfulApiAdvancedSearchBackend
+# from .secrets_backend import SecretsBackend
+
+
+__all__ = [
+    "ApiBackend",
+    # "ApiGetOnlyBackend",
+    "Backend",
+    "CursorBackend",
+    "GraphqlBackend",
+    "MemoryBackend",
+    # "RestfulApiAdvancedSearchBackend",
+    # "SecretsBackend",
+]