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

autonomous/auth/user.py

@@ -5,7 +5,7 @@ This module provides a User class that uses the OpenIDAuth class for authenticat
 from datetime import datetime
 
 from autonomous import log
-from autonomous.model.autoattribute import AutoAttribute
+from autonomous.model.autoattr import DateTimeAttr, StringAttr
 from autonomous.model.automodel import AutoModel
 
 
@@ -14,15 +14,13 @@ class AutoUser(AutoModel):
     This class represents a user who can authenticate using OpenID.
     """
 
-    attributes = {
-        "name": AutoAttribute("TEXT"),
-        "email": AutoAttribute("TEXT", required=True),
-        "last_login": datetime.now(),
-        "state": "unauthenticated",
-        "provider": None,
-        "role": "user",
-        "token": None,
-    }
+    name = StringAttr(default="Anonymous")
+    email = StringAttr(required=True)
+    last_login = DateTimeAttr(default=datetime.now)
+    state = StringAttr(default="unauthenticated")
+    provider = StringAttr()
+    role = StringAttr(default="guest")
+    token = StringAttr()
 
     def __eq__(self, other):
         return self.pk == other.pk

autonomous/model/autoattr.py

@@ -0,0 +1,105 @@
+from mongoengine.base import (
+    get_document,
+)
+from mongoengine.fields import (
+    BooleanField,
+    DateTimeField,
+    DictField,
+    DoesNotExist,
+    EmailField,
+    EnumField,
+    FileField,
+    FloatField,
+    GenericReferenceField,
+    ImageField,
+    IntField,
+    ListField,
+    StringField,
+)
+
+from autonomous import log
+
+
+class StringAttr(StringField):
+    pass
+
+
+class IntAttr(IntField):
+    pass
+
+
+class FloatAttr(FloatField):
+    pass
+
+
+class BoolAttr(BooleanField):
+    pass
+
+
+class DateTimeAttr(DateTimeField):
+    pass
+
+
+class EmailAttr(EmailField):
+    pass
+
+
+class FileAttr(FileField):
+    pass
+
+
+class ImageAttr(ImageField):
+    pass
+
+
+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
+            return None
+
+
+class ListAttr(ListField):
+    def clean_references(self, values):
+        safe_values = []
+        updated = False
+
+        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
+
+
+class DictAttr(DictField):
+    def clean_references(self, values):
+        safe_values = {}
+        updated = False
+        for key, value in values.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
+            except DoesNotExist:
+                updated = True
+
+        return safe_values, updated
+
+
+class EnumAttr(EnumField):
+    pass

autonomous/model/automodel.py

@@ -1,222 +1,51 @@
-# opt : Optional[str]  # for optional attributes
-# default : Optional[str] = "value"  # for default values
-import copy
 import importlib
-
-# import traceback
-from abc import ABC
+import os
+import urllib.parse
 from datetime import datetime
 
-from autonomous import log
-from autonomous.errors import DanglingReferenceError
-
-from .autoattribute import AutoAttribute
-from .orm import ORM
-from .serializer import AutoDecoder, AutoEncoder
-
-
-class DelayedModel:
-    def __init__(self, model, pk):
-        # log(model, pk)
-        assert model
-        assert pk
-        module_name, class_name = model.rsplit(".", 1)
-        try:
-            module = importlib.import_module(module_name)
-            model = getattr(module, class_name)
-        except (ModuleNotFoundError, AttributeError) as e:
-            # stack = traceback.extract_stack()
-            # function_names = [
-            #     f"{frame.filename}:{frame.lineno} - {frame.name} "
-            #     for frame in stack[:-1]
-            #     if "__" not in frame.filename
-            # ]
-            # log(e, *function_names)
-            raise DanglingReferenceError(model, pk, None)
-        else:
-            object.__setattr__(self, "_delayed_model", model)
-            object.__setattr__(self, "_delayed_pk", pk)
-            object.__setattr__(self, "_delayed_obj", None)
-
-    def _instance(self):
-        #### DO NOT TO ANY LOGGING IN THIS METHOD; IT CAUSES INFINITE RECURSION ####
-        if not object.__getattribute__(self, "_delayed_obj"):
-            _pk = object.__getattribute__(self, "_delayed_pk")
-            _model = object.__getattribute__(self, "_delayed_model")
-            _obj = _model.get(_pk)
-            if not _pk or not _model or _obj is None:
-                raise DanglingReferenceError(_model, _pk, _obj)
-            else:
-                object.__setattr__(self, "_delayed_obj", _obj)
-
-        return object.__getattribute__(self, "_delayed_obj")
-
-    def __getattribute__(self, name):
-        # log(name)
-        if name in [
-            "_delayed_model",
-            "_delayed_pk",
-            "_delayed_obj",
-            "_instance",
-        ]:
-            return object.__getattribute__(self, name)
-        try:
-            return object.__getattribute__(self._instance(), name)
-        except DanglingReferenceError as e:
-            log(e)
-            return None
-
-    def __setattr__(self, name, value):
-        if name.startswith("_delayed"):
-            object.__setattr__(self, name, value)
-        else:
-            setattr(self._instance(), name, value)
-
-    def __delattr__(self, name):
-        delattr(self._instance(), name)
-
-    def __nonzero__(self):
-        return bool(self._instance())
-
-    def __str__(self):
-        return str(self._instance().__dict__)
-
-    def __repr__(self):
-        msg = f"\n<<DelayedModel {self._delayed_model.__name__}:{self._delayed_pk}>>"
-        return msg
-
-    def __hash__(self):
-        return hash(self._instance())
-
+from bson import ObjectId
+from mongoengine import Document, connect
+from mongoengine.fields import DateTimeField
 
-class AutoModel(ABC):
-    attributes = {}
-    _table_name = ""
-    _table = None
-    _orm = ORM
-
-    def __new__(cls, *args, **kwargs):
-        """
-        Create a new instance of the AutoModel.
-
-        This method is responsible for creating a new instance of the AutoModel class.
-        It sets default attributes, populates the object from the database if a primary key is provided,
-        and handles additional keyword arguments.
-
-        Args:
-            cls: The class itself.
-            *args: Positional arguments.
-            **kwargs: Keyword arguments, including 'pk' for primary key.
-
-        Returns:
-            obj: The created AutoModel instance.
-        """
-        obj = super().__new__(cls)
-        pk = kwargs.pop("pk", None)
-        # set default attributes
-        # Get model data from database
-        result = cls.table().get(pk) or {}
+from autonomous import log
 
-        # set object attributes
-        for k, v in cls.attributes.items():
-            if isinstance(v, AutoAttribute):
-                v = v.default
-            setattr(obj, k, result.get(k, copy.deepcopy(v)))
-        obj.pk = pk
-        for key, val in list(kwargs.items()):
-            if (
-                getattr(cls, key, None)
-                and getattr(cls, key).fset
-                and f"_{key}" in cls.attributes
-            ):
-                kwargs[f"_{key}"] = kwargs.pop(key)
-        obj.__dict__ |= kwargs
-        # breakpoint()
-        obj.__dict__ = AutoDecoder.decode(obj.__dict__)
-        obj._automodel = obj.model_name(qualified=True)
-        obj.last_updated = datetime.now()
-        return obj
+from .autoattr import DictAttr, ListAttr
 
-    def __getattribute__(self, name):
-        obj = super().__getattribute__(name)
-        if not name.startswith("__"):
-            if isinstance(obj, DelayedModel):
-                try:
-                    result = obj._instance()
-                except DanglingReferenceError as e:
-                    log(e)
-                    super().__setattr__(name, None)
-                    return None
-                else:
-                    super().__setattr__(name, result)
+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}")
 
-            elif isinstance(obj, list):
-                results = []
-                scrubbed = False
-                for i, item in enumerate(obj):
-                    if isinstance(item, DelayedModel):
-                        try:
-                            result = item._instance()
-                        except DanglingReferenceError as e:
-                            log(e)
-                            scrubbed = True
-                        else:
-                            results.append(result)
-                if scrubbed:
-                    super().__setattr__(name, results)
-                    obj = results
 
-            elif isinstance(obj, dict):
-                results = {}
-                scrubbed = False
-                for key, item in obj.items():
-                    if isinstance(item, DelayedModel):
-                        try:
-                            result = item._instance()
-                        except DanglingReferenceError as e:
-                            log(e)
-                            scrubbed = True
-                        else:
-                            results[key] = result
-                    if scrubbed:
-                        super().__setattr__(name, results)
-                        obj = results
-        return obj
+class AutoModel(Document):
+    meta = {"abstract": True, "allow_inheritance": True}
+    last_updated = DateTimeField(default=datetime.now)
 
-    def __str__(self) -> str:
-        return self.__repr__()
+    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 __repr__(self) -> str:
-        """
-        Return a string representation of the AutoModel instance.
+        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")}"
+            # )
 
