clarifai 11.6.3__tar.gz → 11.6.4__tar.gz

{clarifai-11.6.3/clarifai.egg-info → clarifai-11.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clarifai
-Version: 11.6.3
+Version: 11.6.4
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
 Author-email: support@clarifai.com

clarifai-11.6.4/clarifai/__init__.py

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

{clarifai-11.6.3 → clarifai-11.6.4}/clarifai/cli/base.py

@@ -154,11 +154,12 @@ def env(ctx_obj):
 
 
 @cli.command()
-@click.argument('api_url', default="https://api.clarifai.com")
+@click.argument('api_url', default=DEFAULT_BASE)
 @click.option('--user_id', required=False, help='User ID')
 @click.pass_context
 def login(ctx, api_url, user_id):
     """Login command to set PAT and other configurations."""
+    from clarifai.utils.cli import validate_pat_token
 
     name = input('context name (default: "default"): ')
     user_id = user_id if user_id is not None else input('user id: ')
@@ -167,6 +168,18 @@ def login(ctx, api_url, user_id):
         'ENVVAR',
     )
 
+    # Validate the PAT token if it's not "ENVVAR"
+    if pat != "ENVVAR":
+        print("Validating PAT token...")
+        is_valid, error_message = validate_pat_token(pat, user_id, api_url)
+
+        if not is_valid:
+            print(f"❌ PAT token validation failed: {error_message}")
+            print("Please check your token and try again.")
+            return  # Exit without saving the configuration
+        else:
+            print("✓ PAT token is valid")
+
     context = Context(
         name,
         CLARIFAI_API_BASE=api_url,
@@ -181,6 +194,7 @@ def login(ctx, api_url, user_id):
     ctx.obj.current_context = context.name
 
     ctx.obj.to_yaml()
+    print(f"✓ Configuration saved successfully for context '{context.name}'")
 
 
 @cli.group(cls=AliasedGroup)
@@ -211,6 +225,8 @@ def create(
     pat=None,
 ):
     """Create a new context"""
+    from clarifai.utils.cli import validate_pat_token
+
     if name in ctx.obj.contexts:
         print(f'{name} already exists')
         sys.exit(1)
@@ -226,9 +242,22 @@ def create(
             'ENVVAR',
         )
 
+    # Validate the PAT token if it's not "ENVVAR"
+    if pat != "ENVVAR":
+        print("Validating PAT token...")
+        is_valid, error_message = validate_pat_token(pat, user_id, base_url)
+
+        if not is_valid:
+            print(f"❌ PAT token validation failed: {error_message}")
+            print("Please check your token and try again.")
+            return  # Exit without saving the configuration
+        else:
+            print("✓ PAT token is valid")
+
     context = Context(name, CLARIFAI_USER_ID=user_id, CLARIFAI_API_BASE=base_url, CLARIFAI_PAT=pat)
     ctx.obj.contexts[context.name] = context
     ctx.obj.to_yaml()
+    print(f"✓ Context '{name}' created successfully")
 
 
 # write a click command to delete a context

{clarifai-11.6.3 → clarifai-11.6.4}/clarifai/cli/model.py

@@ -7,14 +7,14 @@ import click
 from clarifai.cli.base import cli
 from clarifai.utils.cli import validate_context
 from clarifai.utils.constants import (
-    DEFAULT_LOCAL_DEV_APP_ID,
-    DEFAULT_LOCAL_DEV_COMPUTE_CLUSTER_CONFIG,
-    DEFAULT_LOCAL_DEV_COMPUTE_CLUSTER_ID,
-    DEFAULT_LOCAL_DEV_DEPLOYMENT_ID,
-    DEFAULT_LOCAL_DEV_MODEL_ID,
-    DEFAULT_LOCAL_DEV_MODEL_TYPE,
-    DEFAULT_LOCAL_DEV_NODEPOOL_CONFIG,
-    DEFAULT_LOCAL_DEV_NODEPOOL_ID,
+    DEFAULT_LOCAL_RUNNER_APP_ID,
+    DEFAULT_LOCAL_RUNNER_COMPUTE_CLUSTER_CONFIG,
+    DEFAULT_LOCAL_RUNNER_COMPUTE_CLUSTER_ID,
+    DEFAULT_LOCAL_RUNNER_DEPLOYMENT_ID,
+    DEFAULT_LOCAL_RUNNER_MODEL_ID,
+    DEFAULT_LOCAL_RUNNER_MODEL_TYPE,
+    DEFAULT_LOCAL_RUNNER_NODEPOOL_CONFIG,
+    DEFAULT_LOCAL_RUNNER_NODEPOOL_ID,
 )
 from clarifai.utils.logging import logger
 from clarifai.utils.misc import clone_github_repo, format_github_repo_url
@@ -421,17 +421,16 @@ def run_locally(model_path, port, mode, keep_env, keep_image, skip_dockerfile=Fa
 @click.option(
     "--pool_size",
     type=int,
-    is_flag=True,
-    default=1,  # default to 1 thread for local dev runner to avoid rapid depletion of compute time.
+    default=1,  # default to 1 thread for local runner to avoid rapid depletion of compute time.
     show_default=True,
     help="The number of threads to use. On community plan, the compute time allocation is drained at a rate proportional to the number of threads.",
 )  # pylint: disable=range-builtin-not-iterating
 @click.pass_context
-def local_dev(ctx, model_path, pool_size):
-    """Run the model as a local dev runner to help debug your model connected to the API or to
+def local_runner(ctx, model_path, pool_size):
+    """Run the model as a local runner to help debug your model connected to the API or to
     leverage local compute resources manually. This relies on many variables being present in the env
     of the currently selected context. If they are not present then default values will be used to
-    ease the setup of a local dev runner and your context yaml will be updated in place. The required
+    ease the setup of a local runner and your context yaml will be updated in place. The required
     env vars are:
 
     \b
@@ -445,7 +444,7 @@ def local_dev(ctx, model_path, pool_size):
       CLARIFAI_MODEL_ID:
 
     \b
-      # for where the local dev runner should be in a compute cluser
+      # for where the local runner should be in a compute cluster
       # note the user_id of the compute cluster is the same as the user_id of the model.
 
     \b
@@ -460,7 +459,7 @@ def local_dev(ctx, model_path, pool_size):
     Additionally using the provided model path, if the config.yaml file does not contain the model
     information that matches the above CLARIFAI_USER_ID, CLARIFAI_APP_ID, CLARIFAI_MODEL_ID then the
     config.yaml will be updated to include the model information. This is to ensure that the model
-    that starts up in the local dev runner is the same as the one you intend to call in the API.
+    that starts up in the local runner is the same as the one you intend to call in the API.
 
     MODEL_PATH: Path to the model directory. If not specified, the current directory is used by default.
     """
@@ -469,25 +468,29 @@ def local_dev(ctx, model_path, pool_size):
     from clarifai.runners.server import serve
 
     validate_context(ctx)
-    logger.info("Checking setup for local development runner...")
+    logger.info("Checking setup for local runner...")
     logger.info(f"Current context: {ctx.obj.current.name}")
     user_id = ctx.obj.current.user_id
-    user = User(user_id=user_id, pat=ctx.obj.current.pat, base_url=ctx.obj.current.api_base)
     logger.info(f"Current user_id: {user_id}")
-    logger.debug("Checking if a local dev compute cluster exists...")
+    if not user_id:
+        raise ValueError(
+            f"User with ID '{user_id}' not found. Use 'clarifai login' to setup context."
+        )
+    user = User(user_id=user_id, pat=ctx.obj.current.pat, base_url=ctx.obj.current.api_base)
+    logger.debug("Checking if a local runner compute cluster exists...")
 
     # see if ctx has CLARIFAI_COMPUTE_CLUSTER_ID, if not use default
     try:
         compute_cluster_id = ctx.obj.current.compute_cluster_id
     except AttributeError:
-        compute_cluster_id = DEFAULT_LOCAL_DEV_COMPUTE_CLUSTER_ID
+        compute_cluster_id = DEFAULT_LOCAL_RUNNER_COMPUTE_CLUSTER_ID
     logger.info(f"Current compute_cluster_id: {compute_cluster_id}")
 
     try:
         compute_cluster = user.compute_cluster(compute_cluster_id)
         if compute_cluster.cluster_type != 'local-dev':
             raise ValueError(
-                f"Compute cluster {user_id}/{compute_cluster_id} is not a local-dev compute cluster. Please create a local-dev compute cluster."
+                f"Compute cluster {user_id}/{compute_cluster_id} is not a local-runner compute cluster. Please create a local-runner compute cluster."
             )
         try:
             compute_cluster_id = ctx.obj.current.compute_cluster_id
@@ -503,10 +506,10 @@ def local_dev(ctx, model_path, pool_size):
         )
         if y.lower() != 'y':
             raise click.Abort()
-        # Create a compute cluster with default configuration for local dev.
+        # Create a compute cluster with default configuration for local runner.
         compute_cluster = user.create_compute_cluster(
             compute_cluster_id=compute_cluster_id,
-            compute_cluster_config=DEFAULT_LOCAL_DEV_COMPUTE_CLUSTER_CONFIG,
+            compute_cluster_config=DEFAULT_LOCAL_RUNNER_COMPUTE_CLUSTER_CONFIG,
         )
         ctx.obj.current.CLARIFAI_COMPUTE_CLUSTER_ID = compute_cluster_id
         ctx.obj.to_yaml()  # save to yaml file.
@@ -515,7 +518,7 @@ def local_dev(ctx, model_path, pool_size):
     try:
         nodepool_id = ctx.obj.current.nodepool_id
     except AttributeError:
-        nodepool_id = DEFAULT_LOCAL_DEV_NODEPOOL_ID
+        nodepool_id = DEFAULT_LOCAL_RUNNER_NODEPOOL_ID
     logger.info(f"Current nodepool_id: {nodepool_id}")
 
     try:
@@ -533,7 +536,7 @@ def local_dev(ctx, model_path, pool_size):
         if y.lower() != 'y':
             raise click.Abort()
         nodepool = compute_cluster.create_nodepool(
-            nodepool_config=DEFAULT_LOCAL_DEV_NODEPOOL_CONFIG, nodepool_id=nodepool_id
+            nodepool_config=DEFAULT_LOCAL_RUNNER_NODEPOOL_CONFIG, nodepool_id=nodepool_id
         )
         ctx.obj.current.CLARIFAI_NODEPOOL_ID = nodepool_id
         ctx.obj.to_yaml()  # save to yaml file.
@@ -543,7 +546,7 @@ def local_dev(ctx, model_path, pool_size):
     try:
         app_id = ctx.obj.current.app_id
     except AttributeError:
-        app_id = DEFAULT_LOCAL_DEV_APP_ID
+        app_id = DEFAULT_LOCAL_RUNNER_APP_ID
     logger.info(f"Current app_id: {app_id}")
 
     try:
@@ -562,11 +565,11 @@ def local_dev(ctx, model_path, pool_size):
         ctx.obj.current.CLARIFAI_APP_ID = app_id
         ctx.obj.to_yaml()  # save to yaml file.
 
-    # Within this app we now need a model to call as the local dev runner.
+    # Within this app we now need a model to call as the local runner.
     try:
         model_id = ctx.obj.current.model_id
     except AttributeError:
-        model_id = DEFAULT_LOCAL_DEV_MODEL_ID
+        model_id = DEFAULT_LOCAL_RUNNER_MODEL_ID
     logger.info(f"Current model_id: {model_id}")
 
     try:
@@ -586,7 +589,7 @@ def local_dev(ctx, model_path, pool_size):
         try:
             model_type_id = ctx.obj.current.model_type_id
         except AttributeError:
-            model_type_id = DEFAULT_LOCAL_DEV_MODEL_TYPE
+            model_type_id = DEFAULT_LOCAL_RUNNER_MODEL_TYPE
 
         model = app.create_model(model_id, model_type_id=model_type_id)
         ctx.obj.current.CLARIFAI_MODEL_TYPE_ID = model_type_id
@@ -594,10 +597,10 @@ def local_dev(ctx, model_path, pool_size):
         ctx.obj.to_yaml()  # save to yaml file.
 
     # Now we need to create a version for the model if no version exists. Only need one version that
-    # mentions it's a local dev runner.
+    # mentions it's a local runner.
     model_versions = [v for v in model.list_versions()]
     if len(model_versions) == 0:
-        logger.info("No model versions found. Creating a new version for local dev runner.")
+        logger.info("No model versions found. Creating a new version for local runner.")
         version = model.create_version(pretrained_model_config={"local_dev": True}).model_version
         logger.info(f"Created model version {version.id}")
     else:
@@ -631,12 +634,12 @@ def local_dev(ctx, model_path, pool_size):
             raise AttributeError("Runner not found in nodepool.") from e
     except AttributeError:
         logger.info(
-            f"Create the local dev runner tying this\n  {user_id}/{app_id}/models/{model.id} model (version: {version.id}) to the\n  {user_id}/{compute_cluster_id}/{nodepool_id} nodepool."
+            f"Create the local runner tying this\n  {user_id}/{app_id}/models/{model.id} model (version: {version.id}) to the\n  {user_id}/{compute_cluster_id}/{nodepool_id} nodepool."
         )
         runner = nodepool.create_runner(
             runner_config={
                 "runner": {
-                    "description": "Local dev runner for model testing",
+                    "description": "local runner for model testing",
                     "worker": worker,
                     "num_replicas": 1,
                 }
@@ -653,7 +656,7 @@ def local_dev(ctx, model_path, pool_size):
     try:
         deployment_id = ctx.obj.current.deployment_id
     except AttributeError:
-        deployment_id = DEFAULT_LOCAL_DEV_DEPLOYMENT_ID
+        deployment_id = DEFAULT_LOCAL_RUNNER_DEPLOYMENT_ID
     try:
         deployment = nodepool.deployment(deployment_id)
         # ensure the deployment is using the latest version.
@@ -708,7 +711,7 @@ def local_dev(ctx, model_path, pool_size):
             f"config.yaml not found in {model_path}. Please ensure you are passing the correct directory."
         )
     config = ModelBuilder._load_config(config_file)
-    model_type_id = config.get('model', {}).get('model_type_id', DEFAULT_LOCAL_DEV_MODEL_TYPE)
+    model_type_id = config.get('model', {}).get('model_type_id', DEFAULT_LOCAL_RUNNER_MODEL_TYPE)
     # The config.yaml doens't match what we created above.
     if 'model' in config and model_id != config['model'].get('id'):
         logger.info(f"Current model section of config.yaml: {config.get('model', {})}")
@@ -717,14 +720,14 @@ def local_dev(ctx, model_path, pool_size):
         )
         if y.lower() != 'y':
             raise click.Abort()
-        config = ModelBuilder._set_local_dev_model(
+        config = ModelBuilder._set_local_runner_model(
             config, user_id, app_id, model_id, model_type_id
         )
         ModelBuilder._backup_config(config_file)
         ModelBuilder._save_config(config_file, config)
 
     builder = ModelBuilder(model_path, download_validation_only=True)
-    # don't mock for local dev since you need the dependencies to run the code anyways.
+    # don't mock for local runner since you need the dependencies to run the code anyways.
     method_signatures = builder.get_method_signatures(mocking=False)
 
     from clarifai.runners.utils import code_script
@@ -740,12 +743,12 @@ def local_dev(ctx, model_path, pool_size):
 
     logger.info("""\n
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
-# About to start up the local dev runner in this terminal...
+# About to start up the local runner in this terminal...
 # Here is a code snippet to call this model once it start from another terminal:
 """)
     logger.info(snippet)
 
-    logger.info("Now starting the local dev runner...")
+    logger.info("Now starting the local runner...")
 
     # This reads the config.yaml from the model_path so we alter it above first.
     serve(

{clarifai-11.6.3 → clarifai-11.6.4}/clarifai/client/nodepool.py

@@ -280,7 +280,7 @@ class Nodepool(Lister, BaseClient):
     def create_runner(
         self, config_filepath: str = None, runner_config: Dict[str, Any] = None
     ) -> Runner:
-        """Creates a runner for the nodepool. Only needed for local dev runners.
+        """Creates a runner for the nodepool. Only needed for local runners.
 
         Args:
             config_filepath (str): The path to the runner config file.

{clarifai-11.6.3 → clarifai-11.6.4}/clarifai/runners/dockerfile_template/Dockerfile.template

@@ -48,7 +48,7 @@ ENV PYTHONPATH=${PYTHONPATH}:/home/nonroot/main \
     CLARIFAI_COMPUTE_CLUSTER_ID=${CLARIFAI_COMPUTE_CLUSTER_ID} \
     CLARIFAI_API_BASE=${CLARIFAI_API_BASE:-https://api.clarifai.com}
 
-# Finally run the clarifai entrypoint to start the runner loop and local dev server.
+# Finally run the clarifai entrypoint to start the runner loop and local runner server.
 # Note(zeiler): we may want to make this a clarifai CLI call.
 ENTRYPOINT ["python", "-m", "clarifai.runners.server"]
 CMD ["--model_path", "/home/nonroot/main"]

{clarifai-11.6.3 → clarifai-11.6.4}/clarifai/runners/models/model_builder.py

@@ -383,7 +383,7 @@ class ModelBuilder:
             sys.exit(1)
 
     @staticmethod
-    def _set_local_dev_model(config, user_id, app_id, model_id, model_type_id):
+    def _set_local_runner_model(config, user_id, app_id, model_id, model_type_id):
         """
         Sets the model configuration for local development.
         This is used when running the model locally without uploading it to Clarifai.

{clarifai-11.6.3 → clarifai-11.6.4}/clarifai/utils/cli.py

@@ -4,7 +4,7 @@ import pkgutil
 import sys
 import typing as t
 from collections import defaultdict
-from typing import OrderedDict
+from typing import OrderedDict, Tuple
 
 import click
 import yaml
@@ -172,3 +172,52 @@ def validate_context(ctx):
     if ctx.obj == {}:
         logger.error("CLI config file missing. Run `clarifai login` to set up the CLI config.")
         sys.exit(1)
+
+
+def validate_pat_token(pat: str, user_id: str, api_base: str = None) -> Tuple[bool, str]:
+    """
+    Validate a Personal Access Token (PAT) by making a test API call.
+
+    Args:
+        pat (str): The Personal Access Token to validate
+        user_id (str): The user ID associated with the token
+        api_base (str): The API base URL. Defaults to None (uses default).
+
+    Returns:
+        tuple[bool, str]: A tuple of (is_valid, error_message)
+                         If valid: (True, "")
+                         If invalid: (False, error_description)
+    """
+    try:
+        from clarifai_grpc.grpc.api.status import status_code_pb2
+
+        from clarifai.client.user import User
+
+        # Create user client for validation
+        if api_base:
+            user_client = User(user_id=user_id, pat=pat, base_url=api_base)
+        else:
+            user_client = User(user_id=user_id, pat=pat)
+
+        # Try to get user info as a test API call
+        response = user_client.get_user_info()
+
+        if response.status.code == status_code_pb2.SUCCESS:
+            return True, ""
+        else:
+            return False, f"Authentication failed: {response.status.description}"
+
+    except Exception as e:
+        error_msg = str(e)
+
+        # Check for common authentication errors and provide user-friendly messages
+        if "PERMISSION_DENIED" in error_msg or "Unauthorized" in error_msg:
+            return False, "Invalid PAT token or insufficient permissions"
+        elif "UNAUTHENTICATED" in error_msg:
+            return False, "Invalid PAT token"
+        elif "SSL" in error_msg or "certificate" in error_msg:
+            return False, f"SSL/Certificate error: {error_msg}"
+        elif "Connection" in error_msg or "timeout" in error_msg:
+            return False, f"Network connection error: {error_msg}"
+        else:
+            return False, f"Validation error: {error_msg}"

{clarifai-11.6.3 → clarifai-11.6.4}/clarifai/utils/constants.py

@@ -14,20 +14,20 @@ CLARIFAI_USER_ID_ENV_VAR = "CLARIFAI_USER_ID"
 HOME_PATH = Path.home()
 DEFAULT_CONFIG = HOME_PATH / '.config/clarifai/config'
 
-# Default clusters, etc. for local dev runner easy setup
-DEFAULT_LOCAL_DEV_COMPUTE_CLUSTER_ID = "local-dev-compute-cluster"
-DEFAULT_LOCAL_DEV_NODEPOOL_ID = "local-dev-nodepool"
-DEFAULT_LOCAL_DEV_DEPLOYMENT_ID = "local-dev-deployment"
-DEFAULT_LOCAL_DEV_MODEL_ID = "local-dev-model"
-DEFAULT_LOCAL_DEV_APP_ID = "local-dev-runner-app"
+# Default clusters, etc. for local runner easy setup
+DEFAULT_LOCAL_RUNNER_COMPUTE_CLUSTER_ID = "local-runner-compute-cluster"
+DEFAULT_LOCAL_RUNNER_NODEPOOL_ID = "local-runner-nodepool"
+DEFAULT_LOCAL_RUNNER_DEPLOYMENT_ID = "local-runner-deployment"
+DEFAULT_LOCAL_RUNNER_MODEL_ID = "local-runner-model"
+DEFAULT_LOCAL_RUNNER_APP_ID = "local-runner-app"
 
 # FIXME: should have any-to-any for these cases.
-DEFAULT_LOCAL_DEV_MODEL_TYPE = "text-to-text"
+DEFAULT_LOCAL_RUNNER_MODEL_TYPE = "text-to-text"
 
-DEFAULT_LOCAL_DEV_COMPUTE_CLUSTER_CONFIG = {
+DEFAULT_LOCAL_RUNNER_COMPUTE_CLUSTER_CONFIG = {
     "compute_cluster": {
-        "id": DEFAULT_LOCAL_DEV_COMPUTE_CLUSTER_ID,
-        "description": "Default Local Dev Compute Cluster",
+        "id": DEFAULT_LOCAL_RUNNER_COMPUTE_CLUSTER_ID,
+        "description": "Default Local Runner Compute Cluster",
         "cloud_provider": {
             "id": "local",
         },
@@ -37,12 +37,12 @@ DEFAULT_LOCAL_DEV_COMPUTE_CLUSTER_CONFIG = {
     }
 }
 
-DEFAULT_LOCAL_DEV_NODEPOOL_CONFIG = {
+DEFAULT_LOCAL_RUNNER_NODEPOOL_CONFIG = {
     "nodepool": {
-        "id": DEFAULT_LOCAL_DEV_NODEPOOL_ID,
-        "description": "Default Local Dev Nodepool",
+        "id": DEFAULT_LOCAL_RUNNER_NODEPOOL_ID,
+        "description": "Default Local Runner Nodepool",
         "compute_cluster": {
-            "id": DEFAULT_LOCAL_DEV_COMPUTE_CLUSTER_ID,
+            "id": DEFAULT_LOCAL_RUNNER_COMPUTE_CLUSTER_ID,
             "user_id": None,  # This will be set when creating the compute cluster
         },
         "instance_types": [
@@ -50,8 +50,8 @@ DEFAULT_LOCAL_DEV_NODEPOOL_CONFIG = {
                 "id": "local",
                 "compute_info": {
                     "cpu_limit": str(os.cpu_count()),
-                    "cpu_memory": "16Gi",  # made up as we don't schedule based on this for local dev.
-                    "num_accelerators": 0,  # TODO if we need accelerator detection for local dev.
+                    "cpu_memory": "16Gi",  # made up as we don't schedule based on this for local runner.
+                    "num_accelerators": 0,  # TODO if we need accelerator detection for local runner.
                 },
             }
         ],

{clarifai-11.6.3 → clarifai-11.6.4/clarifai.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clarifai
-Version: 11.6.3
+Version: 11.6.4
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
 Author-email: support@clarifai.com

clarifai-11.6.3/clarifai/__init__.py

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