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

clearskies/condition_parser.py

@@ -1,172 +0,0 @@
-import re
-
-
-class ConditionParser:
-    operators = ["<=>", "!=", "<=", ">=", ">", "<", "=", "in", "is not null", "is null", "is not", "is", "like"]
-
-    operator_lengths = {
-        "<=>": 3,
-        "<=": 2,
-        ">=": 2,
-        "!=": 2,
-        ">": 1,
-        "<": 1,
-        "=": 1,
-        "in": 4,
-        "is not null": 12,
-        "is null": 8,
-        "is not": 8,
-        "is": 4,
-        "like": 6,
-    }
-
-    # some operators require spaces around them
-    operators_for_matching = {
-        "like": " like ",
-        "in": " in ",
-        "is not null": " is not null",
-        "is null": " is null",
-        "is": " is ",
-        "is not": " is not ",
-    }
-
-    operators_with_simple_placeholders = {
-        "<=>": True,
-        "<=": True,
-        ">=": True,
-        "!=": True,
-        "=": True,
-        "<": True,
-        ">": True,
-    }
-
-    operators_without_placeholders = {
-        "is not null",
-        "is null",
-    }
-
-    def parse_condition(self, condition):
-        lowercase_condition = condition.lower()
-        matching_operator = None
-        matching_index = len(condition)
-        # figure out which operator comes earliest in the string: make sure and check all so we match the
-        # earliest operator so we don't get weird results for things like 'age=name<=5'.
-        for operator in self.operators:
-            try:
-                operator_for_match = self.operators_for_matching.get(operator, operator)
-                index = lowercase_condition.index(operator_for_match)
-            except ValueError:
-                continue
-            if index < matching_index:
-                matching_index = index
-                matching_operator = operator
-
-        if matching_operator is None:
-            raise ValueError(f"No supported operators found in condition {condition}")
-
-        column = condition[:matching_index].strip().replace("`", "")
-        value = condition[matching_index + self.operator_lengths[matching_operator] :].strip()
-        if value and (value[0] == "'" and value[-1] == "'"):
-            value = value.strip("'")
-        values = self._parse_condition_list(value) if matching_operator == "in" else [value]
-        table = ""
-        if "." in column:
-            [table, column] = column.split(".")
-        column_for_parsed = f"{table}.{column}" if table else column
-        return {
-            "table": table,
-            "column": column,
-            "operator": matching_operator.upper(),
-            "values": [] if matching_operator in self.operators_without_placeholders else values,
-            "parsed": self._with_placeholders(
-                column_for_parsed, matching_operator, values, escape=False if table else True
-            ),
-        }
-
-    def _parse_condition_list(self, value):
-        if value[0] != "(" and value[-1] != ")":
-            raise ValueError(f"Invalid search value {value} for condition.  For IN operator use `IN (value1,value2)`")
-
-        # note: this is not very smart and will mess things up if there are single quotes/commas in the data
-        return list(map(lambda value: value.strip().strip("'"), value[1:-1].split(",")))
-
-    def _with_placeholders(self, column, operator, values, escape=True, escape_character="`"):
-        quote = escape_character if escape else ""
-        column = column.replace("`", "")
-        upper_case_operator = operator.upper()
-        lower_case_operator = operator.lower()
-        if lower_case_operator in self.operators_with_simple_placeholders:
-            return f"{quote}{column}{quote}{upper_case_operator}%s"
-        if lower_case_operator in self.operators_without_placeholders:
-            return f"{quote}{column}{quote} {upper_case_operator}"
-        if lower_case_operator == "is" or lower_case_operator == "is not" or lower_case_operator == "like":
-            return f"{quote}{column}{quote} {upper_case_operator} %s"
-
-        # the only thing left is "in" which has a variable number of placeholders
-        return f"{quote}{column}{quote} IN (" + ", ".join(["%s" for i in range(len(values))]) + ")"
-
-    def parse_join(self, join):
-        # doing this the simple and stupid way, until that doesn't work.  Yes, it is ugly.
-        # Splitting this into two regexps for simplicity: this one does not check for an alias
-        matches = re.match(
-            "(\\w+\\s+)?join\\s+`?([^\\s`]+)`?\\s+on\\s+`?([^`]+)`?\\.`?([^`]+)`?\\s*=\\s*`?([^`]+)`?\\.`?([^`]+)`?",
-            join,
-            re.IGNORECASE,
-        )
-        if matches:
-            groups = matches.groups()
-            alias = ""
-            join_type = groups[0]
-            right_table = groups[1]
-            first_table = groups[2]
-            first_column = groups[3]
-            second_table = groups[4]
-            second_column = groups[5]
-        else:
-            matches = re.match(
-                "(\\w+\\s+)?join\\s+`?([^\\s`]+)`?\\s+(as\\s+)?(\\S+)\\s+on\\s+`?([^`]+)`?\\.`?([^`]+)`?\\s*=\\s*`?([^`]+)`?\\.`?([^`]+)`?",
-                join,
-                re.IGNORECASE,
-            )
-            if not matches:
-                raise ValueError(f"Specified join condition, '{join}' does not appear to be a valid join statement")
-            groups = matches.groups()
-            join_type = groups[0]
-            right_table = groups[1]
-            alias = groups[3]
-            first_table = groups[4]
-            first_column = groups[5]
-            second_table = groups[6]
-            second_column = groups[7]
-
-        # which is the left table and which is the right table?
-        match_by = alias if alias else right_table
-        if first_table == match_by:
-            join_data = {
-                "left_table": second_table,
-                "left_column": second_column,
-                "right_table": first_table,
-                "right_column": first_column,
-            }
-        elif second_table == match_by:
-            join_data = {
-                "left_table": first_table,
-                "left_column": first_column,
-                "right_table": second_table,
-                "right_column": second_column,
-            }
-        else:
-            raise ValueError(
-                f"Specified join condition, '{join}' was not understandable because the joined table "
-                + "is not referenced in the 'on' clause"
-            )
-
-        return {
-            **join_data,
-            **{
-                "type": groups[0].strip().upper() if groups[0] else "INNER",
-                "table": right_table,
-                "alias": alias,
-                "raw": join,
-            },
-        }

clearskies/contexts/build_context.py

@@ -1,54 +0,0 @@
-from ..application import Application
-from ..di import StandardDependencies
-from ..handlers.callable import Callable
-from .convert_to_application import convert_to_application
-import sys
-
-
-def build_context(
-    context_class,
-    application,
-    di_class=None,
-    bindings=None,
-    binding_classes=None,
-    binding_modules=None,
-    additional_configs=None,
-    additional_kwargs=None,
-):
-    application = convert_to_application(application)
-
-    if di_class is None:
-        di_class = application.di_class if application.di_class is not None else StandardDependencies
-
-    if bindings is None:
-        bindings = {}
-    if binding_classes is None:
-        binding_classes = []
-    if binding_modules is None:
-        binding_modules = []
-    if additional_configs is None:
-        additional_configs = []
-    if additional_kwargs is None:
-        additional_kwargs = {}
-
-    bindings = {
-        **application.bindings,
-        **bindings,
-    }
-    binding_classes = [
-        *application.binding_classes,
-        *binding_classes,
-    ]
-    binding_modules = [
-        *application.binding_modules,
-        *binding_modules,
-    ]
-    additional_configs = [
-        *application.additional_configs,
-        *additional_configs,
-    ]
-
-    di = di_class.init(*binding_classes, **bindings, modules=binding_modules, additional_configs=additional_configs)
-    context = di.build(context_class, cache=False)
-    context.configure(application, **additional_kwargs)
-    return context

clearskies/contexts/convert_to_application.py

