duckhaven-cli 0.1.0__py3-none-any.whl

dh/repl.py

@@ -0,0 +1,158 @@
+"""The interactive `dh sql` shell.
+
+Prefers a **session**, so temp tables, `SET`s and attached catalogs persist
+between statements the way they do in any other SQL shell. Sessions are disabled
+by default on the server, so it falls back to one-shot execution and says so
+once: a stateless REPL is worth far more than a REPL that refuses to start.
+
+The session path goes through `duckhaven-sql-connector`, which is exactly what it
+is for -- one long-lived process holding one connection, with elastic cold-start
+waiting and row pagination already handled.
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import Any
+
+import click
+import typer
+
+from dh import execute
+from dh.errors import DhError, from_connector
+
+#: Everything end-of-input can arrive as. See `read_statements`.
+_END_OF_INPUT = (EOFError, click.Abort, typer.Abort)
+
+_BANNER = "dh sql. Statements end with ';'. Ctrl-D or \\q to quit."
+_QUIT = {"\\q", "quit", "exit", "\\quit"}
+
+
+def read_statements(read_line):
+    """Yield complete statements, buffering until a line ends with `;`.
+
+    A REPL that submitted every line separately could not accept the multi-line
+    SQL people actually paste in.
+    """
+    buffer: list[str] = []
+    while True:
+        prompt = "dh> " if not buffer else "..> "
+        try:
+            line = read_line(prompt)
+        except _END_OF_INPUT:
+            # Ctrl-D is the exit key the banner advertises, and it must leave 0
+            # with anything half-typed still run. Three classes because typer
+            # vendors its own click: `typer.prompt` raises
+            # `typer.exceptions.Abort`, which is *not* `click.exceptions.Abort`,
+            # and `read_line` is an arbitrary callable that may raise EOFError.
+            if buffer:
+                yield "\n".join(buffer)
+            return
+        stripped = line.strip()
+        if not buffer and stripped.lower() in _QUIT:
+            return
+        if not stripped and not buffer:
+            continue
+        buffer.append(line)
+        if stripped.endswith(";"):
+            yield "\n".join(buffer).rstrip().rstrip(";")
+            buffer = []
+
+
+def run(cli, settings, *, agent: str | None = None) -> int:
+    """Run the shell until end of input. Returns the process exit code."""
+    connection = _open_session(cli, settings, agent)
+    if connection is None:
+        cli.note("SQL sessions are not enabled here; running each statement on its own.")
+    try:
+        return _loop(cli, settings, connection, agent)
+    finally:
+        if connection is not None:
+            # Always, including on interrupt: an unclosed session holds an agent
+            # slot until the server's reaper notices.
+            try:
+                connection.close()
+            except Exception:  # noqa: BLE001 - closing is best effort
+                pass
+
+
+def _open_session(cli, settings, agent: str | None):
+    """A connector session, or None when the server has them switched off."""
+    try:
+        from duckhaven_sql_connector import connect
+    except ImportError:  # pragma: no cover - the dependency is declared
+        return None
+    try:
+        return connect(
+            host=settings.require("host"),
+            workspace=settings.require("workspace"),
+            token=settings.require("token"),
+            agent=agent or settings.get("agent"),
+            catalog=settings.get("catalog"),
+            application="dh-repl",
+        )
+    except Exception as exc:  # noqa: BLE001 - any failure means "fall back"
+        cli.debug(f"session unavailable: {exc}")
+        return None
+
+
+def _loop(cli, settings, connection, agent: str | None) -> int:
+    typer.echo(_BANNER, err=True)
+    for sql in read_statements(lambda prompt: typer.prompt(prompt, prompt_suffix="")):
+        try:
+            if connection is not None:
+                _run_on_session(cli, connection, sql)
+            else:
+                _run_one_shot(cli, settings, sql, agent)
+        except KeyboardInterrupt:
+            # Interrupting a statement returns to the prompt; the shell itself
+            # ends at end of input.
+            cli.note("Cancelled.")
+        except DhError as exc:
+            # A failed statement is a normal event in a shell, so report it and
+            # keep the session -- exiting would throw away the temp tables that
+            # are the whole reason for holding one.
+            cli.note(f"Error: {exc.message}")
+    return 0
+
+
+def _run_on_session(cli, connection, sql: str) -> None:
+    cursor = connection.cursor()
+    try:
+        cursor.execute(sql)
+        columns = [d[0] for d in cursor.description or []]
+        # Keyed by column name, matching `RowsPageOut`: the envelope is one public
+        # contract, so the session path must not emit a different row shape from
+        # the one-shot path.
+        rows: list[dict[str, Any]] = (
+            [dict(zip(columns, row)) for row in cursor.fetchall()] if columns else []
+        )
+        cli.emit({"columns": columns, "rows": rows, "total": len(rows)})
+    except Exception as exc:  # noqa: BLE001 - mapped to the CLI taxonomy
+        raise from_connector(exc) from exc
+    finally:
+        cursor.close()
+
+
+def _run_one_shot(cli, settings, sql: str, agent: str | None) -> None:
+    with cli.client(settings) as client:
+        chosen = execute.resolve_agent(client, agent or settings.get("agent"))
+        submitted = execute.submit(
+            client,
+            settings.require("workspace"),
+            sql,
+            agent=chosen,
+            catalog=settings.get("catalog"),
+        )
+        finished = execute.wait(client, submitted["id"], timeout=1200)
+        execute.raise_for_status(finished)
+        page = execute.fetch_rows(client, finished["id"])
+    cli.emit({"columns": page["columns"], "rows": page["rows"], "total": page["total"]})
+
+
+def is_interactive() -> bool:
+    """Whether to start a shell rather than read a script from a pipe."""
+    try:
+        return sys.stdin.isatty()
+    except (AttributeError, ValueError):  # pragma: no cover - detached stream
+        return False

dh/resolve.py

@@ -0,0 +1,146 @@
+"""Settings resolution: flag, then environment, then profile, then default."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from dh.config import Config, Profile
+from dh.errors import ConfigError
+
+#: Setting name -> the environment variable that supplies it.
+ENV_VARS = {
+    "profile": "DH_PROFILE",
+    "host": "DH_HOST",
+    "token": "DH_TOKEN",
+    "workspace": "DH_WORKSPACE",
+    "catalog": "DH_CATALOG",
+    "agent": "DH_AGENT",
+}
+
+#: Settings drawn from the profile table, in `dh auth describe` order.
+SETTINGS = ("host", "token", "workspace", "catalog", "agent")
+
+#: Settings whose value must never be printed.
+SECRET = frozenset({"token"})
+
+
+@dataclass(frozen=True)
+class Value:
+    """A resolved setting and the reason it has the value it has."""
+
+    value: str | None
+    source: str
+
+    def __bool__(self) -> bool:
+        return self.value is not None
+
+
+@dataclass(frozen=True)
+class Settings:
+    profile_name: str | None
+    values: dict[str, Value]
+
+    def get(self, name: str) -> str | None:
+        return self.values[name].value
+
+    def source(self, name: str) -> str:
+        return self.values[name].source
+
+    def require(self, name: str) -> str:
+        """The value, or a message naming every way it could have been supplied.
+
+        A bare "host is required" leaves the reader to guess whether that means a
+        flag, a variable, or a file, so say all three.
+        """
+        value = self.get(name)
+        if value:
+            return value
+        raise ConfigError(
+            f"no_{name}",
+            f"No {name} configured. Set it with --{name}, ${ENV_VARS[name]}, "
+            f"or `dh auth login` to write a profile.",
+        )
+
+
+def resolve(
+    config: Config,
+    env: dict[str, str],
+    overrides: dict[str, str | None] | None = None,
+) -> Settings:
+    """Apply the precedence chain to one invocation.
+
+    ``env`` is passed in rather than read from :mod:`os` so the whole chain is
+    testable without mutating process state.
+    """
+    overrides = {k: v for k, v in (overrides or {}).items() if v is not None}
+
+    profile_name, profile_source = _pick_profile(config, env, overrides)
+    profile = config.get(profile_name) if profile_name else None
+
+    values: dict[str, Value] = {"profile": Value(profile_name, profile_source)}
+    for name in SETTINGS:
+        values[name] = _pick(name, profile, env, overrides)
+    return Settings(profile_name=profile_name, values=values)
+
+
+def _pick_profile(
+    config: Config, env: dict[str, str], overrides: dict[str, str]
+) -> tuple[str | None, str]:
+    """Which profile this invocation uses, and why.
+
+    A profile named explicitly but absent from the file is an error rather than a
+    silent fall back to the default: the caller asked for a specific one, and
+    quietly using another is how the wrong workspace gets written to.
+    """
+    for value, source in ((overrides.get("profile"), "flag"), (env.get("DH_PROFILE"), "env")):
+        if value:
+            if value not in config.profiles:
+                raise ConfigError(
+                    "no_such_profile",
+                    f"No profile named {value!r} in {config.path}. "
+                    f"Known profiles: {', '.join(sorted(config.profiles)) or 'none'}",
+                )
+            return value, "flag --profile" if source == "flag" else "env DH_PROFILE"
+    resolved = config.resolved_default()
+    return resolved, f"default profile {resolved!r}" if resolved else "unset"
+
+
+def _pick(
+    name: str, profile: Profile | None, env: dict[str, str], overrides: dict[str, str]
+) -> Value:
+    if name in overrides:
+        return Value(overrides[name], f"flag --{name}")
+    env_var = ENV_VARS[name]
+    if env.get(env_var):
+        return Value(env[env_var], f"env {env_var}")
+    if profile is not None and getattr(profile, name) is not None:
+        return Value(getattr(profile, name), f"profile {profile.name}")
+    return Value(None, "unset")
+
+
+def describe(settings: Settings) -> list[dict[str, str | None]]:
+    """Rows for `dh auth describe`: what each setting is, and where it came from.
+
+    The token is reported as present or absent and never by value. Someone
+    debugging a credential needs to know *which* one is in play, not what it is,
+    and `dh auth describe` is exactly the command people paste into a bug report.
+    """
+    rows: list[dict[str, str | None]] = [
+        {
+            "setting": "profile",
+            "value": settings.values["profile"].value,
+            "source": settings.values["profile"].source,
+        }
+    ]
+    for name in SETTINGS:
+        resolved = settings.values[name]
+        shown = resolved.value
+        if name in SECRET and shown is not None:
+            shown = _mask(shown)
+        rows.append({"setting": name, "value": shown, "source": resolved.source})
+    return rows
+
+
+def _mask(token: str) -> str:
+    """Enough of the token to tell two apart, not enough to use one."""
+    return f"{token[:11]}…" if len(token) > 14 else "…"

