clarifai 11.6.4__py3-none-any.whl → 11.6.4rc1__py3-none-any.whl

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "11.6.4"
+__version__ = "11.6.4rc1"

clarifai/cli/base.py

@@ -159,7 +159,7 @@ def env(ctx_obj):
 @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
+    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: ')
@@ -168,17 +168,8 @@ 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")
+    # Validate the Context Credentials
+    validate_context_auth(pat, user_id, api_url)
 
     context = Context(
         name,
@@ -194,7 +185,9 @@ 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}'")
+    logger.info(
+        f"Login successful and Configuration saved successfully for context '{context.name}'"
+    )
 
 
 @cli.group(cls=AliasedGroup)
@@ -225,10 +218,10 @@ def create(
     pat=None,
 ):
     """Create a new context"""
-    from clarifai.utils.cli import validate_pat_token
+    from clarifai.utils.cli import validate_context_auth
 
     if name in ctx.obj.contexts:
-        print(f'{name} already exists')
+        logger.info(f'"{name}" context already exists')
         sys.exit(1)
     if not user_id:
         user_id = input('user id: ')
@@ -242,22 +235,13 @@ 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")
+    # 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()
-    print(f"✓ Context '{name}' created successfully")
+    logger.info(f"Context '{name}' created successfully")
 
 
 # write a click command to delete a context

clarifai/cli/model.py

@@ -4,7 +4,7 @@ import tempfile
 
 import click
 
