clarifai 11.1.7rc1__py3-none-any.whl → 11.1.7rc3__py3-none-any.whl

clarifai/runners/models/model_builder.py

@@ -1,3 +1,4 @@
+import builtins
 import importlib
 import inspect
 import os
@@ -6,6 +7,7 @@ import sys
 import tarfile
 import time
 from string import Template
+from unittest.mock import MagicMock
 
 import yaml
 from clarifai_grpc.grpc.api import resources_pb2, service_pb2
@@ -80,7 +82,7 @@ class ModelBuilder:
 
   def load_model_class(self):
     """
-    Import the model class from the model.py file.
+    Import the model class from the model.py file, dynamically handling missing dependencies
     """
     # look for default model.py file location
     for loc in ["model.py", "1/model.py"]:
@@ -95,7 +97,29 @@ class ModelBuilder:
     spec = importlib.util.spec_from_file_location(module_name, model_file)
     module = importlib.util.module_from_spec(spec)
     sys.modules[module_name] = module
-    spec.loader.exec_module(module)
+
+    original_import = builtins.__import__
+
+    def custom_import(name, globals=None, locals=None, fromlist=(), level=0):
+
+      # Allow standard libraries and clarifai
+      if self._is_standard_or_clarifai(name):
+        return original_import(name, globals, locals, fromlist, level)
+
+      # Mock all third-party imports to avoid ImportErrors or other issues
+      return MagicMock()
+
+    # Replace the built-in __import__ function with our custom one
+    builtins.__import__ = custom_import
+
+    try:
+      spec.loader.exec_module(module)
+    except Exception as e:
+      logger.error(f"Error loading model.py: {e}")
+      raise
+    finally:
+      # Restore the original __import__ function
+      builtins.__import__ = original_import
 
     # Find all classes in the model.py file that are subclasses of ModelClass
     classes = [
@@ -122,6 +146,23 @@ class ModelBuilder:
     model_class = classes[0]
     return model_class
 
+  def _is_standard_or_clarifai(self, name):
+    """Check if import is from standard library or clarifai"""
+    if name.startswith("clarifai"):
+      return True
+
+    # Handle Python <3.10 compatibility
+    stdlib_names = getattr(sys, "stdlib_module_names", sys.builtin_module_names)
+    if name in stdlib_names:
+      return True
+
+    # Handle submodules (e.g., os.path)
+    parts = name.split(".")
+    for i in range(1, len(parts)):
+      if ".".join(parts[:i]) in stdlib_names:
+        return True
+    return False
+
   def _validate_folder(self, folder):
     if folder == ".":
       folder = ""  # will getcwd() next which ends with /
@@ -267,9 +308,18 @@ class ModelBuilder:
     """
     model_class = self.load_model_class()
     method_info = model_class._get_method_info()
-    signatures = {name: m.signature for name, m in method_info.items()}
+    signatures = {name: m.signature for name, m in method_info.values()}
     return signatures_to_yaml(signatures)
 
+  def get_method_signatures(self):
+    """
+    Returns the method signatures for the model class.
+    """
+    model_class = self.load_model_class()
+    method_info = model_class._get_method_info()
+    signatures = [method.signature for method in method_info.values()]
+    return signatures
+
   @property
   def client(self):
     if self._client is None:
@@ -548,10 +598,11 @@ class ModelBuilder:
     logger.info(f"Updated config.yaml with {len(concepts)} concepts.")
 
   def get_model_version_proto(self):
-
+    signatures = self.get_method_signatures()
     model_version_proto = resources_pb2.ModelVersion(
         pretrained_model_config=resources_pb2.PretrainedModelConfig(),
         inference_compute_info=self.inference_compute_info,
+        method_signatures=signatures,
     )
 
     model_type_id = self.config.get('model').get('model_type_id')
@@ -739,6 +790,7 @@ class ModelBuilder:
               model_id=self.model_proto.id,
               version_id=self.model_version_id,
           ))
+
       status_code = resp.model_version.status.code
       logs = self.get_model_build_logs()
       for log_entry in logs.log_entries:

clarifai/runners/models/model_class.py

@@ -8,6 +8,7 @@ from typing import Any, Dict, Iterator, List
 
 from clarifai_grpc.grpc.api import resources_pb2, service_pb2
 from clarifai_grpc.grpc.api.status import status_code_pb2, status_pb2
+from google.protobuf import json_format
 
 from clarifai.runners.utils import data_types
 from clarifai.runners.utils.method_signatures import (build_function_signature, deserialize,
@@ -84,6 +85,7 @@ class ModelClass(ABC):
     try:
       # TODO add method name field to proto
       method_name = 'predict'
+      inference_params = get_inference_params(request)
       if len(request.inputs) > 0 and '_method_name' in request.inputs[0].data.metadata:
         method_name = request.inputs[0].data.metadata['_method_name']
       if method_name == '_GET_SIGNATURES':  # special case to fetch signatures, TODO add endpoint for this
@@ -94,15 +96,17 @@ class ModelClass(ABC):
       method_info = method._cf_method_info
       signature = method_info.signature
       python_param_types = method_info.python_param_types
-      inputs = self._convert_input_protos_to_python(request.inputs, signature.inputs,
-                                                    python_param_types)
+      inputs = self._convert_input_protos_to_python(request.inputs, inference_params,
+                                                    signature.input_fields, python_param_types)
       if len(inputs) == 1:
         inputs = inputs[0]
         output = method(**inputs)
-        outputs.append(self._convert_output_to_proto(output, signature.outputs))
+        outputs.append(self._convert_output_to_proto(output, signature.output_fields))
       else:
         outputs = self._batch_predict(method, inputs)
-        outputs = [self._convert_output_to_proto(output, signature.outputs) for output in outputs]
+        outputs = [
+            self._convert_output_to_proto(output, signature.output_fields) for output in outputs
+        ]
 
       return service_pb2.MultiOutputResponse(
           outputs=outputs, status=status_pb2.Status(code=status_code_pb2.SUCCESS))
@@ -119,6 +123,7 @@ class ModelClass(ABC):
                       ) -> Iterator[service_pb2.MultiOutputResponse]:
     try:
       method_name = 'generate'
+      inference_params = get_inference_params(request)
       if len(request.inputs) > 0 and '_method_name' in request.inputs[0].data.metadata:
         method_name = request.inputs[0].data.metadata['_method_name']
       method = getattr(self, method_name)
@@ -126,20 +131,21 @@ class ModelClass(ABC):
       signature = method_info.signature
       python_param_types = method_info.python_param_types
 
-      inputs = self._convert_input_protos_to_python(request.inputs, signature.inputs,
-                                                    python_param_types)
+      inputs = self._convert_input_protos_to_python(request.inputs, inference_params,
+                                                    signature.input_fields, python_param_types)
       if len(inputs) == 1:
         inputs = inputs[0]
         for output in method(**inputs):
           resp = service_pb2.MultiOutputResponse()
-          self._convert_output_to_proto(output, signature.outputs, proto=resp.outputs.add())
+          self._convert_output_to_proto(output, signature.output_fields, proto=resp.outputs.add())
           resp.status.code = status_code_pb2.SUCCESS
           yield resp
       else:
         for outputs in self._batch_generate(method, inputs):
           resp = service_pb2.MultiOutputResponse()
           for output in outputs:
-            self._convert_output_to_proto(output, signature.outputs, proto=resp.outputs.add())
+            self._convert_output_to_proto(
+                output, signature.output_fields, proto=resp.outputs.add())
           resp.status.code = status_code_pb2.SUCCESS
           yield resp
     except Exception as e:
@@ -158,6 +164,7 @@ class ModelClass(ABC):
       assert len(request.inputs) == 1, "Streaming requires exactly one input"
 
       method_name = 'generate'
+      inference_params = get_inference_params(request)
       if len(request.inputs) > 0 and '_method_name' in request.inputs[0].data.metadata:
         method_name = request.inputs[0].data.metadata['_method_name']
       method = getattr(self, method_name)
@@ -166,14 +173,14 @@ class ModelClass(ABC):
       python_param_types = method_info.python_param_types
 
       # find the streaming vars in the signature
-      stream_sig = get_stream_from_signature(signature.inputs)
+      stream_sig = get_stream_from_signature(signature.input_fields)
       if stream_sig is None:
         raise ValueError("Streaming method must have a Stream input")
       stream_argname = stream_sig.name
 
       # convert all inputs for the first request, including the first stream value
-      inputs = self._convert_input_protos_to_python(request.inputs, signature.inputs,
-                                                    python_param_types)
+      inputs = self._convert_input_protos_to_python(request.inputs, inference_params,
+                                                    signature.input_fields, python_param_types)
       kwargs = inputs[0]
 
       # first streaming item
@@ -184,8 +191,8 @@ class ModelClass(ABC):
         yield first_item
         # subsequent streaming items contain only the streaming input
         for request in request_iterator:
-          item = self._convert_input_protos_to_python(request.inputs, stream_sig,
-                                                      python_param_types)
+          item = self._convert_input_protos_to_python(request.inputs, inference_params,
+                                                      [stream_sig], python_param_types)
           item = item[0][stream_argname]
           yield item
 
@@ -194,7 +201,7 @@ class ModelClass(ABC):
 
       for output in method(**kwargs):
         resp = service_pb2.MultiOutputResponse()
-        self._convert_output_to_proto(output, signature.outputs, proto=resp.outputs.add())
+        self._convert_output_to_proto(output, signature.output_fields, proto=resp.outputs.add())
         resp.status.code = status_code_pb2.SUCCESS
         yield resp
     except Exception as e:
@@ -206,11 +213,13 @@ class ModelClass(ABC):
           details=str(e),
           stack_trace=traceback.format_exc().split('\n')))
 
-  def _convert_input_protos_to_python(self, inputs: List[resources_pb2.Input], variables_signature,
+  def _convert_input_protos_to_python(self, inputs: List[resources_pb2.Input],
+                                      inference_params: dict,
+                                      variables_signature: List[resources_pb2.ModelTypeField],
                                       python_param_types) -> List[Dict[str, Any]]:
     result = []
     for input in inputs:
-      kwargs = deserialize(input.data, variables_signature)
+      kwargs = deserialize(input.data, variables_signature, inference_params)
       # dynamic cast to annotated types
       for k, v in kwargs.items():
         if k not in python_param_types:
@@ -219,7 +228,9 @@ class ModelClass(ABC):
       result.append(kwargs)
     return result
 
-  def _convert_output_to_proto(self, output: Any, variables_signature,
+  def _convert_output_to_proto(self,
+                               output: Any,
+                               variables_signature: List[resources_pb2.ModelTypeField],
                                proto=None) -> resources_pb2.Output:
     if proto is None:
       proto = resources_pb2.Output()
@@ -256,6 +267,18 @@ class ModelClass(ABC):
     return method_info
 
 
+# Helper function to get the inference params
+def get_inference_params(request) -> dict:
+  """Get the inference params from the request."""
+  inference_params = {}
+  if request.model.model_version.id != "":
+    output_info = request.model.model_version.output_info
+    output_info = json_format.MessageToDict(output_info, preserving_proto_field_name=True)
+    if "params" in output_info:
+      inference_params = output_info["params"]
+  return inference_params
+
+
 class _MethodInfo:
 
   def __init__(self, method):

clarifai/runners/models/model_class_refract.py

@@ -0,0 +1,80 @@
+import inspect
+from abc import ABC, abstractmethod
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, Dict, Iterator, List, get_type_hints
+
+from clarifai_grpc.grpc.api import resources_pb2, service_pb2
+
+from clarifai.runners.utils.data_handler import Output, kwargs_to_proto, proto_to_kwargs
+
+
+class ModelClass(ABC):
+
+  @abstractmethod
+  def load_model(self):
+    raise NotImplementedError("load_model() not implemented")
+
+  @abstractmethod
+  def predict(self, *args, **kwargs) -> Output:
+    raise NotImplementedError("predict() not implemented")
+
+  @abstractmethod
+  def generate(self, *args, **kwargs) -> Iterator[Output]:
+    raise NotImplementedError("generate() not implemented")
+
+  @abstractmethod
+  def stream(self, *args, **kwargs) -> Iterator[Output]:
+    raise NotImplementedError("stream() not implemented")
+
+  def batch_predict(self, inputs: List[Dict[str, Any]]) -> List[Output]:
+    with ThreadPoolExecutor() as executor:
+      return list(executor.map(lambda x: self.predict(**x), inputs))
+
+  def _process_request(self, request, process_func, is_stream=False):
+    inputs = self._convert_proto_to_python(request.inputs)
+    if len(inputs) == 1:
+      result = process_func(**inputs[0])
+      if is_stream:
+        return (self._convert_output_to_proto(output) for output in result)
+      else:
+        return [self._convert_output_to_proto(result)]
+    else:
+      results = self.batch_predict(inputs) if not is_stream else []
+      return [self._convert_output_to_proto(output) for output in results]
+
+  def predict_wrapper(
+      self, request: service_pb2.PostModelOutputsRequest) -> service_pb2.MultiOutputResponse:
+    outputs = self._process_request(request, self.predict)
+    return service_pb2.MultiOutputResponse(outputs=outputs)
+
+  def generate_wrapper(self, request: service_pb2.PostModelOutputsRequest
+                      ) -> Iterator[service_pb2.MultiOutputResponse]:
+    outputs = self._process_request(request, self.generate, is_stream=True)
+    for output in outputs:
+      yield service_pb2.MultiOutputResponse(outputs=[output])
+
+  def stream_wrapper(self, requests: Iterator[service_pb2.PostModelOutputsRequest]
+                    ) -> Iterator[service_pb2.MultiOutputResponse]:
+    for request in requests:
+      outputs = self._process_request(request, self.stream, is_stream=True)
+      yield service_pb2.MultiOutputResponse(outputs=outputs)
+
+  def _convert_proto_to_python(self, inputs: List[resources_pb2.Input]) -> List[Dict[str, Any]]:
+    get_type_hints(self.predict)
+    required_params = [
+        name for name, param in inspect.signature(self.predict).parameters.items()
+        if param.default == inspect.Parameter.empty
+    ]
+    kwargs_list = []
+    for input_proto in inputs:
+      kwargs = proto_to_kwargs(input_proto.data)
+      missing = [name for name in required_params if name not in kwargs]
+      if missing:
+        raise ValueError(f"Missing required parameters: {missing}")
+      kwargs_list.append(kwargs)
+    return kwargs_list
+
+  def _convert_output_to_proto(self, output: Any) -> resources_pb2.Output:
+    if isinstance(output, Output):
+      return output.to_proto()
+    return kwargs_to_proto(**output).outputs.add()