o ei$( @sdZddlZddlZddlZddlZddlZddlmZddlm Z m Z GdddeZ Gddde Z dd e d ed e e fd dZde de fddZ dde de defddZ  dde de de e ded df ddZdS)zG Module importing related utilities. Author * Sylvain de Langen 2024 N) ModuleType)ListOptionalcsZeZdZdZdededeeffdd Zdedefd d Z defd d Z d dZ Z S) LazyModuleaDefines a module type that lazily imports the target module, thus exposing contents without importing the target module needlessly. Arguments --------- name : str Name of the module. target : str Module to be loading lazily. package : str, optional If specified, the target module load will be relative to this package. Depending on how you inject the lazy module into the environment, you may choose to specify the package here, or you may choose to include it into the `name` with the dot syntax. e.g. see how :func:`~lazy_export` and :func:`~deprecated_redirect` differ. nametargetpackagecs"t|||_d|_||_dSN)super__init__r lazy_moduler)selfrrr __class__[/home/ubuntu/transcripts/venv/lib/python3.10/site-packages/speechbrain/utils/importutils.pyr $s  zLazyModule.__init__ stacklevelreturnc Csd}z tt|d}WntytdYnw|dur*|jdr*t|j durgz |j dur@t |j |_ W|j St d|j |j |_ W|j Styf}z tdt|d|d}~ww|j S)arEnsures that the target module is imported and available as `self.lazy_module`, also returning it. Arguments --------- stacklevel : int The stack trace level of the function that caused the import to occur, relative to the **caller** of this function (e.g. if in function `f` you call `ensure_module(1)`, it will refer to the function that called `f`). Raises ------ AttributeError When the function responsible for the import attempt is found to be `inspect.py`, we raise an `AttributeError` here. This is because some code will inadvertently cause our modules to be imported, such as some of PyTorch's op registering machinery. Returns ------- The target module after ensuring it is imported. NzFailed to inspect frame to check if we should ignore importing a module lazily. This relies on a CPython implementation detail, report an issue if you see this with standard Python and include your version number.z /inspect.py.zLazy import of z failed)inspect getframeinfosys _getframeAttributeErrorwarningswarnfilenameendswithr r importlib import_moduler Exception ImportErrorrepr)r rimporter_frameerrr ensure_module/s4   zLazyModule.ensure_modulecCs"d|jd|jd|jdudS)NzLazyModule(package=z , target=z , loaded=))rrr )r rrr__repr__ks"zLazyModule.__repr__cCst|d|SNr)getattrr&)r attrrrr __getattr__nszLazyModule.__getattr__) __name__ __module__ __qualname____doc__strrr intrr&r(r, __classcell__rrrrrs <rcsTeZdZdZ ddededeeffdd Zdd Zd ed e ffd d Z Z S)DeprecatedModuleRedirectaDefines a module type that lazily imports the target module using :class:`~LazyModule`, but logging a deprecation warning when the import is actually being performed. This is only the module type itself; if you want to define a redirection, use :func:`~deprecated_redirect` instead. Arguments --------- old_import : str Old module import path e.g. `mypackage.myoldmodule` new_import : str New module import path e.g. `mypackage.mynewcoolmodule.mycoolsubmodule` extra_reason : str, optional If specified, extra text to attach to the warning for clarification (e.g. justifying why the move has occurred, or additional problems to look out for). N old_import new_import extra_reasoncs"tj||dd||_||_dS)N)rrr)r r r5r7)r r5r6r7rrrr s z!DeprecatedModuleRedirect.__init__cCsBd|jd|jd}|jdur|d|j7}tj|dddS)zREmits the warning for the redirection (with the extra reason if provided).zModule 'z"' was deprecated, redirecting to 'z'. Please update your script.N )r)r5rr7rr)r warning_textrrr_redirection_warns   z*DeprecatedModuleRedirect._redirection_warnrrcs*|jdu}t|d}|r||Sr))r r r&r;)r r should_warnmodulerrrr&s z&DeprecatedModuleRedirect.ensure_moduler ) r-r.r/r0r1rr r;r2rr&r3rrrrr4ss r4F file_pathfind_subpackagesrcCspg}tj|}t|D](}|drq |dr#||dd|r5tjtj||r5||q |S)aReturns a list of importable scripts in the same module as the specified file. e.g. if you have `foo/__init__.py` and `foo/bar.py`, then `files_in_module("foo/__init__.py")` then the result will be `["bar"]`. Not recursive; this is only applies to the direct modules/subpackages of the package at the given path. Arguments --------- file_path : str Path of the file to navigate the directory of. Typically the `__init__.py` path this is called from, using `__file__`. find_subpackages : bool Whether we should find the subpackages as well. Returns ------- imports : List[str] List of importable scripts with the same module. __z.pyN) ospathdirnamelistdir startswithrappendisdirjoin)r>r?imports module_dirrrrr find_importss      rLrrcCs2ttj||r dSttj||t|||dS)aMakes `name` lazily available under the module list for the specified `package`, unless it was loaded already, in which case it is ignored. Arguments --------- name : str Name of the module, as long as it can get imported with `{package}.{name}`. package : str The relevant package, usually determined with `__name__` from the `__init__.py`. Returns ------- None N)hasattrrmodulessetattrr)rrrrr lazy_exportsrPinit_file_pathexport_subpackagescCs t||dD]}t||qdS)aMakes all modules under a module lazily importable merely by accessing them; e.g. `foo/bar.py` could be accessed with `foo.bar.some_func()`. Arguments --------- init_file_path : str Path of the `__init__.py` file, usually determined with `__file__` from there. package : str The relevant package, usually determined with `__name__` from the `__init__.py`. export_subpackages : bool Whether we should make the subpackages (subdirectories) available directly as well. )r?N)rLrP)rQrrRrrrrlazy_export_alls  rSr5r6r7also_lazy_exportcCspt|||d}|tj|<|r4|d}|d|}||dd}ttj||s6ttj|||dSdSdS)aPatches the module list to add a lazy redirection from `old_import` to `new_import`, emitting a `DeprecationWarning` when imported. Arguments --------- old_import : str Old module import path e.g. `mypackage.myoldmodule` new_import : str New module import path e.g. `mypackage.mycoolpackage.mynewmodule` extra_reason : str, optional If specified, extra text to attach to the warning for clarification (e.g. justifying why the move has occurred, or additional problems to look out for). also_lazy_export : bool Whether the module should also be exported as a lazy module in the package determined in `old_import`. e.g. if you had a `foo.bar.somefunc` import as `old_import`, assuming you have `foo` imported (or lazy loaded), you could use `foo.bar.somefunc` directly without importing `foo.bar` explicitly. )r7rNr)r4rrNrfindrMrO)r5r6r7rTredirectpackage_sep_idx old_package old_modulerrrdeprecated_redirects   rZ)F)NF)r0rrrBrrtypesrtypingrrrr4r1boolrLrPrSrZrrrrsB bA)