composio-videogen 2.5.3__py3-none-any.whl

composio_videogen/__init__.py

@@ -0,0 +1,20 @@
+"""Official Composio custom toolkit for the VideoGen API."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+from .client import resolve_client
+from .operations import Controls
+from .toolkit import create_videogen_toolkit
+from .tools import register_videogen_tools
+
+__all__ = [
+    "Controls",
+    "create_videogen_toolkit",
+    "register_videogen_tools",
+    "resolve_client",
+]
+
+try:
+    __version__ = version("composio-videogen")
+except PackageNotFoundError:
+    __version__ = "0.0.0"

composio_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 Composio 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="composio",
+    )

composio_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["workflow_run_id"], **_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["tool_execution_id"], **_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["export_id"], **_poll_kwargs(controls)
+    )
+    return to_dict(project_export)

composio_videogen/toolkit.py

@@ -0,0 +1,89 @@
+"""Factory for the VideoGen Composio custom toolkit."""
+
+from __future__ import annotations
+
+from typing import Any, Iterable, Optional
+
+from videogen import VideoGen
+
+from .client import resolve_client
+from .operations import Controls
+from .tools import register_videogen_tools
+
+DEFAULT_TOOLKIT_SLUG = "VIDEOGEN"
+DEFAULT_TOOLKIT_NAME = "VideoGen"
+DEFAULT_TOOLKIT_DESCRIPTION = (
+    "Generate videos, images, voiceovers, sound effects, music, and talking-head "
+    "avatars with the VideoGen API."
+)
+
+
+def _new_toolkit(
+    composio: Optional[Any],
+    *,
+    slug: str,
+    name: str,
+    description: str,
+    preload: Optional[bool],
+) -> Any:
+    """Construct an empty Composio custom toolkit.
+
+    Uses ``composio.experimental.Toolkit`` when a client is provided, otherwise
+    falls back to the toolkit class directly so the package is usable without
+    first constructing a ``Composio`` client.
+    """
+    if composio is not None:
+        return composio.experimental.Toolkit(
+            slug=slug, name=name, description=description, preload=preload
+        )
+
+    from composio.core.models.custom_tool import ExperimentalToolkit
+
+    return ExperimentalToolkit(slug=slug, name=name, description=description, preload=preload)
+
+
+def create_videogen_toolkit(
+    composio: Optional[Any] = None,
+    *,
+    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,
+    slug: str = DEFAULT_TOOLKIT_SLUG,
+    name: str = DEFAULT_TOOLKIT_NAME,
+    description: str = DEFAULT_TOOLKIT_DESCRIPTION,
+    preload: Optional[bool] = None,
+) -> Any:
+    """Build a Composio custom toolkit exposing the full VideoGen tool set.
+
+    Pass the returned toolkit to ``composio.create(experimental={"custom_toolkits": [toolkit]})``.
+    ``session.tools()`` then includes every VideoGen tool alongside your other Composio tools.
+
+    Args:
+        composio: A ``Composio`` client. When provided, the toolkit is created via
+            ``composio.experimental.Toolkit``; otherwise the toolkit class is used directly.
+        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 registered tools to these tool names. Defaults to all tools.
+        slug: Toolkit slug (final tool slugs are ``LOCAL_<slug>_<TOOL>``).
+        name: Human-readable toolkit name.
+        description: Toolkit description shown to the agent.
+        preload: When True, expose the toolkit's tools directly instead of via search.
+    """
+    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)
+
+    toolkit = _new_toolkit(
+        composio, slug=slug, name=name, description=description, preload=preload
+    )
+    register_videogen_tools(toolkit, resolved_client, controls, include=include)
+
+    return toolkit