fleet-python 0.2.43__py3-none-any.whl → 0.2.44__py3-none-any.whl

fleet/resources/sqlite.py

@@ -1,4 +1,4 @@
-from typing import Any, List, Optional
+from typing import Any, List, Optional, Dict, Tuple
 from ..instance.models import Resource as ResourceModel
 from ..instance.models import DescribeResponse, QueryRequest, QueryResponse
 from .base import Resource
@@ -25,12 +25,12 @@ from fleet.verifiers.db import (
 class SyncDatabaseSnapshot:
     """Async database snapshot that fetches data through API and stores locally for diffing."""
 
-    def __init__(self, resource: "SQLiteResource", name: str | None = None):
+    def __init__(self, resource: "SQLiteResource", name: Optional[str] = None):
         self.resource = resource
         self.name = name or f"snapshot_{datetime.utcnow().isoformat()}"
         self.created_at = datetime.utcnow()
-        self._data: dict[str, list[dict[str, Any]]] = {}
-        self._schemas: dict[str, list[str]] = {}
+        self._data: Dict[str, List[Dict[str, Any]]] = {}
+        self._schemas: Dict[str, List[str]] = {}
         self._fetched = False
 
     def _ensure_fetched(self):
@@ -69,7 +69,7 @@ class SyncDatabaseSnapshot:
 
         self._fetched = True
 
-    def tables(self) -> list[str]:
+    def tables(self) -> List[str]:
         """Get list of all tables in the snapshot."""
         self._ensure_fetched()
         return list(self._data.keys())
@@ -81,7 +81,7 @@ class SyncDatabaseSnapshot:
     def diff(
         self,
         other: "SyncDatabaseSnapshot",
-        ignore_config: IgnoreConfig | None = None,
+        ignore_config: Optional[IgnoreConfig] = None,
     ) -> "SyncSnapshotDiff":
         """Compare this snapshot with another."""
         self._ensure_fetched()
@@ -95,13 +95,13 @@ class SyncSnapshotQueryBuilder:
     def __init__(self, snapshot: SyncDatabaseSnapshot, table: str):
         self._snapshot = snapshot
         self._table = table
-        self._select_cols: list[str] = ["*"]
-        self._conditions: list[tuple[str, str, Any]] = []
-        self._limit: int | None = None
-        self._order_by: str | None = None
+        self._select_cols: List[str] = ["*"]
+        self._conditions: List[Tuple[str, str, Any]] = []
+        self._limit: Optional[int] = None
+        self._order_by: Optional[str] = None
         self._order_desc: bool = False
 
-    def _get_data(self) -> list[dict[str, Any]]:
+    def _get_data(self) -> List[Dict[str, Any]]:
         """Get table data from snapshot."""
         self._snapshot._ensure_fetched()
         return self._snapshot._data.get(self._table, [])
@@ -122,11 +122,11 @@ class SyncSnapshotQueryBuilder:
         qb._order_desc = desc
         return qb
 
-    def first(self) -> dict[str, Any] | None:
+    def first(self) -> Optional[Dict[str, Any]]:
         rows = self.all()
         return rows[0] if rows else None
 
-    def all(self) -> list[dict[str, Any]]:
+    def all(self) -> List[Dict[str, Any]]:
         data = self._get_data()
 
         # Apply filters
@@ -185,14 +185,14 @@ class SyncSnapshotDiff:
         self,
         before: SyncDatabaseSnapshot,
         after: SyncDatabaseSnapshot,
-        ignore_config: IgnoreConfig | None = None,
+        ignore_config: Optional[IgnoreConfig] = None,
     ):
         self.before = before
         self.after = after
         self.ignore_config = ignore_config or IgnoreConfig()
-        self._cached: dict[str, Any] | None = None
+        self._cached: Optional[Dict[str, Any]] = None
 
-    def _get_primary_key_columns(self, table: str) -> list[str]:
+    def _get_primary_key_columns(self, table: str) -> List[str]:
         """Get primary key columns for a table."""
         # Try to get from schema
         schema_response = self.after.resource.query(f"PRAGMA table_info({table})")
