



import os
import tempfile
from pathlib import Path
from unittest import TestCase

import pyarrow as pa
import pytest

from datasets.arrow_dataset import Dataset
from datasets.arrow_reader import ArrowReader, BaseReader, FileInstructions, ReadInstruction, make_file_instructions
from datasets.info import DatasetInfo
from datasets.splits import NamedSplit, Split, SplitDict, SplitInfo

from .utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases







class 			snake_case__(							__lowerCamelCase							):







						'''simple docstring'''




						def   lowercase_	(			self				,  __lowercase				,  __lowercase=False							)   ->      Tuple:
										lowerCAmelCase_			,					lowerCAmelCase_			,					lowerCAmelCase_	: str      			=			(
										    filename_skip_take['''filename'''],
										    filename_skip_take['''skip'''] if '''skip''' in filename_skip_take else None,
										    filename_skip_take['''take'''] if '''take''' in filename_skip_take else None,
										)
										open(os.path.join(_UpperCamelCase							)				,  '''wb'''							).close()
										lowerCAmelCase_	: Union[str, Any]      			=			pa.Table.from_pydict({'''filename''': [Path(_UpperCamelCase							).name] * 1_0_0}							)
										if take == -1:
														lowerCAmelCase_	: int      			=			len(_UpperCamelCase							) - skip
										if skip is not None and take is not None:
														lowerCAmelCase_	: List[str]      			=			pa_table.slice(_UpperCamelCase				,  _UpperCamelCase							)
										return pa_table







