masonite-orm 2.20.0__tar.gz → 2.22.0__tar.gz

{masonite-orm-2.20.0/src/masonite_orm.egg-info → masonite-orm-2.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: masonite-orm
-Version: 2.20.0
+Version: 2.22.0
 Summary: The Official Masonite ORM
 Home-page: https://github.com/masoniteframework/orm
 Author: Joe Mancuso

{masonite-orm-2.20.0 → masonite-orm-2.22.0}/setup.py

@@ -8,7 +8,7 @@ setup(
     # Versions should comply with PEP440.  For a discussion on single-sourcing
     # the version across setup.py and the project code, see
     # https://packaging.python.org/en/latest/single_source_version.html
-    version="2.20.0",
+    version="2.22.0",
     package_dir={"": "src"},
     description="The Official Masonite ORM",
     long_description=long_description,

{masonite-orm-2.20.0 → masonite-orm-2.22.0/src/masonite_orm.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: masonite-orm
-Version: 2.20.0
+Version: 2.22.0
 Summary: The Official Masonite ORM
 Home-page: https://github.com/masoniteframework/orm
 Author: Joe Mancuso

{masonite-orm-2.20.0 → masonite-orm-2.22.0}/src/masoniteorm/collection/Collection.py

@@ -40,6 +40,7 @@ class Collection:
         if callback:
             filtered = self.filter(callback)
         response = None
+
         if filtered:
             response = filtered[0]
         return response
@@ -91,15 +92,15 @@ class Collection:
         return result
 
     def max(self, key=None):
-        """Returns the average of the items.
+        """Returns the max of the items.
 
-        If a key is given it will return the average of all the values of the key.
+        If a key is given it will return the max of all the values of the key.
 
         Keyword Arguments:
-            key {string} -- The key to use to find the average of all the values of that key. (default: {None})
+            key {string} -- The key to use to find the max of all the values of that key. (default: {None})
 
         Returns:
-            int -- Returns the average.
+            int -- Returns the max.
         """
         result = 0
         items = self._get_value(key) or self._items
@@ -110,6 +111,26 @@ class Collection:
             pass
         return result
 
+    def min(self, key=None):
+        """Returns the min of the items.
+
+        If a key is given it will return the min of all the values of the key.
+
+        Keyword Arguments:
+            key {string} -- The key to use to find the min of all the values of that key. (default: {None})
+
+        Returns:
+            int -- Returns the min.
+        """
+        result = 0
+        items = self._get_value(key) or self._items
+
+        try:
+            return min(items)
+        except (TypeError, ValueError):
+            pass
+        return result
+
     def chunk(self, size: int):
         """Chunks the items.
 
@@ -323,7 +344,7 @@ class Collection:
 
     def add_relation(self, result=None):
         for model in self._items:
-            model.add_relations(result or {})
+            model.add_relation(result or {})
 
         return self
 
@@ -512,8 +533,13 @@ class Collection:
     def __getitem__(self, item):
         if isinstance(item, slice):
             return self.__class__(self._items[item])
+        if isinstance(item, dict):
+            return self._items.get(item, None)
 
-        return self._items[item]
+        try:
+            return self._items[item]
+        except KeyError:
+            return None
 
     def __setitem__(self, key, value):
         self._items[key] = value

{masonite-orm-2.20.0 → masonite-orm-2.22.0}/src/masoniteorm/connections/MySQLConnection.py

@@ -124,6 +124,9 @@ class MySQLConnection(BaseConnection):
         """Transaction"""
         self._connection.rollback()
         self.transaction_level -= 1
+        if self.get_transaction_level() <= 0:
+            self.open = 0
+            self._connection.close()
 
     def get_transaction_level(self):
         """Transaction"""

{masonite-orm-2.20.0 → masonite-orm-2.22.0}/src/masoniteorm/models/Model.py

@@ -810,6 +810,23 @@ class Model(TimeStampsMixin, ObservesEvents, metaclass=ModelMeta):
 
         return None
 
+    def only(self, attributes: list) -> dict:
+        if isinstance(attributes, str):
+            attributes = [attributes]
+        results: dict[str, Any] = {}
+        for attribute in attributes:
+            if " as " in attribute:
+                attribute, alias = attribute.split(" as ")
+                alias = alias.strip()
+                attribute = attribute.strip()
+            else:
+                alias = attribute.strip()
+                attribute = attribute.strip()
+
+            results[alias] = self.get_raw_attribute(attribute)
+
+        return results
+
     def __setattr__(self, attribute, value):
         if hasattr(self, "set_" + attribute + "_attribute"):
             method = getattr(self, "set_" + attribute + "_attribute")

{masonite-orm-2.20.0 → masonite-orm-2.22.0}/src/masoniteorm/query/QueryBuilder.py

@@ -1441,10 +1441,16 @@ class QueryBuilder(ObservesEvents):
             date_fields = model.get_dates()
             for key, value in updates.items():
                 if key in date_fields:
-                    updates[key] = model.get_new_datetime_string(value)
+                    if value:
+                        updates[key] = model.get_new_datetime_string(value)
+                    else:
+                        updates[key] = value
                 # Cast value if necessary
                 if cast:
-                    updates[key] = model.cast_value(value)
+                    if value:
+                        updates[key] = model.cast_value(value)
+                    else:
+                        updates[key] = value
         elif not updates:
             # Do not perform query if there are no updates
             return self
@@ -1945,16 +1951,23 @@ class QueryBuilder(ObservesEvents):
         Returns:
             self
         """
-        if isinstance(hydrated_model, Collection):
+        if related_result and isinstance(hydrated_model, Collection):
+            map_related = self._map_related(related_result, related)
             for model in hydrated_model:
                 if isinstance(related_result, Collection):
-                    related.register_related(relation_key, model, related_result)
+                    related.register_related(relation_key, model, map_related)
                 else:
                     model.add_relation({relation_key: related_result or None})
         else:
             hydrated_model.add_relation({relation_key: related_result or None})
         return self
 
+    def _map_related(self, related_result, related):
+        if related.__class__.__name__ == 'MorphTo':
+            return related_result
+
+        return related_result.group_by(related.foreign_key)
+
     def all(self, selects=[], query=False):
         """Returns all records from the table.
 

{masonite-orm-2.20.0 → masonite-orm-2.22.0}/src/masoniteorm/relationships/BelongsTo.py

@@ -63,8 +63,6 @@ class BelongsTo(BaseRelationship):
             ).first()
 
     def register_related(self, key, model, collection):
-        related = collection.where(
-            self.foreign_key, getattr(model, self.local_key)
-        ).first()
+        related = collection.get(getattr(model, self.local_key), None)
 
-        model.add_relation({key: related or None})
+        model.add_relation({key: related[0] if related else None})

{masonite-orm-2.20.0 → masonite-orm-2.22.0}/src/masoniteorm/relationships/HasMany.py

@@ -28,5 +28,5 @@ class HasMany(BaseRelationship):
 
     def register_related(self, key, model, collection):
         model.add_relation(
-            {key: collection.where(self.foreign_key, getattr(model, self.local_key))}
+            {key: collection.get(getattr(model, self.local_key)) or Collection()}
         )

{masonite-orm-2.20.0 → masonite-orm-2.22.0}/src/masoniteorm/relationships/MorphTo.py

@@ -50,7 +50,7 @@ class MorphTo(BaseRelationship):
 
     def __getattr__(self, attribute):
         relationship = self.fn(self)()
-        return getattr(relationship.builder, attribute)
+        return getattr(relationship._related_builder, attribute)
 
     def apply_query(self, builder, instance):
         """Apply the query and return a dictionary to be hydrated

{masonite-orm-2.20.0 → masonite-orm-2.22.0}/src/masoniteorm/scopes/TimeStampsScope.py

@@ -35,6 +35,9 @@ class TimeStampsScope(BaseScope):
         if not builder._model.__timestamps__:
             return builder
 
+        for update in builder._updates:
+            if builder._model.date_updated_at in update.column:
+                return
         builder._updates += (
             UpdateQueryExpression(
                 {