langchain-camb 0.1.0__py3-none-any.whl

langchain_camb/tools/translation.py

@@ -0,0 +1,150 @@
+"""Translation tool for CAMB AI."""
+
+from __future__ import annotations
+
+from typing import Literal, Optional, Type
+
+from langchain_core.callbacks import (
+    AsyncCallbackManagerForToolRun,
+    CallbackManagerForToolRun,
+)
+from pydantic import BaseModel, Field
+
+from langchain_camb.tools.base import CambBaseTool
+
+
+class TranslationInput(BaseModel):
+    """Input schema for Translation tool."""
+
+    text: str = Field(
+        ...,
+        description="Text to translate.",
+    )
+    source_language: int = Field(
+        ...,
+        description="Source language code (integer). Common codes: 1=English, 2=Spanish, 3=French, 4=German, 5=Italian, 6=Portuguese, 7=Dutch, 8=Russian, 9=Japanese, 10=Korean, 11=Chinese.",
+    )
+    target_language: int = Field(
+        ...,
+        description="Target language code (integer). Use same language codes as source_language.",
+    )
+    formality: Optional[int] = Field(
+        default=None,
+        description="Formality level: 1=formal, 2=informal. Optional.",
+    )
+
+
+class CambTranslationTool(CambBaseTool):
+    """Tool for translating text using CAMB AI.
+
+    This tool provides high-quality machine translation supporting 140+ languages.
+    It uses CAMB AI's streaming translation API for fast responses.
+
+    Example:
+        ```python
+        from langchain_camb import CambTranslationTool
+
+        translator = CambTranslationTool()
+        result = translator.invoke({
+            "text": "Hello, how are you?",
+            "source_language": 1,  # English
+            "target_language": 2,  # Spanish
+        })
+        print(result)  # "Hola, ¿cómo estás?"
+        ```
+    """
+
+    name: str = "camb_translation"
+    description: str = (
+        "Translate text between 140+ languages using CAMB AI. "
+        "Provide source and target language codes (integers) and the text to translate. "
+        "Common codes: 1=English, 2=Spanish, 3=French, 4=German, 5=Italian."
+    )
+    args_schema: Type[BaseModel] = TranslationInput
+
+    def _run(
+        self,
+        text: str,
+        source_language: int,
+        target_language: int,
+        formality: Optional[int] = None,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        """Translate text synchronously.
+
+        Returns:
+            Translated text string.
+        """
+        from camb.core.api_error import ApiError
+
+        kwargs = {
+            "text": text,
+            "source_language": source_language,
+            "target_language": target_language,
+        }
+
+        if formality:
+            kwargs["formality"] = formality
+
+        try:
+            result = self.sync_client.translation.translation_stream(**kwargs)
+            return self._extract_text(result)
+        except ApiError as e:
+            # SDK bug: translation_stream returns plain text but SDK tries to parse as JSON
+            # If status is 200, the body contains the translated text
+            if e.status_code == 200 and e.body:
+                return str(e.body)
+            raise
+
+    async def _arun(
+        self,
+        text: str,
+        source_language: int,
+        target_language: int,
+        formality: Optional[int] = None,
+        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
+    ) -> str:
+        """Translate text asynchronously.
+
+        Returns:
+            Translated text string.
+        """
+        from camb.core.api_error import ApiError
+
+        kwargs = {
+            "text": text,
+            "source_language": source_language,
+            "target_language": target_language,
+        }
+
+        if formality:
+            kwargs["formality"] = formality
+
+        try:
+            result = await self.async_client.translation.translation_stream(**kwargs)
+            return self._extract_text(result)
+        except ApiError as e:
+            # SDK bug: translation_stream returns plain text but SDK tries to parse as JSON
+            # If status is 200, the body contains the translated text
+            if e.status_code == 200 and e.body:
+                return str(e.body)
+            raise
+
+    def _extract_text(self, result) -> str:
+        """Extract text from various result types."""
+        # Handle streaming response - collect all chunks
+        if hasattr(result, "__iter__") and not isinstance(result, (str, bytes)):
+            chunks = []
+            for chunk in result:
+                if hasattr(chunk, "text"):
+                    chunks.append(chunk.text)
+                elif isinstance(chunk, str):
+                    chunks.append(chunk)
+            return "".join(chunks)
+
+        # Direct result
+        if hasattr(result, "text"):
+            return result.text
+        if isinstance(result, str):
+            return result
+        return str(result)

langchain_camb/tools/tts.py

@@ -0,0 +1,182 @@
+"""Text-to-Speech tool for CAMB AI."""
+
+from __future__ import annotations
+
+import base64
+import tempfile
+from typing import Any, Literal, Optional, Type, Union
+
+from langchain_core.callbacks import (
+    AsyncCallbackManagerForToolRun,
+    CallbackManagerForToolRun,
+)
+from pydantic import BaseModel, Field
+
+from langchain_camb.tools.base import CambBaseTool
+
+
+class TTSInput(BaseModel):
+    """Input schema for Text-to-Speech tool."""
+
+    text: str = Field(
+        ...,
+        min_length=3,
+        max_length=3000,
+        description="Text to convert to speech (3-3000 characters).",
+    )
+    language: str = Field(
+        default="en-us",
+        description="BCP-47 language code (e.g., 'en-us', 'es-es', 'fr-fr').",
+    )
+    voice_id: int = Field(
+        default=147320,
+        description="Voice ID to use. Get available voices with CambVoiceListTool.",
+    )
+    speech_model: str = Field(
+        default="mars-flash",
+        description="Speech model: 'mars-flash' (fast), 'mars-pro' (quality), 'mars-instruct' (with instructions).",
+    )
+    output_format: Literal["file_path", "base64", "bytes"] = Field(
+        default="file_path",
+        description="Output format: 'file_path' (save to file), 'base64' (encoded string), 'bytes' (raw bytes).",
+    )
+    speed: float = Field(
+        default=1.0,
+        ge=0.5,
+        le=2.0,
+        description="Speech speed multiplier (0.5-2.0).",
+    )
+    user_instructions: Optional[str] = Field(
+        default=None,
+        description="Instructions for mars-instruct model (e.g., 'Speak with excitement').",
+    )
+
+
+class CambTTSTool(CambBaseTool):
+    """Tool for converting text to speech using CAMB AI.
+
+    This tool uses CAMB AI's streaming TTS API to convert text into natural
+    speech in 140+ languages. Supports multiple voice models and output formats.
+
+    Example:
+        ```python
+        from langchain_camb import CambTTSTool
+
+        tts = CambTTSTool()
+        result = tts.invoke({
+            "text": "Hello, world!",
+            "language": "en-us",
+            "voice_id": 147320
+        })
+        print(result)  # Returns file path to audio
+        ```
+    """
+
+    name: str = "camb_tts"
+    description: str = (
+        "Convert text to speech using CAMB AI. "
+        "Supports 140+ languages and multiple voice models. "
+        "Returns audio as file path, base64, or raw bytes."
+    )
+    args_schema: Type[BaseModel] = TTSInput
+
+    def _run(
+        self,
+        text: str,
+        language: str = "en-us",
+        voice_id: int = 147320,
+        speech_model: str = "mars-flash",
+        output_format: str = "file_path",
+        speed: float = 1.0,
+        user_instructions: Optional[str] = None,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> Union[str, bytes]:
+        """Run text-to-speech conversion synchronously.
+
+        Returns:
+            File path, base64 string, or raw bytes depending on output_format.
+        """
+        from camb import (
+            StreamTtsOutputConfiguration,
+            StreamTtsVoiceSettings,
+        )
+
+        # Build request parameters
+        kwargs: dict[str, Any] = {
+            "text": text,
+            "language": language,
+            "voice_id": voice_id,
+            "speech_model": speech_model,
+            "output_configuration": StreamTtsOutputConfiguration(format="wav"),
+            "voice_settings": StreamTtsVoiceSettings(speed=speed),
+        }
+
+        if user_instructions and speech_model == "mars-instruct":
+            kwargs["user_instructions"] = user_instructions
+
+        # Stream audio chunks
+        audio_chunks: list[bytes] = []
+        for chunk in self.sync_client.text_to_speech.tts(**kwargs):
+            audio_chunks.append(chunk)
+
+        audio_data = b"".join(audio_chunks)
+
+        return self._format_output(audio_data, output_format)
+
+    async def _arun(
+        self,
+        text: str,
+        language: str = "en-us",
+        voice_id: int = 147320,
+        speech_model: str = "mars-flash",
+        output_format: str = "file_path",
+        speed: float = 1.0,
+        user_instructions: Optional[str] = None,
+        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
+    ) -> Union[str, bytes]:
+        """Run text-to-speech conversion asynchronously.
+
+        Returns:
+            File path, base64 string, or raw bytes depending on output_format.
+        """
+        from camb import (
+            StreamTtsOutputConfiguration,
+            StreamTtsVoiceSettings,
+        )
+
+        # Build request parameters
+        kwargs: dict[str, Any] = {
+            "text": text,
+            "language": language,
+            "voice_id": voice_id,
+            "speech_model": speech_model,
+            "output_configuration": StreamTtsOutputConfiguration(format="wav"),
+            "voice_settings": StreamTtsVoiceSettings(speed=speed),
+        }
+
+        if user_instructions and speech_model == "mars-instruct":
+            kwargs["user_instructions"] = user_instructions
+
+        # Stream audio chunks
+        audio_chunks: list[bytes] = []
+        async for chunk in self.async_client.text_to_speech.tts(**kwargs):
+            audio_chunks.append(chunk)
+
+        audio_data = b"".join(audio_chunks)
+
+        return self._format_output(audio_data, output_format)
+
+    def _format_output(
+        self, audio_data: bytes, output_format: str
+    ) -> Union[str, bytes]:
+        """Format audio data according to output_format."""
+        if output_format == "bytes":
+            return audio_data
+        elif output_format == "base64":
+            return base64.b64encode(audio_data).decode("utf-8")
+        else:  # file_path
+            with tempfile.NamedTemporaryFile(
+                suffix=".wav", delete=False
+            ) as f:
+                f.write(audio_data)
+                return f.name

langchain_camb/tools/voice_clone.py

@@ -0,0 +1,152 @@
+"""Voice clone tool for CAMB AI."""
+
+from __future__ import annotations
+
+import json
+from typing import Optional, Type
+
+from langchain_core.callbacks import (
+    AsyncCallbackManagerForToolRun,
+    CallbackManagerForToolRun,
+)
+from pydantic import BaseModel, Field
+
+from langchain_camb.tools.base import CambBaseTool
+
+
+class VoiceCloneInput(BaseModel):
+    """Input schema for Voice Clone tool."""
+
+    voice_name: str = Field(
+        ...,
+        description="Name for the new cloned voice.",
+    )
+    audio_file_path: str = Field(
+        ...,
+        description="Path to audio file (2+ seconds) to clone voice from.",
+    )
+    gender: int = Field(
+        ...,
+        description="Gender: 1=Male, 2=Female, 0=Not Specified, 9=Not Applicable.",
+    )
+    description: Optional[str] = Field(
+        default=None,
+        description="Optional description of the voice.",
+    )
+    age: Optional[int] = Field(
+        default=None,
+        description="Optional age of the voice.",
+    )
+    language: Optional[int] = Field(
+        default=None,
+        description="Optional language code for the voice.",
+    )
+
+
+class CambVoiceCloneTool(CambBaseTool):
+    """Tool for cloning voices using CAMB AI.
+
+    This tool creates a new voice from a 2+ second audio sample.
+    The cloned voice can then be used with TTS tools.
+
+    Example:
+        ```python
+        from langchain_camb import CambVoiceCloneTool
+
+        clone = CambVoiceCloneTool()
+        result = clone.invoke({
+            "voice_name": "My Custom Voice",
+            "audio_file_path": "/path/to/audio.wav",
+            "gender": 2  # Female
+        })
+        print(result)  # JSON with new voice_id
+        ```
+    """
+
+    name: str = "camb_voice_clone"
+    description: str = (
+        "Clone a voice from an audio sample using CAMB AI. "
+        "Requires 2+ seconds of audio. "
+        "Returns the new voice ID that can be used with TTS tools. "
+        "Gender: 1=Male, 2=Female, 0=Not Specified."
+    )
+    args_schema: Type[BaseModel] = VoiceCloneInput
+
+    def _run(
+        self,
+        voice_name: str,
+        audio_file_path: str,
+        gender: int,
+        description: Optional[str] = None,
+        age: Optional[int] = None,
+        language: Optional[int] = None,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        """Clone a voice synchronously.
+
+        Returns:
+            JSON string with new voice_id and details.
+        """
+        with open(audio_file_path, "rb") as f:
+            kwargs = {
+                "voice_name": voice_name,
+                "gender": gender,
+                "file": f,
+            }
+
+            if description:
+                kwargs["description"] = description
+            if age:
+                kwargs["age"] = age
+            if language:
+                kwargs["language"] = language
+
+            result = self.sync_client.voice_cloning.create_custom_voice(**kwargs)
+
+        return self._format_result(result, voice_name)
+
+    async def _arun(
+        self,
+        voice_name: str,
+        audio_file_path: str,
+        gender: int,
+        description: Optional[str] = None,
+        age: Optional[int] = None,
+        language: Optional[int] = None,
+        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
+    ) -> str:
+        """Clone a voice asynchronously.
+
+        Returns:
+            JSON string with new voice_id and details.
+        """
+        with open(audio_file_path, "rb") as f:
+            kwargs = {
+                "voice_name": voice_name,
+                "gender": gender,
+                "file": f,
+            }
+
+            if description:
+                kwargs["description"] = description
+            if age:
+                kwargs["age"] = age
+            if language:
+                kwargs["language"] = language
+
+            result = await self.async_client.voice_cloning.create_custom_voice(**kwargs)
+
+        return self._format_result(result, voice_name)
+
+    def _format_result(self, result, voice_name: str) -> str:
+        """Format the voice clone result as JSON."""
+        output = {
+            "voice_id": getattr(result, "voice_id", getattr(result, "id", None)),
+            "voice_name": voice_name,
+            "status": "created",
+        }
+
+        if hasattr(result, "message"):
+            output["message"] = result.message
+
+        return json.dumps(output, indent=2)

langchain_camb/tools/voice_list.py

@@ -0,0 +1,108 @@
+"""Voice list tool for CAMB AI."""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Optional, Type
+
+from langchain_core.callbacks import (
+    AsyncCallbackManagerForToolRun,
+    CallbackManagerForToolRun,
+)
+from pydantic import BaseModel
+
+from langchain_camb.tools.base import CambBaseTool
+
+
+class VoiceListInput(BaseModel):
+    """Input schema for Voice List tool (no parameters required)."""
+
+    pass
+
+
+class CambVoiceListTool(CambBaseTool):
+    """Tool for listing available voices from CAMB AI.
+
+    This tool retrieves all available voices that can be used with TTS tools.
+    Returns voice ID, name, gender, age, and language information.
+
+    Example:
+        ```python
+        from langchain_camb import CambVoiceListTool
+
+        voice_list = CambVoiceListTool()
+        voices = voice_list.invoke({})
+        print(voices)  # JSON list of available voices
+        ```
+    """
+
+    name: str = "camb_voice_list"
+    description: str = (
+        "List all available voices from CAMB AI. "
+        "Returns voice IDs, names, genders, ages, and languages. "
+        "Use this to find the right voice_id for TTS tools."
+    )
+    args_schema: Type[BaseModel] = VoiceListInput
+
+    def _run(
+        self,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        """Get list of available voices synchronously.
+
+        Returns:
+            JSON string containing list of voices with id, name, gender, age, language.
+        """
+        voices = self.sync_client.voice_cloning.list_voices()
+        return self._format_voices(voices)
+
+    async def _arun(
+        self,
+        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
+    ) -> str:
+        """Get list of available voices asynchronously.
+
+        Returns:
+            JSON string containing list of voices with id, name, gender, age, language.
+        """
+        voices = await self.async_client.voice_cloning.list_voices()
+        return self._format_voices(voices)
+
+    def _format_voices(self, voices: list[Any]) -> str:
+        """Format voice list as JSON."""
+        voice_list = []
+        for voice in voices:
+            # Handle both dict and object responses
+            if isinstance(voice, dict):
+                voice_list.append(
+                    {
+                        "id": voice.get("id"),
+                        "name": voice.get("voice_name", voice.get("name", "Unknown")),
+                        "gender": self._gender_to_string(voice.get("gender", 0)),
+                        "age": voice.get("age"),
+                        "language": voice.get("language"),
+                    }
+                )
+            else:
+                voice_list.append(
+                    {
+                        "id": getattr(voice, "id", None),
+                        "name": getattr(voice, "voice_name", getattr(voice, "name", "Unknown")),
+                        "gender": self._gender_to_string(getattr(voice, "gender", 0)),
+                        "age": getattr(voice, "age", None),
+                        "language": getattr(voice, "language", None),
+                    }
+                )
+
+        return json.dumps(voice_list, indent=2)
+
+    @staticmethod
+    def _gender_to_string(gender: int) -> str:
+        """Convert gender integer to string."""
+        gender_map = {
+            0: "not_specified",
+            1: "male",
+            2: "female",
+            9: "not_applicable",
+        }
+        return gender_map.get(gender, "unknown")

langchain_camb/version.py

@@ -0,0 +1,3 @@
+"""Version information for langchain-camb."""
+
+__version__ = "0.1.0"