clarifai 11.4.2__py3-none-any.whl → 11.4.3__py3-none-any.whl

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "11.4.2"
+__version__ = "11.4.3"

clarifai/cli/base.py

@@ -143,6 +143,13 @@ def dump(ctx_obj, output_format):
         json.dump(ctx_obj.to_dict(), sys.stdout, indent=2)
 
 
+@config.command(['cat'])
+@click.pass_obj
+def env(ctx_obj):
+    """Print env vars. Use: eval "$(clarifai config env)" """
+    ctx_obj.current.print_env_vars()
+
+
 @cli.command()
 @click.argument('api_url', default="https://api.clarifai.com")
 @click.option('--user_id', required=False, help='User ID')

clarifai/cli/model.py

@@ -504,6 +504,10 @@ def local_dev(ctx, model_path):
 
     logger.info(f"Current deployment_id: {deployment_id}")
 
+    logger.info(
+        f"Full url for the model: /users/{user_id}/apps/{app_id}/models/{model.id}/versions/{version.id}"
+    )
+
     # Now that we have all the context in ctx.obj, we need to update the config.yaml in
     # the model_path directory with the model object containing user_id, app_id, model_id, version_id
     config_file = os.path.join(model_path, 'config.yaml')
@@ -526,13 +530,9 @@ def local_dev(ctx, model_path):
         ModelBuilder._backup_config(config_file)
         ModelBuilder._save_config(config_file, config)
 
-    # client_model = Model(
-    # TODO: once we can generate_client_script from ModelBuilder or similar
-    # we should be able to put the exact function call in place.
-    # model_script = model.generate_client_script()
-
     builder = ModelBuilder(model_path, download_validation_only=True)
-    method_signatures = builder.get_method_signatures()
+    # don't mock for local dev since you need the dependencies to run the code anyways.
+    method_signatures = builder.get_method_signatures(mocking=False)
 
     from clarifai.runners.utils import code_script
 
@@ -546,8 +546,6 @@ def local_dev(ctx, model_path):
         base_url=ctx.obj.current.api_base,
     )
 
