
"""simple docstring"""




import importlib
import inspect
from functools import wraps
from typing import TYPE_CHECKING, Optional, Union

from .download.streaming_download_manager import (
    xbasename,
    xdirname,
    xet_parse,
    xexists,
    xgetsize,
    xglob,
    xgzip_open,
    xisdir,
    xisfile,
    xjoin,
    xlistdir,
    xnumpy_load,
    xopen,
    xpandas_read_csv,
    xpandas_read_excel,
    xPath,
    xrelpath,
    xsio_loadmat,
    xsplit,
    xsplitext,
    xwalk,
    xxml_dom_minidom_parse,
)
from .utils.logging import get_logger
from .utils.patching import patch_submodule
from .utils.py_utils import get_imports


A__   :						Union[str, Any] 							=     get_logger(__name__)


if TYPE_CHECKING:
    from .builder import DatasetBuilder



def 				a__			(					lowerCAmelCase						:							Dict							,     lowerCAmelCase						:							Optional[Union[str, bool]] = None		):






     '''simple docstring'''
     UpperCAmelCase__				:			Optional[Any]							=    importlib.import_module(lowerCAmelCase__		)

     # TODO(QL): always update the module to add subsequent new authentication
     if hasattr(lowerCAmelCase__							,     "_patched_for_streaming"		) and module._patched_for_streaming:
          return

     def wrap_auth(lowerCAmelCase						:							Tuple		):
          @wraps(lowerCAmelCase__		)
          def wrapper(*lowerCAmelCase						:							Any							,     **lowerCAmelCase						:							List[Any]		):
               return function(*lowerCAmelCase__							,     use_auth_token=lowerCAmelCase__							,     **lowerCAmelCase__		)

          UpperCAmelCase__				:			int							=    'wrap_auth'
          return wrapper

     # open files in a streaming fashion
     patch_submodule(lowerCAmelCase__							,     "open"							,     wrap_auth(lowerCAmelCase__		)		).start()
     patch_submodule(lowerCAmelCase__							,     "os.listdir"							,     wrap_auth(lowerCAmelCase__		)		).start()
     patch_submodule(lowerCAmelCase__							,     "os.walk"							,     wrap_auth(lowerCAmelCase__		)		).start()
     patch_submodule(lowerCAmelCase__							,     "glob.glob"							,     wrap_auth(lowerCAmelCase__		)		).start()
     # allow to navigate in remote zip files
     patch_submodule(lowerCAmelCase__							,     "os.path.join"							,     lowerCAmelCase__		).start()
     patch_submodule(lowerCAmelCase__							,     "os.path.dirname"							,     lowerCAmelCase__		).start()
     patch_submodule(lowerCAmelCase__							,     "os.path.basename"							,     lowerCAmelCase__		).start()
     patch_submodule(lowerCAmelCase__							,     "os.path.relpath"							,     lowerCAmelCase__		).start()
     patch_submodule(lowerCAmelCase__							,     "os.path.split"							,     lowerCAmelCase__		).start()
     patch_submodule(lowerCAmelCase__							,     "os.path.splitext"							,     lowerCAmelCase__		).start()
     # allow checks on paths
     patch_submodule(lowerCAmelCase__							,     "os.path.exists"							,     wrap_auth(lowerCAmelCase__		)		).start()
     patch_submodule(lowerCAmelCase__							,     "os.path.isdir"							,     wrap_auth(lowerCAmelCase__		)		).start()
     patch_submodule(lowerCAmelCase__							,     "os.path.isfile"							,     wrap_auth(lowerCAmelCase__		)		).start()
     patch_submodule(lowerCAmelCase__							,     "os.path.getsize"							,     wrap_auth(lowerCAmelCase__		)		).start()
     patch_submodule(lowerCAmelCase__							,     "pathlib.Path"							,     lowerCAmelCase__		).start()
     # file readers
     patch_submodule(lowerCAmelCase__							,     "gzip.open"							,     wrap_auth(lowerCAmelCase__		)		).start()
     patch_submodule(lowerCAmelCase__							,     "numpy.load"							,     wrap_auth(lowerCAmelCase__		)		).start()
     patch_submodule(lowerCAmelCase__							,     "pandas.read_csv"							,     wrap_auth(lowerCAmelCase__		)							,     attrs=["__version__"]		).start()
     patch_submodule(lowerCAmelCase__							,     "pandas.read_excel"							,     wrap_auth(lowerCAmelCase__		)							,     attrs=["__version__"]		).start()
     patch_submodule(lowerCAmelCase__							,     "scipy.io.loadmat"							,     wrap_auth(lowerCAmelCase__		)							,     attrs=["__version__"]		).start()
     patch_submodule(lowerCAmelCase__							,     "xml.etree.ElementTree.parse"							,     wrap_auth(lowerCAmelCase__		)		).start()
     patch_submodule(lowerCAmelCase__							,     "xml.dom.minidom.parse"							,     wrap_auth(lowerCAmelCase__		)		).start()
     UpperCAmelCase__				:			List[str]							=    True



