langchain-videogen 2.5.0__py3-none-any.whl

langchain_videogen/__init__.py

@@ -0,0 +1,19 @@
+"""Official LangChain tools for the VideoGen API."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+from .client import resolve_client
+from .operations import Controls
+from .toolkit import VideoGenToolkit, create_videogen_tools
+
+__all__ = [
+    "Controls",
+    "VideoGenToolkit",
+    "create_videogen_tools",
+    "resolve_client",
+]
+
+try:
+    __version__ = version("langchain-videogen")
+except PackageNotFoundError:
+    __version__ = "0.0.0"

langchain_videogen/client.py

@@ -0,0 +1,47 @@
+# AUTO-GENERATED from api/integrations/python-agent-templates/client.py. DO NOT EDIT.
+"""Client resolution for the VideoGen LangChain integration."""
+
+from __future__ import annotations
+
+import os
+from typing import Optional
+
+from videogen import VideoGen
+
+_DEFAULT_BASE_URL = "https://api.videogen.io"
+
+
+def resolve_client(
+    client: Optional[VideoGen] = None,
+    *,
+    api_key: Optional[str] = None,
+    base_url: Optional[str] = None,
+) -> VideoGen:
+    """Resolve a VideoGen client from an explicit client, an explicit key, or the environment.
+
+    Every tool call is authenticated as the team that owns the key.
+
+    Args:
+        client: A pre-configured ``VideoGen`` client. Used as-is when provided.
+        api_key: API key. Falls back to the ``VIDEOGEN_API_KEY`` environment variable.
+        base_url: API base URL. Falls back to ``VIDEOGEN_BASE_URL``, then production.
+    """
+    if client is not None:
+        return client
+
+    resolved_key = api_key or os.environ.get("VIDEOGEN_API_KEY")
+
+    if resolved_key is None or resolved_key.strip() == "":
+        raise ValueError(
+            "No VideoGen API key found. Pass `client` or `api_key`, or set the "
+            "VIDEOGEN_API_KEY environment variable. Create a key at "
+            "https://app.videogen.io/api."
+        )
+
+    resolved_base_url = base_url or os.environ.get("VIDEOGEN_BASE_URL") or _DEFAULT_BASE_URL
+
+    return VideoGen(
+        api_key=resolved_key.strip(),
+        base_url=resolved_base_url,
+        client_id="langchain",
+    )

langchain_videogen/operations.py

@@ -0,0 +1,88 @@
+# AUTO-GENERATED from api/integrations/python-agent-templates/operations.py. DO NOT EDIT.
+"""Shared helpers for starting and polling VideoGen operations."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, Optional
+
+from videogen import VideoGen
+from videogen.poll_executed_tool import poll_executed_tool
+from videogen.poll_project_export import poll_project_export
+from videogen.poll_workflow_run import poll_workflow_run
+
+
+@dataclass
+class Controls:
+    """How the tools handle asynchronous VideoGen operations."""
+
+    wait: bool = True
+    poll_interval_ms: Optional[int] = None
+    timeout_ms: Optional[int] = None
+
+
+def to_dict(obj: Any) -> Any:
+    """Convert an SDK response model into a plain, JSON-serializable structure."""
+    model_dump = getattr(obj, "model_dump", None)
+    if callable(model_dump):
+        return model_dump(mode="json")
+    return obj
+
+
+def drop_none(values: Dict[str, Any]) -> Dict[str, Any]:
+    """Drop ``None``-valued keys so the SDK applies its own defaults."""
+    return {key: value for key, value in values.items() if value is not None}
+
+
+def _poll_kwargs(controls: Controls) -> Dict[str, int]:
+    kwargs: Dict[str, int] = {}
+    if controls.poll_interval_ms is not None:
+        kwargs["poll_interval_ms"] = controls.poll_interval_ms
+    if controls.timeout_ms is not None:
+        kwargs["timeout_ms"] = controls.timeout_ms
+    return kwargs
+
+
+def run_workflow(
+    client: VideoGen,
+    controls: Controls,
+    start: Callable[[], Any],
+) -> Any:
+    """Start a workflow and, unless ``wait`` is False, poll it to a terminal state."""
+    started = start()
+    if not controls.wait:
+        return to_dict(started)
+
+    run = poll_workflow_run(client, started["workflowRunId"], **_poll_kwargs(controls))
+    return to_dict(run)
+
+
+def run_tool(
+    client: VideoGen,
+    controls: Controls,
+    start: Callable[[], Any],
+) -> Any:
+    """Start a media tool execution and, unless ``wait`` is False, poll it to a terminal state."""
+    started = start()
+    if not controls.wait:
+        return to_dict(started)
+
+    execution = poll_executed_tool(client, started["toolExecutionId"], **_poll_kwargs(controls))
+    return to_dict(execution)
+
+
+def run_export(
+    client: VideoGen,
+    controls: Controls,
+    project_id: str,
+    start: Callable[[], Any],
+) -> Any:
+    """Start a project export and, unless ``wait`` is False, poll until the download URL is ready."""
+    started = start()
+    if not controls.wait:
+        return to_dict(started)
+
+    project_export = poll_project_export(
+        client, project_id, started["exportId"], **_poll_kwargs(controls)
+    )
+    return to_dict(project_export)

