letta-nightly 0.5.0.dev20241023104105__tar.gz → 0.5.1.dev20241023193051__tar.gz

{letta_nightly-0.5.0.dev20241023104105 → letta_nightly-0.5.1.dev20241023193051}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.5.0.dev20241023104105
+Version: 0.5.1.dev20241023193051
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team

{letta_nightly-0.5.0.dev20241023104105 → letta_nightly-0.5.1.dev20241023193051}/letta/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.5.0"
+__version__ = "0.5.1"
 
 # import clients
 from letta.client.client import LocalClient, RESTClient, create_client

{letta_nightly-0.5.0.dev20241023104105 → letta_nightly-0.5.1.dev20241023193051}/letta/constants.py

@@ -4,13 +4,13 @@ from logging import CRITICAL, DEBUG, ERROR, INFO, NOTSET, WARN, WARNING
 LETTA_DIR = os.path.join(os.path.expanduser("~"), ".letta")
 
 # Defaults
-DEFAULT_USER_ID = "user-00000000"
+DEFAULT_USER_ID = "user-00000000-0000-4000-8000-000000000000"
 # This UUID follows the UUID4 rules:
 # The 13th character (4) indicates it's version 4.
 # The first character of the third segment (8) ensures the variant is correctly set.
 DEFAULT_ORG_ID = "organization-00000000-0000-4000-8000-000000000000"
-DEFAULT_USER_NAME = "default"
-DEFAULT_ORG_NAME = "default"
+DEFAULT_USER_NAME = "default_user"
+DEFAULT_ORG_NAME = "default_org"
 
 
 # String in the error message for when the context window is too large

{letta_nightly-0.5.0.dev20241023104105 → letta_nightly-0.5.1.dev20241023193051}/letta/metadata.py

@@ -15,7 +15,6 @@ from sqlalchemy import (
     String,
     TypeDecorator,
     asc,
-    desc,
     or_,
 )
 from sqlalchemy.sql import func
@@ -31,8 +30,6 @@ from letta.schemas.file import FileMetadata
 from letta.schemas.job import Job
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import Memory
-
-# from letta.schemas.message import Message, Passage, Record, RecordType, ToolCall
 from letta.schemas.openai.chat_completions import ToolCall, ToolCallFunction
 from letta.schemas.source import Source
 from letta.schemas.tool import Tool
@@ -154,25 +151,6 @@ class ToolCallColumn(TypeDecorator):
         return value
 
 
-class UserModel(Base):
-    __tablename__ = "users"
-    __table_args__ = {"extend_existing": True}
-
-    id = Column(String, primary_key=True)
-    org_id = Column(String)
-    name = Column(String, nullable=False)
-    created_at = Column(DateTime(timezone=True))
-
-    # TODO: what is this?
-    policies_accepted = Column(Boolean, nullable=False, default=False)
-
-    def __repr__(self) -> str:
-        return f"<User(id='{self.id}' name='{self.name}')>"
-
-    def to_record(self) -> User:
-        return User(id=self.id, name=self.name, created_at=self.created_at, org_id=self.org_id)
-
-
 # TODO: eventually store providers?
 # class Provider(Base):
 #    __tablename__ = "providers"
@@ -497,15 +475,6 @@ class MetadataStore:
             tokens = [r.to_record() for r in results]
             return tokens
 
-    @enforce_types
-    def get_user_from_api_key(self, api_key: str) -> Optional[User]:
-        """Get the user associated with a given API key"""
-        token = self.get_api_key(api_key=api_key)
-        if token is None:
-            raise ValueError(f"Provided token does not exist")
-        else:
-            return self.get_user(user_id=token.user_id)
-
     @enforce_types
     def create_agent(self, agent: AgentState):
         # insert into agent table
@@ -527,14 +496,6 @@ class MetadataStore:
             session.add(SourceModel(**vars(source)))
             session.commit()
 
-    @enforce_types
-    def create_user(self, user: User):
-        with self.session_maker() as session:
-            if session.query(UserModel).filter(UserModel.id == user.id).count() > 0:
-                raise ValueError(f"User with id {user.id} already exists")
-            session.add(UserModel(**vars(user)))
-            session.commit()
-
     @enforce_types
     def create_block(self, block: Block):
         with self.session_maker() as session:
@@ -573,12 +534,6 @@ class MetadataStore:
             session.query(AgentModel).filter(AgentModel.id == agent.id).update(fields)
             session.commit()
 
-    @enforce_types
-    def update_user(self, user: User):
-        with self.session_maker() as session:
-            session.query(UserModel).filter(UserModel.id == user.id).update(vars(user))
-            session.commit()
-
     @enforce_types
     def update_source(self, source: Source):
         with self.session_maker() as session:
@@ -657,23 +612,6 @@ class MetadataStore:
 
             session.commit()
 
-    @enforce_types
-    def delete_user(self, user_id: str):
-        with self.session_maker() as session:
-            # delete from users table
-            session.query(UserModel).filter(UserModel.id == user_id).delete()
-
-            # delete associated agents
-            session.query(AgentModel).filter(AgentModel.user_id == user_id).delete()
-
-            # delete associated sources
-            session.query(SourceModel).filter(SourceModel.user_id == user_id).delete()
-
-            # delete associated mappings
-            session.query(AgentSourceMappingModel).filter(AgentSourceMappingModel.user_id == user_id).delete()
-
-            session.commit()
-
     @enforce_types
     def list_tools(self, cursor: Optional[str] = None, limit: Optional[int] = 50, user_id: Optional[str] = None) -> List[ToolModel]:
         with self.session_maker() as session:
@@ -719,30 +657,6 @@ class MetadataStore:
             assert len(results) == 1, f"Expected 1 result, got {len(results)}"  # should only be one result
             return results[0].to_record()
 
-    @enforce_types
-    def get_user(self, user_id: str) -> Optional[User]:
-        with self.session_maker() as session:
-            results = session.query(UserModel).filter(UserModel.id == user_id).all()
-            if len(results) == 0:
-                return None
-            assert len(results) == 1, f"Expected 1 result, got {len(results)}"
-            return results[0].to_record()
-
-    @enforce_types
-    def get_all_users(self, cursor: Optional[str] = None, limit: Optional[int] = 50):
-        with self.session_maker() as session:
-            query = session.query(UserModel).order_by(desc(UserModel.id))
-            if cursor:
-                query = query.filter(UserModel.id < cursor)
-            results = query.limit(limit).all()
-            if not results:
-                return None, []
-            user_records = [r.to_record() for r in results]
-            next_cursor = user_records[-1].id
-            assert isinstance(next_cursor, str)
-
-            return next_cursor, user_records
-
     @enforce_types
     def get_source(
         self, source_id: Optional[str] = None, user_id: Optional[str] = None, source_name: Optional[str] = None

letta_nightly-0.5.1.dev20241023193051/letta/orm/errors.py

@@ -0,0 +1,6 @@
+class NoResultFound(Exception):
+    """A record or records cannot be found given the provided search params"""
+
+
+class MalformedIdError(Exception):
+    """An id not in the right format, most likely violating uuid4 format."""

letta_nightly-0.5.1.dev20241023193051/letta/orm/mixins.py

@@ -0,0 +1,67 @@
+from typing import Optional
+from uuid import UUID
+
+from sqlalchemy import ForeignKey, String
+from sqlalchemy.orm import Mapped, mapped_column
+
+from letta.orm.base import Base
+from letta.orm.errors import MalformedIdError
+
+
+def is_valid_uuid4(uuid_string: str) -> bool:
+    """Check if a string is a valid UUID4."""
+    try:
+        uuid_obj = UUID(uuid_string)
+        return uuid_obj.version == 4
+    except ValueError:
+        return False
+
+
+def _relation_getter(instance: "Base", prop: str) -> Optional[str]:
+    """Get relation and return id with prefix as a string."""
+    prefix = prop.replace("_", "")
+    formatted_prop = f"_{prop}_id"
+    try:
+        id_ = getattr(instance, formatted_prop)  # Get the string id directly
+        return f"{prefix}-{id_}"
+    except AttributeError:
+        return None
+
+
+def _relation_setter(instance: "Base", prop: str, value: str) -> None:
+    """Set relation using the id with prefix, ensuring the id is a valid UUIDv4."""
+    formatted_prop = f"_{prop}_id"
+    prefix = prop.replace("_", "")
+    if not value:
+        setattr(instance, formatted_prop, None)
+        return
+    try:
+        found_prefix, id_ = value.split("-", 1)
+    except ValueError as e:
+        raise MalformedIdError(f"{value} is not a valid ID.") from e
+
+    # Ensure prefix matches
+    assert found_prefix == prefix, f"{found_prefix} is not a valid id prefix, expecting {prefix}"
+
+    # Validate that the id is a valid UUID4 string
+    if not is_valid_uuid4(id_):
+        raise MalformedIdError(f"Hash segment of {value} is not a valid UUID4")
+
+    setattr(instance, formatted_prop, id_)  # Store id as a string
+
+
+class OrganizationMixin(Base):
+    """Mixin for models that belong to an organization."""
+
+    __abstract__ = True
+
+    # Changed _organization_id to store string (still a valid UUID4 string)
+    _organization_id: Mapped[str] = mapped_column(String, ForeignKey("organization._id"))
+
+    @property
+    def organization_id(self) -> str:
+        return _relation_getter(self, "organization")
+
+    @organization_id.setter
+    def organization_id(self, value: str) -> None:
+        _relation_setter(self, "organization", value)

{letta_nightly-0.5.0.dev20241023104105 → letta_nightly-0.5.1.dev20241023193051}/letta/orm/organization.py

@@ -1,35 +1,28 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, List
 
-from sqlalchemy.exc import NoResultFound
-from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.organization import Organization as PydanticOrganization
 
 if TYPE_CHECKING:
-    from sqlalchemy.orm import Session
+
+    from letta.orm.user import User
 
 
 class Organization(SqlalchemyBase):
     """The highest level of the object tree. All Entities belong to one and only one Organization."""
 
-    __tablename__ = "organizations"
+    __tablename__ = "organization"
     __pydantic_model__ = PydanticOrganization
 
     name: Mapped[str] = mapped_column(doc="The display name of the organization.")
 
+    users: Mapped[List["User"]] = relationship("User", back_populates="organization", cascade="all, delete-orphan")
+
     # TODO: Map these relationships later when we actually make these models
     # below is just a suggestion
-    # users: Mapped[List["User"]] = relationship("User", back_populates="organization", cascade="all, delete-orphan")
     # agents: Mapped[List["Agent"]] = relationship("Agent", back_populates="organization", cascade="all, delete-orphan")
     # sources: Mapped[List["Source"]] = relationship("Source", back_populates="organization", cascade="all, delete-orphan")
     # tools: Mapped[List["Tool"]] = relationship("Tool", back_populates="organization", cascade="all, delete-orphan")
     # documents: Mapped[List["Document"]] = relationship("Document", back_populates="organization", cascade="all, delete-orphan")
-
-    @classmethod
-    def default(cls, db_session: "Session") -> "Organization":
-        """Get the default org, or create it if it doesn't exist."""
-        try:
-            return db_session.query(cls).filter(cls.name == "Default Organization").one()
-        except NoResultFound:
-            return cls(name="Default Organization").create(db_session)

{letta_nightly-0.5.0.dev20241023104105 → letta_nightly-0.5.1.dev20241023193051}/letta/orm/sqlalchemy_base.py

@@ -8,6 +8,7 @@ from sqlalchemy.orm import Mapped, mapped_column
 from letta.log import get_logger
 from letta.orm.base import Base, CommonSqlalchemyMetaMixins
 from letta.orm.errors import NoResultFound
+from letta.orm.mixins import is_valid_uuid4
 
 if TYPE_CHECKING:
     from pydantic import BaseModel
@@ -42,7 +43,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             return
         prefix, id_ = value.split("-", 1)
         assert prefix == self.__prefix__(), f"{prefix} is not a valid id prefix for {self.__class__.__name__}"
-        assert SqlalchemyBase.is_valid_uuid4(id_), f"{id_} is not a valid uuid4"
+        assert is_valid_uuid4(id_), f"{id_} is not a valid uuid4"
         self._id = id_
 
     @classmethod
@@ -78,22 +79,11 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         """
         try:
             uuid_string = identifier.split("-", 1)[1] if indifferent else identifier.replace(f"{cls.__prefix__()}-", "")
-            assert SqlalchemyBase.is_valid_uuid4(uuid_string)
+            assert is_valid_uuid4(uuid_string)
             return uuid_string
         except ValueError as e:
             raise ValueError(f"{identifier} is not a valid identifier for class {cls.__name__}") from e
 
-    @classmethod
-    def is_valid_uuid4(cls, uuid_string: str) -> bool:
-        try:
-            # Try to create a UUID object from the string
-            uuid_obj = UUID(uuid_string)
-            # Check if the UUID is version 4
-            return uuid_obj.version == 4
-        except ValueError:
-            # Raised if the string is not a valid UUID
-            return False
-
     @classmethod
     def read(
         cls,

letta_nightly-0.5.1.dev20241023193051/letta/orm/user.py

@@ -0,0 +1,25 @@
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from letta.orm.mixins import OrganizationMixin
+from letta.orm.organization import Organization
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.user import User as PydanticUser
+
+
+class User(SqlalchemyBase, OrganizationMixin):
+    """User ORM class"""
+
+    __tablename__ = "user"
+    __pydantic_model__ = PydanticUser
+
+    name: Mapped[str] = mapped_column(nullable=False, doc="The display name of the user.")
+
+    # relationships
+    organization: Mapped["Organization"] = relationship("Organization", back_populates="users")
+
+    # TODO: Add this back later potentially
+    # agents: Mapped[List["Agent"]] = relationship(
+    #     "Agent", secondary="users_agents", back_populates="users", doc="the agents associated with this user."
+    # )
+    # tokens: Mapped[List["Token"]] = relationship("Token", back_populates="user", doc="the tokens associated with this user.")
+    # jobs: Mapped[List["Job"]] = relationship("Job", back_populates="user", doc="the jobs associated with this user.")

letta_nightly-0.5.1.dev20241023193051/letta/schemas/user.py

@@ -0,0 +1,40 @@
+from datetime import datetime
+from typing import Optional
+
+from pydantic import Field
+
+from letta.constants import DEFAULT_ORG_ID
+from letta.schemas.letta_base import LettaBase
+
+
+class UserBase(LettaBase):
+    __id_prefix__ = "user"
+
+
+class User(UserBase):
+    """
+    Representation of a user.
+
+    Parameters:
+        id (str): The unique identifier of the user.
+        name (str): The name of the user.
+        created_at (datetime): The creation date of the user.
+    """
+
+    id: str = Field(..., description="The id of the user.")
+    organization_id: Optional[str] = Field(DEFAULT_ORG_ID, description="The organization id of the user")
+    name: str = Field(..., description="The name of the user.")
+    created_at: datetime = Field(default_factory=datetime.utcnow, description="The creation date of the user.")
+    updated_at: datetime = Field(default_factory=datetime.utcnow, description="The update date of the user.")
+    is_deleted: bool = Field(False, description="Whether this user is deleted or not.")
+
+
+class UserCreate(UserBase):
+    name: str = Field(..., description="The name of the user.")
+    organization_id: str = Field(..., description="The organization id of the user.")
+
+
+class UserUpdate(UserBase):
+    id: str = Field(..., description="The id of the user to update.")
+    name: Optional[str] = Field(None, description="The new name of the user.")
+    organization_id: Optional[str] = Field(None, description="The new organization id of the user.")

{letta_nightly-0.5.0.dev20241023104105 → letta_nightly-0.5.1.dev20241023193051}/letta/server/rest_api/routers/v1/organizations.py

@@ -42,7 +42,7 @@ def create_org(
     return org
 
 
-@router.delete("/", tags=["admin"], response_model=Organization, operation_id="delete_organization")
+@router.delete("/", tags=["admin"], response_model=Organization, operation_id="delete_organization_by_id")
 def delete_org(
     org_id: str = Query(..., description="The org_id key to be deleted."),
     server: "SyncServer" = Depends(get_letta_server),
@@ -52,7 +52,7 @@ def delete_org(
         org = server.organization_manager.get_organization_by_id(org_id=org_id)
         if org is None:
             raise HTTPException(status_code=404, detail=f"Organization does not exist")
-        server.organization_manager.delete_organization(org_id=org_id)
+        server.organization_manager.delete_organization_by_id(org_id=org_id)
     except HTTPException:
         raise
     except Exception as e:

{letta_nightly-0.5.0.dev20241023104105 → letta_nightly-0.5.1.dev20241023193051}/letta/server/rest_api/routers/v1/users.py

@@ -26,7 +26,7 @@ router = APIRouter(prefix="/users", tags=["users", "admin"])
 
 
 @router.get("/", tags=["admin"], response_model=List[User], operation_id="list_users")
-def get_all_users(
+def list_users(
     cursor: Optional[str] = Query(None),
     limit: Optional[int] = Query(50),
     server: "SyncServer" = Depends(get_letta_server),
@@ -35,8 +35,7 @@ def get_all_users(
     Get a list of all users in the database
     """
     try:
-        next_cursor, users = server.ms.get_all_users(cursor=cursor, limit=limit)
-        # processed_users = [{"user_id": user.id} for user in users]
+        next_cursor, users = server.user_manager.list_users(cursor=cursor, limit=limit)
     except HTTPException:
         raise
     except Exception as e:
@@ -53,7 +52,7 @@ def create_user(
     Create a new user in the database
     """
 
-    user = server.create_user(request)
+    user = server.user_manager.create_user(request)
     return user
 
 
@@ -64,10 +63,10 @@ def delete_user(
 ):
     # TODO make a soft deletion, instead of a hard deletion
     try:
-        user = server.ms.get_user(user_id=user_id)
+        user = server.user_manager.get_user_by_id(user_id=user_id)
         if user is None:
             raise HTTPException(status_code=404, detail=f"User does not exist")
-        server.ms.delete_user(user_id=user_id)
+        server.user_manager.delete_user_by_id(user_id=user_id)
     except HTTPException:
         raise
     except Exception as e:
@@ -95,7 +94,7 @@ def get_api_keys(
     """
     Get a list of all API keys for a user
     """
-    if server.ms.get_user(user_id=user_id) is None:
+    if server.user_manager.get_user_by_id(user_id=user_id) is None:
         raise HTTPException(status_code=404, detail=f"User does not exist")
     api_keys = server.ms.get_all_api_keys_for_user(user_id=user_id)
     return api_keys