clarifai 11.2.3rc8__py3-none-any.whl → 11.2.4rc1__py3-none-any.whl

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "11.2.3rc8"
+__version__ = "11.2.4rc1"

clarifai/client/model_client.py

@@ -259,7 +259,6 @@ class ModelClient:
       inputs,  # TODO set up functions according to fetched signatures?
       method_name: str = 'predict',
   ) -> Any:
-
     input_signature = self._method_signatures[method_name].input_fields
     output_signature = self._method_signatures[method_name].output_fields
 
@@ -328,7 +327,7 @@ class ModelClient:
       response = self.STUB.PostModelOutputs(request)
       if status_is_retryable(
           response.status.code) and time.time() - start_time < 60 * 10:  # 10 minutes
-        logger.info(f"Model predict failed with response {response!r}")
+        logger.info("Model is still deploying, please wait...")
         time.sleep(next(backoff_iterator))
         continue
 

clarifai/runners/models/model_builder.py

@@ -23,6 +23,7 @@ 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
@@ -336,6 +337,16 @@ 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):
@@ -622,14 +633,58 @@ 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,4 +354,9 @@ 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

@@ -169,18 +169,52 @@ class InputField(MessageData):
 
   @classmethod
   def set_default(cls, proto=None, default=None):
-
+    import json
     if proto is None:
       proto = InputFieldProto()
     if default is not None:
-      if isinstance(default, str) or isinstance(default, bool) or isinstance(
-          default, (int, float)):
-        proto.default = str(default)
-      else:
-        import json
-        proto.default = json.dumps(default)
+      proto.default = json.dumps(default)
     return proto
 
+  @classmethod
+  def get_default(cls, proto):
+      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:
+              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:
   """A class that can be used to convert data to and from a specific format."""
@@ -211,54 +245,68 @@ class DataConverter:
     if data_type == resources_pb2.ModelTypeField.DataType.STR:
       if old_data.HasField('text'):
         new_data.string_value = old_data.text.raw
+        old_data.ClearField('text')
       return new_data
     elif data_type == resources_pb2.ModelTypeField.DataType.IMAGE:
       if old_data.HasField('image'):
         new_data.image.CopyFrom(old_data.image)
+        # Clear the old field to avoid duplication
+        old_data.ClearField('image')
       return new_data
     elif data_type == resources_pb2.ModelTypeField.DataType.VIDEO:
       if old_data.HasField('video'):
         new_data.video.CopyFrom(old_data.video)
+        old_data.ClearField('video')
       return new_data
     elif data_type == resources_pb2.ModelTypeField.DataType.BOOL:
       if old_data.bool_value is not False:
         new_data.bool_value = old_data.bool_value
+        old_data.bool_value = False
       return new_data
     elif data_type == resources_pb2.ModelTypeField.DataType.INT:
       if old_data.int_value != 0:
         new_data.int_value = old_data.int_value
+        old_data.int_value = 0
       return new_data
     elif data_type == resources_pb2.ModelTypeField.DataType.FLOAT:
       if old_data.float_value != 0.0:
         new_data.float_value = old_data.float_value
+        old_data.float_value = 0.0
       return new_data
     elif data_type == resources_pb2.ModelTypeField.DataType.BYTES:
       if old_data.bytes_value != b"":
         new_data.bytes_value = old_data.bytes_value
+        old_data.bytes_value = b""
       return new_data
     elif data_type == resources_pb2.ModelTypeField.DataType.NDARRAY:
       if old_data.HasField('ndarray'):
         new_data.ndarray.CopyFrom(old_data.ndarray)
+        old_data.ClearField('ndarray')
       return new_data
     elif data_type == resources_pb2.ModelTypeField.DataType.TEXT:
       if old_data.HasField('text'):
         new_data.text.CopyFrom(old_data.text)
+        old_data.ClearField('text')
       return new_data
     elif data_type == resources_pb2.ModelTypeField.DataType.AUDIO:
       if old_data.HasField('audio'):
         new_data.audio.CopyFrom(old_data.audio)
+        old_data.ClearField('audio')
       return new_data
     elif data_type == resources_pb2.ModelTypeField.DataType.CONCEPT:
       if old_data.concepts:
         new_data.concepts.extend(old_data.concepts)
+        old_data.ClearField('concepts')
       return new_data
     elif data_type == resources_pb2.ModelTypeField.DataType.REGION:
       if old_data.regions:
         new_data.regions.extend(old_data.regions)
+        old_data.ClearField('regions')
       return new_data
     elif data_type == resources_pb2.ModelTypeField.DataType.FRAME:
       if old_data.frames:
         new_data.frames.extend(old_data.frames)
+        old_data.ClearField('frames')
       return new_data
     elif data_type == resources_pb2.ModelTypeField.DataType.LIST:
       if not field.type_args:

clarifai/runners/utils/method_signatures.py

@@ -312,6 +312,8 @@ def deserialize(proto, signatures, inference_params={}, is_output=False):
       kwargs[sig.name] = serializer.deserialize(part.data)
     elif inference_params_value is not None:
       kwargs[sig.name] = inference_params_value
+    # elif sig.default and (sig.required is False) and (not is_output):
+    #   kwargs[sig.name] = data_utils.InputField.get_default(sig)
     else:
       if sig_i == 0:
         # possible inlined first value

clarifai/runners/utils/openai_convertor.py

