plexspaces 0.1.2__tar.gz → 0.1.4__tar.gz

{plexspaces-0.1.2 → plexspaces-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plexspaces
-Version: 0.1.2
+Version: 0.1.4
 Summary: PlexSpaces Python SDK - Build actors with minimal boilerplate
 Author: PlexSpaces Contributors
 License: AGPL-3.0-or-later

{plexspaces-0.1.2 → plexspaces-0.1.4}/plexspaces/generated/plexspaces/application/v1/__init__.py

@@ -258,102 +258,68 @@ class ApplicationSpec(betterproto.Message):
 
     name: str = betterproto.string_field(1)
     """
-    Application name (unique identifier within node)
+    Application name (unique identifier within node).
+     Serves as the namespace for all actors spawned by this application.
      Examples: "byzantine-generals", "genomics-coordinator"
     """
 
     tenant_id: str = betterproto.string_field(2)
     """
     Tenant ID for multi-tenancy isolation.
-     Extracted from JWT token during deployment.
-     All actors spawned by this application will be scoped to this tenant.
-     This is the source of truth for tenant isolation - ActorFactory enforces it.
+     Extracted from JWT token during deployment; fallback from app-config.toml.
     """
 
-    namespace: str = betterproto.string_field(3)
-    """
-    Namespace for actor isolation within a tenant.
-     All actors spawned by this application will be registered in this namespace.
-     If empty, defaults to application_id during deployment.
-     Examples: "bank-test", "genomics-prod", "dev-sandbox"
-    """
-
-    version: str = betterproto.string_field(4)
+    version: str = betterproto.string_field(3)
     """
     Application version (semantic versioning)
      Examples: "0.1.0", "1.2.3"
     """
 
-    description: str = betterproto.string_field(5)
+    description: str = betterproto.string_field(4)
     """Human-readable description"""
 
-    type: "ApplicationType" = betterproto.enum_field(6)
+    type: "ApplicationType" = betterproto.enum_field(5)
     """Application type (library or active)"""
 
-    dependencies: List[str] = betterproto.string_field(7)
-    """
-    Dependencies (other applications that must start first)
-     e.g., ["plexspaces-core", "plexspaces-tuplespace"]
-    """
+    dependencies: List[str] = betterproto.string_field(6)
+    """Dependencies (other applications that must start first)"""
 
     env: Dict[str, str] = betterproto.map_field(
-        8, betterproto.TYPE_STRING, betterproto.TYPE_STRING
+        7, betterproto.TYPE_STRING, betterproto.TYPE_STRING
     )
     """Application-level environment variables"""
 
     supervisor: Optional["__supervision_v1__.SupervisorSpec"] = (
-        betterproto.message_field(9, optional=True)
+        betterproto.message_field(8, optional=True)
     )
     """Supervision tree (only for active applications)"""
 
-    enabled: bool = betterproto.bool_field(10)
-    """
-    Whether application is enabled (false = skip loading)
-     Default: true
-    """
+    enabled: bool = betterproto.bool_field(9)
+    """Whether application is enabled (false = skip loading). Default: true"""
 
-    auto_start: bool = betterproto.bool_field(11)
+    auto_start: bool = betterproto.bool_field(10)
     """
-    Whether to start application automatically on node boot
-     Default: true
-     Future: false allows manual start via ApplicationService API
+    Whether to start application automatically on node boot. Default: true
     """
 
-    shutdown_timeout: timedelta = betterproto.message_field(12)
-    """
-    Shutdown timeout (force kill if exceeded)
-     Default: 60 seconds
-    """
+    shutdown_timeout: timedelta = betterproto.message_field(11)
+    """Shutdown timeout (force kill if exceeded). Default: 60 seconds"""
 
-    shutdown_strategy: "ShutdownStrategy" = betterproto.enum_field(13)
-    """
-    Shutdown strategy (graceful or immediate)
-     Default: GRACEFUL
-    """
+    shutdown_strategy: "ShutdownStrategy" = betterproto.enum_field(12)
+    """Shutdown strategy (graceful or immediate). Default: GRACEFUL"""
 
-    metadata: "__common_v1__.Metadata" = betterproto.message_field(14)
-    """
-    Application metadata (tags, labels, annotations)
-     Examples:
-     - environment: "production"
-     - team: "genomics"
-     - criticality: "high"
-    """
+    metadata: "__common_v1__.Metadata" = betterproto.message_field(13)
+    """Application metadata (tags, labels, annotations)"""
 
-    seed_nodes: List[str] = betterproto.string_field(15)
+    seed_nodes: List[str] = betterproto.string_field(14)
     """
     Seed nodes (gRPC addresses) to connect to when this application is deployed.
-     The node will connect to these addresses if not already connected, so
-     leader-worker and scatter/gather can use workers on other nodes.
-     Example: ["localhost:8091", "localhost:8093"]
     """
 
     required_service_links: List["ApplicationServiceLinkRequirement"] = (
-        betterproto.message_field(16)
+        betterproto.message_field(15)
     )
-    """
-    External service links this application expects at deploy time (validated against node catalog).
-    """
+    """External service links this application expects at deploy time."""
 
 
 @dataclass(eq=False, repr=False)
@@ -556,25 +522,24 @@ class ApplicationInfo(betterproto.Message):
     """Application ID"""
 
     name: str = betterproto.string_field(2)
-    """Application name"""
+    """
+    Application name (also serves as the namespace for actors in this application)
+    """
 
     tenant_id: str = betterproto.string_field(3)
     """Tenant ID for visibility and isolation."""
 
-    namespace: str = betterproto.string_field(4)
-    """Namespace for application-scoped actors and filters."""
-
-    version: str = betterproto.string_field(5)
+    version: str = betterproto.string_field(4)
     """Application version"""
 
-    status: "ApplicationStatus" = betterproto.enum_field(6)
+    status: "ApplicationStatus" = betterproto.enum_field(5)
     """Current status"""
 
-    deployed_at: datetime = betterproto.message_field(7)
+    deployed_at: datetime = betterproto.message_field(6)
     """When the application was deployed"""
 
     metrics: Optional["ApplicationMetrics"] = betterproto.message_field(
-        8, optional=True
+        7, optional=True
     )
     """Application metrics (optional)"""
 

{plexspaces-0.1.2 → plexspaces-0.1.4}/plexspaces/generated/plexspaces/config/v1/__init__.py

@@ -96,7 +96,7 @@ class S3Config(betterproto.Message):
 
     use_path_style: bool = betterproto.bool_field(4)
     """
-    Use path-style URLs (required for MinIO and some S3-compatible stores)
+    Use path-style URLs (required for embedded and some S3-compatible stores)
     """
 
 

{plexspaces-0.1.2 → plexspaces-0.1.4}/plexspaces/generated/plexspaces/dashboard/v1/__init__.py

@@ -20,7 +20,10 @@ from ...application import v1 as __application_v1__
 from ...common import v1 as __common_v1__
 from ...metrics import v1 as __metrics_v1__
 from ...node import v1 as __node_v1__
+from ...object_registry import v1 as __object_registry_v1__
+from ...storage import v1 as __storage_v1__
 from ...system import v1 as __system_v1__
+from ...tuplespace import v1 as __tuplespace_v1__
 from ...workflow import v1 as __workflow_v1__
 
 if TYPE_CHECKING:
@@ -354,6 +357,218 @@ class GetDashboardMetricsResponse(betterproto.Message):
     prometheus_text: str = betterproto.string_field(3)
 
 
+@dataclass(eq=False, repr=False)
+class GetObjectsRequest(betterproto.Message):
+    node_id: str = betterproto.string_field(1)
+    """Filter by node ID (optional, empty = local node)"""
+
+    tenant_id: str = betterproto.string_field(2)
+    """Filter by tenant ID (optional, from auth context if not provided)"""
+
+    namespace: str = betterproto.string_field(3)
+    """Filter by namespace (optional)"""
+
+    object_type: str = betterproto.string_field(4)
+    """
+    Filter by object type string: "ACTOR", "TUPLESPACE", "SERVICE", "VM", "APPLICATION", "WORKFLOW", "NODE" (optional)
+    """
+
+    health_status: str = betterproto.string_field(5)
+    """
+    Filter by health status string: "HEALTHY", "DEGRADED", "DEAD" (optional)
+    """
+
+    id_pattern: str = betterproto.string_field(6)
+    """Filter by object ID pattern (optional)"""
+
+    page: "__common_v1__.PageRequest" = betterproto.message_field(7)
+    """Pagination"""
+
+
+@dataclass(eq=False, repr=False)
+class GetObjectsResponse(betterproto.Message):
+    objects: List["__object_registry_v1__.ObjectRegistration"] = (
+        betterproto.message_field(1)
+    )
+    page: "__common_v1__.PageResponse" = betterproto.message_field(2)
+
+
+@dataclass(eq=False, repr=False)
+class GetKeyValuesRequest(betterproto.Message):
+    node_id: str = betterproto.string_field(1)
+    """Filter by node ID (optional, empty = local node)"""
+
+    tenant_id: str = betterproto.string_field(2)
+    """Filter by tenant ID (optional, from auth context if not provided)"""
+
+    namespace: str = betterproto.string_field(3)
+    """Filter by namespace (optional)"""
+
+    prefix: str = betterproto.string_field(4)
+    """Key prefix filter (optional)"""
+
+    page: "__common_v1__.PageRequest" = betterproto.message_field(5)
+    """Pagination"""
+
+
+@dataclass(eq=False, repr=False)
+class KeyValueDashboardEntry(betterproto.Message):
+    """
+    Lightweight KV entry for dashboard display (value truncated for safety)
+    """
+
+    key: str = betterproto.string_field(1)
+    """The key"""
+
+    value_preview: str = betterproto.string_field(2)
+    """Value preview (first 100 UTF-8 bytes)"""
+
+    size_bytes: int = betterproto.uint64_field(3)
+    """Full value size in bytes"""
+
+
+@dataclass(eq=False, repr=False)
+class GetKeyValuesResponse(betterproto.Message):
+    entries: List["KeyValueDashboardEntry"] = betterproto.message_field(1)
+    page: "__common_v1__.PageResponse" = betterproto.message_field(2)
+
+
+@dataclass(eq=False, repr=False)
+class GetTupleSpacesRequest(betterproto.Message):
+    node_id: str = betterproto.string_field(1)
+    """Filter by node ID (optional, empty = local node)"""
+
+    tenant_id: str = betterproto.string_field(2)
+    """Filter by tenant ID (optional, from auth context if not provided)"""
+
+    namespace: str = betterproto.string_field(3)
+    """Filter by namespace (optional)"""
+
+    pattern: str = betterproto.string_field(4)
+    """Optional pattern string to match against tuples (default: wildcard)"""
+
+
+@dataclass(eq=False, repr=False)
+class TupleSpaceSummary(betterproto.Message):
+    """Summary of a tuplespace namespace"""
+
+    namespace: str = betterproto.string_field(1)
+    """Namespace this summary is for"""
+
+    pattern: str = betterproto.string_field(2)
+    """Pattern used for counting (empty = wildcard)"""
+
+    tuple_count: int = betterproto.uint64_field(3)
+    """Total tuple count matching the pattern"""
+
+    sample_tuples: List["__tuplespace_v1__.Tuple"] = betterproto.message_field(4)
+    """Sample tuples (up to 20)"""
+
+
+@dataclass(eq=False, repr=False)
+class GetTupleSpacesResponse(betterproto.Message):
+    spaces: List["TupleSpaceSummary"] = betterproto.message_field(1)
+
+
+@dataclass(eq=False, repr=False)
+class GetBlobsRequest(betterproto.Message):
+    node_id: str = betterproto.string_field(1)
+    """Filter by node ID (optional, empty = local node)"""
+
+    tenant_id: str = betterproto.string_field(2)
+    """Filter by tenant ID (optional, from auth context if not provided)"""
+
+    namespace: str = betterproto.string_field(3)
+    """Filter by namespace (optional)"""
+
+    kind: str = betterproto.string_field(4)
+    """Filter by blob kind (optional)"""
+
+    prefix: str = betterproto.string_field(5)
+    """Filter by blob name prefix (optional)"""
+
+    page: "__common_v1__.PageRequest" = betterproto.message_field(6)
+    """Pagination"""
+
+
+@dataclass(eq=False, repr=False)
+class GetBlobsResponse(betterproto.Message):
+    blobs: List["__storage_v1__.BlobMetadata"] = betterproto.message_field(1)
+    """Reuses existing BlobMetadata proto from storage package"""
+
+    page: "__common_v1__.PageResponse" = betterproto.message_field(2)
+
+
+@dataclass(eq=False, repr=False)
+class GetBlobPresignedUrlRequest(betterproto.Message):
+    blob_id: str = betterproto.string_field(1)
+    """Blob ID (required)"""
+
+    node_id: str = betterproto.string_field(2)
+    """Node ID where the blob lives (optional, empty = local node)"""
+
+    tenant_id: str = betterproto.string_field(3)
+    """
+    Tenant ID for authorization (optional, from auth context if not provided)
+    """
+
+    namespace: str = betterproto.string_field(4)
+    """Namespace for authorization (optional)"""
+
+
+@dataclass(eq=False, repr=False)
+class GetBlobPresignedUrlResponse(betterproto.Message):
+    url: str = betterproto.string_field(1)
+    """Presigned download URL (empty if not available)"""
+
+    expires_at: datetime = betterproto.message_field(2)
+    """URL expiration timestamp"""
+
+    error: str = betterproto.string_field(3)
+    """Error message if presigned URLs are not configured or blob not found"""
+
+
+@dataclass(eq=False, repr=False)
+class GetServiceLinksRequest(betterproto.Message):
+    node_id: str = betterproto.string_field(1)
+    """Node ID (optional, empty = local node)"""
+
+    tenant_id: str = betterproto.string_field(2)
+    """Tenant ID (optional, used for filtering if auth enabled)"""
+
+
+@dataclass(eq=False, repr=False)
+class GetServiceLinksResponse(betterproto.Message):
+    service_links: List["__node_v1__.ServiceLinkConfig"] = betterproto.message_field(1)
+    """Reuses existing ServiceLinkConfig proto from node/outbound package"""
+
+
+@dataclass(eq=False, repr=False)
+class GetMetricsTableRequest(betterproto.Message):
+    node_id: str = betterproto.string_field(1)
+    """Node ID (optional, empty = local node)"""
+
+    namespace: str = betterproto.string_field(2)
+    """Optional namespace label filter"""
+
+    name_pattern: str = betterproto.string_field(3)
+    """Name glob; empty or "*" matches all metric names"""
+
+    label_filter: Dict[str, str] = betterproto.map_field(
+        4, betterproto.TYPE_STRING, betterproto.TYPE_STRING
+    )
+    """Additional label equality filters (AND)"""
+
+
+@dataclass(eq=False, repr=False)
+class GetMetricsTableResponse(betterproto.Message):
+    metrics: List["__metrics_v1__.Metric"] = betterproto.message_field(1)
+    """All matching metrics with current values"""
+
+    definitions: List["__metrics_v1__.MetricDefinition"] = betterproto.message_field(2)
+    """Metric definitions (metadata: description, unit, type)"""
+
+
 class DashboardServiceStub(betterproto.ServiceStub):
     async def get_summary(
         self,
@@ -491,6 +706,125 @@ class DashboardServiceStub(betterproto.ServiceStub):
             metadata=metadata,
         )
 
+    async def get_objects(
+        self,
+        get_objects_request: "GetObjectsRequest",
+        *,
+        timeout: Optional[float] = None,
+        deadline: Optional["Deadline"] = None,
+        metadata: Optional["MetadataLike"] = None
+    ) -> "GetObjectsResponse":
+        return await self._unary_unary(
+            "/plexspaces.dashboard.v1.DashboardService/GetObjects",
+            get_objects_request,
+            GetObjectsResponse,
+            timeout=timeout,
+            deadline=deadline,
+            metadata=metadata,
+        )
+
+    async def get_key_values(
+        self,
+        get_key_values_request: "GetKeyValuesRequest",
+        *,
+        timeout: Optional[float] = None,
+        deadline: Optional["Deadline"] = None,
+        metadata: Optional["MetadataLike"] = None
+    ) -> "GetKeyValuesResponse":
+        return await self._unary_unary(
+            "/plexspaces.dashboard.v1.DashboardService/GetKeyValues",
+            get_key_values_request,
+            GetKeyValuesResponse,
+            timeout=timeout,
+            deadline=deadline,
+            metadata=metadata,
+        )
+
+    async def get_tuple_spaces(
+        self,
+        get_tuple_spaces_request: "GetTupleSpacesRequest",
+        *,
+        timeout: Optional[float] = None,
+        deadline: Optional["Deadline"] = None,
+        metadata: Optional["MetadataLike"] = None
+    ) -> "GetTupleSpacesResponse":
+        return await self._unary_unary(
+            "/plexspaces.dashboard.v1.DashboardService/GetTupleSpaces",
+            get_tuple_spaces_request,
+            GetTupleSpacesResponse,
+            timeout=timeout,
+            deadline=deadline,
+            metadata=metadata,
+        )
+
+    async def get_blobs(
+        self,
+        get_blobs_request: "GetBlobsRequest",
+        *,
+        timeout: Optional[float] = None,
+        deadline: Optional["Deadline"] = None,
+        metadata: Optional["MetadataLike"] = None
+    ) -> "GetBlobsResponse":
+        return await self._unary_unary(
+            "/plexspaces.dashboard.v1.DashboardService/GetBlobs",
+            get_blobs_request,
+            GetBlobsResponse,
+            timeout=timeout,
+            deadline=deadline,
+            metadata=metadata,
+        )
+
+    async def get_blob_presigned_url(
+        self,
+        get_blob_presigned_url_request: "GetBlobPresignedUrlRequest",
+        *,
+        timeout: Optional[float] = None,
+        deadline: Optional["Deadline"] = None,
+        metadata: Optional["MetadataLike"] = None
+    ) -> "GetBlobPresignedUrlResponse":
+        return await self._unary_unary(
+            "/plexspaces.dashboard.v1.DashboardService/GetBlobPresignedUrl",
+            get_blob_presigned_url_request,
+            GetBlobPresignedUrlResponse,
+            timeout=timeout,
+            deadline=deadline,
+            metadata=metadata,
+        )
+
+    async def get_service_links(
+        self,
+        get_service_links_request: "GetServiceLinksRequest",
+        *,
+        timeout: Optional[float] = None,
+        deadline: Optional["Deadline"] = None,
+        metadata: Optional["MetadataLike"] = None
+    ) -> "GetServiceLinksResponse":
+        return await self._unary_unary(
+            "/plexspaces.dashboard.v1.DashboardService/GetServiceLinks",
+            get_service_links_request,
+            GetServiceLinksResponse,
+            timeout=timeout,
+            deadline=deadline,
+            metadata=metadata,
+        )
+
+    async def get_metrics_table(
+        self,
+        get_metrics_table_request: "GetMetricsTableRequest",
+        *,
+        timeout: Optional[float] = None,
+        deadline: Optional["Deadline"] = None,
+        metadata: Optional["MetadataLike"] = None
+    ) -> "GetMetricsTableResponse":
+        return await self._unary_unary(
+            "/plexspaces.dashboard.v1.DashboardService/GetMetricsTable",
+            get_metrics_table_request,
+            GetMetricsTableResponse,
+            timeout=timeout,
+            deadline=deadline,
+            metadata=metadata,
+        )
+
 
 class DashboardServiceBase(ServiceBase):
 
@@ -534,6 +868,41 @@ class DashboardServiceBase(ServiceBase):
     ) -> "GetDashboardMetricsResponse":
         raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
 
