
import inspect
import unittest

from transformers import BitConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch
  from torch import nn

  from transformers import BitBackbone, BitForImageClassification, BitImageProcessor, BitModel
  from transformers.models.bit.modeling_bit import BIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

class __snake_case		:
    def __init__(  self		,snake_case		,snake_case=3		,snake_case=32		,snake_case=3		,snake_case=10		,snake_case=[8, 16, 32, 64]		,snake_case=[1, 1, 2, 1]		,snake_case=True		,snake_case=True		,snake_case="relu"		,snake_case=3		,snake_case=None		,snake_case=["stage2", "stage3", "stage4"]		,snake_case=[2, 3, 4]		,snake_case=1		,):



           '''simple docstring'''







           lowercase							:     Union[str, Any]       	=      parent
           lowercase							:     List[Any]       	=      batch_size
           lowercase							:     Optional[Any]       	=      image_size
           lowercase							:     str       	=      num_channels
           lowercase							:     Union[str, Any]       	=      embeddings_size
           lowercase							:     Any       	=      hidden_sizes
           lowercase							:     Union[str, Any]       	=      depths
           lowercase							:     int       	=      is_training
           lowercase							:     List[Any]       	=      use_labels
           lowercase							:     List[str]       	=      hidden_act
           lowercase							:     Tuple       	=      num_labels
           lowercase							:     Optional[Any]       	=      scope
           lowercase							:     str       	=      len(snake_case      )
           lowercase							:     int       	=      out_features
           lowercase							:     Any       	=      out_indices
           lowercase							:     Any       	=      num_groups
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     Any       	=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

           lowercase							:     int       	=      None
           if self.use_labels:
                  lowercase							:     Dict       	=      ids_tensor([self.batch_size]		,self.num_labels      )

           lowercase							:     Tuple       	=      self.get_config()

           return config, pixel_values, labels
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           return BitConfig(
               num_channels=self.num_channels		,embeddings_size=self.embeddings_size		,hidden_sizes=self.hidden_sizes		,depths=self.depths		,hidden_act=self.hidden_act		,num_labels=self.num_labels		,out_features=self.out_features		,out_indices=self.out_indices		,num_groups=self.num_groups		,)
    def       _SCREAMING_SNAKE_CASE       (  self		,snake_case		,snake_case		,snake_case      ):



           '''simple docstring'''







           lowercase							:     Tuple       	=      BitModel(config=snake_case      )
           model.to(snake_case      )
           model.eval()
           lowercase							:     List[Any]       	=      model(snake_case      )
           self.parent.assertEqual(
               result.last_hidden_state.shape		,(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)		,)
    def       _SCREAMING_SNAKE_CASE       (  self		,snake_case		,snake_case		,snake_case      ):



           '''simple docstring'''







           lowercase							:     Optional[Any]       	=      self.num_labels
           lowercase							:     List[str]       	=      BitForImageClassification(snake_case      )
           model.to(snake_case      )
           model.eval()
           lowercase							:     List[str]       	=      model(snake_case		,labels=snake_case      )
           self.parent.assertEqual(result.logits.shape		,(self.batch_size, self.num_labels)      )
    def       _SCREAMING_SNAKE_CASE       (  self		,snake_case		,snake_case		,snake_case      ):



           '''simple docstring'''







           lowercase							:     Dict       	=      BitBackbone(config=snake_case      )
           model.to(snake_case      )
           model.eval()
           lowercase							:     List[str]       	=      model(snake_case      )

           # verify feature maps
           self.parent.assertEqual(len(result.feature_maps      )		,len(config.out_features      )      )
           self.parent.assertListEqual(list(result.feature_maps[0].shape      )		,[self.batch_size, self.hidden_sizes[1], 4, 4]      )

           # verify channels
           self.parent.assertEqual(len(model.channels      )		,len(config.out_features      )      )
           self.parent.assertListEqual(model.channels		,config.hidden_sizes[1:]      )

           # verify backbone works with out_features=None
           lowercase							:     Optional[Any]       	=      None
           lowercase							:     List[str]       	=      BitBackbone(config=snake_case      )
           model.to(snake_case      )
           model.eval()
           lowercase							:     Any       	=      model(snake_case      )

           # verify feature maps
           self.parent.assertEqual(len(result.feature_maps      )		,1      )
           self.parent.assertListEqual(list(result.feature_maps[0].shape      )		,[self.batch_size, self.hidden_sizes[-1], 1, 1]      )

           # verify channels
           self.parent.assertEqual(len(model.channels      )		,1      )
           self.parent.assertListEqual(model.channels		,[config.hidden_sizes[-1]]      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     Dict       	=      self.prepare_config_and_inputs()
           lowercase	,			lowercase	,			lowercase							:     str       	=      config_and_inputs
           lowercase							:     Tuple       	=      {"""pixel_values""": pixel_values}
           return config, inputs_dict






@require_torch
class __snake_case		(      lowerCAmelCase					,	lowerCAmelCase					,	unittest.TestCase     ):
    _a		:						Optional[int]=				(BitModel, BitForImageClassification, BitBackbone) if is_torch_available() else ()
    _a		:						Any=				(
        {"feature-extraction": BitModel, "image-classification": BitForImageClassification}
        if is_torch_available()
        else {}
    )

    _a		:						List[Any]=				False
    _a		:						List[Any]=				False
    _a		:						Optional[int]=				False
    _a		:						Tuple=				False
    _a		:						Optional[Any]=				False
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     Tuple       	=      BitModelTester(self      )
           lowercase							:     Tuple       	=      ConfigTester(self		,config_class=snake_case		,has_text_modality=snake_case      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           self.create_and_test_config_common_properties()
           self.config_tester.create_and_test_config_to_json_string()
           self.config_tester.create_and_test_config_to_json_file()
           self.config_tester.create_and_test_config_from_and_save_pretrained()
           self.config_tester.create_and_test_config_with_num_labels()
           self.config_tester.check_config_can_be_init_without_params()
           self.config_tester.check_config_arguments_init()
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           return
    @unittest.skip(reason="""Bit does not output attentions"""      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           pass
    @unittest.skip(reason="""Bit does not use inputs_embeds"""      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           pass
    @unittest.skip(reason="""Bit does not support input and output embeddings"""      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           pass
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase	,			lowercase							:     Tuple       	=      self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
                  lowercase							:     List[str]       	=      model_class(snake_case      )
                  lowercase							:     Any       	=      inspect.signature(model.forward      )
                  # signature.parameters is an OrderedDict => so arg_names order is deterministic
                  lowercase							:     int       	=      [*signature.parameters.keys()]

                  lowercase							:     List[Any]       	=      ["""pixel_values"""]
                  self.assertListEqual(arg_names[:1]		,snake_case      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     Optional[Any]       	=      self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*snake_case      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     Union[str, Any]       	=      self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_backbone(*snake_case      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase	,			lowercase							:     Any       	=      self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
                  lowercase							:     int       	=      model_class(config=snake_case      )
                  for name, module in model.named_modules():
                         if isinstance(snake_case		,(nn.BatchNormad, nn.GroupNorm)      ):
                                self.assertTrue(
                                    torch.all(module.weight == 1      )		,msg=f"Parameter {name} of model {model_class} seems not properly initialized"		,)
                                self.assertTrue(
                                    torch.all(module.bias == 0      )		,msg=f"Parameter {name} of model {model_class} seems not properly initialized"		,)
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           def check_hidden_states_output(snake_case		,snake_case		,snake_case      ):
                  lowercase							:     Any       	=      model_class(snake_case      )
                  model.to(snake_case      )
                  model.eval()

                  with torch.no_grad():
                         lowercase							:     str       	=      model(**self._prepare_for_class(snake_case		,snake_case      )      )

                  lowercase							:     Optional[int]       	=      outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

                  lowercase							:     Optional[int]       	=      self.model_tester.num_stages
                  self.assertEqual(len(snake_case      )		,expected_num_stages + 1      )

                  # Bit's feature maps are of shape (batch_size, num_channels, height, width)
                  self.assertListEqual(
                      list(hidden_states[0].shape[-2:]      )		,[self.model_tester.image_size // 4, self.model_tester.image_size // 4]		,)

           lowercase	,			lowercase							:     int       	=      self.model_tester.prepare_config_and_inputs_for_common()
           lowercase							:     Tuple       	=      ["""preactivation""", """bottleneck"""]
           for model_class in self.all_model_classes:
                  for layer_type in layers_type:
                         lowercase							:     Dict       	=      layer_type
                         lowercase							:     int       	=      True
                         check_hidden_states_output(snake_case		,snake_case		,snake_case      )

                         # check that output_hidden_states also work using config
                         del inputs_dict["output_hidden_states"]
                         lowercase							:     Union[str, Any]       	=      True

                         check_hidden_states_output(snake_case		,snake_case		,snake_case      )
    @unittest.skip(reason="""Bit does not use feedforward chunking"""      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           pass
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     Optional[int]       	=      self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_image_classification(*snake_case      )
    @slow
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           for model_name in BIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                  lowercase							:     Optional[Any]       	=      BitModel.from_pretrained(snake_case      )
                  self.assertIsNotNone(snake_case      )







def 						_snake_case(  ) ->    Optional[int]:
       lowercase							:     str       	=      Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""				)
       return image

@require_torch
@require_vision
class __snake_case		(      unittest.TestCase     ):
    @cached_property
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           return (
               BitImageProcessor.from_pretrained(BIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]      ) if is_vision_available() else None
           )
    @slow
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     List[str]       	=      BitForImageClassification.from_pretrained(BIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]      ).to(snake_case      )

           lowercase							:     Union[str, Any]       	=      self.default_image_processor
           lowercase							:     int       	=      prepare_img()
           lowercase							:     str       	=      image_processor(images=snake_case		,return_tensors="""pt"""      ).to(snake_case      )

           # forward pass
           with torch.no_grad():
                  lowercase							:     Optional[int]       	=      model(**snake_case      )

           # verify the logits
           lowercase							:     int       	=      torch.Size((1, 1000)      )
           self.assertEqual(outputs.logits.shape		,snake_case      )

           lowercase							:     Optional[Any]       	=      torch.tensor([[-0.6_526, -0.5_263, -1.4_398]]      ).to(snake_case      )

           self.assertTrue(torch.allclose(outputs.logits[0, :3]		,snake_case		,atol=1e-4      )      )






@require_torch
class __snake_case		(      lowerCAmelCase					,	unittest.TestCase     ):
    _a		:						Tuple=				(BitBackbone,) if is_torch_available() else ()
    _a		:						str=				BitConfig

    _a		:						str=				False
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     List[Any]       	=      BitModelTester(self      )


from math import sqrt







def 						_snake_case(  SCREAMING_SNAKE_CASE__				) ->    bool:
       assert isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				) and (
           number >= 0
       ), "'number' must been an int and positive"

       lowercase							:     Union[str, Any]       	=      True

       # 0 and 1 are none primes.
       if number <= 1:
              lowercase							:     str       	=      False

       for divisor in range(2					,	int(round(sqrt(SCREAMING_SNAKE_CASE__				)				)				) + 1				):
              # if 'number' divisible by 'divisor' then sets 'status'
              # of false and break up the loop.
              if number % divisor == 0:
                     lowercase							:     Any       	=      False
                     break

    # precondition
       assert isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				), "'status' must been from type bool"

       return status







def 						_snake_case(  SCREAMING_SNAKE_CASE__				) ->    Union[str, Any]:
       assert isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				) and (n > 2), "'N' must been an int and > 2"

       # beginList: contains all natural numbers from 2 up to N
       lowercase							:     str       	=      list(range(2					,	n + 1				)				)

       lowercase							:     Tuple       	=      []  # this list will be returns.

       # actual sieve of erathostenes
       for i in range(len(SCREAMING_SNAKE_CASE__				)				):
              for j in range(i + 1					,	len(SCREAMING_SNAKE_CASE__				)				):
                     if (begin_list[i] != 0) and (begin_list[j] % begin_list[i] == 0):
                            lowercase							:     Tuple       	=      0

    # filters actual prime numbers.
       lowercase							:     int       	=      [x for x in begin_list if x != 0]

       # precondition
       assert isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				), "'ans' must been from type list"

       return ans







def 						_snake_case(  SCREAMING_SNAKE_CASE__				) ->    Optional[Any]:
       assert isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				) and (n > 2), "'N' must been an int and > 2"

       lowercase							:     Dict       	=      []

       # iterates over all numbers between 2 up to N+1
       # if a number is prime then appends to list 'ans'
       for number in range(2					,	n + 1				):
              if is_prime(SCREAMING_SNAKE_CASE__				):
                     ans.append(SCREAMING_SNAKE_CASE__				)

    # precondition
       assert isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				), "'ans' must been from type list"

       return ans







def 						_snake_case(  SCREAMING_SNAKE_CASE__				) ->    Tuple:
       assert isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				) and number >= 0, "'number' must been an int and >= 0"

       lowercase							:     Tuple       	=      []  # this list will be returns of the function.

       # potential prime number factors.

       lowercase							:     Optional[Any]       	=      2

       lowercase							:     Any       	=      number

       if number == 0 or number == 1:
              ans.append(SCREAMING_SNAKE_CASE__				)

       # if 'number' not prime then builds the prime factorization of 'number'
       elif not is_prime(SCREAMING_SNAKE_CASE__				):
              while quotient != 1:
                     if is_prime(SCREAMING_SNAKE_CASE__				) and (quotient % factor == 0):
                            ans.append(SCREAMING_SNAKE_CASE__				)
                            quotient /= factor
                     else:
                            factor += 1

       else:
              ans.append(SCREAMING_SNAKE_CASE__				)

       # precondition
       assert isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				), "'ans' must been from type list"

       return ans







