xorq-labs
diff --git a/‎.github/workflows/ci-test-install.yaml‎
Lines changed: 2 additions & 0 deletions b/‎.github/workflows/ci-test-install.yaml‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎.github/workflows/ci-test-library.yml‎
Lines changed: 4 additions & 0 deletions b/‎.github/workflows/ci-test-library.yml‎
Lines changed: 4 additions & 0 deletions
diff --git a/‎.github/workflows/ci-test.yml‎
Lines changed: 13 additions & 0 deletions b/‎.github/workflows/ci-test.yml‎
Lines changed: 13 additions & 0 deletions
diff --git a/‎pyproject.toml‎
Lines changed: 17 additions & 0 deletions b/‎pyproject.toml‎
Lines changed: 17 additions & 0 deletions
diff --git a/‎python/xorq/tests/bare_install_modules.txt‎
Lines changed: 13 additions & 0 deletions b/‎python/xorq/tests/bare_install_modules.txt‎
Lines changed: 13 additions & 0 deletions
diff --git a/‎python/xorq/tests/check_bare_imports.py‎
Lines changed: 25 additions & 0 deletions b/‎python/xorq/tests/check_bare_imports.py‎
Lines changed: 25 additions & 0 deletions
diff --git a/‎python/xorq/tests/test_bare_install.py‎
Lines changed: 124 additions & 0 deletions b/‎python/xorq/tests/test_bare_install.py‎
Lines changed: 124 additions & 0 deletions
@@ -111,6 +111,7 @@ jobs:
           mkdir -p test-wheel && cd test-wheel
           python -c "import pathlib; print(f'Current working directory: {pathlib.Path.cwd()}')"
           python -c "import xorq; print(f'Successfully imported {xorq.__name__} version {xorq.__version__}')"
+          python "$GITHUB_WORKSPACE/python/xorq/tests/check_bare_imports.py"
           cd ..
           deactivate
           
