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

clearskies/functional/string.py

@@ -1,16 +1,14 @@
-import re
 import datetime
+import re
 
 
 def camel_case_to_snake_case(string: str) -> str:
-    """
-    Converts a title/camel case string (MyString|myString) to snake case (my_string)
-    """
+    """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.title()
+    return camel_case_to_words(string).title().replace(" ", "")
 
 
 def camel_case_to_words(string):
@@ -19,10 +17,12 @@ def camel_case_to_words(string):
     return string
 
 
+def camel_case_to_nice(string):
+    return camel_case_to_words(string).title()
+
+
 def title_case_to_snake_case(string: str) -> str:
-    """
-    Converts a title case string (MyString) to snake case (my_string)
-    """
+    """Convert a title case string (MyString) to snake case (my_string)."""
     return camel_case_to_snake_case(string)
 
 
@@ -34,9 +34,13 @@ def title_case_to_camel_case(string: str) -> str:
     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:
     """
-    Converts a snake case string (my_string) to title case (MyString)
+    Convert a snake case string (my_string) to title case (MyString).
 
     Note this is sometimes ambiguous.  Consider:
 
@@ -50,7 +54,7 @@ def snake_case_to_title_case(string: str) -> str:
 
 def snake_case_to_camel_case(string: str) -> str:
     """
-    Converts a snake case string (my_string) to camel case (myString)
+    Convert a snake case string (my_string) to camel case (myString).
 
     Note this is sometimes ambiguous.  Consider:
 
@@ -62,6 +66,10 @@ def snake_case_to_camel_case(string: str) -> str:
     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": {
@@ -87,7 +95,7 @@ def swap_casing(string: str, from_casing: str, to_casing: str) -> str:
         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)
+    return casing_swap_map[from_casing][to_casing](string)  # type: ignore
 
 
 def make_plural(singular: str):

clearskies/functional/validations.py

@@ -1,24 +1,76 @@
-from typing import Any
-from .. import model
 import inspect
+from typing import Any
 
 
 def is_model(to_check: Any) -> bool:
     """
-    Returns True/False to denote if the given value is a model instance
+    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
     """
-    return isinstance(to_check, model.Model)
+    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:
     """
-    Returns True/False to denote if the given value is a model class
+    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.
     """
-    return inspect.isclass(to_check) and issubclass(to_check, model.Model)
+    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:
-    """
-    Returns True/False to denote if the given value is a model instance or model class
-    """
+    """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,11 +1,13 @@
-from .cli import CLI
-from .input_output import InputOutput
-from .wsgi import WSGI
-from . import exceptions
+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",
+    "Cli",
+    "Headers",
     "InputOutput",
-    "WSGI",
-    "exceptions",
+    "Programmatic",
+    "Wsgi",
 ]

clearskies/input_outputs/cli.py

@@ -1,174 +1,157 @@
+from __future__ import annotations
+
 import json
-from . import exceptions
-from ..handlers.exceptions import ClientError
-
-
-class CLI:
-    _sys = None
-    _args = None
-    _flags = None
-    _cached_body = None
-    _has_body = None
-    _input_type = None
-    _body_loaded_as_json = None
-    _body_as_json = None
-    _routing_data = None
-
-    def __init__(self, sys):
-        self._sys = sys
-        self._args = []
-        self._kwargs = {}
-        self._request_method = None
-        self._parse_args(self._sys.argv)
+import sys
+from os import isatty
+from sys import stdin
 
-    def respond(self, response, status_code=200):
-        if status_code == 404:
-            raise exceptions.CLINotFound()
-        if status_code != 200:
-            self._sys.exit(response)
-        if type(response) != str:
-            print(json.dumps(response))
-        else:
-            print(response)
+from clearskies.input_outputs.headers import Headers
+from clearskies.input_outputs.input_output import InputOutput
 
-    def error(self, body):
-        return self.respond(body, 400)
 
-    def success(self, body):
-        return self.respond(body, 200)
+class Cli(InputOutput):
+    path: str
+    _has_body: bool = False
+    _body: str = ""
 
-    def get_arguments(self):
-        return self._sys.argv
+    def __init__(self):
+        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 _parse_args(self, argv):
-        for arg in argv[1:]:
-            if arg[0] == "-":
-                arg = arg.lstrip("-")
-                if "=" in arg:
-                    name = arg[: arg.index("=")]
-                    value = arg[arg.index("=") + 1 :]
-                else:
-                    name = arg
-                    value = True
-                if name in self._kwargs:
-                    raise exceptions.CLIInputError(f"Received multiple flags for '{name}'")
-                if name == "X":
-                    name = "request_method"
-                if name == "request_method":
-                    if self._request_method:
-                        raise ValueError(
-                            "Received multiple flags for the request method (setablve via 'request_method' and 'X')"
-                        )
-                    self._request_method = value.upper()
-                else:
-                    self._kwargs[name] = value
+        tty_data = None
+        if not isatty(stdin.fileno()):
+            tty_data = sys.stdin.read().strip()
+
+        request_headers = {}
+        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 which are used for building the URL-equivalent
+            arg = argv[index]
+            if arg[0] != "-":
+                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:
-                self._args.append(arg)
-
-    def get_script_name(self):
-        return sys.argv[0]
-
-    def get_path_info(self):
-        return "/".join(self._args)
+                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 = 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].upper()
+            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"
+
+        self.path = "/".join(args)
+
+        # 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_full_path(self):
-        return self.get_path_info()
-
-    def get_request_method(self):
-        return self._request_method if self._request_method else "GET"
-
-    def request_data(self, required=True):
-        request_data = self.json_body(False)
-        if not request_data:
-            if self.has_body():
-                raise ClientError("Request body was not valid JSON")
-            request_data = {}
-        return request_data
+        return self.path
 
     def has_body(self):
-        if self._has_body is None:
-            self._has_body = False
-            # we have a number of different input modes that we will treat as data input,
-            # all of which the callable handler will use as structured input when trying to
-            # compare data against a schema:
-
-            # isatty() means that someone is piping input into the program
-            # however, it behaves unreliably in "alternate" environments in later versions
-            # of python, so I'm removing it until I can find a better solution
-            # if not self._sys.stdin.isatty():
-            # self._has_body = True
-            # self._input_type = 'atty'
-            # or if the user set 'data' or 'd' keys
-            if "data" in self._kwargs or "d" in self._kwargs:
-                self._has_body = True
-                self._input_type = "data" if "data" in self._kwargs else "d"
-            # or finally if we have kwargs in general
-            elif len(self._kwargs):
-                self._has_body = True
-                self._input_type = "kwargs"
         return self._has_body
 
     def get_body(self):
         if not self.has_body():
             return ""
 
-        if self._cached_body is None:
-            if self._input_type == "atty":
-                self._cached_body = "\n".join([line.strip() for line in self._sys.stdin])
-            elif self._input_type == "data":
-                self._cached_body = self._kwargs["data"]
-            elif self._input_type == "data":
-                self._cached_body = self._kwargs["d"]
-            # we don't do anything about self._input_type == 'kwargs' because that only
-            # makes sense when trying to interpret the body as JSON, so we cover it
-            # in the _get_json_body method
-        return self._cached_body
-
-    def json_body(self, required=True):
-        json = self._get_json_body()
-        # if we get None then either the body was not JSON or was empty.
-        # If it is required then we have an exception either way.  If it is not required
-        # then we have an exception if a body was provided but it was not JSON.  We can check for this
-        # if json is None and there is an actual request body.  If json is none, the body is empty,
-        # and it was not required, then we can just return None
-        if json is None:
-            if required or self.has_body():
-                raise ClientError("Request body was not valid JSON")
-        return json
-
-    def _get_json_body(self):
-        if not self.has_body():
-            return None
-        if not self._body_loaded_as_json:
-            if self._input_type == "kwargs":
-                self._body_loaded_as_json = True
-                self._body_as_json = self._kwargs
-            elif self.get_body() is None:
-                self._body_as_json = None
-            else:
-                self._body_loaded_as_json = True
-                try:
-                    self._body_as_json = json.loads(self.get_body())
-                except json.JSONDecodeError:
-                    self._body_as_json = None
-        return self._body_as_json
-
-    def routing_data(self):
-        return self._routing_data if self._routing_data is not None else {}
-
-    def set_routing_data(self, data):
-        self._routing_data = data
-
-    def add_routing_data(self, key, value=None):
-        if self._routing_data is None:
-            self._routing_data = {}
-        if type(key) == dict:
-            self._routing_data = {**self._routing_data, **key}
-        else:
-            self._routing_data[key] = value
+        return self._body
+
+    def get_protocol(self):
+        return "cli"
 
     def context_specifics(self):
-        return {}
+        return {"sys_argv": sys.argv}
 
     def get_client_ip(self):
-        return "cli"
+        return "127.0.0.1"

clearskies/input_outputs/exceptions/__init__.py

@@ -1,2 +1,7 @@
-from .cli_not_found import CLINotFound
 from .cli_input_error import CLIInputError
+from .cli_not_found import CLINotFound
+
+__all__ = [
+    "CLIInputError",
+    "CLINotFound",
+]

clearskies/input_outputs/headers.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import re
+from typing import TypeVar
+
+_T = TypeVar("_T")
+
+
+class Headers(dict[str, str]):
+    _duck_cheat = "headers"
+
+    def __init__(self, headers: dict[str, str] = {}) -> None:
+        normalized_headers = (
+            {key.upper().replace("_", "-"): value for (key, value) in headers.items()} if headers else {}
+        )
+        super().__init__(normalized_headers)
+
+    def __contains__(self, key: object) -> bool:
+        if not isinstance(key, str):
+            return False
+        return super().__contains__(key.upper().replace("_", "-"))
+
+    def __getitem__(self, key: str) -> str:
+        return super().__getitem__(key.upper().replace("_", "-"))
+
+    def __setitem__(self, key: str, value: str) -> None:
+        if not isinstance(key, str):
+            raise TypeError(
+                f"Header keys must be strings, but an object of type '{key.__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."
+            )
+        normalized_key = re.sub("\\s+", " ", key.upper().replace("_", "-"))
+        normalized_value = re.sub("\\s+", " ", value.strip())
+        super().__setitem__(normalized_key, normalized_value)
+
+    def __getattr__(self, key: str) -> str | None:
+        return self.get(key.upper().replace("_", "-"), None)
+
+    def __setattr__(self, key: str, value: str) -> None:
+        if key.startswith("_") or key == "_duck_cheat":
+            # Allow setting private attributes and special attributes normally
+            super().__setattr__(key, value)
+        else:
+            self.__setitem__(key, value)
+
+    def get(self, key: str, default: _T = None) -> str | _T:  # type: ignore[assignment]
+        return super().get(key.upper().replace("_", "-"), default)
+
+    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)