videosdkagent-cli 0.0.1__py2.py3-none-any.whl

videosdk_cli/utils/template_helper.py

@@ -0,0 +1,204 @@
+from pathlib import Path
+import json
+import aiohttp
+from datetime import datetime, timedelta
+from rich.console import Console
+from InquirerPy import inquirer
+from videosdk_cli.utils.config_manager import get_config_value
+import os
+
+console = Console()
+
+CACHE_DIR = Path.home() / ".videosdk"
+CACHE_DIR.mkdir(exist_ok=True)
+CACHE_FILE = CACHE_DIR / "template_cache.json"
+TIMESTAMP_FILE = CACHE_DIR / "template_cache_timestamp.txt"
+CDN_BASE_URL = os.environ.get("CDN_URL","https://probargaining-lynda-contradictiously.ngrok-free.dev/cdn")
+API_BASE_URL = os.environ.get("API_BASE_URL","http://localhost:8000")
+
+
+PROVIDER_IMPORTS = {
+    "DeepgramSTT":       ("videosdk.plugins.deepgram", "DeepgramSTT", "STT", "deepgram", "DEEPGRAM_API_KEY"),
+    "GoogleSTT":         ("videosdk.plugins.google", "GoogleSTT", "STT", "google-cloud-speech","GOOGLE_API_KEY"),
+    "OpenAISTT":         ("videosdk.plugins.openai", "OpenAISTT", "STT", "openai", "OPENAI_API_KEY"),
+
+    "OpenAILLM":         ("videosdk.plugins.openai", "OpenAILLM", "LLM", "openai", "OPENAI_API_KEY"),
+    "GoogleLLM":         ("videosdk.plugins.google", "GoogleLLM", "LLM", "google-cloud-language", "GOOGLE_API_KEY"),
+
+    "ElevenLabsTTS":     ("videosdk.plugins.elevenlabs", "ElevenLabsTTS", "TTS", "elevenlabs", "ELEVENLABS_API_KEY"),
+    "OpenAITTS":         ("videosdk.plugins.openai", "OpenAITTS", "TTS", "openai", "OPENAI_API_KEY"),
+    "GoogleTTS":         ("videosdk.plugins.google", "GoogleTTS", "TTS", "google-cloud-texttospeech", "GOOGLE_API_KEY"),
+    "DeepgramTTS":       ("videosdk.plugins.deepgram", "DeepgramTTS", "TTS", "deepgram", "DEEPGRAM_API_KEY"),
+
+    "OpenAIRealtime":    ("videosdk.plugins.openai", "OpenAIRealtime", "Realtime", "openai", "OPENAI_API_KEY"),
+    "GeminiRealtime":    ("videosdk.plugins.google", "GeminiRealtime", "Realtime", "google-cloud-realtime", "GOOGLE_API_KEY"),
+}
+
+STATIC_REQUIREMENTS = [
+    "videosdk",
+    "aiohttp",
+    "rich",
+    "videosdk.agents",
+    "videosdk.plugins.silero",
+    "videosdk.plugins.turn_detector",
+]
+
+
+async def fetch_template_cache(force_refresh=False):
+    """Fetch template metadata JSON from server if cache missing or expired."""
+    if TIMESTAMP_FILE.exists() and not force_refresh:
+        ts = datetime.fromisoformat(TIMESTAMP_FILE.read_text(encoding="utf-8"))
+        if datetime.now() - ts < timedelta(hours=24) and CACHE_FILE.exists():
+            console.print("[green]Using cached template metadata[/green]")
+            return
+
+    token = get_config_value("VIDEOSDK_AUTH_TOKEN")
+    if not token:
+        console.print("[red]VIDEOSDK_AUTH_TOKEN not set[/red]")
+        return
+
+    console.print("Fetching latest template metadata from server...")
+
+    try:
+        import aiohttp
+
+        timeout = aiohttp.ClientTimeout(total=10)
+        async with aiohttp.ClientSession(timeout=timeout) as session:
+            async with session.get(
+                f"{API_BASE_URL}/v2/cli/templates",
+                headers={
+                    "Accept": "application/json",
+                    "Authorization": f"{token}",
+                },
+            ) as resp:
+                if resp.status != 200:
+                    console.print(
+                        f"[red]Failed to fetch template metadata: {resp.status}[/red]"
+                    )
+                    return
+                data = await resp.json()
+                templateResponse = data.get("templates", {})
+                CACHE_FILE.write_text(json.dumps(templateResponse, indent=4), encoding="utf-8")
+                TIMESTAMP_FILE.write_text(datetime.now().isoformat(), encoding="utf-8")
+                console.print("[green]Template metadata cache updated.[/green]")
+
+    except Exception as e:
+        console.print(f"[red]Error fetching template metadata: {e}[/red]")
+
+async def select_provider_arrow(prompt_message: str, options: list[str]) -> str:
+    """Arrow-based selection for providers."""
+    choice = await inquirer.select(
+        message=prompt_message,
+        choices=options,
+        pointer="👉",
+        instruction="Use ↑ ↓ to navigate, Enter to select",
+    ).execute_async()
+    return choice
+
+
+def generate_cascading_providers(providers: dict):
+    """Generate imports and modules for cascading pipeline."""
+    imports = []
+    provider_modules = []
+    for key in ["STT", "LLM", "TTS"]:
+        provider_class = providers.get(key)
+        if provider_class and provider_class in PROVIDER_IMPORTS:
+            module, class_name, _, _, _ = PROVIDER_IMPORTS[provider_class]
+            imports.append(f"from {module} import {class_name}")
+            provider_modules.append(module)
+    return imports, provider_modules
+
+
+def generate_realtime_providers(providers: dict):
+    """Generate imports and modules for realtime pipeline."""
+    imports = []
+    provider_modules = []
+    provider_class = providers.get("Realtime")
+    if provider_class and provider_class in PROVIDER_IMPORTS:
+        module, class_name, _, _, _ = PROVIDER_IMPORTS[provider_class]
+        imports.append(f"from {module} import {class_name}")
+        provider_modules.append(module)
+    return imports, provider_modules
+
+
+def write_template_file(app_dir: Path, filename: str, imports_str: str, template_code: str):
+    file_path = app_dir / filename
+    file_path.write_text(f"{imports_str}\n\n{template_code}", encoding="utf-8")
+
+
+def write_config(
+    app_dir: Path,
+    template_id: str,
+    file_name: str,
+    description: str,
+    providers: dict,
+    env_path: str = None,
+    auto_configured: bool = True,
+    requirements_installed: bool = False
+):
+    """Write project config.json with both template ID and file name."""
+    config_data = {
+        "template_id": template_id,        
+        "template_file": file_name,        
+        "description": description,
+        "providers": providers,
+        "auto_configured": auto_configured,
+        "requirements_installed": requirements_installed,
+    }
+    if env_path:
+        config_data["venv_path"] = env_path
+
+    (app_dir / "config.json").write_text(
+        json.dumps(config_data, indent=4),
+        encoding="utf-8"
+    )
+
+def write_requirements(app_dir: Path, requirements: list):
+    (app_dir / "requirements.txt").write_text("\n".join(sorted(set(requirements))), encoding="utf-8")
+
+def write_env_file(app_dir: Path, selected_providers: dict, api_keys: dict):
+    """Create a .env file with API keys and auth token."""
+    from collections import OrderedDict
+    auth_token = get_config_value("VIDEOSDK_AUTH_TOKEN") or ""
+
+    env_vars = OrderedDict()
+    env_vars["VIDEOSDK_AUTH_TOKEN"] = auth_token
+
+    for provider in selected_providers.values():
+        env_var_name = PROVIDER_IMPORTS.get(
+            provider,
+            (None, None, None, None, f"{provider.upper()}_API_KEY")
+        )[-1]
+        env_vars[env_var_name] = api_keys.get(provider, "")
+
+    env_content = "\n".join(f"{key}={value}" for key, value in env_vars.items())
+    (app_dir / ".env").write_text(env_content, encoding="utf-8")
+
+async def prompt_provider_api_keys(providers: dict, api_keys: dict = None) -> dict:
+    """Ask user for API keys for selected providers. Skip if already in api_keys."""
+    if api_keys is None:
+        api_keys = {}
+
+    for provider in providers.values():
+        if provider in api_keys:
+            continue
+
+        key = await inquirer.text(
+            message=f"Enter API key for {provider}:",
+            validate=lambda val: len(val.strip()) > 0 or "API key cannot be empty"
+        ).execute_async()
+
+        api_keys[provider] = key
+
+    return api_keys
+
+async def prompt_existing_env():
+    """Ask user whether to use an existing Python environment."""
+    use_existing = await select_provider_arrow(
+        "Do you want to use an existing Python environment (venv/conda)?",
+        ["No, create new venv", "Yes, I have an environment"]
+    )
+    if use_existing == "Yes, I have an environment":
+        path = input("Enter the path to your environment: ").strip()
+        return Path(path)
+    return None

