




'''simple docstring'''


from typing import TYPE_CHECKING

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


_snake_case   :   Optional[Any]     							=	{
    """configuration_whisper""": ["""WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP""", """WhisperConfig""", """WhisperOnnxConfig"""],
    """feature_extraction_whisper""": ["""WhisperFeatureExtractor"""],
    """processing_whisper""": ["""WhisperProcessor"""],
    """tokenization_whisper""": ["""WhisperTokenizer"""],
}

try:
	if not is_tokenizers_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_snake_case   :   Optional[int]     							=	["""WhisperTokenizerFast"""]

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_snake_case   :   List[str]     							=	[
	    """WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST""",
	    """WhisperForConditionalGeneration""",
	    """WhisperModel""",
	    """WhisperPreTrainedModel""",
	    """WhisperForAudioClassification""",
	]

try:
	if not is_tf_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_snake_case   :   List[Any]     							=	[
	    """TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST""",
	    """TFWhisperForConditionalGeneration""",
	    """TFWhisperModel""",
	    """TFWhisperPreTrainedModel""",
	]

try:
	if not is_flax_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_snake_case   :   Dict     							=	[
	    """FlaxWhisperForConditionalGeneration""",
	    """FlaxWhisperModel""",
	    """FlaxWhisperPreTrainedModel""",
	    """FlaxWhisperForAudioClassification""",
	]


if TYPE_CHECKING:
	from .configuration_whisper import WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP, WhisperConfig, WhisperOnnxConfig
	from .feature_extraction_whisper import WhisperFeatureExtractor
	from .processing_whisper import WhisperProcessor
	from .tokenization_whisper import WhisperTokenizer

	try:
		if not is_tokenizers_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .tokenization_whisper_fast import WhisperTokenizerFast

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_whisper import (
		    WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST,
		    WhisperForAudioClassification,
		    WhisperForConditionalGeneration,
		    WhisperModel,
		    WhisperPreTrainedModel,
		)

	try:
		if not is_tf_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_tf_whisper import (
		    TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TFWhisperForConditionalGeneration,
		    TFWhisperModel,
		    TFWhisperPreTrainedModel,
		)

	try:
		if not is_flax_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_flax_whisper import (
		    FlaxWhisperForAudioClassification,
		    FlaxWhisperForConditionalGeneration,
		    FlaxWhisperModel,
		    FlaxWhisperPreTrainedModel,
		)

else:
	import sys

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







'''simple docstring'''


import os

import pytest

from transformers.dynamic_module_utils import get_imports


_snake_case   :   List[str]     							=	'\nimport os\n'

_snake_case   :   Dict     							=	'\ndef foo():\n    import os\n    return False\n'

_snake_case   :   List[Any]     							=	'\ndef foo():\n    def bar():\n        if True:\n            import os\n        return False\n    return bar()\n'

_snake_case   :   Dict     							=	'\nimport os\n\ntry:\n    import bar\nexcept ImportError:\n    raise ValueError()\n'

_snake_case   :   Optional[Any]     							=	'\nimport os\n\ndef foo():\n    try:\n        import bar\n    except ImportError:\n        raise ValueError()\n'

_snake_case   :   Optional[Any]     							=	'\nimport os\n\ntry:\n    import bar\nexcept (ImportError, AttributeError):\n    raise ValueError()\n'

_snake_case   :   Any     							=	'\nimport os\n\ntry:\n    import bar\nexcept ImportError as e:\n    raise ValueError()\n'

_snake_case   :   List[str]     							=	'\nimport os\n\ntry:\n    import bar\nexcept:\n    raise ValueError()\n'

_snake_case   :   Dict     							=	'\nimport os\n\ntry:\n    import bar\n    import baz\nexcept ImportError:\n    raise ValueError()\n'

_snake_case   :   Any     							=	'\nimport os\n\ntry:\n    import bar\n    import baz\nexcept ImportError:\n    x = 1\n    raise ValueError()\n'

_snake_case   :   Union[str, Any]     							=	[
    TOP_LEVEL_IMPORT,
    IMPORT_IN_FUNCTION,
    DEEPLY_NESTED_IMPORT,
    TOP_LEVEL_TRY_IMPORT,
    GENERIC_EXCEPT_IMPORT,
    MULTILINE_TRY_IMPORT,
    MULTILINE_BOTH_IMPORT,
    MULTIPLE_EXCEPTS_IMPORT,
    EXCEPT_AS_IMPORT,
    TRY_IMPORT_IN_FUNCTION,
]
@pytest.mark.parametrize('''case'''				,		UpperCamelCase   )
def 	snake_case_					(UpperCamelCase :						str				,		UpperCamelCase :						List[Any]   ):





							'''simple docstring'''


							_a			  =       os.path.join(UpperCamelCase				,		'''test_file.py'''   )
							with open(UpperCamelCase				,		'''w'''   ) as _tmp_file:
														_tmp_file.write(UpperCamelCase   )

							_a			  =       get_imports(UpperCamelCase   )
							assert parsed_imports == ["os"]

