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

videosdk_cli/utils/template_helper.py

@@ -13,25 +13,89 @@ 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")
+CDN_BASE_URL = "https://cdn.videosdk.live"
+API_BASE_URL = "https://api.videosdk.live"
+DASHBOARD_URL = "https://stage.app.videosdk.live"
 
 
 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"),
+    "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 = [
@@ -78,13 +142,16 @@ async def fetch_template_cache(force_refresh=False):
                     return
                 data = await resp.json()
                 templateResponse = data.get("templates", {})
-                CACHE_FILE.write_text(json.dumps(templateResponse, indent=4), encoding="utf-8")
+                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(
@@ -121,7 +188,9 @@ def generate_realtime_providers(providers: dict):
     return imports, provider_modules
 
 
-def write_template_file(app_dir: Path, filename: str, imports_str: str, template_code: str):
+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")
 
@@ -134,12 +203,12 @@ def write_config(
     providers: dict,
     env_path: str = None,
     auto_configured: bool = True,
-    requirements_installed: bool = False
+    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,        
+        "template_id": template_id,
+        "template_file": file_name,
         "description": description,
         "providers": providers,
         "auto_configured": auto_configured,
@@ -149,16 +218,20 @@ def write_config(
         config_data["venv_path"] = env_path
 
     (app_dir / "config.json").write_text(
-        json.dumps(config_data, indent=4),
-        encoding="utf-8"
+        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")
+    (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()
@@ -166,14 +239,14 @@ def write_env_file(app_dir: Path, selected_providers: dict, api_keys: dict):
 
     for provider in selected_providers.values():
         env_var_name = PROVIDER_IMPORTS.get(
-            provider,
-            (None, None, None, None, f"{provider.upper()}_API_KEY")
+            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:
@@ -185,18 +258,19 @@ async def prompt_provider_api_keys(providers: dict, api_keys: dict = None) -> di
 
         key = await inquirer.text(
             message=f"Enter API key for {provider}:",
-            validate=lambda val: len(val.strip()) > 0 or "API key cannot be empty"
+            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"]
+        ["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()

videosdk_cli/utils/ui/progress_runner.py

@@ -26,19 +26,27 @@ async def run_with_progress(
         try:
             while True:
                 elapsed = asyncio.get_event_loop().time() - start_time
-                percent = min((elapsed / duration) * 95, 95)
 
+                # Check if task is done - complete immediately if so
+                if api_task.done():
+                    result = await api_task
+                    progress.update(task_id, completed=100)
+                    return result
+
+                # Update progress based on elapsed time (up to 95% until task completes)
+                # Duration is the maximum expected time
+                percent = min((elapsed / duration) * 95, 95)
                 progress.update(task_id, completed=percent)
 
-                if api_task.done() and elapsed >= duration:
-                    break
+                # If we've exceeded the maximum duration, break and wait for task
+                if elapsed >= duration:
+                    # Task might still be running, wait for it
+                    result = await api_task
+                    progress.update(task_id, completed=100)
+                    return result
 
                 await asyncio.sleep(0.1)
 
-            result = await api_task
-            progress.update(task_id, completed=100)
-            return result
-
         except asyncio.CancelledError:
             raise
 

videosdk_cli/utils/ui/theme.py

@@ -0,0 +1,144 @@
+"""
+VideoSDK CLI Theme and Styling
+
+Brand Colors:
+- Primary: #D1BCFE (light purple/lavender)
+- Secondary: #37265E (dark purple)
+"""
+
+from rich.console import Console
+from rich.theme import Theme
+from rich.panel import Panel
+from rich.text import Text
+from rich.style import Style
+
+# VideoSDK Brand Colors
+PRIMARY = "#D1BCFE"
+SECONDARY = "#37265E"
+SUCCESS = "#50FA7B"
+ERROR = "#FF5555"
+WARNING = "#FFB86C"
+INFO = "#8BE9FD"
+MUTED = "#6272A4"
+
+# Custom theme for Rich
+VIDEOSDK_THEME = Theme(
+    {
+        "primary": PRIMARY,
+        "secondary": SECONDARY,
+        "success": SUCCESS,
+        "error": ERROR,
+        "warning": WARNING,
+        "info": INFO,
+        "muted": MUTED,
+        "header": f"bold {PRIMARY}",
+        "highlight": f"bold {PRIMARY}",
+        "command": f"bold {INFO}",
+        "path": f"italic {MUTED}",
+    }
+)
+
+# Create themed console
+console = Console(theme=VIDEOSDK_THEME)
+
+
+# ASCII Art Banner - Simple and clean
+BANNER = f"""
+[{PRIMARY}]╭────────────────────────────────────────────────────────────────────╮[/{PRIMARY}]
+[{PRIMARY}]│[/{PRIMARY}]                                                                    [{PRIMARY}]│[/{PRIMARY}]
+[{PRIMARY}]│[/{PRIMARY}]  [bold {PRIMARY}]██╗   ██╗██╗██████╗ ███████╗ ██████╗ ███████╗██████╗ ██╗  ██╗[/bold {PRIMARY}]  [{PRIMARY}]│[/{PRIMARY}]
+[{PRIMARY}]│[/{PRIMARY}]  [bold {PRIMARY}]██║   ██║██║██╔══██╗██╔════╝██╔═══██╗██╔════╝██╔══██╗██║ ██╔╝[/bold {PRIMARY}]  [{PRIMARY}]│[/{PRIMARY}]
+[{PRIMARY}]│[/{PRIMARY}]  [bold {PRIMARY}]██║   ██║██║██║  ██║█████╗  ██║   ██║███████╗██║  ██║█████╔╝[/bold {PRIMARY}]   [{PRIMARY}]│[/{PRIMARY}]
+[{PRIMARY}]│[/{PRIMARY}]  [bold {PRIMARY}]╚██╗ ██╔╝██║██║  ██║██╔══╝  ██║   ██║╚════██║██║  ██║██╔═██╗[/bold {PRIMARY}]   [{PRIMARY}]│[/{PRIMARY}]
+[{PRIMARY}]│[/{PRIMARY}]  [bold {PRIMARY}] ╚████╔╝ ██║██████╔╝███████╗╚██████╔╝███████║██████╔╝██║  ██╗[/bold {PRIMARY}]  [{PRIMARY}]│[/{PRIMARY}]
+[{PRIMARY}]│[/{PRIMARY}]  [bold {PRIMARY}]  ╚═══╝  ╚═╝╚═════╝ ╚══════╝ ╚═════╝ ╚══════╝╚═════╝ ╚═╝  ╚═╝[/bold {PRIMARY}]  [{PRIMARY}]│[/{PRIMARY}]
+[{PRIMARY}]│[/{PRIMARY}]                                                                    [{PRIMARY}]│[/{PRIMARY}]
+[{PRIMARY}]│[/{PRIMARY}]        [{MUTED}]Your Complete Platform for Real-Time Communication[/{MUTED}]        [{PRIMARY}]│[/{PRIMARY}]
+[{PRIMARY}]│[/{PRIMARY}]                                                                    [{PRIMARY}]│[/{PRIMARY}]
+[{PRIMARY}]╰────────────────────────────────────────────────────────────────────╯[/{PRIMARY}]
+"""
+
+MINI_BANNER = """[bold #D1BCFE]◆ VideoSDK CLI[/bold #D1BCFE] [muted]v0.2.0[/muted]"""
+
+
+def print_banner(mini: bool = True):
+    """Print the VideoSDK banner."""
+    if mini:
+        console.print(MINI_BANNER)
+        console.print()
+    else:
+        console.print(BANNER)
+
+
+def print_header(text: str):
+    """Print a styled header."""
+    console.print()
+    console.print(f"[bold {PRIMARY}]◆[/bold {PRIMARY}] [bold white]{text}[/bold white]")
+    console.print()
+
+
+def print_success(text: str):
+    """Print a success message."""
+    console.print(f"[{SUCCESS}]✓[/{SUCCESS}] {text}")
+
+
+def print_error(text: str):
+    """Print an error message."""
+    console.print(f"[{ERROR}]✗[/{ERROR}] [bold {ERROR}]{text}[/bold {ERROR}]")
+
+
+def print_warning(text: str):
+    """Print a warning message."""
+    console.print(f"[{WARNING}]![/{WARNING}] {text}")
+
+
+def print_info(text: str):
+    """Print an info message."""
+    console.print(f"[{INFO}]ℹ[/{INFO}] {text}")
+
+
+def print_step(text: str, step: int = None, total: int = None):
+    """Print a step in a process."""
+    if step and total:
+        console.print(
+            f"[{PRIMARY}]▸[/{PRIMARY}] [{MUTED}][{step}/{total}][/{MUTED}] {text}"
+        )
+    else:
+        console.print(f"[{PRIMARY}]▸[/{PRIMARY}] {text}")
+
+
+def print_key_value(key: str, value: str):
+    """Print a key-value pair."""
+    console.print(f"  [{MUTED}]{key}:[/{MUTED}] [{PRIMARY}]{value}[/{PRIMARY}]")
+
+
+def print_divider():
+    """Print a divider line."""
+    console.print(f"[{MUTED}]{'─' * 60}[/{MUTED}]")
+
+
+def create_styled_table(title: str = None):
+    """Create a styled table with VideoSDK theme."""
+    from rich.table import Table
+
+    table = Table(
+        title=f"[bold {PRIMARY}]{title}[/bold {PRIMARY}]" if title else None,
+        show_header=True,
+        header_style=f"bold {PRIMARY}",
+        border_style=MUTED,
+        title_style=f"bold {PRIMARY}",
+        show_lines=True,
+        row_styles=[f"on {SECONDARY}20", ""],  # Alternating row colors
+    )
+    return table
+
+
+def styled_panel(content: str, title: str = None, subtitle: str = None):
+    """Create a styled panel."""
+    return Panel(
+        content,
+        title=f"[bold {PRIMARY}]{title}[/bold {PRIMARY}]" if title else None,
+        subtitle=f"[{MUTED}]{subtitle}[/{MUTED}]" if subtitle else None,
+        border_style=PRIMARY,
+        padding=(1, 2),
+    )

videosdk_cli/utils/videosdk_yaml_helper.py

@@ -1,6 +1,6 @@
 import yaml
 from pathlib import Path
-from dataclasses import dataclass, asdict
+from dataclasses import dataclass, asdict, field
 from typing import Optional
 
 
@@ -9,54 +9,203 @@ class AgentConfig:
     templateId: Optional[str] = None
     id: Optional[str] = None
     name: Optional[str] = None
-    image: Optional[str] = None
+    description: Optional[str] = None
+    image: Optional[str] = None  # Legacy v1.0 support
 
     @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__
-        })
+        return cls(**{k: v for k, v in data.items() if k in cls.__annotations__})
+
+
+@dataclass
+class BuildLogsConfig:
+    id: Optional[str] = None  # buildId from presigned URL response
+    enabled: Optional[bool] = None
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        if data is None:
+            return cls()
+        return cls(id=data.get("id"), enabled=data.get("enabled"))
+
+
+@dataclass
+class BuildConfig:
+    file: Optional[str] = None
+    image: Optional[str] = None
+    logs: Optional[BuildLogsConfig] = None
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        if data is None:
+            return cls()
+        logs_data = data.get("logs")
+        return cls(
+            file=data.get("file"),
+            image=data.get("image"),
+            logs=BuildLogsConfig.from_dict(logs_data) if logs_data else None,
+        )
+
+
+@dataclass
+class ReplicasConfig:
+    min: Optional[int] = None
+    max: Optional[int] = None
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        if data is None:
+            return cls()
+        return cls(**{k: v for k, v in data.items() if k in cls.__annotations__})
+
+
+@dataclass
+class DeployConfig:
+    id: Optional[str] = None  # deploymentId from API
+    replicas: Optional[ReplicasConfig] = None
+    profile: Optional[str] = None
+    region: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        if data is None:
+            return cls()
+        replicas_data = data.get("replicas")
+        return cls(
+            id=data.get("id"),
+            replicas=ReplicasConfig.from_dict(replicas_data) if replicas_data else None,
+            profile=data.get("profile"),
+            region=data.get("region"),
+        )
+
+
+@dataclass
+class SecretsConfig:
+    env: Optional[str] = None
+    image_pull: Optional[str] = None  # maps from 'image-pull' in YAML
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        if data is None:
+            return cls()
+        return cls(env=data.get("env"), image_pull=data.get("image-pull"))
+
 
 @dataclass
 class VideosdkYamlConfig:
-    agent: AgentConfig
+    version: Optional[str] = None
+    agent: Optional[AgentConfig] = None
+    build: Optional[BuildConfig] = None
+    deploy: Optional[DeployConfig] = None
+    secrets: Optional[SecretsConfig] = None
 
     @classmethod
     def from_dict(cls, data: dict):
         agent_data = data.get("agent", {})
+        build_data = data.get("build")
+        deploy_data = data.get("deploy")
+        secrets_data = data.get("secrets")
+
         # 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):
+        return cls(
+            version=data.get("version"),
+            agent=AgentConfig.from_dict(agent_data),
+            build=BuildConfig.from_dict(build_data) if build_data else None,
+            deploy=DeployConfig.from_dict(deploy_data) if deploy_data else None,
+            secrets=SecretsConfig.from_dict(secrets_data) if secrets_data else None,
+        )
+
+
+def update_agent_config(
+    app_dir: Path,
+    agent_config: AgentConfig = None,
+    deploy_config: DeployConfig = None,
+    build_config: BuildConfig = None,
+    secrets_config: SecretsConfig = None,
+):
+    """
+    Update the videosdk.yaml with agent, deploy, build, and/or secrets configuration.
+
+    Args:
+        app_dir: Directory where videosdk.yaml is located
+        agent_config: AgentConfig dataclass with agent fields to update
+        deploy_config: DeployConfig dataclass with deploy fields to update
+        build_config: BuildConfig dataclass with build fields to update
+        secrets_config: SecretsConfig dataclass with secrets fields to update
+    """
     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)
-    
+
+    # Update agent fields if provided
+    if agent_config:
+        if yaml_config.agent is None:
+            yaml_config.agent = AgentConfig()
+        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)
+
+    # Update deploy fields if provided
+    if deploy_config:
+        if yaml_config.deploy is None:
+            yaml_config.deploy = DeployConfig()
+        updates = asdict(deploy_config)
+        for key, value in updates.items():
+            if value is not None and hasattr(yaml_config.deploy, key):
+                # Handle nested ReplicasConfig
+                if key == "replicas" and isinstance(value, dict):
+                    if yaml_config.deploy.replicas is None:
+                        yaml_config.deploy.replicas = ReplicasConfig()
+                    for rkey, rvalue in value.items():
+                        if rvalue is not None:
+                            setattr(yaml_config.deploy.replicas, rkey, rvalue)
+                else:
+                    setattr(yaml_config.deploy, key, value)
+
+    # Update build fields if provided
+    if build_config:
+        if yaml_config.build is None:
+            yaml_config.build = BuildConfig()
+        updates = asdict(build_config)
+        for key, value in updates.items():
+            if value is not None and hasattr(yaml_config.build, key):
+                # Handle nested BuildLogsConfig
+                if key == "logs" and isinstance(value, dict):
+                    if yaml_config.build.logs is None:
+                        yaml_config.build.logs = BuildLogsConfig()
+                    for lkey, lvalue in value.items():
+                        if lvalue is not None:
+                            setattr(yaml_config.build.logs, lkey, lvalue)
+                else:
+                    setattr(yaml_config.build, key, value)
+
+    # Update secrets fields if provided
+    if secrets_config:
+        if yaml_config.secrets is None:
+            yaml_config.secrets = SecretsConfig()
+        updates = asdict(secrets_config)
+        for key, value in updates.items():
+            if value is not None and hasattr(yaml_config.secrets, key):
+                setattr(yaml_config.secrets, key, value)
+
     # Convert back to dict and clean None values
     raw_output = asdict(yaml_config)
 
@@ -66,10 +215,11 @@ def update_agent_config(app_dir: Path, agent_config: AgentConfig):
     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
+    return value

{videosdkagent_cli-0.0.1.dist-info → videosdkagent_cli-0.0.5.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: videosdkagent-cli
-Version: 0.0.1
+Version: 0.0.5
 Summary: VideoSDK CLI tool
-Author-email: Krishna <krishna@videosdk.live>
+Author-email: VIDEOSDK <sdk@videosdk.live>
 Requires-Dist: aiohttp>=3.9.0
 Requires-Dist: click>=8.1.0
 Requires-Dist: docker-image-py>=0.1.13

videosdkagent_cli-0.0.5.dist-info/RECORD

@@ -0,0 +1,28 @@
+videosdk_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+videosdk_cli/auth.py,sha256=A3tMffpoNoYFHkPFbl-84pjHXqLFLMMJ5oH0S_ruWTc,3495
+videosdk_cli/build.py,sha256=pUjKXhK-GCOvIDPBCYlyPM5SkBzIyW7Mditog8VmXC8,46545
+videosdk_cli/main.py,sha256=MS7os7BuOGOhFMcENx6LL5BXP16bGgCu5_FvdAIj3Hk,3217
+videosdk_cli/projects.py,sha256=e2xHqxTFGpGuGU4eVVfrMGnXX8PULJbREy7CTDHHr9s,4359
+videosdk_cli/run_agent.py,sha256=3Rlki35Q3cTnJnYCbFiCE9EoHfLnQCq79skH-JCA-oA,3205
+videosdk_cli/templates.py,sha256=CLGVGSR_HafIUIyqd1A7jNzMSXcszW5mxyb45eRkcPE,7627
+videosdk_cli/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+videosdk_cli/utils/analytics.py,sha256=4PLCURNI5xiULC3aOjdPRfmAP0JvwYDhwRSb_w84ynI,1975
+videosdk_cli/utils/api_client.py,sha256=ljBre_vaJtmrpwNoovJf6kcPSjLgNcLK_L4U2CNUDKI,3726
+videosdk_cli/utils/auth_api_client.py,sha256=5ins-e3B1QQlpkpQBWoBGGseVexchvXuO0BWSWzbSQA,1361
+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=r2O7mLe5TC3Sl-fJBduhifJz_Xb25bhKHS8pMTq6CR8,8729
+videosdk_cli/utils/template_options.py,sha256=BFNCmn6lLUCJ-eZ9TkhVbRtMNTP89EVm8MHhZQv61Q0,1872
+videosdk_cli/utils/videosdk_yaml_helper.py,sha256=IIb8HAF8cR4Mths4VHJG9bVy-2tnyGUUfVy8HiZjrLE,7426
+videosdk_cli/utils/apis/deployment_client.py,sha256=MIay-XUql5FUr4NmyqAHfB14z11Hu3FJSiFpWCu9V5U,10689
+videosdk_cli/utils/apis/error.py,sha256=UgJI1a0ZU1ZYKAxz01pOKhFYP1XrIsz8JQVVv7XwgDc,248
+videosdk_cli/utils/apis/videosdk_auth_api_client.py,sha256=w_Gpx_kpjzEtMa3zcL4Wb45NcC65ztpqPrmnRlAjxoQ,1863
+videosdk_cli/utils/manager/agent_manager.py,sha256=7SujOT5j7gbTNQ9KOmXfjqUS8-JBp9FYGbqPcnRTnxU,17021
+videosdk_cli/utils/ui/kv_blocks.py,sha256=_KJZ0_q7AbaIDIh9kx6VvHuSQ3AN5fYo-vsMjYIBbFM,288
+videosdk_cli/utils/ui/progress_runner.py,sha256=CHMQgU6ABKbD6AysMF1EVb3iBrnLqEC8OJPtCjuGYcA,1891
+videosdk_cli/utils/ui/theme.py,sha256=LJ4gEmOwSD5kXH-tesPJBGHlieVoJe1uxRwjtDnqkFY,5857
+videosdkagent_cli-0.0.5.dist-info/METADATA,sha256=pVFC6YFG3tpaJiJqUbOl6S_S_w0ZV6sGk5fKt78FyLs,446
+videosdkagent_cli-0.0.5.dist-info/WHEEL,sha256=aha0VrrYvgDJ3Xxl3db_g_MDIW-ZexDdrc_m-Hk8YY4,105
+videosdkagent_cli-0.0.5.dist-info/entry_points.txt,sha256=7qv3V6B64WCwEshsIsTUc3fYcg6iNbnVJJOc6WE4U1E,51
+videosdkagent_cli-0.0.5.dist-info/RECORD,,