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

clearskies/handlers/simple_routing_route.py

@@ -1,192 +0,0 @@
-import logging
-import urllib.parse
-import re
-import json
-from ..autodoc.request import URLPath
-from ..autodoc.schema import String
-from . import simple_routing
-
-logger = logging.getLogger(__name__)
-
-
-class SimpleRoutingRoute:
-    _di = None
-    _handler = None
-    _methods = None
-    _path = None
-    _path_parts = None
-    _resource_paths = None
-    _routes_to_simple_routing = False
-    _bindings = None
-    _path_parameter_with_slashes = None
-    _has_sub_paths = None
-
-    def __init__(self, di):
-        self._di = di
-
-    def configure(
-        self,
-        handler_class,
-        handler_config,
-        path=None,
-        methods=None,
-        authentication=None,
-        response_headers=None,
-        security_headers=None,
-        path_parameter_with_slashes=None,
-        bindings=None,
-        has_sub_paths=True,
-    ):
-        if authentication is not None and not handler_config.get("authentication"):
-            handler_config["authentication"] = authentication
-        response_headers = response_headers if response_headers is not None else {}
-        if "response_headers" in handler_config:
-            if type(handler_config["response_headers"]) != dict:
-                raise ValueError("Invalid configuration: 'response_headers' must be a dictionary")
-            response_headers = {**response_headers, **handler_config["response_headers"]}
-        self._path = path
-        if handler_config.get("base_url"):
-            self._path = path.rstrip("/") + "/" + handler_config.get("base_url").lstrip("/")
-        self._path_parts = self._path.strip("/").split("/") if self._path is not None else []
-        self._resource_paths = self._extract_resource_paths(self._path_parts)
-        self._bindings = bindings if bindings else {}
-        self._path_parameter_with_slashes = path_parameter_with_slashes if path_parameter_with_slashes else []
-        self._has_sub_paths = has_sub_paths
-        if methods is not None:
-            self._methods = [methods.upper()] if isinstance(methods, str) else [met.upper() for met in methods]
-        sub_handler_config = {
-            **handler_config,
-            **{
-                "base_url": ("/" + path.strip("/")) if path is not None else "/",
-            },
-        }
-        if response_headers:
-            sub_handler_config["response_headers"] = response_headers
-        security_headers = security_headers if security_headers is not None else []
-        if "security_headers" in handler_config:
-            security_headers = [*security_headers, *handler_config["security_headers"]]
-        sub_handler_config["security_headers"] = security_headers
-        self._handler = self._di.build(handler_class, cache=False)
-        self._handler.configure(sub_handler_config)
-        self._routes_to_simple_routing = issubclass(handler_class, simple_routing.SimpleRouting)
-
-    def _extract_resource_paths(self, path_parts):
-        resource_paths = {}
-        for index, part in enumerate(path_parts):
-            if not part:
-                continue
-            if part[0] != "{":
-                continue
-            if part[-1] != "}":
-                raise ValueError(
-                    f"Invalid route configuration for URL '{path}': section '{part}'"
-                    + " starts with a '{' but does not end with one"
-                )
-            match = re.match("{(\\w[\\w\\d_]{0,})\\}", part)
-            if not match:
-                raise ValueError(
-                    f"Invalid route configuration for URL '{path}', section '{part}': resource identifiers must start with a letter and contain only letters, numbers, and underscores"
-                )
-            resource_paths[index] = match.group(1)
-        return resource_paths
-
-    def matches(self, full_path, request_method, is_cors=False):
-        """Returns None if the route doesn't match, or a dictionary with route data for a match.
-
-        You can't just match true/false against the return value, because of the route matches
-        but has no route data, it returns an empty dictionary.  Check explicitly for None
-        to understand if there was no route match at all.
-        """
-        # if we're routing to a simple router then defer to it
-        incoming = f"Incoming request: [{request_method}] {full_path}.  Check against route with url '{self._path}'.  Results: "
-        if not self._methods:
-            incoming += " configured for any method except OPTIONS"
-        elif isinstance(self._methods, str):
-            incoming += f" with method '{self._methods}'"
-        else:
-            incoming += " with any of the following methods: " + ", ".join(self._methods)
-        if self._routes_to_simple_routing:
-            return self._handler.can_handle(full_path, request_method, is_cors=is_cors)
-        # If we're routing for CORS then ignore the request method (since it won't match)
-        if not is_cors and self._methods is not None and request_method not in self._methods:
-            logger.debug(
-                f"{incoming} Skipped because this route is not specifically configured for CORS, and this is an OPTIONS request."
-            )
-            return None
-        if self._resource_paths:
-            results = self._resource_path_match(full_path, self._path_parts, self._resource_paths)
-            if not results:
-                logger.debug(f"{incoming} Not a match.")
-            else:
-                logger.debug(f"{incoming} Matched and extracted route data: " + json.dumps(results))
-            return results
-        if self._path is not None:
-            full_path = full_path.strip("/")
-            my_path = self._path.strip("/")
-            my_path_length = len(my_path)
-            full_path_length = len(full_path)
-            if my_path_length > full_path_length:
-                logger.debug(f"{incoming} Not a match. I'm too long to bother checking.")
-                return None
-            if full_path[:my_path_length] != my_path:
-                logger.debug(f"{incoming} Not a match.  Our prefixes just don't match.")
-                return None
-            if not self._has_sub_paths and full_path_length > my_path_length:
-                logger.debug(f"{incoming} Not a match.  It's a partial match but I'm not allowed to do that.")
-                return None
-            # make sure we don't get confused by partial matches.  `user` should match `user/` and `user/5`,
-            # but it shouldn't match `users/`
-            if full_path_length > my_path_length and full_path[my_path_length] != "/" and my_path != "":
-                logger.debug(f"{incoming} Not a match.  I only partially matched the URL but not as a sub-directory.")
-                return None
-        logger.debug(f"{incoming} Match!")
-        return {}
-
-    def _resource_path_match(self, requested_path, path_parts, resource_paths):
-        """Returns None if the route doesn't match, or a dictionary with route data for the match."""
-        requested_parts = requested_path.strip("/").split("/")
-        route_data = {}
-        path_length = len(path_parts)
-        # it's okay if the requested path is longer than the configured path, since there may
-        # be sub-routes that we don't know about.  However, we won't ever have a match if
-        # the requested path is shorter than the configured path.
-        if len(requested_parts) < path_length:
-            return None
-        for index in range(path_length):
-            if index in resource_paths:
-                if resource_paths[index] in self._path_parameter_with_slashes:
-                    route_data[resource_paths[index]] = urllib.parse.unquote("/".join(requested_parts[index:]))
-                else:
-                    route_data[resource_paths[index]] = urllib.parse.unquote(requested_parts[index])
-            else:
-                if requested_parts[index] != path_parts[index]:
-                    return None
-        return route_data
-
-    def __call__(self, input_output):
-        # including calling parameters that came from the route matching
-        return self._handler(input_output)
-
-    def cors(self, input_output):
-        # including calling parameters that came from the route matching
-        return self._handler.cors(input_output)
-
-    def documentation(self):
-        docs = []
-        for doc in self._handler.documentation():
-            if self._methods is not None:
-                doc.set_request_methods(self._methods)
-
-            # do we have any resource paths to document?
-            for path_name in self._resource_paths.values():
-                description = f"The {path_name} to show results for"
-                doc.add_parameter(URLPath(String(path_name), description=description, required=True))
-
-            docs.append(doc)
-        return docs
-
-    def documentation_models(self):
-        return self._handler.documentation_models()
-
-    def documentation_security_schemes(self):
-        return self._handler.documentation_security_schemes()

