clarifai 11.4.3rc1__py3-none-any.whl → 11.4.5__py3-none-any.whl

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "11.4.3rc1"
+__version__ = "11.4.5"

clarifai/cli/base.py

@@ -144,9 +144,8 @@ def dump(ctx_obj, output_format):
 
 
 @config.command(['cat'])
-@click.option('-o', '--output-format', default='yaml', type=click.Choice(['yaml', 'json']))
 @click.pass_obj
-def env(ctx_obj, output_format):
+def env(ctx_obj):
     """Print env vars. Use: eval "$(clarifai config env)" """
     ctx_obj.current.print_env_vars()
 

clarifai/cli/model.py

@@ -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
 
@@ -196,7 +196,7 @@ class ModelClient:
             f.__name__ = method_name
             f.__qualname__ = f'{self.__class__.__name__}.{method_name}'
             input_annotations = code_script._get_annotations_source(method_signature)
-            return_annotation = input_annotations.pop('return', (None, None))[0]
+            return_annotation = input_annotations.pop('return', (None, None, None))[0]
             sig = inspect.signature(f).replace(
                 parameters=[
                     inspect.Parameter(k, inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=v[0])

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/__init__.py

@@ -1,9 +1,11 @@
 from .models.model_builder import ModelBuilder
 from .models.model_class import ModelClass
 from .models.model_runner import ModelRunner
+from .models.openai_class import OpenAIModelClass
 
 __all__ = [
     "ModelRunner",
     "ModelBuilder",
     "ModelClass",
+    "OpenAIModelClass",
 ]

clarifai/runners/models/dummy_openai_model.py

@@ -0,0 +1,197 @@
+"""Dummy OpenAI model implementation for testing."""
+
+import json
+from typing import Any, Dict, Iterator
+
+from clarifai.runners.models.openai_class import OpenAIModelClass
+
+
+class MockOpenAIClient:
+    """Mock OpenAI client for testing."""
+
+    class Completions:
+        def create(self, **kwargs):
+            """Mock create method for compatibility."""
+            if kwargs.get("stream", False):
+                return MockCompletionStream(kwargs.get("messages", []))
+            else:
+                return MockCompletion(kwargs.get("messages", []))
+
+    def __init__(self):
+        self.chat = self  # Make self.chat point to self for compatibility
+        self.completions = self.Completions()  # For compatibility with some clients
+
+
+class MockCompletion:
+    """Mock completion object that mimics the OpenAI completion response structure."""
+
+    class Choice:
+        class Message:
+            def __init__(self, content):
+                self.content = content
+                self.role = "assistant"
+
+        def __init__(self, content):
+            self.message = self.Message(content)
+            self.finish_reason = "stop"
+            self.index = 0
+
+    def __init__(self, messages):
+        # Generate a simple response based on the last message
+        last_message = messages[-1] if messages else {"content": ""}
+        response_text = f"Echo: {last_message.get('content', '')}"
+
+        self.choices = [self.Choice(response_text)]
+        self.usage = {
+            "prompt_tokens": len(str(messages)),
+            "completion_tokens": len(response_text),
+            "total_tokens": len(str(messages)) + len(response_text),
+        }
+        self.id = "dummy-completion-id"
+        self.created = 1234567890
+        self.model = "dummy-model"
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert the completion object to a dictionary."""
+        return {
+            "id": self.id,
+            "created": self.created,
+            "model": self.model,
+            "choices": [
+                {
+                    "message": {"role": choice.message.role, "content": choice.message.content},
+                    "finish_reason": choice.finish_reason,
+                    "index": choice.index,
+                }
+                for choice in self.choices
+            ],
+            "usage": self.usage,
+        }
+
+
+class MockCompletionStream:
+    """Mock completion stream that mimics the OpenAI streaming response structure."""
+
+    class Chunk:
+        class Choice:
+            class Delta:
+                def __init__(self, content=None):
+                    self.content = content
+                    self.role = "assistant" if content is None else None
+
+            def __init__(self, content=None, include_usage=False):
+                self.delta = self.Delta(content)
+                self.finish_reason = None if content else "stop"
+                self.index = 0
+                self.usage = (
+                    {"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15}
+                    if include_usage
+                    else None
+                )
+
+        def __init__(self, content=None, include_usage=False):
+            self.choices = [self.Choice(content, include_usage)]
+            self.id = "dummy-chunk-id"
+            self.created = 1234567890
+            self.model = "dummy-model"
+            self.usage = self.choices[0].usage
+
+        def to_dict(self) -> Dict[str, Any]:
+            """Convert the chunk to a dictionary."""
+            result = {
+                "id": self.id,
+                "created": self.created,
+                "model": self.model,
+                "choices": [
+                    {
+                        "delta": {"role": choice.delta.role, "content": choice.delta.content}
+                        if choice.delta.content is not None
+                        else {"role": choice.delta.role},
+                        "finish_reason": choice.finish_reason,
+                        "index": choice.index,
+                    }
+                    for choice in self.choices
+                ],
+            }
+            if self.usage:
+                result["usage"] = self.usage
+            return result
+
+    def __init__(self, messages):
+        # Generate a simple response based on the last message
+        last_message = messages[-1] if messages else {"content": ""}
+        self.response_text = f"Echo: {last_message.get('content', '')}"
+        # Create chunks that ensure the full text is included in the first chunk
+        self.chunks = [
+            self.response_text,  # First chunk contains the full text
+            "",  # Final chunk is empty to indicate completion
+        ]
+        self.current_chunk = 0
+        self.include_usage = False
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self.current_chunk < len(self.chunks):
+            chunk = self.Chunk(self.chunks[self.current_chunk], self.include_usage)
+            self.current_chunk += 1
+            return chunk
+        else:
+            raise StopIteration
+
+
+class DummyOpenAIModel(OpenAIModelClass):
+    """Dummy OpenAI model implementation for testing."""
+
+    openai_client = MockOpenAIClient()
+    model_name = "dummy-model"
+
+    def _process_request(self, **kwargs) -> Dict[str, Any]:
+        """Process a request for non-streaming responses."""
+        completion_args = self._create_completion_args(kwargs)
+        return self.client.chat.completions.create(**completion_args).to_dict()
+
+    def _process_streaming_request(self, **kwargs) -> Iterator[Dict[str, Any]]:
+        """Process a request for streaming responses."""
+        completion_args = self._create_completion_args(kwargs, stream=True)
+        completion_stream = self.client.chat.completions.create(**completion_args)
+        completion_stream.include_usage = kwargs.get('stream_options', {}).get(
+            'include_usage', False
+        )
+
+        for chunk in completion_stream:
+            yield chunk.to_dict()
+
+    # Override the method directly for testing
+    @OpenAIModelClass.method
+    def openai_stream_transport(self, req: str) -> Iterator[str]:
+        """Direct implementation for testing purposes."""
+        try:
+            request_data = json.loads(req)
+            params = self._extract_request_params(request_data)
+
+            # Validate messages
+            if not params.get("messages"):
+                yield "Error: No messages provided"
+                return
+
+            for message in params["messages"]:
+                if (
+                    not isinstance(message, dict)
+                    or "role" not in message
+                    or "content" not in message
+                ):
+                    yield "Error: Invalid message format"
+                    return
+
+            for chunk in self._process_streaming_request(**params):
+                yield json.dumps(chunk)
+        except Exception as e:
+            yield f"Error: {str(e)}"
+
+    # Additional example method that could be added for specific model implementations
+    @OpenAIModelClass.method
+    def test_method(self, prompt: str) -> str:
+        """Test method that simply echoes the input."""
+        return f"Test: {prompt}"

clarifai/runners/models/mcp_class.py

@@ -10,32 +10,6 @@ from mcp.shared.exceptions import McpError
 
 from clarifai.runners.models.model_class import ModelClass
 
-# class MCPServerProvider(abc.ABC):
-#     """
-#     Base class for creating Model Context Protocol (MCP) servers.
-
-#     This class provides a base implementation of the MCP server, including
-#     methods for handling requests and responses, as well as error handling and
-#     logging.
-
-#     Attributes:
-#     _server: The FastMCP server instance.
-#     _tools: List of tools available in the server.
-#     _resources: List of resources available in the server.
-#     _prompts: List of prompts available in the server.
-
-#     Methods:
-#     get_server(): Returns the FastMCP server instance.
-#     mcp_transport(msg): Handles incoming messages and sends them to the FastMCP server.
-#     """
-
-#     @abc.abstractmethod
-#     def get_server(self) -> FastMCP:
-#         """Required method for each subclass to implement to return the FastMCP server to use."""
-#         if self._server is None:
-#             raise ValueError("Server not initialized")
-#         return self._server
-
 
 class MCPModelClass(ModelClass):
     """Base class for wrapping FastMCP servers as a model running in Clarfai. This handles
@@ -82,8 +56,6 @@ class MCPModelClass(ModelClass):
                 )
 
                 result_type = None
-                print("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")
-                print(types.PingRequest)
                 if isinstance(client_message.root, types.PingRequest):
                     result_type = types.EmptyResult
                 elif isinstance(client_message.root, types.InitializeRequest):
@@ -125,19 +97,27 @@ class MCPModelClass(ModelClass):
         # 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', None).startswith("notifications/"):
-            # rpc_message2 = types.JSONRPCRequest.model_validate(rpc_message)
-            # underlying: types.JSONRPCRequest = rpc_message.root
+        if not d.get('method', '').startswith("notifications/"):
             client_message = types.ClientRequest.model_validate(d)
-            response = asyncio.run(
-                send_request(client_message, id=d.get('id', ""))
-            )  # underlying.id))
+            # Note(zeiler): this response is the "result" field of the JSONRPCResponse.
+            # the API will fill in the "id" and "jsonrpc" fields.
+            response = asyncio.run(send_request(client_message, id=id))
+            if response is None:
+                response = types.JSONRPCError(
+                    jsonrpc="2.0",
+                    id=id,
+                    error=types.ErrorData(
+                        code=types.INTERNAL_ERROR, message="Got empty response from MCP server."
+                    ),
+                )
+            # return as a serialized json string
+            res = response.model_dump_json(by_alias=True, exclude_none=True)
+            return res
         else:  # JSONRPCRequest
             client_message = types.ClientNotification.model_validate(d)
-            response = asyncio.run(send_notification(client_message))
-        if response is None:
-            return ""
-        # return as a serialized json string
-        return response.model_dump_json(by_alias=True, exclude_none=True)
+            # send_notification returns None always so nothing to return.
+            asyncio.run(send_notification(client_message))
+            return "{}"