# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


__SCREAMING_SNAKE_CASE						:   int         =			{
    'configuration_vivit': ['VIVIT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'VivitConfig'],
}
try:
				if not is_vision_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__SCREAMING_SNAKE_CASE						:   int         =			['VivitImageProcessor']


try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__SCREAMING_SNAKE_CASE						:   Optional[Any]         =			[
				    'VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'VivitModel',
				    'VivitPreTrainedModel',
				    'VivitForVideoClassification',
				]


if TYPE_CHECKING:
				from .configuration_vivit import VIVIT_PRETRAINED_CONFIG_ARCHIVE_MAP, VivitConfig

				try:
								if not is_vision_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .image_processing_vivit import VivitImageProcessor

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_vivit import (
								    VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST,
								    VivitForVideoClassification,
								    VivitModel,
								    VivitPreTrainedModel,
								)


else:
				import sys

				__SCREAMING_SNAKE_CASE						:   str         =			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
import importlib
import shutil
import threading
import warnings
from typing import List

import fsspec
import fsspec.asyn

from . import compression
from .hffilesystem import HfFileSystem


__SCREAMING_SNAKE_CASE						:   Any         =			importlib.util.find_spec('s3fs') is not None

if _has_safs:
				from .safilesystem import SaFileSystem  # noqa: F401

__SCREAMING_SNAKE_CASE						:   List[compression.BaseCompressedFileFileSystem]         =			[
    compression.BzaFileSystem,
    compression.GzipFileSystem,
    compression.LzaFileSystem,
    compression.XzFileSystem,
    compression.ZstdFileSystem,
]

# Register custom filesystems
for fs_class in COMPRESSION_FILESYSTEMS + [HfFileSystem]:
				if fs_class.protocol in fsspec.registry and fsspec.registry[fs_class.protocol] is not fs_class:
								warnings.warn(F'''A filesystem protocol was already set for {fs_class.protocol} and will be overwritten.''')
				fsspec.register_implementation(fs_class.protocol, fs_class, clobber=True)
def  snake_case						(__lowercase						)	->	str:

						'''simple docstring'''



						if "://" in dataset_path:
												_snake_case						:					Tuple    =   dataset_path.split("://"						)[1]
						return dataset_path
def  snake_case						(__lowercase						)	->	bool:

						'''simple docstring'''



						if fs is not None and fs.protocol != "file":
												return True
						else:
												return False
def  snake_case						(__lowercase ,      __lowercase ,      __lowercase						)	->	str:

						'''simple docstring'''



						_snake_case						:					Optional[int]    =   not is_remote_filesystem(__lowercase						)
						if is_local:
												# LocalFileSystem.mv does copy + rm, it is more efficient to simply move a local directory
												shutil.move(fs._strip_protocol(__lowercase						) ,      fs._strip_protocol(__lowercase						)						)
						else:
												fs.mv(__lowercase ,      __lowercase ,      recursive=__lowercase						)

def  snake_case						()	->	None:

						'''simple docstring'''



						if hasattr(fsspec.asyn ,      "reset_lock"						):
												# for future fsspec>2022.05.0
												fsspec.asyn.reset_lock()
						else:
												_snake_case						:					List[str]    =   None
												_snake_case						:					str    =   None
												_snake_case						:					List[Any]    =   threading.Lock()