



'''simple docstring'''


from importlib import import_module

from .logging import get_logger


lowercase_      :				Any   					=    get_logger(__name__)




class      __UpperCamelCase       :







	def __init__(    self ,				_lowerCAmelCase ,				_lowerCAmelCase=None						)    ->    Union[str, Any]:
							'''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      __UpperCamelCase       :
	__A			  =					[]







	def __init__(    self ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase=None						)    ->    List[Any]:
							'''simple docstring'''






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







	def __enter__(    self						)    ->    Dict:
							'''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						)    ->    Tuple:
							'''simple docstring'''






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







	def   _a   (    self						)    ->    List[str]:
							'''simple docstring'''






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







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


import os







def      SCREAMING_SNAKE_CASE				(				):
						lowercase        =							os.path.join(os.path.dirname(lowercase_						) ,  """num.txt"""						)
						with open(lowercase_						) as file_hand:
												return str(sum(int(lowercase_						) for line in file_hand						)						)[:10]


if __name__ == "__main__":
						print(solution())


