


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


__lowerCAmelCase	: Union[str, Any]  				={
    'configuration_data2vec_audio': ['DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP', 'Data2VecAudioConfig'],
    'configuration_data2vec_text': [
        'DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'Data2VecTextConfig',
        'Data2VecTextOnnxConfig',
    ],
    'configuration_data2vec_vision': [
        'DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'Data2VecVisionConfig',
        'Data2VecVisionOnnxConfig',
    ],
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__lowerCAmelCase	: Optional[int]  				=[
						    'DATA2VEC_AUDIO_PRETRAINED_MODEL_ARCHIVE_LIST',
						    'Data2VecAudioForAudioFrameClassification',
						    'Data2VecAudioForCTC',
						    'Data2VecAudioForSequenceClassification',
						    'Data2VecAudioForXVector',
						    'Data2VecAudioModel',
						    'Data2VecAudioPreTrainedModel',
						]
						__lowerCAmelCase	: List[str]  				=[
						    'DATA2VEC_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST',
						    'Data2VecTextForCausalLM',
						    'Data2VecTextForMaskedLM',
						    'Data2VecTextForMultipleChoice',
						    'Data2VecTextForQuestionAnswering',
						    'Data2VecTextForSequenceClassification',
						    'Data2VecTextForTokenClassification',
						    'Data2VecTextModel',
						    'Data2VecTextPreTrainedModel',
						]
						__lowerCAmelCase	: str  				=[
						    'DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST',
						    'Data2VecVisionForImageClassification',
						    'Data2VecVisionForMaskedImageModeling',
						    'Data2VecVisionForSemanticSegmentation',
						    'Data2VecVisionModel',
						    'Data2VecVisionPreTrainedModel',
						]

if is_tf_available():
						__lowerCAmelCase	: str  				=[
						    'TFData2VecVisionForImageClassification',
						    'TFData2VecVisionForSemanticSegmentation',
						    'TFData2VecVisionModel',
						    'TFData2VecVisionPreTrainedModel',
						]

if TYPE_CHECKING:
						from .configuration_dataavec_audio import DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP, DataaVecAudioConfig
						from .configuration_dataavec_text import (
						    DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP,
						    DataaVecTextConfig,
						    DataaVecTextOnnxConfig,
						)
						from .configuration_dataavec_vision import (
						    DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP,
						    DataaVecVisionConfig,
						    DataaVecVisionOnnxConfig,
						)

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_dataavec_audio import (
												    DATA2VEC_AUDIO_PRETRAINED_MODEL_ARCHIVE_LIST,
												    DataaVecAudioForAudioFrameClassification,
												    DataaVecAudioForCTC,
												    DataaVecAudioForSequenceClassification,
												    DataaVecAudioForXVector,
												    DataaVecAudioModel,
												    DataaVecAudioPreTrainedModel,
												)
												from .modeling_dataavec_text import (
												    DATA2VEC_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
												    DataaVecTextForCausalLM,
												    DataaVecTextForMaskedLM,
												    DataaVecTextForMultipleChoice,
												    DataaVecTextForQuestionAnswering,
												    DataaVecTextForSequenceClassification,
												    DataaVecTextForTokenClassification,
												    DataaVecTextModel,
												    DataaVecTextPreTrainedModel,
												)
												from .modeling_dataavec_vision import (
												    DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST,
												    DataaVecVisionForImageClassification,
												    DataaVecVisionForMaskedImageModeling,
												    DataaVecVisionForSemanticSegmentation,
												    DataaVecVisionModel,
												    DataaVecVisionPreTrainedModel,
												)
						if is_tf_available():
												from .modeling_tf_dataavec_vision import (
												    TFDataaVecVisionForImageClassification,
												    TFDataaVecVisionForSemanticSegmentation,
												    TFDataaVecVisionModel,
												    TFDataaVecVisionPreTrainedModel,
												)

else:
						import sys

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




from __future__ import annotations


def        _UpperCamelCase							(      lowercase__      ):
						__SCREAMING_SNAKE_CASE						:     Dict					=		0.00
						__SCREAMING_SNAKE_CASE						:     List[str]					=		0
						for resistor in resistors:
												if resistor <= 0:
																		__SCREAMING_SNAKE_CASE						:     Any					=		F'''Resistor at index {index} has a negative or zero value!'''
																		raise ValueError(lowercase__      )
												first_sum += 1 / float(lowercase__      )
												index += 1
						return 1 / first_sum


def        _UpperCamelCase							(      lowercase__      ):
						__SCREAMING_SNAKE_CASE						:     Tuple					=		0.00
						__SCREAMING_SNAKE_CASE						:     int					=		0
						for resistor in resistors:
												sum_r += resistor
												if resistor < 0:
																		__SCREAMING_SNAKE_CASE						:     Tuple					=		F'''Resistor at index {index} has a negative value!'''
																		raise ValueError(lowercase__      )
												index += 1
						return sum_r


if __name__ == "__main__":
						import doctest

						doctest.testmod()
