clarifai 9.8.1__py3-none-any.whl → 9.9.0__py3-none-any.whl

clarifai_utils/schema/search.py

@@ -0,0 +1,60 @@
+from schema import And, Optional, Regex, Schema
+
+
+def get_schema() -> Schema:
+  """Initialize the schema for rank and filter.
+
+        This schema validates:
+
+        - Rank and filter must be a list
+        - Each item in the list must be a dict
+        - The dict can contain these optional keys:
+            - 'image_url': Valid URL string
+            - 'text_raw': Non-empty string
+            - 'metadata': Dict
+            - 'image_bytes': Bytes
+            - 'geo_point': Dict with 'longitude', 'latitude' and 'geo_limit' as float, float and int respectively
+            - 'concepts': List where each item is a concept dict
+        - Concept dict requires at least one of:
+            - 'name': Non-empty string with dashes/underscores
+            - 'id': Non-empty string
+            - 'language': Non-empty string
+            - 'value': 0 or 1 integer
+
+        Returns:
+            Schema: The schema for rank and filter.
+        """
+  # Schema for a single concept
+  concept_schema = Schema({
+      Optional('value'):
+          And(int, lambda x: x in [0, 1]),
+      Optional('id'):
+          And(str, len),
+      Optional('language'):
+          And(str, len),
+      # Non-empty strings with internal dashes and underscores.
+      Optional('name'):
+          And(str, len, Regex(r'^[0-9A-Za-z]+([-_][0-9A-Za-z]+)*$'))
+  })
+
+  # Schema for a rank or filter item
+  rank_filter_item_schema = Schema({
+      Optional('image_url'):
+          And(str, Regex(r'^https?://')),
+      Optional('text_raw'):
+          And(str, len),
+      Optional('metadata'):
+          dict,
+      Optional('image_bytes'):
+          bytes,
+      Optional('geo_point'): {
+          'longitude': float,
+          'latitude': float,
+          'geo_limit': int
+      },
+      Optional("concepts"):
+          And(list, lambda x: all(concept_schema.is_valid(item) and len(item) > 0 for item in x)),
+  })
+
+  # Schema for rank and filter args
+  return Schema([rank_filter_item_schema])

clarifai_utils/utils/logging.py

@@ -1,16 +1,66 @@
 import logging
-from typing import Optional
+from collections import defaultdict
+from typing import Dict, List, Optional
 
+from rich import print as rprint
 from rich.logging import RichHandler
 from rich.table import Table
 from rich.traceback import install
+from rich.tree import Tree
 
 install()
 
 
-def table_from_dict(data, column_names, title="") -> Table:
+def display_workflow_tree(nodes_data: List[Dict]) -> None:
+  """Displays a tree of the workflow nodes."""
+  # Create a mapping of node_id to the list of node_ids that are connected to it.
+  node_adj_mapping = defaultdict(list)
+  # Create a mapping of node_id to the node data info.
+  nodes_data_dict = {}
+  for node in nodes_data:
+    nodes_data_dict[node["id"]] = node
+    if node.get("node_inputs", "") == "":
+      node_adj_mapping["Input"].append(node["id"])
+    else:
+      for node_input in node["node_inputs"]:
+        node_adj_mapping[node_input["node_id"]].append(node["id"])
+
+  # Get all leaf nodes.
+  leaf_node_ids = set()
+  for node_id in list(nodes_data_dict.keys()):
+    if node_adj_mapping.get(node_id, "") == "":
+      leaf_node_ids.add(node_id)
+
+  def build_node_tree(node_id="Input"):
+    """Recursively builds a rich tree of the workflow nodes."""
+    # Set the style of the current node.
+    style_str = "green" if node_id in leaf_node_ids else "white"
+
+    # Create a Tree object for the current node.
+    if node_id != "Input":
+      node_table = table_from_dict(
+          [nodes_data_dict[node_id]["model"]],
+          column_names=["id", "model_type_id", "app_id", "user_id"],
+          title="Node: " + node_id)
+
+      tree = Tree(node_table, style=style_str, guide_style="underline2 white")
+    else:
+      tree = Tree(f"[green] {node_id}", style=style_str, guide_style="underline2 white")
+
+    # Recursively add the child nodes of the current node to the tree.
+    for child in node_adj_mapping.get(node_id, []):
+      tree.add(build_node_tree(child))
+
+    # Return the tree.
+    return tree
+
+  tree = build_node_tree("Input")
+  rprint(tree)
+
+
+def table_from_dict(data: List[Dict], column_names: List[str], title: str = "") -> Table:
   """Use this function for printing tables from a list of dicts."""
-  table = Table(title=title, show_header=True, header_style="bold blue")
+  table = Table(title=title, show_lines=False, show_header=True, header_style="blue")
   for column_name in column_names:
     table.add_column(column_name)
   for row in data:

clarifai_utils/versions.py

@@ -1,6 +1,6 @@
 import os
 
