





import os
import sys
import unittest


__lowerCamelCase	:					Tuple			  =					os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
sys.path.append(os.path.join(git_repo_path, """utils"""))

import get_test_info  # noqa: E402
from get_test_info import (  # noqa: E402
    get_model_to_test_mapping,
    get_model_to_tester_mapping,
    get_test_to_tester_mapping,
)


__lowerCamelCase	:					Dict			  =					os.path.join("""tests""", """models""", """bert""", """test_modeling_bert.py""")
__lowerCamelCase	:					Tuple			  =					os.path.join("""tests""", """models""", """blip""", """test_modeling_blip.py""")



class  A__       (	unittest.TestCase      ):





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : Optional[int]	     =       get_test_to_tester_mapping(A_       )
       UpperCamelCase     : Dict	     =       get_test_to_tester_mapping(A_       )

       UpperCamelCase     : int	     =       {"BertModelTest": "BertModelTester"}

       UpperCamelCase     : Union[str, Any]	     =       {
           "BlipModelTest": "BlipModelTester",
           "BlipTextImageModelTest": "BlipTextImageModelsModelTester",
           "BlipTextModelTest": "BlipTextModelTester",
           "BlipTextRetrievalModelTest": "BlipTextRetrievalModelTester",
           "BlipVQAModelTest": "BlipVQAModelTester",
           "BlipVisionModelTest": "BlipVisionModelTester",
       }

       self.assertEqual(get_test_info.to_json(A_       )	,							A_       )
       self.assertEqual(get_test_info.to_json(A_       )	,							A_       )





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : Tuple	     =       get_model_to_test_mapping(A_       )
       UpperCamelCase     : Tuple	     =       get_model_to_test_mapping(A_       )

       UpperCamelCase     : int	     =       {
           "BertForMaskedLM": ["BertModelTest"],
           "BertForMultipleChoice": ["BertModelTest"],
           "BertForNextSentencePrediction": ["BertModelTest"],
           "BertForPreTraining": ["BertModelTest"],
           "BertForQuestionAnswering": ["BertModelTest"],
           "BertForSequenceClassification": ["BertModelTest"],
           "BertForTokenClassification": ["BertModelTest"],
           "BertLMHeadModel": ["BertModelTest"],
           "BertModel": ["BertModelTest"],
       }

       UpperCamelCase     : List[Any]	     =       {
           "BlipForConditionalGeneration": ["BlipTextImageModelTest"],
           "BlipForImageTextRetrieval": ["BlipTextRetrievalModelTest"],
           "BlipForQuestionAnswering": ["BlipVQAModelTest"],
           "BlipModel": ["BlipModelTest"],
           "BlipTextModel": ["BlipTextModelTest"],
           "BlipVisionModel": ["BlipVisionModelTest"],
       }

       self.assertEqual(get_test_info.to_json(A_       )	,							A_       )
       self.assertEqual(get_test_info.to_json(A_       )	,							A_       )





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : List[str]	     =       get_model_to_tester_mapping(A_       )
       UpperCamelCase     : Union[str, Any]	     =       get_model_to_tester_mapping(A_       )

       UpperCamelCase     : Any	     =       {
           "BertForMaskedLM": ["BertModelTester"],
           "BertForMultipleChoice": ["BertModelTester"],
           "BertForNextSentencePrediction": ["BertModelTester"],
           "BertForPreTraining": ["BertModelTester"],
           "BertForQuestionAnswering": ["BertModelTester"],
           "BertForSequenceClassification": ["BertModelTester"],
           "BertForTokenClassification": ["BertModelTester"],
           "BertLMHeadModel": ["BertModelTester"],
           "BertModel": ["BertModelTester"],
       }

       UpperCamelCase     : str	     =       {
           "BlipForConditionalGeneration": ["BlipTextImageModelsModelTester"],
           "BlipForImageTextRetrieval": ["BlipTextRetrievalModelTester"],
           "BlipForQuestionAnswering": ["BlipVQAModelTester"],
           "BlipModel": ["BlipModelTester"],
           "BlipTextModel": ["BlipTextModelTester"],
           "BlipVisionModel": ["BlipVisionModelTester"],
       }

       self.assertEqual(get_test_info.to_json(A_       )	,							A_       )
       self.assertEqual(get_test_info.to_json(A_       )	,							A_       )