@@ -222,7 +222,7 @@ class SyncSnapshotDiff:
             return self._cached
 
         all_tables = set(self.before.tables()) | set(self.after.tables())
-        diff: dict[str, dict[str, Any]] = {}
+        diff: Dict[str, Dict[str, Any]] = {}
 
         for tbl in all_tables:
             if self.ignore_config.should_ignore_table(tbl):
@@ -236,7 +236,7 @@ class SyncSnapshotDiff:
             after_data = self.after._data.get(tbl, [])
 
             # Create indexes by primary key
-            def make_key(row: dict, pk_cols: list[str]) -> Any:
+            def make_key(row: dict, pk_cols: List[str]) -> Any:
                 if len(pk_cols) == 1:
                     return row.get(pk_cols[0])
                 return tuple(row.get(col) for col in pk_cols)
@@ -304,12 +304,12 @@ class SyncSnapshotDiff:
         self._cached = diff
         return diff
 
-    def expect_only(self, allowed_changes: list[dict[str, Any]]):
+    def expect_only(self, allowed_changes: List[Dict[str, Any]]):
         """Ensure only specified changes occurred."""
         diff = self._collect()
 
         def _is_change_allowed(
-            table: str, row_id: Any, field: str | None, after_value: Any
+            table: str, row_id: Any, field: Optional[str], after_value: Any
         ) -> bool:
             """Check if a change is in the allowed list using semantic comparison."""
             for allowed in allowed_changes:
@@ -440,11 +440,11 @@ class SyncQueryBuilder:
     def __init__(self, resource: "SQLiteResource", table: str):
         self._resource = resource
         self._table = table
-        self._select_cols: list[str] = ["*"]
-        self._conditions: list[tuple[str, str, Any]] = []
-        self._joins: list[tuple[str, dict[str, str]]] = []
-        self._limit: int | None = None
-        self._order_by: str | None = None
+        self._select_cols: List[str] = ["*"]
+        self._conditions: List[Tuple[str, str, Any]] = []
+        self._joins: List[Tuple[str, Dict[str, str]]] = []
+        self._limit: Optional[int] = None
+        self._order_by: Optional[str] = None
 
     # Column projection / limiting / ordering
     def select(self, *columns: str) -> "SyncQueryBuilder":
@@ -486,12 +486,12 @@ class SyncQueryBuilder:
     def lte(self, column: str, value: Any) -> "SyncQueryBuilder":
         return self._add_condition(column, "<=", value)
 
-    def in_(self, column: str, values: list[Any]) -> "SyncQueryBuilder":
+    def in_(self, column: str, values: List[Any]) -> "SyncQueryBuilder":
         qb = self._clone()
         qb._conditions.append((column, "IN", tuple(values)))
         return qb
 
-    def not_in(self, column: str, values: list[Any]) -> "SyncQueryBuilder":
+    def not_in(self, column: str, values: List[Any]) -> "SyncQueryBuilder":
         qb = self._clone()
         qb._conditions.append((column, "NOT IN", tuple(values)))
         return qb
@@ -508,16 +508,16 @@ class SyncQueryBuilder:
         return qb
 
     # JOIN
-    def join(self, other_table: str, on: dict[str, str]) -> "SyncQueryBuilder":
+    def join(self, other_table: str, on: Dict[str, str]) -> "SyncQueryBuilder":
         qb = self._clone()
         qb._joins.append((other_table, on))
         return qb
 
     # Compile to SQL
-    def _compile(self) -> tuple[str, list[Any]]:
+    def _compile(self) -> Tuple[str, List[Any]]:
         cols = ", ".join(self._select_cols)
         sql = [f"SELECT {cols} FROM {self._table}"]
-        params: list[Any] = []
+        params: List[Any] = []
 
         # Joins
         for tbl, onmap in self._joins:
