clarifai 11.6.4rc2__py3-none-any.whl → 11.6.5__py3-none-any.whl

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "11.6.4rc2"
+__version__ = "11.6.5"

clarifai/cli/README.md

@@ -8,6 +8,45 @@ Clarifai offers a user-friendly interface for deploying your local model into pr
 * Easy implementation and testing in Python
 * No need for MLops expertise.
 
+## Context Management
+
+Manage CLI contexts for authentication and environment configuration:
+### List all contexts
+```bash
+clarifai config get-contexts
+```
+
+### Switch context
+```bash
+clarifai config use-context production
+```
+### Show current context
+```bash
+clarifai config current-context
+```
+
+### Create new context
+```bash
+clarifai config create-context staging --user-id myuser --pat 678***
+```
+### View entire configuration
+```bash
+clarifai config view
+```
+### Delete a context
+```bash
+clarifai config delete-context old-context
+```
+### Edit configuration file
+```bash
+clarifai config edit
+```
+
+### Print environment variables for the active context
+```bash
+clarifai context env
+```
+
 ## Compute Orchestration
 
 Quick example for deploying a `visual-classifier` model

clarifai/cli/base.py

@@ -1,6 +1,5 @@
 import json
 import os
-import shutil
 import sys
 
 import click
@@ -13,7 +12,6 @@ from clarifai.utils.constants import DEFAULT_BASE, DEFAULT_CONFIG, DEFAULT_UI
 from clarifai.utils.logging import logger
 
 
-# @click.group(cls=CustomMultiGroup)
 @click.group(cls=AliasedGroup)
 @click.version_option(version=__version__)
 @click.option('--config', default=DEFAULT_CONFIG)
@@ -54,42 +52,71 @@ def shell_completion(shell):
     os.system(f"_CLARIFAI_COMPLETE={shell}_source clarifai")
 
 
-@cli.group(
-    ['cfg'],
-    cls=AliasedGroup,
-    context_settings={'max_content_width': shutil.get_terminal_size().columns - 10},
-)
+@cli.group(cls=AliasedGroup)
 def config():
-    """Manage CLI configuration"""
+    """
+    Manage multiple configuration profiles (contexts).
+
+    Authentication Precedence:\n
+      1. Environment variables (e.g., `CLARIFAI_PAT`) are used first if set.
+      2. The settings from the active context are used if no environment variables are provided.\n
+    """
 
 
-@config.command(['e'])
+@cli.command()
+@click.argument('api_url', default=DEFAULT_BASE)
+@click.option('--user_id', required=False, help='User ID')
 @click.pass_context
-def edit(ctx):
-    """Edit the configuration file"""
-    os.system(f'{os.environ.get("EDITOR", "vi")} {ctx.obj.filename}')
+def login(ctx, api_url, user_id):
+    """Login command to set PAT and other configurations."""
+    from clarifai.utils.cli import validate_context_auth
 
+    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 out of env var rather than config): ',
+        'ENVVAR',
+    )
 
