clear-skies 2.0.3__py3-none-any.whl → 2.0.5__py3-none-any.whl

clearskies/functional/routing.py

@@ -1,92 +0,0 @@
-import re
-
-
-def match_route(expected_route, incoming_route, allow_partial=False) -> tuple[bool, dict[str, str]]:
-    """
-    Check if two routes match, and returns the routing data if so.
-
-    A partial match happens when the beginning of the incoming route matches the expected route.  It's okay for the
-    incoming route to be longer because the routing system is hierarchical, so a partial match at the beginning
-    can work.  e.g.:
-
-    Expected route: `/users`
-    Incoming route: `/users/orders/5`
-
-    But note that it must fully match all route segments, so this is never a match:
-
-    Expected route: `/user`
-    Incoming route: `/users/orders/5`
-    """
-    expected_route = expected_route.strip("/")
-    incoming_route = incoming_route.strip("/")
-
-    expected_parts = expected_route.split("/")
-    incoming_parts = incoming_route.split("/")
-
-    # quick check: if there are less parts in the incoming route than the expected route, then we can't possibly match
-    if len(incoming_parts) < len(expected_parts):
-        return (False, {})
-    # ditto the opposite, if we can't do a partial match
-    if len(expected_parts) < len(incoming_parts) and not allow_partial:
-        return (False, {})
-
-    # if we got this far then we will do a more complete match, so let's find any routing parameters
-    routing_data = {}
-    routing_parameters = extract_url_parameter_name_map(expected_route)
-    # we want it backwards
-    routing_parameters_by_index = {value: key for (key, value) in routing_parameters.items()}
-    for index in range(len(expected_parts)):
-        if index in routing_parameters_by_index:
-            if not incoming_parts[index]:
-                return (False, {})
-            routing_data[routing_parameters_by_index[index]] = incoming_parts[index]
-        else:
-            if expected_parts[index] != incoming_parts[index]:
-                return (False, {})
-
-    return (True, routing_data)
-
-
-def extract_url_parameter_name_map(url: str) -> dict[str, int]:
-    """
-    Create a map to help match URLs with routing parameters.
-
-    Routing parameters are either brace enclosed or start with colons:
-
-    ```python
-    print(
-        routing.extract_url_parameter_name_map("my/path/{some_parameter}/:other_parameter/more/paths")
-    )
-    # prints {"some_parameter": 2, "other_parameter": 3}
-    ```
-
-    Note that leading and trailing slashes are stripped, so "/my/path/{id}" and "my/path/{id}" give identical
-    parameter maps: `{"id": 2}`
-    """
-    parameter_name_map = {}
-    path_parts = url.strip("/").split("/")
-    for index, part in enumerate(path_parts):
-        if not part:
-            continue
-        if part[0] == ":":
-            match = re.match("^:(\\w[\\w\\d_]{0,})$", part)
-        else:
-            if part[0] != "{":
-                continue
-            if part[-1] != "}":
-                raise ValueError(
-                    f"Invalid route configuration for URL '{url}': 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 '{url}', section '{part}': resource identifiers must start with a letter and contain only letters, numbers, and underscores"
-            )
-        parameter_name = match.group(1)
-        if parameter_name in parameter_name_map:
-            raise ValueError(
-                f"Invalid route configuration for URL '{url}', a URL path named '{parameter_name}' appeared more than once."
-            )
-        parameter_name_map[parameter_name] = index
-    return parameter_name_map

clearskies/functional/string.py

