





from __future__ import annotations

import unittest

import numpy as np

from transformers import BlipTextConfig
from transformers.testing_utils import require_tf, slow
from transformers.utils import is_tf_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask


if is_tf_available():
     import tensorflow as tf

     from transformers import TFBlipTextModel
     from transformers.models.blip.modeling_tf_blip import TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST



class    _SCREAMING_SNAKE_CASE						:







 '''simple docstring'''

 def __init__(self				:   List[str]       , UpperCAmelCase_				:   List[Any]       , UpperCAmelCase_				:   Optional[Any]=12       , UpperCAmelCase_				:   Any=7       , UpperCAmelCase_				:   Optional[Any]=True       , UpperCAmelCase_				:   Optional[int]=True       , UpperCAmelCase_				:   Any=True       , UpperCAmelCase_				:   Optional[Any]=99       , UpperCAmelCase_				:   str=32       , UpperCAmelCase_				:   Tuple=32       , UpperCAmelCase_				:   Any=2       , UpperCAmelCase_				:   Any=4       , UpperCAmelCase_				:   Optional[int]=37       , UpperCAmelCase_				:   List[str]=0.1       , UpperCAmelCase_				:   List[str]=0.1       , UpperCAmelCase_				:   List[Any]=512       , UpperCAmelCase_				:   List[Any]=0.02       , UpperCAmelCase_				:   Any=0       , UpperCAmelCase_				:   Optional[Any]=None       , )       ->int:



   '''simple docstring'''



   lowerCamelCase__:      Dict			  =parent
   lowerCamelCase__:      Union[str, Any]			  =batch_size
   lowerCamelCase__:      List[Any]			  =seq_length
   lowerCamelCase__:      Optional[int]			  =is_training
   lowerCamelCase__:      Union[str, Any]			  =use_input_mask
   lowerCamelCase__:      List[Any]			  =use_labels
   lowerCamelCase__:      str			  =vocab_size
   lowerCamelCase__:      Union[str, Any]			  =hidden_size
   lowerCamelCase__:      List[Any]			  =projection_dim
   lowerCamelCase__:      Optional[Any]			  =num_hidden_layers
   lowerCamelCase__:      int			  =num_attention_heads
   lowerCamelCase__:      Any			  =intermediate_size
   lowerCamelCase__:      Any			  =dropout
   lowerCamelCase__:      Any			  =attention_dropout
   lowerCamelCase__:      List[Any]			  =max_position_embeddings
   lowerCamelCase__:      Optional[int]			  =initializer_range
   lowerCamelCase__:      int			  =scope
   lowerCamelCase__:      Tuple			  =bos_token_id

 def 							SCREAMING_SNAKE_CASE_					(self				:   str)       ->Union[str, Any]:



   '''simple docstring'''



   lowerCamelCase__:      str			  =ids_tensor([self.batch_size, self.seq_length]       , self.vocab_size)

   lowerCamelCase__:      str			  =None
   if self.use_input_mask:
     lowerCamelCase__:      Tuple			  =random_attention_mask([self.batch_size, self.seq_length])

   if input_mask is not None:
     lowerCamelCase__:      Union[str, Any]			  =input_mask.numpy()
     lowerCamelCase__:      Optional[Any]			  =input_mask.shape
     lowerCamelCase__:      Optional[Any]			  =np.random.randint(1       , seq_length - 1       , size=(batch_size,))
     for batch_idx, start_index in enumerate(__UpperCAmelCase):
       lowerCamelCase__:      Dict			  =1
       lowerCamelCase__:      Any			  =0

   lowerCamelCase__:      Optional[Any]			  =self.get_config()

   return config, input_ids, tf.convert_to_tensor(__UpperCAmelCase)

 def 							SCREAMING_SNAKE_CASE_					(self				:   Union[str, Any])       ->Optional[int]:



   '''simple docstring'''



   return BlipTextConfig(
       vocab_size=self.vocab_size       , hidden_size=self.hidden_size       , projection_dim=self.projection_dim       , num_hidden_layers=self.num_hidden_layers       , num_attention_heads=self.num_attention_heads       , intermediate_size=self.intermediate_size       , dropout=self.dropout       , attention_dropout=self.attention_dropout       , max_position_embeddings=self.max_position_embeddings       , initializer_range=self.initializer_range       , bos_token_id=self.bos_token_id       , )

 def 							SCREAMING_SNAKE_CASE_					(self				:   Union[str, Any]       , UpperCAmelCase_				:   List[str]       , UpperCAmelCase_				:   str       , UpperCAmelCase_				:   Optional[Any])       ->Optional[Any]:



   '''simple docstring'''



   lowerCamelCase__:      Union[str, Any]			  =TFBlipTextModel(config=__UpperCAmelCase)
   lowerCamelCase__:      Union[str, Any]			  =model(__UpperCAmelCase       , attention_mask=__UpperCAmelCase       , training=__UpperCAmelCase)
   lowerCamelCase__:      Optional[int]			  =model(__UpperCAmelCase       , training=__UpperCAmelCase)
   self.parent.assertEqual(result.last_hidden_state.shape       , (self.batch_size, self.seq_length, self.hidden_size))
   self.parent.assertEqual(result.pooler_output.shape       , (self.batch_size, self.hidden_size))







 def 							SCREAMING_SNAKE_CASE_					(self				:   int)       ->Any:



   '''simple docstring'''



   lowerCamelCase__:      int			  =self.prepare_config_and_inputs()
   lowerCamelCase__:      Dict			  =config_and_inputs
   lowerCamelCase__:      Union[str, Any]			  ={'input_ids': input_ids, 'attention_mask': input_mask}
   return config, inputs_dict



