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

clearskies/input_requirements/__init__.py

@@ -1,78 +0,0 @@
-import datetime
-
-from .after import After
-from .before import Before
-from ..binding_config import BindingConfig
-from .minimum_length import MinimumLength
-from .minimum_value import MinimumValue
-from .maximum_length import MaximumLength
-from .maximum_value import MaximumValue
-from .required import Required
-from .requirement import Requirement
-from .unique import Unique
-from .in_the_future_at_least import InTheFutureAtLeast
-from .in_the_future_at_most import InTheFutureAtMost
-from .in_the_past_at_least import InThePastAtLeast
-from .in_the_past_at_most import InThePastAtMost
-from .time_delta import TimeDelta
-
-
-def after(other_column_name: str, allow_equal: bool = False):
-    return BindingConfig(After, other_column_name=other_column_name, allow_equal=allow_equal)
-
-
-def before(other_column_name: str, allow_equal: bool = False):
-    return BindingConfig(Before, other_column_name=other_column_name, allow_equal=allow_equal)
-
-
-def minimum_length(minimum_length: int):
-    return BindingConfig(MinimumLength, minimum_length)
-
-
-def minimum_value(minimum_value: int):
-    return BindingConfig(MinimumValue, minimum_value)
-
-
-def maximum_length(maximum_length: int):
-    return BindingConfig(MaximumLength, maximum_length)
-
-
-def maximum_value(maximum_value: int):
-    return BindingConfig(MaximumValue, maximum_value)
-
-
-def required():
-    return BindingConfig(Required)
-
-
-def unique():
-    return BindingConfig(Unique)
-
-
-def in_the_future_at_least(time_delta: datetime.timedelta):
-    return BindingConfig(InTheFutureAtLeast, time_delta)
-
-
-def in_the_future_at_most(time_delta: datetime.timedelta):
-    return BindingConfig(InTheFutureAtMost, time_delta)
-
-
-def in_the_past_at_least(time_delta: datetime.timedelta):
-    return BindingConfig(InThePastAtLeast, time_delta)
-
-
-def in_the_past_at_most(time_delta: datetime.timedelta):
-    return BindingConfig(InThePastAtMost, time_delta)
-
-
-__all__ = [
-    "in_the_future_at_least",
-    "in_the_future_at_most",
-    "in_the_past_at_least",
-    "in_the_past_at_most",
-    "minimum_length",
-    "maximum_length",
-    "required",
-    "TimeDelta",
-    "unique",
-]

clearskies/input_requirements/after.py

@@ -1,36 +0,0 @@
-from .requirement import Requirement
-import datetime
-import dateparser
-
-
-class After(Requirement):
-    def configure(self, other_column_name: str, allow_equal: bool = False):
-        self.other_column_name = other_column_name
-        self.allow_equal = allow_equal
-
-    def check(self, model, data):
-        # we won't check anything for missing values (columns should be required if that is an issue)
-        if not data.get(self.column_name):
-            return ""
-        my_value = data[self.column_name]
-        other_value = data.get(self.other_column_name, model.__getitem__(self.other_column_name))
-        # again, no checks for non-values
-        if not other_value:
-            return ""
-
-        my_value_as_date = dateparser.parse(data[self.column_name])
-        if not my_value_as_date:
-            return f"'{self.column_name}' was not a valid date."
-
-        if type(other_value) != str and type(other_value) != datetime.datetime:
-            return f"'{other_column_name}' was not a valid date."
-        other_value_as_date = dateparser.parse(other_value) if type(other_value) == str else other_value
-        if not other_value_as_date:
-            return f"'{self.other_column_name}' was not a valid date."
-
-        if my_value_as_date == other_value_as_date:
-            return "" if self.allow_equal else f"'{self.column_name}' must be after '{self.other_column_name}'"
-
-        if my_value_as_date < other_value_as_date:
-            return f"'{self.column_name}' must be after '{self.other_column_name}'"
-        return ""

clearskies/input_requirements/before.py

@@ -1,36 +0,0 @@
-from .requirement import Requirement
-import datetime
-import dateparser
-
-
-class Before(Requirement):
-    def configure(self, other_column_name: str, allow_equal: bool = False):
-        self.other_column_name = other_column_name
-        self.allow_equal = allow_equal
-
-    def check(self, model, data):
-        # we won't check anything for missing values (columns should be required if that is an issue)
-        if not data.get(self.column_name):
-            return ""
-        my_value = data[self.column_name]
-        other_value = data.get(self.other_column_name, model.__getitem__(self.other_column_name))
-        # again, no checks for non-values
-        if not other_value:
-            return ""
-
-        my_value_as_date = dateparser.parse(data[self.column_name])
-        if not my_value_as_date:
-            return f"'{self.column_name}' was not a valid date."
-
-        if type(other_value) != str and type(other_value) != datetime.datetime:
-            return f"'{other_column_name}' was not a valid date."
-        other_value_as_date = dateparser.parse(other_value) if type(other_value) == str else other_value
-        if not other_value_as_date:
-            return f"'{self.other_column_name}' was not a valid date."
-
-        if my_value_as_date == other_value_as_date:
-            return "" if self.allow_equal else f"'{self.column_name}' must be before '{self.other_column_name}'"
-
-        if my_value_as_date > other_value_as_date:
-            return f"'{self.column_name}' must be before '{self.other_column_name}'"
-        return ""

clearskies/input_requirements/in_the_future_at_least.py

@@ -1,19 +0,0 @@
-from .time_delta import TimeDelta
-import datetime
-import dateparser
-
-
-class InTheFutureAtLeast(TimeDelta):
-    def check(self, model, data):
-        if self.column_name not in data or not data[self.column_name]:
-            return ""
-        as_date = dateparser.parse(data[self.column_name])
-        if not as_date:
-            return f"'{self.column_name}' was not a valid date"
-        now = (
-            self.datetime.datetime.now() if not as_date.tzinfo else self.datetime.datetime.now(tz=datetime.timezone.utc)
-        )
-        if as_date < now + self.time_delta:
-            human_friendly = self.delta_human_friendly()
-            return f"'{self.column_name}' must be at least {human_friendly} in the future."
-        return ""

clearskies/input_requirements/in_the_future_at_most.py

@@ -1,19 +0,0 @@
-from .time_delta import TimeDelta
-import datetime
-import dateparser
-
-
-class InTheFutureAtMost(TimeDelta):
-    def check(self, model, data):
-        if self.column_name not in data or not data[self.column_name]:
-            return ""
-        as_date = dateparser.parse(data[self.column_name])
-        if not as_date:
-            return f"'{self.column_name}' was not a valid date"
-        now = (
-            self.datetime.datetime.now() if not as_date.tzinfo else self.datetime.datetime.now(tz=datetime.timezone.utc)
-        )
-        if as_date > now + self.time_delta:
-            human_friendly = self.delta_human_friendly()
-            return f"'{self.column_name}' must be at most {human_friendly} in the future."
-        return ""

clearskies/input_requirements/in_the_past_at_least.py

@@ -1,19 +0,0 @@
-from .time_delta import TimeDelta
-import datetime
-import dateparser
-
-
-class InThePastAtLeast(TimeDelta):
-    def check(self, model, data):
-        if self.column_name not in data or not data[self.column_name]:
-            return ""
-        as_date = dateparser.parse(data[self.column_name])
-        if not as_date:
-            return f"'{self.column_name}' was not a valid date"
-        now = (
-            self.datetime.datetime.now() if not as_date.tzinfo else self.datetime.datetime.now(tz=datetime.timezone.utc)
-        )
-        if as_date > now - self.time_delta:
-            human_friendly = self.delta_human_friendly()
-            return f"'{self.column_name}' must be at least {human_friendly} in the past."
-        return ""

clearskies/input_requirements/in_the_past_at_most.py

@@ -1,19 +0,0 @@
-from .time_delta import TimeDelta
-import datetime
-import dateparser
-
-
-class InThePastAtMost(TimeDelta):
-    def check(self, model, data):
-        if self.column_name not in data or not data[self.column_name]:
-            return ""
-        as_date = dateparser.parse(data[self.column_name])
-        if not as_date:
-            return f"'{self.column_name}' was not a valid date"
-        now = (
-            self.datetime.datetime.now() if not as_date.tzinfo else self.datetime.datetime.now(tz=datetime.timezone.utc)
-        )
-        if as_date < now - self.time_delta:
-            human_friendly = self.delta_human_friendly()
-            return f"'{self.column_name}' must be at most {human_friendly} in the past."
-        return ""

clearskies/input_requirements/maximum_length.py