-        Returns:
-            str: A string representation of the AutoModel instance.
-        """
-        return str(self.__dict__)
+            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)
 
     def __eq__(self, other):
         return self.pk == other.pk if other else False
 
-    @classmethod
-    def load_model(cls, model, module=None):
-        if not module:
-            module = f"models.{model.lower()}"
-        module = importlib.import_module(module)
-        return getattr(module, model)
-
-    @classmethod
-    def table(cls):
-        # breakpoint()
-        if not cls._table or cls._table.name != cls.__name__:
-            cls.attributes["pk"] = None
-            cls.attributes["last_updated"] = datetime.now()
-            cls.attributes["_automodel"] = AutoAttribute(
-                "TEXT", default=cls.model_name(qualified=True)
-            )
-            cls._table = cls._orm(cls._table_name or cls.__name__, cls.attributes)
-        return cls._table
-
     @classmethod
     def model_name(cls, qualified=False):
         """
@@ -227,74 +56,11 @@ class AutoModel(ABC):
         """
         return f"{cls.__module__}.{cls.__name__}" if qualified else cls.__name__
 
-    @property
-    def _id(self):
-        """
-        Get the primary key of this model.
-
-        Returns:
-            int: The primary key of this model.
-        """
-        return self.pk
-
-    @_id.setter
-    def _id(self, _id):
-        """
-        Get the primary key of this model.
-
-        Returns:
-            int: The primary key of this model.
-        """
-        self.pk = str(_id)
-
-    def validate(self):
-        """
-        Validate this model.
-        """
-        for key, vattr in self.attributes.items():
-            if isinstance(vattr, AutoAttribute):
-                val = getattr(self, key)
-                if vattr.type == "TEXT":
-                    if not isinstance(val, str):
-                        raise TypeError(
-                            f"{key} value must be a string, not {type(val)}"
-                        )
-                elif vattr.type == "NUMERIC":
-                    if not isinstance(val, (int, float)):
-                        raise TypeError(
-                            f"{key} value must be a number, not {type(val)}"
-                        )
-                elif vattr.type == "MODEL":
-                    # log(isinstance(val, (AutoModel, DelayedModel)), type(val))
-                    if val is not None and not isinstance(
-                        val, (AutoModel, DelayedModel)
-                    ):
-                        raise TypeError(
-                            f"{key} value must be an AutoModel or None, not {type(val)}"
-                        )
-                else:
-                    raise ValueError(f"{key}: Invalid type {self.type}")
-
-                if vattr.required and val is None:
-                    raise ValueError(f"{key} is required")
-                if vattr.unique and len(self.search(**{key: val})) > 1:
-                    raise ValueError(f"{key} must be unique")
-                if vattr.primary_key:
-                    self.pk = val
-
-    def save(self):
-        """
-        Save this model to the database.
-
-        Returns:
-            int: The primary key (pk) of the saved model.
-        """
-        self.validate()
-        serialized_obj = self.serialize()
-        serialized_obj["pk"] = self.pk
-        self.pk = self.table().save(serialized_obj)
-
-        return self.pk
+    @classmethod
+    def load_model(cls, model):
+        module_name, model = model.rsplit(".", 1) if "." in model else ("models", model)
+        module = importlib.import_module(module_name)
+        return getattr(module, model)
 
     @classmethod
     def get(cls, pk):
@@ -307,10 +73,13 @@ class AutoModel(ABC):
         Returns:
             AutoModel or None: The retrieved AutoModel instance, or None if not found.
         """
