autonomous-app 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

autonomous/db/queryset/visitor.py

@@ -0,0 +1,189 @@
+import copy
+import warnings
+
+from autonomous.db.errors import InvalidQueryError
+from autonomous.db.queryset import transform
+
+__all__ = ("Q", "QNode")
+
+
+def warn_empty_is_deprecated():
+    msg = "'empty' property is deprecated in favour of using 'not bool(filter)'"
+    warnings.warn(msg, DeprecationWarning, stacklevel=2)
+
+
+class QNodeVisitor:
+    """Base visitor class for visiting Q-object nodes in a query tree."""
+
+    def visit_combination(self, combination):
+        """Called by QCombination objects."""
+        return combination
+
+    def visit_query(self, query):
+        """Called by (New)Q objects."""
+        return query
+
+
+class DuplicateQueryConditionsError(InvalidQueryError):
+    pass
+
+
+class SimplificationVisitor(QNodeVisitor):
+    """Simplifies query trees by combining unnecessary 'and' connection nodes
+    into a single Q-object.
+    """
+
+    def visit_combination(self, combination):
+        if combination.operation == combination.AND:
+            # The simplification only applies to 'simple' queries
+            if all(isinstance(node, Q) for node in combination.children):
+                queries = [n.query for n in combination.children]
+                try:
+                    return Q(**self._query_conjunction(queries))
+                except DuplicateQueryConditionsError:
+                    # Cannot be simplified
+                    pass
+        return combination
+
+    def _query_conjunction(self, queries):
+        """Merges query dicts - effectively &ing them together."""
+        query_ops = set()
+        combined_query = {}
+        for query in queries:
+            ops = set(query.keys())
+            # Make sure that the same operation isn't applied more than once
+            # to a single field
+            intersection = ops.intersection(query_ops)
+            if intersection:
+                raise DuplicateQueryConditionsError()
+
+            query_ops.update(ops)
+            combined_query.update(copy.deepcopy(query))
+        return combined_query
+
+
+class QueryCompilerVisitor(QNodeVisitor):
+    """Compiles the nodes in a query tree to a PyMongo-compatible query
+    dictionary.
+    """
+
+    def __init__(self, document):
+        self.document = document
+
+    def visit_combination(self, combination):
+        operator = "$and"
+        if combination.operation == combination.OR:
+            operator = "$or"
+        return {operator: combination.children}
+
+    def visit_query(self, query):
+        return transform.query(self.document, **query.query)
+
+
+class QNode:
+    """Base class for nodes in query trees."""
+
+    AND = 0
+    OR = 1
+
+    def to_query(self, document):
+        query = self.accept(SimplificationVisitor())
+        query = query.accept(QueryCompilerVisitor(document))
+        return query
+
+    def accept(self, visitor):
+        raise NotImplementedError
+
+    def _combine(self, other, operation):
+        """Combine this node with another node into a QCombination
+        object.
+        """
+        # If the other Q() is empty, ignore it and just use `self`.
+        if not bool(other):
+            return self
+
+        # Or if this Q is empty, ignore it and just use `other`.
+        if not bool(self):
+            return other
+
+        return QCombination(operation, [self, other])
+
+    @property
+    def empty(self):
+        warn_empty_is_deprecated()
+        return False
+
+    def __or__(self, other):
+        return self._combine(other, self.OR)
+
+    def __and__(self, other):
+        return self._combine(other, self.AND)
+
+
+class QCombination(QNode):
+    """Represents the combination of several conditions by a given
+    logical operator.
+    """
+
+    def __init__(self, operation, children):
+        self.operation = operation
+        self.children = []
+        for node in children:
+            # If the child is a combination of the same type, we can merge its
+            # children directly into this combinations children
+            if isinstance(node, QCombination) and node.operation == operation:
+                self.children += node.children
+            else:
+                self.children.append(node)
+
+    def __repr__(self):
+        op = " & " if self.operation is self.AND else " | "
+        return "(%s)" % op.join([repr(node) for node in self.children])
+
+    def __bool__(self):
+        return bool(self.children)
+
+    def accept(self, visitor):
+        for i in range(len(self.children)):
+            if isinstance(self.children[i], QNode):
+                self.children[i] = self.children[i].accept(visitor)
+
+        return visitor.visit_combination(self)
+
+    @property
+    def empty(self):
+        warn_empty_is_deprecated()
+        return not bool(self.children)
+
+    def __eq__(self, other):
+        return (
+            self.__class__ == other.__class__
+            and self.operation == other.operation
+            and self.children == other.children
+        )
+
+
+class Q(QNode):
+    """A simple query object, used in a query tree to build up more complex
+    query structures.
+    """
+
+    def __init__(self, **query):
+        self.query = query
+
+    def __repr__(self):
+        return "Q(**%s)" % repr(self.query)
+
+    def __bool__(self):
+        return bool(self.query)
+
+    def __eq__(self, other):
+        return self.__class__ == other.__class__ and self.query == other.query
+
+    def accept(self, visitor):
+        return visitor.visit_query(self)
+
+    @property
+    def empty(self):
+        warn_empty_is_deprecated()
+        return not bool(self.query)

