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

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "10.9.1"
+__version__ = "10.9.4"

clarifai/cli/base.py

@@ -0,0 +1,74 @@
+import os
+
+import click
+
+from ..utils.cli import dump_yaml, from_yaml, load_command_modules, set_base_url
+
+
+@click.group()
+@click.pass_context
+def cli(ctx):
+  """Clarifai CLI"""
+  ctx.ensure_object(dict)
+  config_path = 'config.yaml'
+  if os.path.exists(config_path):
+    ctx.obj = from_yaml(config_path)
+  else:
+    ctx.obj = {}
+
+
+@cli.command()
+@click.option('--config', type=click.Path(), required=False, help='Path to the config file')
+@click.option(
+    '-e',
+    '--env',
+    required=False,
+    help='Environment to use, choose from prod, staging and dev',
+    type=click.Choice(['prod', 'staging', 'dev']))
+@click.option('--user_id', required=False, help='User ID')
+@click.pass_context
+def login(ctx, config, env, user_id):
+  """Login command to set PAT and other configurations."""
+
+  if config and os.path.exists(config):
+    ctx.obj = from_yaml(config)
+
+  if 'pat' in ctx.obj:
+    os.environ["CLARIFAI_PAT"] = ctx.obj['pat']
+    click.echo("Loaded PAT from config file.")
+  elif 'CLARIFAI_PAT' in os.environ:
+    ctx.obj['pat'] = os.environ["CLARIFAI_PAT"]
+    click.echo("Loaded PAT from environment variable.")
+  else:
+    _pat = click.prompt(
+        "Get your PAT from https://clarifai.com/settings/security and pass it here", type=str)
+    os.environ["CLARIFAI_PAT"] = _pat
+    ctx.obj['pat'] = _pat
+    click.echo("PAT saved successfully.")
+
+  if user_id:
+    ctx.obj['user_id'] = user_id
+    os.environ["CLARIFAI_USER_ID"] = ctx.obj['user_id']
+  elif 'user_id' in ctx.obj or 'CLARIFAI_USER_ID' in os.environ:
+    ctx.obj['user_id'] = ctx.obj.get('user_id', os.environ["CLARIFAI_USER_ID"])
+    os.environ["CLARIFAI_USER_ID"] = ctx.obj['user_id']
+
+  if env:
+    ctx.obj['env'] = env
+    ctx.obj['base_url'] = set_base_url(env)
+    os.environ["CLARIFAI_API_BASE"] = ctx.obj['base_url']
+  elif 'env' in ctx.obj:
+    ctx.obj['env'] = ctx.obj.get('env', "prod")
+    ctx.obj['base_url'] = set_base_url(ctx.obj['env'])
+    os.environ["CLARIFAI_API_BASE"] = ctx.obj['base_url']
+  elif 'CLARIFAI_API_BASE' in os.environ:
+    ctx.obj['base_url'] = os.environ["CLARIFAI_API_BASE"]
+
+  dump_yaml(ctx.obj, 'config.yaml')
+
+
+# Import the CLI commands to register them
+load_command_modules()
+
+if __name__ == '__main__':
+  cli()

clarifai/cli/model.py

@@ -0,0 +1,65 @@
+import click
+from clarifai.cli.base import cli
+
+
+@cli.group()
+def model():
+  """Manage models: upload, test locally"""
+  pass
+
+
+@model.command()
+@click.option(
+    '--model_path',
+    type=click.Path(exists=True),
+    required=True,
+    help='Path to the model directory.')
+@click.option(
+    '--download_checkpoints',
+    is_flag=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.',
+)
+@click.option(
+    '--skip_dockerfile',
+    is_flag=True,
+    help=
+    'Flag to skip generating a dockerfile so that you can manually edit an already created dockerfile.',
+)
+def upload(model_path, download_checkpoints, skip_dockerfile):
+  """Upload a model to Clarifai."""
+  from clarifai.runners.models import model_upload
+
+  model_upload.main(model_path, download_checkpoints, skip_dockerfile)
+
+
+@model.command()
+@click.option(
+    '--model_path',
+    type=click.Path(exists=True),
+    required=True,
+    help='Path to the model directory.')
+def test_locally(model_path):
+  """Test model locally."""
+  try:
+    from clarifai.runners.models import model_run_locally
+    model_run_locally.main(model_path)
+    click.echo(f"Model tested locally from {model_path}.")
+  except Exception as e:
+    click.echo(f"Failed to test model locally: {e}", err=True)
+
+
+@model.command()
+@click.option(
+    '--model_path',
+    type=click.Path(exists=True),
+    required=True,
+    help='Path to the model directory.')
+def run_locally(model_path):
+  """Run model locally and starts a GRPC server to serve the model."""
+  try:
+    from clarifai.runners.models import model_run_locally
+    model_run_locally.main(model_path, run_model_server=True)
+    click.echo(f"Model server started locally from {model_path}.")
+  except Exception as e:
+    click.echo(f"Failed to starts model server locally: {e}", err=True)