langchain_videogen/toolkit.py

@@ -0,0 +1,87 @@
+"""Factory and toolkit for the VideoGen LangChain integration."""
+
+from __future__ import annotations
+
+from typing import Iterable, List, Optional
+
+from langchain_core.tools import BaseTool, BaseToolkit
+from pydantic import ConfigDict, Field
+from videogen import VideoGen
+
+from .client import resolve_client
+from .operations import Controls
+from .tools import build_videogen_tools
+
+
+def create_videogen_tools(
+    client: Optional[VideoGen] = None,
+    *,
+    api_key: Optional[str] = None,
+    base_url: Optional[str] = None,
+    wait: bool = True,
+    poll_interval_ms: Optional[int] = None,
+    timeout_ms: Optional[int] = None,
+    include: Optional[Iterable[str]] = None,
+) -> List[BaseTool]:
+    """Build VideoGen tools in LangChain format, ready to bind to any LangChain or LangGraph agent.
+
+    Args:
+        client: A pre-configured ``VideoGen`` client. When omitted, one is built
+            from ``api_key`` / ``base_url`` or the ``VIDEOGEN_API_KEY`` environment variable.
+        wait: When True (default), tools block until the workflow run or tool execution
+            finishes and return the completed result. Set False to return immediately
+            with the run/execution id for the caller to poll.
+        poll_interval_ms: Poll interval while waiting. Defaults to the SDK's default.
+        timeout_ms: Maximum time to wait before giving up. Defaults to the SDK's default.
+        include: Restrict the returned tool set to these tool names. Defaults to all tools.
+    """
+    resolved_client = resolve_client(client, api_key=api_key, base_url=base_url)
+    controls = Controls(wait=wait, poll_interval_ms=poll_interval_ms, timeout_ms=timeout_ms)
+
+    tools = build_videogen_tools(resolved_client, controls)
+
+    if include is None:
+        return tools
+
+    included = set(include)
+    return [tool for tool in tools if tool.name in included]
+
+
+class VideoGenToolkit(BaseToolkit):
+    """A LangChain toolkit exposing the VideoGen tools.
+
+    Example:
+        >>> toolkit = VideoGenToolkit.from_client()
+        >>> tools = toolkit.get_tools()
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    videogen_tools: List[BaseTool] = Field(default_factory=list)
+
+    def get_tools(self) -> List[BaseTool]:
+        return self.videogen_tools
+
+    @classmethod
+    def from_client(
+        cls,
+        client: Optional[VideoGen] = None,
+        *,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        wait: bool = True,
+        poll_interval_ms: Optional[int] = None,
+        timeout_ms: Optional[int] = None,
+        include: Optional[Iterable[str]] = None,
+    ) -> "VideoGenToolkit":
+        return cls(
+            videogen_tools=create_videogen_tools(
+                client,
+                api_key=api_key,
+                base_url=base_url,
+                wait=wait,
+                poll_interval_ms=poll_interval_ms,
+                timeout_ms=timeout_ms,
+                include=include,
+            )
+        )