@@ -1,190 +0,0 @@
-import inspect
-import os
-import types
-from ..application import Application
-from ..handlers.callable import Callable as CallableHandler
-from ..handlers.simple_routing import SimpleRouting as SimpleRoutingHandler
-from typing import Any, Callable, Dict, Union, List
-
-
-def convert_to_application(
-    application: Union[Application, Dict[str, Any], Callable, List[Callable], types.ModuleType]
-) -> Application:
-    """
-    Converts a variety of allowed inputs into an application which the context can run.
-
-    This is called by the `build_context` method which is in turn used by all of the
-    clearskies.context.* functions.  The goal is to provide flexibility to the developer.
-    The context itself always runs an application.  However, we want to give the developer
-    additional options.  This function marrys the two.  This function can specifically handle:
-
-     1. A module
-     2. A function
-     3. A function with one or more clearskies.decorators.* applied to it
-     4. A list containing any number of the above
-     5. A clearskies.Application object
-     6. A dictionary containing two keys: 'handler_class' and 'handler_config'
-
-    Note that if more than one function is provided they will all be wrapped in a SimpleRouting
-    handler.  In addition, if any of the functions don't have routing information provided
-    by a decorator, then the the function name will be used as the route for the function
-    and only the GET method will be allowed.
-
-    Finally, if passing in a module, note that only functions with routing decorators will be
-    imported.  This stops you from accidentally taking helper functions and exposing them as endpoints.
-    """
-    if type(application) == types.ModuleType:
-        return convert_module_to_application(application)
-
-    # Lists need some special processing, although they just end up back here in the end
-    if type(application) == list:
-        return convert_list_to_application(application)
-
-    # if it has the handler_class attribute, then just assume it is an application object
-    if hasattr(application, "handler_class"):
-        return application
-
-    # check for a dictionary with the same thing (in case the developer doesn't want to bother with
-    # an application)
-    if hasattr(application, "__getitem__") and "handler_class" in application:
-        if not "handler_config" in application:
-            raise ValueError(
-                "build_context was passed a dictionary-like object with 'handler_class', but not "
-                + "'handler_config'.  Both are required to build an application"
-            )
-        return Application(application["handler_class"], application["handler_config"])
-
-    # if we have a wrapped application, then it's a callable with decorators and we can invoke
-    # it to return an application
-    if getattr(application, "is_wrapped_application", False):
-        return application if type(application) == Application else application()
-
-    # if we get a callable, then use the callable handler class
-    if callable(application):
-        return Application(CallableHandler, {"callable": application})
-
-    raise ValueError(
-        "A context was passed something but I'm not smart enough to figure out what it is :(  In general you want to pass in an Application, a callable, or a callable with decorators from the clearskies.decorators module.  You can also try a dictionary with `handler_class` and `handler_config` options.  I'll link to the docs eventually."
-    )
-
-
-def convert_module_to_application(module: types.ModuleType) -> Application:
-    """
-    Take a module, find any routing applications in it, and convert it to a single application
-    """
-    if not hasattr(module, "__file__") or not module.__file__:
-        raise ValueError("I'm trying to find routed functions in a module but I was passed a python-native module")
-    root = os.path.dirname(module.__file__)
-    checked = {}
-    routes = convert_list_to_application(return_routed_functions(module, root, len(root), checked))
-    return routes
-
-
-def return_routed_functions(
-    module: types.ModuleType, root: str, root_len: int, checked: [str, str]
-) -> List[Application]:
-    routed_functions = []
-    for name, item in module.__dict__.items():
-        if type(item) == Application:
-            routed_functions.append(item)
-            continue
-        if getattr(item, "is_wrapped_application", False):
-            routed_functions.append(item())
-            continue
-        if inspect.ismodule(item):
-            if not hasattr(item, "__file__") or not item.__file__:
-                continue
-            child_root = os.path.dirname(item.__file__)
-            if child_root[:root_len] != root:
-                continue
-            if item.__file__ in checked:
-                continue
-            checked[item.__file__] = True
-            routed_functions.extend(return_routed_functions(item, root, root_len, checked))
-    return routed_functions
-
-
-def convert_list_to_application(applications: List[Union[Application, Callable]]) -> Application:
-    """
-    Take a list of applications and convert it into a single application.
-    """
-    # First check the items.  Only callables or SimpleRouting handlers are allowed.  Everything else is too complicated.
-    for index, application in enumerate(applications):
-        if not callable(application) and application.handler_class not in [CallableHandler, SimpleRoutingHandler]:
-            raise ValueError(
-                f"A context was provided with a list of applications, but in this case all the applications must be callables or wrapped in a SimpleRouting function.  Item #{index+1} was not either of these things."
-            )
-
-    # so this is... less than ideal.  In their current iteration, the simple router ignores any DI configuration
-    # on inner applications (bindings, imported modules, imported classes, etc...).  To some extent this is
-    # a short coming of how DI is handled, since all the applications share a single DI container.  If needed,
-    # we can adjust things in the future so that each application may be called with its own DI container.
-    # I'm avoiding that at the moment because it's not clear if it is necessary, and it will impact performance.
-    # In the meantime, we need to collect DI configuration from our inner applications and combine those
-    # in the outer one.
-    di_config = {}
-    routes = []
-    # also, our top level router will need something for authentication.  It's a requirement.  It doesn't
-    # actually matter exactly _what_ it is because it won't overwrite authentication for the children.
-    authentication = None
-    for application in applications:
-        converted = convert_to_application(application)
-        if not authentication and converted.handler_config.get("authentication"):
-            authentication = converted.handler_config.get("authentication")
-        routes.append(ensure_routing(converted))
-        for di_key in ["bindings", "binding_classes", "binding_modules", "additional_configs"]:
-            di_value = getattr(application, di_key, None)
-            if di_value:
-                if di_key == "bindings":
-                    di_config["bindings"] = {**di_config.get("bindings", {}), **di_value}
-                else:
-                    di_config[di_key] = [*di_config.get(di_key, []), *di_value]
-
-    if not authentication:
-        raise ValueError(
-            "I couldn't find any authentication rules while auto-importing your routes.  Make sure an add an authentication decorator to your routes, even if it's just @clearskies.decorators.public"
-        )
-
-    return Application(
-        SimpleRoutingHandler,
-        {
-            "authentication": authentication,
-            "routes": [ensure_routing(convert_to_application(application)) for application in applications],
-        },
-        **di_config,
-    )
-
-
-def ensure_routing(application: Application) -> Application:
-    """
-    Add routing to an application by wrapping it in a SimpleRouting handler if it isn't already.
-    """
-    if application.handler_class == SimpleRoutingHandler:
-        return application
-
-    # We're making assumptions which is bad, but at this point in time the `application` should literally be
-    # an application and it should either be a SimpleRoutingHnadler (which we took care of above) or it
-    # should be a callable application. To add routing we wrap it in a SimpleRouting handler and use the callable
-    # name as the route.  Still, let's just check even if it isn't the most meanginful error message.
-    if not application.handler_config.get("callable"):
-        raise ValueError(
-            "Huh, I should have an application with a callable handler class but it doesn't have a callable so I don't know what went wrong :("
-        )
-    name = application.handler_config["callable"].__name__
-    if name == "<lambda>":
-        raise ValueError(
-            "A lambda was sent to the application for auto-routing, but since lambdas don't have names, I can't create the route for it.  To fix this, switch it out for a regular function, attach a decorator with a path, or manually wrap it in a SimpleRouting handler"
-        )
-    return Application(
-        SimpleRoutingHandler,
-        {
-            "authentication": application.handler_config.get("authentication", None),
-            "routes": [
-                {
-                    "path": name,
-                    "handler_class": application.handler_class,
-                    "handler_config": application.handler_config,
-                }
-            ],
-        },
-    )

