clarifai 11.2.3rc6__py3-none-any.whl → 11.2.3rc8__py3-none-any.whl

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "11.2.3rc6"
+__version__ = "11.2.3rc8"

clarifai/cli/base.py

@@ -1,108 +1,255 @@
+import json
 import os
+import sys
 
 import click
+import yaml
 
-from ..utils.cli import dump_yaml, from_yaml, load_command_modules, set_base_url
+from clarifai.utils.cli import AliasedGroup, TableFormatter, load_command_modules
+from clarifai.utils.config import Config, Context
+from clarifai.utils.constants import DEFAULT_CONFIG
+from clarifai.utils.logging import logger
 
 
-class CustomMultiGroup(click.Group):
+#@click.group(cls=CustomMultiGroup)
+@click.group(cls=AliasedGroup)
+@click.option('--config', default=DEFAULT_CONFIG)
+@click.pass_context
+def cli(ctx, config):
+  """Clarifai CLI"""
+  ctx.ensure_object(dict)
+  if os.path.exists(config):
+    cfg = Config.from_yaml(filename=config)
+    ctx.obj = cfg
+  else:
+    cfg = Config(
+        filename=config,
+        current_context='default',
+        contexts={
+            'default':
+                Context(
+                    'default',
+                    CLARIFAI_PAT=os.environ.get('CLARIFAI_PAT', ''),
+                    CLARIFAI_USER_ID=os.environ.get('CLARIFAI_USER_ID', ''),
+                    CLARIFAI_API_BASE=os.environ.get('CLARIFAI_API_BASE', 'api.clarifai.com'),
+                )
+        })
+    try:
+      cfg.to_yaml(config)
+    except Exception:
+      logger.warning("Could not write configuration to disk. Could be a read only file system.")
+    ctx.obj = cfg  # still have the default config even if couldn't write.
 
-  def group(self, *args, **kwargs):
-    """Behaves the same as `click.Group.group()` except if passed
-        a list of names, all after the first will be aliases for the first.
-        """
 
-    def decorator(f):
-      aliased_group = []
-      if isinstance(args[0], list):
-        # we have a list so create group aliases
-        _args = [args[0][0]] + list(args[1:])
-        for alias in args[0][1:]:
-          grp = super(CustomMultiGroup, self).group(alias, *args[1:], **kwargs)(f)
-          grp.short_help = "Alias for '{}'".format(_args[0])
-          aliased_group.append(grp)
-      else:
-        _args = args
+@cli.command()
+@click.argument('shell', type=click.Choice(['bash', 'zsh']))
+def shell_completion(shell):
+  """Shell completion script"""
+  os.system(f"_CLARIFAI_COMPLETE={shell}_source clarifai")
 
-      # create the main group
-      grp = super(CustomMultiGroup, self).group(*_args, **kwargs)(f)
 
-      # for all of the aliased groups, share the main group commands
-      for aliased in aliased_group:
-        aliased.commands = grp.commands
+@cli.group(['cfg'], cls=AliasedGroup)
+def config():
+  """Manage CLI configuration"""
 
-      return grp
 
-    return decorator
+@config.command(['e'])
+@click.pass_context
+def edit(ctx):
+  """Edit the configuration file"""
+  os.system(f'{os.environ.get("EDITOR", "vi")} {ctx.obj.filename}')
 
 
-@click.group(cls=CustomMultiGroup)
+@config.command(['current'])
+@click.option('-o', '--output-format', default='name', type=click.Choice(['name', 'json', 'yaml']))
 @click.pass_context
-def cli(ctx):
-  """Clarifai CLI"""
-  ctx.ensure_object(dict)
-  config_path = 'config.yaml'
-  if os.path.exists(config_path):
-    ctx.obj = from_yaml(config_path)
+def current_context(ctx, output_format):
+  """Get the current context"""
+  if output_format == 'name':
+    print(ctx.obj.current_context)
   else:
-    ctx.obj = {}
+    if output_format == 'json':
+      print(json.dumps(ctx.obj.contexts[ctx.obj.current_context].to_serializable_dict()))
+    else:
+      print(yaml.safe_dump(ctx.obj.contexts[ctx.obj.current_context].to_serializable_dict()))
 
 
-@cli.command()
-@click.option('--config', type=click.Path(), required=False, help='Path to the config file')
+@config.command(['list', 'ls'])
 @click.option(
-    '-e',
-    '--env',
-    required=False,
-    help='Environment to use, choose from prod, staging and dev',
-    type=click.Choice(['prod', 'staging', 'dev']))
+    '-o', '--output-format', default='wide', type=click.Choice(['wide', 'name', 'json', 'yaml']))
+@click.pass_context
+def get_contexts(ctx, output_format):
+  """Get all contexts"""
+  if output_format == 'wide':
+    formatter = TableFormatter(custom_columns={
+        '': lambda c: '*' if c.name == ctx.obj.current_context else '',
+        'NAME': lambda c: c.name,
+        'USER_ID': lambda c: c.user_id,
+        'API_BASE': lambda c: c.api_base,
+        'PAT': lambda c: pat_display(c.pat),
+    })
+    print(formatter.format(ctx.obj.contexts.values(), fmt="plain"))
+  elif output_format == 'name':
+    print('\n'.join(ctx.obj.contexts))
+  elif output_format in ('json', 'yaml'):
+    dicts = [v.__dict__ for c, v in ctx.obj.contexts.items()]
+    for d in dicts:
+      d.pop('pat')
+    if output_format == 'json':
+      print(json.dumps(dicts))
+    elif output_format == 'yaml':
+      print(yaml.safe_dump(dicts))
+
+
+@config.command(['use'])
+@click.argument('context-name', type=str)
+@click.pass_context
+def use_context(ctx, context_name):
+  """Set the current context"""
+  if context_name not in ctx.obj.contexts:
+    raise click.UsageError('Context not found')
+  ctx.obj.current_context = context_name
+  ctx.obj.to_yaml()
+  print(f'Set {context_name} as the current context')
+
+
+@config.command(['cat'])
+@click.option('-o', '--output-format', default='yaml', type=click.Choice(['yaml', 'json']))
+@click.pass_obj
+def dump(ctx_obj, output_format):
+  """Dump the configuration to stdout"""
+  if output_format == 'yaml':
+    yaml.safe_dump(ctx_obj.to_dict(), sys.stdout)
+  else:
+    json.dump(ctx_obj.to_dict(), sys.stdout, indent=2)
+
+
+@cli.command()
+@click.argument('api_url', default="https://api.clarifai.com")
 @click.option('--user_id', required=False, help='User ID')
 @click.pass_context
-def login(ctx, config, env, user_id):
+def login(ctx, api_url, user_id):
   """Login command to set PAT and other configurations."""
 
-  if config and os.path.exists(config):
-    ctx.obj = from_yaml(config)
+  name = input('context name (default: "default"): ')
+  user_id = user_id if user_id is not None else input('user id: ')
+  pat = input_or_default(
+      'personal access token value (default: "ENVVAR" to get our of env var rather than config): ',
+      'ENVVAR')
 
