
from __future__ import annotations

import random
import unittest

from transformers import TransfoXLConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

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 (
						    TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
						    TFTransfoXLForSequenceClassification,
						    TFTransfoXLLMHeadModel,
						    TFTransfoXLModel,
						)





class   UpperCamelCase_      :







						'''simple docstring'''



						def __init__(			self							:Tuple		,    lowerCAmelCase__							:Optional[int]		,    )  ->str:
										lowercase         =      parent
										lowercase         =      13
										lowercase         =      7
										lowercase         =      30
										lowercase         =      self.seq_length + self.mem_len
										lowercase         =      15
										lowercase         =      True
										lowercase         =      True
										lowercase         =      99
										lowercase         =      [10, 50, 80]
										lowercase         =      32
										lowercase         =      32
										lowercase         =      4
										lowercase         =      8
										lowercase         =      128
										lowercase         =      2
										lowercase         =      2
										lowercase         =      None
										lowercase         =      1
										lowercase         =      0
										lowercase         =      3
										lowercase         =      self.vocab_size - 1
										lowercase         =      0.01





						def        SCREAMING_SNAKE_CASE(			self							:int     )  ->str:
										lowercase         =      ids_tensor([self.batch_size, self.seq_length]		,    self.vocab_size     )
										lowercase         =      ids_tensor([self.batch_size, self.seq_length]		,    self.vocab_size     )

										lowercase         =      None
										if self.use_labels:
														lowercase         =      ids_tensor([self.batch_size, self.seq_length]		,    self.vocab_size     )

										lowercase         =      TransfoXLConfig(
										    vocab_size=self.vocab_size		,    mem_len=self.mem_len		,    clamp_len=self.clamp_len		,    cutoffs=self.cutoffs		,    d_model=self.hidden_size		,    d_embed=self.d_embed		,    n_head=self.num_attention_heads		,    d_head=self.d_head		,    d_inner=self.d_inner		,    div_val=self.div_val		,    n_layer=self.num_hidden_layers		,    eos_token_id=self.eos_token_id		,    pad_token_id=self.vocab_size - 1		,    init_range=self.init_range		,    num_labels=self.num_labels		,    )

										return (config, input_ids_a, input_ids_a, lm_labels)





						def        SCREAMING_SNAKE_CASE(			self							:Union[str, Any]     )  ->Any:
										random.seed(self.seed     )
										tf.random.set_seed(self.seed     )





						def        SCREAMING_SNAKE_CASE(			self							:Union[str, Any]		,    lowerCAmelCase__							:Tuple		,    lowerCAmelCase__							:List[Any]		,    lowerCAmelCase__							:List[str]		,    lowerCAmelCase__							:Tuple     )  ->Optional[int]:
										lowercase         =      TFTransfoXLModel(lowerCAmelCase__     )

										lowercase     ,	lowercase         =      model(lowerCAmelCase__     ).to_tuple()

										lowercase         =      {"input_ids": input_ids_a, "mems": mems_a}

										lowercase     ,	lowercase         =      model(lowerCAmelCase__     ).to_tuple()

										self.parent.assertEqual(hidden_states_a.shape		,    (self.batch_size, self.seq_length, self.hidden_size)     )
										self.parent.assertEqual(hidden_states_a.shape		,    (self.batch_size, self.seq_length, self.hidden_size)     )
										self.parent.assertListEqual(
										    [mem.shape for mem in mems_a]		,    [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers		,    )
										self.parent.assertListEqual(
										    [mem.shape for mem in mems_a]		,    [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers		,    )





						def        SCREAMING_SNAKE_CASE(			self							:Any		,    lowerCAmelCase__							:Union[str, Any]		,    lowerCAmelCase__							:Union[str, Any]		,    lowerCAmelCase__							:Optional[int]		,    lowerCAmelCase__							:Any     )  ->Optional[int]:
										lowercase         =      TFTransfoXLLMHeadModel(lowerCAmelCase__     )

										lowercase     ,	lowercase         =      model(lowerCAmelCase__     ).to_tuple()

										lowercase         =      {"input_ids": input_ids_a, "labels": lm_labels}
										lowercase     ,	lowercase         =      model(lowerCAmelCase__     ).to_tuple()

										lowercase     ,	lowercase         =      model([input_ids_a, mems_a]     ).to_tuple()

										lowercase         =      {"input_ids": input_ids_a, "mems": mems_a, "labels": lm_labels}

										lowercase     ,	lowercase         =      model(lowerCAmelCase__     ).to_tuple()

										self.parent.assertEqual(lm_logits_a.shape		,    (self.batch_size, self.seq_length, self.vocab_size)     )
										self.parent.assertListEqual(
										    [mem.shape for mem in mems_a]		,    [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers		,    )

										self.parent.assertEqual(lm_logits_a.shape		,    (self.batch_size, self.seq_length, self.vocab_size)     )
										self.parent.assertListEqual(
										    [mem.shape for mem in mems_a]		,    [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers		,    )





						def        SCREAMING_SNAKE_CASE(			self							:Optional[int]		,    lowerCAmelCase__							:List[Any]		,    lowerCAmelCase__							:Dict		,    lowerCAmelCase__							:Dict		,    lowerCAmelCase__							:Tuple     )  ->int:
										lowercase         =      TFTransfoXLForSequenceClassification(lowerCAmelCase__     )
										lowercase         =      model(lowerCAmelCase__     )
										self.parent.assertEqual(result.logits.shape		,    (self.batch_size, self.num_labels)     )





						def        SCREAMING_SNAKE_CASE(			self							:Optional[Any]     )  ->List[Any]:
										lowercase         =      self.prepare_config_and_inputs()
										((lowercase)     ,	(lowercase)     ,	(lowercase)     ,	(lowercase))         =      config_and_inputs
										lowercase         =      {"input_ids": input_ids_a}
										return config, inputs_dict





@require_tf
class   UpperCamelCase_      (      __a		,    __a		,    unittest.TestCase		):







						'''simple docstring'''



						UpperCamelCase      :  Optional[int]				   =					(
						    (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
						)
						UpperCamelCase      :  Optional[int]				   =					() if is_tf_available() else ()
						UpperCamelCase      :  int				   =					(
						    {
						        '''feature-extraction''': TFTransfoXLModel,
						        '''text-classification''': TFTransfoXLForSequenceClassification,
						        '''text-generation''': TFTransfoXLLMHeadModel,
						        '''zero-shot''': TFTransfoXLForSequenceClassification,
						    }
						    if is_tf_available()
						    else {}
						)
						# TODO: add this test when TFTransfoXLLMHead has a linear output layer implemented
						UpperCamelCase      :  Tuple				   =					False
						UpperCamelCase      :  Tuple				   =					False
						UpperCamelCase      :  int				   =					False
						UpperCamelCase      :  str				   =					False





						def        SCREAMING_SNAKE_CASE(			self							:Union[str, Any]		,    lowerCAmelCase__							:Tuple		,    lowerCAmelCase__							:Union[str, Any]		,    lowerCAmelCase__							:int		,    lowerCAmelCase__							:Optional[Any]		,    lowerCAmelCase__							:Any     )  ->List[str]:
										if pipeline_test_casse_name == "TextGenerationPipelineTests":
														# Get `ValueError: AttributeError: 'NoneType' object has no attribute 'new_ones'` or `AssertionError`.
														# `TransfoXLConfig` was never used in pipeline tests: cannot create a simple
														# tokenizer.
														return True

										return False





						def        SCREAMING_SNAKE_CASE(			self							:List[Any]     )  ->Dict:
										lowercase         =      TFTransfoXLModelTester(self     )
										lowercase         =      ConfigTester(self		,    config_class=lowerCAmelCase__		,    d_embed=37     )





						def        SCREAMING_SNAKE_CASE(			self							:List[Any]     )  ->List[Any]:
										self.config_tester.run_common_tests()





						def        SCREAMING_SNAKE_CASE(			self							:Optional[Any]     )  ->Union[str, Any]:
										self.model_tester.set_seed()
										lowercase         =      self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_transfo_xl_model(*lowerCAmelCase__     )





						def        SCREAMING_SNAKE_CASE(			self							:str     )  ->Tuple:
										self.model_tester.set_seed()
										lowercase         =      self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_transfo_xl_lm_head(*lowerCAmelCase__     )





						def        SCREAMING_SNAKE_CASE(			self							:int     )  ->Any:
										lowercase         =      self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*lowerCAmelCase__     )





						def        SCREAMING_SNAKE_CASE(			self							:int     )  ->List[Any]:
										lowercase     ,	lowercase         =      self.model_tester.prepare_config_and_inputs_for_common()
										lowercase         =      [TFTransfoXLForSequenceClassification]

										for model_class in self.all_model_classes:
														lowercase         =      model_class(lowerCAmelCase__     )
														assert isinstance(model.get_input_embeddings()		,    tf.keras.layers.Layer     )
														if model_class in list_other_models_with_output_ebd:
																		lowercase         =      model.get_output_embeddings()
																		assert isinstance(lowerCAmelCase__		,    tf.keras.layers.Layer     )
																		lowercase         =      model.get_bias()
																		assert name is None
														else:
																		lowercase         =      model.get_output_embeddings()
																		assert x is None
																		lowercase         =      model.get_bias()
																		assert name is None





						def        SCREAMING_SNAKE_CASE(			self							:List[str]     )  ->List[str]:
										# TODO JP: Make TransfoXL XLA compliant
										pass





						@slow
						def        SCREAMING_SNAKE_CASE(			self							:Optional[int]     )  ->Dict:
										for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														lowercase         =      TFTransfoXLModel.from_pretrained(lowerCAmelCase__     )
														self.assertIsNotNone(lowerCAmelCase__     )





						@unittest.skip(reason="This model doesn't play well with fit() due to not returning a single loss."     )
						def        SCREAMING_SNAKE_CASE(			self							:Optional[Any]     )  ->Any:
										pass





@require_tf
class   UpperCamelCase_      (      unittest.TestCase		):







						'''simple docstring'''



						@unittest.skip("Skip test until #12651 is resolved."     )
						@slow
						def        SCREAMING_SNAKE_CASE(			self							:Any     )  ->Any:
										lowercase         =      TFTransfoXLLMHeadModel.from_pretrained("transfo-xl-wt103"     )
										# fmt: off
										lowercase         =      tf.convert_to_tensor([[33,1297,2,1,1009,4,1109,11739,4762,358,5,25,245,22,1706,17,20098,5,3215,21,37,1110,3,13,1041,4,24,603,490,2,71477,20098,104447,2,20961,1,2604,4,1,329,3,6224,831,16002,2,8,603,78967,29546,23,803,20,25,416,5,8,232,4,277,6,1855,4601,3,29546,54,8,3609,5,57211,49,4,1,277,18,8,1755,15691,3,341,25,416,693,42573,71,17,401,94,31,17919,2,29546,7873,18,1,435,23,11011,755,5,5167,3,7983,98,84,2,29546,3267,8,3609,4,1,4865,1075,2,6087,71,6,346,8,5854,3,29546,824,1400,1868,2,19,160,2,311,8,5496,2,20920,17,25,15097,3,24,24,0]]		,    dtype=tf.intaa     )  # noqa: E231
										# fmt: on
										#  In 1991 , the remains of Russian Tsar Nicholas II and his family
										#  ( except for Alexei and Maria ) are discovered .
										#  The voice of Nicholas's young son , Tsarevich Alexei Nikolaevich , narrates the
										#  remainder of the story . 1883 Western Siberia ,
										#  a young Grigori Rasputin is asked by his father and a group of men to perform magic .
										#  Rasputin has a vision and denounces one of the men as a horse thief . Although his
										#  father initially slaps him for making such an accusation , Rasputin watches as the
										#  man is chased outside and beaten . Twenty years later , Rasputin sees a vision of
										#  the Virgin Mary , prompting him to become a priest . Rasputin quickly becomes famous ,
										#  with people , even a bishop , begging for his blessing . <eod> </s> <eos>

										# fmt: off
										lowercase         =      [33,1297,2,1,1009,4,1109,11739,4762,358,5,25,245,22,1706,17,20098,5,3215,21,37,1110,3,13,1041,4,24,603,490,2,71477,20098,104447,2,20961,1,2604,4,1,329,3,6224,831,16002,2,8,603,78967,29546,23,803,20,25,416,5,8,232,4,277,6,1855,4601,3,29546,54,8,3609,5,57211,49,4,1,277,18,8,1755,15691,3,341,25,416,693,42573,71,17,401,94,31,17919,2,29546,7873,18,1,435,23,11011,755,5,5167,3,7983,98,84,2,29546,3267,8,3609,4,1,4865,1075,2,6087,71,6,346,8,5854,3,29546,824,1400,1868,2,19,160,2,311,8,5496,2,20920,17,25,15097,3,24,24,0,33,1,1857,2,1,1009,4,1109,11739,4762,358,5,25,245,28,1110,3,13,1041,4,24,603,490,2,71477,20098,104447,2,20961,1,2604,4,1,329,3,0]  # noqa: E231
										# fmt: on
										#  In 1991, the remains of Russian Tsar Nicholas II and his family (
										#  except for Alexei and Maria ) are discovered. The voice of young son,
										#  Tsarevich Alexei Nikolaevich, narrates the remainder of the story.
										#  1883 Western Siberia, a young Grigori Rasputin is asked by his father
										#  and a group of men to perform magic. Rasputin has a vision and
										#  denounces one of the men as a horse thief. Although his father initially
										#  slaps him for making such an accusation, Rasputin watches as the man
										#  is chased outside and beaten. Twenty years later, Rasputin sees a vision
										#  of the Virgin Mary, prompting him to become a priest.
										#  Rasputin quickly becomes famous, with people, even a bishop, begging for
										#  his blessing. <unk> <unk> <eos> In the 1990s, the remains of Russian Tsar
										# Nicholas II and his family were discovered. The voice of <unk> young son,
										# Tsarevich Alexei Nikolaevich, narrates the remainder of the story.<eos>

										lowercase         =      model.generate(lowerCAmelCase__		,    max_length=200		,    do_sample=lowerCAmelCase__     )
										self.assertListEqual(output_ids[0].numpy().tolist()		,    lowerCAmelCase__     )


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      :							List[Any]     	=    logging.get_logger(__name__)





@add_end_docstrings(__a		)
class   UpperCamelCase_      (      __a		):







						'''simple docstring'''



						def __init__(			self							:Tuple		,    **lowerCAmelCase__							:Dict     )  ->int:
										super().__init__(**lowerCAmelCase__     )
										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(lowerCAmelCase__     )





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





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





						def        SCREAMING_SNAKE_CASE(			self							:Optional[Any]		,    lowerCAmelCase__							:str		,    lowerCAmelCase__							:Optional[Any]=64		,    lowerCAmelCase__							:int = 0		,    lowerCAmelCase__							:float = 512 / 1500		,    lowerCAmelCase__							:Optional[int] = 32		,    lowerCAmelCase__							:Optional[int] = 1		,    )  ->Any:
										lowercase         =      load_image(lowerCAmelCase__     )
										lowercase         =      self.image_processor.size["longest_edge"]
										lowercase     ,	lowercase     ,	lowercase     ,	lowercase         =      self.image_processor.generate_crop_boxes(
										    lowerCAmelCase__		,    lowerCAmelCase__		,    lowerCAmelCase__		,    lowerCAmelCase__		,    lowerCAmelCase__		,    lowerCAmelCase__     )
										lowercase         =      self.image_processor(images=lowerCAmelCase__		,    return_tensors="pt"     )

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

										lowercase         =      grid_points.shape[1]
										lowercase         =      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		,    lowerCAmelCase__		,    lowerCAmelCase__     ):
														lowercase         =      grid_points[:, i : i + points_per_batch, :, :]
														lowercase         =      input_labels[:, i : i + points_per_batch]
														lowercase         =      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        SCREAMING_SNAKE_CASE(			self							:Union[str, Any]		,    lowerCAmelCase__							:List[Any]		,    lowerCAmelCase__							:Dict=0.88		,    lowerCAmelCase__							:Dict=0.95		,    lowerCAmelCase__							:str=0		,    lowerCAmelCase__							:int=1		,    )  ->str:
										lowercase         =      model_inputs.pop("input_boxes"     )
										lowercase         =      model_inputs.pop("is_last"     )
										lowercase         =      model_inputs.pop("original_sizes"     ).tolist()
										lowercase         =      model_inputs.pop("reshaped_input_sizes"     ).tolist()

										lowercase         =      self.model(**lowerCAmelCase__     )

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





						def        SCREAMING_SNAKE_CASE(			self							:Any		,    lowerCAmelCase__							:Dict		,    lowerCAmelCase__							:Union[str, Any]=False		,    lowerCAmelCase__							:str=False		,    lowerCAmelCase__							:int=0.7		,    )  ->List[Any]:
										lowercase         =      []
										lowercase         =      []
										lowercase         =      []
										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"     )     )

										lowercase         =      torch.cat(lowerCAmelCase__     )
										lowercase         =      torch.cat(lowerCAmelCase__     )
										lowercase     ,	lowercase     ,	lowercase     ,	lowercase         =      self.image_processor.post_process_for_mask_generation(
										    lowerCAmelCase__		,    lowerCAmelCase__		,    lowerCAmelCase__		,    lowerCAmelCase__     )

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

										lowercase         =      {}
										if output_rle_mask:
														lowercase         =      rle_mask

										if output_bboxes_mask:
														lowercase         =      bounding_boxes

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