clarifai/client/auth/helper.py

@@ -5,11 +5,16 @@ from urllib.parse import urlparse
 
 from clarifai_grpc.channel.clarifai_channel import ClarifaiChannel
 from clarifai_grpc.grpc.api import resources_pb2, service_pb2_grpc
+
+from clarifai import __version__
 from clarifai.utils.constants import CLARIFAI_PAT_ENV_VAR, CLARIFAI_SESSION_TOKEN_ENV_VAR
 
 DEFAULT_BASE = "https://api.clarifai.com"
 DEFAULT_UI = "https://clarifai.com"
 
+REQUEST_ID_PREFIX_HEADER = "x-clarifai-request-id-prefix"
+REQUEST_ID_PREFIX = f"sdk-python-{__version__}"
+
 # Map from base domain to True / False for whether the base has https or http.
 # This is filled in get_stub() if it's not in there already.
 base_https_cache = {}
@@ -136,7 +141,7 @@ class ClarifaiAuthHelper:
 
     # Then add in the query params.
     try:
-      auth.add_streamlit_query_params(st.experimental_get_query_params())
+      auth.add_streamlit_query_params(dict(st.query_params))
     except Exception as e:
       st.error(e)
       st.stop()
@@ -269,9 +274,11 @@ Additionally, these optional params are supported:
       metadata: the metadata need to send with all grpc API calls in the API client.
     """
     if self._pat != "":
-      return (("authorization", "Key %s" % self._pat),)
+      return (("authorization", "Key %s" % self._pat), (REQUEST_ID_PREFIX_HEADER,
+                                                        REQUEST_ID_PREFIX))
     elif self._token != "":
-      return (("x-clarifai-session-token", self._token),)
+      return (("x-clarifai-session-token", self._token), (REQUEST_ID_PREFIX_HEADER,
+                                                          REQUEST_ID_PREFIX))
     else:
       raise Exception("'token' or 'pat' needed to be provided in the query params or env vars.")
 

clarifai/client/dataset.py

@@ -628,6 +628,28 @@ class Dataset(Lister, BaseClient):
     if delete_version:
       self.delete_version(dataset_version_id)
 
+  def merge_dataset(self, merge_dataset_id: str) -> None:
+    """Merges the another dataset into current dataset.
+
+    Args:
+        merge_dataset_id (str): The dataset ID of the dataset to merge.
+
+    Example:
+        >>> from clarifai.client.dataset import Dataset
+        >>> dataset = Dataset(dataset_id='dataset_id', user_id='user_id', app_id='app_id')
+        >>> dataset.merge_dataset(merge_dataset_id='merge_dataset_id')
+    """
+    dataset_filter = resources_pb2.Filter(
+        input=resources_pb2.Input(dataset_ids=[merge_dataset_id]))
+    query = resources_pb2.Search(query=resources_pb2.Query(filters=[dataset_filter]))
+    request = service_pb2.PostDatasetInputsRequest(
+        user_app_id=self.user_app_id, dataset_id=self.id, search=query)
+
+    response = self._grpc_request(self.STUB.PostDatasetInputs, request)
+    if response.status.code != status_code_pb2.SUCCESS:
+      raise Exception(response.status)
+    self.logger.info("\nDataset Merged\n%s", response.status)
+
   def archive_zip(self, wait: bool = True) -> str:
     """Exports the dataset to a zip file URL."""
     request = service_pb2.PutDatasetVersionExportsRequest(

clarifai/client/input.py

@@ -100,7 +100,7 @@ class Inputs(Lister, BaseClient):
       if not label_ids:
         concepts=[
             resources_pb2.Concept(
-            id=f"id-{''.join(_label.split(' '))}", name=_label, value=1.)\
+            id=_label, name=_label, value=1.)\
             for _label in labels
         ]
       else:
@@ -516,7 +516,7 @@ class Inputs(Lister, BaseClient):
                 right_col=bbox[2]  #x_max
             )),
             data=resources_pb2.Data(concepts=[
-                resources_pb2.Concept(id=f"id-{''.join(label.split(' '))}", name=label, value=1.)
+                resources_pb2.Concept(id=label, name=label, value=1.)
                 if not label_id else resources_pb2.Concept(id=label_id, name=label, value=1.)
             ]))
     ])
@@ -561,7 +561,7 @@ class Inputs(Lister, BaseClient):
                         visibility="VISIBLE") for _point in polygons
                 ])),
             data=resources_pb2.Data(concepts=[
-                resources_pb2.Concept(id=f"id-{''.join(label.split(' '))}", name=label, value=1.)
+                resources_pb2.Concept(id=label, name=label, value=1.)
                 if not label_id else resources_pb2.Concept(id=label_id, name=label, value=1.)
             ]))
     ])

clarifai/client/model.py

@@ -72,6 +72,7 @@ class Model(Lister, BaseClient):
     self.model_info = resources_pb2.Model(**self.kwargs)
     self.logger = logger
     self.training_params = {}
+    self.input_types = None
     BaseClient.__init__(
         self,
         user_id=self.user_id,
@@ -450,9 +451,55 @@ class Model(Lister, BaseClient):
 
     return response
 
+  def _check_predict_input_type(self, input_type: str) -> None:
+    """Checks if the input type is valid for the model.
+
+    Args:
+        input_type (str): The input type to check.
+    Returns:
+        None
+    """
+    if not input_type:
+      self.load_input_types()
+      if len(self.input_types) > 1:
+        raise UserError(
+            "Model has multiple input types. Please use model.predict() for this multi-modal model."
+        )
+    else:
+      self.input_types = [input_type]
+      if self.input_types[0] not in {'image', 'text', 'video', 'audio'}:
+        raise UserError(
+            f"Got input type {input_type} but expected one of image, text, video, audio.")
+
+  def load_input_types(self) -> None:
+    """Loads the input types for the model.
+
+    Returns:
+        None
+
+    Example:
+        >>> from clarifai.client.model import Model
+        >>> model = Model("url") # Example URL: https://clarifai.com/clarifai/main/models/general-image-recognition
+                    or
+        >>> model = Model(model_id='model_id', user_id='user_id', app_id='app_id')
+        >>> model.load_input_types()
+    """
+    if self.input_types:
+      return self.input_types
+    if self.model_info.model_type_id == "":
+      self.load_info()
+    request = service_pb2.GetModelTypeRequest(
+        user_app_id=self.user_app_id,
+        model_type_id=self.model_info.model_type_id,
+    )
+    response = self._grpc_request(self.STUB.GetModelType, request)
+    if response.status.code != status_code_pb2.SUCCESS:
+      raise Exception(response.status)
+    self.input_types = response.model_type.input_fields
+
   def predict_by_filepath(self,
                           filepath: str,
-                          input_type: str,
+                          input_type: str = None,
                           compute_cluster_id: str = None,
                           nodepool_id: str = None,
                           deployment_id: str = None,
@@ -462,7 +509,7 @@ class Model(Lister, BaseClient):
 
     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.
         compute_cluster_id (str): The compute cluster ID to use for the model.
         nodepool_id (str): The nodepool ID to use for the model.
         deployment_id (str): The deployment ID to use for the model.
@@ -477,8 +524,8 @@ class Model(Lister, BaseClient):
         >>> model = Model("url") # Example URL: https://clarifai.com/clarifai/main/models/general-image-recognition
                     or
         >>> model = Model(model_id='model_id', user_id='user_id', app_id='app_id')
-        >>> model_prediction = model.predict_by_filepath('/path/to/image.jpg', 'image')
-        >>> model_prediction = model.predict_by_filepath('/path/to/text.txt', 'text')
+        >>> model_prediction = model.predict_by_filepath('/path/to/image.jpg')
+        >>> model_prediction = model.predict_by_filepath('/path/to/text.txt')
     """
     if not os.path.isfile(filepath):
       raise UserError('Invalid filepath.')
