masonite-framework-orm 3.0.1__py3-none-any.whl

masoniteorm/relationships/MorphMany.py

@@ -0,0 +1,152 @@
+from ..collection import Collection
+from ..config import load_config
+from .BaseRelationship import BaseRelationship
+
+
+class MorphMany(BaseRelationship):
+    def __init__(self, fn, morph_key="record_type", morph_id="record_id"):
+        if isinstance(fn, str):
+            self.fn = None
+            self.morph_key = fn
+            self.morph_id = morph_key
+        else:
+            self.fn = fn
+            self.morph_id = morph_id
+            self.morph_key = morph_key
+
+    def get_builder(self):
+        return self._related_builder
+
+    def set_keys(self, owner, attribute):
+        self.morph_id = self.morph_id or "record_id"
+        self.morph_key = self.morph_key or "record_type"
+        return self
+
+    def __get__(self, instance, owner):
+        """This method is called when the decorated method is accessed.
+
+        Arguments:
+            instance {object|None} -- The instance we called.
+                If we didn't call the attribute and only accessed it then this will be None.
+
+            owner {object} -- The current model that the property was accessed on.
+
+        Returns:
+            object -- Either returns a builder or a hydrated model.
+        """
+        attribute = self.fn.__name__
+        self._related_builder = instance.builder
+        self.polymorphic_builder = self.fn(self)()
+        self.set_keys(owner, self.fn)
+
+        if not instance.is_loaded():
+            return self
+
+        if attribute in instance._relationships:
+            return instance._relationships[attribute]
+
+        return self.apply_query(self._related_builder, instance)
+
+    def __getattr__(self, attribute):
+        relationship = self.fn(self)()
+        return getattr(relationship.builder, attribute)
+
+    def apply_query(self, builder, instance):
+        """Apply the query and return a dictionary to be hydrated
+
+        Arguments:
+            builder {oject} -- The relationship object
+            instance {object} -- The current model oject.
+
+        Returns:
+            dict -- A dictionary of data which will be hydrated.
+        """
+        polymorphic_key = self.get_record_key_lookup(builder._model)
+        polymorphic_builder = self.polymorphic_builder
+        return (
+            polymorphic_builder.where(self.morph_key, polymorphic_key)
+            .where(self.morph_id, instance.get_primary_key_value())
+            .get()
+        )
+
+    def get_related(self, query, relation, eagers=None, callback=None):
+        """Gets the relation needed between the relation and the related builder. If the relation is a collection
+        then will need to pluck out all the keys from the collection and fetch from the related builder. If
+        relation is just a Model then we can just call the model based on the value of the related
+        builders primary key.
+
+        Args:
+            relation (Model|Collection):
+
+        Returns:
+            Model|Collection
+        """
+
+        if isinstance(relation, Collection):
+            record_type = self.get_record_key_lookup(relation.first())
+            if callback:
+                return callback(
+                    self.polymorphic_builder.where(
+                        f"{self.polymorphic_builder.get_table_name()}.{self.morph_key}",
+                        record_type,
+                    ).where_in(
+                        self.morph_id,
+                        relation.pluck(
+                            relation.first().get_primary_key(),
+                            keep_nulls=False,
+                        ).unique(),
+                    )
+                ).get()
+            return (
+                self.polymorphic_builder.where(
+                    f"{self.polymorphic_builder.get_table_name()}.{self.morph_key}",
+                    record_type,
+                )
+                .where_in(
+                    self.morph_id,
+                    relation.pluck(
+                        relation.first().get_primary_key(), keep_nulls=False
+                    ).unique(),
+                )
+                .get()
+            )
+
+        else:
+            record_type = self.get_record_key_lookup(relation)
+
+            if callback:
+                return callback(
+                    self.polymorphic_builder.where(
+                        self.morph_key, record_type
+                    ).where(self.morph_id, relation.get_primary_key_value())
+                ).get()
+            return (
+                self.polymorphic_builder.where(self.morph_key, record_type)
+                .where(self.morph_id, relation.get_primary_key_value())
+                .get()
+            )
+
+    def register_related(self, key, model, collection):
+        record_type = self.get_record_key_lookup(model)
+        related = collection.where(self.morph_key, record_type).where(
+            self.morph_id, model.get_primary_key_value()
+        )
+
+        model.add_relation({key: related})
+
+    def morph_map(self):
+        return load_config().DB._morph_map
+
+    def get_record_key_lookup(self, relation):
+        record_type = None
+        for record_type_loop, model in self.morph_map().items():
+            if model == relation.__class__:
+                record_type = record_type_loop
+                break
+
+        if not record_type:
+            raise ValueError(
+                f"Could not find the record type key for the {relation} class"
+            )
+
+        return record_type

