ó °Éi^ãó–•SSKJr SSKrSSKJr SSKJr SSKJrJ r \(aSSK J r J r SSK Jr S Sjr\S S j5rS SS jjrg)é)Ú annotationsN)Úcontextmanager)Ú import_module)Ú TYPE_CHECKINGÚAny)ÚIteratorÚSequence)ÚPathcóf•S[R<SU<SURRSU3$)NzWith sys.path = z , accessing z raises z: )ÚsysÚpathÚ __class__Ú__name__)ÚerrorÚobjpaths ÚS/home/james-whalen/.local/lib/python3.13/site-packages/griffe/_internal/importer.pyÚ_error_detailsrs3€Ø œcŸh™h™\¨°g±[ÀÈÏÉ×IaÑIaÐHbÐbdÐejÐdkÐ lÐlóc'óØ# •U(dSv• g[RnUVs/sHn[U5PM sn[lSv• U[lgs snf!U[lf=f7f)z³Redefine `sys.path` temporarily. Parameters: *paths: The paths to use when importing modules. If no paths are given, keep `sys.path` untouched. Yields: Nothing. N)r r Ústr)ÚpathsÚold_pathr s rÚsys_pathrsQé€ö Û ØÜx‰x€HÙ&+Ó,¢e˜d”D– ¡eÑ,„C„HðÛ àŒùò -øðŒüs'‚!A*£A¸ A*ÁAÁ A*Á A'Á'A*c ó¢•URS5n/n/n[U=(d S6 U(aSRU5n[U5nO[SRU55eUnUHn [X‰5nM SSS5 U$![aEnUR [ Xu55 URSURS55 SnAOSnAff=fU(aM´N—![aNnUR [ XuS-SRU5-55 [SRU55eSnAff=f!,(df  W$=f)aûDynamically import the specified object. It can be a module, class, method, function, attribute, type alias, nested arbitrarily. It works like this: - for a given object path `a.b.x.y` - it tries to import `a.b.x.y` as a module (with `importlib.import_module`) - if it fails, it tries again with `a.b.x`, storing `y` - then `a.b`, storing `x.y` - then `a`, storing `b.x.y` - if nothing worked, it raises an error - if one of the iteration worked, it moves on, and... - it tries to get the remaining (stored) parts with `getattr` - for example it gets `b` from `a`, then `x` from `b`, etc. - if a single attribute access fails, it raises an error - if everything worked, it returns the last obtained attribute Since the function potentially tries multiple things before succeeding, all errors happening along the way are recorded, and re-emitted with an `ImportError` when it fails, to let users know what was tried. IMPORTANT: The paths given through the `import_paths` parameter are used to temporarily patch `sys.path`: this function is therefore not thread-safe. IMPORTANT: The paths given as `import_paths` must be *correct*. The contents of `sys.path` must be consistent to what a user of the imported code would expect. Given a set of paths, if the import fails for a user, it will fail here too, with potentially unintuitive errors. If we wanted to make this function more robust, we could add a loop to "roll the window" of given paths, shifting them to the left (for example: `("/a/a", "/a/b", "/a/c/")`, then `("/a/b", "/a/c", "/a/a/")`, then `("/a/c", "/a/a", "/a/b/")`), to make sure each entry is given highest priority at least once, maintaining relative order, but we deem this unnecessary for now. Parameters: import_path: The path of the object to import. import_paths: The (sys) paths to import the object from. Raises: ModuleNotFoundError: When the object's module could not be found. ImportError: When there was an import error or when couldn't get the attribute. Returns: The imported object. Ú.©réÿÿÿÿNz; Ú:) ÚsplitrÚjoinrÚ BaseExceptionÚappendrÚinsertÚpopÚ ImportErrorÚgetattr) Ú import_pathÚ import_pathsÚ module_partsÚ object_partsÚerrorsÚ module_pathÚmodulerÚvalueÚparts rÚdynamic_importr0+s6€ð^*×/Ñ/°Ó4€LØ €LØ €Fä L×& BÒ (ÞØŸ(™( <Ó0ˆKð Ü& {Ó3ðä˜dŸi™i¨Ó/Ó0Ð 0ðˆÛ ˆDð 5Ü Ó,’ñ!÷- )ð: €Løô1!ó =ð— ‘ œn¨UÓ@ÔAØ×#Ñ# A |×'7Ñ'7¸Ó';×<Ñ<ûð  =ú÷ ‰løô0!ó 5Ø— ‘ œn¨UÀ#Ñ4EÈÏÉÐQ]ÓH^Ñ4^Ó_Ô`Ü! $§)¡)¨FÓ"3Ó4Ð4ûð 5ú÷3 )Ô (ð: €LúsZ§D?Á BÁ "D?Á/ C$Á:D? CÂ;Cà D?ÃCà D?Ã$ D<Ã.A D7Ä7D<Ä<D?Ä? E)rr!rrÚreturnr)rz str | Pathr1zIterator[None])N)r'rr(zSequence[str | Path] | Noner1r)Ú __future__rr Ú contextlibrÚ importlibrÚtypingrrÚcollections.abcrr Úpathlibr rrr0rrrÚr8s?ðõ #ã Ý%Ý#ß%æß2Ýômðóóð÷*Pr