@@ -1,112 +0,0 @@
-import datetime
-import re
-
-
-def camel_case_to_snake_case(string: str) -> str:
-    """Convert a title/camel case string (MyString|myString) to snake case (my_string)."""
-    return re.sub("([a-z0-9])([A-Z])", r"\1_\2", re.sub("(.)([A-Z][a-z]+)", r"\1_\2", string)).lower()
-
-
-def camel_case_to_title_case(string):
-    return camel_case_to_words(string).title().replace(" ", "")
-
-
-def camel_case_to_words(string):
-    string = re.sub("(.)([A-Z][a-z]+)", r"\1 \2", string)
-    string = re.sub("([a-z0-9])([A-Z])", r"\1 \2", string).lower()
-    return string
-
-
-def camel_case_to_nice(string):
-    return camel_case_to_words(string).title()
-
-
-def title_case_to_snake_case(string: str) -> str:
-    """Convert a title case string (MyString) to snake case (my_string)."""
-    return camel_case_to_snake_case(string)
-
-
-def title_case_to_camel_case(string: str) -> str:
-    if len(string) == 0:
-        return string
-    if len(string) == 1:
-        return string.lower()
-    return string[0].lower() + string[1:]
-
-
-def title_case_to_nice(string: str) -> str:
-    return camel_case_to_nice(string)
-
-
-def snake_case_to_title_case(string: str) -> str:
-    """
-    Convert a snake case string (my_string) to title case (MyString).
-
-    Note this is sometimes ambiguous.  Consider:
-
-    TitleCase -> snake_case  -> TitleCase
-    MyDbThing -> my_db_thing -> MyDbThing
-    MyDBThing -> my_db_thing -> MyDbThing
-    """
-    words = string.lower().split("_")
-    return "".join([x.title() for x in words])
-
-
-def snake_case_to_camel_case(string: str) -> str:
-    """
-    Convert a snake case string (my_string) to camel case (myString).
-
-    Note this is sometimes ambiguous.  Consider:
-
-    camelCase -> snake_case  -> camelCase
-    myDbThing -> my_db_thing -> myDbThing
-    myDBThing -> my_db_thing -> myDbThing
-    """
-    words = string.lower().split("_")
-    return words[0] + "".join([x.title() for x in words[1:]])
-
-
-def snake_case_to_nice(string: str) -> str:
-    return camel_case_to_nice(snake_case_to_camel_case(string))
-
-
-casings = ["camelCase", "snake_case", "TitleCase"]
-casing_swap_map = {
-    "camelCase": {
-        "camelCase": str,
-        "snake_case": camel_case_to_snake_case,
-        "TitleCase": camel_case_to_title_case,
-    },
-    "snake_case": {
-        "camelCase": snake_case_to_camel_case,
-        "snake_case": str,
-        "TitleCase": snake_case_to_title_case,
-    },
-    "TitleCase": {
-        "camelCase": title_case_to_camel_case,
-        "snake_case": title_case_to_snake_case,
-        "TitleCase": str,
-    },
-}
-
-
-def swap_casing(string: str, from_casing: str, to_casing: str) -> str:
-    if from_casing not in casings:
-        raise ValueError(f"Invalid casing '{from_casing}'.  Must be one of '" + "', ".join(casings) + "'")
-    if to_casing not in casings:
-        raise ValueError(f"Invalid casing '{to_casing}'.  Must be one of '" + "', ".join(casings) + "'")
-    return casing_swap_map[from_casing][to_casing](string)  # type: ignore
-
-
-def make_plural(singular: str):
-    if singular[-1] == "y":
-        return singular[:-1] + "ies"
-    if singular[-1] == "s":
-        return singular + "es"
-    return f"{singular}s"
-
-
-def datetime_to_iso(value):
-    if not isinstance(value, datetime.date) and not isinstance(value, datetime.datetime):
-        return value
-    return value.isoformat()

clearskies/functional/validations.py

@@ -1,76 +0,0 @@
-import inspect
-from typing import Any
-
-
-def is_model(to_check: Any) -> bool:
-    """
-    Return True/False to denote if the given value is a model instance.
-
-    Uses ducktyping rather than checking the type, mostly to minimize the risk of circular imports
-    """
-    if not hasattr(to_check, "destination_name"):
-        return False
-    return True
-
-
-def is_model_class(to_check: Any) -> bool:
-    """Return True/False to denote if the given value is a model class."""
-    return inspect.isclass(to_check) and is_model(to_check)
-
-
-def is_model_class_reference(to_check: Any) -> bool:
-    """Return True/False to denote if the given value is a reference to a model class."""
-    if not hasattr(to_check, "get_model_class"):
-        return False
-
-    if inspect.isclass(to_check):
-        to_check = to_check()
-    return is_model_class(to_check.get_model_class())
-
-
-def is_model_class_or_reference(to_check: Any, raise_error_message=False, strict=True) -> bool:
-    """
-    Return True/False to denote if the given value is a model class or a model reference.
-
-    If strict is false, then it won't check that the model reference returns a model class.  This is often necessary during
-    validation by configs as, otherwise, it tends to trigger circular dependency errors.
-    """
-    if not inspect.isclass(to_check):
-        # for references we will accept either instances or classes
-        if hasattr(to_check, "get_model_class"):
-            return is_model_class(to_check.get_model_class()) if strict else True
-
-        if raise_error_message:
-            raise TypeError(
-                f"I expected a model class or reference, but instead I received something of type '{to_check.__class__.__name__}'"
-            )
-        return False
-
-    if is_model_class(to_check):
-        return True
-
-    if hasattr(to_check, "get_model_class"):
-        if not strict:
-            return True
-
-        model_class = to_check().get_model_class()
-        if is_model_class(model_class):
-            return True
-        if raise_error_message:
-            raise TypeError(
-                f"I expected a model class or reference.  I received a model reference of class '{to_check.__name__}', but when I fetched the model out of it, it gave me back something that wasn't a model.  Instead, I received something of type '{model_class.__name__}'"
-            )
-
-    if raise_error_message:
-        raise TypeError(
-            "I expected a model class or reference, but instead I received a class that was neither.  It had a type of '"
-            + to_check.__class__.__name__
-            + "'"
-        )
-
-    return False
-
-
-def is_model_or_class(to_check: Any) -> bool:
-    """Return True/False to denote if the given value is a model instance or model class."""
-    return is_model(to_check) or is_model_class(to_check)

