clarifai 11.2.4rc2__py3-none-any.whl → 11.2.4rc3__py3-none-any.whl

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "11.2.4rc2"
+__version__ = "11.2.4rc3"

clarifai/runners/models/model_builder.py

@@ -23,7 +23,6 @@ from clarifai.runners.utils.const import (
     DEFAULT_DOWNLOAD_CHECKPOINT_WHEN, DEFAULT_PYTHON_VERSION, DEFAULT_RUNTIME_DOWNLOAD_PATH,
     PYTHON_BASE_IMAGE, TORCH_BASE_IMAGE)
 from clarifai.runners.utils.loader import HuggingFaceLoader
-from clarifai.runners.utils import data_utils
 from clarifai.runners.utils.method_signatures import signatures_to_yaml
 from clarifai.urls.helper import ClarifaiUrlHelper
 from clarifai.utils.logging import logger
@@ -337,16 +336,6 @@ class ModelBuilder:
     method_info = model_class._get_method_info()
     signatures = [method.signature for method in method_info.values()]
     return signatures
-  
-  def get_methods_defaults(self):
-    """
-    Returns the inference parameters for the model class.
-    """
-    model_class = self.load_model_class(mocking=True)
-    method_info = model_class._get_method_info()
-    python_param_defaults = [method.python_param_types for method in method_info.values()]
-    return python_param_defaults
-    
 
   @property
   def client(self):
@@ -633,58 +622,14 @@ class ModelBuilder:
     concepts = config.get('concepts')
     logger.info(f"Updated config.yaml with {len(concepts)} concepts.")
 
-  def filled_params_specs_with_inference_params(self, method_signatures: list[resources_pb2.MethodSignature], methods_defaults) -> list[resources_pb2.ModelTypeField]:
-    """
-    Fills the params_specs with the inference params.
-    """
-    inference_params = set()
-    for i, method_defaults in enumerate(methods_defaults):
-      for name, default in method_defaults.items():
-        if isinstance(default, data_utils.InputField):
-          if i==0:
-            inference_params.add(name)
-          else:
-            # if field.name not in inference_params then remove from inference_params
-            if name not in inference_params:
-              inference_params.remove(field.name)
-    output=[]
-    for signature in method_signatures:
-      for field in signature.input_fields:
-        if field.name in inference_params:
-          field.path = field.name
-          if field.type == resources_pb2.ModelTypeField.DataType.STR:
-            field.default_value= str(field.default)
-            field.field_type = resources_pb2.ModelTypeField.ModelTypeFieldType.STRING
-          elif field.type == resources_pb2.ModelTypeField.DataType.INT:
-            field.default_value= int(field.default)
-            field.field_type = resources_pb2.ModelTypeField.ModelTypeFieldType.NUMBER
-          elif field.type == resources_pb2.ModelTypeField.DataType.FLOAT:
-            field.default_value= float(field.default)
-            field.field_type = resources_pb2.ModelTypeField.ModelTypeFieldType.NUMBER
-          elif field.type == resources_pb2.ModelTypeField.DataType.BOOL:
-            field.default_value= bool(field.default)
-            field.field_type = resources_pb2.ModelTypeField.ModelTypeFieldType.BOOLEAN
-          else:
-            field.default_value= field.default
-            field.field_type = resources_pb2.ModelTypeField.ModelTypeFieldType.STRING
-          output.append(field)
-    return output
-
-
   def get_model_version_proto(self):
     signatures = self.get_method_signatures()
-    methods_defaults = self.get_methods_defaults()
-
     model_version_proto = resources_pb2.ModelVersion(
         pretrained_model_config=resources_pb2.PretrainedModelConfig(),
         inference_compute_info=self.inference_compute_info,
         method_signatures=signatures,
-        output_info= resources_pb2.OutputInfo(
-          params_specs=self.filled_params_specs_with_inference_params(signatures, methods_defaults),
-        )
     )
 
-
     model_type_id = self.config.get('model').get('model_type_id')
     if model_type_id in CONCEPTS_REQUIRED_MODEL_TYPE:
 

clarifai/runners/models/model_class.py

