clarifai 10.10.1__tar.gz → 10.11.1__tar.gz

{clarifai-10.10.1/clarifai.egg-info → clarifai-10.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: clarifai
-Version: 10.10.1
+Version: 10.11.1
 Summary: Clarifai Python SDK
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
@@ -20,8 +20,8 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: clarifai-grpc>=10.9.11
-Requires-Dist: clarifai-protocol>=0.0.6
+Requires-Dist: clarifai-grpc>=10.11.2
+Requires-Dist: clarifai-protocol>=0.0.14
 Requires-Dist: numpy>=1.22.0
 Requires-Dist: tqdm>=4.65.0
 Requires-Dist: tritonclient>=2.34.0
@@ -31,7 +31,6 @@ Requires-Dist: schema==0.7.5
 Requires-Dist: Pillow>=9.5.0
 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
@@ -73,6 +72,10 @@ Give the repo a star ⭐
 
 * **[Installation](#rocket-installation)**
 * **[Getting Started](#memo-getting-started)**
+* **[Compute Orchestration](#rocket-compute-orchestration)**
+  * [Cluster Operations](#cluster-operations)
+  * [Nodepool Operations](#nodepool-operations)
+  * [Depolyment Operations](#deployment-operations)
 * **[Interacting with Datasets](#floppy_disk-interacting-with-datasets)**
 * **[Interacting with Inputs](#floppy_disk-interacting-with-inputs)**
   * [Input Upload](#input-upload)
@@ -157,6 +160,73 @@ client = User(user_id="user_id", pat="your personal access token")
 ```
 
 
+## :rocket: Compute Orchestration
+
+Clarifai’s Compute Orchestration offers a streamlined solution for managing the infrastructure required for training, deploying, and scaling machine learning models and workflows.
+
+This flexible system supports any compute instance — across various hardware providers and deployment methods — and provides automatic scaling to match workload demands. [More Details](https://www.clarifai.com/products/compute-orchestration)
+
+#### Cluster Operations
+```python
+from clarifai.client.user import User
+client = User(user_id="user_id",base_url="https://api.clarifai.com")
+
+# Create a new compute cluster
+compute_cluster = client.create_compute_cluster(compute_cluster_id="demo-id",config_filepath="computer_cluster_config.yaml")
+
+# List Clusters
+all_compute_clusters = list(client.list_compute_clusters())
+print(all_compute_clusters)
+```
+##### [Example Cluster Config](https://github.com/Clarifai/examples/blob/main/ComputeOrchestration/configs/compute_cluster_config.yaml)
+
+
+
+#### Nodepool Operations
+```python
+from clarifai.client.compute_cluster import ComputeCluster
+
+# Initialize the ComputeCluster instance
+compute_cluster = ComputeCluster(user_id="user_id",compute_cluster_id="demo-id")
+
+# Create a new nodepool
+nodepool = compute_cluster.create_nodepool(nodepool_id="demo-nodepool-id",config_filepath="nodepool_config.yaml")
+
+#Get a nodepool
+nodepool = compute_cluster.nodepool(nodepool_id="demo-nodepool-id")
+print(nodepool)
+
+# List nodepools
+all_nodepools = list(compute_cluster.list_nodepools())
+print(all_nodepools)
+```
+##### [Example Nodepool config](https://github.com/Clarifai/examples/blob/main/ComputeOrchestration/configs/nodepool_config.yaml)
+
+#### Deployment Operations
+```python
+from clarifai.client.nodepool import Nodepool
+
+# Initialize the Nodepool instance
+nodepool = Nodepool(user_id="user_id",nodepool_id="demo-nodepool-id")
+
+# Create a new deployment
+deployment = nodepool.create_deployment(deployment_id="demo-deployment-id",config_filepath="deployment_config.yaml")
+
+#Get a deployment
+deployment = nodepool.deployment(nodepool_id="demo-deployment-id")
+print(deployment)
+
+# List deployments
+all_deployments = list(nodepool.list_deployments())
+print(all_deployments)
+
+```
+##### [Example Deployment config](https://github.com/Clarifai/examples/blob/main/ComputeOrchestration/configs/deployment_config.yaml)
+
+#### Compute Orchestration CLI Operations
+Refer Here: https://github.com/Clarifai/clarifai-python/tree/master/clarifai/cli
+
+
 ## :floppy_disk: Interacting with Datasets
 
 Clarifai datasets help in managing datasets used for model training and evaluation. It provides functionalities like creating datasets,uploading datasets, retrying failed uploads from logs and exporting datasets as .zip files.

{clarifai-10.10.1 → clarifai-10.11.1}/README.md

@@ -34,6 +34,10 @@ Give the repo a star ⭐
 
 * **[Installation](#rocket-installation)**
 * **[Getting Started](#memo-getting-started)**
+* **[Compute Orchestration](#rocket-compute-orchestration)**
+  * [Cluster Operations](#cluster-operations)
+  * [Nodepool Operations](#nodepool-operations)
+  * [Depolyment Operations](#deployment-operations)
 * **[Interacting with Datasets](#floppy_disk-interacting-with-datasets)**
 * **[Interacting with Inputs](#floppy_disk-interacting-with-inputs)**
   * [Input Upload](#input-upload)
@@ -118,6 +122,73 @@ client = User(user_id="user_id", pat="your personal access token")
 ```
 
 
+## :rocket: Compute Orchestration
+
+Clarifai’s Compute Orchestration offers a streamlined solution for managing the infrastructure required for training, deploying, and scaling machine learning models and workflows.
+
+This flexible system supports any compute instance — across various hardware providers and deployment methods — and provides automatic scaling to match workload demands. [More Details](https://www.clarifai.com/products/compute-orchestration)
+
+#### Cluster Operations
+```python
+from clarifai.client.user import User
+client = User(user_id="user_id",base_url="https://api.clarifai.com")
+
+# Create a new compute cluster
+compute_cluster = client.create_compute_cluster(compute_cluster_id="demo-id",config_filepath="computer_cluster_config.yaml")
+
+# List Clusters
+all_compute_clusters = list(client.list_compute_clusters())
+print(all_compute_clusters)
+```
+##### [Example Cluster Config](https://github.com/Clarifai/examples/blob/main/ComputeOrchestration/configs/compute_cluster_config.yaml)
+
+
+
+#### Nodepool Operations
+```python
+from clarifai.client.compute_cluster import ComputeCluster
+
+# Initialize the ComputeCluster instance
+compute_cluster = ComputeCluster(user_id="user_id",compute_cluster_id="demo-id")
+
+# Create a new nodepool
+nodepool = compute_cluster.create_nodepool(nodepool_id="demo-nodepool-id",config_filepath="nodepool_config.yaml")
+
+#Get a nodepool
+nodepool = compute_cluster.nodepool(nodepool_id="demo-nodepool-id")
+print(nodepool)
+
+# List nodepools
+all_nodepools = list(compute_cluster.list_nodepools())
+print(all_nodepools)
+```
+##### [Example Nodepool config](https://github.com/Clarifai/examples/blob/main/ComputeOrchestration/configs/nodepool_config.yaml)
+
+#### Deployment Operations
+```python
+from clarifai.client.nodepool import Nodepool
+
+# Initialize the Nodepool instance
+nodepool = Nodepool(user_id="user_id",nodepool_id="demo-nodepool-id")
+
+# Create a new deployment
+deployment = nodepool.create_deployment(deployment_id="demo-deployment-id",config_filepath="deployment_config.yaml")
+
+#Get a deployment
+deployment = nodepool.deployment(nodepool_id="demo-deployment-id")
+print(deployment)
+
+# List deployments
+all_deployments = list(nodepool.list_deployments())
+print(all_deployments)
+
+```
+##### [Example Deployment config](https://github.com/Clarifai/examples/blob/main/ComputeOrchestration/configs/deployment_config.yaml)
+
+#### Compute Orchestration CLI Operations
+Refer Here: https://github.com/Clarifai/clarifai-python/tree/master/clarifai/cli
+
+
 ## :floppy_disk: Interacting with Datasets
 
 Clarifai datasets help in managing datasets used for model training and evaluation. It provides functionalities like creating datasets,uploading datasets, retrying failed uploads from logs and exporting datasets as .zip files.

clarifai-10.11.1/clarifai/__init__.py

@@ -0,0 +1 @@
+__version__ = "10.11.1"

clarifai-10.11.1/clarifai/cli/model.py

@@ -0,0 +1,266 @@
+import click
+
+from clarifai.cli.base import cli
+
+
+@cli.group(['model'])
+def model():
+  """Manage models: upload, test locally, run_locally, predict"""
+  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.')
+@click.option(
+    '--mode',
+    type=click.Choice(['env', 'container'], case_sensitive=False),
+    default='env',
+    show_default=True,
+    help=
+    'Specify how to test the model locally: "env" for virtual environment or "container" for Docker container. Defaults to "env".'
+)
+@click.option(
+    '--keep_env',
+    is_flag=True,
+    help=
+    'Keep the virtual environment after testing the model locally (applicable for virtualenv mode). Defaults to False.'
+)
+@click.option(
+    '--keep_image',
+    is_flag=True,
+    help=
+    'Keep the Docker image after testing the model locally (applicable for container mode). Defaults to False.'
+)
+def test_locally(model_path, keep_env=False, keep_image=False, mode='env'):
+  """Test model locally."""
+  try:
+    from clarifai.runners.models import model_run_locally
+    if mode == 'env' and keep_image:
+      raise ValueError("'keep_image' is applicable only for 'container' mode")
+    if mode == 'container' and keep_env:
+      raise ValueError("'keep_env' is applicable only for 'env' mode")
+
+    if mode == "env":
+      click.echo("Testing model locally in a virtual environment...")
+      model_run_locally.main(model_path, run_model_server=False, keep_env=keep_env)
+    elif mode == "container":
+      click.echo("Testing model locally inside a container...")
+      model_run_locally.main(
+          model_path, inside_container=True, run_model_server=False, keep_image=keep_image)
+    click.echo("Model tested successfully.")
+  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.')
+@click.option(
+    '--port',
+    '-p',
+    type=int,
+    default=8000,
+    show_default=True,
+    help="The port to host the gRPC server for running the model locally. Defaults to 8000.")
+@click.option(
+    '--mode',
+    type=click.Choice(['env', 'container'], case_sensitive=False),
+    default='env',
+    show_default=True,
+    help=
+    'Specifies how to run the model: "env" for virtual environment or "container" for Docker container. Defaults to "env".'
+)
+@click.option(
+    '--keep_env',
+    is_flag=True,
+    help=
+    'Keep the virtual environment after testing the model locally (applicable for virtualenv mode). Defaults to False.'
+)
+@click.option(
+    '--keep_image',
+    is_flag=True,
+    help=
+    'Keep the Docker image after testing the model locally (applicable for container mode). Defaults to False.'
+)
+def run_locally(model_path, port, mode, keep_env, keep_image):
+  """Run the model locally and start a gRPC server to serve the model."""
+  try:
+    from clarifai.runners.models import model_run_locally
+    if mode == 'env' and keep_image:
+      raise ValueError("'keep_image' is applicable only for 'container' mode")
+    if mode == 'container' and keep_env:
+      raise ValueError("'keep_env' is applicable only for 'env' mode")
+
+    if mode == "env":
+      click.echo("Running model locally in a virtual environment...")
+      model_run_locally.main(model_path, run_model_server=True, keep_env=keep_env, port=port)
+    elif mode == "container":
+      click.echo("Running model locally inside a container...")
+      model_run_locally.main(
+          model_path,
+          inside_container=True,
+          run_model_server=True,
+          port=port,
+          keep_image=keep_image)
+    click.echo(f"Model server started locally from {model_path} in {mode} mode.")
+  except Exception as e:
+    click.echo(f"Failed to starts model server locally: {e}", err=True)
+
+
+@model.command()
+@click.option(
+    '--config',
+    type=click.Path(exists=True),
+    required=False,
+    help='Path to the model predict config file.')
+@click.option('--model_id', required=False, help='Model ID of the model used to predict.')
+@click.option('--user_id', required=False, help='User ID of the model used to predict.')
+@click.option('--app_id', required=False, help='App ID of the model used to predict.')
+@click.option('--model_url', required=False, help='Model URL of the model used to predict.')
+@click.option('--file_path', required=False, help='File path of file for the model to predict')
+@click.option('--url', required=False, help='URL to the file for the model to predict')
+@click.option('--bytes', required=False, help='Bytes to the file for the model to predict')
+@click.option(
+    '--input_id', required=False, help='Existing input id in the app for the model to predict')
+@click.option('--input_type', required=False, help='Type of input')
+@click.option(
+    '-cc_id',
+    '--compute_cluster_id',
+    required=False,
+    help='Compute Cluster ID to use for the model')
+@click.option('-np_id', '--nodepool_id', required=False, help='Nodepool ID to use for the model')
+@click.option(
+    '-dpl_id', '--deployment_id', required=False, help='Deployment ID to use for the model')
+@click.option(
+    '--inference_params', required=False, default='{}', help='Inference parameters to override')
+@click.option('--output_config', required=False, default='{}', help='Output config to override')
+@click.pass_context
+def predict(ctx, config, model_id, user_id, app_id, model_url, file_path, url, bytes, input_id,
+            input_type, compute_cluster_id, nodepool_id, deployment_id, inference_params,
+            output_config):
+  """Predict using the given model"""
+  import json
+
+  from clarifai.client.deployment import Deployment
+  from clarifai.client.input import Input
+  from clarifai.client.model import Model
+  from clarifai.client.nodepool import Nodepool
+  from clarifai.utils.cli import from_yaml
+  if config:
+    config = from_yaml(config)
+    model_id, user_id, app_id, model_url, file_path, url, bytes, input_id, input_type, compute_cluster_id, nodepool_id, deployment_id, inference_params, output_config = (
+        config.get(k, v)
+        for k, v in [('model_id', model_id), ('user_id', user_id), ('app_id', app_id), (
+            'model_url', model_url), ('file_path', file_path), ('url', url), ('bytes', bytes), (
+                'input_id',
+                input_id), ('input_type',
+                            input_type), ('compute_cluster_id',
+                                          compute_cluster_id), ('nodepool_id', nodepool_id), (
+                                              'deployment_id',
+                                              deployment_id), ('inference_params',
+                                                               inference_params), ('output_config',
+                                                                                   output_config)])
+  if sum([opt[1] for opt in [(model_id, 1), (user_id, 1), (app_id, 1), (model_url, 3)]
+          if opt[0]]) != 3:
+    raise ValueError("Either --model_id & --user_id & --app_id or --model_url must be provided.")
+  if sum([1 for opt in [file_path, url, bytes, input_id] if opt]) != 1:
+    raise ValueError("Exactly one of --file_path, --url, --bytes or --input_id must be provided.")
+  if compute_cluster_id or nodepool_id or deployment_id:
+    if sum([
+        opt[1] for opt in [(compute_cluster_id, 0.5), (nodepool_id, 0.5), (deployment_id, 1)]
+        if opt[0]
+    ]) != 1:
+      raise ValueError(
+          "Either --compute_cluster_id & --nodepool_id or --deployment_id must be provided.")
+  if model_url:
+    model = Model(url=model_url, pat=ctx.obj['pat'], base_url=ctx.obj['base_url'])
+  else:
+    model = Model(
+        model_id=model_id,
+        user_id=user_id,
+        app_id=app_id,
+        pat=ctx.obj['pat'],
+        base_url=ctx.obj['base_url'])
+
+  if inference_params:
+    inference_params = json.loads(inference_params)
+  if output_config:
+    output_config = json.loads(output_config)
+
+  if file_path:
+    model_prediction = model.predict_by_filepath(
+        filepath=file_path,
+        input_type=input_type,
+        compute_cluster_id=compute_cluster_id,
+        nodepool_id=nodepool_id,
+        deployment_id=deployment_id,
+        inference_params=inference_params,
+        output_config=output_config)
+  elif url:
+    model_prediction = model.predict_by_url(
+        url=url,
+        input_type=input_type,
+        compute_cluster_id=compute_cluster_id,
+        nodepool_id=nodepool_id,
+        deployment_id=deployment_id,
+        inference_params=inference_params,
+        output_config=output_config)
+  elif bytes:
+    bytes = str.encode(bytes)
+    model_prediction = model.predict_by_bytes(
+        input_bytes=bytes,
+        input_type=input_type,
+        compute_cluster_id=compute_cluster_id,
+        nodepool_id=nodepool_id,
+        deployment_id=deployment_id,
+        inference_params=inference_params,
+        output_config=output_config)
+  elif input_id:
+    inputs = [Input.get_input(input_id)]
+    runner_selector = None
+    if deployment_id:
+      runner_selector = Deployment.get_runner_selector(
+          user_id=ctx.obj['user_id'], deployment_id=deployment_id)
+    elif compute_cluster_id and nodepool_id:
+      runner_selector = Nodepool.get_runner_selector(
+          user_id=ctx.obj['user_id'],
+          compute_cluster_id=compute_cluster_id,
+          nodepool_id=nodepool_id)
+    model_prediction = model.predict(
+        inputs=inputs,
+        runner_selector=runner_selector,
+        inference_params=inference_params,
+        output_config=output_config)
+  click.echo(model_prediction)

{clarifai-10.10.1 → clarifai-10.11.1}/clarifai/client/model.py

@@ -743,7 +743,7 @@ class Model(Lister, BaseClient):
       file_bytes = f.read()
 
     return self.generate_by_bytes(
-        filepath=file_bytes,
+        input_bytes=file_bytes,
         input_type=input_type,
         compute_cluster_id=compute_cluster_id,
         nodepool_id=nodepool_id,

{clarifai-10.10.1 → clarifai-10.11.1}/clarifai/datasets/export/inputs_annotations.py

@@ -165,6 +165,14 @@ class InputAnnotationDownloader:
   def _save_annotation_to_archive(self, new_archive: zipfile.ZipFile, annot_data: List[Dict],
                                   file_name: str) -> None:
     """Gets the annotation response bytestring (from requests) and append to zip file."""
+    # Fill zero values for missing bounding box keys
+    for annot in annot_data:
+      if annot.get('regionInfo') and annot['regionInfo'].get('boundingBox'):
+        bbox = annot['regionInfo']['boundingBox']
+        bbox.setdefault('topRow', 0)
+        bbox.setdefault('leftCol', 0)
+        bbox.setdefault('bottomRow', 0)
+        bbox.setdefault('rightCol', 0)
     # Serialize the dictionary to a JSON string
     json_str = json.dumps(annot_data)
     # Convert the JSON string to bytes

{clarifai-10.10.1 → clarifai-10.11.1}/clarifai/rag/rag.py

@@ -45,10 +45,14 @@ class RAG:
       self.logger.info("workflow_url:%s", workflow_url)
       w = Workflow(workflow_url, base_url=base_url, pat=pat)
       self._prompt_workflow = w
-      self._app = App(app_id=w.app_id, base_url=w.base, pat=w.pat)
+      self._app = App(app_id=w.app_id, user_id=w.user_id, base_url=w.base, pat=w.pat)
     elif workflow_url is None and workflow is not None:
       self._prompt_workflow = workflow
-      self._app = App(app_id=workflow.app_id, base_url=workflow.base, pat=workflow.pat)
+      self._app = App(
+          app_id=workflow.app_id,
+          user_id=workflow.user_id,
+          base_url=workflow.base,
+          pat=workflow.pat)
 
   @classmethod
   def setup(cls,

{clarifai-10.10.1 → clarifai-10.11.1}/clarifai/runners/dockerfile_template/Dockerfile.template

@@ -22,6 +22,8 @@ ENV CLARIFAI_API_BASE=${CLARIFAI_API_BASE}
 
 # Set the NUMBA cache dir to /tmp
 ENV NUMBA_CACHE_DIR=/tmp/numba_cache
+# Set the TORCHINDUCTOR cache dir to /tmp
+ENV TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor_cache
 ENV HOME=/tmp
 
 # Set the working directory to /app

{clarifai-10.10.1 → clarifai-10.11.1}/clarifai/runners/models/base_typed_model.py

@@ -24,7 +24,8 @@ class AnyAnyModel(ModelRunner):
     list_input_dict = [
         InputDataHandler.from_proto(input).to_python() for input in input_request.inputs
     ]
-    inference_params = json_format.MessageToDict(input_request.model.output_info.params)
+    inference_params = json_format.MessageToDict(
+        input_request.model.model_version.output_info.params)
 
     return list_input_dict, inference_params
 
@@ -141,7 +142,8 @@ class VisualInputModel(AnyAnyModel):
     list_input_dict = [
         InputDataHandler.from_proto(input).image(format="np") for input in input_request.inputs
     ]
-    inference_params = json_format.MessageToDict(input_request.model.output_info.params)
+    inference_params = json_format.MessageToDict(
+        input_request.model.model_version.output_info.params)
 
     return list_input_dict, inference_params
 
@@ -181,7 +183,8 @@ class TextInputModel(AnyAnyModel):
   def parse_input_request(
       self, input_request: service_pb2.PostModelOutputsRequest) -> Tuple[List[Dict], Dict]:
     list_input_text = [InputDataHandler.from_proto(input).text for input in input_request.inputs]
-    inference_params = json_format.MessageToDict(input_request.model.output_info.params)
+    inference_params = json_format.MessageToDict(
+        input_request.model.model_version.output_info.params)
 
     return list_input_text, inference_params