clarifai 11.2.4rc2__py3-none-any.whl → 11.3.0__py3-none-any.whl

clarifai/__init__.py

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

clarifai/client/deployment.py

@@ -3,6 +3,7 @@ from clarifai_grpc.grpc.api import resources_pb2
 from clarifai.client.base import BaseClient
 from clarifai.client.lister import Lister
 from clarifai.utils.logging import logger
+from clarifai.utils.protobuf import dict_to_protobuf
 
 
 class Deployment(Lister, BaseClient):
@@ -28,7 +29,8 @@ class Deployment(Lister, BaseClient):
         **kwargs: Additional keyword arguments to be passed to the deployment.
     """
     self.kwargs = {**kwargs, 'id': deployment_id, 'user_id': user_id}
-    self.deployment_info = resources_pb2.Deployment(**self.kwargs)
+    self.deployment_info = resources_pb2.Deployment()
+    dict_to_protobuf(self.deployment_info, self.kwargs)
     self.logger = logger
     BaseClient.__init__(
         self,

clarifai/client/model.py

@@ -32,7 +32,7 @@ from clarifai.utils.misc import BackoffIterator
 from clarifai.utils.model_train import (find_and_replace_key, params_parser,
                                         response_to_model_params, response_to_param_info,
                                         response_to_templates)
-
+from clarifai.utils.protobuf import dict_to_protobuf
 MAX_SIZE_PER_STREAM = int(89_128_960)  # 85GiB
 MIN_CHUNK_FOR_UPLOAD_FILE = int(5_242_880)  # 5MiB
 MAX_CHUNK_FOR_UPLOAD_FILE = int(5_242_880_000)  # 5GiB
@@ -73,8 +73,11 @@ class Model(Lister, BaseClient):
       user_id, app_id, _, model_id, model_version_id = ClarifaiUrlHelper.split_clarifai_url(url)
       model_version = {'id': model_version_id}
       kwargs = {'user_id': user_id, 'app_id': app_id}
+
     self.kwargs = {**kwargs, 'id': model_id, 'model_version': model_version, }
-    self.model_info = resources_pb2.Model(**self.kwargs)
+    self.model_info = resources_pb2.Model()
+    dict_to_protobuf(self.model_info, self.kwargs)
+
     self.logger = logger
     self.training_params = {}
     self.input_types = None
@@ -983,7 +986,8 @@ class Model(Lister, BaseClient):
 
     dict_response = MessageToDict(response, preserving_proto_field_name=True)
     self.kwargs = self.process_response_keys(dict_response['model'])
-    self.model_info = resources_pb2.Model(**self.kwargs)
+    self.model_info = resources_pb2.Model()
+    dict_to_protobuf(self.model_info, self.kwargs)
 
   def __str__(self):
     if len(self.kwargs) < 10:

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

@@ -1,3 +1,4 @@
+import collections.abc as abc
 import inspect
 import itertools
 import logging
@@ -271,8 +272,9 @@ class ModelClass(ABC):
         if k not in python_param_types:
           continue
 
-        if hasattr(python_param_types[k], "__args__") and getattr(python_param_types[k],
-                                                                  "__origin__", None) == Iterator:
+        if hasattr(python_param_types[k],
+                   "__args__") and (getattr(python_param_types[k], "__origin__",
+                                            None) in [abc.Iterator, abc.Generator, abc.Iterable]):
           # get the type of the items in the stream
           stream_type = python_param_types[k].__args__[0]
 
@@ -354,9 +356,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_types.py

@@ -160,8 +160,8 @@ class Text(MessageData):
 
 class Concept(MessageData):
 
-  def __init__(self, id: str, name: str, value: float = 1):
-    self.id = id
+  def __init__(self, name: str, value: float = 1):
+    self.id = name
     self.name = name
     self.value = value
 
@@ -173,7 +173,7 @@ class Concept(MessageData):
 
   @classmethod
   def from_proto(cls, proto: ConceptProto) -> "Concept":
-    return cls(proto.id, proto.name, proto.value)
+    return cls(proto.name, proto.value)
 
 
 class Region(MessageData):

clarifai/runners/utils/data_utils.py

@@ -171,51 +171,50 @@ class InputField(MessageData):
       if default is not None:
         proto.default = json.dumps(default)
       return proto
-    except json.JSONDecodeError:
+    except Exception:
       if default is not None:
         proto.default = str(default)
       return proto
     except Exception as e:
-      raise ValueError(f"Error setting default value: {e}")
+      raise ValueError(
+          f"Error setting default value of type, {type(default)} and value: {default}: {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/runners/utils/method_signatures.py

@@ -1,6 +1,5 @@
 import collections.abc as abc
 import inspect
-import logging
 import json
 from collections import namedtuple
 from typing import Dict, List, Tuple, get_args, get_origin
@@ -313,13 +312,6 @@ 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):
-      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/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