autonomous/db/signals.py

@@ -0,0 +1,59 @@
+__all__ = (
+    "pre_init",
+    "post_init",
+    "pre_save",
+    "pre_save_post_validation",
+    "post_save",
+    "pre_delete",
+    "post_delete",
+)
+
+signals_available = False
+try:
+    from blinker import Namespace
+
+    signals_available = True
+except ImportError:
+
+    class Namespace:
+        def signal(self, name, doc=None):
+            return _FakeSignal(name, doc)
+
+    class _FakeSignal:
+        """If blinker is unavailable, create a fake class with the same
+        interface that allows sending of signals but will fail with an
+        error on anything else.  Instead of doing anything on send, it
+        will just ignore the arguments and do nothing instead.
+        """
+
+        def __init__(self, name, doc=None):
+            self.name = name
+            self.__doc__ = doc
+
+        def _fail(self, *args, **kwargs):
+            raise RuntimeError(
+                "signalling support is unavailable "
+                "because the blinker library is "
+                "not installed."
+            )
+
+        send = lambda *a, **kw: None  # noqa
+        connect = disconnect = has_receivers_for = receivers_for = (
+            temporarily_connected_to
+        ) = _fail
+        del _fail
+
+
+# the namespace for code signals.  If you are not autonomous.db code, do
+# not put signals in here.  Create your own namespace instead.
+_signals = Namespace()
+
+pre_init = _signals.signal("pre_init")
+post_init = _signals.signal("post_init")
+pre_save = _signals.signal("pre_save")
+pre_save_post_validation = _signals.signal("pre_save_post_validation")
+post_save = _signals.signal("post_save")
+pre_delete = _signals.signal("pre_delete")
+post_delete = _signals.signal("post_delete")
+pre_bulk_insert = _signals.signal("pre_bulk_insert")
+post_bulk_insert = _signals.signal("post_bulk_insert")

autonomous/logger.py

@@ -43,6 +43,7 @@ class Logger:
 
     def __call__(self, *args, **kwargs):
         if self.enabled:
+            is_printed = kwargs.pop("_print", False)
             caller = inspect.stack()[1]
             fn = caller.filename.split("/")[-1]
             msg = f"\n\n{'='*20}\t{fn}:{caller.function}()::{caller.lineno}\t{'='*20}\n"
@@ -57,6 +58,8 @@ class Logger:
                 current.write(f"{msg}\n")
             with open(self.logarchive, "a") as archive:
                 archive.write(f"{msg}\n")
+            if is_printed:
+                print(msg)
 
 
 log = Logger()

autonomous/model/autoattr.py

