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

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)

clearskies/column_types/many_to_many_with_data.py

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

clearskies/column_types/select.py

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

clearskies/column_types/string.py

@@ -1,24 +0,0 @@
-from .column import Column
-
-
-class String(Column):
-    def __init__(self, di):
-        super().__init__(di)
-
-    def build_condition(self, value, operator=None, column_prefix=""):
-        if not operator:
-            operator = "="
-        if operator.lower() == "like":
-            return f"{column_prefix}{self.name} LIKE '%{value}%'"
-        return f"{column_prefix}{self.name}{operator}{value}"
-
-    def is_allowed_operator(self, operator, relationship_reference=None):
-        """
-        This is called when processing user data to decide if the end-user is specifying an allowed operator
-        """
-        if operator in ["=", "<", ">", "<=", ">=", "in"]:
-            return True
-        return operator.lower() == "like"
-
-    def input_error_for_value(self, value, operator=None):
-        return "value should be a string" if type(value) != str else ""

clearskies/column_types/updated.py

@@ -1,24 +0,0 @@
-from .datetime import DateTime
-
-
-class Updated(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 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}

clearskies/column_types/updated_micro.py

@@ -1,24 +0,0 @@
-from .datetime_micro import DateTimeMicro
-
-
-class UpdatedMicro(DateTimeMicro):
-    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 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}

clearskies/column_types/uuid.py

@@ -1,25 +0,0 @@
-from .string import String
-
-
-class UUID(String):
-    def __init__(self, di, uuid):
-        super().__init__(di)
-        self.uuid = uuid
-
-    @property
-    def is_writeable(self):
-        return False
-
-    def build_condition(self, value, operator=None, column_prefix=""):
-        return f"{column_prefix}{self.name}={value}"
-
-    def is_allowed_operator(self, operator, relationship_reference=None):
-        """
-        This is called when processing user data to decide if the end-user is specifying an allowed operator
-        """
-        return operator == "="
-
-    def pre_save(self, data, model):
-        if model.exists:
-            return data
-        return {**data, self.name: str(self.uuid.uuid4())}

clearskies/columns.py

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