@@ -125,6 +126,7 @@ jobs:
           python -m pip install --upgrade pip
           python -m pip install dist/*.tar.gz
           python -c "import xorq; print(f'Successfully installed xorq {xorq.__version__} from source distribution')"
+          python "$GITHUB_WORKSPACE/python/xorq/tests/check_bare_imports.py"
           deactivate
 
       - name: Test extras installation from wheel
 
@@ -53,11 +53,15 @@ jobs:
       - name: test wheel
         run: | 
           uv run --isolated --no-project -p ${{ matrix.python-version }} --with dist/*.whl -- python -c "import xorq; print(f'Successfully imported {xorq.__name__} version {xorq.__version__}')"
+          # Kept out of the pytest run below, which supplies `packaging` itself.
+          uv run --isolated --no-project -p ${{ matrix.python-version }} --with dist/*.whl -- python python/xorq/tests/check_bare_imports.py
           uv run --isolated --no-project -p ${{ matrix.python-version }} --with dist/*.whl --with pytest --with pytest-cov -- pytest --import-mode=importlib --cov --cov-report=xml -m "library or xorq"
 
       - name: test source distribution
         run: | 
           uv run --isolated --no-project -p ${{ matrix.python-version }} --with dist/*.tar.gz -- python -c "import xorq; print(f'Successfully imported {xorq.__name__} version {xorq.__version__}')"
+          # Kept out of the pytest run below, which supplies `packaging` itself.
+          uv run --isolated --no-project -p ${{ matrix.python-version }} --with dist/*.tar.gz -- python python/xorq/tests/check_bare_imports.py
           uv run --isolated --no-project -p ${{ matrix.python-version }} --with dist/*.tar.gz --with pytest --with pytest-cov -- pytest --import-mode=importlib --cov --cov-report=xml -m "library or xorq"
 
       - name: Upload coverage reports to Codecov
 
@@ -157,6 +157,19 @@ jobs:
           POSTGRES_PORT: 5432
           POSTGRES_DATABASE: ibis_testing
 
+      # Builds its own wheel and isolated env, so the dev/test groups installed
+      # here cannot mask a missing declaration.
+      - name: bare-install CLI round trip
+        if: matrix.backend.name == 'core'
+        timeout-minutes: 10
+        run: >
+          uv run --no-sync pytest
+          --import-mode=importlib
+          python/xorq/tests/test_bare_install.py
+          -m bare_install
+          -v --durations=20
+        working-directory: ${{ github.workspace }}
+
       - name: Upload coverage reports to Codecov
         uses: codecov/codecov-action@v5.5.4
         with:
 
@@ -33,6 +33,22 @@ dependencies = [
     "pandas>=2.2.3,<3 ; python_version >= '3.10' and python_version < '4.0'",
     "atpublic>=5.1",
     "parsy>=2",
+    "packaging>=22",
+    # Per-interpreter floors so `--resolution lowest-direct` gets a wheel and not
+    # a source build.  Each is the first release with wheels for that Python,
+    # except numpy on 3.10, where 1.22.4 is pandas' own floor (1.21.3 was the
+    # first with cp310 wheels).  The `>= '3.13'` rows are open upward and only
+    # safe while requires-python caps at <3.14; raising that cap needs a new row
+    # per interpreter, or lowest-direct picks a release with no wheel for it.
+    "numpy>=1.22.4; python_version < '3.11'",
+    "numpy>=1.23.2; python_version == '3.11'",
+    "numpy>=1.26.0; python_version == '3.12'",
+    "numpy>=2.1.0; python_version >= '3.13'",
+    "xxhash>=3.0; python_version < '3.11'",
+    "xxhash>=3.2; python_version == '3.11'",
+    "xxhash>=3.4; python_version == '3.12'",
+    "xxhash>=3.5; python_version >= '3.13'",
+    "pygments>=2.13",
     "python-dateutil>=2.8.2",
     "pytz>=2022.7",
     "sqlglot>=23.4,!=26.32.0,<28.7.0",
@@ -324,6 +340,7 @@ markers = [
     "databricks: Databricks tests",
     "xorq_datafusion: xorq DataFusion backend tests",
     "uv_export: tests that call uv export against the project lockfile",
+    "bare_install: tests that build the wheel and drive the CLI against declared dependencies only",
     "bigquery: BigQuery tests",
 ]
 consider_namespace_packages = true
 
@@ -0,0 +1,13 @@
+# Modules that must import with only [project].dependencies installed.
+# Read by python/xorq/tests/test_bare_install.py and by the bare-environment
+# smoke steps in ci-test-library.yml and ci-test-install.yaml.
+xorq
+xorq.api
+xorq.cli
+xorq.catalog.cli
+xorq.catalog.tui
+xorq.ibis_yaml.compiler
+xorq.ibis_yaml.packager
+xorq.ibis_yaml.pep723
+xorq.backends.pandas.executor
+xorq.common.utils.dasher
@@ -0,0 +1,25 @@
+"""Import every module in bare_install_modules.txt; exit non-zero on the first failure.
+
+Run inside an environment holding only [project].dependencies, so it must not
+import anything beyond the standard library and xorq itself.
+"""
+
+import importlib
+import pathlib
+import sys
+
+
+def main():
+    listing = pathlib.Path(__file__).with_name("bare_install_modules.txt")
+    lines = (line.strip() for line in listing.read_text().splitlines())
+    names = [line for line in lines if line and not line.startswith("#")]
+    if not names:
+        sys.exit(f"no modules listed in {listing}")
+    for name in names:
+        importlib.import_module(name)
+        print(f"ok {name}")
+    print(f"imported {len(names)} modules with declared dependencies only")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,124 @@
+"""Drive the CLI against an environment holding only the declared dependencies.
+
+Covers what the static scan in ``test_declared_dependencies`` cannot: imports
+deferred inside a function body, which is most of the packager imports in
+``xorq/cli.py``.
+"""
+
+import sys
+
+import pytest
+
+from xorq.common.utils.process_utils import subprocess_run
+
+
+pytestmark = pytest.mark.bare_install
+
+
+PYTHON_VERSION = f"{sys.version_info.major}.{sys.version_info.minor}"
+
+EXPR_PY = """
+import xorq.api as xo
+
+t = xo.memtable({"a": [1, 2, 3]})
+expr = t.filter(t.a > 1)
+"""
+
+BARE_IMPORT_CHECK = "python/xorq/tests/check_bare_imports.py"
+MODULE_LISTING = "python/xorq/tests/bare_install_modules.txt"
+
+
+def run_bare(wheel, args, cwd):
+    return subprocess_run(
+        (
+            "uv",
+            "tool",
+            "run",
+            "--isolated",
+            "--python",
+            PYTHON_VERSION,
+            "--with",
+            str(wheel),
+            *args,
+        ),
+        cwd=cwd,
+        text=True,
+    )
+
+
+@pytest.fixture(scope="module")
+def wheel(root_dir, tmp_path_factory):
+    dist = tmp_path_factory.mktemp("dist")
+    returncode, stdout, stderr = subprocess_run(
+        ("uv", "build", "--wheel", "-o", str(dist)),
+        cwd=root_dir,
+        text=True,
+    )
+    assert returncode == 0, stderr
+    (wheel,) = dist.glob("*.whl")
+    return wheel
+
+
+def test_core_modules_import(wheel, root_dir):
+    """The static scan cannot see function-level imports; this can."""
+    returncode, stdout, stderr = run_bare(
+        wheel, ("python", BARE_IMPORT_CHECK), cwd=root_dir
+    )
+    assert returncode == 0, stderr
+
+
+def test_module_listing_covers_the_new_declarations(root_dir):
+    """Each declaration needs a module that imports it named in the listing.
+
+    pygments comes from catalog/tui.py, numpy from backends/pandas/executor.py,
+    xxhash from common/utils/dasher.  dasher is reached incidentally through
+    xorq.api today, so name it explicitly: coverage should not depend on
+    xorq.api continuing to import it.
+
+    This exercises those import paths; it does not guard the declarations.
+    Removing numpy, pygments or xxhash from pyproject.toml leaves these tests
+    green, because each still arrives transitively via pandas, rich/textual and
+    xorq-dasher.  test_declared_dependencies is what fails on removal.
+    """
+    listing = root_dir.joinpath(MODULE_LISTING).read_text()
+    for module in (
+        "xorq.catalog.tui",
+        "xorq.backends.pandas.executor",
+        "xorq.common.utils.dasher",
+    ):
+        assert module in listing
+
+
+def test_build_then_run_round_trip(wheel, tmp_path):
+    """`xorq build` succeeded even while `xorq run` was broken, so test both."""
+    tmp_path.joinpath("expr.py").write_text(EXPR_PY)
+
+    returncode, stdout, stderr = run_bare(
+        wheel,
+        # not stdout: OTel's ConsoleSpanExporter flushes there at shutdown, after
+        # the path is printed, whenever OTEL_EXPORTER_CONSOLE_FALLBACK is set.
+        ("xorq", "build", "expr.py", "-e", "expr", "--emit-build-path-to", "path.txt"),
+        cwd=tmp_path,
+    )
+    assert returncode == 0, stderr
+    build_path = tmp_path.joinpath("path.txt").read_text().strip()
+    assert tmp_path.joinpath(build_path).exists()
+
+    returncode, stdout, stderr = run_bare(
+        wheel, ("xorq", "run", build_path), cwd=tmp_path
+    )
+    assert returncode == 0, stderr
+
+
+@pytest.mark.parametrize(
+    "args",
+    (
+        ("xorq", "--help"),
+        ("xorq", "build", "--help"),
+        ("xorq", "run", "--help"),
+        ("xorq", "catalog", "--help"),
+    ),
+)
+def test_help_is_reachable(wheel, tmp_path, args):
+    returncode, stdout, stderr = run_bare(wheel, args, cwd=tmp_path)
+    assert returncode == 0, stderr