kodit 0.3.2__py3-none-any.whl → 0.3.3__py3-none-any.whl

kodit/infrastructure/indexing/index_repository.py

@@ -1,286 +0,0 @@
-"""Infrastructure implementation of the index repository."""
-
-from datetime import UTC, datetime
-from typing import TypeVar
-
-from sqlalchemy import delete, func, select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from kodit.domain.entities import (
-    Author,
-    AuthorFileMapping,
-    Embedding,
-    File,
-    Index,
-    Snippet,
-    Source,
-)
-from kodit.domain.services.indexing_service import IndexRepository
-from kodit.domain.value_objects import (
-    IndexView,
-    SnippetWithContext,
-)
-
-T = TypeVar("T")
-
-
-class SQLAlchemyIndexRepository(IndexRepository):
-    """SQLAlchemy implementation of the index repository."""
-
-    def __init__(self, session: AsyncSession) -> None:
-        """Initialize the index repository.
-
-        Args:
-            session: The SQLAlchemy async session to use for database operations.
-
-        """
-        self.session = session
-
-    async def create_index(self, source_id: int) -> IndexView:
-        """Create a new index for a source.
-
-        Args:
-            source_id: The ID of the source to create an index for.
-
-        Returns:
-            The created index view.
-
-        """
-        # Check if index already exists
-        existing_index = await self.get_index_by_source_id(source_id)
-        if existing_index:
-            return existing_index
-
-        index = Index(source_id=source_id)
-        self.session.add(index)
-
-        # Get source for the view
-        source_query = select(Source).where(Source.id == source_id)
-        source_result = await self.session.execute(source_query)
-        source = source_result.scalar_one()
-
-        return IndexView(
-            id=index.id,
-            created_at=index.created_at,
-            updated_at=index.updated_at,
-            source=source.uri,
-            num_snippets=0,
-        )
-
-    async def _get_index_view(self, index: Index, source: Source) -> IndexView:
-        """Create an IndexView from Index and Source entities.
-
-        Args:
-            index: The index entity
-            source: The source entity
-
-        Returns:
-            The index view
-
-        """
-        num_snippets = await self.num_snippets_for_index(index.id)
-        return IndexView(
-            id=index.id,
-            created_at=index.created_at,
-            updated_at=index.updated_at,
-            source=source.uri,
-            num_snippets=num_snippets,
-        )
-
-    async def get_index_by_id(self, index_id: int) -> IndexView | None:
-        """Get an index by its ID.
-
-        Args:
-            index_id: The ID of the index to retrieve.
-
-        Returns:
-            The index view if found, None otherwise.
-
-        """
-        query = (
-            select(Index, Source)
-            .join(Source, Index.source_id == Source.id)
-            .where(Index.id == index_id)
-        )
-        result = await self.session.execute(query)
-        row = result.first()
-
-        if not row:
-            return None
-
-        index, source = row
-        return await self._get_index_view(index, source)
-
-    async def get_index_by_source_id(self, source_id: int) -> IndexView | None:
-        """Get an index by its source ID.
-
-        Args:
-            source_id: The ID of the source to retrieve an index for.
-
-        Returns:
-            The index view if found, None otherwise.
-
-        """
-        query = (
-            select(Index, Source)
-            .join(Source, Index.source_id == Source.id)
-            .where(Index.source_id == source_id)
-        )
-        result = await self.session.execute(query)
-        row = result.first()
-
-        if not row:
-            return None
-
-        index, source = row
-        return await self._get_index_view(index, source)
-
-    async def list_indexes(self) -> list[IndexView]:
-        """List all indexes.
-
-        Returns:
-            A list of index views.
-
-        """
-        query = select(Index, Source).join(
-            Source, Index.source_id == Source.id, full=True
-        )
-        result = await self.session.execute(query)
-        rows = result.tuples()
-
-        indexes = []
-        for index, source in rows:
-            index_view = await self._get_index_view(index, source)
-            indexes.append(index_view)
-
-        return indexes
-
-    async def update_index_timestamp(self, index_id: int) -> None:
-        """Update the timestamp of an index.
-
-        Args:
-            index_id: The ID of the index to update.
-
-        """
-        query = select(Index).where(Index.id == index_id)
-        result = await self.session.execute(query)
-        index = result.scalar_one_or_none()
-
-        if index:
-            index.updated_at = datetime.now(UTC)
-
-    async def delete_all_snippets(self, index_id: int) -> None:
-        """Delete all snippets for an index.
-
-        Args:
-            index_id: The ID of the index to delete snippets for.
-
-        """
-        # First get all snippets for this index
-        snippets = await self.get_snippets_for_index(index_id)
-
-        # Delete all embeddings for these snippets, if there are any
-        for snippet in snippets:
-            query = delete(Embedding).where(Embedding.snippet_id == snippet.id)
-            await self.session.execute(query)
-
-        # Now delete the snippets
-        query = delete(Snippet).where(Snippet.index_id == index_id)
-        await self.session.execute(query)
-
-    async def get_snippets_for_index(self, index_id: int) -> list[Snippet]:
-        """Get all snippets for an index.
-
-        Args:
-            index_id: The ID of the index to get snippets for.
-
-        Returns:
-            A list of Snippet entities.
-
-        """
-        query = select(Snippet).where(Snippet.index_id == index_id)
-        result = await self.session.execute(query)
-        return list(result.scalars())
-
-    async def add_snippet(self, snippet: dict) -> None:
-        """Add a snippet to the database.
-
-        Args:
-            snippet: The snippet to add.
-
-        """
-        db_snippet = Snippet(
-            file_id=snippet["file_id"],
-            index_id=snippet["index_id"],
-            content=snippet["content"],
-            summary=snippet.get("summary", ""),
-        )
-        self.session.add(db_snippet)
-
-    async def update_snippet_content(self, snippet_id: int, content: str) -> None:
-        """Update the content of an existing snippet.
-
-        Args:
-            snippet_id: The ID of the snippet to update.
-            content: The new content for the snippet.
-
-        """
-        query = select(Snippet).where(Snippet.id == snippet_id)
-        result = await self.session.execute(query)
-        snippet = result.scalar_one_or_none()
-
-        if snippet:
-            snippet.content = content
-            # SQLAlchemy will automatically track this change
-
-    async def list_snippets_by_ids(self, ids: list[int]) -> list[SnippetWithContext]:
-        """List snippets by IDs."""
-        query = (
-            select(Snippet, File, Source, Author)
-            .where(Snippet.id.in_(ids))
-            .join(File, Snippet.file_id == File.id)
-            .join(Source, File.source_id == Source.id)
-            .outerjoin(AuthorFileMapping, AuthorFileMapping.file_id == File.id)
-            .outerjoin(Author, AuthorFileMapping.author_id == Author.id)
-        )
-        rows = await self.session.execute(query)
-
-        # Group results by snippet ID and collect authors
-        id_to_result: dict[int, SnippetWithContext] = {}
-        for snippet, file, source, author in rows.all():
-            if snippet.id not in id_to_result:
-                id_to_result[snippet.id] = SnippetWithContext(
-                    snippet=snippet,
-                    file=file,
-                    source=source,
-                    authors=[],
-                )
-            # Add author if it exists (outer join might return None)
-            if author is not None:
-                id_to_result[snippet.id].authors.append(author)
-
-        # Check that all IDs are present
-        if len(id_to_result) != len(ids):
-            # Create a list of missing IDs
-            missing_ids = [
-                snippet_id for snippet_id in ids if snippet_id not in id_to_result
-            ]
-            msg = f"Some IDs are not present: {missing_ids}"
-            raise ValueError(msg)
-
-        # Rebuild the list in the same order that it was passed in
-        return [id_to_result[i] for i in ids]
-
-    async def num_snippets_for_index(self, index_id: int) -> int:
-        """Get the number of snippets for an index.
-
-        Args:
-            index_id: The ID of the index.
-
-        Returns:
-            The number of snippets.
-
-        """
-        query = select(func.count()).where(Snippet.index_id == index_id)
-        result = await self.session.execute(query)
-        return result.scalar_one()