clearskies/contexts/extract_handler.py

@@ -1,37 +0,0 @@
-def extract_handler(application):
-    """
-    This accepts the application passed in to the context and returns the handler
-
-    Most importantly, it doesn't technically have to be an application: if passed a simple function
-    it will assume you mean to use the callable handler, and if passed a dictionary with 'handler_class'
-    and 'handler_config' keys, it will build a handler from that.
-    """
-    # applications will have a handler_class property
-    if hasattr(application, "handler_class"):
-        handler = self.di.build(application.handler_class, cache=False)
-        handler.configure(self.finalize_handler_config(application.handler_config))
-        return handler
-
-    # check for a dictionary with the same thing (in case the developer doesn't want to bother with
-    # an application
-    if hasattr(application, "__getitem__") and "handler_class" in application:
-        if not "handler_config" in application:
-            raise ValueError(
-                "context was passed a dictionary-like object with 'handler_class', but not "
-                + "'handler_config'.  Both are required to execute the handler"
-            )
-        handler = self.di.build(application["handler_class"], cache=False)
-        handler.configure(self.finalize_handler_config(application["handler_config"]))
-        return handler
-
-    # if we get a callable, then use the callable handler class
-    if callable(application):
-        handler = self.di.build(callable_module.Callable, cache=False)
-        handler.configure(self.finalize_handler_config({"callable": application}))
-        return handler
-
-    raise ValueError(
-        "The context received an object it did not know how to handle!  You should pass in either an instance "
-        + "of clearskies.Application, a dictionary with 'handler_class' and 'handler_config' keys, or a "
-        + "function/lambda to be executed"
-    )

clearskies/contexts/test.py

