import-completer 0.4.0__py3-none-any.whl

import_completer/code_scanner.py

@@ -0,0 +1,202 @@
+import re
+from collections.abc import Generator, Iterator
+from pathlib import Path
+from typing import Literal
+
+import tree_sitter_python as tspython
+from tree_sitter import Language, Node, Parser
+
+from import_completer.types import ScannedSymbol
+
+PYTHON_TS_LANGUAGE = Language(tspython.language())
+PYTHON_TS_PARSER = Parser()
+PYTHON_TS_PARSER.language = PYTHON_TS_LANGUAGE
+
+PYTHON_TOP_LEVEL_SYMBOLS_QUERY = PYTHON_TS_LANGUAGE.query(
+    """
+    [
+      ; Direct module children
+      (module
+        (function_definition name: (identifier) @function-name))
+      (module
+        (class_definition name: (identifier) @class-name))
+      (module
+        (decorated_definition
+          (function_definition name: (identifier) @function-name)))
+      (module
+        (decorated_definition
+          (class_definition name: (identifier) @class-name)))
+      (module
+        (expression_statement
+          (assignment left: (identifier) @assignment-name)))
+
+      ; Inside top-level if statements
+      (module
+        (if_statement
+          (block
+            (function_definition name: (identifier) @function-name))))
+      (module
+        (if_statement
+          (block
+            (class_definition name: (identifier) @class-name))))
+      (module
+        (if_statement
+          (block
+            (decorated_definition
+              (function_definition name: (identifier) @function-name)))))
+      (module
+        (if_statement
+          (block
+            (decorated_definition
+              (class_definition name: (identifier) @class-name)))))
+      (module
+        (if_statement
+          (block
+            (expression_statement
+              (assignment left: (identifier) @assignment-name)))))
+      ; Else clause
+      (module
+        (if_statement
+          (else_clause
+            (block
+              (function_definition name: (identifier) @function-name)))))
+      (module
+        (if_statement
+          (else_clause
+            (block
+              (class_definition name: (identifier) @class-name)))))
+      (module
+        (if_statement
+          (else_clause
+            (block
+              (decorated_definition
+                (function_definition name: (identifier) @function-name))))))
+      (module
+        (if_statement
+          (else_clause
+            (block
+              (decorated_definition
+                (class_definition name: (identifier) @class-name))))))
+      (module
+        (if_statement
+          (else_clause
+            (block
+              (expression_statement
+                (assignment left: (identifier) @assignment-name))))))
+    ]
+    """
+)
+
+RE_PYTHON_VALID_MODULE_FILE_NAME = re.compile(r"^[a-zA-Z_][a-zA-Z0-9_]*\.pyi?$")
+RE_PYTHON_VALID_MODULE_DIRECTORY_NAME = re.compile(r"^[a-zA-Z_][a-zA-Z0-9_]*$")
+
+
+def discover_python_modules(directory: str | Path) -> Generator[Path]:
+    """
+    Walk through directory and yield Python module files (.py and .pyi).
+    Descends into subdirectories only if they are Python modules (contain __init__.py).
+
+    Args:
+        directory: Root directory to start scanning from
+
+    Yields:
+        Path objects for Python module files
+    """
+
+    directory = Path(directory)
+
+    if not directory.is_dir():
+        return
+
+    for child_entity_path in directory.iterdir():
+        if (
+            child_entity_path.is_file()
+            and RE_PYTHON_VALID_MODULE_FILE_NAME.match(child_entity_path.name)
+            is not None
+        ):
+            yield child_entity_path
+        elif (
+            child_entity_path.is_dir()
+            and RE_PYTHON_VALID_MODULE_DIRECTORY_NAME.match(child_entity_path.name)
+            is not None
+        ):
+            # Recursively process subdirectories if they are Python packages
+            if (child_entity_path / "__init__.py").exists() or (
+                child_entity_path / "__init__.pyi"
+            ).exists():
+                yield from discover_python_modules(child_entity_path)
+        else:
+            pass
+            # print(f"Skipping {child_entity_path}")
+
+
+def extract_symbols_from_origin(origin_path: Path) -> Iterator[ScannedSymbol]:
+    for module_path in discover_python_modules(origin_path):
+        yield from extract_symbols_from_file(module_path, origin_path)
+
+
+def extract_symbols_from_file(
+    file_path: Path, origin_path: Path
+) -> Iterator[ScannedSymbol]:
+    """
+    Extract all top-level symbols from a given Python file.
+    """
+
+    with open(file_path, "rb") as fh:
+        source_code = fh.read()
+
+    yield from extract_symbols(
+        source_code, annotated_file_path=file_path, origin_path=origin_path
+    )
+
+
+def extract_symbols(
+    source_code: bytes, annotated_file_path: Path, origin_path: Path
+) -> Iterator[ScannedSymbol]:
+    """
+    Extract all top-level symbols from a given Python source code.
+    """
+
+    module_relative_path = Path(annotated_file_path.relative_to(origin_path))
+    parent_module = ".".join(module_relative_path.with_suffix("").parts)
+
+    def _make_scanned_symbol(
+        kind: Literal["function", "class", "variable"], node: Node
+    ) -> ScannedSymbol:
+        assert node.text is not None
+        return ScannedSymbol(
+            kind=kind,
+            name=node.text.decode("utf-8"),
+            parent_module=parent_module,
+            metadata={},
+        )
+
+    tree = PYTHON_TS_PARSER.parse(source_code)
+    root_node = tree.root_node
+
+    captures = PYTHON_TOP_LEVEL_SYMBOLS_QUERY.captures(root_node)
+    for node in captures.get("function-name", []):
+        if node.text:
+            yield _make_scanned_symbol("function", node)
+
+    for node in captures.get("class-name", []):
+        if node.text:
+            yield _make_scanned_symbol("class", node)
+
+    for node in captures.get("assignment-name", []):
+        if node.text:
+            yield _make_scanned_symbol("variable", node)
+
+
+if __name__ == "__main__":
+    import sys
+
+    for path in (Path(p) for p in sys.path):
+        if not path.is_dir():
+            continue
+        for module_path in discover_python_modules(path):
+            print(f"Discovered module: {module_path}")
+            for symbol in extract_symbols_from_file(
+                module_path, annotated_source_sys_path=path
+            ):
+                print(f"  + {symbol.kind}: {symbol.name}")

import_completer/completion_engine.py

@@ -0,0 +1,80 @@
+import sys
+from collections.abc import AsyncGenerator, AsyncIterable
+from contextlib import asynccontextmanager
+from pathlib import Path
+
+from loguru import logger
+
+from import_completer.code_scanner import extract_symbols_from_origin
+from import_completer.path_discovery import get_internal_python_paths
+from import_completer.symbols_database import DatabaseHandler
+from import_completer.types import ScannedSymbol
+
+
+class CompletionEngine:
+    def __init__(
+        self, symbols_database: DatabaseHandler, origin_paths: list[Path]
+    ) -> None:
+        self._symbols_database = symbols_database
+        self._origin_paths = origin_paths
+        self._is_fully_initialized = False
+
+    @property
+    def is_fully_initialized(self) -> bool:
+        return self._is_fully_initialized
+
+    async def initialize_database(self) -> None:
+        self._symbols_database = DatabaseHandler()
+        await self._symbols_database.__aenter__()
+        await self._symbols_database.create_schema()
+        await self._symbols_database.create_indices()
+
+    async def autoload_symbols(self) -> None:
+        assert self._symbols_database is not None, "Database not initialized!"
+        for origin_idx, path in enumerate((Path(p) for p in sys.path), 1):
+            if not path.is_dir():
+                continue
+            logger.info("Rebuilding symbols for path: {}", path)
+            await self._symbols_database.perform_rebuild_for_origin(
+                origin_idx, extract_symbols_from_origin(path)
+            )
+        self._is_fully_initialized = True
+
+    async def lookup_symbol_prefix(self, prefix: str) -> AsyncIterable[ScannedSymbol]:
+        assert self._symbols_database is not None, "Database not initialized!"
+        async for symbol in self._symbols_database.lookup_symbol_name(prefix):
+            yield symbol
+
+
+@asynccontextmanager
+async def create_completion_engine(
+    origin_paths: list[Path],
+) -> AsyncGenerator[CompletionEngine]:
+    symbols_database = DatabaseHandler()
+    async with symbols_database:
+        await symbols_database.create_schema()
+        await symbols_database.create_indices()
+        completion_engine = CompletionEngine(symbols_database, origin_paths)
+        yield completion_engine
+
+
+if __name__ == "__main__":
+    import asyncio
+    import sys
+
+    async def _main():
+        async with create_completion_engine(
+            list(get_internal_python_paths())
+        ) as completion_engine:
+            await completion_engine.autoload_symbols()
+            print("Database fully initialized!")
+
+            for word_to_complete in sys.argv[1:]:
+                print(f"Completing for '{word_to_complete}':")
+                async for symbol in completion_engine.lookup_symbol_prefix(
+                    word_to_complete
+                ):
+                    print(f" - {symbol.kind}: {symbol.name} ({symbol.parent_module})")
+                print()
+
+    asyncio.run(_main())

import_completer/config.py

@@ -0,0 +1,26 @@
+import dataclasses
+from importlib.metadata import PackageNotFoundError, version
+from pathlib import Path
+
+from import_completer.path_discovery import (
+    discover_paths_for_python_executable,
+)
+
+
+def get_version() -> str:
+    """Get the package version from installed metadata, or 'dev' if not installed."""
+    try:
+        return version("import-completer")
+    except PackageNotFoundError:
+        return "dev"
+
+
+@dataclasses.dataclass
+class Config:
+    origin_paths: list[Path]
+
+    @classmethod
+    def default(cls) -> "Config":
+        return cls(
+            origin_paths=list(discover_paths_for_python_executable()),
+        )

import_completer/language_server.py

@@ -0,0 +1,203 @@
+import re
+from contextlib import AsyncExitStack
+from typing import Any
+
+from loguru import logger
+from lsprotocol.types import (
+    INITIALIZED,
+    SHUTDOWN,
+    TEXT_DOCUMENT_COMPLETION,
+    CompletionItem,
+    CompletionItemKind,
+    CompletionList,
+    CompletionParams,
+    InitializeParams,
+    Position,
+    ProgressParams,
+    Range,
+    TextEdit,
+    WorkDoneProgressBegin,
+    WorkDoneProgressEnd,
+    WorkDoneProgressReport,
+)
+from pygls.lsp.server import LanguageServer
+
+from import_completer.completion_engine import (
+    CompletionEngine,
+    create_completion_engine,
+)
+from import_completer.config import Config, get_version
+
+
+def _handler_exception_wrapper(func):
+    async def wrapper(*args, **kwargs):
+        try:
+            return await func(*args, **kwargs)
+        except Exception:
+            logger.exception("Error occurred during handling of {}.", func.__name__)
+            raise
+
+    return wrapper
+
+
+class ImportCompleterLanguageServer(LanguageServer):
+    def __init__(self, *args: Any, config: Config, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self._exit_stack = AsyncExitStack()
+        self._config = config
+        self._completion_engine: CompletionEngine | None = None
+
+        self.feature(INITIALIZED)(
+            _handler_exception_wrapper(self.initialize_completion_engine)
+        )
+        self.feature(TEXT_DOCUMENT_COMPLETION)(
+            _handler_exception_wrapper(self.handle_completion)
+        )
+        self.feature(SHUTDOWN)(
+            _handler_exception_wrapper(self.shutdown_completion_engine)
+        )
+
+    @property
+    def completion_engine(self) -> CompletionEngine:
+        assert self._completion_engine is not None, "Completion engine not initialized!"
+        return self._completion_engine
+
+    async def initialize_completion_engine(self, params: InitializeParams) -> None:
+        logger.info("Initializing language server.")
+
+        # Begin progress
+        token = "import-completer-init"
+        self.protocol.notify(
+            "$/progress",
+            ProgressParams(
+                token=token,
+                value=WorkDoneProgressBegin(
+                    title="Import Completer", message="Initializing...", percentage=0
+                ),
+            ),
+        )
+
+        try:
+            # Report progress - creating engine
+            self.protocol.notify(
+                "$/progress",
+                ProgressParams(
+                    token=token,
+                    value=WorkDoneProgressReport(
+                        message="Creating completion engine...", percentage=30
+                    ),
+                ),
+            )
+
+            self._completion_engine = await self._exit_stack.enter_async_context(
+                create_completion_engine(self._config.origin_paths)
+            )
+
+            # Report progress - loading symbols
+            self.protocol.notify(
+                "$/progress",
+                ProgressParams(
+                    token=token,
+                    value=WorkDoneProgressReport(
+                        message="Loading symbols...", percentage=60
+                    ),
+                ),
+            )
+
+            await self._completion_engine.autoload_symbols()
+
+            # End progress
+            self.protocol.notify(
+                "$/progress",
+                ProgressParams(
+                    token=token, value=WorkDoneProgressEnd(message="Ready!")
+                ),
+            )
+            logger.info("Language server initialization complete.")
+
+        except Exception:
+            # End progress with error
+            self.protocol.notify(
+                "$/progress",
+                ProgressParams(
+                    token=token,
+                    value=WorkDoneProgressEnd(message="Initialization failed"),
+                ),
+            )
+            logger.exception("Failed to initialize language server")
+            raise
+
+    async def shutdown_completion_engine(self, params) -> None:
+        """Clean up resources before server shutdown"""
+        logger.info("Shutting down language server, cleaning up resources...")
+
+        try:
+            # Close all async context managers (including completion engine)
+            await self._exit_stack.aclose()
+            self._completion_engine = None
+            logger.info("Resources cleaned up successfully.")
+        except Exception:
+            logger.exception("Error during shutdown cleanup")
+
+        return None
+
+    async def handle_completion(self, params: CompletionParams) -> CompletionList:
+        logger.debug("Handling completion, with params: {}", params)
+        document = self.workspace.get_text_document(params.text_document.uri)
+        current_line = document.lines[params.position.line]
+        last_word = re.split(
+            r"[^a-zA-Z0-9_.]", current_line[: params.position.character]
+        )[-1]
+        logger.debug("Completing for word: '{}'", last_word)
+
+        if "." in last_word:
+            logger.debug("Ignoring completions for dotted names.")
+            return CompletionList(is_incomplete=False, items=[])
+
+        completions = [
+            symbol
+            async for symbol in self.completion_engine.lookup_symbol_prefix(last_word)
+        ]
+
+        items = []
+        for symbol in completions:
+            match symbol.kind:
+                case "variable":
+                    kind = CompletionItemKind.Variable
+                case "function":
+                    kind = CompletionItemKind.Function
+                case "class":
+                    kind = CompletionItemKind.Class
+                case _:
+                    kind = CompletionItemKind.Text
+            items.append(
+                CompletionItem(
+                    label=symbol.name,
+                    detail=f"from {symbol.parent_module} import {symbol.name}\n# import_completer",
+                    kind=kind,
+                    additional_text_edits=[
+                        TextEdit(
+                            new_text=f"from {symbol.parent_module} import {symbol.name}\n",
+                            range=Range(
+                                start=Position(line=0, character=0),
+                                end=Position(line=0, character=0),
+                            ),
+                        ),
+                    ],
+                ),
+            )
+
+        logger.debug("Generated {} completions.", len(items))
+        return CompletionList(is_incomplete=False, items=items)
+
+
+def start_server():
+    server = ImportCompleterLanguageServer(
+        "import-completer", get_version(), config=Config.default()
+    )
+    logger.info("Starting ImportCompleter language server...")
+    server.start_io()
+
+
+if __name__ == "__main__":
+    start_server()

import_completer/path_discovery.py

@@ -0,0 +1,28 @@
+import subprocess
+import sys
+from collections.abc import Iterable
+from pathlib import Path
+
+
+def discover_paths_for_python_executable(
+    python_executable: str = "python",
+) -> Iterable[Path]:
+    output = subprocess.check_output(
+        [python_executable, "-c", r"import sys; print('\n'.join(sys.path))"]
+    )
+    for output_line in output.decode().splitlines():
+        path = Path(output_line).absolute()
+        if path.is_dir():
+            yield path
+
+
+def get_internal_python_paths() -> Iterable[Path]:
+    return (Path(p) for p in sys.path)
+
+
+if __name__ == "__main__":
+    import sys
+
+    python_executable = sys.argv[1] if len(sys.argv) > 1 else sys.executable
+    for path in discover_paths_for_python_executable(python_executable):
+        print(path)

import_completer/symbols_database.py

@@ -0,0 +1,98 @@
+from collections.abc import AsyncIterable, Iterable
+from pathlib import Path
+
+import aiosqlite
+from loguru import logger
+
+from import_completer.types import ScannedSymbol
+
+DB_SYMBOLS_NAME = "symbols"
+DB_SYMBOLS_SCHEMA = [
+    ("generation", "INTEGER"),
+    ("kind", "TEXT"),
+    ("name", "TEXT"),
+    ("origin_index", "INTEGER"),
+    ("parent_module", "TEXT"),
+    ("metadata_json", "TEXT"),
+]
+DB_INDICES = [
+    ("idx_symbols_name", DB_SYMBOLS_NAME, ["name"]),
+    ("idx_symbols_parent_module", DB_SYMBOLS_NAME, ["origin_index", "parent_module"]),
+]
+
+
+class DatabaseHandler:
+    def __init__(self, database_path: str | Path = ":memory:") -> None:
+        self._database_path = database_path
+        self._connection = None
+
+    async def __aenter__(self):
+        self._connection = await aiosqlite.connect(str(self._database_path))
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if self._connection:
+            await self._connection.close()
+
+    async def create_schema(self) -> None:
+        assert self._connection is not None, "Database connection not initialized!"
+        await self._connection.execute(
+            f"CREATE TABLE IF NOT EXISTS {DB_SYMBOLS_NAME} ({', '.join(f'{name} {type}' for name, type in DB_SYMBOLS_SCHEMA)})"
+        )
+        await self._connection.commit()
+
+    async def create_indices(self) -> None:
+        assert self._connection is not None, "Database connection not initialized!"
+        for index_name, table_name, index_columns in DB_INDICES:
+            await self._connection.execute(
+                f"CREATE INDEX IF NOT EXISTS {index_name} ON {table_name} ({', '.join(index_columns)})"
+            )
+        await self._connection.commit()
+
+    async def drop_indices(self) -> None:
+        assert self._connection is not None, "Database connection not initialized!"
+        for index_name, _, _ in DB_INDICES:
+            await self._connection.execute(f"DROP INDEX IF EXISTS {index_name}")
+        await self._connection.commit()
+
+    async def perform_rebuild_for_origin(
+        self, origin_index: int, symbols: Iterable[ScannedSymbol]
+    ) -> None:
+        assert self._connection is not None, "Database connection not initialized!"
+
+        async with self._connection.cursor() as cursor:
+            await cursor.execute("BEGIN")
+            logger.info(f"Rebuilding symbols for origin_index: {origin_index}")
+            await cursor.execute(
+                f"""
+                DELETE FROM {DB_SYMBOLS_NAME} WHERE origin_index = ?
+                """,
+                (origin_index,),
+            )
+            await cursor.executemany(
+                """
+                INSERT INTO symbols (generation, kind, name, origin_index, parent_module, metadata_json)
+                VALUES (1, ?, ?, ?, ?, ?)
+                """,
+                (
+                    (symbol.kind, symbol.name, origin_index, symbol.parent_module, "")
+                    for symbol in symbols
+                ),
+            )
+            logger.info(
+                f"Added {cursor.rowcount} symbols for origin_index: {origin_index}"
+            )
+            await cursor.execute("COMMIT")
+
+    async def lookup_symbol_name(self, name_part: str) -> AsyncIterable[ScannedSymbol]:
+        assert self._connection is not None, "Database connection not initialized!"
+        cursor = await self._connection.execute(
+            """
+            SELECT kind, name, parent_module
+            FROM symbols
+            WHERE name >= ? AND name < ?
+            """,
+            (f"{name_part}", f"{name_part}~"),
+        )
+        async for row in cursor:
+            yield ScannedSymbol(*row, metadata={})

import_completer/types.py

@@ -0,0 +1,8 @@
+from typing import Literal, NamedTuple
+
+
+class ScannedSymbol(NamedTuple):
+    kind: Literal["variable", "function", "class"]  # TODO: add support for modules
+    name: str
+    parent_module: str
+    metadata: dict

import_completer-0.4.0.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: import-completer
+Version: 0.4.0
+Requires-Python: >=3.13
+Requires-Dist: aiosqlite==0.21.0
+Requires-Dist: click>=8.0.0
+Requires-Dist: loguru==0.7.3
+Requires-Dist: pygls==2.0.0
+Requires-Dist: tree-sitter-python==0.23.6
+Requires-Dist: tree-sitter==0.24.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'

import_completer-0.4.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+import_completer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+import_completer/code_scanner.py,sha256=99P9Zn2PVN-JUV6jq1ATExfRA7xU3394ZO_Pntl5c-M,6256
+import_completer/completion_engine.py,sha256=R8QhTsdU7DUfbiINpfGz-7azncDj1hWPFEyTzwb1I14,2929
+import_completer/config.py,sha256=EQJdEPwiTjD52rsqPuPipHRvG8_V3LpYZmJK8Xf6Kzo,637
+import_completer/language_server.py,sha256=uM3kgaRfM_mMvR7nGTNJuOKmiS9oGvDPQf5CasonVdo,6764
+import_completer/path_discovery.py,sha256=QFtzI229QR_4hkww8EAShbLOBCWadbFOTKfvuVK57vk,769
+import_completer/symbols_database.py,sha256=xhnqXc094doy1V4cVJqkuqAXFHMvAkpMpWCP1rBiArw,3677
+import_completer/types.py,sha256=KYpDfQ6MTPCD1S2zAO81nXWLr-yvW3ZbC3MGGYdArrk,214
+import_completer-0.4.0.dist-info/METADATA,sha256=7UK9c9gslfBpR4R5cDtQAugSlCMGae4bQazjZyJIlMU,398
+import_completer-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+import_completer-0.4.0.dist-info/entry_points.txt,sha256=TVRn0ssT9CrESNAP4vRIsEqykaHVsrGC2dKKH-XcYKk,93
+import_completer-0.4.0.dist-info/RECORD,,

import_completer-0.4.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

import_completer-0.4.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+py-import-completer-server = import_completer.language_server:start_server