





from ..utils import DummyObject, requires_backends

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



					'''simple docstring'''

					__snake_case					:			int				=    ["flax"]






					def __init__(							self		:					Dict		,*lowerCamelCase__		:					Optional[Any]		,**lowerCamelCase__		:					Union[str, Any] )  ->	Dict:




											'''simple docstring'''


											requires_backends(self		,["""flax"""] )






					@classmethod
					def        SCREAMING_SNAKE_CASE__						(							cls		:					Tuple		,*lowerCamelCase__		:					Optional[int]		,**lowerCamelCase__		:					List[str] )  ->	Tuple:




											'''simple docstring'''


											requires_backends(cls		,["""flax"""] )






					@classmethod
					def        SCREAMING_SNAKE_CASE__						(							cls		:					Any		,*lowerCamelCase__		:					int		,**lowerCamelCase__		:					List[Any] )  ->	int:




											'''simple docstring'''


											requires_backends(cls		,["""flax"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



					'''simple docstring'''

					__snake_case					:			Union[str, Any]				=    ["flax"]






					def __init__(							self		:					List[str]		,*lowerCamelCase__		:					Union[str, Any]		,**lowerCamelCase__		:					str )  ->	Optional[int]:




											'''simple docstring'''


											requires_backends(self		,["""flax"""] )






					@classmethod
					def        SCREAMING_SNAKE_CASE__						(							cls		:					List[Any]		,*lowerCamelCase__		:					Optional[int]		,**lowerCamelCase__		:					Any )  ->	List[str]:




											'''simple docstring'''


											requires_backends(cls		,["""flax"""] )






					@classmethod
					def        SCREAMING_SNAKE_CASE__						(							cls		:					str		,*lowerCamelCase__		:					Optional[Any]		,**lowerCamelCase__		:					str )  ->	Tuple:




											'''simple docstring'''


											requires_backends(cls		,["""flax"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



					'''simple docstring'''

					__snake_case					:			Optional[int]				=    ["flax"]






					def __init__(							self		:					List[Any]		,*lowerCamelCase__		:					int		,**lowerCamelCase__		:					List[Any] )  ->	Optional[Any]:




											'''simple docstring'''


											requires_backends(self		,["""flax"""] )






					@classmethod
					def        SCREAMING_SNAKE_CASE__						(							cls		:					int		,*lowerCamelCase__		:					int		,**lowerCamelCase__		:					Optional[Any] )  ->	str:




											'''simple docstring'''


											requires_backends(cls		,["""flax"""] )






					@classmethod
					def        SCREAMING_SNAKE_CASE__						(							cls		:					List[Any]		,*lowerCamelCase__		:					Union[str, Any]		,**lowerCamelCase__		:					int )  ->	int:




											'''simple docstring'''


											requires_backends(cls		,["""flax"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



					'''simple docstring'''

					__snake_case					:			str				=    ["flax"]






					def __init__(							self		:					Union[str, Any]		,*lowerCamelCase__		:					Tuple		,**lowerCamelCase__		:					int )  ->	Optional[int]:




											'''simple docstring'''


											requires_backends(self		,["""flax"""] )






					@classmethod
					def        SCREAMING_SNAKE_CASE__						(							cls		:					List[str]		,*lowerCamelCase__		:					List[str]		,**lowerCamelCase__		:					List[Any] )  ->	int:




											'''simple docstring'''


											requires_backends(cls		,["""flax"""] )






					@classmethod
					def        SCREAMING_SNAKE_CASE__						(							cls		:					Any		,*lowerCamelCase__		:					Union[str, Any]		,**lowerCamelCase__		:					Optional[Any] )  ->	str:




											'''simple docstring'''


											requires_backends(cls		,["""flax"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



					'''simple docstring'''

					__snake_case					:			Optional[Any]				=    ["flax"]






					def __init__(							self		:					Tuple		,*lowerCamelCase__		:					Optional[int]		,**lowerCamelCase__		:					Any )  ->	int:




											'''simple docstring'''


											requires_backends(self		,["""flax"""] )






					@classmethod
					def        SCREAMING_SNAKE_CASE__						(							cls		:					Optional[int]		,*lowerCamelCase__		:					str		,**lowerCamelCase__		:					int )  ->	Optional[Any]:




											'''simple docstring'''


											requires_backends(cls		,["""flax"""] )






					@classmethod
					def        SCREAMING_SNAKE_CASE__						(							cls		:					int		,*lowerCamelCase__		:					List[Any]		,**lowerCamelCase__		:					List[Any] )  ->	List[Any]:




											'''simple docstring'''


											requires_backends(cls		,["""flax"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



					'''simple docstring'''

					__snake_case					:			Any				=    ["flax"]






					def __init__(							self		:					str		,*lowerCamelCase__		:					str		,**lowerCamelCase__		:					List[Any] )  ->	Any:




											'''simple docstring'''


											requires_backends(self		,["""flax"""] )






					@classmethod
					def        SCREAMING_SNAKE_CASE__						(							cls		:					str		,*lowerCamelCase__		:					List[Any]		,**lowerCamelCase__		:					Dict )  ->	int:




											'''simple docstring'''


											requires_backends(cls		,["""flax"""] )






					@classmethod
					def        SCREAMING_SNAKE_CASE__						(							cls		:					List[Any]		,*lowerCamelCase__		:					List[str]		,**lowerCamelCase__		:					Dict )  ->	Optional[int]:




											'''simple docstring'''


											requires_backends(cls		,["""flax"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



					'''simple docstring'''

					__snake_case					:			int				=    ["flax"]






					def __init__(							self		:					Dict		,*lowerCamelCase__		:					Optional[int]		,**lowerCamelCase__		:					Optional[Any] )  ->	List[str]:




											'''simple docstring'''


											requires_backends(self		,["""flax"""] )






					@classmethod
					def        SCREAMING_SNAKE_CASE__						(							cls		:					int		,*lowerCamelCase__		:					Union[str, Any]		,**lowerCamelCase__		:					Tuple )  ->	Optional[Any]:




											'''simple docstring'''


											requires_backends(cls		,["""flax"""] )






					@classmethod
					def        SCREAMING_SNAKE_CASE__						(							cls		:					Dict		,*lowerCamelCase__		:					Union[str, Any]		,**lowerCamelCase__		:					List[Any] )  ->	Union[str, Any]:




											'''simple docstring'''


											requires_backends(cls		,["""flax"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



					'''simple docstring'''

					__snake_case					:			Tuple				=    ["flax"]






					def __init__(							self		:					Tuple		,*lowerCamelCase__		:					List[Any]		,**lowerCamelCase__		:					Dict )  ->	List[str]:




											'''simple docstring'''


											requires_backends(self		,["""flax"""] )






					@classmethod
					def        SCREAMING_SNAKE_CASE__						(							cls		:					int		,*lowerCamelCase__		:					Dict		,**lowerCamelCase__		:					str )  ->	Union[str, Any]:




											'''simple docstring'''


											requires_backends(cls		,["""flax"""] )






					@classmethod
					def        SCREAMING_SNAKE_CASE__						(							cls		:					Tuple		,*lowerCamelCase__		:					List[Any]		,**lowerCamelCase__		:					str )  ->	Any:




											'''simple docstring'''


											requires_backends(cls		,["""flax"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



					'''simple docstring'''

					__snake_case					:			Union[str, Any]				=    ["flax"]






					def __init__(							self		:					List[Any]		,*lowerCamelCase__		:					Optional[int]		,**lowerCamelCase__		:					str )  ->	int:




											'''simple docstring'''


											requires_backends(self		,["""flax"""] )






					@classmethod
					def        SCREAMING_SNAKE_CASE__						(							cls		:					Union[str, Any]		,*lowerCamelCase__		:					Optional[int]		,**lowerCamelCase__		:					Tuple )  ->	Optional[int]:




											'''simple docstring'''


											requires_backends(cls		,["""flax"""] )






					@classmethod
					def        SCREAMING_SNAKE_CASE__						(							cls		:					Tuple		,*lowerCamelCase__		:					Optional[int]		,**lowerCamelCase__		:					Optional[Any] )  ->	List[str]:




											'''simple docstring'''


											requires_backends(cls		,["""flax"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



					'''simple docstring'''

					__snake_case					:			Union[str, Any]				=    ["flax"]






					def __init__(							self		:					List[Any]		,*lowerCamelCase__		:					Tuple		,**lowerCamelCase__		:					Union[str, Any] )  ->	int:




											'''simple docstring'''


											requires_backends(self		,["""flax"""] )






					@classmethod
					def        SCREAMING_SNAKE_CASE__						(							cls		:					int		,*lowerCamelCase__		:					Optional[Any]		,**lowerCamelCase__		:					Union[str, Any] )  ->	str:




											'''simple docstring'''


											requires_backends(cls		,["""flax"""] )






					@classmethod
					def        SCREAMING_SNAKE_CASE__						(							cls		:					Optional[Any]		,*lowerCamelCase__		:					Dict		,**lowerCamelCase__		:					Dict )  ->	int:




											'''simple docstring'''


											requires_backends(cls		,["""flax"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



					'''simple docstring'''

					__snake_case					:			List[Any]				=    ["flax"]






					def __init__(							self		:					Optional[int]		,*lowerCamelCase__		:					str		,**lowerCamelCase__		:					Any )  ->	str:




											'''simple docstring'''


											requires_backends(self		,["""flax"""] )






					@classmethod
					def        SCREAMING_SNAKE_CASE__						(							cls		:					int		,*lowerCamelCase__		:					Optional[Any]		,**lowerCamelCase__		:					Union[str, Any] )  ->	Optional[Any]:




											'''simple docstring'''


											requires_backends(cls		,["""flax"""] )






					@classmethod
					def        SCREAMING_SNAKE_CASE__						(							cls		:					Union[str, Any]		,*lowerCamelCase__		:					Dict		,**lowerCamelCase__		:					List[Any] )  ->	Any:




											'''simple docstring'''


											requires_backends(cls		,["""flax"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



					'''simple docstring'''

					__snake_case					:			Optional[Any]				=    ["flax"]






					def __init__(							self		:					List[Any]		,*lowerCamelCase__		:					Tuple		,**lowerCamelCase__		:					Optional[Any] )  ->	Optional[int]:




											'''simple docstring'''


											requires_backends(self		,["""flax"""] )






					@classmethod
					def        SCREAMING_SNAKE_CASE__						(							cls		:					List[str]		,*lowerCamelCase__		:					Optional[int]		,**lowerCamelCase__		:					Union[str, Any] )  ->	Tuple:




											'''simple docstring'''


											requires_backends(cls		,["""flax"""] )






					@classmethod
					def        SCREAMING_SNAKE_CASE__						(							cls		:					Union[str, Any]		,*lowerCamelCase__		:					Union[str, Any]		,**lowerCamelCase__		:					List[Any] )  ->	Optional[Any]:




											'''simple docstring'''


											requires_backends(cls		,["""flax"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



					'''simple docstring'''

					__snake_case					:			int				=    ["flax"]






					def __init__(							self		:					Optional[Any]		,*lowerCamelCase__		:					Optional[Any]		,**lowerCamelCase__		:					List[str] )  ->	List[Any]:




											'''simple docstring'''


											requires_backends(self		,["""flax"""] )






					@classmethod
					def        SCREAMING_SNAKE_CASE__						(							cls		:					Optional[int]		,*lowerCamelCase__		:					int		,**lowerCamelCase__		:					int )  ->	List[str]:




											'''simple docstring'''


											requires_backends(cls		,["""flax"""] )






					@classmethod
					def        SCREAMING_SNAKE_CASE__						(							cls		:					str		,*lowerCamelCase__		:					Any		,**lowerCamelCase__		:					Optional[int] )  ->	int:




											'''simple docstring'''


											requires_backends(cls		,["""flax"""] )









def      __lowercase     (   _SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE			)				->     float:


      '''simple docstring'''


      _validate_point(_SCREAMING_SNAKE_CASE			)
      _validate_point(_SCREAMING_SNAKE_CASE			)
      if len(_SCREAMING_SNAKE_CASE			) != len(_SCREAMING_SNAKE_CASE			):
            raise ValueError("""Both points must be in the same n-dimensional space"""			)

      return float(sum(abs(a - b			) for a, b in zip(_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE			)			)			)



def      __lowercase     (   _SCREAMING_SNAKE_CASE			)				->     None:


      '''simple docstring'''


      if point:
            if isinstance(_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE			):
                  for item in point:
                        if not isinstance(_SCREAMING_SNAKE_CASE				,		(int, float)			):
                              SCREAMING_SNAKE_CASE	=		(
                                  """Expected a list of numbers as input, found """
                                  F"""{type(_SCREAMING_SNAKE_CASE			).__name__}"""
                              )
                              raise TypeError(_SCREAMING_SNAKE_CASE			)
            else:
                  SCREAMING_SNAKE_CASE	=		F"""Expected a list of numbers as input, found {type(_SCREAMING_SNAKE_CASE			).__name__}"""
                  raise TypeError(_SCREAMING_SNAKE_CASE			)
      else:
            raise ValueError("""Missing an input"""			)



def      __lowercase     (   _SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE			)				->     float:


      '''simple docstring'''


      _validate_point(_SCREAMING_SNAKE_CASE			)
      _validate_point(_SCREAMING_SNAKE_CASE			)
      if len(_SCREAMING_SNAKE_CASE			) != len(_SCREAMING_SNAKE_CASE			):
            raise ValueError("""Both points must be in the same n-dimensional space"""			)

      return float(sum(abs(x - y			) for x, y in zip(_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE			)			)			)


if __name__ == "__main__":
      import doctest

      doctest.testmod()


