clarifai 11.4.10__tar.gz → 11.5.1__tar.gz

{clarifai-11.4.10/clarifai.egg-info → clarifai-11.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clarifai
-Version: 11.4.10
+Version: 11.5.1
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
 Author-email: support@clarifai.com
@@ -19,8 +19,8 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: clarifai-grpc>=11.3.4
-Requires-Dist: clarifai-protocol>=0.0.23
+Requires-Dist: clarifai-grpc>=11.5.5
+Requires-Dist: clarifai-protocol>=0.0.24
 Requires-Dist: numpy>=1.22.0
 Requires-Dist: tqdm>=4.65.0
 Requires-Dist: PyYAML>=6.0.1
@@ -31,6 +31,8 @@ Requires-Dist: fsspec>=2024.6.1
 Requires-Dist: click>=8.1.7
 Requires-Dist: requests>=2.32.3
 Requires-Dist: aiohttp>=3.10.0
+Requires-Dist: uv==0.7.12
+Requires-Dist: ruff==0.11.4
 Provides-Extra: all
 Requires-Dist: pycocotools>=2.0.7; extra == "all"
 Dynamic: author

clarifai-11.5.1/clarifai/__init__.py

@@ -0,0 +1 @@
+__version__ = "11.5.1"

{clarifai-11.4.10 → clarifai-11.5.1}/clarifai/client/app.py

@@ -470,8 +470,8 @@ class App(Lister, BaseClient):
                 model = self.model(
                     model_id=node['model']['model_id'],
                     model_version={"id": node['model'].get('model_version_id', "")},
-                    user_id=node['model'].get('user_id', ""),
-                    app_id=node['model'].get('app_id', ""),
+                    user_id=node['model'].get('user_id', self.user_app_id.user_id),
+                    app_id=node['model'].get('app_id', self.user_app_id.app_id),
                 )
             except Exception as e:
                 if "Model does not exist" in str(e):

{clarifai-11.4.10 → clarifai-11.5.1}/clarifai/runners/__init__.py

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

{clarifai-11.4.10 → clarifai-11.5.1}/clarifai/runners/dockerfile_template/Dockerfile.template

@@ -3,9 +3,13 @@ FROM --platform=$TARGETPLATFORM ${FINAL_IMAGE} as final
 
 COPY --link requirements.txt /home/nonroot/requirements.txt
 
+ENV VIRTUAL_ENV=/venv
+ENV PATH="/home/nonroot/.local/bin:$VIRTUAL_ENV/bin:$PATH"
+
+
 # Update clarifai package so we always have latest protocol to the API. Everything should land in /venv
-RUN ["pip", "install", "--no-cache-dir", "-r", "/home/nonroot/requirements.txt"]
-RUN ["pip", "show", "clarifai"]
+RUN ["uv", "pip", "install", "--no-cache-dir", "-r", "/home/nonroot/requirements.txt"]
+RUN ["uv", "pip", "show", "--no-cache-dir", "clarifai"]
 
 # Set the NUMBA cache dir to /tmp
 # Set the TORCHINDUCTOR cache dir to /tmp

{clarifai-11.4.10 → clarifai-11.5.1}/clarifai/runners/models/dummy_openai_model.py

@@ -13,9 +13,9 @@ class MockOpenAIClient:
         def create(self, **kwargs):
             """Mock create method for compatibility."""
             if kwargs.get("stream", False):
-                return MockCompletionStream(kwargs.get("messages", []))
+                return MockCompletionStream(**kwargs)
             else:
-                return MockCompletion(kwargs.get("messages", []))
+                return MockCompletion(**kwargs)
 
     def __init__(self):
         self.chat = self  # Make self.chat point to self for compatibility
@@ -25,6 +25,19 @@ class MockOpenAIClient:
 class MockCompletion:
     """Mock completion object that mimics the OpenAI completion response structure."""
 
+    class Usage:
+        def __init__(self, prompt_tokens, completion_tokens, total_tokens):
+            self.total_tokens = total_tokens
+            self.prompt_tokens = prompt_tokens
+            self.completion_tokens = completion_tokens
+
+        def to_dict(self):
+            return dict(
+                total_tokens=self.total_tokens,
+                prompt_tokens=self.prompt_tokens,
+                completion_tokens=self.completion_tokens,
+            )
+
     class Choice:
         class Message:
             def __init__(self, content):
@@ -36,17 +49,21 @@ class MockCompletion:
             self.finish_reason = "stop"
             self.index = 0
 
-    def __init__(self, messages):
+    def __init__(self, **kwargs):
         # Generate a simple response based on the last message
+        messages = kwargs.get("messages")
         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.usage = 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"
@@ -65,9 +82,12 @@ class MockCompletion:
                 }
                 for choice in self.choices
             ],
