


import os

import pytest

from transformers.dynamic_module_utils import get_imports


UpperCAmelCase_				:			Tuple   =	'\nimport os\n'

UpperCAmelCase_				:			int   =	'\ndef foo():\n    import os\n    return False\n'

UpperCAmelCase_				:			Tuple   =	'\ndef foo():\n    def bar():\n        if True:\n            import os\n        return False\n    return bar()\n'

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

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

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

UpperCAmelCase_				:			List[Any]   =	'\nimport os\n\ntry:\n    import bar\nexcept ImportError as e:\n    raise ValueError()\n'

UpperCAmelCase_				:			str   =	'\nimport os\n\ntry:\n    import bar\nexcept:\n    raise ValueError()\n'

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

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

UpperCAmelCase_				:			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'  ,   _lowerCAmelCase    )
def 	SCREAMING_SNAKE_CASE_						(      __A			:      Any  ,   __A			:      Dict    )     ->		List[Any]:

       """simple docstring"""

       a_ :		Any							=  os.path.join(_lowerCAmelCase  ,   'test_file.py'    )
       with open(_lowerCAmelCase  ,   'w'    ) as _tmp_file:
              _tmp_file.write(_lowerCAmelCase    )

       a_ :		List[Any]							=  get_imports(_lowerCAmelCase    )
       assert parsed_imports == ["os"]






from typing import TYPE_CHECKING

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


UpperCAmelCase_				:			Union[str, 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:
   UpperCAmelCase_				:			Optional[Any]   =	['WhisperTokenizerFast']

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   UpperCAmelCase_				:			int   =	[
       'WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST',
       'WhisperForConditionalGeneration',
       'WhisperModel',
       'WhisperPreTrainedModel',
       'WhisperForAudioClassification',
   ]

try:
   if not is_tf_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   UpperCAmelCase_				:			int   =	[
       'TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST',
       'TFWhisperForConditionalGeneration',
       'TFWhisperModel',
       'TFWhisperPreTrainedModel',
   ]

try:
   if not is_flax_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   UpperCAmelCase_				:			Any   =	[
       '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

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


