clear-skies 2.0.27__py3-none-any.whl

clearskies/security_headers/cors.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from clearskies import configs, decorators
+from clearskies.security_header import SecurityHeader
+
+
+class Cors(SecurityHeader):
+    origin = configs.String()
+    methods = configs.StringList(default=[])
+    headers = configs.StringList(default=[])
+    max_age = configs.Integer(default=5)
+    credentials = configs.Boolean(default=False)
+    expose_headers = configs.StringList(default=[])
+    is_cors = True
+
+    @decorators.parameters_to_properties
+    def __init__(
+        self,
+        credentials: bool = False,
+        expose_headers: list[str] = [],
+        headers: list[str] = [],
+        max_age: int = 5,
+        methods: list[str] = [],
+        origin: str = "",
+    ):
+        self.finalize_and_validate_configuration()
+
+    def set_headers(self, headers: list[str]):
+        self.headers = headers
+
+    def add_header(self, header: str):
+        self.headers = [*self.headers, header]
+
+    def set_methods(self, methods: list[str]):
+        self.methods = methods
+
+    def add_method(self, method: str):
+        self.methods = [*self.methods, method]
+
+    def set_headers_for_input_output(self, input_output):
+        for key in ["expose_headers", "methods", "headers"]:
+            value = getattr(self, key)
+            if not value:
+                continue
+            input_output.response_headers.add(f"access-control-allow-{key}".replace("_", "-"), ", ".join(value))
+        if self.credentials:
+            input_output.response_headers.add("access-control-allow-credentials", "true")
+        if self.max_age:
+            input_output.response_headers.add("access-control-max-age", str(self.max_age))
+        if self.origin:
+            input_output.response_headers.add("access-control-allow-origin", str(self.origin))

clearskies/security_headers/csp.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+from clearskies import configs, decorators
+from clearskies.security_header import SecurityHeader
+
+
+class Csp(SecurityHeader):
+    header_name = "content-security-policy"
+    default_src = configs.String()
+    script_src = configs.String()
+    style_src = configs.String()
+    img_src = configs.String()
+    connect_src = configs.String()
+    font_src = configs.String()
+    object_src = configs.String()
+    media_src = configs.String()
+    frame_src = configs.String()
+    sandbox = configs.String()
+    report_uri = configs.String()
+    child_src = configs.String()
+    form_action = configs.String()
+    frame_ancestors = configs.String()
+    plugin_types = configs.String()
+    base_uri = configs.String()
+    report_to = configs.String()
+    worker_src = configs.String()
+    manifest_src = configs.String()
+    prefetch_src = configs.String()
+    navigate_to = configs.String()
+
+    directives = [
+        "default_src",
+        "script_src",
+        "style_src",
+        "img_src",
+        "connect_src",
+        "font_src",
+        "object_src",
+        "media_src",
+        "frame_src",
+        "sandbox",
+        "report_uri",
+        "child_src",
+        "form_action",
+        "frame_ancestors",
+        "plugin_types",
+        "base_uri",
+        "report_to",
+        "worker_src",
+        "manifest_src",
+        "prefetch_src",
+        "navigate_to",
+    ]
+
+    @decorators.parameters_to_properties
+    def __init__(
+        self,
+        default_src: str = "",
+        script_src: str = "",
+        style_src: str = "",
+        img_src: str = "",
+        connect_src: str = "",
+        font_src: str = "",
+        object_src: str = "",
+        media_src: str = "",
+        frame_src: str = "",
+        sandbox: str = "",
+        report_uri: str = "",
+        child_src: str = "",
+        form_action: str = "",
+        frame_ancestors: str = "",
+        plugin_types: str = "",
+        base_uri: str = "",
+        report_to: str = "",
+        worker_src: str = "",
+        manifest_src: str = "",
+        prefetch_src: str = "",
+        navigate_to: str = "",
+    ):
+        self.finalize_and_validate_configuration()
+
+    def set_headers_for_input_output(self, input_output):
+        parts = []
+        for variable_name in self.directives:
+            value = getattr(self, variable_name)
+            if not value:
+                continue
+            if value.lower().strip() == "self":
+                value = "'self'"
+            header_key_name = variable_name.replace("_", "-")
+            parts.append(f"{header_key_name} {value}")
+        if not parts:
+            return
+        header_value = "; ".join(parts)
+        input_output.response_headers.add(self.header_name, header_value)

