Use modern python type hints.

Replace Dict, List, Tuple with dict, list, tuple.
Replace Optional[str] with str | None.

Author: amjith

AGENTS.md

@@ -32,6 +32,8 @@
 - Indentation: 4 spaces. Line length: 140 (see `pyproject.toml`).
 - Naming: modules/functions/variables `snake_case`; classes `CamelCase`; tests `test_*.py`.
 - Keep imports sorted and unused code removed (ruff enforces).
+- Use lowercase type hints for dict, list, tuples etc.
+- Use | for Unions and | None for Optional.
 
 ## Testing Guidelines
 - Framework: Pytest with coverage (`coverage run -m pytest` via tox).

litecli/clistyle.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import Dict, List, Tuple
+
 
 import pygments.styles
 from pygments.token import string_to_tokentype, Token
@@ -14,7 +14,7 @@
 logger = logging.getLogger(__name__)
 
 # map Pygments tokens (ptk 1.0) to class names (ptk 2.0).
-TOKEN_TO_PROMPT_STYLE: Dict[Token, str] = {
+TOKEN_TO_PROMPT_STYLE: dict[Token, str] = {
     Token.Menu.Completions.Completion.Current: "completion-menu.completion.current",
     Token.Menu.Completions.Completion: "completion-menu.completion",
     Token.Menu.Completions.Meta.Current: "completion-menu.meta.completion.current",
@@ -43,10 +43,10 @@
 }
 
 # reverse dict for cli_helpers, because they still expect Pygments tokens.
-PROMPT_STYLE_TO_TOKEN: Dict[str, Token] = {v: k for k, v in TOKEN_TO_PROMPT_STYLE.items()}
+PROMPT_STYLE_TO_TOKEN: dict[str, Token] = {v: k for k, v in TOKEN_TO_PROMPT_STYLE.items()}
 
 
-def parse_pygments_style(token_name: str, style_object, style_dict: Dict[str, str]) -> Tuple[Token, str]:
+def parse_pygments_style(token_name: str, style_object, style_dict: dict[str, str]) -> tuple[Token, str]:
     """Parse token type and style string.
 
     :param token_name: str name of Pygments token. Example: "Token.String"
@@ -62,13 +62,13 @@ def parse_pygments_style(token_name: str, style_object, style_dict: Dict[str, st
         return token_type, style_dict[token_name]
 
 
-def style_factory(name: str, cli_style: Dict[str, str]) -> _MergedStyle:
+def style_factory(name: str, cli_style: dict[str, str]) -> _MergedStyle:
     try:
         style = pygments.styles.get_style_by_name(name)
     except ClassNotFound:
         style = pygments.styles.get_style_by_name("native")
 
-    prompt_styles: List[Tuple[str, str]] = []
+    prompt_styles: list[tuple[str, str]] = []
     # prompt-toolkit used pygments tokens for styling before, switched to style
     # names in 2.0. Convert old token types to new style names, for backwards compatibility.
     for token in cli_style:
@@ -90,7 +90,7 @@ def style_factory(name: str, cli_style: Dict[str, str]) -> _MergedStyle:
     return merge_styles([style_from_pygments_cls(style), override_style, Style(prompt_styles)])
 
 
-def style_factory_output(name: str, cli_style: Dict[str, str]):
+def style_factory_output(name: str, cli_style: dict[str, str]):
     try:
         style = pygments.styles.get_style_by_name(name).styles
     except ClassNotFound:

litecli/clitoolbar.py

@@ -1,17 +1,17 @@
 from __future__ import annotations
 
-from typing import Callable, List, Tuple
+from typing import Callable
 
 from prompt_toolkit.key_binding.vi_state import InputMode
 from prompt_toolkit.enums import EditingMode
 from prompt_toolkit.application import get_app
 
 
-def create_toolbar_tokens_func(cli, show_fish_help: Callable[[], bool]) -> Callable[[], List[Tuple[str, str]]]:
+def create_toolbar_tokens_func(cli, show_fish_help: Callable[[], bool]) -> Callable[[], list[tuple[str, str]]]:
     """Return a function that generates the toolbar tokens."""
 
-    def get_toolbar_tokens() -> List[Tuple[str, str]]:
-        result: List[Tuple[str, str]] = []
+    def get_toolbar_tokens() -> list[tuple[str, str]]:
+        result: list[tuple[str, str]] = []
         result.append(("class:bottom-toolbar", " "))
 
         if cli.multi_line:

litecli/completion_refresher.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import threading
-from typing import Callable, Dict, List, Optional, Tuple
+from typing import Callable
 
 from .packages.special.main import COMMANDS
 from collections import OrderedDict
@@ -11,18 +11,18 @@
 
 
 class CompletionRefresher(object):
-    refreshers: Dict[str, Callable] = OrderedDict()
+    refreshers: dict[str, Callable] = OrderedDict()
 
     def __init__(self) -> None:
-        self._completer_thread: Optional[threading.Thread] = None
+        self._completer_thread: threading.Thread | None = None
         self._restart_refresh = threading.Event()
 
     def refresh(
         self,
         executor: SQLExecute,
-        callbacks: Callable | List[Callable],
-        completer_options: Optional[dict] = None,
-    ) -> List[Tuple]:
+        callbacks: Callable | list[Callable],
+        completer_options: dict | None = None,
+    ) -> list[tuple]:
         """Creates a SQLCompleter object and populates it with the relevant
         completion suggestions in a background thread.
 
@@ -61,7 +61,7 @@ def is_refreshing(self) -> bool:
     def _bg_refresh(
         self,
         sqlexecute: SQLExecute,
-        callbacks: Callable | List[Callable],
+        callbacks: Callable | list[Callable],
         completer_options: dict,
     ) -> None:
         completer = SQLCompleter(**completer_options)
@@ -97,7 +97,7 @@ def _bg_refresh(
             callback(completer)
 
 
-def refresher(name: str, refreshers: Dict[str, Callable] = CompletionRefresher.refreshers):
+def refresher(name: str, refreshers: dict[str, Callable] = CompletionRefresher.refreshers):
     """Decorator to add the decorated function to the dictionary of
     refreshers. Any function decorated with a @refresher will be executed as
     part of the completion refresh routine."""

litecli/config.py

@@ -5,7 +5,7 @@
 import os
 import platform
 from os.path import expanduser, exists, dirname
-from typing import Optional
+
 
 from configobj import ConfigObj
 
@@ -20,7 +20,7 @@ def config_location() -> str:
         return expanduser("~/.config/litecli/")
 
 
-def load_config(usr_cfg: str, def_cfg: Optional[str] = None) -> ConfigObj:
+def load_config(usr_cfg: str, def_cfg: str | None = None) -> ConfigObj:
     cfg = ConfigObj()
     if def_cfg:
         cfg.merge(ConfigObj(def_cfg, interpolation=False))
@@ -52,7 +52,7 @@ def upgrade_config(config: str, def_config: str) -> None:
     cfg.write()
 
 
-def get_config(liteclirc_file: Optional[str] = None) -> ConfigObj:
+def get_config(liteclirc_file: str | None = None) -> ConfigObj:
     from litecli import __file__ as package_root
 
     package_root = os.path.dirname(package_root)

litecli/main.py

@@ -17,7 +17,7 @@
 except ImportError:
     from sqlite3 import OperationalError, sqlite_version
 from time import time
-from typing import Any, Iterable, Optional, Dict
+from typing import Any, Iterable
 
 import click
 import sqlparse
@@ -66,12 +66,12 @@ class LiteCli(object):
 
     def __init__(
         self,
-        sqlexecute: Optional[SQLExecute] = None,
-        prompt: Optional[str] = None,
-        logfile: Optional[Any] = None,
+        sqlexecute: SQLExecute | None = None,
+        prompt: str | None = None,
+        logfile: Any | None = None,
         auto_vertical_output: bool = False,
-        warn: Optional[bool] = None,
-        liteclirc: Optional[str] = None,
+        warn: bool | None = None,
+        liteclirc: str | None = None,
     ) -> None:
         self.sqlexecute = sqlexecute
         self.logfile = logfile
@@ -190,7 +190,7 @@ def change_table_format(self, arg: str, **_: Any):
                 msg += "\n\t{}".format(table_type)
             yield (None, None, None, msg)
 
-    def change_db(self, arg: Optional[str], **_: Any):
+    def change_db(self, arg: str | None, **_: Any):
         if arg is None:
             self.sqlexecute.connect()
         else:
@@ -204,7 +204,7 @@ def change_db(self, arg: Optional[str], **_: Any):
             'You are now connected to database "%s"' % (self.sqlexecute.dbname),
         )
 
-    def execute_from_file(self, arg: Optional[str], **_: Any):
+    def execute_from_file(self, arg: str | None, **_: Any):
         if not arg:
             message = "Missing required argument, filename."
             return [(None, None, None, message)]
@@ -220,7 +220,7 @@ def execute_from_file(self, arg: Optional[str], **_: Any):
 
         return self.sqlexecute.run(query)
 
-    def change_prompt_format(self, arg: Optional[str], **_: Any):
+    def change_prompt_format(self, arg: str | None, **_: Any):
         """
         Change the prompt format.
         """
@@ -279,7 +279,7 @@ def initialize_logging(self) -> None:
         root_logger.debug("Initializing litecli logging.")
         root_logger.debug("Log file %r.", log_file)
 
-    def read_my_cnf_files(self, keys: Iterable[str]) -> Dict[str, Optional[str]]:
+    def read_my_cnf_files(self, keys: Iterable[str]) -> dict[str, str | None]:
         """
         Reads a list of config files and merges them. The last one will win.
         :param files: list of files to read
@@ -661,7 +661,7 @@ def echo(self, s: str, **kwargs: Any) -> None:
         self.log_output(s)
         click.secho(s, **kwargs)
 
-    def get_output_margin(self, status: Optional[str] = None) -> int:
+    def get_output_margin(self, status: str | None = None) -> int:
         """Get the output margin (number of rows for the prompt, footer and
         timing message."""
         margin = self.get_reserved_space() + self.get_prompt(self.prompt_format).count("\n") + 2
@@ -670,7 +670,7 @@ def get_output_margin(self, status: Optional[str] = None) -> int:
 
         return margin
 
-    def output(self, output: Iterable[str], status: Optional[str] = None) -> None:
+    def output(self, output: Iterable[str], status: str | None = None) -> None:
         """Output text to stdout or a pager command.
 
         The status text is not outputted to pager or files.

litecli/packages/completion_engine.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 import sqlparse
 from sqlparse.sql import Comparison, Identifier, Where, Token
 from .parseutils import last_word, extract_tables, find_prev_keyword
 from .special import parse_special_command
 
 
-def suggest_type(full_text: str, text_before_cursor: str) -> List[Dict[str, Any]]:
+def suggest_type(full_text: str, text_before_cursor: str) -> list[dict[str, Any]]:
     """Takes the full_text that is typed so far and also the text before the
     cursor to suggest completion type and scope.
 
@@ -18,7 +18,7 @@ def suggest_type(full_text: str, text_before_cursor: str) -> List[Dict[str, Any]
 
     word_before_cursor = last_word(text_before_cursor, include="many_punctuations")
 
-    identifier: Optional[Identifier] = None
+    identifier: Identifier | None = None
 
     # here should be removed once sqlparse has been fixed
     try:
@@ -87,7 +87,7 @@ def suggest_type(full_text: str, text_before_cursor: str) -> List[Dict[str, Any]
     return suggest_based_on_last_token(last_token, text_before_cursor, full_text, identifier)
 
 
-def suggest_special(text: str) -> List[Dict[str, Any]]:
+def suggest_special(text: str) -> list[dict[str, Any]]:
     text = text.lstrip()
     cmd, _, arg = parse_special_command(text)
 
@@ -144,11 +144,11 @@ def _expecting_arg_idx(arg: str, text: str) -> int:
 
 
 def suggest_based_on_last_token(
-    token: Optional[str | Token],
+    token: str | Token | None,
     text_before_cursor: str,
     full_text: str,
-    identifier: Optional[Identifier],
-) -> List[Dict[str, Any]]:
+    identifier: Identifier | None,
+) -> list[dict[str, Any]]:
     if isinstance(token, str):
         token_v = token.lower()
     elif isinstance(token, Comparison):
@@ -169,7 +169,7 @@ def suggest_based_on_last_token(
     else:
         token_v = token.value.lower()
 
-    def is_operand(x: Optional[str]) -> bool:
+    def is_operand(x: str | None) -> bool:
         return bool(x) and any([x.endswith(op) for op in ["+", "-", "*", "/"]])
 
     if not token:
@@ -328,5 +328,5 @@ def is_operand(x: Optional[str]) -> bool:
         return [{"type": "keyword"}]
 
 
-def identifies(id: Any, schema: Optional[str], table: str, alias: Optional[str]) -> bool:
+def identifies(id: Any, schema: str | None, table: str, alias: str | None) -> bool:
     return id == alias or id == table or (schema and (id == schema + "." + table))

litecli/packages/filepaths.py

@@ -1,19 +1,18 @@
 # -*- coding: utf-8
 from __future__ import annotations
 
-from typing import List, Tuple
 
 import os
 
 
-def list_path(root_dir: str) -> List[str]:
+def list_path(root_dir: str) -> list[str]:
     """List directory if exists.
 
     :param dir: str
     :return: list
 
     """
-    res: List[str] = []
+    res: list[str] = []
     if os.path.isdir(root_dir):
         for name in os.listdir(root_dir):
             res.append(name)
@@ -38,7 +37,7 @@ def complete_path(curr_dir: str, last_dir: str) -> str | None:
     return None
 
 
-def parse_path(root_dir: str) -> Tuple[str, str, int]:
+def parse_path(root_dir: str) -> tuple[str, str, int]:
     """Split path into head and last component for the completer.
 
     Also return position where last component starts.
@@ -54,7 +53,7 @@ def parse_path(root_dir: str) -> Tuple[str, str, int]:
     return base_dir, last_dir, position
 
 
-def suggest_path(root_dir: str) -> List[str]:
+def suggest_path(root_dir: str) -> list[str]:
     """List all files and subdirectories in a directory.
 
     If the directory is not specified, suggest root directory,

litecli/packages/parseutils.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
 import re
-from typing import Generator, Iterable, Optional, Tuple, List, Dict
+from typing import Generator, Iterable
 
 import sqlparse
 from sqlparse.sql import IdentifierList, Identifier, Function, Token, TokenList
 from sqlparse.tokens import Keyword, DML, Punctuation
 
-cleanup_regex: Dict[str, re.Pattern[str]] = {
+cleanup_regex: dict[str, re.Pattern[str]] = {
     # This matches only alphanumerics and underscores.
     "alphanum_underscore": re.compile(r"(\w+)$"),
     # This matches everything except spaces, parens, colon, and comma
@@ -120,7 +120,7 @@ def extract_from_part(parsed: TokenList, stop_at_punctuation: bool = True) -> Ge
                     break
 
 
-def extract_table_identifiers(token_stream: Iterable[Token]) -> Generator[Tuple[Optional[str], str, Optional[str]], None, None]:
+def extract_table_identifiers(token_stream: Iterable[Token]) -> Generator[tuple[str | None, str, str | None], None, None]:
     """Yield tuples of (schema_name, table_name, table_alias)."""
 
     for item in token_stream:
@@ -149,7 +149,7 @@ def extract_table_identifiers(token_stream: Iterable[Token]) -> Generator[Tuple[
 
 
 # extract_tables is inspired from examples in the sqlparse lib.
-def extract_tables(sql: str) -> List[Tuple[Optional[str], str, Optional[str]]]:
+def extract_tables(sql: str) -> list[tuple[str | None, str, str | None]]:
     """Extract the table names from an SQL statement.
 
     Returns a list of (schema, table, alias) tuples
@@ -168,7 +168,7 @@ def extract_tables(sql: str) -> List[Tuple[Optional[str], str, Optional[str]]]:
     return list(extract_table_identifiers(stream))
 
 
-def find_prev_keyword(sql: str) -> Tuple[Optional[Token], str]:
+def find_prev_keyword(sql: str) -> tuple[Token | None, str]:
     """Find the last sql keyword in an SQL statement
 
     Returns the value of the last keyword, and the text of the query with