@@ -0,0 +1,227 @@
+import time
+import uuid
+
+def generate_id():
+    return f"chatcmpl-{uuid.uuid4().hex}"
+
+def _format_non_streaming_response(
+    generated_text,
+    model="custom-model",
+    id=None,
+    created=None,
+    usage=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 usage is not None:
+        response["usage"] = usage
+    
+    return response
+
+def _format_streaming_response(
+    generated_chunks,
+    model="custom-model",
+    id=None,
+    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
+    yield {
+        "id": id,
+        "object": "chat.completion.chunk",
+        "created": created,
+        "model": model,
+        "choices": [
+            {
+                "index": 0,
+                "delta": {},
+                "finish_reason": finish_reason,
+                "logprobs": None,
+            }
+        ],
+    }
+
+def openai_response_format(
+    generated_text,
+    model="custom-model",
+    id=None,
+    created=None,
+    usage=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):
+    """
+    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
+        else:
+            # Text-only content (string)
+            hf_content = content
+        
+        hf_messages.append({'role': role, 'content': hf_content})
+    
+    return hf_messages

{clarifai-11.2.3rc8.dist-info → clarifai-11.2.4rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: clarifai
-Version: 11.2.3rc8
+Version: 11.2.4rc1
 Summary: Clarifai Python SDK
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai

{clarifai-11.2.3rc8.dist-info → clarifai-11.2.4rc1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-clarifai/__init__.py,sha256=v5P3pEdtfkPEcv2UsOvdz4iO2xi_nVuRHtOzxV0gx9A,26
+clarifai/__init__.py,sha256=1tWubqQL15wfRZmXoJhZpjYGCNoJRv-6O4MUhDY-j3Q,26
 clarifai/cli.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/errors.py,sha256=RwzTajwds51wLD0MVlMC5kcpBnzRpreDLlazPSBZxrg,2605
 clarifai/versions.py,sha256=jctnczzfGk_S3EnVqb2FjRKfSREkNmvNEwAAa_VoKiQ,222
@@ -31,7 +31,7 @@ clarifai/client/deployment.py,sha256=w7Y6pA1rYG4KRK1SwusRZc2sQRXlG8wezuVdzSWpCo0
 clarifai/client/input.py,sha256=obMAHMDU1OwfXZ8KraOnGFlWzlW-3F7Ob_2lcOQMlhY,46339
 clarifai/client/lister.py,sha256=03KGMvs5RVyYqxLsSrWhNc34I8kiF1Ph0NeyEwu7nMU,2082
 clarifai/client/model.py,sha256=HLTzCoGhZ5Ifm5x5nSFa4YULnLLlBpZF-29nfOcwFuY,76995
-clarifai/client/model_client.py,sha256=U9PUKxGWc6oeMKwW0w6kPslToZh4kJcNJTi0F4ios7w,19980
+clarifai/client/model_client.py,sha256=X0RndVfTdfa4PZaOtSick0VKC3AkQakT-qrkPqaFKuI,19971
 clarifai/client/module.py,sha256=FTkm8s9m-EaTKN7g9MnLhGJ9eETUfKG7aWZ3o1RshYs,4204
 clarifai/client/nodepool.py,sha256=la3vTFrO4LX8zm2eQ5jqf2L0-kQ63Dano8FibadoZbk,10152
 clarifai/client/search.py,sha256=GaPWN6JmTQGZaCHr6U1yv0zqR6wKFl7i9IVLg2ul1CI,14254
@@ -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=vIUZII9n5wL0SGV4xR6wfsdRvrMv4pSHr6P-KdYpikI,36343
-clarifai/runners/models/model_class.py,sha256=2l7AZ2MrwR8tMIIV7KQSagZIzSwydyIFUOu0uFo-4gI,14742
+clarifai/runners/models/model_builder.py,sha256=xk0PB0CnCROv1K1rs71C8mJb0CwJpPTNznxPPOd9sQI,38929
+clarifai/runners/models/model_class.py,sha256=j3oyOCmh-XfFg3UhdquMZ-DxrNSlOGnFlQMNT3fNQSI,14920
 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,10 +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=GmFRRI2xcULEUPGmTTDsEXaVHrs65Nplbxl-7toOeIc,11354
+clarifai/runners/utils/data_utils.py,sha256=seA-3wMenf7VwyOBmqBiZ-domarw9deOk7Ua87bbpGE,12882
 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=2SSStcBuBUbIgvFgAJFt4By0ZHos2c7bDWJOiUxQxZQ,18190
+clarifai/runners/utils/method_signatures.py,sha256=uEPylPTMPAU50I2li3a1qhOQwjxivIHh9Jl4qaW8_GY,18328
+clarifai/runners/utils/openai_convertor.py,sha256=tFFNkjcdsNi73DfT_JOqdZZAu8fDYQwpbToWcr62OOw,7650
 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
@@ -232,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.3rc8.dist-info/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
-clarifai-11.2.3rc8.dist-info/METADATA,sha256=-U8BnxyMRl3eeTJqgrBkkeyhvGne7rNFX9eSY5fQJ0k,22453
-clarifai-11.2.3rc8.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-clarifai-11.2.3rc8.dist-info/entry_points.txt,sha256=X9FZ4Z-i_r2Ud1RpZ9sNIFYuu_-9fogzCMCRUD9hyX0,51
-clarifai-11.2.3rc8.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
-clarifai-11.2.3rc8.dist-info/RECORD,,
+clarifai-11.2.4rc1.dist-info/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
+clarifai-11.2.4rc1.dist-info/METADATA,sha256=oYyxfijRSs87J_aDNP8jzEe2Kr7IxvhOE_Tjk20fEJI,22453
+clarifai-11.2.4rc1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+clarifai-11.2.4rc1.dist-info/entry_points.txt,sha256=X9FZ4Z-i_r2Ud1RpZ9sNIFYuu_-9fogzCMCRUD9hyX0,51
+clarifai-11.2.4rc1.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
+clarifai-11.2.4rc1.dist-info/RECORD,,