clarifai 11.1.5rc7__tar.gz → 11.1.5rc8__tar.gz

{clarifai-11.1.5rc7/clarifai.egg-info → clarifai-11.1.5rc8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: clarifai
-Version: 11.1.5rc7
+Version: 11.1.5rc8
 Summary: Clarifai Python SDK
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai

clarifai-11.1.5rc8/clarifai/__init__.py

@@ -0,0 +1 @@
+__version__ = "11.1.5rc8"

clarifai-11.1.5rc7/clarifai/client/model_client.py → clarifai-11.1.5rc8/clarifai/client/#model_client.py#

@@ -12,6 +12,8 @@ from clarifai.runners.utils.method_signatures import (deserialize, get_stream_fr
                                                       unflatten_nested_keys)
 from clarifai.utils.misc import BackoffIterator, status_is_retryable
 
+from clarifai.utils.logging import logger
+
 
 class ModelClient:
   '''
@@ -69,8 +71,6 @@ class ModelClient:
     if response.status.code != status_code_pb2.SUCCESS:
       raise Exception(f"Model failed with response {response!r}")
     self._method_signatures = signatures_from_json(response.outputs[0].data.text.raw)
-    import pdb
-    pdb.set_trace()
 
   def _define_functions(self):
     '''
@@ -214,10 +214,9 @@ class ModelClient:
     request.inputs.extend(inputs)
 
     if method_name:
-      for inp in inputs:
-        inp.data.metadata['_method_name'] = method_name
       # TODO put in new proto field?
-      # request.model.model_version.output_info.params['_method_name'] = method_name
+      for inp in request.inputs:
+        inp.data.metadata['_method_name'] = method_name
     if inference_params:
       request.model.model_version.output_info.params.update(inference_params)
     if output_config:
@@ -298,9 +297,8 @@ class ModelClient:
 
     if method_name:
       # TODO put in new proto field?
-      for inp in inputs:
+      for inp in request.inputs:
         inp.data.metadata['_method_name'] = method_name
-      # request.model.model_version.output_info.params['_method_name'] = method_name
     if inference_params:
       request.model.model_version.output_info.params.update(inference_params)
     if output_config:
@@ -383,7 +381,6 @@ class ModelClient:
                     output_config: Dict = {}):
     request = service_pb2.PostModelOutputsRequest()
     request.CopyFrom(self.request_template)
-    # request.model.model_version.output_info.params['_method_name'] = method_name
     if inference_params:
       request.model.model_version.output_info.params.update(inference_params)
     if output_config:
@@ -395,6 +392,7 @@ class ModelClient:
         req.inputs.extend(inputs)
       else:
         req.inputs.append(inputs)
+      # TODO: put into new proto field?
       for inp in req.inputs:
         inp.data.metadata['_method_name'] = method_name
       yield req

{clarifai-11.1.5rc7 → clarifai-11.1.5rc8}/clarifai/client/model.py

@@ -1,7 +1,8 @@
+import itertools
 import json
 import os
 import time
-from typing import Any, Dict, Generator, Iterator, List, Tuple, Union
+from typing import Any, Dict, Generator, Iterable, Iterator, List, Tuple, Union
 
 import numpy as np
 import requests
@@ -77,7 +78,8 @@ class Model(Lister, BaseClient):
     self.logger = logger
     self.training_params = {}
     self.input_types = None
-    self._model_client = None
+    self._client = None
+    self._added_methods = False
     self._set_runner_selector(
         compute_cluster_id=compute_cluster_id,
         nodepool_id=nodepool_id,
@@ -418,8 +420,8 @@ class Model(Lister, BaseClient):
           **dict(self.kwargs, model_version=model_version_info))
 
   @property
-  def model_client(self):
-    if self._model_client is None:
+  def client(self):
+    if self._client is None:
       request_template = service_pb2.PostModelOutputsRequest(
           user_app_id=self.user_app_id,
           model_id=self.id,
@@ -427,30 +429,46 @@ class Model(Lister, BaseClient):
           model=self.model_info,
           runner_selector=self._runner_selector,
       )
-      self._model_client = ModelClient(self.STUB, request_template=request_template)
-    return self._model_client
+      self._client = ModelClient(self.STUB, request_template=request_template)
+    return self._client
 
-  def predict(self, inputs: List[Input], inference_params: Dict = {}, output_config: Dict = {}):
-    """Predicts the model based on the given inputs.
-
-    Args:
-        inputs (list[Input]): The inputs to predict, must be less than 128.
+  def predict(self, *args, **kwargs):
     """
+    Calls the model's predict() method with the given arguments.
 
-    return self.model_client._predict_by_proto(
-        inputs=inputs,
-        inference_params=inference_params,
-        output_config=output_config,
-    )
+    If passed in request_pb2.PostModelOutputsRequest values, will send the model the raw
+    protos directly for compatibility with previous versions of the SDK.
+    """
 
-  def predict2(self, inputs):
-    """Predicts the model based on the given inputs.
+    inputs = None
+    if 'inputs' in kwargs:
+      inputs = kwargs['inputs']
+    elif args:
+      inputs = args[0]
+    if inputs and isinstance(inputs, list) and isinstance(inputs[0], resources_pb2.Input):
+      assert not args, "Cannot pass in raw protos and additional arguments at the same time."
+      inference_params = kwargs.get('inference_params', {})
+      output_config = kwargs.get('output_config', {})
+      return self.client._predict_by_proto(
+          inputs=inputs, inference_params=inference_params, output_config=output_config)
 
