

"""simple docstring"""




from importlib import import_module

from .logging import get_logger


SCREAMING_SNAKE_CASE_     :			int	  =			get_logger(__name__)


class 		_A       :





      def __init__(  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__=None		)   ->					Union[str, Any]:
         lowerCamelCase__						=			attrs or []
         if module is not None:
            for key in module.__dict__:
               if key in attrs or not key.startswith("__"		):
                  setattr(self    ,						__A    ,						getattr(__A    ,						__A		)		)
         lowerCamelCase__						=			module._original_module if isinstance(__A    ,						_PatchedModuleObj		) else module






class 		_A       :
      __a								=	[]





      def __init__(  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__=None		)   ->					List[str]:
         lowerCamelCase__						=			obj
         lowerCamelCase__						=			target
         lowerCamelCase__						=			new
         lowerCamelCase__						=			target.split("."		)[0]
         lowerCamelCase__						=			{}
         lowerCamelCase__						=			attrs or []





      def __enter__(  self		)   ->					Union[str, Any]:
         lowerCamelCase__						=			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(__A		)		):
            try:
               lowerCamelCase__						=			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__():
               lowerCamelCase__						=			getattr(self.obj    ,						__A		)
               # 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(__A    ,						_PatchedModuleObj		) and obj_attr._original_module is submodule)
               ):
                  lowerCamelCase__						=			obj_attr
                  # patch at top level
                  setattr(self.obj    ,						__A    ,						_PatchedModuleObj(__A    ,						attrs=self.attrs		)		)
                  lowerCamelCase__						=			getattr(self.obj    ,						__A		)
                  # construct lower levels patches
                  for key in submodules[i + 1 :]:
                     setattr(__A    ,						__A    ,						_PatchedModuleObj(getattr(__A    ,						__A    ,						__A		)    ,						attrs=self.attrs		)		)
                     lowerCamelCase__						=			getattr(__A    ,						__A		)
                  # finally set the target attribute
                  setattr(__A    ,						__A    ,						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:
               lowerCamelCase__						=			getattr(import_module(".".join(__A		)		)    ,						__A		)
            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    ,						__A		) is attr_value:
                  lowerCamelCase__						=			getattr(self.obj    ,						__A		)
                  setattr(self.obj    ,						__A    ,						self.new		)
         elif target_attr in globals()["__builtins__"]:  # if it'a s builtin like "open"
            lowerCamelCase__						=			globals()["__builtins__"][target_attr]
            setattr(self.obj    ,						__A    ,						self.new		)
         else:
            raise RuntimeError(f'Tried to patch attribute {target_attr} instead of a submodule.'		)





      def __exit__(  self    ,						*SCREAMING_SNAKE_CASE__		)   ->					List[Any]:
         for attr in list(self.original		):
            setattr(self.obj    ,						__A    ,						self.original.pop(__A		)		)





      def 					_lowerCamelCase  (  self		)   ->					Optional[int]:
         self.__enter__()
         self._active_patches.append(self		)





      def 					_lowerCamelCase  (  self		)   ->					List[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"""




# flake8: noqa
# Lint as: python3
SCREAMING_SNAKE_CASE_     :			Dict	  =			[
    '''VerificationMode''',
    '''Version''',
    '''disable_progress_bar''',
    '''enable_progress_bar''',
    '''is_progress_bar_enabled''',
    '''experimental''',
]

from .info_utils import VerificationMode
from .logging import disable_progress_bar, enable_progress_bar, is_progress_bar_enabled
from .version import Version
from .experimental import experimental