@@ -491,7 +538,7 @@ class Model(Lister, BaseClient):
 
   def predict_by_bytes(self,
                        input_bytes: bytes,
-                       input_type: str,
+                       input_type: str = None,
                        compute_cluster_id: str = None,
                        nodepool_id: str = None,
                        deployment_id: str = None,
@@ -501,7 +548,7 @@ class Model(Lister, BaseClient):
 
     Args:
         input_bytes (bytes): File 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.
         compute_cluster_id (str): The compute cluster ID to use for the model.
         nodepool_id (str): The nodepool ID to use for the model.
         deployment_id (str): The deployment ID to use for the model.
@@ -515,22 +562,17 @@ class Model(Lister, BaseClient):
         >>> from clarifai.client.model import Model
         >>> model = Model("https://clarifai.com/openai/chat-completion/models/GPT-4")
         >>> model_prediction = model.predict_by_bytes(b'Write a tweet on future of AI',
-                                                      input_type='text',
                                                       inference_params=dict(temperature=str(0.7), max_tokens=30)))
     """
-    if input_type not in {'image', 'text', 'video', 'audio'}:
-      raise UserError(
-          f"Got input type {input_type} but expected one of image, text, video, audio.")
-    if not isinstance(input_bytes, bytes):
-      raise UserError('Invalid bytes.')
+    self._check_predict_input_type(input_type)
 
-    if input_type == "image":
+    if self.input_types[0] == "image":
       input_proto = Inputs.get_input_from_bytes("", image_bytes=input_bytes)
-    elif input_type == "text":
+    elif self.input_types[0] == "text":
       input_proto = Inputs.get_input_from_bytes("", text_bytes=input_bytes)
-    elif input_type == "video":
+    elif self.input_types[0] == "video":
       input_proto = Inputs.get_input_from_bytes("", video_bytes=input_bytes)
-    elif input_type == "audio":
+    elif self.input_types[0] == "audio":
       input_proto = Inputs.get_input_from_bytes("", audio_bytes=input_bytes)
 
     if deployment_id and (compute_cluster_id or nodepool_id):
@@ -553,7 +595,7 @@ class Model(Lister, BaseClient):
 
   def predict_by_url(self,
                      url: str,
-                     input_type: str,
+                     input_type: str = None,
                      compute_cluster_id: str = None,
                      nodepool_id: str = None,
                      deployment_id: str = None,
@@ -563,7 +605,7 @@ class Model(Lister, BaseClient):
 
     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'.
         compute_cluster_id (str): The compute cluster ID to use for the model.
         nodepool_id (str): The nodepool ID to use for the model.
         deployment_id (str): The deployment ID to use for the model.
@@ -578,19 +620,17 @@ class Model(Lister, BaseClient):
         >>> model = Model("url") # Example URL: https://clarifai.com/clarifai/main/models/general-image-recognition
                     or
         >>> model = Model(model_id='model_id', user_id='user_id', app_id='app_id')
-        >>> model_prediction = model.predict_by_url('url', 'image')
+        >>> model_prediction = model.predict_by_url('url')
     """
