



from typing import TYPE_CHECKING

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


UpperCamelCase_	       =   {"configuration_vilt": ["VILT_PRETRAINED_CONFIG_ARCHIVE_MAP", "ViltConfig"]}

try:
							if not is_vision_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCamelCase_	       =   ["ViltFeatureExtractor"]
							UpperCamelCase_	       =   ["ViltImageProcessor"]
							UpperCamelCase_	       =   ["ViltProcessor"]

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCamelCase_	       =   [
							    "VILT_PRETRAINED_MODEL_ARCHIVE_LIST",
							    "ViltForImageAndTextRetrieval",
							    "ViltForImagesAndTextClassification",
							    "ViltForTokenClassification",
							    "ViltForMaskedLM",
							    "ViltForQuestionAnswering",
							    "ViltLayer",
							    "ViltModel",
							    "ViltPreTrainedModel",
							]


if TYPE_CHECKING:
							from .configuration_vilt import VILT_PRETRAINED_CONFIG_ARCHIVE_MAP, ViltConfig

							try:
														if not is_vision_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .feature_extraction_vilt import ViltFeatureExtractor
														from .image_processing_vilt import ViltImageProcessor
														from .processing_vilt import ViltProcessor

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_vilt import (
														    VILT_PRETRAINED_MODEL_ARCHIVE_LIST,
														    ViltForImageAndTextRetrieval,
														    ViltForImagesAndTextClassification,
														    ViltForMaskedLM,
														    ViltForQuestionAnswering,
														    ViltForTokenClassification,
														    ViltLayer,
														    ViltModel,
														    ViltPreTrainedModel,
														)


else:
							import sys

							UpperCamelCase_	       =   _LazyModule(__name__, globals()["__file__"], _import_structure)










from dataclasses import dataclass
from typing import Callable, Optional

import datasets







@dataclass
class 							a_  (		datasets.BuilderConfig				):
						UpperCamelCase__      :						Optional[Callable]				       =None
						UpperCamelCase__      :						Optional[dict]				       =None
						UpperCamelCase__      :						Optional[datasets.Features]				       =None

						def 	__a       (    self	:List[str])		->					List[str]:
												assert self.generator is not None, "generator must be specified"

												if self.gen_kwargs is None:
																		UpperCAmelCase_     							=     {}







class 							a_  (		datasets.GeneratorBasedBuilder				):
						UpperCamelCase__      :						List[str]				       =GeneratorConfig

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

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




						def 	__a       (    self	:Optional[int]   ,						**_lowercase	:str)		->					Union[str, Any]:
												for idx, ex in enumerate(self.config.generator(**_lowercase)):
																		yield idx, ex





