kodit 0.4.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

kodit/infrastructure/mappers/index_mapper.py

@@ -1,345 +0,0 @@
-"""Mapping between domain Index aggregate and SQLAlchemy entities."""
-
-from datetime import UTC, datetime
-from pathlib import Path
-
-from pydantic import AnyUrl
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-import kodit.domain.entities as domain_entities
-from kodit.domain.value_objects import (
-    FileProcessingStatus,
-    SourceType,
-)
-from kodit.infrastructure.sqlalchemy import entities as db_entities
-
-
-# TODO(Phil): Make this a pure mapper without any DB access # noqa: TD003, FIX002
-class IndexMapper:
-    """Mapper for converting between domain Index aggregate and database entities."""
-
-    def __init__(self, session: AsyncSession) -> None:
-        """Initialize mapper with database session."""
-        self._session = session
-
-    async def to_domain_index(
-        self, db_index: db_entities.Index
-    ) -> domain_entities.Index:
-        """Convert SQLAlchemy Index to domain Index aggregate.
-
-        Loads the full aggregate including Source, WorkingCopy, Files, and Snippets.
-        """
-        # Load the source
-        db_source = await self._session.get(db_entities.Source, db_index.source_id)
-        if not db_source:
-            raise ValueError(f"Source not found for index {db_index.id}")
-
-        # Load files for the source
-        files_stmt = select(db_entities.File).where(
-            db_entities.File.source_id == db_source.id
-        )
-        db_files = (await self._session.scalars(files_stmt)).all()
-
-        # Convert files to domain
-        domain_files = []
-        for db_file in db_files:
-            # Load authors for this file
-            authors_stmt = (
-                select(db_entities.Author)
-                .join(db_entities.AuthorFileMapping)
-                .where(db_entities.AuthorFileMapping.file_id == db_file.id)
-            )
-            db_authors = (await self._session.scalars(authors_stmt)).all()
-
-            domain_authors = [
-                domain_entities.Author(
-                    id=author.id, name=author.name, email=author.email
-                )
-                for author in db_authors
-            ]
-
-            domain_file = domain_entities.File(
-                id=db_file.id,
-                created_at=db_file.created_at,
-                updated_at=db_file.updated_at,
-                uri=AnyUrl(db_file.uri),
-                sha256=db_file.sha256,
-                authors=domain_authors,
-                mime_type=db_file.mime_type,
-                file_processing_status=FileProcessingStatus(
-                    db_file.file_processing_status
-                ),
-            )
-            domain_files.append(domain_file)
-
-        # Create working copy
-        working_copy = domain_entities.WorkingCopy(
-            created_at=db_source.created_at,
-            updated_at=db_source.updated_at,
-            remote_uri=AnyUrl(db_source.uri),
-            cloned_path=Path(db_source.cloned_path),
-            source_type=SourceType(db_source.type.value),
-            files=domain_files,
-        )
-
-        # Create source
-        domain_source = domain_entities.Source(
-            id=db_source.id,
-            created_at=db_source.created_at,
-            updated_at=db_source.updated_at,
-            working_copy=working_copy,
-        )
-
-        # Load snippets for this index
-        snippets_stmt = select(db_entities.Snippet).where(
-            db_entities.Snippet.index_id == db_index.id
-        )
-        db_snippets = (await self._session.scalars(snippets_stmt)).all()
-
-        domain_snippets = []
-        for db_snippet in db_snippets:
-            domain_snippet = await self.to_domain_snippet(db_snippet, domain_files)
-            domain_snippets.append(domain_snippet)
-
-        # Create index aggregate
-        return domain_entities.Index(
-            id=db_index.id,
-            created_at=db_index.created_at,
-            updated_at=db_index.updated_at,
-            source=domain_source,
-            snippets=domain_snippets,
-        )
-
-    async def to_domain_source(
-        self, db_source: db_entities.Source
-    ) -> domain_entities.Source:
-        """Convert SQLAlchemy Source to domain Source."""
-        # Load files for the source
-        files_stmt = select(db_entities.File).where(
-            db_entities.File.source_id == db_source.id
-        )
-        db_files = (await self._session.scalars(files_stmt)).all()
-
-        # Convert files to domain
-        domain_files = []
-        for db_file in db_files:
-            # Load authors for this file
-            authors_stmt = (
-                select(db_entities.Author)
-                .join(db_entities.AuthorFileMapping)
-                .where(db_entities.AuthorFileMapping.file_id == db_file.id)
-            )
-            db_authors = (await self._session.scalars(authors_stmt)).all()
-
-            domain_authors = [
-                domain_entities.Author(
-                    id=author.id, name=author.name, email=author.email
-                )
-                for author in db_authors
-            ]
-
-            domain_file = domain_entities.File(
-                id=db_file.id,
-                created_at=db_file.created_at,
-                updated_at=db_file.updated_at,
-                uri=AnyUrl(db_file.uri),
-                sha256=db_file.sha256,
-                authors=domain_authors,
-                mime_type=db_file.mime_type,
-                file_processing_status=FileProcessingStatus(
-                    db_file.file_processing_status
-                ),
-            )
-            domain_files.append(domain_file)
-
-        # Create working copy
-        working_copy = domain_entities.WorkingCopy(
-            created_at=db_source.created_at,
-            updated_at=db_source.updated_at,
-            remote_uri=AnyUrl(db_source.uri),
-            cloned_path=Path(db_source.cloned_path),
-            source_type=SourceType(db_source.type.value),
-            files=domain_files,
-        )
-
-        # Create source
-        return domain_entities.Source(
-            id=db_source.id,
-            created_at=db_source.created_at,
-            updated_at=db_source.updated_at,
-            working_copy=working_copy,
-        )
-
-    async def to_domain_file(self, db_file: db_entities.File) -> domain_entities.File:
-        """Convert SQLAlchemy File to domain File."""
-        # Load authors for this file
-        authors_stmt = (
-            select(db_entities.Author)
-            .join(db_entities.AuthorFileMapping)
-            .where(db_entities.AuthorFileMapping.file_id == db_file.id)
-        )
-        db_authors = (await self._session.scalars(authors_stmt)).all()
-
-        domain_authors = [
-            domain_entities.Author(id=author.id, name=author.name, email=author.email)
-            for author in db_authors
-        ]
-
-        return domain_entities.File(
-            id=db_file.id,
-            created_at=db_file.created_at,
-            updated_at=db_file.updated_at,
-            uri=AnyUrl(db_file.uri),
-            sha256=db_file.sha256,
-            authors=domain_authors,
-            mime_type=db_file.mime_type,
-            file_processing_status=FileProcessingStatus(db_file.file_processing_status),
-        )
-
-    async def to_domain_snippet(
-        self, db_snippet: db_entities.Snippet, domain_files: list[domain_entities.File]
-    ) -> domain_entities.Snippet:
-        """Convert SQLAlchemy Snippet to domain Snippet."""
-        # Find the file this snippet derives from
-        derives_from = []
-        for domain_file in domain_files:
-            if domain_file.id == db_snippet.file_id:
-                derives_from.append(domain_file)
-                break
-
-        # Create domain snippet with original content
-        domain_snippet = domain_entities.Snippet(
-            id=db_snippet.id,
-            created_at=db_snippet.created_at,
-            updated_at=db_snippet.updated_at,
-            derives_from=derives_from,
-        )
-
-        # Add original content
-        if db_snippet.content:
-            domain_snippet.add_original_content(db_snippet.content, "unknown")
-
-        # Add summary content if it exists
-        if db_snippet.summary:
-            domain_snippet.add_summary(db_snippet.summary)
-
-        return domain_snippet
-
-    async def from_domain_index(  # noqa: C901
-        self, domain_index: domain_entities.Index
-    ) -> tuple[
-        db_entities.Index,
-        db_entities.Source,
-        list[db_entities.File],
-        list[db_entities.Author],
-    ]:
-        """Convert domain Index aggregate to SQLAlchemy entities.
-
-        Returns all the entities that need to be persisted.
-        """
-        # Create source entity
-        db_source = db_entities.Source(
-            uri=str(domain_index.source.working_copy.remote_uri),
-            cloned_path=str(domain_index.source.working_copy.cloned_path),
-            source_type=db_entities.SourceType(
-                domain_index.source.working_copy.source_type.value
-            ),
-        )
-        if domain_index.source.id:
-            db_source.id = domain_index.source.id
-        if domain_index.source.created_at:
-            db_source.created_at = domain_index.source.created_at
-        if domain_index.source.updated_at:
-            db_source.updated_at = domain_index.source.updated_at
-
-        # Create index entity
-        # Will be set after source is saved
-        db_index = db_entities.Index(source_id=db_source.id or 0)
-        if domain_index.id:
-            db_index.id = domain_index.id
-        if domain_index.created_at:
-            db_index.created_at = domain_index.created_at
-        if domain_index.updated_at:
-            db_index.updated_at = domain_index.updated_at
-
-        # Create file entities
-        db_files = []
-        all_authors = []
-
-        for domain_file in domain_index.source.working_copy.files:
-            now = datetime.now(UTC)
-            db_file = db_entities.File(
-                created_at=domain_file.created_at or now,
-                updated_at=domain_file.updated_at or now,
-                source_id=db_source.id or 0,  # Will be set after source is saved
-                mime_type="",  # Would need to be determined
-                uri=str(domain_file.uri),
-                # Would need to be determined from working copy + relative path
-                cloned_path="",
-                sha256=domain_file.sha256,
-                size_bytes=0,  # Would need to be determined
-                extension="",  # Would need to be determined
-                file_processing_status=domain_file.file_processing_status.value,
-            )
-            if domain_file.id:
-                db_file.id = domain_file.id
-
-            db_files.append(db_file)
-            all_authors.extend(domain_file.authors)
-
-        # Create unique author entities
-        unique_authors = {}
-        for author in all_authors:
-            key = (author.name, author.email)
-            if key not in unique_authors:
-                db_author = db_entities.Author(name=author.name, email=author.email)
-                if author.id:
-                    db_author.id = author.id
-                unique_authors[key] = db_author
-
-        return db_index, db_source, db_files, list(unique_authors.values())
-
-    async def from_domain_snippet(
-        self, domain_snippet: domain_entities.Snippet, index_id: int
-    ) -> db_entities.Snippet:
-        """Convert domain Snippet to SQLAlchemy Snippet."""
-        # Get file ID from derives_from (use first file if multiple)
-        if not domain_snippet.derives_from:
-            raise ValueError("Snippet must derive from at least one file")
-
-        file_id = domain_snippet.derives_from[0].id
-        if file_id is None:
-            raise ValueError("File must have an ID")
-
-        db_snippet = db_entities.Snippet(
-            file_id=file_id,
-            index_id=index_id,
-            content=domain_snippet.original_text(),
-            summary=domain_snippet.summary_text(),
-        )
-
-        if domain_snippet.id:
-            db_snippet.id = domain_snippet.id
-        if domain_snippet.created_at:
-            db_snippet.created_at = domain_snippet.created_at
-        if domain_snippet.updated_at:
-            db_snippet.updated_at = domain_snippet.updated_at
-
-        return db_snippet
-
-    async def load_snippets_for_index(
-        self, index_id: int, domain_files: list[domain_entities.File]
-    ) -> list[domain_entities.Snippet]:
-        """Load all snippets for an index and convert to domain entities."""
-        stmt = select(db_entities.Snippet).where(
-            db_entities.Snippet.index_id == index_id
-        )
-        db_snippets = (await self._session.scalars(stmt)).all()
-
-        domain_snippets = []
-        for db_snippet in db_snippets:
-            domain_snippet = await self.to_domain_snippet(db_snippet, domain_files)
-            domain_snippets.append(domain_snippet)
-
-        return domain_snippets

