clarifai 11.5.1__py3-none-any.whl → 11.5.3__py3-none-any.whl

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "11.5.1"
+__version__ = "11.5.3"

clarifai/cli/model.py

@@ -49,7 +49,7 @@ def init(model_path, model_type_id):
 
     MODEL_PATH: Path where to create the model directory structure. If not specified, the current directory is used by default.
     """
-    from clarifai.cli.model_templates import (
+    from clarifai.cli.templates.model_templates import (
         get_config_template,
         get_model_template,
         get_requirements_template,
@@ -520,6 +520,10 @@ def local_dev(ctx, model_path):
 
         try:
             runner = nodepool.runner(runner_id)
+            # ensure the deployment is using the latest version.
+            if runner.worker.model.model_version.id != version.id:
+                nodepool.delete_runners([runner_id])
+                raise AttributeError("Deleted runner that was for an old model version ID.")
         except Exception as e:
             raise AttributeError("Runner not found in nodepool.") from e
     except AttributeError:
@@ -549,6 +553,10 @@ def local_dev(ctx, model_path):
         deployment_id = DEFAULT_LOCAL_DEV_DEPLOYMENT_ID
     try:
         deployment = nodepool.deployment(deployment_id)
+        # ensure the deployment is using the latest version.
+        if deployment.worker.model.model_version.id != version.id:
+            nodepool.delete_deployments([deployment_id])
+            raise Exception("Deleted deployment that was for an old model version ID.")
         try:
             deployment_id = ctx.obj.current.deployment_id
         except AttributeError:  # doesn't exist in context but does in API then update the context.
@@ -576,6 +584,7 @@ def local_dev(ctx, model_path):
                             },
                         }
                     ],
+                    "deploy_latest_version": True,
                 }
             },
         )
@@ -810,3 +819,35 @@ def predict(
             output_config=output_config,
         )  ## TO DO: Add support for input_id
     click.echo(model_prediction)
+
+
+@model.command(name="list")
+@click.argument(
+    "user_id",
+    required=False,
+    default=None,
+)
+@click.option(
+    '--app_id',
+    '-a',
+    type=str,
+    default=None,
+    show_default=True,
+    help="Get all models of an app",
+)
+@click.pass_context
+def list_model(ctx, user_id, app_id):
+    """List models of user/community
+
+    USER_ID: User id. If not specified, the current user is used by default. Set "all" to get all public models in Clarifai platform.
+    """
+    from clarifai.client import User
+
+    try:
+        pat = ctx.obj.contexts["default"]["env"]["CLARIFAI_PAT"]
+    except Exception as e:
+        pat = None
+
+    User(pat=pat).list_models(
+        user_id=user_id, app_id=app_id, show=True, return_clarifai_model=False
+    )

clarifai/cli/pipeline.py

@@ -0,0 +1,137 @@
+import os
+import shutil
+
+import click
+
+from clarifai.cli.base import cli
+from clarifai.utils.logging import logger
+
+
+@cli.group(
+    ['pipeline', 'pl'],
+    context_settings={'max_content_width': shutil.get_terminal_size().columns - 10},
+)
+def pipeline():
+    """Manage pipelines: upload, init, etc"""
+
+
+@pipeline.command()
+@click.argument("path", type=click.Path(exists=True), required=False, default=".")
+def upload(path):
+    """Upload a pipeline with associated pipeline steps to Clarifai.
+
+    PATH: Path to the pipeline configuration file or directory containing config.yaml. If not specified, the current directory is used by default.
+    """
+    from clarifai.runners.pipelines.pipeline_builder import upload_pipeline
+
+    upload_pipeline(path)
+
+
+@pipeline.command()
+@click.argument(
+    "pipeline_path",
+    type=click.Path(),
+    required=False,
+    default=".",
+)
+def init(pipeline_path):
+    """Initialize a new pipeline project structure.
+
+    Creates the following structure in the specified directory:
+    ├── config.yaml          # Pipeline configuration
+    ├── stepA/               # First pipeline step
+    │   ├── config.yaml     # Step A configuration
+    │   ├── requirements.txt # Step A dependencies
+    │   └── 1/
+    │       └── pipeline_step.py  # Step A implementation
+    ├── stepB/               # Second pipeline step
+    │   ├── config.yaml     # Step B configuration
+    │   ├── requirements.txt # Step B dependencies
+    │   └── 1/
+    │       └── pipeline_step.py  # Step B implementation
+    └── README.md           # Documentation
+
+    PIPELINE_PATH: Path where to create the pipeline project structure. If not specified, the current directory is used by default.
+    """
+    from clarifai.cli.templates.pipeline_templates import (
+        get_pipeline_config_template,
+        get_pipeline_step_config_template,
+        get_pipeline_step_requirements_template,
+        get_pipeline_step_template,
+        get_readme_template,
+    )
+
+    # Resolve the absolute path
+    pipeline_path = os.path.abspath(pipeline_path)
+
+    # Create the pipeline directory if it doesn't exist
+    os.makedirs(pipeline_path, exist_ok=True)
+
+    # Create pipeline config.yaml
+    config_path = os.path.join(pipeline_path, "config.yaml")
+    if os.path.exists(config_path):
+        logger.warning(f"File {config_path} already exists, skipping...")
+    else:
+        config_template = get_pipeline_config_template()
+        with open(config_path, 'w', encoding='utf-8') as f:
+            f.write(config_template)
+        logger.info(f"Created {config_path}")
+
+    # Create README.md
+    readme_path = os.path.join(pipeline_path, "README.md")
+    if os.path.exists(readme_path):
+        logger.warning(f"File {readme_path} already exists, skipping...")
+    else:
+        readme_template = get_readme_template()
+        with open(readme_path, 'w', encoding='utf-8') as f:
+            f.write(readme_template)
+        logger.info(f"Created {readme_path}")
+
+    # Create pipeline steps (stepA and stepB)
+    for step_id in ["stepA", "stepB"]:
+        step_dir = os.path.join(pipeline_path, step_id)
+        os.makedirs(step_dir, exist_ok=True)
+
+        # Create the 1/ subdirectory for the step version
+        step_version_dir = os.path.join(step_dir, "1")
+        os.makedirs(step_version_dir, exist_ok=True)
+
+        # Create step config.yaml
+        step_config_path = os.path.join(step_dir, "config.yaml")
+        if os.path.exists(step_config_path):
+            logger.warning(f"File {step_config_path} already exists, skipping...")
+        else:
+            step_config_template = get_pipeline_step_config_template(step_id)
+            with open(step_config_path, 'w', encoding='utf-8') as f:
+                f.write(step_config_template)
+            logger.info(f"Created {step_config_path}")
+
+        # Create step requirements.txt
+        step_requirements_path = os.path.join(step_dir, "requirements.txt")
+        if os.path.exists(step_requirements_path):
+            logger.warning(f"File {step_requirements_path} already exists, skipping...")
+        else:
+            step_requirements_template = get_pipeline_step_requirements_template()
+            with open(step_requirements_path, 'w', encoding='utf-8') as f:
+                f.write(step_requirements_template)
+            logger.info(f"Created {step_requirements_path}")
+
+        # Create step pipeline_step.py
+        step_py_path = os.path.join(step_version_dir, "pipeline_step.py")
+        if os.path.exists(step_py_path):
+            logger.warning(f"File {step_py_path} already exists, skipping...")
+        else:
+            step_py_template = get_pipeline_step_template(step_id)
+            with open(step_py_path, 'w', encoding='utf-8') as f:
+                f.write(step_py_template)
+            logger.info(f"Created {step_py_path}")
+
+    logger.info(f"Pipeline initialization complete in {pipeline_path}")
+    logger.info("Next steps:")
+    logger.info("1. Search for '# TODO: please fill in' comments in the generated files")
+    logger.info("2. Update your user_id and app_id in all config.yaml files")
+    logger.info(
+        "3. Implement your pipeline step logic in stepA/1/pipeline_step.py and stepB/1/pipeline_step.py"
+    )
+    logger.info("4. Add dependencies to requirements.txt files as needed")
+    logger.info("5. Run 'clarifai pipeline upload config.yaml' to upload your pipeline")

clarifai/cli/pipeline_step.py

@@ -0,0 +1,104 @@
+import os
+import shutil
+
+import click
+
+from clarifai.cli.base import cli
+from clarifai.utils.logging import logger
+
+
+@cli.group(
+    ['pipelinestep'],
+    context_settings={'max_content_width': shutil.get_terminal_size().columns - 10},
+)
+def pipeline_step():
+    """Manage pipeline steps: upload, test, etc"""
+
+
+@pipeline_step.command()
+@click.argument("pipeline_step_path", type=click.Path(exists=True), required=False, default=".")
+@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(pipeline_step_path, skip_dockerfile):
+    """Upload a pipeline step to Clarifai.
+
+    PIPELINE_STEP_PATH: Path to the pipeline step directory. If not specified, the current directory is used by default.
+    """
+    from clarifai.runners.pipeline_steps.pipeline_step_builder import upload_pipeline_step
+
+    upload_pipeline_step(pipeline_step_path, skip_dockerfile)
+
+
+@pipeline_step.command()
+@click.argument(
+    "pipeline_step_path",
+    type=click.Path(),
+    required=False,
+    default=".",
+)
+def init(pipeline_step_path):
+    """Initialize a new pipeline step directory structure.
+
+    Creates the following structure in the specified directory:
+    ├── 1/
+    │   └── pipeline_step.py
+    ├── requirements.txt
+    └── config.yaml
+
+    PIPELINE_STEP_PATH: Path where to create the pipeline step directory structure. If not specified, the current directory is used by default.
+    """
+    from clarifai.cli.templates.pipeline_step_templates import (
+        get_config_template,
+        get_pipeline_step_template,
+        get_requirements_template,
+    )
+
+    # Resolve the absolute path
+    pipeline_step_path = os.path.abspath(pipeline_step_path)
+
+    # Create the pipeline step directory if it doesn't exist
+    os.makedirs(pipeline_step_path, exist_ok=True)
+
+    # Create the 1/ subdirectory
+    pipeline_step_version_dir = os.path.join(pipeline_step_path, "1")
+    os.makedirs(pipeline_step_version_dir, exist_ok=True)
+
+    # Create pipeline_step.py
+    pipeline_step_py_path = os.path.join(pipeline_step_version_dir, "pipeline_step.py")
+    if os.path.exists(pipeline_step_py_path):
+        logger.warning(f"File {pipeline_step_py_path} already exists, skipping...")
+    else:
+        pipeline_step_template = get_pipeline_step_template()
+        with open(pipeline_step_py_path, 'w') as f:
+            f.write(pipeline_step_template)
+        logger.info(f"Created {pipeline_step_py_path}")
+
+    # Create requirements.txt
+    requirements_path = os.path.join(pipeline_step_path, "requirements.txt")
+    if os.path.exists(requirements_path):
+        logger.warning(f"File {requirements_path} already exists, skipping...")
+    else:
+        requirements_template = get_requirements_template()
+        with open(requirements_path, 'w') as f:
+            f.write(requirements_template)
+        logger.info(f"Created {requirements_path}")
+
+    # Create config.yaml
+    config_path = os.path.join(pipeline_step_path, "config.yaml")
+    if os.path.exists(config_path):
+        logger.warning(f"File {config_path} already exists, skipping...")
+    else:
+        config_template = get_config_template()
+        with open(config_path, 'w') as f:
+            f.write(config_template)
+        logger.info(f"Created {config_path}")
+
+    logger.info(f"Pipeline step initialization complete in {pipeline_step_path}")
+    logger.info("Next steps:")
+    logger.info("1. Search for '# TODO: please fill in' comments in the generated files")
+    logger.info("2. Update the pipeline step configuration in config.yaml")
+    logger.info("3. Add your pipeline step dependencies to requirements.txt")
+    logger.info("4. Implement your pipeline step logic in 1/pipeline_step.py")

clarifai/cli/templates/__init__.py

@@ -0,0 +1 @@
+"""Template files for CLI init commands."""

clarifai/cli/templates/pipeline_step_templates.py

@@ -0,0 +1,64 @@
+"""Templates for initializing pipeline step projects."""
+
+from clarifai.versions import CLIENT_VERSION
+
+
+def get_config_template():
+    """Get the config.yaml template for pipeline steps."""
+    return """pipeline_step:
+  id: "text-classifier-train-upload-step"  # TODO: please fill in
+  user_id: "your_user_id"  # TODO: please fill in
+  app_id: "your_app_id"  # TODO: please fill in
+
+pipeline_step_input_params:
+  - name: param_a
+  - name: param_b
+    default: "param_b_allowed_value1"
+    description: "param_b is the second parameter of the pipeline step"
+    accepted_values:  # list of accepted values for param_b
+      - "param_b_allowed_value1"
+      - "param_b_allowed_value2"
+      - "param_b_allowed_value3"
+
+build_info:
+  python_version: "3.12"
+
+pipeline_step_compute_info:
+  cpu_limit: "500m"
+  cpu_memory: "500Mi"
+  num_accelerators: 0
+"""
+
+
+def get_pipeline_step_template():
+    """Get the pipeline_step.py template."""
+    return '''import argparse
+
+import clarifai
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Concatenate two strings.')
+    parser.add_argument('--param_a', type=str, required=True, help='First string to concatenate')
+    parser.add_argument('--param_b', type=str, required=True, help='Second string to concatenate')
+
+    args = parser.parse_args()
+
+    print(clarifai.__version__)
+
+    print(f"Concatenation Output: {args.param_a + args.param_b}")
+
+
+if __name__ == "__main__":
+    main()
+'''
+
+
+def get_requirements_template():
+    """Get the requirements.txt template."""
+    return f'''clarifai=={CLIENT_VERSION}
+# Add your pipeline step dependencies here
+# Example:
+# torch>=1.9.0
+# transformers>=4.20.0
+'''

clarifai/cli/templates/pipeline_templates.py

@@ -0,0 +1,150 @@
+"""Templates for initializing pipeline projects."""
+
+from clarifai.versions import CLIENT_VERSION
+
+
+def get_pipeline_config_template():
+    """Get the config.yaml template for pipelines."""
+    return """pipeline:
+  id: "hello-world-pipeline"  # TODO: please fill in
+  user_id: "your_user_id"  # TODO: please fill in
+  app_id: "your_app_id"  # TODO: please fill in
+  step_directories:
+    - stepA
+    - stepB
+  orchestration_spec:
+    argo_orchestration_spec: |
+      apiVersion: argoproj.io/v1alpha1
+      kind: Workflow
+      metadata:
+        generateName: hello-world-pipeline-
+      spec:
+        entrypoint: sequence
+        templates:
+        - name: sequence
+          steps:
+          - - name: step-a
+              templateRef:
+                name: users/your_user_id/apps/your_app_id/pipeline-steps/stepA  # TODO: please fill in
+                template: users/your_user_id/apps/your_app_id/pipeline-steps/stepA  # TODO: please fill in
+          - - name: step-b
+              templateRef:
+                name: users/your_user_id/apps/your_app_id/pipeline-steps/stepB  # TODO: please fill in
+                template: users/your_user_id/apps/your_app_id/pipeline-steps/stepB  # TODO: please fill in
+"""
+
+
+def get_pipeline_step_config_template(step_id: str):
+    """Get the config.yaml template for a pipeline step."""
+    return f"""pipeline_step:
+  id: "{step_id}"  # TODO: please fill in
+  user_id: "your_user_id"  # TODO: please fill in
+  app_id: "your_app_id"  # TODO: please fill in
+
+pipeline_step_input_params:
+  - name: input_text
+    description: "Text input for processing"
+
+build_info:
+  python_version: "3.12"
+
+pipeline_step_compute_info:
+  cpu_limit: "500m"
+  cpu_memory: "500Mi"
+  num_accelerators: 0
+"""
+
+
+def get_pipeline_step_template(step_id: str):
+    """Get the pipeline_step.py template for a pipeline step."""
+    return f'''import argparse
+
+import clarifai
+
+
+def main():
+    parser = argparse.ArgumentParser(description='{step_id} processing step.')
+    parser.add_argument('--input_text', type=str, required=True, help='Text input for processing')
+
+    args = parser.parse_args()
+
+    print(clarifai.__version__)
+
+    # TODO: Implement your pipeline step logic here
+    print(f"{step_id} processed: {{args.input_text}}")
+
+
+if __name__ == "__main__":
+    main()
+'''
+
+
+def get_pipeline_step_requirements_template():
+    """Get the requirements.txt template for pipeline steps."""
+    return f'''clarifai=={CLIENT_VERSION}
+# Add your pipeline step dependencies here
+# Example:
+# torch>=1.9.0
+# transformers>=4.20.0
+'''
+
+
+def get_readme_template():
+    """Get the README.md template for the pipeline project."""
+    return """# Pipeline Project
+
+This project contains a Clarifai pipeline with associated pipeline steps.
+
+## Structure
+
+```
+├── config.yaml          # Pipeline configuration
+├── stepA/               # First pipeline step
+│   ├── config.yaml     # Step A configuration
+│   ├── requirements.txt # Step A dependencies
+│   └── 1/
+│       └── pipeline_step.py  # Step A implementation
+├── stepB/               # Second pipeline step
+│   ├── config.yaml     # Step B configuration
+│   ├── requirements.txt # Step B dependencies
+│   └── 1/
+│       └── pipeline_step.py  # Step B implementation
+└── README.md           # This file
+```
+
+## Getting Started
+
+1. **Configure the pipeline**: Edit `config.yaml` and update the TODO fields:
+   - Set your `user_id` and `app_id`
+   - Update the pipeline `id`
+   - Modify the Argo orchestration spec as needed
+
+2. **Configure pipeline steps**: For each step directory (stepA, stepB):
+   - Edit `config.yaml` and fill in the TODO fields
+   - Update `requirements.txt` with your dependencies
+   - Implement your logic in `1/pipeline_step.py`
+
+3. **Upload the pipeline**:
+   ```bash
+   clarifai pipeline upload config.yaml
+   ```
+
+This will:
+- Upload the pipeline steps from the `step_directories`
+- Create the pipeline with proper orchestration
+- Link all components together
+
+## Pipeline Steps
+
+### stepA
+TODO: Describe what stepA does
+
+### stepB
+TODO: Describe what stepB does
+
+## Customization
+
+- Add more pipeline steps by creating new directories and adding them to `step_directories` in `config.yaml`
+- Modify the Argo orchestration spec to change the execution flow
+- Update compute resources in each step's `config.yaml` as needed
+"""

clarifai/client/auth/helper.py

@@ -1,7 +1,6 @@
 import os
 import urllib.request
 from typing import Any, Dict
-from urllib.parse import urlparse
 
 from clarifai_grpc.channel.clarifai_channel import ClarifaiChannel
 from clarifai_grpc.grpc.api import resources_pb2, service_pb2_grpc
@@ -42,28 +41,31 @@ def https_cache(cache: dict, url: str) -> str:
     elif url.startswith("http://"):
         url = url.replace("http://", "")
         cache[url] = HTTP
-    elif url not in cache:
+    elif url.endswith(":443"):
+        # If it ends with :443 then we know it's https.
+        # trim it off the right
+        url = url[:-4]
+        cache[url] = HTTPS
+    elif url.find('.clarifai.com') >= 0:
         # We know our endpoints are https.
-        host_name = urlparse(url).hostname
-        if host_name and host_name.endswith(".clarifai.com"):
-            cache[url] = HTTPS
-        else:  # need to test it.
-            try:  # make request to https endpoint.
-                urllib.request.urlopen("https://%s/v2/auth/methods" % url, timeout=1)
-                cache[url] = HTTPS  # cache it.
-            except Exception as e:
-                if "SSL" in str(e):  # if ssl error then we know it's http.
-                    cache[url] = HTTP
-                    # For http urls we need host:port format.
-                    if ":" not in url:
-                        raise Exception(
-                            "When providing an insecure url it must have both host:port format"
-                        )
-                else:
+        cache[url] = HTTPS
+    elif url not in cache:
+        # need to test ones that we don't have in the cache yet.
+        try:  # make request to https endpoint.
+            urllib.request.urlopen("https://%s/v2/auth/methods" % url, timeout=5)
+            cache[url] = HTTPS  # cache it.
+        except Exception as e:
+            if "SSL" in str(e):  # if ssl error then we know it's http.
+                cache[url] = HTTP
+                # For http urls we need host:port format.
+                if ":" not in url:
                     raise Exception(
-                        "Could not get a valid response from url: %s, is the API running there?"
-                        % url
-                    ) from e
+                        "When providing an insecure url it must have both host:port format"
+                    )
+            else:
+                raise Exception(
+                    "Could not get a valid response from url: %s, is the API running there?" % url
+                ) from e
     return url
 
 
@@ -310,6 +312,29 @@ class ClarifaiAuthHelper:
         stub = service_pb2_grpc.V2Stub(channel)
         return stub
 
+    def get_async_stub(self) -> service_pb2_grpc.V2Stub:
+        """Get the API gRPC async stub using the right channel based on the API endpoint base.
+        Returns:
+        stub: The service_pb2_grpc.V2Stub stub for the API.
+        """
+        if self._base not in base_https_cache:
+            raise Exception("Cannot determine if base %s is https" % self._base)
+
+        https = base_https_cache[self._base]
+        if https:
+            channel = ClarifaiChannel.get_aio_grpc_channel(
+                base=self._base, root_certificates_path=self._root_certificates_path
+            )
+        else:
+            if self._base.find(":") >= 0:
+                host, port = self._base.split(":")
+            else:
+                host = self._base
+                port = 80
+            channel = ClarifaiChannel.get_aio_insecure_grpc_channel(base=host, port=port)
+        stub = service_pb2_grpc.V2Stub(channel)
+        return stub
+
     @property
     def ui(self) -> str:
         """Return the domain for the UI."""

clarifai/client/auth/register.py

@@ -18,6 +18,11 @@ def _register_classes():
     for name in dir(grpc):
         if name.endswith('Callable'):
             RpcCallable.register(getattr(grpc, name))
+    # add grpc aio classes as subclasses of the abcs, so they also succeed in isinstance calls
+    # This is needed for calling AuthorizedRPCCallable in the async stub with metadata headers
+    for name in dir(grpc.aio):
+        if name.endswith('Callable'):
+            RpcCallable.register(getattr(grpc.aio, name))
 
 
 _register_classes()