+    async def get_objects(
+        self, get_objects_request: "GetObjectsRequest"
+    ) -> "GetObjectsResponse":
+        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
+
+    async def get_key_values(
+        self, get_key_values_request: "GetKeyValuesRequest"
+    ) -> "GetKeyValuesResponse":
+        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
+
+    async def get_tuple_spaces(
+        self, get_tuple_spaces_request: "GetTupleSpacesRequest"
+    ) -> "GetTupleSpacesResponse":
+        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
+
+    async def get_blobs(
+        self, get_blobs_request: "GetBlobsRequest"
+    ) -> "GetBlobsResponse":
+        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
+
+    async def get_blob_presigned_url(
+        self, get_blob_presigned_url_request: "GetBlobPresignedUrlRequest"
+    ) -> "GetBlobPresignedUrlResponse":
+        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
+
+    async def get_service_links(
+        self, get_service_links_request: "GetServiceLinksRequest"
+    ) -> "GetServiceLinksResponse":
+        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
+
+    async def get_metrics_table(
+        self, get_metrics_table_request: "GetMetricsTableRequest"
+    ) -> "GetMetricsTableResponse":
+        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
+
     async def __rpc_get_summary(
         self, stream: "grpclib.server.Stream[GetSummaryRequest, GetSummaryResponse]"
     ) -> None:
@@ -594,6 +963,59 @@ class DashboardServiceBase(ServiceBase):
         response = await self.get_dashboard_metrics(request)
         await stream.send_message(response)
 
+    async def __rpc_get_objects(
+        self, stream: "grpclib.server.Stream[GetObjectsRequest, GetObjectsResponse]"
+    ) -> None:
+        request = await stream.recv_message()
+        response = await self.get_objects(request)
+        await stream.send_message(response)
+
+    async def __rpc_get_key_values(
+        self, stream: "grpclib.server.Stream[GetKeyValuesRequest, GetKeyValuesResponse]"
+    ) -> None:
+        request = await stream.recv_message()
+        response = await self.get_key_values(request)
+        await stream.send_message(response)
+
+    async def __rpc_get_tuple_spaces(
+        self,
+        stream: "grpclib.server.Stream[GetTupleSpacesRequest, GetTupleSpacesResponse]",
+    ) -> None:
+        request = await stream.recv_message()
+        response = await self.get_tuple_spaces(request)
+        await stream.send_message(response)
+
+    async def __rpc_get_blobs(
+        self, stream: "grpclib.server.Stream[GetBlobsRequest, GetBlobsResponse]"
+    ) -> None:
+        request = await stream.recv_message()
+        response = await self.get_blobs(request)
+        await stream.send_message(response)
+
+    async def __rpc_get_blob_presigned_url(
+        self,
+        stream: "grpclib.server.Stream[GetBlobPresignedUrlRequest, GetBlobPresignedUrlResponse]",
+    ) -> None:
+        request = await stream.recv_message()
+        response = await self.get_blob_presigned_url(request)
+        await stream.send_message(response)
+
+    async def __rpc_get_service_links(
+        self,
+        stream: "grpclib.server.Stream[GetServiceLinksRequest, GetServiceLinksResponse]",
+    ) -> None:
+        request = await stream.recv_message()
+        response = await self.get_service_links(request)
+        await stream.send_message(response)
+
+    async def __rpc_get_metrics_table(
+        self,
+        stream: "grpclib.server.Stream[GetMetricsTableRequest, GetMetricsTableResponse]",
+    ) -> None:
+        request = await stream.recv_message()
+        response = await self.get_metrics_table(request)
+        await stream.send_message(response)
+
     def __mapping__(self) -> Dict[str, grpclib.const.Handler]:
         return {
             "/plexspaces.dashboard.v1.DashboardService/GetSummary": grpclib.const.Handler(
@@ -644,4 +1066,46 @@ class DashboardServiceBase(ServiceBase):
                 GetDashboardMetricsRequest,
                 GetDashboardMetricsResponse,
             ),
+            "/plexspaces.dashboard.v1.DashboardService/GetObjects": grpclib.const.Handler(
+                self.__rpc_get_objects,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                GetObjectsRequest,
+                GetObjectsResponse,
+            ),
+            "/plexspaces.dashboard.v1.DashboardService/GetKeyValues": grpclib.const.Handler(
+                self.__rpc_get_key_values,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                GetKeyValuesRequest,
+                GetKeyValuesResponse,
+            ),
+            "/plexspaces.dashboard.v1.DashboardService/GetTupleSpaces": grpclib.const.Handler(
+                self.__rpc_get_tuple_spaces,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                GetTupleSpacesRequest,
+                GetTupleSpacesResponse,
+            ),
+            "/plexspaces.dashboard.v1.DashboardService/GetBlobs": grpclib.const.Handler(
+                self.__rpc_get_blobs,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                GetBlobsRequest,
+                GetBlobsResponse,
+            ),
+            "/plexspaces.dashboard.v1.DashboardService/GetBlobPresignedUrl": grpclib.const.Handler(
+                self.__rpc_get_blob_presigned_url,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                GetBlobPresignedUrlRequest,
+                GetBlobPresignedUrlResponse,
+            ),
+            "/plexspaces.dashboard.v1.DashboardService/GetServiceLinks": grpclib.const.Handler(
+                self.__rpc_get_service_links,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                GetServiceLinksRequest,
+                GetServiceLinksResponse,
+            ),
+            "/plexspaces.dashboard.v1.DashboardService/GetMetricsTable": grpclib.const.Handler(
+                self.__rpc_get_metrics_table,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                GetMetricsTableRequest,
+                GetMetricsTableResponse,
+            ),
         }

{plexspaces-0.1.2 → plexspaces-0.1.4}/plexspaces/generated/plexspaces/node/v1/__init__.py

@@ -458,6 +458,15 @@ class NodeConfig(betterproto.Message):
      Example: "http://node1.example.com:8000"
     """
 
+    blob_http_port: int = betterproto.uint32_field(22)
+    """
+    Port for blob HTTP: the PlexSpaces blob REST API (non-embedded) or the
+     embedded rustfs S3-compatible subprocess (when backend = "embedded").
+    
+     Set to 0 (default) to derive automatically as listen_addr port + 100.
+     Example: if listen_addr is "0.0.0.0:8000", blob_http_port defaults to 8100.
+    """
+
 
 @dataclass(eq=False, repr=False)
 class NodeRegistryConfig(betterproto.Message):

{plexspaces-0.1.2 → plexspaces-0.1.4}/plexspaces/generated/plexspaces/services/prv/__init__.py

@@ -42,6 +42,9 @@ class ServiceName(betterproto.Enum):
     WORKFLOW_SERVICE = 19
     SYSTEM_SERVICE = 20
     NODE_SERVICE = 21
+    KEY_VALUE_SERVICE = 22
+    SERVICE_LINK_SERVICE = 23
+    METRICS_SERVICE = 24
 
 
 class ServiceCallErrorCode(betterproto.Enum):

{plexspaces-0.1.2 → plexspaces-0.1.4}/plexspaces/generated/plexspaces/storage/v1/__init__.py

@@ -127,7 +127,10 @@ class BlobConfig(betterproto.Message):
     """Bucket name"""
 
     endpoint: str = betterproto.string_field(3)
-    """Endpoint URL (for SeaweedFS or custom S3-compatible)"""
+    """
+    Endpoint URL for embedded or custom S3-compatible store (e.g., "http://127.0.0.1:9100").
+     Leave empty when using embedded backend — endpoint is set automatically after process start.
+    """
 
     region: str = betterproto.string_field(4)
     """Region (for S3/GCP/Azure)"""

{plexspaces-0.1.2 → plexspaces-0.1.4}/plexspaces.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plexspaces
-Version: 0.1.2
+Version: 0.1.4
 Summary: PlexSpaces Python SDK - Build actors with minimal boilerplate
 Author: PlexSpaces Contributors
 License: AGPL-3.0-or-later

{plexspaces-0.1.2 → plexspaces-0.1.4}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "plexspaces"
-version = "0.1.2"
+version = "0.1.4"
 description = "PlexSpaces Python SDK - Build actors with minimal boilerplate"
 readme = "README.md"
 license = {text = "AGPL-3.0-or-later"}