






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

snake_case__   :						int													=   logging.get_logger(__name__)


@add_end_docstrings(UpperCAmelCase__     )
class     _a							(	UpperCAmelCase__     ):






  """simple docstring"""





  def __init__(  self		,		**_UpperCAmelCase			)      ->			Union[str, Any]:
     super().__init__(**_UpperCAmelCase			)

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

     requires_backends(self		,		'vision'			)
     self.check_model_type(_UpperCAmelCase			)




  def __call__(  self		,		_UpperCAmelCase		,		_UpperCAmelCase = None		,		**_UpperCAmelCase		,		)      ->			Union[str, Any]:
     if "text_queries" in kwargs:
        UpperCamelCase_						=  kwargs.pop('text_queries'			)

     if isinstance(_UpperCAmelCase		,		(str, Image.Image)			):
        UpperCamelCase_						=  {'image': image, 'candidate_labels': candidate_labels}
     else:
        UpperCamelCase_						=  image
     UpperCamelCase_						=  super().__call__(_UpperCAmelCase		,		**_UpperCAmelCase			)
     return results




  def  _UpperCAmelCase  (  self		,		**_UpperCAmelCase			)      ->			Optional[int]:
     UpperCamelCase_						=  {}
     if "threshold" in kwargs:
        UpperCamelCase_						=  kwargs['threshold']
     if "top_k" in kwargs:
        UpperCamelCase_						=  kwargs['top_k']
     return {}, {}, postprocess_params




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase			)      ->			Optional[Any]:
     UpperCamelCase_						=  load_image(inputs['image']			)
     UpperCamelCase_						=  inputs['candidate_labels']
     if isinstance(_UpperCAmelCase		,		_UpperCAmelCase			):
        UpperCamelCase_						=  candidate_labels.split(','			)

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




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase			)      ->			str:
     UpperCamelCase_						=  model_inputs.pop('target_size'			)
     UpperCamelCase_						=  model_inputs.pop('candidate_label'			)
     UpperCamelCase_						=  model_inputs.pop('is_last'			)

     UpperCamelCase_						=  self.model(**_UpperCAmelCase			)

     UpperCamelCase_						=  {'target_size': target_size, 'candidate_label': candidate_label, 'is_last': is_last, **outputs}
     return model_outputs




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase=0.1		,		_UpperCAmelCase=None			)      ->			List[str]:
     UpperCamelCase_						=  []
     for model_output in model_outputs:
        UpperCamelCase_						=  model_output['candidate_label']
        UpperCamelCase_						=  BaseModelOutput(_UpperCAmelCase			)
        UpperCamelCase_						=  self.image_processor.post_process_object_detection(
            outputs=_UpperCAmelCase		,		threshold=_UpperCAmelCase		,		target_sizes=model_output['target_size']			)[0]

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

           UpperCamelCase_						=  {'score': score, 'label': label, 'box': box}
           results.append(_UpperCAmelCase			)

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

     return results




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase			)      ->			Dict[str, int]:
     if self.framework != "pt":
        raise ValueError('The ZeroShotObjectDetectionPipeline is only available in PyTorch.'			)
     UpperCamelCase_		,   UpperCamelCase_		,   UpperCamelCase_		,   UpperCamelCase_						=  box.int().tolist()
     UpperCamelCase_						=  {
         'xmin': xmin,
         'ymin': ymin,
         'xmax': xmax,
         'ymax': ymax,
     }
     return bbox













import os
import tempfile
from functools import partial
from unittest import TestCase
from unittest.mock import patch

import datasets
import datasets.config

from .utils import require_beam


class     _a							(	datasets.BeamBasedBuilder     ):






  """simple docstring"""





  def  _UpperCAmelCase  (  self			)      ->			List[str]:
     return datasets.DatasetInfo(
         features=datasets.Features({'content': datasets.Value('string'			)}			)		,		supervised_keys=_UpperCAmelCase		,		)




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase			)      ->			Optional[Any]:
     return [datasets.SplitGenerator(name=datasets.Split.TRAIN		,		gen_kwargs={'examples': get_test_dummy_examples()}			)]




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase			)      ->			Tuple:
     import apache_beam as beam

     return pipeline | "Load Examples" >> beam.Create(_UpperCAmelCase			)




class     _a							(	datasets.BeamBasedBuilder     ):






  """simple docstring"""





  def  _UpperCAmelCase  (  self			)      ->			Any:
     return datasets.DatasetInfo(
         features=datasets.Features({'a': datasets.Sequence({'b': datasets.Value('string'			)}			)}			)		,		supervised_keys=_UpperCAmelCase		,		)




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase			)      ->			Tuple:
     return [
         datasets.SplitGenerator(name=datasets.Split.TRAIN		,		gen_kwargs={'examples': get_test_nested_examples()}			)
     ]




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase			)      ->			Union[str, Any]:
     import apache_beam as beam

     return pipeline | "Load Examples" >> beam.Create(_UpperCAmelCase			)






def      _snake_case     ():
   return [(i, {"content": content}) for i, content in enumerate(['foo', 'bar', 'foobar'])]






def      _snake_case     ():
   return [(i, {"a": {"b": [content]}}) for i, content in enumerate(['foo', 'bar', 'foobar'])]


class     _a							(	UpperCAmelCase__     ):






  """simple docstring"""





  @require_beam
  def  _UpperCAmelCase  (  self			)      ->			Dict:
     UpperCamelCase_						=  len(get_test_dummy_examples()			)
     with tempfile.TemporaryDirectory() as tmp_cache_dir:
        UpperCamelCase_						=  DummyBeamDataset(cache_dir=_UpperCAmelCase		,		beam_runner='DirectRunner'			)
        builder.download_and_prepare()
        self.assertTrue(
            os.path.exists(
                os.path.join(_UpperCAmelCase		,		builder.name		,		'default'		,		'0.0.0'		,		f"""{builder.name}-train.arrow"""			)			)			)
        self.assertDictEqual(builder.info.features		,		datasets.Features({'content': datasets.Value('string'			)}			)			)
        UpperCamelCase_						=  builder.as_dataset()
        self.assertEqual(dset['train'].num_rows		,		_UpperCAmelCase			)
        self.assertEqual(dset['train'].info.splits['train'].num_examples		,		_UpperCAmelCase			)
        self.assertDictEqual(dset['train'][0]		,		get_test_dummy_examples()[0][1]			)
        self.assertDictEqual(
            dset['train'][expected_num_examples - 1]		,		get_test_dummy_examples()[expected_num_examples - 1][1]			)
        self.assertTrue(
            os.path.exists(os.path.join(_UpperCAmelCase		,		builder.name		,		'default'		,		'0.0.0'		,		'dataset_info.json'			)			)			)
        del dset




  @require_beam
  def  _UpperCAmelCase  (  self			)      ->			List[str]:
     import apache_beam as beam

     UpperCamelCase_						=  beam.io.parquetio.WriteToParquet

     UpperCamelCase_						=  len(get_test_dummy_examples()			)
     with tempfile.TemporaryDirectory() as tmp_cache_dir:
        UpperCamelCase_						=  DummyBeamDataset(cache_dir=_UpperCAmelCase		,		beam_runner='DirectRunner'			)
        with patch('apache_beam.io.parquetio.WriteToParquet'			) as write_parquet_mock:
           UpperCamelCase_						=  partial(_UpperCAmelCase		,		num_shards=2			)
           builder.download_and_prepare()
        self.assertTrue(
            os.path.exists(
                os.path.join(
                    _UpperCAmelCase		,		builder.name		,		'default'		,		'0.0.0'		,		f"""{builder.name}-train-00000-of-00002.arrow"""			)			)			)
        self.assertTrue(
            os.path.exists(
                os.path.join(
                    _UpperCAmelCase		,		builder.name		,		'default'		,		'0.0.0'		,		f"""{builder.name}-train-00000-of-00002.arrow"""			)			)			)
        self.assertDictEqual(builder.info.features		,		datasets.Features({'content': datasets.Value('string'			)}			)			)
        UpperCamelCase_						=  builder.as_dataset()
        self.assertEqual(dset['train'].num_rows		,		_UpperCAmelCase			)
        self.assertEqual(dset['train'].info.splits['train'].num_examples		,		_UpperCAmelCase			)
        # Order is not preserved when sharding, so we just check that all the elements are there
        self.assertListEqual(sorted(dset['train']['content']			)		,		sorted(['foo', 'bar', 'foobar']			)			)
        self.assertTrue(
            os.path.exists(os.path.join(_UpperCAmelCase		,		builder.name		,		'default'		,		'0.0.0'		,		'dataset_info.json'			)			)			)
        del dset




  @require_beam
  def  _UpperCAmelCase  (  self			)      ->			Any:
     with tempfile.TemporaryDirectory() as tmp_cache_dir:
        UpperCamelCase_						=  DummyBeamDataset(cache_dir=_UpperCAmelCase			)
        self.assertRaises(datasets.builder.MissingBeamOptions		,		builder.download_and_prepare			)




  @require_beam
  def  _UpperCAmelCase  (  self			)      ->			Union[str, Any]:
     UpperCamelCase_						=  len(get_test_nested_examples()			)
     with tempfile.TemporaryDirectory() as tmp_cache_dir:
        UpperCamelCase_						=  NestedBeamDataset(cache_dir=_UpperCAmelCase		,		beam_runner='DirectRunner'			)
        builder.download_and_prepare()
        self.assertTrue(
            os.path.exists(
                os.path.join(_UpperCAmelCase		,		builder.name		,		'default'		,		'0.0.0'		,		f"""{builder.name}-train.arrow"""			)			)			)
        self.assertDictEqual(
            builder.info.features		,		datasets.Features({'a': datasets.Sequence({'b': datasets.Value('string'			)}			)}			)			)
        UpperCamelCase_						=  builder.as_dataset()
        self.assertEqual(dset['train'].num_rows		,		_UpperCAmelCase			)
        self.assertEqual(dset['train'].info.splits['train'].num_examples		,		_UpperCAmelCase			)
        self.assertDictEqual(dset['train'][0]		,		get_test_nested_examples()[0][1]			)
        self.assertDictEqual(
            dset['train'][expected_num_examples - 1]		,		get_test_nested_examples()[expected_num_examples - 1][1]			)
        self.assertTrue(
            os.path.exists(os.path.join(_UpperCAmelCase		,		builder.name		,		'default'		,		'0.0.0'		,		'dataset_info.json'			)			)			)
        del dset