@@ -558,11 +558,11 @@ class SyncQueryBuilder:
             return row_dict.get("__cnt__", 0)
         return 0
 
-    def first(self) -> dict[str, Any] | None:
+    def first(self) -> Optional[Dict[str, Any]]:
         rows = self.limit(1).all()
         return rows[0] if rows else None
 
-    def all(self) -> list[dict[str, Any]]:
+    def all(self) -> List[Dict[str, Any]]:
         sql, params = self._compile()
         response = self._resource.query(sql, params)
         if not response.rows:
@@ -651,9 +651,7 @@ class SQLiteResource(Resource):
         )
         return DescribeResponse(**response.json())
 
-    def query(
-        self, query: str, args: Optional[List[Any]] = None
-    ) -> QueryResponse:
+    def query(self, query: str, args: Optional[List[Any]] = None) -> QueryResponse:
         return self._query(query, args, read_only=True)
 
     def exec(self, query: str, args: Optional[List[Any]] = None) -> QueryResponse:
@@ -674,7 +672,7 @@ class SQLiteResource(Resource):
         """Create a query builder for the specified table."""
         return SyncQueryBuilder(self, table_name)
 
-    def snapshot(self, name: str | None = None) -> SyncDatabaseSnapshot:
+    def snapshot(self, name: Optional[str] = None) -> SyncDatabaseSnapshot:
         """Create a snapshot of the current database state."""
         snapshot = SyncDatabaseSnapshot(self, name)
         snapshot._ensure_fetched()
@@ -683,7 +681,7 @@ class SQLiteResource(Resource):
     def diff(
         self,
         other: "SQLiteResource",
-        ignore_config: IgnoreConfig | None = None,
+        ignore_config: Optional[IgnoreConfig] = None,
     ) -> SyncSnapshotDiff:
         """Compare this database with another AsyncSQLiteResource.
 
@@ -695,12 +693,8 @@ class SQLiteResource(Resource):
             AsyncSnapshotDiff: Object containing the differences between the two databases
         """
         # Create snapshots of both databases
-        before_snapshot = self.snapshot(
-            name=f"before_{datetime.utcnow().isoformat()}"
-        )
-        after_snapshot = other.snapshot(
-            name=f"after_{datetime.utcnow().isoformat()}"
-        )
+        before_snapshot = self.snapshot(name=f"before_{datetime.utcnow().isoformat()}")
+        after_snapshot = other.snapshot(name=f"after_{datetime.utcnow().isoformat()}")
 
         # Return the diff between the snapshots
         return before_snapshot.diff(after_snapshot, ignore_config)

fleet/tasks.py

@@ -47,7 +47,7 @@ class Task(BaseModel):
     @property
     def env_key(self) -> str:
         """Get the environment key combining env_id and version."""
-        if self.version and self.version != "None":
+        if self.version and self.version != "None" and ":" not in self.env_id:
             return f"{self.env_id}:{self.version}"
         return self.env_id
 
@@ -70,17 +70,13 @@ class Task(BaseModel):
             import inspect
 
             # Check if verifier has remote method (for decorated verifiers)
-            if hasattr(self.verifier, "remote"):
-                result = self.verifier.remote(env, *args, **kwargs)
-            else:
-                # For verifiers created from string, call directly
-                result = self.verifier(env, *args, **kwargs)
+            result = self.verifier.remote(env, *args, **kwargs)
 
             # If the result is a coroutine, we need to run it
             if inspect.iscoroutine(result):
                 # Check if we're already in an event loop
                 try:
-                    loop = asyncio.get_running_loop()
+                    asyncio.get_running_loop()
                     # We're in an async context, can't use asyncio.run()
                     raise RuntimeError(
                         "Cannot run async verifier in sync mode while event loop is running. "
@@ -141,7 +137,7 @@ def verifier_from_string(
     """
     try:
         import inspect
-        from .verifiers import verifier, SyncVerifierFunction
+        from .verifiers import SyncVerifierFunction
         from .verifiers.code import TASK_SUCCESSFUL_SCORE, TASK_FAILED_SCORE
         from .verifiers.db import IgnoreConfig
 
@@ -172,36 +168,13 @@ def verifier_from_string(
         if func_obj is None:
             raise ValueError("No function found in verifier code")
 
-        # Create a wrapper function that provides the necessary globals
-        def wrapped_verifier(env, *args, **kwargs):
-            # Set up globals for the function execution
-            func_globals = (
-                func_obj.__globals__.copy() if hasattr(func_obj, "__globals__") else {}
-            )
-            func_globals.update(
-                {
-                    "TASK_SUCCESSFUL_SCORE": TASK_SUCCESSFUL_SCORE,
-                    "TASK_FAILED_SCORE": TASK_FAILED_SCORE,
-                    "IgnoreConfig": IgnoreConfig,
-                }
-            )
-
-            # Create a new function with the updated globals
-            import types
-
-            new_func = types.FunctionType(
-                func_obj.__code__,
-                func_globals,
-                func_obj.__name__,
-                func_obj.__defaults__,
-                func_obj.__closure__,
-            )
-
-            return new_func(env, *args, **kwargs)
-
-        # Create an AsyncVerifierFunction instance with the wrapped function
+        # Create an SyncVerifierFunction instance with raw code
         verifier_instance = SyncVerifierFunction(
-            wrapped_verifier, verifier_key, verifier_id
+            func=func_obj,
+            key=verifier_key,
+            verifier_id=verifier_id,
+            sha256=sha256,
+            raw_code=verifier_func,
         )
 
         # Store additional metadata
@@ -214,6 +187,18 @@ def verifier_from_string(
         raise ValueError(f"Failed to create verifier from string: {e}")
 
 
+def load_tasks_from_file(filename: str) -> List[Task]:
+    """Load tasks from a JSON file.
+
+    Example:
+        tasks = fleet.load_tasks_from_file("my_tasks.json")
+    """
+    from .global_client import get_client
+
+    client = get_client()
+    return client.load_tasks_from_file(filename)
+
+
 def load_tasks(
     env_key: Optional[str] = None,
     keys: Optional[List[str]] = None,

fleet/verifiers/__init__.py

@@ -2,7 +2,7 @@
 
 from .db import DatabaseSnapshot, IgnoreConfig, SnapshotDiff
 from .code import TASK_SUCCESSFUL_SCORE, TASK_FAILED_SCORE
-from .decorator import (
+from .verifier import (
     verifier,
     SyncVerifierFunction,
 )

fleet/verifiers/db.py

@@ -22,9 +22,11 @@ import json
 #  Low‑level helpers
 ################################################################################
 
-SQLValue = str | int | float | None
-Condition = tuple[str, str, SQLValue]  # (column, op, value)
-JoinSpec = tuple[str, dict[str, str]]  # (table, on mapping)
+from typing import Union, Tuple, Dict, List, Optional, Any, Set
+
+SQLValue = Union[str, int, float, None]
+Condition = Tuple[str, str, SQLValue]  # (column, op, value)
+JoinSpec = Tuple[str, Dict[str, str]]  # (table, on mapping)
 
 
 def _is_json_string(value: Any) -> bool:
@@ -98,13 +100,13 @@ class QueryBuilder:
     def __init__(self, snapshot: "DatabaseSnapshot", table: str):  # noqa: UP037
         self._snapshot = snapshot
         self._table = table
-        self._select_cols: list[str] = ["*"]
-        self._conditions: list[Condition] = []
-        self._joins: list[JoinSpec] = []
-        self._limit: int | None = None
-        self._order_by: str | None = None
+        self._select_cols: List[str] = ["*"]
+        self._conditions: List[Condition] = []
+        self._joins: List[JoinSpec] = []
+        self._limit: Optional[int] = None
+        self._order_by: Optional[str] = None
         # Cache for idempotent executions
-        self._cached_rows: list[dict[str, Any]] | None = None
+        self._cached_rows: Optional[List[Dict[str, Any]]] = None
 
     # ---------------------------------------------------------------------
     #  Column projection / limiting / ordering
@@ -150,12 +152,12 @@ class QueryBuilder:
     def lte(self, column: str, value: SQLValue) -> "QueryBuilder":  # noqa: UP037
         return self._add_condition(column, "<=", value)
 
-    def in_(self, column: str, values: list[SQLValue]) -> "QueryBuilder":  # noqa: UP037
+    def in_(self, column: str, values: List[SQLValue]) -> "QueryBuilder":  # noqa: UP037
         qb = self._clone()
         qb._conditions.append((column, "IN", tuple(values)))
         return qb
 
-    def not_in(self, column: str, values: list[SQLValue]) -> "QueryBuilder":  # noqa: UP037
+    def not_in(self, column: str, values: List[SQLValue]) -> "QueryBuilder":  # noqa: UP037
         qb = self._clone()
         qb._conditions.append((column, "NOT IN", tuple(values)))
         return qb
@@ -174,7 +176,7 @@ class QueryBuilder:
     # ---------------------------------------------------------------------
     #  JOIN (simple inner join)
     # ---------------------------------------------------------------------
-    def join(self, other_table: str, on: dict[str, str]) -> "QueryBuilder":  # noqa: UP037
+    def join(self, other_table: str, on: Dict[str, str]) -> "QueryBuilder":  # noqa: UP037
         """`on` expects {local_col: remote_col}."""
         qb = self._clone()
         qb._joins.append((other_table, on))
@@ -183,10 +185,10 @@ class QueryBuilder:
     # ---------------------------------------------------------------------
     #  Execution helpers
     # ---------------------------------------------------------------------
-    def _compile(self) -> tuple[str, list[Any]]:
+    def _compile(self) -> Tuple[str, List[Any]]:
         cols = ", ".join(self._select_cols)
         sql = [f"SELECT {cols} FROM {self._table}"]
-        params: list[Any] = []
+        params: List[Any] = []
 
         # Joins -------------------------------------------------------------
         for tbl, onmap in self._joins:
@@ -224,7 +226,7 @@ class QueryBuilder:
 
         return " ".join(sql), params
 
-    def _execute(self) -> list[dict[str, Any]]:
+    def _execute(self) -> List[Dict[str, Any]]:
         if self._cached_rows is not None:
             return self._cached_rows
 
@@ -255,10 +257,10 @@ class QueryBuilder:
         conn.close()
         return _CountResult(val)
 
-    def first(self) -> dict[str, Any] | None:
+    def first(self) -> Optional[Dict[str, Any]]:
         return self.limit(1)._execute()[0] if self.limit(1)._execute() else None
 
-    def all(self) -> list[dict[str, Any]]:
+    def all(self) -> List[Dict[str, Any]]:
         return self._execute()
 
     # Assertions -----------------------------------------------------------
@@ -357,9 +359,9 @@ class IgnoreConfig:
 
     def __init__(
         self,
-        tables: set[str] | None = None,
-        fields: set[str] | None = None,
-        table_fields: dict[str, set[str]] | None = None,
+        tables: Optional[Set[str]] = None,
+        fields: Optional[Set[str]] = None,
+        table_fields: Optional[Dict[str, Set[str]]] = None,
     ):
         """
         Args:
@@ -386,7 +388,7 @@ class IgnoreConfig:
         return False
 
 
-def _format_row_for_error(row: dict[str, Any], max_fields: int = 10) -> str:
+def _format_row_for_error(row: Dict[str, Any], max_fields: int = 10) -> str:
     """Format a row dictionary for error messages with truncation if needed."""
     if not row:
         return "{empty row}"
@@ -402,7 +404,7 @@ def _format_row_for_error(row: dict[str, Any], max_fields: int = 10) -> str:
         return "{" + ", ".join(shown_items) + f", ... +{remaining} more fields" + "}"
 
 
-def _get_row_identifier(row: dict[str, Any]) -> str:
+def _get_row_identifier(row: Dict[str, Any]) -> str:
     """Extract a meaningful identifier from a row for error messages."""
     # Try common ID fields first
     for id_field in ["id", "pk", "primary_key", "key"]:
@@ -429,7 +431,7 @@ class SnapshotDiff:
         self,
         before: DatabaseSnapshot,
         after: DatabaseSnapshot,
-        ignore_config: IgnoreConfig | None = None,
+        ignore_config: Optional[IgnoreConfig] = None,
     ):
         from .sql_differ import SQLiteDiffer  # local import to avoid circularity
 
@@ -437,14 +439,14 @@ class SnapshotDiff:
         self.after = after
         self.ignore_config = ignore_config or IgnoreConfig()
         self._differ = SQLiteDiffer(before.db_path, after.db_path)
-        self._cached: dict[str, Any] | None = None
+        self._cached: Optional[Dict[str, Any]] = None
 
     # ------------------------------------------------------------------
     def _collect(self):
         if self._cached is not None:
             return self._cached
         all_tables = set(self.before.tables()) | set(self.after.tables())
-        diff: dict[str, dict[str, Any]] = {}
+        diff: Dict[str, Dict[str, Any]] = {}
         for tbl in all_tables:
             if self.ignore_config.should_ignore_table(tbl):
                 continue
@@ -453,12 +455,12 @@ class SnapshotDiff:
         return diff
 
     # ------------------------------------------------------------------
-    def expect_only(self, allowed_changes: list[dict[str, Any]]):
+    def expect_only(self, allowed_changes: List[Dict[str, Any]]):
         """Allowed changes is a list of {table, pk, field, after} (before optional)."""
         diff = self._collect()
 
         def _is_change_allowed(
-            table: str, row_id: str, field: str | None, after_value: Any
+            table: str, row_id: str, field: Optional[str], after_value: Any
         ) -> bool:
             """Check if a change is in the allowed list using semantic comparison."""
             for allowed in allowed_changes:
@@ -596,7 +598,10 @@ class SnapshotDiff:
         return self
 
     def expect(
-        self, *, allow: list[dict[str, Any]] = None, forbid: list[dict[str, Any]] = None
+        self,
+        *,
+        allow: Optional[List[Dict[str, Any]]] = None,
+        forbid: Optional[List[Dict[str, Any]]] = None,
     ):
         """More granular: allow / forbid per‑table and per‑field."""
         allow = allow or []
@@ -629,7 +634,7 @@ class SnapshotDiff:
 class DatabaseSnapshot:
     """Represents a snapshot of an SQLite DB with DSL entrypoints."""
 
-    def __init__(self, db_path: str, *, name: str | None = None):
+    def __init__(self, db_path: str, *, name: Optional[str] = None):
         self.db_path = db_path
         self.name = name or f"snapshot_{datetime.utcnow().isoformat()}"
         self.created_at = datetime.utcnow()
@@ -639,7 +644,7 @@ class DatabaseSnapshot:
         return QueryBuilder(self, table)
 
     # Metadata -------------------------------------------------------------
-    def tables(self) -> list[str]:
+    def tables(self) -> List[str]:
         conn = sqlite3.connect(self.db_path)
         cur = conn.cursor()
         cur.execute(
@@ -654,7 +659,7 @@ class DatabaseSnapshot:
     def diff(
         self,
         other: "DatabaseSnapshot",  # noqa: UP037
-        ignore_config: IgnoreConfig | None = None,
+        ignore_config: Optional[IgnoreConfig] = None,
     ) -> SnapshotDiff:
         return SnapshotDiff(self, other, ignore_config)
 
@@ -663,7 +668,7 @@ class DatabaseSnapshot:
     ############################################################################
 
     def expect_row(
-        self, table: str, where: dict[str, SQLValue], expect: dict[str, SQLValue]
+        self, table: str, where: Dict[str, SQLValue], expect: Dict[str, SQLValue]
     ):
         qb = self.table(table)
         for k, v in where.items():
@@ -676,10 +681,10 @@ class DatabaseSnapshot:
     def expect_rows(
         self,
         table: str,
-        where: dict[str, SQLValue],
+        where: Dict[str, SQLValue],
         *,
-        count: int | None = None,
-        contains: list[dict[str, SQLValue]] | None = None,
+        count: Optional[int] = None,
+        contains: Optional[List[Dict[str, SQLValue]]] = None,
     ):
         qb = self.table(table)
         for k, v in where.items():
@@ -694,7 +699,7 @@ class DatabaseSnapshot:
                     raise AssertionError(f"Expected a row matching {cond} in {table}")
         return self
 
-    def expect_absent_row(self, table: str, where: dict[str, SQLValue]):
+    def expect_absent_row(self, table: str, where: Dict[str, SQLValue]):
         qb = self.table(table)
         for k, v in where.items():
             qb = qb.eq(k, v)

fleet/verifiers/parse.py

@@ -1,7 +1,10 @@
 import re
 
 
-def extract_function_name(function_code: str) -> str | None:
+from typing import Optional
+
+
+def extract_function_name(function_code: str) -> Optional[str]:
     """
     Extract function name from Python function code.
 

fleet/verifiers/sql_differ.py

@@ -1,5 +1,5 @@
 import sqlite3
-from typing import Any
+from typing import Any, Optional, List, Dict, Tuple
 
 
 class SQLiteDiffer:
@@ -7,7 +7,7 @@ class SQLiteDiffer:
         self.before_db = before_db
         self.after_db = after_db
 
-    def get_table_schema(self, db_path: str, table_name: str) -> list[str]:
+    def get_table_schema(self, db_path: str, table_name: str) -> List[str]:
         """Get column names for a table"""
         conn = sqlite3.connect(db_path)
         cursor = conn.cursor()
@@ -16,7 +16,7 @@ class SQLiteDiffer:
         conn.close()
         return columns
 
-    def get_primary_key_columns(self, db_path: str, table_name: str) -> list[str]:
+    def get_primary_key_columns(self, db_path: str, table_name: str) -> List[str]:
         """Get all primary key columns for a table, ordered by their position"""
         conn = sqlite3.connect(db_path)
         cursor = conn.cursor()
@@ -34,7 +34,7 @@ class SQLiteDiffer:
         pk_columns.sort(key=lambda x: x[0])
         return [col[1] for col in pk_columns]
 
-    def get_all_tables(self, db_path: str) -> list[str]:
+    def get_all_tables(self, db_path: str) -> List[str]:
         """Get all table names from database"""
         conn = sqlite3.connect(db_path)
         cursor = conn.cursor()
@@ -49,8 +49,8 @@ class SQLiteDiffer:
         self,
         db_path: str,
         table_name: str,
-        primary_key_columns: list[str] | None = None,
-    ) -> tuple[dict[Any, dict], list[str]]:
+        primary_key_columns: Optional[List[str]] = None,
+    ) -> Tuple[Dict[Any, dict], List[str]]:
         """Get table data indexed by primary key (single column or composite)"""
         conn = sqlite3.connect(db_path)
         conn.row_factory = sqlite3.Row
@@ -97,7 +97,7 @@ class SQLiteDiffer:
         conn.close()
         return data, primary_key_columns
 
-    def compare_rows(self, before_row: dict, after_row: dict) -> dict[str, dict]:
+    def compare_rows(self, before_row: dict, after_row: dict) -> Dict[str, dict]:
         """Compare two rows field by field"""
         changes = {}
 
@@ -113,7 +113,7 @@ class SQLiteDiffer:
         return changes
 
     def diff_table(
-        self, table_name: str, primary_key_columns: list[str] | None = None
+        self, table_name: str, primary_key_columns: Optional[List[str]] = None
     ) -> dict:
         """Create comprehensive diff of a table"""
         before_data, detected_pk = self.get_table_data(