def 						_snake_case(  SCREAMING_SNAKE_CASE__				) ->    List[Any]:
       assert isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				) and (
           number >= 0
       ), "'number' bust been an int and >= 0"

       lowercase							:     Tuple       	=      0

       # prime factorization of 'number'
       lowercase							:     Optional[int]       	=      prime_factorization(SCREAMING_SNAKE_CASE__				)

       lowercase							:     Union[str, Any]       	=      max(SCREAMING_SNAKE_CASE__				)

       # precondition
       assert isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				), "'ans' must been from type int"

       return ans







def 						_snake_case(  SCREAMING_SNAKE_CASE__				) ->    str:
       assert isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				) and (
           number >= 0
       ), "'number' bust been an int and >= 0"

       lowercase							:     Union[str, Any]       	=      0

       # prime factorization of 'number'
       lowercase							:     Tuple       	=      prime_factorization(SCREAMING_SNAKE_CASE__				)

       lowercase							:     Union[str, Any]       	=      min(SCREAMING_SNAKE_CASE__				)

       # precondition
       assert isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				), "'ans' must been from type int"

       return ans







def 						_snake_case(  SCREAMING_SNAKE_CASE__				) ->    Optional[Any]:
       assert isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				), "'number' must been an int"
       assert isinstance(number % 2 == 0					,	SCREAMING_SNAKE_CASE__				), "compare bust been from type bool"

       return number % 2 == 0







def 						_snake_case(  SCREAMING_SNAKE_CASE__				) ->    int:
       assert isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				), "'number' must been an int"
       assert isinstance(number % 2 != 0					,	SCREAMING_SNAKE_CASE__				), "compare bust been from type bool"

       return number % 2 != 0







def 						_snake_case(  SCREAMING_SNAKE_CASE__				) ->    int:
       assert (
           isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				) and (number > 2) and is_even(SCREAMING_SNAKE_CASE__				)
       ), "'number' must been an int, even and > 2"

       lowercase							:     Union[str, Any]       	=      []  # this list will returned

       # creates a list of prime numbers between 2 up to 'number'
       lowercase							:     str       	=      get_prime_numbers(SCREAMING_SNAKE_CASE__				)
       lowercase							:     Any       	=      len(SCREAMING_SNAKE_CASE__				)

       # run variable for while-loops.
       lowercase							:     Optional[Any]       	=      0
       lowercase							:     List[Any]       	=      None

       # exit variable. for break up the loops
       lowercase							:     Any       	=      True

       while i < len_pn and loop:
              lowercase							:     str       	=      i + 1

              while j < len_pn and loop:
                     if prime_numbers[i] + prime_numbers[j] == number:
                            lowercase							:     Union[str, Any]       	=      False
                            ans.append(prime_numbers[i]				)
                            ans.append(prime_numbers[j]				)

                     j += 1

              i += 1

       # precondition
       assert (
           isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				)
           and (len(SCREAMING_SNAKE_CASE__				) == 2)
           and (ans[0] + ans[1] == number)
           and is_prime(ans[0]				)
           and is_prime(ans[1]				)
       ), "'ans' must contains two primes. And sum of elements must been eq 'number'"

       return ans







def 						_snake_case(  SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				) ->    str:
       assert (
           isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				)
           and isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				)
           and (numbera >= 0)
           and (numbera >= 0)
       ), "'number1' and 'number2' must been positive integer."

       lowercase							:     Union[str, Any]       	=      0

       while numbera != 0:
              lowercase							:     Optional[int]       	=      numbera % numbera
              lowercase							:     Optional[int]       	=      numbera
              lowercase							:     Dict       	=      rest

       # precondition
       assert isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				) and (
           numbera >= 0
       ), "'number' must been from type int and positive"

       return numbera







def 						_snake_case(  SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				) ->    Tuple:
       assert (
           isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				)
           and isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				)
           and (numbera >= 1)
           and (numbera >= 1)
       ), "'number1' and 'number2' must been positive integer."

       lowercase							:     Dict       	=      1  # actual answer that will be return.

       # for kgV (x,1)
       if numbera > 1 and numbera > 1:
              # builds the prime factorization of 'number1' and 'number2'
              lowercase							:     Optional[Any]       	=      prime_factorization(SCREAMING_SNAKE_CASE__				)
              lowercase							:     Optional[int]       	=      prime_factorization(SCREAMING_SNAKE_CASE__				)

       elif numbera == 1 or numbera == 1:
              lowercase							:     Union[str, Any]       	=      []
              lowercase							:     List[str]       	=      []
              lowercase							:     Dict       	=      max(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				)

       lowercase							:     Union[str, Any]       	=      0
       lowercase							:     Optional[Any]       	=      0

       lowercase							:     List[str]       	=      []  # captured numbers int both 'primeFac1' and 'primeFac2'

       # iterates through primeFac1
       for n in prime_fac_a:
              if n not in done:
                     if n in prime_fac_a:
                            lowercase							:     Dict       	=      prime_fac_a.count(SCREAMING_SNAKE_CASE__				)
                            lowercase							:     Optional[Any]       	=      prime_fac_a.count(SCREAMING_SNAKE_CASE__				)

                            for _ in range(max(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				)				):
                                   ans *= n

                     else:
                            lowercase							:     List[Any]       	=      prime_fac_a.count(SCREAMING_SNAKE_CASE__				)

                            for _ in range(SCREAMING_SNAKE_CASE__				):
                                   ans *= n

                     done.append(SCREAMING_SNAKE_CASE__				)

    # iterates through primeFac2
       for n in prime_fac_a:
              if n not in done:
                     lowercase							:     Optional[int]       	=      prime_fac_a.count(SCREAMING_SNAKE_CASE__				)

                     for _ in range(SCREAMING_SNAKE_CASE__				):
                            ans *= n

                     done.append(SCREAMING_SNAKE_CASE__				)

    # precondition
       assert isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				) and (
           ans >= 0
       ), "'ans' must been from type int and positive"

       return ans







def 						_snake_case(  SCREAMING_SNAKE_CASE__				) ->    Any:
       assert isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				) and (n >= 0), "'number' must been a positive int"

       lowercase							:     Dict       	=      0
       lowercase							:     List[str]       	=      2  # this variable holds the answer

       while index < n:
              index += 1

              ans += 1  # counts to the next number

              # if ans not prime then
              # runs to the next prime number.
              while not is_prime(SCREAMING_SNAKE_CASE__				):
                     ans += 1

    # precondition
       assert isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				) and is_prime(
           SCREAMING_SNAKE_CASE__				), "'ans' must been a prime number and from type int"

       return ans







def 						_snake_case(  SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				) ->    List[Any]:
       assert (
           is_prime(SCREAMING_SNAKE_CASE__				) and is_prime(SCREAMING_SNAKE_CASE__				) and (p_number_a < p_number_a)
       ), "The arguments must been prime numbers and 'pNumber1' < 'pNumber2'"

       lowercase							:     List[str]       	=      p_number_a + 1  # jump to the next number

       lowercase							:     List[Any]       	=      []  # this list will be returns.

       # if number is not prime then
       # fetch the next prime number.
       while not is_prime(SCREAMING_SNAKE_CASE__				):
              number += 1

       while number < p_number_a:
              ans.append(SCREAMING_SNAKE_CASE__				)

              number += 1

              # fetch the next prime number.
              while not is_prime(SCREAMING_SNAKE_CASE__				):
                     number += 1

    # precondition
       assert (
           isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				)
           and ans[0] != p_number_a
           and ans[len(SCREAMING_SNAKE_CASE__				) - 1] != p_number_a
       ), "'ans' must been a list without the arguments"

       # 'ans' contains not 'pNumber1' and 'pNumber2' !
       return ans







