
"""simple docstring"""
import os
import re
import shutil
import sys
import tempfile
import unittest

import black


SCREAMING_SNAKE_CASE_					     =	os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
sys.path.append(os.path.join(git_repo_path, '''utils'''))

import check_copies  # noqa: E402


# This is the reference code that will be used in the tests.
# If BertLMPredictionHead is changed in modeling_bert.py, this code needs to be manually updated.
SCREAMING_SNAKE_CASE_					     =	'''    def __init__(self, config):
        super().__init__()
        self.transform = BertPredictionHeadTransform(config)

        # The output weights are the same as the input embeddings, but there is
        # an output-only bias for each token.
        self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=False)

        self.bias = nn.Parameter(torch.zeros(config.vocab_size))

        # Need a link between the two variables so that the bias is correctly resized with `resize_token_embeddings`
        self.decoder.bias = self.bias

    def forward(self, hidden_states):
        hidden_states = self.transform(hidden_states)
        hidden_states = self.decoder(hidden_states)
        return hidden_states
'''
class       lowerCAmelCase_		(				unittest.TestCase ):



							'''simple docstring'''





							def    A__						( self				)       ->  Optional[Any]:
													__lowerCAmelCase     =  tempfile.mkdtemp()
													os.makedirs(os.path.join(self.transformer_dir    ,				"""models/bert/"""				)				)
													__lowerCAmelCase     =  self.transformer_dir
													shutil.copy(
													    os.path.join(snake_case_    ,				"""src/transformers/models/bert/modeling_bert.py"""				)    ,				os.path.join(self.transformer_dir    ,				"""models/bert/modeling_bert.py"""				)    ,				)




							def    A__						( self				)       ->  Optional[int]:
													__lowerCAmelCase     =  """src/transformers"""
													shutil.rmtree(self.transformer_dir				)




							def    A__						( self    ,				snake_case_    ,				snake_case_    ,				snake_case_    ,				snake_case_=None				)       ->  Optional[int]:
													__lowerCAmelCase     =  comment + f"""\nclass {class_name}(nn.Module):\n""" + class_code
													if overwrite_result is not None:
																			__lowerCAmelCase     =  comment + f"""\nclass {class_name}(nn.Module):\n""" + overwrite_result
													__lowerCAmelCase     =  black.Mode(target_versions={black.TargetVersion.PYaa}    ,				line_length=119				)
													__lowerCAmelCase     =  black.format_str(snake_case_    ,				mode=snake_case_				)
													__lowerCAmelCase     =  os.path.join(self.transformer_dir    ,				"""new_code.py"""				)
													with open(snake_case_    ,				"""w"""    ,				newline="""\n"""				) as f:
																			f.write(snake_case_				)
													if overwrite_result is None:
																			self.assertTrue(len(check_copies.is_copy_consistent(snake_case_				)				) == 0				)
													else:
																			check_copies.is_copy_consistent(f.name    ,				overwrite=snake_case_				)
																			with open(snake_case_    ,				"""r"""				) as f:
																									self.assertTrue(f.read()    ,				snake_case_				)




							def    A__						( self				)       ->  Union[str, Any]:
													__lowerCAmelCase     =  check_copies.find_code_in_transformers("""models.bert.modeling_bert.BertLMPredictionHead"""				)
													self.assertEqual(snake_case_    ,				snake_case_				)




							def    A__						( self				)       ->  List[Any]:
													# Base copy consistency
													self.check_copy_consistency(
													    """# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead"""    ,				"""BertLMPredictionHead"""    ,				REFERENCE_CODE + """\n"""    ,				)

													# With no empty line at the end
													self.check_copy_consistency(
													    """# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead"""    ,				"""BertLMPredictionHead"""    ,				snake_case_    ,				)

													# Copy consistency with rename
													self.check_copy_consistency(
													    """# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->TestModel"""    ,				"""TestModelLMPredictionHead"""    ,				re.sub("""Bert"""    ,				"""TestModel"""    ,				snake_case_				)    ,				)

													# Copy consistency with a really long name
													__lowerCAmelCase     =  """TestModelWithAReallyLongNameBecauseSomePeopleLikeThatForSomeReason"""
													self.check_copy_consistency(
													    f"""# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->{long_class_name}"""    ,				f"""{long_class_name}LMPredictionHead"""    ,				re.sub("""Bert"""    ,				snake_case_    ,				snake_case_				)    ,				)

													# Copy consistency with overwrite
													self.check_copy_consistency(
													    """# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->TestModel"""    ,				"""TestModelLMPredictionHead"""    ,				snake_case_    ,				overwrite_result=re.sub("""Bert"""    ,				"""TestModel"""    ,				snake_case_				)    ,				)




							def    A__						( self				)       ->  Optional[Any]:
													__lowerCAmelCase     =  check_copies.LOCALIZED_READMES["""README_zh-hans.md"""]

													__lowerCAmelCase     =  (
													    """1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (from Google Research and the"""
													    """ Toyota Technological Institute at Chicago) released with the paper [ALBERT: A Lite BERT for"""
													    """ Self-supervised Learning of Language Representations](https://arxiv.org/abs/1909.11942), by Zhenzhong"""
													    """ Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut.\n1."""
													    """ **[DistilBERT](https://huggingface.co/transformers/model_doc/distilbert.html)** (from HuggingFace),"""
													    """ released together with the paper [DistilBERT, a distilled version of BERT: smaller, faster, cheaper and"""
													    """ lighter](https://arxiv.org/abs/1910.01108) by Victor Sanh, Lysandre Debut and Thomas Wolf. The same"""
													    """ method has been applied to compress GPT2 into"""
													    """ [DistilGPT2](https://github.com/huggingface/transformers/tree/main/examples/distillation), RoBERTa into"""
													    """ [DistilRoBERTa](https://github.com/huggingface/transformers/tree/main/examples/distillation),"""
													    """ Multilingual BERT into"""
													    """ [DistilmBERT](https://github.com/huggingface/transformers/tree/main/examples/distillation) and a German"""
													    """ version of DistilBERT.\n1. **[ELECTRA](https://huggingface.co/transformers/model_doc/electra.html)**"""
													    """ (from Google Research/Stanford University) released with the paper [ELECTRA: Pre-training text encoders"""
													    """ as discriminators rather than generators](https://arxiv.org/abs/2003.10555) by Kevin Clark, Minh-Thang"""
													    """ Luong, Quoc V. Le, Christopher D. Manning."""
													)
													__lowerCAmelCase     =  (
													    """1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the"""
													    """ Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of"""
													    """ Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian"""
													    """ Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n"""
													)
													__lowerCAmelCase     =  (
													    """1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the"""
													    """ Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of"""
													    """ Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian"""
													    """ Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n1."""
													    """ **[DistilBERT](https://huggingface.co/transformers/model_doc/distilbert.html)** (来自 HuggingFace) 伴随论文"""
													    """ [DistilBERT, a distilled version of BERT: smaller, faster, cheaper and"""
													    """ lighter](https://arxiv.org/abs/1910.01108) 由 Victor Sanh, Lysandre Debut and Thomas Wolf 发布。 The same"""
													    """ method has been applied to compress GPT2 into"""
													    """ [DistilGPT2](https://github.com/huggingface/transformers/tree/main/examples/distillation), RoBERTa into"""
													    """ [DistilRoBERTa](https://github.com/huggingface/transformers/tree/main/examples/distillation),"""
													    """ Multilingual BERT into"""
													    """ [DistilmBERT](https://github.com/huggingface/transformers/tree/main/examples/distillation) and a German"""
													    """ version of DistilBERT.\n1. **[ELECTRA](https://huggingface.co/transformers/model_doc/electra.html)** (来自"""
													    """ Google Research/Stanford University) 伴随论文 [ELECTRA: Pre-training text encoders as discriminators rather"""
													    """ than generators](https://arxiv.org/abs/2003.10555) 由 Kevin Clark, Minh-Thang Luong, Quoc V. Le,"""
													    """ Christopher D. Manning 发布。\n"""
													)

													__lowerCAmelCase   ,     __lowerCAmelCase     =  check_copies.convert_to_localized_md(
													    snake_case_    ,				snake_case_    ,				localized_readme["""format_model_list"""]				)

													self.assertFalse(snake_case_				)
													self.assertEqual(snake_case_    ,				snake_case_				)

													__lowerCAmelCase   ,     __lowerCAmelCase     =  check_copies.convert_to_localized_md(
													    snake_case_    ,				snake_case_    ,				localized_readme["""format_model_list"""]				)

													# Check whether the number of models is equal to README.md after conversion.
													self.assertTrue(snake_case_				)

													__lowerCAmelCase     =  (
													    """1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (from Google Research and the"""
													    """ Toyota Technological Institute at Chicago) released with the paper [ALBERT: A Lite BERT for"""
													    """ Self-supervised Learning of Language Representations](https://arxiv.org/abs/1909.11942), by Zhenzhong"""
													    """ Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut."""
													)
													__lowerCAmelCase     =  (
													    """1. **[ALBERT](https://huggingface.co/transformers/main/model_doc/albert.html)** (来自 Google Research and"""
													    """ the Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of"""
													    """ Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian"""
													    """ Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n"""
													)
													__lowerCAmelCase     =  (
													    """1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the"""
													    """ Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of"""
													    """ Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian"""
													    """ Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n"""
													)

													__lowerCAmelCase   ,     __lowerCAmelCase     =  check_copies.convert_to_localized_md(
													    snake_case_    ,				snake_case_    ,				localized_readme["""format_model_list"""]				)

													# Check if the model link is synchronized.
													self.assertEqual(snake_case_    ,				snake_case_				)