videosdk_cli/utils/template_options.py

@@ -0,0 +1,51 @@
+from pathlib import Path
+import json
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+
+CACHE_DIR = Path.home() / ".videosdk"
+CACHE_DIR.mkdir(exist_ok=True)
+CACHE_FILE = CACHE_DIR / "template_cache.json"
+CACHE_TIMESTAMP_FILE = CACHE_DIR / "template_cache_timestamp.txt"
+
+@dataclass
+class Template:
+    """Represents a VideoSDK template."""
+    file_name: str
+    description: str
+    mode: str
+    pipe_type: str
+    STT_options: list = None
+    LLM_options: list = None
+    TTS_options: list = None
+    provider_options: list = None
+
+class KeyValuePair:
+    """Loads templates from cached JSON metadata."""
+    def __init__(self, cache_file=CACHE_FILE):
+        self.templates = {}
+        if cache_file.exists():
+            try:
+                data = json.loads(cache_file.read_text(encoding="utf-8"))
+                for name, info in data.items():
+                    self.templates[name] = Template(
+                        file_name=info.get("file_name"),
+                        description=info.get("description"),
+                        mode=info.get("mode"),
+                        pipe_type=info.get("pipe_type"),
+                        STT_options=info.get("STT_options"),
+                        LLM_options=info.get("LLM_options"),
+                        TTS_options=info.get("TTS_options"),
+                        provider_options=info.get("provider_options")
+                    )
+            except Exception as e:
+                print(f"[red]Failed to load template cache: {e}[/red]")
+                self.templates = {}
+
+    def get_template_names(self):
+        """Return list of template names."""
+        return list(self.templates.keys())
+
+    def get_template(self, name: str):
+        """Return Template object by name."""
+        return self.templates.get(name)

