


"""simple docstring"""




from ..utils import DummyObject, requires_backends
class 			SCREAMING_SNAKE_CASE__  (    metaclass=lowercase__      ):
      snake_case__    :					Dict					       =						['''torch''', '''transformers''', '''onnx''']
      def __init__(	self    :	Optional[Any]					,							*SCREAMING_SNAKE_CASE__    :	Optional[Any]					,							**SCREAMING_SNAKE_CASE__    :	Dict					)		->      List[Any]:
             requires_backends(self					,							['torch', 'transformers', 'onnx']					)
      @classmethod
      def 	SCREAMING_SNAKE_CASE							(	cls    :	Optional[int]					,							*SCREAMING_SNAKE_CASE__    :	int					,							**SCREAMING_SNAKE_CASE__    :	List[Any]					)		->      Optional[int]:
             requires_backends(cls					,							['torch', 'transformers', 'onnx']					)

      @classmethod
      def 	SCREAMING_SNAKE_CASE							(	cls    :	Union[str, Any]					,							*SCREAMING_SNAKE_CASE__    :	Tuple					,							**SCREAMING_SNAKE_CASE__    :	str					)		->      List[str]:
             requires_backends(cls					,							['torch', 'transformers', 'onnx']					)
class 			SCREAMING_SNAKE_CASE__  (    metaclass=lowercase__      ):
      snake_case__    :					Tuple					       =						['''torch''', '''transformers''', '''onnx''']
      def __init__(	self    :	str					,							*SCREAMING_SNAKE_CASE__    :	Dict					,							**SCREAMING_SNAKE_CASE__    :	List[str]					)		->      Tuple:
             requires_backends(self					,							['torch', 'transformers', 'onnx']					)
      @classmethod
      def 	SCREAMING_SNAKE_CASE							(	cls    :	int					,							*SCREAMING_SNAKE_CASE__    :	Any					,							**SCREAMING_SNAKE_CASE__    :	int					)		->      Union[str, Any]:
             requires_backends(cls					,							['torch', 'transformers', 'onnx']					)

      @classmethod
      def 	SCREAMING_SNAKE_CASE							(	cls    :	Optional[int]					,							*SCREAMING_SNAKE_CASE__    :	Optional[Any]					,							**SCREAMING_SNAKE_CASE__    :	List[str]					)		->      List[str]:
             requires_backends(cls					,							['torch', 'transformers', 'onnx']					)
class 			SCREAMING_SNAKE_CASE__  (    metaclass=lowercase__      ):
      snake_case__    :					List[Any]					       =						['''torch''', '''transformers''', '''onnx''']
      def __init__(	self    :	Optional[Any]					,							*SCREAMING_SNAKE_CASE__    :	str					,							**SCREAMING_SNAKE_CASE__    :	Tuple					)		->      Optional[int]:
             requires_backends(self					,							['torch', 'transformers', 'onnx']					)
      @classmethod
      def 	SCREAMING_SNAKE_CASE							(	cls    :	str					,							*SCREAMING_SNAKE_CASE__    :	Dict					,							**SCREAMING_SNAKE_CASE__    :	Any					)		->      Union[str, Any]:
             requires_backends(cls					,							['torch', 'transformers', 'onnx']					)

      @classmethod
      def 	SCREAMING_SNAKE_CASE							(	cls    :	Optional[Any]					,							*SCREAMING_SNAKE_CASE__    :	int					,							**SCREAMING_SNAKE_CASE__    :	Optional[Any]					)		->      str:
             requires_backends(cls					,							['torch', 'transformers', 'onnx']					)
