langchain-camb 0.1.0__py3-none-any.whl

langchain_camb/__init__.py

@@ -0,0 +1,81 @@
+"""LangChain integration for CAMB AI.
+
+CAMB AI provides multilingual audio and localization services including:
+- Text-to-Speech (140+ languages)
+- Translation
+- Transcription with speaker identification
+- Voice cloning
+- Text-to-Sound generation
+- Audio separation
+
+Example:
+    ```python
+    from langchain_camb import CambToolkit, CambTTSTool
+    from langchain_openai import ChatOpenAI
+    from langgraph.prebuilt import create_react_agent
+
+    # Use individual tools
+    tts = CambTTSTool()
+    audio_path = tts.invoke({
+        "text": "Hello, world!",
+        "language": "en-us",
+        "voice_id": 147320
+    })
+
+    # Or use the toolkit with an agent
+    toolkit = CambToolkit()
+    agent = create_react_agent(ChatOpenAI(), toolkit.get_tools())
+    agent.invoke({
+        "messages": [{"role": "user", "content": "Say hello in Spanish"}]
+    })
+    ```
+"""
+
+from langchain_camb.tools import (
+    AudioSeparationInput,
+    CambAudioSeparationTool,
+    CambBaseTool,
+    CambTextToSoundTool,
+    CambTranscriptionTool,
+    CambTranslatedTTSTool,
+    CambTranslationTool,
+    CambTTSTool,
+    CambVoiceCloneTool,
+    CambVoiceListTool,
+    TextToSoundInput,
+    TranscriptionInput,
+    TranslatedTTSInput,
+    TranslationInput,
+    TTSInput,
+    VoiceCloneInput,
+    VoiceListInput,
+)
+from langchain_camb.toolkits import CambToolkit
+from langchain_camb.version import __version__
+
+__all__ = [
+    # Version
+    "__version__",
+    # Toolkit
+    "CambToolkit",
+    # Base
+    "CambBaseTool",
+    # Tools
+    "CambTTSTool",
+    "CambTranslatedTTSTool",
+    "CambTranslationTool",
+    "CambTranscriptionTool",
+    "CambVoiceListTool",
+    "CambVoiceCloneTool",
+    "CambTextToSoundTool",
+    "CambAudioSeparationTool",
+    # Input schemas
+    "TTSInput",
+    "TranslatedTTSInput",
+    "TranslationInput",
+    "TranscriptionInput",
+    "VoiceListInput",
+    "VoiceCloneInput",
+    "TextToSoundInput",
+    "AudioSeparationInput",
+]

langchain_camb/toolkits/__init__.py

@@ -0,0 +1,5 @@
+"""CAMB AI LangChain toolkits."""
+
+from langchain_camb.toolkits.camb_toolkit import CambToolkit
+
+__all__ = ["CambToolkit"]

langchain_camb/toolkits/camb_toolkit.py

