rapida-python 0.1.1a0__py3-none-any.whl → 0.1.3a0__py3-none-any.whl

rapida/client/rapida_bridge.py

@@ -22,32 +22,35 @@
 
 
 import logging
-from typing import AsyncIterator, Dict, List, Optional, Mapping
+from typing import AsyncIterator, Dict, List, Optional, Mapping, Iterable
 from google.protobuf.json_format import ParseDict
 from google.protobuf.any_pb2 import Any
 from google.protobuf.struct_pb2 import Struct
+
 from rapida.client.response_wrapper import InvokeResponseWrapper
 from rapida.artifacts.protos import (
     common_pb2,
     integration_api_pb2,
     integration_api_pb2_grpc,
     invoker_api_pb2,
-    invoker_api_pb2_grpc,
+    invoker_api_pb2_grpc, talk_api_pb2_grpc,
+    talk_api_pb2
 )
 from rapida.client.grpc_bridge import GRPCBridge
+from rapida.values import StringValue
 
 _log = logging.getLogger("rapida.client.rapida_bridge")
 
 
 class RapidaBridge(GRPCBridge):
     def __init__(
-        self,
-        service_url: str,
-        rapida_api_key: str,
-        rapida_region: str,
-        rapida_environment: str,
-        rapida_source: str,
-        rapida_is_secure: bool,
+            self,
+            service_url: str,
+            rapida_api_key: str,
+            rapida_region: str,
+            rapida_environment: str,
+            rapida_source: str,
+            rapida_is_secure: bool,
     ):
         """
 
@@ -67,12 +70,12 @@ class RapidaBridge(GRPCBridge):
         )
 
     async def make_invoke_call(
-        self,
-        endpoint_id: int,
-        version: str,
-        body_params: Mapping[str, Any],
-        metadata: Optional[Dict[str, str]],
-        override_options: Optional[Dict[str, str]],
+            self,
+            endpoint_id: int,
+            version: str,
+            body_params: Mapping[str, Any],
+            metadata: Optional[Dict[str, str]],
+            override_options: Optional[Dict[str, str]],
     ) -> InvokeResponseWrapper:
         """
         Endpoint request to the rapida api endpoint servers
@@ -105,7 +108,7 @@ class RapidaBridge(GRPCBridge):
         )
 
     async def make_probe_call(
-        self, rapida_audit_id: int
+            self, rapida_audit_id: int
     ) -> invoker_api_pb2.ProbeResponse:
         """
         To get details about the request for given request id
@@ -126,7 +129,7 @@ class RapidaBridge(GRPCBridge):
         )
 
     async def make_update_call(
-        self, rapida_audit_id: int, rapida_metadata: Optional[Dict[str, str]]
+            self, rapida_audit_id: int, rapida_metadata: Optional[Dict[str, str]]
     ) -> invoker_api_pb2.UpdateResponse:
         """
         Provide an interface to update the metadata for executed request
@@ -152,15 +155,15 @@ class RapidaBridge(GRPCBridge):
             response, invoker_api_pb2.UpdateResponse(), ignore_unknown_fields=True
         )
 
-    async def chat(
-        self,
-        cred: Dict,
-        provider: str,
-        model: str,
-        conversations: List[common_pb2.Message],
-        tool_definitions: List[integration_api_pb2.ToolDefinition],
-        model_parameters: List[integration_api_pb2.ModelParameter],
-        meta: Mapping[str, str] = None,
+    async def make_chat_call(
+            self,
+            cred: Dict,
+            provider: str,
+            model: str,
+            conversations: List[common_pb2.Message],
+            tool_definitions: List[integration_api_pb2.ToolDefinition],
+            model_parameters: List[integration_api_pb2.ModelParameter],
+            meta: Mapping[str, str] = None,
     ) -> integration_api_pb2.ChatResponse:
         """
         Asynchronously initiates a chat interaction with the Rapida service.
@@ -216,15 +219,15 @@ class RapidaBridge(GRPCBridge):
             response, integration_api_pb2.ChatResponse(), ignore_unknown_fields=True
         )
 
-    async def generate(
-        self,
-        cred: Dict,
-        provider: str,
-        model: str,
-        system_prompt: str,
-        prompt: str,
-        model_parameters: Mapping[str, str] = None,
-        meta: Mapping[str, str] = None,
+    async def make_generate_call(
+            self,
+            cred: Dict,
+            provider: str,
+            model: str,
+            system_prompt: str,
+            prompt: str,
+            model_parameters: Mapping[str, str] = None,
+            meta: Mapping[str, str] = None,
     ) -> integration_api_pb2.GenerateResponse:
         """
         Prepares and sends a generation request to the Rapida service.
@@ -278,14 +281,14 @@ class RapidaBridge(GRPCBridge):
             response, integration_api_pb2.GenerateResponse(), ignore_unknown_fields=True
         )
 