-CLIENT_VERSION = '9.8.1'
+CLIENT_VERSION = '9.9.0'
 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]))

clarifai_utils/workflows/export.py

@@ -0,0 +1,68 @@
+from typing import Any, Dict
+
+import yaml
+from google.protobuf.json_format import MessageToDict
+
+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
+
+
+class Exporter:
+
+  def __init__(self, workflow):
+    self.wf = workflow
+
+  def __enter__(self):
+    return self
+
+  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
+
+  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 close(self):
+    del self.wf
+    del self.wf_dict

clarifai_utils/workflows/utils.py

@@ -0,0 +1,59 @@
+from typing import Dict, Optional, Set
+
+from clarifai_grpc.grpc.api import resources_pb2
+from google.protobuf import struct_pb2
+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
+
+  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
+
+  s = struct_pb2.Struct()
+  s.update(yaml_params)
+
+  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)
+
+  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 = {}
+
+  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

clarifai_utils/workflows/validate.py

@@ -0,0 +1,67 @@
+from schema import And, Optional, Regex, Schema, SchemaError, Use
+
+# Non-empty, up to 32-character ASCII strings with internal dashes and underscores.
+_id_validator = And(str, lambda s: 0 < len(s) <= 48, Regex(r'^[0-9A-Za-z]+([-_][0-9A-Za-z]+)*$'))
+
+# 32-character hex string, converted to lower-case.
+_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
+
+
+def _model_has_other_fields(m):
+  return any(k not in ['model_id', 'model_version_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"])
+
+  return True
+
+
+_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,
+                            },
+                        }, _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)

clarifai/models/model_serving/envs/triton_conda-cp3.8-torch1.13.1-19f97078.yaml

@@ -1,35 +0,0 @@
-name: triton_conda-cp3.8-torch1.13.1-19f97078
-channels:
-  - conda-forge
-dependencies:
-  - _libgcc_mutex=0.1=conda_forge
-  - _openmp_mutex=4.5=2_gnu
-  - bzip2=1.0.8=h7f98852_4
-  - ca-certificates=2022.12.7=ha878542_0
-  - ld_impl_linux-64=2.40=h41732ed_0
-  - libffi=3.4.2=h7f98852_5
-  - libgcc-ng=12.2.0=h65d4601_19
-  - libgomp=12.2.0=h65d4601_19
-  - libnsl=2.0.0=h7f98852_0
-  - libsqlite=3.40.0=h753d276_0
-  - libuuid=2.32.1=h7f98852_1000
-  - libzlib=1.2.13=h166bdaf_4
-  - ncurses=6.3=h27087fc_1
-  - openssl=3.0.8=h0b41bf4_0
-  - pip=23.0.1=pyhd8ed1ab_0
-  - python=3.8.16=he550d4f_1_cpython
-  - readline=8.1.2=h0f457ee_0
-  - setuptools=67.4.0=pyhd8ed1ab_0
-  - tk=8.6.12=h27826a3_0
-  - wheel=0.38.4=pyhd8ed1ab_0
-  - xz=5.2.6=h166bdaf_0
-  - pip:
-      - numpy==1.24.2
-      - nvidia-cublas-cu11==11.10.3.66
-      - nvidia-cuda-nvrtc-cu11==11.7.99
-      - nvidia-cuda-runtime-cu11==11.7.99
-      - nvidia-cudnn-cu11==8.5.0.96
-      - opencv-python==4.7.0.72
-      - pillow==9.4.0
-      - torch==1.13.1
-      - typing-extensions==4.5.0

clarifai/models/model_serving/envs/triton_conda-cp3.8-torch2.0.0-ce980f28.yaml

@@ -1,51 +0,0 @@
-name: triton_conda-cp3.8-torch2.0.0-ce980f28
-channels:
-  - conda-forge
-dependencies:
-  - _libgcc_mutex=0.1=conda_forge
-  - _openmp_mutex=4.5=2_gnu
-  - bzip2=1.0.8=h7f98852_4
-  - ca-certificates=2023.5.7=hbcca054_0
-  - ld_impl_linux-64=2.40=h41732ed_0
-  - libffi=3.4.2=h7f98852_5
-  - libgcc-ng=13.1.0=he5830b7_0
-  - libgomp=13.1.0=he5830b7_0
-  - libnsl=2.0.0=h7f98852_0
-  - libsqlite=3.42.0=h2797004_0
-  - libuuid=2.38.1=h0b41bf4_0
-  - libzlib=1.2.13=hd590300_5
-  - ncurses=6.4=hcb278e6_0
-  - openssl=3.1.1=hd590300_1
-  - pip=23.1.2=pyhd8ed1ab_0
-  - python=3.8.17=he550d4f_0_cpython
-  - readline=8.2=h8228510_1
-  - setuptools=68.0.0=pyhd8ed1ab_0
-  - tk=8.6.12=h27826a3_0
-  - wheel=0.40.0=pyhd8ed1ab_0
-  - xz=5.2.6=h166bdaf_0
-  - pip:
-      - cmake==3.26.4
-      - filelock==3.12.2
-      - jinja2==3.1.2
-      - lit==16.0.6
-      - markupsafe==2.1.3
-      - mpmath==1.3.0
-      - networkx==3.1
-      - numpy==1.24.2
-      - nvidia-cublas-cu11==11.10.3.66
-      - nvidia-cuda-cupti-cu11==11.7.101
-      - nvidia-cuda-nvrtc-cu11==11.7.99
-      - nvidia-cuda-runtime-cu11==11.7.99
-      - nvidia-cudnn-cu11==8.5.0.96
-      - nvidia-cufft-cu11==10.9.0.58
-      - nvidia-curand-cu11==10.2.10.91
-      - nvidia-cusolver-cu11==11.4.0.1
-      - nvidia-cusparse-cu11==11.7.4.91
-      - nvidia-nccl-cu11==2.14.3
-      - nvidia-nvtx-cu11==11.7.91
-      - opencv-python==4.7.0.72
-      - pillow==9.4.0
-      - sympy==1.12
-      - torch==2.0.0
-      - triton==2.0.0
-      - typing-extensions==4.5.0