def 				a__			(					lowerCAmelCase						:							"DatasetBuilder"		):






     '''simple docstring'''
     extend_module_for_streaming(builder.__module__							,     use_auth_token=builder.use_auth_token		)
     # if needed, we also have to extend additional internal imports (like wmt14 -> wmt_utils)
     if not builder.__module__.startswith("datasets."		):  # check that it's not a packaged builder like csv
          for imports in get_imports(inspect.getfile(builder.__class__		)		):
               if imports[0] == "internal":
                    UpperCAmelCase__				:			Union[str, Any]							=    imports[1]
                    UpperCAmelCase__				:			Union[str, Any]							=    '.'.join(builder.__module__.split("."		)[:-1] + [internal_import_name]		)
                    extend_module_for_streaming(lowerCAmelCase__							,     use_auth_token=builder.use_auth_token		)

    # builders can inherit from other builders that might use streaming functionality
    # (for example, ImageFolder and AudioFolder inherit from FolderBuilder which implements examples generation)
    # but these parents builders are not patched automatically as they are not instantiated, so we patch them here
     from .builder import DatasetBuilder

     UpperCAmelCase__				:			Optional[int]							=    [
         cls.__module__
         for cls in type(lowerCAmelCase__		).__mro__[1:]  # make sure it's not the same module we've already patched
         if issubclass(cls							,     lowerCAmelCase__		) and cls.__module__ != DatasetBuilder.__module__
     ]  # check it's not a standard builder from datasets.builder
     for module in parent_builder_modules:
          extend_module_for_streaming(lowerCAmelCase__							,     use_auth_token=builder.use_auth_token		)











from ...configuration_utils import PretrainedConfig
from ...utils import logging


A										=      logging.get_logger(__name__)

A										=      {
    'ZinengTang/tvlt-base': 'https://huggingface.co/ZinengTang/tvlt-base/blob/main/config.json',
}


class 				__a				(	__A    ):





		'''simple docstring'''



		UpperCAmelCase__   :					str					     =    """tvlt"""


		def __init__(    self			,     UpperCamelCase__=224			,     UpperCamelCase__=2048			,     UpperCamelCase__=128			,     UpperCamelCase__=[16, 16]			,     UpperCamelCase__=[16, 16]			,     UpperCamelCase__=3			,     UpperCamelCase__=1			,     UpperCamelCase__=8			,     UpperCamelCase__=768			,     UpperCamelCase__=12			,     UpperCamelCase__=12			,     UpperCamelCase__=3072			,     UpperCamelCase__="gelu"			,     UpperCamelCase__=0.0			,     UpperCamelCase__=0.0			,     UpperCamelCase__=0.02			,     UpperCamelCase__=1E-6			,     UpperCamelCase__=True			,     UpperCamelCase__=False			,     UpperCamelCase__=16			,     UpperCamelCase__=512			,     UpperCamelCase__=8			,     UpperCamelCase__=2048			,     UpperCamelCase__=0.75			,     UpperCamelCase__=0.15			,     UpperCamelCase__="frame-level"			,     UpperCamelCase__=True			,     UpperCamelCase__=True			,     UpperCamelCase__="classification"			,     **UpperCamelCase__			,     ):
						super().__init__(**UpperCamelCase__							)

						if audio_mask_type not in ("frame-level", "patch_level"):
										raise ValueError(
										    'audio_mask_type must be one of two acceptable strategies - {\'frame_level\', \'patch-level\') '
										    F'''got {audio_mask_type}'''							)

						SCREAMING_SNAKE_CASE_ :						Tuple    				= image_size
						SCREAMING_SNAKE_CASE_ :						int    				= spectrogram_length
						SCREAMING_SNAKE_CASE_ :						Optional[Any]    				= frequency_length
						SCREAMING_SNAKE_CASE_ :						Any    				= image_patch_size
						SCREAMING_SNAKE_CASE_ :						List[Any]    				= audio_patch_size
						SCREAMING_SNAKE_CASE_ :						int    				= num_image_channels
						SCREAMING_SNAKE_CASE_ :						Any    				= num_audio_channels
						SCREAMING_SNAKE_CASE_ :						Any    				= num_frames

						SCREAMING_SNAKE_CASE_ :						Optional[int]    				= hidden_size
						SCREAMING_SNAKE_CASE_ :						str    				= num_hidden_layers
						SCREAMING_SNAKE_CASE_ :						Optional[Any]    				= num_attention_heads
						SCREAMING_SNAKE_CASE_ :						str    				= intermediate_size
						SCREAMING_SNAKE_CASE_ :						Optional[Any]    				= hidden_act
						SCREAMING_SNAKE_CASE_ :						Optional[int]    				= hidden_dropout_prob
						SCREAMING_SNAKE_CASE_ :						int    				= attention_probs_dropout_prob
						SCREAMING_SNAKE_CASE_ :						Dict    				= initializer_range
						SCREAMING_SNAKE_CASE_ :						Dict    				= layer_norm_eps
						SCREAMING_SNAKE_CASE_ :						Union[str, Any]    				= qkv_bias
						SCREAMING_SNAKE_CASE_ :						List[str]    				= use_mean_pooling

						SCREAMING_SNAKE_CASE_ :						str    				= decoder_num_attention_heads
						SCREAMING_SNAKE_CASE_ :						Optional[int]    				= decoder_hidden_size
						SCREAMING_SNAKE_CASE_ :						Any    				= decoder_num_hidden_layers
						SCREAMING_SNAKE_CASE_ :						List[Any]    				= decoder_intermediate_size
						SCREAMING_SNAKE_CASE_ :						List[str]    				= pixel_mask_ratio
						SCREAMING_SNAKE_CASE_ :						Optional[int]    				= audio_mask_ratio
						SCREAMING_SNAKE_CASE_ :						Optional[Any]    				= audio_mask_type

						SCREAMING_SNAKE_CASE_ :						Any    				= task_matching
						SCREAMING_SNAKE_CASE_ :						Any    				= task_mae
						SCREAMING_SNAKE_CASE_ :						int    				= loss_type