clarifai 11.4.9__tar.gz → 11.5.0__tar.gz

{clarifai-11.4.9/clarifai.egg-info → clarifai-11.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clarifai
-Version: 11.4.9
+Version: 11.5.0
 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

clarifai-11.5.0/clarifai/__init__.py

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

{clarifai-11.4.9 → clarifai-11.5.0}/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.9 → clarifai-11.5.0}/clarifai/runners/models/model_builder.py

@@ -839,6 +839,7 @@ class ModelBuilder:
     def get_model_version_proto(self):
         signatures = self.get_method_signatures()
         model_version_proto = resources_pb2.ModelVersion(
+            pretrained_model_config=resources_pb2.PretrainedModelConfig(),
             inference_compute_info=self.inference_compute_info,
             method_signatures=signatures,
         )

clarifai-11.5.0/clarifai/runners/models/openai_class.py

@@ -0,0 +1,167 @@
+"""Base class for creating OpenAI-compatible API server."""
+
+import json
+from typing import Any, Dict, Iterator
+
+from clarifai.runners.models.model_class import ModelClass
+
+
+class OpenAIModelClass(ModelClass):
+    """Base class for wrapping OpenAI-compatible servers as a model running in Clarifai.
+    This handles all the transport between the API and the OpenAI-compatible server.
+
+    To use this class, create a subclass and set the following class attributes:
+    - client: The OpenAI-compatible client instance
+    - model: The name of the model to use with the client
+
+    Example:
+        class MyOpenAIModel(OpenAIModelClass):
+            client = OpenAI(api_key="your-key")
+            model = "gpt-4"
+    """
+
+    # API Endpoints
+    ENDPOINT_CHAT_COMPLETIONS = "/chat/completions"
+    ENDPOINT_IMAGES_GENERATE = "/images/generations"
+    ENDPOINT_EMBEDDINGS = "/embeddings"
+    ENDPOINT_RESPONSES = "/responses"
+
+    # Default endpoint
+    DEFAULT_ENDPOINT = ENDPOINT_CHAT_COMPLETIONS
+
+    # These should be overridden in subclasses
+    client = None
+    model = None
+
+    def __init__(self) -> None:
+        if self.client is None:
+            raise NotImplementedError("Subclasses must set the 'client' class attribute")
+        if self.model is None:
+            try:
+                self.model = self.client.models.list().data[0].id
+            except Exception as e:
+                raise NotImplementedError(
+                    "Subclasses must set the 'model' class attribute or ensure the client can list models"
+                ) from e
+
+    def _create_completion_args(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Create the completion arguments dictionary from parameters.
+
+        Args:
+            params: Dictionary of parameters extracted from request
+
+        Returns:
+            Dict containing the completion arguments
+        """
+        completion_args = {**params}
+        completion_args.update({"model": self.model})
+        stream = completion_args.pop("stream", False)
+        if stream:
+            # Force to use usage
+            stream_options = params.pop("stream_options", {})
+            stream_options.update({"include_usage": True})
+            completion_args["stream_options"] = stream_options
+        completion_args["stream"] = stream
+
+        return completion_args
+
+    def _set_usage(self, resp):
+        if resp.usage and resp.usage.prompt_tokens and resp.usage.completion_tokens:
+            self.set_output_context(
+                prompt_tokens=resp.usage.prompt_tokens,
+                completion_tokens=resp.usage.completion_tokens,
+            )
+
+    def _handle_chat_completions(self, request_data: Dict[str, Any]):
+        """Handle chat completion requests."""
+        completion_args = self._create_completion_args(request_data)
+        completion = self.client.chat.completions.create(**completion_args)
+        self._set_usage(completion)
+        return completion
+
+    def _handle_images_generate(self, request_data: Dict[str, Any]):
+        """Handle image generation requests."""
+        image_args = {**request_data}
+        image_args.update({"model": self.model})
+        response = self.client.images.generate(**image_args)
+        return response
+
+    def _handle_embeddings(self, request_data: Dict[str, Any]):
+        """Handle embedding requests."""
+        embedding_args = {**request_data}
+        embedding_args.update({"model": self.model})
+        response = self.client.embeddings.create(**embedding_args)
+        return response
+
+    def _handle_responses(self, request_data: Dict[str, Any]):
+        """Handle response requests."""
+        response_args = {**request_data}
+        response_args.update({"model": self.model})
+        response = self.client.responses.create(**response_args)
+        return response
+
+    def _route_request(self, endpoint: str, request_data: Dict[str, Any]):
+        """Route the request to appropriate handler based on endpoint."""
+        handlers = {
+            self.ENDPOINT_CHAT_COMPLETIONS: self._handle_chat_completions,
+            self.ENDPOINT_IMAGES_GENERATE: self._handle_images_generate,
+            self.ENDPOINT_EMBEDDINGS: self._handle_embeddings,
+            self.ENDPOINT_RESPONSES: self._handle_responses,
+        }
+
+        handler = handlers.get(endpoint)
+        if not handler:
+            raise ValueError(f"Unsupported endpoint: {endpoint}")
+
+        return handler(request_data)
+
+    @ModelClass.method
+    def openai_transport(self, msg: str) -> str:
+        """Process an OpenAI-compatible request and send it to the appropriate OpenAI endpoint.
+
+        Args:
+            msg: JSON string containing the request parameters including 'openai_endpoint'
+
+        Returns:
+            JSON string containing the response or error
+        """
+        try:
+            request_data = json.loads(msg)
+            endpoint = request_data.pop("openai_endpoint", self.DEFAULT_ENDPOINT)
+            response = self._route_request(endpoint, request_data)
+            return json.dumps(response.model_dump())
+        except Exception as e:
+            return f"Error: {e}"
+
+    @ModelClass.method
+    def openai_stream_transport(self, msg: str) -> Iterator[str]:
+        """Process an OpenAI-compatible request and return a streaming response iterator.
+        This method is used when stream=True and returns an iterator of strings directly,
+        without converting to a list or JSON serializing. Supports chat completions and responses endpoints.
+
+        Args:
+            msg: The request as a JSON string.
+
+        Returns:
+            Iterator[str]: An iterator yielding text chunks from the streaming response.
+        """
+        try:
+            request_data = json.loads(msg)
+            endpoint = request_data.pop("openai_endpoint", self.DEFAULT_ENDPOINT)
+            if endpoint not in [self.ENDPOINT_CHAT_COMPLETIONS, self.ENDPOINT_RESPONSES]:
+                raise ValueError("Streaming is only supported for chat completions and responses.")
+
+            if endpoint == self.ENDPOINT_RESPONSES:
+                # Handle responses endpoint
+                stream_response = self._route_request(endpoint, request_data)
+                for chunk in stream_response:
+                    yield json.dumps(chunk.model_dump())
+            else:
+                completion_args = self._create_completion_args(request_data)
+                stream_completion = self.client.chat.completions.create(**completion_args)
+                for chunk in stream_completion:
+                    self._set_usage(chunk)
+                    yield json.dumps(chunk.model_dump())
+
+        except Exception as e:
+            yield f"Error: {e}"

{clarifai-11.4.9 → clarifai-11.5.0}/clarifai/runners/models/visual_classifier_class.py

@@ -52,7 +52,7 @@ class VisualClassifierClass(ModelClass):
 
     @staticmethod
     def process_concepts(
-        logits: torch.Tensor, threshold: float, model_labels: Dict[int, str]
+        logits: torch.Tensor, model_labels: Dict[int, str]
     ) -> List[List[Concept]]:
         """Convert model logits into a structured format of concepts.
 

{clarifai-11.4.9 → clarifai-11.5.0}/clarifai/runners/utils/code_script.py

@@ -111,7 +111,7 @@ 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({model_ui_url},
+model = Model("{model_ui_url}",
                deployment_id = {deployment_id}, # Only needed for dedicated deployed models
                {base_url_str}
  )
@@ -133,6 +133,8 @@ model = Model({model_ui_url},
                 continue
             if default_value is None and required:
                 default_value = _set_default_value(param_type)
+            if param_type == "str" and default_value is not None:
+                default_value = json.dumps(default_value)
             client_script_str += f"{param_name}={default_value}, "
         client_script_str = client_script_str.rstrip(", ") + ")"
         if method_signature.method_type == resources_pb2.RunnerMethodType.UNARY_UNARY:

{clarifai-11.4.9 → clarifai-11.5.0}/clarifai/runners/utils/data_utils.py

@@ -377,8 +377,14 @@ class Param(MessageData):
 
             if proto is None:
                 proto = ParamProto()
-            proto.default = json.dumps(default)
+
+            if isinstance(default, str):
+                proto.default = default
+            else:
+                proto.default = json.dumps(default)
+
             return proto
+
         except Exception:
             if default is not None:
                 proto.default = str(default)

{clarifai-11.4.9 → clarifai-11.5.0/clarifai.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clarifai
-Version: 11.4.9
+Version: 11.5.0
 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

{clarifai-11.4.9 → clarifai-11.5.0}/clarifai.egg-info/requires.txt

@@ -1,5 +1,5 @@
-clarifai-grpc>=11.3.4
-clarifai-protocol>=0.0.23
+clarifai-grpc>=11.5.5
+clarifai-protocol>=0.0.24
 numpy>=1.22.0
 tqdm>=4.65.0
 PyYAML>=6.0.1

{clarifai-11.4.9 → clarifai-11.5.0}/requirements.txt

@@ -1,5 +1,5 @@
-clarifai-grpc>=11.3.4
-clarifai-protocol>=0.0.23
+clarifai-grpc>=11.5.5
+clarifai-protocol>=0.0.24
 numpy>=1.22.0
 tqdm>=4.65.0
 PyYAML>=6.0.1

clarifai-11.4.9/clarifai/__init__.py

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

clarifai-11.4.9/clarifai/runners/models/openai_class.py

@@ -1,221 +0,0 @@
-"""Base class for creating OpenAI-compatible API server."""
-
-import json
-from typing import Any, Dict, Iterator
-
-from clarifai.runners.models.model_class import ModelClass
-
-
-class OpenAIModelClass(ModelClass):
-    """Base class for wrapping OpenAI-compatible servers as a model running in Clarifai.
-    This handles all the transport between the API and the OpenAI-compatible server.
-
-    To use this class, create a subclass and set the following class attributes:
-    - client: The OpenAI-compatible client instance
-    - model: The name of the model to use with the client
-
-    Example:
-        class MyOpenAIModel(OpenAIModelClass):
-            client = OpenAI(api_key="your-key")
-            model = "gpt-4"
-    """
-
-    # These should be overridden in subclasses
-    client = None
-    model = None
-
-    def __init__(self) -> None:
-        if self.client is None:
-            raise NotImplementedError("Subclasses must set the 'client' class attribute")
-        if self.model is None:
-            try:
-                self.model = self.client.models.list().data[0].id
-            except Exception as e:
-                raise NotImplementedError(
-                    "Subclasses must set the 'model' class attribute or ensure the client can list models"
-                ) from e
-
-    def _extract_request_params(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
-        """Extract and validate common openai arguments parameters from the request data.
-
-        Args:
-            request_data: The parsed JSON request data
-
-        Returns:
-            Dict containing the extracted parameters
-        """
-        return {
-            "messages": request_data.get("messages", []),
-            "temperature": request_data.get("temperature", 1.0),
-            "max_tokens": request_data.get("max_tokens"),
-            "max_completion_tokens": request_data.get("max_completion_tokens"),
-            "n": request_data.get("n", 1),
-            "frequency_penalty": request_data.get("frequency_penalty"),
-            "presence_penalty": request_data.get("presence_penalty"),
-            "top_p": request_data.get("top_p", 1.0),
-            "reasoning_effort": request_data.get("reasoning_effort"),
-            "response_format": request_data.get("response_format"),
-            "stop": request_data.get("stop"),
-            "tools": request_data.get("tools"),
-            "tool_choice": request_data.get("tool_choice"),
-            "tool_resources": request_data.get("tool_resources"),
-            "modalities": request_data.get("modalities"),
-            "stream_options": request_data.get("stream_options", {"include_usage": True}),
-        }
-
-    def _create_completion_args(
-        self, params: Dict[str, Any], stream: bool = False
-    ) -> Dict[str, Any]:
-        """Create the completion arguments dictionary from parameters.
-
-        Args:
-            params: Dictionary of parameters extracted from request
-            stream: Whether this is a streaming request
-
-        Returns:
-            Dict containing the completion arguments
-        """
-        completion_args = {
-            "model": self.model,
-            "messages": params["messages"],
-            "temperature": params["temperature"],
-        }
-
-        if stream:
-            completion_args["stream"] = True
-            if params.get("stream_options"):
-                completion_args["stream_options"] = params["stream_options"]
-
-        # Add optional parameters if they exist
-        optional_params = [
-            "max_tokens",
-            "max_completion_tokens",
-            "n",
-            "frequency_penalty",
-            "presence_penalty",
-            "top_p",
-            "reasoning_effort",
-            "response_format",
-            "stop",
-            "tools",
-            "tool_choice",
-            "tool_resources",
-            "modalities",
-        ]
-
-        for param in optional_params:
-            if params.get(param) is not None:
-                completion_args[param] = params[param]
-
-        return completion_args
-
-    def _format_error_response(self, error: Exception) -> str:
-        """Format an error response in OpenAI-compatible format.
-
-        Args:
-            error: The exception that occurred
-
-        Returns:
-            JSON string containing the error response
-        """
-        error_response = {
-            "error": {
-                "message": str(error),
-                "type": "InvalidRequestError",
-                "code": "invalid_request_error",
-            }
-        }
-        return json.dumps(error_response)
-
-    @ModelClass.method
-    def openai_transport(self, msg: str) -> str:
-        """The single model method to get the OpenAI-compatible request and send it to the OpenAI server
-        then return its response.
-
-        Args:
-            msg: JSON string containing the request parameters
-
-        Returns:
-            JSON string containing the response or error
-        """
-        try:
-            request_data = json.loads(msg)
-            params = self._extract_request_params(request_data)
-            stream = request_data.get("stream", False)
-
-            if stream:
-                chunks = self._process_streaming_request(**params)
-                response_list = []
-                for chunk in chunks:
-                    response_list.append(chunk)
-                return json.dumps(response_list)
-            else:
-                completion = self._process_request(**params)
-                if completion.get('usage'):
-                    if completion['usage'].get('prompt_tokens') and completion['usage'].get(
-                        'completion_tokens'
-                    ):
-                        self.set_output_context(
-                            prompt_tokens=completion['usage']['prompt_tokens'],
-                            completion_tokens=completion['usage']['completion_tokens'],
-                        )
-
-                return json.dumps(completion)
-
-        except Exception as e:
-            return self._format_error_response(e)
-
-    @ModelClass.method
-    def openai_stream_transport(self, msg: str) -> Iterator[str]:
-        """Process an OpenAI-compatible request and return a streaming response iterator.
-        This method is used when stream=True and returns an iterator of strings directly,
-        without converting to a list or JSON serializing.
-
-        Args:
-            msg: The request as a JSON string.
-
-        Returns:
-            Iterator[str]: An iterator yielding text chunks from the streaming response.
-        """
-        try:
-            request_data = json.loads(msg)
-            params = self._extract_request_params(request_data)
-            for chunk in self._process_streaming_request(**params):
-                if chunk.get('usage'):
-                    if chunk['usage'].get('prompt_tokens') and chunk['usage'].get(
-                        'completion_tokens'
-                    ):
-                        self.set_output_context(
-                            prompt_tokens=chunk['usage']['prompt_tokens'],
-                            completion_tokens=chunk['usage']['completion_tokens'],
-                        )
-                yield json.dumps(chunk)
-        except Exception as e:
-            yield f"Error: {str(e)}"
-
-    def _process_request(self, **kwargs) -> Any:
-        """Process a standard (non-streaming) request using the OpenAI client.
-
-        Args:
-            **kwargs: Request parameters
-
-        Returns:
-            The completion response from the OpenAI client
-        """
-        completion_args = self._create_completion_args(kwargs)
-        return self.client.chat.completions.create(**completion_args).to_dict()
-
-    def _process_streaming_request(self, **kwargs) -> Iterator[str]:
-        """Process a streaming request using the OpenAI client.
-
-        Args:
-            **kwargs: Request parameters
-
-        Returns:
-            Iterator yielding response chunks
-        """
-        completion_args = self._create_completion_args(kwargs, stream=True)
-        completion_stream = self.client.chat.completions.create(**completion_args)
-
-        for chunk in completion_stream:
-            yield chunk.to_dict()