class 			SCREAMING_SNAKE_CASE__  (    metaclass=lowercase__      ):
      snake_case__    :					Dict					       =						['''torch''', '''transformers''', '''onnx''']
      def __init__(	self    :	Any					,							*SCREAMING_SNAKE_CASE__    :	Tuple					,							**SCREAMING_SNAKE_CASE__    :	Optional[int]					)		->      Any:
             requires_backends(self					,							['torch', 'transformers', 'onnx']					)
      @classmethod
      def 	SCREAMING_SNAKE_CASE							(	cls    :	Any					,							*SCREAMING_SNAKE_CASE__    :	Dict					,							**SCREAMING_SNAKE_CASE__    :	Union[str, Any]					)		->      Any:
             requires_backends(cls					,							['torch', 'transformers', 'onnx']					)

      @classmethod
      def 	SCREAMING_SNAKE_CASE							(	cls    :	int					,							*SCREAMING_SNAKE_CASE__    :	Dict					,							**SCREAMING_SNAKE_CASE__    :	Any					)		->      List[str]:
             requires_backends(cls					,							['torch', 'transformers', 'onnx']					)
class 			SCREAMING_SNAKE_CASE__  (    metaclass=lowercase__      ):
      snake_case__    :					List[str]					       =						['''torch''', '''transformers''', '''onnx''']
      def __init__(	self    :	Optional[Any]					,							*SCREAMING_SNAKE_CASE__    :	Optional[int]					,							**SCREAMING_SNAKE_CASE__    :	List[Any]					)		->      Dict:
             requires_backends(self					,							['torch', 'transformers', 'onnx']					)
      @classmethod
      def 	SCREAMING_SNAKE_CASE							(	cls    :	Dict					,							*SCREAMING_SNAKE_CASE__    :	List[Any]					,							**SCREAMING_SNAKE_CASE__    :	Optional[Any]					)		->      Dict:
             requires_backends(cls					,							['torch', 'transformers', 'onnx']					)

      @classmethod
      def 	SCREAMING_SNAKE_CASE							(	cls    :	Any					,							*SCREAMING_SNAKE_CASE__    :	Dict					,							**SCREAMING_SNAKE_CASE__    :	Dict					)		->      List[str]:
             requires_backends(cls					,							['torch', 'transformers', 'onnx']					)
class 			SCREAMING_SNAKE_CASE__  (    metaclass=lowercase__      ):
      snake_case__    :					Union[str, Any]					       =						['''torch''', '''transformers''', '''onnx''']
      def __init__(	self    :	str					,							*SCREAMING_SNAKE_CASE__    :	Optional[Any]					,							**SCREAMING_SNAKE_CASE__    :	List[str]					)		->      Tuple:
             requires_backends(self					,							['torch', 'transformers', 'onnx']					)
      @classmethod
      def 	SCREAMING_SNAKE_CASE							(	cls    :	int					,							*SCREAMING_SNAKE_CASE__    :	Union[str, Any]					,							**SCREAMING_SNAKE_CASE__    :	int					)		->      Any:
             requires_backends(cls					,							['torch', 'transformers', 'onnx']					)

      @classmethod
      def 	SCREAMING_SNAKE_CASE							(	cls    :	str					,							*SCREAMING_SNAKE_CASE__    :	Dict					,							**SCREAMING_SNAKE_CASE__    :	Tuple					)		->      Optional[Any]:
             requires_backends(cls					,							['torch', 'transformers', 'onnx']					)






def 	SCREAMING_SNAKE_CASE_						(      __A			:      list    )     ->		bool:

       """simple docstring"""

       if not isinstance(__A  ,   __A    ):
              raise ValueError('Input series is not valid, valid series - [2, 4, 6]'    )
       if len(__A    ) == 0:
              raise ValueError('Input list must be a non empty list'    )
       if len(__A    ) == 1:
              return True
       a_ :		Tuple							=  series[1] - series[0]
       for index in range(len(__A    ) - 1    ):
              if series[index + 1] - series[index] != common_diff:
                     return False
       return True







def 	SCREAMING_SNAKE_CASE_						(      __A			:      list    )     ->		float:

       """simple docstring"""

       if not isinstance(__A  ,   __A    ):
              raise ValueError('Input series is not valid, valid series - [2, 4, 6]'    )
       if len(__A    ) == 0:
              raise ValueError('Input list must be a non empty list'    )
       a_ :		str							=  0
       for val in series:
              answer += val
       return answer / len(__A    )


if __name__ == "__main__":
   import doctest

   doctest.testmod()


