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

clarifai/utils/protobuf.py

@@ -19,125 +19,148 @@ WRAPPER_TYPES = {
 
 
 def dict_to_protobuf(pb_obj: Message, data: dict) -> None:
-  """Recursively convert a nested dictionary to a Protobuf message object.
+    """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:
+    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 enums as string or int.
+            # Alternative is to use MessageToDict with use_integers_for_enums=True everywhere
+            # we end up calling dict_to_protobuf afterwards.
+            elif field_descriptor.type == FieldDescriptor.TYPE_ENUM:
+                if isinstance(value, str):
+                    enum_value = field_descriptor.enum_type.values_by_name.get(value)
+                    if enum_value is not None:
+                        setattr(pb_obj, field, enum_value.number)
+                elif isinstance(value, int):
+                    enum_value = field_descriptor.enum_type.values_by_number.get(value)
+                    if enum_value is not None:
+                        setattr(pb_obj, field, enum_value.number)
+
+            # Handle scalar fields
+            elif 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)
     # 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, dict):
+        nested_pb = msg_class()
+        dict_to_protobuf(nested_pb, value)
+        target_field.CopyFrom(nested_pb)
     elif isinstance(value, Message):
-      target_field.CopyFrom(value)
+        target_field.CopyFrom(value)
     else:
-      logger.warning(f"Invalid type {type(value).__name__} for message field '{field}'")
+        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)
+    """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)
+    elif isinstance(value, Timestamp):
+        ts = value
+    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
+    """Convert dictionary to Protobuf Struct."""
+    if isinstance(value, struct_pb2.Struct):
+        struct = value
+    else:
+        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)
+        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)
+    """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/versions.py

@@ -1,7 +1,9 @@
 import os
+
 from clarifai import __version__
 
 CLIENT_VERSION = __version__
 OS_VER = os.sys.platform
 PYTHON_VERSION = '.'.join(
-    map(str, [os.sys.version_info.major, os.sys.version_info.minor, os.sys.version_info.micro]))
+    map(str, [os.sys.version_info.major, os.sys.version_info.minor, os.sys.version_info.micro])
+)

clarifai/workflows/export.py

@@ -7,62 +7,60 @@ VALID_YAML_KEYS = ["workflow", "id", "nodes", "node_inputs", "node_id", "model"]
 
 
 def clean_up_unused_keys(wf: dict):
-  """Removes unused keys from dict before exporting to yaml. Supports nested dicts."""
-  new_wf = dict()
-  for key, val in wf.items():
-    if key not in VALID_YAML_KEYS:
-      continue
-    if key == "model":
-      new_wf["model"] = {
-          "model_id": wf["model"]["id"],
-          "model_version_id": wf["model"]["model_version"]["id"]
-      }
-      # If the model is not from clarifai main, add the app_id and user_id to the model dict.
-      if wf["model"]["user_id"] != "clarifai" and wf["model"]["app_id"] != "main":
-        new_wf["model"].update({
-            "app_id": wf["model"]["app_id"],
-            "user_id": wf["model"]["user_id"]
-        })
-    elif isinstance(val, dict):
-      new_wf[key] = clean_up_unused_keys(val)
-    elif isinstance(val, list):
-      new_list = []
-      for i in val:
-        new_list.append(clean_up_unused_keys(i))
-      new_wf[key] = new_list
-    else:
-      new_wf[key] = val
-  return new_wf
+    """Removes unused keys from dict before exporting to yaml. Supports nested dicts."""
+    new_wf = dict()
+    for key, val in wf.items():
+        if key not in VALID_YAML_KEYS:
+            continue
+        if key == "model":
+            new_wf["model"] = {
+                "model_id": wf["model"]["id"],
+                "model_version_id": wf["model"]["model_version"]["id"],
+            }
+            # If the model is not from clarifai main, add the app_id and user_id to the model dict.
+            if wf["model"]["user_id"] != "clarifai" and wf["model"]["app_id"] != "main":
+                new_wf["model"].update(
+                    {"app_id": wf["model"]["app_id"], "user_id": wf["model"]["user_id"]}
+                )
+        elif isinstance(val, dict):
+            new_wf[key] = clean_up_unused_keys(val)
+        elif isinstance(val, list):
+            new_list = []
+            for i in val:
+                new_list.append(clean_up_unused_keys(i))
+            new_wf[key] = new_list
+        else:
+            new_wf[key] = val
+    return new_wf
 
 
 class Exporter:
+    def __init__(self, workflow):
+        self.wf = workflow
 
-  def __init__(self, workflow):
-    self.wf = workflow
+    def __enter__(self):
+        return self
 
