
"""simple docstring"""







from math import sqrt
def 					__lowerCAmelCase       (_UpperCamelCase	):
	assert isinstance(_UpperCamelCase ,						_UpperCamelCase	) and (
	    number >= 0
	), "'number' must been an int and positive"

	__lowerCAmelCase		    =   True

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

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

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

	return status
def 					__lowerCAmelCase       (_UpperCamelCase	):
	assert isinstance(_UpperCamelCase ,						_UpperCamelCase	) and (n > 2), "'N' must been an int and > 2"

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

	__lowerCAmelCase		    =   []  # this list will be returns.

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

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

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

	return ans
def 					__lowerCAmelCase       (_UpperCamelCase	):
	assert isinstance(_UpperCamelCase ,						_UpperCamelCase	) and (n > 2), "'N' must been an int and > 2"

	__lowerCAmelCase		    =   []

	# 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(_UpperCamelCase	):
			ans.append(_UpperCamelCase	)

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

	return ans
def 					__lowerCAmelCase       (_UpperCamelCase	):
	assert isinstance(_UpperCamelCase ,						_UpperCamelCase	) and number >= 0, "'number' must been an int and >= 0"

	__lowerCAmelCase		    =   []  # this list will be returns of the function.

	# potential prime number factors.

	__lowerCAmelCase		    =   2

	__lowerCAmelCase		    =   number

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

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

	else:
		ans.append(_UpperCamelCase	)

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

	return ans
def 					__lowerCAmelCase       (_UpperCamelCase	):
	assert isinstance(_UpperCamelCase ,						_UpperCamelCase	) and (
	    number >= 0
	), "'number' bust been an int and >= 0"

	__lowerCAmelCase		    =   0

	# prime factorization of 'number'
	__lowerCAmelCase		    =   prime_factorization(_UpperCamelCase	)

	__lowerCAmelCase		    =   max(_UpperCamelCase	)

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

	return ans
def 					__lowerCAmelCase       (_UpperCamelCase	):
	assert isinstance(_UpperCamelCase ,						_UpperCamelCase	) and (
	    number >= 0
	), "'number' bust been an int and >= 0"

	__lowerCAmelCase		    =   0

	# prime factorization of 'number'
	__lowerCAmelCase		    =   prime_factorization(_UpperCamelCase	)

	__lowerCAmelCase		    =   min(_UpperCamelCase	)

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

	return ans
def 					__lowerCAmelCase       (_UpperCamelCase	):
	assert isinstance(_UpperCamelCase ,						_UpperCamelCase	), "'number' must been an int"
	assert isinstance(number % 2 == 0 ,						_UpperCamelCase	), "compare bust been from type bool"

	return number % 2 == 0
def 					__lowerCAmelCase       (_UpperCamelCase	):
	assert isinstance(_UpperCamelCase ,						_UpperCamelCase	), "'number' must been an int"
	assert isinstance(number % 2 != 0 ,						_UpperCamelCase	), "compare bust been from type bool"

	return number % 2 != 0
def 					__lowerCAmelCase       (_UpperCamelCase	):
	assert (
	    isinstance(_UpperCamelCase ,						_UpperCamelCase	) and (number > 2) and is_even(_UpperCamelCase	)
	), "'number' must been an int, even and > 2"

	__lowerCAmelCase		    =   []  # this list will returned

	# creates a list of prime numbers between 2 up to 'number'
	__lowerCAmelCase		    =   get_prime_numbers(_UpperCamelCase	)
	__lowerCAmelCase		    =   len(_UpperCamelCase	)

	# run variable for while-loops.
	__lowerCAmelCase		    =   0
	__lowerCAmelCase		    =   None

	# exit variable. for break up the loops
	__lowerCAmelCase		    =   True

	while i < len_pn and loop:
		__lowerCAmelCase		    =   i + 1

		while j < len_pn and loop:
			if prime_numbers[i] + prime_numbers[j] == number:
				__lowerCAmelCase		    =   False
				ans.append(prime_numbers[i]	)
				ans.append(prime_numbers[j]	)

			j += 1

		i += 1

	# precondition
	assert (
	    isinstance(_UpperCamelCase ,						_UpperCamelCase	)
	    and (len(_UpperCamelCase	) == 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 					__lowerCAmelCase       (_UpperCamelCase ,						_UpperCamelCase	):
	assert (
	    isinstance(_UpperCamelCase ,						_UpperCamelCase	)
	    and isinstance(_UpperCamelCase ,						_UpperCamelCase	)
	    and (numbera >= 0)
	    and (numbera >= 0)
	), "'number1' and 'number2' must been positive integer."

	__lowerCAmelCase		    =   0

	while numbera != 0:
		__lowerCAmelCase		    =   numbera % numbera
		__lowerCAmelCase		    =   numbera
		__lowerCAmelCase		    =   rest

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

	return numbera
def 					__lowerCAmelCase       (_UpperCamelCase ,						_UpperCamelCase	):
	assert (
	    isinstance(_UpperCamelCase ,						_UpperCamelCase	)
	    and isinstance(_UpperCamelCase ,						_UpperCamelCase	)
	    and (numbera >= 1)
	    and (numbera >= 1)
	), "'number1' and 'number2' must been positive integer."

	__lowerCAmelCase		    =   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'
		__lowerCAmelCase		    =   prime_factorization(_UpperCamelCase	)
		__lowerCAmelCase		    =   prime_factorization(_UpperCamelCase	)

	elif numbera == 1 or numbera == 1:
		__lowerCAmelCase		    =   []
		__lowerCAmelCase		    =   []
		__lowerCAmelCase		    =   max(_UpperCamelCase ,						_UpperCamelCase	)

	__lowerCAmelCase		    =   0
	__lowerCAmelCase		    =   0

	__lowerCAmelCase		    =   []  # 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:
				__lowerCAmelCase		    =   prime_fac_a.count(_UpperCamelCase	)
				__lowerCAmelCase		    =   prime_fac_a.count(_UpperCamelCase	)

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

			else:
				__lowerCAmelCase		    =   prime_fac_a.count(_UpperCamelCase	)

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

			done.append(_UpperCamelCase	)

    # iterates through primeFac2
	for n in prime_fac_a:
		if n not in done:
			__lowerCAmelCase		    =   prime_fac_a.count(_UpperCamelCase	)

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

			done.append(_UpperCamelCase	)

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

	return ans
def 					__lowerCAmelCase       (_UpperCamelCase	):
	assert isinstance(_UpperCamelCase ,						_UpperCamelCase	) and (n >= 0), "'number' must been a positive int"

	__lowerCAmelCase		    =   0
	__lowerCAmelCase		    =   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(_UpperCamelCase	):
			ans += 1

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

	return ans
def 					__lowerCAmelCase       (_UpperCamelCase ,						_UpperCamelCase	):
	assert (
	    is_prime(_UpperCamelCase	) and is_prime(_UpperCamelCase	) and (p_number_a < p_number_a)
	), "The arguments must been prime numbers and 'pNumber1' < 'pNumber2'"

	__lowerCAmelCase		    =   p_number_a + 1  # jump to the next number

	__lowerCAmelCase		    =   []  # this list will be returns.

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

	while number < p_number_a:
		ans.append(_UpperCamelCase	)

		number += 1

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

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

	# 'ans' contains not 'pNumber1' and 'pNumber2' !
	return ans
def 					__lowerCAmelCase       (_UpperCamelCase	):
	assert isinstance(_UpperCamelCase ,						_UpperCamelCase	) and (n >= 1), "'n' must been int and >= 1"

	__lowerCAmelCase		    =   []  # will be returned.

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

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

	return ans
def 					__lowerCAmelCase       (_UpperCamelCase	):
	assert isinstance(_UpperCamelCase ,						_UpperCamelCase	) and (
	    number > 1
	), "'number' must been an int and >= 1"

	__lowerCAmelCase		    =   get_divisors(_UpperCamelCase	)

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

	# summed all divisors up to 'number' (exclusive), hence [:-1]
	return sum(divisors[:-1]	) == number
def 					__lowerCAmelCase       (_UpperCamelCase ,						_UpperCamelCase	):
	assert (
	    isinstance(_UpperCamelCase ,						_UpperCamelCase	)
	    and isinstance(_UpperCamelCase ,						_UpperCamelCase	)
	    and (denominator != 0)
	), "The arguments must been from type int and 'denominator' != 0"

	# build the greatest common divisor of numerator and denominator.
	__lowerCAmelCase		    =   gcd(abs(_UpperCamelCase	) ,						abs(_UpperCamelCase	)	)

	# precondition
	assert (
	    isinstance(_UpperCamelCase ,						_UpperCamelCase	)
	    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 					__lowerCAmelCase       (_UpperCamelCase	):
	assert isinstance(_UpperCamelCase ,						_UpperCamelCase	) and (n >= 0), "'n' must been a int and >= 0"

	__lowerCAmelCase		    =   1  # this will be return.

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

	return ans
def 					__lowerCAmelCase       (_UpperCamelCase	):
	assert isinstance(_UpperCamelCase ,						_UpperCamelCase	) and (n >= 0), "'n' must been an int and >= 0"

	__lowerCAmelCase		    =   0
	__lowerCAmelCase		    =   1
	__lowerCAmelCase		    =   1  # this will be return

	for _ in range(n - 1	):
		__lowerCAmelCase		    =   ans
		ans += fiba
		__lowerCAmelCase		    =   tmp

	return ans

"""simple docstring"""







import argparse
import os
import pickle
import sys

import torch

from transformers import TransfoXLConfig, TransfoXLLMHeadModel, load_tf_weights_in_transfo_xl
from transformers.models.transfo_xl import tokenization_transfo_xl as data_utils
from transformers.models.transfo_xl.tokenization_transfo_xl import CORPUS_NAME, VOCAB_FILES_NAMES
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()

# We do this to be able to load python 2 datasets pickles
# See e.g. https://stackoverflow.com/questions/2121874/python-pickling-after-changing-a-modules-directory/2121918#2121918
lowerCamelCase__           =	data_utils.TransfoXLTokenizer
lowerCamelCase__           =	data_utils.TransfoXLCorpus
lowerCamelCase__           =	data_utils
lowerCamelCase__           =	data_utils
def 					__lowerCAmelCase       (_UpperCamelCase ,						_UpperCamelCase ,						_UpperCamelCase ,						_UpperCamelCase	):
	if transfo_xl_dataset_file:
		# Convert a pre-processed corpus (see original TensorFlow repo)
		with open(_UpperCamelCase ,						'rb'	) as fp:
			__lowerCAmelCase    :		int		    =   pickle.load(_UpperCamelCase ,						encoding='latin1'	)
		# Save vocabulary and dataset cache as Dictionaries (should be better than pickles for the long-term)
		__lowerCAmelCase    :		Any		    =   pytorch_dump_folder_path + '/' + VOCAB_FILES_NAMES['pretrained_vocab_file']
		print(F"Save vocabulary to {pytorch_vocab_dump_path}"	)
		__lowerCAmelCase    :		Optional[Any]		    =   corpus.vocab.__dict__
		torch.save(_UpperCamelCase ,						_UpperCamelCase	)

		__lowerCAmelCase    :		Dict		    =   corpus.__dict__
		corpus_dict_no_vocab.pop('vocab' ,						_UpperCamelCase	)
		__lowerCAmelCase    :		List[str]		    =   pytorch_dump_folder_path + '/' + CORPUS_NAME
		print(F"Save dataset to {pytorch_dataset_dump_path}"	)
		torch.save(_UpperCamelCase ,						_UpperCamelCase	)

	if tf_checkpoint_path:
		# Convert a pre-trained TensorFlow model
		__lowerCAmelCase    :		Tuple		    =   os.path.abspath(_UpperCamelCase	)
		__lowerCAmelCase    :		List[Any]		    =   os.path.abspath(_UpperCamelCase	)

		print(F"Converting Transformer XL checkpoint from {tf_path} with config at {config_path}."	)
		# Initialise PyTorch model
		if transfo_xl_config_file == "":
			__lowerCAmelCase    :		Any		    =   TransfoXLConfig()
		else:
			__lowerCAmelCase    :		str		    =   TransfoXLConfig.from_json_file(_UpperCamelCase	)
		print(F"Building PyTorch model from configuration: {config}"	)
		__lowerCAmelCase    :		Optional[Any]		    =   TransfoXLLMHeadModel(_UpperCamelCase	)

		__lowerCAmelCase    :		Dict		    =   load_tf_weights_in_transfo_xl(_UpperCamelCase ,						_UpperCamelCase ,						_UpperCamelCase	)
		# Save pytorch-model
		__lowerCAmelCase    :		str		    =   os.path.join(_UpperCamelCase ,						_UpperCamelCase	)
		__lowerCAmelCase    :		Tuple		    =   os.path.join(_UpperCamelCase ,						_UpperCamelCase	)
		print(F"Save PyTorch model to {os.path.abspath(_UpperCamelCase	)}"	)
		torch.save(model.state_dict() ,						_UpperCamelCase	)
		print(F"Save configuration file to {os.path.abspath(_UpperCamelCase	)}"	)
		with open(_UpperCamelCase ,						'w' ,						encoding='utf-8'	) as f:
			f.write(config.to_json_string()	)


if __name__ == "__main__":
							lowerCamelCase__           =	argparse.ArgumentParser()
							parser.add_argument(
							    """--pytorch_dump_folder_path""",
							    default=None,
							    type=str,
							    required=True,
							    help="""Path to the folder to store the PyTorch model or dataset/vocab.""",
							)
							parser.add_argument(
							    """--tf_checkpoint_path""",
							    default="""""",
							    type=str,
							    help="""An optional path to a TensorFlow checkpoint path to be converted.""",
							)
							parser.add_argument(
							    """--transfo_xl_config_file""",
							    default="""""",
							    type=str,
							    help=(
							        """An optional config json file corresponding to the pre-trained BERT model. \n"""
							        """This specifies the model architecture."""
							    ),
							)
							parser.add_argument(
							    """--transfo_xl_dataset_file""",
							    default="""""",
							    type=str,
							    help="""An optional dataset file to be converted in a vocabulary.""",
							)
							lowerCamelCase__           =	parser.parse_args()
							convert_transfo_xl_checkpoint_to_pytorch(
							    args.tf_checkpoint_path,
							    args.transfo_xl_config_file,
							    args.pytorch_dump_folder_path,
							    args.transfo_xl_dataset_file,
							)