Resolve error and fix remaining type hint violations

Author: filipchristiansen

requirements.txt

@@ -1,11 +1,13 @@
 black
 click>=8.0.0
 djlint
+dotenv
 fastapi-analytics
 fastapi[standard]
 pre-commit
 pytest
 pytest-asyncio
 slowapi
+starlette
 tiktoken
 uvicorn

src/config.py

@@ -1,4 +1,4 @@
-MAX_DISPLAY_SIZE = 300000
+MAX_DISPLAY_SIZE = 300_000
 TMP_BASE_PATH = "../tmp"
 
 EXAMPLE_REPOS = [

src/gitingest/cli.py

@@ -1,4 +1,5 @@
 import os
+from typing import Optional, Tuple
 
 import click
 

src/gitingest/clone.py

@@ -1,5 +1,5 @@
 import asyncio
-from typing import Dict, Tuple
+from typing import Any, Dict, Tuple
 
 from gitingest.utils import async_timeout
 

src/gitingest/ingest.py

@@ -1,7 +1,8 @@
 import asyncio
+import inspect
 import shutil
 from pathlib import Path
-from typing import List, Union
+from typing import List, Optional, Tuple, Union
 
 from gitingest.clone import clone_repo
 from gitingest.ingest_from_query import ingest_from_query
@@ -16,9 +17,19 @@ def ingest(
     output: Optional[str] = None,
 ) -> Tuple[str, str, str]:
     try:
-        query = parse_query(source, max_file_size, False, include_patterns, exclude_patterns)
+        query = parse_query(
+            source=source,
+            max_file_size=max_file_size,
+            from_web=False,
+            include_patterns=include_patterns,
+            ignore_patterns=exclude_patterns,
+        )
         if query['url']:
-            asyncio.run(clone_repo(query))
+            clone_result = clone_repo(query)
+            if inspect.iscoroutine(clone_result):
+                asyncio.run(clone_result)
+            else:
+                raise TypeError("clone_repo did not return a coroutine as expected.")
 
         summary, tree, content = ingest_from_query(query)
 

src/gitingest/ingest_from_query.py

@@ -1,6 +1,6 @@
 import os
 from fnmatch import fnmatch
-from typing import Dict, List, Set
+from typing import Any, Dict, List, Optional, Set, Tuple
 
 import tiktoken
 
@@ -335,10 +335,10 @@ def generate_token_string(context_string: str) -> Optional[str]:
         print(e)
         return None
 
-    if total_tokens > 1000000:
-        formatted_tokens = f"{total_tokens/1000000:.1f}M"
-    elif total_tokens > 1000:
-        formatted_tokens = f"{total_tokens/1000:.1f}k"
+    if total_tokens > 1_000_000:
+        formatted_tokens = f"{total_tokens / 1_000_000:.1f}M"
+    elif total_tokens > 1_000:
+        formatted_tokens = f"{total_tokens / 1_000:.1f}k"
     else:
         formatted_tokens = f"{total_tokens}"
 
@@ -383,6 +383,8 @@ def ingest_single_file(path: str, query: Dict[str, Any]) -> Tuple[str, str, str]
 
 def ingest_directory(path: str, query: Dict[str, Any]) -> Tuple[str, str, str]:
     nodes = scan_directory(path=path, query=query)
+    if not nodes:
+        raise ValueError(f"No files found in {path}")
     files = extract_files_content(query=query, node=nodes, max_file_size=query['max_file_size'])
     summary = create_summary_string(query, nodes, files)
     tree = "Directory structure:\n" + create_tree_structure(query, nodes)

src/gitingest/parse_query.py

@@ -7,7 +7,7 @@
 TMP_BASE_PATH = "../tmp"
 
 
-def parse_url(url: str) -> Dict[str, Optional[str]]:
+def parse_url(url: str) -> Dict[str, Any]:
     parsed = {
         "user_name": None,
         "repo_name": None,
@@ -97,8 +97,8 @@ def parse_query(
     source: str,
     max_file_size: int,
     from_web: bool,
-    include_patterns: Union[List[str], str] = None,
-    ignore_patterns: Union[List[str], str] = None,
+    include_patterns: Optional[Union[List[str], str]] = None,
+    ignore_patterns: Optional[Union[List[str], str]] = None,
 ) -> Dict[str, Any]:
     if from_web:
         query = parse_url(source)
@@ -107,6 +107,7 @@ def parse_query(
             query = parse_url(source)
         else:
             query = parse_path(source)
+
     query['max_file_size'] = max_file_size
 
     if ignore_patterns and ignore_patterns != "":

src/gitingest/tests/test_clone.py

@@ -1,7 +1,8 @@
 from unittest.mock import AsyncMock, patch
 
 import pytest
-from clone import check_repo_exists, clone_repo
+
+from gitingest.clone import check_repo_exists, clone_repo
 
 
 @pytest.mark.asyncio

src/gitingest/tests/test_ingest.py

@@ -75,6 +75,8 @@ def temp_directory(tmp_path: Path) -> Path:
 
 def test_scan_directory(temp_directory: Path, sample_query: Dict[str, Any]) -> None:
     result = scan_directory(str(temp_directory), query=sample_query)
+    if result is None:
+        assert False, "Result is None"
 
     assert result['type'] == 'directory'
     assert result['file_count'] == 8  # All .txt and .py files
@@ -84,6 +86,8 @@ def test_scan_directory(temp_directory: Path, sample_query: Dict[str, Any]) -> N
 
 def test_extract_files_content(temp_directory: Path, sample_query: Dict[str, Any]) -> None:
     nodes = scan_directory(str(temp_directory), query=sample_query)
+    if nodes is None:
+        assert False, "Nodes is None"
     files = extract_files_content(query=sample_query, node=nodes, max_file_size=1_000_000)
     assert len(files) == 8  # All .txt and .py files
 

src/gitingest/utils.py

@@ -1,9 +1,10 @@
 ## Async Timeout decorator
 import asyncio
 import functools
-from typing import Awaitable, Callable, TypeVar
+from typing import Awaitable, Callable, ParamSpec, TypeVar
 
 T = TypeVar("T")
+P = ParamSpec("P")
 
 
 class AsyncTimeoutError(Exception):
@@ -12,14 +13,14 @@ class AsyncTimeoutError(Exception):
     pass
 
 
-def async_timeout(seconds: int = 10) -> Callable[[Callable[..., Awaitable[T]]], Callable[..., Awaitable[T]]]:
-    def decorator(func: Callable[..., T]) -> Callable[..., T]:
+def async_timeout(seconds: int = 10) -> Callable[[Callable[P, Awaitable[T]]], Callable[P, Awaitable[T]]]:
+    def decorator(func: Callable[P, Awaitable[T]]) -> Callable[P, Awaitable[T]]:
         @functools.wraps(func)
-        async def wrapper(*args, **kwargs) -> T:
+        async def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
             try:
                 return await asyncio.wait_for(func(*args, **kwargs), timeout=seconds)
             except asyncio.TimeoutError:
-                raise AsyncTimeoutError(f"Clone timed out after {seconds} seconds")
+                raise AsyncTimeoutError(f"Operation timed out after {seconds} seconds")
 
         return wrapper