-  def __enter__(self):
-    return self
+    def parse(self) -> Dict[str, Any]:
+        """Reads a resources_pb2.Workflow object (e.g. from a GetWorkflow response)
 
-  def parse(self) -> Dict[str, Any]:
-    """Reads a resources_pb2.Workflow object (e.g. from a GetWorkflow response)
+        Returns:
+            dict: A dict representation of the workflow.
+        """
+        if isinstance(self.wf, list):
+            self.wf = self.wf[0]
+        wf = {"workflow": MessageToDict(self.wf, preserving_proto_field_name=True)}
+        clean_wf = clean_up_unused_keys(wf)
+        self.wf_dict = clean_wf
+        return clean_wf
 
-    Returns:
-        dict: A dict representation of the workflow.
-    """
-    if isinstance(self.wf, list):
-      self.wf = self.wf[0]
-    wf = {"workflow": MessageToDict(self.wf, preserving_proto_field_name=True)}
-    clean_wf = clean_up_unused_keys(wf)
-    self.wf_dict = clean_wf
-    return clean_wf
+    def export(self, out_path):
+        with open(out_path, 'w') as out_file:
+            yaml.dump(self.wf_dict["workflow"], out_file, default_flow_style=False)
 
-  def export(self, out_path):
-    with open(out_path, 'w') as out_file:
-      yaml.dump(self.wf_dict["workflow"], out_file, default_flow_style=False)
+    def __exit__(self, *args):
+        self.close()
 
-  def __exit__(self, *args):
-    self.close()
-
-  def close(self):
-    del self.wf
-    del self.wf_dict
+    def close(self):
+        del self.wf
+        del self.wf_dict

clarifai/workflows/utils.py

@@ -6,54 +6,57 @@ from google.protobuf.json_format import MessageToDict
 
 
 def get_yaml_output_info_proto(yaml_model_output_info: Dict) -> Optional[resources_pb2.OutputInfo]:
-  """Converts a yaml model output info to an api model output info."""
-  if not yaml_model_output_info:
-    return None
+    """Converts a yaml model output info to an api model output info."""
+    if not yaml_model_output_info:
+        return None
 
-  return resources_pb2.OutputInfo(
-      params=convert_yaml_params_to_api_params(yaml_model_output_info.get('params')))
+    return resources_pb2.OutputInfo(
+        params=convert_yaml_params_to_api_params(yaml_model_output_info.get('params'))
+    )
 
 
 def convert_yaml_params_to_api_params(yaml_params: Dict) -> Optional[struct_pb2.Struct]:
-  """Converts a yaml model output info params to an api model output info params."""
-  if not yaml_params:
-    return None
+    """Converts a yaml model output info params to an api model output info params."""
+    if not yaml_params:
+        return None
 
-  s = struct_pb2.Struct()
-  s.update(yaml_params)
+    s = struct_pb2.Struct()
+    s.update(yaml_params)
 
-  return s
+    return s
 
 
 def is_same_yaml_model(api_model: resources_pb2.Model, yaml_model: Dict) -> bool:
-  """Compares a model from the API with a model from a yaml file."""
-  api_model = MessageToDict(api_model, preserving_proto_field_name=True)
+    """Compares a model from the API with a model from a yaml file."""
+    api_model = MessageToDict(api_model, preserving_proto_field_name=True)
 
-  yaml_model_from_api = dict()
-  for k, _ in yaml_model.items():
-    if k == "output_info" and api_model["model_version"].get("output_info", "") != "":
-      yaml_model_from_api[k] = dict(params=api_model["model_version"]["output_info"].get("params"))
-    else:
-      yaml_model_from_api[k] = api_model.get(k)
-  yaml_model_from_api.update({"model_id": api_model.get("id")})
+    yaml_model_from_api = dict()
+    for k, _ in yaml_model.items():
+        if k == "output_info" and api_model["model_version"].get("output_info", "") != "":
+            yaml_model_from_api[k] = dict(
+                params=api_model["model_version"]["output_info"].get("params")
+            )
+        else:
+            yaml_model_from_api[k] = api_model.get(k)
+    yaml_model_from_api.update({"model_id": api_model.get("id")})
 
-  ignore_keys = {}
+    ignore_keys = {}
 
-  return is_dict_in_dict(yaml_model, yaml_model_from_api, ignore_keys)
+    return is_dict_in_dict(yaml_model, yaml_model_from_api, ignore_keys)
 
 
 def is_dict_in_dict(d1: Dict, d2: Dict, ignore_keys: Set = None) -> bool:
-  """Compares two dicts recursively."""
-  for k, v in d1.items():
-    if ignore_keys and k in ignore_keys:
-      continue
-    if k not in d2:
-      return False
-    if isinstance(v, dict):
-      if not isinstance(d2[k], dict):
-        return False
-      return is_dict_in_dict(d1[k], d2[k], None)
-    elif v != d2[k]:
-      return False
-
-  return True
+    """Compares two dicts recursively."""
+    for k, v in d1.items():
+        if ignore_keys and k in ignore_keys:
+            continue
+        if k not in d2:
+            return False
+        if isinstance(v, dict):
+            if not isinstance(d2[k], dict):
+                return False
+            return is_dict_in_dict(d1[k], d2[k], None)
+        elif v != d2[k]:
+            return False
+
+    return True