@@ -1,19 +0,0 @@
-from .requirement import Requirement
-
-
-class MaximumLength(Requirement):
-    maximum_length = None
-
-    def configure(self, maximum_length):
-        if type(maximum_length) != int:
-            raise ValueError(
-                f"Maximum length must be an int to use the MaximumLength class for column '{self.column_name}'"
-            )
-        self.maximum_length = maximum_length
-
-    def check(self, model, data):
-        if self.column_name not in data or not data[self.column_name]:
-            return ""
-        if len(data[self.column_name]) <= self.maximum_length:
-            return ""
-        return f"'{self.column_name}' must be at most {self.maximum_length} characters long."

clearskies/input_requirements/maximum_value.py

@@ -1,19 +0,0 @@
-from .requirement import Requirement
-
-
-class MaximumValue(Requirement):
-    maximum_value = None
-
-    def configure(self, maximum_value):
-        if type(maximum_value) != int:
-            raise ValueError(
-                f"Maximum value must be an int to use the MaximumValue class for column '{self.column_name}'"
-            )
-        self.maximum_value = maximum_value
-
-    def check(self, model, data):
-        if self.column_name not in data or not data[self.column_name]:
-            return ""
-        if int(data[self.column_name]) <= self.maximum_value:
-            return ""
-        return f"'{self.column_name}' must be at most {self.maximum_value}."

clearskies/input_requirements/minimum_length.py

@@ -1,22 +0,0 @@
-from .requirement import Requirement
-
-
-class MinimumLength(Requirement):
-    minimum_length = None
-
-    def configure(self, minimum_length):
-        if type(minimum_length) != int:
-            raise ValueError(
-                f"Minimum length must be an int to use the MinimumLength class for column '{self.column_name}'"
-            )
-        self.minimum_length = minimum_length
-
-    def check(self, model, data):
-        # If the column isn't in the data then skip this check.  Otherwise, setting a minimum length would implicitly
-        # make a column required, and this will likely cause more problems than it solves.  In short, the minimum
-        # length should only apply if data is actually being set
-        if self.column_name not in data or not data[self.column_name]:
-            return ""
-        if len(data[self.column_name]) >= self.minimum_length:
-            return ""
-        return f"'{self.column_name}' must be at least {self.minimum_length} characters long."

clearskies/input_requirements/minimum_value.py

@@ -1,19 +0,0 @@
-from .requirement import Requirement
-
-
-class MinimumValue(Requirement):
-    minimum_value = None
-
-    def configure(self, minimum_value):
-        if type(minimum_value) != int:
-            raise ValueError(
-                f"Minimum value must be an int to use the MinimumValue class for column '{self.column_name}'"
-            )
-        self.minimum_value = minimum_value
-
-    def check(self, model, data):
-        if self.column_name not in data or not data[self.column_name]:
-            return ""
-        if int(data[self.column_name]) >= self.minimum_value:
-            return ""
-        return f"'{self.column_name}' must be at least {self.minimum_value}."

clearskies/input_requirements/requirement.py

@@ -1,25 +0,0 @@
-from abc import ABC, abstractmethod
-
-
-class Requirement(ABC):
-    _column_name = None
-
-    @property
-    def column_name(self):
-        if self._column_name is None:
-            raise ValueError("Attempt to get column name on requirement before setting it")
-        return self._column_name
-
-    @column_name.setter
-    def column_name(self, column_name):
-        self._column_name = column_name
-
-    def configure(self, *arguments):
-        pass
-
-    @abstractmethod
-    def check(self, data):
-        pass
-
-    def additional_write_columns(self, is_create=False):
-        return {}

clearskies/input_requirements/time_delta.py

@@ -1,38 +0,0 @@
-from .requirement import Requirement
-import datetime
-from collections import OrderedDict
-
-
-class TimeDelta(Requirement):
-    time_delta = None
-
-    def __init__(self, datetime):
-        self.datetime = datetime
-
-    def configure(self, time_delta: datetime.timedelta):
-        if type(time_delta) != datetime.timedelta:
-            raise ValueError(
-                "The argument for all time-related input requirement classes is a datetime.timedelta object, but I received something else."
-            )
-        self.time_delta = time_delta
-        self.human_friendly = None
-
-    def delta_human_friendly(self):
-        remainder = int(self.time_delta.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)

clearskies/input_requirements/unique.py

