kodit 0.1.14__py3-none-any.whl → 0.1.15__py3-none-any.whl

kodit/indexing/indexing_service.py

@@ -13,13 +13,16 @@ import pydantic
 import structlog
 from tqdm.asyncio import tqdm
 
-from kodit.bm25.bm25 import BM25Service
-from kodit.embedding.embedding import Embedder, EmbeddingInput
-from kodit.embedding.embedding_models import Embedding, EmbeddingType
+from kodit.bm25.keyword_search_service import BM25Document, KeywordSearchProvider
+from kodit.embedding.vector_search_service import (
+    VectorSearchRequest,
+    VectorSearchService,
+)
 from kodit.indexing.indexing_models import Snippet
 from kodit.indexing.indexing_repository import IndexRepository
 from kodit.snippets.snippets import SnippetService
 from kodit.source.source_service import SourceService
+from kodit.util.spinner import Spinner
 
 # List of MIME types that are blacklisted from being indexed
 MIME_BLACKLIST = ["unknown/unknown"]
@@ -51,8 +54,8 @@ class IndexService:
         self,
         repository: IndexRepository,
         source_service: SourceService,
-        data_dir: Path,
-        embedding_service: Embedder,
+        keyword_search_provider: KeywordSearchProvider,
+        vector_search_service: VectorSearchService,
     ) -> None:
         """Initialize the index service.
 
@@ -65,8 +68,8 @@ class IndexService:
         self.source_service = source_service
         self.snippet_service = SnippetService()
         self.log = structlog.get_logger(__name__)
-        self.bm25 = BM25Service(data_dir)
-        self.code_embedding_service = embedding_service
+        self.keyword_search_provider = keyword_search_provider
+        self.code_search_service = vector_search_service
 
     async def create(self, source_id: int) -> IndexView:
         """Create a new index for a source.
@@ -126,36 +129,27 @@ class IndexService:
             msg = f"Index not found: {index_id}"
             raise ValueError(msg)
 
-        # First delete all old snippets, if they exist
-        await self.repository.delete_all_snippets(index_id)
-
         # Create snippets for supported file types
         await self._create_snippets(index_id)
 
         snippets = await self.repository.get_all_snippets(index_id)
 
         self.log.info("Creating keyword index")
-        self.bm25.index(
-            [
-                snippet.content
-                for snippet in tqdm(snippets, total=len(snippets), leave=False)
-            ]
-        )
+        with Spinner():
+            await self.keyword_search_provider.index(
+                [
+                    BM25Document(snippet_id=snippet.id, text=snippet.content)
+                    for snippet in snippets
+                ]
+            )
 
         self.log.info("Creating semantic code index")
-        async for e in tqdm(
-            self.code_embedding_service.embed(
-                [EmbeddingInput(snippet.id, snippet.content) for snippet in snippets]
-            ),
-            total=len(snippets),
-            leave=False,
-        ):
-            await self.repository.add_embedding(
-                Embedding(
-                    snippet_id=e.id,
-                    embedding=e.embedding,
-                    type=EmbeddingType.CODE,
-                )
+        with Spinner():
+            await self.code_search_service.index(
+                [
+                    VectorSearchRequest(snippet.id, snippet.content)
+                    for snippet in snippets
+                ]
             )
 
         # Update index timestamp
@@ -174,6 +168,7 @@ class IndexService:
 
         """
         files = await self.repository.files_for_index(index_id)
+        self.log.info("Creating snippets for files", index_id=index_id)
         for file in tqdm(files, total=len(files), leave=False):
             # Skip unsupported file types
             if file.mime_type in MIME_BLACKLIST:
@@ -195,4 +190,4 @@ class IndexService:
                     file_id=file.id,
                     content=snippet.text,
                 )
-                await self.repository.add_snippet(s)
+                await self.repository.add_snippet_or_update_content(s)

kodit/mcp.py

@@ -12,9 +12,10 @@ from pydantic import Field
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from kodit._version import version
+from kodit.bm25.keyword_search_factory import keyword_search_factory
 from kodit.config import AppContext
 from kodit.database import Database
-from kodit.embedding.embedding import embedding_factory
+from kodit.embedding.embedding_factory import embedding_factory
 from kodit.search.search_repository import SearchRepository
 from kodit.search.search_service import SearchRequest, SearchResult, SearchService
 
@@ -129,13 +130,16 @@ async def search(
 
     log.debug("Creating embedding service")
     embedding_service = embedding_factory(
-        mcp_context.app_context.get_default_openai_client()
+        app_context=mcp_context.app_context, session=mcp_context.session
     )
 
     log.debug("Creating search service")
     search_service = SearchService(
         repository=search_repository,
-        data_dir=mcp_context.app_context.get_data_dir(),
+        keyword_search_provider=keyword_search_factory(
+            app_context=mcp_context.app_context,
+            session=mcp_context.session,
+        ),
         embedding_service=embedding_service,
     )
 

kodit/search/search_repository.py

@@ -2,13 +2,11 @@
 
 from typing import TypeVar
 
-import numpy as np
 from sqlalchemy import (
     select,
 )
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from kodit.embedding.embedding_models import Embedding, EmbeddingType
 from kodit.indexing.indexing_models import Snippet
 from kodit.source.source_models import File
 
@@ -57,122 +55,3 @@ class SearchRepository:
 
         # Return results in the same order as input IDs
         return [id_to_result[i] for i in ids]
-
-    async def list_semantic_results(
-        self, embedding_type: EmbeddingType, embedding: list[float], top_k: int = 10
-    ) -> list[tuple[int, float]]:
-        """List semantic results using cosine similarity.
-
-        This implementation fetches all embeddings of the given type and computes
-        cosine similarity in Python using NumPy for better performance.
-
-        Args:
-            embedding_type: The type of embeddings to search
-            embedding: The query embedding vector
-            top_k: Number of results to return
-
-        Returns:
-            List of (snippet_id, similarity_score) tuples, sorted by similarity
-
-        """
-        # Step 1: Fetch embeddings from database
-        embeddings = await self._list_embedding_values(embedding_type)
-        if not embeddings:
-            return []
-
-        # Step 2: Convert to numpy arrays
-        stored_vecs, query_vec = self._prepare_vectors(embeddings, embedding)
-
-        # Step 3: Compute similarities
-        similarities = self._compute_similarities(stored_vecs, query_vec)
-
-        # Step 4: Get top-k results
-        return self._get_top_k_results(similarities, embeddings, top_k)
-
-    async def _list_embedding_values(
-        self, embedding_type: EmbeddingType
-    ) -> list[tuple[int, list[float]]]:
-        """List all embeddings of a given type from the database.
-
-        Args:
-            embedding_type: The type of embeddings to fetch
-
-        Returns:
-            List of (snippet_id, embedding) tuples
-
-        """
-        # Only select the fields we need and use a more efficient query
-        query = select(Embedding.snippet_id, Embedding.embedding).where(
-            Embedding.type == embedding_type
-        )
-        rows = await self.session.execute(query)
-        return [tuple(row) for row in rows.all()]  # Convert Row objects to tuples
-
-    def _prepare_vectors(
-        self, embeddings: list[tuple[int, list[float]]], query_embedding: list[float]
-    ) -> tuple[np.ndarray, np.ndarray]:
-        """Convert embeddings to numpy arrays.
-
-        Args:
-            embeddings: List of (snippet_id, embedding) tuples
-            query_embedding: Query embedding vector
-
-        Returns:
-            Tuple of (stored_vectors, query_vector) as numpy arrays
-
-        """
-        try:
-            stored_vecs = np.array(
-                [emb[1] for emb in embeddings]
-            )  # Use index 1 to get embedding
-        except ValueError as e:
-            if "inhomogeneous" in str(e):
-                msg = (
-                    "The database has returned embeddings of different sizes. If you"
-                    "have recently updated the embedding model, you will need to"
-                    "delete your database and re-index your snippets."
-                )
-                raise ValueError(msg) from e
-            raise
-
-        query_vec = np.array(query_embedding)
-        return stored_vecs, query_vec
-
-    def _compute_similarities(
-        self, stored_vecs: np.ndarray, query_vec: np.ndarray
-    ) -> np.ndarray:
-        """Compute cosine similarities between stored vectors and query vector.
-
-        Args:
-            stored_vecs: Array of stored embedding vectors
-            query_vec: Query embedding vector
-
-        Returns:
-            Array of similarity scores
-
-        """
-        stored_norms = np.linalg.norm(stored_vecs, axis=1)
-        query_norm = np.linalg.norm(query_vec)
-        return np.dot(stored_vecs, query_vec) / (stored_norms * query_norm)
-
-    def _get_top_k_results(
-        self,
-        similarities: np.ndarray,
-        embeddings: list[tuple[int, list[float]]],
-        top_k: int,
-    ) -> list[tuple[int, float]]:
-        """Get top-k results by similarity score.
-
-        Args:
-            similarities: Array of similarity scores
-            embeddings: List of (snippet_id, embedding) tuples
-            top_k: Number of results to return
-
-        Returns:
-            List of (snippet_id, similarity_score) tuples
-
-        """
-        top_indices = np.argsort(similarities)[::-1][:top_k]
-        return [
-            (embeddings[i][0], float(similarities[i])) for i in top_indices
-        ]  # Use index 0 to get snippet_id

kodit/search/search_service.py

@@ -1,13 +1,10 @@
 """Search service."""
 
-from pathlib import Path
-
 import pydantic
 import structlog
 
-from kodit.bm25.bm25 import BM25Service
-from kodit.embedding.embedding import Embedder
-from kodit.embedding.embedding_models import EmbeddingType
+from kodit.bm25.keyword_search_service import BM25Result, KeywordSearchProvider
+from kodit.embedding.vector_search_service import VectorSearchService
 from kodit.search.search_repository import SearchRepository
 
 
@@ -44,25 +41,25 @@ class SearchService:
     def __init__(
         self,
         repository: SearchRepository,
-        data_dir: Path,
-        embedding_service: Embedder,
+        keyword_search_provider: KeywordSearchProvider,
+        embedding_service: VectorSearchService,
     ) -> None:
         """Initialize the search service."""
         self.repository = repository
         self.log = structlog.get_logger(__name__)
-        self.bm25 = BM25Service(data_dir)
+        self.keyword_search_provider = keyword_search_provider
         self.code_embedding_service = embedding_service
 
     async def search(self, request: SearchRequest) -> list[SearchResult]:
         """Search for relevant data."""
         fusion_list = []
         if request.keywords:
-            snippet_ids = await self.repository.list_snippet_ids()
-
             # Gather results for each keyword
-            result_ids: list[tuple[int, float]] = []
+            result_ids: list[BM25Result] = []
             for keyword in request.keywords:
-                results = self.bm25.retrieve(snippet_ids, keyword, request.top_k)
+                results = await self.keyword_search_provider.retrieve(
+                    keyword, request.top_k
+                )
                 result_ids.extend(results)
 
             # Sort results by score
@@ -76,19 +73,10 @@ class SearchService:
         # Compute embedding for semantic query
         semantic_results = []
         if request.code_query:
-            query_embedding = await anext(
-                self.code_embedding_service.query([request.code_query])
-            )
-
-            query_results = await self.repository.list_semantic_results(
-                EmbeddingType.CODE, query_embedding, top_k=request.top_k
+            query_embedding = await self.code_embedding_service.retrieve(
+                request.code_query, top_k=request.top_k
             )
-
-            # Sort results by score
-            query_results.sort(key=lambda x: x[1], reverse=True)
-
-            # Extract the snippet ids from the query results
-            semantic_results = [x[0] for x in query_results]
+            semantic_results = [x.snippet_id for x in query_embedding]
             fusion_list.append(semantic_results)
 
         if len(fusion_list) == 0:

kodit/source/source_service.py

@@ -109,6 +109,8 @@ class SourceService:
                 uri_or_path_like = uri_or_path_like + ".git"
                 try:
                     return await self._create_git_source(uri_or_path_like)
+                except git.GitCommandError:
+                    raise
                 except ValueError:
                     pass
 
@@ -197,11 +199,14 @@ class SourceService:
             clone_path.mkdir(parents=True, exist_ok=True)
 
             try:
-                # Clone the repository
+                self.log.info("Cloning repository", uri=uri, clone_path=str(clone_path))
                 git.Repo.clone_from(uri, clone_path)
             except git.GitCommandError as e:
-                msg = f"Failed to clone repository: {e}"
-                raise ValueError(msg) from e
+                if "already exists and is not an empty directory" in str(e):
+                    self.log.info("Repository already exists, reusing...", uri=uri)
+                else:
+                    msg = f"Failed to clone repository: {e}"
+                    raise ValueError(msg) from e
 
             source = await self.repository.create_source(
                 Source(uri=uri, cloned_path=str(clone_path)),
@@ -212,6 +217,7 @@ class SourceService:
             file_count = sum(1 for _ in clone_path.rglob("*") if _.is_file())
 
             # Process each file in the source directory
+            self.log.info("Inspecting files", source_id=source.id)
             for path in tqdm(clone_path.rglob("*"), total=file_count, leave=False):
                 await self._process_file(source.id, path.absolute())
 

kodit/util/__init__.py

@@ -0,0 +1 @@
+"""Utility functions and classes."""

kodit/util/spinner.py

@@ -0,0 +1,59 @@
+"""Spinner for long-running tasks."""
+
+import itertools
+import sys
+import threading
+import time
+
+
+class Spinner:
+    """Spinner for long-running tasks."""
+
+    def __init__(self, delay: float = 0.1) -> None:
+        """Initialize the spinner."""
+        self.spinner = itertools.cycle(["-", "/", "|", "\\"])
+        self.delay = delay
+        self.busy = False
+        self.spinner_visible = False
+
+    def write_next(self) -> None:
+        """Write the next character of the spinner."""
+        with self._screen_lock:
+            if not self.spinner_visible:
+                sys.stdout.write(next(self.spinner))
+                self.spinner_visible = True
+                sys.stdout.flush()
+
+    def remove_spinner(self, cleanup: bool = False) -> None:  # noqa: FBT001, FBT002
+        """Remove the spinner."""
+        with self._screen_lock:
+            if self.spinner_visible:
+                sys.stdout.write("\b")
+                self.spinner_visible = False
+                if cleanup:
+                    sys.stdout.write(" ")  # overwrite spinner with blank
+                    sys.stdout.write("\r")  # move to next line
+                sys.stdout.flush()
+
+    def spinner_task(self) -> None:
+        """Task that runs the spinner."""
+        while self.busy:
+            self.write_next()
+            time.sleep(self.delay)
+            self.remove_spinner()
+
+    def __enter__(self) -> None:
+        """Enter the context manager."""
+        if sys.stdout.isatty():
+            self._screen_lock = threading.Lock()
+            self.busy = True
+            self.thread = threading.Thread(target=self.spinner_task)
+            self.thread.start()
+
+    def __exit__(self, exception: object, value: object, tb: object) -> None:
+        """Exit the context manager."""
+        if sys.stdout.isatty():
+            self.busy = False
+            self.remove_spinner(cleanup=True)
+        else:
+            sys.stdout.write("\r")

{kodit-0.1.14.dist-info → kodit-0.1.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kodit
-Version: 0.1.14
+Version: 0.1.15
 Summary: Code indexing for better AI code generation
 Project-URL: Homepage, https://docs.helixml.tech/kodit/
 Project-URL: Documentation, https://docs.helixml.tech/kodit/
@@ -21,6 +21,7 @@ Requires-Dist: aiofiles>=24.1.0
 Requires-Dist: aiosqlite>=0.20.0
 Requires-Dist: alembic>=1.15.2
 Requires-Dist: asgi-correlation-id>=4.3.4
+Requires-Dist: asyncpg>=0.30.0
 Requires-Dist: better-exceptions>=0.3.3
 Requires-Dist: bm25s[core]>=0.2.12
 Requires-Dist: click>=8.1.8

kodit-0.1.15.dist-info/RECORD

@@ -0,0 +1,58 @@
+kodit/.gitignore,sha256=ztkjgRwL9Uud1OEi36hGQeDGk3OLK1NfDEO8YqGYy8o,11
+kodit/__init__.py,sha256=aEKHYninUq1yh6jaNfvJBYg-6fenpN132nJt1UU6Jxs,59
+kodit/_version.py,sha256=OX-WIjJlMaFvqRmCfLtOYEOYoiov9NdOA089N36rG-g,513
+kodit/app.py,sha256=Mr5BFHOHx5zppwjC4XPWVvHjwgl1yrKbUjTWXKubJQM,891
+kodit/cli.py,sha256=wAaMZQs-h6hyashWB3DBR2GIf496vfHmepcXhpa7-eM,8085
+kodit/config.py,sha256=2W2u5J8j-Mbt-C4xzOuK-PeuDCx0S_rnCXPhBwvfLT4,4353
+kodit/database.py,sha256=WB1KpVxUYPgiJGU0gJa2hqytYB8wJEJ5z3WayhWzNMU,2403
+kodit/log.py,sha256=HU1OmuxO4FcVw61k4WW7Y4WM7BrDaeplw1PcBHhuIZY,5434
+kodit/mcp.py,sha256=HA3R7YG0Al1A6MjSCSIi0hEGXG3WP7tix-N5AROasCM,5278
+kodit/middleware.py,sha256=I6FOkqG9-8RH5kR1-0ZoQWfE4qLCB8lZYv8H_OCH29o,2714
+kodit/bm25/__init__.py,sha256=j8zyriNWhbwE5Lbybzg1hQAhANlU9mKHWw4beeUR6og,19
+kodit/bm25/keyword_search_factory.py,sha256=rp-wx3DJsc2KlELK1V337EyeYvmwnMQwUqOo1WVPSmg,631
+kodit/bm25/keyword_search_service.py,sha256=aBbWQKgQmi2re3EIHdXFS00n7Wj3b2D0pZsLZ4qmHfE,754
+kodit/bm25/local_bm25.py,sha256=AAbFhbQDqyL3d7jsPL7W4HsLxdoYctaDsREUXOLy6jM,3260
+kodit/bm25/vectorchord_bm25.py,sha256=_nGrkUReYLLV-L8RIuIVLwjuhSYZl9T532n5OVf0kWs,6393
+kodit/embedding/__init__.py,sha256=h9NXzDA1r-K23nvBajBV-RJzHJN0p3UJ7UQsmdnOoRw,24
+kodit/embedding/embedding_factory.py,sha256=qzoxBS3scR-ABd-u9215uGES7c6clYy2DiKcSDQivnA,1603
+kodit/embedding/embedding_models.py,sha256=rN90vSs86dYiqoawcp8E9jtwY31JoJXYfaDlsJK7uqc,656
+kodit/embedding/embedding_repository.py,sha256=-ux3scpBzel8c0pMH9fNOEsSXFIzl-IfgaWrkTb1szo,6907
+kodit/embedding/local_vector_search_service.py,sha256=hkF0qlfzjyGt400qIX9Mr6B7b7i8WvYIYWN2Z2C_pcs,1907
+kodit/embedding/vector_search_service.py,sha256=pQJ129QjGrAWOXzqkywmgtDRpy8_gtzYgkivyqF9Vrs,1009
+kodit/embedding/vectorchord_vector_search_service.py,sha256=OsVeM3gpoT8Ihzh-kEIzBm3xh_a4D-sErPvsQSKCME8,4732
+kodit/embedding/embedding_provider/__init__.py,sha256=h9NXzDA1r-K23nvBajBV-RJzHJN0p3UJ7UQsmdnOoRw,24
+kodit/embedding/embedding_provider/embedding_provider.py,sha256=NKs4nriup47R8xRciP07NE1-eZE9RPHklS7VH910UZ4,1537
+kodit/embedding/embedding_provider/hash_embedding_provider.py,sha256=nAhlhh8j8PqqCCbhVl26Y8ntFBm2vJBCtB4X04g5Wwg,2638
+kodit/embedding/embedding_provider/local_embedding_provider.py,sha256=4ER-UPq506Y0TWU6qcs0nUqw6bSKQkSrdog-DhNQWM8,1906
+kodit/embedding/embedding_provider/openai_embedding_provider.py,sha256=bmUpegDgaF5Qj9uWcj1az4ADA2cKHUjraaMjGGPr83U,2076
+kodit/indexing/__init__.py,sha256=cPyi2Iej3G1JFWlWr7X80_UrsMaTu5W5rBwgif1B3xo,75
+kodit/indexing/indexing_models.py,sha256=6NX9HVcj6Pu9ePwHC7n-PWSyAgukpJq0nCNmUIigtbo,1282
+kodit/indexing/indexing_repository.py,sha256=4RJ3zY8p6QxHrYW7dDjru_w94Eu19v2gQ4mdlTgcXvY,6331
+kodit/indexing/indexing_service.py,sha256=T_dxOzNW_0OCpR4Fha1hHuNkmtLcDMZwL6t5xeu5VXQ,6613
+kodit/migrations/README,sha256=ISVtAOvqvKk_5ThM5ioJE-lMkvf9IbknFUFVU_vPma4,58
+kodit/migrations/__init__.py,sha256=lP5MuwlyWRMO6UcDWnQcQ3G-GYHcFb6rl9gYPHJ1sjo,40
+kodit/migrations/env.py,sha256=w1M7OZh-ZeR2dPHS0ByXAUxQjfZQ8xIzMseWuzLDTWw,2469
+kodit/migrations/script.py.mako,sha256=zWziKtiwYKEWuwPV_HBNHwa9LCT45_bi01-uSNFaOOE,703
+kodit/migrations/versions/7c3bbc2ab32b_add_embeddings_table.py,sha256=-61qol9PfQKILCDQRA5jEaats9aGZs9Wdtp-j-38SF4,1644
+kodit/migrations/versions/85155663351e_initial.py,sha256=Cg7zlF871o9ShV5rQMQ1v7hRV7fI59veDY9cjtTrs-8,3306
+kodit/migrations/versions/__init__.py,sha256=9-lHzptItTzq_fomdIRBegQNm4Znx6pVjwD4MiqRIdo,36
+kodit/search/__init__.py,sha256=4QbdjbrlhNKMovmuKHxJnUeZT7KNjTTFU0GdnuwUHdQ,36
+kodit/search/search_repository.py,sha256=6q0k7JMTM_7hPK2TSA30CykGbc5N16kCL7HTjlbai0w,1563
+kodit/search/search_service.py,sha256=-XlbP_50e1dKFJ5jBvex5FjLnffW43LcwQV_SeYNFB0,3944
+kodit/snippets/__init__.py,sha256=-2coNoCRjTixU9KcP6alpmt7zqf37tCRWH3D7FPJ8dg,48
+kodit/snippets/method_snippets.py,sha256=EVHhSNWahAC5nSXv9fWVFJY2yq25goHdCSCuENC07F8,4145
+kodit/snippets/snippets.py,sha256=mwN0bM1Msu8ZeEsUHyQ7tx3Hj3vZsm8G7Wu4eWSkLY8,1539
+kodit/snippets/languages/__init__.py,sha256=Bj5KKZSls2MQ8ZY1S_nHg447MgGZW-2WZM-oq6vjwwA,1187
+kodit/snippets/languages/csharp.scm,sha256=gbBN4RiV1FBuTJF6orSnDFi8H9JwTw-d4piLJYsWUsc,222
+kodit/snippets/languages/python.scm,sha256=ee85R9PBzwye3IMTE7-iVoKWd_ViU3EJISTyrFGrVeo,429
+kodit/source/__init__.py,sha256=1NTZyPdjThVQpZO1Mp1ColVsS7sqYanOVLqnoqV9Ipo,83
+kodit/source/source_models.py,sha256=xb42CaNDO1CUB8SIW-xXMrB6Ji8cFw-yeJ550xBEg9Q,2398
+kodit/source/source_repository.py,sha256=0EksMpoLzdkfe8S4eeCm4Sf7TuxsOzOzaF4BBsMYo-4,3163
+kodit/source/source_service.py,sha256=u_GaH07ewakThQJRfT8O_yZ54A52qLtJuM1bF3xUT2A,9633
+kodit/util/__init__.py,sha256=bPu6CtqDWCRGU7VgW2_aiQrCBi8G89FS6k1PjvDajJ0,37
+kodit/util/spinner.py,sha256=R9bzrHtBiIH6IfLbmsIVHL53s8vg-tqW4lwGGALu4dw,1932
+kodit-0.1.15.dist-info/METADATA,sha256=8E-bw8L-Df5Hdt16R5IWkyw7uUAr13CwYfcEyFExaPw,2380
+kodit-0.1.15.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+kodit-0.1.15.dist-info/entry_points.txt,sha256=hoTn-1aKyTItjnY91fnO-rV5uaWQLQ-Vi7V5et2IbHY,40
+kodit-0.1.15.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+kodit-0.1.15.dist-info/RECORD,,