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

clearskies/handlers/restful_api.py

@@ -1,218 +0,0 @@
-import urllib.parse
-from .routing import Routing
-from .create import Create
-from .update import Update
-from .delete import Delete
-from .get import Get
-from .list import List
-from .advanced_search import AdvancedSearch
-from .. import autodoc
-
-
-class InvalidUrl(Exception):
-    pass
-
-
-class RestfulAPI(Routing):
-    _cached_handlers = None
-
-    _configuration_defaults = {
-        "base_url": "",
-        "allow_create": True,
-        "allow_delete": True,
-        "allow_get": True,
-        "allow_list": True,
-        "allow_search": True,
-        "allow_update": True,
-        "create_handler": Create,
-        "delete_handler": Delete,
-        "get_handler": Get,
-        "list_handler": List,
-        "search_handler": AdvancedSearch,
-        "update_handler": Update,
-        "read_only": False,
-        "create_request_method": "POST",
-        "delete_request_method": "DELETE",
-        "get_request_method": "GET",
-        "list_request_method": "GET",
-        "search_request_method": ["GET", "POST"],
-        "update_request_method": "PUT",
-    }
-
-    _resource_id = None
-    _is_search = False
-
-    def __init__(self, di):
-        super().__init__(di)
-        self._cached_handlers = {}
-
-    def handler_classes(self, configuration):
-        classes = []
-        for action in ["create", "delete", "get", "list", "search", "update"]:
-            allow_key = f"allow_{action}"
-            handler_key = f"{action}_handler"
-            if allow_key in configuration and not configuration[allow_key]:
-                continue
-            classes.append(
-                configuration[handler_key]
-                if handler_key in configuration
-                else self._configuration_defaults[handler_key]
-            )
-        return classes
-
-    def configure(self, configuration):
-        # if we have read only set then we can't allow any write methods
-        if configuration.get("read_only"):
-            for action in ["update", "delete", "create"]:
-                if configuration.get(f"allow_{action}"):
-                    raise ValueError(
-                        f"Contradictory configuration for handler '{self.__class__.__name__}': "
-                        + f"'read_only' and 'allow_{action} are both set to True"
-                    )
-                configuration[f"allow_{action}"] = False
-
-        super().configure(configuration)
-
-    def _finalize_configuration(self, configuration):
-        search_request_method = configuration.get("search_request_method")
-        if type(search_request_method) == str:
-            configuration["search_request_method"] = [search_request_method]
-        configuration["search_request_method"] = [method.upper() for method in configuration["search_request_method"]]
-
-        request_method_keys = [
-            "create_request_method",
-            "delete_request_method",
-            "get_request_method",
-            "list_request_method",
-            "update_request_method",
-        ]
-        for key in request_method_keys:
-            configuration[key] = configuration[key].upper()
-
-        return super()._finalize_configuration(configuration)
-
-    def handle(self, input_output):
-        [resource_id, handler_class] = self._get_handler_class_for_route(input_output)
-        if handler_class is None:
-            return self.error(input_output, "Not Found", 404)
-        handler = self.fetch_cached_handler(handler_class)
-        if resource_id is not None:
-            input_output.add_routing_data({"id": resource_id})
-        return handler(input_output)
-
-    def cors(self, input_output):
-        cors = self._cors_header
-        if not cors:
-            return self.error(input_output, "not found", 404)
-        authentication = self._configuration.get("authentication")
-        if authentication:
-            authentication.set_headers_for_cors(cors)
-        methods = {}
-        for action in ["create", "delete", "list", "search", "update"]:
-            if self.configuration(f"allow_{action}"):
-                route_methods = self.configuration(f"{action}_request_method")
-                if type(route_methods) != list:
-                    route_methods = [route_methods]
-                for route_method in route_methods:
-                    methods[route_method] = True
-        for method in methods.keys():
-            cors.add_method(method)
-        cors.set_headers_for_input_output(input_output)
-        return input_output.respond("", 200)
-
-    def fetch_cached_handler(self, handler_class):
-        cache_key = handler_class.__name__
-        if cache_key not in self._cached_handlers:
-            self._cached_handlers[cache_key] = self.build_handler(handler_class)
-        return self._cached_handlers[cache_key]
-
-    def build_handler(self, handler_class, configuration=None):
-        if not configuration and handler_class == self.configuration("update_handler"):
-            configuration = self._configuration
-            configuration["include_id_in_path"] = True
-        return super().build_handler(handler_class, configuration=configuration)
-
-    def _get_handler_class_for_route(self, input_output):
-        try:
-            [is_search, resource_id] = self._parse_url(input_output)
-        except InvalidUrl:
-            return [None, None]
-        request_method = input_output.get_request_method().upper()
-        if is_search:
-            if request_method not in self.configuration("search_request_method"):
-                return [None, None]
-            return [resource_id, self.configuration("search_handler") if self.configuration("allow_search") else None]
-        if resource_id:
-            if request_method == self.configuration("update_request_method"):
-                return [
-                    resource_id,
-                    self.configuration("update_handler") if self.configuration("allow_update") else None,
-                ]
-            elif request_method == self.configuration("delete_request_method"):
-                return [
-                    resource_id,
-                    self.configuration("delete_handler") if self.configuration("allow_delete") else None,
-                ]
-            if request_method != self.configuration("get_request_method"):
-                return [None, None]
-            return [resource_id, self.configuration("get_handler") if self.configuration("allow_get") else None]
-        if request_method == self.configuration("create_request_method"):
-            return [resource_id, self.configuration("create_handler") if self.configuration("allow_create") else None]
-        if request_method == self.configuration("list_request_method"):
-            return [resource_id, self.configuration("list_handler") if self.configuration("allow_list") else None]
-        return [None, None]
-
-    def _parse_url(self, input_output):
-        resource_id = None
-        is_search = False
-        full_path = input_output.get_full_path().strip("/")
-        base_url = self.configuration("base_url").strip("/")
-        for key, value in input_output.routing_data().items():
-            base_url = base_url.replace("{" + key + "}", value)
-        if base_url and full_path[: len(base_url)] != base_url:
-            raise InvalidUrl()
-        url = full_path[len(base_url) :].strip("/")
-        if url:
-            if url == "search" and self.configuration("allow_search"):
-                is_search = True
-            else:
-                resource_id = urllib.parse.unquote(url)
-        return [is_search, resource_id]
-
-    def documentation(self):
-        docs = []
-        for name in ["list", "get", "search", "create", "update", "delete"]:
-            if not self.configuration(f"allow_{name}"):
-                continue
-            handler = self.build_handler(self.configuration(f"{name}_handler"))
-            action_docs = handler.documentation()
-            for doc in action_docs:
-                request_methods = self.configuration(f"{name}_request_method")
-
-                # for search, filter down the docs to only the allowed request methods.
-                # for the rest, set the request method to match the allowed one.
-                # this helps with the fact that the searching has different input methods depending
-                # on the request method, and helps with the fact that search has different rules
-                # for different methods.
-                if name == "search":
-                    if not set(request_methods).intersection(set(doc.request_methods)):
-                        continue
-                else:
-                    doc.set_request_methods(request_methods if type(request_methods) == list else [request_methods])
-
-                if name == "search":
-                    doc.append_relative_path("search")
-
-                docs.append(doc)
-
-        return docs
-
-    def documentation_models(self):
-        # read and write use the same model, so we just need one
-        read_handler = self.build_handler(self.configuration("get_handler"))
-        return read_handler.documentation_models()
-
-    def documentation_security_schemes(self):
-        # read and write use the same model, so we just need one
-        read_handler = self.build_handler(self.configuration("get_handler"))
-        return read_handler.documentation_security_schemes()