clearskies/security_headers/hsts.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from clearskies import configs, decorators
+from clearskies.security_header import SecurityHeader
+
+
+class Hsts(SecurityHeader):
+    max_age = configs.Integer(default=31536000)
+    include_sub_domains = configs.Boolean()
+
+    @decorators.parameters_to_properties
+    def __init__(
+        self,
+        max_age: int = 31536000,
+        include_sub_domains: bool = False,
+    ):
+        self.finalize_and_validate_configuration()
+
+    def set_headers_for_input_output(self, input_output):
+        value = f"max-age={self.max_age} ;"
+        if self.include_sub_domains:
+            value += " includeSubDomains"
+        input_output.response_headers.add("strict-transport-security", value)

clearskies/typing.py

@@ -0,0 +1,11 @@
+from typing import Any, Callable
+
+from clearskies.action import Action
+from clearskies.query import Condition
+from clearskies.validator import Validator
+
+action = Callable[..., dict[str, Any]] | Action
+condition = str | Callable | Condition
+join = str | Callable[..., str]
+validator = Callable[..., str] | Validator
+response = str | bytes | dict[str, Any] | list[Any]

clearskies/validator.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any
+
+from clearskies import configurable
+
+if TYPE_CHECKING:
+    from clearskies import Column, Model
+
+
+class Validator(ABC, configurable.Configurable):
+    """
+    Attach input validation rules to columns.
+
+    The validators provide a way to attach input validation logic to columns.  The columns themselves already
+    provide basic validation (making sure strings are strings, integers are integers, etc...) but these classes
+    allow for more detailed rules.
+
+    It's important to understand that validators only apply to client input, which means that input validation
+    is only enforced by appropriate endpoints.  If you inject a model into a function of your own and execute
+    a save operation with it, validators will **NOT** be checked.
+    """
+
+    is_unique = False
+    is_required = False
+
+    def __call__(self, model: Model, column_name: str, data: dict[str, Any]) -> str:
+        return self.check(model, column_name, data)
+
+    @abstractmethod
+    def check(self, model: Model, column_name: str, data: dict[str, Any]) -> str:
+        pass
+
+    def additional_write_columns(self, is_create=False) -> dict[str, Column]:
+        return {}

clearskies/validators/__init__.py

@@ -0,0 +1,33 @@
+from clearskies.validators.after_column import AfterColumn
+from clearskies.validators.before_column import BeforeColumn
+from clearskies.validators.in_the_future import InTheFuture
+from clearskies.validators.in_the_future_at_least import InTheFutureAtLeast
+from clearskies.validators.in_the_future_at_most import InTheFutureAtMost
+from clearskies.validators.in_the_past import InThePast
+from clearskies.validators.in_the_past_at_least import InThePastAtLeast
+from clearskies.validators.in_the_past_at_most import InThePastAtMost
+from clearskies.validators.maximum_length import MaximumLength
+from clearskies.validators.maximum_value import MaximumValue
+from clearskies.validators.minimum_length import MinimumLength
+from clearskies.validators.minimum_value import MinimumValue
+from clearskies.validators.required import Required
+from clearskies.validators.timedelta import Timedelta
+from clearskies.validators.unique import Unique
+
+__all__ = [
+    "AfterColumn",
+    "BeforeColumn",
+    "InTheFuture",
+    "InTheFutureAtLeast",
+    "InTheFutureAtMost",
+    "InThePast",
+    "InThePastAtLeast",
+    "InThePastAtMost",
+    "MaximumLength",
+    "MaximumValue",
+    "MinimumValue",
+    "MinimumLength",
+    "Required",
+    "Timedelta",
+    "Unique",
+]

