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

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()

clarifai/cli/pipeline.py

@@ -229,12 +229,34 @@ def init(pipeline_path):
     # Create the pipeline directory if it doesn't exist
     os.makedirs(pipeline_path, exist_ok=True)
 
+    # Prompt for user inputs
+    click.echo("Welcome to Clarifai Pipeline Initialization!")
+    click.echo("Please provide the following information:")
+
+    user_id = click.prompt("User ID", type=str)
+    app_id = click.prompt("App ID", type=str)
+    pipeline_id = click.prompt("Pipeline ID", default="hello-world-pipeline", type=str)
+    num_steps = click.prompt("Number of pipeline steps", default=2, type=int)
+
+    # Get step names
+    step_names = []
+    default_names = ["stepA", "stepB", "stepC", "stepD", "stepE", "stepF"]
+
+    for i in range(num_steps):
+        default_name = default_names[i] if i < len(default_names) else f"step{i + 1}"
+        step_name = click.prompt(f"Name for step {i + 1}", default=default_name, type=str)
+        step_names.append(step_name)
+
+    click.echo(f"\nCreating pipeline '{pipeline_id}' with steps: {', '.join(step_names)}")
+
     # Create pipeline config.yaml
     config_path = os.path.join(pipeline_path, "config.yaml")
     if os.path.exists(config_path):
         logger.warning(f"File {config_path} already exists, skipping...")
     else:
-        config_template = get_pipeline_config_template()
+        config_template = get_pipeline_config_template(
+            pipeline_id=pipeline_id, user_id=user_id, app_id=app_id, step_names=step_names
+        )
         with open(config_path, 'w', encoding='utf-8') as f:
             f.write(config_template)
         logger.info(f"Created {config_path}")
@@ -249,8 +271,8 @@ def init(pipeline_path):
             f.write(readme_template)
         logger.info(f"Created {readme_path}")
 
-    # Create pipeline steps (stepA and stepB)
-    for step_id in ["stepA", "stepB"]:
+    # Create pipeline steps
+    for step_id in step_names:
         step_dir = os.path.join(pipeline_path, step_id)
         os.makedirs(step_dir, exist_ok=True)
 
@@ -263,7 +285,9 @@ def init(pipeline_path):
         if os.path.exists(step_config_path):
             logger.warning(f"File {step_config_path} already exists, skipping...")
         else:
-            step_config_template = get_pipeline_step_config_template(step_id)
+            step_config_template = get_pipeline_step_config_template(
+                step_id=step_id, user_id=user_id, app_id=app_id
+            )
             with open(step_config_path, 'w', encoding='utf-8') as f:
                 f.write(step_config_template)
             logger.info(f"Created {step_config_path}")
@@ -290,13 +314,9 @@ def init(pipeline_path):
 
     logger.info(f"Pipeline initialization complete in {pipeline_path}")
     logger.info("Next steps:")
-    logger.info("1. Search for '# TODO: please fill in' comments in the generated files")
-    logger.info("2. Update your user_id and app_id in all config.yaml files")
-    logger.info(
-        "3. Implement your pipeline step logic in stepA/1/pipeline_step.py and stepB/1/pipeline_step.py"
-    )
-    logger.info("4. Add dependencies to requirements.txt files as needed")
-    logger.info("5. Run 'clarifai pipeline upload config.yaml' to upload your pipeline")
+    logger.info("1. Implement your pipeline step logic in the generated pipeline_step.py files")
+    logger.info("2. Add dependencies to requirements.txt files as needed")
+    logger.info("3. Run 'clarifai pipeline upload config.yaml' to upload your pipeline")
 
 
 @pipeline.command(['ls'])

clarifai/cli/pipeline_step_templates.py

@@ -0,0 +1,64 @@
+"""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/cli/templates/pipeline_templates.py

@@ -3,43 +3,55 @@
 from clarifai.versions import CLIENT_VERSION
 
 
-def get_pipeline_config_template():
+def get_pipeline_config_template(
+    pipeline_id="hello-world-pipeline",
+    user_id="your_user_id",
+    app_id="your_app_id",
+    step_names=None,
+):
     """Get the config.yaml template for pipelines."""
-    return """pipeline:
-  id: "hello-world-pipeline"  # TODO: please fill in
-  user_id: "your_user_id"  # TODO: please fill in
-  app_id: "your_app_id"  # TODO: please fill in
+    if step_names is None:
+        step_names = ["stepA", "stepB"]
+
+    step_directories = "\n".join(f"    - {step}" for step in step_names)
+
+    # Generate step templates for orchestration
+    step_templates = []
+    for i, step_name in enumerate(step_names):
+        step_templates.append(f"""          - - name: step-{i}
+              templateRef:
+                name: users/{user_id}/apps/{app_id}/pipeline_steps/{step_name}
+                template: users/{user_id}/apps/{app_id}/pipeline_steps/{step_name}""")
+
+    steps_yaml = "\n".join(step_templates)
+
+    return f"""pipeline:
+  id: "{pipeline_id}"
+  user_id: "{user_id}"
+  app_id: "{app_id}"
   step_directories:
-    - stepA
-    - stepB
+{step_directories}
   orchestration_spec:
     argo_orchestration_spec: |
       apiVersion: argoproj.io/v1alpha1
       kind: Workflow
       metadata:
-        generateName: hello-world-pipeline-
+        generateName: {pipeline_id}-
       spec:
         entrypoint: sequence
         templates:
         - name: sequence
           steps:
-          - - name: step-a
-              templateRef:
-                name: users/your_user_id/apps/your_app_id/pipeline_steps/stepA  # TODO: please fill in
-                template: users/your_user_id/apps/your_app_id/pipeline_steps/stepA  # TODO: please fill in
-          - - name: step-b
-              templateRef:
-                name: users/your_user_id/apps/your_app_id/pipeline_steps/stepB  # TODO: please fill in
-                template: users/your_user_id/apps/your_app_id/pipeline_steps/stepB  # TODO: please fill in
+{steps_yaml}
 """
 
 
