clarifai 10.9.1__py3-none-any.whl → 10.9.4__py3-none-any.whl

clarifai/client/workflow.py

@@ -5,10 +5,12 @@ from typing import Dict, Generator, List
 from clarifai_grpc.grpc.api import resources_pb2, service_pb2
 from clarifai_grpc.grpc.api.resources_pb2 import Input
 from clarifai_grpc.grpc.api.status import status_code_pb2
+from google.protobuf.json_format import MessageToDict
 
 from clarifai.client.base import BaseClient
 from clarifai.client.input import Inputs
 from clarifai.client.lister import Lister
+from clarifai.client.model import Model
 from clarifai.constants.workflow import MAX_WORKFLOW_PREDICT_INPUTS
 from clarifai.errors import UserError
 from clarifai.urls.helper import ClarifaiUrlHelper
@@ -60,6 +62,7 @@ class Workflow(Lister, BaseClient):
     self.output_config = output_config
     self.workflow_info = resources_pb2.Workflow(**self.kwargs)
     self.logger = logger
+    self.input_types = None
     BaseClient.__init__(
         self,
         user_id=self.user_id,
@@ -109,20 +112,26 @@ class Workflow(Lister, BaseClient):
 
     return response
 
-  def predict_by_filepath(self, filepath: str, input_type: str):
+  def predict_by_filepath(self, filepath: str, input_type: str = None):
     """Predicts the workflow based on the given filepath.
 
     Args:
         filepath (str): The filepath to predict.
-        input_type (str): The type of input. Can be 'image', 'text', 'video' or 'audio.
+        input_type (str, optional): The type of input. Can be 'image', 'text', 'video' or 'audio.
 
     Example:
         >>> from clarifai.client.workflow import Workflow
         >>> workflow = Workflow("url") # Example: https://clarifai.com/clarifai/main/workflows/Face-Sentiment
                       or
         >>> workflow = Workflow(user_id='user_id', app_id='app_id', workflow_id='workflow_id')
-        >>> workflow_prediction = workflow.predict_by_filepath('filepath', 'image')
+        >>> workflow_prediction = workflow.predict_by_filepath('filepath')
     """
+    if not input_type:
+      self.load_info()
+      if len(self.input_types) > 1:
+        raise UserError("Workflow has multiple input types. Please use workflow.predict().")
+      input_type = self.input_types[0]
+
     if input_type not in {'image', 'text', 'video', 'audio'}:
       raise UserError('Invalid input type it should be image, text, video or audio.')
     if not os.path.isfile(filepath):
@@ -133,13 +142,19 @@ class Workflow(Lister, BaseClient):
 
     return self.predict_by_bytes(file_bytes, input_type)
 
-  def predict_by_bytes(self, input_bytes: bytes, input_type: str):
+  def predict_by_bytes(self, input_bytes: bytes, input_type: str = None):
     """Predicts the workflow based on the given bytes.
 
     Args:
         input_bytes (bytes): Bytes to predict on.
-        input_type (str): The type of input. Can be 'image', 'text', 'video' or 'audio.
+        input_type (str, optional): The type of input. Can be 'image', 'text', 'video' or 'audio.
     """
+    if not input_type:
+      self.load_info()
+      if len(self.input_types) > 1:
+        raise UserError("Workflow has multiple input types. Please use workflow.predict().")
+      input_type = self.input_types[0]
+
     if input_type not in {'image', 'text', 'video', 'audio'}:
       raise UserError('Invalid input type it should be image, text, video or audio.')
     if not isinstance(input_bytes, bytes):
@@ -156,20 +171,26 @@ class Workflow(Lister, BaseClient):
 
     return self.predict(inputs=[input_proto])
 
-  def predict_by_url(self, url: str, input_type: str):
+  def predict_by_url(self, url: str, input_type: str = None):
     """Predicts the workflow based on the given URL.
 
     Args:
         url (str): The URL to predict.
-        input_type (str): The type of input. Can be 'image', 'text', 'video' or 'audio.
+        input_type (str, optional): The type of input. Can be 'image', 'text', 'video' or 'audio.
 
     Example:
         >>> from clarifai.client.workflow import Workflow
         >>> workflow = Workflow("url") # Example: https://clarifai.com/clarifai/main/workflows/Face-Sentiment
                       or
         >>> workflow = Workflow(user_id='user_id', app_id='app_id', workflow_id='workflow_id')
-        >>> workflow_prediction = workflow.predict_by_url('url', 'image')
+        >>> workflow_prediction = workflow.predict_by_url('url')
     """
+    if not input_type:
+      self.load_info()
+      if len(self.input_types) > 1:
+        raise UserError("Workflow has multiple input types. Please use workflow.predict().")
+      input_type = self.input_types[0]
+
     if input_type not in {'image', 'text', 'video', 'audio'}:
       raise UserError('Invalid input type it should be image, text, video or audio.')
 
@@ -245,6 +266,25 @@ class Workflow(Lister, BaseClient):
 
     self.logger.info(f"Exported workflow to {out_path}")
 
+  def load_info(self) -> None:
+    """Loads the workflow info."""
+    if not self.input_types:
+      request = service_pb2.GetWorkflowRequest(user_app_id=self.user_app_id, workflow_id=self.id)
+      response = self._grpc_request(self.STUB.GetWorkflow, request)
+      if response.status.code != status_code_pb2.SUCCESS:
+        raise Exception(f"Workflow Get failed with response {response.status!r}")
+
+      dict_response = MessageToDict(response, preserving_proto_field_name=True)
+      self.kwargs = self.process_response_keys(dict_response['workflow'])
+      self.workflow_info = resources_pb2.Workflow(**self.kwargs)
+
+      model = Model(
+          model_id=self.kwargs['nodes'][0]['model']['id'],
+          **self.kwargs['nodes'][0]['model'],
+          pat=self.pat)
+      model.load_input_types()
+      self.input_types = model.input_types
+
   def __getattr__(self, name):
     return getattr(self.workflow_info, name)
 

clarifai/datasets/export/inputs_annotations.py

@@ -192,9 +192,11 @@ class InputAnnotationDownloader:
         self._save_video_to_archive(new_archive, hosted_url, file_name)
       self.num_inputs += 1
 
-    if data_dict.get("concepts") or data_dict.get("regions"):
+    if data_dict.get("metadata") or data_dict.get("concepts") or data_dict.get("regions"):
       file_name = os.path.join(split, "annotations", input_.id + ".json")
-      annot_data = data_dict.get("regions", []) + data_dict.get("concepts", [])
+      annot_data = [{
+          "metadata": data_dict.get("metadata", {})
+      }] + data_dict.get("regions", []) + data_dict.get("concepts", [])
 
       self._save_annotation_to_archive(new_archive, annot_data, file_name)
       self.num_annotations += 1

clarifai/datasets/upload/utils.py

@@ -143,7 +143,7 @@ class DisplayUploadStatus:
 
     for data in dict_response["datasetVersionMetricsGroups"]:
       if isinstance(data["value"], str):
-        if data["value"].startswith("id-"):
+        if ("type" in data) and (data["type"] == "CONCEPT_ID"):
           data["metrics"].update({"Concept": data["value"]})
           data["metrics"].pop("regionLocationMatrix", None)
           dataset_statistics.append(data["metrics"])

clarifai/runners/dockerfile_template/Dockerfile.cuda.template

@@ -64,6 +64,10 @@ ENV CLARIFAI_NODEPOOL_ID=${CLARIFAI_NODEPOOL_ID}
 ENV CLARIFAI_COMPUTE_CLUSTER_ID=${CLARIFAI_COMPUTE_CLUSTER_ID}
 ENV CLARIFAI_API_BASE=${CLARIFAI_API_BASE}
 
+# Set the NUMBA cache dir to /tmp
+ENV NUMBA_CACHE_DIR=/tmp/numba_cache
+ENV HOME=/tmp
+
 # Set the working directory to /app
 WORKDIR /app
 

clarifai/runners/models/model_run_locally.py

@@ -1,4 +1,3 @@
-import argparse
 import importlib.util
 import inspect
 import os
@@ -22,8 +21,6 @@ class ModelRunLocally:
   def __init__(self, model_path):
     self.model_path = model_path
     self.requirements_file = os.path.join(self.model_path, "requirements.txt")
-    self.venv_dir, self.temp_dir = self.create_temp_venv()
-    self.python_executable = os.path.join(self.venv_dir, "bin", "python")
 
   def create_temp_venv(self):
     """Create a temporary virtual environment."""
@@ -32,6 +29,10 @@ class ModelRunLocally:
     venv_dir = os.path.join(temp_dir, "venv")
     venv.create(venv_dir, with_pip=True)
 
+    self.venv_dir = venv_dir
+    self.temp_dir = temp_dir
+    self.python_executable = os.path.join(venv_dir, "bin", "python")
+
     logger.info(f"Created temporary virtual environment at {venv_dir}")
     return venv_dir, temp_dir
 
@@ -124,8 +125,8 @@ class ModelRunLocally:
         runner_id="n/a",
         nodepool_id="n/a",
         compute_cluster_id="n/a",
+        user_id="n/a",
     )
-    runner.load_model()
 
     # send an inference.
     response = self._run_model_inference(runner)
@@ -174,21 +175,16 @@ class ModelRunLocally:
       shutil.rmtree(self.temp_dir)
 
 
-def main():
-  parser = argparse.ArgumentParser()
-  parser.add_argument(
-      '--model_path', type=str, required=True, help='Path of the model folder to upload')
-  args = parser.parse_args()
+def main(model_path, run_model_server=False):
 
-  model_path = args.model_path
   manager = ModelRunLocally(model_path)
+  manager.create_temp_venv()
 
   try:
     manager.install_requirements()
-    manager.test_model()
+    if run_model_server:
+      manager.run_model_server()
+    else:
+      manager.test_model()
   finally:
     manager.clean_up()
-
-
-if __name__ == "__main__":
-  main()

clarifai/runners/models/model_servicer.py

@@ -28,7 +28,7 @@ class ModelServicer(service_pb2_grpc.V2Servicer):
     """
 
     # Download any urls that are not already bytes.
-    ensure_urls_downloaded(self.url_fetcher, request)
+    ensure_urls_downloaded(request)
 
     try:
       return self.model_class.predict(request)
@@ -47,7 +47,7 @@ class ModelServicer(service_pb2_grpc.V2Servicer):
     returns an output.
     """
     # Download any urls that are not already bytes.
-    ensure_urls_downloaded(self.url_fetcher, request)
+    ensure_urls_downloaded(request)
 
     try:
       return self.model_class.generate(request)
@@ -71,7 +71,7 @@ class ModelServicer(service_pb2_grpc.V2Servicer):
 
     # Download any urls that are not already bytes.
     for req in request:
-      ensure_urls_downloaded(self.url_fetcher, req)
+      ensure_urls_downloaded(req)
 
     try:
       return self.model_class.stream(request_copy)

clarifai/runners/models/model_upload.py

@@ -1,4 +1,3 @@
-import argparse
 import os
 import time
 from string import Template
@@ -60,9 +59,6 @@ class ModelUploader:
     return config
 
   def _validate_config_checkpoints(self):
-    if not self.config.get("checkpoints"):
-      logger.info("No checkpoints specified in the config file")
-      return None
 
     assert "type" in self.config.get("checkpoints"), "No loader type specified in the config file"
     loader_type = self.config.get("checkpoints").get("type")
@@ -201,15 +197,20 @@ class ModelUploader:
     return f"{self.folder}.tar.gz"
 
   def download_checkpoints(self):
+    if not self.config.get("checkpoints"):
+      logger.info("No checkpoints specified in the config file")
+      return True
+
     repo_id, hf_token = self._validate_config_checkpoints()
-    if repo_id and hf_token:
-      loader = HuggingFaceLoader(repo_id=repo_id, token=hf_token)
-      success = loader.download_checkpoints(self.checkpoint_path)
 
-      if not success:
-        logger.error(f"Failed to download checkpoints for model {repo_id}")
-        return
+    loader = HuggingFaceLoader(repo_id=repo_id, token=hf_token)
+    success = loader.download_checkpoints(self.checkpoint_path)
+
+    if not success:
+      logger.error(f"Failed to download checkpoints for model {repo_id}")
+    else:
       logger.info(f"Downloaded checkpoints for model {repo_id}")
+    return success
 
   def _concepts_protos_from_concepts(self, concepts):
     concept_protos = []
@@ -245,15 +246,23 @@ class ModelUploader:
     model_type_id = self.config.get('model').get('model_type_id')
     if model_type_id in self.CONCEPTS_REQUIRED_MODEL_TYPE:
 
-      labels = HuggingFaceLoader.fetch_labels(self.checkpoint_path)
-      # sort the concepts by id and then update the config file
-      labels = sorted(labels.items(), key=lambda x: int(x[0]))
+      if 'concepts' in self.config:
+        labels = self.config.get('concepts')
+        logger.info(f"Found {len(labels)} concepts in the config file.")
+        for concept in labels:
+          concept_proto = json_format.ParseDict(concept, resources_pb2.Concept())
+          model_version_proto.output_info.data.concepts.append(concept_proto)
+      else:
+        labels = HuggingFaceLoader.fetch_labels(self.checkpoint_path)
+        logger.info(f"Found {len(labels)} concepts from the model checkpoints.")
+        # sort the concepts by id and then update the config file
+        labels = sorted(labels.items(), key=lambda x: int(x[0]))
 
-      config_file = os.path.join(self.folder, 'config.yaml')
-      self.hf_labels_to_config(labels, config_file)
+        config_file = os.path.join(self.folder, 'config.yaml')
+        self.hf_labels_to_config(labels, config_file)
 
-      model_version_proto.output_info.data.concepts.extend(
-          self._concepts_protos_from_concepts(labels))
+        model_version_proto.output_info.data.concepts.extend(
+            self._concepts_protos_from_concepts(labels))
     return model_version_proto
 
   def upload_model_version(self, download_checkpoints):
@@ -261,17 +270,31 @@ class ModelUploader:
     logger.info(f"Will tar it into file: {file_path}")
 
     model_type_id = self.config.get('model').get('model_type_id')
-    repo_id, hf_token = self._validate_config_checkpoints()
 