def 						_snake_case(  SCREAMING_SNAKE_CASE__				) ->    Any:
       assert isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				) and (n >= 1), "'n' must been int and >= 1"

       lowercase							:     Optional[Any]       	=      []  # will be returned.

       for divisor in range(1					,	n + 1				):
              if n % divisor == 0:
                     ans.append(SCREAMING_SNAKE_CASE__				)

    # precondition
       assert ans[0] == 1 and ans[len(SCREAMING_SNAKE_CASE__				) - 1] == n, "Error in function getDivisiors(...)"

       return ans







def 						_snake_case(  SCREAMING_SNAKE_CASE__				) ->    Any:
       assert isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				) and (
           number > 1
       ), "'number' must been an int and >= 1"

       lowercase							:     str       	=      get_divisors(SCREAMING_SNAKE_CASE__				)

       # precondition
       assert (
           isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				)
           and (divisors[0] == 1)
           and (divisors[len(SCREAMING_SNAKE_CASE__				) - 1] == number)
       ), "Error in help-function getDivisiors(...)"

       # summed all divisors up to 'number' (exclusive), hence [:-1]
       return sum(divisors[:-1]				) == number







def 						_snake_case(  SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				) ->    Dict:
       assert (
           isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				)
           and isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				)
           and (denominator != 0)
       ), "The arguments must been from type int and 'denominator' != 0"

       # build the greatest common divisor of numerator and denominator.
       lowercase							:     Tuple       	=      gcd(abs(SCREAMING_SNAKE_CASE__				)					,	abs(SCREAMING_SNAKE_CASE__				)				)

       # precondition
       assert (
           isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				)
           and (numerator % gcd_of_fraction == 0)
           and (denominator % gcd_of_fraction == 0)
       ), "Error in function gcd(...,...)"

       return (numerator // gcd_of_fraction, denominator // gcd_of_fraction)







def 						_snake_case(  SCREAMING_SNAKE_CASE__				) ->    int:
       assert isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				) and (n >= 0), "'n' must been a int and >= 0"

       lowercase							:     List[str]       	=      1  # this will be return.

       for factor in range(1					,	n + 1				):
              ans *= factor

       return ans







def 						_snake_case(  SCREAMING_SNAKE_CASE__				) ->    Union[str, Any]:
       assert isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				) and (n >= 0), "'n' must been an int and >= 0"

       lowercase							:     int       	=      0
       lowercase							:     Union[str, Any]       	=      1
       lowercase							:     int       	=      1  # this will be return

       for _ in range(n - 1				):
              lowercase							:     Optional[int]       	=      ans
              ans += fiba
              lowercase							:     Optional[int]       	=      tmp

       return ans
