
import unittest

from transformers import (
    MODEL_FOR_CAUSAL_LM_MAPPING,
    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
    TextGenerationPipeline,
    logging,
    pipeline,
)
from transformers.testing_utils import (
    CaptureLogger,
    is_pipeline_test,
    require_accelerate,
    require_tf,
    require_torch,
    require_torch_gpu,
    require_torch_or_tf,
)

from .test_pipelines_common import ANY

@is_pipeline_test
@require_torch_or_tf
class    lowerCAmelCase__     (	unittest.TestCase			):
		a__       :						Optional[Any]        =		MODEL_FOR_CAUSAL_LM_MAPPING
		a__       :						Optional[int]        =		TF_MODEL_FOR_CAUSAL_LM_MAPPING






		@require_torch
		def  __A       (		self		:							List[str]  )     ->							List[Any]:
						__lowerCamelCase    					=	pipeline(task='''text-generation'''							,			model='''sshleifer/tiny-ctrl'''							,			framework='''pt'''  )
						# Using `do_sample=False` to force deterministic output
						__lowerCamelCase    					=	text_generator('''This is a test'''							,			do_sample=SCREAMING_SNAKE_CASE__  )
						self.assertEqual(
						    SCREAMING_SNAKE_CASE__							,			[
						        {
						            '''generated_text''': (
						                '''This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope.'''
						                ''' oscope. FiliFili@@'''
						            )
						        }
						    ]							,			)

						__lowerCamelCase    					=	text_generator(['''This is a test''', '''This is a second test''']  )
						self.assertEqual(
						    SCREAMING_SNAKE_CASE__							,			[
						        [
						            {
						                '''generated_text''': (
						                    '''This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope.'''
						                    ''' oscope. FiliFili@@'''
						                )
						            }
						        ],
						        [
						            {
						                '''generated_text''': (
						                    '''This is a second test ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy'''
						                    ''' oscope. oscope. FiliFili@@'''
						                )
						            }
						        ],
						    ]							,			)

						__lowerCamelCase    					=	text_generator('''This is a test'''							,			do_sample=SCREAMING_SNAKE_CASE__							,			num_return_sequences=2							,			return_tensors=SCREAMING_SNAKE_CASE__  )
						self.assertEqual(
						    SCREAMING_SNAKE_CASE__							,			[
						        {'''generated_token_ids''': ANY(SCREAMING_SNAKE_CASE__  )},
						        {'''generated_token_ids''': ANY(SCREAMING_SNAKE_CASE__  )},
						    ]							,			)
						__lowerCamelCase    					=	text_generator.model.config.eos_token_id
						__lowerCamelCase    					=	'''<pad>'''
						__lowerCamelCase    					=	text_generator(
						    ['''This is a test''', '''This is a second test''']							,			do_sample=SCREAMING_SNAKE_CASE__							,			num_return_sequences=2							,			batch_size=2							,			return_tensors=SCREAMING_SNAKE_CASE__							,			)
						self.assertEqual(
						    SCREAMING_SNAKE_CASE__							,			[
						        [
						            {'''generated_token_ids''': ANY(SCREAMING_SNAKE_CASE__  )},
						            {'''generated_token_ids''': ANY(SCREAMING_SNAKE_CASE__  )},
						        ],
						        [
						            {'''generated_token_ids''': ANY(SCREAMING_SNAKE_CASE__  )},
						            {'''generated_token_ids''': ANY(SCREAMING_SNAKE_CASE__  )},
						        ],
						    ]							,			)






		@require_tf
		def  __A       (		self		:							Tuple  )     ->							Any:
						__lowerCamelCase    					=	pipeline(task='''text-generation'''							,			model='''sshleifer/tiny-ctrl'''							,			framework='''tf'''  )

						# Using `do_sample=False` to force deterministic output
						__lowerCamelCase    					=	text_generator('''This is a test'''							,			do_sample=SCREAMING_SNAKE_CASE__  )
						self.assertEqual(
						    SCREAMING_SNAKE_CASE__							,			[
						        {
						            '''generated_text''': (
						                '''This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵'''
						                ''' please,'''
						            )
						        }
						    ]							,			)

						__lowerCamelCase    					=	text_generator(['''This is a test''', '''This is a second test''']							,			do_sample=SCREAMING_SNAKE_CASE__  )
						self.assertEqual(
						    SCREAMING_SNAKE_CASE__							,			[
						        [
						            {
						                '''generated_text''': (
						                    '''This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵'''
						                    ''' please,'''
						                )
						            }
						        ],
						        [
						            {
						                '''generated_text''': (
						                    '''This is a second test Chieftain Chieftain prefecture prefecture prefecture Cannes Cannes'''
						                    ''' Cannes 閲閲Cannes Cannes Cannes 攵 please,'''
						                )
						            }
						        ],
						    ]							,			)






		def  __A       (		self		:							List[str]							,			SCREAMING_SNAKE_CASE__		:							List[str]							,			SCREAMING_SNAKE_CASE__		:							str							,			SCREAMING_SNAKE_CASE__		:							Union[str, Any]  )     ->							Any:
						__lowerCamelCase    					=	TextGenerationPipeline(model=SCREAMING_SNAKE_CASE__							,			tokenizer=SCREAMING_SNAKE_CASE__  )
						return text_generator, ["This is a test", "Another test"]






		def  __A       (		self		:							List[str]  )     ->							List[str]:
						__lowerCamelCase    					=	'''Hello I believe in'''
						__lowerCamelCase    					=	pipeline('''text-generation'''							,			model='''hf-internal-testing/tiny-random-gpt2'''  )
						__lowerCamelCase    					=	text_generator(SCREAMING_SNAKE_CASE__  )
						self.assertEqual(
						    SCREAMING_SNAKE_CASE__							,			[{'''generated_text''': '''Hello I believe in fe fe fe fe fe fe fe fe fe fe fe fe'''}]							,			)

						__lowerCamelCase    					=	text_generator(SCREAMING_SNAKE_CASE__							,			stop_sequence=''' fe'''  )
						self.assertEqual(SCREAMING_SNAKE_CASE__							,			[{'''generated_text''': '''Hello I believe in fe'''}]  )






		def  __A       (		self		:							Optional[int]							,			SCREAMING_SNAKE_CASE__		:							int							,			SCREAMING_SNAKE_CASE__		:							List[str]  )     ->							Optional[int]:
						__lowerCamelCase    					=	text_generator.model
						__lowerCamelCase    					=	text_generator.tokenizer

						__lowerCamelCase    					=	text_generator('''This is a test'''  )
						self.assertEqual(SCREAMING_SNAKE_CASE__							,			[{'''generated_text''': ANY(SCREAMING_SNAKE_CASE__  )}]  )
						self.assertTrue(outputs[0]['''generated_text'''].startswith('''This is a test'''  )  )

						__lowerCamelCase    					=	text_generator('''This is a test'''							,			return_full_text=SCREAMING_SNAKE_CASE__  )
						self.assertEqual(SCREAMING_SNAKE_CASE__							,			[{'''generated_text''': ANY(SCREAMING_SNAKE_CASE__  )}]  )
						self.assertNotIn('''This is a test'''							,			outputs[0]['''generated_text''']  )

						__lowerCamelCase    					=	pipeline(task='''text-generation'''							,			model=SCREAMING_SNAKE_CASE__							,			tokenizer=SCREAMING_SNAKE_CASE__							,			return_full_text=SCREAMING_SNAKE_CASE__  )
						__lowerCamelCase    					=	text_generator('''This is a test'''  )
						self.assertEqual(SCREAMING_SNAKE_CASE__							,			[{'''generated_text''': ANY(SCREAMING_SNAKE_CASE__  )}]  )
						self.assertNotIn('''This is a test'''							,			outputs[0]['''generated_text''']  )

						__lowerCamelCase    					=	text_generator('''This is a test'''							,			return_full_text=SCREAMING_SNAKE_CASE__  )
						self.assertEqual(SCREAMING_SNAKE_CASE__							,			[{'''generated_text''': ANY(SCREAMING_SNAKE_CASE__  )}]  )
						self.assertTrue(outputs[0]['''generated_text'''].startswith('''This is a test'''  )  )

						__lowerCamelCase    					=	text_generator(['''This is great !''', '''Something else''']							,			num_return_sequences=2							,			do_sample=SCREAMING_SNAKE_CASE__  )
						self.assertEqual(
						    SCREAMING_SNAKE_CASE__							,			[
						        [{'''generated_text''': ANY(SCREAMING_SNAKE_CASE__  )}, {'''generated_text''': ANY(SCREAMING_SNAKE_CASE__  )}],
						        [{'''generated_text''': ANY(SCREAMING_SNAKE_CASE__  )}, {'''generated_text''': ANY(SCREAMING_SNAKE_CASE__  )}],
						    ]							,			)

						if text_generator.tokenizer.pad_token is not None:
										__lowerCamelCase    					=	text_generator(
										    ['''This is great !''', '''Something else''']							,			num_return_sequences=2							,			batch_size=2							,			do_sample=SCREAMING_SNAKE_CASE__  )
										self.assertEqual(
										    SCREAMING_SNAKE_CASE__							,			[
										        [{'''generated_text''': ANY(SCREAMING_SNAKE_CASE__  )}, {'''generated_text''': ANY(SCREAMING_SNAKE_CASE__  )}],
										        [{'''generated_text''': ANY(SCREAMING_SNAKE_CASE__  )}, {'''generated_text''': ANY(SCREAMING_SNAKE_CASE__  )}],
										    ]							,			)

						with self.assertRaises(SCREAMING_SNAKE_CASE__  ):
										__lowerCamelCase    					=	text_generator('''test'''							,			return_full_text=SCREAMING_SNAKE_CASE__							,			return_text=SCREAMING_SNAKE_CASE__  )
						with self.assertRaises(SCREAMING_SNAKE_CASE__  ):
										__lowerCamelCase    					=	text_generator('''test'''							,			return_full_text=SCREAMING_SNAKE_CASE__							,			return_tensors=SCREAMING_SNAKE_CASE__  )
						with self.assertRaises(SCREAMING_SNAKE_CASE__  ):
										__lowerCamelCase    					=	text_generator('''test'''							,			return_text=SCREAMING_SNAKE_CASE__							,			return_tensors=SCREAMING_SNAKE_CASE__  )

						# Empty prompt is slighly special
						# it requires BOS token to exist.
						# Special case for Pegasus which will always append EOS so will
						# work even without BOS.
						if (
						    text_generator.tokenizer.bos_token_id is not None
						    or "Pegasus" in tokenizer.__class__.__name__
						    or "Git" in model.__class__.__name__
						):
										__lowerCamelCase    					=	text_generator(''''''  )
										self.assertEqual(SCREAMING_SNAKE_CASE__							,			[{'''generated_text''': ANY(SCREAMING_SNAKE_CASE__  )}]  )
						else:
										with self.assertRaises((ValueError, AssertionError)  ):
														__lowerCamelCase    					=	text_generator(''''''  )

						if text_generator.framework == "tf":
										# TF generation does not support max_new_tokens, and it's impossible
										# to control long generation with only max_length without
										# fancy calculation, dismissing tests for now.
										return
						# We don't care about infinite range models.
						# They already work.
						# Skip this test for XGLM, since it uses sinusoidal positional embeddings which are resized on-the-fly.
						__lowerCamelCase    					=	['''RwkvForCausalLM''', '''XGLMForCausalLM''', '''GPTNeoXForCausalLM''']
						if (
						    tokenizer.model_max_length < 1_00_00
						    and text_generator.model.__class__.__name__ not in EXTRA_MODELS_CAN_HANDLE_LONG_INPUTS
						):
										# Handling of large generations
										with self.assertRaises((RuntimeError, IndexError, ValueError, AssertionError)  ):
														text_generator('''This is a test''' * 5_00							,			max_new_tokens=20  )

										__lowerCamelCase    					=	text_generator('''This is a test''' * 5_00							,			handle_long_generation='''hole'''							,			max_new_tokens=20  )
										# Hole strategy cannot work
										with self.assertRaises(SCREAMING_SNAKE_CASE__  ):
														text_generator(
														    '''This is a test''' * 5_00							,			handle_long_generation='''hole'''							,			max_new_tokens=tokenizer.model_max_length + 10							,			)






		@require_torch
		@require_accelerate
		@require_torch_gpu
		def  __A       (		self		:							Any  )     ->							Any:
						import torch

						# Classic `model_kwargs`
						__lowerCamelCase    					=	pipeline(
						    model='''hf-internal-testing/tiny-random-bloom'''							,			model_kwargs={'''device_map''': '''auto''', '''torch_dtype''': torch.bfloataa}							,			)
						self.assertEqual(pipe.model.device							,			torch.device(0  )  )
						self.assertEqual(pipe.model.lm_head.weight.dtype							,			torch.bfloataa  )
						__lowerCamelCase    					=	pipe('''This is a test'''  )
						self.assertEqual(
						    SCREAMING_SNAKE_CASE__							,			[
						        {
						            '''generated_text''': (
						                '''This is a test test test test test test test test test test test test test test test test'''
						                ''' test'''
						            )
						        }
						    ]							,			)

						# Upgraded those two to real pipeline arguments (they just get sent for the model as they're unlikely to mean anything else.)
						__lowerCamelCase    					=	pipeline(model='''hf-internal-testing/tiny-random-bloom'''							,			device_map='''auto'''							,			torch_dtype=torch.bfloataa  )
						self.assertEqual(pipe.model.device							,			torch.device(0  )  )
						self.assertEqual(pipe.model.lm_head.weight.dtype							,			torch.bfloataa  )
						__lowerCamelCase    					=	pipe('''This is a test'''  )
						self.assertEqual(
						    SCREAMING_SNAKE_CASE__							,			[
						        {
						            '''generated_text''': (
						                '''This is a test test test test test test test test test test test test test test test test'''
						                ''' test'''
						            )
						        }
						    ]							,			)

						# torch_dtype will be automatically set to float32 if not provided - check: https://github.com/huggingface/transformers/pull/20602
						__lowerCamelCase    					=	pipeline(model='''hf-internal-testing/tiny-random-bloom'''							,			device_map='''auto'''  )
						self.assertEqual(pipe.model.device							,			torch.device(0  )  )
						self.assertEqual(pipe.model.lm_head.weight.dtype							,			torch.floataa  )
						__lowerCamelCase    					=	pipe('''This is a test'''  )
						self.assertEqual(
						    SCREAMING_SNAKE_CASE__							,			[
						        {
						            '''generated_text''': (
						                '''This is a test test test test test test test test test test test test test test test test'''
						                ''' test'''
						            )
						        }
						    ]							,			)






		@require_torch
		@require_torch_gpu
		def  __A       (		self		:							Any  )     ->							Optional[int]:
						import torch

						__lowerCamelCase    					=	pipeline(model='''hf-internal-testing/tiny-random-bloom'''							,			device=0							,			torch_dtype=torch.floataa  )
						pipe('''This is a test'''  )






		@require_torch
		@require_accelerate
		@require_torch_gpu
		def  __A       (		self		:							Union[str, Any]  )     ->							Tuple:
						import torch

						__lowerCamelCase    					=	pipeline(model='''hf-internal-testing/tiny-random-bloom'''							,			device_map='''auto'''							,			torch_dtype=torch.floataa  )
						pipe('''This is a test'''							,			do_sample=SCREAMING_SNAKE_CASE__							,			top_p=0.5  )







		def  __A       (		self		:							Dict  )     ->							Tuple:
						__lowerCamelCase    					=	'''Hello world'''
						__lowerCamelCase    					=	pipeline('''text-generation'''							,			model='''hf-internal-testing/tiny-random-gpt2'''  )
						if text_generator.model.framework == "tf":
										__lowerCamelCase    					=	logging.get_logger('''transformers.generation.tf_utils'''  )
						else:
										__lowerCamelCase    					=	logging.get_logger('''transformers.generation.utils'''  )
						__lowerCamelCase    					=	'''Both `max_new_tokens`'''  # The beggining of the message to be checked in this test

						# Both are set by the user -> log warning
						with CaptureLogger(SCREAMING_SNAKE_CASE__  ) as cl:
										__lowerCamelCase    					=	text_generator(SCREAMING_SNAKE_CASE__							,			max_length=10							,			max_new_tokens=1  )
						self.assertIn(SCREAMING_SNAKE_CASE__							,			cl.out  )

						# The user only sets one -> no warning
						with CaptureLogger(SCREAMING_SNAKE_CASE__  ) as cl:
										__lowerCamelCase    					=	text_generator(SCREAMING_SNAKE_CASE__							,			max_new_tokens=1  )
						self.assertNotIn(SCREAMING_SNAKE_CASE__							,			cl.out  )

						with CaptureLogger(SCREAMING_SNAKE_CASE__  ) as cl:
										__lowerCamelCase    					=	text_generator(SCREAMING_SNAKE_CASE__							,			max_length=10  )
						self.assertNotIn(SCREAMING_SNAKE_CASE__							,			cl.out  )





import copy
from typing import Dict, List, Optional

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto import CONFIG_MAPPING


SCREAMING_SNAKE_CASE__   :			Dict												=    {
    "facebook/mask2former-swin-small-coco-instance": (
        "https://huggingface.co/facebook/mask2former-swin-small-coco-instance/blob/main/config.json"
    )
    # See all Mask2Former models at https://huggingface.co/models?filter=mask2former
}

SCREAMING_SNAKE_CASE__   :			int												=    logging.get_logger(__name__)

class    lowerCAmelCase__     (	__lowercase			):
		a__       :						Any        =		"""mask2former"""
		a__       :						Dict        =		["""swin"""]
		a__       :						Any        =		{"""hidden_size""": """hidden_dim"""}






		def __init__(		self		:							Any							,			SCREAMING_SNAKE_CASE__		:							Optional[Dict] = None							,			SCREAMING_SNAKE_CASE__		:							int = 2_56							,			SCREAMING_SNAKE_CASE__		:							int = 2_56							,			SCREAMING_SNAKE_CASE__		:							int = 2_56							,			SCREAMING_SNAKE_CASE__		:							int = 10_24							,			SCREAMING_SNAKE_CASE__		:							str = "relu"							,			SCREAMING_SNAKE_CASE__		:							int = 6							,			SCREAMING_SNAKE_CASE__		:							int = 10							,			SCREAMING_SNAKE_CASE__		:							int = 8							,			SCREAMING_SNAKE_CASE__		:							float = 0.0							,			SCREAMING_SNAKE_CASE__		:							int = 20_48							,			SCREAMING_SNAKE_CASE__		:							bool = False							,			SCREAMING_SNAKE_CASE__		:							bool = False							,			SCREAMING_SNAKE_CASE__		:							int = 4							,			SCREAMING_SNAKE_CASE__		:							int = 2_55							,			SCREAMING_SNAKE_CASE__		:							int = 1_00							,			SCREAMING_SNAKE_CASE__		:							float = 0.1							,			SCREAMING_SNAKE_CASE__		:							float = 2.0							,			SCREAMING_SNAKE_CASE__		:							float = 5.0							,			SCREAMING_SNAKE_CASE__		:							float = 5.0							,			SCREAMING_SNAKE_CASE__		:							int = 1_25_44							,			SCREAMING_SNAKE_CASE__		:							float = 3.0							,			SCREAMING_SNAKE_CASE__		:							float = 0.75							,			SCREAMING_SNAKE_CASE__		:							float = 0.02							,			SCREAMING_SNAKE_CASE__		:							float = 1.0							,			SCREAMING_SNAKE_CASE__		:							bool = True							,			SCREAMING_SNAKE_CASE__		:							List[int] = [4, 8, 16, 32]							,			SCREAMING_SNAKE_CASE__		:							bool = None							,			**SCREAMING_SNAKE_CASE__		:							Tuple							,			)     ->							str:
						if backbone_config is None:
										logger.info('''`backbone_config` is `None`. Initializing the config with the default `Swin` backbone.'''  )
										__lowerCamelCase    					=	CONFIG_MAPPING['''swin'''](
										    image_size=2_24							,			in_channels=3							,			patch_size=4							,			embed_dim=96							,			depths=[2, 2, 18, 2]							,			num_heads=[3, 6, 12, 24]							,			window_size=7							,			drop_path_rate=0.3							,			use_absolute_embeddings=SCREAMING_SNAKE_CASE__							,			out_features=['''stage1''', '''stage2''', '''stage3''', '''stage4''']							,			)

						if isinstance(SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__  ):
										__lowerCamelCase    					=	backbone_config.pop('''model_type'''  )
										__lowerCamelCase    					=	CONFIG_MAPPING[backbone_model_type]
										__lowerCamelCase    					=	config_class.from_dict(SCREAMING_SNAKE_CASE__  )

						# verify that the backbone is supported
						if backbone_config.model_type not in self.backbones_supported:
										logger.warning_once(
										    f'''Backbone {backbone_config.model_type} is not a supported model and may not be compatible with Mask2Former. '''
										    f'''Supported model types: {','.join(self.backbones_supported  )}'''  )

						__lowerCamelCase    					=	backbone_config
						__lowerCamelCase    					=	feature_size
						__lowerCamelCase    					=	mask_feature_size
						__lowerCamelCase    					=	hidden_dim
						__lowerCamelCase    					=	encoder_feedforward_dim
						__lowerCamelCase    					=	activation_function
						__lowerCamelCase    					=	encoder_layers
						__lowerCamelCase    					=	decoder_layers
						__lowerCamelCase    					=	num_attention_heads
						__lowerCamelCase    					=	dropout
						__lowerCamelCase    					=	dim_feedforward
						__lowerCamelCase    					=	pre_norm
						__lowerCamelCase    					=	enforce_input_projection
						__lowerCamelCase    					=	common_stride
						__lowerCamelCase    					=	ignore_value
						__lowerCamelCase    					=	num_queries
						__lowerCamelCase    					=	no_object_weight
						__lowerCamelCase    					=	class_weight
						__lowerCamelCase    					=	mask_weight
						__lowerCamelCase    					=	dice_weight
						__lowerCamelCase    					=	train_num_points
						__lowerCamelCase    					=	oversample_ratio
						__lowerCamelCase    					=	importance_sample_ratio
						__lowerCamelCase    					=	init_std
						__lowerCamelCase    					=	init_xavier_std
						__lowerCamelCase    					=	use_auxiliary_loss
						__lowerCamelCase    					=	feature_strides
						__lowerCamelCase    					=	output_auxiliary_logits
						__lowerCamelCase    					=	decoder_layers

						super().__init__(**SCREAMING_SNAKE_CASE__  )






		@classmethod
		def  __A       (		cls		:							Any							,			SCREAMING_SNAKE_CASE__		:							PretrainedConfig							,			**SCREAMING_SNAKE_CASE__		:							Optional[Any]  )     ->							List[Any]:
						return cls(
						    backbone_config=SCREAMING_SNAKE_CASE__							,			**SCREAMING_SNAKE_CASE__							,			)







		def  __A       (		self		:							Any  )     ->							Dict[str, any]:
						__lowerCamelCase    					=	copy.deepcopy(self.__dict__  )
						__lowerCamelCase    					=	self.backbone_config.to_dict()
						__lowerCamelCase    					=	self.__class__.model_type
						return output