-    async def embedding(
-        self,
-        cred: Dict,
-        provider: str,
-        model: str,
-        contents: List[str],
-        model_parameters: Mapping[str, str] = None,
-        meta: Mapping[str, str] = None,
+    async def make_embedding_call(
+            self,
+            cred: Dict,
+            provider: str,
+            model: str,
+            contents: List[str],
+            model_parameters: Mapping[str, str] = None,
+            meta: Mapping[str, str] = None,
     ) -> integration_api_pb2.EmbeddingResponse:
 
         credentials = Struct()
@@ -297,7 +300,7 @@ class RapidaBridge(GRPCBridge):
             args.append(
                 integration_api_pb2.ModelParameter(
                     key=k,
-                    value=v,
+                    value=StringValue(v),
                 )
             )
 
@@ -324,15 +327,15 @@ class RapidaBridge(GRPCBridge):
             ignore_unknown_fields=True,
         )
 
-    async def chat_stream(
-        self,
-        cred: Dict,
-        provider: str,
-        model: str,
-        conversations: List[common_pb2.Message],
-        tool_definitions: List[integration_api_pb2.ToolDefinition],
-        model_parameters: List[integration_api_pb2.ModelParameter],
-        meta: Mapping[str, str] = None,
+    async def make_chat_stream(
+            self,
+            cred: Dict,
+            provider: str,
+            model: str,
+            conversations: List[common_pb2.Message],
+            tool_definitions: List[integration_api_pb2.ToolDefinition],
+            model_parameters: List[integration_api_pb2.ModelParameter],
+            meta: Mapping[str, str] = None,
     ) -> AsyncIterator[integration_api_pb2.ChatResponse]:
         """
         Asynchronously initiates a chat interaction with the Rapida service and streams the responses.
@@ -372,18 +375,77 @@ class RapidaBridge(GRPCBridge):
 
         # Stream the chat response from the gRPC server
         async for response in self.fetch_stream(
-            stub=integration_api_pb2_grpc.RapidaServiceStub,
-            attr="StreamChat",
-            message_type=integration_api_pb2.ChatRequest(
-                credential=integration_api_pb2.Credential(value=credentials),
-                model=f"{provider}/{model}",
-                conversations=conversations,
-                toolDefinitions=tool_definitions,
-                modelParameters=model_parameters,
-                additionalData=meta,
-            ),
-            preserving_proto_field_name=True,
+                stub=integration_api_pb2_grpc.RapidaServiceStub,
+                attr="StreamChat",
+                message_type=integration_api_pb2.ChatRequest(
+                    credential=integration_api_pb2.Credential(value=credentials),
+                    model=f"{provider}/{model}",
+                    conversations=conversations,
+                    toolDefinitions=tool_definitions,
+                    modelParameters=model_parameters,
+                    additionalData=meta,
+                ),
+                preserving_proto_field_name=True,
         ):
             yield ParseDict(
                 response, integration_api_pb2.ChatResponse(), ignore_unknown_fields=True
             )
+
+    async def make_initiate_assistant_talk(self,
+                                           assistant_id: int, version: str,
+                                           source: common_pb2.Source,
+                                           params: Mapping[str, Any],
+                                           args: Mapping[str, Any],
+                                           metadata: Optional[Dict[str, Any]] = None,
+                                           options: Optional[Dict[str, str]] = None
+                                           ) -> talk_api_pb2.InitiateAssistantTalkResponse:
+        response = await self.fetch(
+            stub=talk_api_pb2_grpc.TalkServiceStub,
+            attr="InitiateAssistantTalk",
+            message_type=talk_api_pb2.InitiateAssistantTalkRequest(
+                assistant=talk_api_pb2.AssistantDefinition(
+                    assistantId=assistant_id, version=version
+                ),
+                source=source,
+                params=talk_api_pb2.InitiateAssistantTalkParameter(items=params),
+                args=args,
+                metadata=metadata,
+                options=options,
+            ),
+            preserving_proto_field_name=True,
+        )
+
+        return ParseDict(
+            response,
+            talk_api_pb2.InitiateAssistantTalkResponse(),
+            ignore_unknown_fields=True,
+        )
+
+    async def make_initiate_bulk_assistant_talk(self,
+                                                assistant_id: int, version: str,
+                                                source: common_pb2.Source,
+                                                params: Iterable[Mapping[str, Any]],
+                                                args: Mapping[str, Any],
+                                                metadata: Optional[Dict[str, Any]] = None,
+                                                options: Optional[Dict[str, str]] = None
+                                                ) -> talk_api_pb2.InitiateBulkAssistantTalkResponse:
+        response = await self.fetch(
+            stub=talk_api_pb2_grpc.TalkServiceStub,
+            attr="InitiateBulkAssistantTalk",
+            message_type=talk_api_pb2.InitiateBulkAssistantTalkRequest(
+                assistant=talk_api_pb2.AssistantDefinition(
+                    assistantId=assistant_id, version=version
+                ),
+                source=source,
+                params=[talk_api_pb2.InitiateAssistantTalkParameter(items=p) for p in params],
+                args=args,
+                metadata=metadata,
+                options=options,
+            ),
+            preserving_proto_field_name=True,
+        )
+        return ParseDict(
+            response,
+            talk_api_pb2.InitiateBulkAssistantTalkResponse(),
+            ignore_unknown_fields=True,
+        )

rapida/constants.py

@@ -29,5 +29,5 @@ HEADER_REGION_KEY = "x-rapida-region"
 
 
 ENDPOINT_URL = "connect.rapida.ai"
-ASSISTANT_URL = "assistant-01.rapida.ai"
+ASSISTANT_URL = "workflow-01.rapida.ai"
 GATEWAY_URL = "gateway-01.rapida.ai"

rapida/rapida_client.py

@@ -22,9 +22,12 @@
 
 import warnings
 from typing import AsyncIterator, Dict, List, Union, Optional, Tuple, Mapping
+
+from google.protobuf.json_format import ParseDict, MessageToDict
+
+from rapida.rapida_source import RapidaSource
 from rapida.client.rapida_bridge import RapidaBridge
 from rapida.client.response_wrapper import (
-    ToolDefinition,
     InvokeResponseWrapper,
     Message,
     ToolDefinition,
@@ -33,10 +36,12 @@ from rapida.rapida_client_options import RapidaClientOptions
 from rapida.exceptions import RapidaException
 from rapida.exceptions.exceptions import handle_request_exception
 from rapida.exceptions.exceptions import RapidaConfigurationException
-from rapida.artifacts.protos import common_pb2, integration_api_pb2
+from rapida.artifacts.protos import common_pb2, integration_api_pb2, talk_api_pb2
 from rapida.artifacts.protos.invoker_api_pb2 import InvokerError
 from google.protobuf.any_pb2 import Any
 
+from rapida.values import MapToDict
+
 
 class RapidaClient:
     # an client/bridge of rapida endpoint
@@ -85,18 +90,18 @@ class RapidaEndpointClient(RapidaClient):
         )
 
     def _endpoint_params(
-        self,
-        endpoint: Tuple[int, Union[str, None]],
+            self,
+            endpoint: Tuple[int, Union[str, None]],
     ) -> Tuple[int, str]:
         rapida_endpoint, rapida_endpoint_version = endpoint
         if rapida_endpoint is None:
             raise Exception(
-                "The endpoint key is required. Please provide a endpoint key.",
+                "The endpoint id is required. Please provide a endpoint id.",
             )
 
         if rapida_endpoint_version is None:
             warnings.warn(
-                "The version is required. Default latest will be used.",
+                "The version is optional. Default latest will be used.",
             )
             return rapida_endpoint, "latest"
         return rapida_endpoint, rapida_endpoint_version
@@ -122,17 +127,17 @@ class RapidaEndpointClient(RapidaClient):
         return _extras
 
     async def invoke(
-        self,
-        endpoint: Tuple[int, Union[str, None]],
-        inputs: Mapping[str, Any],
-        metadata: Optional[Dict[str, str]] = None,
-        options: Optional[Dict[str, Any]] = None,
-    ) -> InvokeResponseWrapper:
+            self,
+            endpoint: Tuple[int, Union[str, None]],
+            arguments: Mapping[str, Any],
+            metadata: Optional[Dict[str, str]] = None,
+            options: Optional[Dict[str, Any]] = None,
+    ) -> InvokeResponseWrapper | None:
         """
         Invokes a deployment with the specified key.
 
         Args:
-            inputs: Dictionary of input parameters for the prompts
+            arguments: Dictionary of input parameters for the prompts
             metadata: Dictionary of metadata for the current execution
             options: Dictionary of options for the override parameters for the model
             endpoint (int, str): The endpoint key.
@@ -147,15 +152,15 @@ class RapidaEndpointClient(RapidaClient):
         response = await self.rapida_bridge.make_invoke_call(
             endpoint_id,
             endpoint_version,
-            inputs,
+            arguments,
             metadata,
             options,
         )
 
         if response.is_success():
             return response
-
         self.handle_deployment_exception(response.error)
+        return None
 
     async def update_metadata(self, rapida_audit_id: int, rapida_metadata: Dict):
         """
@@ -178,18 +183,20 @@ class RapidaEndpointClient(RapidaClient):
         if response.success:
             return response
         self.handle_deployment_exception(response.error)
+        return None
 
     async def probe(self, rapida_audit_id: int):
         """
         Probe request for given endpoint audit id
         Args:
-            audit_id: request id for probe
+            rapida_audit_id: request id for probe
 
         """
         response = await self.rapida_bridge.make_probe_call(rapida_audit_id)
         if response.success:
             return response
         self.handle_deployment_exception(response.error)
+        return None
 
     def handle_deployment_exception(self, error: Union[None, InvokerError]):
         """
@@ -227,14 +234,14 @@ class RapidaGatewayClient(RapidaClient):
         )
 
     async def chat(
-        self,
-        credentials: Dict,
-        provider: str,
-        model: str,
-        conversations: List[Message],
-        tools: List[ToolDefinition] = None,
-        model_parameters: Mapping[str, Any] = None,
-        meta: Mapping[str, str] = None,
+            self,
+            credentials: Dict,
+            provider: str,
+            model: str,
+            conversations: List[Message],
+            tools: List[ToolDefinition] = None,
+            model_parameters: Mapping[str, Any] = None,
+            meta: Mapping[str, str] = None,
     ) -> integration_api_pb2.ChatResponse:
 
         conv: List[common_pb2.Message] = []
