






'''simple docstring'''







from typing import TYPE_CHECKING

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


_A     :      List[Any]     					={
    '''configuration_electra''': ['''ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''ElectraConfig''', '''ElectraOnnxConfig'''],
    '''tokenization_electra''': ['''ElectraTokenizer'''],
}

try:
			if not is_tokenizers_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_A     :      Tuple     					=['''ElectraTokenizerFast''']

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_A     :      Any     					=[
			    '''ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST''',
			    '''ElectraForCausalLM''',
			    '''ElectraForMaskedLM''',
			    '''ElectraForMultipleChoice''',
			    '''ElectraForPreTraining''',
			    '''ElectraForQuestionAnswering''',
			    '''ElectraForSequenceClassification''',
			    '''ElectraForTokenClassification''',
			    '''ElectraModel''',
			    '''ElectraPreTrainedModel''',
			    '''load_tf_weights_in_electra''',
			]

try:
			if not is_tf_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_A     :      Optional[Any]     					=[
			    '''TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST''',
			    '''TFElectraForMaskedLM''',
			    '''TFElectraForMultipleChoice''',
			    '''TFElectraForPreTraining''',
			    '''TFElectraForQuestionAnswering''',
			    '''TFElectraForSequenceClassification''',
			    '''TFElectraForTokenClassification''',
			    '''TFElectraModel''',
			    '''TFElectraPreTrainedModel''',
			]

try:
			if not is_flax_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_A     :      Optional[Any]     					=[
			    '''FlaxElectraForCausalLM''',
			    '''FlaxElectraForMaskedLM''',
			    '''FlaxElectraForMultipleChoice''',
			    '''FlaxElectraForPreTraining''',
			    '''FlaxElectraForQuestionAnswering''',
			    '''FlaxElectraForSequenceClassification''',
			    '''FlaxElectraForTokenClassification''',
			    '''FlaxElectraModel''',
			    '''FlaxElectraPreTrainedModel''',
			]


if TYPE_CHECKING:
			from .configuration_electra import ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, ElectraConfig, ElectraOnnxConfig
			from .tokenization_electra import ElectraTokenizer

			try:
						if not is_tokenizers_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .tokenization_electra_fast import ElectraTokenizerFast

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_electra import (
						    ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
						    ElectraForCausalLM,
						    ElectraForMaskedLM,
						    ElectraForMultipleChoice,
						    ElectraForPreTraining,
						    ElectraForQuestionAnswering,
						    ElectraForSequenceClassification,
						    ElectraForTokenClassification,
						    ElectraModel,
						    ElectraPreTrainedModel,
						    load_tf_weights_in_electra,
						)

			try:
						if not is_tf_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_tf_electra import (
						    TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
						    TFElectraForMaskedLM,
						    TFElectraForMultipleChoice,
						    TFElectraForPreTraining,
						    TFElectraForQuestionAnswering,
						    TFElectraForSequenceClassification,
						    TFElectraForTokenClassification,
						    TFElectraModel,
						    TFElectraPreTrainedModel,
						)

			try:
						if not is_flax_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_flax_electra import (
						    FlaxElectraForCausalLM,
						    FlaxElectraForMaskedLM,
						    FlaxElectraForMultipleChoice,
						    FlaxElectraForPreTraining,
						    FlaxElectraForQuestionAnswering,
						    FlaxElectraForSequenceClassification,
						    FlaxElectraForTokenClassification,
						    FlaxElectraModel,
						    FlaxElectraPreTrainedModel,
						)

else:
			import sys

			_A     :      int     					=_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)









'''simple docstring'''







def 			SCREAMING_SNAKE_CASE_	(UpperCamelCase				)				->	list:

							# bit count represents no. of bits in the gray code
							if bit_count < 0:
														raise ValueError("""The given input must be positive"""				)

							# get the generated string sequence
							lowerCamelCase__ :     List[str]	  =	gray_code_sequence_string(UpperCamelCase				)
							#
							# convert them to integers
							for i in range(len(UpperCamelCase				)				):
														lowerCamelCase__ :     int	  =	int(sequence[i]    ,      2				)

							return sequence





def 			SCREAMING_SNAKE_CASE_	(UpperCamelCase				)				->	list:

							# The approach is a recursive one
							# Base case achieved when either n = 0 or n=1
							if bit_count == 0:
														return ["0"]

							if bit_count == 1:
														return ["0", "1"]

							lowerCamelCase__ :     Optional[Any]	  =	1 << bit_count  # defines the length of the sequence
							# 1<< n is equivalent to 2^n

							# recursive answer will generate answer for n-1 bits
							lowerCamelCase__ :     Any	  =	gray_code_sequence_string(bit_count - 1				)

							lowerCamelCase__ :     Union[str, Any]	  =	[]

							# append 0 to first half of the smaller sequence generated
							for i in range(seq_len // 2				):
														lowerCamelCase__ :     Optional[int]	  =	"""0""" + smaller_sequence[i]
														sequence.append(UpperCamelCase				)

							# append 1 to second half ... start from the end of the list
							for i in reversed(range(seq_len // 2				)				):
														lowerCamelCase__ :     int	  =	"""1""" + smaller_sequence[i]
														sequence.append(UpperCamelCase				)

							return sequence


if __name__ == "__main__":
			import doctest

			doctest.testmod()

