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

clearskies/handlers/create.py

@@ -1,35 +0,0 @@
-from .write import Write
-from .exceptions import InputError
-from collections import OrderedDict
-from ..functional import string
-import json
-
-
-class Create(Write):
-    _is_create = True
-
-    def __init__(self, di, logging):
-        super().__init__(di)
-        self._logging = logging
-
-    def handle(self, input_output):
-        model = self._model.empty_model()
-        input_data = self.request_data(input_output)
-        self._logging.debug("Incoming request data: " + json.dumps(input_data))
-        input_errors = {
-            **self._extra_column_errors(input_data),
-            **self._find_input_errors(model, input_data, input_output),
-        }
-        if input_errors:
-            self._logging.debug("Request rejected due to input errors: " + json.dumps(input_errors))
-            raise InputError(input_errors)
-        model.save(input_data, columns=self._columns)
-
-        return self.success(input_output, self._model_as_json(model, input_output))
-
-    def documentation(self):
-        nice_model = string.camel_case_to_words(self._model.__class__.__name__)
-        return self._documentation(
-            description=f"Create a new {nice_model}",
-            response_description=f"The new {nice_model}",
-        )

clearskies/handlers/crud_by_method.py

@@ -1,18 +0,0 @@
-from .request_method_routing import RequestMethodRouting
-from .create import Create
-from .update import Update
-from .delete import Delete
-from .get import Get
-
-
-class CRUDByMethod(RequestMethodRouting):
-    def __init__(self, di):
-        super().__init__(di)
-
-    def method_handler_map(self):
-        return {
-            "CREATE": Create,
-            "GET": Get,
-            "PATCH": Update,
-            "DELETE": Delete,
-        }

clearskies/handlers/database_connector.py

@@ -1,32 +0,0 @@
-from .base import Base
-import os
-
-
-class DatabaseConnector(Base):
-    _configuration_defaults = {
-        "tunnel_only": False,
-        "command": "mysql",
-    }
-
-    def __init__(self, di):
-        super().__init__(di)
-
-    def handle(self, input_output):
-        connection_details = self._di.build("connection_details")
-        request_body = input_output.json_body(required=False)
-        if request_body and "tunnel_only" in request_body:
-            tunnel_only = request_body["tunnel_only"]
-        else:
-            tunnel_only = self.configuration("tunnel_only")
-
-        if tunnel_only:
-            return self.success(input_output, {})
-
-        command = self.configuration("command")
-        port = connection_details.get("port", 3306)
-        print("connect!")
-        print(connection_details["host"])
-        os.system(
-            f"{command} -h {connection_details['host']} -u '{connection_details['username']}' -p'{connection_details['password']}' --port={port} -D {connection_details['database']}"
-        )
-        print("done!")

clearskies/handlers/delete.py

@@ -1,61 +0,0 @@
-from collections import OrderedDict
-from .base import Base
-from .. import autodoc
-from ..functional import string
-from .get import Get
-
-
-class Delete(Get):
-    _configuration_defaults = {
-        "model": None,
-        "model_class": None,
-        "readable_columns": None,
-        "where": [],
-    }
-
-    def __init__(self, di):
-        super().__init__(di)
-
-    def handle(self, input_output):
-        model = self.fetch_model(input_output)
-        if type(model) == str:
-            return self.error(input_output, model, 404)
-
-        model.delete()
-        return self.success(input_output, {})
-
-    def documentation(self):
-        nice_model = string.camel_case_to_words(self._model.__class__.__name__)
-
-        authentication = self.configuration("authentication")
-        standard_error_responses = []
-        if not getattr(authentication, "is_public", False):
-            standard_error_responses.append(self.documentation_access_denied_response())
-            if getattr(authentication, "can_authorize", False):
-                standard_error_responses.append(self.documentation_unauthorized_response())
-
-        id_label = "id" if self.configuration("id_column_name") else self.id_column_name
-        return [
-            autodoc.request.Request(
-                "Delete the " + nice_model + " with an " + id_label + " of {" + id_label + "}",
-                [
-                    self.documentation_success_response(
-                        autodoc.schema.Object("data", children=[]),
-                        description=f"The {nice_model} was deleted",
-                    ),
-                    *standard_error_responses,
-                    self.documentation_not_found(),
-                ],
-                relative_path=self.configuration("base_url").rstrip("/") + "/{" + id_label + "}",
-                parameters=[
-                    autodoc.request.URLPath(
-                        autodoc.schema.Integer(id_label),
-                        description=f"The {id_label} of the record to delete.",
-                        required=True,
-                    )
-                ],
-                root_properties={
-                    "security": self.documentation_request_security(),
-                },
-            )
-        ]