-from clarifai.cli.base import cli
+from clarifai.cli.base import cli, pat_display
 from clarifai.utils.cli import validate_context
 from clarifai.utils.constants import (
     DEFAULT_LOCAL_RUNNER_APP_ID,
@@ -15,9 +15,54 @@ from clarifai.utils.constants import (
     DEFAULT_LOCAL_RUNNER_MODEL_TYPE,
     DEFAULT_LOCAL_RUNNER_NODEPOOL_CONFIG,
     DEFAULT_LOCAL_RUNNER_NODEPOOL_ID,
+    DEFAULT_OLLAMA_MODEL_REPO,
+    DEFAULT_OLLAMA_MODEL_REPO_BRANCH,
 )
 from clarifai.utils.logging import logger
-from clarifai.utils.misc import clone_github_repo, format_github_repo_url
+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(
@@ -48,21 +93,36 @@ def model():
     help='GitHub Personal Access Token for authentication when cloning private repositories.',
 )
 @click.option(
-    '--github-repo',
+    '--github-url',
     required=False,
     help='GitHub repository URL or "user/repo" format to clone a repository from. If provided, the entire repository contents will be copied to the target directory instead of using default templates.',
 )
 @click.option(
-    '--branch',
+    '--toolkit',
+    type=click.Choice(['ollama'], case_sensitive=False),
     required=False,
-    help='Git branch to clone from the GitHub repository. If not specified, the default branch will be used.',
+    help='Toolkit to use for model initialization. Currently supports "ollama".',
 )
 @click.option(
-    '--local-ollama-model',
-    is_flag=True,
-    help='Create an Ollama model template by cloning from GitHub repository.',
+    '--model-name',
+    required=False,
+    help='Model name to configure when using --toolkit. For ollama toolkit, this sets the Ollama model to use (e.g., "llama3.1", "mistral", etc.).',
+)
+@click.option(
+    '--port',
+    type=str,
+    help='Port to run the Ollama server on. Defaults to 23333.',
+    required=False,
+)
+@click.option(
+    '--context-length',
+    type=str,
+    help='Context length for the Ollama model. Defaults to 8192.',
+    required=False,
 )
-def init(model_path, model_type_id, github_pat, github_repo, branch, local_ollama_model):
+def init(
+    model_path, model_type_id, github_pat, github_url, toolkit, model_name, port, context_length
+):
     """Initialize a new model directory structure.
 
     Creates the following structure in the specified directory:
@@ -77,42 +137,99 @@ def init(model_path, model_type_id, github_pat, github_repo, branch, local_ollam
     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 to clone a repository from. If provided, the entire repository contents 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.
     """
-    # Handle the --local-ollama-model flag
-    if local_ollama_model:
-        if github_repo or branch:
-            raise click.ClickException(
-                "Cannot specify both --local-ollama-model and --github-repo/--branch"
-            )
-        github_repo = "https://github.com/Clarifai/runners-examples"
-        branch = "ollama"
-
     # Resolve the absolute path
     model_path = os.path.abspath(model_path)
 
     # Create the model directory if it doesn't exist
     os.makedirs(model_path, exist_ok=True)
 
-    # Handle GitHub repository cloning if provided
-    if github_repo:
-        logger.info(f"Initializing model from GitHub repository: {github_repo}")
+    # Validate parameters
+    if port and not port.isdigit():
+        logger.error("Invalid value: --port must be a number")
+        raise click.Abort()
+
+    if context_length and not context_length.isdigit():
+        logger.error("Invalid value: --context-length must be a number")
+        raise click.Abort()
+
+    # Validate option combinations
+    if model_name and not (toolkit):
+        logger.error("--model-name can only be used with --toolkit")
+        raise click.Abort()
+
+    if toolkit and (github_url):
+        logger.error("Cannot specify both --toolkit and --github-repo")
+        raise click.Abort()
+
+    # --toolkit option
+    if toolkit == 'ollama':
+        github_url = DEFAULT_OLLAMA_MODEL_REPO
+        branch = DEFAULT_OLLAMA_MODEL_REPO_BRANCH
+
+    if github_url:
+        if not toolkit:
+            owner, repo, branch, folder_path = GitHubDownloader().parse_github_url(url=github_url)
+            logger.info(
+                f"Parsed GitHub repository: owner={owner}, repo={repo}, branch={branch}, folder_path={folder_path}"
+            )
+            if folder_path != "":
+                downloader = GitHubDownloader(
+                    max_retries=3,
+                    github_token=github_pat,
+                )
+                try:
+                    downloader.download_github_folder(
+                        url=github_url,
+                        output_dir=model_path,
+                        github_token=github_pat,
+                    )
+                    logger.info(f"Successfully downloaded folder contents to {model_path}")
+                    logger.info("Model initialization complete with GitHub folder download")
+                    return
+
+                except Exception as e:
+                    logger.error(f"Failed to download GitHub folder: {e}")
+                    # Continue with the rest of the initialization process
+                    github_url = None  # Fall back to template mode
+
+            elif branch and folder_path == "":
+                # When we have a branch but no specific folder path
+                logger.info(
+                    f"Initializing model from GitHub repository: {github_url} (branch: {branch})"
+                )
+
+                # Check if it's a local path or normalize the GitHub repo URL
+                if os.path.exists(github_url):
+                    repo_url = github_url
+                else:
+                    repo_url = format_github_repo_url(github_url)
+                    repo_url = f"https://github.com/{owner}/{repo}"
+
+    if toolkit:
+        logger.info(f"Initializing model from GitHub repository: {github_url}")
 
         # Check if it's a local path or normalize the GitHub repo URL
-        if os.path.exists(github_repo):
-            repo_url = github_repo
+        if os.path.exists(github_url):
+            repo_url = github_url
         else:
-            repo_url = format_github_repo_url(github_repo)
+            repo_url = format_github_repo_url(github_url)
 
+    try:
         # Create a temporary directory for cloning
-        with tempfile.TemporaryDirectory() as temp_dir:
-            clone_dir = os.path.join(temp_dir, "repo")
-
-            # Clone the repository
+        with tempfile.TemporaryDirectory(prefix="clarifai_model_") as clone_dir:
+            # Clone the repository with explicit branch parameter
             if not clone_github_repo(repo_url, clone_dir, github_pat, branch):
-                logger.error(
-                    "Failed to clone repository. Falling back to template-based initialization."
-                )
-                github_repo = None  # Fall back to template mode
+                logger.error(f"Failed to clone repository from {repo_url}")
+                github_url = None  # Fall back to template mode
+
             else:
                 # Copy the entire repository content to target directory (excluding .git)
                 for item in os.listdir(clone_dir):
@@ -127,15 +244,21 @@ def init(model_path, model_type_id, github_pat, github_repo, branch, local_ollam
                     else:
                         shutil.copy2(source_path, target_path)
 
-                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'")
-                return
+    except Exception as e:
+        logger.error(f"Failed to clone GitHub repository: {e}")
+        github_url = None
+
+    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'")
 
     # Fall back to template-based initialization if no GitHub repo or if GitHub repo failed
-    if not github_repo:
+    if not github_url:
         from clarifai.cli.templates.model_templates import (
             get_config_template,
             get_model_template,
@@ -473,9 +596,16 @@ def local_runner(ctx, model_path, pool_size):
     user_id = ctx.obj.current.user_id
     logger.info(f"Current user_id: {user_id}")
     if not user_id:
-        raise ValueError(
-            f"User with ID '{user_id}' not found. Use 'clarifai login' to setup context."
+        logger.error(f"User with ID '{user_id}' not found. Use 'clarifai login' to setup context.")
+        raise click.Abort()
+    pat = ctx.obj.current.pat
+    display_pat = pat_display(pat) if pat else ""
+    logger.info(f"Current PAT: {display_pat}")
+    if not pat:
+        logger.error(
+            "Personal Access Token (PAT) not found. Use 'clarifai login' to setup context."
         )
+        raise click.Abort()
     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...")
 

clarifai/cli/model_templates.py

@@ -0,0 +1,243 @@
+"""Templates for model initialization."""
+
+from clarifai import __version__
+
+
+def get_model_class_template() -> str:
+    """Return the template for a basic ModelClass-based model."""
+    return '''from typing import Iterator, List
+from clarifai.runners.models.model_class import ModelClass
+from clarifai.runners.util.data_utils import Param
+
+class MyModel(ModelClass):
+    """A custom model implementation using ModelClass."""
+
+    def load_model(self):
+        """Load the model here.
+        # TODO: please fill in
+        # Add your model loading logic here
+        """
+        pass
+
+    @ModelClass.method
+    def predict(
+        self,
+        prompt: str = "",
+        chat_history: List[dict] = None,
+        max_tokens: int = Param(default=256, description="The maximum number of tokens to generate. Shorter token lengths will provide faster performance."),
+        temperature: float = Param(default=1.0, description="A decimal number that determines the degree of randomness in the response"),
+        top_p: float = Param(default=1.0, description="An alternative to sampling with temperature, where the model considers the results of the tokens with top_p probability mass."),
+    ) -> str:
+        """This is the method that will be called when the runner is run. It takes in an input and returns an output."""
+        # TODO: please fill in
+        # Implement your prediction logic here
+        pass  # Replace with your actual logic
+
+    @ModelClass.method
+    def generate(
+        self,
+        prompt: str = "",
+        chat_history: List[dict] = None,
+        max_tokens: int = Param(default=256, description="The maximum number of tokens to generate. Shorter token lengths will provide faster performance."),
+        temperature: float = Param(default=1.0, description="A decimal number that determines the degree of randomness in the response"),
+        top_p: float = Param(default=1.0, description="An alternative to sampling with temperature, where the model considers the results of the tokens with top_p probability mass."),
+    ) -> Iterator[str]:
+        """Example yielding a streamed response."""
+        # TODO: please fill in
+        # Implement your generation logic here
+        pass # Replace with your actual logic
+'''
+
+
+def get_mcp_model_class_template() -> str:
+    """Return the template for an MCPModelClass-based model."""
+    return '''from typing import Any
+
+from fastmcp import FastMCP  # use fastmcp v2 not the built in mcp
+from pydantic import Field
+
+from clarifai.runners.models.mcp_class import MCPModelClass
+
+# TODO: please fill in
+# Configure your FastMCP server
+server = FastMCP("my-mcp-server", instructions="", stateless_http=True)
+
+
+# TODO: please fill in
+# Add your tools, resources, and prompts here
+@server.tool("example_tool", description="An example tool")
+def example_tool(input_param: Any = Field(description="Example input parameter")):
+    """Example tool implementation."""
+    # TODO: please fill in
+    # Implement your tool logic here
+    return f"Processed: {input_param}"
+
+
+# Static resource example
+@server.resource("config://version")
+def get_version():
+    """Example static resource."""
+    # TODO: please fill in
+    # Return your resource data
+    return "1.0.0"
+
+
+@server.prompt()
+def example_prompt(text: str) -> str:
+    """Example prompt template."""
+    # TODO: please fill in
+    # Define your prompt template
+    return f"Process this text: {text}"
+
+
+class MyModel(MCPModelClass):
+    """A custom model implementation using MCPModelClass."""
+
+    def get_server(self) -> FastMCP:
+        """Return the FastMCP server instance."""
+        return server
+'''
+
+
+def get_openai_model_class_template() -> str:
+    """Return the template for an OpenAIModelClass-based model."""
+    return '''from typing import List
+from openai import OpenAI
+from clarifai.runners.models.openai_class import OpenAIModelClass
+from clarifai.runners.util.data_utils import Param
+from clarifai.runners.utils.openai_convertor import build_openai_messages
+
+class MyModel(OpenAIModelClass):
+    """A custom model implementation using OpenAIModelClass."""
+
+    # TODO: please fill in
+    # Configure your OpenAI-compatible client for local model
+    client = OpenAI(
+        api_key="local-key",  # TODO: please fill in - use your local API key
+        base_url="http://localhost:8000/v1",  # TODO: please fill in - your local model server endpoint
+    )
+
+    # TODO: please fill in
+    # Specify the model name to use
+    model = "my-local-model"  # TODO: please fill in - replace with your local model name
+
+    def load_model(self):
+        """Optional: Add any additional model loading logic here."""
+        # TODO: please fill in (optional)
+        # Add any initialization logic if needed
+        pass
+
+    @OpenAIModelClass.method
+    def predict(
+        self,
+        prompt: str = "",
+        chat_history: List[dict] = None,
+        max_tokens: int = Param(default=256, description="The maximum number of tokens to generate. Shorter token lengths will provide faster performance."),
+        temperature: float = Param(default=1.0, description="A decimal number that determines the degree of randomness in the response"),
+        top_p: float = Param(default=1.0, description="An alternative to sampling with temperature, where the model considers the results of the tokens with top_p probability mass."),
+    ) -> str:
+        """Run a single prompt completion using the OpenAI client."""
+        # TODO: please fill in
+        # Implement your prediction logic here
+        messages = build_openai_messages(prompt, chat_history)
+        response = self.client.chat.completions.create(
+            model=self.model,
+            messages=messages,
+            max_completion_tokens=max_tokens,
+            temperature=temperature,
+            top_p=top_p,
+        )
+        return response.choices[0].message.content
+
+    @OpenAIModelClass.method
+    def generate(
+        self,
+        prompt: str = "",
+        chat_history: List[dict] = None,
+        max_tokens: int = Param(default=256, description="The maximum number of tokens to generate. Shorter token lengths will provide faster performance."),
+        temperature: float = Param(default=1.0, description="A decimal number that determines the degree of randomness in the response"),
+        top_p: float = Param(default=1.0, description="An alternative to sampling with temperature, where the model considers the results of the tokens with top_p probability mass."),
+    ):
+        """Stream a completion response using the OpenAI client."""
+        # TODO: please fill in
+        # Implement your streaming logic here
+        messages = build_openai_messages(prompt, chat_history)
+        stream = self.client.chat.completions.create(
+            model=self.model,
+            messages=messages,
+            max_completion_tokens=max_tokens,
+            temperature=temperature,
+            top_p=top_p,
+            stream=True,
+        )
+        for chunk in stream:
+            if chunk.choices:
+                text = (chunk.choices[0].delta.content
+                        if (chunk and chunk.choices[0].delta.content) is not None else '')
+                yield text
+'''
+
+
+def get_config_template(model_type_id: str = "text-to-text") -> str:
+    """Return the template for config.yaml."""
+    return f'''# Configuration file for your Clarifai model
+
+model:
+  id: "my-model"  # TODO: please fill in - replace with your model ID
+  user_id: "user_id"  # TODO: please fill in - replace with your user ID
+  app_id: "app_id"  # TODO: please fill in - replace with your app ID
+  model_type_id: "{model_type_id}"  # TODO: please fill in - replace if different model type ID
+
+build_info:
+  python_version: "3.12"
+
+# TODO: please fill in - adjust compute requirements for your model
+inference_compute_info:
+  cpu_limit: "1"  # TODO: please fill in - Amount of CPUs to use as a limit
+  cpu_memory: "1Gi"  # TODO: please fill in - Amount of CPU memory to use as a limit
+  cpu_requests: "0.5"  # TODO: please fill in - Amount of CPUs to use as a minimum
+  cpu_memory_requests: "512Mi"  # TODO: please fill in - Amount of CPU memory to use as a minimum
+  num_accelerators: 1  # TODO: please fill in - Amount of GPU/TPUs to use
+  accelerator_type: ["NVIDIA-*"]  # TODO: please fill in - type of accelerators requested
+  accelerator_memory: "1Gi"  # TODO: please fill in - Amount of accelerator/GPU memory to use as a minimum
+
+# TODO: please fill in (optional) - add checkpoints section if needed
+# checkpoints:
+#   type: "huggingface"  # supported type
+#   repo_id: "your-model-repo"  # for huggingface
+#   when: "build"  # or "runtime", "upload"
+'''
+
+
+def get_requirements_template(model_type_id: str = None) -> str:
+    """Return the template for requirements.txt."""
+    requirements = f'''# Clarifai SDK - required
+clarifai>={__version__}
+'''
+    if model_type_id == "mcp":
+        requirements += "fastmcp\n"
+    elif model_type_id == "openai":
+        requirements += "openai\n"
+    requirements += '''
+# TODO: please fill in - add your model's dependencies here
+# Examples:
+# torch>=2.0.0
+# transformers>=4.30.0
+# numpy>=1.21.0
+# pillow>=9.0.0
+'''
+    return requirements
+
+
+# Mapping of model type IDs to their corresponding templates
+MODEL_TYPE_TEMPLATES = {
+    "mcp": get_mcp_model_class_template,
+    "openai": get_openai_model_class_template,
+}
+
+
+def get_model_template(model_type_id: str = None) -> str:
+    """Get the appropriate model template based on model_type_id."""
+    if model_type_id in MODEL_TYPE_TEMPLATES:
+        return MODEL_TYPE_TEMPLATES[model_type_id]()
+    return get_model_class_template()