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

clearskies/column_types/many_to_many_with_data.py

@@ -1,162 +0,0 @@
-from .many_to_many import ManyToMany
-
-
-class ManyToManyWithData(ManyToMany):
-    """
-    Controls a many-to-many relationship where additional data is stored in the pivot table.
-    """
-
-    required_configs = [
-        "pivot_models_class",
-        "related_models_class",
-    ]
-
-    my_configs = [
-        "foreign_column_name_in_pivot",
-        "own_column_name_in_pivot",
-        "pivot_table",
-        "readable_related_columns",
-        "is_readable",
-        "setable_columns",
-        "persist_unique_lookup_column_to_pivot_table",
-    ]
-
-    def __init__(self, di):
-        super().__init__(di)
-
-    @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 _check_configuration(self, configuration):
-        super()._check_configuration(configuration)
-        setable_columns = configuration.get("setable_columns")
-        if setable_columns is None:
-            return
-        pivot_columns = self.di.build(configuration["pivot_models_class"], cache=True).raw_columns_configuration()
-        if not hasattr(setable_columns, "__iter__"):
-            raise ValueError(
-                f"{error_prefix} 'setable_columns' should be None or an iterable "
-                + "with the list of pivot columns that can be set."
-            )
-        if isinstance(setable_columns, str):
-            raise ValueError(
-                f"{error_prefix} 'setable_columns' should be None or an iterable "
-                + "with the list of pivot columns that can be set."
-            )
-        for column_name in setable_columns:
-            if column_name not in pivot_columns:
-                raise ValueError(
-                    f"{error_prefix} 'setable_columns' references column named '{column_name}' but this"
-                    + "column does not exist in the pivot model class."
-                )
-
-    def _finalize_configuration(self, configuration):
-        configuration = super()._finalize_configuration(configuration)
-        if "persist_unique_lookup_column_to_pivot_table" not in configuration:
-            configuration["persist_unique_lookup_column_to_pivot_table"] = False
-        return configuration
-
-    def post_save(self, data, model, id):
-        # if our incoming data is not in the data array or is None, then nothing has been set and we do not want
-        # to make any changes
-        if self.name not in data or data[self.name] is None:
-            return data
-
-        # figure out what ids need to be created or deleted from the pivot table.
-        if not model.exists:
-            old_ids = set()
-        else:
-            old_ids = set(getattr(model, f"{self.name}_ids"))
-
-        # this is trickier for many-to-many-with-data compared to many-to-many.  We're generally
-        # expecting data[self.name] to be a list of dictionaries.  For each entry, we need to find
-        # the corresponding entry in the pivot table to decide if we need to delete, create, or update.
-        # However, since we have a dictionary there are a variety of ways that we can connect to
-        # an entry in the related table - either related id or any unique column from the related
-        # table.  Technically we might also specify a pivot id, but we're generally trying to be
-        # transparent to those, so let's ignore that one.
-
-        # unfortunately I'm using related_models and foreign_models interchangeably - this is likely
-        # an accident due to the slow inheritence from he belongs to class, to the many to many class,
-        # and now this.  Keep in mind that "foreign" and "related" refer to the same thing
-        foreign_column_name_in_pivot = self.config("foreign_column_name_in_pivot")
-        own_column_name_in_pivot = self.config("own_column_name_in_pivot")
-        unique_foreign_columns = {
-            column.name: column.name for column in self.related_columns.values() if column.is_unique
-        }
-        related_models = self.related_models
-        pivot_models = self.pivot_models
-        new_ids = set()
-        for pivot_record in data[self.name]:
-            # first we need to identify which foreign column this belongs to.
-            foreign_column_id = None
-            # if they provide the foreign column id in the pivot data then we're good
-            if foreign_column_name_in_pivot in pivot_record:
-                foreign_column_id = pivot_record[foreign_column_name_in_pivot]
-            elif len(unique_foreign_columns):
-                for pivot_column, pivot_value in pivot_record.items():
-                    if pivot_column not in unique_foreign_columns:
-                        continue
-                    foreign_model = related_models.find(f"{pivot_column}={pivot_value}")
-                    foreign_column_id = foreign_model.id
-                    if foreign_column_id:
-                        # remove this column from the data - it was used to lookup the right
-                        # record, but mostly won't exist in the model, unless we've been instructed
-                        # to keep it
-                        if not self.config("persist_unique_lookup_column_to_pivot_table"):
-                            del pivot_record[pivot_column]
-                        break
-            if not foreign_column_id:
-                column_list = "'" + "', '".join([column for column in unique_foreign_columns.key()]) + "'"
-                raise ValueError(
-                    f"Missing data for {self.name}: Unable to match foreign record for a record in the many-to-many relationship: you must provide either '{foreign_column_name_in_pivot}' with the id column for the foreign table, or a value from one of the unique columns: {column_list}"
-                )
-            pivot_model = (
-                pivot_models.where(f"{foreign_column_name_in_pivot}={foreign_column_id}")
-                .where(f"{own_column_name_in_pivot}={id}")
-                .first()
-            )
-            new_ids.add(foreign_column_id)
-            # this will either update or create accordingly
-            pivot_model.save(
-                {
-                    **pivot_record,
-                    foreign_column_name_in_pivot: foreign_column_id,
-                    own_column_name_in_pivot: id,
-                }
-            )
-
-        # the above took care of isnerting and updating active records.  Now we need to delete
-        # records that are no longer needed.
-        to_delete = old_ids - new_ids
-        if to_delete:
-            pivot_models = self.pivot_models
-            foreign_column_name = self.config("foreign_column_name_in_pivot")
-            for model_to_delete in pivot_models.where(
-                f"{foreign_column_name} IN (" + ",".join(map(str, to_delete)) + ")"
-            ):
-                model_to_delete.delete()
-
-        return data
-
-    def can_provide(self, column_name):
-        if column_name == self.name:
-            return True
-        if column_name == f"{self.name}_ids":
-            return True
-        if column_name == f"{self.name}_pivots":
-            return True
-
-    def provide(self, data, column_name):
-        # the base class handles most of this: returning the list of matching
-        # ids or returning the list of related models
-        if column_name == self.name or column_name == f"{self.name}_ids":
-            return super().provide(data, column_name)
-
-        # so if we get here then we need to provide the pivot models for this record
-        own_column_name_in_pivot = self.config("own_column_name_in_pivot")
-        my_id = data[self.config("own_id_column_name")]
-        return [model for model in self.pivot_models.where(f"{own_column_name_in_pivot}={my_id}")]

