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

masoniteorm/models/Pivot.py

@@ -0,0 +1,5 @@
+from .Model import Model
+
+
+class Pivot(Model):
+    __primary_key__ = "id"

masoniteorm/models/__init__.py

@@ -0,0 +1 @@
+from .Model import Model

masoniteorm/observers/ObservesEvents.py

@@ -0,0 +1,27 @@
+class ObservesEvents:
+    def observe_events(self, model, event):
+        if model.__has_events__ == True:
+            for observer in model.__observers__.get(model.__class__, []):
+                try:
+                    getattr(observer, event)(model)
+                except AttributeError:
+                    pass
+
+    @classmethod
+    def observe(cls, observer):
+        if cls in cls.__observers__:
+            cls.__observers__[cls].append(observer)
+        else:
+            cls.__observers__.update({cls: [observer]})
+
+    @classmethod
+    def without_events(cls):
+        """Sets __has_events__ attribute on model to false."""
+        cls.__has_events__ = False
+        return cls
+
+    @classmethod
+    def with_events(cls):
+        """Sets __has_events__ attribute on model to True."""
+        cls.__has_events__ = True
+        return cls

masoniteorm/observers/__init__.py

@@ -0,0 +1 @@
+from .ObservesEvents import ObservesEvents

masoniteorm/pagination/BasePaginator.py

@@ -0,0 +1,10 @@
+import json
+
+
+class BasePaginator:
+    def __iter__(self):
+        for result in self.result:
+            yield result
+
+    def to_json(self):
+        return json.dumps(self.serialize())

masoniteorm/pagination/LengthAwarePaginator.py

@@ -0,0 +1,34 @@
+import math
+
+from .BasePaginator import BasePaginator
+
+
+class LengthAwarePaginator(BasePaginator):
+    def __init__(self, result, per_page, current_page, total, url=None):
+        self.result = result
+        self.current_page = current_page
+        self.per_page = per_page
+        self.count = len(self.result)
+        self.last_page = int(math.ceil(total / per_page))
+        self.next_page = (
+            (int(self.current_page) + 1) if self.has_more_pages() else None
+        )
+        self.previous_page = (int(self.current_page) - 1) or None
+        self.total = total
+        self.url = url
+
+    def serialize(self, *args, **kwargs):
+        return {
+            "data": self.result.serialize(*args, **kwargs),
+            "meta": {
+                "total": self.total,
+                "next_page": self.next_page,
+                "count": self.count,
+                "previous_page": self.previous_page,
+                "last_page": self.last_page,
+                "current_page": self.current_page,
+            },
+        }
+
+    def has_more_pages(self):
+        return self.current_page < self.last_page

masoniteorm/pagination/SimplePaginator.py

@@ -0,0 +1,28 @@
+from .BasePaginator import BasePaginator
+
+
+class SimplePaginator(BasePaginator):
+    def __init__(self, result, per_page, current_page, url=None):
+        self.result = result
+        self.current_page = current_page
+        self.per_page = per_page
+        self.count = len(self.result)
+        self.next_page = (
+            (int(self.current_page) + 1) if self.has_more_pages() else None
+        )
+        self.previous_page = (int(self.current_page) - 1) or None
+        self.url = url
+
+    def serialize(self, *args, **kwargs):
+        return {
+            "data": self.result.serialize(*args, **kwargs),
+            "meta": {
+                "next_page": self.next_page,
+                "count": self.count,
+                "previous_page": self.previous_page,
+                "current_page": self.current_page,
+            },
+        }
+
+    def has_more_pages(self):
+        return len(self.result) > self.per_page

masoniteorm/pagination/__init__.py

@@ -0,0 +1,2 @@
+from .LengthAwarePaginator import LengthAwarePaginator
+from .SimplePaginator import SimplePaginator

masoniteorm/providers/ORMProvider.py

@@ -0,0 +1,39 @@
+from masonite.providers import Provider
+
+from masoniteorm.commands import (
+    MakeMigrationCommand,
+    MakeModelCommand,
+    MakeObserverCommand,
+    MakeSeedCommand,
+    MigrateCommand,
+    MigrateRefreshCommand,
+    MigrateResetCommand,
+    MigrateRollbackCommand,
+    MigrateStatusCommand,
+    SeedRunCommand,
+)
+
+
+class ORMProvider(Provider):
+    """Masonite ORM database provider to be used inside
+    Masonite based projects."""
+
+    def __init__(self, application):
+        self.application = application
+
+    def register(self):
+        self.application.make("commands").add(
+            MakeMigrationCommand(),
+            MakeSeedCommand(),
+            MakeObserverCommand(),
+            MigrateCommand(),
+            MigrateResetCommand(),
+            MakeModelCommand(),
+            MigrateStatusCommand(),
+            MigrateRefreshCommand(),
+            MigrateRollbackCommand(),
+            SeedRunCommand(),
+        ),
+
+    def boot(self):
+        pass

masoniteorm/providers/__init__.py

@@ -0,0 +1 @@
+from .ORMProvider import ORMProvider

masoniteorm/query/EagerRelation.py

@@ -0,0 +1,42 @@
+class EagerRelations:
+    def __init__(self, relation=None):
+        self.eagers = []
+        self.nested_eagers = {}
+        self.callback_eagers = {}
+        self.is_nested = False
+        self.relation = relation
+
+    def register(self, *relations, callback=None):
+        for relation in relations:
+            if isinstance(relation, str) and "." not in relation:
+                self.eagers += [relation]
+            elif isinstance(relation, str) and "." in relation:
+                self.is_nested = True
+                relation_key = relation.split(".")[0]
+                if relation_key not in self.nested_eagers:
+                    self.nested_eagers = {
+                        relation_key: relation.split(".")[1:]
+                    }
+                else:
+                    self.nested_eagers[relation_key] += relation.split(".")[1:]
+            elif isinstance(relation, (tuple, list)):
+                for eagers in relations:
+                    for eager in eagers:
+                        self.register(eager)
+            elif isinstance(relation, dict):
+                self.callback_eagers.update(relation)
+
+        return self
+
+    def get_eagers(self):
+        eagers = []
+        if self.eagers:
+            eagers.append(self.eagers)
+
+        if self.nested_eagers:
+            eagers.append(self.nested_eagers)
+
+        if self.callback_eagers:
+            eagers.append(self.callback_eagers)
+
+        return eagers