"""simple docstring"""






from importlib import import_module

from .logging import get_logger


__lowerCAmelCase    :       List[Any]					     =get_logger(__name__)





class  _A						:

      def __init__(						self		,       __lowerCAmelCase		,       __lowerCAmelCase=None						):







            """simple docstring"""



            lowercase														=	attrs or []
            if module is not None:
                  for key in module.__dict__:
                        if key in attrs or not key.startswith("""__"""						):
                              setattr(self		,       __lowerCAmelCase		,       getattr(__lowerCAmelCase		,       __lowerCAmelCase						)						)
            lowercase														=	module._original_module if isinstance(__lowerCAmelCase		,       _PatchedModuleObj						) else module






class  _A						:
      snake_case__			:   Tuple							  =	[]

      def __init__(						self		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase=None						):







            """simple docstring"""



            lowercase														=	obj
            lowercase														=	target
            lowercase														=	new
            lowercase														=	target.split("""."""						)[0]
            lowercase														=	{}
            lowercase														=	attrs or []

      def __enter__(						self						):







            """simple docstring"""



            *lowercase							,							lowercase														=	self.target.split("""."""						)

            # Patch modules:
            # it's used to patch attributes of submodules like "os.path.join";
            # in this case we need to patch "os" and "os.path"

            for i in range(len(__lowerCAmelCase						)						):
                  try:
                        lowercase														=	import_module(""".""".join(submodules[: i + 1]						)						)
                  except ModuleNotFoundError:
                        continue
                  # We iterate over all the globals in self.obj in case we find "os" or "os.path"
                  for attr in self.obj.__dir__():
                        lowercase														=	getattr(self.obj		,       __lowerCAmelCase						)
                        # We don't check for the name of the global, but rather if its value *is* "os" or "os.path".
                        # This allows to patch renamed modules like "from os import path as ospath".
                        if obj_attr is submodule or (
                            (isinstance(__lowerCAmelCase		,       _PatchedModuleObj						) and obj_attr._original_module is submodule)
                        ):
                              lowercase														=	obj_attr
                              # patch at top level
                              setattr(self.obj		,       __lowerCAmelCase		,       _PatchedModuleObj(__lowerCAmelCase		,       attrs=self.attrs						)						)
                              lowercase														=	getattr(self.obj		,       __lowerCAmelCase						)
                              # construct lower levels patches
                              for key in submodules[i + 1 :]:
                                    setattr(__lowerCAmelCase		,       __lowerCAmelCase		,       _PatchedModuleObj(getattr(__lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase						)		,       attrs=self.attrs						)						)
                                    lowercase														=	getattr(__lowerCAmelCase		,       __lowerCAmelCase						)
                              # finally set the target attribute
                              setattr(__lowerCAmelCase		,       __lowerCAmelCase		,       self.new						)

        # Patch attribute itself:
        # it's used for builtins like "open",
        # and also to patch "os.path.join" we may also need to patch "join"
        # itself if it was imported as "from os.path import join".

            if submodules:  # if it's an attribute of a submodule like "os.path.join"
                  try:
                        lowercase														=	getattr(import_module(""".""".join(__lowerCAmelCase						)						)		,       __lowerCAmelCase						)
                  except (AttributeError, ModuleNotFoundError):
                        return
                  # We iterate over all the globals in self.obj in case we find "os.path.join"
                  for attr in self.obj.__dir__():
                        # We don't check for the name of the global, but rather if its value *is* "os.path.join".
                        # This allows to patch renamed attributes like "from os.path import join as pjoin".
                        if getattr(self.obj		,       __lowerCAmelCase						) is attr_value:
                              lowercase														=	getattr(self.obj		,       __lowerCAmelCase						)
                              setattr(self.obj		,       __lowerCAmelCase		,       self.new						)
            elif target_attr in globals()["__builtins__"]:  # if it'a s builtin like "open"
                  lowercase														=	globals()["""__builtins__"""][target_attr]
                  setattr(self.obj		,       __lowerCAmelCase		,       self.new						)
            else:
                  raise RuntimeError(f'Tried to patch attribute {target_attr} instead of a submodule.'						)

      def __exit__(						self		,       *__lowerCAmelCase						):







            """simple docstring"""



            for attr in list(self.original						):
                  setattr(self.obj		,       __lowerCAmelCase		,       self.original.pop(__lowerCAmelCase						)						)

      def 				A__       (						self						):







            """simple docstring"""



            self.__enter__()
            self._active_patches.append(self						)







      def 				A__       (						self						):







            """simple docstring"""



            try:
                  self._active_patches.remove(self						)
            except ValueError:
                  # If the patch hasn't been started this will fail
                  return None

            return self.__exit__()




"""simple docstring"""






from __future__ import annotations

import numpy as np


def 			UpperCAmelCase__       (				lowerCAmelCase__     :list[float]		) ->    Optional[Any]:
      '''simple docstring'''


      return np.maximum(0					,		lowerCAmelCase__		)


if __name__ == "__main__":
       print(np.array(relu([-1, 0, 5])))  # --> [0, 0, 5]



