
'''simple docstring'''







import io
import json

import fsspec
import pytest

from datasets import Dataset, DatasetDict, Features, NamedSplit, Value
from datasets.io.json import JsonDatasetReader, JsonDatasetWriter

from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases



def 			_a		(	_SCREAMING_SNAKE_CASE		:   str	,			_SCREAMING_SNAKE_CASE		:   Union[str, Any]  ):
						assert isinstance(_SCREAMING_SNAKE_CASE	,			_SCREAMING_SNAKE_CASE  )
						assert dataset.num_rows == 4
						assert dataset.num_columns == 3
						assert dataset.column_names == ["col_1", "col_2", "col_3"]
						for feature, expected_dtype in expected_features.items():
												assert dataset.features[feature].dtype == expected_dtype



@pytest.mark.parametrize("keep_in_memory"	,			[False, True]  )
def 			_a		(	_SCREAMING_SNAKE_CASE		:   Tuple	,			_SCREAMING_SNAKE_CASE		:   int	,			_SCREAMING_SNAKE_CASE		:   Optional[int]  ):
						_SCREAMING_SNAKE_CASE				= tmp_path / "cache"
						_SCREAMING_SNAKE_CASE				= {"col_1": "string", "col_2": "int64", "col_3": "float64"}
						with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
												_SCREAMING_SNAKE_CASE				= JsonDatasetReader(_SCREAMING_SNAKE_CASE	,			cache_dir=_SCREAMING_SNAKE_CASE	,			keep_in_memory=_SCREAMING_SNAKE_CASE  ).read()
						_check_json_dataset(_SCREAMING_SNAKE_CASE	,			_SCREAMING_SNAKE_CASE  )



@pytest.mark.parametrize(
    "features"	,			[
        None,
        {"col_1": "string", "col_2": "int64", "col_3": "float64"},
        {"col_1": "string", "col_2": "string", "col_3": "string"},
        {"col_1": "int32", "col_2": "int32", "col_3": "int32"},
        {"col_1": "float32", "col_2": "float32", "col_3": "float32"},
    ]	,			)
def 			_a		(	_SCREAMING_SNAKE_CASE		:   List[Any]	,			_SCREAMING_SNAKE_CASE		:   int	,			_SCREAMING_SNAKE_CASE		:   Dict  ):
						_SCREAMING_SNAKE_CASE				= tmp_path / "cache"
						_SCREAMING_SNAKE_CASE				= {"col_1": "string", "col_2": "int64", "col_3": "float64"}
						_SCREAMING_SNAKE_CASE				= features.copy() if features else default_expected_features
						_SCREAMING_SNAKE_CASE				= (
						    Features({feature: Value(_SCREAMING_SNAKE_CASE  ) for feature, dtype in features.items()}  ) if features is not None else None
						)
						_SCREAMING_SNAKE_CASE				= JsonDatasetReader(_SCREAMING_SNAKE_CASE	,			features=_SCREAMING_SNAKE_CASE	,			cache_dir=_SCREAMING_SNAKE_CASE  ).read()
						_check_json_dataset(_SCREAMING_SNAKE_CASE	,			_SCREAMING_SNAKE_CASE  )



@pytest.mark.parametrize(
    "features"	,			[
        None,
        {"col_3": "float64", "col_1": "string", "col_2": "int64"},
    ]	,			)
