langgraph-cli 0.1.0__py3-none-any.whl

langgraph_cli/cli.py

@@ -0,0 +1,202 @@
+import asyncio
+import json
+import os
+import pathlib
+import shutil
+import signal
+from datetime import datetime, timezone
+from typing import Coroutine, Optional
+
+import click
+
+import langgraph_cli.config
+import langgraph_cli.docker
+
+
+async def exec(cmd: str, *args: str, input: str = None, wait: float = None):
+    if wait:
+        await asyncio.sleep(wait)
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            cmd, *args, stdin=asyncio.subprocess.PIPE if input else None
+        )
+        await proc.communicate(input.encode() if input else None)
+        if (
+            proc.returncode != 0  # success
+            and proc.returncode != 130  # user interrupt
+        ):
+            raise click.exceptions.Exit(proc.returncode)
+    finally:
+        try:
+            if proc.returncode is None:
+                try:
+                    os.killpg(os.getpgid(proc.pid), signal.SIGINT)
+                except (ProcessLookupError, KeyboardInterrupt):
+                    pass
+        except UnboundLocalError:
+            pass
+
+
+PLACEHOLDER_NOW = object()
+
+
+async def exec_loop(cmd: str, *args: str, input: str = None):
+    now = datetime.now(timezone.utc).isoformat()
+    while True:
+        try:
+            await exec(
+                cmd, *(now if a is PLACEHOLDER_NOW else a for a in args), input=input
+            )
+            now = datetime.now(timezone.utc).isoformat()
+            await asyncio.sleep(1)
+        except Exception as e:
+            print(e)
+            pass
+
+
+async def gather(*coros: Coroutine):
+    tasks = [asyncio.create_task(coro) for coro in coros]
+    exceptions = []
+    while tasks:
+        done, tasks = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
+        for t in tasks:
+            t.cancel()
+        for d in done:
+            if exc := d.exception():
+                exceptions.append(exc)
+
+
+OPT_O = click.option(
+    "--override",
+    "-o",
+    type=click.Path(
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        resolve_path=True,
+        path_type=pathlib.Path,
+    ),
+)
+OPT_C = click.option(
+    "--config",
+    "-c",
+    type=click.Path(
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        resolve_path=True,
+        path_type=pathlib.Path,
+    ),
+)
+OPT_PORT = click.option("--port", "-p", type=int, default=8123)
+
+
+@click.group()
+def cli():
+    pass
+
+
+@OPT_O
+@OPT_C
+@OPT_PORT
+@click.option("--recreate", is_flag=True, default=False)
+@click.option("--pull", is_flag=True, default=False)
+@cli.command()
+def up(
+    override: Optional[pathlib.Path],
+    config: Optional[pathlib.Path],
+    port: int,
+    recreate: bool,
+    pull: bool,
+):
+    if not override and not config:
+        raise click.UsageError("Must provide either --override or --config")
+    with asyncio.Runner() as runner:
+        # check docker available
+        try:
+            runner.run(exec("docker", "--version"))
+            runner.run(exec("docker", "compose", "version"))
+        except click.exceptions.Exit:
+            click.echo("Docker not installed or not running")
+            return
+        # pull latest images
+        if pull:
+            runner.run(exec("docker", "pull", "langchain/langserve"))
+        # prepare args
+        stdin = langgraph_cli.docker.compose(port=port)
+        args = [
+            "--project-directory",
+            override.parent if override else config.parent,
+            "-f",
+            "-",  # stdin
+        ]
+        # apply options
+        if override:
+            args.extend(["-f", str(override)])
+        args.append("up")
+        if config:
+            with open(config) as f:
+                stdin += langgraph_cli.config.config_to_compose(config, json.load(f))
+        if recreate:
+            args.extend(["--force-recreate", "--remove-orphans"])
+            shutil.rmtree(".langserve-data", ignore_errors=True)
+        # run docker compose
+        runner.run(exec("docker", "compose", *args, input=stdin))
+
+
+@OPT_O
+@OPT_PORT
+@cli.command()
+def watch(override: pathlib.Path, port: int):
+    compose = langgraph_cli.docker.compose(port=port)
+
+    with asyncio.Runner() as runner:
+        try:
+            runner.run(
+                gather(
+                    exec(
+                        "docker",
+                        "compose",
+                        "--project-directory",
+                        override.parent,
+                        "-f",
+                        "-",
+                        "-f",
+                        str(override),
+                        "watch",
+                        input=compose,
+                    ),
+                    exec_loop(
+                        "docker",
+                        "compose",
+                        "--project-directory",
+                        override.parent,
+                        "-f",
+                        "-",
+                        "-f",
+                        str(override),
+                        "logs",
+                        "--follow",
+                        "--since",
+                        PLACEHOLDER_NOW,
+                        "langserve",
+                        input=compose,
+                    ),
+                )
+            )
+        finally:
+            # docker compose watch doesn't clean up on exit, so we need to do it
+            runner.run(
+                exec(
+                    "docker",
+                    "compose",
+                    "--project-directory",
+                    override.parent,
+                    "-f",
+                    "-",
+                    "-f",
+                    str(override),
+                    "kill",
+                    input=compose,
+                )
+            )

langgraph_cli/config.py