-  if 'pat' in ctx.obj:
-    os.environ["CLARIFAI_PAT"] = ctx.obj['pat']
-    click.echo("Loaded PAT from config file.")
-  elif 'CLARIFAI_PAT' in os.environ:
-    ctx.obj['pat'] = os.environ["CLARIFAI_PAT"]
-    click.echo("Loaded PAT from environment variable.")
-  else:
-    _pat = click.prompt(
-        "Get your PAT from https://clarifai.com/settings/security and pass it here", type=str)
-    os.environ["CLARIFAI_PAT"] = _pat
-    ctx.obj['pat'] = _pat
-    click.echo("PAT saved successfully.")
-
-  if user_id:
-    ctx.obj['user_id'] = user_id
-    os.environ["CLARIFAI_USER_ID"] = ctx.obj['user_id']
-  elif 'user_id' in ctx.obj:
-    ctx.obj['user_id'] = ctx.obj.get('user_id', "")
-    os.environ["CLARIFAI_USER_ID"] = ctx.obj['user_id']
-  elif 'CLARIFAI_USER_ID' in os.environ:
-    ctx.obj['user_id'] = os.environ["CLARIFAI_USER_ID"]
-  else:
-    user_id = click.prompt("Pass the User ID here", type=str)
-    os.environ["CLARIFAI_USER_ID"] = user_id
-    ctx.obj['user_id'] = user_id
-    click.echo("User ID saved successfully.")
-
-  if env:
-    ctx.obj['env'] = env
-    ctx.obj['base_url'] = set_base_url(env)
-    os.environ["CLARIFAI_API_BASE"] = ctx.obj['base_url']
-  elif 'env' in ctx.obj:
-    ctx.obj['env'] = ctx.obj.get('env', "prod")
-    ctx.obj['base_url'] = set_base_url(ctx.obj['env'])
-    os.environ["CLARIFAI_API_BASE"] = ctx.obj['base_url']
-  elif 'CLARIFAI_API_BASE' in os.environ:
-    ctx.obj['base_url'] = os.environ["CLARIFAI_API_BASE"]
-
-  dump_yaml(ctx.obj, 'config.yaml')
+  context = Context(
+      name,
+      CLARIFAI_API_BASE=api_url,
+      CLARIFAI_USER_ID=user_id,
+      CLARIFAI_PAT=pat,
+  )
+
+  if context.name == '':
+    context.name = 'default'
+
+  ctx.obj.contexts[context.name] = context
+  ctx.obj.current_context = context.name
+
+  ctx.obj.to_yaml()
+
+
+@cli.group(cls=AliasedGroup)
+def context():
+  """Manage contexts"""
+
+
+def pat_display(pat):
+  return pat[:5] + "****"
+
+
+@context.command(['ls'])
+@click.pass_context
+def list(ctx):
+  """List available contexts"""
+  formatter = TableFormatter(custom_columns={
+      '': lambda c: '*' if c.name == ctx.obj.current_context else '',
+      'NAME': lambda c: c.name,
+      'USER_ID': lambda c: c.user_id,
+      'API_BASE': lambda c: c.api_base,
+      'PAT': lambda c: pat_display(c.pat)
+  })
+  print(formatter.format(ctx.obj.contexts.values(), fmt="plain"))
+
+
+def input_or_default(prompt, default):
+  value = input(prompt)
+  return value if value else default
+
+
+@context.command()
+@click.argument('name')
+@click.option('--user-id', required=False, help='User ID')
+@click.option('--base-url', required=False, help='Base URL')
+@click.option('--pat', required=False, help='Personal access token')
+@click.pass_context
+def create(
+    ctx,
+    name,
+    user_id=None,
+    base_url=None,
+    pat=None,
+):
+  """Create a new context"""
+  if name in ctx.obj.contexts:
+    print(f'{name} already exists')
+    exit(1)
+  if not user_id:
+    user_id = input('user id: ')
+  if not base_url:
+    base_url = input_or_default('base url (default: https://api.clarifai.com): ',
+                                'https://api.clarifai.com')
+  if not pat:
+    pat = input_or_default(
+        'personal access token value (default: "ENVVAR" to get our of env var rather than config): ',
+        'ENVVAR')
+
+  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()
+
+
+# write a click command to delete a context
+@context.command(['rm'])
+@click.argument('name')
+@click.pass_context
+def delete(ctx, name):
+  """Delete a context"""
+  if name not in ctx.obj.contexts:
+    print(f'{name} is not a valid context')
+    exit(1)
+  ctx.obj.contexts.pop(name)
+  ctx.obj.to_yaml()
+  print(f'{name} deleted')
+
+
+@context.command()
+@click.argument('name', type=str)
+@click.pass_context
+def use(ctx, name):
+  """Set the current context"""
+  if name not in ctx.obj.contexts:
+    raise click.UsageError('Context not found')
+  ctx.obj.current_context = name
+  ctx.obj.to_yaml()
+  print(f'Set {name} as the current context')
+
+
+@cli.command()
+@click.argument('script', type=str)
+@click.option('--context', type=str, help='Context to use')
+@click.pass_context
+def run(ctx, script, context=None):
+  """Execute a script with the current context's environment"""
+  context = ctx.obj.current if not context else context
+  cmd = f'CLARIFAI_USER_ID={context.user_id} CLARIFAI_API_BASE={context.base_url} CLARIFAI_PAT={context.pat} '
+  cmd += ' '.join([f'{k}={v}' for k, v in context.env.items()])
+  cmd += f' {script}'
+  os.system(cmd)
 
 
 # Import the CLI commands to register them

