code: from __future__ import annotations
  
  import unittest
  
  from transformers import OpenAIGPTConfig, 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, random_attention_mask
  from ...test_pipeline_mixin import PipelineTesterMixin
  
  
  if is_tf_available():
    import tensorflow as tf
  
    from transformers.models.openai.modeling_tf_openai import (
        TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFOpenAIGPTDoubleHeadsModel,
        TFOpenAIGPTForSequenceClassification,
        TFOpenAIGPTLMHeadModel,
        TFOpenAIGPTModel,
    )
  
  
  
  
  class 					UpperCamelCase	:
  
  
  
  
       def __init__( self :					Any      ,_lowerCAmelCase :					Optional[int]      ,):
  
  
         """simple docstring"""
  
  
  
  
         __snake_case		       =     parent
         __snake_case		       =     13
         __snake_case		       =     7
         __snake_case		       =     True
         __snake_case		       =     True
         __snake_case		       =     True
         __snake_case		       =     True
         __snake_case		       =     True
         __snake_case		       =     99
         __snake_case		       =     32
         __snake_case		       =     2
         __snake_case		       =     4
         __snake_case		       =     37
         __snake_case		       =     "gelu"
         __snake_case		       =     0.1
         __snake_case		       =     0.1
         __snake_case		       =     512
         __snake_case		       =     16
         __snake_case		       =     2
         __snake_case		       =     0.0_2
         __snake_case		       =     3
         __snake_case		       =     4
         __snake_case		       =     None
         __snake_case		       =     self.vocab_size - 1
  
  
  
  
       def 							UpperCamelCase_						( self :					Dict						):
  
  
         """simple docstring"""
  
  
  
  
         __snake_case		       =     ids_tensor([self.batch_size, self.seq_length]      ,self.vocab_size						)
  
         __snake_case		       =     None
         if self.use_input_mask:
           __snake_case		       =     random_attention_mask([self.batch_size, self.seq_length]						)
  
         __snake_case		       =     None
         if self.use_token_type_ids:
           __snake_case		       =     ids_tensor([self.batch_size, self.seq_length]      ,self.type_vocab_size						)
  
         __snake_case		       =     None
         if self.use_mc_token_ids:
           __snake_case		       =     ids_tensor([self.batch_size, self.num_choices]      ,self.seq_length						)
  
         __snake_case		       =     None
         __snake_case		       =     None
         __snake_case		       =     None
         if self.use_labels:
           __snake_case		       =     ids_tensor([self.batch_size]      ,self.type_sequence_label_size						)
           __snake_case		       =     ids_tensor([self.batch_size, self.seq_length]      ,self.num_labels						)
           __snake_case		       =     ids_tensor([self.batch_size]      ,self.num_choices						)
  
         __snake_case		       =     OpenAIGPTConfig(
             vocab_size=self.vocab_size      ,n_embd=self.hidden_size      ,n_layer=self.num_hidden_layers      ,n_head=self.num_attention_heads      ,n_positions=self.max_position_embeddings      ,pad_token_id=self.pad_token_id      ,)
  
         __snake_case		       =     ids_tensor([self.num_hidden_layers, self.num_attention_heads]      ,2						)
  
         return (
             config,
             input_ids,
             input_mask,
             head_mask,
             token_type_ids,
             mc_token_ids,
             sequence_labels,
             token_labels,
             choice_labels,
         )
  
  
  
  
       def 							UpperCamelCase_						( self :					int      ,_lowerCAmelCase :					Any      ,_lowerCAmelCase :					str      ,_lowerCAmelCase :					Dict      ,_lowerCAmelCase :					str      ,_lowerCAmelCase :					List[Any]      ,*_lowerCAmelCase :					Dict						):
  
  
         """simple docstring"""
  
  
  
  
         __snake_case		       =     TFOpenAIGPTModel(config=_lowerCAmelCase						)
         __snake_case		       =     {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
         __snake_case		       =     model(_lowerCAmelCase						)
  
         __snake_case		       =     [input_ids, input_mask]
         __snake_case		       =     model(_lowerCAmelCase						)
  
         __snake_case		       =     model(_lowerCAmelCase						)
  
         self.parent.assertEqual(result.last_hidden_state.shape      ,(self.batch_size, self.seq_length, self.hidden_size)						)
  
  
  
  
       def 							UpperCamelCase_						( self :					str      ,_lowerCAmelCase :					Tuple      ,_lowerCAmelCase :					Tuple      ,_lowerCAmelCase :					Dict      ,_lowerCAmelCase :					Union[str, Any]      ,_lowerCAmelCase :					str      ,*_lowerCAmelCase :					str						):
  
  
         """simple docstring"""
  
  
  
  
         __snake_case		       =     TFOpenAIGPTLMHeadModel(config=_lowerCAmelCase						)
         __snake_case		       =     {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
         __snake_case		       =     model(_lowerCAmelCase						)
         self.parent.assertEqual(result.logits.shape      ,(self.batch_size, self.seq_length, self.vocab_size)						)
  
  
  
  
       def 							UpperCamelCase_						( self :					Tuple      ,_lowerCAmelCase :					Dict      ,_lowerCAmelCase :					Union[str, Any]      ,_lowerCAmelCase :					int      ,_lowerCAmelCase :					List[Any]      ,_lowerCAmelCase :					Optional[Any]      ,_lowerCAmelCase :					Optional[Any]      ,*_lowerCAmelCase :					List[Any]						):
  
  
         """simple docstring"""
  
  
  
  
         __snake_case		       =     TFOpenAIGPTDoubleHeadsModel(config=_lowerCAmelCase						)
  
         __snake_case		       =     tf.tile(tf.expand_dims(_lowerCAmelCase      ,1						)      ,(1, self.num_choices, 1)						)
         __snake_case		       =     tf.tile(tf.expand_dims(_lowerCAmelCase      ,1						)      ,(1, self.num_choices, 1)						)
         __snake_case		       =     tf.tile(tf.expand_dims(_lowerCAmelCase      ,1						)      ,(1, self.num_choices, 1)						)
  
         __snake_case		       =     {
             "input_ids": multiple_choice_inputs_ids,
             "mc_token_ids": mc_token_ids,
             "attention_mask": multiple_choice_input_mask,
             "token_type_ids": multiple_choice_token_type_ids,
         }
         __snake_case		       =     model(_lowerCAmelCase						)
         self.parent.assertEqual(
             result.logits.shape      ,(self.batch_size, self.num_choices, self.seq_length, self.vocab_size)						)
         self.parent.assertEqual(result.mc_logits.shape      ,(self.batch_size, self.num_choices)						)
  
  
  
  
       def 							UpperCamelCase_						( self :					Tuple      ,_lowerCAmelCase :					int      ,_lowerCAmelCase :					Tuple      ,_lowerCAmelCase :					Tuple      ,_lowerCAmelCase :					Dict      ,_lowerCAmelCase :					List[Any]      ,*_lowerCAmelCase :					int						):
  
  
         """simple docstring"""
  
  
  
  
         __snake_case		       =     self.num_labels
         __snake_case		       =     ids_tensor([self.batch_size]      ,self.type_sequence_label_size						)
         __snake_case		       =     {
             "input_ids": input_ids,
             "attention_mask": input_mask,
             "token_type_ids": token_type_ids,
             "labels": sequence_labels,
         }
         __snake_case		       =     TFOpenAIGPTForSequenceClassification(_lowerCAmelCase						)
         __snake_case		       =     model(_lowerCAmelCase						)
         self.parent.assertEqual(result.logits.shape      ,(self.batch_size, self.num_labels)						)
  
  
  
  
  
  
  
       def 							UpperCamelCase_						( self :					int						):
  
  
         """simple docstring"""
  
  
  
  
         __snake_case		       =     self.prepare_config_and_inputs()
  
         (
             (
             __snake_case       
         )       ,       (
             __snake_case       
         )       ,       (
             __snake_case       
         )       ,       (
             __snake_case       
         )       ,       (
             __snake_case       
         )       ,       (
             __snake_case       
         )       ,       (
             __snake_case       
         )       ,       (
             __snake_case       
         )       ,       (
             __snake_case       
         )       ,              
         )		       =     config_and_inputs
  
         __snake_case		       =     {"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
         return config, inputs_dict
  
  
  
  
  @require_tf
  class 					UpperCamelCase	(     snake_case__			,      snake_case__			,      unittest.TestCase      ):
       __UpperCamelCase						=   (
           (TFOpenAIGPTModel, TFOpenAIGPTLMHeadModel, TFOpenAIGPTDoubleHeadsModel, TFOpenAIGPTForSequenceClassification)
           if is_tf_available()
           else ()
       )
       __UpperCamelCase						=   (
           (TFOpenAIGPTLMHeadModel,) if is_tf_available() else ()
       )  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
       __UpperCamelCase						=   (
           {
               """feature-extraction""": TFOpenAIGPTModel,
               """text-classification""": TFOpenAIGPTForSequenceClassification,
               """text-generation""": TFOpenAIGPTLMHeadModel,
               """zero-shot""": TFOpenAIGPTForSequenceClassification,
           }
           if is_tf_available()
           else {}
       )
       __UpperCamelCase						=   False
       __UpperCamelCase						=   False
  
  
  
  
       def 							UpperCamelCase_						( self :					List[Any]      ,_lowerCAmelCase :					List[Any]      ,_lowerCAmelCase :					Optional[int]      ,_lowerCAmelCase :					Any      ,_lowerCAmelCase :					Optional[int]      ,_lowerCAmelCase :					str						):
  
  
         """simple docstring"""
  
  
  
  
         if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
           # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
           # `OpenAIGPTConfig` was never used in pipeline tests, either because of a missing checkpoint or because a
           # tiny config could not be created.
           return True
  
         return False
  
  
  
  
       def 							UpperCamelCase_						( self :					Dict						):
  
  
         """simple docstring"""
  
  
  
  
         __snake_case		       =     TFOpenAIGPTModelTester(self						)
         __snake_case		       =     ConfigTester(self      ,config_class=_lowerCAmelCase      ,n_embd=37						)
  
  
  
  
       def 							UpperCamelCase_						( self :					List[Any]						):
  
  
         """simple docstring"""
  
  
  
  
         self.config_tester.run_common_tests()
  
  
  
  
       def 							UpperCamelCase_						( self :					List[Any]						):
  
  
         """simple docstring"""
  
  
  
  
         __snake_case		       =     self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_openai_gpt_model(*_lowerCAmelCase						)
  
  
  
  
       def 							UpperCamelCase_						( self :					Optional[Any]						):
  
  
         """simple docstring"""
  
  
  
  
         __snake_case		       =     self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_openai_gpt_lm_head(*_lowerCAmelCase						)
  
  
  
  
       def 							UpperCamelCase_						( self :					Union[str, Any]						):
  
  
         """simple docstring"""
  
  
  
  
         __snake_case		       =     self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_openai_gpt_double_head(*_lowerCAmelCase						)
  
  
  
  
       def 							UpperCamelCase_						( self :					Optional[Any]						):
  
  
         """simple docstring"""
  
  
  
  
         __snake_case		       =     self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*_lowerCAmelCase						)
  
  
  
  
  
  
  
       @slow
       def 							UpperCamelCase_						( self :					Optional[int]						):
  
  
         """simple docstring"""
  
  
  
  
         for model_name in TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           __snake_case		       =     TFOpenAIGPTModel.from_pretrained(_lowerCAmelCase						)
           self.assertIsNotNone(_lowerCAmelCase						)
  
  
  
  
  @require_tf
  class 					UpperCamelCase	(     unittest.TestCase      ):
  
  
  
  
       @slow
       def 							UpperCamelCase_						( self :					Optional[Any]						):
  
  
         """simple docstring"""
  
  
  
  
         __snake_case		       =     TFOpenAIGPTLMHeadModel.from_pretrained("openai-gpt"						)
         __snake_case		       =     tf.convert_to_tensor([[481, 4_735, 544]]      ,dtype=tf.intaa						)  # the president is
         __snake_case		       =     [
             481,
             4_735,
             544,
             246,
             963,
             870,
             762,
             239,
             244,
             40_477,
             244,
             249,
             719,
             881,
             487,
             544,
             240,
             244,
             603,
             481,
         ]  # the president is a very good man. " \n " i\'m sure he is, " said the
  
         __snake_case		       =     model.generate(_lowerCAmelCase      ,do_sample=_lowerCAmelCase						)
         self.assertListEqual(output_ids[0].numpy().tolist()      ,_lowerCAmelCase						)
  
  
  
  
  
  
style_context: import posixpath
  from pathlib import Path
  from unittest.mock import patch
  
  import pytest
  from fsspec.implementations.local import AbstractFileSystem, LocalFileSystem, stringify_path
  from fsspec.registry import _registry as _fsspec_registry
  
  
  
  
  class 					UpperCamelCase	(     snake_case__      ):
  					__UpperCamelCase						=   """mock"""
  
  
  
  
  					def __init__( self :					List[Any]      ,*_lowerCAmelCase :					Optional[int]      ,_lowerCAmelCase :					Union[str, Any]      ,**_lowerCAmelCase :					Union[str, Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							super().__init__()
  							__snake_case		       =     LocalFileSystem(*_lowerCAmelCase      ,**_lowerCAmelCase						)
  							__snake_case		       =     Path(_lowerCAmelCase						).resolve().as_posix() + "/"
  
  
  
  
  					def 							UpperCamelCase_						( self :					List[Any]      ,_lowerCAmelCase :					Optional[Any]      ,*_lowerCAmelCase :					Union[str, Any]      ,**_lowerCAmelCase :					Dict						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     posixpath.join(self.local_root_dir      ,self._strip_protocol(_lowerCAmelCase						)						)
  							return self._fs.mkdir(_lowerCAmelCase      ,*_lowerCAmelCase      ,**_lowerCAmelCase						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					int      ,_lowerCAmelCase :					Tuple      ,*_lowerCAmelCase :					Optional[Any]      ,**_lowerCAmelCase :					Optional[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     posixpath.join(self.local_root_dir      ,self._strip_protocol(_lowerCAmelCase						)						)
  							return self._fs.makedirs(_lowerCAmelCase      ,*_lowerCAmelCase      ,**_lowerCAmelCase						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					Tuple      ,_lowerCAmelCase :					Any						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     posixpath.join(self.local_root_dir      ,self._strip_protocol(_lowerCAmelCase						)						)
  							return self._fs.rmdir(_lowerCAmelCase						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					List[Any]      ,_lowerCAmelCase :					List[Any]      ,_lowerCAmelCase :					str=True      ,*_lowerCAmelCase :					int      ,**_lowerCAmelCase :					List[str]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     posixpath.join(self.local_root_dir      ,self._strip_protocol(_lowerCAmelCase						)						)
  							__snake_case		       =     self._fs.ls(_lowerCAmelCase      ,detail=_lowerCAmelCase      ,*_lowerCAmelCase      ,**_lowerCAmelCase						)
  							if detail:
  									return [{**info, "name": info["name"][len(self.local_root_dir						) :]} for info in out]
  							else:
  									return [name[len(self.local_root_dir						) :] for name in out]
  
  
  
  
  					def 							UpperCamelCase_						( self :					List[str]      ,_lowerCAmelCase :					Any      ,*_lowerCAmelCase :					Any      ,**_lowerCAmelCase :					str						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     posixpath.join(self.local_root_dir      ,self._strip_protocol(_lowerCAmelCase						)						)
  							__snake_case		       =     dict(self._fs.info(_lowerCAmelCase      ,*_lowerCAmelCase      ,**_lowerCAmelCase						)						)
  							__snake_case		       =     out["name"][len(self.local_root_dir						) :]
  							return out
  
  
  
  
  					def 							UpperCamelCase_						( self :					Tuple      ,_lowerCAmelCase :					Optional[int]      ,_lowerCAmelCase :					Optional[Any]      ,*_lowerCAmelCase :					int      ,**_lowerCAmelCase :					Optional[int]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     posixpath.join(self.local_root_dir      ,self._strip_protocol(_lowerCAmelCase						)						)
  							__snake_case		       =     posixpath.join(self.local_root_dir      ,self._strip_protocol(_lowerCAmelCase						)						)
  							return self._fs.cp_file(_lowerCAmelCase      ,_lowerCAmelCase      ,*_lowerCAmelCase      ,**_lowerCAmelCase						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					Union[str, Any]      ,_lowerCAmelCase :					int      ,*_lowerCAmelCase :					List[Any]      ,**_lowerCAmelCase :					int						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     posixpath.join(self.local_root_dir      ,self._strip_protocol(_lowerCAmelCase						)						)
  							return self._fs.rm_file(_lowerCAmelCase      ,*_lowerCAmelCase      ,**_lowerCAmelCase						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					Optional[Any]      ,_lowerCAmelCase :					str      ,*_lowerCAmelCase :					Optional[int]      ,**_lowerCAmelCase :					int						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     posixpath.join(self.local_root_dir      ,self._strip_protocol(_lowerCAmelCase						)						)
  							return self._fs.rm(_lowerCAmelCase      ,*_lowerCAmelCase      ,**_lowerCAmelCase						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					int      ,_lowerCAmelCase :					Optional[int]      ,*_lowerCAmelCase :					str      ,**_lowerCAmelCase :					Optional[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     posixpath.join(self.local_root_dir      ,self._strip_protocol(_lowerCAmelCase						)						)
  							return self._fs._open(_lowerCAmelCase      ,*_lowerCAmelCase      ,**_lowerCAmelCase						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					Union[str, Any]      ,_lowerCAmelCase :					Tuple						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     posixpath.join(self.local_root_dir      ,self._strip_protocol(_lowerCAmelCase						)						)
  							return self._fs.created(_lowerCAmelCase						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					Union[str, Any]      ,_lowerCAmelCase :					int						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     posixpath.join(self.local_root_dir      ,self._strip_protocol(_lowerCAmelCase						)						)
  							return self._fs.modified(_lowerCAmelCase						)
  
  
  
  
  
  
  
  					@classmethod
  					def 							UpperCamelCase_						( cls :					Dict      ,_lowerCAmelCase :					Dict						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     stringify_path(_lowerCAmelCase						)
  							if path.startswith("mock://"						):
  									__snake_case		       =     path[7:]
  							return path
  
  
  
  
  class 					UpperCamelCase	(     snake_case__      ):
  					__UpperCamelCase						=   """tmp"""
  					__UpperCamelCase						=   None
  
  
  
  
  					def __init__( self :					int      ,*_lowerCAmelCase :					Tuple      ,**_lowerCAmelCase :					Union[str, Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							assert self.tmp_dir is not None, "TmpDirFileSystem.tmp_dir is not set"
  							super().__init__(*_lowerCAmelCase      ,**_lowerCAmelCase      ,local_root_dir=self.tmp_dir      ,auto_mkdir=_lowerCAmelCase						)
  
  
  
  
  
  
  
  					@classmethod
  					def 							UpperCamelCase_						( cls :					int      ,_lowerCAmelCase :					str						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     stringify_path(_lowerCAmelCase						)
  							if path.startswith("tmp://"						):
  									__snake_case		       =     path[6:]
  							return path
  
  
  
  
  @pytest.fixture
  def 							_lowerCamelCase(				)  ->   str:
  		__snake_case		       =     MockFileSystem
  		__snake_case		       =     TmpDirFileSystem
  		yield
  		del _fsspec_registry["mock"]
  		del _fsspec_registry["tmp"]
  
  
  
  @pytest.fixture
  def 							_lowerCamelCase(				__snake_case						,						__snake_case	)  ->   Dict:
  		__snake_case		       =     tmp_path_factory.mktemp("mockfs"	)
  		return MockFileSystem(local_root_dir=__snake_case						,						auto_mkdir=__snake_case	)
  
  
  
  
  
  @pytest.fixture
  def 							_lowerCamelCase(				__snake_case						,						__snake_case	)  ->   List[Any]:
  		__snake_case		       =     tmp_path_factory.mktemp("tmpfs"	)
  		with patch.object(__snake_case						,						"tmp_dir"						,						__snake_case	):
  				yield TmpDirFileSystem()
  
  
  
  
  
  