clearskies/validators/after_column.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import datetime
+from typing import TYPE_CHECKING, Any
+
+import dateparser
+
+from clearskies import configs, decorators
+from clearskies.validator import Validator
+
+if TYPE_CHECKING:
+    from clearskies import Model
+
+
+class AfterColumn(Validator):
+    """The name of the other date column for comparison."""
+
+    other_column_name = configs.String(default="", required=True)
+
+    """
+    If true, then this column is allowed to be eqaul to the other column.
+    """
+    allow_equal = configs.Boolean(default=False)
+
+    @decorators.parameters_to_properties
+    def __init__(self, other_column_name: str, allow_equal: bool = False):
+        self.other_column_name = other_column_name
+        self.allow_equal = allow_equal
+        self.finalize_and_validate_configuration()
+
+    def check(self, model: Model, column_name: str, data: dict[str, Any]) -> str:
+        # we won't check anything for missing values (columns should be required if that is an issue)
+        if not data.get(column_name):
+            return ""
+        my_value = data[column_name]
+        other_value = data.get(self.other_column_name, getattr(model, self.other_column_name))
+        # again, no checks for non-values
+        if not other_value:
+            return ""
+
+        my_value = dateparser.parse(my_value) if isinstance(my_value, str) else my_value
+        if not my_value:
+            return f"'{column_name}' was not a valid date."
+
+        if type(other_value) != str and type(other_value) != datetime.datetime:
+            return f"'{self.other_column_name}' was not a valid date."
+        other_value = dateparser.parse(other_value) if isinstance(other_value, str) else other_value
+        if not other_value:
+            return f"'{self.other_column_name}' was not a valid date."
+
+        return self.date_comparison(my_value, other_value, column_name)
+
+    def date_comparison(
+        self, incoming_date: datetime.datetime, comparison_date: datetime.datetime, column_name: str
+    ) -> str:
+        if incoming_date == comparison_date:
+            return "" if self.allow_equal else f"'{column_name}' must be after '{self.other_column_name}'"
+
+        if incoming_date < comparison_date:
+            return f"'{column_name}' must be after '{self.other_column_name}'"
+        return ""

clearskies/validators/before_column.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+import datetime
+
+from clearskies.validators.after_column import AfterColumn
+
+
+class BeforeColumn(AfterColumn):
+    def date_comparison(self, incoming_date: datetime.datetime, comparison_date: datetime.datetime, column_name) -> str:
+        if incoming_date == comparison_date:
+            return "" if self.allow_equal else f"'{column_name}' must be before '{self.other_column_name}'"
+
+        if incoming_date > comparison_date:
+            return f"'{column_name}' must be before '{self.other_column_name}'"
+        return ""

clearskies/validators/in_the_future.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import datetime
+from typing import TYPE_CHECKING, Any
+
+import dateparser
+
+from clearskies.di import InjectableProperties, inject
+from clearskies.validator import Validator
+
+if TYPE_CHECKING:
+    from clearskies import Model
+
+
+class InTheFuture(Validator, InjectableProperties):
+    utcnow = inject.Utcnow()
+
+    def check(self, model: Model, column_name: str, data: dict[str, Any]) -> str:
+        if not data.get(column_name):
+            return ""
+
+        as_date = dateparser.parse(data[column_name]) if isinstance(data[column_name], str) else data[column_name]
+        if not as_date:
+            return f"'{column_name}' was not a valid date"
+        if as_date.tzinfo == None:
+            as_date = as_date.replace(tzinfo=datetime.timezone.utc)
+        if as_date <= self.utcnow:
+            return f"'{column_name}' must be in the future"
+        return ""

clearskies/validators/in_the_future_at_least.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+import datetime
+
+from clearskies.validators.timedelta import Timedelta
+
+
+class InTheFutureAtLeast(Timedelta):
+    def check_timedelta(self, as_date: datetime.datetime, column_name: str) -> str:
+        if as_date < self.utcnow + self.timedelta:
+            human_friendly = self.delta_human_friendly()
+            return f"'{column_name}' must be at least {human_friendly} in the future."
+        return ""