@@ -1,94 +0,0 @@
-from ..authentication import public
-from ..mocks import InputOutput
-from ..backends import MemoryBackend
-from datetime import datetime, timezone
-from .build_context import build_context
-from .context import Context
-from .convert_to_application import convert_to_application
-
-
-class Test(Context):
-    application = None
-    input_output = None
-    memory_backend = None
-    now = None
-
-    def __init__(self, di):
-        super().__init__(di)
-
-    def configure(self, application, cursor_backend_to_memory_backend=True):
-        # so for the other contexts, the application is just a way to manage configuration,
-        # and so gets promptly thrown away.  We actually want it though
-        self.application = convert_to_application(application)
-        self.memory_backend = self.di.build(MemoryBackend, cache=False)
-        self.memory_backend.silent_on_missing_tables(silent=True)
-
-        if "now" not in self.di._prepared:
-            self.now = datetime.now().replace(tzinfo=timezone.utc, microsecond=0)
-            self.di.bind("now", self.now)
-        if cursor_backend_to_memory_backend:
-            self.di.bind("cursor_backend", self.memory_backend)
-
-    def __call__(
-        self,
-        method=None,
-        body=None,
-        headers=None,
-        url=None,
-        routing_data=None,
-        input_output=None,
-        query_parameters=None,
-        authorization_data=None,
-        context_specifics=None,
-    ):
-        if self.application is None:
-            raise ValueError("Cannot call the test context without an application")
-
-        if input_output is None:
-            input_output = InputOutput()
-        if body is not None:
-            input_output.set_body(body)
-        if headers is not None:
-            input_output.set_request_headers(headers)
-        if method is not None:
-            input_output.set_request_method(method)
-        if url is not None:
-            input_output.set_request_url(url)
-        if routing_data is not None:
-            input_output.set_routing_data(routing_data)
-        if query_parameters is not None:
-            input_output.set_query_parameters(query_parameters)
-        if authorization_data is not None:
-            input_output.set_authorization_data(authorization_data)
-        if context_specifics is not None:
-            input_output.set_context_specifics(context_specifics)
-
-        self.handler = self.di.build(self.application.handler_class, cache=False)
-        self.handler.configure(
-            {
-                **{"authentication": public()},
-                **self.application.handler_config,
-            }
-        )
-        return self.handler(input_output)
-
-
-def test(
-    application,
-    di_class=None,
-    bindings=None,
-    binding_classes=None,
-    binding_modules=None,
-    additional_configs=None,
-    cursor_backend_to_memory_backend=True,
-):
-    return build_context(
-        Test,
-        application,
-        di_class=di_class,
-        bindings=bindings,
-        binding_classes=binding_classes,
-        binding_modules=binding_modules,
-        additional_configs=additional_configs,
-        additional_kwargs={"cursor_backend_to_memory_backend": cursor_backend_to_memory_backend},
-    )

clearskies/decorators/__init__.py

@@ -1,39 +0,0 @@
-from .auth0_jwks import auth0_jwks
-from .authorization import authorization
-from .bindings import bindings
-from .binding_classes import binding_classes
-from .binding_modules import binding_modules
-from .create import create
-from .delete import delete
-from .docs import docs
-from .get import get
-from .jwks import jwks
-from .patch import patch
-from .post import post
-from .public import public
-from .response_headers import response_headers
-from .return_raw_response import return_raw_response
-from .schema import schema
-from .secret_bearer import secret_bearer
-from .security_headers import security_headers
-
-__all__ = [
-    "auth0_jwks",
-    "authorization",
-    "bindings",
-    "binding_classes",
-    "binding_modules",
-    "create",
-    "delete",
-    "docs",
-    "get",
-    "jwks",
-    "patch",
-    "post",
-    "public",
-    "response_headers",
-    "return_raw_response",
-    "schema",
-    "secret_bearer",
-    "security_headers",
-]

clearskies/decorators/auth0_jwks.py

@@ -1,22 +0,0 @@
-from .merge import merge
-from typing import List, Optional
-from ..authentication import auth0_jwks as auth0_jwks_binding
-
-
-def auth0_jwks(
-    auth0_domain: str,
-    audience: str,
-    algorithms: Optional[List[str]] = None,
-    documentation_security_name: Optional[str] = None,
-):
-    def wrap_in_application(function):
-        auth0 = auth0_jwks_binding(
-            auth0_domain=auth0_domain,
-            audience=audience,
-            algorithms=algorithms,
-            documentation_security_name=documentation_security_name,
-        )
-        return merge(function, authentication=auth0)
-
-    wrap_in_application.is_wrapped_application = True
-    return wrap_in_application

clearskies/decorators/authorization.py

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

clearskies/decorators/binding_classes.py

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

clearskies/decorators/binding_modules.py

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

clearskies/decorators/bindings.py

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

clearskies/decorators/create.py

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

clearskies/decorators/delete.py

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