


'''simple docstring'''






from importlib import import_module

from .logging import get_logger


a_   :      Any				    =      get_logger(__name__)




class 	a       :
 def __init__(	self ,			__magic_name__ ,			__magic_name__=None  )   ->							Any:
      _a      =							attrs or []
      if module is not None:
           for key in module.__dict__:
                if key in attrs or not key.startswith('__'  ):
                     setattr(self ,			__magic_name__ ,			getattr(__magic_name__ ,			__magic_name__  )  )
      _a      =							module._original_module if isinstance(__magic_name__ ,			_PatchedModuleObj  ) else module





class 	a       :
 _lowerCAmelCase	   =		[]
 def __init__(	self ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__=None  )   ->							int:
      _a      =							obj
      _a      =							target
      _a      =							new
      _a      =							target.split('.'  )[0]
      _a      =							{}
      _a      =							attrs or []
 def __enter__(	self  )   ->							List[Any]:
      *_a ,				_a      =							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(__magic_name__  )  ):
           try:
                _a      =							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__():
                _a      =							getattr(self.obj ,			__magic_name__  )
                # 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(__magic_name__ ,			_PatchedModuleObj  ) and obj_attr._original_module is submodule)
                ):
                     _a      =							obj_attr
                     # patch at top level
                     setattr(self.obj ,			__magic_name__ ,			_PatchedModuleObj(__magic_name__ ,			attrs=self.attrs  )  )
                     _a      =							getattr(self.obj ,			__magic_name__  )
                     # construct lower levels patches
                     for key in submodules[i + 1 :]:
                          setattr(__magic_name__ ,			__magic_name__ ,			_PatchedModuleObj(getattr(__magic_name__ ,			__magic_name__ ,			__magic_name__  ) ,			attrs=self.attrs  )  )
                          _a      =							getattr(__magic_name__ ,			__magic_name__  )
                     # finally set the target attribute
                     setattr(__magic_name__ ,			__magic_name__ ,			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:
                _a      =							getattr(import_module('.'.join(__magic_name__  )  ) ,			__magic_name__  )
           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 ,			__magic_name__  ) is attr_value:
                     _a      =							getattr(self.obj ,			__magic_name__  )
                     setattr(self.obj ,			__magic_name__ ,			self.new  )
      elif target_attr in globals()["__builtins__"]:  # if it'a s builtin like "open"
           _a      =							globals()['__builtins__'][target_attr]
           setattr(self.obj ,			__magic_name__ ,			self.new  )
      else:
           raise RuntimeError(f'Tried to patch attribute {target_attr} instead of a submodule.'  )
 def __exit__(	self ,			*__magic_name__  )   ->							Union[str, Any]:
      for attr in list(self.original  ):
           setattr(self.obj ,			__magic_name__ ,			self.original.pop(__magic_name__  )  )
 def 							__UpperCAmelCase						(	self  )   ->							str:
      self.__enter__()
      self._active_patches.append(self  )




 def 							__UpperCAmelCase						(	self  )   ->							Union[str, Any]:
      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'''






def 		_A			(lowerCAmelCase__					:int						)				->					int:




     '''simple docstring'''



     assert (
         isinstance(lowerCAmelCase__			,  lowerCAmelCase__						) and number_of_steps > 0
     ), f'number_of_steps needs to be positive integer, your input {number_of_steps}'
     if number_of_steps == 1:
          return 1
     _a ,				_a      =							1, 1
     for _ in range(number_of_steps - 1						):
          _a ,				_a      =							current + previous, current
     return current


if __name__ == "__main__":
 import doctest

 doctest.testmod()

