

from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
    is_vision_available,
)


__snake_case							:			Optional[Any]      		= {
    """configuration_mobilevitv2""": [
        """MOBILEVITV2_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """MobileViTV2Config""",
        """MobileViTV2OnnxConfig""",
    ],
}


try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__snake_case							:			Union[str, Any]      		= [
						    """MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST""",
						    """MobileViTV2ForImageClassification""",
						    """MobileViTV2ForSemanticSegmentation""",
						    """MobileViTV2Model""",
						    """MobileViTV2PreTrainedModel""",
						]

if TYPE_CHECKING:
						from .configuration_mobilevitva import (
						    MOBILEVITV2_PRETRAINED_CONFIG_ARCHIVE_MAP,
						    MobileViTVaConfig,
						    MobileViTVaOnnxConfig,
						)

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_mobilevitva import (
												    MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST,
												    MobileViTVaForImageClassification,
												    MobileViTVaForSemanticSegmentation,
												    MobileViTVaModel,
												    MobileViTVaPreTrainedModel,
												)

else:
						import sys

						__snake_case							:			Tuple      		= _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)





from dataclasses import dataclass
from typing import Callable, Optional

import datasets



@dataclass
class 					A__(datasets.BuilderConfig       ):
						"""simple docstring"""






						_A						:							Optional[Callable]									= None
						_A						:							Optional[dict]									= None
						_A						:							Optional[datasets.Features]									= None





						def  UpperCamelCase__				(						self						)    ->   Tuple:
									assert self.generator is not None, "generator must be specified"

									if self.gen_kwargs is None:
												a_	:	Tuple          =   {}







class 					A__(datasets.GeneratorBasedBuilder       ):
						"""simple docstring"""






						_A						:							Dict									= GeneratorConfig





						def  UpperCamelCase__				(						self						)    ->   List[Any]:
									return datasets.DatasetInfo(features=self.config.features						)





						def  UpperCamelCase__				(						self     ,			_lowercase						)    ->   List[Any]:
									return [datasets.SplitGenerator(name=datasets.Split.TRAIN     ,			gen_kwargs=self.config.gen_kwargs						)]





						def  UpperCamelCase__				(						self     ,			**_lowercase						)    ->   Tuple:
									for idx, ex in enumerate(self.config.generator(**_lowercase						)						):
												yield idx, ex