clearskies/handlers/routing.py

@@ -1,62 +0,0 @@
-from .base import Base
-from abc import abstractmethod
-
-
-class Routing(Base):
-    def __init__(self, di):
-        super().__init__(di)
-
-    @abstractmethod
-    def handler_classes(self, configuration):
-        pass
-
-    @abstractmethod
-    def handle(self, input_output):
-        pass
-
-    def build_handler(self, handler_class, configuration=None):
-        if configuration is None:
-            configuration = self._configuration
-        handler = self._di.build(handler_class, cache=False)
-        handler_configuration = {}
-        for key in handler._configuration_defaults.keys():
-            if key in configuration:
-                handler_configuration[key] = configuration[key]
-        for key in handler._global_configuration_defaults.keys():
-            if key in configuration:
-                handler_configuration[key] = configuration[key]
-        handler.configure(self._finalize_configuration_for_sub_handler(handler_configuration, handler_class))
-        return handler
-
-    def _finalize_configuration_for_sub_handler(self, configuration, handler_class):
-        return configuration
-
-    def configure(self, configuration):
-        # we need to completely clobber the base configuration process because it expects to have
-        # the list of all allowed configurations.  We don't know what that list is - rather, we
-        # just need to fulfill the requirements of the handlers we'll be routing to.
-        # We also want to make it possible for handlers that extend this to still define their
-        # own possible configuration values.  Therefore, we'll loop over all of the handlers
-        # which we might route to, make them, have them check the configs, and let them throw exceptions
-        # as needed.  Finally we'll figure out what configs may not have been "used" by a child handler
-        # and see if those are in our own configuration - if not, we'll throw an "Unknown config" exception
-
-        # First, let's check the configuration for the handlers, which is just a matter of building
-        # the handlers (they willl automatically throw exceptions for invalid configurations as part
-        # of this process)
-        used_configs = list(self._global_configuration_defaults.keys())
-        used_configs.extend(self._configuration_defaults.keys())
-        for handler_class in self.handler_classes(configuration):
-            handler = self.build_handler(handler_class, configuration=configuration)
-            used_configs.extend(handler._configuration_defaults.keys())
-
-        for key in configuration.keys():
-            if key not in used_configs and key not in self._global_configuration_defaults:
-                class_name = self.__class__.__name__
-                raise KeyError(f"Attempt to set unknown configuration setting '{key}' for handler '{class_name}'")
-
-        self._check_configuration(configuration)
-        self._configuration = self._finalize_configuration(self.apply_default_configuration(configuration))
-
-    def _check_configuration(self, configuration):
-        super()._check_configuration(configuration)

