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

clearskies/column_types/belongs_to.py

@@ -1,271 +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",
-        "where",
-    ]
-
-    def __init__(self, di):
-        super().__init__(di)
-
-    def _check_configuration(self, configuration):
-        super()._check_configuration(configuration)
-        self.validate_models_class(configuration["parent_models_class"])
-
-        error_prefix = f"Configuration error for '{self.name}' in '{self.model_class.__name__}':"
-        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"{error_prefix} '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"{error_prefix} 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()
-            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."
-                    )
-
-        wheres = configuration.get("where")
-        if wheres:
-            if not isinstance(wheres, list):
-                raise ValueError(
-                    f"{error_prefix} 'where' must be a list of where conditions or callables that return where conditions"
-                )
-            for index, where in enumerate(wheres):
-                if callable(where) or isinstance(where, str):
-                    continue
-                raise ValueError(
-                    f"{error_prefix} 'where' must be a list of where conditions or callables that return where conditions, but the item in entry #${index+1} was neither a string nor a callable"
-                )
-
-    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(),
-                "where": configuration.get("where", []),
-            },
-        }
-
-    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):
-        parents = self.di.build(self.config("parent_models_class"), cache=True)
-        for where in self.config("where"):
-            if callable(where):
-                parents = self.di.call_function(where, model=parents)
-                if not parents:
-                    raise ValueError(
-                        f"Configuration error for column '{self.name}' in model '{self.model_class.__name__}': when 'where' is a callable, it must return a models class, but when the callable in where entry #{index+1} was called, it did not return the models class"
-                    )
-            else:
-                parents = parents.where(where)
-        return parents
-
-    @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}."))

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,304 +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",
-        "children_column_name",
-        "descendents_column_name",
-        "ancestors_column_name",
-        "load_relatives_strategy",
-    ]
-
-    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",
-        )
-        load_relatives_strategy = configuration.get("load_relatives_strategy", None)
-        if load_relatives_strategy and load_relatives_strategy not in ["join", "where_in", "individual"]:
-            raise ValueError(
-                f"Configuration error for category_tree column '{self.name} in model class '{self.model_class.__name__}': load_relatives_strategy must be one of ['join', 'where_in', or 'individual']"
-            )
-
-    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),
-                "children_column_name": configuration.get("children_column_name", "children"),
-                "descendents_column_name": configuration.get("descendents_column_name", "descendents"),
-                "ancestors_column_name": configuration.get("ancestors_column_name", "ancestors"),
-                "load_relatives_strategy": configuration.get("load_relatives_strategy", "join"),
-            },
-        }
-
-    @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.get(self.id_column_name), 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. "
-        )
-
-    def can_provide(self, column_name):
-        return column_name in [
-            self.config("model_column_name"),
-            self.config("children_column_name"),
-            self.config("descendents_column_name"),
-            self.config("ancestors_column_name"),
-        ]
-
-    def provide(self, data, column_name):
-        if column_name == self.config("model_column_name"):
-            return super().provide(data, column_name)
-
-        if column_name == self.config("children_column_name"):
-            return self.relatives(data)
-
-        if column_name == self.config("descendents_column_name"):
-            return self.relatives(data, include_all=True)
-
-        if column_name == self.config("ancestors_column_name"):
-            return self.relatives(data, find_parents=True, include_all=True)
-
-    def relatives(self, data, include_all=False, find_parents=False):
-        id_column_name = self.model_class.id_column_name
-        model_id = data[self.model_class.id_column_name]
-        model_table_name = self.model_class.table_name()
-        tree_table_name = self.config("tree_models_class").table_name()
-        parent_id_column_name = self.config("tree_parent_id_column_name")
-        child_id_column_name = self.config("tree_child_id_column_name")
-        is_parent_column_name = self.config("tree_is_parent_column_name")
-        level_column_name = self.config("tree_level_column_name")
-
-        if find_parents:
-            join_on = parent_id_column_name
-            search_on = child_id_column_name
-        else:
-            join_on = child_id_column_name
-            search_on = parent_id_column_name
-
-        # if we can join then use a join.
-        if self.config("load_relatives_strategy") == "join":
-            relatives = self.parent_models.join(
-                f"{tree_table_name} as tree on tree.{join_on}={model_table_name}.{id_column_name}"
-            )
-            relatives = relatives.where(f"tree.{search_on}={model_id}")
-            if not include_all:
-                relatives = relatives.where(f"tree.{is_parent_column_name}=1")
-            if find_parents:
-                relatives = relatives.sort_by(level_column_name, "asc")
-            return relatives
-
-        # joins only work for SQL-like backends.  Otherwise, we have to pull out our list of ids
-        branches = self.tree_models.where(f"{search_on}={model_id}")
-        if not include_all:
-            branches = branches.where(f"{is_parent_column_name}=1")
-        if find_parents:
-            branches = branches.sort_by(level_column_name, "asc")
-        ids = [str(branch.get(join_on)) for branch in branches]
-
-        # Can we search with a WHERE IN() clause?  If the backend supports it, it is probably faster
-        if self.config("load_relatives_strategy") == "where_in":
-            return self.parent_models.where(f"{id_column_name} IN ('" + "','".join(ids) + "')")
-
-        # otherwise we have to load each model individually which is SLOW....
-        return [self.parent_models.find(f"{id_column_name}={id}") for id in ids]