videosdk_cli/utils/ui/kv_blocks.py

@@ -0,0 +1,8 @@
+def print_kv_blocks(items):
+    max_key_len = max(len(k) for item in items for k in item.keys())
+
+    for idx, item in enumerate(items):
+        for key, value in item.items():
+            print(f"{key.ljust(max_key_len)} : {value}")
+        if idx != len(items) - 1:
+            print()

videosdk_cli/utils/ui/progress_runner.py

@@ -0,0 +1,53 @@
+import asyncio
+import contextlib
+from rich.progress import Progress, BarColumn, TextColumn, TimeElapsedColumn
+
+
+async def run_with_progress(
+    coro,
+    *,
+    console,
+    title: str = "Working",
+    duration: float = 10.0,
+):
+    with Progress(
+        TextColumn(f"[bold cyan]{title}"),
+        BarColumn(bar_width=None),
+        TextColumn("{task.percentage:>3.0f}%"),
+        TimeElapsedColumn(),
+        console=console,
+    ) as progress:
+
+        task_id = progress.add_task("progress", total=100)
+        start_time = asyncio.get_event_loop().time()
+
+        api_task = asyncio.create_task(coro)
+
+        try:
+            while True:
+                elapsed = asyncio.get_event_loop().time() - start_time
+                percent = min((elapsed / duration) * 95, 95)
+
+                progress.update(task_id, completed=percent)
+
+                if api_task.done() and elapsed >= duration:
+                    break
+
+                await asyncio.sleep(0.1)
+
+            result = await api_task
+            progress.update(task_id, completed=100)
+            return result
+
+        except asyncio.CancelledError:
+            raise
+
+        finally:
+            if not api_task.done():
+                api_task.cancel()
+
+            with contextlib.suppress(
+                asyncio.CancelledError,
+                Exception,
+            ):
+                await api_task