kodit/infrastructure/reporting/tdqm_progress.py

@@ -1,73 +0,0 @@
-"""TQDM progress."""
-
-from tqdm import tqdm
-
-from kodit.config import ReportingConfig
-from kodit.domain.protocols import ReportingModule
-from kodit.domain.value_objects import Progress, ProgressState, ReportingState
-
-
-class TQDMReportingModule(ReportingModule):
-    """TQDM reporting module."""
-
-    def __init__(self, config: ReportingConfig) -> None:
-        """Initialize the TQDM reporting module."""
-        self.config = config
-        self.pbar = tqdm()
-
-    def on_change(self, step: Progress) -> None:
-        """On step changed."""
-        if step.state == ReportingState.COMPLETED:
-            self.pbar.close()
-            return
-
-        self.pbar.set_description(step.message)
-        self.pbar.refresh()
-        # Update description if message is provided
-        if step.message:
-            # Fix the event message to a specific size so it's not jumping around
-            # If it's too small, add spaces
-            # If it's too large, truncate
-            if len(step.message) < 30:
-                self.pbar.set_description(step.message + " " * (30 - len(step.message)))
-            else:
-                self.pbar.set_description(step.message[-30:])
-        else:
-            self.pbar.set_description(step.name)
-
-
-class TQDMProgress(Progress):
-    """TQDM-based progress callback implementation."""
-
-    def __init__(self, config: ReportingConfig | None = None) -> None:
-        """Initialize with a TQDM progress bar."""
-        self.config = config or ReportingConfig()
-        self.pbar = tqdm()
-
-    def on_update(self, state: ProgressState) -> None:
-        """Update the TQDM progress bar."""
-        # Update total if it changes
-        if state.total != self.pbar.total:
-            self.pbar.total = state.total
-
-        # Update the progress bar
-        self.pbar.n = state.current
-        self.pbar.refresh()
-
-        # Update description if message is provided
-        if state.message:
-            # Fix the event message to a specific size so it's not jumping around
-            # If it's too small, add spaces
-            # If it's too large, truncate
-            if len(state.message) < 30:
-                self.pbar.set_description(
-                    state.message + " " * (30 - len(state.message))
-                )
-            else:
-                self.pbar.set_description(state.message[-30:])
-        else:
-            self.pbar.set_description(state.operation)
-
-    def on_complete(self) -> None:
-        """Complete the progress bar."""
-        self.pbar.close()

kodit/infrastructure/slicing/language_detection_service.py

@@ -1,18 +0,0 @@
-"""Language detection service implementation."""
-
-from pathlib import Path
-
-from kodit.domain.services.index_service import LanguageDetectionService
-
-
-class FileSystemLanguageDetectionService(LanguageDetectionService):
-    """Simple file extension based language detection service."""
-
-    def __init__(self, language_map: dict[str, str]) -> None:
-        """Initialize with a mapping of extensions to languages."""
-        self._language_map = language_map
-
-    async def detect_language(self, file_path: Path) -> str:
-        """Detect language based on file extension."""
-        extension = file_path.suffix.lstrip(".")
-        return self._language_map.get(extension, "unknown")