# Lint as: python3
import os
import re
import urllib.parse
from pathlib import Path
from typing import Callable, List, Optional, Union
from zipfile import ZipFile

from ..utils.file_utils import cached_path, hf_github_url
from ..utils.logging import get_logger
from ..utils.version import Version


__a  :     Dict       =  get_logger(__name__)




class    _UpperCamelCase      :


			"""simple docstring"""






			__a  : List[str]			 =						'''dummy_data'''
			__a  : Tuple			 =						'''datasets'''
			__a  : Optional[int]			 =						False





			def __init__(   self      ,   lowerCAmelCase__      ,   lowerCAmelCase__      ,   lowerCAmelCase__      ,   lowerCAmelCase__ = None      ,   lowerCAmelCase__ = False      ,   lowerCAmelCase__ = True      ,   lowerCAmelCase__ = None      ,   )     ->					Dict:

							'''simple docstring'''


							__lowercase 			=							0
							__lowercase 			=							dataset_name
							__lowercase 			=							cache_dir
							__lowercase 			=							use_local_dummy_data
							__lowercase 			=							config
							# download_callbacks take a single url as input
							__lowercase 			=							download_callbacks or []
							# if False, it doesn't load existing files and it returns the paths of the dummy files relative
							# to the dummy_data zip file root
							__lowercase 			=							load_existing_dummy_data

							# TODO(PVP, QL) might need to make this more general
							__lowercase 			=							str(lowerCAmelCase__						)
							# to be downloaded
							__lowercase 			=							None
							__lowercase 			=							None





			@property
			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Dict:

							'''simple docstring'''


							if self._dummy_file is None:
											__lowercase 			=							self.download_dummy_data()
							return self._dummy_file





			@property
			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					int:

							'''simple docstring'''


							if self.config is not None:
											# structure is dummy / config_name / version_name
											return os.path.join('''dummy'''      ,   self.config.name      ,   self.version_name						)
							# structure is dummy / version_name
							return os.path.join('''dummy'''      ,   self.version_name						)





			@property
			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					int:

							'''simple docstring'''


							return os.path.join(self.dummy_data_folder      ,   '''dummy_data.zip'''						)





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					List[str]:

							'''simple docstring'''


							__lowercase 			=							(
							    self.local_path_to_dummy_data if self.use_local_dummy_data is True else self.github_path_to_dummy_data
							)

							__lowercase 			=							cached_path(
							    lowerCAmelCase__      ,   cache_dir=self.cache_dir      ,   extract_compressed_file=lowerCAmelCase__      ,   force_extract=lowerCAmelCase__						)

							return os.path.join(lowerCAmelCase__      ,   self.dummy_file_name						)





			@property
			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Dict:

							'''simple docstring'''


							return os.path.join(self.datasets_scripts_dir      ,   self.dataset_name      ,   self.dummy_zip_file						)





			@property
			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					List[Any]:

							'''simple docstring'''


							if self._bucket_url is None:
											__lowercase 			=							hf_github_url(self.dataset_name      ,   self.dummy_zip_file.replace(os.sep      ,   '''/'''						)						)
							return self._bucket_url





			@property
			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					List[Any]:

							'''simple docstring'''


							if os.path.isdir(self.dummy_file						):
											return self.dummy_file
							# else cut off path to file -> example `xsum`.
							return "/".join(self.dummy_file.replace(os.sep      ,   '''/'''						).split('''/'''						)[:-1]						)





			def        _SCREAMING_SNAKE_CASE			(   self      ,   lowerCAmelCase__      ,   *lowerCAmelCase__						)     ->					Tuple:

							'''simple docstring'''


							if self.load_existing_dummy_data:
											# dummy data is downloaded and tested
											__lowercase 			=							self.dummy_file
							else:
											# dummy data cannot be downloaded and only the path to dummy file is returned
											__lowercase 			=							self.dummy_file_name

							# special case when data_url is a dict
							if isinstance(lowerCAmelCase__      ,   lowerCAmelCase__						):
											return self.create_dummy_data_dict(lowerCAmelCase__      ,   lowerCAmelCase__						)
							elif isinstance(lowerCAmelCase__      ,   (list, tuple)						):
											return self.create_dummy_data_list(lowerCAmelCase__      ,   lowerCAmelCase__						)
							else:
											return self.create_dummy_data_single(lowerCAmelCase__      ,   lowerCAmelCase__						)





			def        _SCREAMING_SNAKE_CASE			(   self      ,   lowerCAmelCase__      ,   *lowerCAmelCase__						)     ->					Union[str, Any]:

							'''simple docstring'''


							return self.download_and_extract(lowerCAmelCase__						)





			def        _SCREAMING_SNAKE_CASE			(   self      ,   lowerCAmelCase__      ,   lowerCAmelCase__						)     ->					List[str]:

							'''simple docstring'''


							return self.download_and_extract(lowerCAmelCase__						)





			def        _SCREAMING_SNAKE_CASE			(   self      ,   lowerCAmelCase__      ,   *lowerCAmelCase__      ,   **lowerCAmelCase__						)     ->					List[Any]:

							'''simple docstring'''


							return path





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					str:

							'''simple docstring'''


							return {}





			def        _SCREAMING_SNAKE_CASE			(   self      ,   lowerCAmelCase__      ,   lowerCAmelCase__						)     ->					Tuple:

							'''simple docstring'''


							__lowercase 			=							{}
							for key, single_urls in data_url.items():
											for download_callback in self.download_callbacks:
															if isinstance(lowerCAmelCase__      ,   lowerCAmelCase__						):
																			for single_url in single_urls:
																							download_callback(lowerCAmelCase__						)
															else:
																			__lowercase 			=							single_urls
																			download_callback(lowerCAmelCase__						)
            # we force the name of each key to be the last file / folder name of the url path
            # if the url has arguments, we need to encode them with urllib.parse.quote_plus
											if isinstance(lowerCAmelCase__      ,   lowerCAmelCase__						):
															__lowercase 			=							[os.path.join(lowerCAmelCase__      ,   urllib.parse.quote_plus(Path(lowerCAmelCase__						).name						)						) for x in single_urls]
											else:
															__lowercase 			=							single_urls
															__lowercase 			=							os.path.join(lowerCAmelCase__      ,   urllib.parse.quote_plus(Path(lowerCAmelCase__						).name						)						)
											__lowercase 			=							value

							# make sure that values are unique
							if all(isinstance(lowerCAmelCase__      ,   lowerCAmelCase__						) for i in dummy_data_dict.values()						) and len(set(dummy_data_dict.values()						)						) < len(
							    dummy_data_dict.values()						):
											# append key to value to make its name unique
											__lowercase 			=							{key: value + key for key, value in dummy_data_dict.items()}

							return dummy_data_dict





			def        _SCREAMING_SNAKE_CASE			(   self      ,   lowerCAmelCase__      ,   lowerCAmelCase__						)     ->					int:

							'''simple docstring'''


							__lowercase 			=							[]
							# trick: if there are many shards named like `data.txt-000001-of-00300`, only use the first one
							__lowercase 			=							all(bool(re.findall('''[0-9]{3,}-of-[0-9]{3,}'''      ,   lowerCAmelCase__						)						) for url in data_url						)
							__lowercase 			=							all(
							    url.startswith('''https://ftp.ncbi.nlm.nih.gov/pubmed/baseline/pubmed'''						) for url in data_url						)
							if data_url and (is_tf_records or is_pubmed_records):
											__lowercase 			=							[data_url[0]] * len(lowerCAmelCase__						)
							for single_url in data_url:
											for download_callback in self.download_callbacks:
															download_callback(lowerCAmelCase__						)
											# we force the name of each key to be the last file / folder name of the url path
											# if the url has arguments, we need to encode them with urllib.parse.quote_plus
											__lowercase 			=							os.path.join(lowerCAmelCase__      ,   urllib.parse.quote_plus(single_url.split('''/'''						)[-1]						)						)
											dummy_data_list.append(lowerCAmelCase__						)
							return dummy_data_list





			def        _SCREAMING_SNAKE_CASE			(   self      ,   lowerCAmelCase__      ,   lowerCAmelCase__						)     ->					Any:

							'''simple docstring'''


							for download_callback in self.download_callbacks:
											download_callback(lowerCAmelCase__						)
							# we force the name of each key to be the last file / folder name of the url path
							# if the url has arguments, we need to encode them with urllib.parse.quote_plus
							__lowercase 			=							os.path.join(lowerCAmelCase__      ,   urllib.parse.quote_plus(data_url.split('''/'''						)[-1]						)						)
							if os.path.exists(lowerCAmelCase__						) or not self.load_existing_dummy_data:
											return value
							else:
											# Backward compatibility, maybe deprecate at one point.
											# For many datasets with single url calls to dl_manager.download_and_extract,
											# the dummy_data.zip file is actually the zipped downloaded file
											# while now we expected the dummy_data.zip file to be a directory containing
											# the downloaded file.
											return path_to_dummy_data





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Tuple:

							'''simple docstring'''


							pass





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Dict:

							'''simple docstring'''


							pass





			def        _SCREAMING_SNAKE_CASE			(   self      ,   lowerCAmelCase__						)     ->					Union[str, Any]:

							'''simple docstring'''


							def _iter_archive_members(lowerCAmelCase__						):
											# this preserves the order of the members inside the ZIP archive
											__lowercase 			=							Path(self.dummy_file						).parent
											__lowercase 			=							path.relative_to(lowerCAmelCase__						)
											with ZipFile(self.local_path_to_dummy_data						) as zip_file:
															__lowercase 			=							zip_file.namelist()
											for member in members:
															if member.startswith(relative_path.as_posix()						):
																			yield dummy_parent_path.joinpath(lowerCAmelCase__						)

							__lowercase 			=							Path(lowerCAmelCase__						)
							__lowercase 			=							_iter_archive_members(lowerCAmelCase__						) if self.use_local_dummy_data else path.rglob('''*'''						)
							for file_path in file_paths:
											if file_path.is_file() and not file_path.name.startswith(('''.''', '''__''')						):
															yield file_path.relative_to(lowerCAmelCase__						).as_posix(), file_path.open('''rb'''						)





			def        _SCREAMING_SNAKE_CASE			(   self      ,   lowerCAmelCase__						)     ->					List[str]:

							'''simple docstring'''


							if not isinstance(lowerCAmelCase__      ,   lowerCAmelCase__						):
											__lowercase 			=							[paths]
							for path in paths:
											if os.path.isfile(lowerCAmelCase__						):
															if os.path.basename(lowerCAmelCase__						).startswith(('''.''', '''__''')						):
																			return
															yield path
											else:
															for dirpath, dirnames, filenames in os.walk(lowerCAmelCase__						):
																			if os.path.basename(lowerCAmelCase__						).startswith(('''.''', '''__''')						):
																							continue
																			dirnames.sort()
																			for filename in sorted(lowerCAmelCase__						):
																							if filename.startswith(('''.''', '''__''')						):
																											continue
																							yield os.path.join(lowerCAmelCase__      ,   lowerCAmelCase__						)