clarifai/cli/compute_cluster.py

@@ -1,51 +1,61 @@
 import click
+
 from clarifai.cli.base import cli
-from clarifai.client.user import User
-from clarifai.utils.cli import display_co_resources
+from clarifai.utils.cli import AliasedGroup, display_co_resources, validate_context
 
 
-@cli.group(['computecluster', 'cc'])
+@cli.group(['computecluster', 'cc'], cls=AliasedGroup)
 def computecluster():
   """Manage Compute Clusters: create, delete, list"""
-  pass
 
 
-@computecluster.command()
+@computecluster.command(['c'])
+@click.argument('compute_cluster_id')
 @click.option(
     '--config',
     type=click.Path(exists=True),
     required=True,
     help='Path to the compute cluster config file.')
-@click.option(
-    '-cc_id',
-    '--compute_cluster_id',
-    required=False,
-    help='New Compute Cluster ID for the compute cluster to create.')
 @click.pass_context
-def create(ctx, config, compute_cluster_id):
+def create(ctx, compute_cluster_id, config):
   """Create a new Compute Cluster with the given config file."""
-  user = User(user_id=ctx.obj['user_id'], pat=ctx.obj['pat'], base_url=ctx.obj['base_url'])
+  from clarifai.client.user import User
+  validate_context(ctx)
+  user = User(
+      user_id=ctx.obj.current.user_id, pat=ctx.obj.current.pat, base_url=ctx.obj.current.api_base)
   if compute_cluster_id:
     user.create_compute_cluster(config, compute_cluster_id=compute_cluster_id)
   else:
     user.create_compute_cluster(config)
 
 
-@computecluster.command()
+@computecluster.command(['ls'])
 @click.option('--page_no', required=False, help='Page number to list.', default=1)
 @click.option('--per_page', required=False, help='Number of items per page.', default=16)
 @click.pass_context
 def list(ctx, page_no, per_page):
   """List all compute clusters for the user."""
-  user = User(user_id=ctx.obj['user_id'], pat=ctx.obj['pat'], base_url=ctx.obj['base_url'])
+  from clarifai.client.user import User
+  validate_context(ctx)
+  user = User(
+      user_id=ctx.obj.current.user_id, pat=ctx.obj.current.pat, base_url=ctx.obj.current.api_base)
   response = user.list_compute_clusters(page_no, per_page)
-  display_co_resources(response, "Compute Cluster")
+  display_co_resources(
+      response,
+      custom_columns={
+          'ID': lambda c: c.id,
+          'USER_ID': lambda c: c.user_id,
+          'DESCRIPTION': lambda c: c.description,
+      })
 
 
-@computecluster.command()
-@click.option('-cc_id', '--compute_cluster_id', help='Compute Cluster ID of the user to delete.')
+@computecluster.command(['rm'])
+@click.argument('compute_cluster_id')
 @click.pass_context
 def delete(ctx, compute_cluster_id):
   """Deletes a compute cluster for the user."""
-  user = User(user_id=ctx.obj['user_id'], pat=ctx.obj['pat'], base_url=ctx.obj['base_url'])
+  from clarifai.client.user import User
+  validate_context(ctx)
+  user = User(
+      user_id=ctx.obj.current.user_id, pat=ctx.obj.current.pat, base_url=ctx.obj.current.api_base)
   user.delete_compute_clusters([compute_cluster_id])

clarifai/cli/deployment.py

@@ -1,84 +1,112 @@
 import click
+
 from clarifai.cli.base import cli
