clarifai 11.4.9__py3-none-any.whl → 11.5.0__py3-none-any.whl

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "11.4.9"
+__version__ = "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/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/runners/models/openai_class.py

@@ -20,6 +20,15 @@ class OpenAIModelClass(ModelClass):
             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
@@ -35,141 +44,100 @@ class OpenAIModelClass(ModelClass):
                     "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]:
+    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
-            stream: Whether this is a streaming request
 
         Returns:
             Dict containing the completion arguments
         """
-        completion_args = {
-            "model": self.model,
-            "messages": params["messages"],
-            "temperature": params["temperature"],
-        }
-
+        completion_args = {**params}
+        completion_args.update({"model": self.model})
+        stream = completion_args.pop("stream", False)
         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]
+            # 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 _format_error_response(self, error: Exception) -> str:
-        """Format an error response in OpenAI-compatible format.
+    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,
+        }
 
-        Args:
-            error: The exception that occurred
+        handler = handlers.get(endpoint)
+        if not handler:
+            raise ValueError(f"Unsupported endpoint: {endpoint}")
 
-        Returns:
-            JSON string containing the error response
-        """
-        error_response = {
-            "error": {
-                "message": str(error),
-                "type": "InvalidRequestError",
-                "code": "invalid_request_error",
-            }
-        }
-        return json.dumps(error_response)
+        return handler(request_data)
 
     @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.
+        """Process an OpenAI-compatible request and send it to the appropriate OpenAI endpoint.
 
         Args:
-            msg: JSON string containing the request parameters
+            msg: JSON string containing the request parameters including 'openai_endpoint'
 
         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)
-
+            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 self._format_error_response(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.
+        without converting to a list or JSON serializing. Supports chat completions and responses endpoints.
 
         Args:
             msg: The request as a JSON string.
@@ -179,43 +147,21 @@ class OpenAIModelClass(ModelClass):
         """
         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)
+            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())
 
-        for chunk in completion_stream:
-            yield chunk.to_dict()
+        except Exception as e:
+            yield f"Error: {e}"

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/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/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.dist-info → clarifai-11.5.0.dist-info}/METADATA

@@ -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.dist-info → clarifai-11.5.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-clarifai/__init__.py,sha256=SIhopzpvdgMSl3sPaYcNcFup4S7F1oJ6rqaOtCSjmJ4,23
+clarifai/__init__.py,sha256=89g_4HXr4XouZfNDdwEbm-Xwu06Vvu-EUBmo-baEVQQ,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
@@ -68,20 +68,20 @@ clarifai/runners/__init__.py,sha256=CQhpUOj_x-oV9xEUKdL-hi3A1BQAtPUv-FFOev4a96w,
 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/dummy_openai_model.py,sha256=5oa7r8j1GpymenpmMfaAV9Vt6VObKvrT9tDXgFmP4qY,7208
+clarifai/runners/models/dummy_openai_model.py,sha256=pcmAVbqTTGG4J3BLVjKfvM_SQ-GET_XexIUdLcr9Zvo,8373
 clarifai/runners/models/mcp_class.py,sha256=7uwCMade0LMMBq7vczhPf4Kxdmh8Rj0R7Pg3pPxYdjQ,6386
-clarifai/runners/models/model_builder.py,sha256=mPkIvHojNmIv4uGvUgmY1vJ3Y_ibRxUqWdF5BTaB2hA,49156
+clarifai/runners/models/model_builder.py,sha256=PiqPyTGPSKsYvOQNpBzs4e1_wuEbtE-P3yEkLE4Py10,49231
 clarifai/runners/models/model_class.py,sha256=-euUF-eHUi4KXR_e1pIwvToDZ13CM6TSz2FolzildjM,16069
 clarifai/runners/models/model_run_locally.py,sha256=6-6WjEKc0ba3gAv4wOLdMs2XOzS3b-2bZHJS0wdVqJY,20088
 clarifai/runners/models/model_runner.py,sha256=SccX-RxTgruSpQaM21uMSl-z1x6fOa13fQZMQW8NNRY,7297
 clarifai/runners/models/model_servicer.py,sha256=rRd_fNEXwqiBSzTUtPI2r07EBdcCPd8tcSPHeqTe0_I,3445
-clarifai/runners/models/openai_class.py,sha256=3u6K7vTdYybxdTT3t3pYh9wvQyWhkL595t7hR5IkljU,8159
-clarifai/runners/models/visual_classifier_class.py,sha256=f9ZP8KFamMUdMpUG3AlL9nVCdcggy_E5n9RJY3ixR1U,2739
+clarifai/runners/models/openai_class.py,sha256=aXlk5W6LWkh-A4eZYi74DeLW0i_86_9DYYGxpJHXI0w,6688
+clarifai/runners/models/visual_classifier_class.py,sha256=1ZoLfCT2crrgRbejjTMAIwpTRgQMiH9N9yflOVpFxSg,2721
 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=fiuwsY-uxmMzQXBv1V8Gpw0n6s_xzrigAk4J5htOAao,12646
+clarifai/runners/utils/code_script.py,sha256=Ae1u2686ycxDGdYXnPzVvDxhc5i-JZ_A4GDpq0xHvjo,12772
 clarifai/runners/utils/const.py,sha256=Q4Ps6gIEJCyTdQCfmT6PaS61WHmhT25XigV1NugWz-E,1544
-clarifai/runners/utils/data_utils.py,sha256=4M4n-cGprBEBV5UkgOWaUlVfZ3WBTmegdffGQ3SfYCU,20750
+clarifai/runners/utils/data_utils.py,sha256=HRpMYR2O0OiDpXXhOManLHTeomC4bFnXMHVAiT_12yE,20856
 clarifai/runners/utils/loader.py,sha256=K5Y8MPbIe5STw2gDnrL8KqFgKNxEo7bz-RV0ip1T4PM,10900
 clarifai/runners/utils/method_signatures.py,sha256=qdHaO8ZIgP6BBXXMhMPhcQ46dse-XMP2t4VJCNG7O3Q,18335
 clarifai/runners/utils/openai_convertor.py,sha256=ZlIrvvfHttD_DavLvmKZdL8gNq_TQvQtZVnYamwdWz4,8248
@@ -107,9 +107,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.9.dist-info/licenses/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
-clarifai-11.4.9.dist-info/METADATA,sha256=ik-jR4kso026x30ICc47SoptmYdxq1Ut5lsUifmp55o,22682
-clarifai-11.4.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-clarifai-11.4.9.dist-info/entry_points.txt,sha256=X9FZ4Z-i_r2Ud1RpZ9sNIFYuu_-9fogzCMCRUD9hyX0,51
-clarifai-11.4.9.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
-clarifai-11.4.9.dist-info/RECORD,,
+clarifai-11.5.0.dist-info/licenses/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
+clarifai-11.5.0.dist-info/METADATA,sha256=nHyy0pNlitK61Ym0VVAxz-Ev7UEtqpjyKrpbHwc2jmQ,22682
+clarifai-11.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+clarifai-11.5.0.dist-info/entry_points.txt,sha256=X9FZ4Z-i_r2Ud1RpZ9sNIFYuu_-9fogzCMCRUD9hyX0,51
+clarifai-11.5.0.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
+clarifai-11.5.0.dist-info/RECORD,,