


"""simple docstring"""



from collections import defaultdict
from typing import Optional

from ..image_utils import load_image
from ..utils import (
    add_end_docstrings,
    is_torch_available,
    logging,
    requires_backends,
)
from .base import PIPELINE_INIT_ARGS, ChunkPipeline


if is_torch_available():
  import torch

  from ..models.auto.modeling_auto import MODEL_FOR_MASK_GENERATION_MAPPING

__snake_case       =       logging.get_logger(__name__)







@add_end_docstrings(snake_case_      )
class _lowerCAmelCase							( snake_case_      ):







   def __init__(      self		,      **UpperCamelCase__		)      ->						str:

       '''simple docstring'''




       super().__init__(**UpperCamelCase__		)
       requires_backends(self		,      "vision"		)
       requires_backends(self		,      "torch"		)

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

       self.check_model_type(UpperCamelCase__		)







   def 					lowerCamelCase						(      self		,      **UpperCamelCase__		)      ->						List[Any]:

       '''simple docstring'''




       snake_case       : Union[str, Any]    =       {}
       snake_case       : List[Any]    =       {}
       snake_case       : List[Any]    =       {}
       # preprocess args
       if "points_per_batch" in kwargs:
           snake_case       : Tuple    =       kwargs["points_per_batch"]
       if "points_per_crop" in kwargs:
           snake_case       : List[str]    =       kwargs["points_per_crop"]
       if "crops_n_layers" in kwargs:
           snake_case       : Optional[Any]    =       kwargs["crops_n_layers"]
       if "crop_overlap_ratio" in kwargs:
           snake_case       : Dict    =       kwargs["crop_overlap_ratio"]
       if "crop_n_points_downscale_factor" in kwargs:
           snake_case       : List[Any]    =       kwargs["crop_n_points_downscale_factor"]
       # postprocess args
       if "pred_iou_thresh" in kwargs:
           snake_case       : int    =       kwargs["pred_iou_thresh"]
       if "stability_score_offset" in kwargs:
           snake_case       : str    =       kwargs["stability_score_offset"]
       if "mask_threshold" in kwargs:
           snake_case       : int    =       kwargs["mask_threshold"]
       if "stability_score_thresh" in kwargs:
           snake_case       : str    =       kwargs["stability_score_thresh"]
       if "crops_nms_thresh" in kwargs:
           snake_case       : Optional[Any]    =       kwargs["crops_nms_thresh"]
       if "output_rle_mask" in kwargs:
           snake_case       : str    =       kwargs["output_rle_mask"]
       if "output_bboxes_mask" in kwargs:
           snake_case       : Union[str, Any]    =       kwargs["output_bboxes_mask"]
       return preprocess_kwargs, forward_params, postprocess_kwargs







   def __call__(      self		,      UpperCamelCase__		,      *UpperCamelCase__		,      UpperCamelCase__=None		,      UpperCamelCase__=None		,      **UpperCamelCase__		)      ->						List[Any]:

       '''simple docstring'''




       return super().__call__(UpperCamelCase__		,      *UpperCamelCase__		,      num_workers=UpperCamelCase__		,      batch_size=UpperCamelCase__		,      **UpperCamelCase__		)







   def 					lowerCamelCase						(      self		,      UpperCamelCase__		,      UpperCamelCase__=64		,      UpperCamelCase__ = 0		,      UpperCamelCase__ = 512 / 1500		,      UpperCamelCase__ = 32		,      UpperCamelCase__ = 1		,      )      ->						Tuple:

       '''simple docstring'''




       snake_case       : List[str]    =       load_image(UpperCamelCase__		)
       snake_case       : Dict    =       self.image_processor.size["longest_edge"]
       snake_case   ,snake_case   ,snake_case   ,snake_case       : Tuple    =       self.image_processor.generate_crop_boxes(
           UpperCamelCase__		,      UpperCamelCase__		,      UpperCamelCase__		,      UpperCamelCase__		,      UpperCamelCase__		,      UpperCamelCase__		)
       snake_case       : Optional[Any]    =       self.image_processor(images=UpperCamelCase__		,      return_tensors="pt"		)

       with self.device_placement():
           if self.framework == "pt":
               snake_case       : Optional[Any]    =       self.get_inference_context()
               with inference_context():
                   snake_case       : int    =       self._ensure_tensor_on_device(UpperCamelCase__		,      device=self.device		)
                   snake_case       : List[Any]    =       self.model.get_image_embeddings(model_inputs.pop("pixel_values"		)		)
                   snake_case       : Dict    =       image_embeddings

       snake_case       : Tuple    =       grid_points.shape[1]
       snake_case       : Tuple    =       points_per_batch if points_per_batch is not None else n_points

       if points_per_batch <= 0:
           raise ValueError(
               "Cannot have points_per_batch<=0. Must be >=1 to returned batched outputs. "
               "To return all points at once, set points_per_batch to None"		)

       for i in range(0		,      UpperCamelCase__		,      UpperCamelCase__		):
           snake_case       : Tuple    =       grid_points[:, i : i + points_per_batch, :, :]
           snake_case       : Optional[int]    =       input_labels[:, i : i + points_per_batch]
           snake_case       : Tuple    =       i == n_points - points_per_batch
           yield {
               "input_points": batched_points,
               "input_labels": labels,
               "input_boxes": crop_boxes,
               "is_last": is_last,
               **model_inputs,
           }







   def 					lowerCamelCase						(      self		,      UpperCamelCase__		,      UpperCamelCase__=0.88		,      UpperCamelCase__=0.95		,      UpperCamelCase__=0		,      UpperCamelCase__=1		,      )      ->						List[Any]:

       '''simple docstring'''




       snake_case       : Optional[int]    =       model_inputs.pop("input_boxes"		)
       snake_case       : List[str]    =       model_inputs.pop("is_last"		)
       snake_case       : str    =       model_inputs.pop("original_sizes"		).tolist()
       snake_case       : List[str]    =       model_inputs.pop("reshaped_input_sizes"		).tolist()

       snake_case       : Optional[Any]    =       self.model(**UpperCamelCase__		)

       # post processing happens here in order to avoid CPU GPU copies of ALL the masks
       snake_case       : List[Any]    =       model_outputs["pred_masks"]
       snake_case       : Any    =       self.image_processor.post_process_masks(
           UpperCamelCase__		,      UpperCamelCase__		,      UpperCamelCase__		,      UpperCamelCase__		,      binarize=UpperCamelCase__		)
       snake_case       : Tuple    =       model_outputs["iou_scores"]
       snake_case   ,snake_case   ,snake_case       : str    =       self.image_processor.filter_masks(
           masks[0]		,      iou_scores[0]		,      original_sizes[0]		,      input_boxes[0]		,      UpperCamelCase__		,      UpperCamelCase__		,      UpperCamelCase__		,      UpperCamelCase__		,      )
       return {
           "masks": masks,
           "is_last": is_last,
           "boxes": boxes,
           "iou_scores": iou_scores,
       }







   def 					lowerCamelCase						(      self		,      UpperCamelCase__		,      UpperCamelCase__=False		,      UpperCamelCase__=False		,      UpperCamelCase__=0.7		,      )      ->						Optional[Any]:

       '''simple docstring'''




       snake_case       : List[Any]    =       []
       snake_case       : Any    =       []
       snake_case       : Optional[int]    =       []
       for model_output in model_outputs:
           all_scores.append(model_output.pop("iou_scores"		)		)
           all_masks.extend(model_output.pop("masks"		)		)
           all_boxes.append(model_output.pop("boxes"		)		)

       snake_case       : List[str]    =       torch.cat(UpperCamelCase__		)
       snake_case       : Tuple    =       torch.cat(UpperCamelCase__		)
       snake_case   ,snake_case   ,snake_case   ,snake_case       : Union[str, Any]    =       self.image_processor.post_process_for_mask_generation(
           UpperCamelCase__		,      UpperCamelCase__		,      UpperCamelCase__		,      UpperCamelCase__		)

       snake_case       : Any    =       defaultdict(UpperCamelCase__		)
       for output in model_outputs:
           for k, v in output.items():
               extra[k].append(UpperCamelCase__		)

       snake_case       : int    =       {}
       if output_rle_mask:
           snake_case       : List[Any]    =       rle_mask

       if output_bboxes_mask:
           snake_case       : Any    =       bounding_boxes

       return {"masks": output_masks, "scores": iou_scores, **optional, **extra}









"""simple docstring"""



# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# 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.
from ..models.whisper import WhisperForConditionalGeneration, WhisperProcessor
from .base import PipelineTool







class _lowerCAmelCase							( snake_case_      ):
   __UpperCAmelCase					:			List[str]				    =    '''openai/whisper-base'''
   __UpperCAmelCase					:			Any				    =    (
       '''This is a tool that transcribes an audio into text. It takes an input named `audio` and returns the '''
       '''transcribed text.'''
   )
   __UpperCAmelCase					:			Tuple				    =    '''transcriber'''
   __UpperCAmelCase					:			Union[str, Any]				    =    WhisperProcessor
   __UpperCAmelCase					:			str				    =    WhisperForConditionalGeneration

   __UpperCAmelCase					:			int				    =    ['''audio''']
   __UpperCAmelCase					:			Optional[int]				    =    ['''text''']







   def 					lowerCamelCase						(      self		,      UpperCamelCase__		)      ->						Tuple:

       '''simple docstring'''




       return self.pre_processor(UpperCamelCase__		,      return_tensors="pt"		).input_features







   def 					lowerCamelCase						(      self		,      UpperCamelCase__		)      ->						int:

       '''simple docstring'''




       return self.model.generate(inputs=UpperCamelCase__		)







   def 					lowerCamelCase						(      self		,      UpperCamelCase__		)      ->						Optional[Any]:

       '''simple docstring'''




       return self.pre_processor.batch_decode(UpperCamelCase__		,      skip_special_tokens=UpperCamelCase__		)[0]





