





from abc import ABC, abstractmethod
from typing import Optional, Union

from .. import Dataset, DatasetDict, Features, IterableDataset, IterableDatasetDict, NamedSplit
from ..utils.typing import NestedDataStructureLike, PathLike

class      lowerCAmelCase							(      __UpperCamelCase    ):
 def __init__(   self						:   List[Any]    ,  UpperCAmelCase						:   Optional[NestedDataStructureLike[PathLike]] = None    ,  UpperCAmelCase						:   Optional[NamedSplit] = None    ,  UpperCAmelCase						:   Optional[Features] = None    ,  UpperCAmelCase						:   str = None    ,  UpperCAmelCase						:   bool = False    ,  UpperCAmelCase						:   bool = False    ,  UpperCAmelCase						:   Optional[int] = None    ,  **UpperCAmelCase						:   List[Any]    ,  )    ->			Any:
     lowerCamelCase__					:   Dict      				=	path_or_paths
     lowerCamelCase__					:   Optional[Any]      				=	split if split or isinstance(UpperCAmelCase    ,  UpperCAmelCase			) else 'train'
     lowerCamelCase__					:   Any      				=	features
     lowerCamelCase__					:   Dict      				=	cache_dir
     lowerCamelCase__					:   Union[str, Any]      				=	keep_in_memory
     lowerCamelCase__					:   Dict      				=	streaming
     lowerCamelCase__					:   List[str]      				=	num_proc
     lowerCamelCase__					:   Dict      				=	kwargs







 @abstractmethod
 def   A_			(   self						:   Any			)    ->			Union[Dataset, DatasetDict, IterableDataset, IterableDatasetDict]:
     pass


class      lowerCAmelCase							(      __UpperCamelCase    ):
 def __init__(   self						:   List[str]    ,  UpperCAmelCase						:   Optional[Features] = None    ,  UpperCAmelCase						:   str = None    ,  UpperCAmelCase						:   bool = False    ,  UpperCAmelCase						:   bool = False    ,  UpperCAmelCase						:   Optional[int] = None    ,  **UpperCAmelCase						:   List[str]    ,  )    ->			Dict:
     lowerCamelCase__					:   List[str]      				=	features
     lowerCamelCase__					:   Optional[int]      				=	cache_dir
     lowerCamelCase__					:   Tuple      				=	keep_in_memory
     lowerCamelCase__					:   str      				=	streaming
     lowerCamelCase__					:   Any      				=	num_proc
     lowerCamelCase__					:   Dict      				=	kwargs







 @abstractmethod
 def   A_			(   self						:   Optional[int]			)    ->			Union[Dataset, IterableDataset]:
     pass










from ..utils import DummyObject, requires_backends

class      lowerCAmelCase							(      metaclass=__UpperCamelCase    ):
 UpperCAmelCase__									=	["""torch""", """transformers""", """onnx"""]
 def __init__(   self						:   Tuple    ,  *UpperCAmelCase						:   str    ,  **UpperCAmelCase						:   Optional[int]			)    ->			List[str]:
     requires_backends(self    ,  ['torch', 'transformers', 'onnx']			)
 @classmethod
 def   A_			(   cls						:   Union[str, Any]    ,  *UpperCAmelCase						:   Dict    ,  **UpperCAmelCase						:   List[str]			)    ->			int:
     requires_backends(cls    ,  ['torch', 'transformers', 'onnx']			)







 @classmethod
 def   A_			(   cls						:   Any    ,  *UpperCAmelCase						:   List[Any]    ,  **UpperCAmelCase						:   Tuple			)    ->			Union[str, Any]:
     requires_backends(cls    ,  ['torch', 'transformers', 'onnx']			)


class      lowerCAmelCase							(      metaclass=__UpperCamelCase    ):
 UpperCAmelCase__									=	["""torch""", """transformers""", """onnx"""]
 def __init__(   self						:   List[Any]    ,  *UpperCAmelCase						:   Union[str, Any]    ,  **UpperCAmelCase						:   Dict			)    ->			Any:
     requires_backends(self    ,  ['torch', 'transformers', 'onnx']			)
 @classmethod
 def   A_			(   cls						:   str    ,  *UpperCAmelCase						:   Union[str, Any]    ,  **UpperCAmelCase						:   Union[str, Any]			)    ->			Tuple:
     requires_backends(cls    ,  ['torch', 'transformers', 'onnx']			)







 @classmethod
 def   A_			(   cls						:   List[Any]    ,  *UpperCAmelCase						:   str    ,  **UpperCAmelCase						:   Dict			)    ->			str:
     requires_backends(cls    ,  ['torch', 'transformers', 'onnx']			)


