clear-skies 1.22.31__py3-none-any.whl → 2.0.1__py3-none-any.whl

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

clearskies/validators/after_column.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import datetime
+from typing import TYPE_CHECKING, Any
+
+import dateparser
+
+import clearskies.configs
+import clearskies.parameters_to_properties
+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.parameters_to_properties.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

@@ -0,0 +1,13 @@
+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,32 @@
+from __future__ import annotations
+
+import datetime
+from collections import OrderedDict
+from typing import TYPE_CHECKING, Any
+
+import dateparser
+
+import clearskies.configs
+import clearskies.di
+import clearskies.parameters_to_properties
+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

@@ -0,0 +1,11 @@
+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,10 @@
+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,32 @@
+from __future__ import annotations
+
+import datetime
+from collections import OrderedDict
+from typing import TYPE_CHECKING, Any
+
+import dateparser
+
+import clearskies.configs
+import clearskies.di
+import clearskies.parameters_to_properties
+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

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

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

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

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

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import datetime
+from typing import TYPE_CHECKING, Any
+
+import clearskies.configs
+from clearskies import parameters_to_properties
+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

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import datetime
+from collections import OrderedDict
+from typing import TYPE_CHECKING, Any
+
+import dateparser
+
+import clearskies.configs
+import clearskies.di
+import clearskies.parameters_to_properties
+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.parameters_to_properties.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

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import datetime
+from typing import TYPE_CHECKING, Any
+
+import clearskies.configs
+from clearskies import parameters_to_properties
+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 ""