






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__   :						str													=   logging.get_logger(__name__)


@add_end_docstrings(UpperCAmelCase__     )
class     _a							(	UpperCAmelCase__     ):






  """simple docstring"""





  def __init__(  self		,		**_UpperCAmelCase			)      ->			Optional[Any]:
     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  _UpperCAmelCase  (  self		,		**_UpperCAmelCase			)      ->			Any:
     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		,		_UpperCAmelCase		,		*_UpperCAmelCase		,		_UpperCAmelCase=None		,		_UpperCAmelCase=None		,		**_UpperCAmelCase			)      ->			List[str]:
     return super().__call__(_UpperCAmelCase		,		*_UpperCAmelCase		,		num_workers=_UpperCAmelCase		,		batch_size=_UpperCAmelCase		,		**_UpperCAmelCase			)




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase=64		,		_UpperCAmelCase = 0		,		_UpperCAmelCase = 512 / 1500		,		_UpperCAmelCase = 32		,		_UpperCAmelCase = 1		,		)      ->			Optional[Any]:
     UpperCamelCase_						=  load_image(_UpperCAmelCase			)
     UpperCamelCase_						=  self.image_processor.size['longest_edge']
     UpperCamelCase_		,   UpperCamelCase_		,   UpperCamelCase_		,   UpperCamelCase_						=  self.image_processor.generate_crop_boxes(
         _UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase			)
     UpperCamelCase_						=  self.image_processor(images=_UpperCAmelCase		,		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(_UpperCAmelCase		,		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		,		_UpperCAmelCase		,		_UpperCAmelCase			):
        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		,		_UpperCAmelCase		,		_UpperCAmelCase=0.8_8		,		_UpperCAmelCase=0.9_5		,		_UpperCAmelCase=0		,		_UpperCAmelCase=1		,		)      ->			List[Any]:
     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(**_UpperCAmelCase			)

     # 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(
         _UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase		,		binarize=_UpperCAmelCase			)
     UpperCamelCase_						=  model_outputs['iou_scores']
     UpperCamelCase_		,   UpperCamelCase_		,   UpperCamelCase_						=  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  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase=False		,		_UpperCAmelCase=False		,		_UpperCAmelCase=0.7		,		)      ->			Any:
     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(_UpperCAmelCase			)
     UpperCamelCase_						=  torch.cat(_UpperCAmelCase			)
     UpperCamelCase_		,   UpperCamelCase_		,   UpperCamelCase_		,   UpperCamelCase_						=  self.image_processor.post_process_for_mask_generation(
         _UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase			)

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

     UpperCamelCase_						=  {}
     if output_rle_mask:
        UpperCamelCase_						=  rle_mask

     if output_bboxes_mask:
        UpperCamelCase_						=  bounding_boxes

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













from __future__ import annotations

import unittest

from transformers import AutoTokenizer, MBartConfig, is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
 import tensorflow as tf

 from transformers import TFAutoModelForSeqaSeqLM, TFMBartForConditionalGeneration, TFMBartModel


@require_tf
class     _a							:






  """simple docstring"""





  A_						       = MBartConfig
  A_						       = {}
  A_						       = """gelu"""




  def __init__(  self		,		_UpperCAmelCase		,		_UpperCAmelCase=13		,		_UpperCAmelCase=7		,		_UpperCAmelCase=True		,		_UpperCAmelCase=False		,		_UpperCAmelCase=99		,		_UpperCAmelCase=32		,		_UpperCAmelCase=2		,		_UpperCAmelCase=4		,		_UpperCAmelCase=37		,		_UpperCAmelCase=0.1		,		_UpperCAmelCase=0.1		,		_UpperCAmelCase=20		,		_UpperCAmelCase=2		,		_UpperCAmelCase=1		,		_UpperCAmelCase=0		,		)      ->			Union[str, Any]:
     UpperCamelCase_						=  parent
     UpperCamelCase_						=  batch_size
     UpperCamelCase_						=  seq_length
     UpperCamelCase_						=  is_training
     UpperCamelCase_						=  use_labels
     UpperCamelCase_						=  vocab_size
     UpperCamelCase_						=  hidden_size
     UpperCamelCase_						=  num_hidden_layers
     UpperCamelCase_						=  num_attention_heads
     UpperCamelCase_						=  intermediate_size
     UpperCamelCase_						=  hidden_dropout_prob
     UpperCamelCase_						=  attention_probs_dropout_prob
     UpperCamelCase_						=  max_position_embeddings
     UpperCamelCase_						=  eos_token_id
     UpperCamelCase_						=  pad_token_id
     UpperCamelCase_						=  bos_token_id




  def  _UpperCAmelCase  (  self			)      ->			List[Any]:
     UpperCamelCase_						=  ids_tensor([self.batch_size, self.seq_length - 1]		,		self.vocab_size			)
     UpperCamelCase_						=  tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size			)		,		1			)
     UpperCamelCase_						=  tf.concat([input_ids, eos_tensor]		,		axis=1			)

     UpperCamelCase_						=  ids_tensor([self.batch_size, self.seq_length]		,		self.vocab_size			)

     UpperCamelCase_						=  self.config_cls(
         vocab_size=self.vocab_size		,		d_model=self.hidden_size		,		encoder_layers=self.num_hidden_layers		,		decoder_layers=self.num_hidden_layers		,		encoder_attention_heads=self.num_attention_heads		,		decoder_attention_heads=self.num_attention_heads		,		encoder_ffn_dim=self.intermediate_size		,		decoder_ffn_dim=self.intermediate_size		,		dropout=self.hidden_dropout_prob		,		attention_dropout=self.attention_probs_dropout_prob		,		max_position_embeddings=self.max_position_embeddings		,		eos_token_ids=[2]		,		bos_token_id=self.bos_token_id		,		pad_token_id=self.pad_token_id		,		decoder_start_token_id=self.pad_token_id		,		**self.config_updates		,		)
     UpperCamelCase_						=  prepare_mbart_inputs_dict(_UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase			)
     return config, inputs_dict




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase			)      ->			List[str]:
     UpperCamelCase_						=  TFMBartModel(config=_UpperCAmelCase			).get_decoder()
     UpperCamelCase_						=  inputs_dict['input_ids']

     UpperCamelCase_						=  input_ids[:1, :]
     UpperCamelCase_						=  inputs_dict['attention_mask'][:1, :]
     UpperCamelCase_						=  inputs_dict['head_mask']
     UpperCamelCase_						=  1

     # first forward pass
     UpperCamelCase_						=  model(_UpperCAmelCase		,		attention_mask=_UpperCAmelCase		,		head_mask=_UpperCAmelCase		,		use_cache=_UpperCAmelCase			)

     UpperCamelCase_		,   UpperCamelCase_						=  outputs.to_tuple()
     UpperCamelCase_						=  past_key_values[1]






def      _snake_case     (__lowercase     ,   __lowercase     ,   __lowercase     ,   __lowercase=None     ,   __lowercase=None     ,   __lowercase=None     ,   __lowercase=None     ,   __lowercase=None     ,   ):
   if attention_mask is None:
      UpperCamelCase_						=  tf.cast(tf.math.not_equal(__lowercase     ,   config.pad_token_id)     ,   tf.inta)
   if decoder_attention_mask is None:
      UpperCamelCase_						=  tf.concat(
          [
              tf.ones(decoder_input_ids[:, :1].shape     ,   dtype=tf.inta),
              tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:]     ,   config.pad_token_id)     ,   tf.inta),
          ]     ,   axis=-1     ,   )
   if head_mask is None:
      UpperCamelCase_						=  tf.ones((config.encoder_layers, config.encoder_attention_heads))
   if decoder_head_mask is None:
      UpperCamelCase_						=  tf.ones((config.decoder_layers, config.decoder_attention_heads))
   if cross_attn_head_mask is None:
      UpperCamelCase_						=  tf.ones((config.decoder_layers, config.decoder_attention_heads))
   return {
       "input_ids": input_ids,
       "decoder_input_ids": decoder_input_ids,
       "attention_mask": attention_mask,
       "decoder_attention_mask": decoder_attention_mask,
       "head_mask": head_mask,
       "decoder_head_mask": decoder_head_mask,
       "cross_attn_head_mask": cross_attn_head_mask,
   }