"""simple docstring"""
import enum
import warnings

from ..tokenization_utils import TruncationStrategy
from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_tf_available():
			import tensorflow as tf

			from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING

if is_torch_available():
			from ..models.auto.modeling_auto import MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING

SCREAMING_SNAKE_CASE_					     =	logging.get_logger(__name__)
class       lowerCAmelCase_		(				enum.Enum ):



							'''simple docstring'''





							_snake_case						      =		0
							_snake_case						      =		1
@add_end_docstrings(A__ )
class       lowerCAmelCase_		(				A__ ):



							'''simple docstring'''





							_snake_case						      =		'''generated'''




							def __init__( self    ,				*snake_case_    ,				**snake_case_				)       ->  Optional[int]:
													super().__init__(*snake_case_    ,				**snake_case_				)

													self.check_model_type(
													    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
													    if self.framework == """tf"""
													    else MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING				)




							def    A__						( self    ,				snake_case_=None    ,				snake_case_=None    ,				snake_case_=None    ,				snake_case_=None    ,				snake_case_=None    ,				snake_case_=None    ,				**snake_case_    ,				)       ->  Union[str, Any]:
													__lowerCAmelCase     =  {}
													if truncation is not None:
																			__lowerCAmelCase     =  truncation

													__lowerCAmelCase     =  generate_kwargs

													__lowerCAmelCase     =  {}
													if return_tensors is not None and return_type is None:
																			__lowerCAmelCase     =  ReturnType.TENSORS if return_tensors else ReturnType.TEXT
													if return_type is not None:
																			__lowerCAmelCase     =  return_type

													if clean_up_tokenization_spaces is not None:
																			__lowerCAmelCase     =  clean_up_tokenization_spaces

													if stop_sequence is not None:
																			__lowerCAmelCase     =  self.tokenizer.encode(snake_case_    ,				add_special_tokens=snake_case_				)
																			if len(snake_case_				) > 1:
																									warnings.warn(
																									    """Stopping on a multiple token sequence is not yet supported on transformers. The first token of"""
																									    """ the stop sequence will be used as the stop sequence string in the interim."""				)
																			__lowerCAmelCase     =  stop_sequence_ids[0]

													return preprocess_params, forward_params, postprocess_params




							def    A__						( self    ,				snake_case_    ,				snake_case_    ,				snake_case_				)       ->  Any:
													return True




							def    A__						( self    ,				*snake_case_    ,				snake_case_				)       ->  Dict:
													__lowerCAmelCase     =  self.model.config.prefix if self.model.config.prefix is not None else """"""
													if isinstance(args[0]    ,				snake_case_				):
																			if self.tokenizer.pad_token_id is None:
																									raise ValueError("""Please make sure that the tokenizer has a pad_token_id when using a batch input"""				)
																			__lowerCAmelCase     =  ([prefix + arg for arg in args[0]],)
																			__lowerCAmelCase     =  True

													elif isinstance(args[0]    ,				snake_case_				):
																			__lowerCAmelCase     =  (prefix + args[0],)
																			__lowerCAmelCase     =  False
													else:
																			raise ValueError(
																			    f""" `args[0]`: {args[0]} have the wrong format. The should be either of type `str` or type `list`"""				)
													__lowerCAmelCase     =  self.tokenizer(*snake_case_    ,				padding=snake_case_    ,				truncation=snake_case_    ,				return_tensors=self.framework				)
													# This is produced by tokenizers but is an invalid generate kwargs
													if "token_type_ids" in inputs:
																			del inputs["token_type_ids"]
													return inputs




							def __call__( self    ,				*snake_case_    ,				**snake_case_				)       ->  Dict:
													__lowerCAmelCase     =  super().__call__(*snake_case_    ,				**snake_case_				)
													if (
													    isinstance(args[0]    ,				snake_case_				)
													    and all(isinstance(snake_case_    ,				snake_case_				) for el in args[0]				)
													    and all(len(snake_case_				) == 1 for res in result				)
													):
																			return [res[0] for res in result]
													return result




							def    A__						( self    ,				snake_case_    ,				snake_case_=TruncationStrategy.DO_NOT_TRUNCATE    ,				**snake_case_				)       ->  Tuple:
													__lowerCAmelCase     =  self._parse_and_tokenize(snake_case_    ,				truncation=snake_case_    ,				**snake_case_				)
													return inputs




							def    A__						( self    ,				snake_case_    ,				**snake_case_				)       ->  Union[str, Any]:
													if self.framework == "pt":
																			__lowerCAmelCase   ,     __lowerCAmelCase     =  model_inputs["""input_ids"""].shape
													elif self.framework == "tf":
																			__lowerCAmelCase   ,     __lowerCAmelCase     =  tf.shape(model_inputs["""input_ids"""]				).numpy()

													__lowerCAmelCase     =  generate_kwargs.get("""min_length"""    ,				self.model.config.min_length				)
													__lowerCAmelCase     =  generate_kwargs.get("""max_length"""    ,				self.model.config.max_length				)
													self.check_inputs(snake_case_    ,				generate_kwargs["""min_length"""]    ,				generate_kwargs["""max_length"""]				)
													__lowerCAmelCase     =  self.model.generate(**snake_case_    ,				**snake_case_				)
													__lowerCAmelCase     =  output_ids.shape[0]
													if self.framework == "pt":
																			__lowerCAmelCase     =  output_ids.reshape(snake_case_    ,				out_b // in_b    ,				*output_ids.shape[1:]				)
													elif self.framework == "tf":
																			__lowerCAmelCase     =  tf.reshape(snake_case_    ,				(in_b, out_b // in_b, *output_ids.shape[1:])				)
													return {"output_ids": output_ids}




							def    A__						( self    ,				snake_case_    ,				snake_case_=ReturnType.TEXT    ,				snake_case_=False				)       ->  Dict:
													__lowerCAmelCase     =  []
													for output_ids in model_outputs["output_ids"][0]:
																			if return_type == ReturnType.TENSORS:
																									__lowerCAmelCase     =  {f"""{self.return_name}_token_ids""": output_ids}
																			elif return_type == ReturnType.TEXT:
																									__lowerCAmelCase     =  {
																									    f"""{self.return_name}_text""": self.tokenizer.decode(
																									        snake_case_    ,				skip_special_tokens=snake_case_    ,				clean_up_tokenization_spaces=snake_case_    ,				)
																									}
																			records.append(snake_case_				)
													return records
@add_end_docstrings(A__ )
class       lowerCAmelCase_		(				A__ ):



							'''simple docstring'''





							_snake_case						      =		'''summary'''




							def __call__( self    ,				*snake_case_    ,				**snake_case_				)       ->  Tuple:
													return super().__call__(*snake_case_    ,				**snake_case_				)




							def    A__						( self    ,				snake_case_    ,				snake_case_    ,				snake_case_				)       ->  bool:
													if max_length < min_length:
																			logger.warning(f"""Your min_length={min_length} must be inferior than your max_length={max_length}."""				)

													if input_length < max_length:
																			logger.warning(
																			    f"""Your max_length is set to {max_length}, but your input_length is only {input_length}. Since this is """
																			    """a summarization task, where outputs shorter than the input are typically wanted, you might """
																			    f"""consider decreasing max_length manually, e.g. summarizer('...', max_length={input_length//2})"""				)
@add_end_docstrings(A__ )
class       lowerCAmelCase_		(				A__ ):



							'''simple docstring'''





							_snake_case						      =		'''translation'''




							def    A__						( self    ,				snake_case_    ,				snake_case_    ,				snake_case_				)       ->  Optional[int]:
													if input_length > 0.9 * max_length:
																			logger.warning(
																			    f"""Your input_length: {input_length} is bigger than 0.9 * max_length: {max_length}. You might consider """
																			    """increasing your max_length manually, e.g. translator('...', max_length=400)"""				)
													return True




							def    A__						( self    ,				*snake_case_    ,				snake_case_=TruncationStrategy.DO_NOT_TRUNCATE    ,				snake_case_=None    ,				snake_case_=None				)       ->  List[Any]:
													if getattr(self.tokenizer    ,				"""_build_translation_inputs"""    ,				snake_case_				):
																			return self.tokenizer._build_translation_inputs(
																			    *snake_case_    ,				return_tensors=self.framework    ,				truncation=snake_case_    ,				src_lang=snake_case_    ,				tgt_lang=snake_case_				)
													else:
																			return super()._parse_and_tokenize(*snake_case_    ,				truncation=snake_case_				)




							def    A__						( self    ,				snake_case_=None    ,				snake_case_=None    ,				**snake_case_				)       ->  List[Any]:
													__lowerCAmelCase   ,     __lowerCAmelCase   ,     __lowerCAmelCase     =  super()._sanitize_parameters(**snake_case_				)
													if src_lang is not None:
																			__lowerCAmelCase     =  src_lang
													if tgt_lang is not None:
																			__lowerCAmelCase     =  tgt_lang
													if src_lang is None and tgt_lang is None:
																			# Backward compatibility, direct arguments use is preferred.
																			__lowerCAmelCase     =  kwargs.get("""task"""    ,				self.task				)
																			__lowerCAmelCase     =  task.split("""_"""				)
																			if task and len(snake_case_				) == 4:
																									# translation, XX, to YY
																									__lowerCAmelCase     =  items[1]
																									__lowerCAmelCase     =  items[3]
													return preprocess_params, forward_params, postprocess_params




							def __call__( self    ,				*snake_case_    ,				**snake_case_				)       ->  List[Any]:
													return super().__call__(*snake_case_    ,				**snake_case_				)
