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

clearskies/column_types/created_by_authorization_data.py

@@ -1,26 +0,0 @@
-from .string import String
-
-
-class CreatedByAuthorizationData(String):
-    required_configs = [
-        "authorization_data_key_name",
-    ]
-
-    def __init__(self, di):
-        super().__init__(di)
-
-    @property
-    def is_writeable(self):
-        return False
-
-    def pre_save(self, data, model):
-        if model.exists:
-            return data
-
-        authorization_data = self.di.build("input_output", cache=True).get_authorization_data()
-        # data comes last so that it can override the info in the authorization data.  This seems counter-intuitive,
-        # but is important.  You would think that you *don't* want the data from the authorization data to be
-        # overridden (since this is mainly used for logging), but the trouble is that there are a variety of use-cases
-        # where the application must provide the audit data.  Examples include registration and login.  In these
-        # cases, authorization data will be empty, and must be provided by the applicaiton.
-        return {self.name: authorization_data.get(self.config("authorization_data_key_name"), "N/A"), **data}

clearskies/column_types/created_by_header.py

@@ -1,24 +0,0 @@
-from .string import String
-
-
-class CreatedByHeader(String):
-    required_configs = [
-        "header_name",
-    ]
-
-    def __init__(self, di):
-        super().__init__(di)
-
-    @property
-    def is_writeable(self):
-        return False
-
-    def pre_save(self, data, model):
-        if model.exists:
-            return data
-
-        input_output = self.di.build("input_output", cache=True)
-        return {
-            **data,
-            self.name: input_output.get_request_header(self.config("header_name")),
-        }

clearskies/column_types/created_by_ip.py

@@ -1,17 +0,0 @@
-from .string import String
-
-
-class CreatedByIp(String):
-    def __init__(self, di):
-        super().__init__(di)
-
-    @property
-    def is_writeable(self):
-        return False
-
-    def pre_save(self, data, model):
-        if model.exists:
-            return data
-
-        input_output = self.di.build("input_output", cache=True)
-        return {**data, self.name: input_output.get_client_ip()}

clearskies/column_types/created_by_routing_data.py

@@ -1,25 +0,0 @@
-from .string import String
-
-
-class CreatedByRoutingData(String):
-    required_configs = [
-        "routing_data_name",
-    ]
-
-    def __init__(self, di):
-        super().__init__(di)
-
-    @property
-    def is_writeable(self):
-        return False
-
-    def pre_save(self, data, model):
-        if model.exists:
-            return data
-
-        input_output = self.di.build("input_output", cache=True)
-        routing_data = input_output.routing_data()
-        return {
-            **data,
-            self.name: routing_data[self.config("routing_data_name")],
-        }

clearskies/column_types/created_by_user_agent.py

@@ -1,17 +0,0 @@
-from .string import String
-
-
-class CreatedByUserAgent(String):
-    def __init__(self, di):
-        super().__init__(di)
-
-    @property
-    def is_writeable(self):
-        return False
-
-    def pre_save(self, data, model):
-        if model.exists:
-            return data
-
-        input_output = self.di.build("input_output", cache=True)
-        return {**data, self.name: input_output.get_request_header("user-agent")}

clearskies/column_types/created_micro.py

@@ -1,26 +0,0 @@
-from .datetime_micro import DateTimeMicro
-
-
-class CreatedMicro(DateTimeMicro):
-    my_configs = [
-        "date_format",
-        "default_date",
-        "utc",
-    ]
-
-    def __init__(self, di, datetime):
-        super().__init__(di)
-        self.datetime = datetime
-
-    @property
-    def is_writeable(self):
-        return False
-
-    def pre_save(self, data, model):
-        if model.exists:
-            return data
-        if self.config("utc", silent=True):
-            now = self.datetime.datetime.now(self.datetime.timezone.utc)
-        else:
-            now = self.datetime.datetime.now()
-        return {**data, self.name: now}

clearskies/column_types/datetime.py

