

"""simple docstring"""





import os
import sys
import unittest


_a       =							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,
)


_a       =							os.path.join('tests', 'models', 'bert', 'test_modeling_bert.py')
_a       =							os.path.join('tests', 'models', 'blip', 'test_modeling_blip.py')




class 					_lowerCAmelCase  (	unittest.TestCase   ):







 """simple docstring"""







 def 					_lowercase (			self							:			int	):
    __lowercase								=						get_test_to_tester_mapping(UpperCAmelCase__	)
    __lowercase								=						get_test_to_tester_mapping(UpperCAmelCase__	)

    __lowercase								=						{"BertModelTest": "BertModelTester"}

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

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


 def 					_lowercase (			self							:			List[str]	):
    __lowercase								=						get_model_to_test_mapping(UpperCAmelCase__	)
    __lowercase								=						get_model_to_test_mapping(UpperCAmelCase__	)

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

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

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



 def 					_lowercase (			self							:			List[Any]	):
    __lowercase								=						get_model_to_tester_mapping(UpperCAmelCase__	)
    __lowercase								=						get_model_to_tester_mapping(UpperCAmelCase__	)

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

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

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






"""simple docstring"""




from __future__ import annotations

from functools import lru_cache
from math import ceil

_A			:       Optional[Any]   		=       1_00

_A			:       Optional[int]   		=       set(range(3, NUM_PRIMES, 2))
primes.add(2)
_A			:       int

for prime in range(3, ceil(NUM_PRIMES**0.5), 2):
   if prime not in primes:
      continue
   primes.difference_update(set(range(prime * prime, NUM_PRIMES, prime)))


@lru_cache(maxsize=100  )
def   __magic_name__	(      __snake_case				:       int  ) ->				set[int]:
       if number_to_partition < 0:
              return set()
       elif number_to_partition == 0:
              return {1}

       lowercase    :				set[int]       		=							set()
       lowercase    :				int
       lowercase    :				int

       for prime in primes:
              if prime > number_to_partition:
                     continue
              for sub in partition(number_to_partition - prime  ):
                     ret.add(sub * prime  )

       return ret


def   __magic_name__	(      __snake_case				:       int = 5000  ) ->				int | None:
       for number_to_partition in range(1     , __snake_case  ):
              if len(partition(__snake_case  )  ) > number_unique_partitions:
                     return number_to_partition
       return None


if __name__ == "__main__":
   print(F"{solution() = }")


