dbqm 2.3.0__tar.gz → 2.3.2__tar.gz

{dbqm-2.3.0 → dbqm-2.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbqm
-Version: 2.3.0
+Version: 2.3.2
 Summary: Multi-database interactive query tool with fullscreen TUI
 Author: Silvio Chagas
 License-Expression: MIT
@@ -23,6 +23,7 @@ Requires-Dist: pymssql>=2.2; sys_platform != "win32" or platform_machine != "ARM
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: mypy>=1.11; extra == "dev"
 Provides-Extra: oracle
 Requires-Dist: oracledb>=2.0; extra == "oracle"
 Provides-Extra: postgres

dbqm-2.3.2/dbqm/_version.py

@@ -0,0 +1 @@
+__version__ = "2.3.2"

{dbqm-2.3.0 → dbqm-2.3.2}/dbqm/cli/commands/query.py

@@ -23,8 +23,10 @@ from dbqm.cli.render import console
 # by text and remaps it here; anything else really is `sql_error`.
 _USAGE_SQL_MESSAGES = (
     "Apenas comandos SELECT sao permitidos.",
-    "Tipo de SQL nao suportado. Use SELECT, INSERT, UPDATE, DELETE, DDL "
-    "(CREATE/ALTER/DROP...) ou EXPLAIN PLAN.",
+    (
+        "Tipo de SQL nao suportado. Use SELECT, INSERT, UPDATE, DELETE, DDL "
+        "(CREATE/ALTER/DROP...) ou EXPLAIN PLAN."
+    ),
     "Passe apenas a query (sem EXPLAIN PLAN FOR) ao usar --explain.",
 )
 
@@ -319,12 +321,23 @@ def cmd_sql(args: argparse.Namespace) -> None:
         _fail_or_print(args, "sql", "usage", "DML requer --commit para confirmar a operacao.")
 
     try:
-        result = deps.execute_adhoc(sql, conn, param_values, auto_commit=args.commit)
+        outcome = deps.execute_adhoc(sql, conn, param_values, auto_commit=args.commit)
     except deps.ReadOnlyViolation as e:
         _fail_or_print(args, "sql", "read_only", str(e))
 
+    # `execute_adhoc` only returns the `(result, connection)` tuple for a DML
+    # statement left uncommitted (`auto_commit=False`); the --commit guard
+    # above already exits before this call whenever `sql_type` is DML and
+    # `--commit` was not given, and no other `sql_type` ever produces that
+    # tuple. So this call always yields a plain `AdhocResult`.
+    if isinstance(outcome, tuple):  # pragma: no cover - unreachable, see above
+        raise RuntimeError(
+            "execute_adhoc returned a manual-commit tuple despite auto_commit=True"
+        )
+    result = outcome
+
     # For non-SELECT results (always AdhocResult with auto_commit=True at this point)
-    if not isinstance(result, tuple) and result.sql_type in ("INSERT", "UPDATE", "DELETE"):
+    if result.sql_type in ("INSERT", "UPDATE", "DELETE"):
         if not result.success:
             _fail_or_print(args, "sql", _sql_error_code(result.error, result.error_kind),
                             result.error or "Erro ao executar SQL.")
@@ -335,7 +348,7 @@ def cmd_sql(args: argparse.Namespace) -> None:
         return
 
     # DDL results
-    if not isinstance(result, tuple) and result.sql_type == "DDL":
+    if result.sql_type == "DDL":
         if not result.success:
             code = _sql_error_code(result.error, result.error_kind)
             if args.format == "json":
@@ -350,7 +363,7 @@ def cmd_sql(args: argparse.Namespace) -> None:
         return
 
     # PL/SQL anonymous block results
-    if not isinstance(result, tuple) and result.sql_type == "PLSQL":
+    if result.sql_type == "PLSQL":
         if not result.success:
             _fail_or_print(args, "sql", _sql_error_code(result.error, result.error_kind),
                             result.error or "Erro ao executar bloco.")

{dbqm-2.3.0 → dbqm-2.3.2}/dbqm/cli/commands/schema.py

@@ -209,7 +209,7 @@ def cmd_rows(args: argparse.Namespace) -> None:
             if args.table.upper() not in tabelas | vistas:
                 raise deps.ObjectNotFound(
                     f"Tabela '{args.table}' nao encontrada em {conn.name}."
-                )
+                ) from original
             raise
 
     resultado = _with_open_connection(args, "rows", conn, acao)