@@ -0,0 +1,81 @@
+import json
+import os
+import pathlib
+from typing import TypedDict, Union
+
+
+class Config(TypedDict):
+    dependencies: list[str]
+    graphs: dict[str, str]
+    env: Union[dict[str, str], str]
+
+
+def config_to_compose(config_path: pathlib.Path, config: Config):
+    pypi_deps = [dep for dep in config["dependencies"] if not dep.startswith(".")]
+    local_pkgs = []
+    faux_pkgs = {}
+    locals_set = set()
+
+    for local_dep in config["dependencies"]:
+        if local_dep.startswith("."):
+            resolved = config_path.parent / local_dep
+
+            # validate local dependency
+            if not resolved.exists():
+                raise FileNotFoundError(f"Could not find local dependency: {resolved}")
+            elif not resolved.is_dir():
+                raise NotADirectoryError(
+                    f"Local dependency must be a directory: {resolved}"
+                )
+            elif resolved.name in locals_set:
+                raise ValueError(f"Duplicate local dependency: {resolved}")
+            else:
+                locals_set.add(resolved.name)
+
+            # if it's installable, add it to local_pkgs
+            # otherwise, add it to faux_pkgs, and create a pyproject.toml
+            files = os.listdir(resolved)
+            if "pyproject.toml" in files:
+                local_pkgs.append(local_dep)
+            elif "setup.py" in files:
+                local_pkgs.append(local_dep)
+            else:
+                faux_pkgs[resolved.name] = local_dep
+
+    for _, import_str in config["graphs"].items():
+        module_str, _, attrs_str = import_str.partition(":")
+        if not module_str or not attrs_str:
+            message = (
+                'Import string "{import_str}" must be in format "<module>:<attribute>".'
+            )
+            raise ValueError(message.format(import_str=import_str))
+
+    faux_pkgs_str = "\n\n".join(
+        f"ADD {path} /tmp/{name}/{name}\n                RUN touch /tmp/{name}/pyproject.toml"
+        for name, path in faux_pkgs.items()
+    )
+    local_pkgs_str = f"ADD {' '.join(local_pkgs)} /tmp/" if local_pkgs else ""
+    env_vars_str = (
+        "\n".join(f"            {k}: {v}" for k, v in config["env"].items())
+        if isinstance(config["env"], dict)
+        else ""
+    )
+    env_file_str = (
+        f"env_file: {config['env']}" if isinstance(config["env"], str) else ""
+    )
+
+    return f"""
+            LANGSERVE_GRAPHS: '{json.dumps(config["graphs"])}'
+            {env_vars_str}
+        {env_file_str}
+        pull_policy: build
+        build:
+            dockerfile_inline: |
+                FROM langchain/langserve
+
+                {local_pkgs_str}
+
+                {faux_pkgs_str}
+
+                RUN pip install {' '.join(pypi_deps)} /tmp/*
+"""

langgraph_cli/docker.py

@@ -0,0 +1,63 @@
+import pathlib
+from typing import Optional
+
+
+ROOT = pathlib.Path(__file__).parent.parent.resolve()
+
+
+DB = f"""
+    postgres:
+        image: postgres:16
+        restart: on-failure
+        healthcheck:
+            test: pg_isready -U postgres
+            start_interval: 1s
+            start_period: 5s
+            interval: 5s
+            retries: 5
+        ports:
+            - "5433:5432"
+        environment:
+            POSTGRES_DB: postgres
+            POSTGRES_USER: postgres
+            POSTGRES_PASSWORD: postgres
+        volumes:
+            - ./.langserve-data:/var/lib/postgresql/data
+            - {ROOT}/initdb:/docker-entrypoint-initdb.d
+"""
+
+
+def compose(
+    *,
+    # postgres://user:password@host:port/database?option=value
+    postgres_uri: Optional[str] = None,
+    port: int,
+) -> str:
+    if postgres_uri is None:
+        include_db = True
+        postgres_uri = "postgres://postgres:postgres@postgres:5432/postgres?sslmode=disable&search_path=langserve"
+    else:
+        include_db = False
+
+    return f"""
+services:
+{DB if include_db else ""}
+    migrate:
+        image: langchain/langserve-migrate
+        pull_policy: always
+        {'''depends_on:
+            postgres:
+                condition: service_healthy''' if include_db else ""}
+        environment:
+            POSTGRES_URI: {postgres_uri}
+    langserve:
+        image: langchain/langserve
+        restart: on-failure:3
+        ports:
+            - "{port}:8000"
+        depends_on:
+            migrate:
+                condition: service_completed_successfully
+        environment:
+            POSTGRES_URI: {postgres_uri}
+"""

langgraph_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: langgraph-cli
+Version: 0.1.0
+Summary: 
+Author: Nuno Campos
+Author-email: nuno@langchain.dev
+Requires-Python: >=3.9.0,<3.12
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: click (>=8.1.7,<9.0.0)
+Description-Content-Type: text/markdown
+
+# langserve
+

langgraph_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+langgraph_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langgraph_cli/cli.py,sha256=pgCOyXO7PGCFYr4QAnfNhEhsHendIWTkw8m7i22dICM,5685
+langgraph_cli/config.py,sha256=ZtVy9xfzCEb0HZyuSRhIh5895dnsKMTZ_JbNcoyqEp4,2738
+langgraph_cli/docker.py,sha256=O9kIheEbPYizsy72Ygj29l301Ods53DXG8aiQXZc-Dc,1616
+langgraph_cli-0.1.0.dist-info/METADATA,sha256=PYvi7zZojPUb4gL6gOC3GbCyDzd5iHDF26p9YhdKxA0,443
+langgraph_cli-0.1.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+langgraph_cli-0.1.0.dist-info/entry_points.txt,sha256=pq7AcWiYJM1-9PtAAF5jZKrOJw6WxnmYuVR_h6i1j4g,51
+langgraph_cli-0.1.0.dist-info/RECORD,,

langgraph_cli-0.1.0.dist-info/WHEEL

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

langgraph_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+langgraph=langgraph_cli.cli:cli
+