def 			_a		(	_SCREAMING_SNAKE_CASE		:   List[Any]	,			_SCREAMING_SNAKE_CASE		:   Optional[int]	,			_SCREAMING_SNAKE_CASE		:   Any  ):
						_SCREAMING_SNAKE_CASE				= tmp_path / "cache"
						_SCREAMING_SNAKE_CASE				= {"col_3": "float64", "col_1": "string", "col_2": "int64"}
						_SCREAMING_SNAKE_CASE				= features.copy() if features else default_expected_features
						_SCREAMING_SNAKE_CASE				= (
						    Features({feature: Value(_SCREAMING_SNAKE_CASE  ) for feature, dtype in features.items()}  ) if features is not None else None
						)
						_SCREAMING_SNAKE_CASE				= JsonDatasetReader(_SCREAMING_SNAKE_CASE	,			features=_SCREAMING_SNAKE_CASE	,			cache_dir=_SCREAMING_SNAKE_CASE  ).read()
						assert isinstance(_SCREAMING_SNAKE_CASE	,			_SCREAMING_SNAKE_CASE  )
						assert dataset.num_rows == 2
						assert dataset.num_columns == 3
						assert dataset.column_names == ["col_3", "col_1", "col_2"]
						for feature, expected_dtype in expected_features.items():
												assert dataset.features[feature].dtype == expected_dtype



def 			_a		(	_SCREAMING_SNAKE_CASE		:   Any	,			_SCREAMING_SNAKE_CASE		:   Optional[int]  ):
						_SCREAMING_SNAKE_CASE				= {"col_2": "int64", "col_3": "float64", "col_1": "string"}
						_SCREAMING_SNAKE_CASE				= features.copy()
						_SCREAMING_SNAKE_CASE				= (
						    Features({feature: Value(_SCREAMING_SNAKE_CASE  ) for feature, dtype in features.items()}  ) if features is not None else None
						)
						_SCREAMING_SNAKE_CASE				= tmp_path / "cache"
						_SCREAMING_SNAKE_CASE				= JsonDatasetReader(_SCREAMING_SNAKE_CASE	,			features=_SCREAMING_SNAKE_CASE	,			cache_dir=_SCREAMING_SNAKE_CASE  ).read()
						assert isinstance(_SCREAMING_SNAKE_CASE	,			_SCREAMING_SNAKE_CASE  )
						assert dataset.num_rows == 2
						assert dataset.num_columns == 3
						assert dataset.column_names == ["col_2", "col_3", "col_1"]
						for feature, expected_dtype in expected_features.items():
												assert dataset.features[feature].dtype == expected_dtype



@pytest.mark.parametrize("split"	,			[None, NamedSplit("train"  ), "train", "test"]  )
def 			_a		(	_SCREAMING_SNAKE_CASE		:   List[Any]	,			_SCREAMING_SNAKE_CASE		:   Optional[Any]	,			_SCREAMING_SNAKE_CASE		:   Union[str, Any]  ):
						_SCREAMING_SNAKE_CASE				= tmp_path / "cache"
						_SCREAMING_SNAKE_CASE				= {"col_1": "string", "col_2": "int64", "col_3": "float64"}
						_SCREAMING_SNAKE_CASE				= JsonDatasetReader(_SCREAMING_SNAKE_CASE	,			cache_dir=_SCREAMING_SNAKE_CASE	,			split=_SCREAMING_SNAKE_CASE  ).read()
						_check_json_dataset(_SCREAMING_SNAKE_CASE	,			_SCREAMING_SNAKE_CASE  )
						assert dataset.split == split if split else "train"



@pytest.mark.parametrize("path_type"	,			[str, list]  )
def 			_a		(	_SCREAMING_SNAKE_CASE		:   Any	,			_SCREAMING_SNAKE_CASE		:   List[str]	,			_SCREAMING_SNAKE_CASE		:   Optional[int]  ):




						if issubclass(_SCREAMING_SNAKE_CASE	,			_SCREAMING_SNAKE_CASE  ):
												_SCREAMING_SNAKE_CASE				= jsonl_path
						elif issubclass(_SCREAMING_SNAKE_CASE	,			_SCREAMING_SNAKE_CASE  ):
												_SCREAMING_SNAKE_CASE				= [jsonl_path]
						_SCREAMING_SNAKE_CASE				= tmp_path / "cache"
						_SCREAMING_SNAKE_CASE				= {"col_1": "string", "col_2": "int64", "col_3": "float64"}
						_SCREAMING_SNAKE_CASE				= JsonDatasetReader(_SCREAMING_SNAKE_CASE	,			cache_dir=_SCREAMING_SNAKE_CASE  ).read()
						_check_json_dataset(_SCREAMING_SNAKE_CASE	,			_SCREAMING_SNAKE_CASE  )



def 			_a		(	_SCREAMING_SNAKE_CASE		:   Optional[int]	,			_SCREAMING_SNAKE_CASE		:   int	,			_SCREAMING_SNAKE_CASE		:   str=("train",)  ):
						assert isinstance(_SCREAMING_SNAKE_CASE	,			_SCREAMING_SNAKE_CASE  )
						for split in splits:
												_SCREAMING_SNAKE_CASE				= dataset_dict[split]
												assert dataset.num_rows == 4
												assert dataset.num_columns == 3
												assert dataset.column_names == ["col_1", "col_2", "col_3"]
												for feature, expected_dtype in expected_features.items():
																		assert dataset.features[feature].dtype == expected_dtype



@pytest.mark.parametrize("keep_in_memory"	,			[False, True]  )
def 			_a		(	_SCREAMING_SNAKE_CASE		:   Dict	,			_SCREAMING_SNAKE_CASE		:   int	,			_SCREAMING_SNAKE_CASE		:   List[str]  ):
						_SCREAMING_SNAKE_CASE				= tmp_path / "cache"
						_SCREAMING_SNAKE_CASE				= {"col_1": "string", "col_2": "int64", "col_3": "float64"}
						with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
												_SCREAMING_SNAKE_CASE				= JsonDatasetReader({"train": jsonl_path}	,			cache_dir=_SCREAMING_SNAKE_CASE	,			keep_in_memory=_SCREAMING_SNAKE_CASE  ).read()
						_check_json_datasetdict(_SCREAMING_SNAKE_CASE	,			_SCREAMING_SNAKE_CASE  )



@pytest.mark.parametrize(
    "features"	,			[
        None,
        {"col_1": "string", "col_2": "int64", "col_3": "float64"},
        {"col_1": "string", "col_2": "string", "col_3": "string"},
        {"col_1": "int32", "col_2": "int32", "col_3": "int32"},
        {"col_1": "float32", "col_2": "float32", "col_3": "float32"},
    ]	,			)
def 			_a		(	_SCREAMING_SNAKE_CASE		:   int	,			_SCREAMING_SNAKE_CASE		:   Any	,			_SCREAMING_SNAKE_CASE		:   Dict  ):
						_SCREAMING_SNAKE_CASE				= tmp_path / "cache"
						_SCREAMING_SNAKE_CASE				= {"col_1": "string", "col_2": "int64", "col_3": "float64"}
						_SCREAMING_SNAKE_CASE				= features.copy() if features else default_expected_features
						_SCREAMING_SNAKE_CASE				= (
						    Features({feature: Value(_SCREAMING_SNAKE_CASE  ) for feature, dtype in features.items()}  ) if features is not None else None
						)
						_SCREAMING_SNAKE_CASE				= JsonDatasetReader({"train": jsonl_path}	,			features=_SCREAMING_SNAKE_CASE	,			cache_dir=_SCREAMING_SNAKE_CASE  ).read()
						_check_json_datasetdict(_SCREAMING_SNAKE_CASE	,			_SCREAMING_SNAKE_CASE  )



