


"""simple docstring"""
from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__SCREAMING_SNAKE_CASE				:     Optional[int]		=     {
    'configuration_dpr': ['DPR_PRETRAINED_CONFIG_ARCHIVE_MAP', 'DPRConfig'],
    'tokenization_dpr': [
        'DPRContextEncoderTokenizer',
        'DPRQuestionEncoderTokenizer',
        'DPRReaderOutput',
        'DPRReaderTokenizer',
    ],
}


try:
				if not is_tokenizers_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__SCREAMING_SNAKE_CASE				:     Dict		=     [
				    'DPRContextEncoderTokenizerFast',
				    'DPRQuestionEncoderTokenizerFast',
				    'DPRReaderTokenizerFast',
				]

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__SCREAMING_SNAKE_CASE				:     str		=     [
				    'DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'DPRContextEncoder',
				    'DPRPretrainedContextEncoder',
				    'DPRPreTrainedModel',
				    'DPRPretrainedQuestionEncoder',
				    'DPRPretrainedReader',
				    'DPRQuestionEncoder',
				    'DPRReader',
				]

try:
				if not is_tf_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__SCREAMING_SNAKE_CASE				:     Dict		=     [
				    'TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'TFDPRContextEncoder',
				    'TFDPRPretrainedContextEncoder',
				    'TFDPRPretrainedQuestionEncoder',
				    'TFDPRPretrainedReader',
				    'TFDPRQuestionEncoder',
				    'TFDPRReader',
				]


if TYPE_CHECKING:
				from .configuration_dpr import DPR_PRETRAINED_CONFIG_ARCHIVE_MAP, DPRConfig
				from .tokenization_dpr import (
				    DPRContextEncoderTokenizer,
				    DPRQuestionEncoderTokenizer,
				    DPRReaderOutput,
				    DPRReaderTokenizer,
				)

				try:
								if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .tokenization_dpr_fast import (
								    DPRContextEncoderTokenizerFast,
								    DPRQuestionEncoderTokenizerFast,
								    DPRReaderTokenizerFast,
								)

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_dpr import (
								    DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
								    DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
								    DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
								    DPRContextEncoder,
								    DPRPretrainedContextEncoder,
								    DPRPreTrainedModel,
								    DPRPretrainedQuestionEncoder,
								    DPRPretrainedReader,
								    DPRQuestionEncoder,
								    DPRReader,
								)

				try:
								if not is_tf_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_tf_dpr import (
								    TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
								    TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
								    TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
								    TFDPRContextEncoder,
								    TFDPRPretrainedContextEncoder,
								    TFDPRPretrainedQuestionEncoder,
								    TFDPRPretrainedReader,
								    TFDPRQuestionEncoder,
								    TFDPRReader,
								)

else:
				import sys

				__SCREAMING_SNAKE_CASE				:     Tuple		=     _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)







"""simple docstring"""
import math







def     _a					(   _SCREAMING_SNAKE_CASE					)     ->					list[int]:
							if not isinstance(_SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE					):
														snake_case_     							=		f"""Input value of [number={number}] must be an integer"""
														raise TypeError(_SCREAMING_SNAKE_CASE					)
							if number < 1:
														snake_case_     							=		f"""Input value of [number={number}] must be a positive integer"""
														raise ValueError(_SCREAMING_SNAKE_CASE					)
							snake_case_     							=		[number]
							while number != 1:
														if number % 2 == 0:
																					snake_case_     							=		math.floor(math.sqrt(_SCREAMING_SNAKE_CASE					)					)
														else:
																					snake_case_     							=		math.floor(
																					    math.sqrt(_SCREAMING_SNAKE_CASE					) * math.sqrt(_SCREAMING_SNAKE_CASE					) * math.sqrt(_SCREAMING_SNAKE_CASE					)					)
														sequence.append(_SCREAMING_SNAKE_CASE					)
							return sequence


if __name__ == "__main__":
				import doctest

				doctest.testmod()