dh/rest.py

@@ -0,0 +1,201 @@
+"""The REST client for everything the SQL connector does not cover.
+
+The connector owns sessions, statements, polling and row pagination. This covers
+the other ~95 operations -- catalog, grants, schedules, lineage, semantic, admin --
+and shares nothing with it but the host and token, because a DB-API driver has no
+business modelling a catalog.
+
+Two things it does that every hand-written `curl` invocation gets wrong: it joins
+the `/api` mount exactly once, and it walks `cursor` to the end of a paged
+collection instead of silently returning the first hundred rows.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import Any
+
+import httpx
+
+from dh import __version__
+from dh.errors import TimeoutError as DhTimeoutError
+from dh.errors import UnavailableError, from_status
+
+#: Read from the response before deciding it is an error, so a proxy's HTML page
+#: still yields something to show the user.
+_MAX_ERROR_BODY = 64 * 1024
+
+
+class RestClient:
+    """A thin, synchronous client bound to one host and token."""
+
+    def __init__(
+        self,
+        host: str,
+        token: str | None = None,
+        *,
+        timeout: float = 60.0,
+        verify: bool = True,
+        transport: httpx.BaseTransport | None = None,
+    ) -> None:
+        self.base_url = f"{host.rstrip('/')}/api"
+        headers = {
+            # Named so the server can attribute traffic; the session router
+            # records it per session.
+            "User-Agent": f"duckhaven-cli/{__version__}",
+            "Accept": "application/json",
+        }
+        # No token is a deliberate mode, not an oversight: `dh auth login` signs in
+        # with a password, holds the session cookie for three requests while it
+        # mints a PAT, and signs out. httpx keeps cookies on the client, so that
+        # whole exchange runs on one instance and the cookie never reaches disk.
+        if token:
+            headers["Authorization"] = f"Bearer {token}"
+        self._client = httpx.Client(
+            timeout=timeout,
+            verify=verify,
+            transport=transport,
+            headers=headers,
+            # A host given as `http://` behind a TLS-terminating proxy answers 301.
+            # Unfollowed that is a <400 response with no body, so the caller got
+            # `None` and tripped over it rather than reaching the API.
+            follow_redirects=True,
+        )
+
+    def __enter__(self) -> RestClient:
+        return self
+
+    def __exit__(self, *_exc: object) -> None:
+        self.close()
+
+    def close(self) -> None:
+        self._client.close()
+
+    # --- Requests ----------------------------------------------------------
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+        json: Any = None,
+        content: bytes | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> Any:
+        """Send one request and return its decoded body, or raise a ``DhError``.
+
+        ``content`` sends bytes verbatim -- the semantic import route reads its
+        body raw so a hand-written YAML document arrives exactly as published, and
+        re-encoding it through ``json=`` would defeat that.
+        """
+        url = f"{self.base_url}/{path.lstrip('/')}"
+        try:
+            response = self._client.request(
+                method,
+                url,
+                params=_clean(params),
+                json=json,
+                content=content,
+                headers=headers,
+            )
+        except httpx.TimeoutException as exc:
+            raise DhTimeoutError("client_timeout", f"{method} {path} timed out: {exc}") from exc
+        except httpx.TransportError as exc:
+            raise UnavailableError(
+                "transport_error", f"Could not reach {self.base_url}: {exc}"
+            ) from exc
+
+        if response.status_code >= 400:
+            raise from_status(response.status_code, _body(response))
+        if response.status_code == 204 or not response.content:
+            return None
+        try:
+            return response.json()
+        except ValueError:
+            # `/metrics` is Prometheus text and the assistant route streams SSE.
+            # Both are reachable only through `dh api`, so hand the body back
+            # rather than failing outside the error taxonomy it advertises.
+            return response.text
+
+    def get(self, path: str, **kwargs: Any) -> Any:
+        return self.request("GET", path, **kwargs)
+
+    def post(self, path: str, **kwargs: Any) -> Any:
+        return self.request("POST", path, **kwargs)
+
+    def put(self, path: str, **kwargs: Any) -> Any:
+        return self.request("PUT", path, **kwargs)
+
+    def patch(self, path: str, **kwargs: Any) -> Any:
+        return self.request("PATCH", path, **kwargs)
+
+    def delete(self, path: str, **kwargs: Any) -> Any:
+        return self.request("DELETE", path, **kwargs)
+
+    # --- Collections -------------------------------------------------------
+
+    def collect(
+        self,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+        limit: int | None = None,
+    ) -> tuple[list[Any], str | None, bool]:
+        """One page of a collection, whichever shape the endpoint returns.
+
+        DuckHaven's conventions define two: an unbounded collection answers
+        ``{items, cursor, has_more}``, a bounded one a bare array. Which is which
+        is decided per endpoint and documented, but a caller should not have to
+        know, so this reports both as ``(rows, cursor, has_more)``.
+        """
+        body = self.get(path, params={**(params or {}), **({"limit": limit} if limit else {})})
+        if isinstance(body, list):
+            return body, None, False
+        if isinstance(body, dict) and isinstance(body.get("items"), list):
+            return body["items"], body.get("cursor"), bool(body.get("has_more"))
+        # A single object where a collection was expected: report it as one row
+        # rather than raising, so a caller-facing command still shows something.
+        return [body], None, False
+
+    def walk(
+        self,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+        limit: int | None = None,
+    ) -> Iterator[Any]:
+        """Every row of a collection, following ``cursor`` to the end.
+
+        The truncation trap this exists to close: a single fetch of a paged
+        endpoint returns the first page and looks complete. A bare-array endpoint
+        has no cursor and simply yields once.
+        """
+        cursor: str | None = None
+        while True:
+            page_params = dict(params or {})
+            if cursor:
+                page_params["cursor"] = cursor
+            rows, cursor, has_more = self.collect(path, params=page_params, limit=limit)
+            yield from rows
+            if not cursor or not has_more or not rows:
+                return
+
+
+def _clean(params: dict[str, Any] | None) -> dict[str, Any] | None:
+    """Drop unset parameters so an omitted filter is absent, not empty.
+
+    `status` and friends have no server-side default by design -- a caller who
+    omits one should get everything -- and sending `status=` would narrow it to
+    nothing instead.
+    """
+    if not params:
+        return None
+    return {k: v for k, v in params.items() if v is not None and v != []}
+
+
+def _body(response: httpx.Response) -> object:
+    try:
+        return response.json()
+    except ValueError:
+        return response.text[:_MAX_ERROR_BODY]

duckhaven_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,69 @@
+Metadata-Version: 2.5
+Name: duckhaven-cli
+Version: 0.1.0
+Summary: dh — the command-line interface for DuckHaven
+Project-URL: Homepage, https://github.com/tamasmrtn/duckhaven-clients
+Project-URL: Source, https://github.com/tamasmrtn/duckhaven-clients
+Author: DuckHaven
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: cli,duckdb,duckhaven,iceberg,lakehouse
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Database
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: duckhaven-sql-connector>=0.4.1
+Requires-Dist: httpx>=0.28
+Requires-Dist: tomli>=2.0; python_version < '3.11'
+Requires-Dist: typer>=0.15
+Description-Content-Type: text/markdown
+
+# duckhaven-cli
+
+`dh` — the command-line interface for [DuckHaven](https://github.com/tamasmrtn/duckhaven).
+
+It gives analysts, CI pipelines and operators scriptable access to DuckHaven's REST API:
+running SQL, browsing the catalog, publishing dbt lineage and semantic models, managing
+grants, and operating service accounts, users and agents.
+
+Like every member of this repo it is a **pure HTTP client of DuckHaven's public REST
+API**, authenticating with a Personal Access Token (`dh_pat_…`). The interactive REPL
+holds a SQL session through
+[`duckhaven-sql-connector`](../duckhaven-sql-connector/README.md); everything else,
+including one-shot `dh sql`, goes over the REST API directly, because the one-shot query
+route works on deployments where SQL sessions are switched off.
+
+## Install
+
+```sh
+pip install duckhaven-cli
+# or, to get an isolated tool install:
+uv tool install duckhaven-cli
+```
+
+## Getting started
+
+```sh
+dh auth login --host https://duckhaven.example.com
+dh sql -q "select 1"
+```
+
+## Documentation
+
+- [Command-line quickstart](https://tamasmrtn.github.io/duckhaven/getting-started/cli-quickstart/) — install, sign in,
+  run a query
+- [CLI reference](https://tamasmrtn.github.io/duckhaven/reference/cli/) — every command and flag
+
+## Licence
+
+Apache-2.0. See [LICENSE](LICENSE).

duckhaven_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+dh/__init__.py,sha256=sTWxNIX959ccfy-L6TwSw2-nkD6JIQjhAvNf2KQumkY,826
+dh/_version.py,sha256=n_5vdJsPNu7wZ57LGuRL585uvll-hiuvZUBWzdG0RQU,520
+dh/config.py,sha256=yIcKPmYolr2vZ27mEtgT6J1dKLKFGOmyLE22UzGScgE,9397
+dh/context.py,sha256=wcIIkWneSQ6hqvebdyNcIyY6cWMmnHmXVZ4c_vZ2ClI,6342
+dh/errors.py,sha256=bvYYuyngNOVR5u8iwZY567XJ7FvrvnpwTTOMOdRnQvY,5957
+dh/execute.py,sha256=qAcBpxeigv6zrD3f618I8hiEivwGPm5BlIbY_7-o2Gs,6906
+dh/introspect.py,sha256=zPD0ubm7S29W6dCGvMEfnoCud2cH1B6kpD5jTHwqkIU,2830
+dh/main.py,sha256=4zGO8KywL_adYKijOyA7CTLPdT78QqhAYPqeyK55c0Q,7837
+dh/repl.py,sha256=IuPzthYLD24-3N1O_iMy3FqC3_evZ2kCVELhRI83NeU,6067
+dh/resolve.py,sha256=TZ4dMdIyALHFDZz5JlDAmxwoINkvlBHCYzBY0Q5AePE,5005
+dh/rest.py,sha256=Xr6cRGk59hS7Sn0k_P3xLAONDow9dzlLE0V8GugYKJU,7547
+dh/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dh/commands/admin.py,sha256=1eDxi2ry5KosPU5hkJqgkGxuLRWLW1_2GAA2QFwXw2k,12597
+dh/commands/api.py,sha256=8RxwhMpluWaFOk5aWK1WtE5b_5DaUFUX7Bc82pAgWGs,2615
+dh/commands/auth.py,sha256=p4_V3qglAqP4419EnfI77HUeva7dglednNZAmzW_96o,10643
+dh/commands/catalog.py,sha256=KjS8_Zdn3-FA1pDcI7SNArw19eZ_KklRllMUsMeU6gg,15724
+dh/commands/dbt.py,sha256=mdYacYmQJaj7eZa3K_ExB2qsZ5vvxh5RC4XgmSwJYUo,10305
+dh/commands/grant.py,sha256=z1vSKBm86Omt9nG6lZM6cUiqqjDY2oNXAhzl9GHFsNc,5229
+dh/commands/health.py,sha256=ZDcxMWGmkkA8pMfXIn9uuz42uNMSw4RPG9hsE_RHFKk,2515
+dh/commands/profile.py,sha256=TMfUoIV0XomaMtDGj80Vmb0AvuOdfhBmziqxivv86DI,2466
+dh/commands/query.py,sha256=qJEthxwd3u_Yt80HGXB7mccAD_Y05BB5IAcAGzd7ajU,8438
+dh/commands/saved.py,sha256=9DpuikxiNrzzJ8DJWoGnQx4fJ0FxxDqSFBtQ2UEeG60,7658
+dh/commands/session.py,sha256=bwPdoH9dgE9gQaOEhk2Gix5_ud4rOW8s5s4tnm8XwOE,7986
+dh/output/__init__.py,sha256=pXDRpU0o2PKcoRKioAMH4OjfDG5oFB3QjXIzMj7nXZk,6017
+duckhaven_cli-0.1.0.dist-info/METADATA,sha256=2Tk-LSpHkKjikzeTvF-lT3XNlQby_3AWXgEds677YnM,2466
+duckhaven_cli-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+duckhaven_cli-0.1.0.dist-info/entry_points.txt,sha256=b_2m18bQul2Qc2i9i18ZuRKkPx0WGrb1k5wbRED22Zc,35
+duckhaven_cli-0.1.0.dist-info/licenses/LICENSE,sha256=YjVDAaUD-K0JDNSP-Yr2VgQ0cUmduwQ5iwpvrjKySNc,11339
+duckhaven_cli-0.1.0.dist-info/RECORD,,

duckhaven_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

duckhaven_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dh = dh.main:run