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

clearskies/security_headers/csp.py

@@ -1,94 +0,0 @@
-import clearskies.configs
-import clearskies.decorators
-from clearskies.security_header import SecurityHeader
-
-
-class Csp(SecurityHeader):
-    header_name = "content-security-policy"
-    default_src = clearskies.configs.String()
-    script_src = clearskies.configs.String()
-    style_src = clearskies.configs.String()
-    img_src = clearskies.configs.String()
-    connect_src = clearskies.configs.String()
-    font_src = clearskies.configs.String()
-    object_src = clearskies.configs.String()
-    media_src = clearskies.configs.String()
-    frame_src = clearskies.configs.String()
-    sandbox = clearskies.configs.String()
-    report_uri = clearskies.configs.String()
-    child_src = clearskies.configs.String()
-    form_action = clearskies.configs.String()
-    frame_ancestors = clearskies.configs.String()
-    plugin_types = clearskies.configs.String()
-    base_uri = clearskies.configs.String()
-    report_to = clearskies.configs.String()
-    worker_src = clearskies.configs.String()
-    manifest_src = clearskies.configs.String()
-    prefetch_src = clearskies.configs.String()
-    navigate_to = clearskies.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",
-    ]
-
-    @clearskies.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

@@ -1,22 +0,0 @@
-import clearskies.configs
-import clearskies.decorators
-from clearskies.security_header import SecurityHeader
-
-
-class Hsts(SecurityHeader):
-    max_age = clearskies.configs.Integer(default=31536000)
-    include_sub_domains = clearskies.configs.Boolean()
-
-    @clearskies.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/test_base.py

@@ -1,8 +0,0 @@
-import unittest
-
-
-class TestBase(unittest.TestCase):
-    def tearDown(self):
-        import clearskies.backends.memory_backend
-
-        clearskies.backends.memory_backend.MemoryBackend.clear_table_cache()

clearskies/typing.py

@@ -1,11 +0,0 @@
-from typing import Any, Callable
-
-from clearskies.action import Action
-from clearskies.query.condition 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

@@ -1,37 +0,0 @@
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Any
-
-from clearskies import configurable
-
-if TYPE_CHECKING:
-    import clearskies.column
-    import clearskies.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: clearskies.model.Model, column_name: str, data: dict[str, Any]) -> str:
-        return self.check(model, column_name, data)
-
-    @abstractmethod
-    def check(self, model: clearskies.model.Model, column_name: str, data: dict[str, Any]) -> str:
-        pass
-
-    def additional_write_columns(self, is_create=False) -> dict[str, clearskies.column.Column]:
-        return {}

clearskies/validators/__init__.py

@@ -1,33 +0,0 @@
-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",
-    "MinimumLength",
-    "MaximumLength",
-    "Required",
-    "Timedelta",
-    "Unique",
-]

clearskies/validators/after_column.py

@@ -1,62 +0,0 @@
-from __future__ import annotations
-
-import datetime
-from typing import TYPE_CHECKING, Any
-
-import dateparser
-
-import clearskies.configs
-import clearskies.decorators
-from clearskies.validator import Validator
-
-if TYPE_CHECKING:
-    import clearskies.model
-
-
-class AfterColumn(Validator):
-    """The name of the other date column for comparison."""
-
-    other_column_name = clearskies.configs.String(default="", required=True)
-
-    """
-    If true, then this column is allowed to be eqaul to the other column.
-    """
-    allow_equal = clearskies.configs.Boolean(default=False)
-
-    @clearskies.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: clearskies.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

@@ -1,13 +0,0 @@
-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

@@ -1,32 +0,0 @@
-from __future__ import annotations
-
-import datetime
-from collections import OrderedDict
-from typing import TYPE_CHECKING, Any
-
-import dateparser
-
-import clearskies.configs
-import clearskies.decorators
-import clearskies.di
-from clearskies.validator import Validator
-
-if TYPE_CHECKING:
-    import clearskies.model
-
-
-class InTheFuture(Validator, clearskies.di.InjectableProperties):
-    utcnow = clearskies.di.inject.Utcnow()
-
-    def check(self, model: clearskies.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

@@ -1,11 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,32 +0,0 @@
-from __future__ import annotations
-
-import datetime
-from collections import OrderedDict
-from typing import TYPE_CHECKING, Any
-
-import dateparser
-
-import clearskies.configs
-import clearskies.decorators
-import clearskies.di
-from clearskies.validator import Validator
-
-if TYPE_CHECKING:
-    import clearskies.model
-
-
-class InThePast(Validator, clearskies.di.InjectableProperties):
-    utcnow = clearskies.di.inject.Utcnow()
-
-    def check(self, model: clearskies.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

@@ -1,10 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,26 +0,0 @@
-from __future__ import annotations
-
-import datetime
-from typing import TYPE_CHECKING, Any
-
-import clearskies.configs
-from clearskies.validator import Validator
-
-if TYPE_CHECKING:
-    import clearskies.model
-
-
-class MaximumLength(Validator):
-    maximum_length = clearskies.configs.Integer(required=True)
-
-    def __init__(self, maximum_length: int):
-        self.maximum_length = maximum_length
-        self.finalize_and_validate_configuration()
-
-    def check(self, model: clearskies.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

@@ -1,29 +0,0 @@
-from __future__ import annotations
-
-import datetime
-from typing import TYPE_CHECKING, Any
-
-import clearskies.configs
-from clearskies.validator import Validator
-
-if TYPE_CHECKING:
-    import clearskies.model
-
-
-class MaximumValue(Validator):
-    maximum_value = clearskies.configs.Integer(required=True)
-
-    def __init__(self, maximum_value: int):
-        self.maximum_value = maximum_value
-        self.finalize_and_validate_configuration()
-
-    def check(self, model: clearskies.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

@@ -1,26 +0,0 @@
-from __future__ import annotations
-
-import datetime
-from typing import TYPE_CHECKING, Any
-
-import clearskies.configs
-from clearskies.validator import Validator
-
-if TYPE_CHECKING:
-    import clearskies.model
-
-
-class MinimumLength(Validator):
-    minimum_length = clearskies.configs.Integer(required=True)
-
-    def __init__(self, minimum_length: int):
-        self.minimum_length = minimum_length
-        self.finalize_and_validate_configuration()
-
-    def check(self, model: clearskies.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

@@ -1,29 +0,0 @@
-from __future__ import annotations
-
-import datetime
-from typing import TYPE_CHECKING, Any
-
-import clearskies.configs
-from clearskies.validator import Validator
-
-if TYPE_CHECKING:
-    import clearskies.model
-
-
-class MinimumValue(Validator):
-    minimum_value = clearskies.configs.Integer(required=True)
-
-    def __init__(self, minimum_value: int):
-        self.minimum_value = minimum_value
-        self.finalize_and_validate_configuration()
-
-    def check(self, model: clearskies.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

@@ -1,34 +0,0 @@
-from __future__ import annotations
-
-import datetime
-from typing import TYPE_CHECKING, Any
-
-import clearskies.configs
-from clearskies.validator import Validator
-
-if TYPE_CHECKING:
-    import clearskies.model
-
-
-class Required(Validator):
-    is_required = True
-
-    def check(self, model: clearskies.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

@@ -1,59 +0,0 @@
-from __future__ import annotations
-
-import datetime
-from collections import OrderedDict
-from typing import TYPE_CHECKING, Any
-
-import dateparser
-
-import clearskies.configs
-import clearskies.decorators
-import clearskies.di
-from clearskies.validator import Validator
-
-if TYPE_CHECKING:
-    import clearskies.model
-
-
-class Timedelta(Validator, clearskies.di.InjectableProperties):
-    timedelta = clearskies.configs.Timedelta(default=None)
-
-    utcnow = clearskies.di.inject.Utcnow()
-
-    @clearskies.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: clearskies.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 ""

clearskies/validators/unique.py

@@ -1,30 +0,0 @@
-from __future__ import annotations
-
-import datetime
-from typing import TYPE_CHECKING, Any
-
-import clearskies.configs
-from clearskies.validator import Validator
-
-if TYPE_CHECKING:
-    import clearskies.model
-
-
-class Unique(Validator):
-    is_unique = True
-
-    def check(self, model: clearskies.model.Model, column_name: str, data: dict[str, Any]) -> str:
-        # Unique is mildly tricky.  We obviously want to search the backend for the new value,
-        # but we need to first skip this if our column is not being set, or if we're editing
-        # the model and nothing is changing.
-        if column_name not in data:
-            return ""
-        new_value = data[column_name]
-        if model and getattr(model, column_name) == new_value:
-            return ""
-
-        as_query = model.as_query()
-        matching_model = as_query.find(f"{column_name}={new_value}")
-        if matching_model:
-            return f"Invalid value for '{column_name}': the given value already exists, and must be unique."
-        return ""