@pytest.mark.parametrize("split"	,			[None, NamedSplit("train"  ), "train", "test"]  )
def 			_a		(	_SCREAMING_SNAKE_CASE		:   int	,			_SCREAMING_SNAKE_CASE		:   Optional[int]	,			_SCREAMING_SNAKE_CASE		:   int  ):




						if split:
												_SCREAMING_SNAKE_CASE				= {split: jsonl_path}
						else:
												_SCREAMING_SNAKE_CASE				= "train"
												_SCREAMING_SNAKE_CASE				= {"train": jsonl_path, "test": jsonl_path}
						_SCREAMING_SNAKE_CASE				= tmp_path / "cache"
						_SCREAMING_SNAKE_CASE				= {"col_1": "string", "col_2": "int64", "col_3": "float64"}
						_SCREAMING_SNAKE_CASE				= JsonDatasetReader(_SCREAMING_SNAKE_CASE	,			cache_dir=_SCREAMING_SNAKE_CASE  ).read()
						_check_json_datasetdict(_SCREAMING_SNAKE_CASE	,			_SCREAMING_SNAKE_CASE	,			splits=list(path.keys()  )  )
						assert all(dataset[split].split == split for split in path.keys()  )



def 			_a		(	_SCREAMING_SNAKE_CASE		:   Optional[Any]  ):
						return json.load(_SCREAMING_SNAKE_CASE  )



def 			_a		(	_SCREAMING_SNAKE_CASE		:   Tuple  ):
						return [json.loads(_SCREAMING_SNAKE_CASE  ) for line in buffer]




