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

clearskies/column_types/__init__.py

@@ -1,184 +0,0 @@
-from .audit import Audit
-from .belongs_to import BelongsTo
-from .boolean import Boolean
-from .category_tree import CategoryTree
-from .column import Column
-from .created import Created
-from .created_by_authorization_data import CreatedByAuthorizationData
-from .created_by_header import CreatedByHeader
-from .created_by_ip import CreatedByIp
-from .created_by_routing_data import CreatedByRoutingData
-from .created_by_user_agent import CreatedByUserAgent
-from .created_micro import CreatedMicro
-from .datetime import DateTime
-from .datetime_micro import DateTimeMicro
-from .email import Email
-from .float import Float
-from .has_many import HasMany
-from .integer import Integer
-from .json import JSON
-from .many_to_many import ManyToMany
-from .many_to_many_with_data import ManyToManyWithData
-from .select import Select
-from .string import String
-from .updated import Updated
-from .updated_micro import UpdatedMicro
-from .uuid import UUID
-
-
-def build_column_config(name, column_class, **kwargs):
-    return (name, {**{"class": column_class}, **kwargs})
-
-
-def audit(name, **kwargs):
-    return build_column_config(name, Audit, **kwargs)
-
-
-def belongs_to(name, **kwargs):
-    return build_column_config(name, BelongsTo, **kwargs)
-
-
-def boolean(name, **kwargs):
-    return build_column_config(name, Boolean, **kwargs)
-
-
-def category_tree(name, **kwargs):
-    return build_column_config(name, CategoryTree, **kwargs)
-
-
-def created(name, **kwargs):
-    return build_column_config(name, Created, **kwargs)
-
-
-def created_by_authorization_data(name, **kwargs):
-    return build_column_config(name, CreatedByAuthorizationData, **kwargs)
-
-
-def created_by_header(name, **kwargs):
-    return build_column_config(name, CreatedByHeader, **kwargs)
-
-
-def created_by_ip(name, **kwargs):
-    return build_column_config(name, CreatedByIp, **kwargs)
-
-
-def created_by_routing_data(name, **kwargs):
-    return build_column_config(name, CreatedByRoutingData, **kwargs)
-
-
-def created_by_user_agent(name, **kwargs):
-    return build_column_config(name, CreatedByUserAgent, **kwargs)
-
-
-def created_micro(name, **kwargs):
-    return build_column_config(name, CreatedMicro, **kwargs)
-
-
-def datetime(name, **kwargs):
-    return build_column_config(name, DateTime, **kwargs)
-
-
-def datetime_micro(name, **kwargs):
-    return build_column_config(name, DateTimeMicro, **kwargs)
-
-
-def email(name, **kwargs):
-    return build_column_config(name, Email, **kwargs)
-
-
-def float(name, **kwargs):
-    return build_column_config(name, Float, **kwargs)
-
-
-def has_many(name, **kwargs):
-    return build_column_config(name, HasMany, **kwargs)
-
-
-def integer(name, **kwargs):
-    return build_column_config(name, Integer, **kwargs)
-
-
-def json(name, **kwargs):
-    return build_column_config(name, JSON, **kwargs)
-
-
-def many_to_many(name, **kwargs):
-    return build_column_config(name, ManyToMany, **kwargs)
-
-
-def many_to_many_with_data(name, **kwargs):
-    return build_column_config(name, ManyToManyWithData, **kwargs)
-
-
-def select(name, **kwargs):
-    return build_column_config(name, Select, **kwargs)
-
-
-def string(name, **kwargs):
-    return build_column_config(name, String, **kwargs)
-
-
-def updated(name, **kwargs):
-    return build_column_config(name, Updated, **kwargs)
-
-
-def updated_micro(name, **kwargs):
-    return build_column_config(name, UpdatedMicro, **kwargs)
-
-
-def uuid(name, **kwargs):
-    return build_column_config(name, UUID, **kwargs)
-
-
-__all__ = [
-    "build_column_config",
-    "audit",
-    "Audit",
-    "belongs_to",
-    "BelongsTo",
-    "boolean",
-    "Boolean",
-    "category_tree",
-    "CategoryTree",
-    "Column",
-    "created",
-    "created_micro",
-    "Created",
-    "CreatdMicro",
-    "created_by_authorization_data",
-    "CreatedByAuthorizationData",
-    "created_by_ip",
-    "CreatedByIp",
-    "created_by_user_agent",
-    "CreatedByUserAgent",
-    "CreatedMicro",
-    "created_micro",
-    "datetime",
-    "datetime_micro",
-    "DateTime",
-    "DateTimeMicro",
-    "email",
-    "Email",
-    "float",
-    "Float",
-    "has_many",
-    "HasMany",
-    "integer",
-    "Integer",
-    "json",
-    "JSON",
-    "many_to_many",
-    "ManyToMany",
-    "many_to_many_with_data",
-    "ManyToManyWithData",
-    "select",
-    "Select",
-    "string",
-    "String",
-    "updated",
-    "updated_micro",
-    "Updated",
-    "UpdatedMicro",
-    "uuid",
-    "UUID",
-]

clearskies/column_types/audit.py

@@ -1,235 +0,0 @@
-from . import string, has_many
-from clearskies.functional.string import title_case_to_snake_case
-
-
-class Audit(has_many.HasMany):
-    """
-    Enables auditing for a model.
-
-    Specif the audit class to use and attach this to your model. Everytime the model is created/updated/deleted,
-    the audit class will record the action and the changes.  Your audit model must have the following columns:
-
-    | Name        | type     |
-    |-------------|----------|
-    | class       | str      |
-    | resource_id | str      |
-    | action      | str      |
-    | data        | json     |
-    | created_at  | created  |
-
-    The names are not currently adjustable.
-
-     1. Class is a string that records the name of the class that the action happened for.  This allows you to use
-        the same audit class for multiple, different, resources.
-     2. resource_id is the id of the record which the audit entry is for.
-     3. Action is the actual action taken (create/update/delete)
-     4. Data is a serialized record of what columns in the record were changed (both their previous and new values)
-     5. The time the audit record was created
-
-    With `exclude_columns` you can specify some names of columns to ignore.  If an update happens and only columns
-    in `exclude_columns` are being set, then a history entry will not be created.  Also, these columns will
-    not be included in the audit record.
-
-    With `mask_columns` you can specify the names of columns which should be noted as updated in the audit record,
-    but the actual values (before and after) should not be recorded.
-    """
-
-    _parent_columns = None
-
-    required_configs = [
-        "audit_models_class",
-    ]
-
-    my_configs = [
-        "child_models_class",
-        "exclude_columns",
-        "mask_columns",
-        "foreign_column_name",
-        "is_readable",
-        "readable_child_columns",
-        "parent_class_name",
-        "parent_id_column_name",
-    ]
-
-    def __init__(self, di):
-        super().__init__(di)
-
-    def configure(self, name, configuration, model_class):
-        if "audit_models_class" not in configuration:
-            raise KeyError(
-                "Missing required configuration value 'audit_models_class' for column '{name}' in model class "
-                + f"'{model_class.__name__}'"
-            )
-        self.validate_models_class(configuration["audit_models_class"])
-        has_many_configuration = {
-            **configuration,
-            "child_models_class": configuration.get("audit_models_class"),
-            "foreign_column_name": "resource_id",
-            "is_readable": True,
-            "readable_child_columns": ["resource_id", "action", "data", "created_at"],
-            "parent_class_name": model_class.__name__,
-            "exclude_columns": configuration.get("exclude_columns", []),
-            "mask_columns": configuration.get("mask_columns", []),
-        }
-        super().configure(name, has_many_configuration, model_class)
-
-    def _check_configuration(self, configuration):
-        super()._check_configuration(configuration)
-        error_prefix = f"Configuration error for '{self.name}' in '{self.model_class.__name__}':"
-        audit_columns = self.di.build(configuration["audit_models_class"], cache=True).raw_columns_configuration()
-        parent_columns = self.di.build(self.model_class, cache=True).raw_columns_configuration()
-        required_audit_columns = {
-            "class": string.String,
-            "resource_id": True,
-            "action": string.String,
-            "data": True,
-            "created_at": True,
-        }
-        for column_name, column_type in required_audit_columns.items():
-            if column_name not in audit_columns:
-                raise ValueError(f"{error_prefix} audit models class does not have the required column '{column_name}'")
-            if column_type == True:
-                continue
-            if audit_columns[column_name]["class"] != column_type:
-                raise ValueError(
-                    f"{error_prefix} the '{column_name}' column in the audit models class should have a type of "
-                    + column_type.__name__
-                    + " but it has something else"
-                )
-
-        for config_name in ["exclude_columns", "mask_columns"]:
-            if config_name not in configuration:
-                continue
-
-            config_columns = configuration[config_name]
-            if not hasattr(config_columns, "__iter__"):
-                raise ValueError(f"{error_prefix} '{config_name}' should be an iterable with the list of column names.")
-            if isinstance(config_columns, str):
-                raise ValueError(
-                    f"{error_prefix} '{config_name}' should be an iterable " + "with a list of column names."
-                )
-            for column_name in config_columns:
-                if column_name not in parent_columns:
-                    raise ValueError(
-                        f"{error_prefix} '{config_name}' references column named '{column_name}' but this"
-                        + " column does not exist in the original model class."
-                    )
-
-    def provide(self, data, column_name):
-        return super().provide(data, column_name).where("class=" + self.config("parent_class_name"))
-
-    def save_finished(self, model):
-        super().save_finished(model)
-        old_data = model._previous_data
-        new_data = model._data
-        exclude_columns = self.config("exclude_columns")
-        mask_columns = self.config("mask_columns")
-        parent_columns = self.parent_columns
-
-        if not old_data:
-            create_data = {}
-            for key in new_data.keys():
-                if key in exclude_columns:
-                    continue
-                create_data = {
-                    **create_data,
-                    **parent_columns[key].to_json(model),
-                }
-                if key in mask_columns and key in create_data:
-                    create_data[key] = "****"
-            self.record(model, "create", data=create_data)
-            return
-
-        # note that this is fairly simple logic to get started.  It's not going to detect changes that happen
-        # in other "tables".  For instance, disconnecting a record by deleting an entry in a many-to-many relationship
-        # won't be picked up by this.
-        old_model = model.empty_model()
-        old_model.data = old_data
-        from_data = {}
-        to_data = {}
-        for column, new_value in new_data.items():
-            if column in exclude_columns or column not in old_data:
-                continue
-            if old_data[column] == new_value:
-                continue
-            from_data = {
-                **from_data,
-                **parent_columns[column].to_json(old_model),
-            }
-            to_data = {
-                **to_data,
-                **parent_columns[column].to_json(model),
-            }
-            if column in mask_columns and column in to_data:
-                to_data[column] = "****"
-                from_data[column] = "****"
-        if not from_data and not to_data:
-            return
-
-        self.record(
-            model,
-            "update",
-            data={
-                "from": from_data,
-                "to": to_data,
-            },
-        )
-
-    def post_delete(self, model):
-        super().post_delete(model)
-        exclude_columns = self.config("exclude_columns")
-        parent_columns = self.parent_columns
-        mask_columns = self.config("mask_columns")
-
-        final_data = {}
-        for key in model._data.keys():
-            if key in exclude_columns:
-                continue
-            final_data = {
-                **final_data,
-                **parent_columns[key].to_json(model),
-            }
-
-        for key in mask_columns:
-            if key not in final_data:
-                continue
-            final_data[key] = "****"
-
-        self.child_models.create(
-            {
-                "class": self.config("parent_class_name"),
-                "resource_id": model.get(self.config("parent_id_column_name")),
-                "action": "delete",
-                "data": final_data,
-            }
-        )
-
-    @property
-    def parent_columns(self):
-        if self._parent_columns == None:
-            self._parent_columns = self.di.build(self.model_class, cache=True).columns()
-        return self._parent_columns
-
-    def record(self, model, action, data=None, record_data=None):
-        audit_data = {
-            "class": self.config("parent_class_name"),
-            "resource_id": model.get(self.config("parent_id_column_name")),
-            "action": action,
-        }
-        if data is not None:
-            audit_data["data"] = data
-        if record_data is not None:
-            audit_data = {
-                **audit_data,
-                **record_data,
-            }
-
-        self.child_models.create(audit_data)
-
-
-def build_column_config(name, column_class, **kwargs):
-    return (name, {**{"class": column_class}, **kwargs})
-
-
-def audit(name, **kwargs):
-    return build_column_config(name, Audit, **kwargs)

clearskies/column_types/belongs_to.py

@@ -1,250 +0,0 @@
-import re
-from .string import String
-from ..autodoc.schema import Array as AutoDocArray
-from ..autodoc.schema import Object as AutoDocObject
-from ..autodoc.schema import String as AutoDocString
-from collections import OrderedDict
-
-
-class BelongsTo(String):
-    """
-    Controls a belongs to relationship.
-
-    This column should be named something like 'parent_id', e.g. user_id, column_id, etc...  It expects the actual
-    database column to be an integer.  It also provides an additional property on the model which returns the
-    related model, instead of the id, with a name given by dropping `_id` from the column name.  In other words,
-    if you have a column called user_id and a particular model has a user_id of 5, then:
-
-    ```
-    print(model.user_id)
-    # prints 5
-    print(model.user.id)
-    # prints 5
-    print(model.user.name)
-    # prints the name of the user with an id of 5.
-    ```
-    """
-
-    wants_n_plus_one = True
-    required_configs = [
-        "parent_models_class",
-    ]
-
-    my_configs = [
-        "model_column_name",
-        "readable_parent_columns",
-        "join_type",
-    ]
-
-    def __init__(self, di):
-        super().__init__(di)
-
-    def _check_configuration(self, configuration):
-        super()._check_configuration(configuration)
-        self.validate_models_class(configuration["parent_models_class"])
-
-        if not configuration.get("model_column_name") and self.name[-3:] != "_id":
-            raise ValueError(
-                f"Invalid name for column '{self.name}' in '{self.model_class.__name__}' - "
-                + "BelongsTo column names must end in '_id', or you must set 'model_column_name' to specify the name of the column "
-                + "that the parent model can be fetched from."
-            )
-        if configuration.get("model_column_name") and type(configuration.get("model_column_name")) != str:
-            raise ValueError(
-                f"Configuration error for '{self.name}' in '{self.model_class.__name__}': 'model_column_name' must be a string."
-            )
-
-        join_type = configuration.get("join_type")
-        if join_type and join_type.upper() not in ["LEFT", "INNER"]:
-            raise ValueError(
-                f"Configuration error for '{self.name}' in '{self.model_class.__name__}': join_type must be INNER or LEFT"
-            )
-
-        if configuration.get("readable_parent_columns"):
-            parent_columns = self.di.build(configuration["parent_models_class"], cache=True).raw_columns_configuration()
-            error_prefix = f"Configuration error for '{self.name}' in '{self.model_class.__name__}':"
-            readable_parent_columns = configuration["readable_parent_columns"]
-            if not hasattr(readable_parent_columns, "__iter__"):
-                raise ValueError(
-                    f"{error_prefix} 'readable_parent_columns' should be an iterable "
-                    + "with the list of child columns to output."
-                )
-            if isinstance(readable_parent_columns, str):
-                raise ValueError(
-                    f"{error_prefix} 'readable_parent_columns' should be an iterable "
-                    + "with the list of child columns to output."
-                )
-            for column_name in readable_parent_columns:
-                if column_name not in parent_columns:
-                    raise ValueError(
-                        f"{error_prefix} 'readable_parent_columns' references column named '{column_name}' but this"
-                        + "column does not exist in the model class."
-                    )
-
-    def _finalize_configuration(self, configuration):
-        return {
-            **super()._finalize_configuration(configuration),
-            **{
-                "model_column_name": configuration.get("model_column_name")
-                if configuration.get("model_column_name")
-                else self.name[:-3],
-                "join_type": configuration.get("join_type", "INNER").upper(),
-            },
-        }
-
-    def input_error_for_value(self, value, operator=None):
-        integer_check = super().input_error_for_value(value)
-        if integer_check:
-            return integer_check
-        parent_models = self.parent_models
-        id_column_name = parent_models.get_id_column_name()
-        matching_parents = parent_models.where(f"{id_column_name}={value}")
-        input_output = self.di.build("input_output", cache=True)
-        matching_parents = matching_parents.where_for_request(
-            matching_parents,
-            input_output.routing_data(),
-            input_output.get_authorization_data(),
-            input_output,
-        )
-        if not len(matching_parents):
-            return f"Invalid selection for {self.name}: record does not exist"
-        return ""
-
-    def can_provide(self, column_name):
-        return column_name == self.config("model_column_name")
-
-    def provide(self, data, column_name):
-        # did we have data parent data loaded up with a query?
-        alias = self.join_table_alias()
-        parent_id_column_name = self.parent_models.get_id_column_name()
-        if f"{alias}_{parent_id_column_name}" in data:
-            parent_data = {parent_id_column_name: data[f"{alias}_{parent_id_column_name}"]}
-            for column_name in self.parent_columns.keys():
-                select_alias = f"{alias}_{column_name}"
-                parent_data[column_name] = data[select_alias] if select_alias in data else None
-            return self.parent_models.model(parent_data)
-
-        # if not, just look it up from the id
-        parent_id = data.get(self.name)
-        if parent_id:
-            parent_id_column_name = self.parent_models.get_id_column_name()
-            return self.parent_models.where(f"{parent_id_column_name}={parent_id}").first()
-        return self.parent_models.empty_model()
-
-    def join_table_alias(self):
-        return self.parent_models.table_name() + "_" + self.name
-
-    def configure_n_plus_one(self, models, columns=None):
-        if columns is None:
-            columns = self.config("readable_parent_columns", silent=True)
-        if not columns:
-            return models
-
-        models = self.add_join(models)
-        alias = self.join_table_alias()
-        parent_id_column_name = self.parent_models.get_id_column_name()
-        select_parts = [f"{alias}.{column_name} AS {alias}_{column_name}" for column_name in columns]
-        select_parts.append(f"{alias}.{parent_id_column_name} AS {alias}_{parent_id_column_name}")
-        return models.select(", ".join(select_parts))
-
-    @property
-    def parent_models(self):
-        return self.di.build(self.config("parent_models_class"), cache=True)
-
-    @property
-    def parent_columns(self):
-        return self.parent_models.model_columns
-
-    def to_json(self, model):
-        # if we don't have readable parent columns specified, then just return the id
-        if not self.config("readable_parent_columns", silent=True):
-            return super().to_json(model)
-
-        # otherwise return an object with the readable parent columns
-        columns = self.parent_columns
-        parent = model.__getattr__(self.config("model_column_name"))
-        json = OrderedDict()
-        if parent.id_column_name not in self.config("readable_parent_columns"):
-            json[parent.id_column_name] = list(columns[parent.id_column_name].to_json(parent).values())[0]
-        for column_name in self.config("readable_parent_columns"):
-            json = {**json, **columns[column_name].to_json(parent)}
-        id_less_name = self.config("model_column_name")
-        return {
-            **super().to_json(model),
-            id_less_name: json,
-        }
-
-    def documentation(self, name=None, example=None, value=None):
-        columns = self.parent_columns
-        parent_id_column_name = self.parent_models.get_id_column_name()
-        parent_properties = [columns[parent_id_column_name].documentation()]
-
-        parent_columns = self.config("readable_parent_columns", silent=True)
-        parent_id_doc = AutoDocString(name if name is not None else self.name)
-        if not parent_columns:
-            return parent_id_doc
-
-        for column_name in self.config("readable_parent_columns"):
-            if column_name == parent_id_column_name:
-                continue
-            parent_properties.append(columns[column_name].documentation())
-
-        return [
-            parent_id_doc,
-            AutoDocObject(
-                self.config("model_column_name"),
-                parent_properties,
-            ),
-        ]
-
-    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 not relationship_reference:
-            return "="
-        parent_columns = self.parent_columns
-        if relationship_reference not in self.parent_columns:
-            raise ValueError(
-                "I was asked to search on a related column that doens't exist.  This shouldn't have happened :("
-            )
-        return self.parent_columns[relationship_reference].is_allowed_operator(operator)
-
-    def check_search_value(self, value, operator=None, relationship_reference=None):
-        if not relationship_reference:
-            return self.input_error_for_value(value, operator=operator)
-        parent_columns = self.parent_columns
-        if relationship_reference not in self.parent_columns:
-            raise ValueError(
-                "I was asked to search on a related column that doens't exist.  This shouldn't have happened :("
-            )
-        return self.parent_columns[relationship_reference].check_search_value(value, operator=operator)
-
-    def add_join(self, models):
-        parent_table = self.parent_models.table_name()
-        alias = self.join_table_alias()
-
-        if models.is_joined(parent_table, alias=alias):
-            return models
-
-        join_type = "LEFT " if self.config("join_type") == "LEFT" else ""
-        own_table_name = models.table_name()
-        parent_id_column_name = self.parent_models.get_id_column_name()
-        return models.join(
-            f"{join_type}JOIN {parent_table} as {alias} on {alias}.{parent_id_column_name}={own_table_name}.{self.name}"
-        )
-
-    def add_search(self, models, value, operator=None, relationship_reference=None):
-        if not relationship_reference:
-            return super().add_search(models, value, operator=operator)
-
-        parent_columns = self.parent_columns
-        if relationship_reference not in self.parent_columns:
-            raise ValueError(
-                "I was asked to search on a related column that doens't exist.  This shouldn't have happened :("
-            )
-
-        models = self.add_join(models)
-        related_column = self.parent_columns[relationship_reference]
-        alias = self.join_table_alias()
-        return models.where(related_column.build_condition(value, operator=operator, column_prefix=f"{alias}."))