-    loader = HuggingFaceLoader(repo_id=repo_id, token=hf_token)
-
-    if not download_checkpoints and not loader.validate_download(self.checkpoint_path) and (
-        model_type_id in self.CONCEPTS_REQUIRED_MODEL_TYPE) and 'concepts' not in self.config:
-      logger.error(
-          f"Model type {model_type_id} requires concepts to be specified in the config file or download the model checkpoints to infer the concepts."
+    if (model_type_id in self.CONCEPTS_REQUIRED_MODEL_TYPE) and 'concepts' not in self.config:
+      logger.info(
+          f"Model type {model_type_id} requires concepts to be specified in the config.yaml file.."
       )
-      input("Press Enter to download the checkpoints to infer the concepts and continue...")
-      self.download_checkpoints()
+      if self.config.get("checkpoints"):
+        logger.info(
+            "Checkpoints specified in the config.yaml file, will download the HF model's config.json file to infer the concepts."
+        )
+
+        if not download_checkpoints and not HuggingFaceLoader.validate_config(
+            self.checkpoint_path):
+
+          input(
+              "Press Enter to download the HuggingFace model's config.json file to infer the concepts and continue..."
+          )
+          repo_id, hf_token = self._validate_config_checkpoints()
+          loader = HuggingFaceLoader(repo_id=repo_id, token=hf_token)
+          loader.download_config(self.checkpoint_path)
+
+      else:
+        logger.error(
+            "No checkpoints specified in the config.yaml file to infer the concepts. Please either specify the concepts directly in the config.yaml file or include a checkpoints section to download the HF model's config.json file to infer the concepts."
+        )
+        return
 
     model_version_proto = self.get_model_version_proto()
 
@@ -385,11 +408,11 @@ class ModelUploader:
         return False
 
 
-def main(folder, download_checkpoints):
+def main(folder, download_checkpoints, skip_dockerfile):
   uploader = ModelUploader(folder)
   if download_checkpoints:
     uploader.download_checkpoints()
-  if not args.skip_dockerfile:
+  if not skip_dockerfile:
     uploader.create_dockerfile()
   exists = uploader.check_model_exists()
   if exists:
@@ -401,25 +424,3 @@ def main(folder, download_checkpoints):
 
   input("Press Enter to continue...")
   uploader.upload_model_version(download_checkpoints)
-
-
-if __name__ == "__main__":
-  parser = argparse.ArgumentParser()
-  parser.add_argument(
-      '--model_path', type=str, help='Path of the model folder to upload', required=True)
-  # flag to default to not download checkpoints
-  parser.add_argument(
-      '--download_checkpoints',
-      action='store_true',
-      help=
-      'Flag to download checkpoints before uploading and including them in the tar file that is uploaded. Defaults to False, which will attempt to download them at docker build time.',
-  )
-  parser.add_argument(
-      '--skip_dockerfile',
-      action='store_true',
-      help=
-      'Flag to skip generating a dockerfile so that you can manually edit an already created dockerfile.',
-  )
-  args = parser.parse_args()
-
-  main(args.model_path, args.download_checkpoints)

clarifai/runners/utils/loader.py

@@ -18,9 +18,17 @@ class HuggingFaceLoader:
         if importlib.util.find_spec("huggingface_hub") is None:
           raise ImportError(self.HF_DOWNLOAD_TEXT)
         os.environ['HF_TOKEN'] = token
+        from huggingface_hub import HfApi
+
+        api = HfApi()
+        api.whoami(token=token)
+
         subprocess.run(f'huggingface-cli login --token={os.environ["HF_TOKEN"]}', shell=True)
       except Exception as e:
-        Exception("Error setting up Hugging Face token ", e)
+        logger.error(
+            f"Error setting up Hugging Face token, please make sure you have the correct token: {e}"
+        )
+        logger.info("Continuing without Hugging Face token")
 
   def download_checkpoints(self, checkpoint_path: str):
     # throw error if huggingface_hub wasn't installed
@@ -50,6 +58,28 @@ class HuggingFaceLoader:
           return False
       return True
 
+  def download_config(self, checkpoint_path: str):
+    # throw error if huggingface_hub wasn't installed
+    try:
+      from huggingface_hub import hf_hub_download
+    except ImportError:
+      raise ImportError(self.HF_DOWNLOAD_TEXT)
+    if os.path.exists(checkpoint_path) and os.path.exists(
+        os.path.join(checkpoint_path, 'config.json')):
+      logger.info("HF model's config.json already exists")
+      return True
+    os.makedirs(checkpoint_path, exist_ok=True)
+    try:
+      is_hf_model_exists = self.validate_hf_model()
+      if not is_hf_model_exists:
+        logger.error("Model %s not found on Hugging Face" % (self.repo_id))
+        return False
+      hf_hub_download(repo_id=self.repo_id, filename='config.json', local_dir=checkpoint_path)
+    except Exception as e:
+      logger.error(f"Error downloading model's config.json {e}")
+      return False
+    return True
+
   def validate_hf_model(self,):
     # check if model exists on HF
     try:
@@ -70,6 +100,12 @@ class HuggingFaceLoader:
     return (len(checkpoint_dir_files) >= len(list_repo_files(self.repo_id))) and len(
         list_repo_files(self.repo_id)) > 0
 
+  @staticmethod
+  def validate_config(checkpoint_path: str):
+    # check if downloaded config.json exists
+    return os.path.exists(checkpoint_path) and os.path.exists(
+        os.path.join(checkpoint_path, 'config.json'))
+
   @staticmethod
   def fetch_labels(checkpoint_path: str):
     # Fetch labels for classification, detection and segmentation models

clarifai/utils/cli.py

@@ -0,0 +1,45 @@
+import importlib
+import os
+import pkgutil
+
+import click
+import yaml
+
+
+def from_yaml(filename: str):
+  try:
+    with open(filename, 'r') as f:
+      return yaml.safe_load(f)
+  except yaml.YAMLError as e:
+    click.echo(f"Error reading YAML file: {e}", err=True)
+    return {}
+
+
+def dump_yaml(data, filename: str):
+  try:
+    with open(filename, 'w') as f:
+      yaml.dump(data, f)
+  except Exception as e:
+    click.echo(f"Error writing YAML file: {e}", err=True)
+
+
+def set_base_url(env):
+  environments = {
+      'prod': 'https://api.clarifai.com',
+      'staging': 'https://api-staging.clarifai.com',
+      'dev': 'https://api-dev.clarifai.com'
+  }
+
+  if env in environments:
+    return environments[env]
+  else:
+    raise ValueError("Invalid environment. Please choose from 'prod', 'staging', 'dev'.")
+
+
+# Dynamically find and import all command modules from the cli directory
+def load_command_modules():
+  package_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'cli')
+
+  for _, module_name, _ in pkgutil.iter_modules([package_dir]):
+    if module_name != 'base':  # Skip the base.py file itself
+      importlib.import_module(f'clarifai.cli.{module_name}')

