Allow running tests with geltest

`geltest` [1] is `edb test` extracted out of Gel server codebase and
generalized to run any `unittest`-based suite.

Notable changes here:

1. `_testbase` moved to `_internal._testbase` and broken down along
   major case types (base, models, third-party ORM);

2. Test cases that involve model generation now reuse `std` reflection
   for better `mypy` cache utilization.  Speaking of the latter,
   `mypy` now uses sqlite cache, which is notably faster on my machines;

3. Test models are now reflected into (.gitignored) `tests/models` and
   relative imports in tests now work consistently (so instead of
   `from models.orm import Foo` write `from .models.orm import Foo` and
   have your editor LSP pick that up.  This obviates the need to run
   `tools/gen_models.py` (which I will remove in a subsequent commit).

Author: elprans

gel/_internal/_dirhash.py

@@ -0,0 +1,96 @@
+# SPDX-PackageName: gel-python
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright Gel Data Inc. and the contributors.
+
+"""Directory hashing utilities.
+
+This module provides functionality to compute hashes of directory trees based
+on file contents. It's primarily used for generating content-based hashes that
+can detect changes in directory structures and file contents across multiple
+directories with specific file extensions.
+
+The hashing is deterministic and uses SHA-1 for performance, making it
+suitable for use cases where speed is more important than cryptographic
+security (e.g., build system cache invalidation).
+"""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+import hashlib
+import os
+import pathlib
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+
+def dirhash(
+    dirs: Iterable[tuple[str, str]],
+    *,
+    extra_files: Iterable[os.PathLike[str]] | None = None,
+    extra_data: bytes | None = None,
+) -> bytes:
+    """Compute a hash digest of directory contents and additional data.
+
+    This function recursively scans directories for files matching specific
+    extensions and computes a SHA-1 hash of their combined contents. The
+    hash includes file contents from matching files in the specified
+    directories, optional extra files, and optional extra data.
+
+    Args:
+        dirs: An iterable of (directory_path, file_extension) tuples.
+            Each tuple specifies a directory to scan and the file extension
+            to filter for (e.g., ('.py', '.txt')). Only files ending with
+            the specified extension will be included in the hash.
+        extra_files: Optional iterable of additional file paths to include
+            in the hash computation. These files are included regardless
+            of their extension or location.
+        extra_data: Optional bytes to include in the hash computation.
+            This can be used to incorporate additional context or metadata
+            into the hash.
+
+    Returns:
+        The SHA-1 digest as bytes representing the combined hash of all
+        included file contents and extra data.
+
+    Raises:
+        OSError: If any of the specified directories or files cannot be
+            accessed or read.
+        FileNotFoundError: If any of the specified paths don't exist.
+
+    Note:
+        - Files are processed in sorted order by their resolved absolute
+          paths to ensure deterministic hash computation.
+        - The function uses SHA-1 for performance reasons, not cryptographic
+          security.
+        - Symbolic links are resolved to their targets before hashing.
+    """
+
+    def hash_dir(dirname: str, ext: str, paths: list[pathlib.Path]) -> None:
+        with os.scandir(dirname) as it:
+            for entry in it:
+                if entry.is_file() and entry.name.endswith(ext):
+                    paths.append(pathlib.Path(entry.path).resolve(strict=True))
+                elif entry.is_dir():
+                    hash_dir(entry.path, ext, paths)
+
+    paths: list[pathlib.Path] = []
+    for dirname, ext in dirs:
+        hash_dir(dirname, ext, paths)
+
+    if extra_files:
+        paths.extend(
+            pathlib.Path(extra_file).resolve(strict=True)
+            for extra_file in extra_files
+        )
+
+    h = hashlib.sha1()  # noqa: S324 # sha1 is the fastest one
+
+    for path in sorted(paths):
+        h.update(path.read_bytes())
+
+    if extra_data is not None:
+        h.update(extra_data)
+
+    return h.digest()

gel/_internal/_import_extras.py

@@ -0,0 +1,37 @@
+# SPDX-PackageName: gel-python
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright Gel Data Inc. and the contributors.
+
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+import contextlib
+import importlib
+import os
+import sys
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+
+def _set_sys_path(entries: list[str]) -> None:
+    if sys.path is None:
+        # Might happen at shutdown
+        return
+    sys.path[:] = entries
+    importlib.invalidate_caches()
+
+
+@contextlib.contextmanager
+def sys_path(*paths: os.PathLike[str] | str) -> Iterator[None]:
+    """Modify sys.path by temporarily placing the given entry in front"""
+    orig_sys_path = sys.path[:]
+    entries = [os.fspath(path) for path in paths]
+    paths_set = {*entries}
+    _set_sys_path(
+        [*entries, *(p for p in orig_sys_path if p not in paths_set)]
+    )
+    try:
+        yield
+    finally:
+        _set_sys_path(orig_sys_path)

gel/_internal/_testbase/__init__.py

@@ -0,0 +1,31 @@
+# SPDX-PackageName: gel-python
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright Gel Data Inc. and the contributors.
+
+
+from ._base import (
+    AsyncQueryTestCase,
+    BranchTestCase,
+    SyncQueryTestCase,
+    TestAsyncIOClient,
+    TestCase,
+    TestClient,
+    UI,
+    gen_lock_key,
+    silence_asyncio_long_exec_warning,
+    xfail,
+)
+
+
+__all__ = (
+    "UI",
+    "AsyncQueryTestCase",
+    "BranchTestCase",
+    "SyncQueryTestCase",
+    "TestAsyncIOClient",
+    "TestCase",
+    "TestClient",
+    "gen_lock_key",
+    "silence_asyncio_long_exec_warning",
+    "xfail",
+)