@require_tf
class     _a							(	UpperCAmelCase__    ,							UpperCAmelCase__    ,							unittest.TestCase     ):






  """simple docstring"""





  A_						       = (TFMBartForConditionalGeneration, TFMBartModel) if is_tf_available() else ()
  A_						       = (TFMBartForConditionalGeneration,) if is_tf_available() else ()
  A_						       = (
      {
          """conversational""": TFMBartForConditionalGeneration,
          """feature-extraction""": TFMBartModel,
          """summarization""": TFMBartForConditionalGeneration,
          """text2text-generation""": TFMBartForConditionalGeneration,
          """translation""": TFMBartForConditionalGeneration,
      }
      if is_tf_available()
      else {}
  )
  A_						       = True
  A_						       = False
  A_						       = False




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase			)      ->			Tuple:
     if pipeline_test_casse_name != "FeatureExtractionPipelineTests":
        # Exception encountered when calling layer '...'
        return True

     return False




  def  _UpperCAmelCase  (  self			)      ->			Optional[int]:
     UpperCamelCase_						=  TFMBartModelTester(self			)
     UpperCamelCase_						=  ConfigTester(self		,		config_class=_UpperCAmelCase			)




  def  _UpperCAmelCase  (  self			)      ->			Optional[int]:
     self.config_tester.run_common_tests()




  def  _UpperCAmelCase  (  self			)      ->			List[Any]:
     UpperCamelCase_						=  self.model_tester.prepare_config_and_inputs_for_common()
     self.model_tester.check_decoder_model_past_large_inputs(*_UpperCAmelCase			)




@require_sentencepiece
@require_tokenizers
@require_tf
class     _a							(	unittest.TestCase     ):






  """simple docstring"""





  A_						       = [
      """ UN Chief Says There Is No Military Solution in Syria""",
  ]
  A_						       = [
      """Şeful ONU declară că nu există o soluţie militară în Siria""",
  ]
  A_						       = """facebook/mbart-large-en-ro"""




  @cached_property
  def  _UpperCAmelCase  (  self			)      ->			Any:
     return AutoTokenizer.from_pretrained(self.model_name			)




  @cached_property
  def  _UpperCAmelCase  (  self			)      ->			List[str]:
     UpperCamelCase_						=  TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name			)
     return model




  def  _UpperCAmelCase  (  self		,		**_UpperCAmelCase			)      ->			int:
     UpperCamelCase_						=  self.translate_src_text(**_UpperCAmelCase			)
     self.assertListEqual(self.expected_text		,		_UpperCAmelCase			)




  def  _UpperCAmelCase  (  self		,		**_UpperCAmelCase			)      ->			List[str]:
     UpperCamelCase_						=  self.tokenizer(self.src_text		,		**_UpperCAmelCase		,		return_tensors='tf'			)
     UpperCamelCase_						=  self.model.generate(
         model_inputs.input_ids		,		attention_mask=model_inputs.attention_mask		,		num_beams=2			)
     UpperCamelCase_						=  self.tokenizer.batch_decode(_UpperCAmelCase		,		skip_special_tokens=_UpperCAmelCase			)
     return generated_words




  @slow
  def  _UpperCAmelCase  (  self			)      ->			List[Any]:
     self._assert_generated_batch_equal_expected()