kodit/infrastructure/indexing/snippet_domain_service_factory.py

@@ -1,37 +0,0 @@
-"""Factory for creating snippet domain service."""
-
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from kodit.domain.services.snippet_service import SnippetDomainService
-from kodit.infrastructure.snippet_extraction.snippet_extraction_factory import (
-    create_snippet_extraction_domain_service,
-)
-from kodit.infrastructure.sqlalchemy.file_repository import SqlAlchemyFileRepository
-from kodit.infrastructure.sqlalchemy.snippet_repository import (
-    SqlAlchemySnippetRepository,
-)
-
-
-def snippet_domain_service_factory(session: AsyncSession) -> SnippetDomainService:
-    """Create a snippet domain service with all dependencies.
-
-    Args:
-        session: The database session
-
-    Returns:
-        Configured snippet domain service
-
-    """
-    # Create domain service for snippet extraction
-    snippet_extraction_service = create_snippet_extraction_domain_service()
-
-    # Create repositories
-    snippet_repository = SqlAlchemySnippetRepository(session)
-    file_repository = SqlAlchemyFileRepository(session)
-
-    # Create and return the domain service
-    return SnippetDomainService(
-        snippet_extraction_service=snippet_extraction_service,
-        snippet_repository=snippet_repository,
-        file_repository=file_repository,
-    )

kodit/infrastructure/sqlalchemy/repository.py

@@ -1,133 +0,0 @@
-"""SQLAlchemy repository."""
-
-from collections.abc import Sequence
-from typing import cast
-
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from kodit.domain.entities import Author, AuthorFileMapping, File, Source, SourceType
-from kodit.domain.repositories import AuthorRepository, SourceRepository
-
-
-class SqlAlchemySourceRepository(SourceRepository):
-    """SQLAlchemy source repository."""
-
-    def __init__(self, session: AsyncSession) -> None:
-        """Initialize the repository."""
-        self._session = session
-
-    async def get(self, id: int) -> Source | None:  # noqa: A002
-        """Get a source by ID."""
-        return await self._session.get(Source, id)
-
-    async def save(self, entity: Source) -> Source:
-        """Save entity."""
-        self._session.add(entity)
-        return entity
-
-    async def delete(self, id: int) -> None:  # noqa: A002
-        """Delete entity by ID."""
-        source = await self.get(id)
-        if source:
-            await self._session.delete(source)
-
-    async def list(self) -> Sequence[Source]:
-        """List all entities."""
-        stmt = select(Source)
-        return (await self._session.scalars(stmt)).all()
-
-    async def get_by_uri(self, uri: str) -> Source | None:
-        """Get a source by URI."""
-        stmt = select(Source).where(Source.uri == uri)
-        return cast("Source | None", await self._session.scalar(stmt))
-
-    async def list_by_type(
-        self, source_type: SourceType | None = None
-    ) -> Sequence[Source]:
-        """List sources by type."""
-        stmt = select(Source)
-        if source_type is not None:
-            stmt = stmt.where(Source.type == source_type)
-        return (await self._session.scalars(stmt)).all()
-
-    async def create_file(self, file: File) -> File:
-        """Create a new file record."""
-        self._session.add(file)
-        return file
-
-    async def upsert_author(self, author: Author) -> Author:
-        """Create a new author or return existing one if email already exists."""
-        # First check if author already exists with same name and email
-        stmt = select(Author).where(
-            Author.name == author.name, Author.email == author.email
-        )
-        existing_author = cast("Author | None", await self._session.scalar(stmt))
-
-        if existing_author:
-            return existing_author
-
-        # Author doesn't exist, create new one
-        self._session.add(author)
-        return author
-
-    async def upsert_author_file_mapping(
-        self, mapping: AuthorFileMapping
-    ) -> AuthorFileMapping:
-        """Create a new author file mapping or return existing one if already exists."""
-        # First check if mapping already exists with same author_id and file_id
-        stmt = select(AuthorFileMapping).where(
-            AuthorFileMapping.author_id == mapping.author_id,
-            AuthorFileMapping.file_id == mapping.file_id,
-        )
-        existing_mapping = cast(
-            "AuthorFileMapping | None", await self._session.scalar(stmt)
-        )
-
-        if existing_mapping:
-            return existing_mapping
-
-        # Mapping doesn't exist, create new one
-        self._session.add(mapping)
-        return mapping
-
-
-class SqlAlchemyAuthorRepository(AuthorRepository):
-    """SQLAlchemy author repository."""
-
-    def __init__(self, session: AsyncSession) -> None:
-        """Initialize the repository."""
-        self._session = session
-
-    async def get(self, id: int) -> Author | None:  # noqa: A002
-        """Get an author by ID."""
-        return await self._session.get(Author, id)
-
-    async def save(self, entity: Author) -> Author:
-        """Save entity."""
-        self._session.add(entity)
-        return entity
-
-    async def delete(self, id: int) -> None:  # noqa: A002
-        """Delete entity by ID."""
-        author = await self.get(id)
-        if author:
-            await self._session.delete(author)
-
-    async def list(self) -> Sequence[Author]:
-        """List authors."""
-        return (await self._session.scalars(select(Author))).all()
-
-    async def get_by_name(self, name: str) -> Author | None:
-        """Get an author by name."""
-        return cast(
-            "Author | None",
-            await self._session.scalar(select(Author).where(Author.name == name)),
-        )
-
-    async def get_by_email(self, email: str) -> Author | None:
-        """Get an author by email."""
-        return cast(
-            "Author | None",
-            await self._session.scalar(select(Author).where(Author.email == email)),
-        )