basic-memory 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

basic_memory/schemas/memory.py

@@ -1,11 +1,10 @@
 """Schemas for memory context."""
 
 from datetime import datetime
-from typing import Dict, List, Any, Optional, Annotated
+from typing import List, Optional, Annotated, Sequence
 
-import pydantic
 from annotated_types import MinLen, MaxLen
-from pydantic import BaseModel, field_validator, Field, BeforeValidator, TypeAdapter, AnyUrl
+from pydantic import BaseModel, Field, BeforeValidator, TypeAdapter
 
 from basic_memory.schemas.search import SearchItemType
 
@@ -32,19 +31,20 @@ def normalize_memory_url(url: str) -> str:
 MemoryUrl = Annotated[
     str,
     BeforeValidator(str.strip),  # Clean whitespace
-    MinLen(1),       
-    MaxLen(2028),   
+    MinLen(1),
+    MaxLen(2028),
 ]
 
-memory_url = TypeAdapter(MemoryUrl) 
+memory_url = TypeAdapter(MemoryUrl)
 
-def memory_url_path(url: memory_url) -> str:
+
+def memory_url_path(url: memory_url) -> str:  # pyright: ignore
     """
     Returns the uri for a url value by removing the prefix "memory://" from a given MemoryUrl.
 
     This function processes a given MemoryUrl by removing the "memory://"
-    prefix and returns the resulting string. If the provided url does not 
-    begin with "memory://", the function will simply return the input url 
+    prefix and returns the resulting string. If the provided url does not
+    begin with "memory://", the function will simply return the input url
     unchanged.
 
     :param url: A MemoryUrl object representing the URL with a "memory://" prefix.
@@ -55,7 +55,6 @@ def memory_url_path(url: memory_url) -> str:
     return url.removeprefix("memory://")
 
 
-
 class EntitySummary(BaseModel):
     """Simplified entity representation."""
 
@@ -101,14 +100,14 @@ class GraphContext(BaseModel):
     """Complete context response."""
 
     # Direct matches
-    primary_results: List[EntitySummary | RelationSummary | ObservationSummary] = Field(
+    primary_results: Sequence[EntitySummary | RelationSummary | ObservationSummary] = Field(
         description="results directly matching URI"
     )
 
     # Related entities
-    related_results: List[EntitySummary | RelationSummary | ObservationSummary] = Field(
+    related_results: Sequence[EntitySummary | RelationSummary | ObservationSummary] = Field(
         description="related results"
     )
 
     # Context metadata
-    metadata: MemoryMetadata
+    metadata: MemoryMetadata

basic_memory/schemas/request.py

@@ -1,23 +1,16 @@
 """Request schemas for interacting with the knowledge graph."""
 
-from typing import List, Optional, Annotated, Dict, Any
+from typing import List, Optional, Annotated
 from annotated_types import MaxLen, MinLen
 
 from pydantic import BaseModel
 
 from basic_memory.schemas.base import (
-    Observation,
-    Entity,
     Relation,
-    PathId,
-    ObservationCategory,
-    EntityType,
+    Permalink,
 )
 
 
-
-
-
 class SearchNodesRequest(BaseModel):
     """Search for entities in the knowledge graph.
 
@@ -47,7 +40,7 @@ class SearchNodesRequest(BaseModel):
     """
 
     query: Annotated[str, MinLen(1), MaxLen(200)]
-    category: Optional[ObservationCategory] = None
+    category: Optional[str] = None
 
 
 class GetEntitiesRequest(BaseModel):
@@ -58,20 +51,8 @@ class GetEntitiesRequest(BaseModel):
     discovered through search.
     """
 
-    permalinks: Annotated[List[PathId], MinLen(1)]
+    permalinks: Annotated[List[Permalink], MinLen(1)]
 
 
 class CreateRelationsRequest(BaseModel):
     relations: List[Relation]
-
-
-## update
-
-# TODO remove UpdateEntityRequest
-class UpdateEntityRequest(BaseModel):
-    """Request to update an existing entity."""
-
-    title: Optional[str] = None
-    entity_type: Optional[EntityType] = None
-    content: Optional[str] = None
-    entity_metadata: Optional[Dict[str, Any]] = None

basic_memory/schemas/response.py

@@ -15,7 +15,7 @@ from typing import List, Optional, Dict
 
 from pydantic import BaseModel, ConfigDict, Field, AliasPath, AliasChoices
 
-from basic_memory.schemas.base import Relation, PathId, EntityType, ContentType, Observation
+from basic_memory.schemas.base import Relation, Permalink, EntityType, ContentType, Observation
 
 
 class SQLAlchemyModel(BaseModel):
@@ -28,7 +28,7 @@ class SQLAlchemyModel(BaseModel):
 
     model_config = ConfigDict(from_attributes=True)
 
-    
+
 class ObservationResponse(Observation, SQLAlchemyModel):
     """Schema for observation data returned from the service.
 
@@ -59,7 +59,7 @@ class RelationResponse(Relation, SQLAlchemyModel):
     }
     """
 
-    from_id: PathId = Field(
+    from_id: Permalink = Field(
         # use the permalink from the associated Entity
         # or the from_id value
         validation_alias=AliasChoices(
@@ -67,25 +67,26 @@ class RelationResponse(Relation, SQLAlchemyModel):
             "from_id",
         )
     )
-    to_id: Optional[PathId] = Field(
+    to_id: Optional[Permalink] = Field(  # pyright: ignore
         # use the permalink from the associated Entity
         # or the to_id value
         validation_alias=AliasChoices(
             AliasPath("to_entity", "permalink"),
             "to_id",
-        ), default=None
+        ),
+        default=None,
     )
-    to_name: Optional[PathId] = Field(
+    to_name: Optional[Permalink] = Field(
         # use the permalink from the associated Entity
         # or the to_id value
         validation_alias=AliasChoices(
             AliasPath("to_entity", "title"),
             "to_name",
-        ), default=None
+        ),
+        default=None,
     )
 
 
-
 class EntityResponse(SQLAlchemyModel):
     """Complete entity data returned from the service.
 
@@ -125,7 +126,7 @@ class EntityResponse(SQLAlchemyModel):
     }
     """
 
-    permalink: PathId
+    permalink: Permalink
     title: str
     file_path: str
     entity_type: EntityType

basic_memory/schemas/search.py

@@ -49,8 +49,6 @@ class SearchQuery(BaseModel):
     @classmethod
     def validate_date(cls, v: Optional[Union[datetime, str]]) -> Optional[str]:
         """Convert datetime to ISO format if needed."""
-        if v is None:
-            return None
         if isinstance(v, datetime):
             return v.isoformat()
         return v
@@ -71,12 +69,11 @@ class SearchResult(BaseModel):
 
     id: int
     type: SearchItemType
-    score: Optional[float] = None
-    metadata: Optional[dict] = None
+    score: float
+    permalink: str
+    file_path: str
 
-    # Common fields
-    permalink: Optional[str] = None
-    file_path: Optional[str] = None
+    metadata: Optional[dict] = None
 
     # Type-specific fields
     entity_id: Optional[int] = None  # For observations

basic_memory/services/__init__.py

@@ -1,12 +1,7 @@
 """Services package."""
-from .database_service import DatabaseService
+
 from .service import BaseService
 from .file_service import FileService
 from .entity_service import EntityService
 
-__all__ = [
-    "BaseService",
-    "FileService",
-    "EntityService",
-    "DatabaseService"
-]
+__all__ = ["BaseService", "FileService", "EntityService"]

basic_memory/services/context_service.py

@@ -50,8 +50,8 @@ class ContextService:
 
     async def build_context(
         self,
-        memory_url: MemoryUrl = None,
-        types: List[SearchItemType] = None,
+        memory_url: Optional[MemoryUrl] = None,
+        types: Optional[List[SearchItemType]] = None,
         depth: int = 1,
         since: Optional[datetime] = None,
         max_results: int = 10,
@@ -66,9 +66,7 @@ class ContextService:
             # Pattern matching - use search
             if "*" in path:
                 logger.debug(f"Pattern search for '{path}'")
-                primary = await self.search_repository.search(
-                    permalink_match=path
-                )
+                primary = await self.search_repository.search(permalink_match=path)
 
             # Direct lookup for exact path
             else:
@@ -120,11 +118,19 @@ class ContextService:
         - Connected entities
         - Their observations
         - Relations that connect them
+
+        Note on depth:
+        Each traversal step requires two depth levels - one to find the relation,
+        and another to follow that relation to an entity. So a max_depth of 4 allows
+        traversal through two entities (relation->entity->relation->entity), while reaching
+        an entity three steps away requires max_depth=6 (relation->entity->relation->entity->relation->entity).
         """
+        max_depth = max_depth * 2
+
         if not type_id_pairs:
             return []
 
-        logger.debug(f"Finding connected items for {len(type_id_pairs)} with depth {max_depth}")
+        logger.debug(f"Finding connected items for {type_id_pairs} with depth {max_depth}")
 
         # Build the VALUES clause directly since SQLite doesn't handle parameterized IN well
         values = ", ".join([f"('{t}', {i})" for t, i in type_id_pairs])
@@ -132,7 +138,7 @@ class ContextService:
         # Parameters for bindings
         params = {"max_depth": max_depth, "max_results": max_results}
         if since:
-            params["since_date"] = since.isoformat()
+            params["since_date"] = since.isoformat()  # pyright: ignore
 
         # Build date filter
         date_filter = "AND base.created_at >= :since_date" if since else ""
@@ -140,113 +146,113 @@ class ContextService:
         related_date_filter = "AND e.created_at >= :since_date" if since else ""
 
         query = text(f"""
-WITH RECURSIVE context_graph AS (
-    -- Base case: seed items (unchanged)
-    SELECT 
-        id,
-        type,
-        title, 
-        permalink,
-        file_path,
-        from_id,
-        to_id,
-        relation_type,
-        content,
-        category,
-        entity_id,
-        0 as depth,
-        id as root_id,
-        created_at,
-        created_at as relation_date,
-        0 as is_incoming
-    FROM search_index base
-    WHERE (base.type, base.id) IN ({values})
-    {date_filter}
+        WITH RECURSIVE context_graph AS (
+            -- Base case: seed items 
+            SELECT 
+                id,
+                type,
+                title, 
+                permalink,
+                file_path,
+                from_id,
+                to_id,
+                relation_type,
+                content,
+                category,
+                entity_id,
+                0 as depth,
+                id as root_id,
+                created_at,
+                created_at as relation_date,
+                0 as is_incoming
+            FROM search_index base
+            WHERE (base.type, base.id) IN ({values})
+            {date_filter}
 
-    UNION  -- Changed from UNION ALL
+            UNION ALL  -- Allow same paths at different depths
 
-    -- Get relations from current entities 
-    SELECT DISTINCT
-        r.id,
-        r.type,
-        r.title,
-        r.permalink,
-        r.file_path,
-        r.from_id,
-        r.to_id,
-        r.relation_type,
-        r.content,
-        r.category,
-        r.entity_id,
-        cg.depth + 1,
-        cg.root_id,
-        r.created_at,
-        r.created_at as relation_date,
-        CASE WHEN r.from_id = cg.id THEN 0 ELSE 1 END as is_incoming
-    FROM context_graph cg
-    JOIN search_index r ON (
-        cg.type = 'entity' AND
-        r.type = 'relation' AND 
-        (r.from_id = cg.id OR r.to_id = cg.id)
-        {r1_date_filter}
-    )
-    WHERE cg.depth < :max_depth
+            -- Get relations from current entities 
+            SELECT DISTINCT
+                r.id,
+                r.type,
+                r.title,
+                r.permalink,
+                r.file_path,
+                r.from_id,
+                r.to_id,
+                r.relation_type,
+                r.content,
+                r.category,
+                r.entity_id,
+                cg.depth + 1,
+                cg.root_id,
+                r.created_at,
+                r.created_at as relation_date,
+                CASE WHEN r.from_id = cg.id THEN 0 ELSE 1 END as is_incoming
+            FROM context_graph cg
+            JOIN search_index r ON (
+                cg.type = 'entity' AND
+                r.type = 'relation' AND 
+                (r.from_id = cg.id OR r.to_id = cg.id)
+                {r1_date_filter}
+            )
+            WHERE cg.depth < :max_depth
 
-    UNION  -- Changed from UNION ALL
+            UNION ALL
 
-    -- Get entities connected by relations
-    SELECT DISTINCT
-        e.id,
-        e.type,
-        e.title,
-        e.permalink,
-        e.file_path,
-        e.from_id,
-        e.to_id,
-        e.relation_type,
-        e.content,
-        e.category,
-        e.entity_id,
-        cg.depth,
-        cg.root_id,
-        e.created_at,
-        cg.relation_date,
-        cg.is_incoming
-    FROM context_graph cg
-    JOIN search_index e ON (
-        cg.type = 'relation' AND 
-        e.type = 'entity' AND
-        e.id = CASE 
-            WHEN cg.from_id = cg.id THEN cg.to_id  
-            ELSE cg.from_id                             
-        END
-        {related_date_filter}
-    )
-    WHERE cg.depth < :max_depth
-)
-SELECT DISTINCT 
-    type,
-    id,
-    title,
-    permalink,
-    file_path,
-    from_id,
-    to_id,
-    relation_type,
-    content,
-    category,
-    entity_id,
-    MIN(depth) as depth,
-    root_id,
-    created_at
-FROM context_graph
-WHERE (type, id) NOT IN ({values})
-GROUP BY
-    type, id, title, permalink, from_id, to_id,
-    relation_type, category, entity_id,
-    root_id, created_at
-ORDER BY depth, type, id
-LIMIT :max_results
+            -- Get entities connected by relations
+            SELECT DISTINCT
+                e.id,
+                e.type,
+                e.title,
+                e.permalink,
+                e.file_path,
+                e.from_id,
+                e.to_id,
+                e.relation_type,
+                e.content,
+                e.category,
+                e.entity_id,
+                cg.depth + 1,  -- Increment depth for entities
+                cg.root_id,
+                e.created_at,
+                cg.relation_date,
+                cg.is_incoming
+            FROM context_graph cg
+            JOIN search_index e ON (
+                cg.type = 'relation' AND 
+                e.type = 'entity' AND
+                e.id = CASE 
+                    WHEN cg.is_incoming = 0 THEN cg.to_id  -- Fixed entity lookup
+                    ELSE cg.from_id                             
+                END
+                {related_date_filter}
+            )
+            WHERE cg.depth < :max_depth
+        )
+        SELECT DISTINCT 
+            type,
+            id,
+            title,
+            permalink,
+            file_path,
+            from_id,
+            to_id,
+            relation_type,
+            content,
+            category,
+            entity_id,
+            MIN(depth) as depth,
+            root_id,
+            created_at
+        FROM context_graph
+        WHERE (type, id) NOT IN ({values})
+        GROUP BY
+            type, id, title, permalink, from_id, to_id,
+            relation_type, category, entity_id,
+            root_id, created_at
+        ORDER BY depth, type, id
+        LIMIT :max_results
        """)
 
         result = await self.search_repository.execute_query(query, params=params)