@@ -1,108 +0,0 @@
-from .column import Column
-from datetime import datetime, timezone
-import dateparser
-from ..autodoc.schema import DateTime as AutoDocDateTime
-
-
-class DateTime(Column):
-    _auto_doc_class = AutoDocDateTime
-    _date_format = "%Y-%m-%d %H:%M:%S"
-    _default_date = "0000-00-00 00:00:00"
-
-    my_configs = [
-        "date_format",
-        "default_date",
-    ]
-
-    def __init__(self, di):
-        super().__init__(di)
-
-    def _finalize_configuration(self, configuration):
-        return {
-            **{
-                "date_format": self._date_format,
-                "default_date": self._default_date,
-            },
-            **super()._finalize_configuration(configuration),
-        }
-
-    def from_backend(self, value):
-        if not value or value == self.config("default_date"):
-            date = None
-        elif type(value) == str:
-            date = dateparser.parse(value)
-        else:
-            date = value
-        return date.replace(tzinfo=timezone.utc) if date else None
-
-    def to_backend(self, data):
-        if not self.name in data or type(data[self.name]) == str or data[self.name] == None:
-            return data
-
-        # hopefully this is a Python datetime object in UTC timezone...
-        return {**data, **{self.name: data[self.name].strftime(self.config("date_format"))}}
-
-    def to_json(self, model):
-        datetime = model.get(self.name, silent=True)
-        return {self.name: datetime.isoformat() if datetime else None}
-
-    def build_condition(self, value, operator=None, column_prefix=""):
-        date = dateparser.parse(value).astimezone(timezone.utc).strftime(self.config("date_format"))
-        if not operator:
-            operator = "="
-        return f"{column_prefix}{self.name}{operator}{date}"
-
-    def is_allowed_operator(self, operator, relationship_reference=None):
-        """
-        This is called when processing user data to decide if the end-user is specifying an allowed operator
-        """
-        return operator in ["=", "<", ">", "<=", ">="]
-
-    def input_error_for_value(self, value, operator=None):
-        value = dateparser.parse(value)
-        if not value:
-            return "given value did not appear to be a valid date"
-        if not value.tzinfo:
-            return "date is missing timezone information"
-        return ""
-
-    def values_match(self, value_1, value_2):
-        """
-        Compares two values to see if they are the same
-        """
-        # in this function we deal with data directly out of the backend, so our date is likely
-        # to be string-ified and we want to look for default (e.g. null) values in string form.
-        if type(value_1) == str and "0000-00-00" in value_1:
-            value_1 = None
-        if type(value_2) == str and "0000-00-00" in value_2:
-            value_2 = None
-        number_values = 0
-        if value_1:
-            number_values += 1
-        if value_2:
-            number_values += 1
-        if number_values == 0:
-            return True
-        if number_values == 1:
-            return False
-
-        if type(value_1) == str:
-            value_1 = dateparser.parse(value_1)
-        if type(value_2) == str:
-            value_2 = dateparser.parse(value_2)
-
-        # we need to make sure we're comparing in the same timezones.  For our purposes, a difference in timezone
-        # is fine as long as they represent the same time (e.g. 16:00EST == 20:00UTC).  For python, same time in different
-        # timezones is treated as different datetime objects.
-        if value_1.tzinfo is not None and value_2.tzinfo is not None:
-            value_1 = value_1.astimezone(value_2.tzinfo)
-
-        # two times can be the same but if one is datetime-aware and one is not, python will treat them as not equal.
-        # we want to treat such times as being the same.  Therefore, check for equality but ignore the timezone.
-        for to_check in ["year", "month", "day", "hour", "minute", "second", "microsecond"]:
-            if getattr(value_1, to_check) != getattr(value_2, to_check):
-                return False
-
-        # and since we already converted the timezones to match (or one has a timezone and one doesn't), we're good to go.
-        # if we passed the above loop then the times are the same.
-        return True

clearskies/column_types/datetime_micro.py

@@ -1,12 +0,0 @@
-from .datetime import DateTime
-from datetime import datetime, timezone
-import dateparser
-from ..autodoc.schema import DateTime as AutoDocDateTime
-
-
-class DateTimeMicro(DateTime):
-    _date_format = "%Y-%m-%d %H:%M:%S.%f"
-    _default_date = "0000-00-00 00:00:00.000000"
-
-    def __init__(self, di):
-        super().__init__(di)

clearskies/column_types/email.py

@@ -1,18 +0,0 @@
-from .string import String
-import re
-
-
-class Email(String):
-    def __init__(self, di):
-        super().__init__(di)
-
-    def input_error_for_value(self, value, operator=None):
-        if type(value) != str:
-            return f"Value must be a string for {self.name}"
-        if operator and operator.lower() == "like":
-            # don't check for an email if doing a fuzzy search, since we may be searching
-            # for a partial email
-            return ""
-        if re.search(r"^[^@\s]+@[^@]+\.[^@]+$", value):
-            return ""
-        return "Invalid email address"