clearskies/input_outputs/__init__.py

@@ -1,13 +0,0 @@
-from clearskies.input_outputs.cli import Cli
-from clearskies.input_outputs.headers import Headers
-from clearskies.input_outputs.input_output import InputOutput
-from clearskies.input_outputs.programmatic import Programmatic
-from clearskies.input_outputs.wsgi import Wsgi
-
-__all__ = [
-    "Cli",
-    "Headers",
-    "InputOutput",
-    "Programmatic",
-    "Wsgi",
-]

clearskies/input_outputs/cli.py

@@ -1,171 +0,0 @@
-import json
-import sys
-from os import isatty
-from sys import stdin
-
-from clearskies.input_outputs.input_output import InputOutput
-
-
-class Cli(InputOutput):
-    _args: list[str] = []
-    _has_body: bool = False
-    _body: str = ""
-    _request_method: str = ""
-    _request_headers: dict[str, str] = {}
-
-    def __init__(self):
-        self._request_headers = {}
-        self._args = []
-        self._parse_args(sys.argv)
-        super().__init__()
-
-    def respond(self, response, status_code=200):
-        if type(response) != str:
-            final = json.dumps(response)
-        else:
-            final = response
-        if status_code != 200:
-            sys.exit(final)
-        print(final)
-
-    def get_arguments(self):
-        return sys.argv
-
-    def _parse_args(self, argv):
-        tty_data = None
-        if not isatty(stdin.fileno()):
-            tty_data = sys.stdin.read().strip()
-
-        request_headers = {}
-        self._args = []
-        kwargs = {}
-        index = 0
-        # In general we will use positional arguments for routing, and kwargs for request data.
-        # If things start with a dash then they are assumed to be a kwarg.  If not, then a positional argument.
-        # we don't allow for simple flags: everything is a positional argument or a key/value pair
-        # For kwargs, we'll allow for using an equal sign or not, e.g.: '--key=value' or '--key value' or '-d thing'.
-        while index < len(argv) - 1:
-            index += 1
-
-            # if we don't start with a dash then we are a positional argument
-            arg = argv[index]
-            if arg[0] != "-":
-                self._args.append(arg)
-                continue
-
-            # otherwise a kwarg
-            arg = arg.strip("-")
-
-            # if we have an equal sign in our kwarg then it's self-contained
-            if "=" in arg:
-                [key, value] = arg.split("=", 1)
-
-            # otherwise we have to grab the next argument to get the value
-            else:
-                key = arg
-                value = argv[index + 1]
-                if "-" in value:
-                    raise ValueError(
-                        f"Invalid clearskies cli calling sequence: found two key names next to eachother without any values: '-{arg} {value}'"
-                    )
-                index += 1
-
-            if key.lower() == "h":
-                parts = value.split(":", 1)
-                if len(parts) != 2:
-                    raise ValueError(
-                        f"Invalid clearskies cli calling sequence: a parameter named '-H' was found, which is treated as a request header, but it didn't have the proper 'key: value' format."
-                    )
-                request_headers[parts[0]] = parts[1]
-                continue
-
-            kwargs[key] = value
-
-        self._request_headers = request_headers
-        self._request_method = "GET"
-        request_method_source = ""
-        for key in ["x", "X", "request_method"]:
-            if key not in kwargs:
-                continue
-
-            if request_method_source:
-                raise ValueError(
-                    f"Invalid clearskies cli calling sequence: the request method was specified via both the -{key} parameter and the -{request_method_source} parameter. To avoid ambiguity, it should only be set once."
-                )
-            self._request_method = kwargs[key]
-            del kwargs[key]
-            request_method_source = key
-
-        final_data = None
-        data_source = None
-        if tty_data:
-            final_data = tty_data
-            data_source = "piped input"
-        if kwargs.get("d"):
-            if final_data:
-                raise ValueError(
-                    f"Invalid clearskies cli calling sequence: request data was sent by both the -d parameter and {data_source}.  To avoid ambiguity, it should only be sent one way."
-                )
-            final_data = kwargs.get("d")
-            data_source = "the -d parameter"
-            del kwargs["d"]
-        if kwargs.get("data"):
-            if final_data:
-                raise ValueError(
-                    f"Invalid calling sequence: request data was sent by both the -data parameter and {data_source}.  To avoid ambiguity, it should only be sent one way."
-                )
-            final_data = kwargs.get("data")
-            data_source = "the -data parameter"
-            del kwargs["data"]
-        if final_data and len(kwargs):
-            raise ValueError(
-                f"Invalid calling sequence: extra parameters were specified after sending a body via {data_source}.  To avoid ambiguity, send all data via {data_source}."
-            )
-        if not final_data and len(kwargs):
-            final_data = kwargs
-            data_source = "kwargs"
-
-        # Most of the above inputs result in a string for our final data, in which case we'll leave it as the "raw body"
-        # so that it can optionally be interpreted as JSON.  If we received a bunch of kwargs though, we'll allow those to
-        # only be "read" as JSON.
-        if data_source == "kwargs":
-            self._body_as_json = final_data  # type: ignore
-            self._body_loaded_as_json = True
-            self._has_body = True
-            self._body = json.dumps(final_data)
-        elif final_data:
-            self._has_body = True
-            self._body = final_data
-
-    def get_script_name(self):
-        return sys.argv[0]
-
-    def get_path_info(self):
-        return "/".join(self._args)
-
-    def get_full_path(self):
-        return self.get_path_info()
-
-    def get_request_method(self):
-        return self._request_method
-
-    def has_body(self):
-        return self._has_body
-
-    def get_body(self):
-        if not self.has_body():
-            return ""
-
-        return self._body
-
-    def context_specifics(self):
-        return {}
-
-    def get_client_ip(self):
-        return "127.0.0.1"
-
-    def get_query_string(self):
-        return ""
-
-    def get_request_headers(self):
-        return self._request_headers