@require_tf
class    _SCREAMING_SNAKE_CASE						(	__SCREAMING_SNAKE_CASE    ,							unittest.TestCase    ):







 '''simple docstring'''
 lowercase_		=			(TFBlipTextModel,) if is_tf_available() else ()
 lowercase_		=			False
 lowercase_		=			False
 lowercase_		=			False

 def 							SCREAMING_SNAKE_CASE_					(self				:   Union[str, Any])       ->List[str]:



   '''simple docstring'''



   lowerCamelCase__:      Dict			  =BlipTextModelTester(self)
   lowerCamelCase__:      Optional[Any]			  =ConfigTester(self       , config_class=__UpperCAmelCase       , hidden_size=37)

 def 							SCREAMING_SNAKE_CASE_					(self				:   List[str])       ->str:



   '''simple docstring'''



   self.config_tester.run_common_tests()

 def 							SCREAMING_SNAKE_CASE_					(self				:   List[str])       ->Any:



   '''simple docstring'''



   lowerCamelCase__:      List[str]			  =self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_model(*__UpperCAmelCase)

 def 							SCREAMING_SNAKE_CASE_					(self				:   Dict)       ->Optional[Any]:



   '''simple docstring'''



   pass

 def 							SCREAMING_SNAKE_CASE_					(self				:   Optional[Any])       ->Dict:



   '''simple docstring'''



   pass

 @unittest.skip(reason="Blip does not use inputs_embeds")
 def 							SCREAMING_SNAKE_CASE_					(self				:   Union[str, Any])       ->Tuple:



   '''simple docstring'''



   pass

 @unittest.skip(reason="BlipTextModel has no base class and is not available in MODEL_MAPPING")
 def 							SCREAMING_SNAKE_CASE_					(self				:   Union[str, Any])       ->List[str]:



   '''simple docstring'''



   pass

 @unittest.skip(reason="BlipTextModel has no base class and is not available in MODEL_MAPPING")
 def 							SCREAMING_SNAKE_CASE_					(self				:   Optional[Any])       ->Optional[int]:



   '''simple docstring'''



   pass

 @slow
 def 							SCREAMING_SNAKE_CASE_					(self				:   List[str])       ->List[str]:



   '''simple docstring'''



   for model_name in TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
     lowerCamelCase__:      List[Any]			  =TFBlipTextModel.from_pretrained(__UpperCAmelCase)
     self.assertIsNotNone(__UpperCAmelCase)







 def 							SCREAMING_SNAKE_CASE_					(self				:   Any       , UpperCAmelCase_				:   int=True)       ->Optional[Any]:



   '''simple docstring'''



   super().test_pt_tf_model_equivalence(allow_missing_keys=__UpperCAmelCase)








"""simple docstring"""





from collections import Counter
from pathlib import Path
from typing import Optional, Tuple

import yaml






class 					_lowerCAmelCase   (     yaml.SafeLoader       ):
       """simple docstring"""




       def      snake_case						(    self    , __UpperCAmelCase      ):



         '''simple docstring'''

         lowerCAmelCase__			:List[Any]											=							[self.constructed_objects[key_node] for key_node, _ in node.value]
         lowerCAmelCase__			:str											=							[tuple(__UpperCAmelCase      ) if isinstance(__UpperCAmelCase    , __UpperCAmelCase      ) else key for key in keys]
         lowerCAmelCase__			:Optional[int]											=							Counter(__UpperCAmelCase      )
         lowerCAmelCase__			:int											=							[key for key in counter if counter[key] > 1]
         if duplicate_keys:
           raise TypeError(F"Got duplicate yaml keys: {duplicate_keys}"      )






       def      snake_case						(    self    , __UpperCAmelCase    , __UpperCAmelCase=False      ):



         '''simple docstring'''

         lowerCAmelCase__			:Union[str, Any]											=							super().construct_mapping(__UpperCAmelCase    , deep=__UpperCAmelCase      )
         self._check_no_duplicates_on_constructed_node(__UpperCAmelCase      )
         return mapping






