



"""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(SCREAMING_SNAKE_CASE_				)
class       A_			(     SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""






						def __init__(					self :List[Any]   ,  **lowercase_ :int					)				->			Union[str, Any]:
												super().__init__(**lowercase_					)
												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(lowercase_					)






						def 	UpperCAmelCase__     (					self :Union[str, Any]   ,  **lowercase_ :int					)				->			List[str]:
												UpperCAmelCase             = {}
												UpperCAmelCase             = {}
												UpperCAmelCase             = {}
												# preprocess args
												if "points_per_batch" in kwargs:
																		UpperCAmelCase             = kwargs['points_per_batch']
												if "points_per_crop" in kwargs:
																		UpperCAmelCase             = kwargs['points_per_crop']
												if "crops_n_layers" in kwargs:
																		UpperCAmelCase             = kwargs['crops_n_layers']
												if "crop_overlap_ratio" in kwargs:
																		UpperCAmelCase             = kwargs['crop_overlap_ratio']
												if "crop_n_points_downscale_factor" in kwargs:
																		UpperCAmelCase             = kwargs['crop_n_points_downscale_factor']
												# postprocess args
												if "pred_iou_thresh" in kwargs:
																		UpperCAmelCase             = kwargs['pred_iou_thresh']
												if "stability_score_offset" in kwargs:
																		UpperCAmelCase             = kwargs['stability_score_offset']
												if "mask_threshold" in kwargs:
																		UpperCAmelCase             = kwargs['mask_threshold']
												if "stability_score_thresh" in kwargs:
																		UpperCAmelCase             = kwargs['stability_score_thresh']
												if "crops_nms_thresh" in kwargs:
																		UpperCAmelCase             = kwargs['crops_nms_thresh']
												if "output_rle_mask" in kwargs:
																		UpperCAmelCase             = kwargs['output_rle_mask']
												if "output_bboxes_mask" in kwargs:
																		UpperCAmelCase             = kwargs['output_bboxes_mask']
												return preprocess_kwargs, forward_params, postprocess_kwargs






						def __call__(					self :Tuple   ,  lowercase_ :str   ,  *lowercase_ :Tuple   ,  lowercase_ :Optional[int]=None   ,  lowercase_ :Tuple=None   ,  **lowercase_ :str					)				->			List[Any]:
												return super().__call__(lowercase_   ,  *lowercase_   ,  num_workers=lowercase_   ,  batch_size=lowercase_   ,  **lowercase_					)






						def 	UpperCAmelCase__     (					self :Optional[int]   ,  lowercase_ :Any   ,  lowercase_ :Optional[Any]=64   ,  lowercase_ :int = 0   ,  lowercase_ :float = 5_12 / 15_00   ,  lowercase_ :Optional[int] = 32   ,  lowercase_ :Optional[int] = 1   ,  )				->			Union[str, Any]:
												UpperCAmelCase             = load_image(lowercase_					)
												UpperCAmelCase             = self.image_processor.size['longest_edge']
												UpperCAmelCase      ,    UpperCAmelCase      ,    UpperCAmelCase      ,    UpperCAmelCase             = self.image_processor.generate_crop_boxes(
												    lowercase_   ,  lowercase_   ,  lowercase_   ,  lowercase_   ,  lowercase_   ,  lowercase_					)
												UpperCAmelCase             = self.image_processor(images=lowercase_   ,  return_tensors='pt'					)

												with self.device_placement():
																		if self.framework == "pt":
																								UpperCAmelCase             = self.get_inference_context()
																								with inference_context():
																														UpperCAmelCase             = self._ensure_tensor_on_device(lowercase_   ,  device=self.device					)
																														UpperCAmelCase             = self.model.get_image_embeddings(model_inputs.pop('pixel_values'					)					)
																														UpperCAmelCase             = image_embeddings

												UpperCAmelCase             = grid_points.shape[1]
												UpperCAmelCase             = 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   ,  lowercase_   ,  lowercase_					):
																		UpperCAmelCase             = grid_points[:, i : i + points_per_batch, :, :]
																		UpperCAmelCase             = input_labels[:, i : i + points_per_batch]
																		UpperCAmelCase             = 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 	UpperCAmelCase__     (					self :Optional[Any]   ,  lowercase_ :Any   ,  lowercase_ :Optional[Any]=0.88   ,  lowercase_ :Tuple=0.95   ,  lowercase_ :Optional[Any]=0   ,  lowercase_ :Optional[int]=1   ,  )				->			str:
												UpperCAmelCase             = model_inputs.pop('input_boxes'					)
												UpperCAmelCase             = model_inputs.pop('is_last'					)
												UpperCAmelCase             = model_inputs.pop('original_sizes'					).tolist()
												UpperCAmelCase             = model_inputs.pop('reshaped_input_sizes'					).tolist()

												UpperCAmelCase             = self.model(**lowercase_					)

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






						def 	UpperCAmelCase__     (					self :Tuple   ,  lowercase_ :Any   ,  lowercase_ :Optional[Any]=False   ,  lowercase_ :List[str]=False   ,  lowercase_ :Union[str, Any]=0.7   ,  )				->			str:
												UpperCAmelCase             = []
												UpperCAmelCase             = []
												UpperCAmelCase             = []
												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'					)					)

												UpperCAmelCase             = torch.cat(lowercase_					)
												UpperCAmelCase             = torch.cat(lowercase_					)
												UpperCAmelCase      ,    UpperCAmelCase      ,    UpperCAmelCase      ,    UpperCAmelCase             = self.image_processor.post_process_for_mask_generation(
												    lowercase_   ,  lowercase_   ,  lowercase_   ,  lowercase_					)

												UpperCAmelCase             = defaultdict(lowercase_					)
												for output in model_outputs:
																		for k, v in output.items():
																								extra[k].append(lowercase_					)

												UpperCAmelCase             = {}
												if output_rle_mask:
																		UpperCAmelCase             = rle_mask

												if output_bboxes_mask:
																		UpperCAmelCase             = bounding_boxes

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









# 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 	UpperCAmelCase_					(					UpperCamelCase    ):

   '''simple docstring'''




   __A :      Dict     		=		"openai/whisper-base"
   __A :      str     		=		(
       "This is a tool that transcribes an audio into text. It takes an input named `audio` and returns the "
       "transcribed text."
   )
   __A :      Any     		=		"transcriber"
   __A :      Any     		=		WhisperProcessor
   __A :      int     		=		WhisperForConditionalGeneration

   __A :      Any     		=		["audio"]
   __A :      List[str]     		=		["text"]






   def _snake_case    (		self						,				__A ):






     """simple docstring"""





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






   def _snake_case    (		self						,				__A ):






     """simple docstring"""





     return self.model.generate(inputs=__A )






   def _snake_case    (		self						,				__A ):






     """simple docstring"""





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