-from clarifai.client.nodepool import Nodepool
-from clarifai.utils.cli import display_co_resources, from_yaml
+from clarifai.utils.cli import AliasedGroup, display_co_resources, from_yaml, validate_context
 
 
-@cli.group(['deployment', 'dpl'])
+@cli.group(['deployment', 'dp'], cls=AliasedGroup)
 def deployment():
   """Manage Deployments: create, delete, list"""
-  pass
 
 
-@deployment.command()
-@click.option(
-    '-np_id',
-    '--nodepool_id',
-    required=False,
-    help='Nodepool ID for the Nodepool to interact with.')
+@deployment.command(['c'])
+@click.argument('nodepool_id')
+@click.argument('deployment_id')
 @click.option(
     '--config',
     type=click.Path(exists=True),
     required=True,
     help='Path to the deployment config file.')
-@click.option(
-    '-dpl_id',
-    '--deployment_id',
-    required=False,
-    help='New deployment ID for the deployment to create.')
 @click.pass_context
-def create(ctx, nodepool_id, config, deployment_id):
+def create(ctx, nodepool_id, deployment_id, config):
   """Create a new Deployment with the given config file."""
+
+  from clarifai.client.nodepool import Nodepool
+  validate_context(ctx)
   if not nodepool_id:
     deployment_config = from_yaml(config)
     nodepool_id = deployment_config['deployment']['nodepools'][0]['id']
 
   nodepool = Nodepool(
       nodepool_id=nodepool_id,
-      user_id=ctx.obj['user_id'],
-      pat=ctx.obj['pat'],
-      base_url=ctx.obj['base_url'])
+      user_id=ctx.obj.current.user_id,
+      pat=ctx.obj.current.pat,
+      base_url=ctx.obj.current.api_base)
   if deployment_id:
     nodepool.create_deployment(config, deployment_id=deployment_id)
   else:
     nodepool.create_deployment(config)
 
 
-@deployment.command()
-@click.option(
-    '-np_id',
-    '--nodepool_id',
-    required=True,
-    help='Nodepool ID for the Nodepool to interact with.')
+@deployment.command(['ls'])
+@click.argument('nodepool_id', default="")
 @click.option('--page_no', required=False, help='Page number to list.', default=1)
 @click.option('--per_page', required=False, help='Number of items per page.', default=16)
 @click.pass_context
 def list(ctx, nodepool_id, page_no, per_page):
   """List all deployments for the nodepool."""
+  from clarifai.client.compute_cluster import ComputeCluster
+  from clarifai.client.nodepool import Nodepool
+  from clarifai.client.user import User
 
-  nodepool = Nodepool(
-      nodepool_id=nodepool_id,
-      user_id=ctx.obj['user_id'],
-      pat=ctx.obj['pat'],
-      base_url=ctx.obj['base_url'])
-  response = nodepool.list_deployments(page_no=page_no, per_page=per_page)
-  display_co_resources(response, "Deployment")
+  validate_context(ctx)
+  if nodepool_id:
+    nodepool = Nodepool(
+        nodepool_id=nodepool_id,
+        user_id=ctx.obj.current.user_id,
+        pat=ctx.obj.current.pat,
+        base_url=ctx.obj.current.api_base)
+    response = nodepool.list_deployments(page_no=page_no, per_page=per_page)
+  else:
+    user = User(
+        user_id=ctx.obj.current.user_id,
+        pat=ctx.obj.current.pat,
+        base_url=ctx.obj.current.api_base)
+    ccs = user.list_compute_clusters(page_no, per_page)
+    nps = []
+    for cc in ccs:
+      compute_cluster = ComputeCluster(
+          compute_cluster_id=cc.id,
+          user_id=ctx.obj.current.user_id,
+          pat=ctx.obj.current.pat,
+          base_url=ctx.obj.current.api_base)
+      nps.extend([i for i in compute_cluster.list_nodepools(page_no, per_page)])
+    response = []
+    for np in nps:
+      nodepool = Nodepool(
+          nodepool_id=np.id,
+          user_id=ctx.obj.current.user_id,
+          pat=ctx.obj.current.pat,
+          base_url=ctx.obj.current.api_base)
+      response.extend([i for i in nodepool.list_deployments(page_no=page_no, per_page=per_page)])
 
