rapida-python 0.1.2a0__tar.gz → 0.1.4a0__tar.gz

{rapida-python-0.1.2a0/rapida_python.egg-info → rapida_python-0.1.4a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
-Name: rapida-python
-Version: 0.1.2a0
+Name: rapida_python
+Version: 0.1.4a0
 Summary: rapidaAi sdk to integrate rapida.ai api's
 Home-page: https://github.com/rapidaai/rapida-python
 Author-email: code@rapida.ai
@@ -12,6 +12,7 @@ Classifier: Environment :: Web Environment
 Classifier: Intended Audience :: Developers
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+Provides-Extra: dev
 Provides-Extra: grpcio-tools
 
 ## Table Of Contents

{rapida-python-0.1.2a0 → rapida_python-0.1.4a0}/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-python-0.1.2a0 → rapida_python-0.1.4a0}/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-python-0.1.2a0 → rapida_python-0.1.4a0}/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-python-0.1.2a0 → rapida_python-0.1.4a0}/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-python-0.1.2a0 → rapida_python-0.1.4a0}/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-python-0.1.2a0 → rapida_python-0.1.4a0}/rapida/version.py

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

{rapida-python-0.1.2a0 → rapida_python-0.1.4a0/rapida_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rapida-python
-Version: 0.1.2a0
+Version: 0.1.4a0
 Summary: rapidaAi sdk to integrate rapida.ai api's
 Home-page: https://github.com/rapidaai/rapida-python
 Author-email: code@rapida.ai
@@ -12,6 +12,7 @@ Classifier: Environment :: Web Environment
 Classifier: Intended Audience :: Developers
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+Provides-Extra: dev
 Provides-Extra: grpcio-tools
 
 ## Table Of Contents

rapida_python-0.1.4a0/rapida_python.egg-info/requires.txt

@@ -0,0 +1,42 @@
+
+[:python_version >= "3.6"]
+idna==3.10
+invoke==2.2.0
+
+[:python_version >= "3.7" and python_version < "4.0"]
+grpc-interceptor==0.15.4
+
+[:python_version >= "3.8"]
+annotated-types==0.7.0
+attrs==25.3.0
+
+[:python_version >= "3.9"]
+aiohappyeyeballs==2.6.1
+aiohttp==3.12.13
+aiosignal==1.3.2
+frozenlist==1.7.0
+grpcio==1.72.1
+grpcio-tools==1.72.1
+multidict==6.5.0
+pillow==11.2.1
+propcache==0.3.2
+protobuf==6.31.1
+pydantic==2.11.7
+pydantic-core==2.33.2
+setuptools==80.9.0
+types-protobuf==6.30.2.20250516
+typing-extensions==4.14.0
+typing-inspection==0.4.1
+yarl==1.20.1
+
+[dev]
+pytest
+pytest-cov
+flake8
+black
+mypy
+
+[grpcio-tools]
+
+[grpcio-tools:python_version >= "3.9"]
+grpcio-tools==1.72.1

rapida_python-0.1.4a0/setup.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python
+import os.path
+
+from setuptools import find_packages, setup
+
+
+def read(*parts):
+    with open(os.path.join(*parts)) as f:
+        return f.read().strip()
+
+
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Programming Language :: Python :: 3.9",
+    "Environment :: Web Environment",
+    "Intended Audience :: Developers",
+]
+
+VERSION = {}
+# version.py defines VERSION and VERSION_SHORT variables.
+# We use exec here to read it so that we don't import scispacy
+with open("rapida/version.py") as version_file:
+    exec(version_file.read(), VERSION)
+
+setup(
+    name="rapida_python",
+    version=VERSION["VERSION"],
+    author_email="code@rapida.ai",
+    description="rapidaAi sdk to integrate rapida.ai api's",
+    long_description=read("README.md"),
+    long_description_content_type="text/markdown",
+    classifiers=classifiers,
+    platforms=["POSIX"],
+    url="https://github.com/rapidaai/rapida-python",
+    packages=find_packages(exclude=["examples", "*.proto"]),
+    install_requires=[
+        "aiohappyeyeballs==2.6.1; python_version >= '3.9'",
+        "aiohttp==3.12.13; python_version >= '3.9'",
+        "aiosignal==1.3.2; python_version >= '3.9'",
+        "annotated-types==0.7.0; python_version >= '3.8'",
+        "attrs==25.3.0; python_version >= '3.8'",
+        "frozenlist==1.7.0; python_version >= '3.9'",
+        "grpc-interceptor==0.15.4; python_version >= '3.7' and python_version < '4.0'",
+        "grpcio==1.72.1; python_version >= '3.9'",
+        "grpcio-tools==1.72.1; python_version >= '3.9'",
+        "idna==3.10; python_version >= '3.6'",
+        "invoke==2.2.0; python_version >= '3.6'",
+        "multidict==6.5.0; python_version >= '3.9'",
+        "pillow==11.2.1; python_version >= '3.9'",
+        "propcache==0.3.2; python_version >= '3.9'",
+        "protobuf==6.31.1; python_version >= '3.9'",
+        "pydantic==2.11.7; python_version >= '3.9'",
+        "pydantic-core==2.33.2; python_version >= '3.9'",
+        "setuptools==80.9.0; python_version >= '3.9'",
+        "types-protobuf==6.30.2.20250516; python_version >= '3.9'",
+        "typing-extensions==4.14.0; python_version >= '3.9'",
+        "typing-inspection==0.4.1; python_version >= '3.9'",
+        "yarl==1.20.1; python_version >= '3.9'",
+    ],
+    extras_require={
+        "dev": [
+            "pytest",
+            "pytest-cov",
+            "flake8",
+            "black",
+            "mypy",
+        ],
+        "grpcio-tools": ["grpcio-tools==1.72.1; python_version >= '3.9'"],
+    },
+    tests_require=["pytest", "pytest-cov", "flake8", "black", "mypy"],
+    package_data={"rapida-python": ["py.typed"]},
+    python_requires=">=3.9",
+    include_package_data=True,
+)