{dbqm-2.3.0 → dbqm-2.3.2}/dbqm/cli/envelope.py

@@ -17,12 +17,12 @@ from __future__ import annotations
 
 import json
 import sys
-from typing import Any, NoReturn
+from typing import Any, NoReturn, TextIO
 
 from dbqm.cli.errors import exit_for
 
 
-def _write(stream, payload: dict) -> None:
+def _write(stream: TextIO, payload: dict[str, Any]) -> None:
     json.dump(payload, stream, indent=2, ensure_ascii=False, default=str)
     stream.write("\n")
 

{dbqm-2.3.0 → dbqm-2.3.2}/dbqm/cli/params.py

@@ -5,6 +5,7 @@ import argparse
 import getpass
 import os
 import sys
+from typing import Literal, overload
 
 from rich.markup import escape
 
@@ -14,7 +15,7 @@ from dbqm.cli.render import console
 
 
 def _parse_params(param_list: list[str] | None, args: argparse.Namespace | None = None,
-                   command: str = "params") -> dict:
+                   command: str = "params") -> dict[str, str]:
     """Parse key=value parameter pairs from CLI arguments.
 
     `args`/`command` let a malformed `-p` speak the envelope under `-f json`
@@ -77,6 +78,16 @@ def _add_connection_fields(parser: argparse.ArgumentParser) -> None:
                         help="Formato de saida")
 
 
+@overload
+def resolve_password(
+    args: argparse.Namespace, env_var: str, prompt: str, *, required: Literal[True],
+    use_env: bool = True, command: str = "password",
+) -> str: ...
+@overload
+def resolve_password(
+    args: argparse.Namespace, env_var: str, prompt: str, *, required: bool,
+    use_env: bool = True, command: str = "password",
+) -> str | None: ...
 def resolve_password(
     args: argparse.Namespace, env_var: str, prompt: str, *, required: bool,
     use_env: bool = True, command: str = "password",
@@ -110,7 +121,11 @@ def resolve_password(
     `table`'s unchanged prose-and-`sys.exit` branch.
     """
     from_stdin = getattr(args, "password_stdin", False)
-    direct = getattr(args, "password", None)
+    # `args.password`, where the parser defines it, is a plain string
+    # argument (argparse's `--password`). `argparse.Namespace` is untyped
+    # so `getattr` returns `Any`; the annotation states what the value
+    # actually is instead of letting that `Any` leak into the return type.
+    direct: str | None = getattr(args, "password", None)
     fmt = getattr(args, "format", "table")
 
     if from_stdin and direct:

{dbqm-2.3.0 → dbqm-2.3.2}/dbqm/cli/render.py

@@ -7,6 +7,7 @@ from rich.console import Console
 from rich.table import Table
 from rich.theme import Theme as _RichTheme
 
+from dbqm.core.group_engine import ComparisonResult
 from dbqm.design.tokens import DARK_TOKENS
 
 
@@ -68,7 +69,7 @@ def _print_query_result(result: Any, output_format: str = "table") -> None:
         console.print(f"[dim]{result.row_count} registros em {result.elapsed:.2f}s[/dim]")
 
 