-    Args:
-        inputs (list[Input]): The inputs to predict, must be less than 128.
-    """
+    return self.client.predict(*args, **kwargs)
 
-    return self.model_client._predict(inputs=inputs,)
+  def __getattr__(self, name):
+    try:
+      return getattr(self.model_info, name)
+    except AttributeError:
+      pass
+    if not self._added_methods:
+      # fetch and set all the model methods
+      self._added_methods = True
+      self.client.fetch()
+      for method_name in self.client._method_signatures.keys():
+        if not hasattr(self, method_name):
+          setattr(self, method_name, getattr(self.client, method_name))
+    if hasattr(self.client, name):
+      return getattr(self.client, name)
+    raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
 
   def _check_predict_input_type(self, input_type: str) -> None:
     """Checks if the input type is valid for the model.
@@ -635,24 +653,27 @@ class Model(Lister, BaseClient):
     return self.predict(
         inputs=[input_proto], inference_params=inference_params, output_config=output_config)
 
-  def generate(
-      self,
-      inputs: List[Input],
-      inference_params: Dict = {},
-      output_config: Dict = {},
-  ):
-    """Generate the stream output on model based on the given inputs.
+  def generate(self, *args, **kwargs):
+    """
+    Calls the model's generate() method with the given arguments.
 
-    Args:
-        inputs (list[Input]): The inputs to generate, must be less than 128.
-        inference_params (dict): The inference params to override.
-        output_config (dict): The output config to override.
+    If passed in request_pb2.PostModelOutputsRequest values, will send the model the raw
+    protos directly for compatibility with previous versions of the SDK.
     """
-    return self.model_client._generate_by_proto(
-        inputs=inputs,
-        inference_params=inference_params,
-        output_config=output_config,
-    )
+
+    inputs = None
+    if 'inputs' in kwargs:
+      inputs = kwargs['inputs']
+    elif args:
+      inputs = args[0]
+    if inputs and isinstance(inputs, list) and isinstance(inputs[0], resources_pb2.Input):
+      assert not args, "Cannot pass in raw protos and additional arguments at the same time."
+      inference_params = kwargs.get('inference_params', {})
+      output_config = kwargs.get('output_config', {})
+      return self.client._generate_by_proto(
+          inputs=inputs, inference_params=inference_params, output_config=output_config)
+
+    return self.client.generate(*args, **kwargs)
 
   def generate_by_filepath(self,
                            filepath: str,
@@ -766,28 +787,44 @@ class Model(Lister, BaseClient):
     return self.generate(
         inputs=[input_proto], inference_params=inference_params, output_config=output_config)
 
-  def stream(self,
-             inputs: Iterator[List[Input]],
-             inference_params: Dict = {},
-             output_config: Dict = {}):
-    """Generate the stream output on model based on the given stream of inputs.
-
-    Args:
-        inputs (Iterator[list[Input]]): stream of inputs to predict, must be less than 128.
+  def stream(self, *args, **kwargs):
+    """
+    Calls the model's stream() method with the given arguments.
 
-    Example:
-        >>> from clarifai.client.model import Model
-        >>> model = Model("url") # Example URL: https://clarifai.com/clarifai/main/models/general-image-recognition
-                    or
-        >>> model = Model(model_id='model_id', user_id='user_id', app_id='app_id')
-        >>> stream_response = model.stream(inputs=inputs, runner_selector=runner_selector)
-        >>> list_stream_response = [response for response in stream_response]
+    If passed in request_pb2.PostModelOutputsRequest values, will send the model the raw
+    protos directly for compatibility with previous versions of the SDK.
     """
-    return self.model_client._stream_by_proto(
-        inputs=inputs,
-        inference_params=inference_params,
-        output_config=output_config,
-    )
+
+    use_proto_call = False
+    inputs = None
+    if 'inputs' in kwargs:
+      inputs = kwargs['inputs']
+    elif args:
+      inputs = args[0]
+    if inputs and isinstance(inputs, Iterable):
+      inputs_iter = iter(inputs)
+      try:
+        peek = next(inputs_iter)
+      except StopIteration:
+        pass
+      else:
+        use_proto_call = isinstance(peek, resources_pb2.Input)
+        # put back the peeked value
+        if inputs_iter is inputs:
+          inputs = itertools.chain([peek], inputs_iter)
+          if 'inputs' in kwargs:
+            kwargs['inputs'] = inputs
+          else:
+            args = (inputs,) + args[1:]
+
+    if use_proto_call:
+      assert not args, "Cannot pass in raw protos and additional arguments at the same time."
+      inference_params = kwargs.get('inference_params', {})
+      output_config = kwargs.get('output_config', {})
+      return self.client._stream_by_proto(
+          inputs=inputs, inference_params=inference_params, output_config=output_config)
+
+    return self.client.stream(*args, **kwargs)
 
   def stream_by_filepath(self,
                          filepath: str,
@@ -946,9 +983,6 @@ class Model(Lister, BaseClient):
     self.kwargs = self.process_response_keys(dict_response['model'])
     self.model_info = resources_pb2.Model(**self.kwargs)
 
-  def __getattr__(self, name):
-    return getattr(self.model_info, name)
-
   def __str__(self):
     if len(self.kwargs) < 10:
       self.load_info()