clearskies/validators/in_the_future_at_most.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+import datetime
+
+from clearskies.validators.timedelta import Timedelta
+
+
+class InTheFutureAtMost(Timedelta):
+    def check_timedelta(self, as_date: datetime.datetime, column_name: str) -> str:
+        if as_date > self.utcnow + self.timedelta:
+            return f"'{column_name}' must be at most {self.delta_human_friendly()} in the future."
+        return ""

clearskies/validators/in_the_past.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import datetime
+from typing import TYPE_CHECKING, Any
+
+import dateparser
+
+from clearskies.di import InjectableProperties, inject
+from clearskies.validator import Validator
+
+if TYPE_CHECKING:
+    from clearskies import Model
+
+
+class InThePast(Validator, InjectableProperties):
+    utcnow = inject.Utcnow()
+
+    def check(self, model: Model, column_name: str, data: dict[str, Any]) -> str:
+        if not data.get(column_name):
+            return ""
+
+        as_date = dateparser.parse(data[column_name]) if isinstance(data[column_name], str) else data[column_name]
+        if not as_date:
+            return f"'{column_name}' was not a valid date"
+        if as_date.tzinfo == None:
+            as_date = as_date.replace(tzinfo=datetime.timezone.utc)
+        if as_date >= self.utcnow:
+            return f"'{column_name}' must be in the past"
+        return ""

clearskies/validators/in_the_past_at_least.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+import datetime
+
+from clearskies.validators.timedelta import Timedelta
+
+
+class InThePastAtLeast(Timedelta):
+    def check_timedelta(self, as_date: datetime.datetime, column_name: str) -> str:
+        if as_date > self.utcnow - self.timedelta:
+            return f"'{column_name}' must be at least {self.delta_human_friendly()} in the past."
+        return ""

clearskies/validators/in_the_past_at_most.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+import datetime
+
+from clearskies.validators.timedelta import Timedelta
+
+
+class InThePastAtMost(Timedelta):
+    def check_timedelta(self, as_date: datetime.datetime, column_name: str) -> str:
+        if as_date < self.utcnow - self.timedelta:
+            return f"'{column_name}' must be at most {self.delta_human_friendly()} in the past."
+        return ""

clearskies/validators/maximum_length.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from clearskies import configs
+from clearskies.validator import Validator
+
+if TYPE_CHECKING:
+    from clearskies import Model
+
+
+class MaximumLength(Validator):
+    maximum_length = configs.Integer(required=True)
+
+    def __init__(self, maximum_length: int):
+        self.maximum_length = maximum_length
+        self.finalize_and_validate_configuration()
+
+    def check(self, model: Model, column_name: str, data: dict[str, Any]) -> str:
+        # we won't check anything for missing values (columns should be required if that is an issue)
+        if not data.get(column_name):
+            return ""
+        if len(data[column_name]) <= self.maximum_length:
+            return ""
+        return f"'{column_name}' must be at most {self.maximum_length} characters long."

clearskies/validators/maximum_value.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from clearskies import configs
+from clearskies.validator import Validator
+
+if TYPE_CHECKING:
+    from clearskies import Model
+
+
+class MaximumValue(Validator):
+    maximum_value = configs.Integer(required=True)
+
+    def __init__(self, maximum_value: int):
+        self.maximum_value = maximum_value
+        self.finalize_and_validate_configuration()
+
+    def check(self, model: Model, column_name: str, data: dict[str, Any]) -> str:
+        if column_name not in data:
+            return ""
+        try:
+            value = float(data[column_name])
+        except ValueError:
+            return f"{column_name} must be an integer or float"
+        if float(value) <= self.maximum_value:
+            return ""
+        return f"'{column_name}' must be at most {self.maximum_value}."

clearskies/validators/minimum_length.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from clearskies import configs
+from clearskies.validator import Validator
+
+if TYPE_CHECKING:
+    from clearskies import Model
+
+
+class MinimumLength(Validator):
+    minimum_length = configs.Integer(required=True)
+
+    def __init__(self, minimum_length: int):
+        self.minimum_length = minimum_length
+        self.finalize_and_validate_configuration()
+
+    def check(self, model: Model, column_name: str, data: dict[str, Any]) -> str:
+        # we won't check anything for missing values (columns should be required if that is an issue)
+        if not data.get(column_name):
+            return ""
+        if len(data[column_name]) >= self.minimum_length:
+            return ""
+        return f"'{column_name}' must be at least {self.minimum_length} characters long."

clearskies/validators/minimum_value.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from clearskies import configs
+from clearskies.validator import Validator
+
+if TYPE_CHECKING:
+    from clearskies import Model
+
+
+class MinimumValue(Validator):
+    minimum_value = configs.Integer(required=True)
+
+    def __init__(self, minimum_value: int):
+        self.minimum_value = minimum_value
+        self.finalize_and_validate_configuration()
+
+    def check(self, model: Model, column_name: str, data: dict[str, Any]) -> str:
+        if column_name not in data:
+            return ""
+        try:
+            value = float(data[column_name])
+        except ValueError:
+            return f"{column_name} must be an integer or float"
+        if float(value) >= self.minimum_value:
+            return ""
+        return f"'{column_name}' must be at least {self.minimum_value}."

clearskies/validators/required.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from clearskies.validator import Validator
+
+if TYPE_CHECKING:
+    from clearskies import Model
+
+
+class Required(Validator):
+    is_required = True
+
+    def check(self, model: Model, column_name: str, data: dict[str, Any]) -> str:
+        # you'd think that "required" is straight forward and we want an input error if it isn't found.
+        # this isn't strictly true though.  If the model already exists, the column has a value in the model already,
+        # and the column is completely missing from the input data, then it is actually perfectly fine (because
+        # there will still be a value in the column after the save).  However, if the model doesn't exist, then
+        # we must require the column in the data with an actual value.
+        has_value = False
+        has_some_value = False
+        if column_name in data:
+            has_some_value = True
+            if type(data[column_name]) == str:
+                has_value = bool(data[column_name].strip())
+            else:
+                has_value = bool(data[column_name])
+        if has_value:
+            return ""
+        if model and getattr(model, column_name) and not has_some_value:
+            return ""
+        return f"'{column_name}' is required."

clearskies/validators/timedelta.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import datetime
+from collections import OrderedDict
+from typing import TYPE_CHECKING, Any
+
+import dateparser
+
+from clearskies import configs, decorators
+from clearskies.di import InjectableProperties, inject
+from clearskies.validator import Validator
+
+if TYPE_CHECKING:
+    from clearskies import Model
+
+
+class Timedelta(Validator, InjectableProperties):
+    timedelta = configs.Timedelta(default=None)
+
+    utcnow = inject.Utcnow()
+
+    @decorators.parameters_to_properties
+    def __init__(self, timedelta: datetime.timedelta):
+        self.finalize_and_validate_configuration()
+
+    def delta_human_friendly(self):
+        remainder = int(self.timedelta.total_seconds())
+        parts = []
+        conversion = OrderedDict(
+            [
+                ("year", 31536000),
+                ("day", 86400),
+                ("hour", 3600),
+                ("minute", 60),
+                ("second", 1),
+            ]
+        )
+        for name, num_seconds in conversion.items():
+            if num_seconds > remainder:
+                continue
+            amount = int(remainder / num_seconds)
+            remainder -= amount * num_seconds
+            parts.append(f"{amount} {name}" + ("s" if amount != 1 else ""))
+        return ", ".join(parts)
+
+    def check(self, model: Model, column_name: str, data: dict[str, Any]) -> str:
+        if not data.get(column_name):
+            return ""
+
+        as_date = dateparser.parse(data[column_name]) if isinstance(data[column_name], str) else data[column_name]
+        if not as_date:
+            return f"'{column_name}' was not a valid date"
+        if as_date.tzinfo == None:
+            as_date = as_date.replace(tzinfo=datetime.timezone.utc)
+        return self.check_timedelta(as_date, column_name)
+
+    def check_timedelta(self, as_date: datetime.datetime, column_name: str) -> str:
+        return ""