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

clearskies/column_types/boolean.py

@@ -1,60 +0,0 @@
-from .column import Column
-from ..autodoc.schema import Boolean as AutoDocBoolean
-
-
-class Boolean(Column):
-    _auto_doc_class = AutoDocBoolean
-
-    my_configs = {
-        "on_true": None,
-        "on_false": None,
-    }
-
-    def __init__(self, di):
-        super().__init__(di)
-
-    def _check_configuration(self, configuration):
-        """Check the configuration and throw exceptions as needed"""
-        super()._check_configuration(configuration)
-        for trigger in ["on_true", "on_false"]:
-            if configuration.get(trigger):
-                self._check_actions(configuration[trigger], trigger)
-
-    def to_backend(self, data):
-        if self.name not in data or data[self.name] is None:
-            return data
-
-        return {
-            **data,
-            self.name: bool(data[self.name]),
-        }
-
-    def from_backend(self, value):
-        return bool(value)
-
-    def input_error_for_value(self, value, operator=None):
-        return f"{self.name} must be a boolean" if type(value) != bool else ""
-
-    def build_condition(self, value, operator=None, column_prefix=""):
-        condition_value = "1" if value else "0"
-        if not operator:
-            operator = "="
-        return f"{column_prefix}{self.name}{operator}{condition_value}"
-
-    def save_finished(self, model):
-        """
-        Make any necessary changes needed after a save has completely finished.
-        """
-        super().save_finished(model)
-
-        on_true = self.config("on_true", silent=True)
-        on_false = self.config("on_false", silent=True)
-        if not on_true and not on_false:
-            return
-        if not model.was_changed(self.name):
-            return
-
-        if model.get(self.name) and on_true:
-            self.execute_actions(on_true, model)
-        if not model.get(self.name) and on_false:
-            self.execute_actions(on_false, model)

clearskies/column_types/category_tree.py