{clarifai-10.9.1.dist-info → clarifai-10.9.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: clarifai
-Version: 10.9.1
+Version: 10.9.4
 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 >=10.8.8
+Requires-Dist: clarifai-grpc >=10.9.11
 Requires-Dist: clarifai-protocol >=0.0.6
 Requires-Dist: numpy >=1.22.0
 Requires-Dist: tqdm >=4.65.0
@@ -33,15 +33,17 @@ Requires-Dist: inquirerpy ==0.3.4
 Requires-Dist: tabulate >=0.9.0
 Requires-Dist: protobuf ==5.27.3
 Requires-Dist: fsspec ==2024.6.1
+Requires-Dist: click ==8.1.7
 Provides-Extra: all
 Requires-Dist: pycocotools ==2.0.6 ; extra == 'all'
 
 <h1 align="center">
-  <a href="https://www.clarifai.com/"><img alt="Clarifai" title="Clarifai" src="https://upload.wikimedia.org/wikipedia/commons/b/bc/Clarifai_Logo_FC_Web.png"></a>
+  <a href="https://www.clarifai.com/"><img alt="Clarifai" title="Clarifai" src="https://github.com/user-attachments/assets/623b883b-7fe5-4b95-bbfa-8691f5779af4"></a>
 </h1>
 
+
 <h2 align="center">
-Clarifai Python SDK</a>
+Clarifai Python SDK
 </h2>
 
 
@@ -51,6 +53,8 @@ Clarifai Python SDK</a>
   </a>
   <a href="https://pypi.org/project/clarifai" target="_blank"> <img src="https://img.shields.io/pypi/dm/clarifai" alt="PyPI - Downloads">
   </a>
+  <a href="https://img.shields.io/pypi/pyversions/clarifai" target="_blank"> <img src="https://img.shields.io/pypi/pyversions/clarifai" alt="PyPI - Versions">
+  </a>
 </p>
 
 
@@ -261,19 +265,19 @@ print(gpt_4_model)
 
 
 # Model Predict
-model_prediction = Model("https://clarifai.com/anthropic/completion/models/claude-v2").predict_by_bytes(b"Write a tweet on future of AI", input_type="text")
+model_prediction = Model("https://clarifai.com/anthropic/completion/models/claude-v2").predict_by_bytes(b"Write a tweet on future of AI")
 
 # Customizing Model Inference Output
-model_prediction = gpt_4_model.predict_by_bytes(b"Write a tweet on future of AI", "text", inference_params=dict(temperature=str(0.7), max_tokens=30))
+model_prediction = gpt_4_model.predict_by_bytes(b"Write a tweet on future of AI", inference_params=dict(temperature=str(0.7), max_tokens=30))
 # Return predictions having prediction confidence > 0.98
-model_prediction = model.predict_by_filepath(filepath="local_filepath", input_type, output_config={"min_value": 0.98}) # Supports image, text, audio, video
+model_prediction = model.predict_by_filepath(filepath="local_filepath", output_config={"min_value": 0.98}) # Supports image, text, audio, video
 
 # Supports prediction by url
-model_prediction = model.predict_by_url(url="url", input_type) # Supports image, text, audio, video
+model_prediction = model.predict_by_url(url="url") # Supports image, text, audio, video
 
 # Return predictions for specified interval of video
 video_input_proto = [input_obj.get_input_from_url("Input_id", video_url=BEER_VIDEO_URL)]
-model_prediction = model.predict(video_input_proto, input_type="video", output_config={"sample_ms": 2000})
+model_prediction = model.predict(video_input_proto, output_config={"sample_ms": 2000})
 ```
 #### Model Training
 ```python
@@ -383,12 +387,12 @@ from clarifai.client.workflow import Workflow
 
 # Workflow Predict
 workflow = Workflow("workflow_url") # Example: https://clarifai.com/clarifai/main/workflows/Face-Sentiment
-workflow_prediction = workflow.predict_by_url(url="url", input_type="image") # Supports image, text, audio, video
+workflow_prediction = workflow.predict_by_url(url="url") # Supports image, text, audio, video
 
 # Customizing Workflow Inference Output
 workflow = Workflow(user_id="user_id", app_id="app_id", workflow_id="workflow_id",
                   output_config={"min_value": 0.98}) # Return predictions having prediction confidence > 0.98
-workflow_prediction = workflow.predict_by_filepath(filepath="local_filepath", input_type="text") # Supports image, text, audio, video
+workflow_prediction = workflow.predict_by_filepath(filepath="local_filepath") # Supports image, text, audio, video
 ```
 
 #### Workflows Listing