clearskies/handlers/simple_search.py

@@ -1,136 +0,0 @@
-from .list import List
-from .. import autodoc
-from ..functional import string
-
-
-class SimpleSearch(List):
-    search_control_columns = ["sort", "direction", "limit"]
-
-    @property
-    def allowed_request_keys(self):
-        return [
-            *self.search_control_columns,
-            # the list comprehension seems unnecessary, but that is because we require searchable
-            # columns to be an iterable, but that doesn't guarantee that it converts automatically
-            # into a list.
-            *[key for key in self.configuration("searchable_columns")],
-        ]
-
-    def check_search_in_request_data(self, request_data, query_parameters):
-        for input_source_label, input_data in [("request body", request_data), ("URL data", query_parameters)]:
-            for column_name, value in input_data.items():
-                if column_name in self.search_control_columns:
-                    continue
-                if column_name not in self.configuration("searchable_columns"):
-                    return f"Invalid request. An invalid search column, '{column_name}', was found in the {input_source_label}"
-                [column_name, relationship_reference] = self._unpack_column_name_with_reference(column_name)
-                value_error = self._columns[column_name].check_search_value(
-                    value, relationship_reference=relationship_reference
-                )
-                if value_error:
-                    return (
-                        f"Invalid request. {value_error} for search column '{column_name}' in the {input_source_label}"
-                    )
-
-    def configure_models_from_request_data(self, models, request_data, query_parameters, pagination_data):
-        [models, limit] = super().configure_models_from_request_data(
-            models, request_data, query_parameters, pagination_data
-        )
-        # we can play fast and loose with the possiblity of duplicate keys because our input checking already
-        # disallows that
-        for input_source in [request_data, query_parameters]:
-            for column_name, value in input_source.items():
-                if column_name in self.search_control_columns:
-                    continue
-                if column_name == "id":
-                    column_name = self.id_column_name
-                models = self._add_join(column_name, models)
-                [column_name, relationship_reference] = self._unpack_column_name_with_reference(column_name)
-                column = self._columns[column_name]
-                models = column.add_search(models, value, relationship_reference=relationship_reference)
-
-        return [models, limit]
-
-    def _check_configuration(self, configuration):
-        super()._check_configuration(configuration)
-        self._check_columns_in_configuration(configuration, "searchable_columns")
-
-    def _documentation_request(self, request_method, parameters):
-        nice_model = string.camel_case_to_words(self._model.__class__.__name__)
-        schema_model_name = string.camel_case_to_snake_case(self._model.__class__.__name__)
-        data_schema = self.documentation_data_schema()
-
-        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())
-
-        return autodoc.request.Request(
-            f"Fetch the list of current {nice_model} records",
-            [
-                self.documentation_success_response(
-                    autodoc.schema.Array(
-                        self.auto_case_internal_column_name("data"),
-                        autodoc.schema.Object(nice_model, children=data_schema, model_name=schema_model_name),
-                    ),
-                    description=f"The matching {nice_model} records",
-                    include_pagination=True,
-                ),
-                *standard_error_responses,
-                self.documentation_generic_error_response(),
-            ],
-            relative_path=self.configuration("base_url"),
-            request_methods=request_method,
-            parameters=parameters,
-            root_properties={
-                "security": self.documentation_request_security(),
-            },
-        )
-
-    def documentation(self):
-        return [
-            self._documentation_request(
-                "GET",
-                [
-                    *self.documentation_url_pagination_parameters(),
-                    *self.documentation_url_sort_parameters(),
-                    *self.documentation_url_search_parameters(),
-                ],
-            ),
-            self._documentation_request(
-                "POST",
-                [
-                    *self.documentation_url_pagination_parameters(),
-                    *self.documentation_url_sort_parameters(),
-                    *self.documentation_json_search_parameters(),
-                ],
-            ),
-        ]
-
-    def documentation_url_search_parameters(self):
-        docs = []
-        for column in self._get_searchable_columns().values():
-            column_doc = column.documentation()
-            column_doc.name = self.auto_case_internal_column_name(column_doc.name)
-            docs.append(
-                autodoc.request.URLParameter(
-                    column_doc,
-                    description=f"Search by {column_doc.name} (via exact match)",
-                )
-            )
-        return docs
-
-    def documentation_json_search_parameters(self):
-        docs = []
-        for column in self._get_searchable_columns().values():
-            column_doc = column.documentation()
-            column_doc.name = self.auto_case_internal_column_name(column_doc.name)
-            docs.append(
-                autodoc.request.JSONBody(
-                    column_doc,
-                    description=f"Search by {column_doc.name} (via exact match)",
-                )
-            )
-        return docs