-        table = cls.table()
-        result = table.get(pk)
-        obj = cls(**result) if result else None
-        return obj
+        if pk and isinstance(pk, str):
+            pk = ObjectId(pk)
+        try:
+            return cls.objects(pk=pk).get()
+        except Exception as e:
+            log(e)
+            return None
 
     @classmethod
     def random(cls):
@@ -323,9 +92,11 @@ class AutoModel(ABC):
         Returns:
             AutoModel or None: The retrieved AutoModel instance, or None if not found.
         """
-        result = cls.table().random()
-        # breakpoint()
-        return cls(**result) if result else None
+        pipeline = [{"$sample": {"size": 1}}]
+
+        result = cls.objects.aggregate(pipeline)
+        random_document = next(result, None)
+        return cls._from_son(random_document) if random_document else None
 
     @classmethod
     def all(cls):
@@ -335,10 +106,10 @@ class AutoModel(ABC):
         Returns:
             list: A list of AutoModel instances.
         """
-        return [cls(**o) for o in cls.table().all()]
+        return list(cls.objects())
 
     @classmethod
-    def search(cls, **kwargs):
+    def search(cls, _order_by=None, _limit=None, **kwargs):
         """
         Search for models containing the keyword values.
 
@@ -348,9 +119,15 @@ class AutoModel(ABC):
         Returns:
             list: A list of AutoModel instances that match the search criteria.
         """
