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

kodit/infrastructure/cloning/git/factory.py

@@ -1,153 +0,0 @@
-"""Factory for creating git-based working copies."""
-
-import tempfile
-from pathlib import Path
-
-import git
-import structlog
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from kodit.domain.entities import AuthorFileMapping, Source, SourceType
-from kodit.domain.interfaces import NullProgressCallback, ProgressCallback
-from kodit.domain.repositories import SourceRepository
-from kodit.domain.services.ignore_service import IgnoreService
-from kodit.domain.value_objects import ProgressEvent
-from kodit.infrastructure.cloning.git.working_copy import GitWorkingCopyProvider
-from kodit.infrastructure.cloning.metadata import (
-    GitAuthorExtractor,
-    GitFileMetadataExtractor,
-)
-from kodit.infrastructure.git.git_utils import sanitize_git_url
-from kodit.infrastructure.ignore.ignore_pattern_provider import GitIgnorePatternProvider
-
-
-class GitSourceFactory:
-    """Factory for creating git-based working copies."""
-
-    def __init__(
-        self,
-        repository: SourceRepository,
-        working_copy: GitWorkingCopyProvider,
-        session: AsyncSession,
-    ) -> None:
-        """Initialize the source factory."""
-        self.log = structlog.get_logger(__name__)
-        self.repository = repository
-        self.working_copy = working_copy
-        self.metadata_extractor = GitFileMetadataExtractor()
-        self.author_extractor = GitAuthorExtractor(repository)
-        self.session = session
-
-    async def create(
-        self, uri: str, progress_callback: ProgressCallback | None = None
-    ) -> Source:
-        """Create a git source from a URI."""
-        # Use null callback if none provided
-        if progress_callback is None:
-            progress_callback = NullProgressCallback()
-
-        # Normalize the URI
-        # Never log the raw URI in production
-        self.log.debug("Normalising git uri", uri="[REDACTED]" + uri[-4:])
-        with tempfile.TemporaryDirectory() as temp_dir:
-            git.Repo.clone_from(uri, temp_dir)
-            remote = git.Repo(temp_dir).remote()
-            uri = remote.url
-
-        # Sanitize the URI to remove any credentials
-        sanitized_uri = sanitize_git_url(uri)
-        self.log.debug("Sanitized git uri", sanitized_uri=sanitized_uri)
-
-        # Check if source already exists
-        self.log.debug("Checking if source already exists", uri=sanitized_uri)
-        source = await self.repository.get_by_uri(sanitized_uri)
-
-        if source:
-            self.log.info("Source already exists, reusing...", source_id=source.id)
-            return source
-
-        # Prepare working copy (use original URI for cloning, sanitized for storage)
-        clone_path = await self.working_copy.prepare(uri)
-
-        # Create source record
-        self.log.debug("Creating source", uri=sanitized_uri, clone_path=str(clone_path))
-        source = await self.repository.save(
-            Source(
-                uri=sanitized_uri,
-                cloned_path=str(clone_path),
-                source_type=SourceType.GIT,
-            )
-        )
-
-        # Commit source creation so we get an ID for foreign key relationships
-        await self.session.commit()
-
-        # Get files to process using ignore patterns
-        ignore_provider = GitIgnorePatternProvider(clone_path)
-        ignore_service = IgnoreService(ignore_provider)
-        files = [
-            f
-            for f in clone_path.rglob("*")
-            if f.is_file() and not ignore_service.should_ignore(f)
-        ]
-
-        # Process files
-        self.log.info("Inspecting files", source_id=source.id, num_files=len(files))
-        await self._process_files(source, files, progress_callback)
-
-        # Commit file processing
-        await self.session.commit()
-
-        return source
-
-    async def _process_files(
-        self, source: Source, files: list[Path], progress_callback: ProgressCallback
-    ) -> None:
-        """Process files for a source."""
-        total_files = len(files)
-
-        # Notify start of operation
-        await progress_callback.on_progress(
-            ProgressEvent(
-                operation="process_files",
-                current=0,
-                total=total_files,
-                message="Processing files...",
-            )
-        )
-
-        for i, path in enumerate(files, 1):
-            if not path.is_file():
-                continue
-
-            # Extract file metadata
-            file_record = await self.metadata_extractor.extract(path, source)
-            await self.repository.create_file(file_record)
-
-            # Extract authors
-            authors = await self.author_extractor.extract(path, source)
-
-            # Commit authors so they get IDs before creating mappings
-            if authors:
-                await self.session.commit()
-
-            for author in authors:
-                await self.repository.upsert_author_file_mapping(
-                    AuthorFileMapping(
-                        author_id=author.id,
-                        file_id=file_record.id,
-                    )
-                )
-
-            # Update progress
-            await progress_callback.on_progress(
-                ProgressEvent(
-                    operation="process_files",
-                    current=i,
-                    total=total_files,
-                    message=f"Processing {path.name}...",
-                )
-            )
-
-        # Notify completion
-        await progress_callback.on_complete("process_files")

kodit/infrastructure/indexing/index_repository.py

@@ -1,273 +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 Embedding, File, Index, Snippet, Source
-from kodit.domain.services.indexing_service import IndexRepository
-from kodit.domain.value_objects import FileInfo, IndexView, SnippetInfo, SnippetWithFile
-
-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"],
-        )
-        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[SnippetWithFile]:
-        """List snippets by IDs.
-
-        Args:
-            ids: List of snippet IDs to retrieve.
-
-        Returns:
-            List of SnippetWithFile objects containing file and snippet information.
-
-        """
-        query = (
-            select(Snippet, File)
-            .where(Snippet.id.in_(ids))
-            .join(File, Snippet.file_id == File.id)
-        )
-        rows = await self.session.execute(query)
-
-        # Create a dictionary for O(1) lookup of results by ID
-        id_to_result = {}
-        for snippet, file in rows.all():
-            id_to_result[snippet.id] = SnippetWithFile(
-                file=FileInfo(uri=file.uri),
-                snippet=SnippetInfo(id=snippet.id, content=snippet.content)
-            )
-
-        # 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)),
-        )