-@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)
-    elif 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()))
+    # Validate the Context Credentials
+    validate_context_auth(pat, user_id, api_url)
+
+    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()
+    logger.info(
+        f"Login successful and Configuration saved successfully for context '{context.name}'"
+    )
+
+
+def pat_display(pat):
+    return pat[:5] + "****"
+
+
+def input_or_default(prompt, default):
+    value = input(prompt)
+    return value if value else default
 
 
-@config.command(['list', 'ls'])
+# Context management commands under config group
+@config.command(aliases=['get-contexts', 'list-contexts'])
 @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"""
+    """List all available contexts."""
     if output_format == 'wide':
         columns = {
             '': lambda c: '*' if c.name == ctx.obj.current_context else '',
@@ -106,7 +133,6 @@ def get_contexts(ctx, output_format):
                         additional_columns.add(key)
         for key in sorted(additional_columns):
             columns[key] = lambda c, k=key: getattr(c, k) if hasattr(c, k) else ""
-
         formatter = TableFormatter(
             custom_columns=columns,
         )
@@ -123,101 +149,45 @@ def get_contexts(ctx, output_format):
             print(yaml.safe_dump(dicts))
 
 
-@config.command(['use'])
-@click.argument('context-name', type=str)
+@config.command(aliases=['use-context'])
+@click.argument('name', type=str)
 @click.pass_context
-def use_context(ctx, context_name):
-    """Set the current context"""
-    if context_name not in ctx.obj.contexts:
+def use_context(ctx, name):
+    """Set the current context."""
+    if name not in ctx.obj.contexts:
         raise click.UsageError('Context not found')
-    ctx.obj.current_context = context_name
+    ctx.obj.current_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)
-
-
-@config.command(['cat'])
-@click.pass_obj
-def env(ctx_obj):
-    """Print env vars. Use: eval "$(clarifai config env)" """
-    ctx_obj.current.print_env_vars()
+    print(f'Set {name} as the current context')
 
 
-@cli.command()
-@click.argument('api_url', default=DEFAULT_BASE)
-@click.option('--user_id', required=False, help='User ID')
+@config.command(aliases=['current-context'])
+@click.option('-o', '--output-format', default='name', type=click.Choice(['name', 'json', 'yaml']))
 @click.pass_context
-def login(ctx, api_url, user_id):
-    """Login command to set PAT and other configurations."""
-    from clarifai.utils.cli import validate_context_auth
-
-    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',
-    )
-
-    # Validate the Context Credentials
-    validate_context_auth(pat, user_id, api_url)
-
-    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()
-    logger.info(
-        f"Login successful and Configuration saved successfully for context '{context.name}'"
-    )
-
-
-@cli.group(cls=AliasedGroup)
-def context():
-    """Manage contexts"""
-
-
-def pat_display(pat):
-    return pat[:5] + "****"
-
-
-def input_or_default(prompt, default):
-    value = input(prompt)
-    return value if value else default
+def current_context(ctx, output_format):
+    """Show the current context's details."""
+    if output_format == 'name':
+        print(ctx.obj.current_context)
+    elif 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()))
 
 
-@context.command()
+@config.command(aliases=['create-context', 'set-context'])
 @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(
+def create_context(
     ctx,
     name,
     user_id=None,
     base_url=None,
     pat=None,
 ):
-    """Create a new context"""
+    """Create a new context."""
     from clarifai.utils.cli import validate_context_auth
 
     if name in ctx.obj.contexts:
@@ -234,22 +204,28 @@ def create(
             'personal access token value (default: "ENVVAR" to get our of env var rather than config): ',
             'ENVVAR',
         )
-
-    # Validate the Context Credentials
     validate_context_auth(pat, user_id, base_url)
-
     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()
     logger.info(f"Context '{name}' created successfully")
 
 
-# write a click command to delete a context
-@context.command(['rm'])
+@config.command(aliases=['e'])
+@click.pass_context
+def edit(
+    ctx,
+):
+    """Open the configuration file for editing."""
+    # For now, just open the config file (not per-context)
+    os.system(f'{os.environ.get("EDITOR", "vi")} {ctx.obj.filename}')
+
+
+@config.command(aliases=['delete-context'])
 @click.argument('name')
 @click.pass_context
-def delete(ctx, name):
-    """Delete a context"""
+def delete_context(ctx, name):
+    """Delete a context."""
     if name not in ctx.obj.contexts:
         print(f'{name} is not a valid context')
         sys.exit(1)
@@ -258,16 +234,29 @@ def delete(ctx, name):
     print(f'{name} deleted')
 
 
-@context.command()
-@click.argument('name', type=str)
+@config.command(aliases=['get-env'])
 @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')
+def env(ctx):
+    """Print env vars for the active context."""
+    ctx.obj.current.print_env_vars()
+
+
+@config.command(aliases=['show'])
+@click.option('-o', '--output-format', default='yaml', type=click.Choice(['json', 'yaml']))
+@click.pass_context
+def view(ctx, output_format):
+    """Display the current configuration."""
+    config_dict = {
+        'current-context': ctx.obj.current_context,
+        'contexts': {
+            name: context.to_serializable_dict() for name, context in ctx.obj.contexts.items()
+        },
+    }
+
+    if output_format == 'json':
+        print(json.dumps(config_dict, indent=2))
+    else:
+        print(yaml.safe_dump(config_dict, default_flow_style=False))
 
 
 @cli.command()

clarifai/cli/model.py

@@ -5,7 +5,12 @@ import tempfile
 import click
 
 from clarifai.cli.base import cli, pat_display
-from clarifai.utils.cli import validate_context
+from clarifai.utils.cli import (
+    check_ollama_installed,
+    check_requirements_installed,
+    customize_ollama_model,
+    validate_context,
+)
 from clarifai.utils.constants import (
     DEFAULT_LOCAL_RUNNER_APP_ID,
     DEFAULT_LOCAL_RUNNER_COMPUTE_CLUSTER_CONFIG,
@@ -22,49 +27,6 @@ from clarifai.utils.logging import logger
 from clarifai.utils.misc import GitHubDownloader, clone_github_repo, format_github_repo_url
 
 
-def customize_ollama_model(model_path, model_name, port, context_length):
-    """Customize the Ollama model name in the cloned template files.
-    Args:
-     model_path: Path to the cloned model directory
-     model_name: The model name to set (e.g., 'llama3.1', 'mistral')
-
-    """
-    model_py_path = os.path.join(model_path, "1", "model.py")
-
-    if not os.path.exists(model_py_path):
-        logger.warning(f"Model file {model_py_path} not found, skipping model name customization")
-        return
-
-    try:
-        # Read the model.py file
-        with open(model_py_path, 'r') as file:
-            content = file.read()
-        if model_name:
-            # Replace the default model name in the load_model method
-            content = content.replace(
-                'self.model = os.environ.get("OLLAMA_MODEL_NAME", \'llama3.2\')',
-                f'self.model = os.environ.get("OLLAMA_MODEL_NAME", \'{model_name}\')',
-            )
-
-        if port:
-            # Replace the default port variable in the model.py file
-            content = content.replace("PORT = '23333'", f"PORT = '{port}'")
-
-        if context_length:
-            # Replace the default context length variable in the model.py file
-            content = content.replace(
-                "context_length = '8192'", f"context_length = '{context_length}'"
-            )
-
-        # Write the modified content back to model.py
-        with open(model_py_path, 'w') as file:
-            file.write(content)
-
-    except Exception as e:
-        logger.error(f"Failed to customize Ollama model name in {model_py_path}: {e}")
-        raise
-
-
 @cli.group(
     ['model'], context_settings={'max_content_width': shutil.get_terminal_size().columns - 10}
 )
@@ -125,11 +87,11 @@ def init(
 ):
     """Initialize a new model directory structure.
 
-    Creates the following structure in the specified directory:
-    ├── 1/
-    │   └── model.py
-    ├── requirements.txt
-    └── config.yaml
+    Creates the following structure in the specified directory:\n
+    ├── 1/\n
+    │   └── model.py\n
+    ├── requirements.txt\n
+    └── config.yaml\n
 
     If --github-repo is provided, the entire repository contents will be copied to the target
     directory instead of using default templates. The --github-pat option can be used for authentication
@@ -137,13 +99,6 @@ def init(
     branch to clone from.
 
     MODEL_PATH: Path where to create the model directory structure. If not specified, the current directory is used by default.
-    model_type_id: Type of model to initialize. Options are 'mcp' for MCPModelClass or 'openai' for OpenAIModelClass.
-    github_pat: GitHub Personal Access Token for cloning private repositories.
-    github_url: GitHub repository URL or "user/repo" format or the github folder URL to clone a model files from. If provided, the entire contents of repo/folder will be copied to the target directory instead of using default templates.
-    toolkit: Toolkit to use for model initialization. Currently supports 'ollama'.
-    model_name: Model name to configure when using --toolkit. For ollama toolkit, this sets the Ollama model to use (e.g., 'llama3.1', 'mistral', etc.).
-    port: Port to run the Ollama server on. Defaults to 23333.
-    context_length: Context length for the Ollama model. Defaults to 8192.
     """
     # Resolve the absolute path
     model_path = os.path.abspath(model_path)
@@ -171,6 +126,11 @@ def init(
 
     # --toolkit option
     if toolkit == 'ollama':
+        if not check_ollama_installed():
+            logger.error(
+                "Ollama is not installed. Please install it from `https://ollama.com/` to use the Ollama toolkit."
+            )
+            raise click.Abort()
         github_url = DEFAULT_OLLAMA_MODEL_REPO
         branch = DEFAULT_OLLAMA_MODEL_REPO_BRANCH
 
@@ -251,11 +211,12 @@ def init(
     if (model_name or port or context_length) and (toolkit == 'ollama'):
         customize_ollama_model(model_path, model_name, port, context_length)
 
-    logger.info("Model initialization complete with GitHub repository")
-    logger.info("Next steps:")
-    logger.info("1. Review the model configuration")
-    logger.info("2. Install any required dependencies manually")
-    logger.info("3. Test the model locally using 'clarifai model local-test'")
+    if github_url:
+        logger.info("Model initialization complete with GitHub repository")
+        logger.info("Next steps:")
+        logger.info("1. Review the model configuration")
+        logger.info("2. Install any required dependencies manually")
+        logger.info("3. Test the model locally using 'clarifai model local-test'")
 
     # Fall back to template-based initialization if no GitHub repo or if GitHub repo failed
     if not github_url:
@@ -620,7 +581,7 @@ def local_runner(ctx, model_path, pool_size):
         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-runner compute cluster. Please create a local-runner compute cluster."
+                f"Compute cluster {user_id}/{compute_cluster_id} is not a compute cluster of type 'local-dev'. Please use a compute cluster of type 'local-dev'."
             )
         try:
             compute_cluster_id = ctx.obj.current.compute_cluster_id
@@ -630,7 +591,7 @@ def local_runner(ctx, model_path, pool_size):
     except ValueError:
         raise
     except Exception as e:
-        logger.info(f"Failed to get compute cluster with ID {compute_cluster_id}: {e}")
+        logger.warning(f"Failed to get compute cluster with ID '{compute_cluster_id}':\n{e}")
         y = input(
             f"Compute cluster not found. Do you want to create a new compute cluster {user_id}/{compute_cluster_id}? (y/n): "
         )
@@ -659,7 +620,7 @@ def local_runner(ctx, model_path, pool_size):
             ctx.obj.current.CLARIFAI_NODEPOOL_ID = nodepool.id
             ctx.obj.to_yaml()  # save to yaml file.
     except Exception as e:
-        logger.info(f"Failed to get nodepool with ID {nodepool_id}: {e}")
+        logger.warning(f"Failed to get nodepool with ID '{nodepool_id}':\n{e}")
         y = input(
             f"Nodepool not found. Do you want to create a new nodepool {user_id}/{compute_cluster_id}/{nodepool_id}? (y/n): "
         )
@@ -687,7 +648,7 @@ def local_runner(ctx, model_path, pool_size):
             ctx.obj.current.CLARIFAI_APP_ID = app.id
             ctx.obj.to_yaml()  # save to yaml file.
     except Exception as e:
-        logger.info(f"Failed to get app with ID {app_id}: {e}")
+        logger.warning(f"Failed to get app with ID '{app_id}':\n{e}")
         y = input(f"App not found. Do you want to create a new app {user_id}/{app_id}? (y/n): ")
         if y.lower() != 'y':
             raise click.Abort()
@@ -710,7 +671,7 @@ def local_runner(ctx, model_path, pool_size):
             ctx.obj.current.CLARIFAI_MODEL_ID = model.id
             ctx.obj.to_yaml()  # save to yaml file.
     except Exception as e:
-        logger.info(f"Failed to get model with ID {model_id}: {e}")
+        logger.warning(f"Failed to get model with ID '{model_id}':\n{e}")
         y = input(
             f"Model not found. Do you want to create a new model {user_id}/{app_id}/models/{model_id}? (y/n): "
         )
@@ -730,9 +691,8 @@ def local_runner(ctx, model_path, pool_size):
     # 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 runner.")
+        logger.warning("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:
         version = model_versions[0].model_version
 
@@ -759,12 +719,16 @@ def local_runner(ctx, model_path, pool_size):
             # 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.")
+                logger.warning("Deleted runner that was for an old model version ID.")
+                raise AttributeError(
+                    "Runner deleted because it was associated with an outdated model version."
+                )
         except Exception as e:
-            raise AttributeError("Runner not found in nodepool.") from e
+            logger.warning(f"Failed to get runner with ID '{runner_id}':\n{e}")
+            raise AttributeError("Runner not found in nodepool.")
     except AttributeError:
         logger.info(
-            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."
+            f"Creating the local runner tying this '{user_id}/{app_id}/models/{model.id}' model (version: {version.id}) to the '{user_id}/{compute_cluster_id}/{nodepool_id}' nodepool."
         )
         runner = nodepool.create_runner(
             runner_config={
@@ -792,14 +756,17 @@ def local_runner(ctx, model_path, pool_size):
         # 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.")
+            logger.warning("Deleted deployment that was for an old model version ID.")
+            raise Exception(
+                "Deployment deleted because it was associated with an outdated model version."
+            )
         try:
             deployment_id = ctx.obj.current.deployment_id
         except AttributeError:  # doesn't exist in context but does in API then update the context.
             ctx.obj.current.CLARIFAI_DEPLOYMENT_ID = deployment.id
             ctx.obj.to_yaml()  # save to yaml file.
     except Exception as e:
-        logger.info(f"Failed to get deployment with ID {deployment_id}: {e}")
+        logger.warning(f"Failed to get deployment with ID {deployment_id}:\n{e}")
         y = input(
             f"Deployment not found. Do you want to create a new deployment {user_id}/{compute_cluster_id}/{nodepool_id}/{deployment_id}? (y/n): "
         )
@@ -830,16 +797,17 @@ def local_runner(ctx, model_path, pool_size):
     logger.info(f"Current deployment_id: {deployment_id}")
 
     logger.info(
-        f"Full url for the model: {ctx.obj.current.ui}/users/{user_id}/apps/{app_id}/models/{model.id}/versions/{version.id}"
+        f"Full url for the model:\n{ctx.obj.current.ui}/users/{user_id}/apps/{app_id}/models/{model.id}/versions/{version.id}"
     )
 
     # Now that we have all the context in ctx.obj, we need to update the config.yaml in
     # the model_path directory with the model object containing user_id, app_id, model_id, version_id
     config_file = os.path.join(model_path, 'config.yaml')
     if not os.path.exists(config_file):
-        raise ValueError(
+        logger.error(
             f"config.yaml not found in {model_path}. Please ensure you are passing the correct directory."
         )
+        raise click.Abort()
     config = ModelBuilder._load_config(config_file)
     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.
@@ -857,6 +825,18 @@ def local_runner(ctx, model_path, pool_size):
         ModelBuilder._save_config(config_file, config)
 
     builder = ModelBuilder(model_path, download_validation_only=True)
+    if not check_requirements_installed(model_path):
+        logger.error(f"Requirements not installed for model at {model_path}.")
+        raise click.Abort()
+
+    # Post check while running `clarifai model local-runner` we check if the toolkit is ollama
+    if builder.config.get('toolkit', {}).get('provider') == 'ollama':
+        if not check_ollama_installed():
+            logger.error(
+                "Ollama is not installed. Please install it from `https://ollama.com/` to use the Ollama toolkit."
+            )
+            raise click.Abort()
+
     # don't mock for local runner since you need the dependencies to run the code anyways.
     method_signatures = builder.get_method_signatures(mocking=False)
 
@@ -871,12 +851,15 @@ def local_runner(ctx, model_path, pool_size):
         base_url=ctx.obj.current.api_base,
     )
 
-    logger.info("""\n
-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+    logger.info(f"""\nXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 # 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:
+# Here is a code snippet to call this model once it start from another terminal:{snippet}
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 """)
-    logger.info(snippet)
+
+    logger.info(
+        f"Playground: To chat with your model, visit:\n{ctx.obj.current.ui}/playground?model={model.id}__{version.id}&user_id={user_id}&app_id={app_id}"
+    )
 
     logger.info("Now starting the local runner...")
 

clarifai/client/app.py

@@ -445,7 +445,7 @@ class App(Lister, BaseClient):
         response = self._grpc_request(self.STUB.PostModels, request)
         if response.status.code != status_code_pb2.SUCCESS:
             raise Exception(response.status)
-        self.logger.info("\nModel created\n%s", response.status)
+        self.logger.info(f"Model with ID '{model_id}' is created:\n{response.status}")
         kwargs.update(
             {
                 'model_id': model_id,