clarifai/workflows/validate.py

@@ -8,60 +8,72 @@ _hex_id_validator = And(str, Use(str.lower), Regex(r'^[0-9a-f]{32}'))
 
 
 def _model_does_not_have_model_version_id_and_other_fields(m):
-  """ Validate that model does not have model_version_id and other model fields."""
-  if ('model_version_id' in m) and _model_has_other_fields(m):
-    raise SchemaError(f"model should not set model_version_id and other model fields: {m};"
-                      f" please remove model_version_id or other model fields.")
-  return True
+    """Validate that model does not have model_version_id and other model fields."""
+    if ('model_version_id' in m) and _model_has_other_fields(m):
+        raise SchemaError(
+            f"model should not set model_version_id and other model fields: {m};"
+            f" please remove model_version_id or other model fields."
+        )
+    return True
 
 
 def _model_has_other_fields(m):
-  return any(k not in ['model_id', 'model_version_id', 'user_id', 'app_id'] for k in m.keys())
+    return any(k not in ['model_id', 'model_version_id', 'user_id', 'app_id'] for k in m.keys())
 
 
 def _workflow_nodes_have_valid_dependencies(nodes):
-  """Validate that all inputs to a node are declared before it."""
-  node_ids = set()
-  for node in nodes:
-    for node_input in node.get("node_inputs", []):
-      if node_input["node_id"] not in node_ids:
-        raise SchemaError(f"missing input '{node_input['node_id']}' for node '{node['id']}'")
-    node_ids.add(node["id"])
+    """Validate that all inputs to a node are declared before it."""
+    node_ids = set()
+    for node in nodes:
+        for node_input in node.get("node_inputs", []):
+            if node_input["node_id"] not in node_ids:
+                raise SchemaError(
+                    f"missing input '{node_input['node_id']}' for node '{node['id']}'"
+                )
+        node_ids.add(node["id"])
 
-  return True
+    return True
 
 
-_data_schema = Schema({
-    "workflow": {
-        "id":
-            _id_validator,
-        "nodes":
-            And(
+_data_schema = Schema(
+    {
+        "workflow": {
+            "id": _id_validator,
+            "nodes": And(
                 len,
-                [{
-                    "id":
-                        And(str, len),  # Node IDs are not validated as IDs by the API.
-                    "model":
-                        And({
-                            "model_id": _id_validator,
-                            Optional("app_id"): _id_validator,
-                            Optional("user_id"): _id_validator,
-                            Optional("model_version_id"): _hex_id_validator,
-                            Optional("model_type_id"): _id_validator,
-                            Optional("description"): str,
-                            Optional("output_info"): {
-                                Optional("params"): dict,
+                [
+                    {
+                        "id": And(str, len),  # Node IDs are not validated as IDs by the API.
+                        "model": And(
+                            {
+                                "model_id": _id_validator,
+                                Optional("app_id"): _id_validator,
+                                Optional("user_id"): _id_validator,
+                                Optional("model_version_id"): _hex_id_validator,
+                                Optional("model_type_id"): _id_validator,
+                                Optional("description"): str,
+                                Optional("output_info"): {
+                                    Optional("params"): dict,
+                                },
                             },
-                        }, _model_does_not_have_model_version_id_and_other_fields),
-                    Optional("node_inputs"):
-                        And(len, [{
-                            "node_id": And(str, len),
-                        }]),
-                }],
-                _workflow_nodes_have_valid_dependencies),
-    },
-})
+                            _model_does_not_have_model_version_id_and_other_fields,
+                        ),
+                        Optional("node_inputs"): And(
+                            len,
+                            [
+                                {
+                                    "node_id": And(str, len),
+                                }
+                            ],
+                        ),
+                    }
+                ],
+                _workflow_nodes_have_valid_dependencies,
+            ),
+        },
+    }
+)
 
 
 def validate(data):
-  return _data_schema.validate(data)
+    return _data_schema.validate(data)

{clarifai-11.3.0rc2.dist-info → clarifai-11.4.0.dist-info}/METADATA

@@ -1,7 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: clarifai
-Version: 11.3.0rc2
-Summary: Clarifai Python SDK
+Version: 11.4.0
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
 Author-email: support@clarifai.com
@@ -20,8 +19,8 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: clarifai-grpc>=11.3.3
-Requires-Dist: clarifai-protocol>=0.0.22
+Requires-Dist: clarifai-grpc>=11.3.4
+Requires-Dist: clarifai-protocol>=0.0.23
 Requires-Dist: numpy>=1.22.0
 Requires-Dist: tqdm>=4.65.0
 Requires-Dist: rich>=13.4.2
@@ -34,7 +33,18 @@ Requires-Dist: click>=8.1.7
 Requires-Dist: requests>=2.32.3
 Requires-Dist: aiohttp>=3.10.0
 Provides-Extra: all
-Requires-Dist: pycocotools==2.0.6; extra == "all"
+Requires-Dist: pycocotools>=2.0.7; extra == "all"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
 
 <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>