
"""simple docstring"""







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

	__lowerCAmelCase      :						int						      =				True

	# 0 and 1 are none primes.
	if number <= 1:
		__lowerCAmelCase      :						Union[str, Any]						      =				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      :						List[Any]						      =				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      :						Dict						      =				list(range(2	,  n + 1		)		)

	__lowerCAmelCase      :						Tuple						      =				[]  # 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      :						Union[str, Any]						      =				0

    # filters actual prime numbers.
	__lowerCAmelCase      :						Tuple						      =				[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      :						str						      =				[]

	# 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      :						Any						      =				[]  # this list will be returns of the function.

	# potential prime number factors.

	__lowerCAmelCase      :						List[Any]						      =				2

	__lowerCAmelCase      :						Optional[Any]						      =				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      :						List[Any]						      =				0

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

	__lowerCAmelCase      :						str						      =				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      :						Optional[int]						      =				0

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

	__lowerCAmelCase      :						str						      =				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      :						Dict						      =				[]  # this list will returned

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

	# run variable for while-loops.
	__lowerCAmelCase      :						str						      =				0
	__lowerCAmelCase      :						Optional[int]						      =				None

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

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

		while j < len_pn and loop:
			if prime_numbers[i] + prime_numbers[j] == number:
				__lowerCAmelCase      :						List[Any]						      =				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      :						str						      =				0

	while numbera != 0:
		__lowerCAmelCase      :						int						      =				numbera % numbera
		__lowerCAmelCase      :						Tuple						      =				numbera
		__lowerCAmelCase      :						Union[str, Any]						      =				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      :						Any						      =				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      :						Optional[Any]						      =				prime_factorization(_UpperCamelCase		)
		__lowerCAmelCase      :						Optional[int]						      =				prime_factorization(_UpperCamelCase		)

	elif numbera == 1 or numbera == 1:
		__lowerCAmelCase      :						List[Any]						      =				[]
		__lowerCAmelCase      :						Tuple						      =				[]
		__lowerCAmelCase      :						str						      =				max(_UpperCamelCase	,  _UpperCamelCase		)

	__lowerCAmelCase      :						Union[str, Any]						      =				0
	__lowerCAmelCase      :						Any						      =				0

	__lowerCAmelCase      :						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:
				__lowerCAmelCase      :						Optional[int]						      =				prime_fac_a.count(_UpperCamelCase		)
				__lowerCAmelCase      :						List[str]						      =				prime_fac_a.count(_UpperCamelCase		)

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

			else:
				__lowerCAmelCase      :						Optional[Any]						      =				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      :						int						      =				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      :						List[str]						      =				0
	__lowerCAmelCase      :						List[Any]						      =				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      :						List[Any]						      =				p_number_a + 1  # jump to the next number

	__lowerCAmelCase      :						Optional[int]						      =				[]  # 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      :						Union[str, Any]						      =				[]  # 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      :						Any						      =				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      :						Optional[int]						      =				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      :						List[str]						      =				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      :						Optional[int]						      =				0
	__lowerCAmelCase      :						Tuple						      =				1
	__lowerCAmelCase      :						Union[str, Any]						      =				1  # this will be return

	for _ in range(n - 1		):
		__lowerCAmelCase      :						Union[str, Any]						      =				ans
		ans += fiba
		__lowerCAmelCase      :						int						      =				tmp

	return ans

"""simple docstring"""







# flake8: noqa
# Lint as: python3

from typing import Dict, List, Optional, Type

from .. import config
from ..utils import logging
from .formatting import (
    ArrowFormatter,
    CustomFormatter,
    Formatter,
    PandasFormatter,
    PythonFormatter,
    TensorFormatter,
    format_table,
    query_table,
)
from .np_formatter import NumpyFormatter


lowerCamelCase__        =		logging.get_logger(__name__)

lowerCamelCase__        =		{}
lowerCamelCase__        =		{}
lowerCamelCase__        =		{}
def    __lowerCAmelCase    (_UpperCamelCase	,  _UpperCamelCase	,  _UpperCamelCase = None	,  ):
	__lowerCAmelCase      :						Union[str, Any]						      =				aliases if aliases is not None else []
	if format_type in _FORMAT_TYPES:
		logger.warning(
		    F"Overwriting format type '{format_type}' ({_FORMAT_TYPES[format_type].__name__} -> {formatter_cls.__name__})"		)
	__lowerCAmelCase      :						str						      =				formatter_cls
	for alias in set(aliases + [format_type]		):
		if alias in _FORMAT_TYPES_ALIASES:
			logger.warning(
			    F"Overwriting format type alias '{alias}' ({_FORMAT_TYPES_ALIASES[alias]} -> {format_type})"		)
		__lowerCAmelCase      :						Any						      =				format_type
def    __lowerCAmelCase    (_UpperCamelCase	,  _UpperCamelCase	,  _UpperCamelCase = None		):
	__lowerCAmelCase      :						int						      =				aliases if aliases is not None else []
	for alias in set(aliases + [format_type]		):
		__lowerCAmelCase      :						str						      =				unavailable_error


# Here we define all the available formatting functions that can be used by `Dataset.set_format`
_register_formatter(PythonFormatter, None, aliases=["""python"""])
_register_formatter(ArrowFormatter, """arrow""", aliases=["""pa""", """pyarrow"""])
_register_formatter(NumpyFormatter, """numpy""", aliases=["""np"""])
_register_formatter(PandasFormatter, """pandas""", aliases=["""pd"""])
_register_formatter(CustomFormatter, """custom""")

if config.TORCH_AVAILABLE:
							from .torch_formatter import TorchFormatter

							_register_formatter(TorchFormatter, """torch""", aliases=["""pt""", """pytorch"""])
else:
							lowerCamelCase__        =		ValueError("""PyTorch needs to be installed to be able to return PyTorch tensors.""")
							_register_unavailable_formatter(_torch_error, """torch""", aliases=["""pt""", """pytorch"""])

if config.TF_AVAILABLE:
							from .tf_formatter import TFFormatter

							_register_formatter(TFFormatter, """tensorflow""", aliases=["""tf"""])
else:
							lowerCamelCase__        =		ValueError("""Tensorflow needs to be installed to be able to return Tensorflow tensors.""")
							_register_unavailable_formatter(_tf_error, """tensorflow""", aliases=["""tf"""])

if config.JAX_AVAILABLE:
							from .jax_formatter import JaxFormatter

							_register_formatter(JaxFormatter, """jax""", aliases=[])
else:
							lowerCamelCase__        =		ValueError("""JAX needs to be installed to be able to return JAX arrays.""")
							_register_unavailable_formatter(_jax_error, """jax""", aliases=[])
def    __lowerCAmelCase    (_UpperCamelCase		):
	if format_type in _FORMAT_TYPES_ALIASES:
		return _FORMAT_TYPES_ALIASES[format_type]
	else:
		return format_type
def    __lowerCAmelCase    (_UpperCamelCase	,  **_UpperCamelCase		):
	__lowerCAmelCase      :						Any						      =				get_format_type_from_alias(_UpperCamelCase		)
	if format_type in _FORMAT_TYPES:
		return _FORMAT_TYPES[format_type](**_UpperCamelCase		)
	if format_type in _FORMAT_TYPES_ALIASES_UNAVAILABLE:
		raise _FORMAT_TYPES_ALIASES_UNAVAILABLE[format_type]
	else:
		raise ValueError(
		    F"Return type should be None or selected in {list(type for type in _FORMAT_TYPES.keys() if type != None		)}, but got '{format_type}'"		)