@@ -354,9 +354,4 @@ class _MethodInfo:
         for p in inspect.signature(method).parameters.values()
         if p.annotation != inspect.Parameter.empty
     }
-    self.python_param_defaults = {
-        p.name: p.default
-        for p in inspect.signature(method).parameters.values()
-        if p.default != inspect.Parameter.empty
-    }
     self.python_param_types.pop('self', None)

clarifai/runners/utils/data_utils.py

@@ -180,42 +180,40 @@ class InputField(MessageData):
 
   @classmethod
   def get_default(cls, proto):
-      default_str = proto.default
-      default = None
-      import json
+    default_str = proto.default
+    default = None
+    import json
+    try:
+      # Attempt to parse as JSON first (for complex types)
+      return json.loads(default_str)
+    except json.JSONDecodeError:
+      pass
+    # Check for boolean values stored as "True" or "False"
+    if proto.type == resources_pb2.ModelTypeField.DataType.BOOL:
       try:
-          # Attempt to parse as JSON first (for complex types)
-          return json.loads(default_str)
-      except json.JSONDecodeError:
-          pass
-      # Check for boolean values stored as "True" or "False"
-      if proto.type == resources_pb2.ModelTypeField.DataType.BOOL:
-          try:
-              default = bool(default_str)
-          except ValueError:
-              pass
-      # Try to parse as integer
-      elif proto.type == resources_pb2.ModelTypeField.DataType.INT:
-          try:
-              default = int(default_str)
-          except ValueError:
-              pass
-
-      # Try to parse as float
-      elif proto.type == resources_pb2.ModelTypeField.DataType.FLOAT:
-          try:
-              default = float(default_str)
-          except ValueError:
-              pass
-      elif proto.type == resources_pb2.ModelTypeField.DataType.STR:
-          default = default_str
-
-      if default is None:
-          # If all parsing fails, return the string value
-          default = default_str
-      return default
-
+        default = bool(default_str)
+      except ValueError:
+        pass
+    # Try to parse as integer
+    elif proto.type == resources_pb2.ModelTypeField.DataType.INT:
+      try:
+        default = int(default_str)
+      except ValueError:
+        pass
 
+    # Try to parse as float
+    elif proto.type == resources_pb2.ModelTypeField.DataType.FLOAT:
+      try:
+        default = float(default_str)
+      except ValueError:
+        pass
+    elif proto.type == resources_pb2.ModelTypeField.DataType.STR:
+      default = default_str
+
+    if default is None:
+      # If all parsing fails, return the string value
+      default = default_str
+    return default
 
 
 class DataConverter:

clarifai/runners/utils/method_signatures.py

@@ -1,7 +1,7 @@
 import collections.abc as abc
 import inspect
-import logging
 import json
+import logging
 from collections import namedtuple
 from typing import Dict, List, Tuple, get_args, get_origin
 

clarifai/runners/utils/openai_convertor.py

@@ -1,44 +1,54 @@
 import time
 import uuid
 
+
 def generate_id():
-    return f"chatcmpl-{uuid.uuid4().hex}"
+  return f"chatcmpl-{uuid.uuid4().hex}"
+
 
 def _format_non_streaming_response(
     generated_text,
     model="custom-model",
     id=None,
     created=None,
-    usage=None,
+    prompt_tokens=None,
+    completion_tokens=None,
     finish_reason="stop",
 ):
-    if id is None:
-        id = generate_id()
-    if created is None:
-        created = int(time.time())
-    
-    response = {
-        "id": id,
-        "object": "chat.completion",
-        "created": created,
-        "model": model,
-        "choices": [
-            {
-                "index": 0,
-                "message": {
-                    "role": "assistant",
-                    "content": generated_text,
-                },
-                "finish_reason": finish_reason,
-                "logprobs": None,
-            }
-        ],
+  if id is None:
+    id = generate_id()
+  if created is None:
+    created = int(time.time())
+
+  response = {
+      "id":
+          id,
+      "object":
+          "chat.completion",
+      "created":
+          created,
+      "model":
+          model,
+      "choices": [{
+          "index": 0,
+          "message": {
+              "role": "assistant",
+              "content": generated_text,
+          },
+          "finish_reason": finish_reason,
+          "logprobs": None,
+      }],
+  }
+
+  if prompt_tokens is not None and completion_tokens is not None:
+    response["usage"] = {
+        "prompt_tokens": prompt_tokens,
+        "completion_tokens": completion_tokens,
+        "total_tokens": prompt_tokens + completion_tokens,
     }
-    
-    if usage is not None:
-        response["usage"] = usage
-    
-    return response
+
+  return response
+
 
 def _format_streaming_response(
     generated_chunks,
@@ -47,181 +57,111 @@ def _format_streaming_response(
     created=None,
     finish_reason="stop",
 ):
-    if id is None:
-        id = generate_id()
-    if created is None:
-        created = int(time.time())
-    
-    for chunk in generated_chunks:
-        yield {
-            "id": id,
-            "object": "chat.completion.chunk",
-            "created": created,
-            "model": model,
-            "choices": [
-                {
-                    "index": 0,
-                    "delta": {
-                        "content": chunk,
-                    },
-                    "finish_reason": None,
-                    "logprobs": None,
-                }
-            ],
-        }
-    
-    # Final chunk indicating completion
+  if id is None:
+    id = generate_id()
+  if created is None:
+    created = int(time.time())
+
+  for chunk in generated_chunks:
     yield {
-        "id": id,
-        "object": "chat.completion.chunk",
-        "created": created,
-        "model": model,
-        "choices": [
-            {
-                "index": 0,
-                "delta": {},
-                "finish_reason": finish_reason,
-                "logprobs": None,
-            }
-        ],
+        "id":
+            id,
+        "object":
+            "chat.completion.chunk",
+        "created":
+            created,
+        "model":
+            model,
+        "choices": [{
+            "index": 0,
+            "delta": {
+                "content": chunk,
+            },
+            "finish_reason": None,
+            "logprobs": None,
+        }],
     }
 
-def openai_response_format(
+  # Final chunk indicating completion
+  yield {
+      "id": id,
+      "object": "chat.completion.chunk",
+      "created": created,
+      "model": model,
+      "choices": [{
+          "index": 0,
+          "delta": {},
+          "finish_reason": finish_reason,
+          "logprobs": None,
+      }],
+  }
+
+
+def openai_response(
     generated_text,
     model="custom-model",
     id=None,
     created=None,
-    usage=None,
+    prompt_tokens=None,
+    completion_tokens=None,
     finish_reason="stop",
     stream=True,
 ):
-    if stream:
-        return _format_streaming_response(
-            generated_text, model, id, created, finish_reason
-        )
-    else:
-        return _format_non_streaming_response(
-            generated_text, model, id, created, usage, finish_reason
-)
-from typing import List, Dict, Union, Optional
-import base64
-from PIL import Image
-import io
-
-def openai_to_hf_chat_messages(
-    messages: List[Dict[str, str]],
-    tokenizer: Optional[object] = None
-) -> List[Dict[str, Union[str, Dict]]]:
-    """
-    Converts OpenAI-style chat messages into Hugging Face chat template format.
-    
-    Args:
-        messages: List of OpenAI-style messages (e.g., [{"role": "user", "content": "Hello"}]).
-        model_family: Optional model family (e.g., "llava", "llama") for special handling.
-        tokenizer: Optional tokenizer to check for chat template support.
-    
-    Returns:
-        List of messages in Hugging Face chat format.
-    """
-    hf_messages = []
-    
-    for msg in messages:
-        role = msg["role"]
-        content = msg["content"]
-        
-        # Handle multimodal content (e.g., images in OpenAI format)
-        if isinstance(content, list):
-            # OpenAI-style multimodal: [{"type": "text", "text": "..."}, {"type": "image_url", "image_url": "..."}]
-            new_content = []
-            for item in content:
-                if item["type"] == "text":
-                    new_content.append(item["text"])
-                elif item["type"] == "image_url":
-                    # Handle image (extract base64 or URL)
-                    image_url = item["image_url"]["url"]
-                    if image_url.startswith("data:image"):
-                        # Base64-encoded image
-                        image_data = image_url.split(",")[1]
-                        image_bytes = base64.b64decode(image_data)
-                        image = Image.open(io.BytesIO(image_bytes))
-                        new_content.append({"image": image})
-                    else:
-                        # URL (model must handle downloads)
-                        new_content.append({"url": image_url})
-            content = " ".join(new_content) if all(isinstance(c, str) for c in new_content) else new_content
-        elif not isinstance(content, str):
-            raise ValueError(f"Unsupported content type: {type(content)}")
-        
-        # Add to HF messages
-        hf_messages.append({"role": role, "content": content})
-    
-    # Apply model-specific adjustments
-    if tokenizer is not None and hasattr(tokenizer, "apply_chat_template"):
-        # Let Hugging Face tokenizer handle further formatting if needed
-        try:
-            return tokenizer.apply_chat_template(hf_messages, tokenize=False)
-        except:
-            pass  # Fall back to manual formatting
-    
-    return hf_messages
-
-def convert_openai_to_hf_messages(openai_messages):
-    """
+  if stream:
+    return _format_streaming_response(generated_text, model, id, created, finish_reason)
+  else:
+    return _format_non_streaming_response(generated_text, model, id, created, prompt_tokens,
+                                          completion_tokens, finish_reason)
+
+
+def openai_to_hf_messages(openai_messages):
+  """
     Converts OpenAI-style chat messages into a format compatible with Hugging Face's
     `tokenizer.apply_chat_template()` function, supporting all modalities (text, images, etc.).
-    
+
     Args:
         openai_messages (list): List of OpenAI-style messages, where each message is a dict with
                                 'role' (str) and 'content' (str or list of parts).
-    
+
     Returns:
         list: Hugging Face-compatible messages. Each message is a dict with 'role' and 'content'.
               Content is a string (text-only) or a list of parts (multimodal).
     """
-    hf_messages = []
-    for msg in openai_messages:
-        role = msg['role']
-        content = msg['content']
-        
-        if isinstance(content, list):
-            # Handle multimodal content (e.g., text + images)
-            converted_content = []
-            for part in content:
-                if part['type'] == 'text':
-                    converted_content.append({'type': 'text', 'text': part['text']})
-                elif part['type'] == 'image_url':
-                    # Handle image (extract base64 or URL)
-                    image_url = part["image_url"]["url"]
-                    if image_url.startswith("data:image"):
-                        # Base64-encoded image
-                        b64_img = image_url.split(",")[1]
-                        converted_content.append({
-                            'type': 'image',
-                            'base64': b64_img
-                        })
-                    else:
-                        # URL (model must handle downloads)
-                        converted_content.append({
-                            'type': 'image',
-                            'url': image_url
-                        })
-                elif part['type'] == 'video_url':
-                    video_url = part["video_url"]["url"]
-                    if video_url.startswith("data:video"):
-                        ValueError("Base64 video data is not supported in HF format.")
-                    else:
-                        # URL (model must handle downloads)
-                        converted_content.append({
-                            'type': 'video',
-                            'url': video_url
-                        })
-                else:
-                    raise ValueError(f"Unsupported content type: {part['type']} for conversion.")
-            hf_content = converted_content
+  hf_messages = []
+  for msg in openai_messages:
+    role = msg['role']
+    content = msg['content']
+
+    if isinstance(content, list):
+      # Handle multimodal content (e.g., text + images)
+      converted_content = []
+      for part in content:
+        if part['type'] == 'text':
+          converted_content.append({'type': 'text', 'text': part['text']})
+        elif part['type'] == 'image_url':
+          # Handle image (extract base64 or URL)
+          image_url = part["image_url"]["url"]
+          if image_url.startswith("data:image"):
+            # Base64-encoded image
+            b64_img = image_url.split(",")[1]
+            converted_content.append({'type': 'image', 'base64': b64_img})
+          else:
+            # URL (model must handle downloads)
+            converted_content.append({'type': 'image', 'url': image_url})
+        elif part['type'] == 'video_url':
+          video_url = part["video_url"]["url"]
+          if video_url.startswith("data:video"):
+            ValueError("Base64 video data is not supported in HF format.")
+          else:
+            # URL (model must handle downloads)
+            converted_content.append({'type': 'video', 'url': video_url})
         else:
-            # Text-only content (string)
-            hf_content = content
-        
-        hf_messages.append({'role': role, 'content': hf_content})
-    
-    return hf_messages
+          raise ValueError(f"Unsupported content type: {part['type']} for conversion.")
+      hf_content = converted_content
+    else:
+      # Text-only content (string)
+      hf_content = content
+
+    hf_messages.append({'role': role, 'content': hf_content})
+
+  return hf_messages

{clarifai-11.2.4rc2.dist-info → clarifai-11.2.4rc3.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.1
 Name: clarifai
-Version: 11.2.4rc2
+Version: 11.2.4rc3
 Summary: Clarifai Python SDK
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
@@ -35,17 +35,6 @@ Requires-Dist: requests>=2.32.3
 Requires-Dist: aiohttp>=3.10.0
 Provides-Extra: all
 Requires-Dist: pycocotools==2.0.6; extra == "all"
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license
-Dynamic: provides-extra
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
 
 <h1 align="center">
   <a href="https://www.clarifai.com/"><img alt="Clarifai" title="Clarifai" src="https://github.com/user-attachments/assets/623b883b-7fe5-4b95-bbfa-8691f5779af4"></a>

{clarifai-11.2.4rc2.dist-info → clarifai-11.2.4rc3.dist-info}/RECORD

@@ -1,4 +1,4 @@
-clarifai/__init__.py,sha256=MifEmQdTShs6F9sPHBKRleuDIhSTAInWoN8okWqMJPs,26
+clarifai/__init__.py,sha256=JujgM2t-mATi_SX1natNHTB73fM8G_c1vcI4bMKtqWs,26
 clarifai/cli.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/errors.py,sha256=RwzTajwds51wLD0MVlMC5kcpBnzRpreDLlazPSBZxrg,2605
 clarifai/versions.py,sha256=jctnczzfGk_S3EnVqb2FjRKfSREkNmvNEwAAa_VoKiQ,222
@@ -138,8 +138,8 @@ clarifai/runners/dockerfile_template/Dockerfile.nim,sha256=CSdUAehj3uOwminioLnT5
 clarifai/runners/dockerfile_template/Dockerfile.template,sha256=5cjv7U8PmWa3DB_5B1CqSYh_6GE0E0np52TIAa7EIDE,2312
 clarifai/runners/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/runners/models/base_typed_model.py,sha256=0QCWxch8CcyJSKvE1D4PILd2RSnQZHTmx4DXlQQ6dpo,7856
-clarifai/runners/models/model_builder.py,sha256=6ezRfKxXYI7jwWUiXdsy2L72Q3dvarqikvQuE5ZraVQ,38849
-clarifai/runners/models/model_class.py,sha256=j3oyOCmh-XfFg3UhdquMZ-DxrNSlOGnFlQMNT3fNQSI,14920
+clarifai/runners/models/model_builder.py,sha256=vIUZII9n5wL0SGV4xR6wfsdRvrMv4pSHr6P-KdYpikI,36343
+clarifai/runners/models/model_class.py,sha256=2l7AZ2MrwR8tMIIV7KQSagZIzSwydyIFUOu0uFo-4gI,14742
 clarifai/runners/models/model_class_refract.py,sha256=HxuozxSW7ag5yWCPxjNwgLArQ6dORhyGXlnpPaZz2-c,3211
 clarifai/runners/models/model_run_locally.py,sha256=H7FKUBzZ_EPPj1b6P59qbOYr3mUJjJTlD5gavH5e80o,17746
 clarifai/runners/models/model_runner.py,sha256=T4Qn_x0vky7XdeS54bvipzEmKZMra1tQdAu_u01yyjc,6503
@@ -161,11 +161,11 @@ clarifai/runners/utils/const.py,sha256=9qnOC1Bt6SGLQ9XCQEQ6519XhW4gzcztsV1Rgej67
 clarifai/runners/utils/data_handler.py,sha256=b7k6MWYPXSgjrfw6wsDf82xFYa0D7UjYmjE4mw5HzHM,8499
 clarifai/runners/utils/data_handler_refract.py,sha256=3M-V4hkOoF-9Ix4hE6ocXWiTJPc9dewtu6FMtddd-jQ,6343
 clarifai/runners/utils/data_types.py,sha256=CtcYoW4EFE1EG6JkcP2rcRast9Eac8hFoYRHHCuwl2w,12432
-clarifai/runners/utils/data_utils.py,sha256=BuIxcQOudFEle8V6ZvycrYd-6X0i__EQbXxKKF1n7mA,12911
+clarifai/runners/utils/data_utils.py,sha256=ODlBS3USrQM52ZARpoST7yK-CQnxV_myIruAy0oOxS8,12797
 clarifai/runners/utils/loader.py,sha256=Sl0m29RDtMPx2cIiSbbDFtKHQj2ktXQ5CnkvaHi-zDc,8804
 clarifai/runners/utils/logger.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-clarifai/runners/utils/method_signatures.py,sha256=HypEj1EN7pzRPzn-KUu1oOZcKlwfarvYTZXUZ-DEEYQ,18509
-clarifai/runners/utils/openai_convertor.py,sha256=tFFNkjcdsNi73DfT_JOqdZZAu8fDYQwpbToWcr62OOw,7650
+clarifai/runners/utils/method_signatures.py,sha256=aMf6CNhrZ48Gy0mbjg3sz7o3kVmIbPiEtKZk8S5D06Q,18509
+clarifai/runners/utils/openai_convertor.py,sha256=qRhq_nGacaLFD_-8oAbPaDhGZJVMtKbgb2A4X7FlhD0,4564
 clarifai/runners/utils/openai_format.py,sha256=vOrpgqVWmQZGGFANZf0hmR_ksZXsr2-S9WUxvkG5lZs,1980
 clarifai/runners/utils/serializers.py,sha256=S4sRsOVvH191vAGTRTAAdwLlQwlK4T5QVRDGPptg9nQ,7191
 clarifai/runners/utils/url_fetcher.py,sha256=v_8JOWmkyFAzsBulsieKX7Nfjy1Yg7wGSZeqfEvw2cg,1640
@@ -233,9 +233,9 @@ clarifai/workflows/__pycache__/__init__.cpython-39.pyc,sha256=9nA--jULSW7OFrYOcs
 clarifai/workflows/__pycache__/export.cpython-310.pyc,sha256=phEGwi2gAojCUhRTqjZVeTDn7Gk6LCVBeSTjAj4m9iY,2418
 clarifai/workflows/__pycache__/utils.cpython-310.pyc,sha256=M9_KTM7GOOS5SPrWwAzqHDqyGvgKi3xuSGvyw6MNf-I,1925
 clarifai/workflows/__pycache__/validate.cpython-310.pyc,sha256=c18Jgp_-CAm8RD_tmUpDCPoqZeexaoWELG0yBzb9rjw,2149
-clarifai-11.2.4rc2.dist-info/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
-clarifai-11.2.4rc2.dist-info/METADATA,sha256=2NQ4ajyyei0MMGHMBZimPeO7qxqoxMfMvlq1TaNzLRI,22453
-clarifai-11.2.4rc2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-clarifai-11.2.4rc2.dist-info/entry_points.txt,sha256=X9FZ4Z-i_r2Ud1RpZ9sNIFYuu_-9fogzCMCRUD9hyX0,51
-clarifai-11.2.4rc2.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
-clarifai-11.2.4rc2.dist-info/RECORD,,
+clarifai-11.2.4rc3.dist-info/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
+clarifai-11.2.4rc3.dist-info/METADATA,sha256=rHJD6tV9a8RvcifQFuQAfGWKLD-m_6A45Yc9796WRfI,22215
+clarifai-11.2.4rc3.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+clarifai-11.2.4rc3.dist-info/entry_points.txt,sha256=X9FZ4Z-i_r2Ud1RpZ9sNIFYuu_-9fogzCMCRUD9hyX0,51
+clarifai-11.2.4rc3.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
+clarifai-11.2.4rc3.dist-info/RECORD,,

{clarifai-11.2.4rc2.dist-info → clarifai-11.2.4rc3.dist-info}/WHEEL

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