clarifai 11.2.3rc1__py3-none-any.whl → 11.2.3rc2__py3-none-any.whl

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "11.2.3rc1"
+__version__ = "11.2.3rc2"

clarifai/cli/base.py

@@ -1,255 +1,108 @@
-import json
 import os
-import sys
 
 import click
-import yaml
 
-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
+from ..utils.cli import dump_yaml, from_yaml, load_command_modules, set_base_url
 
 
-#@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.
-
-
-@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")
-
-
-@cli.group(['cfg'], cls=AliasedGroup)
-def config():
-  """Manage CLI configuration"""
+class CustomMultiGroup(click.Group):
 
+  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.
+        """
 
-@config.command(['e'])
-@click.pass_context
-def edit(ctx):
-  """Edit the configuration file"""
-  os.system(f'{os.environ.get("EDITOR", "vi")} {ctx.obj.filename}')
+    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
 
+      # create the main group
+      grp = super(CustomMultiGroup, self).group(*_args, **kwargs)(f)
 
-@config.command(['current'])
-@click.option('-o', '--output-format', default='name', type=click.Choice(['name', 'json', 'yaml']))
-@click.pass_context
-def current_context(ctx, output_format):
-  """Get the current context"""
-  if output_format == 'name':
-    print(ctx.obj.current_context)
-  else:
-    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()))
+      # for all of the aliased groups, share the main group commands
+      for aliased in aliased_group:
+        aliased.commands = grp.commands
 
+      return grp
 
-@config.command(['list', 'ls'])
-@click.option(
-    '-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))
+    return decorator
 
 
-@config.command(['use'])
-@click.argument('context-name', type=str)
+@click.group(cls=CustomMultiGroup)
 @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)
+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)
   else:
-    json.dump(ctx_obj.to_dict(), sys.stdout, indent=2)
+    ctx.obj = {}
 
 
 @cli.command()
-@click.argument('api_url', default="https://api.clarifai.com")
+@click.option('--config', type=click.Path(), required=False, help='Path to the config file')
+@click.option(
+    '-e',
+    '--env',
+    required=False,
+    help='Environment to use, choose from prod, staging and dev',
+    type=click.Choice(['prod', 'staging', 'dev']))
 @click.option('--user_id', required=False, help='User ID')
 @click.pass_context
-def login(ctx, api_url, user_id):
+def login(ctx, config, env, user_id):
   """Login command to set PAT and other configurations."""
 
-  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')
-
-  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()
-
+  if config and os.path.exists(config):
+    ctx.obj = from_yaml(config)
 
-@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)
+  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')
 
 
 # Import the CLI commands to register them

clarifai/cli/compute_cluster.py

@@ -1,59 +1,51 @@
 import click
-
 from clarifai.cli.base import cli
 from clarifai.client.user import User
-from clarifai.utils.cli import AliasedGroup, display_co_resources, validate_context
+from clarifai.utils.cli import display_co_resources
 
 
-@cli.group(['computecluster', 'cc'], cls=AliasedGroup)
+@cli.group(['computecluster', 'cc'])
 def computecluster():
   """Manage Compute Clusters: create, delete, list"""
+  pass
 
 
-@computecluster.command(['c'])
-@click.argument('compute_cluster_id')
+@computecluster.command()
 @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, compute_cluster_id, config):
+def create(ctx, config, compute_cluster_id):
   """Create a new Compute Cluster with the given config file."""
-  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 = User(user_id=ctx.obj['user_id'], pat=ctx.obj['pat'], base_url=ctx.obj['base_url'])
   if compute_cluster_id:
     user.create_compute_cluster(config, compute_cluster_id=compute_cluster_id)
   else:
     user.create_compute_cluster(config)
 
 
-@computecluster.command(['ls'])
+@computecluster.command()
 @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."""
-  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 = User(user_id=ctx.obj['user_id'], pat=ctx.obj['pat'], base_url=ctx.obj['base_url'])
   response = user.list_compute_clusters(page_no, per_page)
-  display_co_resources(
-      response,
-      custom_columns={
-          'ID': lambda c: c.id,
-          'USER_ID': lambda c: c.user_id,
-          'DESCRIPTION': lambda c: c.description,
-      })
+  display_co_resources(response, "Compute Cluster")
 
 
-@computecluster.command(['rm'])
-@click.argument('compute_cluster_id')
+@computecluster.command()
+@click.option('-cc_id', '--compute_cluster_id', help='Compute Cluster ID of the user to delete.')
 @click.pass_context
 def delete(ctx, compute_cluster_id):
   """Deletes a compute cluster for the 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 = User(user_id=ctx.obj['user_id'], pat=ctx.obj['pat'], base_url=ctx.obj['base_url'])
   user.delete_compute_clusters([compute_cluster_id])

clarifai/cli/deployment.py

@@ -1,110 +1,84 @@
 import click
-
 from clarifai.cli.base import cli
-from clarifai.client.compute_cluster import ComputeCluster
 from clarifai.client.nodepool import Nodepool
-from clarifai.client.user import User
-from clarifai.utils.cli import AliasedGroup, display_co_resources, from_yaml, validate_context
+from clarifai.utils.cli import display_co_resources, from_yaml
 
 
-@cli.group(['deployment', 'dp'], cls=AliasedGroup)
+@cli.group(['deployment', 'dpl'])
 def deployment():
   """Manage Deployments: create, delete, list"""
+  pass
 
 
-@deployment.command(['c'])
-@click.argument('nodepool_id')
-@click.argument('deployment_id')
+@deployment.command()
+@click.option(
+    '-np_id',
+    '--nodepool_id',
+    required=False,
+    help='Nodepool ID for the Nodepool to interact with.')
 @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, deployment_id, config):
+def create(ctx, nodepool_id, config, deployment_id):
   """Create a new Deployment with the given config file."""
-
-  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.current.user_id,
-      pat=ctx.obj.current.pat,
-      base_url=ctx.obj.current.api_base)
+      user_id=ctx.obj['user_id'],
+      pat=ctx.obj['pat'],
+      base_url=ctx.obj['base_url'])
   if deployment_id:
     nodepool.create_deployment(config, deployment_id=deployment_id)
   else:
     nodepool.create_deployment(config)
 
 
-@deployment.command(['ls'])
-@click.argument('nodepool_id', default="")
+@deployment.command()
+@click.option(
+    '-np_id',
+    '--nodepool_id',
+    required=True,
+    help='Nodepool ID for the Nodepool to interact with.')
 @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."""
 
-  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,
-      })
+  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")
 
 
-@deployment.command(['rm'])
-@click.argument('nodepool_id')
-@click.argument('deployment_id')
+@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.')
 @click.pass_context
 def delete(ctx, nodepool_id, deployment_id):
   """Deletes a deployment for the nodepool."""
 
-  validate_context(ctx)
   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)
+      user_id=ctx.obj['user_id'],
+      pat=ctx.obj['pat'],
+      base_url=ctx.obj['base_url'])
   nodepool.delete_deployments([deployment_id])