clearskies/column_types/phone.py

@@ -1,48 +0,0 @@
-from .string import String
-import re
-
-
-class Phone(String):
-    my_configs = [
-        "usa_only",
-    ]
-
-    def __init__(self, di):
-        super().__init__(di)
-
-    def to_backend(self, data):
-        if self.name not in data:
-            return data
-
-        # phone numbers are stored as only digits.
-        return {**data, **{self.name: re.sub(r"\D", "", data[self.name])}}
-
-    def input_error_for_value(self, value, operator=None):
-        if type(value) != str:
-            return f"Value must be a string for {self.name}"
-
-        # we'll allow spaces, dashes, parenthesis, dashes, and plus signs.
-        # if there is anything else then it's not a valid phone number.
-        # However, we don't do more detailed validation, because I'm too lazy to
-        # figure out what is and is not a valid phone number, especially when
-        # you get to the world of international numbers.
-        if re.search(r"[^\d \-()+]", value):
-            return "Invalid phone number"
-
-        # for some final validation (especially US numbers) work only with the digits.
-        value = re.sub(r"\D", "", value)
-
-        if len(value) > 15:
-            return "Invalid phone number"
-
-        # we can't be too short unless we're doing a fuzzy search
-        if len(value) < 10 and operator and operator.lower() != "like":
-            return "Invalid phone number"
-
-        if self.config("usa_only", silent=True):
-            if len(value) > 11:
-                return "Invalid phone number"
-            if value[0] == "1" and len(value) != 11:
-                return "Invalid phone number"
-
-        return ""

clearskies/column_types/select.py

@@ -1,11 +0,0 @@
-from .string import String
-
-
-class Select(String):
-    required_configs = ["values"]
-
-    def __init__(self, di):
-        super().__init__(di)
-
-    def input_error_for_value(self, value, operator=None):
-        return f"Invalid value for {self.name}" if value not in self.config("values") else ""

clearskies/column_types/string.py

@@ -1,24 +0,0 @@
-from .column import Column
-
-
-class String(Column):
-    def __init__(self, di):
-        super().__init__(di)
-
-    def build_condition(self, value, operator=None, column_prefix=""):
-        if not operator:
-            operator = "="
-        if operator.lower() == "like":
-            return f"{column_prefix}{self.name} LIKE '%{value}%'"
-        return f"{column_prefix}{self.name}{operator}{value}"
-
-    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
-        """
-        if operator in ["=", "<", ">", "<=", ">=", "in"]:
-            return True
-        return operator.lower() == "like"
-
-    def input_error_for_value(self, value, operator=None):
-        return "value should be a string" if type(value) != str else ""

clearskies/column_types/timestamp.py

@@ -1,73 +0,0 @@
-import time
-from .datetime import DateTime
-from datetime import datetime, timezone
-import dateparser
-from ..autodoc.schema import DateTime as AutoDocDateTime
-
-
-class Timestamp(DateTime):
-    my_configs = [
-        "date_format",
-        "milliseconds",
-    ]
-
-    def _finalize_configuration(self, configuration):
-        return {
-            **{
-                "date_format": self._date_format,
-                "milliseconds": False,
-            },
-            **super()._finalize_configuration(configuration),
-        }
-
-    def from_backend(self, value):
-        mult = 1000 if self.config("milliseconds") else 1
-        if not value:
-            date = None
-        elif isinstance(value, str):
-            if not value.isdigit():
-                raise ValueError(
-                    f"Invalid data was found in the backend for model {self.model_class.__name__} and column {self.name}: a string value was found that is not a timestamp.  It was '{value}'"
-                )
-            date = datetime.fromtimestamp(int(value) / mult, self._timezone)
-        elif isinstance(value, int):
-            date = datetime.fromtimestamp(value / mult, self._timezone)
-        else:
-            if not isinstance(value, datetime):
-                raise ValueError(
-                    f"Invalid data was found in the backend for model {self.model_class.__name__} and column {self.name}: the value was neither an integer, a string, nor a datetime object"
-                )
-            date = value
-        return date.replace(tzinfo=self._timezone) if date else None
-
-    def to_backend(self, data):
-        if not self.name in data or isinstance(data[self.name], int) or data[self.name] == None:
-            return data
-
-        value = data[self.name]
-        if isinstance(value, str):
-            if not value.isdigit():
-                raise ValueError(
-                    f"Invalid data was sent to the backend for model {self.model_class.__name__} and column {self.name}: a string value was found that is not a timestamp. It was '{value}'"
-                )
-            value = int(value)
-        elif isinstance(value, datetime):
-            value = value.timestamp()
-        else:
-            raise ValueError(
-                f"Invalid data was sent to the backend for model {self.model_class.__name__} and column {self.name}: the value was neither an integer, a string, nor a datetime object"
-            )
-
-        # hopefully this is a Python datetime object in UTC timezone...
-        return {**data, **{self.name: value}}
-
-    def input_error_for_value(self, value, operator=None):
-        if not isinstance(value, int):
-            return f"'{self.name}' must be an integer"
-        return ""
-
-    def values_match(self, value_1, value_2):
-        """
-        Compares two values to see if they are the same
-        """
-        return value_1 == value_2

clearskies/column_types/updated.py

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

clearskies/column_types/updated_micro.py

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

clearskies/column_types/uuid.py

@@ -1,25 +0,0 @@
-from .string import String
-
-
-class UUID(String):
-    def __init__(self, di, uuid):
-        super().__init__(di)
-        self.uuid = uuid
-
-    @property
-    def is_writeable(self):
-        return False
-
-    def build_condition(self, value, operator=None, column_prefix=""):
-        return f"{column_prefix}{self.name}={value}"
-
-    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 == "="
-
-    def pre_save(self, data, model):
-        if model.exists:
-            return data
-        return {**data, self.name: str(self.uuid.uuid4())}

clearskies/columns.py

@@ -1,123 +0,0 @@
-from collections import OrderedDict
-from collections.abc import Sequence
-import inspect
-from .binding_config import BindingConfig
-
-
-class Columns:
-    def __init__(self, di):
-        self.di = di
-
-    def configure(self, definitions, model_class, overrides=None):
-        columns = OrderedDict()
-        for name, configuration in definitions.items():
-            name = name.strip()
-            if not name:
-                raise ValueError(f"Missing name for column in '{model_class.__name__}'")
-            if name in columns:
-                raise ValueError(f"Duplicate column '{name}' found for model '{model_class.__name__}'")
-            column_overrides = overrides[name] if (overrides is not None and name in overrides) else {}
-            # if the overrides changes the class then we need to completely replace the column definition
-            # with what is in the overrides.
-            if "class" in column_overrides and id(column_overrides["class"]) != id(configuration["class"]):
-                configuration = column_overrides
-            else:
-                configuration = {
-                    **configuration,
-                    **column_overrides,
-                    "input_requirements": self._resolve_input_requirements(
-                        self._merge_input_requirements(
-                            configuration.get("input_requirements"),
-                            column_overrides.get("input_requirements"),
-                        ),
-                        name,
-                        model_class.__name__,
-                    ),
-                }
-            columns[name] = self.build_column(name, configuration, model_class)
-
-        # overrides can add columns too - need to handle those separately
-        if overrides is not None:
-            for name, configuration in overrides.items():
-                if name in columns:
-                    continue
-                configuration["input_requirements"] = (
-                    self._resolve_input_requirements(configuration["input_requirements"], name, model_class.__name__)
-                    if "input_requirements" in configuration
-                    else []
-                )
-                columns[name] = self.build_column(name, configuration, model_class)
-
-        return columns
-
-    def build_column(self, name, configuration, model_class):
-        if not "class" in configuration:
-            raise ValueError(f"Missing column class for column {name} in {model_class.__name__}")
-        column = self.di.build(configuration["class"], cache=False)
-        column.configure(name, configuration, model_class)
-        return column
-
-    def _merge_input_requirements(self, config_requirements, override_requirements):
-        if config_requirements is None and override_requirements is None:
-            return []
-        if config_requirements is None:
-            return override_requirements
-        if override_requirements is None:
-            return config_requirements
-
-        # if we have more than one of the same class then use the one from the overrides
-        requirements = []
-        used_classes = {}
-        for requirement in override_requirements:
-            requirements.append(requirement)
-            [requirement_class, args, kwargs] = self._input_requirement_args_and_class(requirement)
-            used_classes[requirement_class.__name__] = True
-        for requirement in config_requirements:
-            [requirement_class, args, kwargs] = self._input_requirement_args_and_class(requirement)
-            if requirement_class.__name__ in used_classes:
-                continue
-            requirements.append(requirement)
-            used_classes[requirement_class.__name__] = True
-
-        return requirements
-
-    def _input_requirement_args_and_class(self, requirement):
-        """
-        This takes the input requirement data provided by the developer and returns the things we need to build it.
-
-        An input requirement can be:
-
-         1. An InputRequirement class (aka `Required`)
-         2. A tuple with the class and then configuration parameters for the class (aka `(MaxLength, 255)`)
-         3. A BindingConfig
-
-        This normalizes these three options and returns a list with `[Class, [args], {kwargs}]` for building
-        """
-        if inspect.isclass(requirement):
-            return [requirement, [], {}]
-        elif isinstance(requirement, BindingConfig):
-            return [requirement.object_class, requirement.args, requirement.kwargs]
-        elif isinstance(requirement, Sequence) and type(requirement) != str:
-            if not inspect.isclass(requirement[0]):
-                raise ValueError(
-                    f"{error_prefix} incorrect value for input_requirement. First element should "
-                    + f"be the Requirement class, but instead {type(requirement[0])} was found"
-                )
-            return [requirement[0], requirement[1:], {}]
-        else:
-            raise ValueError("Unrecognized value for input_requirement")
-
-    def _resolve_input_requirements(self, input_requirements, column_name, model_class_name):
-        error_prefix = f"Configuration error for column '{column_name}' in model '{model_class_name}':"
-        if not hasattr(input_requirements, "__iter__"):
-            raise ValueError(
-                f"{error_prefix} 'input_requirements' should be an iterable but is {type(input_requirements)}"
-            )
-        resolved_requirements = []
-        for requirement in input_requirements:
-            [requirement_class, args, kwargs] = self._input_requirement_args_and_class(requirement)
-            requirement_instance = self.di.build(requirement_class, cache=False)
-            requirement_instance.column_name = column_name
-            requirement_instance.configure(*args, **kwargs)
-            resolved_requirements.append(requirement_instance)
-        return resolved_requirements