class 			snake_case__(							__lowerCamelCase							):







						'''simple docstring'''




						def   lowercase_	(			self							)   ->      Any:
										lowerCAmelCase_	: str      			=			'''my_name'''
										lowerCAmelCase_	: str      			=			SplitInfo(name='''train'''				,  num_examples=1_0_0							)
										lowerCAmelCase_	: Any      			=			SplitInfo(name='''test'''				,  num_examples=1_0_0							)
										lowerCAmelCase_	: int      			=			[train_info, test_info]
										lowerCAmelCase_	: Dict      			=			SplitDict()
										split_dict.add(_UpperCamelCase							)
										split_dict.add(_UpperCamelCase							)
										lowerCAmelCase_	: Optional[Any]      			=			DatasetInfo(splits=_UpperCamelCase							)

										with tempfile.TemporaryDirectory() as tmp_dir:
														lowerCAmelCase_	: Union[str, Any]      			=			ReaderTest(_UpperCamelCase				,  _UpperCamelCase							)

														lowerCAmelCase_	: List[Any]      			=			'''test[:33%]'''
														lowerCAmelCase_	: List[Any]      			=			Dataset(**reader.read(_UpperCamelCase				,  _UpperCamelCase				,  _UpperCamelCase							)							)
														self.assertEqual(dset['''filename'''][0]				,  f"""{name}-test"""							)
														self.assertEqual(dset.num_rows				,  3_3							)
														self.assertEqual(dset.num_columns				,  1							)

														lowerCAmelCase_	: Union[str, Any]      			=			['''train''', '''test[:33%]''']
														lowerCAmelCase_	: Optional[Any]      			=			[Split.TRAIN, ReadInstruction.from_spec('''test[:33%]'''							)]
														for instructions in [instructionsa, instructionsa]:
																		lowerCAmelCase_	: str      			=			[reader.read(_UpperCamelCase				,  _UpperCamelCase				,  _UpperCamelCase							) for instr in instructions]
																		lowerCAmelCase_			,					lowerCAmelCase_	: List[Any]      			=			(Dataset(**_UpperCamelCase							) for dataset_kwargs in datasets_kwargs)
																		self.assertEqual(train_dset['''filename'''][0]				,  f"""{name}-train"""							)
																		self.assertEqual(train_dset.num_rows				,  1_0_0							)
																		self.assertEqual(train_dset.num_columns				,  1							)
																		self.assertIsInstance(train_dset.split				,  _UpperCamelCase							)
																		self.assertEqual(str(train_dset.split							)				,  '''train'''							)
																		self.assertEqual(test_dset['''filename'''][0]				,  f"""{name}-test"""							)
																		self.assertEqual(test_dset.num_rows				,  3_3							)
																		self.assertEqual(test_dset.num_columns				,  1							)
																		self.assertIsInstance(test_dset.split				,  _UpperCamelCase							)
																		self.assertEqual(str(test_dset.split							)				,  '''test[:33%]'''							)
																		del train_dset, test_dset




						def   lowercase_	(			self							)   ->      str:
										lowerCAmelCase_	: List[str]      			=			'''my_name'''
										lowerCAmelCase_	: Any      			=			SplitInfo(name='''train'''				,  num_examples=1_0_0_0				,  shard_lengths=[1_0_0] * 1_0							)
										lowerCAmelCase_	: Dict      			=			[train_info]
										lowerCAmelCase_	: List[str]      			=			SplitDict()
										split_dict.add(_UpperCamelCase							)
										lowerCAmelCase_	: Tuple      			=			DatasetInfo(splits=_UpperCamelCase							)

										with tempfile.TemporaryDirectory() as tmp_dir:
														lowerCAmelCase_	: Union[str, Any]      			=			ReaderTest(_UpperCamelCase				,  _UpperCamelCase							)

														lowerCAmelCase_	: str      			=			'''train[:33%]'''
														lowerCAmelCase_	: str      			=			Dataset(**reader.read(_UpperCamelCase				,  _UpperCamelCase				,  _UpperCamelCase							)							)
														self.assertEqual(dset['''filename'''][0]				,  f"""{name}-train-00000-of-00010"""							)
														self.assertEqual(dset['''filename'''][-1]				,  f"""{name}-train-00003-of-00010"""							)
														self.assertEqual(dset.num_rows				,  3_3_0							)
														self.assertEqual(dset.num_columns				,  1							)




						def   lowercase_	(			self							)   ->      Union[str, Any]:
										lowerCAmelCase_	: int      			=			SplitInfo(name='''train'''				,  num_examples=1_0_0							)
										lowerCAmelCase_	: Any      			=			SplitInfo(name='''test'''				,  num_examples=1_0_0							)
										lowerCAmelCase_	: Optional[int]      			=			SplitDict()
										split_dict.add(_UpperCamelCase							)
										split_dict.add(_UpperCamelCase							)
										lowerCAmelCase_	: Dict      			=			DatasetInfo(splits=_UpperCamelCase							)

										with tempfile.TemporaryDirectory() as tmp_dir:
														lowerCAmelCase_	: int      			=			ReaderTest(_UpperCamelCase				,  _UpperCamelCase							)

														lowerCAmelCase_	: List[str]      			=			[
														    {'''filename''': os.path.join(_UpperCamelCase				,  '''train'''							)},
														    {'''filename''': os.path.join(_UpperCamelCase				,  '''test'''							), '''skip''': 1_0, '''take''': 1_0},
														]
														lowerCAmelCase_	: int      			=			Dataset(**reader.read_files(_UpperCamelCase				,  original_instructions='''train+test[10:20]'''							)							)
														self.assertEqual(dset.num_rows				,  1_1_0							)
														self.assertEqual(dset.num_columns				,  1							)
														del dset






@pytest.mark.parametrize('''in_memory'''	,				[False, True]	)
def      lowerCAmelCase	(						lowerCAmelCase_	,				lowerCAmelCase_	,				lowerCAmelCase_	)->	List[Any]:
				lowerCAmelCase_	: int      			=			arrow_file
				with assert_arrow_memory_increases() if in_memory else assert_arrow_memory_doesnt_increase():
								lowerCAmelCase_	: List[str]      			=			ArrowReader.read_table(__UpperCamelCase	,				in_memory=__UpperCamelCase	)
				assert table.shape == dataset.data.shape
				assert set(table.column_names	) == set(dataset.data.column_names	)
				assert dict(table.to_pydict()	) == dict(dataset.data.to_pydict()	)  # to_pydict returns OrderedDict