masoniteorm/relationships/MorphOne.py

@@ -0,0 +1,156 @@
+from ..collection import Collection
+from ..config import load_config
+from .BaseRelationship import BaseRelationship
+
+
+class MorphOne(BaseRelationship):
+    def __init__(self, fn, morph_key="record_type", morph_id="record_id"):
+        if isinstance(fn, str):
+            self.fn = None
+            self.morph_key = fn
+            self.morph_id = morph_key
+        else:
+            self.fn = fn
+            self.morph_id = morph_id
+            self.morph_key = morph_key
+
+    def get_builder(self):
+        return self._related_builder
+
+    def set_keys(self, owner, attribute):
+        self.morph_id = self.morph_id or "record_id"
+        self.morph_key = self.morph_key or "record_type"
+        return self
+
+    def __get__(self, instance, owner):
+        """This method is called when the decorated method is accessed.
+
+        Arguments:
+            instance {object|None} -- The instance we called.
+                If we didn't call the attribute and only accessed it then this will be None.
+
+            owner {object} -- The current model that the property was accessed on.
+
+        Returns:
+            object -- Either returns a builder or a hydrated model.
+        """
+        attribute = self.fn.__name__
+        self._related_builder = instance.builder
+        self.polymorphic_builder = self.fn(self)()
+        self.set_keys(owner, self.fn)
+
+        if not instance.is_loaded():
+            return self
+
+        if attribute in instance._relationships:
+            return instance._relationships[attribute]
+
+        return self.apply_query(self._related_builder, instance)
+
+    def __getattr__(self, attribute):
+        relationship = self.fn(self)()
+        return getattr(relationship.builder, attribute)
+
+    def apply_query(self, builder, instance):
+        """Apply the query and return a dictionary to be hydrated
+
+        Arguments:
+            builder {oject} -- The relationship object
+            instance {object} -- The current model oject.
+
+        Returns:
+            dict -- A dictionary of data which will be hydrated.
+        """
+        polymorphic_key = self.get_record_key_lookup(builder._model)
+        polymorphic_builder = self.polymorphic_builder
+
+        return (
+            polymorphic_builder.where(self.morph_key, polymorphic_key)
+            .where(self.morph_id, instance.get_primary_key_value())
+            .first()
+        )
+
+    def get_related(self, query, relation, eagers=None, callback=None):
+        """Gets the relation needed between the relation and the related builder. If the relation is a collection
+        then will need to pluck out all the keys from the collection and fetch from the related builder. If
+        relation is just a Model then we can just call the model based on the value of the related
+        builders primary key.
+
+        Args:
+            relation (Model|Collection):
+
+        Returns:
+            Model|Collection
+        """
+
+        if isinstance(relation, Collection):
+            record_type = self.get_record_key_lookup(relation.first())
+            if callback:
+                return callback(
+                    self.polymorphic_builder.where(
+                        f"{self.polymorphic_builder.get_table_name()}.{self.morph_key}",
+                        record_type,
+                    ).where_in(
+                        self.morph_id,
+                        relation.pluck(
+                            relation.first().get_primary_key(),
+                            keep_nulls=False,
+                        ).unique(),
+                    )
+                ).get()
+
+            return (
+                self.polymorphic_builder.where(
+                    f"{self.polymorphic_builder.get_table_name()}.{self.morph_key}",
+                    record_type,
+                )
+                .where_in(
+                    self.morph_id,
+                    relation.pluck(
+                        relation.first().get_primary_key(), keep_nulls=False
+                    ).unique(),
+                )
+                .get()
+            )
+
+        else:
+            record_type = self.get_record_key_lookup(relation)
+            if callback:
+                return callback(
+                    self.polymorphic_builder.where(
+                        self.morph_key, record_type
+                    ).where(self.morph_id, relation.get_primary_key_value())
+                ).first()
+
+            return (
+                self.polymorphic_builder.where(self.morph_key, record_type)
+                .where(self.morph_id, relation.get_primary_key_value())
+                .first()
+            )
+
+    def register_related(self, key, model, collection):
+        record_type = self.get_record_key_lookup(model)
+        related = (
+            collection.where(self.morph_key, record_type)
+            .where(self.morph_id, model.get_primary_key_value())
+            .first()
+        )
+
+        model.add_relation({key: related})
+
+    def morph_map(self):
+        return load_config().DB._morph_map
+
+    def get_record_key_lookup(self, relation):
+        record_type = None
+        for record_type_loop, model in self.morph_map().items():
+            if model == relation.__class__:
+                record_type = record_type_loop
+                break
+
+        if not record_type:
+            raise ValueError(
+                f"Could not find the record type key for the {relation} class"
+            )
+
+        return record_type

