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

basic_memory/services/entity_service.py

@@ -1,10 +1,9 @@
 """Service for managing entities in the database."""
 
 from pathlib import Path
-from typing import Sequence, List, Optional
+from typing import Sequence, List, Optional, Tuple, Union
 
 import frontmatter
-from frontmatter import Post
 from loguru import logger
 from sqlalchemy.exc import IntegrityError
 
@@ -14,6 +13,7 @@ from basic_memory.models import Entity as EntityModel, Observation, Relation
 from basic_memory.repository import ObservationRepository, RelationRepository
 from basic_memory.repository.entity_repository import EntityRepository
 from basic_memory.schemas import Entity as EntitySchema
+from basic_memory.schemas.base import Permalink
 from basic_memory.services.exceptions import EntityNotFoundError, EntityCreationError
 from basic_memory.services import FileService
 from basic_memory.services import BaseService
@@ -42,9 +42,7 @@ class EntityService(BaseService[EntityModel]):
         self.link_resolver = link_resolver
 
     async def resolve_permalink(
-            self,
-            file_path: Path,
-            markdown: Optional[EntityMarkdown] = None
+        self, file_path: Permalink | Path, markdown: Optional[EntityMarkdown] = None
     ) -> str:
         """Get or generate unique permalink for an entity.
 
@@ -54,19 +52,17 @@ class EntityService(BaseService[EntityModel]):
         3. For existing files, keep current permalink from db
         4. Generate new unique permalink from file path
         """
-        file_path = str(file_path)
-
         # If markdown has explicit permalink, try to validate it
         if markdown and markdown.frontmatter.permalink:
             desired_permalink = markdown.frontmatter.permalink
             existing = await self.repository.get_by_permalink(desired_permalink)
 
             # If no conflict or it's our own file, use as is
-            if not existing or existing.file_path == file_path:
+            if not existing or existing.file_path == str(file_path):
                 return desired_permalink
 
         # For existing files, try to find current permalink
-        existing = await self.repository.get_by_file_path(file_path)
+        existing = await self.repository.get_by_file_path(str(file_path))
         if existing:
             return existing.permalink
 
@@ -85,12 +81,11 @@ class EntityService(BaseService[EntityModel]):
             logger.debug(f"creating unique permalink: {permalink}")
 
         return permalink
-    
-    async def create_or_update_entity(self, schema: EntitySchema) -> (EntityModel, bool):
+
+    async def create_or_update_entity(self, schema: EntitySchema) -> Tuple[EntityModel, bool]:
         """Create new entity or update existing one.
-        if a new entity is created, the return value is (entity, True)
+        Returns: (entity, is_new) where is_new is True if a new entity was created
         """
-
         logger.debug(f"Creating or updating entity: {schema}")
 
         # Try to find existing entity using smart resolution
@@ -107,7 +102,7 @@ class EntityService(BaseService[EntityModel]):
         """Create a new entity and write to filesystem."""
         logger.debug(f"Creating entity: {schema.permalink}")
 
-        # get file path
+        # Get file path and ensure it's a Path object
         file_path = Path(schema.file_path)
 
         if await self.file_service.exists(file_path):
@@ -127,11 +122,9 @@ class EntityService(BaseService[EntityModel]):
 
         # parse entity from file
         entity_markdown = await self.entity_parser.parse_file(file_path)
-        
+
         # create entity
-        created_entity = await self.create_entity_from_markdown(
-            file_path, entity_markdown
-        )
+        await self.create_entity_from_markdown(file_path, entity_markdown)
 
         # add relations
         entity = await self.update_entity_relations(file_path, entity_markdown)
@@ -139,12 +132,11 @@ class EntityService(BaseService[EntityModel]):
         # Set final checksum to mark complete
         return await self.repository.update(entity.id, {"checksum": checksum})
 
-
     async def update_entity(self, entity: EntityModel, schema: EntitySchema) -> EntityModel:
         """Update an entity's content and metadata."""
         logger.debug(f"Updating entity with permalink: {entity.permalink}")
 
