clarifai 11.4.4__py3-none-any.whl → 11.4.6__py3-none-any.whl

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "11.4.4"
+__version__ = "11.4.6"

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."""
+
+    client = MockOpenAIClient()
+    model = "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

@@ -102,13 +102,22 @@ class MCPModelClass(ModelClass):
         # If we have an id it's a JSONRPCRequest
         if not d.get('method', '').startswith("notifications/"):
             client_message = types.ClientRequest.model_validate(d)
+            # 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:
-            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)
+            # send_notification returns None always so nothing to return.
+            asyncio.run(send_notification(client_message))
+            return "{}"

clarifai/runners/models/model_class.py

@@ -6,6 +6,7 @@ import traceback
 from abc import ABC
 from collections import abc
 from typing import Any, Dict, Iterator, List
+from unittest.mock import MagicMock
 
 from clarifai_grpc.grpc.api import resources_pb2, service_pb2
 from clarifai_grpc.grpc.api.status import status_code_pb2, status_pb2
@@ -346,6 +347,13 @@ class ModelClass(ABC):
         methods = {}
         for base in reversed(cls.__mro__):
             for name, method in base.__dict__.items():
+                # Skip class attributes, mocked objects, and non-methods
+                if not callable(method) or isinstance(method, (classmethod, staticmethod)):
+                    continue
+                # Skip any mocked objects or attributes
+                if isinstance(method, MagicMock) or hasattr(method, '_mock_return_value'):
+                    continue
+                # Only include methods that have been decorated with @ModelClass.method
                 method_info = getattr(method, _METHOD_INFO_ATTR, None)
                 if not method_info:  # regular function, not a model method
                     continue

clarifai/runners/models/openai_class.py

@@ -0,0 +1,221 @@
+"""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()

clarifai/runners/utils/code_script.py

@@ -88,9 +88,6 @@ model = Model({model_ui_url},
         client_script_str = f'response = model.{method_name}('
         annotations = _get_annotations_source(method_signature)
         for param_name, (param_type, default_value, required) in annotations.items():
-            print(
-                f"param_name: {param_name}, param_type: {param_type}, default_value: {default_value}"
-            )
             if param_name == "return":
                 continue
             if default_value is None and required:
@@ -262,7 +259,7 @@ def _parse_default_value(field: resources_pb2.ModelTypeField):
         elif data_type == resources_pb2.ModelTypeField.DataType.BOOL:
             return 'True' if default_str.lower() == 'true' else 'False'
         elif data_type == resources_pb2.ModelTypeField.DataType.STR:
-            return repr(default_str)
+            return default_str
         elif data_type == resources_pb2.ModelTypeField.DataType.BYTES:
             return f"b{repr(default_str.encode('utf-8'))}"
         elif data_type == resources_pb2.ModelTypeField.DataType.JSON_DATA:

{clarifai-11.4.4.dist-info → clarifai-11.4.6.dist-info}/METADATA

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

{clarifai-11.4.4.dist-info → clarifai-11.4.6.dist-info}/RECORD

@@ -1,4 +1,4 @@
-clarifai/__init__.py,sha256=sUX_44ac6i5WHivSDqnx8WOTpwJ2J_D46SUoKT-SUh4,23
+clarifai/__init__.py,sha256=nV_wnJ_Jf3dtyFB9emgspFcYUJJezVc0zPs1ncsDV3Q,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
@@ -63,20 +63,22 @@ clarifai/modules/style.css,sha256=j7FNPZVhLPj35vvBksAJ90RuX5sLuqzDR5iM2WIEhiA,60
 clarifai/rag/__init__.py,sha256=wu3PzAzo7uqgrEzuaC9lY_3gj1HFiR3GU3elZIKTT5g,40
 clarifai/rag/rag.py,sha256=EG3GoFrHFCmA70Tz49_0Jo1-3WIaHSgWGHecPeErcdc,14170
 clarifai/rag/utils.py,sha256=_gVZdABuMnraCKViLruV75x0F3IpgFXN6amYSGE5_xc,4462
-clarifai/runners/__init__.py,sha256=cDJ31l41dDsqW4Xn6sFMkKxxdIMTnGH9IW6sVkq0TNw,207
+clarifai/runners/__init__.py,sha256=CQhpUOj_x-oV9xEUKdL-hi3A1BQAtPUv-FFOev4a96w,281
 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/mcp_class.py,sha256=trtChVaesNSrb-Z3hdr0sdJjX7U7TlX4EMuO00vznTA,5960
+clarifai/runners/models/dummy_openai_model.py,sha256=5oa7r8j1GpymenpmMfaAV9Vt6VObKvrT9tDXgFmP4qY,7208
+clarifai/runners/models/mcp_class.py,sha256=7uwCMade0LMMBq7vczhPf4Kxdmh8Rj0R7Pg3pPxYdjQ,6386
 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_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/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=qU5B3vJmIjQnB_nQJI_aUfj8glezmNWgaPonZsE0_Xo,11278
+clarifai/runners/utils/code_script.py,sha256=u8rN-Av7V8ZZK61P6wu6WOFkUDjU2gc0B8Z53Y6FEWQ,11137
 clarifai/runners/utils/const.py,sha256=Q4Ps6gIEJCyTdQCfmT6PaS61WHmhT25XigV1NugWz-E,1544
 clarifai/runners/utils/data_utils.py,sha256=4M4n-cGprBEBV5UkgOWaUlVfZ3WBTmegdffGQ3SfYCU,20750
 clarifai/runners/utils/loader.py,sha256=K5Y8MPbIe5STw2gDnrL8KqFgKNxEo7bz-RV0ip1T4PM,10900
@@ -104,9 +106,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.4.dist-info/licenses/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
-clarifai-11.4.4.dist-info/METADATA,sha256=PPC2dIigq8LyS79SNag-OWUK5oMM9BCU24_KFRv4AF0,22398
-clarifai-11.4.4.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-clarifai-11.4.4.dist-info/entry_points.txt,sha256=X9FZ4Z-i_r2Ud1RpZ9sNIFYuu_-9fogzCMCRUD9hyX0,51
-clarifai-11.4.4.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
-clarifai-11.4.4.dist-info/RECORD,,
+clarifai-11.4.6.dist-info/licenses/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
+clarifai-11.4.6.dist-info/METADATA,sha256=Y2hsYELo0z0R3xTTPuv0-VvPcMlYdieAS1EWKfkhQ6o,22398
+clarifai-11.4.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+clarifai-11.4.6.dist-info/entry_points.txt,sha256=X9FZ4Z-i_r2Ud1RpZ9sNIFYuu_-9fogzCMCRUD9hyX0,51
+clarifai-11.4.6.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
+clarifai-11.4.6.dist-info/RECORD,,

{clarifai-11.4.4.dist-info → clarifai-11.4.6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.8.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any