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

clearskies/security_headers/hsts.py

@@ -1,24 +1,23 @@
-from .base import Base
-from ..binding_config import BindingConfig
+from __future__ import annotations
 
+from clearskies import configs, decorators
+from clearskies.security_header import SecurityHeader
 
-class HSTS(Base):
-    max_age = None
-    include_sub_domains = None
 
-    def __init__(self, environment):
-        super().__init__(environment)
+class Hsts(SecurityHeader):
+    max_age = configs.Integer(default=31536000)
+    include_sub_domains = configs.Boolean()
 
-    def configure(self, max_age=31536000, include_sub_domains=False):
-        self.max_age = max_age
-        self.include_sub_domains = include_sub_domains
+    @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.set_header("strict-transport-security", value)
-
-
-def hsts(max_age=31536000, include_sub_domains=False):
-    return BindingConfig(HSTS, max_age=max_age, include_sub_domains=include_sub_domains)
+        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/{input_requirements → validators}/required.py

@@ -1,8 +1,17 @@
-from .requirement import Requirement
+from __future__ import annotations
 
+from typing import TYPE_CHECKING, Any
 
-class Required(Requirement):
-    def check(self, model, data):
+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
@@ -10,14 +19,14 @@ class Required(Requirement):
         # we must require the column in the data with an actual value.
         has_value = False
         has_some_value = False
-        if self.column_name in data:
+        if column_name in data:
             has_some_value = True
-            if type(data[self.column_name]) == str:
-                has_value = bool(data[self.column_name].strip())
+            if type(data[column_name]) == str:
+                has_value = bool(data[column_name].strip())
             else:
-                has_value = bool(data[self.column_name])
+                has_value = bool(data[column_name])
         if has_value:
             return ""
-        if model.exists and model[self.column_name] and not has_some_value:
+        if model and getattr(model, column_name) and not has_some_value:
             return ""
-        return f"'{self.column_name}' is required."
+        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 ""

clearskies/validators/unique.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from clearskies.validator import Validator
+
+if TYPE_CHECKING:
+    from clearskies import Model
+
+
+class Unique(Validator):
+    is_unique = True
+
+    def check(self, 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 ""

clear_skies-1.22.10.dist-info/METADATA

@@ -1,47 +0,0 @@
-Metadata-Version: 2.1
-Name: clear-skies
-Version: 1.22.10
-Summary: A framework for building backends in the cloud
-Home-page: https://github.com/cmancone/clearskies
-License: MIT
-Author: Conor Mancone
-Author-email: cmancone@gmail.com
-Requires-Python: >=3.10,<4.0
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
-Provides-Extra: jose
-Provides-Extra: jwcrypto
-Provides-Extra: mysql
-Provides-Extra: secrets
-Requires-Dist: akeyless (>=4.0.0,<5.0.0) ; extra == "secrets"
-Requires-Dist: akeyless-cloud-id (>=0.2.3,<0.3.0) ; extra == "secrets"
-Requires-Dist: dateparser (>=1.1.8,<2.0.0)
-Requires-Dist: jose (>=1.0.0,<2.0.0) ; extra == "jose"
-Requires-Dist: jwcrypto (>=1.5.6,<2.0.0) ; extra == "jwcrypto"
-Requires-Dist: pymysql (>=1.1.0,<2.0.0) ; extra == "mysql"
-Requires-Dist: requests (>=2.31.0,<3.0.0)
-Requires-Dist: typing-extensions (>=4.12.0,<5.0.0) ; python_version >= "3.10" and python_version < "3.11"
-Project-URL: Repository, https://github.com/cmancone/clearskies
-Description-Content-Type: text/markdown
-
-# clearskies
-
-clearskies is a very opinionated Python framework intended for developing microservices in the cloud via declarative programming principles.  It is mainly intended for backend services and so is designed for RESTful API endpoints, queue listeners, scheduled tasks, and the like.
-
-# Installation, Documentation, and Usage
-
-To install:
-
-```
-pip3 install clear-skies
-```
-
-Documentation is under construction here:
-
-[https://clearskies.info](https://clearskies.info)
-