-def get_pipeline_step_config_template(step_id: str):
+def get_pipeline_step_config_template(step_id: str, user_id="your_user_id", app_id="your_app_id"):
     """Get the config.yaml template for a pipeline step."""
     return f"""pipeline_step:
-  id: "{step_id}"  # TODO: please fill in
-  user_id: "your_user_id"  # TODO: please fill in
-  app_id: "your_app_id"  # TODO: please fill in
+  id: "{step_id}"
+  user_id: "{user_id}"
+  app_id: "{app_id}"
 
 pipeline_step_input_params:
   - name: input_text
@@ -114,17 +126,11 @@ This project contains a Clarifai pipeline with associated pipeline steps.
 
 ## Getting Started
 
-1. **Configure the pipeline**: Edit `config.yaml` and update the TODO fields:
-   - Set your `user_id` and `app_id`
-   - Update the pipeline `id`
-   - Modify the Argo orchestration spec as needed
-
-2. **Configure pipeline steps**: For each step directory (stepA, stepB):
-   - Edit `config.yaml` and fill in the TODO fields
+1. **Implement pipeline steps**: For each step directory:
    - Update `requirements.txt` with your dependencies
    - Implement your logic in `1/pipeline_step.py`
 
-3. **Upload the pipeline**:
+2. **Upload the pipeline**:
    ```bash
    clarifai pipeline upload config.yaml
    ```

clarifai/client/pipeline.py

@@ -193,6 +193,7 @@ class Pipeline(Lister, BaseClient):
         """
         start_time = time.time()
         seen_logs = set()
+        current_page = 1  # Track current page for log pagination.
 
         while time.time() - start_time < timeout:
             # Get run status
@@ -217,8 +218,8 @@ class Pipeline(Lister, BaseClient):
                     pipeline_run, preserving_proto_field_name=True
                 )
 
-                # Display new log entries
-                self._display_new_logs(run_id, seen_logs)
+                # Display new log entries and update current page
+                current_page = self._display_new_logs(run_id, seen_logs, current_page)
 
                 elapsed_time = time.time() - start_time
                 logger.info(f"Pipeline run monitoring... (elapsed {elapsed_time:.1f}s)")
@@ -276,12 +277,16 @@ class Pipeline(Lister, BaseClient):
         logger.error(f"Pipeline run timed out after {timeout} seconds")
         return {"status": "timeout"}
 
-    def _display_new_logs(self, run_id: str, seen_logs: set):
+    def _display_new_logs(self, run_id: str, seen_logs: set, current_page: int = 1) -> int:
         """Display new log entries for a pipeline version run.
 
         Args:
             run_id (str): The pipeline version run ID.
             seen_logs (set): Set of already seen log entry IDs.
+            current_page (int): The current page to fetch logs from.
+
+        Returns:
+            int: The next page number to fetch from in subsequent calls.
         """
         try:
             logs_request = service_pb2.ListLogEntriesRequest()
@@ -290,7 +295,7 @@ class Pipeline(Lister, BaseClient):
             logs_request.pipeline_version_id = self.pipeline_version_id or ""
             logs_request.pipeline_version_run_id = run_id
             logs_request.log_type = "pipeline.version.run"  # Set required log type
-            logs_request.page = 1
+            logs_request.page = current_page
             logs_request.per_page = 50
 
             logs_response = self.STUB.ListLogEntries(
@@ -298,7 +303,9 @@ class Pipeline(Lister, BaseClient):
             )
 
             if logs_response.status.code == status_code_pb2.StatusCode.SUCCESS:
+                entries_count = 0
                 for log_entry in logs_response.log_entries:
+                    entries_count += 1
                     # Use log entry URL or timestamp as unique identifier
                     log_id = log_entry.url or f"{log_entry.created_at.seconds}_{log_entry.message}"
                     if log_id not in seen_logs:
@@ -312,5 +319,14 @@ class Pipeline(Lister, BaseClient):
                         else:
                             logger.info(log_message)
 
+                # If we got a full page (50 entries), there might be more logs on the next page
+                # If we got fewer than 50 entries, we've reached the end and should stay on current page
+                if entries_count == 50:
+                    return current_page + 1
+                else:
+                    return current_page
+
         except Exception as e:
             logger.debug(f"Error fetching logs: {e}")
+            # Return current page on error to retry the same page next fetch
+            return current_page