@@ -0,0 +1,148 @@
+"""CAMB AI toolkit that bundles all CAMB tools."""
+
+from __future__ import annotations
+
+import os
+from typing import List, Optional
+
+from langchain_core.tools import BaseTool
+from pydantic import BaseModel, ConfigDict, Field
+
+from langchain_camb.tools import (
+    CambAudioSeparationTool,
+    CambTextToSoundTool,
+    CambTranscriptionTool,
+    CambTranslatedTTSTool,
+    CambTranslationTool,
+    CambTTSTool,
+    CambVoiceCloneTool,
+    CambVoiceListTool,
+)
+
+
+class CambToolkit(BaseModel):
+    """Toolkit that bundles all CAMB AI tools.
+
+    Provides convenient access to all CAMB AI services:
+    - Text-to-Speech (TTS)
+    - Translated TTS
+    - Translation
+    - Transcription
+    - Voice Listing
+    - Voice Cloning
+    - Text-to-Sound
+    - Audio Separation
+
+    Example:
+        ```python
+        from langchain_camb import CambToolkit
+        from langchain_openai import ChatOpenAI
+        from langgraph.prebuilt import create_react_agent
+
+        toolkit = CambToolkit()
+        tools = toolkit.get_tools()
+
+        agent = create_react_agent(ChatOpenAI(), tools)
+        agent.invoke({
+            "messages": [{"role": "user", "content": "Say hello in Spanish"}]
+        })
+        ```
+    """
+
+    api_key: Optional[str] = Field(
+        default=None,
+        description="CAMB AI API key. Falls back to CAMB_API_KEY environment variable.",
+    )
+    base_url: Optional[str] = Field(
+        default=None,
+        description="Optional custom base URL for CAMB AI API.",
+    )
+    timeout: float = Field(
+        default=60.0,
+        description="Request timeout in seconds.",
+    )
+    include_tts: bool = Field(
+        default=True,
+        description="Include TTS tool.",
+    )
+    include_translated_tts: bool = Field(
+        default=True,
+        description="Include Translated TTS tool.",
+    )
+    include_translation: bool = Field(
+        default=True,
+        description="Include Translation tool.",
+    )
+    include_transcription: bool = Field(
+        default=True,
+        description="Include Transcription tool.",
+    )
+    include_voice_list: bool = Field(
+        default=True,
+        description="Include Voice List tool.",
+    )
+    include_voice_clone: bool = Field(
+        default=True,
+        description="Include Voice Clone tool.",
+    )
+    include_text_to_sound: bool = Field(
+        default=True,
+        description="Include Text-to-Sound tool.",
+    )
+    include_audio_separation: bool = Field(
+        default=True,
+        description="Include Audio Separation tool.",
+    )
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    def _get_api_key(self) -> str:
+        """Get API key from field or environment."""
+        key = self.api_key or os.environ.get("CAMB_API_KEY")
+        if not key:
+            raise ValueError(
+                "CAMB AI API key is required. "
+                "Set it via 'api_key' parameter or CAMB_API_KEY environment variable."
+            )
+        return key
+
+    def get_tools(self) -> List[BaseTool]:
+        """Get all enabled CAMB AI tools.
+
+        Returns:
+            List of LangChain tools configured with the toolkit's settings.
+        """
+        api_key = self._get_api_key()
+        common_kwargs = {
+            "api_key": api_key,
+            "base_url": self.base_url,
+            "timeout": self.timeout,
+        }
+
+        tools: List[BaseTool] = []
+
+        if self.include_tts:
+            tools.append(CambTTSTool(**common_kwargs))
+
+        if self.include_translated_tts:
+            tools.append(CambTranslatedTTSTool(**common_kwargs))
+
+        if self.include_translation:
+            tools.append(CambTranslationTool(**common_kwargs))
+
+        if self.include_transcription:
+            tools.append(CambTranscriptionTool(**common_kwargs))
+
+        if self.include_voice_list:
+            tools.append(CambVoiceListTool(**common_kwargs))
+
+        if self.include_voice_clone:
+            tools.append(CambVoiceCloneTool(**common_kwargs))
+
+        if self.include_text_to_sound:
+            tools.append(CambTextToSoundTool(**common_kwargs))
+
+        if self.include_audio_separation:
+            tools.append(CambAudioSeparationTool(**common_kwargs))
+
+        return tools

langchain_camb/tools/__init__.py