from ...configuration_utils import PretrainedConfig
from ...utils import logging


__a  :     str       =  logging.get_logger(__name__)

__a  :     Optional[int]       =  {
    """google/vivit-b-16x2-kinetics400""": (
        """https://huggingface.co/google/vivit-b-16x2-kinetics400/resolve/main/config.json"""
    ),
    # See all Vivit models at https://huggingface.co/models?filter=vivit
}




class    _UpperCamelCase      (						_UpperCAmelCase ):


			"""simple docstring"""






			__a  : Tuple			 =						'''vivit'''





			def __init__(   self      ,   lowerCAmelCase__=2_24      ,   lowerCAmelCase__=32      ,   lowerCAmelCase__=[2, 16, 16]      ,   lowerCAmelCase__=3      ,   lowerCAmelCase__=7_68      ,   lowerCAmelCase__=12      ,   lowerCAmelCase__=12      ,   lowerCAmelCase__=30_72      ,   lowerCAmelCase__="gelu_fast"      ,   lowerCAmelCase__=0.0      ,   lowerCAmelCase__=0.0      ,   lowerCAmelCase__=0.02      ,   lowerCAmelCase__=1E-06      ,   lowerCAmelCase__=True      ,   **lowerCAmelCase__      ,   )     ->					int:

							'''simple docstring'''


							__lowercase 			=							hidden_size
							__lowercase 			=							num_hidden_layers
							__lowercase 			=							num_attention_heads
							__lowercase 			=							intermediate_size
							__lowercase 			=							hidden_act
							__lowercase 			=							hidden_dropout_prob
							__lowercase 			=							attention_probs_dropout_prob
							__lowercase 			=							initializer_range
							__lowercase 			=							layer_norm_eps

							__lowercase 			=							image_size
							__lowercase 			=							num_frames
							__lowercase 			=							tubelet_size
							__lowercase 			=							num_channels
							__lowercase 			=							qkv_bias

							super().__init__(**lowerCAmelCase__						)