@pytest.mark.parametrize('''in_memory'''	,				[False, True]	)
def      lowerCAmelCase	(						lowerCAmelCase_	,				lowerCAmelCase_	,				lowerCAmelCase_	)->	List[str]:
				lowerCAmelCase_	: List[str]      			=			arrow_file
				lowerCAmelCase_	: Optional[int]      			=			ArrowReader(''''''	,				__UpperCamelCase	)
				with assert_arrow_memory_increases() if in_memory else assert_arrow_memory_doesnt_increase():
								lowerCAmelCase_	: Optional[Any]      			=			reader.read_files([{'''filename''': filename}]	,				in_memory=__UpperCamelCase	)
				assert dataset_kwargs.keys() == {"arrow_table", "info", "split"}
				lowerCAmelCase_	: Union[str, Any]      			=			dataset_kwargs['''arrow_table''']
				assert table.shape == dataset.data.shape
				assert set(table.column_names	) == set(dataset.data.column_names	)
				assert dict(table.to_pydict()	) == dict(dataset.data.to_pydict()	)  # to_pydict returns OrderedDict



def      lowerCAmelCase	(						)->	Any:
				assert ReadInstruction('''train'''	,				to=10	,				unit='''abs'''	).to_spec() == "train[:10]"
				assert ReadInstruction('''train'''	,				from_=-80	,				to=10	,				unit='''%'''	).to_spec() == "train[-80%:10%]"

				lowerCAmelCase_	: Union[str, Any]      			=			'''train+test'''
				assert ReadInstruction.from_spec(__UpperCamelCase	).to_spec() == spec_train_test

				lowerCAmelCase_	: Union[str, Any]      			=			'''train[2:10]'''
				assert ReadInstruction.from_spec(__UpperCamelCase	).to_spec() == spec_train_abs

				lowerCAmelCase_	: Tuple      			=			'''train[15%:-20%]'''
				assert ReadInstruction.from_spec(__UpperCamelCase	).to_spec() == spec_train_pct

				lowerCAmelCase_	: Dict      			=			'''train[:10%](closest)'''
				assert ReadInstruction.from_spec(__UpperCamelCase	).to_spec() == "train[:10%]"

				lowerCAmelCase_	: Tuple      			=			'''train[:10%](pct1_dropremainder)'''
				assert ReadInstruction.from_spec(__UpperCamelCase	).to_spec() == spec_train_pct_rounding

				lowerCAmelCase_	: Optional[Any]      			=			'''train[:10%](pct1_dropremainder)+test[-10%:](pct1_dropremainder)'''
				assert ReadInstruction.from_spec(__UpperCamelCase	).to_spec() == spec_train_test_pct_rounding



