pipecatcloud 0.2.12__tar.gz → 0.2.13__tar.gz

{pipecatcloud-0.2.12 → pipecatcloud-0.2.13}/CHANGELOG.md

@@ -5,6 +5,32 @@ All notable changes to **Pipecat Cloud** will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.13] - 2025-12-03
+
+### Added
+
+- Added `pcc organizations properties` commands for managing organization-level
+  configuration:
+
+  - `properties list` - Display current property values
+  - `properties set <name> <value>` - Update a property value
+  - `properties schema` - Show available properties with metadata and allowed
+    values
+
+- Added `pcc organizations default-region [region]` convenience command to get or
+  set the organization's default region.
+
+### Changed
+
+- Region is now optional for `secrets set`, `secrets image-pull-secret`, and
+  `deploy` commands. When `--region` is not specified, the API now uses the
+  organization's configured default region instead of the CLI defaulting to
+  `us-west`. The confirmation display shows the actual region that will be used
+  (e.g., "us-west (organization default)").
+
+- Removed deprecation warnings about region defaulting to `us-west`. The
+  organization's default region is now the source of truth.
+
 ## [0.2.12] - 2025-11-26
 
 ### Added

{pipecatcloud-0.2.12/src/pipecatcloud.egg-info → pipecatcloud-0.2.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pipecatcloud
-Version: 0.2.12
+Version: 0.2.13
 Summary: Cloud hosting for Pipecat AI applications
 License: BSD 2-Clause License
 Project-URL: Website, https://docs.pipecat.daily.co/

{pipecatcloud-0.2.12 → pipecatcloud-0.2.13}/src/pipecatcloud/api.py

@@ -266,11 +266,13 @@ class _API:
         """
         return self.create_api_method(self._secrets_list)
 
-    async def _secrets_upsert(self, data: dict, set_name: str, org: str, region: str) -> dict:
+    async def _secrets_upsert(self, data: dict, set_name: str, org: str, region: Optional[str] = None) -> dict:
         url = f"{self.construct_api_url('secrets_path').format(org=org)}/{set_name}"
 
-        # Add region to data payload
-        data = {**data, "region": region}
+        # Add region to data payload only if explicitly provided
+        # If not provided, API will use org's default region
+        if region:
+            data = {**data, "region": region}
 
         return await self._base_request("PUT", url, json=data) or {}
 
@@ -506,3 +508,57 @@ class _API:
             List of region objects with 'code' and 'display_name' fields
         """
         return self.create_api_method(self._regions)
+
+    # Organization Properties
+
+    async def _properties(self, org: str) -> dict | None:
+        url = self.construct_api_url("properties_path").format(org=org)
+        result = await self._base_request("GET", url, not_found_is_empty=True)
+        if result and "properties" in result:
+            return result["properties"]
+        return None
+
+    @property
+    def properties(self):
+        """Get current organization properties
+        Args:
+            org: Organization ID
+        Returns:
+            Dict of property names to current values
+        """
+        return self.create_api_method(self._properties)
+
+    async def _properties_schema(self, org: str) -> dict | None:
+        url = f"{self.construct_api_url('properties_path').format(org=org)}/schema"
+        result = await self._base_request("GET", url, not_found_is_empty=True)
+        if result and "properties" in result:
+            return result["properties"]
+        return None
+
+    @property
+    def properties_schema(self):
+        """Get organization properties schema with metadata
+        Args:
+            org: Organization ID
+        Returns:
+            Dict of property names to schema info (type, description, currentValue, default, availableValues)
+        """
+        return self.create_api_method(self._properties_schema)
+
+    async def _properties_update(self, org: str, properties: dict) -> dict | None:
+        url = self.construct_api_url("properties_path").format(org=org)
+        result = await self._base_request("PATCH", url, json=properties)
+        if result and "properties" in result:
+            return result["properties"]
+        return None
+
+    @property
+    def properties_update(self):
+        """Update organization properties
+        Args:
+            org: Organization ID
+            properties: Dict of property names to new values
+        Returns:
+            Updated properties dict
+        """
+        return self.create_api_method(self._properties_update)

{pipecatcloud-0.2.12 → pipecatcloud-0.2.13}/src/pipecatcloud/cli/commands/deploy.py

@@ -38,6 +38,7 @@ ALIVE_CHECK_SLEEP = 5
 
 async def _deploy(params: DeployConfigParams, org, force: bool = False):
     existing_agent = False
+    deployed_region = None  # Will be captured from API response
 
     # Check for an existing deployment with this agent name
     with Live(
@@ -381,18 +382,12 @@ def create_deploy_command(app: typer.Typer):
         partial_config.enable_managed_keys = managed_keys or partial_config.enable_managed_keys
         partial_config.agent_profile = profile or partial_config.agent_profile
 
-        # Handle region with warning if not specified
+        # Handle region - if not specified, API will use org's default region
         deploy_region = region or partial_config.region
-        if not deploy_region:
-            logger.warning(
-                "Region not specified, defaulting to 'us-west'. Please use --region to specify explicitly. "
-                "This default will be required in a future version."
-            )
-            deploy_region = "us-west"
-        partial_config.region = deploy_region
+        partial_config.region = deploy_region  # Can be None, API will use org default
 
-        # Validate region against API
-        if not await validate_region(deploy_region):
+        # Validate region if explicitly provided
+        if deploy_region and not await validate_region(deploy_region):
             valid_regions = await get_region_codes()
             console.error(
                 f"Invalid region '{deploy_region}'. Valid regions are: {', '.join(valid_regions)}"
@@ -432,11 +427,21 @@ def create_deploy_command(app: typer.Typer):
         else:
             table.add_row("Max agents", "[dim]Use existing or default[/dim]")
 
+        # Resolve region display - fetch org default if not explicitly specified
+        if partial_config.region:
+            region_display = f"[green]{partial_config.region}[/green]"
+        else:
+            # Fetch org's default region to show user what will be used
+            props, error = await API.properties(org)
+            if error:
+                return typer.Exit()
+            region_display = f"[green]{props['defaultRegion']}[/green] [dim](organization default)[/dim]"
+
         content = Group(
             (f"[bold white]Agent name:[/bold white] [green]{partial_config.agent_name}[/green]"),
             (f"[bold white]Image:[/bold white] [green]{partial_config.image}[/green]"),
             (f"[bold white]Organization:[/bold white] [green]{org}[/green]"),
-            (f"[bold white]Region:[/bold white] [green]{partial_config.region}[/green]"),
+            (f"[bold white]Region:[/bold white] {region_display}"),
             (f"[bold white]Secret set:[/bold white] {'[dim]None[/dim]' if not partial_config.secret_set else '[green] '+ partial_config.secret_set + '[/green]'}"),
             (f"[bold white]Image pull secret:[/bold white] {'[dim]None[/dim]' if not partial_config.image_credentials else '[green]' + partial_config.image_credentials + '[/green]'}"),
             (f"[bold white]Agent profile:[/bold white] {'[dim]None[/dim]' if not partial_config.agent_profile else '[green]' + partial_config.agent_profile + '[/green]'}"),

{pipecatcloud-0.2.12 → pipecatcloud-0.2.13}/src/pipecatcloud/cli/commands/organizations.py

@@ -25,7 +25,9 @@ organization_cli = typer.Typer(
     name="organizations", help="User organizations", no_args_is_help=True
 )
 keys_cli = typer.Typer(name="keys", help="API key management commands", no_args_is_help=True)
+properties_cli = typer.Typer(name="properties", help="Organization property management", no_args_is_help=True)
 organization_cli.add_typer(keys_cli)
+organization_cli.add_typer(properties_cli)
 
 
 # ---- Commands
@@ -385,3 +387,196 @@ async def use_key(
     except Exception as e:
         logger.debug(e)
         console.error("Unable to set default key in local config. Please contact support.")
+
+
+# ---- Properties Commands ----
+
+
+@properties_cli.command(name="list", help="List current organization property values.")
+@synchronizer.create_blocking
+@requires_login
+async def properties_list(
+    organization: str = typer.Option(
+        None,
+        "--organization",
+        "-o",
+        help="Organization to list properties for",
+    ),
+):
+    org = organization or config.get("org")
+
+    with console.status(
+        f"[dim]Fetching properties for organization: [bold]'{org}'[/bold][/dim]", spinner="dots"
+    ):
+        data, error = await API.properties(org)
+
+        if error:
+            return typer.Exit()
+
+    if not data:
+        console.print("[dim]No properties configured.[/dim]")
+        return
+
+    table = Table(
+        show_header=True,
+        show_lines=False,
+        border_style="dim",
+        box=box.SIMPLE,
+    )
+    table.add_column("Property", style="cyan")
+    table.add_column("Value", style="white")
+
+    for prop_name, prop_value in data.items():
+        table.add_row(prop_name, str(prop_value))
+
+    console.success(table, title_extra=f"Properties for organization: {org}")
+
+
+@properties_cli.command(name="schema", help="Show available properties with metadata.")
+@synchronizer.create_blocking
+@requires_login
+async def properties_schema(
+    organization: str = typer.Option(
+        None,
+        "--organization",
+        "-o",
+        help="Organization to show properties schema for",
+    ),
+):
+    org = organization or config.get("org")
+
+    with console.status(
+        f"[dim]Fetching properties schema for organization: [bold]'{org}'[/bold][/dim]",
+        spinner="dots",
+    ):
+        data, error = await API.properties_schema(org)
+
+        if error:
+            return typer.Exit()
+
+    if not data:
+        console.print("[dim]No properties available.[/dim]")
+        return
+
+    table = Table(
+        show_header=True,
+        show_lines=True,
+        border_style="dim",
+        box=box.SIMPLE,
+    )
+    table.add_column("Property", style="cyan")
+    table.add_column("Type")
+    table.add_column("Current Value", style="green")
+    table.add_column("Default")
+    table.add_column("Description")
+
+    for prop_name, prop_info in data.items():
+        current = prop_info.get("currentValue", "")
+        default = prop_info.get("default", "")
+        available = prop_info.get("availableValues")
+
+        # Show available values in description if present
+        description = prop_info.get("description", "")
+        if available:
+            description += f"\n[dim]Available: {', '.join(str(v) for v in available)}[/dim]"
+
+        table.add_row(
+            prop_name,
+            prop_info.get("type", ""),
+            str(current) if current is not None else "[dim]not set[/dim]",
+            str(default) if default is not None else "",
+            description,
+        )
+
+    console.success(table, title_extra=f"Properties schema for organization: {org}")
+
+
+@properties_cli.command(name="set", help="Update an organization property.")
+@synchronizer.create_blocking
+@requires_login
+async def properties_set(
+    property_name: str = typer.Argument(..., help="Name of the property to set"),
+    value: str = typer.Argument(..., help="Value to set"),
+    organization: str = typer.Option(
+        None,
+        "--organization",
+        "-o",
+        help="Organization to update property for",
+    ),
+):
+    org = organization or config.get("org")
+
+    with console.status(
+        f"[dim]Updating property [bold]'{property_name}'[/bold] for organization: [bold]'{org}'[/bold][/dim]",
+        spinner="dots",
+    ):
+        data, error = await API.properties_update(org, {property_name: value})
+
+        if error:
+            return typer.Exit()
+
+    if not data:
+        console.error("Failed to update property.")
+        return typer.Exit(1)
+
+    new_value = data.get(property_name, value)
+    console.success(
+        f"Property [bold cyan]{property_name}[/bold cyan] set to [bold green]{new_value}[/bold green]"
+    )
+
+
+# ---- Convenience Commands ----
+
+
+@organization_cli.command(name="default-region", help="Get or set the default region for an organization.")
+@synchronizer.create_blocking
+@requires_login
+async def default_region(
+    region: str = typer.Argument(None, help="Region to set as default (omit to show current)"),
+    organization: str = typer.Option(
+        None,
+        "--organization",
+        "-o",
+        help="Organization to configure",
+    ),
+):
+    org = organization or config.get("org")
+
+    if region:
+        # Set the default region
+        with console.status(
+            f"[dim]Setting default region to [bold]'{region}'[/bold] for organization: [bold]'{org}'[/bold][/dim]",
+            spinner="dots",
+        ):
+            data, error = await API.properties_update(org, {"defaultRegion": region})
+
+            if error:
+                return typer.Exit()
+
+        if not data:
+            console.error("Failed to update default region.")
+            return typer.Exit(1)
+
+        console.success(f"Default region set to [bold green]{data.get('defaultRegion', region)}[/bold green]")
+    else:
+        # Show the current default region
+        with console.status(
+            f"[dim]Fetching default region for organization: [bold]'{org}'[/bold][/dim]",
+            spinner="dots",
+        ):
+            data, error = await API.properties_schema(org)
+
+            if error:
+                return typer.Exit()
+
+        if not data or "defaultRegion" not in data:
+            console.print("[dim]No default region configured.[/dim]")
+            return
+
+        prop = data["defaultRegion"]
+        current = prop.get("currentValue", prop.get("default", "not set"))
+        available = prop.get("availableValues", [])
+
+        console.print(f"Default region: [bold green]{current}[/bold green]")
+        if available:
+            console.print(f"[dim]Available regions: {', '.join(available)}[/dim]")

{pipecatcloud-0.2.12 → pipecatcloud-0.2.13}/src/pipecatcloud/cli/commands/secrets.py

@@ -184,21 +184,12 @@ async def set(
 
     validate_secrets(secrets_dict)
 
-    # Handle region with warning if not specified
-    # CLI always sends region explicitly (PUT semantics), API validates it matches for existing sets
-    secret_region = region
-    if not secret_region:
-        logger.warning(
-            "Region not specified, defaulting to 'us-west'. Please use --region to specify explicitly. "
-            "This default will be required in a future version."
-        )
-        secret_region = "us-west"
-
-    # Validate region against API
-    if not await validate_region(secret_region):
+    # Validate region if explicitly provided
+    # If not provided, API will use org's default region
+    if region and not await validate_region(region):
         valid_regions = await get_region_codes()
         console.print(
-            f"[red]Invalid region '{secret_region}'. Valid regions are: {', '.join(valid_regions)}[/red]"
+            f"[red]Invalid region '{region}'. Valid regions are: {', '.join(valid_regions)}[/red]"
         )
         return typer.Exit(1)
 
@@ -213,7 +204,14 @@ async def set(
             table.add_row(key, preview)
 
         console.print(f"\n[bold white]Secret Set:[/bold white] {name}")
-        console.print(f"[bold white]Region:[/bold white] {secret_region}\n")
+        if region:
+            console.print(f"[bold white]Region:[/bold white] {region}\n")
+        else:
+            # Fetch org's default region to show user what will be used
+            props, error = await API.properties(org)
+            if error:
+                return typer.Exit()
+            console.print(f"[bold white]Region:[/bold white] {props['defaultRegion']} [dim](organization default)[/dim]\n")
         console.print(
             Panel(
                 table,
@@ -255,6 +253,7 @@ async def set(
                 console.print("[bold red]Secret set creation cancelled[/bold red]")
                 return typer.Exit(1)
 
+    used_region = None
     with console.status(
         f"[dim]{'Modifying' if existing_set else 'Creating'} secret set [bold]'{name}'[/bold][/dim]",
         spinner="dots",
@@ -269,14 +268,19 @@ async def set(
                 },
                 set_name=name,
                 org=org,
-                region=secret_region,
+                region=region,  # Pass region if provided, otherwise API uses org default
             )
 
             if error:
                 return typer.Exit()
 
+            # Capture the region that was used (from API response)
+            if data and "region" in data:
+                used_region = data["region"]
+
     action = "created" if not existing_set else "modified"
-    message = f"Secret set [bold green]'{name}'[/bold green] {action} successfully"
+    region_info = f" in [bold cyan]{used_region}[/bold cyan]" if used_region else ""
+    message = f"Secret set [bold green]'{name}'[/bold green] {action} successfully{region_info}"
     if action == "modified":
         message += "\n[bold white]You must re-deploy any agents using this secret set for changes to take effect[/bold white]"
     else:
@@ -539,25 +543,17 @@ async def image_pull_secret(
     if base64encode:
         credentials = base64.b64encode(credentials.encode()).decode()
 
-    # Handle region with warning if not specified
-    # CLI always sends region explicitly (PUT semantics)
-    secret_region = region
-    if not secret_region:
-        logger.warning(
-            "Region not specified, defaulting to 'us-west'. Please use --region to specify explicitly. "
-            "This default will be required in a future version."
-        )
-        secret_region = "us-west"
-
-    # Validate region against API
-    if not await validate_region(secret_region):
+    # Validate region if explicitly provided
+    # If not provided, API will use org's default region
+    if region and not await validate_region(region):
         valid_regions = await get_region_codes()
         console.print(
-            f"[red]Invalid region '{secret_region}'. Valid regions are: {', '.join(valid_regions)}[/red]"
+            f"[red]Invalid region '{region}'. Valid regions are: {', '.join(valid_regions)}[/red]"
         )
         return typer.Exit(1)
 
     # Check if secret already exists
+    used_region = None
     with Live(
         console.status(
             f"[dim]Checking if image pull secret '{name}' already exists[/dim]", spinner="dots"
@@ -590,12 +586,17 @@ async def image_pull_secret(
             data={"isImagePullSecret": True, "secretValue": credentials, "host": host},
             set_name=name,
             org=org,
-            region=secret_region,
+            region=region,  # Pass region if provided, otherwise API uses org default
         )
 
         if error:
             return typer.Exit()
 
+        # Capture the region that was used (from API response)
+        if data and "region" in data:
+            used_region = data["region"]
+
+    region_info = f" in [bold cyan]{used_region}[/bold cyan]" if used_region else ""
     console.success(
-        f"Image pull secret [bold green]'{name}'[/bold green] for [bold green]{host}[/bold green] created successfully.",
+        f"Image pull secret [bold green]'{name}'[/bold green] for [bold green]{host}[/bold green] created successfully{region_info}.",
     )

{pipecatcloud-0.2.12 → pipecatcloud-0.2.13}/src/pipecatcloud/config.py

@@ -35,6 +35,7 @@ _SETTINGS = {
     "api_keys_path": _Setting("/v1/organizations/{org}/apiKeys"),
     "secrets_path": _Setting("/v1/organizations/{org}/secrets"),
     "regions_path": _Setting("/v1/organizations/{org}/regions"),
+    "properties_path": _Setting("/v1/organizations/{org}/properties"),
 }
 
 

{pipecatcloud-0.2.12 → pipecatcloud-0.2.13/src/pipecatcloud.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pipecatcloud
-Version: 0.2.12
+Version: 0.2.13
 Summary: Cloud hosting for Pipecat AI applications
 License: BSD 2-Clause License
 Project-URL: Website, https://docs.pipecat.daily.co/

{pipecatcloud-0.2.12 → pipecatcloud-0.2.13}/tests/test_api_client.py

@@ -111,6 +111,25 @@ class TestAPISecretsRegions:
             assert payload["secretValue"] == "value"
             assert payload["isImagePullSecret"] is False
 
+    @pytest.mark.asyncio
+    async def test_secrets_upsert_without_region(self, api_client):
+        """Secrets upsert without region should not include region in payload (API uses org default)."""
+        # Arrange
+        data = {"secretKey": "KEY", "secretValue": "value"}
+
+        with patch.object(api_client, "_base_request", new_callable=AsyncMock) as mock_request:
+            mock_request.return_value = {"status": "OK", "region": "us-west"}
+
+            # Act
+            await api_client._secrets_upsert(
+                data=data, set_name="my-secrets", org="test-org", region=None
+            )
+
+            # Assert
+            mock_request.assert_called_once()
+            payload = mock_request.call_args[1]["json"]
+            assert "region" not in payload  # Region omitted, API uses org default
+
 
 class TestAPIServicesRegions:
     """Test API client services/agents methods with region support."""
@@ -270,3 +289,76 @@ class TestAPIRegionWithOtherParameters:
             assert payload["secretSet"] == "my-secrets"
             assert payload["imagePullSecretSet"] == "my-creds"
             assert payload["enableIntegratedKeysProxy"] is True
+
+
+class TestAPIProperties:
+    """Test API client organization properties methods."""
+
+    @pytest.fixture
+    def api_client(self):
+        """Create an API client instance."""
+        return _API(token="test-token", is_cli=True)
+
+    @pytest.mark.asyncio
+    async def test_properties_returns_properties_dict(self, api_client):
+        """Properties endpoint should return the properties object."""
+        # Arrange
+        with patch.object(api_client, "_base_request", new_callable=AsyncMock) as mock_request:
+            mock_request.return_value = {"properties": {"defaultRegion": "us-west"}}
+
+            # Act
+            result = await api_client._properties(org="test-org")
+
+            # Assert
+            assert result == {"defaultRegion": "us-west"}
+            mock_request.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_properties_schema_returns_schema_dict(self, api_client):
+        """Properties schema endpoint should return schema with metadata."""
+        # Arrange
+        mock_schema = {
+            "defaultRegion": {
+                "type": "string",
+                "description": "Default region for deployments",
+                "readOnly": False,
+                "currentValue": "us-west",
+                "default": "us-west",
+                "availableValues": ["us-west", "eu-central"]
+            }
+        }
+
+        with patch.object(api_client, "_base_request", new_callable=AsyncMock) as mock_request:
+            mock_request.return_value = {"properties": mock_schema}
+
+            # Act
+            result = await api_client._properties_schema(org="test-org")
+
+            # Assert
+            assert result == mock_schema
+            mock_request.assert_called_once()
+            # Verify it called the /schema endpoint
+            call_url = mock_request.call_args[0][1]
+            assert "/schema" in call_url
+
+    @pytest.mark.asyncio
+    async def test_properties_update_sends_patch_request(self, api_client):
+        """Properties update should send PATCH request with properties payload."""
+        # Arrange
+        with patch.object(api_client, "_base_request", new_callable=AsyncMock) as mock_request:
+            mock_request.return_value = {"properties": {"defaultRegion": "eu-central"}}
+
+            # Act
+            result = await api_client._properties_update(
+                org="test-org",
+                properties={"defaultRegion": "eu-central"}
+            )
+
+            # Assert
+            assert result == {"defaultRegion": "eu-central"}
+            mock_request.assert_called_once()
+            # Verify PATCH method
+            assert mock_request.call_args[0][0] == "PATCH"
+            # Verify payload
+            payload = mock_request.call_args[1]["json"]
+            assert payload == {"defaultRegion": "eu-central"}