clearskies/handlers/schema_helper.py

@@ -1,128 +0,0 @@
-from collections import OrderedDict
-from abc import ABC
-from ..functional import validations
-
-
-class FakeModel:
-    def __getattr__(self, key):
-        return None
-
-
-class SchemaHelper(ABC):
-    """
-    A helper for handlers that want to accept arbitrary schemas as configuration inputs.
-
-    To use this, the schema should be stored in a configuration called `schema`.  You can then check
-    some data against the schema by doing something like this:
-
-    ```
-    input_errors = {
-        **self._extra_column_errors(request_data),
-        **self._find_input_errors(request_data),
-    }
-    ```
-    """
-
-    def _check_schema(self, schema, writeable_columns, error_prefix):
-        """
-        Validates that the schema provided in the configuration is valid.
-
-        The schema is allowed to be one of 3 things:
-
-        1. A list of column definitions.
-        2. A model class.
-        3. A model.
-
-        An example of option #1 would be:
-
-        ```
-        {
-            'schema': [
-                clearskies.column_types.string('name', input_requirements=[clearskies.input_requirements.required()]),
-                clearskies.column_types.integer('age'),
-            ],
-        }
-        ```
-        """
-        is_valid_schema = False
-        if validations.is_model_or_class(schema):
-            is_valid_schema = True
-        else:
-            if not hasattr(schema, "__iter__") or type(schema) == str:
-                raise ValueError(
-                    f"{error_prefix} 'schema' should be a list of column definitions, but was instead a " + type(schema)
-                )
-            for column in schema:
-                if type(column) != tuple:
-                    raise ValueError(
-                        f"{error_prefix} 'schema' should be a list of column definitions, but one of the entries was not a column definition"
-                    )
-            is_valid_schema = True
-        if not is_valid_schema:
-            raise ValueError(
-                f"{error_prefix} 'schema' should be a model, model class, or list of column definitions, but was instead a "
-                + type(schema)
-            )
-
-        if not writeable_columns and writeable_columns is not None:
-            raise ValueError(
-                f"{error_prefix} 'writeable_columns' can't be an empty list.  It can be 'None', but otherwise I don't know how to handle empty values"
-            )
-
-        if writeable_columns:
-            if not hasattr(writeable_columns, "__iter__") or type(writeable_columns) == str:
-                raise ValueError(
-                    f"{error_prefix} 'writeable_columns' should be a list of column names, but was instead a "
-                    + type(writeable_columns)
-                )
-            columns = self._schema_to_columns(schema)
-            for column in writeable_columns:
-                if type(column) != str:
-                    raise ValueError(
-                        f"{error_prefix} 'writeable_columns' should be a list of column names, but one of the entries was not a string"
-                    )
-                if column not in columns:
-                    raise ValueError(
-                        f"{error_prefix} 'writeable_columns' references a column named '{column}' but this column does not exist in the schema"
-                    )
-
-    def _schema_to_columns(self, schema, columns_to_keep=None):
-        """
-        Converts the schema from the developer to a columns object
-        """
-        # the schema can be a model, model class, or list of column configs.
-        # Each requires a different conversion method
-        if validations.is_model(schema):
-            columns = schema.columns()
-        elif validations.is_model_class(schema):
-            columns = self._di.build(schema).columns()
-        else:
-            columns = self._di.build("columns").configure(OrderedDict(schema), self.__class__)
-
-        # if we don't have a list of columns to keep, then we're done
-        if not columns_to_keep:
-            return columns
-
-        # only keep things that we're allowed to keep
-        return OrderedDict([(key, value) for (key, value) in columns.items() if key in columns_to_keep])
-
-    def _find_input_errors(self, input_data, schema=None):
-        if not schema:
-            schema = self.configuration("schema")
-        input_errors = {}
-        fake_model = FakeModel()
-        for column in schema.values():
-            input_errors = {
-                **input_errors,
-                **column.input_errors(fake_model, input_data),
-            }
-        return input_errors
-
-    def _extra_column_errors(self, input_data, schema=None):
-        if not schema:
-            schema = self.configuration("schema")
-        input_errors = {}
-        for column_name in input_data.keys():
-            if column_name not in schema:
-                input_errors[column_name] = f"Input column '{column_name}' is not an allowed column"
-        return input_errors

