


'''simple docstring'''






import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
						from PIL import Image

						from transformers import OwlViTImageProcessor, OwlViTProcessor






@require_vision
class   SCREAMING_SNAKE_CASE_						(			unittest.TestCase		):




			def       _snake_case (   self							)      ->    Dict:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE       :				Dict       =			tempfile.mkdtemp()

								# fmt: off
								__SCREAMING_SNAKE_CASE       :				Dict       =			['', 'l', 'o', 'w', 'e', 'r', 's', 't', 'i', 'd', 'n', 'lo', 'l</w>', 'w</w>', 'r</w>', 't</w>', 'low</w>', 'er</w>', 'lowest</w>', 'newer</w>', 'wider', '<unk>', '<|startoftext|>', '<|endoftext|>']
								# fmt: on
								__SCREAMING_SNAKE_CASE       :				List[Any]       =			dict(zip(_UpperCAmelCase       ,   range(len(_UpperCAmelCase							)							)							)							)
								__SCREAMING_SNAKE_CASE       :				Any       =			['#version: 0.2', 'l o', 'lo w</w>', 'e r</w>', '']
								__SCREAMING_SNAKE_CASE       :				Any       =			{'unk_token': '<unk>'}

								__SCREAMING_SNAKE_CASE       :				Any       =			os.path.join(self.tmpdirname       ,   VOCAB_FILES_NAMES['''vocab_file''']							)
								__SCREAMING_SNAKE_CASE       :				int       =			os.path.join(self.tmpdirname       ,   VOCAB_FILES_NAMES['''merges_file''']							)
								with open(self.vocab_file       ,   '''w'''       ,   encoding='''utf-8'''							) as fp:
													fp.write(json.dumps(_UpperCAmelCase							) + '''\n'''							)
								with open(self.merges_file       ,   '''w'''       ,   encoding='''utf-8'''							) as fp:
													fp.write('''\n'''.join(_UpperCAmelCase							)							)

								__SCREAMING_SNAKE_CASE       :				Any       =			{
								    'do_resize': True,
								    'size': 2_0,
								    'do_center_crop': True,
								    'crop_size': 1_8,
								    'do_normalize': True,
								    'image_mean': [0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3],
								    'image_std': [0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1],
								}
								__SCREAMING_SNAKE_CASE       :				Tuple       =			os.path.join(self.tmpdirname       ,   _UpperCAmelCase							)
								with open(self.image_processor_file       ,   '''w'''       ,   encoding='''utf-8'''							) as fp:
													json.dump(_UpperCAmelCase       ,   _UpperCAmelCase							)




			def       _snake_case (   self       ,   **lowercase							)      ->    List[str]:


								'''simple docstring'''






								return CLIPTokenizer.from_pretrained(self.tmpdirname       ,   pad_token='''!'''       ,   **_UpperCAmelCase							)




			def       _snake_case (   self       ,   **lowercase							)      ->    Dict:


								'''simple docstring'''






								return CLIPTokenizerFast.from_pretrained(self.tmpdirname       ,   pad_token='''!'''       ,   **_UpperCAmelCase							)




			def       _snake_case (   self       ,   **lowercase							)      ->    Dict:


								'''simple docstring'''






								return OwlViTImageProcessor.from_pretrained(self.tmpdirname       ,   **_UpperCAmelCase							)




			def       _snake_case (   self							)      ->    Optional[int]:


								'''simple docstring'''






								shutil.rmtree(self.tmpdirname							)




			def       _snake_case (   self							)      ->    int:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE       :				int       =			[np.random.randint(2_5_5       ,   size=(3, 3_0, 4_0_0)       ,   dtype=np.uinta							)]

								__SCREAMING_SNAKE_CASE       :				Optional[int]       =			[Image.fromarray(np.moveaxis(_UpperCAmelCase       ,   0       ,   -1							)							) for x in image_inputs]

								return image_inputs




			def       _snake_case (   self							)      ->    Optional[int]:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE       :				List[str]       =			self.get_tokenizer()
								__SCREAMING_SNAKE_CASE       :				List[Any]       =			self.get_rust_tokenizer()
								__SCREAMING_SNAKE_CASE       :				Optional[Any]       =			self.get_image_processor()

								__SCREAMING_SNAKE_CASE       :				Tuple       =			OwlViTProcessor(tokenizer=_UpperCAmelCase       ,   image_processor=_UpperCAmelCase							)
								processor_slow.save_pretrained(self.tmpdirname							)
								__SCREAMING_SNAKE_CASE       :				List[str]       =			OwlViTProcessor.from_pretrained(self.tmpdirname       ,   use_fast=_UpperCAmelCase							)

								__SCREAMING_SNAKE_CASE       :				Optional[Any]       =			OwlViTProcessor(tokenizer=_UpperCAmelCase       ,   image_processor=_UpperCAmelCase							)
								processor_fast.save_pretrained(self.tmpdirname							)
								__SCREAMING_SNAKE_CASE       :				List[Any]       =			OwlViTProcessor.from_pretrained(self.tmpdirname							)

								self.assertEqual(processor_slow.tokenizer.get_vocab()       ,   tokenizer_slow.get_vocab()							)
								self.assertEqual(processor_fast.tokenizer.get_vocab()       ,   tokenizer_fast.get_vocab()							)
								self.assertEqual(tokenizer_slow.get_vocab()       ,   tokenizer_fast.get_vocab()							)
								self.assertIsInstance(processor_slow.tokenizer       ,   _UpperCAmelCase							)
								self.assertIsInstance(processor_fast.tokenizer       ,   _UpperCAmelCase							)

								self.assertEqual(processor_slow.image_processor.to_json_string()       ,   image_processor.to_json_string()							)
								self.assertEqual(processor_fast.image_processor.to_json_string()       ,   image_processor.to_json_string()							)
								self.assertIsInstance(processor_slow.image_processor       ,   _UpperCAmelCase							)
								self.assertIsInstance(processor_fast.image_processor       ,   _UpperCAmelCase							)




			def       _snake_case (   self							)      ->    Optional[Any]:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE       :				Tuple       =			OwlViTProcessor(tokenizer=self.get_tokenizer()       ,   image_processor=self.get_image_processor()							)
								processor.save_pretrained(self.tmpdirname							)

								__SCREAMING_SNAKE_CASE       :				Optional[Any]       =			self.get_tokenizer(bos_token='''(BOS)'''       ,   eos_token='''(EOS)'''							)
								__SCREAMING_SNAKE_CASE       :				Dict       =			self.get_image_processor(do_normalize=_UpperCAmelCase							)

								__SCREAMING_SNAKE_CASE       :				Dict       =			OwlViTProcessor.from_pretrained(
								    self.tmpdirname       ,   bos_token='''(BOS)'''       ,   eos_token='''(EOS)'''       ,   do_normalize=_UpperCAmelCase							)

								self.assertEqual(processor.tokenizer.get_vocab()       ,   tokenizer_add_kwargs.get_vocab()							)
								self.assertIsInstance(processor.tokenizer       ,   _UpperCAmelCase							)

								self.assertEqual(processor.image_processor.to_json_string()       ,   image_processor_add_kwargs.to_json_string()							)
								self.assertIsInstance(processor.image_processor       ,   _UpperCAmelCase							)




			def       _snake_case (   self							)      ->    str:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE       :				str       =			self.get_image_processor()
								__SCREAMING_SNAKE_CASE       :				List[Any]       =			self.get_tokenizer()

								__SCREAMING_SNAKE_CASE       :				List[Any]       =			OwlViTProcessor(tokenizer=_UpperCAmelCase       ,   image_processor=_UpperCAmelCase							)

								__SCREAMING_SNAKE_CASE       :				str       =			self.prepare_image_inputs()

								__SCREAMING_SNAKE_CASE       :				Any       =			image_processor(_UpperCAmelCase       ,   return_tensors='''np'''							)
								__SCREAMING_SNAKE_CASE       :				Optional[Any]       =			processor(images=_UpperCAmelCase       ,   return_tensors='''np'''							)

								for key in input_image_proc.keys():
													self.assertAlmostEqual(input_image_proc[key].sum()       ,   input_processor[key].sum()       ,   delta=1e-2							)




			def       _snake_case (   self							)      ->    int:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE       :				List[Any]       =			self.get_image_processor()
								__SCREAMING_SNAKE_CASE       :				Optional[int]       =			self.get_tokenizer()

								__SCREAMING_SNAKE_CASE       :				Optional[Any]       =			OwlViTProcessor(tokenizer=_UpperCAmelCase       ,   image_processor=_UpperCAmelCase							)

								__SCREAMING_SNAKE_CASE       :				Optional[int]       =			'lower newer'

								__SCREAMING_SNAKE_CASE       :				List[str]       =			processor(text=_UpperCAmelCase       ,   return_tensors='''np'''							)

								__SCREAMING_SNAKE_CASE       :				Union[str, Any]       =			tokenizer(_UpperCAmelCase       ,   return_tensors='''np'''							)

								for key in encoded_tok.keys():
													self.assertListEqual(encoded_tok[key][0].tolist()       ,   encoded_processor[key][0].tolist()							)




			def       _snake_case (   self							)      ->    str:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE       :				Optional[Any]       =			self.get_image_processor()
								__SCREAMING_SNAKE_CASE       :				Optional[Any]       =			self.get_tokenizer()

								__SCREAMING_SNAKE_CASE       :				List[str]       =			OwlViTProcessor(tokenizer=_UpperCAmelCase       ,   image_processor=_UpperCAmelCase							)

								__SCREAMING_SNAKE_CASE       :				int       =			'lower newer'
								__SCREAMING_SNAKE_CASE       :				Union[str, Any]       =			self.prepare_image_inputs()

								__SCREAMING_SNAKE_CASE       :				List[str]       =			processor(text=_UpperCAmelCase       ,   images=_UpperCAmelCase							)

								self.assertListEqual(list(inputs.keys()							)       ,   ['''input_ids''', '''attention_mask''', '''pixel_values''']							)

								# test if it raises when no input is passed
								with pytest.raises(_UpperCAmelCase							):
													processor()




			def       _snake_case (   self							)      ->    int:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE       :				Union[str, Any]       =			'google/owlvit-base-patch32'
								__SCREAMING_SNAKE_CASE       :				Any       =			OwlViTProcessor.from_pretrained(_UpperCAmelCase							)

								__SCREAMING_SNAKE_CASE       :				Optional[int]       =			['cat', 'nasa badge']
								__SCREAMING_SNAKE_CASE       :				Optional[int]       =			processor(text=_UpperCAmelCase							)

								__SCREAMING_SNAKE_CASE       :				Union[str, Any]       =			1_6
								self.assertListEqual(list(inputs.keys()							)       ,   ['''input_ids''', '''attention_mask''']							)
								self.assertEqual(inputs['''input_ids'''].shape       ,   (2, seq_length)							)

								# test if it raises when no input is passed
								with pytest.raises(_UpperCAmelCase							):
													processor()




			def       _snake_case (   self							)      ->    Optional[Any]:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE       :				Dict       =			'google/owlvit-base-patch32'
								__SCREAMING_SNAKE_CASE       :				Dict       =			OwlViTProcessor.from_pretrained(_UpperCAmelCase							)

								__SCREAMING_SNAKE_CASE       :				Optional[int]       =			[['cat', 'nasa badge'], ['person']]
								__SCREAMING_SNAKE_CASE       :				List[Any]       =			processor(text=_UpperCAmelCase							)

								__SCREAMING_SNAKE_CASE       :				List[str]       =			1_6
								__SCREAMING_SNAKE_CASE       :				Tuple       =			len(_UpperCAmelCase							)
								__SCREAMING_SNAKE_CASE       :				Union[str, Any]       =			max([len(_UpperCAmelCase							) for texts in input_texts]							)

								self.assertListEqual(list(inputs.keys()							)       ,   ['''input_ids''', '''attention_mask''']							)
								self.assertEqual(inputs['''input_ids'''].shape       ,   (batch_size * num_max_text_queries, seq_length)							)

								# test if it raises when no input is passed
								with pytest.raises(_UpperCAmelCase							):
													processor()




			def       _snake_case (   self							)      ->    int:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE       :				Any       =			'google/owlvit-base-patch32'
								__SCREAMING_SNAKE_CASE       :				List[Any]       =			OwlViTProcessor.from_pretrained(_UpperCAmelCase							)

								__SCREAMING_SNAKE_CASE       :				int       =			['cat', 'nasa badge']
								__SCREAMING_SNAKE_CASE       :				str       =			processor(text=_UpperCAmelCase							)

								__SCREAMING_SNAKE_CASE       :				Union[str, Any]       =			1_6
								__SCREAMING_SNAKE_CASE       :				Any       =			inputs['input_ids']
								__SCREAMING_SNAKE_CASE       :				List[Any]       =			[
								    [4_9_4_0_6, 2_3_6_8, 4_9_4_0_7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
								    [4_9_4_0_6, 6_8_4_1, 1_1_3_0_1, 4_9_4_0_7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
								]

								self.assertListEqual(list(inputs.keys()							)       ,   ['''input_ids''', '''attention_mask''']							)
								self.assertEqual(inputs['''input_ids'''].shape       ,   (2, seq_length)							)
								self.assertListEqual(list(input_ids[0]							)       ,   predicted_ids[0]							)
								self.assertListEqual(list(input_ids[1]							)       ,   predicted_ids[1]							)




			def       _snake_case (   self							)      ->    Optional[int]:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE       :				List[Any]       =			self.get_image_processor()
								__SCREAMING_SNAKE_CASE       :				Optional[int]       =			self.get_tokenizer()

								__SCREAMING_SNAKE_CASE       :				Union[str, Any]       =			OwlViTProcessor(tokenizer=_UpperCAmelCase       ,   image_processor=_UpperCAmelCase							)

								__SCREAMING_SNAKE_CASE       :				Any       =			self.prepare_image_inputs()
								__SCREAMING_SNAKE_CASE       :				Optional[int]       =			self.prepare_image_inputs()

								__SCREAMING_SNAKE_CASE       :				Union[str, Any]       =			processor(images=_UpperCAmelCase       ,   query_images=_UpperCAmelCase							)

								self.assertListEqual(list(inputs.keys()							)       ,   ['''query_pixel_values''', '''pixel_values''']							)

								# test if it raises when no input is passed
								with pytest.raises(_UpperCAmelCase							):
													processor()




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


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE       :				Dict       =			self.get_image_processor()
								__SCREAMING_SNAKE_CASE       :				Optional[Any]       =			self.get_tokenizer()

								__SCREAMING_SNAKE_CASE       :				Optional[Any]       =			OwlViTProcessor(tokenizer=_UpperCAmelCase       ,   image_processor=_UpperCAmelCase							)

								__SCREAMING_SNAKE_CASE       :				Dict       =			[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

								__SCREAMING_SNAKE_CASE       :				Optional[Any]       =			processor.batch_decode(_UpperCAmelCase							)
								__SCREAMING_SNAKE_CASE       :				List[str]       =			tokenizer.batch_decode(_UpperCAmelCase							)

								self.assertListEqual(_UpperCAmelCase       ,   _UpperCAmelCase							)







'''simple docstring'''

# 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


__lowerCAmelCase		     =  get_logger(__name__)

class       __magic_name__		:
							lowerCAmelCase			:       Optional[Any]  							=   'dummy_data'
							lowerCAmelCase			:       List[str]  							=   'datasets'
							lowerCAmelCase			:       str  							=   False







							def __init__(				self   :			Tuple      ,_UpperCAmelCase   :			str      ,_UpperCAmelCase   :			str      ,_UpperCAmelCase   :			Union[Version, str]      ,_UpperCAmelCase   :			Optional[str] = None      ,_UpperCAmelCase   :			bool = False      ,_UpperCAmelCase   :			bool = True      ,_UpperCAmelCase   :			Optional[List[Callable]] = None      ,):
									_a	: int								=				0
									_a	: str								=				dataset_name
									_a	: Optional[int]								=				cache_dir
									_a	: int								=				use_local_dummy_data
									_a	: Optional[int]								=				config
									# download_callbacks take a single url as input
									_a	: List[Callable]								=				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
									_a	: str								=				load_existing_dummy_data

									# TODO(PVP, QL) might need to make this more general
									_a	: Optional[int]								=				str(_UpperCAmelCase						)
									# to be downloaded
									_a	: Union[str, Any]								=				None
									_a	: Dict								=				None







							@property
							def 				__lowercase     (				self   :			Any						):
									if self._dummy_file is None:
											_a	: Dict								=				self.download_dummy_data()
									return self._dummy_file







							@property
							def 				__lowercase     (				self   :			Optional[int]						):
									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 				__lowercase     (				self   :			Any						):
									return os.path.join(self.dummy_data_folder      ,'dummy_data.zip'						)







							def 				__lowercase     (				self   :			List[str]						):
									_a	: Dict								=				(
									    self.local_path_to_dummy_data if self.use_local_dummy_data is True else self.github_path_to_dummy_data
									)

									_a	: Dict								=				cached_path(
									    _UpperCAmelCase      ,cache_dir=self.cache_dir      ,extract_compressed_file=_UpperCAmelCase      ,force_extract=_UpperCAmelCase						)

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







							@property
							def 				__lowercase     (				self   :			List[str]						):
									return os.path.join(self.datasets_scripts_dir      ,self.dataset_name      ,self.dummy_zip_file						)







							@property
							def 				__lowercase     (				self   :			Optional[Any]						):
									if self._bucket_url is None:
											_a	: Any								=				hf_github_url(self.dataset_name      ,self.dummy_zip_file.replace(os.sep      ,'/'						)						)
									return self._bucket_url







							@property
							def 				__lowercase     (				self   :			int						):
									# return full path if its a dir
									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 				__lowercase     (				self   :			Dict      ,_UpperCAmelCase   :			str      ,*_UpperCAmelCase   :			int						):
									if self.load_existing_dummy_data:
											# dummy data is downloaded and tested
											_a	: List[Any]								=				self.dummy_file
									else:
											# dummy data cannot be downloaded and only the path to dummy file is returned
											_a	: str								=				self.dummy_file_name

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







							def 				__lowercase     (				self   :			List[str]      ,_UpperCAmelCase   :			Optional[int]      ,*_UpperCAmelCase   :			Optional[int]						):
									return self.download_and_extract(_UpperCAmelCase						)







							def 				__lowercase     (				self   :			Tuple      ,_UpperCAmelCase   :			List[Any]      ,_UpperCAmelCase   :			Optional[Any]						):
									return self.download_and_extract(_UpperCAmelCase						)







							def 				__lowercase     (				self   :			List[str]      ,_UpperCAmelCase   :			List[str]      ,*_UpperCAmelCase   :			int      ,**_UpperCAmelCase   :			Dict						):
									return path







							def 				__lowercase     (				self   :			Optional[Any]						):
									return {}







							def 				__lowercase     (				self   :			Optional[Any]      ,_UpperCAmelCase   :			List[Any]      ,_UpperCAmelCase   :			str						):
									_a	: int								=				{}
									for key, single_urls in data_url.items():
											for download_callback in self.download_callbacks:
													if isinstance(_UpperCAmelCase      ,_UpperCAmelCase						):
															for single_url in single_urls:
																	download_callback(_UpperCAmelCase						)
													else:
															_a	: Union[str, Any]								=				single_urls
															download_callback(_UpperCAmelCase						)
            # 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(_UpperCAmelCase      ,_UpperCAmelCase						):
													_a	: Optional[int]								=				[os.path.join(_UpperCAmelCase      ,urllib.parse.quote_plus(Path(_UpperCAmelCase						).name						)						) for x in single_urls]
											else:
													_a	: Tuple								=				single_urls
													_a	: Optional[Any]								=				os.path.join(_UpperCAmelCase      ,urllib.parse.quote_plus(Path(_UpperCAmelCase						).name						)						)
											_a	: Union[str, Any]								=				value

									# make sure that values are unique
									if all(isinstance(_UpperCAmelCase      ,_UpperCAmelCase						) 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
											_a	: Dict								=				{key: value + key for key, value in dummy_data_dict.items()}

									return dummy_data_dict







							def 				__lowercase     (				self   :			List[Any]      ,_UpperCAmelCase   :			List[str]      ,_UpperCAmelCase   :			List[str]						):
									_a	: str								=				[]
									# trick: if there are many shards named like `data.txt-000001-of-00300`, only use the first one
									_a	: Tuple								=				all(bool(re.findall('[0-9]{3,}-of-[0-9]{3,}'      ,_UpperCAmelCase						)						) for url in data_url						)
									_a	: str								=				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):
											_a	: str								=				[data_url[0]] * len(_UpperCAmelCase						)
									for single_url in data_url:
											for download_callback in self.download_callbacks:
													download_callback(_UpperCAmelCase						)
											# 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
											_a	: List[Any]								=				os.path.join(_UpperCAmelCase      ,urllib.parse.quote_plus(single_url.split('/'						)[-1]						)						)
											dummy_data_list.append(_UpperCAmelCase						)
									return dummy_data_list







							def 				__lowercase     (				self   :			List[Any]      ,_UpperCAmelCase   :			Union[str, Any]      ,_UpperCAmelCase   :			List[str]						):
									for download_callback in self.download_callbacks:
											download_callback(_UpperCAmelCase						)
									# 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
									_a	: List[Any]								=				os.path.join(_UpperCAmelCase      ,urllib.parse.quote_plus(data_url.split('/'						)[-1]						)						)
									if os.path.exists(_UpperCAmelCase						) 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 				__lowercase     (				self   :			Tuple						):
									pass







							def 				__lowercase     (				self   :			Optional[int]						):
									pass







							def 				__lowercase     (				self   :			List[str]      ,_UpperCAmelCase   :			Dict						):
									def _iter_archive_members(_UpperCAmelCase   :			List[Any]						):
											# this preserves the order of the members inside the ZIP archive
											_a	: int								=				Path(self.dummy_file						).parent
											_a	: List[str]								=				path.relative_to(_UpperCAmelCase						)
											with ZipFile(self.local_path_to_dummy_data						) as zip_file:
													_a	: List[Any]								=				zip_file.namelist()
											for member in members:
													if member.startswith(relative_path.as_posix()						):
															yield dummy_parent_path.joinpath(_UpperCAmelCase						)

									_a	: Dict								=				Path(_UpperCAmelCase						)
									_a	: Dict								=				_iter_archive_members(_UpperCAmelCase						) 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(_UpperCAmelCase						).as_posix(), file_path.open('rb'						)







							def 				__lowercase     (				self   :			Any      ,_UpperCAmelCase   :			Union[str, Any]						):
									if not isinstance(_UpperCAmelCase      ,_UpperCAmelCase						):
											_a	: str								=				[paths]
									for path in paths:
											if os.path.isfile(_UpperCAmelCase						):
													if os.path.basename(_UpperCAmelCase						).startswith(('.', '__')						):
															return
													yield path
											else:
													for dirpath, dirnames, filenames in os.walk(_UpperCAmelCase						):
															if os.path.basename(_UpperCAmelCase						).startswith(('.', '__')						):
																	continue
															dirnames.sort()
															for filename in sorted(_UpperCAmelCase						):
																	if filename.startswith(('.', '__')						):
																			continue
																	yield os.path.join(_UpperCAmelCase      ,_UpperCAmelCase						)