def  __A   (_SCREAMING_SNAKE_CASE			)					->Tuple[Optional[str], str]:





  """simple docstring"""


  lowerCAmelCase__			:Optional[Any]											=							list(readme_content.splitlines()			)
  if full_content and full_content[0] == "---" and "---" in full_content[1:]:
    lowerCAmelCase__			:Optional[int]											=							full_content[1:].index('---'			) + 1
    lowerCAmelCase__			:Union[str, Any]											=							'\n'.join(full_content[1:sep_idx]			)
    return yamlblock, "\n".join(full_content[sep_idx + 1 :]			)

  return None, "\n".join(_SCREAMING_SNAKE_CASE			)






class 					_lowerCAmelCase   (     a       ):
       """simple docstring"""




       __magic_name__     :List[str]		  =					{"""train_eval_index"""}  # train-eval-index in the YAML metadata






       @classmethod
       def      snake_case						(    cls    , __UpperCAmelCase      ):



         '''simple docstring'''

         with open(__UpperCAmelCase    , encoding='utf-8'      ) as readme_file:
           lowerCAmelCase__							,				lowerCAmelCase__			:Union[str, Any]											=							_split_yaml_from_readme(readme_file.read()      )
         if yaml_string is not None:
           return cls.from_yaml_string(__UpperCAmelCase      )
         else:
           return cls()






       def      snake_case						(    self    , __UpperCAmelCase      ):



         '''simple docstring'''

         if path.exists():
           with open(__UpperCAmelCase    , encoding='utf-8'      ) as readme_file:
             lowerCAmelCase__			:Optional[Any]											=							readme_file.read()
         else:
           lowerCAmelCase__			:Union[str, Any]											=							None
         lowerCAmelCase__			:Union[str, Any]											=							self._to_readme(__UpperCAmelCase      )
         with open(__UpperCAmelCase    , 'w'    , encoding='utf-8'      ) as readme_file:
           readme_file.write(__UpperCAmelCase      )






       def      snake_case						(    self    , __UpperCAmelCase = None      ):



         '''simple docstring'''

         if readme_content is not None:
           lowerCAmelCase__							,				lowerCAmelCase__			:Optional[int]											=							_split_yaml_from_readme(__UpperCAmelCase      )
           lowerCAmelCase__			:Optional[Any]											=							'---\n' + self.to_yaml_string() + '---\n' + content
         else:
           lowerCAmelCase__			:str											=							'---\n' + self.to_yaml_string() + '---\n'
         return full_content






       @classmethod
       def      snake_case						(    cls    , __UpperCAmelCase      ):



         '''simple docstring'''

         lowerCAmelCase__			:Dict											=							yaml.load(__UpperCAmelCase    , Loader=_NoDuplicateSafeLoader      ) or {}

         # Convert the YAML keys to DatasetMetadata fields
         lowerCAmelCase__			:int											=							{
             (key.replace('-'    , '_'      ) if key.replace('-'    , '_'      ) in cls._FIELDS_WITH_DASHES else key): value
             for key, value in metadata_dict.items()
         }
         return cls(**__UpperCAmelCase      )






       def      snake_case						(    self      ):



         '''simple docstring'''

         return yaml.safe_dump(
             {
                 (key.replace('_'    , '-'      ) if key in self._FIELDS_WITH_DASHES else key): value
                 for key, value in self.items()
             }    , sort_keys=__UpperCAmelCase    , allow_unicode=__UpperCAmelCase    , encoding='utf-8'    , ).decode('utf-8'      )






__A											=		{
    """image-classification""": [],
    """translation""": [],
    """image-segmentation""": [],
    """fill-mask""": [],
    """automatic-speech-recognition""": [],
    """token-classification""": [],
    """sentence-similarity""": [],
    """audio-classification""": [],
    """question-answering""": [],
    """summarization""": [],
    """zero-shot-classification""": [],
    """table-to-text""": [],
    """feature-extraction""": [],
    """other""": [],
    """multiple-choice""": [],
    """text-classification""": [],
    """text-to-image""": [],
    """text2text-generation""": [],
    """zero-shot-image-classification""": [],
    """tabular-classification""": [],
    """tabular-regression""": [],
    """image-to-image""": [],
    """tabular-to-text""": [],
    """unconditional-image-generation""": [],
    """text-retrieval""": [],
    """text-to-speech""": [],
    """object-detection""": [],
    """audio-to-audio""": [],
    """text-generation""": [],
    """conversational""": [],
    """table-question-answering""": [],
    """visual-question-answering""": [],
    """image-to-text""": [],
    """reinforcement-learning""": [],
    """voice-activity-detection""": [],
    """time-series-forecasting""": [],
    """document-question-answering""": [],
}


if __name__ == "__main__":
  from argparse import ArgumentParser

  __A											=		ArgumentParser(usage="""Validate the yaml metadata block of a README.md file.""")
  ap.add_argument("""readme_filepath""")
  __A											=		ap.parse_args()

  __A											=		Path(args.readme_filepath)
  __A											=		DatasetMetadata.from_readme(readme_filepath)
  print(dataset_metadata)
  dataset_metadata.to_readme(readme_filepath)
