clarifai 11.2.4rc1__tar.gz → 11.2.4rc3__tar.gz

{clarifai-11.2.4rc1/clarifai.egg-info → clarifai-11.2.4rc3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.1
 Name: clarifai
-Version: 11.2.4rc1
+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.4rc3/clarifai/__init__.py

@@ -0,0 +1 @@
+__version__ = "11.2.4rc3"

{clarifai-11.2.4rc1 → clarifai-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-11.2.4rc1 → clarifai-11.2.4rc3}/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-11.2.4rc1 → clarifai-11.2.4rc3}/clarifai/runners/utils/data_utils.py

@@ -115,12 +115,7 @@ class InputField(MessageData):
     # proto.is_param = self.is_param
 
     if self.default is not None:
-      if isinstance(self.default, str) or isinstance(self.default, bool) or isinstance(
-          self.default, (int, float)):
-        proto.default = str(self.default)
-      else:
-        import json
-        proto.default = json.dumps(self.default)
+      proto = self.set_default(proto, self.default)
 
     return proto
 
@@ -169,51 +164,56 @@ 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:
-      proto.default = json.dumps(default)
-    return proto
+    try:
+      import json
+      if proto is None:
+        proto = InputFieldProto()
+      if default is not None:
+        proto.default = json.dumps(default)
+      return proto
+    except json.JSONDecodeError:
+      if default is not None:
+        proto.default = str(default)
+      return proto
+    except Exception as e:
+      raise ValueError(f"Error setting default value: {e}")
 
   @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-11.2.4rc1 → clarifai-11.2.4rc3}/clarifai/runners/utils/method_signatures.py

@@ -1,6 +1,7 @@
 import collections.abc as abc
 import inspect
 import json
+import logging
 from collections import namedtuple
 from typing import Dict, List, Tuple, get_args, get_origin
 
@@ -312,8 +313,13 @@ 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)
+    elif sig.default and (sig.required is False) and (not is_output):
+      try:
+        kwargs[sig.name] = data_utils.InputField.get_default(sig)
+      except Exception as e:
+        # default is not set, so ignore
+        logging.exception('Default value not set for %s: %s', sig.name, e)
+        pass
     else:
       if sig_i == 0:
         # possible inlined first value

clarifai-11.2.4rc3/clarifai/runners/utils/openai_convertor.py

@@ -0,0 +1,167 @@
+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,
+    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 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,
+    }
+
+  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(
+    generated_text,
+    model="custom-model",
+    id=None,
+    created=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, 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
+    else:
+      # Text-only content (string)
+      hf_content = content
+
+    hf_messages.append({'role': role, 'content': hf_content})
+
+  return hf_messages

{clarifai-11.2.4rc1 → clarifai-11.2.4rc3/clarifai.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.1
 Name: clarifai
-Version: 11.2.4rc1
+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.4rc1/clarifai/__init__.py

@@ -1 +0,0 @@
-__version__ = "11.2.4rc1"

clarifai-11.2.4rc1/clarifai/runners/utils/openai_convertor.py

@@ -1,227 +0,0 @@
-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