class      lowerCAmelCase							(      metaclass=__UpperCamelCase    ):
 UpperCAmelCase__									=	["""torch""", """transformers""", """onnx"""]
 def __init__(   self						:   Dict    ,  *UpperCAmelCase						:   Dict    ,  **UpperCAmelCase						:   Dict			)    ->			Optional[int]:
     requires_backends(self    ,  ['torch', 'transformers', 'onnx']			)
 @classmethod
 def   A_			(   cls						:   Optional[Any]    ,  *UpperCAmelCase						:   Union[str, Any]    ,  **UpperCAmelCase						:   Any			)    ->			Any:
     requires_backends(cls    ,  ['torch', 'transformers', 'onnx']			)







 @classmethod
 def   A_			(   cls						:   List[str]    ,  *UpperCAmelCase						:   Any    ,  **UpperCAmelCase						:   Dict			)    ->			Tuple:
     requires_backends(cls    ,  ['torch', 'transformers', 'onnx']			)


class      lowerCAmelCase							(      metaclass=__UpperCamelCase    ):
 UpperCAmelCase__									=	["""torch""", """transformers""", """onnx"""]
 def __init__(   self						:   Union[str, Any]    ,  *UpperCAmelCase						:   Optional[int]    ,  **UpperCAmelCase						:   Optional[int]			)    ->			Any:
     requires_backends(self    ,  ['torch', 'transformers', 'onnx']			)
 @classmethod
 def   A_			(   cls						:   List[Any]    ,  *UpperCAmelCase						:   Dict    ,  **UpperCAmelCase						:   int			)    ->			Dict:
     requires_backends(cls    ,  ['torch', 'transformers', 'onnx']			)







 @classmethod
 def   A_			(   cls						:   Dict    ,  *UpperCAmelCase						:   Dict    ,  **UpperCAmelCase						:   Optional[int]			)    ->			Optional[int]:
     requires_backends(cls    ,  ['torch', 'transformers', 'onnx']			)


class      lowerCAmelCase							(      metaclass=__UpperCamelCase    ):
 UpperCAmelCase__									=	["""torch""", """transformers""", """onnx"""]
 def __init__(   self						:   List[str]    ,  *UpperCAmelCase						:   List[Any]    ,  **UpperCAmelCase						:   List[str]			)    ->			Optional[int]:
     requires_backends(self    ,  ['torch', 'transformers', 'onnx']			)
 @classmethod
 def   A_			(   cls						:   List[Any]    ,  *UpperCAmelCase						:   Optional[Any]    ,  **UpperCAmelCase						:   Optional[Any]			)    ->			str:
     requires_backends(cls    ,  ['torch', 'transformers', 'onnx']			)







 @classmethod
 def   A_			(   cls						:   List[Any]    ,  *UpperCAmelCase						:   Optional[int]    ,  **UpperCAmelCase						:   Any			)    ->			Any:
     requires_backends(cls    ,  ['torch', 'transformers', 'onnx']			)


class      lowerCAmelCase							(      metaclass=__UpperCamelCase    ):
 UpperCAmelCase__									=	["""torch""", """transformers""", """onnx"""]
 def __init__(   self						:   List[str]    ,  *UpperCAmelCase						:   Tuple    ,  **UpperCAmelCase						:   Optional[int]			)    ->			Optional[Any]:
     requires_backends(self    ,  ['torch', 'transformers', 'onnx']			)
 @classmethod
 def   A_			(   cls						:   Union[str, Any]    ,  *UpperCAmelCase						:   List[Any]    ,  **UpperCAmelCase						:   Optional[Any]			)    ->			Tuple:
     requires_backends(cls    ,  ['torch', 'transformers', 'onnx']			)







 @classmethod
 def   A_			(   cls						:   Tuple    ,  *UpperCAmelCase						:   List[str]    ,  **UpperCAmelCase						:   List[str]			)    ->			Tuple:
     requires_backends(cls    ,  ['torch', 'transformers', 'onnx']			)