@@ -255,7 +262,7 @@ class RapidaGatewayClient(RapidaClient):
         for v in tools:
             tool_definitions.append(v.to_tool_definition())
 
-        return await self.rapida_bridge.chat(
+        return await self.rapida_bridge.make_chat_call(
             cred=credentials,
             provider=provider,
             model=model,
@@ -266,14 +273,14 @@ class RapidaGatewayClient(RapidaClient):
         )
 
     async def chat_stream(
-        self,
-        credentials: Dict,
-        provider: str,
-        model: str,
-        conversations: List[Message],
-        tools: List[ToolDefinition] = None,
-        model_parameters: Mapping[str, Any] = None,
-        meta: Mapping[str, str] = None,
+            self,
+            credentials: Dict,
+            provider: str,
+            model: str,
+            conversations: List[Message],
+            tools: List[ToolDefinition] = None,
+            model_parameters: Mapping[str, Any] = None,
+            meta: Mapping[str, str] = None,
     ) -> AsyncIterator[integration_api_pb2.ChatResponse]:
 
         conv: List[common_pb2.Message] = []
@@ -294,29 +301,29 @@ class RapidaGatewayClient(RapidaClient):
         for v in tools:
             tool_definitions.append(v.to_tool_definition())
 
-        async for response in self.rapida_bridge.chat_stream(
-            cred=credentials,
-            provider=provider,
-            model=model,
-            conversations=conv,
-            tool_definitions=tool_definitions,
-            model_parameters=args,
-            meta=meta,
+        async for response in self.rapida_bridge.make_chat_stream(
+                cred=credentials,
+                provider=provider,
+                model=model,
+                conversations=conv,
+                tool_definitions=tool_definitions,
+                model_parameters=args,
+                meta=meta,
         ):
             yield response
 
     async def generate(
-        self,
-        cred: Dict,
-        provider: str,
-        model: str,
-        system_prompt: str,
-        prompt: str,
-        model_parameters: Mapping[str, str],
-        meta: Mapping[str, str],
+            self,
+            cred: Dict,
+            provider: str,
+            model: str,
+            system_prompt: str,
+            prompt: str,
+            model_parameters: Mapping[str, str],
+            meta: Mapping[str, str],
     ):
 
-        return await self.rapida_bridge.generate(
+        return await self.rapida_bridge.make_generate_call(
             cred=cred,
             provider=provider,
             model=model,
@@ -327,15 +334,15 @@ class RapidaGatewayClient(RapidaClient):
         )
 
     async def embedding(
-        self,
-        cred: Dict,
-        provider: str,
-        model: str,
-        contents: List[str],
-        model_parameters: Mapping[str, str],
-        meta: Mapping[str, str],
+            self,
+            cred: Dict,
+            provider: str,
+            model: str,
+            contents: List[str],
+            model_parameters: Mapping[str, str],
+            meta: Mapping[str, str],
     ):
-        return await self.rapida_bridge.embedding(
+        return await self.rapida_bridge.make_embedding_call(
             cred=cred,
             provider=provider,
             model=model,
@@ -360,4 +367,89 @@ class RapidaAssistantClient(RapidaClient):
             rapida_region=options.rapida_region.get(),
             rapida_environment=options.rapida_environment.get(),
             rapida_is_secure=options.is_secure,
+            rapida_source=options.rapida_source.get(),
+        )
+
+    def _assistant_params(
+            self,
+            assistant: Tuple[int, Union[str, None]],
+    ) -> Tuple[int, str]:
+        assistant_id, assistant_version = assistant
+        if assistant_id is None:
+            raise Exception(
+                "The assistant id is required. Please provide a assistant id.",
+            )
+
+        if assistant_version is None:
+            warnings.warn(
+                "The version is optional. Default latest will be used.",
+            )
+            return assistant_id, "latest"
+        return assistant_id, assistant_version
+
+    async def initiate_assistant_deployment(self,
+                                            assistant: Tuple[int, Union[str, None]],
+                                            source: RapidaSource,
+                                            params: Mapping[str, Any],
+                                            arguments: Optional[Mapping[str, Any]] = None,
+                                            metadata: Optional[Mapping[str, Any]] = None,
+                                            options: Optional[Mapping[
+                                                str, Any]] = None) -> Dict | None:
+        assistant_id, version = self._assistant_params(assistant)
+        response = await self.rapida_bridge.make_initiate_assistant_talk(
+            assistant_id,
+            version,
+            source.source(),
+            params,
+            arguments,
+            metadata,
+            options,
+
+        )
+        if response.success:
+            return MapToDict(response.data.items)
+        self.handle_assistant_exception(response.error)
+        return None
+
+    async def initiate_bulk_assistant_deployment(self,
+                                                 assistant: Tuple[int, Union[str, None]],
+                                                 source: RapidaSource,
+                                                 params: List[Dict[str, Any]],
+                                                 arguments: Optional[Dict[str, Any]] = None,
+                                                 metadata: Optional[Dict[str, Any]] = None,
+                                                 options: Optional[Dict[str, Any]] = None) -> List[Dict] | None:
+        assistant_id, version = self._assistant_params(assistant)
+        response = await self.rapida_bridge.make_initiate_bulk_assistant_talk(
+            assistant_id,
+            version,
+            source.source(),
+            params,
+            arguments,
+            metadata,
+            options,
+        )
+
+        if response.success:
+            return [MapToDict(proto_map.items) for proto_map in response.data]
+        self.handle_assistant_exception(response.error)
+        return None
+
+    def handle_assistant_exception(self, error: Union[None, common_pb2.Error]):
+        """
+            Handling exception for all the common endpoint error
+            Args:
+                error: An instance of invokeError if found in response
+
+            """
+
+        if error is None:
+            raise RapidaException(
+                code=500,
+                message="An unknown error occurred.",
+                source="internal client error",
+            )
+        raise RapidaException(
+            code=500,
+            message=error.errorMessage,
+            source=error.humanMessage,
         )

rapida/rapida_client_options.py

@@ -46,10 +46,10 @@ class RapidaClientOptions:
     def __init__(
         self,
         api_key: Optional[str] = None,
-        endpoint_url: Optional[str] = None,
         environment: Optional[RapidaEnvironment] = RapidaEnvironment.PRODUCTION,
         region: Optional[RapidaRegion] = RapidaRegion.ALL,
         is_secure: bool = True,
+        endpoint_url: Optional[str] = None,
         assistant_url: Optional[str] = None,
         gateway_url: Optional[str] = None,
     ):

rapida/rapida_source.py

@@ -23,6 +23,8 @@
 from enum import Enum
 import logging
 
+from rapida.artifacts.protos import common_pb2, common_pb2_grpc
+
 
 class RapidaSource(Enum):
     """
@@ -32,21 +34,52 @@ class RapidaSource(Enum):
     WEB_PLUGIN = "web-plugin"
     RAPIDA_APP = "rapida-app"
     DEBUGGER = "debugger"
+
+    # language SDKs
     PYTHON_SDK = "python-sdk"
     NODE_SDK = "node-sdk"
     GO_SDK = "go-sdk"
-    TYPESCRIPT_SDK = "typescript-sdk"
     JAVA_SDK = "java-sdk"
     PHP_SDK = "php-sdk"
     RUST_SDK = "rust-sdk"
+    REACT_SDK = "react-sdk"
+
+    # extensions
     TWILIO_CALL = "twilio-call"
 
+    MAPPING = {
+        WEB_PLUGIN: common_pb2.Source.WEB_PLUGIN,
+        RAPIDA_APP: common_pb2.Source.RAPIDA_APP,
+        PYTHON_SDK: common_pb2.Source.PYTHON_SDK,
+        NODE_SDK: common_pb2.Source.NODE_SDK,
+        GO_SDK: common_pb2.Source.GO_SDK,
+        JAVA_SDK: common_pb2.Source.JAVA_SDK,
+        PHP_SDK: common_pb2.Source.PHP_SDK,
+        RUST_SDK: common_pb2.Source.RUST_SDK,
+        REACT_SDK: common_pb2.Source.REACT_SDK,
+        TWILIO_CALL: common_pb2.Source.TWILIO_CALL,
+    }
+
     def get(self) -> str:
         return str(self.value)
 
+    def source(self) -> common_pb2.Source:
+        mapping = {
+            RapidaSource.WEB_PLUGIN: common_pb2.Source.WEB_PLUGIN,
+            RapidaSource.RAPIDA_APP: common_pb2.Source.RAPIDA_APP,
+            RapidaSource.PYTHON_SDK: common_pb2.Source.PYTHON_SDK,
+            RapidaSource.NODE_SDK: common_pb2.Source.NODE_SDK,
+            RapidaSource.GO_SDK: common_pb2.Source.GO_SDK,
+            RapidaSource.JAVA_SDK: common_pb2.Source.JAVA_SDK,
+            RapidaSource.PHP_SDK: common_pb2.Source.PHP_SDK,
+            RapidaSource.RUST_SDK: common_pb2.Source.RUST_SDK,
+            RapidaSource.REACT_SDK: common_pb2.Source.REACT_SDK,
+            RapidaSource.TWILIO_CALL: common_pb2.Source.TWILIO_CALL,
+        }
+        return mapping.get(self)
+
     @staticmethod
     def from_str(label: str):
-        logging.info(f"Got the label {label}")
         source_map = {
             "web-plugin": RapidaSource.WEB_PLUGIN,
             "rapida-app": RapidaSource.RAPIDA_APP,
@@ -54,7 +87,6 @@ class RapidaSource(Enum):
             "python-sdk": RapidaSource.PYTHON_SDK,
             "node-sdk": RapidaSource.NODE_SDK,
             "go-sdk": RapidaSource.GO_SDK,
-            "typescript-sdk": RapidaSource.TYPESCRIPT_SDK,
             "java-sdk": RapidaSource.JAVA_SDK,
             "php-sdk": RapidaSource.PHP_SDK,
             "rust-sdk": RapidaSource.RUST_SDK,
@@ -69,3 +101,4 @@ class RapidaSource(Enum):
                 "'go-sdk', 'typescript-sdk', 'java-sdk', 'php-sdk', 'rust-sdk', 'twilio-call'."
             )
         return result
+

rapida/values.py

@@ -22,8 +22,8 @@
 
 import mimetypes
 import re
+import typing
 
-from google.protobuf.any_pb2 import Any
 from google.protobuf.wrappers_pb2 import (
     StringValue as _StringValue,
     BytesValue,
@@ -33,7 +33,9 @@ from google.protobuf.wrappers_pb2 import (
 import os
 from PIL import Image
 
-from rapida import RapidaException
+from rapida.exceptions.exceptions import RapidaException
+from google.protobuf.any_pb2 import Any
+from google.protobuf import wrappers_pb2, timestamp_pb2, duration_pb2, empty_pb2, struct_pb2, json_format
 
 
 def StringValue(_in: str) -> Any:
@@ -317,3 +319,53 @@ def URLValue(url: str) -> Any:
     any_message.Pack(string_value)
 
     return any_message
+
+
+def AnyToValue(any_value: Any) -> typing.Any:
+    if not any_value or not getattr(any_value, "type_url", None):
+        return None
+
+    type_map: dict[str, typing.Type] = {
+        "type.googleapis.com/google.protobuf.StringValue": wrappers_pb2.StringValue,
+        "type.googleapis.com/google.protobuf.Int32Value": wrappers_pb2.Int32Value,
+        "type.googleapis.com/google.protobuf.Int64Value": wrappers_pb2.Int64Value,
+        "type.googleapis.com/google.protobuf.UInt32Value": wrappers_pb2.UInt32Value,
+        "type.googleapis.com/google.protobuf.UInt64Value": wrappers_pb2.UInt64Value,
+        "type.googleapis.com/google.protobuf.FloatValue": wrappers_pb2.FloatValue,
+        "type.googleapis.com/google.protobuf.DoubleValue": wrappers_pb2.DoubleValue,
+        "type.googleapis.com/google.protobuf.BoolValue": wrappers_pb2.BoolValue,
+        "type.googleapis.com/google.protobuf.BytesValue": wrappers_pb2.BytesValue,
+        "type.googleapis.com/google.protobuf.Timestamp": timestamp_pb2.Timestamp,
+        "type.googleapis.com/google.protobuf.Duration": duration_pb2.Duration,
+        "type.googleapis.com/google.protobuf.Empty": empty_pb2.Empty,
+        "type.googleapis.com/google.protobuf.Struct": struct_pb2.Struct,
+    }
+
+    msg_class = type_map.get(any_value.type_url)
+    if msg_class:
+        msg = msg_class()
+        any_value.Unpack(msg)
+
+        if isinstance(msg, timestamp_pb2.Timestamp):
+            return msg.ToDatetime()
+        elif isinstance(msg, duration_pb2.Duration):
+            return msg.ToTimedelta()
+        elif isinstance(msg, empty_pb2.Empty):
+            return None
+        elif isinstance(msg, struct_pb2.Struct):
+            return json_format.MessageToDict(msg)
+        elif hasattr(msg, "value"):
+            return msg.value
+        else:
+            return json_format.MessageToDict(msg)
+    else:
+        return json_format.MessageToJson(any_value)
+
+
+def MapToDict(proto_map: typing.Mapping[str, Any]) -> dict[str, typing.Any]:
+    result: dict[str, typing.Any] = {}
+
+    for key, any_value in proto_map.items():
+        result[key] = AnyToValue(any_value)
+
+    return result

rapida/version.py

@@ -22,7 +22,7 @@
 
 _MAJOR = "0"
 _MINOR = "1"
-_REVISION = "1-alpha"
+_REVISION = "3-alpha"
 
 VERSION_SHORT = f"{_MAJOR}.{_MINOR}"
 VERSION = f"{_MAJOR}.{_MINOR}.{_REVISION}"

{rapida_python-0.1.1a0.dist-info → rapida_python-0.1.3a0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rapida-python
-Version: 0.1.1a0
+Version: 0.1.3a0
 Summary: rapidaAi sdk to integrate rapida.ai api's
 Home-page: https://github.com/rapidaai/rapida-python
 Author-email: code@rapida.ai

{rapida_python-0.1.1a0.dist-info → rapida_python-0.1.3a0.dist-info}/RECORD

@@ -1,17 +1,17 @@
 bin/__init__.py,sha256=uunvHyOaVic6mTNNF4PCIyo1VGRDH5PwAoLhf3I-lCA,35
 rapida/__init__.py,sha256=nOtzJAi6XBDfgaowERqtLoDcKskRrsUERdjUNzUYgaM,2171
-rapida/constants.py,sha256=5kQv86tiIkoM7cqfM0nB5wRtpOW_LP8qXSZTn9vo4Wk,1445
-rapida/rapida_client.py,sha256=xauRKSQ0691EeNuDIRlhbBqhpAnTq5O-CEKkgevVefM,12684
-rapida/rapida_client_options.py,sha256=89YFRtKZlvz7WyffJqe8U2Z5VdNQSzM8UgHO3IVMvGQ,2915
+rapida/constants.py,sha256=7qVonsY5oJGY7TY7XLd51l4CQch4NnRlbJ774TVD6fM,1444
+rapida/rapida_client.py,sha256=7m8SVIkLsFdiddLRXyME07u7UQJI_6tP5ka8PeNnX1w,16535
+rapida/rapida_client_options.py,sha256=lE13nuQ_b9VExVwtqP2fpik5RrErPawfUPtlXIlRqIc,2915
 rapida/rapida_environment.py,sha256=S0wpHjNAokg3PbGXt5QkzATmX0_jPCjCC8zC_G33qaQ,1780
 rapida/rapida_region.py,sha256=ZO6_VGTlawtM2G_XOPVQldupOlMRRS__A97KGu8TQkE,1788
-rapida/rapida_source.py,sha256=IeIDIERDtEJn2cqJ0qXpOMnENb900Pr0ma7vE1U2unM,2718
-rapida/values.py,sha256=Ws7Omz96k0jbgWFOBtrBqugrjsk8j8DpTPuyV14_0xs,9278
-rapida/version.py,sha256=62odGDcHP0GN3tfqOYCjMMqRLSAajc9Gucjj69120J0,1275
+rapida/rapida_source.py,sha256=LwBRU-CwTgce3rDfXMfOA5xMJ11kIxZHrPBPGwUVvOQ,3955
+rapida/values.py,sha256=sfRWMh-AemF5kdWX6yYIx8qiC2lzKoWkeVc_kuoB-g0,11550
+rapida/version.py,sha256=WnfI7kdasNH46IpovJI5i_o7K-0dM_8Kz-KZgUKOrVM,1275
 rapida/artifacts/__init__.py,sha256=uunvHyOaVic6mTNNF4PCIyo1VGRDH5PwAoLhf3I-lCA,35
 rapida/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rapida/client/grpc_bridge.py,sha256=3mvALHj6JKyJX1qXymnGTn3RoYLR2lLYGFijdONABok,8678
-rapida/client/rapida_bridge.py,sha256=sy3BZaZml5cXAWiXmFr9j5WyYJ4XYSE8ebmm4y2p5nI,14103
+rapida/client/rapida_bridge.py,sha256=aObV6qo2Ge2VhdhvgnrRZEP_642qjkPspBRS2JizIbw,17286
 rapida/client/response_wrapper.py,sha256=hOaEvrnVNbsETBxgR5lr4rQfiE6WTgTpoYexVl7jT-k,8829
 rapida/exceptions/__init__.py,sha256=-Sn1p5ezX1P90_kBPvFYUUz-Pc1d33uv3KQYPsK4qqQ,1546
 rapida/exceptions/exceptions.py,sha256=B26HQSaK_KwDYt44EonJYk-Gvqw0jfa_ho8vwupVG1s,3976
@@ -19,7 +19,7 @@ rapida/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rapida/tests/test_rapida_client.py,sha256=I3PJCz_R2S1sqptCRxo81BHV6K8Jtf_4DjEIBtnpfQk,5781
 rapida/tests/test_rapida_client_options.py,sha256=zOWRx9LTNF-9MYajWeFeIFWg_HUuAirH4EdffeH8W7M,3203
 rapida/tests/test_values.py,sha256=pnXy4djs7b-xn5_W2SXSEJBtRBm9tbmucLKWyqSnmm8,1709
-rapida_python-0.1.1a0.dist-info/METADATA,sha256=3WJvyzakxD2bv5qgnUCxy53J1UobsHcRHraOMI6by_U,1914
-rapida_python-0.1.1a0.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
-rapida_python-0.1.1a0.dist-info/top_level.txt,sha256=046qVW6wPXCDmFm-V2YJcXQY0vApej2JLfv1NDKevoE,11
-rapida_python-0.1.1a0.dist-info/RECORD,,
+rapida_python-0.1.3a0.dist-info/METADATA,sha256=OREr6tnwWfwtQicMKaUrNI5V4IO3lUhIzynG8TqoVgI,1914
+rapida_python-0.1.3a0.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+rapida_python-0.1.3a0.dist-info/top_level.txt,sha256=046qVW6wPXCDmFm-V2YJcXQY0vApej2JLfv1NDKevoE,11
+rapida_python-0.1.3a0.dist-info/RECORD,,

{rapida_python-0.1.1a0.dist-info → rapida_python-0.1.3a0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.44.0)
+Generator: bdist_wheel (0.45.1)
 Root-Is-Purelib: true
 Tag: py3-none-any