-    if input_type not in {'image', 'text', 'video', 'audio'}:
-      raise UserError(
-          f"Got input type {input_type} but expected one of image, text, video, audio.")
+    self._check_predict_input_type(input_type)
 
-    if input_type == "image":
+    if self.input_types[0] == "image":
       input_proto = Inputs.get_input_from_url("", image_url=url)
-    elif input_type == "text":
+    elif self.input_types[0] == "text":
       input_proto = Inputs.get_input_from_url("", text_url=url)
-    elif input_type == "video":
+    elif self.input_types[0] == "video":
       input_proto = Inputs.get_input_from_url("", video_url=url)
-    elif input_type == "audio":
+    elif self.input_types[0] == "audio":
       input_proto = Inputs.get_input_from_url("", audio_url=url)
 
     if deployment_id and (compute_cluster_id or nodepool_id):
@@ -668,7 +708,7 @@ class Model(Lister, BaseClient):
 
   def generate_by_filepath(self,
                            filepath: str,
-                           input_type: str,
+                           input_type: str = None,
                            compute_cluster_id: str = None,
                            nodepool_id: str = None,
                            deployment_id: str = None,
@@ -678,7 +718,7 @@ class Model(Lister, BaseClient):
 
     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.
         compute_cluster_id (str): The compute cluster ID to use for the model.
         nodepool_id (str): The nodepool ID to use for the model.
         deployment_id (str): The deployment ID to use for the model.
@@ -713,7 +753,7 @@ class Model(Lister, BaseClient):
 
   def generate_by_bytes(self,
                         input_bytes: bytes,
-                        input_type: str,
+                        input_type: str = None,
                         compute_cluster_id: str = None,
                         nodepool_id: str = None,
                         deployment_id: str = None,
@@ -723,7 +763,7 @@ class Model(Lister, BaseClient):
 
     Args:
         input_bytes (bytes): File 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.
         compute_cluster_id (str): The compute cluster ID to use for the model.
         nodepool_id (str): The nodepool ID to use for the model.
         deployment_id (str): The deployment ID to use for the model.
@@ -737,24 +777,19 @@ class Model(Lister, BaseClient):
         >>> from clarifai.client.model import Model
         >>> model = Model("https://clarifai.com/openai/chat-completion/models/GPT-4")
         >>> stream_response = model.generate_by_bytes(b'Write a tweet on future of AI',
-                                                      input_type='text',
                                                       deployment_id='deployment_id',
                                                       inference_params=dict(temperature=str(0.7), max_tokens=30)))
         >>> list_stream_response = [response for response in stream_response]
     """
-    if input_type not in {'image', 'text', 'video', 'audio'}:
-      raise UserError(
-          f"Got input type {input_type} but expected one of image, text, video, audio.")
-    if not isinstance(input_bytes, bytes):
-      raise UserError('Invalid bytes.')
+    self._check_predict_input_type(input_type)
 
-    if input_type == "image":
+    if self.input_types[0] == "image":
       input_proto = Inputs.get_input_from_bytes("", image_bytes=input_bytes)
-    elif input_type == "text":
+    elif self.input_types[0] == "text":
       input_proto = Inputs.get_input_from_bytes("", text_bytes=input_bytes)
-    elif input_type == "video":
+    elif self.input_types[0] == "video":
       input_proto = Inputs.get_input_from_bytes("", video_bytes=input_bytes)
-    elif input_type == "audio":
+    elif self.input_types[0] == "audio":
       input_proto = Inputs.get_input_from_bytes("", audio_bytes=input_bytes)
 
     if deployment_id and (compute_cluster_id or nodepool_id):
@@ -777,7 +812,7 @@ class Model(Lister, BaseClient):
 
   def generate_by_url(self,
                       url: str,
-                      input_type: str,
+                      input_type: str = None,
                       compute_cluster_id: str = None,
                       nodepool_id: str = None,
                       deployment_id: str = None,
@@ -787,7 +822,7 @@ class Model(Lister, BaseClient):
 
     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.
         compute_cluster_id (str): The compute cluster ID to use for the model.
         nodepool_id (str): The nodepool ID to use for the model.
         deployment_id (str): The deployment ID to use for the model.
@@ -802,20 +837,18 @@ class Model(Lister, BaseClient):
         >>> model = Model("url") # Example URL: https://clarifai.com/clarifai/main/models/general-image-recognition
                     or
         >>> model = Model(model_id='model_id', user_id='user_id', app_id='app_id')
-        >>> stream_response = model.generate_by_url('url', 'image', deployment_id='deployment_id')
+        >>> stream_response = model.generate_by_url('url', deployment_id='deployment_id')
         >>> list_stream_response = [response for response in stream_response]
     """
-    if input_type not in {'image', 'text', 'video', 'audio'}:
-      raise UserError(
-          f"Got input type {input_type} but expected one of image, text, video, audio.")
+    self._check_predict_input_type(input_type)
 
-    if input_type == "image":
+    if self.input_types[0] == "image":
       input_proto = Inputs.get_input_from_url("", image_url=url)
-    elif input_type == "text":
+    elif self.input_types[0] == "text":
       input_proto = Inputs.get_input_from_url("", text_url=url)
-    elif input_type == "video":
+    elif self.input_types[0] == "video":
       input_proto = Inputs.get_input_from_url("", video_url=url)
-    elif input_type == "audio":
+    elif self.input_types[0] == "audio":
       input_proto = Inputs.get_input_from_url("", audio_url=url)
 
     if deployment_id and (compute_cluster_id or nodepool_id):
@@ -893,7 +926,7 @@ class Model(Lister, BaseClient):
 
   def stream_by_filepath(self,
                          filepath: str,
-                         input_type: str,
+                         input_type: str = None,
                          compute_cluster_id: str = None,
                          nodepool_id: str = None,
                          deployment_id: str = None,
@@ -903,7 +936,7 @@ class Model(Lister, BaseClient):
 
     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.
         compute_cluster_id (str): The compute cluster ID to use for the model.
         nodepool_id (str): The nodepool ID to use for the model.
         deployment_id (str): The deployment ID to use for the model.
@@ -916,7 +949,7 @@ class Model(Lister, BaseClient):
     Example:
         >>> from clarifai.client.model import Model
         >>> model = Model("url")
-        >>> stream_response = model.stream_by_filepath('/path/to/image.jpg', 'image', deployment_id='deployment_id')
+        >>> stream_response = model.stream_by_filepath('/path/to/image.jpg', deployment_id='deployment_id')
         >>> list_stream_response = [response for response in stream_response]
     """
     if not os.path.isfile(filepath):
@@ -936,7 +969,7 @@ class Model(Lister, BaseClient):
 
   def stream_by_bytes(self,
                       input_bytes_iterator: Iterator[bytes],
-                      input_type: str,
+                      input_type: str = None,
                       compute_cluster_id: str = None,
                       nodepool_id: str = None,
                       deployment_id: str = None,
@@ -946,7 +979,7 @@ class Model(Lister, BaseClient):
 
     Args:
         input_bytes_iterator (Iterator[bytes]): Iterator of file 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.
         compute_cluster_id (str): The compute cluster ID to use for the model.
         nodepool_id (str): The nodepool ID to use for the model.
         deployment_id (str): The deployment ID to use for the model.
@@ -960,24 +993,21 @@ class Model(Lister, BaseClient):
         >>> from clarifai.client.model import Model
         >>> model = Model("https://clarifai.com/openai/chat-completion/models/GPT-4")
         >>> stream_response = model.stream_by_bytes(iter([b'Write a tweet on future of AI']),
-                                                    input_type='text',
                                                     deployment_id='deployment_id',
                                                     inference_params=dict(temperature=str(0.7), max_tokens=30)))
         >>> list_stream_response = [response for response in stream_response]
     """
-    if input_type not in {'image', 'text', 'video', 'audio'}:
-      raise UserError(
-          f"Got input type {input_type} but expected one of image, text, video, audio.")
+    self._check_predict_input_type(input_type)
 
     def input_generator():
       for input_bytes in input_bytes_iterator:
-        if input_type == "image":
+        if self.input_types[0] == "image":
           yield [Inputs.get_input_from_bytes("", image_bytes=input_bytes)]
-        elif input_type == "text":
+        elif self.input_types[0] == "text":
           yield [Inputs.get_input_from_bytes("", text_bytes=input_bytes)]
-        elif input_type == "video":
+        elif self.input_types[0] == "video":
           yield [Inputs.get_input_from_bytes("", video_bytes=input_bytes)]
-        elif input_type == "audio":
+        elif self.input_types[0] == "audio":
           yield [Inputs.get_input_from_bytes("", audio_bytes=input_bytes)]
 
     if deployment_id and (compute_cluster_id or nodepool_id):
@@ -1000,7 +1030,7 @@ class Model(Lister, BaseClient):
 
   def stream_by_url(self,
                     url_iterator: Iterator[str],
-                    input_type: str,
+                    input_type: str = None,
                     compute_cluster_id: str = None,
                     nodepool_id: str = None,
                     deployment_id: str = None,
@@ -1010,7 +1040,7 @@ class Model(Lister, BaseClient):
 
     Args:
         url_iterator (Iterator[str]): Iterator of URLs 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.
         compute_cluster_id (str): The compute cluster ID to use for the model.
         nodepool_id (str): The nodepool ID to use for the model.
         deployment_id (str): The deployment ID to use for the model.
@@ -1023,22 +1053,20 @@ class Model(Lister, BaseClient):
     Example:
         >>> from clarifai.client.model import Model
         >>> model = Model("url")
-        >>> stream_response = model.stream_by_url(iter(['url']), 'image', deployment_id='deployment_id')
+        >>> stream_response = model.stream_by_url(iter(['url']), deployment_id='deployment_id')
         >>> list_stream_response = [response for response in stream_response]
     """
-    if input_type not in {'image', 'text', 'video', 'audio'}:
-      raise UserError(
-          f"Got input type {input_type} but expected one of image, text, video, audio.")
+    self._check_predict_input_type(input_type)
 
     def input_generator():
       for url in url_iterator:
-        if input_type == "image":
+        if self.input_types[0] == "image":
           yield [Inputs.get_input_from_url("", image_url=url)]
-        elif input_type == "text":
+        elif self.input_types[0] == "text":
           yield [Inputs.get_input_from_url("", text_url=url)]
-        elif input_type == "video":
+        elif self.input_types[0] == "video":
           yield [Inputs.get_input_from_url("", video_url=url)]
-        elif input_type == "audio":
+        elif self.input_types[0] == "audio":
           yield [Inputs.get_input_from_url("", audio_url=url)]
 
     if deployment_id and (compute_cluster_id or nodepool_id):