masoniteorm/relationships/MorphTo.py

@@ -0,0 +1,111 @@
+from ..collection import Collection
+from ..config import load_config
+from .BaseRelationship import BaseRelationship
+
+
+class MorphTo(BaseRelationship):
+    def __init__(self, fn, morph_key="record_type", morph_id="record_id"):
+        if isinstance(fn, str):
+            self.fn = None
+            self.morph_key = fn
+            self.morph_id = morph_key
+        else:
+            self.fn = fn
+            self.morph_id = morph_id
+            self.morph_key = morph_key
+
+    def get_builder(self):
+        return self._related_builder
+
+    def set_keys(self, owner, attribute):
+        self.morph_id = self.morph_id or "record_id"
+        self.morph_key = self.morph_key or "record_type"
+        return self
+
+    def __get__(self, instance, owner):
+        """This method is called when the decorated method is accessed.
+
+        Arguments:
+            instance {object|None} -- The instance we called.
+                If we didn't call the attribute and only accessed it then this will be None.
+
+            owner {object} -- The current model that the property was accessed on.
+
+        Returns:
+            object -- Either returns a builder or a hydrated model.
+        """
+        attribute = self.fn.__name__
+        self._related_builder = instance.builder
+        self.set_keys(owner, self.fn)
+
+        if not instance.is_loaded():
+            return self
+
+        if attribute in instance._relationships:
+            return instance._relationships[attribute]
+
+        return self.apply_query(self._related_builder, instance)
+
+    def __getattr__(self, attribute):
+        relationship = self.fn(self)()
+        return getattr(relationship._related_builder, attribute)
+
+    def apply_query(self, builder, instance):
+        """Apply the query and return a dictionary to be hydrated
+
+        Arguments:
+            builder {oject} -- The relationship object
+            instance {object} -- The current model oject.
+
+        Returns:
+            dict -- A dictionary of data which will be hydrated.
+        """
+        model = self.morph_map().get(instance.__attributes__[self.morph_key])
+        record = instance.__attributes__[self.morph_id]
+
+        return model.where(model.get_primary_key(), record).first()
+
+    def get_related(self, query, relation, eagers=None, callback=None):
+        """Gets the relation needed between the relation and the related builder. If the relation is a collection
+        then will need to pluck out all the keys from the collection and fetch from the related builder. If
+        relation is just a Model then we can just call the model based on the value of the related
+        builders primary key.
+
+        Args:
+            relation (Model|Collection):
+
+        Returns:
+            Model|Collection
+        """
+        if isinstance(relation, Collection):
+            relations = Collection()
+            for group, items in relation.group_by(self.morph_key).items():
+                morphed_model = self.morph_map().get(group)
+                relations.merge(
+                    morphed_model.where_in(
+                        f"{morphed_model.get_table_name()}.{morphed_model.get_primary_key()}",
+                        Collection(items)
+                        .pluck(self.morph_id, keep_nulls=False)
+                        .unique(),
+                    ).get()
+                )
+            return relations
+        else:
+            model = self.morph_map().get(getattr(relation, self.morph_key))
+            if model:
+                return model.find(getattr(relation, self.morph_id))
+
+    def register_related(self, key, model, collection):
+        morphed_model = self.morph_map().get(getattr(model, self.morph_key))
+
+        related = collection.where(
+            morphed_model.get_primary_key(), getattr(model, self.morph_id)
+        ).first()
+
+        model.add_relation({key: related})
+
+    def morph_map(self):
+        return load_config().DB._morph_map
+
+    def map_related(self, related_result):
+        return related_result