-            "usage": self.usage,
+            "usage": self.usage.to_dict(),
         }
 
+    def model_dump(self):
+        return self.to_dict()
+
 
 class MockCompletionStream:
     """Mock completion stream that mimics the OpenAI streaming response structure."""
@@ -79,14 +99,27 @@ class MockCompletionStream:
                     self.content = content
                     self.role = "assistant" if content is None else None
 
+            class Usage:
+                def __init__(self, prompt_tokens, completion_tokens, total_tokens):
+                    self.total_tokens = total_tokens
+                    self.prompt_tokens = prompt_tokens
+                    self.completion_tokens = completion_tokens
+
+                def to_dict(self):
+                    return dict(
+                        total_tokens=self.total_tokens,
+                        prompt_tokens=self.prompt_tokens,
+                        completion_tokens=self.completion_tokens,
+                    )
+
             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}
+                    self.Usage(**{"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15})
                     if include_usage
-                    else None
+                    else self.Usage(None, None, None)
                 )
 
         def __init__(self, content=None, include_usage=False):
@@ -114,11 +147,16 @@ class MockCompletionStream:
                 ],
             }
             if self.usage:
-                result["usage"] = self.usage
+                result["usage"] = self.usage.to_dict()
             return result
 
-    def __init__(self, messages):
+        def model_dump(self):
+            return self.to_dict()
+
+    def __init__(self, **kwargs):
         # Generate a simple response based on the last message
+        messages = kwargs.get("messages")
+
         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
@@ -127,7 +165,7 @@ class MockCompletionStream:
             "",  # Final chunk is empty to indicate completion
         ]
         self.current_chunk = 0
-        self.include_usage = False
+        self.include_usage = kwargs.get("stream_options", {}).get("include_usage")
 
     def __iter__(self):
         return self
@@ -150,18 +188,14 @@ class DummyOpenAIModel(OpenAIModelClass):
     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()
+        return self.client.chat.completions.create(**completion_args).model_dump()
 
     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
-        )
+        completion_stream = self.client.chat.completions.create(**kwargs)
 
         for chunk in completion_stream:
-            yield chunk.to_dict()
+            yield chunk.model_dump()
 
     # Override the method directly for testing
     @OpenAIModelClass.method
@@ -169,14 +203,13 @@ class DummyOpenAIModel(OpenAIModelClass):
         """Direct implementation for testing purposes."""
         try:
             request_data = json.loads(req)
-            params = self._extract_request_params(request_data)
-
+            request_data = self._create_completion_args(request_data)
             # Validate messages
-            if not params.get("messages"):
+            if not request_data.get("messages"):
                 yield "Error: No messages provided"
                 return
 
-            for message in params["messages"]:
+            for message in request_data["messages"]:
                 if (
                     not isinstance(message, dict)
                     or "role" not in message
@@ -185,7 +218,7 @@ class DummyOpenAIModel(OpenAIModelClass):
                     yield "Error: Invalid message format"
                     return
 
-            for chunk in self._process_streaming_request(**params):
+            for chunk in self._process_streaming_request(**request_data):
                 yield json.dumps(chunk)
         except Exception as e:
             yield f"Error: {str(e)}"

{clarifai-11.4.10 → clarifai-11.5.1}/clarifai/runners/models/mcp_class.py

@@ -2,14 +2,13 @@
 
 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 typing import TYPE_CHECKING, Any
 
 from clarifai.runners.models.model_class import ModelClass
 
+if TYPE_CHECKING:
+    from fastmcp import FastMCP
+
 
 class MCPModelClass(ModelClass):
     """Base class for wrapping FastMCP servers as a model running in Clarfai. This handles
@@ -19,10 +18,17 @@ class MCPModelClass(ModelClass):
     """
 
     def load_model(self):
+        try:
+            from fastmcp import Client
+        except ImportError:
+            raise ImportError(
+                "fastmcp package is required to use MCP functionality. "
+                "Install it with: pip install fastmcp"
+            )
         # 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:
+    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")
 
@@ -32,6 +38,8 @@ class MCPModelClass(ModelClass):
         return it's response.
 
         """
+        from mcp import types
+        from mcp.shared.exceptions import McpError
 
         async def send_notification(client_message: types.ClientNotification) -> None:
             async with self.client: