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

autonomous/model/automodel.py

@@ -1,221 +1,57 @@
-# 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 autonomous import log
+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
 
-class AutoModel(ABC):
-    attributes = {}
-    _table_name = ""
-    _table = None
-    _orm = ORM
+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")))
+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}")
 
-    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 {}
-
-        # 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
-
-    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)
-
-            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
-
-    def __str__(self) -> str:
-        return self.__repr__()
-
-    def __repr__(self) -> str:
-        """
-        Return a string representation of the AutoModel instance.
-
-        Returns:
-            str: A string representation of the AutoModel instance.
-        """
-        return str(self.__dict__)
+class AutoModel(Document):
+    meta = {"abstract": True, "allow_inheritance": True, "strict": False}
+    last_updated = DateTimeField(default=datetime.now)
 
     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)
+    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
 
     @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
+    def _auto_pre_init(cls, sender, document, **kwargs):
+        sender.auto_pre_init(sender, document, **kwargs)
+
+    @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):
@@ -227,74 +63,13 @@ 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 (f"models.{model.lower()}", model)
+        )
+        module = importlib.import_module(module_name)
+        return getattr(module, model)
 
     @classmethod
     def get(cls, pk):
@@ -307,10 +82,22 @@ 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 isinstance(pk, str):
+            pk = ObjectId(pk)
+        elif isinstance(pk, dict) and "$oid" in pk:
+            pk = ObjectId(pk["$oid"])
+        try:
+            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):
@@ -323,9 +110,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 +124,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 +137,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 +158,56 @@ 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):
+    @classmethod
+    def auto_pre_save(cls, sender, document, **kwargs):
         """
-        Delete this model from the database.
+        Post-save hook for this 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()
+        pass
 
-    def delete(self):
+    @classmethod
+    def _auto_pre_save(cls, sender, document, **kwargs):
         """
-        Delete this model from the database.
+        Post-save hook for this model.
         """
-        return self.table().delete(self.pk)
+        sender.auto_pre_save(sender, document, **kwargs)
 
-    def serialize(self):
+    def save(self):
         """
-        Serialize this model to a dictionary.
+        Save this model to the database.
 
         Returns:
-            dict: A dictionary representation of the serialized model.
+            int: The primary key (pk) of the saved model.
         """
-        vars = {k: v for k, v in self.__dict__.items() if k in self.attributes}
-        json_vars = AutoEncoder.encode(vars)
-        return json_vars
+        # 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,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

autonomous/tasks/autotask.py

@@ -1,31 +1,12 @@
 import importlib
 import os
 import subprocess
-import time
 
 from redis import Redis
 from rq import Queue, Worker
-from rq.job import Job
 
 from autonomous import log
 
-# class AutoJob(Job):
-#     def perform(self):
-#         start = time.time()
-#         result = super().perform()
-#         end = time.time()
-#         log.info(
-#             "Job Finished",
-#             key=self.key,
-#             seconds=(end - start),
-#             method=self.func_name,
-#             data_size=len(self._data),
-#             queue=self.origin,
-#             enqueued_at=self.enqueued_at.timestamp() if self.enqueued_at else None,
-#             started_at=self.started_at.timestamp() if self.started_at else None,
-#         )
-#         return result
-
 
 class AutoTask:
     def __init__(self, job):
@@ -161,9 +142,3 @@ class AutoTasks:
     def clear(self):
         AutoTasks.queue.empty()
         AutoTasks.all_tasks = []
-
-
-# if __name__ == "__main__":
-#     autotasks = AutoTasks()
-#     for _ in range(autotasks.workers):
-#         create_worker(autotasks.queue.name)

{autonomous_app-0.2.25.dist-info → autonomous_app-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autonomous-app
-Version: 0.2.25
+Version: 0.3.1
 Summary: Containerized application framework built on Flask with additional libraries and tools for rapid development of web applications.
 Author-email: Steven A Moore <samoore@binghamton.edu>
 License: MIT License
@@ -25,27 +25,26 @@ License: MIT License
         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
         SOFTWARE.
 Project-URL: homepage, https://github.com/Sallenmoore/autonomous
-Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.11
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: Flask
-Requires-Dist: icecream
 Requires-Dist: setuptools
 Requires-Dist: python-dotenv
+Requires-Dist: blinker
 Requires-Dist: PyGithub
 Requires-Dist: pygit2
-Requires-Dist: cloudinary
 Requires-Dist: pillow
-Requires-Dist: pymongo
+Requires-Dist: redis
 Requires-Dist: jsmin
 Requires-Dist: requests
 Requires-Dist: gunicorn
 Requires-Dist: Authlib
-Requires-Dist: openai>=1.21.1
-Requires-Dist: validators
+Requires-Dist: rq
+Requires-Dist: openai>=1.42
 Requires-Dist: dateparser
 Requires-Dist: python-slugify