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

{clarifai-11.4.3rc1.dist-info → clarifai-11.4.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.1.0)
+Generator: setuptools (80.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

clarifai/runners/models/base_typed_model.py

@@ -1,238 +0,0 @@
-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

@@ -1,44 +0,0 @@
-"""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

clarifai/runners/models/mcp_class.py~

@@ -1,149 +0,0 @@
-"""Base class for creating Model Context Protocol (MCP) servers."""
-
-import asyncio
-import json
-from typing import Any
-
-from fastmcp import Client, FastMCP  # use fastmcp v2 not the built in mcp
-from mcp import types
-from mcp.shared.exceptions import McpError
-
-from clarifai.runners.models.model_class import ModelClass
-
-# class MCPServerProvider(abc.ABC):
-#     """
-#     Base class for creating Model Context Protocol (MCP) servers.
-
-#     This class provides a base implementation of the MCP server, including
-#     methods for handling requests and responses, as well as error handling and
-#     logging.
-
-#     Attributes:
-#     _server: The FastMCP server instance.
-#     _tools: List of tools available in the server.
-#     _resources: List of resources available in the server.
-#     _prompts: List of prompts available in the server.
-
-#     Methods:
-#     get_server(): Returns the FastMCP server instance.
-#     mcp_transport(msg): Handles incoming messages and sends them to the FastMCP server.
-#     """
-
-#     @abc.abstractmethod
-#     def get_server(self) -> FastMCP:
-#         """Required method for each subclass to implement to return the FastMCP server to use."""
-#         if self._server is None:
-#             raise ValueError("Server not initialized")
-#         return self._server
-
-
-class MCPModelClass(ModelClass, MCPServerProvider):
-    """Base class for wrapping FastMCP servers as a model running in Clarfai. This handles
-    all the transport between the API and the MCP server here. Simply subclass this and implement
-    the get_server() method to return the FastMCP server instance. The server is then used to
-    handle all the requests and responses.
-    """
-
-    def load_model(self):
-        # in memory transport provided in fastmcp v2 so we can easily use the client functions.
-        self.client = Client(self.get_server())
-
-    def get_server(self) -> FastMCP:
-        """Required method for each subclass to implement to return the FastMCP server to use."""
-        if self._server is None:
-            raise ValueError("Server not initialized")
-        return self._server
-
-    @ModelClass.method
-    def mcp_transport(self, msg: str) -> str:
-        """The single model method to get the jsonrpc message and send it to the FastMCP server then
-        return it's response.
-
-        Arguments:
-          msg: The incoming message to be handled in serialized JSONRPC format from an MCP client.
-        Returns:
-          str: The response to the incoming message in serialized JSONRPC format
-        """
-
-        async def send_notification(client_message: types.ClientNotification) -> None:
-            async with self.client:
-                # Strip the jsonrpc field since send_notification will also pass it in for some reason.
-                client_message = types.ClientNotification.model_validate(
-                    client_message.model_dump(
-                        by_alias=True, mode="json", exclude_none=True, exclude={"jsonrpc"}
-                    )
-                )
-                try:
-                    return await self.client.session.send_notification(client_message)
-                except McpError as e:
-                    return types.JSONRPCError(jsonrpc="2.0", error=e.error)
-
-        async def send_request(client_message: types.ClientRequest, id: str) -> Any:
-            async with self.client:
-                # Strip the jsonrpc and id fields as send_request sets them again too.
-                client_message = types.ClientRequest.model_validate(
-                    client_message.model_dump(
-                        by_alias=True, mode="json", exclude_none=True, exclude={"jsonrpc", "id"}
-                    )
-                )
-
-                result_type = None
-                print("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")
-                print(types.PingRequest)
-                if isinstance(client_message.root, types.PingRequest):
-                    result_type = types.EmptyResult
-                elif isinstance(client_message.root, types.InitializeRequest):
-                    return await self.client.session.initialize()
-                elif isinstance(client_message.root, types.SetLevelRequest):
-                    result_type = types.EmptyResult
-                elif isinstance(client_message.root, types.ListResourcesRequest):
-                    result_type = types.ListResourcesResult
-                elif isinstance(client_message.root, types.ListResourceTemplatesRequest):
-                    result_type = types.ListResourceTemplatesResult
-                elif isinstance(client_message.root, types.ReadResourceRequest):
-                    result_type = types.ReadResourceResult
-                elif isinstance(client_message.root, types.SubscribeRequest):
-                    result_type = types.EmptyResult
-                elif isinstance(client_message.root, types.UnsubscribeRequest):
-                    result_type = types.EmptyResult
-                elif isinstance(client_message.root, types.ListPromptsRequest):
-                    result_type = types.ListPromptsResult
-                elif isinstance(client_message.root, types.GetPromptRequest):
-                    result_type = types.GetPromptResult
-                elif isinstance(client_message.root, types.CompleteRequest):
-                    result_type = types.CompleteResult
-                elif isinstance(client_message.root, types.ListToolsRequest):
-                    result_type = types.ListToolsResult
-                elif isinstance(client_message.root, types.CallToolRequest):
-                    result_type = types.CallToolResult
-                else:
-                    # this is a special case where we need to return the list of tools.
-                    raise NotImplementedError(f"Method {client_message.method} not implemented")
-                # Call the mcp server using send_request() or send_notification() depending on the method.
-                try:
-                    return await self.client.session.send_request(client_message, result_type)
-                except McpError as e:
-                    return types.JSONRPCError(jsonrpc="2.0", id=id, error=e.error)
-
-        # The message coming here is the generic request. We look at it's .method
-        # to determine which client function to call and to further subparse the params.
-        # Note(zeiler): unfortunately the pydantic types in mcp/types.py are not consistent.
-        # The JSONRPCRequest are supposed to have an id but the InitializeRequest
-        # does not have it.
-        d = json.loads(msg)
-
-        # If we have an id it's a JSONRPCRequest
-        if not d.get('method', None).startswith("notifications/"):
-            # rpc_message2 = types.JSONRPCRequest.model_validate(rpc_message)
-            # underlying: types.JSONRPCRequest = rpc_message.root
-            client_message = types.ClientRequest.model_validate(d)
-            response = asyncio.run(
-                send_request(client_message, id=d.get('id', ""))
-            )  # underlying.id))
-        else:  # JSONRPCRequest
-            client_message = types.ClientNotification.model_validate(d)
-            response = asyncio.run(send_notification(client_message))
-        if response is None:
-            return ""
-        # return as a serialized json string
-        return response.model_dump_json(by_alias=True, exclude_none=True)