clarifai 9.7.0__py3-none-any.whl → 9.7.2__py3-none-any.whl

clarifai/client/lister.py

@@ -0,0 +1,41 @@
+from typing import Any, Callable, Dict, Generator
+
+from clarifai_grpc.grpc.api.status import status_code_pb2
+from google.protobuf.json_format import MessageToDict
+
+from clarifai.client.base import BaseClient
+
+
+class Lister(BaseClient):
+  """Lister class for obtaining paginated results from the Clarifai API."""
+
+  def __init__(self, page_size: int = 16):
+    self.default_page_size = page_size
+
+  def list_all_pages_generator(
+      self, endpoint: Callable, proto_message: Any,
+      request_data: Dict[str, Any]) -> Generator[Dict[str, Any], None, None]:
+    """Lists all pages of a resource.
+
+    Args:
+        endpoint (Callable): The endpoint to call.
+        proto_message (Any): The proto message to use.
+        request_data (dict): The request data to use.
+
+    Yields:
+        response_dict: The next item in the listing.
+    """
+    page = 1
+    while True:
+      request_data['page'] = page
+      response = self._grpc_request(endpoint, proto_message(**request_data))
+      dict_response = MessageToDict(response, preserving_proto_field_name=True)
+      if response.status.code != status_code_pb2.SUCCESS:
+        raise Exception(f"Listing failed with response {response!r}")
+      if len(list(dict_response.keys())) == 1:
+        break
+      else:
+        listing_resource = list(dict_response.keys())[1]
+        for item in dict_response[listing_resource]:
+          yield self.process_response_keys(item, listing_resource[:-1])
+      page += 1

clarifai/client/model.py

@@ -0,0 +1,218 @@
+import os
+import time
+from typing import Dict, 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 clarifai.client.base import BaseClient
+from clarifai.client.lister import Lister
+from clarifai.errors import UserError
+from clarifai.urls.helper import ClarifaiUrlHelper
+from clarifai.utils.logging import get_logger
+from clarifai.utils.misc import BackoffIterator
+
+
+class Model(Lister, BaseClient):
+  """Model is a class that provides access to Clarifai API endpoints related to Model information."""
+
+  def __init__(self,
+               url_init: str = "",
+               model_id: str = "",
+               model_version: Dict = {'id': ""},
+               output_config: Dict = {'min_value': 0},
+               **kwargs):
+    """Initializes a Model object.
+
+    Args:
+        url_init (str): The URL to initialize the model object.
+        model_id (str): The Model ID to interact with.
+        model_version (dict): The Model Version to interact with.
+        output_config (dict): The output config to interact with.
+          min_value (float): The minimum value of the prediction confidence to filter.
+          max_concepts (int): The maximum number of concepts to return.
+          select_concepts (list[Concept]): The concepts to select.
+          sample_ms (int): The number of milliseconds to sample.
+        **kwargs: Additional keyword arguments to be passed to the ClarifaiAuthHelper.
+    """
+    if url_init != "" and model_id != "":
+      raise UserError("You can only specify one of url_init or model_id.")
+    if url_init == "" and model_id == "":
+      raise UserError("You must specify one of url_init or model_id.")
+    if url_init != "":
+      user_id, app_id, _, model_id, model_version_id = ClarifaiUrlHelper.split_clarifai_url(
+          url_init)
+      model_version = {'id': model_version_id}
+      kwargs = {'user_id': user_id, 'app_id': app_id}
+    self.kwargs = {**kwargs, 'id': model_id, 'model_version': model_version,
+                   'output_info': {'output_config': output_config}}
+    self.model_info = resources_pb2.Model(**self.kwargs)
+    self.logger = get_logger(logger_level="INFO")
+    BaseClient.__init__(self, user_id=self.user_id, app_id=self.app_id)
+    Lister.__init__(self)
+
+  def predict(self, inputs: List[Input]):
+    """Predicts the model based on the given inputs.
+
+    Args:
+        inputs (list[Input]): The inputs to predict, must be less than 128.
+    """
+    if len(inputs) > 128:
+      raise UserError("Too many inputs. Max is 128.")  # TODO Use Chunker for inputs len > 128
+
+    request = service_pb2.PostModelOutputsRequest(
+        user_app_id=self.user_app_id,
+        model_id=self.id,
+        version_id=self.model_version.id,
+        inputs=inputs,
+        model=self.model_info)
+
+    start_time = time.time()
+    backoff_iterator = BackoffIterator()
+    while True:
+      response = self._grpc_request(self.STUB.PostModelOutputs, request)
+
+      if response.outputs and \
+        response.outputs[0].status.code == status_code_pb2.MODEL_DEPLOYING and \
+        time.time() - start_time < 60 * 10: # 10 minutes
+        self.logger.info(f"{self.id} model is still deploying, please wait...")
+        time.sleep(next(backoff_iterator))
+        continue
+
+      if response.status.code != status_code_pb2.SUCCESS:
+        raise Exception(f"Model Predict failed with response {response.status!r}")
+      else:
+        break
+
+    return response
+
+  def predict_by_filepath(self, filepath: str, input_type: str):
+    """Predicts the model 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.
+
+    Example:
+        >>> from clarifai.client.model import Model
+        >>> 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_prediction = model.predict_by_filepath('/path/to/image.jpg', 'image')
+        >>> model_prediction = model.predict_by_filepath('/path/to/text.txt', 'text')
+    """
+    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):
+      raise UserError('Invalid filepath.')
+
+    with open(filepath, "rb") as f:
+      file_bytes = f.read()
+
+    return self.predict_by_bytes(file_bytes, input_type)
+
+  def predict_by_bytes(self, input_bytes: bytes, input_type: str):
+    """Predicts the model based on the given bytes.
+
+    Args:
+        input_bytes (bytes): File Bytes to predict on.
+        input_type (str): The type of input. Can be 'image', 'text', 'video' or 'audio'.
+
+    Example:
+        >>> from clarifai.client.model import Model
+        >>> model = Model("https://clarifai.com/anthropic/completion/models/claude-v2")
+        >>> model_prediction = model.predict_by_bytes(b'Write a tweet on future of AI', 'text')
+    """
+    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):
+      raise UserError('Invalid bytes.')
+    # TODO will obtain proto from input class
+    if input_type == "image":
+      input_proto = resources_pb2.Input(
+          data=resources_pb2.Data(image=resources_pb2.Image(base64=input_bytes)))
+    elif input_type == "text":
+      input_proto = resources_pb2.Input(
+          data=resources_pb2.Data(text=resources_pb2.Text(raw=input_bytes)))
+    elif input_type == "video":
+      input_proto = resources_pb2.Input(
+          data=resources_pb2.Data(video=resources_pb2.Video(base64=input_bytes)))
+    elif input_type == "audio":
+      input_proto = resources_pb2.Input(
+          data=resources_pb2.Data(audio=resources_pb2.Audio(base64=input_bytes)))
+
+    return self.predict(inputs=[input_proto])
+
+  def predict_by_url(self, url: str, input_type: str):
+    """Predicts the model 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.
+
+    Example:
+        >>> from clarifai.client.model import Model
+        >>> 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_prediction = model.predict_by_url('url', 'image')
+    """
+    if input_type not in {'image', 'text', 'video', 'audio'}:
+      raise UserError('Invalid input type it should be image, text, video or audio.')
+    # TODO will be obtain proto from input class
+    if input_type == "image":
+      input_proto = resources_pb2.Input(
+          data=resources_pb2.Data(image=resources_pb2.Image(url=url)))
+    elif input_type == "text":
+      input_proto = resources_pb2.Input(data=resources_pb2.Data(text=resources_pb2.Text(url=url)))
+    elif input_type == "video":
+      input_proto = resources_pb2.Input(
+          data=resources_pb2.Data(video=resources_pb2.Video(url=url)))
+    elif input_type == "audio":
+      input_proto = resources_pb2.Input(
+          data=resources_pb2.Data(audio=resources_pb2.Audio(url=url)))
+
+    return self.predict(inputs=[input_proto])
+
+  def list_versions(self) -> List['Model']:
+    """Lists all the versions for the model.
+
+    Returns:
+        List[Model]: A list of Model objects for the versions of the model.
+
+    Example:
+        >>> from clarifai.client.model import Model
+        >>> 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')
+        >>> all_model_versions = model.list_versions()
+    """
+    request_data = dict(
+        user_app_id=self.user_app_id,
+        model_id=self.id,
+        per_page=self.default_page_size,
+    )
+    all_model_versions_info = list(
+        self.list_all_pages_generator(self.STUB.ListModelVersions,
+                                      service_pb2.ListModelVersionsRequest, request_data))
+
+    for model_version_info in all_model_versions_info:
+      model_version_info['id'] = model_version_info['model_version_id']
+      del model_version_info['model_version_id']
+
+    return [
+        Model(model_id=self.id, **dict(self.kwargs, model_version=model_version_info))
+        for model_version_info in all_model_versions_info
+    ]
+
+  def __getattr__(self, name):
+    return getattr(self.model_info, name)
+
+  def __str__(self):
+    init_params = [param for param in self.kwargs.keys()]
+    attribute_strings = [
+        f"{param}={getattr(self.model_info, param)}" for param in init_params
+        if hasattr(self.model_info, param)
+    ]
+    return f"Model Details: \n{', '.join(attribute_strings)}\n"

clarifai/client/module.py

@@ -0,0 +1,82 @@
+from typing import Dict, List
+
+from clarifai_grpc.grpc.api import resources_pb2, service_pb2
+
+from clarifai.client.base import BaseClient
+from clarifai.client.lister import Lister
+from clarifai.errors import UserError
+from clarifai.urls.helper import ClarifaiUrlHelper
+from clarifai.utils.logging import get_logger
+
+
+class Module(Lister, BaseClient):
+  """Module is a class that provides access to Clarifai API endpoints related to Module information."""
+
+  def __init__(self,
+               url_init: str = "",
+               module_id: str = "",
+               module_version: Dict = {'id': ""},
+               **kwargs):
+    """Initializes a Module object.
+
+        Args:
+            url_init (str): The URL to initialize the module object.
+            module_id (str): The Module ID to interact with.
+            module_version (dict): The Module Version to interact with.
+            **kwargs: Additional keyword arguments to be passed to the ClarifaiAuthHelper.
+        """
+    if url_init != "" and module_id != "":
+      raise UserError("You can only specify one of url_init or module_id.")
+    if url_init == "" and module_id == "":
+      raise UserError("You must specify one of url_init or module_id.")
+    if url_init != "":
+      user_id, app_id, module_id, module_version_id = ClarifaiUrlHelper.split_module_ui_url(
+          url_init)
+      module_version = {'id': module_version_id}
+      kwargs = {'user_id': user_id, 'app_id': app_id}
+
+    self.kwargs = {**kwargs, 'id': module_id, 'module_version': module_version}
+    self.module_info = resources_pb2.Module(**self.kwargs)
+    self.logger = get_logger(logger_level="INFO")
+    BaseClient.__init__(self, user_id=self.user_id, app_id=self.app_id)
+    Lister.__init__(self)
+
+  def list_versions(self) -> List['Module']:
+    """Lists all the module versions for the module.
+
+        Returns:
+            List[Moudle]: A list of Module objects for versions of the module.
+
+        Example:
+            >>> from clarifai.client.module import Module
+            >>> module = Module(module_id='module_id', user_id='user_id', app_id='app_id')
+            >>> all_Module_versions = module.list_versions()
+        """
+    request_data = dict(
+        user_app_id=self.user_app_id,
+        module_id=self.id,
+        per_page=self.default_page_size,
+    )
+    all_module_versions_info = list(
+        self.list_all_pages_generator(self.STUB.ListModuleVersions,
+                                      service_pb2.ListModuleVersionsRequest, request_data))
+
+    for module_version_info in all_module_versions_info:
+      module_version_info['id'] = module_version_info['module_version_id']
+      del module_version_info['module_version_id']
+
+    return [
+        Module(module_id=self.id, **dict(self.kwargs, module_version=module_version_info))
+        for module_version_info in all_module_versions_info
+    ]
+
+  def __getattr__(self, name):
+    return getattr(self.module_info, name)
+
+  def __str__(self):
+    init_params = [param for param in self.kwargs.keys()]
+    attribute_strings = [
+        f"{param}={getattr(self.module_info, param)}" for param in init_params
+        if hasattr(self.module_info, param)
+    ]
+    return f"Module Details: \n{', '.join(attribute_strings)}\n"

clarifai/client/user.py

@@ -0,0 +1,125 @@
+from typing import Any, Dict, List
+
+from clarifai_grpc.grpc.api import resources_pb2, service_pb2  # noqa: F401
+from clarifai_grpc.grpc.api.status import status_code_pb2
+
+from clarifai.client.app import App
+from clarifai.client.base import BaseClient
+from clarifai.client.lister import Lister
+from clarifai.utils.logging import get_logger
+
+
+class User(Lister, BaseClient):
+  """User is a class that provides access to Clarifai API endpoints related to user information."""
+
+  def __init__(self, user_id: str = "", **kwargs):
+    """Initializes an User object.
+
+    Args:
+        user_id (str): The user ID for the user to interact with.
+        **kwargs: Additional keyword arguments to be passed to the ClarifaiAuthHelper.
+    """
+    self.kwargs = {**kwargs, 'id': user_id}
+    self.user_info = resources_pb2.User(**self.kwargs)
+    self.logger = get_logger(logger_level="INFO", name=__name__)
+    BaseClient.__init__(self, user_id=self.id, app_id="")
+    Lister.__init__(self)
+
+  def list_apps(self, filter_by: Dict[str, Any] = {}) -> List[App]:
+    """Lists all the apps for the user.
+
+    Args:
+        filter_by (dict): A dictionary of filters to be applied to the list of apps.
+
+    Returns:
+        list of App: A list of App objects for the user.
+
+    Example:
+        >>> from clarifai.client.user import User
+        >>> apps = User("user_id").list_apps()
+    """
+    request_data = dict(user_app_id=self.user_app_id, per_page=self.default_page_size, **filter_by)
+    all_apps_info = list(
+        self.list_all_pages_generator(self.STUB.ListApps, service_pb2.ListAppsRequest,
+                                      request_data))
+
+    return [App(**app_info) for app_info in all_apps_info]
+
+  def create_app(self, app_id: str, base_workflow: str = 'Language-Understanding',
+                 **kwargs) -> App:
+    """Creates an app for the user.
+
+    Args:
+        app_id (str): The app ID for the app to create.
+        base_workflow (str): The base workflow to use for the app.(Examples: 'Universal', 'Empty', 'General')
+        **kwargs: Additional keyword arguments to be passed to the App.
+
+    Returns:
+        App: An App object for the specified app ID.
+
+    Example:
+        >>> from clarifai.client.user import User
+        >>> client = User(user_id="user_id")
+        >>> app = client.create_app(app_id="app_id",base_workflow="Universal")
+    """
+    workflow = resources_pb2.Workflow(id=base_workflow, app_id="main", user_id="clarifai")
+    request = service_pb2.PostAppsRequest(
+        user_app_id=self.user_app_id,
+        apps=[resources_pb2.App(id=app_id, default_workflow=workflow, **kwargs)])
+    response = self._grpc_request(self.STUB.PostApps, request)
+    if response.status.code != status_code_pb2.SUCCESS:
+      raise Exception(response.status)
+    self.logger.info("\nApp created\n%s", response.status)
+    kwargs.update({'user_id': self.id})
+    return App(app_id=app_id, **kwargs)
+
+  def app(self, app_id: str, **kwargs) -> App:
+    """Returns an App object for the specified app ID.
+
+    Args:
+        app_id (str): The app ID for the app to interact with.
+        **kwargs: Additional keyword arguments to be passed to the App.
+
+    Returns:
+        App: An App object for the specified app ID.
+
+    Example:
+        >>> from clarifai.client.user import User
+        >>> app = User("user_id").app("app_id")
+    """
+    request = service_pb2.GetAppRequest(
+        user_app_id=resources_pb2.UserAppIDSet(user_id=self.id, app_id=app_id))
+    response = self._grpc_request(self.STUB.GetApp, request)
+    if response.status.code != status_code_pb2.SUCCESS:
+      raise Exception(response.status)
+
+    kwargs['user_id'] = self.id
+    return App(app_id=app_id, **kwargs)
+
+  def delete_app(self, app_id: str) -> None:
+    """Deletes an app for the user.
+
+    Args:
+        app_id (str): The app ID for the app to delete.
+
+    Example:
+        >>> from clarifai.client.user import User
+        >>> user = User("user_id").delete_app("app_id")
+    """
+    request = service_pb2.DeleteAppRequest(
+        user_app_id=resources_pb2.UserAppIDSet(user_id=self.id, app_id=app_id))
+    response = self._grpc_request(self.STUB.DeleteApp, request)
+    if response.status.code != status_code_pb2.SUCCESS:
+      raise Exception(response.status)
+    self.logger.info("\nApp Deleted\n%s", response.status)
+
+  def __getattr__(self, name):
+    return getattr(self.user_info, name)
+
+  def __str__(self):
+    init_params = [param for param in self.kwargs.keys()]
+    attribute_strings = [
+        f"{param}={getattr(self.user_info, param)}" for param in init_params
+        if hasattr(self.user_info, param)
+    ]
+    return f"Clarifai User Details: \n{', '.join(attribute_strings)}\n"

clarifai/client/workflow.py

@@ -0,0 +1,194 @@
+import os
+from typing import Dict, 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 clarifai.client.base import BaseClient
+from clarifai.client.lister import Lister
+from clarifai.errors import UserError
+from clarifai.urls.helper import ClarifaiUrlHelper
+from clarifai.utils.logging import get_logger
+
+
+class Workflow(Lister, BaseClient):
+  """Workflow is a class that provides access to Clarifai API endpoints related to Workflow information."""
+
+  def __init__(self,
+               url_init: str = "",
+               workflow_id: str = "",
+               workflow_version: Dict = {'id': ""},
+               output_config: Dict = {'min_value': 0},
+               **kwargs):
+    """Initializes a Workflow object.
+
+    Args:
+        url_init (str): The URL to initialize the workflow object.
+        workflow_id (str): The Workflow ID to interact with.
+        workflow_version (dict): The Workflow Version to interact with.
+        output_config (dict): The output config to interact with.
+          min_value (float): The minimum value of the prediction confidence to filter.
+          max_concepts (int): The maximum number of concepts to return.
+          select_concepts (list[Concept]): The concepts to select.
+          sample_ms (int): The number of milliseconds to sample.
+        **kwargs: Additional keyword arguments to be passed to the ClarifaiAuthHelper.
+    """
+    if url_init != "" and workflow_id != "":
+      raise UserError("You can only specify one of url_init or workflow_id.")
+    if url_init == "" and workflow_id == "":
+      raise UserError("You must specify one of url_init or workflow_id.")
+    if url_init != "":
+      user_id, app_id, _, workflow_id, workflow_version_id = ClarifaiUrlHelper.split_clarifai_url(
+          url_init)
+      workflow_version = {'id': workflow_version_id}
+      kwargs = {'user_id': user_id, 'app_id': app_id}
+    self.kwargs = {**kwargs, 'id': workflow_id, 'version': workflow_version}
+    self.output_config = output_config
+    self.workflow_info = resources_pb2.Workflow(**self.kwargs)
+    self.logger = get_logger(logger_level="INFO")
+    BaseClient.__init__(self, user_id=self.user_id, app_id=self.app_id)
+    Lister.__init__(self)
+
+  def predict(self, inputs: List[Input]):
+    """Predicts the workflow based on the given inputs.
+
+    Args:
+        inputs (list[Input]): The inputs to predict.
+    """
+    if len(inputs) > 128:
+      raise UserError("Too many inputs. Max is 128.")  # TODO Use Chunker for inputs len > 128
+    request = service_pb2.PostWorkflowResultsRequest(
+        user_app_id=self.user_app_id,
+        workflow_id=self.id,
+        version_id=self.version.id,
+        inputs=inputs,
+        output_config=self.output_config)
+
+    response = self._grpc_request(self.STUB.PostWorkflowResults, request)
+    if response.status.code != status_code_pb2.SUCCESS:
+      raise Exception(f"Workflow Predict failed with response {response.status!r}")
+
+    return response
+
+  def predict_by_filepath(self, filepath: str, input_type: str):
+    """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.
+
+    Example:
+        >>> from clarifai.client.workflow import Workflow
+        >>> 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')
+    """
+    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):
+      raise UserError('Invalid filepath.')
+
+    with open(filepath, "rb") as f:
+      file_bytes = f.read()
+
+    return self.predict_by_bytes(file_bytes, input_type)
+
+  def predict_by_bytes(self, input_bytes: bytes, input_type: str):
+    """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.
+    """
+    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):
+      raise UserError('Invalid bytes.')
+
+    if input_type == "image":
+      input_proto = resources_pb2.Input(
+          data=resources_pb2.Data(image=resources_pb2.Image(base64=input_bytes)))
+    elif input_type == "text":
+      input_proto = resources_pb2.Input(
+          data=resources_pb2.Data(text=resources_pb2.Text(raw=input_bytes)))
+    elif input_type == "video":
+      input_proto = resources_pb2.Input(
+          data=resources_pb2.Data(video=resources_pb2.Video(base64=input_bytes)))
+    elif input_type == "audio":
+      input_proto = resources_pb2.Input(
+          data=resources_pb2.Data(audio=resources_pb2.Audio(base64=input_bytes)))
+
+    return self.predict(inputs=[input_proto])
+
+  def predict_by_url(self, url: str, input_type: str):
+    """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.
+
+    Example:
+        >>> from clarifai.client.workflow import Workflow
+        >>> 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')
+    """
+    if input_type not in {'image', 'text', 'video', 'audio'}:
+      raise UserError('Invalid input type it should be image, text, video or audio.')
+
+    if input_type == "image":
+      input_proto = resources_pb2.Input(
+          data=resources_pb2.Data(image=resources_pb2.Image(url=url)))
+    elif input_type == "text":
+      input_proto = resources_pb2.Input(data=resources_pb2.Data(text=resources_pb2.Text(url=url)))
+    elif input_type == "video":
+      input_proto = resources_pb2.Input(
+          data=resources_pb2.Data(video=resources_pb2.Video(url=url)))
+    elif input_type == "audio":
+      input_proto = resources_pb2.Input(
+          data=resources_pb2.Data(audio=resources_pb2.Audio(url=url)))
+
+    return self.predict(inputs=[input_proto])
+
+  def list_versions(self) -> List['Workflow']:
+    """Lists all the versions of the workflow.
+
+    Returns:
+        list[Workflow]: A list of Workflow objects.
+
+    Example:
+        >>> from clarifai.client.workflow import Workflow
+        >>> workflow = Workflow(user_id='user_id', app_id='app_id', workflow_id='workflow_id')
+        >>> workflow_versions = workflow.list_versions()
+    """
+    request_data = dict(
+        user_app_id=self.user_app_id,
+        workflow_id=self.id,
+        per_page=self.default_page_size,
+    )
+    all_workflow_versions_info = list(
+        self.list_all_pages_generator(self.STUB.ListWorkflowVersions,
+                                      service_pb2.ListWorkflowVersionsRequest, request_data))
+
+    for workflow_version_info in all_workflow_versions_info:
+      workflow_version_info['id'] = workflow_version_info['workflow_version_id']
+      del workflow_version_info['workflow_version_id']
+
+    return [
+        Workflow(workflow_id=self.id, **dict(self.kwargs, version=workflow_version_info))
+        for workflow_version_info in all_workflow_versions_info
+    ]
+
+  def __getattr__(self, name):
+    return getattr(self.workflow_info, name)
+
+  def __str__(self):
+    init_params = [param for param in self.kwargs.keys()]
+    attribute_strings = [
+        f"{param}={getattr(self.workflow_info, param)}" for param in init_params
+        if hasattr(self.workflow_info, param)
+    ]
+    return f"Workflow Details: \n{', '.join(attribute_strings)}\n"