@@ -0,0 +1,40 @@
+"""CAMB AI LangChain tools."""
+
+from langchain_camb.tools.audio_separation import (
+    AudioSeparationInput,
+    CambAudioSeparationTool,
+)
+from langchain_camb.tools.base import CambBaseTool
+from langchain_camb.tools.text_to_sound import CambTextToSoundTool, TextToSoundInput
+from langchain_camb.tools.transcription import CambTranscriptionTool, TranscriptionInput
+from langchain_camb.tools.translated_tts import (
+    CambTranslatedTTSTool,
+    TranslatedTTSInput,
+)
+from langchain_camb.tools.translation import CambTranslationTool, TranslationInput
+from langchain_camb.tools.tts import CambTTSTool, TTSInput
+from langchain_camb.tools.voice_clone import CambVoiceCloneTool, VoiceCloneInput
+from langchain_camb.tools.voice_list import CambVoiceListTool, VoiceListInput
+
+__all__ = [
+    # Base
+    "CambBaseTool",
+    # Tools
+    "CambTTSTool",
+    "CambTranslatedTTSTool",
+    "CambTranslationTool",
+    "CambTranscriptionTool",
+    "CambVoiceListTool",
+    "CambVoiceCloneTool",
+    "CambTextToSoundTool",
+    "CambAudioSeparationTool",
+    # Input schemas
+    "TTSInput",
+    "TranslatedTTSInput",
+    "TranslationInput",
+    "TranscriptionInput",
+    "VoiceListInput",
+    "VoiceCloneInput",
+    "TextToSoundInput",
+    "AudioSeparationInput",
+]

langchain_camb/tools/audio_separation.py