clearskies/input_outputs/exceptions/__init__.py

@@ -1,2 +0,0 @@
-from .cli_input_error import CLIInputError
-from .cli_not_found import CLINotFound

clearskies/input_outputs/exceptions/cli_input_error.py

@@ -1,2 +0,0 @@
-class CLIInputError(Exception):
-    pass

clearskies/input_outputs/exceptions/cli_not_found.py

@@ -1,2 +0,0 @@
-class CLINotFound(Exception):
-    pass

clearskies/input_outputs/headers.py

@@ -1,45 +0,0 @@
-import re
-
-
-class Headers:
-    _headers: dict[str, str] = {}
-
-    def __init__(self, headers: dict[str, str] = {}):
-        self.__dict__["_headers"] = (
-            {key.upper().replace("_", "-"): value for (key, value) in headers.items()} if headers else {}
-        )
-
-    def __contains__(self, key: str):
-        return key.upper().replace("_", "-") in self._headers
-
-    def __getattr__(self, key: str) -> str | None:
-        return self._headers.get(key.upper().replace("_", "-"), None)
-
-    def __setattr__(self, key: str, value: str) -> None:
-        if not isinstance(key, str):
-            raise TypeError(
-                f"Header keys must be strings, but an object of type '{value.__class__.__name__}' was provided."
-            )
-        if not isinstance(value, str):
-            raise TypeError(
-                f"Header values must be strings, but an object of type '{value.__class__.__name__}' was provided."
-            )
-        self._headers[re.sub("\\s+", " ", key.upper().replace("_", "-"))] = re.sub("\\s+", " ", value.strip())
-
-    def get(self, key, default=None):
-        if key not in self:
-            return default
-        return self.__getattr__(key)
-
-    def keys(self) -> list[str]:
-        return list(self._headers.keys())
-
-    def values(self) -> list[str]:
-        return list(self._headers.keys())
-
-    def items(self) -> list[tuple[str]]:
-        return list(self._headers.items())  # type: ignore
-
-    def add(self, key: str, value: str) -> None:
-        """Add a header.  This expects a string with a colon separating the key and value."""
-        setattr(self, key, value)

clearskies/input_outputs/input_output.py