-        for k, v in kwargs.items():
-            kwargs[k] = AutoEncoder.encode(v)
-        return [cls(**attribs) for attribs in cls.table().search(**kwargs)]
+        results = cls.objects(**kwargs)
+        if _order_by:
+            results = results.order_by(*_order_by)
+        if _limit:
+            if isinstance(_limit, list):
+                results = results[_limit[0] : _limit[-1]]
+            else:
+                results = results[:_limit]
+        return list(results)
 
     @classmethod
     def find(cls, **kwargs):
@@ -363,38 +140,20 @@ class AutoModel(ABC):
         Returns:
             AutoModel or None: The first matching AutoModel instance, or None if not found.
         """
-        for k, v in kwargs.items():
-            kwargs[k] = AutoEncoder.encode(v)
-        attribs = cls.table().find(**kwargs)
-        return cls(**attribs) if attribs else None
+        return cls.objects(**kwargs).first()
 
-    def update(self, values):
+    def save(self):
         """
-        Delete this model from the database.
+        Save this model to the database.
+
+        Returns:
+            int: The primary key (pk) of the saved model.
         """
-        if not isinstance(values, dict):
-            raise ValueError("Values must be a dictionary")
-        for k, v in values.items():
-            if k in self.attributes or f"_{k}" in self.attributes:
-                if getattr(self.__class__, k, None) and getattr(self.__class__, k).fset:
-                    getattr(self.__class__, k).fset(self, v)
-                elif k in self.attributes:
-                    setattr(self, k, v)
-        self.save()
+        # log(self.model_dump_json())
+        return super().save()
 
     def delete(self):
         """
         Delete this model from the database.
         """
-        return self.table().delete(self.pk)
-
-    def serialize(self):
-        """
-        Serialize this model to a dictionary.
-
-        Returns:
-            dict: A dictionary representation of the serialized model.
-        """
-        vars = {k: v for k, v in self.__dict__.items() if k in self.attributes}
-        json_vars = AutoEncoder.encode(vars)
-        return json_vars
+        return super().delete()

autonomous/storage/imagestorage.py

@@ -1,4 +1,3 @@
-import glob
 import io
 import os
 import shutil
@@ -15,12 +14,6 @@ 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("/"):
@@ -75,10 +68,10 @@ class ImageStorage:
         if not asset_id:
             return ""
         original_path = f"{self.get_path(asset_id)}"
-        # log(f"Getting image: {asset_id}", original_path)
+        # log(f"Getting image: {asset_id}.{size}", original_path)
         if not os.path.exists(original_path):
             log(f"Original image not found: {original_path}")
-            return None
+            return ""
         file_path = f"{original_path}/{size}.webp"
         # log(file_path)
         result_url = f"/{file_path}"
@@ -88,11 +81,7 @@ class ImageStorage:
         #     os.path.exists(original_path),
         #     os.path.exists(file_path),
         # )
-        if (
-            size != "orig"
-            and os.path.exists(original_path)
-            and not os.path.exists(file_path)
-        ):
+        if size != "orig" and not os.path.exists(file_path):
             # If the file doesn't exist, create it
             if result := self._resize_image(asset_id, size):
                 with open(file_path, "wb") as asset:
@@ -115,7 +104,10 @@ class ImageStorage:
 
     def get_path(self, asset_id):
         if asset_id:
-            return os.path.join(self.base_path, f"{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}")
         else:
             return self.base_path
 
@@ -132,45 +124,8 @@ 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):
-            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)
+            shutil.rmtree(file_path)
+            return True
         return False