def      lowerCAmelCase	(						)->	Optional[int]:
				lowerCAmelCase_	: Union[str, Any]      			=			'''dummy'''
				lowerCAmelCase_	: Optional[Any]      			=			[SplitInfo(name='''train'''	,				num_examples=100	)]
				lowerCAmelCase_	: int      			=			'''train[:33%]'''
				lowerCAmelCase_	: Optional[int]      			=			'''arrow'''
				lowerCAmelCase_	: Tuple      			=			'''prefix'''

				lowerCAmelCase_	: str      			=			make_file_instructions(__UpperCamelCase	,				__UpperCamelCase	,				__UpperCamelCase	,				__UpperCamelCase	,				__UpperCamelCase	)
				assert isinstance(__UpperCamelCase	,				__UpperCamelCase	)
				assert file_instructions.num_examples == 33
				assert file_instructions.file_instructions == [
				    {"filename": os.path.join(__UpperCamelCase	,				f"""{name}-train.arrow"""	), "skip": 0, "take": 33}
				]

				lowerCAmelCase_	: Any      			=			[SplitInfo(name='''train'''	,				num_examples=100	,				shard_lengths=[10] * 10	)]
				lowerCAmelCase_	: List[Any]      			=			make_file_instructions(__UpperCamelCase	,				__UpperCamelCase	,				__UpperCamelCase	,				__UpperCamelCase	,				__UpperCamelCase	)
				assert isinstance(__UpperCamelCase	,				__UpperCamelCase	)
				assert file_instructions.num_examples == 33
				assert file_instructions.file_instructions == [
				    {"filename": os.path.join(__UpperCamelCase	,				f"""{name}-train-00000-of-00010.arrow"""	), "skip": 0, "take": -1},
				    {"filename": os.path.join(__UpperCamelCase	,				f"""{name}-train-00001-of-00010.arrow"""	), "skip": 0, "take": -1},
				    {"filename": os.path.join(__UpperCamelCase	,				f"""{name}-train-00002-of-00010.arrow"""	), "skip": 0, "take": -1},
				    {"filename": os.path.join(__UpperCamelCase	,				f"""{name}-train-00003-of-00010.arrow"""	), "skip": 0, "take": 3},
				]




@pytest.mark.parametrize('''name, expected_exception'''	,				[(None, TypeError), ('''''', ValueError)]	)
def      lowerCAmelCase	(						lowerCAmelCase_	,				lowerCAmelCase_	)->	Any:
				lowerCAmelCase_	: str      			=			[SplitInfo(name='''train'''	,				num_examples=100	)]
				lowerCAmelCase_	: Optional[int]      			=			'''train'''
				lowerCAmelCase_	: List[Any]      			=			'''arrow'''
				lowerCAmelCase_	: Dict      			=			'''prefix_path'''
				with pytest.raises(__UpperCamelCase	):
								lowerCAmelCase_	: Optional[int]      			=			make_file_instructions(__UpperCamelCase	,				__UpperCamelCase	,				__UpperCamelCase	,				__UpperCamelCase	,				__UpperCamelCase	)



from ..utils import DummyObject, requires_backends







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					int   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Tuple   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      int:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Any   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Any:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      int:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Union[str, Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Union[str, Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Tuple   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      str:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					str   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      int:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[int]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Any:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Union[str, Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[str]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Optional[Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      str:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      int:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Dict:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Union[str, Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Optional[int]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					int   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      int:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					int   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      int:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[int]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Dict:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Tuple   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      int:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Union[str, Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Union[str, Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Union[str, Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Optional[int]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					int   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Union[str, Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Union[str, Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					int   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Any:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					str   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Union[str, Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Union[str, Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Tuple:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[int]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Dict:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Tuple:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Dict   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[str]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Dict   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Union[str, Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					str   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      str:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Any   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Any:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Dict   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[str]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[str]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					int   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Tuple:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Dict   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					str   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Any:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Union[str, Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      int:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Tuple:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[str]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					int   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					str   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Optional[int]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Union[str, Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      str:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					int   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      str:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Tuple   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Any:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Dict   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      str:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[str]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Optional[Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[str]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[str]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Any   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Tuple:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[int]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Optional[int]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Dict   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Tuple:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Tuple   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Any:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					str   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      int:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[str]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Optional[int]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Union[str, Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[str]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					int   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Optional[Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[str]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Tuple:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					str   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Dict:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Tuple:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      int:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[str]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Dict   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Any:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Optional[int]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[str]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      int:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Union[str, Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Union[str, Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					int   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[str]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[str]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Any:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Optional[int]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					Tuple   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      List[Any]:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					int   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Dict:
										requires_backends(self				,  ['''vision''']							)







class 			snake_case__(							metaclass=UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__ :					List[Any]   =							["""vision"""]




						def __init__(			self				,  *__lowercase				,  **__lowercase							)   ->      Optional[Any]:
										requires_backends(self				,  ['''vision''']							)