"""simple docstring"""






from typing import Any, Dict, List, Union

from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging, requires_backends
from .base import PIPELINE_INIT_ARGS, ChunkPipeline


if is_vision_available():
       from PIL import Image

       from ..image_utils import load_image

if is_torch_available():
       import torch

       from transformers.modeling_outputs import BaseModelOutput

       from ..models.auto.modeling_auto import MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING

__lowerCAmelCase    :       List[str]					     =logging.get_logger(__name__)





@add_end_docstrings(lowerCAmelCase	)
class  _A						(       lowerCAmelCase	):

      def __init__(						self		,       **__lowerCAmelCase						):







            """simple docstring"""



            super().__init__(**__lowerCAmelCase						)

            if self.framework == "tf":
                  raise ValueError(f'The {self.__class__} is only available in PyTorch.'						)

            requires_backends(self		,       """vision"""						)
            self.check_model_type(__lowerCAmelCase						)

      def __call__(						self		,       __lowerCAmelCase		,       __lowerCAmelCase = None		,       **__lowerCAmelCase		,       ):







            """simple docstring"""



            if "text_queries" in kwargs:
                  lowercase														=	kwargs.pop("""text_queries"""						)

            if isinstance(__lowerCAmelCase		,       (str, Image.Image)						):
                  lowercase														=	{"""image""": image, """candidate_labels""": candidate_labels}
            else:
                  lowercase														=	image
            lowercase														=	super().__call__(__lowerCAmelCase		,       **__lowerCAmelCase						)
            return results

      def 				A__       (						self		,       **__lowerCAmelCase						):







            """simple docstring"""



            lowercase														=	{}
            if "threshold" in kwargs:
                  lowercase														=	kwargs["""threshold"""]
            if "top_k" in kwargs:
                  lowercase														=	kwargs["""top_k"""]
            return {}, {}, postprocess_params

      def 				A__       (						self		,       __lowerCAmelCase						):







            """simple docstring"""



            lowercase														=	load_image(inputs["""image"""]						)
            lowercase														=	inputs["""candidate_labels"""]
            if isinstance(__lowerCAmelCase		,       __lowerCAmelCase						):
                  lowercase														=	candidate_labels.split(""","""						)

            lowercase														=	torch.tensor([[image.height, image.width]]		,       dtype=torch.intaa						)
            for i, candidate_label in enumerate(__lowerCAmelCase						):
                  lowercase														=	self.tokenizer(__lowerCAmelCase		,       return_tensors=self.framework						)
                  lowercase														=	self.image_processor(__lowerCAmelCase		,       return_tensors=self.framework						)
                  yield {
                      "is_last": i == len(__lowerCAmelCase						) - 1,
                      "target_size": target_size,
                      "candidate_label": candidate_label,
                      **text_inputs,
                      **image_features,
                  }

      def 				A__       (						self		,       __lowerCAmelCase						):







            """simple docstring"""



            lowercase														=	model_inputs.pop("""target_size"""						)
            lowercase														=	model_inputs.pop("""candidate_label"""						)
            lowercase														=	model_inputs.pop("""is_last"""						)

            lowercase														=	self.model(**__lowerCAmelCase						)

            lowercase														=	{"""target_size""": target_size, """candidate_label""": candidate_label, """is_last""": is_last, **outputs}
            return model_outputs

      def 				A__       (						self		,       __lowerCAmelCase		,       __lowerCAmelCase=0.1		,       __lowerCAmelCase=None						):







            """simple docstring"""



            lowercase														=	[]
            for model_output in model_outputs:
                  lowercase														=	model_output["""candidate_label"""]
                  lowercase														=	BaseModelOutput(__lowerCAmelCase						)
                  lowercase														=	self.image_processor.post_process_object_detection(
                      outputs=__lowerCAmelCase		,       threshold=__lowerCAmelCase		,       target_sizes=model_output["""target_size"""]						)[0]

                  for index in outputs["scores"].nonzero():
                        lowercase														=	outputs["""scores"""][index].item()
                        lowercase														=	self._get_bounding_box(outputs["""boxes"""][index][0]						)

                        lowercase														=	{"""score""": score, """label""": label, """box""": box}
                        results.append(__lowerCAmelCase						)

            lowercase														=	sorted(__lowerCAmelCase		,       key=lambda __lowerCAmelCase						: x["score"]		,       reverse=__lowerCAmelCase						)
            if top_k:
                  lowercase														=	results[:top_k]

            return results







      def 				A__       (						self		,       __lowerCAmelCase						):







            """simple docstring"""



            if self.framework != "pt":
                  raise ValueError("""The ZeroShotObjectDetectionPipeline is only available in PyTorch."""						)
            lowercase							,							lowercase							,							lowercase							,							lowercase														=	box.int().tolist()
            lowercase														=	{
                """xmin""": xmin,
                """ymin""": ymin,
                """xmax""": xmax,
                """ymax""": ymax,
            }
            return bbox




"""simple docstring"""






from ..utils import DummyObject, requires_backends





class  _A						(       metaclass=lowerCAmelCase	):
      snake_case__			:   List[str]							  =	['onnx']

      def __init__(						self		,       *__lowerCAmelCase		,       **__lowerCAmelCase						):







            """simple docstring"""



            requires_backends(self		,       ["""onnx"""]						)

      @classmethod
      def 				A__       (						cls		,       *__lowerCAmelCase		,       **__lowerCAmelCase						):







            """simple docstring"""



            requires_backends(cls		,       ["""onnx"""]						)







      @classmethod
      def 				A__       (						cls		,       *__lowerCAmelCase		,       **__lowerCAmelCase						):







            """simple docstring"""



            requires_backends(cls		,       ["""onnx"""]						)



