clarifai 11.2.4rc2__tar.gz → 11.3.0__tar.gz

{clarifai-11.2.4rc2/clarifai.egg-info → clarifai-11.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: clarifai
-Version: 11.2.4rc2
+Version: 11.3.0
 Summary: Clarifai Python SDK
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
@@ -20,7 +20,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: clarifai-grpc>=11.2.6
+Requires-Dist: clarifai-grpc>=11.3.2
 Requires-Dist: clarifai-protocol>=0.0.22
 Requires-Dist: numpy>=1.22.0
 Requires-Dist: tqdm>=4.65.0
@@ -42,6 +42,7 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license
+Dynamic: license-file
 Dynamic: provides-extra
 Dynamic: requires-dist
 Dynamic: requires-python

clarifai-11.3.0/clarifai/__init__.py

@@ -0,0 +1 @@
+__version__ = "11.3.0"

{clarifai-11.2.4rc2 → clarifai-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-11.2.4rc2 → clarifai-11.3.0}/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-11.2.4rc2 → clarifai-11.3.0}/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.4rc2 → clarifai-11.3.0}/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-11.2.4rc2 → clarifai-11.3.0}/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-11.2.4rc2 → clarifai-11.3.0}/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-11.2.4rc2 → clarifai-11.3.0}/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-11.3.0/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.3.0/clarifai/utils/protobuf.py

@@ -0,0 +1,143 @@
+from google.protobuf import struct_pb2, symbol_database, wrappers_pb2
+from google.protobuf.descriptor import FieldDescriptor
+from google.protobuf.message import Message
+from google.protobuf.timestamp_pb2 import Timestamp
+
+from clarifai.utils.logging import logger
+
+# Initialize the Protobuf symbol database for dynamic message type resolution
+db = symbol_database.Default()
+
+# Define standard wrapper types for Protobuf well-known types
+WRAPPER_TYPES = {
+    wrappers_pb2.Int32Value,
+    wrappers_pb2.Int64Value,
+    wrappers_pb2.StringValue,
+    wrappers_pb2.UInt32Value,
+    wrappers_pb2.UInt64Value,
+}
+
+
+def dict_to_protobuf(pb_obj: Message, data: dict) -> None:
+  """Recursively convert a nested dictionary to a Protobuf message object.
+
+    Args:
+        pb_obj: The target Protobuf message instance to populate.
+        data: Source dictionary containing the data to convert.
+    """
+  for field, value in data.items():
+    if field not in pb_obj.DESCRIPTOR.fields_by_name:
+      logger.warning(f"Ignoring unknown field '{field}' in message '{pb_obj.DESCRIPTOR.name}'")
+      continue
+
+    field_descriptor = pb_obj.DESCRIPTOR.fields_by_name[field]
+
+    try:
+      # Handle repeated fields (lists)
+      if field_descriptor.label == FieldDescriptor.LABEL_REPEATED:
+        _handle_repeated_field(pb_obj, field_descriptor, field, value)
+
+      # Handle message fields (nested messages)
+      elif field_descriptor.type == FieldDescriptor.TYPE_MESSAGE:
+        _handle_message_field(pb_obj, field_descriptor, field, value)
+
+      # Handle scalar fields
+      else:
+        if value:
+          setattr(pb_obj, field, value)
+
+    except Exception as e:
+      logger.error(f"Error processing field '{field}': {str(e)}")
+      raise
+
+
+def _handle_repeated_field(pb_obj: Message, field_descriptor: FieldDescriptor, field: str,
+                           value: list) -> None:
+  """Process repeated fields (both scalar and message types)."""
+  if not isinstance(value, list):
+    logger.warning(f"Expected list for repeated field '{field}', got {type(value).__name__}")
+    return
+
+  repeated_field = getattr(pb_obj, field)
+
+  # Handle repeated message fields
+  if field_descriptor.type == FieldDescriptor.TYPE_MESSAGE:
+    for item in value:
+      if isinstance(item, dict):
+        item_msg = repeated_field.add()
+        dict_to_protobuf(item_msg, item)
+      elif isinstance(item, Message):
+        repeated_field.add().CopyFrom(item)
+      else:
+        logger.warning(f"Invalid type {type(item).__name__} in repeated message field '{field}'")
+  else:
+    # Handle repeated scalar fields
+    try:
+      repeated_field.extend(value)
+    except TypeError as e:
+      logger.error(f"Type mismatch in repeated scalar field '{field}': {str(e)}")
+      raise
+
+
+def _handle_message_field(pb_obj: Message, field_descriptor: FieldDescriptor, field: str,
+                          value: object) -> None:
+  """Process message-type fields including special types."""
+  msg_class = db.GetSymbol(field_descriptor.message_type.full_name)
+  target_field = getattr(pb_obj, field)
+
+  # Handle special message types
+  if msg_class is Timestamp:
+    _set_timestamp_value(target_field, value)
+  elif msg_class is struct_pb2.Struct:
+    _set_struct_value(target_field, value)
+  elif msg_class in WRAPPER_TYPES:
+    _set_wrapper_value(target_field, msg_class, value)
+  else:
+    # Handle nested messages
+    if isinstance(value, dict):
+      nested_pb = msg_class()
+      dict_to_protobuf(nested_pb, value)
+      target_field.CopyFrom(nested_pb)
+    elif isinstance(value, Message):
+      target_field.CopyFrom(value)
+    else:
+      logger.warning(f"Invalid type {type(value).__name__} for message field '{field}'")
+
+
+def _set_timestamp_value(target_field: Message, value: object) -> None:
+  """Set timestamp value from dict or numeric timestamp."""
+  ts = Timestamp()
+  if isinstance(value, dict):
+    ts.seconds = value.get('seconds', 0)
+    ts.nanos = value.get('nanos', 0)
+  elif isinstance(value, (int, float)):
+    ts.seconds = int(value)
+    ts.nanos = int((value - ts.seconds) * 1e9)
+  else:
+    logger.warning(f"Unsupported timestamp format: {type(value).__name__}")
+  target_field.CopyFrom(ts)
+
+
+def _set_struct_value(target_field: Message, value: object) -> None:
+  """Convert dictionary to Protobuf Struct."""
+  if not isinstance(value, dict):
+    logger.warning(f"Expected dict for Struct field, got {type(value).__name__}")
+    return
+
+  struct = struct_pb2.Struct()
+  try:
+    struct.update(value)
+  except ValueError as e:
+    logger.error(f"Invalid value in Struct: {str(e)}")
+    raise
+  target_field.CopyFrom(struct)
+
+
+def _set_wrapper_value(target_field: Message, wrapper_type: type, value: object) -> None:
+  """Set value for wrapper types (e.g., Int32Value)."""
+  try:
+    wrapper = wrapper_type(value=value)
+  except TypeError as e:
+    logger.error(f"Invalid value for {wrapper_type.__name__}: {str(e)}")
+    raise
+  target_field.CopyFrom(wrapper)

{clarifai-11.2.4rc2 → clarifai-11.3.0/clarifai.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: clarifai
-Version: 11.2.4rc2
+Version: 11.3.0
 Summary: Clarifai Python SDK
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
@@ -20,7 +20,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: clarifai-grpc>=11.2.6
+Requires-Dist: clarifai-grpc>=11.3.2
 Requires-Dist: clarifai-protocol>=0.0.22
 Requires-Dist: numpy>=1.22.0
 Requires-Dist: tqdm>=4.65.0
@@ -42,6 +42,7 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license
+Dynamic: license-file
 Dynamic: provides-extra
 Dynamic: requires-dist
 Dynamic: requires-python