clearskies/handlers/update.py

@@ -1,96 +0,0 @@
-from .write import Write
-from .exceptions import InputError
-from collections import OrderedDict
-from ..functional import string
-
-
-class Update(Write):
-    def __init__(self, di):
-        super().__init__(di)
-
-    _configuration_defaults = {
-        "model": None,
-        "model_class": None,
-        "columns": None,
-        "column_overrides": None,
-        "writeable_columns": None,
-        "readable_columns": None,
-        "output_map": None,
-        "where": [],
-        "input_error_callable": None,
-        "include_id_in_path": False,
-    }
-
-    def get_model_id(self, input_output, input_data):
-        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 handle(self, input_output):
-        input_data = self.request_data(input_output)
-        model_id = self.get_model_id(input_output, input_data)
-        if not model_id:
-            return self.error(input_output, "Not Found", 404)
-        id_column_name = self.id_column_name
-        models = self._model.where(f"{id_column_name}={model_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()
-                )
-        models = models.where_for_request(
-            models,
-            input_output.routing_data(),
-            input_output.get_authorization_data(),
-            input_output,
-            overrides=self.configuration("column_overrides"),
-        )
-        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 self.error(input_output, "Not Found", 404)
-        if "id" in input_data:
-            del input_data["id"]
-
-        input_errors = {
-            **self._extra_column_errors(input_data),
-            **self._find_input_errors(model, input_data, input_output),
-        }
-        if input_errors:
-            raise InputError(input_errors)
-        model.save(input_data, columns=self._get_writeable_columns())
-
-        return self.success(input_output, self._model_as_json(model, input_output))
-
-    def _check_configuration(self, configuration):
-        super()._check_configuration(configuration)
-        error_prefix = "Configuration error for %s:" % (self.__class__.__name__)
-        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",
-                    )
-
-    def documentation(self):
-        nice_model = string.camel_case_to_words(self._model.__class__.__name__)
-        id_label = "id" if self.configuration("id_column_name") else self.id_column_name
-        return self._documentation(
-            description="Update the " + nice_model + " with an " + id_label + " of {" + id_label + "}",
-            response_description=f"The updated {nice_model}",
-            include_id_in_path=self.configuration("include_id_in_path"),
-        )

clearskies/handlers/write.py

@@ -1,193 +0,0 @@
-from .base import Base
-from .input_processing import InputProcessing
-from .exceptions import InputError
-from collections import OrderedDict
-from abc import abstractmethod
-from .. import autodoc
-from ..functional import string
-import inspect
-
-
-class Write(Base, InputProcessing):
-    _di = None
-    _model = None
-    _columns = None
-    _authentication = None
-    _writeable_columns = None
-    _readable_columns = None
-
-    _configuration_defaults = {
-        "model": None,
-        "model_class": None,
-        "columns": None,
-        "column_overrides": None,
-        "writeable_columns": None,
-        "output_map": None,
-        "readable_columns": None,
-        "input_error_callable": None,
-    }
-
-    def __init__(self, di):
-        super().__init__(di)
-
-    @abstractmethod
-    def handle(self, input_output):
-        pass
-
-    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 "input_error_callable" in configuration and not callable(configuration.get("input_error_callable")):
-            raise ValueError(
-                "{error_prefix} you must provide a callable for the 'input_error_callable' configuration but the provided value is not callable"
-            )
-        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"))
-        has_columns = "columns" in configuration and configuration["columns"] is not None
-        has_writeable = "writeable_columns" in configuration and configuration["writeable_columns"] is not None
-        has_readable = "readable_columns" in configuration and configuration["readable_columns"] is not None
-        if not has_columns and not has_writeable:
-            raise KeyError(f"{error_prefix} you must specify 'columns' OR 'writeable_columns'")
-        if not has_columns and not has_readable:
-            raise KeyError(f"{error_prefix} you must specify 'columns' OR 'readable_columns'")
-        if has_columns and has_writeable:
-            raise KeyError(f"{error_prefix} you must specify 'columns' OR 'writeable_columns', not both")
-        if has_columns and has_readable:
-            raise KeyError(f"{error_prefix} you must specify 'columns' OR 'readable_columns', not both")
-        if has_writeable and not has_readable:
-            raise KeyError(f"{error_prefix} you must specify 'readable_columns' if you specify 'writeable_columns'")
-        if has_readable and not has_writeable:
-            raise KeyError(f"{error_prefix} you must specify 'writeable_columns' if you specify 'readable_columns'")
-
-        for config_name in ["columns", "writeable_columns", "readable_columns"]:
-            if config_name not in configuration or configuration[config_name] is not None:
-                continue
-            if hasattr(configuration[config_name], "__iter__"):
-                continue
-            raise ValueError(
-                f"{error_prefix} '{config_name}' should be a list of column names "
-                + f", not {str(type(configuration[config_name]))}"
-            )
-
-        if has_columns and not configuration["columns"]:
-            raise KeyError(f"{error_prefix} you must specify at least one column for 'columns'")
-        if has_writeable and not configuration["writeable_columns"]:
-            raise KeyError(f"{error_prefix} you must specify at least one column for 'writeable_columns'")
-        if has_readable and not configuration["readable_columns"]:
-            raise KeyError(f"{error_prefix} you must specify at least one column for 'readable_columns'")
-        writeable_columns = configuration["writeable_columns"] if has_writeable else configuration["columns"]
-        for column_name in writeable_columns:
-            if column_name not in self._columns:
-                raise KeyError(f"{error_prefix} specified writeable column '{column_name}' does not exist")
-            if not self._columns[column_name].is_writeable:
-                raise KeyError(f"{error_prefix} specified writeable column '{column_name}' is not writeable")
-        readable_columns = configuration["readable_columns"] if has_readable else configuration["columns"]
-        for column_name in readable_columns:
-            if column_name not in self._columns:
-                raise KeyError(f"{error_prefix} specified readable column '{column_name}' does not exist")
-
-    def _get_rw_columns(self, rw_type):
-        column_names = self.configuration("columns")
-        if column_names is None:
-            column_names = self.configuration(f"{rw_type}_columns")
-        wr_columns = OrderedDict()
-        for column_name in column_names:
-            if column_name not in self._columns:
-                class_name = self.__class__.__name__
-                model_class = self._model.__class__.__name__
-                raise ValueError(
-                    f"Configuration error for {self.__class__.__name__}: handler was configured with {rw_type} "
-                    + f"column '{column_name}' but this column doesn't exist for model {model_class}"
-                )
-            wr_columns[column_name] = self._columns[column_name]
-        return wr_columns
-
-    def _get_readable_columns(self):
-        if self._readable_columns is None:
-            self._readable_columns = self._get_rw_columns("readable")
-        return self._readable_columns
-
-    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(),
-            ),
-        }
-
-    def _documentation(self, description="", response_description="", include_id_in_path=False):
-        nice_model = string.camel_case_to_words(self._model.__class__.__name__)
-        data_schema = self.documentation_data_schema()
-        schema_model_name = string.camel_case_to_snake_case(self._model.__class__.__name__)
-
-        authentication = self.configuration("authentication")
-        standard_error_responses = [
-            self.documentation_input_error_response(),
-        ]
-        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
-
-        url = self.configuration("base_url")
-        if include_id_in_path:
-            url = url.rstrip("/") + "/{" + id_label + "}"
-
-        return [
-            autodoc.request.Request(
-                description,
-                [
-                    self.documentation_success_response(
-                        autodoc.schema.Object(
-                            self.auto_case_internal_column_name("data"),
-                            children=data_schema,
-                            model_name=schema_model_name,
-                        ),
-                        description=description,
-                    ),
-                    *standard_error_responses,
-                    self.documentation_not_found(),
-                ],
-                relative_path=url,
-                parameters=[
-                    *self.documentation_write_parameters(nice_model, include_id_in_path=include_id_in_path),
-                ],
-                root_properties={
-                    "security": self.documentation_request_security(),
-                },
-            )
-        ]
-
-    def documentation_write_parameters(self, model_name, include_id_in_path=False):
-        id_label = "id" if self.configuration("id_column_name") else self.id_column_name
-        parameters = [
-            autodoc.request.JSONBody(
-                column.documentation(name=self.auto_case_column_name(column.name, True)),
-                description=f"Set '{column.name}' for the {model_name}",
-                required=column.is_required,
-            )
-            for column in self._get_writeable_columns().values()
-        ]
-        if include_id_in_path:
-            parameters.append(
-                autodoc.request.URLPath(
-                    autodoc.schema.String(id_label),
-                    description=f"The {id_label} of the record in question.",
-                    required=True,
-                )
-            )
-        return parameters