clearskies/column_types/float.py

@@ -1,43 +0,0 @@
-from .column import Column
-from ..autodoc.schema import Number as AutoDocNumber
-
-
-class Float(Column):
-    _auto_doc_class = AutoDocNumber
-
-    def __init__(self, di):
-        super().__init__(di)
-
-    def from_backend(self, value):
-        return float(value)
-
-    def to_backend(self, data):
-        if self.name not in data or data[self.name] is None:
-            return data
-
-        return {
-            **data,
-            self.name: float(data[self.name]),
-        }
-
-    def check_input(self, model, data):
-        if not self.name in data:
-            return ""
-        if isinstance(data[self.name], int) or isinstance(data[self.name], float) or data[self.name] == None:
-            return ""
-        return f"Invalid input: {self.name} must be an integer or float"
-
-    def build_condition(self, value, operator=None, column_prefix=""):
-        if not operator:
-            operator = "="
-        return f"{column_prefix}{self.name}{operator}{value}"
-
-    def is_allowed_operator(self, operator, relationship_reference=None):
-        return operator in ["=", "<", ">", "<=", ">="]
-
-    def input_error_for_value(self, value, operator=None):
-        return (
-            "value should be an integer or float"
-            if (type(value) != int and type(value) != float and value is not None)
-            else ""
-        )

clearskies/column_types/has_many.py

@@ -1,139 +0,0 @@
-from .column import Column
-import re
-from collections import OrderedDict
-from ..autodoc.schema import Array as AutoDocArray
-from ..autodoc.schema import Object as AutoDocObject
-from ..autodoc.schema import String as AutoDocString
-
-
-class HasMany(Column):
-    """
-    Controls a has-many relationship.
-
-    This is a readonly column.  When used in a model context it will return an iterable with the related child records.
-    When used in an API context, it will convert the child records into a list of objects.
-
-    It assumes that the foreign id in the child table is `[parent_model_class_name]_id` in all lower case.
-    e.g., if the parent model class is named Status, then it assumes an id in the child class called `status_id`.
-    """
-
-    required_configs = [
-        "child_models_class",
-    ]
-
-    my_configs = [
-        "foreign_column_name",
-        "child_columns",
-        "is_readable",
-        "readable_child_columns",
-        "parent_id_column_name",
-    ]
-
-    def __init__(self, di):
-        super().__init__(di)
-
-    @property
-    def is_writeable(self):
-        return False
-
-    @property
-    def is_readable(self):
-        is_readable = self.config("is_readable", True)
-        # default is_readable to False
-        return True if (is_readable and is_readable is not None) else False
-
-    def configure(self, name, configuration, model_class):
-        if "child_models_class" not in configuration:
-            raise KeyError(
-                f"Missing required configuration 'child_models_class' for column '{name}' in model class "
-                + f"'{model_class.__name__}'"
-            )
-        self.validate_models_class(configuration["child_models_class"])
-        configuration["parent_id_column_name"] = model_class.id_column_name
-
-        # if readable_child_columns is set then load up the child models/columns now, because we'll need it in the
-        # _check_configuration step, but we don't want to load it there because we can't save it back into the config
-        if "foreign_column_name" not in configuration:
-            configuration["foreign_column_name"] = (
-                re.sub(r"(?<!^)(?=[A-Z])", "_", model_class.__name__.replace("_", "")).lower() + "_id"
-            )
-
-        # continue normally now...
-        super().configure(name, configuration, model_class)
-
-    def _check_configuration(self, configuration):
-        super()._check_configuration(configuration)
-        if configuration.get("is_readable"):
-            child_columns = self.di.build(configuration["child_models_class"], cache=True).raw_columns_configuration()
-            error_prefix = f"Configuration error for '{self.name}' in '{self.model_class.__name__}':"
-            if not "readable_child_columns" in configuration:
-                raise ValueError(f"{error_prefix} must provide 'readable_child_columns' if is_readable is set")
-            readable_child_columns = configuration["readable_child_columns"]
-            if not hasattr(readable_child_columns, "__iter__"):
-                raise ValueError(
-                    f"{error_prefix} 'readable_child_columns' should be an iterable "
-                    + "with the list of child columns to output."
-                )
-            if isinstance(readable_child_columns, str):
-                raise ValueError(
-                    f"{error_prefix} 'readable_child_columns' should be an iterable "
-                    + "with the list of child columns to output."
-                )
-            for column_name in readable_child_columns:
-                if column_name not in child_columns:
-                    raise ValueError(
-                        f"{error_prefix} 'readable_child_columns' references column named '{column_name}' but this"
-                        + "column does not exist in the model class."
-                    )
-
-    def get_child_columns(self):
-        if "child_columns" not in self.configuration:
-            self.configuration["child_columns"] = self.child_models.columns()
-        return self.configuration["child_columns"]
-
-    def can_provide(self, column_name):
-        return column_name == self.name
-
-    def provide(self, data, column_name):
-        foreign_column_name = self.config("foreign_column_name")
-        id_column_name = self.config("parent_id_column_name")
-        return self.child_models.where(f"{foreign_column_name}={data[id_column_name]}")
-
-    def to_json(self, model):
-        children = []
-        columns = self.get_child_columns()
-        for child in model.__getattr__(self.name):
-            json = OrderedDict()
-            child_id_column_name = child.id_column_name
-            json = {
-                **json,
-                **columns[child_id_column_name].to_json(child),
-            }
-            for column_name in self.config("readable_child_columns"):
-                json = {
-                    **json,
-                    **columns[column_name].to_json(child),
-                }
-            children.append(json)
-        return {self.name: children}
-
-    @property
-    def child_models(self):
-        return self.di.build(self.config("child_models_class"), cache=True)
-
-    def documentation(self, name=None, example=None, value=None):
-        columns = self.get_child_columns()
-        child_id_column_name = self.child_models.get_id_column_name()
-        child_properties = [columns[child_id_column_name].documentation()]
-
-        for column_name in self.config("readable_child_columns"):
-            child_docs = columns[column_name].documentation()
-            if type(child_docs) != list:
-                child_docs = [child_docs]
-            child_properties.extend(child_docs)
-
-        child_object = AutoDocObject(
-            self.camel_to_nice(self.child_models.model_class().__name__),
-            child_properties,
-        )
-        return AutoDocArray(name if name is not None else self.name, child_object, value=value)

