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

autonomous/ai/textagent.py

@@ -0,0 +1,35 @@
+from autonomous import log
+from autonomous.model.autoattr import ReferenceAttr, StringAttr
+from autonomous.model.automodel import AutoModel
+
+from .models.openai import OpenAIModel
+
+
+class TextAgent(AutoModel):
+    client = ReferenceAttr(choices=[OpenAIModel])
+    name = StringAttr(default="textagent")
+    instructions = StringAttr(
+        default="You are highly skilled AI trained to assist with generating text according to the given requirements."
+    )
+    description = StringAttr(
+        default="A helpful AI assistant trained to assist with generating text according to the given requirements."
+    )
+
+    _ai_model = OpenAIModel
+
+    def get_client(self):
+        if self.client is None:
+            self.client = self._ai_model(
+                name=self.name,
+                instructions=self.instructions,
+                description=self.description,
+            )
+            self.client.save()
+            self.save()
+        return self.client
+
+    def summarize_text(self, text, primer=""):
+        return self.get_client().summarize_text(text, primer)
+
+    def generate(self, messages, additional_instructions=""):
+        return self.get_client().generate_text(messages, additional_instructions)

autonomous/auth/autoauth.py

@@ -1,17 +1,18 @@
+import json
 import uuid
 from datetime import datetime
 from functools import wraps
 
 import requests
 from authlib.integrations.requests_client import OAuth2Auth, OAuth2Session
-from flask import current_app, redirect, request, session, url_for
+from flask import redirect, session, url_for
 
 from autonomous import log
-from autonomous.auth.user import AutoUser
+from autonomous.auth.user import User
 
 
 class AutoAuth:
-    user_class = AutoUser
+    user_class: type[User] = User
 
     def __init__(
         self,
@@ -46,13 +47,12 @@ class AutoAuth:
         """
         Returns the current user.
         """
-        user = cls.user_class.get_guest()
-        if session.get("user") and session["user"]["state"] == "authenticated":
-            try:
-                user = cls.user_class.get(session["user"].get("pk"))
-                user.pk
-            except Exception as e:
-                log(e, session["user"])
+
+        user = (
+            cls.user_class.from_json(session["user"]) if session.get("user") else None
+        )
+        if not user or user.state != "authenticated":
+            user = cls.user_class.get_guest()
         return user
 
     def authenticate(self):
@@ -106,7 +106,7 @@ class AutoAuth:
                     user.last_login = datetime.now()
                     # log(user)
                     user.save()
-                session["user"] = user.serialize()
+                session["user"] = user.to_json()
                 # log(guest, user.is_guest)
                 if not guest and user.is_guest:
                     return redirect(url_for("auth.login"))

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,18 @@ 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,
+    meta = {
+        "abstract": True,
+        "allow_inheritance": True,
+        "strict": False,
     }
+    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
@@ -36,9 +39,10 @@ class AutoUser(AutoModel):
         email = user_info["email"].strip()
         name = user_info["name"].strip()
         user = cls.find(email=email)
+        log(email, user)
         if not user:
             log(f"Creating new user for {email}")
-            user = cls(name=name, email=email)
+            # user = cls(name=name, email=email)
 
         # parse user_info into a user object
         user.name = name
@@ -53,7 +57,7 @@ class AutoUser(AutoModel):
         """
         Returns a guest user.
         """
-        guest = cls.find(name="_GuestOfAutonomous_", state="guest")
+        guest = cls.find(name="_GuestOfAutonomous_")
         if not guest:
             guest = cls(
                 name="_GuestOfAutonomous_",
@@ -84,3 +88,12 @@ class AutoUser(AutoModel):
         Returns True if the user is a guest, False otherwise.
         """
         return self.is_authenticated and self.role == "admin"
+
+
+class User(AutoUser):
+    """
+    This class represents a user who can authenticate using OpenID.
+    """
+
+    def __repr__(self):
+        return f"<User {self.pk} {self.email}>"

autonomous/db/__init__.py

@@ -1 +1,42 @@
+# Import submodules so that we can expose their __all__
+# Import everything from each submodule so that it can be accessed via
+# autonomous.db, e.g. instead of `from autonomous.db.connection import connect`,
+# users can simply use `from autonomous.db import connect`, or even
+# `from autonomous.db import *` and then `connect('testdb')`.
+from autonomous.db import (
+    connection,
+    document,
+    errors,
+    fields,
+    queryset,
+    signals,
+)
+from autonomous.db.connection import *  # noqa: F401
+from autonomous.db.document import *  # noqa: F401
+from autonomous.db.errors import *  # noqa: F401
+from autonomous.db.fields import *  # noqa: F401
+from autonomous.db.queryset import *  # noqa: F401
+from autonomous.db.signals import *  # noqa: F401
 
+__all__ = (
+    list(document.__all__)
+    + list(fields.__all__)
+    + list(connection.__all__)
+    + list(queryset.__all__)
+    + list(signals.__all__)
+    + list(errors.__all__)
+)
+
+
+VERSION = (0, 29, 0)
+
+
+def get_version():
+    """Return the VERSION as a string.
+
+    For example, if `VERSION == (0, 10, 7)`, return '0.10.7'.
+    """
+    return ".".join(map(str, VERSION))
+
+
+__version__ = get_version()

autonomous/db/base/__init__.py

@@ -0,0 +1,33 @@
+# Base module is split into several files for convenience. Files inside of
+# this module should import from a specific submodule (e.g.
+# `from autonomous.db.base.document import BaseDocument`), but all of the
+# other modules should import directly from the top-level module (e.g.
+# `from autonomous.db.base import BaseDocument`). This approach is cleaner and
+# also helps with cyclical import errors.
+from autonomous.db.base.common import *
+from autonomous.db.base.datastructures import *
+from autonomous.db.base.document import *
+from autonomous.db.base.fields import *
+from autonomous.db.base.metaclasses import *
+
+__all__ = (
+    # common
+    "UPDATE_OPERATORS",
+    "_document_registry",
+    "get_document",
+    # datastructures
+    "BaseDict",
+    "BaseList",
+    "EmbeddedDocumentList",
+    "LazyReference",
+    # document
+    "BaseDocument",
+    # fields
+    "BaseField",
+    "ComplexBaseField",
+    "ObjectIdField",
+    "GeoJsonBaseField",
+    # metaclasses
+    "DocumentMetaclass",
+    "TopLevelDocumentMetaclass",
+)

autonomous/db/base/common.py

@@ -0,0 +1,62 @@
+from autonomous.db.errors import NotRegistered
+
+__all__ = ("UPDATE_OPERATORS", "get_document", "_document_registry")
+
+
+UPDATE_OPERATORS = {
+    "set",
+    "unset",
+    "inc",
+    "dec",
+    "mul",
+    "pop",
+    "push",
+    "push_all",
+    "pull",
+    "pull_all",
+    "add_to_set",
+    "set_on_insert",
+    "min",
+    "max",
+    "rename",
+}
+
+
+_document_registry = {}
+
+
+def get_document(name):
+    """Get a registered Document class by name."""
+    doc = _document_registry.get(name, None)
+    if not doc:
+        # Possible old style name
+        single_end = name.split(".")[-1]
+        compound_end = ".%s" % single_end
+        possible_match = [
+            k for k in _document_registry if k.endswith(compound_end) or k == single_end
+        ]
+        if len(possible_match) == 1:
+            doc = _document_registry.get(possible_match.pop(), None)
+    if not doc:
+        raise NotRegistered(
+            """
+            `%s` has not been registered in the document registry.
+            Importing the document class automatically registers it, has it
+            been imported?
+        """.strip()
+            % name
+        )
+    return doc
+
+
+def _get_documents_by_db(connection_alias, default_connection_alias):
+    """Get all registered Documents class attached to a given database"""
+
+    def get_doc_alias(doc_cls):
+        return doc_cls._meta.get("db_alias", default_connection_alias)
+
+    return [
+        doc_cls
+        for doc_cls in _document_registry.values()
+        if get_doc_alias(doc_cls) == connection_alias
+    ]