@@ -1,226 +0,0 @@
-import re
-from .belongs_to import BelongsTo
-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 CategoryTree(BelongsTo):
-    """
-    Builds a tree table for quick lookups in a category heirarchy.
-
-    Imagine you have a model that represents a category heirarchy:
-
-    ```
-    CREATE TABLE categories (
-      id varchar(255),
-      parent_id varchar(255),
-      name varchar(255)
-    )
-    ```
-
-    Where `parent_id` references a record in the same categories table - a category tree!  This works
-    fine but it gets tricky when you want to answer the question "what are all the parent categories
-    of X category?" or "what are all the child categories of Y category?".  This column class solves that
-    by building a tree table that caches this data as the categories are updated.  That table should look
-    like this:
-
-    ```
-    CREATE TABLE category_tree (
-      id varchar(255),
-      parent_id varchar(255),
-      child_id varchar(255),
-      is_parent tinyint(1),
-      level tinyint(1),
-    )
-    ```
-
-    (add indexes as desired).  You then you have your corresponding models:
-
-    ```
-    import clearskies
-
-    class CategoryTree(clearskies.Model):
-        def __init__(self, cursor_backend, columns):
-            super().__init__(cursor_backend, columns)
-
-        def columns_configuration(self):
-            return OrderedDict([
-                clearskies.column_types.string('parent_id'),
-                clearskies.column_types.string('child_id'),
-                clearskies.column_types.integer('is_parent'),
-                clearskies.column_types.integer('level'),
-            ])
-
-    class Category(clearskies.Model):
-        def __init__(self, cursor_backend, columns):
-            super().__init__(cursor_backend, columns)
-
-        def columns_configuration(self):
-            return OrderedDict([
-                clearskies.column_types.string('name'),
-                clearskies.column_types.category_tree('parent_id', tree_models_class=CategoryTree),
-            ])
-    ```
-
-    You would then build your cateogry tree normally:
-
-    ```
-    # categories object comes in from dependency injection
-    root_category = categories.create({'name': 'my root category'})
-    sub_category = categories.create({'name': 'my sub category', parent_id=root_category.id})
-    alt_sub_category = categories.create({'name': 'my alternate sub category', parent_id=root_category.id})
-    sub_sub_category = categories.create({'name': 'my sub-sub category', parent_id=sub_category.id})
-    sub_sub_sub_category = categories.create({'name': 'my sub-sub-sub category', parent_id=sub_sub_category.id})
-    ```
-
-    and your database would look like this (using auto-incrementing ids for hopeful clarity)
-
-    ```
-    $ SELECT * FROM category_tree
-
-    parent_id | child_id | is_parent | level
-    1         | 2        | 1         | 0     # sub category
-    1         | 3        | 1         | 0     # alt sub category
-    1         | 4        | 0         | 0     # sub sub category referencing the root category
-    2         | 4        | 1         | 1     # sub sub category referencing the sub category
-    1         | 5        | 0         | 0     # sub sub sub category referencing the root category
-    2         | 5        | 0         | 1     # sub sub sub category referencing the sub category
-    4         | 5        | 1         | 2     # sub sub sub category referencing the sub sub category
-    ```
-
-    You can then use various SQL statements to efficiently fetch various pieces of data.
-
-    ```
-    # the category tree for a specific category
-    SELECT parent_id FROM category_tree WHERE child_id=5 ORDER BY level DESC;
-    # all the children of a parent (excluding sub-children)
-    SELECT child_id FROM category_tree WHERE parent_id=1 AND is_parent=1
-    # All the children of a parent (including sub-children)
-    SELECT child_id FROM category_tree WHERE parent_id=1;
-    ```
-
-    Of course other kinds of databases are better at this (such as graph databases), but it isn't
-    always worth managing another database unless performance is becoming a problem.
-    """
-
-    required_configs = [
-        "tree_models_class",
-    ]
-
-    my_configs = [
-        "model_column_name",
-        "readable_parent_columns",
-        "join_type",
-        "tree_parent_id_column_name",
-        "tree_child_id_column_name",
-        "tree_is_parent_column_name",
-        "tree_level_column_name",
-        "max_iterations",
-        "parent_models_class",
-    ]
-
-    def __init__(self, di):
-        super().__init__(di)
-
-    def _check_configuration(self, configuration):
-        # our parent class is the BelongsTo which needs to know the parent model class.
-        # with a category tree, we _are_ our own parent model class, so no need to ask for it.
-        super()._check_configuration(
-            {
-                **configuration,
-                "parent_models_class": configuration.get("parent_models_class", self.model_class),
-            }
-        )
-        self.validate_models_class(
-            configuration["tree_models_class"],
-            config_name="tree_models_class",
-        )
-
-    def _finalize_configuration(self, configuration):
-        return {
-            **super()._finalize_configuration(
-                {
-                    **configuration,
-                    "parent_models_class": configuration.get("parent_models_class", self.model_class),
-                }
-            ),
-            **{
-                "tree_parent_id_column_name": configuration.get("tree_parent_id_column_name", "parent_id"),
-                "tree_child_id_column_name": configuration.get("tree_child_id_column_name", "child_id"),
-                "tree_is_parent_column_name": configuration.get("tree_is_parent_column_name", "is_parent"),
-                "tree_level_column_name": configuration.get("tree_level_column_name", "level"),
-                "max_iterations": configuration.get("max_iterations", 100),
-            },
-        }
-
-    @property
-    def tree_models(self):
-        return self.di.build(self.config("tree_models_class"), cache=True)
-
-    def post_save(self, data, model, id):
-        if not model.is_changing(self.name, data):
-            return data
-
-        self.update_tree_table(model, id, model.latest(self.name, data))
-        return data
-
-    def force_tree_update(self, model):
-        self.update_tree_table(model, model.id, model.__getattr__(self.name))
-
-    def update_tree_table(self, model, child_id, direct_parent_id):
-        tree_models = self.tree_models
-        parent_models = self.parent_models
-        model_column_name = self.config("model_column_name")
-        tree_parent_id_column_name = self.config("tree_parent_id_column_name")
-        tree_child_id_column_name = self.config("tree_child_id_column_name")
-        tree_is_parent_column_name = self.config("tree_is_parent_column_name")
-        tree_level_column_name = self.config("tree_level_column_name")
-        max_iterations = self.config("max_iterations")
-
-        # we're going to be lazy and just delete the data for the current record in the tree table,
-        # and then re-insert everything (but we can skip this if creating a new record)
-        if model.exists:
-            for tree in tree_models.where(f"{tree_child_id_column_name}={child_id}"):
-                tree.delete()
-
-        # if we are a root category then we don't have a tree
-        if not direct_parent_id:
-            return
-
-        is_root = False
-        id_column_name = parent_models.id_column_name
-        next_parent = parent_models.find(f"{id_column_name}={direct_parent_id}")
-        tree = []
-        c = 0
-        while not is_root:
-            c += 1
-            if c > max_iterations:
-                self._circular(max_iterations)
-
-            tree.append(next_parent.__getattr__(next_parent.id_column_name))
-            if not next_parent.__getattr__(self.name):
-                is_root = True
-            else:
-                next_next_parent_id = next_parent.__getattr__(self.name)
-                next_parent = parent_models.find(f"{id_column_name}={next_next_parent_id}")
-
-        tree.reverse()
-        for index, parent_id in enumerate(tree):
-            tree_models.create(
-                {
-                    tree_parent_id_column_name: parent_id,
-                    tree_child_id_column_name: child_id,
-                    tree_is_parent_column_name: 1 if parent_id == direct_parent_id else 0,
-                    tree_level_column_name: index,
-                }
-            )
-
-    def _circular(self, max_iterations):
-        raise ValueError(
-            f"Error for column '{self.name}' for model class '{self.model_class.__name__}': "
-            + f"I've climbed through {max_iterations} parents and haven't found the root yet."
-            + "You may have accidentally created a circular cateogry tree.  If not, and your category tree "
-            + "really _is_ that deep, then adjust the 'max_iterations' configuration for this column accordingly. "
-        )