@@ -1,138 +0,0 @@
-import json
-from abc import ABC, abstractmethod
-from typing import Any
-from urllib.parse import parse_qs
-
-import clearskies.configurable
-import clearskies.typing
-from clearskies.configs import AnyDict, StringDict
-from clearskies.exceptions import ClientError
-
-from .headers import Headers
-
-
-class InputOutput(ABC, clearskies.configurable.Configurable):
-    """Manage the request and response to the client."""
-
-    response_headers: Headers = None  # type: ignore
-    request_headers: Headers = None  # type: ignore
-    query_parameters = clearskies.configs.AnyDict(default={})
-    routing_data = clearskies.configs.StringDict(default={})
-    authorization_data = clearskies.configs.AnyDict(default={})
-
-    _body_as_json: dict[str, Any] | list[Any] | None = {}
-    _body_loaded_as_json = False
-
-    def __init__(self):
-        self.response_headers = Headers()
-        self.request_headers = Headers(self.get_request_headers())
-        self.query_parameters = {key: val[0] for (key, val) in parse_qs(self.get_query_string()).items()}
-        self.authorization_data = {}
-        self.routing_data = {}
-        self.finalize_and_validate_configuration()
-
-    @abstractmethod
-    def respond(self, body: clearskies.typing.response, status_code: int = 200) -> Any:
-        """
-        Pass along a response to the client.
-
-        Accepts a string, bytes, dictionary, or list.  If a content type has not been set then it will automatically
-        be set to application/json
-        """
-        pass
-
-    @abstractmethod
-    def get_body(self) -> str:
-        """Return the raw body set by the client."""
-        pass
-
-    @abstractmethod
-    def has_body(self) -> bool:
-        """Whether or not the request included a body."""
-        pass
-
-    @property
-    def request_data(self) -> dict[str, Any] | list[Any] | None:
-        """Return the data from the request body, assuming it is JSON."""
-        if not self._body_loaded_as_json:
-            self._body_loaded_as_json = True
-            if not self.has_body():
-                self._body_as_json = None
-            else:
-                try:
-                    self._body_as_json = json.loads(self.get_body())
-                except json.JSONDecodeError:
-                    self._body_as_json = None
-        return self._body_as_json
-
-    @abstractmethod
-    def get_request_method(self) -> str:
-        """Return the request method set by the client."""
-        pass
-
-    @abstractmethod
-    def get_script_name(self) -> str:
-        """Return the script name, e.g. the path requested."""
-        pass
-
-    @abstractmethod
-    def get_path_info(self) -> str:
-        """Return the path info for the request."""
-        pass
-
-    @abstractmethod
-    def get_query_string(self) -> str:
-        """Return the full query string for the request (everything after the first question mark in the document URL)."""
-        pass
-
-    @abstractmethod
-    def get_client_ip(self):
-        pass
-
-    @abstractmethod
-    def get_request_headers(self) -> dict[str, str]:
-        pass
-
-    def get_full_path(self) -> str:
-        """Return the full path requested by the client."""
-        path_info = self.get_path_info()
-        script_name = self.get_script_name()
-        if not path_info or path_info[0] != "/":
-            path_info = f"/{path_info}"
-        return f"{path_info}{script_name}".replace("//", "/")
-
-    def context_specifics(self):
-        return {}
-
-    def get_context_for_callables(self) -> dict[str, Any]:
-        """
-        Return a dictionary with various important parts of the request that are passed along to user-defined functions.
-
-        It's common to make various aspects of an incoming request available to user-defined functions that are
-        attached to clearskies hooks everywhere.  This function centralizes the definition of what aspects of
-        the reequest shouuld be passed along to callables in this case.  When this is in use it typically
-        looks like this:
-
-        di.call_function(some_function, **input_output.get_context_for_callables())
-
-        And this function returns a dictionary with the following values:
-
-        | Key                | Type                             | Ref                             | Value                                                                           |
-        |--------------------|----------------------------------|---------------------------------|---------------------------------------------------------------------------------|
-        | routing_data       | dict[str, str]                   | input_output.routing_data       | A dictionary of data extracted from URL path parameters.                        |
-        | authorization_data | dict[str, Any]                   | input_output.authorization_data | A dictionary containing the authorization data set by the authentication method |
-        | request_data       | dict[str, Any] | None            | input_output.request_data       | The data sent along with the request (assuming a JSON request body)             |
-        | query_parameters   | dict[str, Any]                   | input_output.query_parameters   | The query parameters                                                            |
-        | request_headers    | clearskies.input_outputs.Headers | input_output.request_headers    | The request headers sent by the client                                          |
-        | **routing_data     | string                           | **input_output.routing_data     | The routing data is unpacked so keys can be fetched directly                    |
-        """
-        return {
-            **self.routing_data,
-            **{
-                "routing_data": self.routing_data,
-                "authorization_data": self.authorization_data,
-                "request_data": self.request_data,
-                "request_headers": self.request_headers,
-                "query_parameters": self.query_parameters,
-            },
-        }