



"""simple docstring"""






import os

import pytest
import yaml

from datasets.features.features import Features, Value
from datasets.info import DatasetInfo, DatasetInfosDict






@pytest.mark.parametrize(
    '''files''',							[
        ['''full:README.md''', '''dataset_infos.json'''],
        ['''empty:README.md''', '''dataset_infos.json'''],
        ['''dataset_infos.json'''],
        ['''full:README.md'''],
    ],							)
def 			snake_case_    ( A_   :						Dict,							A_   :						List[str]		):


       '''simple docstring'''





       _lowerCamelCase		:							int            =					tmp_path_factory.mktemp('''dset_infos_dir'''		)
       if "full:README.md" in files:
              with open(dataset_infos_dir / '''README.md''',							'''w'''		) as f:
                     f.write('''---\ndataset_info:\n  dataset_size: 42\n---'''		)
       if "empty:README.md" in files:
              with open(dataset_infos_dir / '''README.md''',							'''w'''		) as f:
                     f.write(''''''		)
    # we want to support dataset_infos.json for backward compatibility
       if "dataset_infos.json" in files:
              with open(dataset_infos_dir / '''dataset_infos.json''',							'''w'''		) as f:
                     f.write('''{"default": {"dataset_size": 42}}'''		)
       _lowerCamelCase		:							str            =					DatasetInfosDict.from_directory(A_		)
       assert dataset_infos
       assert dataset_infos["default"].dataset_size == 42






@pytest.mark.parametrize(
    '''dataset_info''',							[
        DatasetInfo(),
        DatasetInfo(
            description='''foo''',							features=Features({'''a''': Value('''int32'''		)}		),							builder_name='''builder''',							config_name='''config''',							version='''1.0.0''',							splits=[{'''name''': '''train'''}],							download_size=42,							),
    ],							)
def 			snake_case_    ( A_   :						str,							A_   :						DatasetInfo		):


       '''simple docstring'''





       _lowerCamelCase		:							Optional[Any]            =					str(A_		)
       dataset_info.write_to_directory(A_		)
       _lowerCamelCase		:							str            =					DatasetInfo.from_directory(A_		)
       assert dataset_info == reloaded
       assert os.path.exists(os.path.join(A_,							'''dataset_info.json'''		)		)






def 			snake_case_    ( ):


       '''simple docstring'''





       _lowerCamelCase		:							Union[str, Any]            =					DatasetInfo(
           description='''foo''',							citation='''bar''',							homepage='''https://foo.bar''',							license='''CC0''',							features=Features({'''a''': Value('''int32'''		)}		),							post_processed={},							supervised_keys=(),							task_templates=[],							builder_name='''builder''',							config_name='''config''',							version='''1.0.0''',							splits=[{'''name''': '''train''', '''num_examples''': 42}],							download_checksums={},							download_size=13_37,							post_processing_size=4_42,							dataset_size=12_34,							size_in_bytes=13_37 + 4_42 + 12_34,							)
       _lowerCamelCase		:							Optional[Any]            =					dataset_info._to_yaml_dict()
       assert sorted(A_		) == sorted(DatasetInfo._INCLUDED_INFO_IN_YAML		)
       for key in DatasetInfo._INCLUDED_INFO_IN_YAML:
              assert key in dataset_info_yaml_dict
              assert isinstance(dataset_info_yaml_dict[key],							(list, dict, int, str)		)
       _lowerCamelCase		:							str            =					yaml.safe_dump(A_		)
       _lowerCamelCase		:							Tuple            =					yaml.safe_load(A_		)
       assert dataset_info_yaml_dict == reloaded






def 			snake_case_    ( ):


       '''simple docstring'''





       _lowerCamelCase		:							int            =					DatasetInfo()
       _lowerCamelCase		:							Dict            =					dataset_info._to_yaml_dict()
       assert dataset_info_yaml_dict == {}







@pytest.mark.parametrize(
    '''dataset_infos_dict''',							[
        DatasetInfosDict(),
        DatasetInfosDict({'''default''': DatasetInfo()}		),
        DatasetInfosDict({'''my_config_name''': DatasetInfo()}		),
        DatasetInfosDict(
            {
                '''default''': DatasetInfo(
                    description='''foo''',							features=Features({'''a''': Value('''int32'''		)}		),							builder_name='''builder''',							config_name='''config''',							version='''1.0.0''',							splits=[{'''name''': '''train'''}],							download_size=42,							)
            }		),
        DatasetInfosDict(
            {
                '''v1''': DatasetInfo(dataset_size=42		),
                '''v2''': DatasetInfo(dataset_size=13_37		),
            }		),
    ],							)
def 			snake_case_    ( A_   :						Optional[Any],							A_   :						DatasetInfosDict		):


       '''simple docstring'''





       _lowerCamelCase		:							List[str]            =					str(A_		)
       dataset_infos_dict.write_to_directory(A_		)
       _lowerCamelCase		:							List[Any]            =					DatasetInfosDict.from_directory(A_		)

       # the config_name of the dataset_infos_dict take over the attribute
       for config_name, dataset_info in dataset_infos_dict.items():
              _lowerCamelCase		:							str            =					config_name
              # the yaml representation doesn't include fields like description or citation
              # so we just test that we can recover what we can from the yaml
              _lowerCamelCase		:							Any            =					DatasetInfo._from_yaml_dict(dataset_info._to_yaml_dict()		)
       assert dataset_infos_dict == reloaded

       if dataset_infos_dict:
              assert os.path.exists(os.path.join(A_,							'''README.md'''		)		)






"""simple docstring"""


from ..utils import DummyObject, requires_backends
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Union[str, Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       str							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Union[str, Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Tuple							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Any							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Any							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Dict							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       str							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Tuple							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Union[str, Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       str							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Tuple							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Any							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Any							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Tuple							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Dict							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Union[str, Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       str							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Union[str, Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Any							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )




