Make ty pass all the type hints

Author: kracekumar

litecli/config.py

@@ -1,11 +1,10 @@
 from __future__ import annotations
 
 import errno
-import shutil
 import os
 import platform
-from os.path import expanduser, exists, dirname
-
+import shutil
+from os.path import dirname, exists, expanduser
 
 from configobj import ConfigObj
 
@@ -55,7 +54,7 @@ def upgrade_config(config: str, def_config: str) -> None:
 def get_config(liteclirc_file: str | None = None) -> ConfigObj:
     from litecli import __file__ as package_root
 
-    package_root = os.path.dirname(package_root)
+    package_root = os.path.dirname(str(package_root))
 
     liteclirc_file = liteclirc_file or f"{config_location()}config"
 

litecli/main.py

@@ -13,7 +13,7 @@
 from io import open
 
 try:
-    from sqlean import OperationalError, sqlite_version
+    from sqlean import OperationalError, sqlite_version  # ty: ignore[unresolved-import]
 except ImportError:
     from sqlite3 import OperationalError, sqlite_version
 from time import time
@@ -521,7 +521,8 @@ def one_iteration(text: str | None = None) -> None:
                 raise e
             except KeyboardInterrupt:
                 try:
-                    sqlexecute.conn.interrupt()
+                    # since connection can sqlite3 or sqlean, it's hard to annotate the type for interrupt. so ignore the type hint warning.
+                    sqlexecute.conn.interrupt()  # ty: ignore[possibly-missing-attribute]
                 except Exception as e:
                     self.echo(
                         "Encountered error while cancelling query: {}".format(e),
@@ -754,6 +755,7 @@ def refresh_completions(self, reset: bool = False) -> list[tuple]:
         if reset:
             with self._completer_lock:
                 self.completer.reset_completions()
+        assert self.sqlexecute is not None
         self.completion_refresher.refresh(
             self.sqlexecute,
             self._on_completions_refreshed,

litecli/packages/parseutils.py

@@ -4,8 +4,8 @@
 from typing import Generator, Iterable, Literal
 
 import sqlparse
-from sqlparse.sql import IdentifierList, Identifier, Function, Token, TokenList
-from sqlparse.tokens import Keyword, DML, Punctuation
+from sqlparse.sql import Function, Identifier, IdentifierList, Token, TokenList
+from sqlparse.tokens import DML, Keyword, Punctuation
 
 cleanup_regex: dict[str, re.Pattern[str]] = {
     # This matches only alphanumerics and underscores.
@@ -18,10 +18,10 @@
     "all_punctuations": re.compile(r"([^\s]+)$"),
 }
 
+LAST_WORD_INCLUDE_TYPE = Literal["alphanum_underscore", "many_punctuations", "most_punctuations", "all_punctuations"]
 
-def last_word(
-    text: str, include: Literal["alphanum_underscore", "many_punctuations", "most_punctuations", "all_punctuations"] = "alphanum_underscore"
-) -> str:
+
+def last_word(text: str, include: LAST_WORD_INCLUDE_TYPE = "alphanum_underscore") -> str:
     R"""
     Find the last word in a sentence.
 

litecli/packages/special/__init__.py

@@ -10,7 +10,8 @@
 
 def export(defn: Callable[..., Any]) -> Callable[..., Any]:
     """Decorator to explicitly mark functions that are exposed in a lib."""
-    if isinstance(defn, FunctionType):
+    # ty, requires explict check for callable of tyep | function type to access __name__
+    if isinstance(defn, (type, FunctionType)):
         globals()[defn.__name__] = defn
         __all__.append(defn.__name__)
     return defn
@@ -19,3 +20,24 @@ def export(defn: Callable[..., Any]) -> Callable[..., Any]:
 from . import dbcommands
 from . import iocommands
 from . import llm
+from . import utils
+from .main import CommandNotFound, register_special_command, execute
+from .iocommands import (
+    set_favorite_queries,
+    editor_command,
+    get_filename,
+    get_editor_query,
+    open_external_editor,
+    is_expanded_output,
+    set_expanded_output,
+    write_tee,
+    unset_once_if_written,
+    unset_pipe_once_if_written,
+    disable_pager,
+    set_pager,
+    is_pager_enabled,
+    write_once,
+    write_pipe_once,
+    close_tee,
+)
+from .llm import is_llm_command, handle_llm, FinishIteration

litecli/packages/special/llm.py

@@ -25,7 +25,8 @@
 LLM_TEMPLATE_NAME = "litecli-llm-template"
 LLM_CLI_COMMANDS: list[str] = list(cli.commands.keys())
 # Mapping of model_id to None used for completion tree leaves.
-MODELS: dict[str, None] = {x.model_id: None for x in llm.get_models()}
+# the file name is llm.py and module name is llm, hence ty is complaining that get_models is missing.
+MODELS: dict[str, None] = {x.model_id: None for x in llm.get_models()}  # ty: ignore[unresolved-attribute]
 
 
 def run_external_cmd(

litecli/sqlcompleter.py

@@ -1,18 +1,18 @@
 from __future__ import annotations
 
 import logging
-from re import compile, escape
 from collections import Counter
+from re import compile, escape
 from typing import Any, Collection, Generator, Iterable, Literal, Sequence
 
 from prompt_toolkit.completion import CompleteEvent, Completer, Completion
 from prompt_toolkit.completion.base import Document
 
 from .packages.completion_engine import suggest_type
-from .packages.parseutils import last_word
-from .packages.special.iocommands import favoritequeries
+from .packages.filepaths import complete_path, parse_path, suggest_path
+from .packages.parseutils import LAST_WORD_INCLUDE_TYPE, last_word
 from .packages.special import llm
-from .packages.filepaths import parse_path, complete_path, suggest_path
+from .packages.special.iocommands import favoritequeries
 
 _logger = logging.getLogger(__name__)
 
@@ -381,7 +381,7 @@ def extend_functions(self, func_data: Iterable[Sequence[str]]) -> None:
             metadata[self.dbname][func[0]] = None
             self.all_completions.add(func[0])
 
-    def set_dbname(self, dbname: str) -> None:
+    def set_dbname(self, dbname: str | None) -> None:
         self.dbname = dbname
 
     def reset_completions(self) -> None:
@@ -397,7 +397,7 @@ def find_matches(
         start_only: bool = False,
         fuzzy: bool = True,
         casing: str | None = None,
-        punctuations: str = "most_punctuations",
+        punctuations: LAST_WORD_INCLUDE_TYPE = "most_punctuations",
     ) -> Generator[Completion, None, None]:
         """Find completion matches for the given text.
 

litecli/sqlexecute.py

@@ -6,7 +6,7 @@
 
 try:
     import sqlean as sqlite3
-    from sqlean import OperationalError
+    from sqlean import OperationalError  # ty: ignore[unresolved-import]
 
     sqlite3.extensions.enable_all()
 except ImportError:
@@ -17,10 +17,9 @@
 
 import sqlparse
 
+from litecli.packages import special
 from litecli.packages.special.utils import check_if_sqlitedotcommand
 
-from .packages import special
-
 _logger = logging.getLogger(__name__)
 
 # FIELD_TYPES = decoders.copy()

pyproject.toml

@@ -18,7 +18,7 @@ dependencies = [
     "setuptools", # Required by llm commands to install models
     "pip",
     "llm>=0.25.0",
-    "ty>=0.0.2",
+    "ty>=0.0.4",
 ]
 
 [build-system]
@@ -92,10 +92,8 @@ exclude = [
 
 [tool.ty.environment]
 python-version = "3.9"
-root = ["litecli"]
+root = [".", "litecli", "litecli/packages", "litecli/packages/special"]
 
-[tool.ty.rules]
-unresolved-import = "ignore"
 
 [tool.ty.src]
 exclude = [