__lowerCamelCase	:					Tuple			  =					"""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"""



def 		A_    (					_lowerCAmelCase					)						->			bytes:
 # Make sure the supplied data is a bytes-like object
 if not isinstance(_lowerCAmelCase							,       _lowerCAmelCase					):
  UpperCamelCase     : str	     =       F"""a bytes-like object is required, not '{data.__class__.__name__}'"""
  raise TypeError(_lowerCAmelCase					)

 UpperCamelCase     : Optional[int]	     =       "".join(bin(_lowerCAmelCase					)[2:].zfill(8					) for byte in data					)

 UpperCamelCase     : str	     =       len(_lowerCAmelCase					) % 6 != 0

 if padding_needed:
  # The padding that will be added later
  UpperCamelCase     : Optional[Any]	     =       b"=" * ((6 - len(_lowerCAmelCase					) % 6) // 2)

  # Append binary_stream with arbitrary binary digits (0's by default) to make its
  # length a multiple of 6.
  binary_stream += "0" * (6 - len(_lowerCAmelCase					) % 6)
 else:
  UpperCamelCase     : List[Any]	     =       b""

 # Encode every 6 binary digits to their corresponding Base64 character
 return (
     "".join(
         B64_CHARSET[int(binary_stream[index : index + 6]							,       2					)]
         for index in range(0							,       len(_lowerCAmelCase					)							,       6					)					).encode()
     + padding
 )



def 		A_    (					_lowerCAmelCase					)						->			bytes:
 # Make sure encoded_data is either a string or a bytes-like object
 if not isinstance(_lowerCAmelCase							,       _lowerCAmelCase					) and not isinstance(_lowerCAmelCase							,       _lowerCAmelCase					):
  UpperCamelCase     : List[Any]	     =       (
      "argument should be a bytes-like object or ASCII string, "
      F"""not '{encoded_data.__class__.__name__}'"""
  )
  raise TypeError(_lowerCAmelCase					)

 # In case encoded_data is a bytes-like object, make sure it contains only
 # ASCII characters so we convert it to a string object
 if isinstance(_lowerCAmelCase							,       _lowerCAmelCase					):
  try:
   UpperCamelCase     : Any	     =       encoded_data.decode("utf-8"					)
  except UnicodeDecodeError:
   raise ValueError("base64 encoded data should only contain ASCII characters"					)

 UpperCamelCase     : Union[str, Any]	     =       encoded_data.count("="					)

 # Check if the encoded string contains non base64 characters
 if padding:
  assert all(
      char in B64_CHARSET for char in encoded_data[:-padding]					), "Invalid base64 character(s) found."
 else:
  assert all(
      char in B64_CHARSET for char in encoded_data					), "Invalid base64 character(s) found."

 # Check the padding
 assert len(_lowerCAmelCase					) % 4 == 0 and padding < 3, "Incorrect padding"

 if padding:
  # Remove padding if there is one
  UpperCamelCase     : List[str]	     =       encoded_data[:-padding]

  UpperCamelCase     : List[Any]	     =       "".join(
      bin(B64_CHARSET.index(_lowerCAmelCase					)					)[2:].zfill(6					) for char in encoded_data					)[: -padding * 2]
 else:
  UpperCamelCase     : List[Any]	     =       "".join(
      bin(B64_CHARSET.index(_lowerCAmelCase					)					)[2:].zfill(6					) for char in encoded_data					)

 UpperCamelCase     : Any	     =       [
     int(binary_stream[index : index + 8]							,       2					)
     for index in range(0							,       len(_lowerCAmelCase					)							,       8					)
 ]

 return bytes(_lowerCAmelCase					)


if __name__ == "__main__":
    import doctest

    doctest.testmod()
