clear-skies 1.19.22__py3-none-any.whl → 2.0.23__py3-none-any.whl

clearskies/decorators/docs.py

@@ -1,14 +0,0 @@
-from .merge import merge
-
-
-def docs(doc_description=None, doc_model_name=None, doc_response_data_schema=None):
-    def wrap_in_application(function):
-        return merge(
-            function,
-            doc_description=doc_description,
-            doc_model_name=doc_model_name,
-            doc_response_data_schema=doc_response_data_schema,
-        )
-
-    wrap_in_application.is_wrapped_application = True
-    return wrap_in_application

clearskies/decorators/get.py

@@ -1,10 +0,0 @@
-from .merge import merge
-
-
-def get(path, **kwargs):
-    def wrap_in_application(function):
-        kwargs["path"] = path
-        return merge(function, **{**kwargs, "methods": "GET"})
-
-    wrap_in_application.is_wrapped_application = True
-    return wrap_in_application

clearskies/decorators/jwks.py

@@ -1,26 +0,0 @@
-from .merge import merge
-from typing import List, Optional
-from ..authentication import jwks as jwks_binding
-
-
-def jwks(
-    jwks_url: str,
-    audience: Optional[str] = None,
-    issuer: Optional[str] = None,
-    algorithms: Optional[List[str]] = None,
-    documentation_security_name: Optional[str] = None,
-    jwks_cache_time: Optional[int] = None,
-):
-    def wrap_in_application(function):
-        auth0 = jwks_binding(
-            jwks_url=jwks_url,
-            audience=audience,
-            issuer=issuer,
-            algorithms=algorithms,
-            documentation_security_name=documentation_security_name,
-            jwks_cache_time=jwks_cache_time,
-        )
-        return merge(function, authentication=auth0)
-
-    wrap_in_application.is_wrapped_application = True
-    return wrap_in_application

clearskies/decorators/merge.py

