clarifai 11.4.1__py3-none-any.whl → 11.4.3rc1__py3-none-any.whl

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "11.4.1"
+__version__ = "11.4.3rc1"

clarifai/cli/base.py

@@ -143,6 +143,14 @@ def dump(ctx_obj, output_format):
         json.dump(ctx_obj.to_dict(), sys.stdout, indent=2)
 
 
+@config.command(['cat'])
+@click.option('-o', '--output-format', default='yaml', type=click.Choice(['yaml', 'json']))
+@click.pass_obj
+def env(ctx_obj, output_format):
+    """Print env vars. Use: eval "$(clarifai config env)" """
+    ctx_obj.current.print_env_vars()
+
+
 @cli.command()
 @click.argument('api_url', default="https://api.clarifai.com")
 @click.option('--user_id', required=False, help='User ID')

clarifai/cli/model.py

@@ -504,6 +504,10 @@ def local_dev(ctx, model_path):
 
     logger.info(f"Current deployment_id: {deployment_id}")
 
+    logger.info(
+        f"Full url for the model: /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')
@@ -526,13 +530,9 @@ def local_dev(ctx, model_path):
         ModelBuilder._backup_config(config_file)
         ModelBuilder._save_config(config_file, config)
 
-    # client_model = Model(
-    # TODO: once we can generate_client_script from ModelBuilder or similar
-    # we should be able to put the exact function call in place.
-    # model_script = model.generate_client_script()
-
     builder = ModelBuilder(model_path, download_validation_only=True)
-    method_signatures = builder.get_method_signatures()
+    # don't mock for local dev since you need the dependencies to run the code anyways.
+    method_signatures = builder.get_method_signatures(mocking=False)
 
     from clarifai.runners.utils import code_script
 

clarifai/client/dataset.py

@@ -685,6 +685,12 @@ class Dataset(Lister, BaseClient):
         Note:
             This is a beta feature and is subject to change.
         """
+        try:
+            import rich  # noqa: F401
+        except ImportError:
+            raise UserError(
+                "Rich library is not installed. Please install it using pip install rich>=13.4.2"
+            )
         self.logger.info("Getting dataset upload status...")
         dataset_version_id = uuid.uuid4().hex
         _ = self.create_version(id=dataset_version_id, description="SDK Upload Status")

clarifai/runners/models/base_typed_model.py

@@ -0,0 +1,238 @@
+import itertools
+from typing import Any, Dict, Iterator, List, Tuple
+
+import numpy as np
+from clarifai_grpc.grpc.api import resources_pb2, service_pb2
+from clarifai_grpc.grpc.api.service_pb2 import PostModelOutputsRequest
+from google.protobuf import json_format
+
+from ..utils.data_handler import InputDataHandler, OutputDataHandler
+from .model_class import ModelClass
+
+
+class AnyAnyModel(ModelClass):
+
+  def load_model(self):
+    """
+    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.
+    """
+    raise NotImplementedError
+
+  def parse_input_request(
+      self, input_request: service_pb2.PostModelOutputsRequest) -> Tuple[List[Dict], Dict]:
+    list_input_dict = [
+        InputDataHandler.from_proto(input).to_python() for input in input_request.inputs
+    ]
+    inference_params = json_format.MessageToDict(
+        input_request.model.model_version.output_info.params)
+
+    return list_input_dict, inference_params
+
+  def convert_output_to_proto(self, outputs: list):
+    assert (isinstance(outputs, Iterator) or isinstance(outputs, list) or
+            isinstance(outputs, tuple)), "outputs must be an Iterator"
+    output_protos = []
+    for output in outputs:
+      if isinstance(output, OutputDataHandler):
+        output = output.proto
+      elif isinstance(output, resources_pb2.Output):
+        pass
+      else:
+        raise NotImplementedError
+      output_protos.append(output)
+
+    return service_pb2.MultiOutputResponse(outputs=output_protos)
+
+  def predict_wrapper(
+      self, request: service_pb2.PostModelOutputsRequest) -> service_pb2.MultiOutputResponse:
+    list_dict_input, inference_params = self.parse_input_request(request)
+    outputs = self.predict(list_dict_input, inference_parameters=inference_params)
+    return self.convert_output_to_proto(outputs)
+
+  def generate_wrapper(
+      self, request: PostModelOutputsRequest) -> Iterator[service_pb2.MultiOutputResponse]:
+    list_dict_input, inference_params = self.parse_input_request(request)
+    outputs = self.generate(list_dict_input, inference_parameters=inference_params)
+    for output in outputs:
+      yield self.convert_output_to_proto(output)
+
+  def _preprocess_stream(
+      self, request: Iterator[PostModelOutputsRequest]) -> Iterator[Tuple[List[Dict], List[Dict]]]:
+    """Return generator of processed data (from proto to python) and inference parameters like predict and generate"""
+    for i, req in enumerate(request):
+      input_data, _ = self.parse_input_request(req)
+      yield input_data
+
+  def stream_wrapper(self, request: Iterator[PostModelOutputsRequest]
+                    ) -> Iterator[service_pb2.MultiOutputResponse]:
+    first_request = next(request)
+    _, inference_params = self.parse_input_request(first_request)
+    request_iterator = itertools.chain([first_request], request)
+    outputs = self.stream(self._preprocess_stream(request_iterator), inference_params)
+    for output in outputs:
+      yield self.convert_output_to_proto(output)
+
+  def predict(self, input_data: List[Dict],
+              inference_parameters: Dict[str, Any] = {}) -> List[OutputDataHandler]:
+    """
+    Prediction method.
+
+    Args:
+    -----
+    - input_data: is list of dict where key is input type name.
+      * image: np.ndarray
+      * text: str
+      * audio: bytes
+
+    - inference_parameters (Dict[str, Union[bool, str, float, int]]): your inference parameters.
+
+    Returns:
+    --------
+      List of OutputDataHandler
+    """
+    raise NotImplementedError
+
+  def generate(self, input_data: List[Dict],
+               inference_parameters: Dict[str, Any] = {}) -> Iterator[List[OutputDataHandler]]:
+    """
+    Generate method.
+
+    Args:
+    -----
+    - input_data: is list of dict where key is input type name.
+      * image: np.ndarray
+      * text: str
+      * audio: bytes
+
+    - inference_parameters (Dict[str, Union[bool, str, float, int]]): your inference parameters.
+
+    Yield:
+    --------
+      List of OutputDataHandler
+    """
+    raise NotImplementedError
+
+  def stream(self, inputs: Iterator[List[Dict[str, Any]]],
+             inference_params: Dict[str, Any]) -> Iterator[List[OutputDataHandler]]:
+    """
+    Stream method.
+
+    Args:
+    -----
+    input_request: is an Iterator of Tuple which
+    - First element (List[Dict[str, Union[np.ndarray, str, bytes]]]) is list of dict input data type which keys and values are:
+        * image: np.ndarray
+        * text: str
+        * audio: bytes
+
+    - Second element (Dict[str, Union[bool, str, float, int]]): is a dict of inference_parameters
+
+    Yield:
+    --------
+      List of OutputDataHandler
+    """
+    raise NotImplementedError
+
+
+class VisualInputModel(AnyAnyModel):
+
+  def parse_input_request(
+      self, input_request: service_pb2.PostModelOutputsRequest) -> Tuple[List[Dict], Dict]:
+    list_input_dict = [
+        InputDataHandler.from_proto(input).image(format="np") for input in input_request.inputs
+    ]
+    inference_params = json_format.MessageToDict(
+        input_request.model.model_version.output_info.params)
+
+    return list_input_dict, inference_params
+
+  def load_model(self):
+    """
+    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.
+    """
+    raise NotImplementedError
+
+  def predict(self, input_data: List[np.ndarray],
+              inference_parameters: Dict[str, Any] = {}) -> List[OutputDataHandler]:
+    """
+    Prediction method.
+
+    Args:
+    -----
+    - input_data(List[np.ndarray]): is list of image as np.ndarray type
+    - inference_parameters (Dict[str, Union[bool, str, float, int]]): your inference parameters.
+
+    Returns:
+    --------
+      List of OutputDataHandler
+    """
+    raise NotImplementedError
+
+
+class TextInputModel(AnyAnyModel):
+
+  def load_model(self):
+    """
+    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.
+    """
+    raise NotImplementedError
+
+  def parse_input_request(
+      self, input_request: service_pb2.PostModelOutputsRequest) -> Tuple[List[Dict], Dict]:
+    list_input_text = [InputDataHandler.from_proto(input).text for input in input_request.inputs]
+    inference_params = json_format.MessageToDict(
+        input_request.model.model_version.output_info.params)
+
+    return list_input_text, inference_params
+
+  def predict(self, input_data: List[str],
+              inference_parameters: Dict[str, Any] = {}) -> List[OutputDataHandler]:
+    """
+    Prediction method.
+
+    Args:
+    -----
+    - input_data(List[str]): is list of text as str type
+    - inference_parameters (Dict[str, Union[bool, str, float, int]]): your inference parameters.
+
+    Returns:
+    --------
+      List of OutputDataHandler
+    """
+    raise NotImplementedError
+
+  def generate(self, input_data: List[str],
+               inference_parameters: Dict[str, Any] = {}) -> Iterator[List[OutputDataHandler]]:
+    """
+    Prediction method.
+
+    Args:
+    -----
+    - input_data(List[str]): is list of text as str type
+    - inference_parameters (Dict[str, Union[bool, str, float, int]]): your inference parameters.
+
+    Yield:
+    --------
+      List of OutputDataHandler
+    """
+    raise NotImplementedError
+
+  def stream(self, inputs: Iterator[List[str]],
+             inference_params: Dict[str, Any]) -> Iterator[List[OutputDataHandler]]:
+    """
+    Stream method.
+
+    Args:
+    -----
+    input_request: is an Iterator of Tuple which
+    - First element (List[str]) is list of input text:
+    - Second element (Dict[str, Union[bool, str, float, int]]): is a dict of inference_parameters
+
+    Yield:
+    --------
+      List of OutputDataHandler
+    """
+    raise NotImplementedError

clarifai/runners/models/example_mcp_server.py

@@ -0,0 +1,44 @@
+"""Example of how to create an MCP server using MCPClass."""
+
+from typing import Dict
+from fastmcp import Tool
+
+from clarifai.runners.models.mcp_class import MCPClass
+
+
+class ExampleMCPServer(MCPClass):
+    """Example MCP server that provides a simple calculator tool."""
+
+    def __init__(self):
+        super().__init__()
+        
+        # Define and register a calculator tool
+        calculator_tool = Tool(
+            name="calculator",
+            description="A simple calculator that can add two numbers",
+            parameters={
+                "type": "object",
+                "properties": {
+                    "a": {"type": "number", "description": "First number"},
+                    "b": {"type": "number", "description": "Second number"}
+                },
+                "required": ["a", "b"]
+            }
+        )
+        
+        @calculator_tool
+        async def add(params: Dict[str, float]) -> float:
+            """Add two numbers together."""
+            return params["a"] + params["b"]
+
+        # Register the tool with the MCP server
+        self.add_tool(calculator_tool)
+
+
+# Usage example:
+if __name__ == "__main__":
+    # Create and run the server
+    server = ExampleMCPServer()
+    
+    # The server is now ready to handle MCP requests through the mcp_transport method
+    # For example, a client could send a request to list tools or call the calculator