-        # get file path
+        # Convert file path string to Path
         file_path = Path(entity.file_path)
 
         post = await schema_to_markdown(schema)
@@ -157,9 +149,7 @@ class EntityService(BaseService[EntityModel]):
         entity_markdown = await self.entity_parser.parse_file(file_path)
 
         # update entity in db
-        entity = await self.update_entity_and_observations(
-            file_path, entity_markdown
-        )
+        entity = await self.update_entity_and_observations(file_path, entity_markdown)
 
         # add relations
         await self.update_entity_relations(file_path, entity_markdown)
@@ -187,10 +177,6 @@ class EntityService(BaseService[EntityModel]):
             logger.info(f"Entity not found: {permalink}")
             return True  # Already deleted
 
-        except Exception as e:
-            logger.error(f"Failed to delete entity: {e}")
-            raise
-
     async def get_by_permalink(self, permalink: str) -> EntityModel:
         """Get entity by type and name combination."""
         logger.debug(f"Getting entity by permalink: {permalink}")
@@ -199,32 +185,14 @@ class EntityService(BaseService[EntityModel]):
             raise EntityNotFoundError(f"Entity not found: {permalink}")
         return db_entity
 
-    async def get_all(self) -> Sequence[EntityModel]:
-        """Get all entities."""
-        return await self.repository.find_all()
-
-    async def get_entity_types(self) -> List[str]:
-        """Get list of all distinct entity types in the system."""
-        logger.debug("Getting all distinct entity types")
-        return await self.repository.get_entity_types()
-
-    async def list_entities(
-        self,
-        entity_type: Optional[str] = None,
-        sort_by: Optional[str] = "updated_at",
-        include_related: bool = False,
-    ) -> Sequence[EntityModel]:
-        """List entities with optional filtering and sorting."""
-        logger.debug(f"Listing entities: type={entity_type} sort={sort_by}")
-        return await self.repository.list_entities(entity_type=entity_type, sort_by=sort_by)
-
     async def get_entities_by_permalinks(self, permalinks: List[str]) -> Sequence[EntityModel]:
         """Get specific nodes and their relationships."""
         logger.debug(f"Getting entities permalinks: {permalinks}")
         return await self.repository.find_by_permalinks(permalinks)
 
-    async def delete_entity_by_file_path(self, file_path):
-        await self.repository.delete_by_file_path(file_path)
+    async def delete_entity_by_file_path(self, file_path: Union[str, Path]) -> None:
+        """Delete entity by file path."""
+        await self.repository.delete_by_file_path(str(file_path))
 
     async def create_entity_from_markdown(
         self, file_path: Path, markdown: EntityMarkdown
@@ -234,15 +202,15 @@ class EntityService(BaseService[EntityModel]):
         Creates the entity with null checksum to indicate sync not complete.
         Relations will be added in second pass.
         """
-        logger.debug(f"Creating entity: {markdown.frontmatter.title}")        
+        logger.debug(f"Creating entity: {markdown.frontmatter.title}")
         model = entity_model_from_markdown(file_path, markdown)
 
-        # Mark as incomplete sync
+        # Mark as incomplete because we still need to add relations
         model.checksum = None
-        return await self.add(model)
+        return await self.repository.add(model)
 
     async def update_entity_and_observations(
-        self, file_path: Path | str, markdown: EntityMarkdown
+        self, file_path: Path, markdown: EntityMarkdown
     ) -> EntityModel:
         """Update entity fields and observations.
 
@@ -250,11 +218,8 @@ class EntityService(BaseService[EntityModel]):
         to indicate sync not complete.
         """
         logger.debug(f"Updating entity and observations: {file_path}")
-        file_path = str(file_path)
 
-        db_entity = await self.repository.get_by_file_path(file_path)
-        if not db_entity:
-            raise EntityNotFoundError(f"Entity not found: {file_path}")
+        db_entity = await self.repository.get_by_file_path(str(file_path))
 
         # Clear observations for entity
         await self.observation_repository.delete_by_fields(entity_id=db_entity.id)
@@ -277,9 +242,8 @@ class EntityService(BaseService[EntityModel]):
 
         # checksum value is None == not finished with sync
         db_entity.checksum = None
-        
+
         # update entity
-        # checksum value is None == not finished with sync
         return await self.repository.update(
             db_entity.id,
             db_entity,
@@ -287,14 +251,13 @@ class EntityService(BaseService[EntityModel]):
 
     async def update_entity_relations(
         self,
-        file_path: Path | str,
+        file_path: Path,
         markdown: EntityMarkdown,
     ) -> EntityModel:
         """Update relations for entity"""
         logger.debug(f"Updating relations for entity: {file_path}")
 
-        file_path = str(file_path)
-        db_entity = await self.repository.get_by_file_path(file_path)
+        db_entity = await self.repository.get_by_file_path(str(file_path))
 
         # Clear existing relations first
         await self.relation_repository.delete_outgoing_relations_from_entity(db_entity.id)
@@ -328,4 +291,4 @@ class EntityService(BaseService[EntityModel]):
                 )
                 continue
 
-        return await self.repository.get_by_file_path(file_path)
+        return await self.repository.get_by_file_path(str(file_path))

basic_memory/services/exceptions.py

@@ -9,6 +9,7 @@ class EntityNotFoundError(Exception):
 
     pass
 
+
 class EntityCreationError(Exception):
     """Raised when an entity cannot be created"""
 

basic_memory/services/file_service.py

@@ -1,20 +1,23 @@
 """Service for file operations with checksum tracking."""
 
 from pathlib import Path
-from typing import Optional, Tuple
+from typing import Tuple, Union
 
 from loguru import logger
 
 from basic_memory import file_utils
 from basic_memory.markdown.markdown_processor import MarkdownProcessor
-from basic_memory.markdown.utils import entity_model_to_markdown
 from basic_memory.models import Entity as EntityModel
-from basic_memory.services.exceptions import FileOperationError
 from basic_memory.schemas import Entity as EntitySchema
+from basic_memory.services.exceptions import FileOperationError
+
 
 class FileService:
-    """
-    Service for handling file operations.
+    """Service for handling file operations.
+
+    All paths are handled as Path objects internally. Strings are converted to
+    Path objects when passed in. Relative paths are assumed to be relative to
+    base_path.
 
     Features:
     - Consistent file writing with checksums
@@ -28,105 +31,66 @@ class FileService:
         base_path: Path,
         markdown_processor: MarkdownProcessor,
     ):
-        self.base_path = base_path
+        self.base_path = base_path.resolve()  # Get absolute path
         self.markdown_processor = markdown_processor
 
-    def get_entity_path(self, entity: EntityModel| EntitySchema) -> Path:
-        """Generate absolute filesystem path for entity."""
-        return self.base_path / f"{entity.file_path}"
-
-    async def write_entity_file(
-        self,
-        entity: EntityModel,
-        content: Optional[str] = None,
-        expected_checksum: Optional[str] = None,
-    ) -> Tuple[Path, str]:
-        """Write entity to filesystem and return path and checksum.
-
-        Uses read->modify->write pattern:
-        1. Read existing file if it exists
-        2. Update with new content if provided
-        3. Write back atomically
+    def get_entity_path(self, entity: Union[EntityModel, EntitySchema]) -> Path:
+        """Generate absolute filesystem path for entity.
 
         Args:
-            entity: Entity model to write
-            content: Optional new content (preserves existing if None)
-            expected_checksum: Optional checksum to verify file hasn't changed
+            entity: Entity model or schema with file_path attribute
 
         Returns:
-            Tuple of (file path, new checksum)
-
-        Raises:
-            FileOperationError: If write fails
+            Absolute Path to the entity file
         """
-        try:
-            path = self.get_entity_path(entity)
-
-            # Read current state if file exists
-            if path.exists():
-                # read the existing file
-                existing_markdown = await self.markdown_processor.read_file(path)
-
-                # if content is supplied use it or existing content
-                content=content or existing_markdown.content
-            
-            # Create new file structure with provided content
-            markdown = entity_model_to_markdown(entity, content=content)
-
-            # Write back atomically
-            checksum = await self.markdown_processor.write_file(
-                path=path, markdown=markdown, expected_checksum=expected_checksum
-            )
-
-            return path, checksum
-
-        except Exception as e:
-            logger.exception(f"Failed to write entity file: {e}")
-            raise FileOperationError(f"Failed to write entity file: {e}")
+        return self.base_path / entity.file_path
 
     async def read_entity_content(self, entity: EntityModel) -> str:
-        """Get entity's content without frontmatter or structured sections (used to index for search)
+        """Get entity's content without frontmatter or structured sections.
+
+        Used to index for search. Returns raw content without frontmatter,
+        observations, or relations.
 
         Args:
             entity: Entity to read content for
 
         Returns:
-            Raw content without frontmatter, observations, or relations
-
-        Raises:
-            FileOperationError: If entity file doesn't exist
+            Raw content string without metadata sections
         """
         logger.debug(f"Reading entity with permalink: {entity.permalink}")
 
-        try:
-            file_path = self.get_entity_path(entity)
-            markdown = await self.markdown_processor.read_file(file_path)
-            return markdown.content or ""
-
-        except Exception as e:
-            logger.error(f"Failed to read entity content: {e}")
-            raise FileOperationError(f"Failed to read entity content: {e}")
+        file_path = self.get_entity_path(entity)
+        markdown = await self.markdown_processor.read_file(file_path)
+        return markdown.content or ""
 
     async def delete_entity_file(self, entity: EntityModel) -> None:
-        """Delete entity file from filesystem."""
-        try:
-            path = self.get_entity_path(entity)
-            await self.delete_file(path)
-        except Exception as e:
-            logger.error(f"Failed to delete entity file: {e}")
-            raise FileOperationError(f"Failed to delete entity file: {e}")
+        """Delete entity file from filesystem.
+
+        Args:
+            entity: Entity model whose file should be deleted
 
-    async def exists(self, path: Path) -> bool:
+        Raises:
+            FileOperationError: If deletion fails
         """
-        Check if file exists at the provided path. If path is relative, it is assumed to be relative to base_path.
+        path = self.get_entity_path(entity)
+        await self.delete_file(path)
+
+    async def exists(self, path: Union[Path, str]) -> bool:
+        """Check if file exists at the provided path.
+
+        If path is relative, it is assumed to be relative to base_path.
 
         Args:
-            path: Path to check
+            path: Path to check (Path object or string)
 
         Returns:
             True if file exists, False otherwise
+
+        Raises:
+            FileOperationError: If check fails
         """
         try:
+            path = Path(path)
             if path.is_absolute():
                 return path.exists()
             else:
@@ -135,12 +99,14 @@ class FileService:
             logger.error(f"Failed to check file existence {path}: {e}")
             raise FileOperationError(f"Failed to check file existence: {e}")
 
-    async def write_file(self, path: Path, content: str) -> str:
-        """
-        Write content to file and return checksum.
+    async def write_file(self, path: Union[Path, str], content: str) -> str:
+        """Write content to file and return checksum.
+
+        Handles both absolute and relative paths. Relative paths are resolved
+        against base_path.
 
         Args:
-            path: Path where to write
+            path: Where to write (Path object or string)
             content: Content to write
 
         Returns:
@@ -149,30 +115,33 @@ class FileService:
         Raises:
             FileOperationError: If write fails
         """
-        
-        path = path if path.is_absolute() else self.base_path / path
+        path = Path(path)
+        full_path = path if path.is_absolute() else self.base_path / path
+
         try:
             # Ensure parent directory exists
-            await file_utils.ensure_directory(path.parent)
+            await file_utils.ensure_directory(full_path.parent)
 
             # Write content atomically
-            await file_utils.write_file_atomic(path, content)
+            await file_utils.write_file_atomic(full_path, content)
 
             # Compute and return checksum
             checksum = await file_utils.compute_checksum(content)
-            logger.debug(f"wrote file: {path}, checksum: {checksum} content: \n{content}")
+            logger.debug(f"wrote file: {full_path}, checksum: {checksum}")
             return checksum
 
         except Exception as e:
-            logger.error(f"Failed to write file {path}: {e}")
+            logger.error(f"Failed to write file {full_path}: {e}")
             raise FileOperationError(f"Failed to write file: {e}")
 
-    async def read_file(self, path: Path) -> Tuple[str, str]:
-        """
-        Read file and compute checksum.
+    async def read_file(self, path: Union[Path, str]) -> Tuple[str, str]:
+        """Read file and compute checksum.
+
+        Handles both absolute and relative paths. Relative paths are resolved
+        against base_path.
 
         Args:
-            path: Path to read
+            path: Path to read (Path object or string)
 
         Returns:
             Tuple of (content, checksum)
@@ -180,33 +149,28 @@ class FileService:
         Raises:
             FileOperationError: If read fails
         """
-        path = path if path.is_absolute() else self.base_path / path
+        path = Path(path)
+        full_path = path if path.is_absolute() else self.base_path / path
+
         try:
             content = path.read_text()
             checksum = await file_utils.compute_checksum(content)
-            logger.debug(f"read file: {path}, checksum: {checksum}")
+            logger.debug(f"read file: {full_path}, checksum: {checksum}")
             return content, checksum
 
         except Exception as e:
-            logger.error(f"Failed to read file {path}: {e}")
+            logger.error(f"Failed to read file {full_path}: {e}")
             raise FileOperationError(f"Failed to read file: {e}")
 
-    async def delete_file(self, path: Path) -> None:
-        """
-        Delete file if it exists.
+    async def delete_file(self, path: Union[Path, str]) -> None:
+        """Delete file if it exists.
 
-        Args:
-            path: Path to delete
+        Handles both absolute and relative paths. Relative paths are resolved
+        against base_path.
 
-        Raises:
-            FileOperationError: If deletion fails
+        Args:
+            path: Path to delete (Path object or string)
         """
-        path = path if path.is_absolute() else self.base_path / path
-        try:
-            path.unlink(missing_ok=True)
-        except Exception as e:
-            logger.error(f"Failed to delete file {path}: {e}")
-            raise FileOperationError(f"Failed to delete file: {e}")
-
-    def path(self, path_string: str, absolute: bool = False):
-        return Path( self.base_path / path_string ) if absolute else Path(path_string).relative_to(self.base_path)
+        path = Path(path)
+        full_path = path if path.is_absolute() else self.base_path / path
+        full_path.unlink(missing_ok=True)

basic_memory/services/link_resolver.py

@@ -5,9 +5,10 @@ from typing import Optional, Tuple, List
 from loguru import logger
 
 from basic_memory.repository.entity_repository import EntityRepository
+from basic_memory.repository.search_repository import SearchIndexRow
 from basic_memory.services.search_service import SearchService
 from basic_memory.models import Entity
-from basic_memory.schemas.search import SearchQuery, SearchResult, SearchItemType
+from basic_memory.schemas.search import SearchQuery, SearchItemType
 
 
 class LinkResolver:
@@ -45,18 +46,19 @@ class LinkResolver:
             return entity
 
         if use_search:
-            
             # 3. Fall back to search for fuzzy matching on title if specified
             results = await self.search_service.search(
                 query=SearchQuery(title=clean_text, types=[SearchItemType.ENTITY]),
             )
-    
+
             if results:
                 # Look for best match
                 best_match = self._select_best_match(clean_text, results)
-                logger.debug(f"Selected best match from {len(results)} results: {best_match.permalink}")
+                logger.debug(
+                    f"Selected best match from {len(results)} results: {best_match.permalink}"
+                )
                 return await self.entity_repository.get_by_permalink(best_match.permalink)
-    
+
             # if we couldn't find anything then return None
         return None
 
@@ -85,7 +87,7 @@ class LinkResolver:
 
         return text, alias
 
-    def _select_best_match(self, search_text: str, results: List[SearchResult]) -> Entity:
+    def _select_best_match(self, search_text: str, results: List[SearchIndexRow]) -> Entity:
         """Select best match from search results.
 
         Uses multiple criteria:
@@ -93,9 +95,6 @@ class LinkResolver:
         2. Word matches in path
         3. Overall search score
         """
-        if not results:
-            raise ValueError("Cannot select from empty results")
-
         # Get search terms for matching
         terms = search_text.lower().split()
 
@@ -104,6 +103,7 @@ class LinkResolver:
         for result in results:
             # Start with base score (lower is better)
             score = result.score
+            assert score is not None
 
             # Parse path components
             path_parts = result.permalink.lower().split("/")

basic_memory/services/search_service.py

@@ -1,5 +1,6 @@
 """Service for search operations."""
 
+from datetime import datetime
 from typing import List, Optional, Set
 
 from fastapi import BackgroundTasks
@@ -8,9 +9,8 @@ from loguru import logger
 from basic_memory.models import Entity
 from basic_memory.repository import EntityRepository
 from basic_memory.repository.search_repository import SearchRepository, SearchIndexRow
-from basic_memory.schemas.search import SearchQuery, SearchResult, SearchItemType
+from basic_memory.schemas.search import SearchQuery, SearchItemType
 from basic_memory.services import FileService
-from basic_memory.services.exceptions import FileOperationError
 
 
 class SearchService:
@@ -51,9 +51,7 @@ class SearchService:
 
         logger.info("Reindex complete")
 
-    async def search(
-        self, query: SearchQuery, context: Optional[List[str]] = None
-    ) -> List[SearchResult]:
+    async def search(self, query: SearchQuery) -> List[SearchIndexRow]:
         """Search across all indexed content.
 
         Supports three modes:
@@ -67,6 +65,16 @@ class SearchService:
 
         logger.debug(f"Searching with query: {query}")
 
+        after_date = (
+            (
+                query.after_date
+                if isinstance(query.after_date, datetime)
+                else datetime.fromisoformat(query.after_date)
+            )
+            if query.after_date
+            else None
+        )
+
         # permalink search
         results = await self.repository.search(
             search_text=query.text,
@@ -75,12 +83,13 @@ class SearchService:
             title=query.title,
             types=query.types,
             entity_types=query.entity_types,
-            after_date=query.after_date,
+            after_date=after_date,
         )
 
         return results
 
-    def _generate_variants(self, text: str) -> Set[str]:
+    @staticmethod
+    def _generate_variants(text: str) -> Set[str]:
         """Generate text variants for better fuzzy matching.
 
         Creates variations of the text to improve match chances:
@@ -140,7 +149,6 @@ class SearchService:
         title_variants = self._generate_variants(entity.title)
         content_parts.extend(title_variants)
 
-        # TODO should we do something to content on indexing?
         content = await self.file_service.read_entity_content(entity)
         if content:
             content_parts.append(content)
@@ -162,8 +170,8 @@ class SearchService:
                 metadata={
                     "entity_type": entity.entity_type,
                 },
-                created_at=entity.created_at.isoformat(),
-                updated_at=entity.updated_at.isoformat(),
+                created_at=entity.created_at,
+                updated_at=entity.updated_at,
             )
         )
 
@@ -183,8 +191,8 @@ class SearchService:
                     metadata={
                         "tags": obs.tags,
                     },
-                    created_at=entity.created_at.isoformat(),
-                    updated_at=entity.updated_at.isoformat(),
+                    created_at=entity.created_at,
+                    updated_at=entity.updated_at,
                 )
             )
 
@@ -201,15 +209,14 @@ class SearchService:
                 SearchIndexRow(
                     id=rel.id,
                     title=relation_title,
-                    content=rel.context or "",
                     permalink=rel.permalink,
                     file_path=entity.file_path,
                     type=SearchItemType.RELATION.value,
                     from_id=rel.from_id,
                     to_id=rel.to_id,
                     relation_type=rel.relation_type,
-                    created_at=entity.created_at.isoformat(),
-                    updated_at=entity.updated_at.isoformat(),
+                    created_at=entity.created_at,
+                    updated_at=entity.updated_at,
                 )
             )