clarifai 9.10.2__py3-none-any.whl → 9.10.3__py3-none-any.whl

clarifai_utils/client/module.py

@@ -1,94 +0,0 @@
-from typing import Dict, Generator
-
-from clarifai_grpc.grpc.api import resources_pb2, service_pb2
-
-from clarifai.client.base import BaseClient
-from clarifai.client.lister import Lister
-from clarifai.errors import UserError
-from clarifai.urls.helper import ClarifaiUrlHelper
-from clarifai.utils.logging import get_logger
-
-
-class Module(Lister, BaseClient):
-  """Module is a class that provides access to Clarifai API endpoints related to Module information."""
-
-  def __init__(self,
-               url_init: str = "",
-               module_id: str = "",
-               module_version: Dict = {'id': ""},
-               base_url: str = "https://api.clarifai.com",
-               **kwargs):
-    """Initializes a Module object.
-
-        Args:
-            url_init (str): The URL to initialize the module object.
-            module_id (str): The Module ID to interact with.
-            module_version (dict): The Module Version to interact with.
-            base_url (str): Base API url. Default "https://api.clarifai.com"
-            **kwargs: Additional keyword arguments to be passed to the Module.
-        """
-    if url_init != "" and module_id != "":
-      raise UserError("You can only specify one of url_init or module_id.")
-    if url_init == "" and module_id == "":
-      raise UserError("You must specify one of url_init or module_id.")
-    if url_init != "":
-      user_id, app_id, module_id, module_version_id = ClarifaiUrlHelper.split_module_ui_url(
-          url_init)
-      module_version = {'id': module_version_id}
-      kwargs = {'user_id': user_id, 'app_id': app_id}
-
-    self.kwargs = {**kwargs, 'id': module_id, 'module_version': module_version}
-    self.module_info = resources_pb2.Module(**self.kwargs)
-    self.logger = get_logger(logger_level="INFO")
-    BaseClient.__init__(self, user_id=self.user_id, app_id=self.app_id, base=base_url)
-    Lister.__init__(self)
-
-  def list_versions(self, page_no: int = None,
-                    per_page: int = None) -> Generator['Module', None, None]:
-    """Lists all the module versions for the module.
-
-    Args:
-        page_no (int): The page number to list.
-        per_page (int): The number of items per page.
-
-    Yields:
-        Moudle: Module objects for versions of the module.
-
-    Example:
-        >>> from clarifai.client.module import Module
-        >>> module = Module(module_id='module_id', user_id='user_id', app_id='app_id')
-        >>> all_Module_versions = list(module.list_versions())
-
-    Note:
-        Defaults to 16 per page if page_no is specified and per_page is not specified.
-        If both page_no and per_page are None, then lists all the resources.
-    """
-    request_data = dict(
-        user_app_id=self.user_app_id,
-        module_id=self.id,
-    )
-    all_module_versions_info = self.list_pages_generator(
-        self.STUB.ListModuleVersions,
-        service_pb2.ListModuleVersionsRequest,
-        request_data,
-        per_page=per_page,
-        page_no=page_no)
-
-    for module_version_info in all_module_versions_info:
-      module_version_info['id'] = module_version_info['module_version_id']
-      del module_version_info['module_version_id']
-      yield Module(
-          module_id=self.id,
-          base_url=self.base,
-          **dict(self.kwargs, module_version=module_version_info))
-
-  def __getattr__(self, name):
-    return getattr(self.module_info, name)
-
-  def __str__(self):
-    init_params = [param for param in self.kwargs.keys()]
-    attribute_strings = [
-        f"{param}={getattr(self.module_info, param)}" for param in init_params
-        if hasattr(self.module_info, param)
-    ]
-    return f"Module Details: \n{', '.join(attribute_strings)}\n"

clarifai_utils/client/runner.py