@@ -1,124 +0,0 @@
-from ..application import Application
-from ..handlers import callable as callable_handler
-from ..handlers import simple_routing
-from typing import Any, Dict, Set
-
-routing_kwargs = ["path", "methods"]
-binding_kwargs = ["bindings", "binding_classes", "binding_modules"]
-
-
-def merge(function: callable, **kwargs: Dict[str, Any]) -> Application:
-    is_wrapped_application = getattr(function, "is_wrapped_application", False)
-    binding_configs = extract_binding_configs(kwargs)
-    callable_configs = extract_callable_configs(kwargs)
-    routing_configs = extract_routing_configs(kwargs)
-
-    # if ths is the first decorator added then we need to wrap it in an application
-    if not is_wrapped_application and type(function) != Application:
-        application = Application(
-            callable_handler.Callable,
-            {**callable_configs, "callable": function},
-            **binding_configs,
-        )
-        # and if we have a route then we also want to wrap it in a router. Note that
-        # there is a possible future issue in here and things will break if path
-        # and methods are not specified at the same time.
-        if "path" in kwargs:
-            application = Application(
-                simple_routing.SimpleRouting,
-                {
-                    "routes": [
-                        {
-                            **routing_configs,
-                            "handler_class": application.handler_class,
-                            "handler_config": application.handler_config,
-                        },
-                    ],
-                },
-                **binding_configs,
-            )
-        # and then we are all done
-        return application
-
-    # if we got here then we have a wrapped application, which means that function will return an
-    # application when called... except when it doesn't which has to do with nested decorators and
-    # I'm too lazy to sort it out but the below works fine.
-    if is_wrapped_application:
-        application = function()
-    else:
-        application = function
-    authentication = application.handler_config.get("authentication")
-
-    # Next question: is there a path in our kwargs?  If so then we are trying to add routing to
-    # the application.
-    if "path" in kwargs:
-        # before we add routing, make sure we're not double routing
-        if application.handler_class == simple_routing.SimpleRouting:
-            raise ValueError(
-                "Error applying decorators: it looks like more than one routing decorator was added to a function"
-            )
-        # Now then, wrap the application in a router.  For the inner application,
-        # merge any configurations for the callable
-        for binding_name in binding_kwargs:
-            if not getattr(application, binding_name):
-                continue
-            from_application = getattr(application, binding_name)
-            from_configs = binding_configs.get(binding_name, {} if type(from_application) == dict else [])
-            if type(from_application) == dict:
-                binding_configs[binding_name] = {**from_application, **from_configs}
-            else:
-                binding_configs[binding_name] = [*from_application, *from_configs]
-        return Application(
-            simple_routing.SimpleRouting,
-            {
-                "authentication": authentication,
-                "routes": [
-                    {
-                        **routing_configs,
-                        "handler_class": application.handler_class,
-                        "handler_config": {
-                            **application.handler_config,
-                            **callable_configs,
-                        },
-                    },
-                ],
-            },
-            **binding_configs,
-        )
-
-    # if we got here then we just need to merge in our callable configs.  The only trick is
-    # whether or not we have an outer routing application.
-    if application.handler_class == simple_routing.SimpleRouting:
-        application.handler_config["routes"][0]["handler_config"] = {
-            **application.handler_config["routes"][0]["handler_config"],
-            **callable_configs,
-        }
-
-    else:
-        application.handler_config = {**application.handler_config, **callable_configs}
-
-    for binding_name in binding_kwargs:
-        if binding_configs.get(binding_name):
-            from_application = getattr(application, binding_name)
-            from_configs = binding_configs[binding_name]
-            if type(from_application) == dict:
-                setattr(application, binding_name, {**from_application, **from_configs})
-            else:
-                setattr(application, binding_name, [*from_application, *from_configs])
-    return application
-
-
-def extract_callable_configs(kwargs: Dict[str, Any]) -> Dict[str, Any]:
-    """Return the configuration settings from the kwargs which are valid for the callable handler."""
-    # all configs execpt 'path' and 'methods' go with the callable
-    return {key: kwargs[key] for key in kwargs.keys() if key not in routing_kwargs and key not in binding_kwargs}
-
-
-def extract_routing_configs(kwargs: Dict[str, Any]) -> Dict[str, Any]:
-    """Return the configuration settings from the kwargs which are valid for the routing info."""
-    return {key: kwargs[key] for key in kwargs.keys() if key in routing_kwargs}
-
-
-def extract_binding_configs(kwargs: Dict[str, Any]) -> Dict[str, Any]:
-    """Return the configuration settings from the kwargs which are valid for bindings."""
-    return {key: kwargs[key] for key in kwargs.keys() if key in binding_kwargs}

clearskies/decorators/patch.py

@@ -1,10 +0,0 @@
-from .merge import merge
-
-
-def patch(path, **kwargs):
-    def wrap_in_application(function):
-        kwargs["path"] = path
-        return merge(function, **{**kwargs, "methods": "PATCH"})
-
-    wrap_in_application.is_wrapped_application = True
-    return wrap_in_application

clearskies/decorators/post.py

@@ -1,10 +0,0 @@
-from .merge import merge
-
-
-def post(path, **kwargs):
-    def wrap_in_application(function):
-        kwargs["path"] = path
-        return merge(function, **{**kwargs, "methods": "POST"})
-
-    wrap_in_application.is_wrapped_application = True
-    return wrap_in_application

clearskies/decorators/public.py

@@ -1,11 +0,0 @@
-from .merge import merge
-from typing import List, Optional
-from ..authentication import public as public_binding
-
-
-def public():
-    def wrap_in_application(function):
-        return merge(function, authentication=public_binding())
-
-    wrap_in_application.is_wrapped_application = True
-    return wrap_in_application

clearskies/decorators/response_headers.py

@@ -1,10 +0,0 @@
-from .merge import merge
-from typing import Dict
-
-
-def response_headers(response_headers: Dict[str, str]):
-    def wrap_in_application(function):
-        return merge(function, response_headers=response_headers)
-
-    wrap_in_application.is_wrapped_application = True
-    return wrap_in_application