clearskies/column_types/column.py

@@ -1,373 +0,0 @@
-from abc import ABC
-import re
-from ..autodoc.schema import String as AutoDocString
-from .. import input_requirements
-from .. import binding_config
-import inspect
-
-
-class Column(ABC):
-    _auto_doc_class = AutoDocString
-    _is_unique = None
-    _is_required = None
-    configuration = None
-    common_configs = [
-        "input_requirements",
-        "class",
-        "is_writeable",
-        "is_temporary",
-        "on_change",
-        "default",
-        "setable",
-        "created_by_source_type",
-        "created_by_source_key",
-    ]
-
-    def __init__(self, di):
-        self.di = di
-
-    my_configs = []
-    required_configs = []
-
-    @property
-    def is_writeable(self):
-        is_writeable = self.config("is_writeable", True)
-        return True if (is_writeable or is_writeable is None) else False
-
-    @property
-    def is_readable(self):
-        return True
-
-    @property
-    def is_unique(self):
-        if self._is_unique is None:
-            requirements = self.config("input_requirements")
-            self._is_unique = False
-            for requirement in requirements:
-                if isinstance(requirement, input_requirements.Unique):
-                    self._is_unique = True
-        return self._is_unique
-
-    @property
-    def is_temporary(self):
-        return bool(self.config("is_temporary", silent=True))
-
-    @property
-    def is_required(self):
-        if self._is_required is None:
-            requirements = self.config("input_requirements")
-            self._is_required = False
-            for requirement in requirements:
-                if isinstance(requirement, input_requirements.Required):
-                    self._is_required = True
-        return self._is_required
-
-    def model_column_configurations(self):
-        nargs = len(inspect.getfullargspec(self.model_class.__init__).args) - 1
-        fake_model = self.model_class(*([""] * nargs))
-        return fake_model.all_columns()
-
-    def configure(self, name, configuration, model_class):
-        if not name:
-            raise ValueError(f"Missing name for column in '{model_class.__name__}'")
-        self.model_class = model_class
-        self.name = name
-        self._check_configuration(configuration)
-        configuration = self._finalize_configuration(configuration)
-        self.configuration = configuration
-
-    def _check_configuration(self, configuration):
-        """Check the configuration and throw exceptions as needed"""
-        for key in self.required_configs:
-            if key not in configuration:
-                raise KeyError(
-                    f"Missing required configuration '{key}' for column '{self.name}' in '{self.model_class.__name__}'"
-                )
-        for key in configuration.keys():
-            if key not in self.common_configs and key not in self.my_configs and key not in self.required_configs:
-                raise KeyError(
-                    f"Configuration '{key}' not allowed for column '{self.name}' in '{self.model_class.__name__}'"
-                )
-        if "is_writeable" in configuration and type(configuration["is_writeable"]) != bool:
-            raise ValueError("'is_writeable' must be a boolean")
-        if configuration.get("on_change"):
-            self._check_actions(configuration.get("on_change"), "on_change")
-
-        self._check_created_by_source(configuration)
-
-    def _finalize_configuration(self, configuration):
-        """Make any changes to the configuration/fill in defaults"""
-        if not "input_requirements" in configuration:
-            configuration["input_requirements"] = []
-        return configuration
-
-    def _check_created_by_source(self, configuration):
-        source_type = configuration.get("created_by_source_type")
-        source_key = configuration.get("created_by_source_key")
-        if not source_type and not source_key:
-            return
-
-        error_prefix = f"Misconfiguration for column '{self.name}' in '{self.model_class.__name__}': "
-        if not source_type or not source_key:
-            raise ValueError(
-                f"{error_prefix} must provide both 'created_by_source_type' and 'created_by_source_key' but only one was provided."
-            )
-
-        if not isinstance(source_type, str):
-            raise ValueError(
-                f"{error_prefix} 'created_by_source_type' must be a string but is a '"
-                + source_type.__class__.__name__
-                + "'"
-            )
-        if not isinstance(source_key, str):
-            raise ValueError(
-                f"{error_prefix} 'created_by_source_key' must be a string but is a '"
-                + source_key.__class__.__name__
-                + "'"
-            )
-
-        allowed_types = ["authorization_data"]
-        if source_type not in allowed_types:
-            raise ValueError(
-                f"{error_prefix} 'created_by_source_type' must be one of '" + "', '".join(allowed_types) + "'"
-            )
-        if configuration.get("setable"):
-            raise ValueError(f"{error_prefix} you cannot set both 'setable' and 'created_by_source_type'")
-
-    def _check_actions(self, actions, trigger_name):
-        """Check that the given actions are actually understandable by the system"""
-        if type(actions) != list:
-            raise ValueError(
-                "The actions provided to a trigger should be a list of callables/binding configs, but something "
-                + f"else was provided for the '{trigger_name}' trigger in '{self.model_class.__name__}'"
-            )
-        for index, action in enumerate(actions):
-            # if it's callable we're good.  This includes functions, lambdas, callable objects,
-            # and classes that will be callable when instantiated
-            if callable(action):
-                continue
-            # the above pretty much covers everything.  The only thing that we support otherwise
-            # is a binding config containing a callable class.
-            if type(action) == binding_config.BindingConfig:
-                if callable(action.object_class):
-                    continue
-
-            raise ValueError(
-                f"Invalid action: action #{index+1} for trigger '{trigger_name} in '{self.model_class.__name__}'"
-            )
-
-    def config(self, key, silent=False):
-        if not key in self.configuration:
-            if silent:
-                return None
-            raise KeyError(f"column '{self.__class__.__name__}' does not have a configuration named '{key}'")
-
-        return self.configuration[key]
-
-    def additional_write_columns(self, is_create=False):
-        additional_write_columns = {}
-        for requirement in self.config("input_requirements"):
-            additional_write_columns = {
-                **additional_write_columns,
-                **requirement.additional_write_columns(is_create=is_create),
-            }
-        return additional_write_columns
-
-    def from_backend(self, value):
-        """
-        Takes the database representation and returns a python representation
-
-        For instance, for an SQL date field, this will return a Python DateTime object
-        """
-        return value
-
-    def to_backend(self, data):
-        """
-        Makes any changes needed to save the data to the backend.
-
-        This typically means formatting changes - converting DateTime objects to database
-        date strings, etc...
-        """
-        return data
-
-    def to_json(self, model):
-        """
-        Grabs the column out of the model and converts it into a representation that can be turned into JSON
-        """
-        return {self.name: model.get(self.name, silent=True)}
-
-    def input_errors(self, model, data):
-        error = self.check_input(model, data)
-        if error:
-            return {self.name: error}
-
-        for requirement in self.config("input_requirements"):
-            error = requirement.check(model, data)
-            if error:
-                return {self.name: error}
-
-        return {}
-
-    def check_input(self, model, data):
-        if self.name not in data or not data[self.name]:
-            return ""
-        return self.input_error_for_value(data[self.name])
-
-    def pre_save(self, data, model):
-        """
-        Make any changes needed to the data before starting the save process
-
-        The difference between this and transform_for_database is that transform_for_database only affects
-        the data as it is going into the database, while this affects the data that will get persisted
-        in the object as well.  So for instance, for a "created" field, pre_save may fill in the current
-        date with a Python DateTime object when the record is being saved, and then transform_for_database may
-        turn that into an SQL-compatible date string.
-
-        The difference between this and post_save is that this happens before the database is updated.
-        As a result, if you need the model id to make your changes, it has to happen in post_save, not pre_save
-        """
-        if not model.exists:
-            source_type = self.configuration.get("created_by_source_type")
-            if source_type:
-                if source_type == "authorization_data":
-                    authorization_data = self.di.build("input_output", cache=True).get_authorization_data()
-                    data[self.name] = authorization_data.get(self.config("created_by_source_key"), "N/A")
-        if "setable" in self.configuration:
-            setable = self.configuration["setable"]
-            if callable(setable):
-                data[self.name] = self.di.call_function(setable, data=data, model=model)
-            else:
-                data[self.name] = setable
-        if not model.exists and "default" in self.configuration and self.name not in data:
-            data[self.name] = self.configuration["default"]
-        return data
-
-    def post_save(self, data, model, id):
-        """
-        Make any changes needed after saving to the database
-
-        data is the data being saved and id is the id of the record.   Note that while the database is updated
-        before this is called, the model isn't, so there will be a difference between what is in the database
-        and what is in the object.
-        """
-        return data
-
-    def save_finished(self, model):
-        """
-        Make any necessary changes needed after a save has completely finished.
-
-        This is typically used for configurable triggers set by the developer.   Column-specific behavior
-        that needs to always happen is placed in pre_save or post_save because those affect the save
-        process itself.
-        """
-        on_change_actions = self.config("on_change", silent=True)
-        if on_change_actions and model.was_changed(self.name):
-            self.execute_actions(on_change_actions, model)
-
-    def values_match(self, value_1, value_2):
-        """
-        Compares two values to see if they are the same
-        """
-        return value_1 == value_2
-
-    def pre_delete(self, model):
-        """
-        Make any changes needed to the data before starting the delete process
-        """
-        pass
-
-    def post_delete(self, model):
-        """
-        Make any changes needed to the data before finishing the delete process
-        """
-        pass
-
-    def can_provide(self, column_name):
-        """
-        This works together with self.provide to load ancillary data
-
-        For instance, a foreign key will have an "id" column such as `user_id` but it can also load up
-        the user model, which you expect to happen by requesting `model.user`.  If a model receives a
-        request for a column name that it doesn't recognize, it will loop through all the columns and
-        call `can_provide` with the column name.  We then have to return True or False to denote whether
-        or not we can provide the thing being requested.  If we return True then the model will then
-        call `column.provide` with the data from the model and the requested column name
-        """
-        return False
-
-    def provide(self, data, column_name):
-        """
-        This is called if the column declares that it can provide something, and should return the value
-
-        See can_provide for more details on the flow here
-        """
-        pass
-
-    def execute_actions(self, actions, model):
-        for action in actions:
-            if type(action) == binding_config.BindingConfig:
-                action = self.di.build(action)
-            elif inspect.isclass(action):
-                action = self.di.build(action)
-            if hasattr(action, "__call__"):
-                self.di.call_function(action.__call__, model=model)
-            else:
-                self.di.call_function(action.__call__, model=model)
-
-    def add_search(self, models, value, operator=None, relationship_reference=None):
-        return models.where(self.build_condition(value, operator=operator))
-
-    def build_condition(self, value, operator=None, column_prefix=""):
-        """
-        This is called by the read (and related) handlers to turn user input into a condition.
-
-        Note that this may look like it is vulnerable to SQLi, but it isn't.  These conditions aren't passed directly
-        into a query.  Rather, they are parsed by the condition parser before being sent into the backend.
-        The condition parser can safely reconstruct the original pieces, and the backend can then use the data
-        safely (and remember, the backend may not be an SQL anyway)
-
-        As a result, this is perfectly safe for any user input, assuming normal system flow.
-        """
-        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 configure_n_plus_one(self, models):
-        return models
-
-    def check_search_value(self, value, operator=None, relationship_reference=None):
-        return self.input_error_for_value(value, operator=operator)
-
-    def input_error_for_value(self, value, operator=None):
-        return ""
-
-    def where_for_request(self, models, routing_data, authorization_data, input_output):
-        """
-        A hook to automatically apply filtering whenever the column makes an appearance in a get/update/list/search handler.
-        """
-        return models
-
-    def validate_models_class(self, models_class, config_name="parent_models_class"):
-        if not hasattr(models_class, "model_class"):
-            if hasattr(models_class, "columns_configuration"):
-                raise ValueError(
-                    f"'{config_name}' in configuration for column '{self.name}' in model class "
-                    + f"'{self.model_class.__name__}' appears to be a Model class, but it should be a Models class"
-                )
-            else:
-                raise ValueError(
-                    f"'{config_name}' in configuration for column '{self.name}' should be a Models class, "
-                    + f"but it appears to be something unknown."
-                )
-
-    def camel_to_nice(self, string):
-        string = re.sub("(.)([A-Z][a-z]+)", r"\1 \2", string)
-        string = re.sub("([a-z0-9])([A-Z])", r"\1 \2", string).lower()
-        return string
-
-    def documentation(self, name=None, example=None, value=None):
-        return self._auto_doc_class(name if name is not None else self.name, example=example, value=value)

clearskies/column_types/created.py

@@ -1,26 +0,0 @@
-from .datetime import DateTime
-
-
-class Created(DateTime):
-    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}