-def _colored_comparison_lines(comparisons: list) -> list[str]:
+def _colored_comparison_lines(comparisons: list[ComparisonResult]) -> list[str]:
     """Linhas de resumo do grupo, coloridas pelo eixo de veredito.
 
     Reconstroi o texto a partir de `ComparisonResult` (contagens), em vez de

{dbqm-2.3.0 → dbqm-2.3.2}/dbqm/core/audit.py

@@ -16,7 +16,7 @@ def log_execution(
     action: str,
     name: str,
     connection: str = "",
-    params: dict | None = None,
+    params: dict[str, str] | None = None,
     row_count: int = 0,
     success: bool = True,
     error: str = "",
@@ -39,7 +39,7 @@ def log_execution(
 
     CONFIG_DIR.mkdir(parents=True, exist_ok=True)
     is_new = not AUDIT_FILE.exists()
-    with open(AUDIT_FILE, "a", encoding="utf-8") as f:
+    with AUDIT_FILE.open("a", encoding="utf-8") as f:
         f.write(json.dumps(entry, ensure_ascii=False, default=str) + "\n")
     if is_new:
         try:

{dbqm-2.3.0 → dbqm-2.3.2}/dbqm/core/db_manager.py

@@ -103,7 +103,7 @@ def _python_is_64bit() -> bool:
 def _pe_machine(dll: Path) -> int | None:
     """Read the COFF machine field of a PE binary. None when unreadable."""
     try:
-        with open(dll, "rb") as f:
+        with dll.open("rb") as f:
             f.seek(0x3C)
             pe_offset = int.from_bytes(f.read(4), "little")
             f.seek(pe_offset + 4)
@@ -450,14 +450,13 @@ def get_connection(conn: Connection) -> Any:
     """Get a database connection based on connection type."""
     if conn.db_type == "oracle":
         return get_oracle_connection(conn)
-    elif conn.db_type == "sqlserver":
+    if conn.db_type == "sqlserver":
         return get_sqlserver_connection(conn)
-    elif conn.db_type == "postgresql":
+    if conn.db_type == "postgresql":
         return get_postgresql_connection(conn)
-    elif conn.db_type == "mysql":
+    if conn.db_type == "mysql":
         return get_mysql_connection(conn)
-    else:
-        raise ValueError(f"Tipo de banco desconhecido: {conn.db_type}")
+    raise ValueError(f"Tipo de banco desconhecido: {conn.db_type}")
 
 
 def fetch_table_columns(conn: Connection, table: str) -> list[str]:

{dbqm-2.3.0 → dbqm-2.3.2}/dbqm/core/ddl_extractor.py

@@ -245,9 +245,9 @@ def _build_constraint_ddl_fallback(
 
     if c_type == "P":
         return f"ALTER TABLE {owner}.{table_name} ADD CONSTRAINT {c_name} PRIMARY KEY ({col_list});"
-    elif c_type == "U":
+    if c_type == "U":
         return f"ALTER TABLE {owner}.{table_name} ADD CONSTRAINT {c_name} UNIQUE ({col_list});"
-    elif c_type == "R":
+    if c_type == "R":
         ref = ""
         if r_owner and r_cname:
             ref_cols = _query_all(cursor, """