clearskies/decorators/return_raw_response.py

@@ -1,9 +0,0 @@
-from .merge import merge
-
-
-def return_raw_response():
-    def wrap_in_application(function):
-        return merge(function, return_raw_response=True)
-
-    wrap_in_application.is_wrapped_application = True
-    return wrap_in_application

clearskies/decorators/schema.py

@@ -1,10 +0,0 @@
-from .merge import merge
-from typing import Dict
-
-
-def schema(schema, writeable_columns=None):
-    def wrap_in_application(function):
-        return merge(function, schema=schema, writeable_columns=writeable_columns)
-
-    wrap_in_application.is_wrapped_application = True
-    return wrap_in_application

clearskies/decorators/secret_bearer.py

@@ -1,24 +0,0 @@
-from .merge import merge
-from typing import List, Optional
-from ..authentication import secret_bearer as secret_bearer_binding
-
-
-def secret_bearer(
-    secret: str = None,
-    secret_key: str = None,
-    header_prefix: str = None,
-    environment_key: str = None,
-    documentation_security_name: str = None,
-):
-    def wrap_in_application(function):
-        secret_bearer = secret_bearer_binding(
-            secret=secret,
-            environment_key=environment_key,
-            documentation_security_name=documentation_security_name,
-            header_prefix=header_prefix,
-            secret_key=secret_key,
-        )
-        return merge(function, authentication=secret_bearer)
-
-    wrap_in_application.is_wrapped_application = True
-    return wrap_in_application

clearskies/decorators/security_headers.py

@@ -1,10 +0,0 @@
-from .merge import merge
-from typing import List, Optional
-
-
-def security_headers(*args):
-    def wrap_in_application(function):
-        return merge(function, security_headers=args)
-
-    wrap_in_application.is_wrapped_application = True
-    return wrap_in_application

clearskies/di/standard_dependencies.py

@@ -1,140 +0,0 @@
-from .di import DI
-from ..columns import Columns
-from ..environment import Environment
-from ..backends import CursorBackend, JsonBackend, MemoryBackend, SecretsBackend
-from .. import autodoc
-import os
-import uuid
-import inspect
-
-
-class StandardDependencies(DI):
-    def provide_requests(self):
-        # by importing the requests library when requested, instead of in the top of the file,
-        # it is not necessary to install the requests library if it is never used.
-        import requests
-        from requests.adapters import HTTPAdapter
-        from requests.packages.urllib3.util.retry import Retry
-
-        use_allowed_methods = "allowed_methods" in inspect.getfullargspec(Retry.__init__).args
-        methods_key = "allowed_methods" if use_allowed_methods else "method_whitelist"
-        kwargs = {
-            "total": 3,
-            "status_forcelist": [429, 500, 502, 503, 504],
-            "backoff_factor": 1,
-            methods_key: ["GET", "POST", "DELETE", "OPTIONS", "PATCH"],
-        }
-
-        retry_strategy = Retry(**kwargs)
-        adapter = HTTPAdapter(max_retries=retry_strategy)
-        http = requests.Session()
-        http.mount("https://", adapter)
-        return http
-
-    def provide_sys(self):
-        import sys
-
-        return sys
-
-    def provide_columns(self):
-        return Columns(self)
-
-    def provide_secrets(self):
-        from ..secrets import secrets
-
-        return secrets.Secrets()
-
-    def provide_environment(self):
-        return Environment(os.getcwd() + "/.env", os.environ, {})
-
-    def provide_connection_no_autocommit(self, connection_details):
-        # I should probably just switch things so that autocommit is *off* by default
-        # and only have one of these, but for now I'm being lazy.
-        import pymysql
-
-        return pymysql.connect(
-            user=connection_details["username"],
-            password=connection_details["password"],
-            host=connection_details["host"],
-            database=connection_details["database"],
-            port=connection_details.get("port", 3306),
-            ssl_ca=connection_details.get("ssl_ca", None),
-            autocommit=False,
-            connect_timeout=2,
-            cursorclass=pymysql.cursors.DictCursor,
-        )
-
-    def provide_connection(self, connection_details):
-        import pymysql
-
-        return pymysql.connect(
-            user=connection_details["username"],
-            password=connection_details["password"],
-            host=connection_details["host"],
-            database=connection_details["database"],
-            port=connection_details.get("port", 3306),
-            ssl_ca=connection_details.get("ssl_ca", None),
-            autocommit=True,
-            connect_timeout=2,
-            cursorclass=pymysql.cursors.DictCursor,
-        )
-
-    def provide_connection_details(self, environment):
-        return {
-            "username": environment.get("db_username"),
-            "password": environment.get("db_password"),
-            "host": environment.get("db_host"),
-            "database": environment.get("db_database"),
-        }
-
-    def provide_cursor(self, connection):
-        return connection.cursor()
-
-    def provide_cursor_backend(self, cursor):
-        return CursorBackend(cursor)
-
-    def provide_memory_backend(self):
-        return MemoryBackend()
-
-    def provide_json_backend(self):
-        return JsonBackend()
-
-    def provide_secrets_backend(self, secrets):
-        return SecretsBackend(secrets)
-
-    def provide_logging(self):
-        import logging
-
-        return logging
-
-    def provide_now(self):
-        import datetime
-
-        return datetime.datetime.now()
-
-    def provide_datetime(self):
-        import datetime
-
-        return datetime
-
-    def provide_utcnow(self):
-        import datetime
-
-        return datetime.datetime.now(datetime.timezone.utc)
-
-    def provide_input_output(self):
-        raise AttributeError("The dependency injector requested an InputOutput but none has been configured")
-
-    def provide_authentication(self):
-        raise AttributeError("The dependency injector requested an Authenticaiton method but none has been configured")
-
-    def provide_jose_jwt(self):
-        from jose import jwt
-
-        return jwt
-
-    def provide_oai3_schema_resolver(self):
-        return autodoc.formats.oai3_json.OAI3SchemaResolver()
-
-    def provide_uuid(self):
-        return uuid

clearskies/di/test_module/__init__.py

@@ -1,6 +0,0 @@
-from . import another_module
-from .module_class import ModuleClass
-
-
-class Hi:
-    pass

clearskies/di/test_module/another_module/__init__.py

@@ -1,2 +0,0 @@
-class AnotherModuleClass:
-    pass

clearskies/di/test_module/module_class.py

@@ -1,5 +0,0 @@
-import datetime
-
-
-class ModuleClass:
-    pass

clearskies/handlers/__init__.py

@@ -1,41 +0,0 @@
-from .advanced_search import AdvancedSearch
-from .callable import Callable
-from .create import Create
-from .crud_by_method import CRUDByMethod
-from .database_connector import DatabaseConnector
-from .delete import Delete
-from .get import Get
-from .health_check import HealthCheck
-from .list import List
-from .mygrations import Mygrations
-from .request_method_routing import RequestMethodRouting
-from .restful_api import RestfulAPI
-from .routing import Routing
-from .update import Update
-from .write import Write
-from .schema_helper import SchemaHelper
-from .simple_routing import SimpleRouting
-from .simple_search import SimpleSearch
-from . import exceptions
-
-__all__ = [
-    "exceptions",
-    "AdvancedSearch",
-    "Callable",
-    "Create",
-    "CRUDByMethod",
-    "DatabaseConnector",
-    "Delete",
-    "Get",
-    "HealthCheck",
-    "List",
-    "Mygrations",
-    "RequestMethodRouting",
-    "RestfulAPI",
-    "Routing",
-    "Update",
-    "Write",
-    "SchemaHelper",
-    "SimpleRouting",
-    "SimpleSearch",
-]