gQddlmZddlZddlmZddlmZddlmZm Z erddl m Z m Z ddl mZd dZed d Zd dd Zy)) annotationsN)contextmanager) import_module) TYPE_CHECKINGAny)IteratorSequence)Pathcbdtjd|d|jjd|S)NzWith sys.path = z , accessing z raises z: )syspath __class____name__)errorobjpaths E/var/www/openai/venv/lib/python3.12/site-packages/_griffe/importer.py_error_detailsrs3 chh\g[IaIaHbbdejdk llc'K|sdytj}|Dcgc] }t|c}t_ d|t_ycc}w#|t_wxYww)zRedefine `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)pathsold_pathr s rsys_pathrsR  xxH&+,edD e,CH  -s&A"A  A"AA" AA"c x|jd}g}g}t|xsd5|rdj|} t|}ntdj||}|D]} t|| } ddd|S#t$rF}|j t |||jd|jdYd}~nd}~wwxYw|r#t$rO}|j t ||dzdj|ztdj|d}~wwxYw#1swYSxYw)aDynamically import the specified object. It can be a module, class, method, function, attribute, 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. .rNz; :) splitrjoinr BaseExceptionappendrinsertpop ImportErrorgetattr) import_path import_paths module_parts object_partserrors module_pathmodulervalueparts rdynamic_importr0+s7^*//4L L F L&B (((<0K &{3dii/0 0 D 5t,!- ): L1! = nUK@A##A|'7'7';<<  = 0! 5 nUK#4EQ]H^4^_`!$))F"344 53 ): LsYD/ A>"D/% C1D/> C r8s? # %#%2m*Pr