@@ -260,7 +260,7 @@ def _build_constraint_ddl_fallback(
                 ref_col_list = ", ".join(c[1] for c in ref_cols)
                 ref = f" REFERENCES {r_owner}.{ref_table} ({ref_col_list})"
         return f"ALTER TABLE {owner}.{table_name} ADD CONSTRAINT {c_name} FOREIGN KEY ({col_list}){ref};"
-    elif c_type == "C":
+    if c_type == "C":
         cond = search_cond.strip() if search_cond else ""
         return f"ALTER TABLE {owner}.{table_name} ADD CONSTRAINT {c_name} CHECK ({cond});"
     return f"-- Constraint {c_name} type={c_type}"
@@ -399,7 +399,7 @@ def _parse_routines(source: str) -> dict[str, dict]:
     if not matches:
         return routines
 
-    for i, m in enumerate(matches):
+    for _i, m in enumerate(matches):
         rtype = m.group(1).upper()
         rname = m.group(2)
         start = m.start()
@@ -447,7 +447,7 @@ def _find_routine_end(source: str, offset: int, routine_name: str) -> int:
 
     for tok in token_pattern.finditer(source, pos):
         g = tok.group(0).upper()
-        if g.startswith("'") or g.startswith("--") or g.startswith("/*"):
+        if g.startswith(("'", "--", "/*")):
             continue
         if g in ("BEGIN", "CASE"):
             depth += 1

{dbqm-2.3.0 → dbqm-2.3.2}/dbqm/core/ddl_mysql.py

@@ -1,10 +1,12 @@
 """MySQL DDL extraction via SHOW CREATE statements."""
 from __future__ import annotations
 
+from typing import Any
+
 from dbqm.core.ddl_extractor import ExtractionResult, ExtractedObject
 
 
-def extract_mysql_ddl(db, object_name: str, result: ExtractionResult, on_progress=None):
+def extract_mysql_ddl(db: Any, object_name: str, result: ExtractionResult, on_progress: Any = None) -> None:
     """Extract DDL for a MySQL object (table, view, procedure, function)."""
     cursor = db.cursor()
     name = object_name.strip()

{dbqm-2.3.0 → dbqm-2.3.2}/dbqm/core/exporter.py

@@ -37,8 +37,7 @@ _MIN_FILENAME_BODY = 8
 def _sanitize(name: str) -> str:
     """Sanitize a name for safe use in filenames."""
     s = name.replace(" ", "_").replace("/", "_").replace("\\", "_")
-    s = re.sub(r'[<>:"|?*]', "_", s)
-    return s
+    return re.sub(r'[<>:"|?*]', "_", s)
 
 
 def _normalize_label(name: str) -> str:
@@ -242,7 +241,7 @@ def export_query_csv(result: QueryResult, table: str = "", params: dict | None =
     """Export a single query result to CSV. Returns the file path."""
     label = table or result.query_name
     filepath = _build_filepath("consultas", label, result.connection_name, params, "csv")
-    with open(filepath, "w", newline="", encoding="utf-8") as f:
+    with filepath.open("w", newline="", encoding="utf-8") as f:
         writer = csv.writer(f)
         writer.writerow(result.columns)
         writer.writerows(result.rows)
@@ -259,7 +258,7 @@ def export_query_json(result: QueryResult, table: str = "", params: dict | None
         "columns": result.columns,
         "row_count": result.row_count,
         "elapsed": round(result.elapsed, 3),
-        "rows": [dict(zip(result.columns, row)) for row in result.rows],
+        "rows": [dict(zip(result.columns, row, strict=True)) for row in result.rows],
     }
     filepath.write_text(json.dumps(data, indent=2, ensure_ascii=False, default=str), encoding="utf-8")
     return str(filepath)
@@ -373,7 +372,7 @@ def export_group_csv(group_result: GroupResult, params: dict | None = None) -> s
 
     query_names, compare_columns, all_keys, lookup = _build_pivoted_data(group_result)
 
-    with open(filepath, "w", newline="", encoding="utf-8") as f:
+    with filepath.open("w", newline="", encoding="utf-8") as f:
         if params:
             for k, v in params.items():
                 f.write(f"# Parametro: {k} = {v}\n")
@@ -539,7 +538,7 @@ def export_group_flat_csv(group_result: GroupResult, params: dict | None = None)
 
     query_names = list(group_result.query_results.keys())
 
-    with open(filepath, "w", newline="", encoding="utf-8") as f:
+    with filepath.open("w", newline="", encoding="utf-8") as f:
         if params:
             for k, v in params.items():
                 f.write(f"# Parametro: {k} = {v}\n")

{dbqm-2.3.0 → dbqm-2.3.2}/dbqm/core/group_engine.py

@@ -92,7 +92,7 @@ def run_comparison(
             continue
         for row in result.rows:
             key_val = row[key_idx]
-            row_dict = dict(zip(result.columns, row))
+            row_dict = dict(zip(result.columns, row, strict=True))
             indexed[qname][key_val] = row_dict
 
     # Collect all unique keys
@@ -138,8 +138,8 @@ def run_comparison(
                 status = "ABSENT"
                 absent_count += 1
             else:
-                unique_normalized = set(v for v in values.values() if v is not None)
-                unique_raw = set(str(v) for v in raw_values.values() if v is not None)
+                unique_normalized = {v for v in values.values() if v is not None}
+                unique_raw = {str(v) for v in raw_values.values() if v is not None}
                 if len(unique_normalized) <= 1:
                     if len(unique_raw) <= 1:
                         status = "OK"

{dbqm-2.3.0 → dbqm-2.3.2}/dbqm/core/html_report.py

@@ -29,7 +29,7 @@ def _light_theme_block(tokens: dict[str, str]) -> str:
     return f"@media (prefers-color-scheme: light) {{\n  :root {{\n{linhas}\n  }}\n}}"
 
 
-def export_group_html(group_result: GroupResult, params: dict | None = None) -> str:
+def export_group_html(group_result: GroupResult, params: dict[str, str] | None = None) -> str:
     """Export group comparison as a standalone HTML file. Returns file path."""
     query_names = list(group_result.query_results.keys())
     filepath = _build_filepath("grupos", group_result.group_name, params=params, ext="html")
@@ -47,7 +47,7 @@ def _status_label(status: str) -> str:
     return {"OK": "OK", "OK*": "OK*", "DIFF": "DIFERE", "ABSENT": "AUSENTE"}.get(status, status)
 
 
-def _build_html(group_result: GroupResult, query_names: list[str], params: dict | None) -> str:
+def _build_html(group_result: GroupResult, query_names: list[str], params: dict[str, str] | None) -> str:
     now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
     overall = "CONSISTENTE" if group_result.all_match else "DIVERGENTE"
     overall_class = "ok" if group_result.all_match else "diff"

{dbqm-2.3.0 → dbqm-2.3.2}/dbqm/core/oracle_client_installer.py

@@ -243,7 +243,7 @@ def _download(url: str, dest: Path, progress: ProgressCallback | None) -> None:
         total = resp.length  # may be None
         chunk = 1 << 16
         done = 0
-        with open(dest, "wb") as out:
+        with dest.open("wb") as out:
             while True:
                 buf = resp.read(chunk)
                 if not buf:

{dbqm-2.3.0 → dbqm-2.3.2}/dbqm/core/paths.py

@@ -24,7 +24,7 @@ SETTINGS_FILE = CONFIG_DIR / "settings.json"
 TEMPLATES_DIR = DBQM_HOME / "templates"
 TEMPLATES_FILE = TEMPLATES_DIR / "templates.json"
 
-def ensure_dirs():
+def ensure_dirs() -> None:
     """Create data directories if they don't exist."""
     for d in [CONFIG_DIR, EXPORTS_DIR, HISTORY_DIR, TEMPLATES_DIR]:
         d.mkdir(parents=True, exist_ok=True)

{dbqm-2.3.0 → dbqm-2.3.2}/dbqm/core/query_engine.py

@@ -480,7 +480,7 @@ def execute_adhoc(sql: str, conn: Connection, param_values: dict, auto_commit: b
                 elapsed=elapsed,
                 output_lines=output_lines,
             )
-        elif sql_type == "DDL":
+        if sql_type == "DDL":
             cursor.close()
             # For DDL on Oracle, check compilation errors if applicable
             compilation_errors = _fetch_ddl_errors(db, sql, conn.db_type)
@@ -496,7 +496,7 @@ def execute_adhoc(sql: str, conn: Connection, param_values: dict, auto_commit: b
                 error=compilation_errors,
                 success=not compilation_errors,
             )
-        elif sql_type == "PLSQL":
+        if sql_type == "PLSQL":
             output_lines = _read_dbms_output(cursor) if capture_dbms_output else []
             columns: list[str] = []
             rows: list[list[Any]] = []
@@ -523,7 +523,7 @@ def execute_adhoc(sql: str, conn: Connection, param_values: dict, auto_commit: b
                 success=True,
                 output_lines=output_lines,
             )
-        elif sql_type == "EXPLAIN":
+        if sql_type == "EXPLAIN":
             # Oracle EXPLAIN PLAN inserts into PLAN_TABLE — no result set.
             # PostgreSQL/MySQL EXPLAIN returns the plan as rows.
             if cursor.description:
@@ -554,35 +554,33 @@ def execute_adhoc(sql: str, conn: Connection, param_values: dict, auto_commit: b
                 committed=True,
                 success=True,
             )
-        else:
-            rows_affected = cursor.rowcount
-            output_lines = _read_dbms_output(cursor) if capture_dbms_output else []
-            if auto_commit:
-                db.commit()
-                cursor.close()
-                return AdhocResult(
-                    sql_type=sql_type,
-                    connection_name=conn.name,
-                    sql=original_sql,
-                    db_type=conn.db_type,
-                    rows_affected=rows_affected,
-                    elapsed=elapsed,
-                    committed=True,
-                    output_lines=output_lines,
-                )
-            else:
-                # Caller owns the connection for commit/rollback
-                owned_db = db
-                db = None  # prevent finally from closing it
-                return AdhocResult(
-                    sql_type=sql_type,
-                    connection_name=conn.name,
-                    sql=original_sql,
-                    db_type=conn.db_type,
-                    rows_affected=rows_affected,
-                    elapsed=elapsed,
-                    output_lines=output_lines,
-                ), owned_db
+        rows_affected = cursor.rowcount
+        output_lines = _read_dbms_output(cursor) if capture_dbms_output else []
+        if auto_commit:
+            db.commit()
+            cursor.close()
+            return AdhocResult(
+                sql_type=sql_type,
+                connection_name=conn.name,
+                sql=original_sql,
+                db_type=conn.db_type,
+                rows_affected=rows_affected,
+                elapsed=elapsed,
+                committed=True,
+                output_lines=output_lines,
+            )
+        # Caller owns the connection for commit/rollback
+        owned_db = db
+        db = None  # prevent finally from closing it
+        return AdhocResult(
+            sql_type=sql_type,
+            connection_name=conn.name,
+            sql=original_sql,
+            db_type=conn.db_type,
+            rows_affected=rows_affected,
+            elapsed=elapsed,
+            output_lines=output_lines,
+        ), owned_db
 
     except Exception as e:
         return AdhocResult(
@@ -816,7 +814,7 @@ def parse_dml_literals(sql: str) -> dict[str, str]:
             cols = [c.strip() for c in col_match.group(1).split(",")]
             raw_vals = re.findall(r"'([^']*)'|(\d+(?:\.\d+)?)", val_match.group(1))
             vals = [v[0] if v[0] else v[1] for v in raw_vals]
-            for col, val in zip(cols, vals):
+            for col, val in zip(cols, vals, strict=False):
                 literals[col.lower()] = val
 
     elif sql_type == "UPDATE":

{dbqm-2.3.0 → dbqm-2.3.2}/dbqm/core/read_only.py

@@ -13,9 +13,13 @@ the generated statement, the careless paste.
 from __future__ import annotations
 
 import re
+from typing import TYPE_CHECKING
 
 import sqlparse
 
+if TYPE_CHECKING:
+    from dbqm.models.connection import Connection
+
 #: What a query-only connection may carry. `EXPLAIN` is here only as a
 #: prefix — see `_explains_a_query`, which is what decides whether a given
 #: EXPLAIN is actually read-only.
@@ -52,7 +56,10 @@ def statement_count(sql: str) -> int:
     and neither is one inside a string literal -- `sqlparse` handles both,
     which is why the count is not a `str.count(";")`.
     """
-    return len([s for s in sqlparse.parse(sql) if s.token_first() is not None])
+    return len([
+        s for s in sqlparse.parse(sql)
+        if s.token_first() is not None  # type: ignore[no-untyped-call]  # sqlparse ships py.typed, but Statement.token_first() itself is unannotated upstream
+    ])
 
 
 def _explains_a_query(sql: str) -> bool:
@@ -76,7 +83,7 @@ def _explains_a_query(sql: str) -> bool:
     return classify_sql(restante) == "SELECT"
 
 
-def check_read_only(sql: str, conn) -> None:
+def check_read_only(sql: str, conn: "Connection") -> None:
     """Raise `ReadOnlyViolation` if `conn` is read-only and `sql` could write.
 
     Does nothing when the connection is writable, so callers can invoke it

{dbqm-2.3.0 → dbqm-2.3.2}/dbqm/core/template_engine.py

@@ -127,7 +127,7 @@ def render_template(
     values: dict[str, str],
 ) -> str:
     """Render template content by replacing {{field}} placeholders with values."""
-    def _replace(match: re.Match) -> str:
+    def _replace(match: re.Match[str]) -> str:
         field_name = match.group(1)
         return values.get(field_name, match.group(0))
 

{dbqm-2.3.0 → dbqm-2.3.2}/dbqm/main.py

@@ -2,7 +2,7 @@
 import sys
 
 
-def main():
+def main() -> None:
     # Version flag
     if len(sys.argv) == 2 and sys.argv[1] in ("--version", "-V"):
         from dbqm._version import __version__

{dbqm-2.3.0 → dbqm-2.3.2}/dbqm/models/connection.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import json
 from dataclasses import dataclass, field, asdict
 from datetime import datetime
-from typing import Optional
+from typing import Any, Optional
 
 from dbqm.core.paths import CONFIG_DIR, CONNECTIONS_FILE
 
@@ -31,12 +31,12 @@ class Connection:
     read_only: bool = False
     created_at: str = field(default_factory=lambda: datetime.now().isoformat(timespec="seconds"))
 
-    def to_dict(self) -> dict:
+    def to_dict(self) -> dict[str, Any]:
         d = asdict(self)
         return {k: v for k, v in d.items() if v is not None}
 
     @classmethod
-    def from_dict(cls, data: dict) -> Connection:
+    def from_dict(cls, data: dict[str, Any]) -> Connection:
         valid_fields = {f.name for f in cls.__dataclass_fields__.values()}
         filtered = {k: v for k, v in data.items() if k in valid_fields}
         return cls(**filtered)

{dbqm-2.3.0 → dbqm-2.3.2}/dbqm/models/settings.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 import json
 from dataclasses import dataclass, asdict
+from typing import Any
 
 from dbqm.core.paths import CONFIG_DIR, SETTINGS_FILE
 
@@ -20,11 +21,11 @@ class Settings:
     # tool (e.g. PL/SQL Developer) cannot hijack the 64-bit client dbqm needs.
     oracle_client_dir: str = ""
 
-    def to_dict(self) -> dict:
+    def to_dict(self) -> dict[str, Any]:
         return asdict(self)
 
     @classmethod
-    def from_dict(cls, data: dict) -> Settings:
+    def from_dict(cls, data: dict[str, Any]) -> Settings:
         return cls(
             audit_log_enabled=data.get("audit_log_enabled", False),
             theme=data.get("theme", "plano-escuro"),

{dbqm-2.3.0 → dbqm-2.3.2}/dbqm/models/template.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 import json
 from dataclasses import dataclass, field, asdict
 from datetime import datetime
-from typing import Optional
+from typing import Any, Optional
 
 from dbqm.core.paths import TEMPLATES_DIR, TEMPLATES_FILE
 
@@ -16,11 +16,11 @@ class Template:
     content: str  # Template text with {{field}} placeholders
     created_at: str = field(default_factory=lambda: datetime.now().isoformat(timespec="seconds"))
 
-    def to_dict(self) -> dict:
+    def to_dict(self) -> dict[str, str]:
         return asdict(self)
 
     @classmethod
-    def from_dict(cls, data: dict) -> Template:
+    def from_dict(cls, data: dict[str, Any]) -> Template:
         return cls(
             name=data["name"],
             description=data.get("description", ""),

{dbqm-2.3.0 → dbqm-2.3.2}/dbqm/ui/modals/column_maps.py

@@ -10,7 +10,7 @@ from textual.widgets import Button, DataTable, Input, Select
 from dbqm.ui.widgets.dialog import Dialog
 
 
-class ColumnMapsModal(ModalScreen[dict | None]):
+class ColumnMapsModal(ModalScreen[dict[str, dict[str, str]] | None]):
     """Configure column value mappings (DE-PARA).
 
     Dismisses with updated maps dict on save, or None on cancel/ESC.

{dbqm-2.3.0 → dbqm-2.3.2}/dbqm/ui/modals/export_picker.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 
 from typing import Callable
 
-from textual.app import ComposeResult
+from textual.app import App, ComposeResult
 from textual.binding import Binding
 from textual.screen import ModalScreen
 from textual.widgets import Button
@@ -61,7 +61,7 @@ class ExportPickerModal(ModalScreen[str | None]):
 
 
 def request_export(
-    app,
+    app: App[object],
     callback: Callable[[str | None], None] | None = None,
 ) -> None:
     """Public entry point for the export flow.

{dbqm-2.3.0 → dbqm-2.3.2}/dbqm/ui/modals/param_input.py

@@ -60,7 +60,7 @@ class ParamModal(ModalScreen[dict[str, str] | None]):
     def __init__(
         self,
         query_name: str,
-        params: list[dict],
+        params: list[dict[str, str]],
         last_values: dict[str, str] | None = None,
         description: str = "",
     ) -> None: