



"""simple docstring"""
from ..utils import DummyObject, requires_backends




class       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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_    (				*SCREAMING_SNAKE_CASE__,			**SCREAMING_SNAKE_CASE__						)      ->   str:
		requires_backends(SCREAMING_SNAKE_CASE__,			["torch"]						)



def 							lowerCAmelCase_    (				*SCREAMING_SNAKE_CASE__,			**SCREAMING_SNAKE_CASE__						)      ->   Union[str, Any]:
		requires_backends(SCREAMING_SNAKE_CASE__,			["torch"]						)



def 							lowerCAmelCase_    (				*SCREAMING_SNAKE_CASE__,			**SCREAMING_SNAKE_CASE__						)      ->   int:
		requires_backends(SCREAMING_SNAKE_CASE__,			["torch"]						)



def 							lowerCAmelCase_    (				*SCREAMING_SNAKE_CASE__,			**SCREAMING_SNAKE_CASE__						)      ->   Union[str, Any]:
		requires_backends(SCREAMING_SNAKE_CASE__,			["torch"]						)



def 							lowerCAmelCase_    (				*SCREAMING_SNAKE_CASE__,			**SCREAMING_SNAKE_CASE__						)      ->   Optional[int]:
		requires_backends(SCREAMING_SNAKE_CASE__,			["torch"]						)



def 							lowerCAmelCase_    (				*SCREAMING_SNAKE_CASE__,			**SCREAMING_SNAKE_CASE__						)      ->   Optional[Any]:
		requires_backends(SCREAMING_SNAKE_CASE__,			["torch"]						)



def 							lowerCAmelCase_    (				*SCREAMING_SNAKE_CASE__,			**SCREAMING_SNAKE_CASE__						)      ->   Dict:
		requires_backends(SCREAMING_SNAKE_CASE__,			["torch"]						)




class       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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       snake_case_    (    metaclass=__lowercase					):
							__lowerCAmelCase            =       ["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"]   )

import datetime
import platform
import subprocess
from typing import Optional, Tuple, Union

import numpy as np


def 				__A(lowerCAmelCase    ,	lowerCAmelCase			)		->					np.array:

		"""simple docstring"""






		_UpperCamelCase         =						F'{sampling_rate}'
		_UpperCamelCase         =						"""1"""
		_UpperCamelCase         =						"""f32le"""
		_UpperCamelCase         =						[
		    """ffmpeg""",
		    """-i""",
		    """pipe:0""",
		    """-ac""",
		    ac,
		    """-ar""",
		    ar,
		    """-f""",
		    format_for_conversion,
		    """-hide_banner""",
		    """-loglevel""",
		    """quiet""",
		    """pipe:1""",
		]

		try:
				with subprocess.Popen(lowerCAmelCase    ,	stdin=subprocess.PIPE    ,	stdout=subprocess.PIPE			) as ffmpeg_process:
						_UpperCamelCase         =						ffmpeg_process.communicate(lowerCAmelCase			)
		except FileNotFoundError as error:
				raise ValueError("""ffmpeg was not found but is required to load audio files from filename"""			) from error
		_UpperCamelCase         =						output_stream[0]
		_UpperCamelCase         =						np.frombuffer(lowerCAmelCase    ,	np.floataa			)
		if audio.shape[0] == 0:
				raise ValueError("""Malformed soundfile"""			)
		return audio


def 				__A(lowerCAmelCase    ,	lowerCAmelCase    ,	lowerCAmelCase = "f32le"    ,	)		->					Union[str, Any]:

		"""simple docstring"""






		_UpperCamelCase         =						F'{sampling_rate}'
		_UpperCamelCase         =						"""1"""
		if format_for_conversion == "s16le":
				_UpperCamelCase         =						2
		elif format_for_conversion == "f32le":
				_UpperCamelCase         =						4
		else:
				raise ValueError(F'Unhandled format `{format_for_conversion}`. Please use `s16le` or `f32le`'			)

		_UpperCamelCase         =						platform.system()
		if system == "Linux":
				_UpperCamelCase         =						"""alsa"""
				_UpperCamelCase         =						"""default"""
		elif system == "Darwin":
				_UpperCamelCase         =						"""avfoundation"""
				_UpperCamelCase         =						""":0"""
		elif system == "Windows":
				_UpperCamelCase         =						"""dshow"""
				_UpperCamelCase         =						"""default"""

		_UpperCamelCase         =						[
		    """ffmpeg""",
		    """-f""",
		    format_,
		    """-i""",
		    input_,
		    """-ac""",
		    ac,
		    """-ar""",
		    ar,
		    """-f""",
		    format_for_conversion,
		    """-fflags""",
		    """nobuffer""",
		    """-hide_banner""",
		    """-loglevel""",
		    """quiet""",
		    """pipe:1""",
		]
		_UpperCamelCase         =						int(round(sampling_rate * chunk_length_s			)			) * size_of_sample
		_UpperCamelCase         =						_ffmpeg_stream(lowerCAmelCase    ,	lowerCAmelCase			)
		for item in iterator:
				yield item


def 				__A(lowerCAmelCase    ,	lowerCAmelCase    ,	lowerCAmelCase = None    ,	lowerCAmelCase = None    ,	lowerCAmelCase = "f32le"    ,	)		->					Any:

		"""simple docstring"""






		if stream_chunk_s is not None:
				_UpperCamelCase         =						stream_chunk_s
		else:
				_UpperCamelCase         =						chunk_length_s

		_UpperCamelCase         =						ffmpeg_microphone(lowerCAmelCase    ,	lowerCAmelCase    ,	format_for_conversion=lowerCAmelCase			)
		if format_for_conversion == "s16le":
				_UpperCamelCase         =						np.intaa
				_UpperCamelCase         =						2
		elif format_for_conversion == "f32le":
				_UpperCamelCase         =						np.floataa
				_UpperCamelCase         =						4
		else:
				raise ValueError(F'Unhandled format `{format_for_conversion}`. Please use `s16le` or `f32le`'			)

		if stride_length_s is None:
				_UpperCamelCase         =						chunk_length_s / 6
		_UpperCamelCase         =						int(round(sampling_rate * chunk_length_s			)			) * size_of_sample
		if isinstance(lowerCAmelCase    ,	(int, float)			):
				_UpperCamelCase         =						[stride_length_s, stride_length_s]

		_UpperCamelCase         =						int(round(sampling_rate * stride_length_s[0]			)			) * size_of_sample
		_UpperCamelCase         =						int(round(sampling_rate * stride_length_s[1]			)			) * size_of_sample
		_UpperCamelCase         =						datetime.datetime.now()
		_UpperCamelCase         =						datetime.timedelta(seconds=lowerCAmelCase			)
		for item in chunk_bytes_iter(lowerCAmelCase    ,	lowerCAmelCase    ,	stride=(stride_left, stride_right)    ,	stream=lowerCAmelCase			):
				# Put everything back in numpy scale
				_UpperCamelCase         =						np.frombuffer(item["""raw"""]    ,	dtype=lowerCAmelCase			)
				_UpperCamelCase         =						(
				    item["""stride"""][0] // size_of_sample,
				    item["""stride"""][1] // size_of_sample,
				)
				_UpperCamelCase         =						sampling_rate
				audio_time += delta
				if datetime.datetime.now() > audio_time + 1_0 * delta:
						# We're late !! SKIP
						continue
				yield item


def 				__A(lowerCAmelCase    ,	lowerCAmelCase    ,	lowerCAmelCase    ,	lowerCAmelCase = False			)		->					str:

		"""simple docstring"""






		_UpperCamelCase         =						b""""""
		_UpperCamelCase     ,						_UpperCamelCase         =						stride
		if stride_left + stride_right >= chunk_len:
				raise ValueError(
				    F'Stride needs to be strictly smaller than chunk_len: ({stride_left}, {stride_right}) vs {chunk_len}'			)
		_UpperCamelCase         =						0
		for raw in iterator:
				acc += raw
				if stream and len(lowerCAmelCase			) < chunk_len:
						_UpperCamelCase         =						(_stride_left, 0)
						yield {"raw": acc[:chunk_len], "stride": stride, "partial": True}
				else:
						while len(lowerCAmelCase			) >= chunk_len:
								# We are flushing the accumulator
								_UpperCamelCase         =						(_stride_left, stride_right)
								_UpperCamelCase         =						{"""raw""": acc[:chunk_len], """stride""": stride}
								if stream:
										_UpperCamelCase         =						False
								yield item
								_UpperCamelCase         =						stride_left
								_UpperCamelCase         =						acc[chunk_len - stride_left - stride_right :]
    # Last chunk
		if len(lowerCAmelCase			) > stride_left:
				_UpperCamelCase         =						{"""raw""": acc, """stride""": (_stride_left, 0)}
				if stream:
						_UpperCamelCase         =						False
				yield item







def 				__A(lowerCAmelCase    ,	lowerCAmelCase			)		->					Tuple:

		"""simple docstring"""






		_UpperCamelCase         =						2**2_4  # 16Mo
		try:
				with subprocess.Popen(lowerCAmelCase    ,	stdout=subprocess.PIPE    ,	bufsize=lowerCAmelCase			) as ffmpeg_process:
						while True:
								_UpperCamelCase         =						ffmpeg_process.stdout.read(lowerCAmelCase			)
								if raw == b"":
										break
								yield raw
		except FileNotFoundError as error:
				raise ValueError("""ffmpeg was not found but is required to stream audio files from filename"""			) from error