clarifai/models/model_serving/examples/image_classification/age_vit/triton_conda.yaml

@@ -1 +0,0 @@
-name: triton_conda-cp3.8-torch1.13.1-19f97078

clarifai/models/model_serving/examples/text_classification/xlm-roberta/triton_conda.yaml

@@ -1 +0,0 @@
-name: triton_conda-cp3.8-torch1.13.1-19f97078

clarifai/models/model_serving/examples/text_to_image/sd-v1.5/triton_conda.yaml

@@ -1 +0,0 @@
-name: triton_conda-cp3.8-torch1.13.1-19f97078

clarifai/models/model_serving/examples/text_to_text/bart-summarize/triton_conda.yaml

@@ -1 +0,0 @@
-name: triton_conda-cp3.8-torch1.13.1-19f97078

clarifai/models/model_serving/examples/visual_detection/yolov5x/triton_conda.yaml

@@ -1 +0,0 @@
-name: triton_conda-cp3.8-torch1.13.1-19f97078

clarifai/models/model_serving/examples/visual_embedding/vit-base/triton_conda.yaml

@@ -1 +0,0 @@
-name: triton_conda-cp3.8-torch1.13.1-19f97078

clarifai/models/model_serving/examples/visual_segmentation/segformer-b2/triton_conda.yaml

@@ -1 +0,0 @@
-name: triton_conda-cp3.8-torch1.13.1-19f97078

clarifai/models/model_serving/model_config/deploy.py

@@ -1,75 +0,0 @@
-# Copyright 2023 Clarifai, Inc.
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Triton Model Config classes."""
-
-from dataclasses import dataclass, field
-from typing import List
-
-
-@dataclass
-class ClarifaiFieldsMap:
-  """
-  Triton Model Config base.
-  Params:
-  -------
-  model_type
-
-  Returns:
-  --------
-  ClarifaiFieldsMap
-  """
-  model_type: str
-  input_fields_map: List = field(default_factory=list)
-  output_fields_map: List = field(default_factory=list)
-
-  def __post_init__(self):
-    """
-    Set mapping of clarifai in/output vs triton in/output
-    """
-    text_input_fields = {"text": "text"}
-    image_input_fields = {"image": "image"}
-
-    embedding_output_fields = {"embeddings": "embeddings"}
-
-    if self.model_type == "visual-detector":
-      self.input_fields_map = image_input_fields
-      self.output_fields_map = {
-          "regions[...].region_info.bounding_box": "predicted_bboxes",
-          "regions[...].data.concepts[...].id": "predicted_labels",
-          "regions[...].data.concepts[...].value": "predicted_scores"
-      }
-    elif self.model_type == "visual-classifier":
-      self.input_fields_map = image_input_fields
-      self.output_fields_map = {"concepts": "softmax_predictions"}
-    elif self.model_type == "text-classifier":
-      self.input_fields_map = text_input_fields
-      self.output_fields_map = {"concepts": "softmax_predictions"}
-    elif self.model_type == "text-embedder":
-      self.input_fields_map = text_input_fields
-      self.output_fields_map = embedding_output_fields
-    elif self.model_type == "text-to-text":
-      self.input_fields_map = text_input_fields
-      # input and output fields are the same for text-to-text
-      self.output_fields_map = text_input_fields
-    elif self.model_type == "text-to-image":
-      self.input_fields_map = text_input_fields
-      # image output fields match image_input fields
-      self.output_fields_map = image_input_fields
-    elif self.model_type == "visual-embedder":
-      self.input_fields_map = image_input_fields
-      self.output_fields_map = embedding_output_fields
-    elif self.model_type == "visual-segmenter":
-      self.input_fields_map = image_input_fields
-      self.output_fields_map = {
-          "regions[...].region_info.mask,regions[...].data.concepts": "predicted_mask"
-      }