clearskies/handlers/exceptions/__init__.py

@@ -1,5 +0,0 @@
-from .authentication import Authentication
-from .authorization import Authorization
-from .client_error import ClientError
-from .input_error import InputError
-from .not_found import NotFound

clearskies/handlers/exceptions/not_found.py

@@ -1,3 +0,0 @@
-class NotFound(Exception):
-    def __init__(self, error):
-        super().__init__(self, error)

clearskies/handlers/get.py

@@ -1,156 +0,0 @@
-from .base import Base
-from collections import OrderedDict
-from .. import autodoc
-from .. import condition_parser
-from ..functional import string
-import inspect
-
-
-class Get(Base):
-    _model = None
-
-    _configuration_defaults = {
-        "model": None,
-        "model_class": None,
-        "readable_columns": None,
-        "where": [],
-    }
-
-    def __init__(self, di):
-        super().__init__(di)
-
-    def handle(self, input_output):
-        model = self.fetch_model(input_output)
-        if type(model) == str:
-            return self.error(input_output, model, 404)
-        return self.success(input_output, self._model_as_json(model, input_output))
-
-    def get_model_id(self, input_output):
-        routing_data = input_output.routing_data()
-        if self.id_column_name in routing_data:
-            return routing_data[self.id_column_name]
-        if "id" in routing_data:
-            return routing_data["id"]
-        raise ValueError("I didn't receive the ID in my routing data.  I am probably misconfigured.")
-
-    def fetch_model(self, input_output):
-        id = self.get_model_id(input_output)
-        models = self._model.where(f"{self.id_column_name}={id}")
-        for where in self.configuration("where"):
-            if type(where) == str:
-                models = models.where(where)
-            else:
-                models = self._di.call_function(
-                    where,
-                    models=models,
-                    input_output=input_output,
-                    routing_data=input_output.routing_data(),
-                    authorization_data=input_output.get_authorization_data(),
-                )
-        models = models.where_for_request(
-            models,
-            input_output.routing_data(),
-            input_output.get_authorization_data(),
-            input_output,
-        )
-        authorization = self._configuration.get("authorization", None)
-        if authorization and hasattr(authorization, "filter_models"):
-            models = authorization.filter_models(models, input_output.get_authorization_data(), input_output)
-        model = models.first()
-        if not model.exists:
-            return "Not Found"
-
-        return model
-
-    def _check_configuration(self, configuration):
-        super()._check_configuration(configuration)
-        error_prefix = "Configuration error for %s:" % (self.__class__.__name__)
-        has_model_class = ("model_class" in configuration) and configuration["model_class"] is not None
-        has_model = ("model" in configuration) and configuration["model"] is not None
-        if not has_model and not has_model_class:
-            raise KeyError(f"{error_prefix} you must specify 'model' or 'model_class'")
-        if has_model and has_model_class:
-            raise KeyError(f"{error_prefix} you specified both 'model' and 'model_class', but can only provide one")
-        if has_model and inspect.isclass(configuration["model"]):
-            raise ValueError(
-                "{error_prefix} you must provide a model instance in the 'model' configuration setting, but a class was provided instead"
-            )
-        if "where" in configuration:
-            if not hasattr(configuration["where"], "__iter__") or type(configuration["where"]) == str:
-                raise ValueError(
-                    f"{error_prefix} 'where' should be an iterable of coditions or callables "
-                    + ", not "
-                    + str(type(configuration["where"])),
-                )
-            for index, where in enumerate(configuration["where"]):
-                if type(where) != str and not callable(where):
-                    raise ValueError(
-                        f"{error_prefix} 'where' entry should be a string with a condition or a callable that filters models "
-                        + f", but entry #{index+1} is neither of these",
-                    )
-        self._model = self._di.build(configuration["model_class"]) if has_model_class else configuration["model"]
-        self._columns = self._model.columns(overrides=configuration.get("column_overrides"))
-
-    def _get_readable_columns(self):
-        resolved_columns = OrderedDict()
-        for column_name in self.configuration("readable_columns"):
-            if column_name not in self._columns:
-                class_name = self.__class__.__name__
-                model_class = self._model.__class__.__name__
-                raise ValueError(
-                    f"Handler {class_name} was configured with readable column '{column_name}' but this "
-                    + f"column doesn't exist for model {model_class}"
-                )
-            resolved_columns[column_name] = self._columns[column_name]
-        return resolved_columns
-
-    def documentation(self):
-        nice_model = string.camel_case_to_words(self._model.__class__.__name__)
-
-        authentication = self.configuration("authentication")
-        standard_error_responses = []
-        if not getattr(authentication, "is_public", False):
-            standard_error_responses.append(self.documentation_access_denied_response())
-            if getattr(authentication, "can_authorize", False):
-                standard_error_responses.append(self.documentation_unauthorized_response())
-
-        id_label = "id" if self.configuration("id_column_name") else self.id_column_name
-
-        return [
-            autodoc.request.Request(
-                "Fetch the " + nice_model + " with an " + id_label + " of {" + id_label + "}",
-                [
-                    self.documentation_success_response(
-                        autodoc.schema.Object(
-                            "data",
-                            children=self.documentation_data_schema(),
-                            model_name=string.camel_case_to_snake_case(self._model.__class__.__name__),
-                        ),
-                        description=f"The {nice_model} record",
-                    ),
-                    *standard_error_responses,
-                    self.documentation_not_found(),
-                ],
-                relative_path=self.configuration("base_url").rstrip("/") + "/{" + id_label + "}",
-                parameters=[
-                    autodoc.request.URLPath(
-                        autodoc.schema.String(id_label),
-                        description=f"The {id_label} of the record to get",
-                        required=True,
-                    )
-                ],
-                root_properties={
-                    "security": self.documentation_request_security(),
-                },
-            )
-        ]
-
-    def documentation_models(self):
-        schema_model_name = string.camel_case_to_snake_case(self._model.__class__.__name__)
-
-        return {
-            schema_model_name: autodoc.schema.Object(
-                "data",
-                children=self.documentation_data_schema(),
-            ),
-        }

clearskies/handlers/health_check.py

@@ -1,59 +0,0 @@
-from .base import Base
-from collections import OrderedDict
-from .. import autodoc
-from .. import condition_parser
-from ..functional import string
-import inspect
-
-
-class HealthCheck(Base):
-    _configuration_defaults = {
-        "services": [],
-        "callable": None,
-    }
-
-    def __init__(self, di):
-        super().__init__(di)
-
-    def top_level_authentication_and_authorization(self, input_output, authentication=None):
-        pass
-
-    def handle(self, input_output):
-        services = self.configuration("services")
-        health_callable = self.configuration("callable")
-        try:
-            if services:
-                for service in services:
-                    self._di.build(service, cache=True)
-            if health_callable and not health_callable():
-                return self.respond(input_output, {"status": "failure"}, 500)
-        except:
-            return self.respond(input_output, {"status": "failure"}, 500)
-
-        return self.success(input_output, {})
-
-    def _check_configuration(self, configuration):
-        error_prefix = "Configuration error for %s:" % (self.__class__.__name__)
-        services = configuration.get("services")
-        if services is not None and type(services) != list:
-            raise ValueError(
-                f'{error_prefix} "services" should be a list of names, with each name corresponding to a dependency to load'
-            )
-        health_callable = configuration.get("callable")
-        if health_callable is not None and not callable(health_callable):
-            raise ValueError(
-                f'{error_prefix} "callable" should be a callable that returns true/false to denote health status'
-            )
-
-    def documentation(self):
-        return [
-            autodoc.request.Request(
-                "Healthcheck",
-                [
-                    self.documentation_success_response(
-                        autodoc.schema.Object("data", children=[]),
-                    ),
-                ],
-                relative_path=self.configuration("base_url"),
-            )
-        ]

clearskies/handlers/input_processing.py

@@ -1,79 +0,0 @@
-from .exceptions import InputError
-from collections import OrderedDict
-from abc import abstractmethod
-
-
-class InputProcessing:
-    _is_create = False
-
-    def _get_writeable_columns(self):
-        if self._writeable_columns is None:
-            self._writeable_columns = self._get_rw_columns("writeable")
-            additional_columns = OrderedDict()
-            for column in self._writeable_columns.values():
-                more_columns = column.additional_write_columns(is_create=self._is_create)
-                for additional_column_name, additional_column in more_columns.items():
-                    additional_columns[additional_column_name] = additional_column
-            for additional_column_name, additional_column in additional_columns.items():
-                self._writeable_columns[additional_column_name] = additional_column
-        return self._writeable_columns
-
-    def _extra_column_errors(self, input_data):
-        input_errors = {}
-        allowed = self._get_writeable_columns()
-        for column_name in input_data.keys():
-            if column_name not in allowed:
-                input_errors[column_name] = f"Input column '{column_name}' is not an allowed column"
-        return input_errors
-
-    def _find_input_errors(self, model, input_data, input_output):
-        input_errors = {}
-        for column in self._get_writeable_columns().values():
-            input_errors = {
-                **input_errors,
-                **column.input_errors(model, input_data),
-            }
-        input_error_callable = self.configuration("input_error_callable")
-        if input_error_callable:
-            more_input_errors = self._di.call_function(
-                input_error_callable,
-                input_data=input_data,
-                request_data=input_data,
-                input_output=input_output,
-                routing_data=input_output.routing_data(),
-                authorization_data=input_output.get_authorization_data(),
-            )
-            if type(more_input_errors) != dict:
-                raise ValueError(
-                    "The input error callable, '"
-                    + str(input_error_callable)
-                    + "', did not return a dictionary as required"
-                )
-            input_errors = {
-                **input_errors,
-                **more_input_errors,
-            }
-        return input_errors
-
-    def request_data(self, input_output, required=True):
-        # we have to map from internal names to external names, because case mapping
-        # isn't always one-to-one, so we want to do it exactly the same way that the documentation
-        # is built.
-        key_map = {self.auto_case_column_name(key, True): key for key in self._get_writeable_columns().keys()}
-        # in case the id comes up in the request body
-        key_map[self.auto_case_internal_column_name("id")] = "id"
-
-        # and make sure we don't drop any data along the way, because the input validation
-        # needs to return an error for unexpected data.
-        request_data = {
-            key_map.get(key, key): value for (key, value) in input_output.request_data(required=required).items()
-        }
-        # the parent handler should provide our resource id (we don't do any routing ourselves)
-        # However, our update/etc handlers need to find the id easily, so I'm going to be lazy and
-        # just dump it into the request.  I'll probably regret that.
-        routing_data = input_output.routing_data()
-        # we don't have to worry about casing on the 'id' in routing_data because it doesn't come in from the
-        # route with a name.  Rather, it is populated by clearskies, so will always just be 'id'
-        if "id" in routing_data:
-            request_data["id"] = routing_data["id"]
-        return request_data