clearskies/handlers/simple_routing.py

@@ -1,206 +0,0 @@
-from .base import Base
-from abc import abstractmethod
-from .simple_routing_route import SimpleRoutingRoute
-from . import callable as callable_handler
-from ..functional import string
-from .. import autodoc
-
-
-class SimpleRouting(Base):
-    _routes = None
-
-    _configuration_defaults = {
-        "base_url": "",
-        "authentication": None,
-        "routes": [],
-        "schema_route": "",
-        "schema_configuration": {},
-        "schema_format": autodoc.formats.oai3_json.OAI3JSON,
-        "schema_authentication": None,
-    }
-
-    def __init__(self, di):
-        super().__init__(di)
-
-    def top_level_authentication_and_authorization(self, input_output, authentication=None):
-        # Check for separate authentication on the schema route
-        schema_authentication = self.configuration("schema_authentication")
-        if schema_authentication:
-            request_method = input_output.get_request_method()
-            full_path = input_output.get_full_path().strip("/")
-            if self.configuration("schema_route") and self.configuration("schema_route") == full_path:
-                return super().top_level_authentication_and_authorization(input_output, schema_authentication)
-        return super().top_level_authentication_and_authorization(input_output)
-
-    def can_handle(self, full_path, request_method, is_cors=False):
-        for route in self._routes:
-            route_data = route.matches(full_path, request_method, is_cors=is_cors)
-            if route_data is not None:
-                return route_data
-        return None
-
-    def handle(self, input_output):
-        request_method = input_output.get_request_method()
-        full_path = input_output.get_full_path().strip("/")
-        if self.configuration("schema_route") and self.configuration("schema_route") == full_path:
-            return self.hosted_schema(input_output)
-
-        if request_method == "OPTIONS":
-            return self.cors(input_output)
-
-        for route in self._routes:
-            route_data = route.matches(full_path, request_method)
-            if route_data is None:
-                continue
-            input_output.add_routing_data(route_data)
-
-            return route(input_output)
-
-        return self.error(input_output, "Page not found", 404)
-
-    def cors(self, input_output):
-        if not self._cors_header:
-            return self.error(input_output, "not found", 404)
-        request_method = input_output.get_request_method()
-        full_path = input_output.get_full_path().strip("/")
-        for route in self._routes:
-            route_data = route.matches(full_path, request_method, is_cors=True)
-            if route_data is None:
-                continue
-
-            return route.cors(input_output)
-        return self.error(input_output, "Page not found", 404)
-
-    def _check_configuration(self, configuration):
-        super()._check_configuration(configuration)
-
-        if not configuration.get("routes"):
-            raise ValueError(f"'routes' must be a list of routes for the {self.__class__.__name__} handler")
-        if not hasattr(configuration["routes"], "__iter__"):
-            raise ValueError(
-                f"'routes' must be a list of routes for the {self.__class__.__name__} handler, "
-                + "but a non-iterable was provided instead"
-            )
-        if isinstance(configuration["routes"], str):
-            raise ValueError(
-                f"'routes' must be a list of routes for the {self.__class__.__name__} handler, "
-                + "but a string was provided instead"
-            )
-
-        # we're actually going to build our routes, which will implicitly check the configuration too
-        base_url = configuration.get("base_url")
-        self._build_routes(
-            configuration["routes"],
-            base_url if base_url else "/",
-            authentication=configuration.get("authentication"),
-            response_headers=configuration.get("response_headers"),
-            security_headers=configuration.get("security_headers"),
-        )
-
-    def _finalize_configuration(self, configuration):
-        configuration = super()._finalize_configuration(configuration)
-        if configuration.get("schema_route"):
-            base_url = configuration.get("base_url")
-            configuration["schema_route"] = (
-                base_url.strip("/") + "/" + configuration["schema_route"].strip("/")
-            ).strip("/")
-        if configuration.get("schema_authentication") is not None:
-            configuration["schema_authentication"] = self._di.build(configuration["schema_authentication"])
-        return configuration
-
-    def _build_routes(self, routes, base_url, authentication=None, response_headers=None, security_headers=None):
-        self._routes = []
-        if base_url is None:
-            base_url = ""
-        for i, route_config in enumerate(routes):
-            # in general the route should be a dictionary with the route configuration,
-            # but there are two exceptions.  The first is a "plain" callable.  In that case,
-            # wrap it in a callable handler and define the path from the name
-            if type(route_config) != dict:
-                if callable(route_config):
-                    route_config = {
-                        "path": route_config.__name__,
-                        "handler_class": callable_handler.Callable,
-                        "handler_config": {"callable": route_config},
-                    }
-                # the other option is an application with another simple routing handler, in which
-                # case just skip the path (which is optional anyway)
-                elif (
-                    hasattr(route_config, "handler_class")
-                    and hasattr(route_config, "handler_config")
-                    and issubclass(route_config.handler_class, SimpleRouting)
-                ):
-                    route_config = {
-                        "path": "",
-                        "application": route_config,
-                    }
-            if type(route_config) != dict:
-                raise ValueError(
-                    f"Routing config expected a dictionary with route information but found something else for route #{i+1}"
-                )
-            path = route_config.get("path")
-            if path is None:
-                path = ""
-            if route_config.get("application"):
-                application = route_config.get("application")
-                if not hasattr(application, "handler_config") or not hasattr(application, "handler_class"):
-                    raise ValueError(f"A non application was passed in the 'application' key of route #{i+1}")
-                route_config["handler_class"] = application.handler_class
-                route_config["handler_config"] = application.handler_config
-            if not route_config.get("handler_class"):
-                raise ValueError(
-                    "Each route must specify a handler class via 'handler_class' key, "
-                    + f"but 'handler_class' was missing for route #{i+1}"
-                )
-            if route_config.get("handler_config") is None:
-                raise ValueError(
-                    "Each route must specify the handler configuration via 'handler_config' key, "
-                    + f"but 'handler_config' was missing for route #{i+1}"
-                )
-            if route_config.get("authentication"):
-                authentication = self._di.build(route_config.get("authentication"), cache=True)
-            route = SimpleRoutingRoute(self._di)
-            route.configure(
-                route_config["handler_class"],
-                route_config["handler_config"],
-                path=base_url.rstrip("/") + "/" + path.lstrip("/"),
-                methods=route_config.get("methods"),
-                path_parameter_with_slashes=route_config.get("path_parameter_with_slashes"),
-                authentication=authentication,
-                response_headers=response_headers,
-                security_headers=security_headers,
-                has_sub_paths=route_config.get("has_sub_paths", True),
-            )
-            self._routes.append(route)
-
-    def documentation(self):
-        docs = []
-        for route in self._routes:
-            docs.extend(route.documentation())
-        return docs
-
-    def documentation_security_schemes(self):
-        schemes = {}
-        for route in self._routes:
-            schemes = {**schemes, **route.documentation_security_schemes()}
-        return schemes
-
-    def documentation_models(self):
-        models = {}
-        for route in self._routes:
-            models = {**models, **route.documentation_models()}
-        return models
-
-    def hosted_schema(self, input_output):
-        schema = self._di.build(self.configuration("schema_format"))
-        schema.set_requests(self.documentation())
-        schema.set_components(self.documentation_components())
-        extra_schema_config = self.configuration("schema_configuration")
-        if "info" not in extra_schema_config:
-            extra_schema_config["info"] = {"title": "Auto generated by clearskies", "version": "1.0"}
-        response_headers = self.configuration("response_headers")
-        if response_headers:
-            input_output.set_headers(response_headers)
-        for security_header in self.configuration("security_headers"):
-            security_header.set_headers_for_input_output(input_output)
-        return input_output.respond(schema.pretty(root_properties=extra_schema_config), 200)