@@ -1,7 +1,5 @@
-from mongoengine.base import (
-    get_document,
-)
-from mongoengine.fields import (
+from autonomous import log
+from autonomous.db.fields import (
     BooleanField,
     DateTimeField,
     DictField,
@@ -10,6 +8,7 @@ from mongoengine.fields import (
     EnumField,
     FileField,
     FloatField,
+    GenericLazyReferenceField,
     GenericReferenceField,
     ImageField,
     IntField,
@@ -17,8 +16,6 @@ from mongoengine.fields import (
     StringField,
 )
 
-from autonomous import log
-
 
 class StringAttr(StringField):
     pass
@@ -55,50 +52,68 @@ class ImageAttr(ImageField):
 class ReferenceAttr(GenericReferenceField):
     def __get__(self, instance, owner):
         try:
-            # Attempt to retrieve the referenced document
-            return super().__get__(instance, owner)
-        except DoesNotExist:
-            # If the document doesn't exist, return None
+            result = super().__get__(instance, owner)
+        except DoesNotExist as e:
+            log(f"ReferenceAttr Error: {e}")
             return None
+        return result
 
 
-class ListAttr(ListField):
-    def clean_references(self, values):
-        safe_values = []
-        updated = False
+# class ReferenceAttr(GenericLazyReferenceField):
+#     def __get__(self, instance, owner):
+#         try:
+#             result = super().__get__(instance, owner)
+#         except DoesNotExist as e:
+#             log(f"ReferenceAttr Error: {e}")
+#             return None
+#         return result.fetch() if result and result.pk else result
 
-        for value in values:
-            try:
-                if isinstance(value, dict) and "_cls" in value:
-                    doc_cls = get_document(value["_cls"])
-                    value = doc_cls._get_db().dereference(value["_ref"])
-                if value:
-                    safe_values.append(value)
-                else:
-                    updated = True
-            except DoesNotExist:
-                updated = True
-        log("hi")
-        return safe_values, updated
+# except DoesNotExist:
+# If the document doesn't exist, return None
+#    return None
+
+# def validate(self, value):
+#     if value is not None and not self.required:
+#         super().validate(value)
+
+
+class ListAttr(ListField):
+    # pass
+    def __get__(self, instance, owner):
+        # log(instance, owner)
+        results = super().__get__(instance, owner) or []
+        # print(self.name, self.field, owner, results)
+        if isinstance(self.field, ReferenceAttr):
+            i = 0
+            while i < len(results):
+                try:
+                    if not results[i]:
+                        log(f"Removing Object: {results[i]}")
+                        results.pop(i)
+                    else:
+                        i += 1
+                except DoesNotExist:
+                    results.pop(i)
+                    log(f"Object Not Found: {results[i]}")
+        # log(results)
+        return results
 
 
 class DictAttr(DictField):
-    def clean_references(self, values):
-        safe_values = {}
-        updated = False
-        for key, value in values.items():
+    def __get__(self, instance, owner):
+        # log(instance, owner)
+        results = super().__get__(instance, owner) or {}
+        # log(self.name, self.field, owner, results)
+        for key, lazy_obj in results.items():
             try:
-                if isinstance(value, dict) and "_cls" in value:
-                    doc_cls = get_document(value["_cls"])
-                    value = doc_cls._get_db().dereference(value["_ref"])
-                if value:
-                    safe_values[key] = value
-                else:
-                    updated = True
+                if hasattr(lazy_obj, "fetch"):
+                    lazy_obj = (
+                        lazy_obj.fetch() if lazy_obj and lazy_obj.pk else lazy_obj
+                    )
             except DoesNotExist:
-                updated = True
-
-        return safe_values, updated
+                log(f"Object Not Found: {lazy_obj}")
+            results[key] = lazy_obj
+        return results
 
 
 class EnumAttr(EnumField):

autonomous/model/automodel.py

@@ -4,47 +4,54 @@ import urllib.parse
 from datetime import datetime
 
 from bson import ObjectId
-from mongoengine import Document, connect
-from mongoengine.fields import DateTimeField
 
 from autonomous import log
-
-from .autoattr import DictAttr, ListAttr
+from autonomous.db import Document, connect, signals
+from autonomous.db.errors import ValidationError
+from autonomous.db.fields import DateTimeField
+from autonomous.model.autoattr import DictAttr, ListAttr
 
 host = os.getenv("DB_HOST", "db")
 port = os.getenv("DB_PORT", 27017)
 password = urllib.parse.quote_plus(str(os.getenv("DB_PASSWORD")))
 username = urllib.parse.quote_plus(str(os.getenv("DB_USERNAME")))
-db = os.getenv("DB_DB")
-connect(host=f"mongodb://{username}:{password}@{host}:{port}")
+dbname = os.getenv("DB_DB")
+# log(f"Connecting to MongoDB at {host}:{port} with {username}:{password} for {dbname}")
+connect(host=f"mongodb://{username}:{password}@{host}:{port}/{dbname}?authSource=admin")
+# log(f"{db}")
 
 
 class AutoModel(Document):
-    meta = {"abstract": True, "allow_inheritance": True}
+    meta = {"abstract": True, "allow_inheritance": True, "strict": False}
     last_updated = DateTimeField(default=datetime.now)
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        if kwargs.pop("pk", None):
-            self.reload()
-        for k, v in kwargs.items():
-            setattr(self, k, v)
-        self.last_updated = datetime.now()
+    def __eq__(self, other):
+        return self.pk == other.pk if other else False
 
-        for field_name, field in self._fields.items():
-            value = getattr(self, field_name, None)
-            # log(
-            #     f"Field: {field_name}, Type:{type(value)}, Value: {value}, {hasattr(field, "clean_references")}"
-            # )
+    @classmethod
+    def auto_pre_init(cls, sender, document, **kwargs):
+        values = kwargs.pop("values", None)
+        if pk := values.get("pk") or values.get("id"):
+            # Try to load the existing document from the database
+            if existing_doc := sender._get_collection().find_one({"_id": ObjectId(pk)}):
+                # Update the current instance with the existing data
+                existing_doc.pop("_id", None)
+                existing_doc.pop("_cls", None)
+                for k, v in existing_doc.items():
+                    if not values.get(k):
+                        values[k] = v
 
-            if hasattr(field, "clean_references") and value:
-                cleaned_values, updated = field.clean_references(value)
-                # log(f"Cleaned Values: {cleaned_values}")
-                if updated:
-                    setattr(self, field_name, cleaned_values)
+    @classmethod
+    def _auto_pre_init(cls, sender, document, **kwargs):
+        sender.auto_pre_init(sender, document, **kwargs)
 
-    def __eq__(self, other):
-        return self.pk == other.pk if other else False
+    @classmethod
+    def auto_post_init(cls, sender, document, **kwargs):
+        document.last_updated = datetime.now()
+
+    @classmethod
+    def _auto_post_init(cls, sender, document, **kwargs):
+        sender.auto_post_init(sender, document, **kwargs)
 
     @classmethod
     def model_name(cls, qualified=False):
@@ -58,7 +65,9 @@ class AutoModel(Document):
 
     @classmethod
     def load_model(cls, model):
-        module_name, model = model.rsplit(".", 1) if "." in model else ("models", model)
+        module_name, model = (
+            model.rsplit(".", 1) if "." in model else (f"models.{model.lower()}", model)
+        )
         module = importlib.import_module(module_name)
         return getattr(module, model)
 
@@ -73,13 +82,22 @@ class AutoModel(Document):
         Returns:
             AutoModel or None: The retrieved AutoModel instance, or None if not found.
         """
-        if pk and isinstance(pk, str):
+
+        if isinstance(pk, str):
             pk = ObjectId(pk)
+        elif isinstance(pk, dict) and "$oid" in pk:
+            pk = ObjectId(pk["$oid"])
         try:
-            return cls.objects(pk=pk).get()
-        except Exception as e:
-            log(e)
+            return cls.objects.get(id=pk)
+        except cls.DoesNotExist as e:
+            log(f"Model {cls.__name__} with pk {pk} not found : {e}")
+            return None
+        except ValidationError as e:
+            log(f"Model Validation failure {cls.__name__} [{pk}]: {e}")
             return None
+        except Exception as e:
+            log(f"Error getting model {cls.__name__} with pk {pk}: {e}", _print=True)
+            raise e
 
     @classmethod
     def random(cls):
@@ -119,7 +137,14 @@ class AutoModel(Document):
         Returns:
             list: A list of AutoModel instances that match the search criteria.
         """
-        results = cls.objects(**kwargs)
+        new_kwargs = {}
+        for k, v in kwargs.items():
+            if isinstance(v, str):
+                new_k = f"{k}__icontains"
+                new_kwargs[new_k] = v
+            else:
+                new_kwargs[k] = v
+        results = cls.objects(**new_kwargs)
         if _order_by:
             results = results.order_by(*_order_by)
         if _limit:
@@ -142,6 +167,20 @@ class AutoModel(Document):
         """
         return cls.objects(**kwargs).first()
 
+    @classmethod
+    def auto_pre_save(cls, sender, document, **kwargs):
+        """
+        Post-save hook for this model.
+        """
+        pass
+
+    @classmethod
+    def _auto_pre_save(cls, sender, document, **kwargs):
+        """
+        Post-save hook for this model.
+        """
+        sender.auto_pre_save(sender, document, **kwargs)
+
     def save(self):
         """
         Save this model to the database.
@@ -149,11 +188,33 @@ class AutoModel(Document):
         Returns:
             int: The primary key (pk) of the saved model.
         """
-        # log(self.model_dump_json())
-        return super().save()
+        # log(self.to_json())
+        obj = super().save()
+        self.pk = obj.pk
+        return self.pk
+
+    @classmethod
+    def auto_post_save(cls, sender, document, **kwargs):
+        """
+        Post-save hook for this model.
+        """
+        pass
+
+    @classmethod
+    def _auto_post_save(cls, sender, document, **kwargs):
+        """
+        Post-save hook for this model.
+        """
+        sender.auto_post_save(sender, document, **kwargs)
 
     def delete(self):
         """
         Delete this model from the database.
         """
         return super().delete()
+
+
+signals.pre_init.connect(AutoModel._auto_pre_init)
+signals.post_init.connect(AutoModel._auto_post_init)
+signals.pre_save.connect(AutoModel._auto_pre_save)
+signals.post_save.connect(AutoModel._auto_post_save)

autonomous/storage/imagestorage.py

@@ -1,3 +1,4 @@
+import glob
 import io
 import os
 import shutil
@@ -14,6 +15,12 @@ class ImageStorage:
     def __init__(self, path="static/images"):
         self.base_path = path
 
+    def scan_storage(self, path=None):
+        for root, dirs, files in os.walk(path or self.base_path):
+            for file in files:
+                if file == "orig.webp":
+                    yield os.path.join(root, file)
+
     @classmethod
     def _get_key(cls, folder="", pkey=None):
         if folder and not folder.endswith("/"):
@@ -68,10 +75,10 @@ class ImageStorage:
         if not asset_id:
             return ""
         original_path = f"{self.get_path(asset_id)}"
-        # log(f"Getting image: {asset_id}.{size}", original_path)
+        # log(f"Getting image: {asset_id}", original_path)
         if not os.path.exists(original_path):
             log(f"Original image not found: {original_path}")
-            return ""
+            return None
         file_path = f"{original_path}/{size}.webp"
         # log(file_path)
         result_url = f"/{file_path}"
@@ -104,10 +111,7 @@ class ImageStorage:
 
     def get_path(self, asset_id):
         if asset_id:
-            asset_path = asset_id.replace(".", "/")
-            if asset_path.endswith("/"):
-                asset_path = asset_path[:-1]
-            return os.path.join(self.base_path, f"{asset_path}")
+            return os.path.join(self.base_path, f"{asset_id}")
         else:
             return self.base_path
 
@@ -124,8 +128,45 @@ class ImageStorage:
         return imgs
 
     def remove(self, asset_id):
+        if not asset_id:
+            return False
+        file_path = self.get_path(asset_id)
+        if os.path.isdir(file_path):
+            print(f"Removing {file_path}")
+            # return shutil.rmtree(file_path, ignore_errors=True)
+        return False
+
+    def clear_cached(self, asset_id):
         file_path = self.get_path(asset_id)
         if os.path.isdir(file_path):
-            shutil.rmtree(file_path)
-            return True
+            for file in glob.glob(os.path.join(file_path, "*")):
+                if os.path.basename(file) != "orig.webp":
+                    os.remove(file)
+        return False
+
+    def rotate(self, asset_id, amount=-90):
+        file_path = self.get_path(asset_id)
+        log(asset_id)
+        with Image.open(f"{file_path}/orig.webp") as img:
+            # Rotate the image 90 degrees
+            rotated_img = img.rotate(amount, expand=True)
+            # Save the rotated image
+            log(img, rotated_img)
+            # img = img.copy()
+            # img_byte_arr = io.BytesIO()
+            # img.save(img_byte_arr, )
+            self.clear_cached(asset_id)
+            rotated_img.save(f"{file_path}/orig.webp", format="WEBP")
+        return False
+
+    def flip(self, asset_id, flipx=True, flipy=True):
+        file_path = self.get_path(asset_id)
+        with Image.open(f"{file_path}/orig.webp") as img:
+            if flipx:
+                rotated_img = img.transpose(Image.FLIP_LEFT_RIGHT)
+            if flipy:
+                rotated_img = img.transpose(Image.FLIP_TOP_BOTTOM)
+            # Save the rotated image
+            rotated_img.save(f"{file_path}/orig.webp", format="WEBP")
+            self.clear_cached(asset_id)
         return False