clarifai 11.7.5rc1__py3-none-any.whl → 11.8.1__py3-none-any.whl

clarifai/cli/model_templates.py

@@ -1,243 +0,0 @@
-"""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()

clarifai/cli/pipeline_step_templates.py

@@ -1,64 +0,0 @@
-"""Templates for initializing pipeline step projects."""
-
-from clarifai.versions import CLIENT_VERSION
-
-
-def get_config_template():
-    """Get the config.yaml template for pipeline steps."""
-    return """pipeline_step:
-  id: "text-classifier-train-upload-step"  # TODO: please fill in
-  user_id: "your_user_id"  # TODO: please fill in
-  app_id: "your_app_id"  # TODO: please fill in
-
-pipeline_step_input_params:
-  - name: param_a
-  - name: param_b
-    default: "param_b_allowed_value1"
-    description: "param_b is the second parameter of the pipeline step"
-    accepted_values:  # list of accepted values for param_b
-      - "param_b_allowed_value1"
-      - "param_b_allowed_value2"
-      - "param_b_allowed_value3"
-
-build_info:
-  python_version: "3.12"
-
-pipeline_step_compute_info:
-  cpu_limit: "500m"
-  cpu_memory: "500Mi"
-  num_accelerators: 0
-"""
-
-
-def get_pipeline_step_template():
-    """Get the pipeline_step.py template."""
-    return '''import argparse
-
-import clarifai
-
-
-def main():
-    parser = argparse.ArgumentParser(description='Concatenate two strings.')
-    parser.add_argument('--param_a', type=str, required=True, help='First string to concatenate')
-    parser.add_argument('--param_b', type=str, required=True, help='Second string to concatenate')
-
-    args = parser.parse_args()
-
-    print(clarifai.__version__)
-
-    print(f"Concatenation Output: {args.param_a + args.param_b}")
-
-
-if __name__ == "__main__":
-    main()
-'''
-
-
-def get_requirements_template():
-    """Get the requirements.txt template."""
-    return f'''clarifai=={CLIENT_VERSION}
-# Add your pipeline step dependencies here
-# Example:
-# torch>=1.9.0
-# transformers>=4.20.0
-'''

clarifai/models/model_serving/README.md

@@ -1,158 +0,0 @@
-# Clarifai Model Serving
-
-## Overview
-
-Model Serving is a part of user journey at Clarifai offers a user-friendly interface for deploying your local model into production with Clarifai, featuring:
-
-* A convenient command-line interface (CLI)
-* Easy implementation and testing in Python
-* No need for MLops expertise.
-
-## Quickstart Guide
-
-Quick example for deploying a `text-to-text` model
-
-### Initialize a Clarifai model repository
-
-Suppose your working directory name is `your_model_dir`. Then run
-
-```bash
-$ clarifai create model --type text-to-text --working-dir your_model_dir
-$ cd your_model_dir
-```
-
-In `your_model_dir` folder you will see essential files for deployment process
-
-```bash
-your_model_dir
-├── clarifai_config.yaml
-├── inference.py
-├── test.py
-└── requirements.txt
-```
-
-### Implementation
-
-Write your code in class `InferenceModel` which is an interface between your model and Clarifai server in `inference.py`, there are 2 functions you must implement:
-
-* `__init__`: load your model checkpoint once.
-* `predict`: make prediction, called everytime when you make request from API.
-
-For example, a complete implementation of a hf text-generation model
-
-```python
-import os
-from typing import Dict, Union
-from clarifai.models.model_serving.model_config import *
-
-import torch
-from transformers import AutoTokenizer
-import transformers
-
-class InferenceModel(TextToText):
-  """User model inference class."""
-
-  def __init__(self) -> None:
-    """
-    Load inference time artifacts that are called frequently .e.g. models, tokenizers, etc.
-    in this method so they are loaded only once for faster inference.
-    """
-    # current directory
-    self.base_path = os.path.dirname(__file__)
-    # where you save hf checkpoint in your working dir e.i. `your_model_dir`
-    model_path = os.path.join(self.base_path, "checkpoint")
-    self.tokenizer = AutoTokenizer.from_pretrained(model_path)
-    self.pipeline = transformers.pipeline(
-        "text-generation",
-        model=model_path,
-        torch_dtype=torch.float16,
-        device_map="auto",
-    )
-
-  def predict(self, input_data: list,
-              inference_parameters: Dict[str, Union[str, float, int]]) -> list:
-    """ Custom prediction function for `text-to-text` (also called as `text generation`) model.
-
-    Args:
-      input_data (List[str]): List of text
-      inference_parameters (Dict[str, Union[str, float, int]]): your inference parameters
-
-    Returns:
-      list of TextOutput
-
-    """
-    output_sequences = self.pipeline(
-        input_data,
-        eos_token_id=self.tokenizer.eos_token_id,
-        **inference_parameters)
-
-    # wrap outputs in Clarifai defined output
-    return [TextOutput(each[0]) for each in output_sequences]
-```
-
-Update dependencies in `requirements.txt`
-
-```
-clarifai
-torch=2.1.1
-transformers==4.36.2
-accelerate==0.26.1
-```
-
-### Test (optional)
-
-> NOTE: Running `test` is also involved in `build` and `upload` command.
-
-Test and play with your implementation by executing `test.py`.
-
-Install pytest
-
-```bash
-$ pip install pytest
-```
-
-Execute test
-
-```bash
-$ pytest test.py
-```
-
-### Build
-
-Prepare for deployment step. Run:
-
-```bash
-$ clarifai build model
-```
-
-You will obtain `*.clarifai` file, it's simply a zip having all nessecary files in it to get your model work on Clarifai platform.
-
-`NOTE`: you need to upload your built file to cloud storage to get direct download `url` for next step
-
-### Deployment
-
-Login to Clarifai
-
-```bash
-$ clarifai login
-Get your PAT from https://clarifai.com/settings/security and pass it here: <insert your pat here>
-```
-
-Upload
-
-```bash
-# upload built file directly
-$ clarifai upload model <your-working-dir> --user-app <your_user_id>/<your_app_id> --id <your_model_id>
-# or using direct download url of cloud storage
-$ clarifai upload model --url <url> --user-app <your_user_id>/<your_app_id> --id <your_model_id>
-```
-
-## Learn More
-
-* [Detail Instruction](./docs/concepts.md)
-* [Examples](https://github.com/Clarifai/examples/tree/main/model_upload)
-* [Initialize from example](./docs/cli.md)
-* [CLI usage](./docs/cli.md)
-* [Inference parameters](./docs/inference_parameters.md)
-* [Model Types](./docs/model_types.md)
-* [Dependencies](./docs/dependencies.md)