duckle 0.5.7__py3-none-win_amd64.whl

duckle/__init__.py

@@ -0,0 +1,40 @@
+"""Duckle: local-first ETL/ELT pipelines that run on DuckDB.
+
+    import duckle
+
+    (duckle.read_csv("orders.csv")
+        .where("amount >= 20")
+        .derive(total="round(amount * 1.2, 2)")
+        .write_parquet("out.parquet")
+        .run())
+
+Python builds the plan; DuckDB moves the rows. Nothing here pulls data into
+the interpreter, and the Python expressions above are compiled to vectorized
+SQL before the run starts.
+"""
+
+from .expr import Expr, col, lit, when  # noqa: F401
+from ._ns import component_ids, describe, root_namespaces  # noqa: F401
+
+# Every component id becomes an attribute path: duckle.src.salesforce(...),
+# duckle.xf.geo.reproject(...), duckle.snk.salesforce.bulk(...).
+globals().update(root_namespaces())
+from .api import (  # noqa: F401
+    DuckleError,
+    Pipeline,
+    from_json,
+    read_csv,
+    read_duckdb,
+    read_json,
+    read_parquet,
+    read_postgres,
+)
+
+__version__ = "0.5.7"
+__all__ = [
+    "Pipeline", "DuckleError", "from_json",
+    "col", "lit", "when", "Expr",
+    "component_ids", "describe",
+    *sorted(__import__("duckle._ns", fromlist=["root_namespaces"]).root_namespaces()),
+    "read_csv", "read_parquet", "read_json", "read_postgres", "read_duckdb",
+]

duckle/__main__.py

@@ -0,0 +1,95 @@
+"""Console entry point: hand off to the bundled duckle-runner binary.
+
+The wheel ships a real compiled executable next to this module. This shim
+exists only so the command lands on PATH as `duckle` rather than under the
+Cargo target name, and so the DuckDB CLI that `duckdb-cli` installs is found
+without the user configuring anything.
+
+On POSIX it execs, replacing this process, so signals, exit codes and stdio
+behave exactly as if the binary had been invoked directly. Windows has no
+exec that preserves the process, so there it subprocesses and forwards the
+return code.
+"""
+
+import os
+import shutil
+import subprocess
+import sys
+
+_BIN_NAME = "duckle-runner.exe" if os.name == "nt" else "duckle-runner"
+
+
+def _binary_path():
+    path = os.path.join(os.path.dirname(os.path.abspath(__file__)), _BIN_NAME)
+    if not os.path.exists(path):
+        sys.stderr.write(
+            "duckle: bundled runner not found at {}\n"
+            "This wheel appears to be built for a different platform.\n"
+            "Report at https://github.com/slothflowlabs/duckle/issues\n".format(path)
+        )
+        raise SystemExit(2)
+    return path
+
+
+def _find_duckdb():
+    """Locate the DuckDB CLI that `duckdb-cli` installed alongside us.
+
+    PATH alone is not enough. `duckle` is frequently invoked by absolute path
+    rather than through an activated environment - CI steps, cron entries,
+    pipx and uvx all do this - and then the venv's scripts directory is not on
+    PATH and `duckdb` is invisible even though pip installed it right next to
+    this entry point. So look in our own environment first and treat PATH as
+    the fallback, not the primary.
+    """
+    exe = "duckdb.exe" if os.name == "nt" else "duckdb"
+    candidates = [
+        # The scripts/bin dir of the interpreter running this shim.
+        os.path.join(os.path.dirname(os.path.abspath(sys.executable)), exe),
+        # sys.argv[0] is the generated `duckle` launcher, so its directory is
+        # the scripts dir even when a different interpreter is in play.
+        os.path.join(os.path.dirname(os.path.abspath(sys.argv[0])), exe),
+    ]
+    for path in candidates:
+        if os.path.isfile(path) and os.access(path, os.X_OK):
+            return path
+    return shutil.which("duckdb")
+
+
+def _engine_env():
+    """Point the runner at the DuckDB CLI without the user configuring it.
+
+    An explicit DUCKLE_DUCKDB_BIN always wins, so a user pinning their own
+    build is never overridden.
+    """
+    env = os.environ.copy()
+    if env.get("DUCKLE_DUCKDB_BIN"):
+        return env
+    found = _find_duckdb()
+    if found:
+        env["DUCKLE_DUCKDB_BIN"] = found
+    return env
+
+
+def main():
+    binary = _binary_path()
+    # argv[0] is what the runner sees as its own name, and it renders help
+    # under that name. Passing the bundled binary's path would make a pip user
+    # read "duckle-runner --pipeline ..." for a command they do not have, so
+    # pass the launcher's name (normally "duckle") instead.
+    invoked = os.path.splitext(os.path.basename(sys.argv[0]))[0] or "duckle"
+    argv = [invoked] + sys.argv[1:]
+    env = _engine_env()
+    if os.name == "nt":
+        # No exec that preserves the process on Windows: subprocess and
+        # forward the child's exit code so CI still sees 0 / 1 / 2.
+        # `executable` says what to launch while argv[0] says what the child
+        # believes it is called. Without it, subprocess would try to launch
+        # argv[0] ("duckle") as a path and fail with WinError 2.
+        raise SystemExit(subprocess.call(argv, executable=binary, env=env))
+    # execve already takes the binary separately from argv, so argv[0] is
+    # free to be the friendly name.
+    os.execve(binary, argv, env)
+
+
+if __name__ == "__main__":
+    main()