clearskies/column_types/integer.py

@@ -1,41 +0,0 @@
-from .column import Column
-from ..autodoc.schema import Integer as AutoDocInteger
-
-
-class Integer(Column):
-    _auto_doc_class = AutoDocInteger
-
-    def __init__(self, di):
-        super().__init__(di)
-
-    def to_backend(self, data):
-        if self.name not in data or data[self.name] is None:
-            return data
-
-        return {
-            **data,
-            self.name: int(data[self.name]),
-        }
-
-    def from_backend(self, value):
-        return int(value)
-
-    def input_error_for_value(self, value, operator=None):
-        if operator == "in":
-            if type(value) != list:
-                return f'{self.name} must be an integer when searching with the "IN" operator'
-            for val in value:
-                if type(val) != int:
-                    return f"All items in {self.name} must be integers"
-            return ""
-        return f"{self.name} must be an integer" if type(value) != int else ""
-
-    def build_condition(self, value, operator=None, column_prefix=""):
-        if operator == "in":
-            return f"{column_prefix}{self.name} IN (" + ",".join([str(val) for val in value]) + ")"
-        if not operator:
-            operator = "="
-        return f"{column_prefix}{self.name}{operator}{value}"
-
-    def is_allowed_operator(self, operator, relationship_reference=None):
-        return operator in ["=", "<", ">", "<=", ">=", "in"]

clearskies/column_types/json.py

@@ -1,25 +0,0 @@
-import json
-from .column import Column
-
-
-class JSON(Column):
-    def __init__(self, di):
-        super().__init__(di)
-
-    def from_backend(self, value):
-        if type(value) == list or type(value) == dict:
-            return value
-        if not value:
-            return None
-        try:
-            return json.loads(value)
-        except json.JSONDecodeError:
-            return None
-
-    def to_backend(self, data):
-        if self.name in data:
-            data[self.name] = json.dumps(data[self.name]) if data[self.name] else ""
-        return data
-
-    def to_json(self, model):
-        return {self.name: model.get(self.name, silent=True)}