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

clearskies/column_types/float.py

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

clearskies/column_types/has_many.py

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

clearskies/column_types/has_one.py

@@ -1,58 +0,0 @@
-from .has_many import HasMany
-import re
-from collections import OrderedDict
-from ..autodoc.schema import Array as AutoDocArray
-from ..autodoc.schema import Object as AutoDocObject
-from ..autodoc.schema import String as AutoDocString
-
-
-class HasOne(HasMany):
-    """
-    Controls a has-one relationship.
-
-    This is a readonly column.  When used in a model context it will return the related record.
-    When used in an API context, it will convert the child record into an object.
-
-    It assumes that the foreign id in the child table is `[parent_model_class_name]_id` in all lower case.
-    e.g., if the parent model class is named Status, then it assumes an id in the child class called `status_id`.
-    """
-
-    def can_provide(self, column_name):
-        return column_name == self.name
-
-    def provide(self, data, column_name):
-        foreign_column_name = self.config("foreign_column_name")
-        id_column_name = self.config("parent_id_column_name")
-        return self.child_models.find(f"{foreign_column_name}={data[id_column_name]}")
-
-    def to_json(self, model):
-        json = OrderedDict()
-        columns = self.get_child_columns()
-        child = model.__getattr__(self.name)
-        child_id_column_name = child.id_column_name
-        json = {
-            **json,
-            **columns[child_id_column_name].to_json(child),
-        }
-        for column_name in self.config("readable_child_columns"):
-            json = {
-                **json,
-                **columns[column_name].to_json(child),
-            }
-        return {self.name: json}
-
-    def documentation(self, name=None, example=None, value=None):
-        columns = self.get_child_columns()
-        child_id_column_name = self.child_models.get_id_column_name()
-        child_properties = [columns[child_id_column_name].documentation()]
-
-        for column_name in self.config("readable_child_columns"):
-            child_docs = columns[column_name].documentation()
-            if type(child_docs) != list:
-                child_docs = [child_docs]
-            child_properties.extend(child_docs)
-
-        return AutoDocObject(
-            self.camel_to_nice(self.child_models.model_class().__name__),
-            child_properties,
-        )

clearskies/column_types/integer.py

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

clearskies/column_types/json.py

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

clearskies/column_types/many_to_many.py