videosdk_cli/utils/videosdk_yaml_helper.py

@@ -0,0 +1,75 @@
+import yaml
+from pathlib import Path
+from dataclasses import dataclass, asdict
+from typing import Optional
+
+
+@dataclass
+class AgentConfig:
+    templateId: Optional[str] = None
+    id: Optional[str] = None
+    name: Optional[str] = None
+    image: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        # Filter keys to only those present in the dataclass
+        return cls(**{
+            k: v for k, v in data.items() 
+            if k in cls.__annotations__
+        })
+
+@dataclass
+class VideosdkYamlConfig:
+    agent: AgentConfig
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        agent_data = data.get("agent", {})
+        # If agent_data is None (key exists but empty), default to empty dict
+        if agent_data is None:
+            agent_data = {}
+        return cls(agent=AgentConfig.from_dict(agent_data))
+
+def update_agent_config(app_dir: Path, agent_config: AgentConfig):
+    videosdk_dir = app_dir
+    videosdk_dir.mkdir(parents=True, exist_ok=True)
+    
+    config_file = videosdk_dir / "videosdk.yaml"
+    
+    config_data = {}
+    
+    if config_file.exists():
+        try:
+            with open(config_file, "r") as f:
+                config_data = yaml.safe_load(f) or {}
+        except yaml.YAMLError:
+            pass
+            
+    # Load into dataclass structure
+    yaml_config = VideosdkYamlConfig.from_dict(config_data)
+    
+    # Update agent fields dynamically from the passed AgentConfig object
+    # We iterate over fields in the passed config and update if they are not None
+    
+    updates = asdict(agent_config)
+    for key, value in updates.items():
+        if value is not None and hasattr(yaml_config.agent, key):
+             setattr(yaml_config.agent, key, value)
+    
+    # Convert back to dict and clean None values
+    raw_output = asdict(yaml_config)
+
+    output_data = clean_nones(raw_output)
+
+    # Write to YAML
+    with open(config_file, "w") as f:
+        yaml.dump(output_data, f, default_flow_style=False, sort_keys=False)
+
+# Helper to remove None values recursively
+def clean_nones(value):
+    if isinstance(value, dict):
+        return {k: clean_nones(v) for k, v in value.items() if v is not None}
+    if isinstance(value, list):
+        return [clean_nones(v) for v in value if v is not None]
+    return value

videosdkagent_cli-0.0.1.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: videosdkagent-cli
+Version: 0.0.1
+Summary: VideoSDK CLI tool
+Author-email: Krishna <krishna@videosdk.live>
+Requires-Dist: aiohttp>=3.9.0
+Requires-Dist: click>=8.1.0
+Requires-Dist: docker-image-py>=0.1.13
+Requires-Dist: fastapi>=0.111.0
+Requires-Dist: inquirerpy>=0.3.1
+Requires-Dist: nest-asyncio>=1.5
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: uvicorn>=0.25.0

videosdkagent_cli-0.0.1.dist-info/RECORD

@@ -0,0 +1,28 @@
+videosdk_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+videosdk_cli/auth.py,sha256=2xMKx_oWKZN-jxhvL8fHJ1MoYO9OuIFZ2MmYRJ2i-sg,1872
+videosdk_cli/build.py,sha256=KW6nDFI0cTuQjCzP4gtS4SdMnZjT9poLJdffq-9R5Ko,16202
+videosdk_cli/main.py,sha256=PYjRDxGtL3rmDEaN3pkYoEprAfwWxTSdBi-niZXoisE,2452
+videosdk_cli/projects.py,sha256=DG83uO0gUjkMHNhaJ6WjCKTsWfJeDc4g85igo_9YIQM,4314
+videosdk_cli/run_agent.py,sha256=3Rlki35Q3cTnJnYCbFiCE9EoHfLnQCq79skH-JCA-oA,3205
+videosdk_cli/secret_set.py,sha256=1sVQxuPAcplDWJGM5Jm9mo5gNHBaaV9u0T9HDq6F0iM,2539
+videosdk_cli/templates.py,sha256=ph9zsROqp5HUM_N-YzXeGvUxyT10Q0XsUQfTpQvJj6g,6564
+videosdk_cli/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+videosdk_cli/utils/analytics.py,sha256=7qrVEVi2rU9Runz2CZrtJA5PlrjQJLiTvGfgn83YSog,1968
+videosdk_cli/utils/api_client.py,sha256=JKfVBc2QaC0tffnloTRnijaa3Z2EaSS8LkAVXxJ5EgE,3533
+videosdk_cli/utils/auth_api_client.py,sha256=5dp2gibuC7YEczeWDjbLKGRQxOTQK3QeMea3LCO0yx8,1379
+videosdk_cli/utils/config_manager.py,sha256=yygGOp-CaU1KINClLZC7nFKI8Ob7vzuL-7cBP20dNEU,1893
+videosdk_cli/utils/exceptions.py,sha256=1Tjxxmw8Ts8DOQEZqnJBmNAFgJ0CpcHkAQ95RLQs4iw,133
+videosdk_cli/utils/project_config.py,sha256=X-jro6nUDkZ1ZTdJ324JfqE8_0MCZMyGqGUDhM_e0Rs,3141
+videosdk_cli/utils/template_helper.py,sha256=eVMhgWnASNqRB5hkKrefG3yM3jlLb4Duxx8x8B4u2MM,8220
+videosdk_cli/utils/template_options.py,sha256=BFNCmn6lLUCJ-eZ9TkhVbRtMNTP89EVm8MHhZQv61Q0,1872
+videosdk_cli/utils/videosdk_yaml_helper.py,sha256=kXdO5ZkEyV_OptCOd_NFNSGCZKv_J8nAwIXwFtxXbkc,2303
+videosdk_cli/utils/apis/deployment_client.py,sha256=KyScSq6CGm1fX2vus7hS1_whSCfYFkyk0ItRNBYq6dY,6359
+videosdk_cli/utils/apis/error.py,sha256=UgJI1a0ZU1ZYKAxz01pOKhFYP1XrIsz8JQVVv7XwgDc,248
+videosdk_cli/utils/apis/videosdk_auth_api_client.py,sha256=_yJg4nE6WQ9s1mKvYCS0EdHz7kbrXVJabQ30VFcMSo8,1896
+videosdk_cli/utils/manager/agent_manager.py,sha256=Yf7hjn_2krpYl01kwL-T9rRPRRF7ay0nI4dZRHrB1TE,12142
+videosdk_cli/utils/ui/kv_blocks.py,sha256=_KJZ0_q7AbaIDIh9kx6VvHuSQ3AN5fYo-vsMjYIBbFM,288
+videosdk_cli/utils/ui/progress_runner.py,sha256=UhXgoQGDOKW3bSZuXy8BxCfFy_g9QpYOijeO3xJq_8Y,1380
+videosdkagent_cli-0.0.1.dist-info/METADATA,sha256=Jpm5Rm-EhOF6nW0fAMfQtmxL0_i48Ru5zCfJA1aryuc,449
+videosdkagent_cli-0.0.1.dist-info/WHEEL,sha256=aha0VrrYvgDJ3Xxl3db_g_MDIW-ZexDdrc_m-Hk8YY4,105
+videosdkagent_cli-0.0.1.dist-info/entry_points.txt,sha256=7qv3V6B64WCwEshsIsTUc3fYcg6iNbnVJJOc6WE4U1E,51
+videosdkagent_cli-0.0.1.dist-info/RECORD,,

videosdkagent_cli-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any

videosdkagent_cli-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+videosdk = videosdk_cli.main:cli