masoniteorm/relationships/MorphToMany.py

@@ -0,0 +1,108 @@
+from ..collection import Collection
+from ..config import load_config
+from .BaseRelationship import BaseRelationship
+
+
+class MorphToMany(BaseRelationship):
+    def __init__(self, fn, morph_key="record_type", morph_id="record_id"):
+        if isinstance(fn, str):
+            self.fn = None
+            self.morph_key = fn
+            self.morph_id = morph_key
+        else:
+            self.fn = fn
+            self.morph_id = morph_id
+            self.morph_key = morph_key
+
+    def get_builder(self):
+        return self._related_builder
+
+    def set_keys(self, owner, attribute):
+        self.morph_id = self.morph_id or "record_id"
+        self.morph_key = self.morph_key or "record_type"
+        return self
+
+    def __get__(self, instance, owner):
+        """This method is called when the decorated method is accessed.
+
+        Arguments:
+            instance {object|None} -- The instance we called.
+                If we didn't call the attribute and only accessed it then this will be None.
+
+            owner {object} -- The current model that the property was accessed on.
+
+        Returns:
+            object -- Either returns a builder or a hydrated model.
+        """
+        attribute = self.fn.__name__
+        self._related_builder = instance.builder
+        self.set_keys(owner, self.fn)
+
+        if not instance.is_loaded():
+            return self
+
+        if attribute in instance._relationships:
+            return instance._relationships[attribute]
+
+        return self.apply_query(self._related_builder, instance)
+
+    def __getattr__(self, attribute):
+        relationship = self.fn(self)()
+        return getattr(relationship.builder, attribute)
+
+    def apply_query(self, builder, instance):
+        """Apply the query and return a dictionary to be hydrated
+
+        Arguments:
+            builder {oject} -- The relationship object
+            instance {object} -- The current model oject.
+
+        Returns:
+            dict -- A dictionary of data which will be hydrated.
+        """
+        model = self.morph_map().get(instance.__attributes__[self.morph_key])
+        record = instance.__attributes__[self.morph_id]
+
+        return model.where(model.get_primary_key(), record).first()
+
+    def get_related(self, query, relation, eagers=None, callback=None):
+        """Gets the relation needed between the relation and the related builder. If the relation is a collection
+        then will need to pluck out all the keys from the collection and fetch from the related builder. If
+        relation is just a Model then we can just call the model based on the value of the related
+        builders primary key.
+
+        Args:
+            relation (Model|Collection):
+
+        Returns:
+            Model|Collection
+        """
+        if isinstance(relation, Collection):
+            relations = Collection()
+            for group, items in relation.group_by(self.morph_key).items():
+                morphed_model = self.morph_map().get(group)
+                relations.merge(
+                    morphed_model.where_in(
+                        f"{morphed_model.get_table_name()}.{morphed_model.get_primary_key()}",
+                        Collection(items)
+                        .pluck(self.morph_id, keep_nulls=False)
+                        .unique(),
+                    ).get()
+                )
+            return relations
+        else:
+            model = self.morph_map().get(getattr(relation, self.morph_key))
+            if model:
+                return model.find([getattr(relation, self.morph_id)])
+
+    def register_related(self, key, model, collection):
+        morphed_model = self.morph_map().get(getattr(model, self.morph_key))
+
+        related = collection.where(
+            morphed_model.get_primary_key(), getattr(model, self.morph_id)
+        )
+
+        model.add_relation({key: related})
+
+    def morph_map(self):
+        return load_config().DB._morph_map

masoniteorm/relationships/__init__.py

@@ -0,0 +1,10 @@
+from .BelongsTo import BelongsTo as belongs_to
+from .BelongsToMany import BelongsToMany as belongs_to_many
+from .HasMany import HasMany as has_many
+from .HasManyThrough import HasManyThrough as has_many_through
+from .HasOne import HasOne as has_one
+from .HasOneThrough import HasOneThrough as has_one_through
+from .MorphMany import MorphMany as morph_many
+from .MorphOne import MorphOne as morph_one
+from .MorphTo import MorphTo as morph_to
+from .MorphToMany import MorphToMany as morph_to_many