-    # TODO: put in the ClarifaiUrlHelper to create the model url.
-
     logger.info("""\n
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 # About to start up the local dev runner in this terminal...

clarifai/client/app.py

@@ -19,6 +19,7 @@ from clarifai.client.workflow import Workflow
 from clarifai.constants.model import TRAINABLE_MODEL_TYPES
 from clarifai.errors import UserError
 from clarifai.urls.helper import ClarifaiUrlHelper
+from clarifai.utils.constants import DEFAULT_BASE
 from clarifai.utils.logging import display_concept_relations_tree, display_workflow_tree, logger
 from clarifai.utils.misc import concept_relations_accumulation
 from clarifai.workflows.utils import get_yaml_output_info_proto, is_same_yaml_model
@@ -33,7 +34,7 @@ class App(Lister, BaseClient):
         url: str = None,
         app_id: str = None,
         user_id: str = None,
-        base_url: str = "https://api.clarifai.com",
+        base_url: str = DEFAULT_BASE,
         pat: str = None,
         token: str = None,
         root_certificates_path: str = None,

clarifai/client/auth/helper.py

@@ -7,10 +7,12 @@ from clarifai_grpc.channel.clarifai_channel import ClarifaiChannel
 from clarifai_grpc.grpc.api import resources_pb2, service_pb2_grpc
 
 from clarifai import __version__
-from clarifai.utils.constants import CLARIFAI_PAT_ENV_VAR, CLARIFAI_SESSION_TOKEN_ENV_VAR
-
-DEFAULT_BASE = "https://api.clarifai.com"
-DEFAULT_UI = "https://clarifai.com"
+from clarifai.utils.constants import (
+    CLARIFAI_PAT_ENV_VAR,
+    CLARIFAI_SESSION_TOKEN_ENV_VAR,
+    DEFAULT_BASE,
+    DEFAULT_UI,
+)
 
 REQUEST_ID_PREFIX_HEADER = "x-clarifai-request-id-prefix"
 REQUEST_ID_PREFIX = f"sdk-python-{__version__}"

clarifai/client/compute_cluster.py

@@ -10,6 +10,7 @@ from clarifai.client.base import BaseClient
 from clarifai.client.lister import Lister
 from clarifai.client.nodepool import Nodepool
 from clarifai.errors import UserError
+from clarifai.utils.constants import DEFAULT_BASE
 from clarifai.utils.logging import logger
 
 
@@ -20,7 +21,7 @@ class ComputeCluster(Lister, BaseClient):
         self,
         compute_cluster_id: str = None,
         user_id: str = None,
-        base_url: str = "https://api.clarifai.com",
+        base_url: str = DEFAULT_BASE,
         pat: str = None,
         token: str = None,
         root_certificates_path: str = None,

clarifai/client/dataset.py

@@ -45,6 +45,7 @@ ClarifaiDatasetType = TypeVar(
     VisualSegmentationDataset,
     TextClassificationDataset,
 )
+from clarifai.utils.constants import DEFAULT_BASE
 
 
 class Dataset(Lister, BaseClient):
@@ -55,7 +56,7 @@ class Dataset(Lister, BaseClient):
         url: str = None,
         dataset_id: str = None,
         dataset_version_id: str = None,
-        base_url: str = "https://api.clarifai.com",
+        base_url: str = DEFAULT_BASE,
         pat: str = None,
         token: str = None,
         root_certificates_path: str = None,

clarifai/client/deployment.py

@@ -2,6 +2,7 @@ from clarifai_grpc.grpc.api import resources_pb2
 
 from clarifai.client.base import BaseClient
 from clarifai.client.lister import Lister
+from clarifai.utils.constants import DEFAULT_BASE
 from clarifai.utils.logging import logger
 from clarifai.utils.protobuf import dict_to_protobuf
 
@@ -13,7 +14,7 @@ class Deployment(Lister, BaseClient):
         self,
         deployment_id: str = None,
         user_id: str = None,
-        base_url: str = "https://api.clarifai.com",
+        base_url: str = DEFAULT_BASE,
         pat: str = None,
         token: str = None,
         root_certificates_path: str = None,

clarifai/client/input.py

@@ -21,6 +21,7 @@ from clarifai.client.lister import Lister
 from clarifai.constants.dataset import MAX_RETRIES
 from clarifai.constants.input import MAX_UPLOAD_BATCH_SIZE
 from clarifai.errors import UserError
+from clarifai.utils.constants import DEFAULT_BASE
 from clarifai.utils.logging import logger
 from clarifai.utils.misc import BackoffIterator, Chunker, clean_input_id
 
@@ -33,7 +34,7 @@ class Inputs(Lister, BaseClient):
         user_id: str = None,
         app_id: str = None,
         logger_level: str = "INFO",
-        base_url: str = "https://api.clarifai.com",
+        base_url: str = DEFAULT_BASE,
         pat: str = None,
         token: str = None,
         root_certificates_path: str = None,

clarifai/client/model.py

@@ -34,6 +34,7 @@ from clarifai.constants.model import (
 )
 from clarifai.errors import UserError
 from clarifai.urls.helper import ClarifaiUrlHelper
+from clarifai.utils.constants import DEFAULT_BASE
 from clarifai.utils.logging import logger
 from clarifai.utils.misc import BackoffIterator
 from clarifai.utils.model_train import (
@@ -58,7 +59,7 @@ class Model(Lister, BaseClient):
         url: str = None,
         model_id: str = None,
         model_version: Dict = {'id': ""},
-        base_url: str = "https://api.clarifai.com",
+        base_url: str = DEFAULT_BASE,
         pat: str = None,
         token: str = None,
         root_certificates_path: str = None,

clarifai/client/model_client.py

@@ -8,7 +8,6 @@ from clarifai_grpc.grpc.api.status import status_code_pb2
 from clarifai.constants.model import MAX_MODEL_PREDICT_INPUTS
 from clarifai.errors import UserError
 from clarifai.runners.utils import code_script, method_signatures
-from clarifai.runners.utils.data_utils import is_openai_chat_format
 from clarifai.runners.utils.method_signatures import (
     CompatibilitySerializer,
     deserialize,
@@ -16,6 +15,7 @@ from clarifai.runners.utils.method_signatures import (
     serialize,
     signatures_from_json,
 )
+from clarifai.runners.utils.openai_convertor import is_openai_chat_format
 from clarifai.utils.logging import logger
 from clarifai.utils.misc import BackoffIterator, status_is_retryable
 

clarifai/client/module.py

@@ -6,6 +6,7 @@ from clarifai.client.base import BaseClient
 from clarifai.client.lister import Lister
 from clarifai.errors import UserError
 from clarifai.urls.helper import ClarifaiUrlHelper
+from clarifai.utils.constants import DEFAULT_BASE
 from clarifai.utils.logging import logger
 
 
@@ -17,7 +18,7 @@ class Module(Lister, BaseClient):
         url: str = None,
         module_id: str = None,
         module_version: Dict = {'id': ""},
-        base_url: str = "https://api.clarifai.com",
+        base_url: str = DEFAULT_BASE,
         pat: str = None,
         token: str = None,
         root_certificates_path: str = None,

clarifai/client/nodepool.py

@@ -11,6 +11,7 @@ from clarifai.client.deployment import Deployment
 from clarifai.client.lister import Lister
 from clarifai.client.runner import Runner
 from clarifai.errors import UserError
+from clarifai.utils.constants import DEFAULT_BASE
 from clarifai.utils.logging import logger
 
 
@@ -21,7 +22,7 @@ class Nodepool(Lister, BaseClient):
         self,
         nodepool_id: str = None,
         user_id: str = None,
-        base_url: str = "https://api.clarifai.com",
+        base_url: str = DEFAULT_BASE,
         pat: str = None,
         token: str = None,
         root_certificates_path: str = None,

clarifai/client/runner.py

@@ -2,6 +2,7 @@ from clarifai_grpc.grpc.api import resources_pb2
 
 from clarifai.client.base import BaseClient
 from clarifai.client.lister import Lister
+from clarifai.utils.constants import DEFAULT_BASE
 from clarifai.utils.logging import logger
 from clarifai.utils.protobuf import dict_to_protobuf
 
@@ -13,7 +14,7 @@ class Runner(Lister, BaseClient):
         self,
         runner_id: str = None,
         user_id: str = None,
-        base_url: str = "https://api.clarifai.com",
+        base_url: str = DEFAULT_BASE,
         pat: str = None,
         token: str = None,
         root_certificates_path: str = None,

clarifai/client/search.py

@@ -17,6 +17,7 @@ from clarifai.constants.search import (
 )
 from clarifai.errors import UserError
 from clarifai.schema.search import get_schema
+from clarifai.utils.constants import DEFAULT_BASE
 
 
 class Search(Lister, BaseClient):
@@ -28,7 +29,7 @@ class Search(Lister, BaseClient):
         metric: str = DEFAULT_SEARCH_METRIC,
         algorithm: str = DEFAULT_SEARCH_ALGORITHM,
         pagination: bool = False,
-        base_url: str = "https://api.clarifai.com",
+        base_url: str = DEFAULT_BASE,
         pat: str = None,
         token: str = None,
         root_certificates_path: str = None,

clarifai/client/user.py

@@ -12,6 +12,7 @@ from clarifai.client.base import BaseClient
 from clarifai.client.compute_cluster import ComputeCluster
 from clarifai.client.lister import Lister
 from clarifai.errors import UserError
+from clarifai.utils.constants import DEFAULT_BASE
 from clarifai.utils.logging import logger
 
 
@@ -21,7 +22,7 @@ class User(Lister, BaseClient):
     def __init__(
         self,
         user_id: str = None,
-        base_url: str = "https://api.clarifai.com",
+        base_url: str = DEFAULT_BASE,
         pat: str = None,
         token: str = None,
         root_certificates_path: str = None,

clarifai/client/workflow.py

@@ -14,6 +14,7 @@ from clarifai.client.model import Model
 from clarifai.constants.workflow import MAX_WORKFLOW_PREDICT_INPUTS
 from clarifai.errors import UserError
 from clarifai.urls.helper import ClarifaiUrlHelper
+from clarifai.utils.constants import DEFAULT_BASE
 from clarifai.utils.logging import logger
 from clarifai.utils.misc import BackoffIterator, status_is_retryable
 from clarifai.workflows.export import Exporter
@@ -28,7 +29,7 @@ class Workflow(Lister, BaseClient):
         workflow_id: str = None,
         workflow_version: Dict = {'id': ""},
         output_config: Dict = {'min_value': 0},
-        base_url: str = "https://api.clarifai.com",
+        base_url: str = DEFAULT_BASE,
         pat: str = None,
         token: str = None,
         root_certificates_path: str = None,

clarifai/runners/models/mcp_class.py

@@ -0,0 +1,114 @@
+"""Base class for creating Model Context Protocol (MCP) servers."""
+
+import asyncio
+import json
+from typing import Any
+
+from fastmcp import Client, FastMCP  # use fastmcp v2 not the built in mcp
+from mcp import types
+from mcp.shared.exceptions import McpError
+
+from clarifai.runners.models.model_class import ModelClass
+
+
+class MCPModelClass(ModelClass):
+    """Base class for wrapping FastMCP servers as a model running in Clarfai. This handles
+    all the transport between the API and the MCP server here. Simply subclass this and implement
+    the get_server() method to return the FastMCP server instance. The server is then used to
+    handle all the requests and responses.
+    """
+
+    def load_model(self):
+        # in memory transport provided in fastmcp v2 so we can easily use the client functions.
+        self.client = Client(self.get_server())
+
+    def get_server(self) -> FastMCP:
+        """Required method for each subclass to implement to return the FastMCP server to use."""
+        raise NotImplementedError("Subclasses must implement get_server() method")
+
+    @ModelClass.method
+    def mcp_transport(self, msg: str) -> str:
+        """The single model method to get the jsonrpc message and send it to the FastMCP server then
+        return it's response.
+
+        """
+
+        async def send_notification(client_message: types.ClientNotification) -> None:
+            async with self.client:
+                # Strip the jsonrpc field since send_notification will also pass it in for some reason.
+                client_message = types.ClientNotification.model_validate(
+                    client_message.model_dump(
+                        by_alias=True, mode="json", exclude_none=True, exclude={"jsonrpc"}
+                    )
+                )
+                try:
+                    return await self.client.session.send_notification(client_message)
+                except McpError as e:
+                    return types.JSONRPCError(jsonrpc="2.0", error=e.error)
+
+        async def send_request(client_message: types.ClientRequest, id: str) -> Any:
+            async with self.client:
+                # Strip the jsonrpc and id fields as send_request sets them again too.
+                client_message = types.ClientRequest.model_validate(
+                    client_message.model_dump(
+                        by_alias=True, mode="json", exclude_none=True, exclude={"jsonrpc", "id"}
+                    )
+                )
+
+                result_type = None
+                if isinstance(client_message.root, types.PingRequest):
+                    result_type = types.EmptyResult
+                elif isinstance(client_message.root, types.InitializeRequest):
+                    return await self.client.session.initialize()
+                elif isinstance(client_message.root, types.SetLevelRequest):
+                    result_type = types.EmptyResult
+                elif isinstance(client_message.root, types.ListResourcesRequest):
+                    result_type = types.ListResourcesResult
+                elif isinstance(client_message.root, types.ListResourceTemplatesRequest):
+                    result_type = types.ListResourceTemplatesResult
+                elif isinstance(client_message.root, types.ReadResourceRequest):
+                    result_type = types.ReadResourceResult
+                elif isinstance(client_message.root, types.SubscribeRequest):
+                    result_type = types.EmptyResult
+                elif isinstance(client_message.root, types.UnsubscribeRequest):
+                    result_type = types.EmptyResult
+                elif isinstance(client_message.root, types.ListPromptsRequest):
+                    result_type = types.ListPromptsResult
+                elif isinstance(client_message.root, types.GetPromptRequest):
+                    result_type = types.GetPromptResult
+                elif isinstance(client_message.root, types.CompleteRequest):
+                    result_type = types.CompleteResult
+                elif isinstance(client_message.root, types.ListToolsRequest):
+                    result_type = types.ListToolsResult
+                elif isinstance(client_message.root, types.CallToolRequest):
+                    result_type = types.CallToolResult
+                else:
+                    # this is a special case where we need to return the list of tools.
+                    raise NotImplementedError(f"Method {client_message.method} not implemented")
+                # Call the mcp server using send_request() or send_notification() depending on the method.
+                try:
+                    return await self.client.session.send_request(client_message, result_type)
+                except McpError as e:
+                    return types.JSONRPCError(jsonrpc="2.0", id=id, error=e.error)
+
+        # The message coming here is the generic request. We look at it's .method
+        # to determine which client function to call and to further subparse the params.
+        # Note(zeiler): unfortunately the pydantic types in mcp/types.py are not consistent.
+        # The JSONRPCRequest are supposed to have an id but the InitializeRequest
+        # does not have it.
+        d = json.loads(msg)
+        id = d.get('id', "")
+
+        # If we have an id it's a JSONRPCRequest
+        if not d.get('method', '').startswith("notifications/"):
+            client_message = types.ClientRequest.model_validate(d)
+            response = asyncio.run(send_request(client_message, id=id))
+        else:  # JSONRPCRequest
+            client_message = types.ClientNotification.model_validate(d)
+            response = asyncio.run(send_notification(client_message))
+        if response is None:
+            response = types.JSONRPCError(
+                jsonrpc="2.0", id=id, error="Got empty response from MCP server."
+            )
+        # return as a serialized json string
+        return response.model_dump_json(by_alias=True, exclude_none=True)

clarifai/runners/models/model_builder.py

@@ -410,11 +410,17 @@ class ModelBuilder:
         signatures = {method.name: method.signature for method in method_info.values()}
         return signatures_to_yaml(signatures)
 
-    def get_method_signatures(self):
+    def get_method_signatures(self, mocking=True):
         """
         Returns the method signatures for the model class.
+
+        Args:
+          mocking (bool): Whether to mock the model class or not. Defaults to False.
+
+        Returns:
+          list: A list of method signatures for the model class.
         """
-        model_class = self.load_model_class(mocking=True)
+        model_class = self.load_model_class(mocking=mocking)
         method_info = model_class._get_method_info()
         signatures = [method.signature for method in method_info.values()]
         return signatures
@@ -436,22 +442,42 @@ class ModelBuilder:
         return self._client
 
     @property
-    def model_url(self):
+    def model_ui_url(self):
+        url_helper = ClarifaiUrlHelper(self._client.auth_helper)
+        # Note(zeiler): the UI experience isn't the best when including version id right now.
+        # if self.model_version_id is not None:
+        #     return url_helper.clarifai_url(
+        #         self.client.user_app_id.user_id,
+        #         self.client.user_app_id.app_id,
+        #         "models",
+        #         self.model_id,
+        #         self.model_version_id,
+        #     )
+        # else:
+        return url_helper.clarifai_url(
+            self.client.user_app_id.user_id,
+            self.client.user_app_id.app_id,
+            "models",
+            self.model_id,
+        )
+
+    @property
+    def model_api_url(self):
         url_helper = ClarifaiUrlHelper(self._client.auth_helper)
         if self.model_version_id is not None:
-            return url_helper.clarifai_url(
+            return url_helper.api_url(
                 self.client.user_app_id.user_id,
                 self.client.user_app_id.app_id,
                 "models",
                 self.model_id,
+                self.model_version_id,
             )
         else:
-            return url_helper.clarifai_url(
+            return url_helper.api_url(
                 self.client.user_app_id.user_id,
                 self.client.user_app_id.app_id,
                 "models",
                 self.model_id,
-                self.model_version_id,
             )
 
     def _get_model_proto(self):
@@ -930,10 +956,11 @@ class ModelBuilder:
             return
         self.model_version_id = response.model_version_id
         logger.info(f"Created Model Version ID: {self.model_version_id}")
-        logger.info(f"Full url to that version is: {self.model_url}")
+        logger.info(f"Full url to that version is: {self.model_ui_url}")
         try:
             is_uploaded = self.monitor_model_build()
             if is_uploaded:
+                # python code to run the model.
                 from clarifai.runners.utils import code_script
 
                 method_signatures = self.get_method_signatures()
@@ -945,7 +972,7 @@ class ModelBuilder:
                 )
                 logger.info("""\n
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
-# Here is a code snippet to call this model:
+# Here is a code snippet to use this model:
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
                 """)
                 logger.info(snippet)
@@ -1049,7 +1076,7 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
                 logger.info("Model build complete!")
                 logger.info(f"Build time elapsed {time.time() - st:.1f}s)")
                 logger.info(
-                    f"Check out the model at {self.model_url} version: {self.model_version_id}"
+                    f"Check out the model at {self.model_ui_url} version: {self.model_version_id}"
                 )
                 return True
             else:
@@ -1074,10 +1101,12 @@ def upload_model(folder, stage, skip_dockerfile):
     exists = builder.check_model_exists()
     if exists:
         logger.info(
-            f"Model already exists at {builder.model_url}, this upload will create a new version for it."
+            f"Model already exists at {builder.model_ui_url}, this upload will create a new version for it."
         )
     else:
-        logger.info(f"New model will be created at {builder.model_url} with it's first version.")
+        logger.info(
+            f"New model will be created at {builder.model_ui_url} with it's first version."
+        )
 
     input("Press Enter to continue...")
     builder.upload_model_version()

clarifai/runners/utils/code_script.py

@@ -4,6 +4,7 @@ from typing import List
 from clarifai_grpc.grpc.api import resources_pb2
 
 from clarifai.runners.utils import data_utils
+from clarifai.urls.helper import ClarifaiUrlHelper
 
 
 def generate_client_script(
@@ -15,6 +16,38 @@ def generate_client_script(
     deployment_id: str = None,
     use_ctx: bool = False,
 ) -> str:
+    url_helper = ClarifaiUrlHelper()
+
+    # Provide an mcp client config
+    if len(method_signatures) == 1 and method_signatures[0].name == "mcp_transport":
+        api_url = url_helper.api_url(
+            user_id,
+            app_id,
+            "models",
+            model_id,
+        )
+
+        _CLIENT_TEMPLATE = """
+import asyncio
+import os
+from fastmcp import Client
+from fastmcp.client.transports import StreamableHttpTransport
+
+transport = StreamableHttpTransport(url="%s/mcp",
+                                    headers={"Authorization": "Bearer " + os.environ["CLARIFAI_PAT"]})
+
+async def main():
+  async with Client(transport) as client:
+    tools = await client.list_tools()
+    print(f"Available tools: {tools}")
+    result = await client.call_tool(tools[0].name, {"a": 5, "b": 3})
+    print(f"Result: {result[0].text}")
+
+if __name__ == "__main__":
+  asyncio.run(main())
+"""
+        return _CLIENT_TEMPLATE % api_url
+
     _CLIENT_TEMPLATE = """\
 import os
 
@@ -35,8 +68,9 @@ from clarifai.runners.utils import data_types
         model_section = """
 model = Model.from_current_context()"""
     else:
+        model_ui_url = url_helper.clarifai_url(user_id, app_id, "models", model_id)
         model_section = f"""
-model = Model("https://clarifai.com/{user_id}/{app_id}/models/{model_id}",
+model = Model({model_ui_url},
                deployment_id = {deployment_id}, # Only needed for dedicated deployed models
                {base_url_str}
  )

clarifai/runners/utils/data_types/data_types.py

@@ -395,6 +395,22 @@ class Image(MessageData):
             raise ValueError("Image has no bytes")
         return PILImage.open(io.BytesIO(self.proto.base64))
 
+    def to_base64_str(self) -> str:
+        if not self.proto.base64:
+            raise ValueError("Image has no bytes")
+        if isinstance(self.proto.base64, str):
+            return self.proto.base64
+        if isinstance(self.proto.base64, bytes):
+            try:
+                # trying direct decode (if already a base64 bytes)
+                return self.proto.base64.decode('utf-8')
+            except UnicodeDecodeError:
+                import base64
+
+                return base64.b64encode(self.proto.base64).decode('utf-8')
+        else:
+            raise TypeError("Expected str or bytes for Image.base64")
+
     def to_numpy(self) -> np.ndarray:
         return np.asarray(self.to_pil())
 
@@ -466,6 +482,22 @@ class Audio(MessageData):
     def to_proto(self) -> AudioProto:
         return self.proto
 
+    def to_base64_str(self) -> str:
+        if not self.proto.base64:
+            raise ValueError("Audio has no bytes")
+        if isinstance(self.proto.base64, str):
+            return self.proto.base64
+        if isinstance(self.proto.base64, bytes):
+            try:
+                # trying direct decode (if already a base64 bytes)
+                return self.proto.base64.decode('utf-8')
+            except UnicodeDecodeError:
+                import base64
+
+                return base64.b64encode(self.proto.base64).decode('utf-8')
+        else:
+            raise TypeError("Expected str or bytes for Audio.base64")
+
     @classmethod
     def from_proto(cls, proto: AudioProto) -> "Audio":
         return cls(proto)
@@ -578,6 +610,22 @@ class Video(MessageData):
     def to_proto(self) -> VideoProto:
         return self.proto
 
+    def to_base64_str(self) -> str:
+        if not self.proto.base64:
+            raise ValueError("Video has no bytes")
+        if isinstance(self.proto.base64, str):
+            return self.proto.base64
+        if isinstance(self.proto.base64, bytes):
+            try:
+                # trying direct decode (if already a base64 bytes)
+                return self.proto.base64.decode('utf-8')
+            except UnicodeDecodeError:
+                import base64
+
+                return base64.b64encode(self.proto.base64).decode('utf-8')
+        else:
+            raise TypeError("Expected str or bytes for Video.base64")
+
     @classmethod
     def from_proto(cls, proto: VideoProto) -> "Video":
         return cls(proto)

clarifai/runners/utils/data_utils.py

@@ -1,63 +1,89 @@
+import base64
 import json
 import math
 import operator
 from io import BytesIO
-from typing import List
+from typing import Dict, List
 
+import requests
 from clarifai_grpc.grpc.api import resources_pb2
 from clarifai_grpc.grpc.api.resources_pb2 import ModelTypeEnumOption, ModelTypeRangeInfo
 from clarifai_grpc.grpc.api.resources_pb2 import ModelTypeField as ParamProto
-from PIL import Image
+from PIL import Image as PILImage
 
-from clarifai.runners.utils.data_types import MessageData
+from clarifai.runners.utils.data_types import Audio, Image, MessageData, Video
 
 
-def image_to_bytes(img: Image.Image, format="JPEG") -> bytes:
+def image_to_bytes(img: PILImage.Image, format="JPEG") -> bytes:
     buffered = BytesIO()
     img.save(buffered, format=format)
     img_str = buffered.getvalue()
     return img_str
 
 
-def bytes_to_image(bytes_img) -> Image.Image:
-    img = Image.open(BytesIO(bytes_img))
+def bytes_to_image(bytes_img) -> PILImage.Image:
+    img = PILImage.open(BytesIO(bytes_img))
     return img
 
 
-def is_openai_chat_format(messages):
-    """
-    Verify if the given argument follows the OpenAI chat messages format.
-
-    Args:
-        messages (list): A list of dictionaries representing chat messages.
-
-    Returns:
-        bool: True if valid, False otherwise.
-    """
-    if not isinstance(messages, list):
-        return False
-
-    valid_roles = {"system", "user", "assistant", "function"}
-
-    for msg in messages:
-        if not isinstance(msg, dict):
-            return False
-        if "role" not in msg or "content" not in msg:
-            return False
-        if msg["role"] not in valid_roles:
-            return False
-
-        content = msg["content"]
-
-        # Content should be either a string (text message) or a multimodal list
-        if isinstance(content, str):
-            continue  # Valid text message
-
-        elif isinstance(content, list):
-            for item in content:
-                if not isinstance(item, dict):
-                    return False
-    return True
+def process_image(image: Image) -> Dict:
+    """Convert Clarifai Image object to OpenAI image format."""
+
+    if image.bytes:
+        b64_img = image.to_base64_str()
+        return {'type': 'image_url', 'image_url': {'url': f"data:image/jpeg;base64,{b64_img}"}}
+    elif image.url:
+        return {'type': 'image_url', 'image_url': {'url': image.url}}
+    else:
+        raise ValueError("Image must contain either bytes or URL")
+
+
+def process_audio(audio: Audio) -> Dict:
+    """Convert Clarifai Audio object to OpenAI audio format."""
+
+    if audio.bytes:
+        audio = audio.to_base64_str()
+        audio = {
+            "type": "input_audio",
+            "input_audio": {"data": audio, "format": "wav"},
+        }
+    elif audio.url:
+        response = requests.get(audio.url)
+        if response.status_code != 200:
+            raise ValueError(f"Failed to fetch audio from URL: {audio.url}")
+        audio_base64_str = base64.b64encode(response.content).decode('utf-8')
+        audio = {
+            "type": "input_audio",
+            "input_audio": {"data": audio_base64_str, "format": "wav"},
+        }
+    else:
+        raise ValueError("Audio must contain either bytes or URL")
+
+    return audio
+
+
+def process_video(video: Video) -> Dict:
+    """Convert Clarifai Video object to OpenAI video format."""
+
+    if video.bytes:
+        video = "data:video/mp4;base64," + video.to_base64_str()
+        video = {
+            "type": "video_url",
+            "video_url": {"url": video},
+        }
+    elif video.url:
+        response = requests.get(video.url)
+        if response.status_code != 200:
+            raise ValueError(f"Failed to fetch video from URL: {video.url}")
+        video_base64_str = base64.b64encode(response.content).decode('utf-8')
+        video = {
+            "type": "video_url",
+            "video_url": {"url": video_base64_str},
+        }
+    else:
+        raise ValueError("Video must contain either bytes or URL")
+
+    return video
 
 
 class Param(MessageData):

clarifai/runners/utils/openai_convertor.py

@@ -1,5 +1,9 @@
 import time
 import uuid
+from typing import Dict, List
+
+from clarifai.runners.utils.data_types import Audio, Image, Video
+from clarifai.runners.utils.data_utils import process_audio, process_image, process_video
 
 
 def generate_id():
@@ -164,3 +168,102 @@ def openai_to_hf_messages(openai_messages):
         hf_messages.append({'role': role, 'content': hf_content})
 
     return hf_messages
+
+
+def build_openai_messages(
+    prompt: str,
+    image: Image,
+    images: List[Image],
+    audio: Audio,
+    audios: List[Audio],
+    video: Video,
+    videos: List[Video],
+    messages: List[Dict],
+) -> List[Dict]:
+    """
+    Construct OpenAI-compatible messages from input components.
+      Args:
+          prompt (str): The prompt text.
+          image (Image): Clarifai Image object.
+          images (List[Image]): List of Clarifai Image objects.
+          audio (Audio): Clarifai Audio object.
+          audios (List[Audio]): List of Clarifai Audio objects.
+          video (Video): Clarifai Video object.
+          videos (List[Video]): List of Clarifai Video objects.
+          messages (List[Dict]): List of chat messages.
+      Returns:
+          List[Dict]: Formatted chat messages.
+    """
+
+    openai_messages = []
+    # Add previous conversation history
+    if messages and is_openai_chat_format(messages):
+        openai_messages.extend(messages)
+
+    content = []
+    if prompt.strip():
+        # Build content array for current message
+        content.append({'type': 'text', 'text': prompt})
+    # Add single image if present
+    if image:
+        content.append(process_image(image))
+    # Add multiple images if present
+    if images:
+        for img in images:
+            content.append(process_image(img))
+    # Add single audio if present
+    if audio:
+        content.append(process_audio(audio))
+    # Add multiple audios if present
+    if audios:
+        for audio in audios:
+            content.append(process_audio(audio))
+    # Add single video if present
+    if video:
+        content.append(process_video(video))
+    # Add multiple videos if present
+    if videos:
+        for video in videos:
+            content.append(process_video(video))
+
+    if content:
+        # Append complete user message
+        openai_messages.append({'role': 'user', 'content': content})
+
+    return openai_messages
+
+
+def is_openai_chat_format(messages):
+    """
+    Verify if the given argument follows the OpenAI chat messages format.
+
+    Args:
+        messages (list): A list of dictionaries representing chat messages.
+
+    Returns:
+        bool: True if valid, False otherwise.
+    """
+    if not isinstance(messages, list):
+        return False
+
+    valid_roles = {"system", "user", "assistant", "function"}
+
+    for msg in messages:
+        if not isinstance(msg, dict):
+            return False
+        if "role" not in msg or "content" not in msg:
+            return False
+        if msg["role"] not in valid_roles:
+            return False
+
+        content = msg["content"]
+
+        # Content should be either a string (text message) or a multimodal list
+        if isinstance(content, str):
+            continue  # Valid text message
+
+        elif isinstance(content, list):
+            for item in content:
+                if not isinstance(item, dict):
+                    return False
+    return True

clarifai/urls/helper.py

@@ -1,10 +1,25 @@
+import os
+from collections import namedtuple
 from urllib.parse import urlparse
 
+from clarifai.utils.constants import DEFAULT_BASE, DEFAULT_UI
+
+# To help with using ClarifaiUrlHelper with defaults as ClarifaiUrlHelper()
+auth_obj = namedtuple("auth", ["ui", "base"])
+default_auth = auth_obj(
+    ui=os.environ.get("CLARIFAI_UI", DEFAULT_UI),
+    base=os.environ.get("CLARIFAI_API_BASE", DEFAULT_BASE),
+)
+
 
 class ClarifaiUrlHelper(object):
     """Lots of helper functionality for dealing with urls around modules."""
 
-    def __init__(self, auth, module_manager_imv_id="module_manager_install"):
+    def __init__(
+        self,
+        auth=default_auth,
+        module_manager_imv_id: str = "module_manager_install",
+    ):
         """
         Args:
           auth: a ClarifaiAuthHelper object.
@@ -13,13 +28,17 @@ class ClarifaiUrlHelper(object):
         self._module_manager_imv_id = module_manager_imv_id
 
     @property
-    def auth(self):
-        return self._auth
+    def ui(self):
+        return self._auth.ui
+
+    @property
+    def base(self):
+        return self._auth.base
 
     def module_ui_url(self, user_id, app_id, module_id, module_version_id):
         """This is the path to the module in community."""
         return "%s/%s/%s/modules/%s/versions/%s" % (
-            self.auth.ui,
+            self.ui,
             user_id,
             app_id,
             module_id,
@@ -30,7 +49,7 @@ class ClarifaiUrlHelper(object):
         """This is a url that allows for installation of the module from the community at 'module_url'
         into the destination app_id of the destination user_id."""
         return "%s/%s/%s/installed_module_versions/%s/install?install=%s" % (
-            self.auth.ui,
+            self.ui,
             dest_user_id,
             dest_app_id,
             self._module_manager_imv_id,
@@ -39,22 +58,51 @@ class ClarifaiUrlHelper(object):
 
     def imv_ui_url(self, dest_user_id, dest_app_id, imv_id):
         return "%s/%s/%s/installed_module_versions/%s" % (
-            self.auth.ui,
+            self.ui,
             dest_user_id,
             dest_app_id,
             imv_id,
         )
 
-    def clarifai_url(self, user_id, app_id, resource_type, resource_id, version_id: str = None):
-        """This is the path to the resource in community.
+    def api_url(self, user_id, app_id, resource_type, resource_id, version_id: str = None):
+        """This is the path to the resource in the API.
+
+        Example:
+          https://api.clarifai.com/v2/zeiler/app/modules/module1/versions/2
+          https://api.clarifai.com/v2/zeiler/app/models/model1/versions/2
+          https://api.clarifai.com/v2/zeiler/app/concepts/concept1
+          https://api.clarifai.com/v2/zeiler/app/workflows/workflow1
+          https://api.clarifai.com/v2/zeiler/app/tasks/task1
+          https://api.clarifai.com/v2/zeiler/app/installed_module_versions/module_manager_install
 
         Args:
           user_id: the author of the resource.
           app_id: the author's app the resource was created in.
-          resource_type: the type of resource. One of "modules", "models", "concepts", "inputs", "workflows", "tasks", "installed_module_versions"
+          resource_type: the type of resource. One of "modules", "models", "concepts", "inputs", "workflows", "tasks"
           resource_id: the resource ID
-          version_id: the version of the resource.
         """
+        self._validate_resource_type(resource_type)
+        if version_id is None:
+            return "%s/v2/users/%s/apps/%s/%s/%s" % (
+                self.base,
+                user_id,
+                app_id,
+                resource_type,
+                resource_id,
+            )
+
+        if resource_type in ["concepts", "tasks", "installed_module_versions"]:
+            raise ValueError(f"{resource_type} do not have versions.")
+        return "%s/v2/users/%s/apps/%s/%s/%s/versions/%s" % (
+            self.base,
+            user_id,
+            app_id,
+            resource_type,
+            resource_id,
+            version_id,
+        )
+
+    def _validate_resource_type(self, resource_type):
         if resource_type not in [
             "modules",
             "models",
@@ -68,10 +116,30 @@ class ClarifaiUrlHelper(object):
                 "resource_type must be one of modules, models, concepts, inputs, workflows, tasks, installed_module_versions but was %s"
                 % resource_type
             )
+
+    def clarifai_url(self, user_id, app_id, resource_type, resource_id, version_id: str = None):
+        """This is the path to the resource in community UI.
+
+        Example:
+          https://clarifai.com/zeiler/modules/module1/versions/2
+          https://clarifai.com/zeiler/models/model1/versions/2
+          https://clarifai.com/zeiler/concepts/concept1
+          https://clarifai.com/zeiler/workflows/workflow1
+          https://clarifai.com/zeiler/tasks/task1
+          https://clarifai.com/zeiler/installed_module_versions/module_manager_install
+
+        Args:
+          user_id: the author of the resource.
+          app_id: the author's app the resource was created in.
+          resource_type: the type of resource. One of "modules", "models", "concepts", "inputs", "workflows", "tasks", "installed_module_versions"
+          resource_id: the resource ID
+          version_id: the version of the resource.
+        """
+        self._validate_resource_type(resource_type)
         if version_id is None:
-            return "%s/%s/%s/%s/%s" % (self.auth.ui, user_id, app_id, resource_type, resource_id)
+            return "%s/%s/%s/%s/%s" % (self.ui, user_id, app_id, resource_type, resource_id)
         return "%s/%s/%s/%s/%s/versions/%s" % (
-            self.auth.ui,
+            self.ui,
             user_id,
             app_id,
             resource_type,

clarifai/utils/config.py

@@ -102,6 +102,25 @@ class Context(OrderedDict):
                 envvar_name = 'CLARIFAI_' + envvar_name
             os.environ[envvar_name] = str(v)
 
+    def print_env_vars(self):
+        """prints the context env vars to the terminal
+
+        Example:
+          # This is helpful in scripts so you can do
+
+          from clarifai.utils.config import Config
+
+          Config.from_yaml().current.print_env_vars()
+
+        """
+        for k, v in sorted(self['env'].items()):
+            if isinstance(v, dict):
+                continue
+            envvar_name = k.upper()
+            if not envvar_name.startswith('CLARIFAI_'):
+                envvar_name = 'CLARIFAI_' + envvar_name
+            print(f"export {envvar_name}=\"{v}\"")
+
 
 @dataclass
 class Config:

clarifai/utils/constants.py

@@ -1,5 +1,9 @@
 import os
 
+DEFAULT_UI = os.environ.get("CLARIFAI_UI", "https://clarifai.com")
+DEFAULT_BASE = os.environ.get("CLARIFAI_API_BASE", "https://api.clarifai.com")
+
+
 CLARIFAI_PAT_ENV_VAR = "CLARIFAI_PAT"
 CLARIFAI_SESSION_TOKEN_ENV_VAR = "CLARIFAI_SESSION_TOKEN"
 CLARIFAI_USER_ID_ENV_VAR = "CLARIFAI_USER_ID"

{clarifai-11.4.2.dist-info → clarifai-11.4.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clarifai
-Version: 11.4.2
+Version: 11.4.3
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
 Author-email: support@clarifai.com

{clarifai-11.4.2.dist-info → clarifai-11.4.3.dist-info}/RECORD

@@ -1,33 +1,33 @@
-clarifai/__init__.py,sha256=pSlLOPfmtDJ3YrQTjGkuoViOvxNtsJ3x0m9xPOysJPQ,23
+clarifai/__init__.py,sha256=WC-Q7uwDymQD3TdIUlUDTeqf9vxRXHJ_xDIRpvTVvsw,23
 clarifai/cli.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/errors.py,sha256=GXa6D4v_L404J83jnRNFPH7s-1V9lk7w6Ws99f1g-AY,2772
 clarifai/versions.py,sha256=ecSuEB_nOL2XSoYHDw2n23XUbm_KPOGjudMXmQrGdS8,224
 clarifai/cli/README.md,sha256=YGApHfeUyu5P0Pdth-mqQCQftWHDxz6bugDlvDXDhOE,1942
 clarifai/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/cli/__main__.py,sha256=7nPbLW7Jr2shkgMPvnxpn4xYGMvIcnqluJ69t9w4H_k,74
-clarifai/cli/base.py,sha256=Bp5wWHTFNPgruQ5qitPzYFSK-w6LqWQg0kS49bdB1Ls,8067
+clarifai/cli/base.py,sha256=Rk87oliNs3q-pVX2ubyjycgo4Gtd0hcDSgr9MqDxyko,8227
 clarifai/cli/compute_cluster.py,sha256=8Xss0Obrp6l1XuxJe0luOqU_pf8vXGDRi6jyIe8qR6k,2282
 clarifai/cli/deployment.py,sha256=9C4I6_kyMxRkWl6h681wc79-3mAtDHtTUaxRv05OZMs,4262
-clarifai/cli/model.py,sha256=TXpjcm1My5F1QK8mMW1FwRx1EkS1GRpm1y6gR1qYfV4,27433
+clarifai/cli/model.py,sha256=M1O0QCdIyTcn2GzrkROAtgWR-8SX2WV9nz0l84rkiG4,27375
 clarifai/cli/nodepool.py,sha256=H6OIdUW_EiyDUwZogzEDoYmVwEjLMsgoDlPyE7gjIuU,4245
 clarifai/client/__init__.py,sha256=NhpNFRJY6mTi8ca-5hUeTEmYeDKHDNXY48FN63pDuos,703
-clarifai/client/app.py,sha256=LmIz06Tf1SVNd5SdLV5iqttEiY1x_8r5zX85MCfuXlo,41344
+clarifai/client/app.py,sha256=D0FG9v07g1dExLnQsYt0OQjsJCkVvuw76BOpcqaCzfM,41380
 clarifai/client/base.py,sha256=zOmB5HJP_-NmF2BPka14W7VUeJ1OF-fNxeacLsaRj3E,8775
-clarifai/client/compute_cluster.py,sha256=Tf4Svvx96pC2dMwdtpUsMiope-Nq941dpOViH4uDx5k,10218
-clarifai/client/dataset.py,sha256=lsHrY2yxN_zfTGWzE_Gp7W_oi2G6BW2kPvAmKv6FyVE,35263
-clarifai/client/deployment.py,sha256=MQ3Kd8Ldp_JTC1hqhRqPiHe0RVUjb6iBY5DiA2Q7NxA,2839
-clarifai/client/input.py,sha256=Oswf3sp8PLs39jGIqfbJ89afh9GTCSsaQ--lYPtEtRo,51169
+clarifai/client/compute_cluster.py,sha256=ViPyh-FibXL1J0ypsVOTaQnR1ymKohmZEuA13RwA-hc,10254
+clarifai/client/dataset.py,sha256=OgdpZkQ_vYmRxL8-qphcNozpvPV1bWTlte9Jv6UkKb8,35299
+clarifai/client/deployment.py,sha256=QBf0tzkKBEpzNgmOEmWUJMOlVWdFEFc70Y44o8y75Gs,2875
+clarifai/client/input.py,sha256=jpX47qwn7aUBBIEuSSLHF5jk70XaWEh0prD065c9b-E,51205
 clarifai/client/lister.py,sha256=1YEm2suNxPaJO4x9V5szgD_YX6N_00vgSO-7m0HagY8,2208
-clarifai/client/model.py,sha256=6KHMxKBb5EbOS_FC3lf3q9jl8p2-mitDhaZ1PejKVo8,86231
-clarifai/client/model_client.py,sha256=YCmbUQjMy3pzDzIB7_4hMro7sZCZTMwBFvNpyHpmPtY,22380
-clarifai/client/module.py,sha256=LDFpJciJUX-y9EzmLwAY86UGKlzabMSzUXxujoh8C9o,4501
-clarifai/client/nodepool.py,sha256=DXTa5Ap-TgcUiwd2tcdHuBFaqe3IgW4RkG05n9iUm98,16379
-clarifai/client/runner.py,sha256=Bs7kNk0YiLFKKOWkLZIyAHZxVWf1B5YIl2bsMhIYJw8,2217
-clarifai/client/search.py,sha256=Z-8PJJYAw5IlF0ac1M0GCz6TRQhouI8fwZryOJZkP1Q,15625
-clarifai/client/user.py,sha256=Ey-sqW5dFE_3HLC-E4mHncKth-nQ1j_q6Tp80TMOfwI,18358
-clarifai/client/workflow.py,sha256=55fO5IYhER-kHL1FwP3IiWjWEZYNG3jpe7vBRIi_PJQ,13381
+clarifai/client/model.py,sha256=XptnbfvNnaRCvv6Sdc7hfZnEPL8z9_-nFB3OmKujfAE,86267
+clarifai/client/model_client.py,sha256=V0rDa1Qnol2qfAvJI6SwZfbtXqNowPRRMOYBH2Em0so,22386
+clarifai/client/module.py,sha256=jLViQYvVV3FmRN_ivvbk83uwsx7CgYGeEx4dYAr6yD4,4537
+clarifai/client/nodepool.py,sha256=Y5zQ0JLdTjAp2TmVnx7AAOwaB2YUslk3nl7s6BQ90FQ,16415
+clarifai/client/runner.py,sha256=5xCiqByGGscfNm0IjHelhDTx8-9l8G0C3HL-3YZogK8,2253
+clarifai/client/search.py,sha256=3LLfATrdU43a0mRNITmJV-E53bhfafZkYsbwkTtlnyU,15661
+clarifai/client/user.py,sha256=VqY5j75wJqw1AeaWpZLvbNfSjQHGQm_bdjknDjX_fQY,18394
+clarifai/client/workflow.py,sha256=Bqh8lAmJcSbviJebckchTxucYlU11UQEhFSov7elpsk,13417
 clarifai/client/auth/__init__.py,sha256=7EwR0NrozkAUwpUnCsqXvE_p0wqx_SelXlSpKShKJK0,136
-clarifai/client/auth/helper.py,sha256=10Ow_eCgWMKURYW2aT46GLEax-GYoEUHwbcdt7tX6jg,15199
+clarifai/client/auth/helper.py,sha256=kHBi8GTX19EUiD9n_QgCqilv127TDIpP0_o5MMtzFdY,15167
 clarifai/client/auth/register.py,sha256=pyY-Kg_64WpN6rXz1SyEzfqL14BS4yADtuYMxLJ4jx4,554
 clarifai/client/auth/stub.py,sha256=pU4FYeghooCBZmCRyNTdDfJaVe4WyeRBqE3xVwfmMTY,5388
 clarifai/constants/base.py,sha256=ogmFSZYoF0YhGjHg5aiOc3MLqPr_poKAls6xaD0_C3U,89
@@ -67,7 +67,8 @@ clarifai/runners/__init__.py,sha256=cDJ31l41dDsqW4Xn6sFMkKxxdIMTnGH9IW6sVkq0TNw,
 clarifai/runners/server.py,sha256=9qVAs8pRHmtyY0RCNIQ1uP8nqDADIFZ03LnkoDt1h4U,4692
 clarifai/runners/dockerfile_template/Dockerfile.template,sha256=5cjv7U8PmWa3DB_5B1CqSYh_6GE0E0np52TIAa7EIDE,2312
 clarifai/runners/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-clarifai/runners/models/model_builder.py,sha256=8Rj5nxDUa_jpDBQ04tD0hztenzXKcx2OEg4ce9ELY4I,48237
+clarifai/runners/models/mcp_class.py,sha256=trtChVaesNSrb-Z3hdr0sdJjX7U7TlX4EMuO00vznTA,5960
+clarifai/runners/models/model_builder.py,sha256=PiqPyTGPSKsYvOQNpBzs4e1_wuEbtE-P3yEkLE4Py10,49231
 clarifai/runners/models/model_class.py,sha256=OHVd0tMOXDyl9v1vWeHOmYGx_dvP77N4zlLGMyTakag,15575
 clarifai/runners/models/model_run_locally.py,sha256=6-6WjEKc0ba3gAv4wOLdMs2XOzS3b-2bZHJS0wdVqJY,20088
 clarifai/runners/models/model_runner.py,sha256=SccX-RxTgruSpQaM21uMSl-z1x6fOa13fQZMQW8NNRY,7297
@@ -75,22 +76,22 @@ clarifai/runners/models/model_servicer.py,sha256=rRd_fNEXwqiBSzTUtPI2r07EBdcCPd8
 clarifai/runners/models/visual_classifier_class.py,sha256=f9ZP8KFamMUdMpUG3AlL9nVCdcggy_E5n9RJY3ixR1U,2739
 clarifai/runners/models/visual_detector_class.py,sha256=ky4oFAkGCKPpGPdgaOso-n6D3HcmnbKee_8hBsNiV8U,2883
 clarifai/runners/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-clarifai/runners/utils/code_script.py,sha256=M3S8c5XBMdY_VFsirLxdFRrC-PCqk1Tul0_qbm_89l4,10394
+clarifai/runners/utils/code_script.py,sha256=3_zBuMKs-eKfC4rbxKf-atVMz36djKH5QvDY2Fgs6Jk,11418
 clarifai/runners/utils/const.py,sha256=Q4Ps6gIEJCyTdQCfmT6PaS61WHmhT25XigV1NugWz-E,1544
-clarifai/runners/utils/data_utils.py,sha256=phrqojg3zhKDZxgXFdxL0NVLkuV0abbOLOSQPIGPPVI,19744
+clarifai/runners/utils/data_utils.py,sha256=GspFOTgUPdqSQG-Zy6lrB1V55gQhGDG3Co6AxiqAr1I,20792
 clarifai/runners/utils/loader.py,sha256=K5Y8MPbIe5STw2gDnrL8KqFgKNxEo7bz-RV0ip1T4PM,10900
 clarifai/runners/utils/method_signatures.py,sha256=3EqrTLxynaBC4clj23iw9fZApFDQeapCzVlre6uybbI,19152
-clarifai/runners/utils/openai_convertor.py,sha256=QhbytqGU856gEFggaamZy01hhCwjiWz8ju48iubvbeI,5074
+clarifai/runners/utils/openai_convertor.py,sha256=2emAgi9YXpxlOGRw5MG9jhyUUrdDjD9Sv3mnGtwcgts,8192
 clarifai/runners/utils/serializers.py,sha256=pI7GqMTC0T3Lu_X8v8TO4RiplO-gC_49Ns37jYwsPtg,7908
 clarifai/runners/utils/url_fetcher.py,sha256=Segkvi-ktPa3-koOpUu8DNZeWOaK6G82Ya9b7_oIKwo,1778
 clarifai/runners/utils/data_types/__init__.py,sha256=iBtmPkIoLK9ew6ZiXElGt2YBBTDLEA0fmxE_eOYzvhk,478
-clarifai/runners/utils/data_types/data_types.py,sha256=4o2sReR4kMu8B8mLkFntNbBR4tFpfp5hi7dm2MEg5Qs,17948
+clarifai/runners/utils/data_types/data_types.py,sha256=UBHTNPshr94qUs2KqkYis0VlArm23rcSG_EyO_Uetgc,19823
 clarifai/schema/search.py,sha256=o9-ct8ulLZByB3RCVwZWPgaDwdcW7cM5s-g8oyAz89s,2421
-clarifai/urls/helper.py,sha256=mnCWw2JcV67xWMS1Wf36lcEG1RwtDviYpYivpeRaNj8,5342
+clarifai/urls/helper.py,sha256=UshKiEnBAZfMyoWiM3Xx6USXEYmXRFTd4kNpuQSQQM8,7868
 clarifai/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/utils/cli.py,sha256=7lHajIsWzyEU7jfgH1nykwYG63wcHCZ3ep7a6amWZH4,5413
-clarifai/utils/config.py,sha256=-mZwJEtv31pfchavgmiaNxRgwbcUhWpxJATH2hU8kwQ,4591
-clarifai/utils/constants.py,sha256=goxDnTuI6jtDhP2pWasMGcfd4FL3k6qUs2PE67EZOeM,1882
+clarifai/utils/config.py,sha256=AguQ4UPFxNwDT8hTBrdV4grQ0t4m-pW2V9XKxBWfnNg,5177
+clarifai/utils/constants.py,sha256=RYfDVFpaW7V5ISIvY7uvu5nqTvQ2NEwFOd0dcCytyGk,2030
 clarifai/utils/logging.py,sha256=0we53uTqUvzrulC86whu-oeWNxn1JjJL0OQ98Bwf9vo,15198
 clarifai/utils/misc.py,sha256=x7JP8oxU672Z9yAav47Y1anFiL4RD8WvlKBHMVlbyZM,3137
 clarifai/utils/model_train.py,sha256=0XSAoTkSsrwf4f-W9yw2mkXZtkal7LBLJSoi86CFCn4,9250
@@ -103,9 +104,9 @@ clarifai/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 clarifai/workflows/export.py,sha256=Oq3RVNKvv1iH46U6oIjXa-MXWJ4sTlXr_NSfwoxr3H4,2149
 clarifai/workflows/utils.py,sha256=ESL3INcouNcLKCh-nMpfXX-YbtCzX7tz7hT57_RGQ3M,2079
 clarifai/workflows/validate.py,sha256=UhmukyHkfxiMFrPPeBdUTiCOHQT5-shqivlBYEyKTlU,2931
-clarifai-11.4.2.dist-info/licenses/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
-clarifai-11.4.2.dist-info/METADATA,sha256=8ezcxLu3AgPvciJRlpPHEXWoJCfmzrliSXPhTN9nwaM,22398
-clarifai-11.4.2.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-clarifai-11.4.2.dist-info/entry_points.txt,sha256=X9FZ4Z-i_r2Ud1RpZ9sNIFYuu_-9fogzCMCRUD9hyX0,51
-clarifai-11.4.2.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
-clarifai-11.4.2.dist-info/RECORD,,
+clarifai-11.4.3.dist-info/licenses/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
+clarifai-11.4.3.dist-info/METADATA,sha256=ZtwykytAB7xvh8sEZVa84cPoTAM7nX15TQowlnejPE0,22398
+clarifai-11.4.3.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+clarifai-11.4.3.dist-info/entry_points.txt,sha256=X9FZ4Z-i_r2Ud1RpZ9sNIFYuu_-9fogzCMCRUD9hyX0,51
+clarifai-11.4.3.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
+clarifai-11.4.3.dist-info/RECORD,,