rapida-python-0.1.2a0/rapida_python.egg-info/requires.txt

@@ -1,6 +0,0 @@
-grpcio==1.65.4
-protobuf==5.27.3
-pillow==10.4.0
-
-[grpcio-tools]
-grpcio-tools==1.60.0

rapida-python-0.1.2a0/setup.py

@@ -1,44 +0,0 @@
-#!/usr/bin/env python
-import os.path
-
-from setuptools import find_packages, setup
-
-
-def read(*parts):
-    with open(os.path.join(*parts)) as f:
-        return f.read().strip()
-
-
-classifiers = [
-    "Development Status :: 5 - Production/Stable",
-    "Programming Language :: Python :: 3.9",
-    "Environment :: Web Environment",
-    "Intended Audience :: Developers",
-]
-
-VERSION = {}
-# version.py defines VERSION and VERSION_SHORT variables.
-# We use exec here to read it so that we don't import scispacy
-with open("rapida/version.py") as version_file:
-    exec(version_file.read(), VERSION)
-
-setup(
-    name="rapida-python",
-    version=VERSION["VERSION"],
-    author_email="code@rapida.ai",
-    description="rapidaAi sdk to integrate rapida.ai api's",
-    long_description=read("README.md"),
-    long_description_content_type="text/markdown",
-    classifiers=classifiers,
-    platforms=["POSIX"],
-    url="https://github.com/rapidaai/rapida-python",
-    packages=find_packages(exclude=["examples", "*.proto"]),
-    install_requires=["grpcio==1.65.4", "protobuf==5.27.3", "pillow==10.4.0"],
-    extras_require={
-        "grpcio-tools": ["grpcio-tools==1.60.0"],
-    },
-    tests_require=["pytest", "pytest-cov", "flake8", "black", "mypy"],
-    package_data={"rapida-python": ["py.typed"]},
-    python_requires=">=3.9",
-    include_package_data=True,
-)

{rapida-python-0.1.2a0 → rapida_python-0.1.4a0}/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,
     ):