class 			snake_case__ :




		@pytest.mark.parametrize("lines, load_json_function"					,						[(True, load_json_lines), (False, load_json)]      )
		def     lowercase       (				self					,						UpperCamelCase					,						UpperCamelCase					,						UpperCamelCase      ):
								with io.BytesIO() as buffer:
														JsonDatasetWriter(UpperCamelCase					,						UpperCamelCase					,						lines=UpperCamelCase      ).write()
														buffer.seek(0      )
														_SCREAMING_SNAKE_CASE				= load_json_function(UpperCamelCase      )
								assert isinstance(UpperCamelCase					,						UpperCamelCase      )
								assert isinstance(exported_content[0]					,						UpperCamelCase      )
								assert len(UpperCamelCase      ) == 10




		@pytest.mark.parametrize(
		    "orient, container, keys, len_at"					,						[
		        ("records", list, {"tokens", "labels", "answers", "id"}, None),
		        ("split", dict, {"columns", "data"}, "data"),
		        ("index", dict, set("0123456789"      ), None),
		        ("columns", dict, {"tokens", "labels", "answers", "id"}, "tokens"),
		        ("values", list, None, None),
		        ("table", dict, {"schema", "data"}, "data"),
		    ]					,						)
		def     lowercase       (				self					,						UpperCamelCase					,						UpperCamelCase					,						UpperCamelCase					,						UpperCamelCase					,						UpperCamelCase      ):
								with io.BytesIO() as buffer:
														JsonDatasetWriter(UpperCamelCase					,						UpperCamelCase					,						lines=UpperCamelCase					,						orient=UpperCamelCase      ).write()
														buffer.seek(0      )
														_SCREAMING_SNAKE_CASE				= load_json(UpperCamelCase      )
								assert isinstance(UpperCamelCase					,						UpperCamelCase      )
								if keys:
														if container is dict:
																				assert exported_content.keys() == keys
														else:
																				assert exported_content[0].keys() == keys
								else:
														assert not hasattr(UpperCamelCase					,						"keys"      ) and not hasattr(exported_content[0]					,						"keys"      )
								if len_at:
														assert len(exported_content[len_at]      ) == 10
								else:
														assert len(UpperCamelCase      ) == 10




		@pytest.mark.parametrize("lines, load_json_function"					,						[(True, load_json_lines), (False, load_json)]      )
		def     lowercase       (				self					,						UpperCamelCase					,						UpperCamelCase					,						UpperCamelCase      ):
								with io.BytesIO() as buffer:
														JsonDatasetWriter(UpperCamelCase					,						UpperCamelCase					,						lines=UpperCamelCase					,						num_proc=2      ).write()
														buffer.seek(0      )
														_SCREAMING_SNAKE_CASE				= load_json_function(UpperCamelCase      )
								assert isinstance(UpperCamelCase					,						UpperCamelCase      )
								assert isinstance(exported_content[0]					,						UpperCamelCase      )
								assert len(UpperCamelCase      ) == 10




		@pytest.mark.parametrize(
		    "orient, container, keys, len_at"					,						[
		        ("records", list, {"tokens", "labels", "answers", "id"}, None),
		        ("split", dict, {"columns", "data"}, "data"),
		        ("index", dict, set("0123456789"      ), None),
		        ("columns", dict, {"tokens", "labels", "answers", "id"}, "tokens"),
		        ("values", list, None, None),
		        ("table", dict, {"schema", "data"}, "data"),
		    ]					,						)
		def     lowercase       (				self					,						UpperCamelCase					,						UpperCamelCase					,						UpperCamelCase					,						UpperCamelCase					,						UpperCamelCase      ):
								with io.BytesIO() as buffer:
														JsonDatasetWriter(UpperCamelCase					,						UpperCamelCase					,						lines=UpperCamelCase					,						orient=UpperCamelCase					,						num_proc=2      ).write()
														buffer.seek(0      )
														_SCREAMING_SNAKE_CASE				= load_json(UpperCamelCase      )
								assert isinstance(UpperCamelCase					,						UpperCamelCase      )
								if keys:
														if container is dict:
																				assert exported_content.keys() == keys
														else:
																				assert exported_content[0].keys() == keys
								else:
														assert not hasattr(UpperCamelCase					,						"keys"      ) and not hasattr(exported_content[0]					,						"keys"      )
								if len_at:
														assert len(exported_content[len_at]      ) == 10
								else:
														assert len(UpperCamelCase      ) == 10




		def     lowercase       (				self					,						UpperCamelCase      ):
								with pytest.raises(UpperCamelCase      ):
														with io.BytesIO() as buffer:
																				JsonDatasetWriter(UpperCamelCase					,						UpperCamelCase					,						num_proc=0      )




		@pytest.mark.parametrize("compression, extension"					,						[("gzip", "gz"), ("bz2", "bz2"), ("xz", "xz")]      )
		def     lowercase       (				self					,						UpperCamelCase					,						UpperCamelCase					,						UpperCamelCase					,						UpperCamelCase					,						UpperCamelCase      ):
								_SCREAMING_SNAKE_CASE				= tmp_path_factory.mktemp("data"      ) / F'test.json.{extension}'
								_SCREAMING_SNAKE_CASE				= str(shared_datadir / F'test_file.json.{extension}'      )
								JsonDatasetWriter(UpperCamelCase					,						UpperCamelCase					,						compression=UpperCamelCase      ).write()

								with fsspec.open(UpperCamelCase					,						"rb"					,						compression="infer"      ) as f:
														_SCREAMING_SNAKE_CASE				= f.read()
								with fsspec.open(UpperCamelCase					,						"rb"					,						compression="infer"      ) as f:
														_SCREAMING_SNAKE_CASE				= f.read()
								assert exported_content == original_content

'''simple docstring'''







from ..utils import DummyObject, requires_backends


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					Dict       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					Tuple       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					str       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					Tuple       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					List[Any]       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					Any       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					Any       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					int       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					str       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					Any       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					Any       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					Optional[Any]       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					Union[str, Any]       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					Optional[Any]       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					str       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					Union[str, Any]       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					int       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					Dict       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					List[str]       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					Optional[Any]       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					Optional[int]       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					Dict       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					Dict       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					str       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					Optional[Any]       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					Tuple       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					Union[str, Any]       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					str       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					Optional[int]       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					Optional[Any]       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )


class 			lowerCAmelCase (				metaclass=__UpperCAmelCase			):
		a							:					Dict       =					["""sentencepiece"""]




		def __init__(				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								requires_backends(self					,						["sentencepiece"]      )