@@ -1,278 +0,0 @@
-from .string import String
-import re
-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 ManyToMany(String):
-    """
-    Controls a many-to-many relationship.
-
-    This column connects to models via a many-to-many relationship, meaning that a record in either table can
-    be associated with multiple records in the other table.  Image you had two models: users and teams, where
-    a user can be on more than one team.  To keep track of the mapping, a "pivot" table is required which tracks
-    relationships.  In the case of users/teams, you might imagine a table called "users_teams" which has 3 columns:
-
-     - id
-     - user_id
-     - team_id
-
-    You would then create a many-to-many relationship in both your users model and your teams model that would
-    look something like:
-
-    ```
-    class User:
-      def columns_configuration(self):
-        return OrderedDict([
-          clearskies.column_types.has_many('teams', related_models_class=Teams, pivot_models_class=UsersTeams),
-        ')
-
-    class Team:
-      def columns_configuration(self):
-        return OrderedDict([
-          clearskies.column_types.has_many('users', related_models_class=Users, pivot_models_class=UsersTeams),
-        ')
-    ```
-
-    Note that `related_models_class` and pivot_models_class receive the model*s* class, not the _model_ class.
-
-    You can attach records to eachother by saving a list of ids via the column name, i.e.:
-
-    ```
-    user.save({'teams': [1, 2, 3]})
-    team.save({'users': [4, 5, 6]})
-    ```
-
-    The many_to_many column will let you easily pull out the related models:
-
-    ```
-    print(user.teams)
-    # prints [<__main__.Team object>, <__main__.Team object>, <__main__.Team object>]
-    ```
-
-    as well as their ids:
-
-    ```
-    print(user.teams_ids)
-    # prints [1, 2, 3]
-    ```
-    """
-
-    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",
-    ]
-
-    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)
-        self.validate_models_class(configuration["pivot_models_class"])
-        self.validate_models_class(configuration["related_models_class"])
-        if self.name[-3:] == "_id" or self.name[-4:] == "_ids":
-            raise ValueError(
-                f"Invalid name for column '{self.name}' in '{self.model_class.__name__}' - "
-                + "ManyToMany column should not end in '_id' or '_ids'"
-            )
-
-        if configuration.get("is_readable"):
-            related_columns = self.di.build(
-                configuration["related_models_class"], cache=True
-            ).raw_columns_configuration()
-            error_prefix = f"Configuration error for '{self.name}' in '{self.model_class.__name__}':"
-            if not "readable_related_columns" in configuration:
-                raise ValueError(f"{error_prefix} must provide 'readable_related_columns' if is_readable is set")
-            readable_related_columns = configuration["readable_related_columns"]
-            if not hasattr(readable_related_columns, "__iter__"):
-                raise ValueError(
-                    f"{error_prefix} 'readable_related_columns' should be an iterable "
-                    + "with the list of child columns to output."
-                )
-            if isinstance(readable_related_columns, str):
-                raise ValueError(
-                    f"{error_prefix} 'readable_related_columns' should be an iterable "
-                    + "with the list of child columns to output."
-                )
-            for column_name in readable_related_columns:
-                if column_name not in related_columns:
-                    raise ValueError(
-                        f"{error_prefix} 'readable_related_columns' references column named '{column_name}' but this"
-                        + "column does not exist in the model class."
-                    )
-
-    def _finalize_configuration(self, configuration):
-        pivot_models = self.di.build(configuration["pivot_models_class"], cache=True)
-        related_models = self.di.build(configuration["related_models_class"], cache=True)
-
-        if not configuration.get("foreign_column_name_in_pivot"):
-            model_class = related_models.model_class()
-            foreign_column_name = re.sub(r"(?<!^)(?=[A-Z])", "_", model_class.__name__.replace("_", "")).lower() + "_id"
-        else:
-            foreign_column_name = configuration["foreign_column_name_in_pivot"]
-
-        if not configuration.get("own_column_name_in_pivot"):
-            own_column_name = (
-                re.sub(r"(?<!^)(?=[A-Z])", "_", self.model_class.__name__.replace("_", "")).lower() + "_id"
-            )
-        else:
-            own_column_name = configuration["own_column_name_in_pivot"]
-
-        return {
-            **super()._finalize_configuration(configuration),
-            **{
-                "foreign_column_name_in_pivot": foreign_column_name,
-                "own_column_name_in_pivot": own_column_name,
-                "pivot_table": pivot_models.get_table_name(),
-                "own_id_column_name": self.model_class.id_column_name,
-                "related_id_column_name": related_models.get_id_column_name(),
-            },
-        }
-
-    def input_error_for_value(self, value, operator=None):
-        if type(value) != list:
-            return f"{self.name} should be a list of ids"
-        related_models = self.related_models
-        related_id_column_name = self.config("related_id_column_name")
-        for id_to_check in value:
-            if type(id_to_check) != str:
-                return f"Invalid selection for {self.name}: all values must be strings"
-            if not len(related_models.where(f"{related_id_column_name}={id_to_check}")):
-                return f"Invalid selection for {self.name}: record {id_to_check} does not exist"
-        return ""
-
-    def can_provide(self, column_name):
-        return column_name == self.name or column_name == f"{self.name}_ids"
-
-    def provide(self, data, column_name):
-        foreign_column_name_in_pivot = self.config("foreign_column_name_in_pivot")
-        own_column_name_in_pivot = self.config("own_column_name_in_pivot")
-        own_id_column_name = self.config("own_id_column_name")
-        pivot_table = self.config("pivot_table")
-        related_id_column_name = self.config("related_id_column_name")
-        models = self.related_models
-        join = f"JOIN {pivot_table} ON {pivot_table}.{foreign_column_name_in_pivot}={models.get_table_name()}.{related_id_column_name}"
-        related_models = models.join(join).where(f"{pivot_table}.{own_column_name_in_pivot}={data[own_id_column_name]}")
-        if column_name == self.name:
-            return [model for model in related_models]
-        return [model.__getattr__(related_id_column_name) for model in related_models]
-
-    def to_backend(self, data):
-        # we can't persist our mapping data to the database directly, so remove anything here
-        # and take care of things in post_save
-        if self.name in data:
-            del data[self.name]
-        return data
-
-    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"))
-
-        new_ids = set(data[self.name])
-        to_delete = old_ids - new_ids
-        to_create = new_ids - old_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()
-        if to_create:
-            pivot_models = self.pivot_models
-            foreign_column_name = self.config("foreign_column_name_in_pivot")
-            own_column_name = self.config("own_column_name_in_pivot")
-            for to_insert in new_ids - old_ids:
-                pivot_models.create(
-                    {
-                        foreign_column_name: to_insert,
-                        own_column_name: id,
-                    }
-                )
-
-        return data
-
-    @property
-    def pivot_models(self):
-        return self.di.build(self.config("pivot_models_class"), cache=True)
-
-    @property
-    def related_models(self):
-        return self.di.build(self.config("related_models_class"), cache=True)
-
-    @property
-    def related_columns(self):
-        return self.related_models.model_columns
-
-    def add_search(self, models, value, operator=None, relationship_reference=None):
-        foreign_column_name_in_pivot = self.config("foreign_column_name_in_pivot")
-        own_column_name_in_pivot = self.config("own_column_name_in_pivot")
-        own_id_column_name = self.config("own_id_column_name")
-        pivot_table = self.config("pivot_table")
-        my_table_name = self.model_class.table_name()
-        related_table_name = self.related_models.get_table_name()
-        join_pivot = (
-            f"JOIN {pivot_table} ON {pivot_table}.{own_column_name_in_pivot}={my_table_name}.{own_id_column_name}"
-        )
-        # no reason we can't support searching by both an id or a list of ids
-        values = value if type(value) == list else [value]
-        search = " IN (" + ", ".join([str(val) for val in value]) + ")"
-        return models.join(join_pivot).where(f"{pivot_table}.{foreign_column_name_in_pivot}{search}")
-
-    def to_json(self, model):
-        records = []
-        columns = self.related_columns
-        related_id_column_name = self.config("related_id_column_name")
-        for related in model.__getattr__(self.name):
-            json = OrderedDict()
-            if related_id_column_name not in self.config("readable_related_columns"):
-                json[related_id_column_name] = columns[related_id_column_name].to_json(related)
-            for column_name in self.config("readable_related_columns"):
-                column_data = columns[column_name].to_json(related)
-                if type(column_data) == dict:
-                    json = {**json, **column_data}
-                else:
-                    json[column_name] = column_data
-            records.append(json)
-        return {self.name: records}
-
-    def documentation(self, name=None, example=None, value=None):
-        columns = self.related_columns
-        related_id_column_name = self.config("related_id_column_name")
-        related_properties = [columns[related_id_column_name].documentation()]
-
-        for column_name in self.config("readable_related_columns"):
-            related_docs = columns[column_name].documentation()
-            if type(related_docs) != list:
-                related_docs = [related_docs]
-            related_properties.extend(child_docs)
-
-        related_object = AutoDocObject(
-            self.camel_to_nice(self.related_models.model_class().__name__),
-            related_properties,
-        )
-        return AutoDocArray(name if name is not None else self.name, related_object, value=value)