@@ -1,18 +0,0 @@
-from .requirement import Requirement
-
-
-class Unique(Requirement):
-    def check(self, model, data):
-        # 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 self.column_name not in data:
-            return ""
-        new_value = data[self.column_name]
-        if model.exists and model.__getattr__(self.column_name) == new_value:
-            return ""
-
-        matching_model = model.find(f"{self.column_name}={new_value}")
-        if matching_model.exists:
-            return f"Invalid value for '{self.column_name}': the given value already exists, and must be unique."
-        return ""

clearskies/mocks/__init__.py

@@ -1,7 +0,0 @@
-from .models import Models
-from .input_output import InputOutput
-
-__all__ = [
-    "Models",
-    "InputOutput",
-]

clearskies/mocks/input_output.py

@@ -1,124 +0,0 @@
-import json
-from .. import input_outputs
-
-
-class InputOutput(input_outputs.InputOutput):
-    _body = None
-    _request_method = None
-    _script_name = ""
-    _path_info = ""
-    _query_string = ""
-    _content_type = ""
-    _protocol = ""
-    _query_parameters = None
-    _context_specifics = None
-    _client_ip = None
-    response = None
-
-    def __init__(
-        self,
-        request_headers=None,
-        body=None,
-        request_method="GET",
-        request_url="",
-        script_name="",
-        path_info="",
-        query_string="",
-        content_type="",
-        protocol="",
-        query_parameters=None,
-        authorization_data=None,
-        context_specifics=None,
-        client_ip=None,
-    ):
-        self.set_request_method(request_method)
-        self.set_body(body)
-        self.set_request_headers(request_headers)
-        self.set_request_url(request_url, script_name=script_name)
-        self._path_info = path_info
-        self._query_string = query_string
-        self._content_type = content_type
-        self._protocol = protocol
-        self._query_parameters = query_parameters if query_parameters is not None else {}
-        self._authorization_data = authorization_data
-        self._context_specifics = context_specifics if context_specifics is not None else {}
-        self._client_ip = client_ip if client_ip is not None else "127.0.0.1"
-
-    def respond(self, body, status_code=200):
-        self.response = {"body": body, "status_code": status_code, "headers": self._response_headers}
-        return (body, status_code)
-
-    def get_body(self):
-        return self._body
-
-    def has_body(self):
-        return bool(self._body)
-
-    def set_body(self, body):
-        self._body = None
-        if body:
-            self._body = body if type(body) == str else json.dumps(body)
-
-    def set_request_url(self, request_url, script_name=""):
-        if request_url and script_name:
-            raise ValueError("You cannot specify both request_url and script_name")
-        self._script_name = request_url if request_url else script_name
-
-    def get_request_method(self):
-        return self._request_method
-
-    def set_request_method(self, request_method):
-        self._request_method = request_method.upper()
-
-    def set_request_headers(self, request_headers):
-        self._request_headers = {}
-        if request_headers is None:
-            request_headers = {}
-        for key, value in request_headers.items():
-            self._request_headers[key.lower()] = value
-
-    def set_query_parameters(self, query_parameters):
-        if query_parameters is None:
-            self._query_parameters = {}
-        else:
-            self._query_parameters = query_parameters
-
-    def get_script_name(self):
-        return self._script_name
-
-    def get_path_info(self):
-        return self._path_info
-
-    def get_query_string(self):
-        return self._query_string
-
-    def get_content_type(self):
-        return self._content_type
-
-    def get_protocol(self):
-        return self._protocol
-
-    def has_request_header(self, header_name):
-        return header_name.lower() in self._request_headers
-
-    def get_request_header(self, header_name, silent=True):
-        if not self.has_request_header(header_name):
-            if not silent:
-                raise ValueError(f"Request header '{header_name}' not found in request")
-            return ""
-        return self._request_headers[header_name.lower()]
-
-    def get_query_parameter(self, key):
-        return self._query_parameters[key] if key in self._query_parameters else ""
-
-    def get_query_parameters(self):
-        return self._query_parameters
-
-    def set_context_specifics(self, context_specifics):
-        self._context_specifics = context_specifics
-
-    def context_specifics(self):
-        return self._context_specifics
-
-    def get_client_ip(self):
-        return self._client_ip

clearskies/mocks/models.py

@@ -1,142 +0,0 @@
-from ..models import Models as ModelsBase
-from ..model import Model as ModelBase
-from ..columns import Columns
-from ..di import StandardDependencies
-
-
-class Model(ModelBase):
-    _columns_configuration = None
-
-    def set_columns_configuration(self, columns_configuration):
-        self._columns_configuration = columns_configuration
-
-    def columns_configuration(self):
-        return self._columns_configuration
-
-
-class Models(ModelsBase):
-    _model_configuration = None
-    updated = None
-    created = None
-    deleted = None
-    create_responses = None
-    update_responses = None
-    search_responses = None
-    iterating = None
-    iterator_index = None
-    iterated = None
-    counted = None
-
-    @classmethod
-    def reset(cls):
-        cls.updated = None
-        cls.created = None
-        cls.iterated = None
-        cls.counted = None
-        cls.deleted = None
-
-    def __init__(self, model_configuration):
-        self._model_configuration = model_configuration
-        super().__init__(self, Columns(StandardDependencies()))
-
-    def model(self, data):
-        model_class = self.model_class()
-        model = model_class(self._backend, self._columns)
-        model.set_columns_configuration(self._model_configuration)
-        model.data = data
-        return model
-
-    def model_class(self):
-        return Model
-
-    def table_name(self):
-        return "mock_model"
-
-    def blank(self):
-        blank = self.__class__(self._model_configuration)
-        blank.create_responses = self.create_responses
-        blank.update_responses = self.update_responses
-        blank.search_responses = self.search_responses
-        return blank
-
-    def add_update_response(self, data):
-        if self.update_responses is None:
-            self.update_responses = []
-        self.update_responses.append(data)
-
-    def add_create_response(self, data):
-        if self.create_responses is None:
-            self.create_responses = []
-        self.create_responses.append(data)
-
-    def add_search_response(self, data):
-        # We're expecting a list because a search implicitly returns multiple records.  Technically, we're also
-        # okay with tuples, but this is the most straight-forward way to get what we want and should avoid weird
-        # errors without causing serious issues later.
-        if type(data) != list:
-            raise ValueError("A list should be passed into to 'add_search_response'")
-        if self.search_responses is None:
-            self.search_responses = []
-        self.search_responses.append(data)
-
-    def clear_search_responses(self):
-        self.search_responses = None
-
-    # our mock models also acts as the backend for the mock model
-    def update(self, id, data, model):
-        if self.update_responses is None:
-            raise ValueError("Must set update data through 'models.add_update_response' before attempting to update")
-        if not len(self.update_responses):
-            raise ValueError("Ran out of responses while processing an update!")
-        if Models.updated is None:
-            Models.updated = []
-        Models.updated.append({"id": id, "data": data, "model": model})
-        return self.update_responses.pop(0)
-
-    def create(self, data, model):
-        if self.create_responses is None:
-            raise ValueError("Must set create data through 'models.add_create_response' before attempting to create")
-        if not len(self.create_responses):
-            raise ValueError("Ran out of responses while processing an create!")
-        if Models.created is None:
-            Models.created = []
-        Models.created.append({"data": data, "model": model})
-        return self.create_responses.pop(0)
-
-    def delete(self, id, model):
-        if Models.deleted is None:
-            Models.deleted = []
-        Models.deleted.append({"id": id, "model": model})
-        return True
-
-    def count(self, configuration, model):
-        if self.search_responses is None:
-            raise ValueError("Must set search data through 'models.add_search_response' before counting")
-        if Models.counted == None:
-            Models.counted = []
-        del configuration["model_columns"]
-        Models.counted.append(configuration)
-        counted = self.search_responses.pop(0)
-        return len(counted)
-
-    def records(self, configuration, model, next_page_data=None):
-        if self.search_responses is None:
-            raise ValueError("Must set search data through 'models.add_search_response' before counting")
-        if Models.iterated == None:
-            Models.iterated = []
-        del configuration["model_columns"]
-        Models.iterated.append(configuration)
-        records = self.search_responses.pop(0)
-        return records
-
-    def next(self):
-        self.iterator_index += 1
-        if self.iterator_index >= len(self.iterating):
-            raise StopIteration()
-        return self.iterating[self.iterator_index]
-
-    def column_from_backend(self, column, value):
-        return column.from_backend(value)
-
-    def column_to_backend(self, column, backend_data):
-        return column.to_backend(backend_data)