+  display_co_resources(
+      response,
+      custom_columns={
+          'ID': lambda c: c.id,
+          'USER_ID': lambda c: c.user_id,
+          'COMPUTE_CLUSTER_ID': lambda c: c.nodepools[0].compute_cluster.id,
+          'NODEPOOL_ID': lambda c: c.nodepools[0].id,
+          'MODEL_USER_ID': lambda c: c.worker.model.user_id,
+          'MODEL_APP_ID': lambda c: c.worker.model.app_id,
+          'MODEL_ID': lambda c: c.worker.model.id,
+          'MODEL_VERSION_ID': lambda c: c.worker.model.model_version.id,
+          'DESCRIPTION': lambda c: c.description,
+      })
 
-@deployment.command()
-@click.option(
-    '-np_id',
-    '--nodepool_id',
-    required=True,
-    help='Nodepool ID for the Nodepool to interact with.')
-@click.option('-dpl_id', '--deployment_id', help='Deployment ID of the nodepool to delete.')
+
+@deployment.command(['rm'])
+@click.argument('nodepool_id')
+@click.argument('deployment_id')
 @click.pass_context
 def delete(ctx, nodepool_id, deployment_id):
   """Deletes a deployment for the nodepool."""
+  from clarifai.client.nodepool import Nodepool
 
+  validate_context(ctx)
   nodepool = Nodepool(
       nodepool_id=nodepool_id,
-      user_id=ctx.obj['user_id'],
-      pat=ctx.obj['pat'],
-      base_url=ctx.obj['base_url'])
+      user_id=ctx.obj.current.user_id,
+      pat=ctx.obj.current.pat,
+      base_url=ctx.obj.current.api_base)
   nodepool.delete_deployments([deployment_id])

clarifai/cli/model.py

@@ -5,7 +5,7 @@ from clarifai.cli.base import cli
 
 @cli.group(['model'])
 def model():
-  """Manage models: upload, test locally, run locally, predict, and more"""
+  """Manage models: upload, test, local dev, predict, etc"""
 
 
 @model.command()
@@ -121,11 +121,14 @@ def signatures(model_path, out_path):
     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.
-
-  MODEL_PATH: Path to the model directory. If not specified, the current directory is used by 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. Apply for `--mode conatainer`.',
+)
+def test_locally(model_path, keep_env=False, keep_image=False, mode='env', skip_dockerfile=False):
+  """Test model locally."""
   try:
     from clarifai.runners.models import model_run_locally
     if mode == 'env' and keep_image:
@@ -139,7 +142,11 @@ def test_locally(model_path, keep_env=False, keep_image=False, mode='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)
+          model_path,
+          inside_container=True,
+          run_model_server=False,
+          keep_image=keep_image,
+          skip_dockerfile=skip_dockerfile)
     click.echo("Model tested successfully.")
   except Exception as e:
     click.echo(f"Failed to test model locally: {e}", err=True)
@@ -179,11 +186,14 @@ def test_locally(model_path, keep_env=False, keep_image=False, mode='env'):
     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.
-
-  MODEL_PATH: Path to the model directory. If not specified, the current directory is used by 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. Apply for `--mode conatainer`.',
+)
+def run_locally(model_path, port, mode, keep_env, keep_image, skip_dockerfile=False):
+  """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:
@@ -201,7 +211,8 @@ def run_locally(model_path, port, mode, keep_env, keep_image):
           inside_container=True,
           run_model_server=True,
           port=port,
-          keep_image=keep_image)
+          keep_image=keep_image,
+          skip_dockerfile=skip_dockerfile)
     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)
@@ -255,7 +266,8 @@ def predict(ctx, config, model_id, user_id, app_id, model_url, file_path, url, b
   import json
 
   from clarifai.client.model import Model
-  from clarifai.utils.cli import from_yaml
+  from clarifai.utils.cli import from_yaml, validate_context
+  validate_context(ctx)
   if config:
     config = from_yaml(config)
     model_id, user_id, app_id, model_url, file_path, url, bytes, input_type, compute_cluster_id, nodepool_id, deployment_id, inference_params, output_config = (