
import os
import sys
import unittest


lowercase  :					Optional[Any]						    =							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,
)


lowercase  :					Optional[int]						    =							os.path.join("""tests""", """models""", """bert""", """test_modeling_bert.py""")
lowercase  :					List[str]						    =							os.path.join("""tests""", """models""", """blip""", """test_modeling_blip.py""")

class __snake_case		(      unittest.TestCase     ):
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     List[str]       	=      get_test_to_tester_mapping(snake_case      )
           lowercase							:     Dict       	=      get_test_to_tester_mapping(snake_case      )

           lowercase							:     str       	=      {"""BertModelTest""": """BertModelTester"""}

           lowercase							:     Dict       	=      {
               """BlipModelTest""": """BlipModelTester""",
               """BlipTextImageModelTest""": """BlipTextImageModelsModelTester""",
               """BlipTextModelTest""": """BlipTextModelTester""",
               """BlipTextRetrievalModelTest""": """BlipTextRetrievalModelTester""",
               """BlipVQAModelTest""": """BlipVQAModelTester""",
               """BlipVisionModelTest""": """BlipVisionModelTester""",
           }

           self.assertEqual(get_test_info.to_json(snake_case      )		,snake_case      )
           self.assertEqual(get_test_info.to_json(snake_case      )		,snake_case      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     Tuple       	=      get_model_to_test_mapping(snake_case      )
           lowercase							:     str       	=      get_model_to_test_mapping(snake_case      )

           lowercase							:     List[Any]       	=      {
               """BertForMaskedLM""": ["""BertModelTest"""],
               """BertForMultipleChoice""": ["""BertModelTest"""],
               """BertForNextSentencePrediction""": ["""BertModelTest"""],
               """BertForPreTraining""": ["""BertModelTest"""],
               """BertForQuestionAnswering""": ["""BertModelTest"""],
               """BertForSequenceClassification""": ["""BertModelTest"""],
               """BertForTokenClassification""": ["""BertModelTest"""],
               """BertLMHeadModel""": ["""BertModelTest"""],
               """BertModel""": ["""BertModelTest"""],
           }

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

           self.assertEqual(get_test_info.to_json(snake_case      )		,snake_case      )
           self.assertEqual(get_test_info.to_json(snake_case      )		,snake_case      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     List[Any]       	=      get_model_to_tester_mapping(snake_case      )
           lowercase							:     Any       	=      get_model_to_tester_mapping(snake_case      )

           lowercase							:     List[str]       	=      {
               """BertForMaskedLM""": ["""BertModelTester"""],
               """BertForMultipleChoice""": ["""BertModelTester"""],
               """BertForNextSentencePrediction""": ["""BertModelTester"""],
               """BertForPreTraining""": ["""BertModelTester"""],
               """BertForQuestionAnswering""": ["""BertModelTester"""],
               """BertForSequenceClassification""": ["""BertModelTester"""],
               """BertForTokenClassification""": ["""BertModelTester"""],
               """BertLMHeadModel""": ["""BertModelTester"""],
               """BertModel""": ["""BertModelTester"""],
           }

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

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

'''simple docstring'''




_lowercase						: str						=						tuple[float, float, float]
_lowercase						: List[Any]						=						tuple[float, float, float]




def 							lowerCamelCase	(      UpperCAmelCase__       :					Pointad      ,      UpperCAmelCase__       :					Pointad )			->      Vectorad:
							lowercase_					:			List[str]										=       end_pointa[0] - end_pointa[0]
							lowercase_					:			Union[str, Any]										=       end_pointa[1] - end_pointa[1]
							lowercase_					:			List[Any]										=       end_pointa[2] - end_pointa[2]
							return (x, y, z)




def 							lowerCamelCase	(      UpperCAmelCase__       :					Vectorad      ,      UpperCAmelCase__       :					Vectorad )			->      Vectorad:
							lowercase_					:			List[Any]										=       ab[1] * ac[2] - ab[2] * ac[1]  # *i
							lowercase_					:			Union[str, Any]										=       (ab[0] * ac[2] - ab[2] * ac[0]) * -1  # *j
							lowercase_					:			List[str]										=       ab[0] * ac[1] - ab[1] * ac[0]  # *k
							return (x, y, z)




def 							lowerCamelCase	(      UpperCAmelCase__       :					Vectorad      ,      UpperCAmelCase__       :					int )			->      bool:
							return tuple(round(UpperCAmelCase__      ,      UpperCAmelCase__ ) for x in vector ) == (0, 0, 0)




def 							lowerCamelCase	(      UpperCAmelCase__       :					Pointad      ,      UpperCAmelCase__       :					Pointad      ,      UpperCAmelCase__       :					Pointad      ,      UpperCAmelCase__       :					int = 10 )			->      bool:
							lowercase_					:			Dict										=       create_vector(UpperCAmelCase__      ,      UpperCAmelCase__ )
							lowercase_					:			Optional[int]										=       create_vector(UpperCAmelCase__      ,      UpperCAmelCase__ )
							return is_zero_vector(get_ad_vectors_cross(UpperCAmelCase__      ,      UpperCAmelCase__ )      ,      UpperCAmelCase__ )