@@ -1,161 +0,0 @@
-# Copyright 2023 Clarifai, Inc.
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Interface to Clarifai Runners API."""
-
-import os
-
-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.client.base import BaseClient
-from clarifai.errors import UserError
-from clarifai.utils.logging import get_logger
-
-
-class Runner(BaseClient):
-  """Base class for remote inference runners. This should be subclassed with the run_input method
-  implemented to process each input in the request.
-
-  Then on the subclass call start() to start the run loop.
-  """
-
-  def __init__(self,
-               runner_id: str,
-               user_id: str = "",
-               check_runner_exists: bool = True,
-               base_url: str = "https://api.clarifai.com",
-               **kwargs) -> None:
-    """
-    Args:
-      runner_id (str): the id of the runner to use. Create the runner in the Clarifai API first
-      user_id (str): Clarifai User ID
-      base_url (str): Base API url. Default "https://api.clarifai.com"
-    """
-    user_id = user_id or os.environ.get("CLARIFAI_USER_ID", "")
-
-    if user_id == "":
-      raise UserError(
-          "Set CLARIFAI_USER_ID as environment variables or pass user_id as input arguments")
-
-    self.runner_id = runner_id
-    self.logger = get_logger("INFO", __name__)
-    self.kwargs = {**kwargs, 'id': runner_id, 'user_id': user_id}
-    self.runner_info = resources_pb2.Runner(**self.kwargs)
-    BaseClient.__init__(self, user_id=self.user_id, app_id="", base=base_url)
-
-    # Check that the runner exists.
-    if check_runner_exists:
-      request = service_pb2.GetRunnerRequest(user_app_id=self.user_app_id, runner_id=runner_id)
-      response = self._grpc_request(self.STUB.GetRunner, request)
-      if response.status.code != status_code_pb2.SUCCESS:
-        raise Exception(
-            f"""Error getting runner, are you use this is a valid runner id {runner_id} at the user_id
-            {self.user_app_id.user_id}.
-            Error: {response.status.description}""")
-
-  def start(self):
-    """Start the run loop. This will ask the Clarifai API for work, and when it gets work, it will run
-    the model on the inputs and post the results back to the Clarifai API. It will then ask for more
-    work again.
-    """
-    self._long_poll_loop()
-
-  def _run(self, request: service_pb2.PostModelOutputsRequest) -> service_pb2.MultiOutputResponse:
-    """Run the model on the given request. You shouldn't need to override this method, see run_input
-    for the implementation to process each input in the request.
-
-    Args:
-      request: service_pb2.PostModelOutputsRequest - the request to run the model on
-
-    Returns:
-      service_pb2.MultiOutputResponse - the response from the model's run_input implementation.
-    """
-    outputs = []
-    # TODO: parallelize this
-    for inp in request.inputs:
-      # TODO: handle errors
-      outputs.append(self.run_input(inp))
-
-    return service_pb2.MultiOutputResponse(
-        status=status_pb2.Status(
-            code=status_code_pb2.SUCCESS,
-            description="Success",
-        ),
-        outputs=outputs,
-    )
-
-  def run_input(self, input: resources_pb2.Input) -> resources_pb2.Output:
-    """Run the model on the given input in the request. This is the method you should override to
-    process each input in the request.
-
-    Args:
-      input: resources_pb2.Input - the input to run the model on
-
-    Returns:
-      resources_pb2.Output - the response from the model's run_input implementation.
-    """
-    raise NotImplementedError("run_input() not implemented")
-
-  def _long_poll_loop(self):
-    """This method will long poll for work, and when it gets work, it will run the model on the inputs
-    and post the results back to the Clarifai API. It will then long poll again for more work.
-    """
-    c = 0
-    # TODO: handle more errors within this loop so it never stops.
-    # TODO: perhaps have multiple processes running this loop to handle more work.
-    while True:
-      # Long poll waiting for work.
-      self.logger.info("Loop iteration: {}".format(c))
-      request = service_pb2.ListRunnerItemsRequest(
-          user_app_id=self.user_app_id, runner_id=self.runner_id)
-      work_response = self._grpc_request(self.STUB.ListRunnerItems, request)
-      if work_response.status.code == status_code_pb2.RUNNER_NEEDS_RETRY:
-        c += 1
-        continue  # immediate restart the long poll
-      if work_response.status.code != status_code_pb2.SUCCESS:
-        raise Exception("Error getting work: {}".format(work_response.status.description))
-      if len(work_response.items) == 0:
-        self.logger.info("No work to do. Waiting...")
-        continue
-
-      # We have work to do. Run the model on the inputs.
-      for item in work_response.items:
-        if not item.HasField('post_model_outputs_request'):
-          raise Exception("Unexpected work item type: {}".format(item))
-        self.logger.info(
-            f"Working on item: {item.id} with inputs {len(item.post_model_outputs_request.inputs)}"
-        )
-        result = self._run(item.post_model_outputs_request)
-
-        request = service_pb2.PostRunnerItemOutputsRequest(
-            user_app_id=self.user_app_id,
-            item_id=item.id,
-            runner_id=self.runner_id,
-            runner_item_outputs=[service_pb2.RunnerItemOutput(multi_output_response=result)])
-        result_response = self._grpc_request(self.STUB.PostRunnerItemOutputs, request)
-        if result_response.status.code != status_code_pb2.SUCCESS:
-          raise Exception(
-              json_format.MessageToJson(result_response, preserving_proto_field_name=True))
-          # raise Exception("Error posting result: {}".format(result_response.status.description))
-
-  def __getattr__(self, name):
-    return getattr(self.runner_info, name)
-
-  def __str__(self):
-    init_params = [param for param in self.kwargs.keys()]
-    attribute_strings = [
-        f"{param}={getattr(self.runner_info, param)}" for param in init_params
-        if hasattr(self.runner_info, param)
-    ]
-    return f"Runner Details: \n{', '.join(attribute_strings)}\n"

clarifai_utils/client/search.py

@@ -1,254 +0,0 @@
-from math import ceil
-from typing import Any, Callable, Dict, Generator
-
-from clarifai_grpc.grpc.api import resources_pb2, service_pb2
-from clarifai_grpc.grpc.api.status import status_code_pb2
-from google.protobuf.json_format import MessageToDict
-from google.protobuf.struct_pb2 import Struct
-from schema import SchemaError
-
-from clarifai.client.base import BaseClient
-from clarifai.client.input import Inputs
-from clarifai.client.lister import Lister
-from clarifai.constants.search import DEFAULT_SEARCH_METRIC, DEFAULT_TOP_K
-from clarifai.errors import UserError
-from clarifai.schema.search import get_schema
-
-
-class Search(Lister, BaseClient):
-
-  def __init__(self,
-               user_id,
-               app_id,
-               top_k: int = DEFAULT_TOP_K,
-               metric: str = DEFAULT_SEARCH_METRIC):
-    """Initialize the Search object.
-
-    Args:
-        user_id (str): User ID.
-        app_id (str): App ID.
-        top_k (int, optional): Top K results to retrieve. Defaults to 10.
-        metric (str, optional): Similarity metric (either 'cosine' or 'euclidean'). Defaults to 'cosine'.
-
-    Raises:
-        UserError: If the metric is not 'cosine' or 'euclidean'.
-    """
-    if metric not in ["cosine", "euclidean"]:
-      raise UserError("Metric should be either cosine or euclidean")
-
-    self.user_id = user_id
-    self.app_id = app_id
-    self.metric_distance = dict(cosine="COSINE_DISTANCE", euclidean="EUCLIDEAN_DISTANCE")[metric]
-    self.data_proto = resources_pb2.Data()
-    self.top_k = top_k
-
-    self.inputs = Inputs(user_id=self.user_id, app_id=self.app_id)
-    self.rank_filter_schema = get_schema()
-    BaseClient.__init__(self, user_id=self.user_id, app_id=self.app_id)
-    Lister.__init__(self, page_size=1000)
-
-  def _get_annot_proto(self, **kwargs):
-    """Get an Annotation proto message based on keyword arguments.
-
-    Args:
-        **kwargs: Keyword arguments specifying the resource.
-
-    Returns:
-        resources_pb2.Annotation: An Annotation proto message.
-    """
-    if not kwargs:
-      return resources_pb2.Annotation()
-
-    self.data_proto = resources_pb2.Data()
-    for key, value in kwargs.items():
-      if key == "image_bytes":
-        image_proto = self.inputs.get_input_from_bytes("", image_bytes=value).data.image
-        self.data_proto.image.CopyFrom(image_proto)
-
-      elif key == "image_url":
-        image_proto = self.inputs.get_input_from_url("", image_url=value).data.image
-        self.data_proto.image.CopyFrom(image_proto)
-
-      elif key == "concepts":
-        for concept in value:
-          concept_proto = resources_pb2.Concept(**concept)
-          self.data_proto.concepts.add().CopyFrom(concept_proto)
-
-      elif key == "text_raw":
-        text_proto = self.inputs.get_input_from_bytes(
-            "", text_bytes=bytes(value, 'utf-8')).data.text
-        self.data_proto.text.CopyFrom(text_proto)
-
-      elif key == "metadata":
-        metadata_struct = Struct()
-        metadata_struct.update(value)
-        self.data_proto.metadata.CopyFrom(metadata_struct)
-
-      elif key == "geo_point":
-        geo_point_proto = self._get_geo_point_proto(value["longitude"], value["latitude"],
-                                                    value["geo_limit"])
-        self.data_proto.geo.CopyFrom(geo_point_proto)
-
-      else:
-        raise UserError(f"kwargs contain key that is not supported: {key}")
-    return resources_pb2.Annotation(data=self.data_proto)
-
-  def _get_input_proto(self, **kwargs):
-    """Get an Input proto message based on keyword arguments.
-
-    Args:
-        **kwargs: Keyword arguments specifying the resource.
-
-    Returns:
-        resources_pb2.Input: An Input proto message.
-    """
-    if not kwargs:
-      return resources_pb2.Input()
-
-    self.input_proto = resources_pb2.Input()
-    self.data_proto = resources_pb2.Data()
-    for key, value in kwargs.items():
-      if key == "input_types":
-        for input_type in value:
-          if input_type == "image":
-            self.data_proto.image.CopyFrom(resources_pb2.Image())
-          elif input_type == "text":
-            self.data_proto.text.CopyFrom(resources_pb2.Text())
-          elif input_type == "audio":
-            self.data_proto.audio.CopyFrom(resources_pb2.Audio())
-          elif input_type == "video":
-            self.data_proto.video.CopyFrom(resources_pb2.Video())
-        self.input_proto.data.CopyFrom(self.data_proto)
-      elif key == "input_dataset_ids":
-        self.input_proto.dataset_ids.extend(value)
-      elif key == "input_status_code":
-        self.input_proto.status.code = value
-      else:
-        raise UserError(f"kwargs contain key that is not supported: {key}")
-    return self.input_proto
-
-  def _get_geo_point_proto(self, longitude: float, latitude: float,
-                           geo_limit: float) -> resources_pb2.Geo:
-    """Get a GeoPoint proto message based on geographical data.
-
-    Args:
-        longitude (float): Longitude coordinate.
-        latitude (float): Latitude coordinate.
-        geo_limit (float): Geographical limit.
-
-    Returns:
-        resources_pb2.Geo: A Geo proto message.
-    """
-    return resources_pb2.Geo(
-        geo_point=resources_pb2.GeoPoint(longitude=longitude, latitude=latitude),
-        geo_limit=resources_pb2.GeoLimit(type="withinKilometers", value=geo_limit))
-
-  def list_all_pages_generator(
-      self, endpoint: Callable[..., Any], proto_message: Any,
-      request_data: Dict[str, Any]) -> Generator[Dict[str, Any], None, None]:
-    """Lists all pages of a resource.
-
-        Args:
-            endpoint (Callable): The endpoint to call.
-            proto_message (Any): The proto message to use.
-            request_data (dict): The request data to use.
-
-        Yields:
-            response_dict: The next item in the listing.
-        """
-    max_pages = ceil(self.top_k / self.default_page_size)
-    total_hits = 0
-    page = 1
-    while (page <= max_pages):
-      if (page == max_pages):
-        per_page = self.top_k - total_hits
-      else:
-        per_page = self.default_page_size
-      request_data['pagination'] = service_pb2.Pagination(page=page, per_page=per_page)
-      response = self._grpc_request(endpoint, proto_message(**request_data))
-      dict_response = MessageToDict(response, preserving_proto_field_name=True)
-      if response.status.code != status_code_pb2.SUCCESS:
-        if "page * perPage cannot exceed" in str(response.status.details):
-          msg = (f"Your top_k is set to {self.top_k}. "
-                 f"The current pagination settings exceed the limit. Please reach out to "
-                 f"support@clarifai.com to request an increase for your use case.\n"
-                 f"req_id: {response.status.req_id}")
-          raise UserError(msg)
-        else:
-          raise Exception(f"Listing failed with response {response!r}")
-
-      if 'hits' not in list(dict_response.keys()):
-        break
-      page += 1
-      total_hits += per_page
-      yield response
-
-  def query(self, ranks=[{}], filters=[{}]):
-    """Perform a query with rank and filters.
-
-    Args:
-        ranks (List[Dict], optional): List of rank parameters. Defaults to [{}].
-        filters (List[Dict], optional): List of filter parameters. Defaults to [{}].
-
-    Returns:
-        Generator[Dict[str, Any], None, None]: A generator of query results.
-
-    Examples:
-        Get successful inputs of type image or text
-        >>> from clarifai.client.search import Search
-        >>> search = Search(user_id='user_id', app_id='app_id', top_k=10, metric='cosine')
-        >>> res = search.query(filters=[{'input_types': ['image', 'text']}, {'input_status_code': 30000}])
-
-        Vector search over inputs
-        >>> from clarifai.client.search import Search
-        >>> search = Search(user_id='user_id', app_id='app_id', top_k=1, metric='cosine')
-        >>> res = search.query(ranks=[{'image_url': 'https://samples.clarifai.com/dog.tiff'}])
-
-    Note: For more detailed search examples, please refer to [examples](https://github.com/Clarifai/examples/tree/main/search).
-    """
-    try:
-      self.rank_filter_schema.validate(ranks)
-      self.rank_filter_schema.validate(filters)
-    except SchemaError as err:
-      raise UserError(f"Invalid rank or filter input: {err}")
-
-    ## Calls PostInputsSearches for input filters
-    if any(["input" in k for k in filters[0].keys()]):
-      filters_input_proto = []
-      for filter_dict in filters:
-        filters_input_proto.append(self._get_input_proto(**filter_dict))
-      all_filters = [
-          resources_pb2.Filter(input=filter_input) for filter_input in filters_input_proto
-      ]
-      request_data = dict(
-          user_app_id=self.user_app_id,
-          searches=[
-              resources_pb2.Search(
-                  query=resources_pb2.Query(filters=all_filters), metric=self.metric_distance)
-          ])
-
-      return self.list_all_pages_generator(self.STUB.PostInputsSearches,
-                                           service_pb2.PostInputsSearchesRequest, request_data)
-
-    # Calls PostAnnotationsSearches for annotation ranks, filters
-    rank_annot_proto, filters_annot_proto = [], []
-    for rank_dict in ranks:
-      rank_annot_proto.append(self._get_annot_proto(**rank_dict))
-    for filter_dict in filters:
-      filters_annot_proto.append(self._get_annot_proto(**filter_dict))
-
-    all_ranks = [resources_pb2.Rank(annotation=rank_annot) for rank_annot in rank_annot_proto]
-    all_filters = [
-        resources_pb2.Filter(annotation=filter_annot) for filter_annot in filters_annot_proto
-    ]
-
-    request_data = dict(
-        user_app_id=self.user_app_id,
-        searches=[
-            resources_pb2.Search(
-                query=resources_pb2.Query(ranks=all_ranks, filters=all_filters),
-                metric=self.metric_distance)
-        ])
-
-    return self.list_all_pages_generator(self.STUB.PostAnnotationsSearches,
-                                         service_pb2.PostAnnotationsSearchesRequest, request_data)