@@ -0,0 +1,189 @@
+"""Audio separation tool for CAMB AI."""
+
+from __future__ import annotations
+
+import json
+import tempfile
+from typing import Any, Optional, Type
+
+from langchain_core.callbacks import (
+    AsyncCallbackManagerForToolRun,
+    CallbackManagerForToolRun,
+)
+from pydantic import BaseModel, Field, model_validator
+
+from langchain_camb.tools.base import CambBaseTool
+
+
+class AudioSeparationInput(BaseModel):
+    """Input schema for Audio Separation tool."""
+
+    audio_url: Optional[str] = Field(
+        default=None,
+        description="URL of the audio file to separate. Provide either audio_url or audio_file_path.",
+    )
+    audio_file_path: Optional[str] = Field(
+        default=None,
+        description="Local file path to the audio. Provide either audio_url or audio_file_path.",
+    )
+
+    @model_validator(mode="after")
+    def validate_audio_source(self) -> "AudioSeparationInput":
+        """Ensure exactly one audio source is provided."""
+        if not self.audio_url and not self.audio_file_path:
+            raise ValueError("Either audio_url or audio_file_path must be provided.")
+        if self.audio_url and self.audio_file_path:
+            raise ValueError(
+                "Provide only one of audio_url or audio_file_path, not both."
+            )
+        return self
+
+
+class CambAudioSeparationTool(CambBaseTool):
+    """Tool for separating vocals from background audio using CAMB AI.
+
+    This tool isolates speech/vocals from background music or noise.
+    Returns paths to separated audio files.
+
+    Example:
+        ```python
+        from langchain_camb import CambAudioSeparationTool
+
+        separator = CambAudioSeparationTool()
+        result = separator.invoke({
+            "audio_file_path": "/path/to/mixed_audio.mp3"
+        })
+        print(result)  # JSON with paths to vocals and background
+        ```
+    """
+
+    name: str = "camb_audio_separation"
+    description: str = (
+        "Separate vocals/speech from background audio using CAMB AI. "
+        "Provide an audio URL or file path. "
+        "Returns separate files for vocals and background audio."
+    )
+    args_schema: Type[BaseModel] = AudioSeparationInput
+
+    def _run(
+        self,
+        audio_url: Optional[str] = None,
+        audio_file_path: Optional[str] = None,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        """Separate audio synchronously.
+
+        Returns:
+            JSON string with paths to vocals and background audio.
+        """
+        kwargs: dict[str, Any] = {}
+
+        if audio_file_path:
+            with open(audio_file_path, "rb") as f:
+                kwargs["media_file"] = f
+                result = self.sync_client.audio_separation.create_audio_separation(
+                    **kwargs
+                )
+        else:
+            # For URL, we may need to handle differently depending on SDK
+            result = self.sync_client.audio_separation.create_audio_separation(**kwargs)
+
+        task_id = result.task_id
+
+        # Poll for completion and get run_id from status
+        status = self._poll_task_status_sync(
+            self.sync_client.audio_separation.get_audio_separation_status,
+            task_id,
+        )
+        run_id = status.run_id
+
+        # Get result
+        separation_result = self.sync_client.audio_separation.get_audio_separation_run_info(
+            run_id
+        )
+
+        return self._format_result(separation_result)
+
+    async def _arun(
+        self,
+        audio_url: Optional[str] = None,
+        audio_file_path: Optional[str] = None,
+        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
+    ) -> str:
+        """Separate audio asynchronously.
+
+        Returns:
+            JSON string with paths to vocals and background audio.
+        """
+        kwargs: dict[str, Any] = {}
+
+        if audio_file_path:
+            with open(audio_file_path, "rb") as f:
+                kwargs["media_file"] = f
+                result = await self.async_client.audio_separation.create_audio_separation(
+                    **kwargs
+                )
+        else:
+            result = await self.async_client.audio_separation.create_audio_separation(
+                **kwargs
+            )
+
+        task_id = result.task_id
+
+        # Poll for completion and get run_id from status
+        status = await self._poll_task_status(
+            self.async_client.audio_separation.get_audio_separation_status,
+            task_id,
+        )
+        run_id = status.run_id
+
+        # Get result
+        separation_result = (
+            await self.async_client.audio_separation.get_audio_separation_run_info(
+                run_id
+            )
+        )
+
+        return self._format_result(separation_result)
+
+    def _format_result(self, result: Any) -> str:
+        """Format separation result as JSON."""
+        output = {
+            "vocals": None,
+            "background": None,
+            "status": "completed",
+        }
+
+        # Extract URLs or data from result
+        if hasattr(result, "vocals_url"):
+            output["vocals"] = result.vocals_url
+        elif hasattr(result, "vocals"):
+            # If it's bytes, save to temp file
+            if isinstance(result.vocals, bytes):
+                with tempfile.NamedTemporaryFile(
+                    suffix="_vocals.wav", delete=False
+                ) as f:
+                    f.write(result.vocals)
+                    output["vocals"] = f.name
+            else:
+                output["vocals"] = result.vocals
+
+        if hasattr(result, "background_url"):
+            output["background"] = result.background_url
+        elif hasattr(result, "background"):
+            if isinstance(result.background, bytes):
+                with tempfile.NamedTemporaryFile(
+                    suffix="_background.wav", delete=False
+                ) as f:
+                    f.write(result.background)
+                    output["background"] = f.name
+            else:
+                output["background"] = result.background
+
+        # Handle alternative attribute names
+        if hasattr(result, "instrumental_url"):
+            output["background"] = result.instrumental_url
+        if hasattr(result, "voice_url"):
+            output["vocals"] = result.voice_url
+
+        return json.dumps(output, indent=2)

langchain_camb/tools/base.py

@@ -0,0 +1,161 @@
+"""Base class for CAMB AI LangChain tools."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from abc import ABC
+from typing import Any, Optional
+
+from langchain_core.tools import BaseTool
+from pydantic import ConfigDict, Field, model_validator
+
+from camb.client import AsyncCambAI, CambAI
+
+
+class CambBaseTool(BaseTool, ABC):
+    """Base class for CAMB AI tools.
+
+    Provides shared client management and configuration for all CAMB AI tools.
+    """
+
+    api_key: Optional[str] = Field(
+        default=None,
+        description="CAMB AI API key. Falls back to CAMB_API_KEY environment variable.",
+    )
+    base_url: Optional[str] = Field(
+        default=None,
+        description="Optional custom base URL for CAMB AI API.",
+    )
+    timeout: float = Field(
+        default=60.0,
+        description="Request timeout in seconds.",
+    )
+    max_poll_attempts: int = Field(
+        default=60,
+        description="Maximum number of polling attempts for async tasks.",
+    )
+    poll_interval: float = Field(
+        default=2.0,
+        description="Interval between polling attempts in seconds.",
+    )
+
+    # Private attributes for lazy client initialization
+    _sync_client: Optional[CambAI] = None
+    _async_client: Optional[AsyncCambAI] = None
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    @model_validator(mode="after")
+    def validate_api_key(self) -> "CambBaseTool":
+        """Validate that API key is available."""
+        if not self.api_key:
+            self.api_key = os.environ.get("CAMB_API_KEY")
+        if not self.api_key:
+            raise ValueError(
+                "CAMB AI API key is required. "
+                "Set it via 'api_key' parameter or CAMB_API_KEY environment variable."
+            )
+        return self
+
+    @property
+    def sync_client(self) -> CambAI:
+        """Get or create synchronous CAMB AI client."""
+        if self._sync_client is None:
+            self._sync_client = CambAI(
+                api_key=self.api_key,
+                base_url=self.base_url,
+                timeout=self.timeout,
+            )
+        return self._sync_client
+
+    @property
+    def async_client(self) -> AsyncCambAI:
+        """Get or create asynchronous CAMB AI client."""
+        if self._async_client is None:
+            self._async_client = AsyncCambAI(
+                api_key=self.api_key,
+                base_url=self.base_url,
+                timeout=self.timeout,
+            )
+        return self._async_client
+
+    async def _poll_task_status(
+        self,
+        get_status_fn: Any,
+        task_id: str,
+        *,
+        run_id: Optional[int] = None,
+    ) -> Any:
+        """Poll for async task completion.
+
+        Args:
+            get_status_fn: Async function to check task status.
+            task_id: The task ID to poll.
+            run_id: Optional run ID for the request.
+
+        Returns:
+            The final status result when task completes.
+
+        Raises:
+            TimeoutError: If polling exceeds max attempts.
+            RuntimeError: If task fails.
+        """
+        for attempt in range(self.max_poll_attempts):
+            status = await get_status_fn(task_id, run_id=run_id)
+
+            if hasattr(status, "status"):
+                status_value = status.status
+                if status_value in ("completed", "SUCCESS"):
+                    return status
+                elif status_value in ("failed", "FAILED", "error"):
+                    error_msg = getattr(status, "error", "Unknown error")
+                    raise RuntimeError(f"Task failed: {error_msg}")
+
+            await asyncio.sleep(self.poll_interval)
+
+        raise TimeoutError(
+            f"Task {task_id} did not complete within "
+            f"{self.max_poll_attempts * self.poll_interval} seconds"
+        )
+
+    def _poll_task_status_sync(
+        self,
+        get_status_fn: Any,
+        task_id: str,
+        *,
+        run_id: Optional[int] = None,
+    ) -> Any:
+        """Poll for async task completion (synchronous version).
+
+        Args:
+            get_status_fn: Sync function to check task status.
+            task_id: The task ID to poll.
+            run_id: Optional run ID for the request.
+
+        Returns:
+            The final status result when task completes.
+
+        Raises:
+            TimeoutError: If polling exceeds max attempts.
+            RuntimeError: If task fails.
+        """
+        import time
+
+        for attempt in range(self.max_poll_attempts):
+            status = get_status_fn(task_id, run_id=run_id)
+
+            if hasattr(status, "status"):
+                status_value = status.status
+                if status_value in ("completed", "SUCCESS"):
+                    return status
+                elif status_value in ("failed", "FAILED", "error"):
+                    error_msg = getattr(status, "error", "Unknown error")
+                    raise RuntimeError(f"Task failed: {error_msg}")
+
+            time.sleep(self.poll_interval)
+
+        raise TimeoutError(
+            f"Task {task_id} did not complete within "
+            f"{self.max_poll_attempts * self.poll_interval} seconds"
+        )