�
Ϫ�f�h � �6 � d Z ddlmZ ddlZddlZddlZddlZddlmZm Z
ddl m Z m
Z
ddlmZ ddlmZ ddlmZmZ dd lmZ dd
lmZ e� Zd gZe du Z e rej; d � nej; d
� d� Z d� Z G d� d� Z G d� d� Z! G d� de � Z" G d� de � Z# G d� de � Z$ e
e$� G d� d� � Z% e%� Z& e
e$� G d � d � � Z' ee'ejP e$� d � Z) G d � d � Z* e*� Z+d$d!�Z,d"� Z-d#� Z.y)%a_
This module aims to provide a unified, object-oriented view of Python's
runtime hierarchy.
Python is a very dynamic language with wide variety of introspection utilities.
However, these utilities can be hard to use, because there is no consistent
API. The introspection API in python is made up of attributes (__name__,
__module__, func_name, etc) on instances, modules, classes and functions which
vary between those four types, utility modules such as 'inspect' which provide
some functionality, the 'imp' module, the "compiler" module, the semantics of
PEP 302 support, and setuptools, among other things.
At the top, you have "PythonPath", an abstract representation of sys.path which
includes methods to locate top-level modules, with or without loading them.
The top-level exposed functions in this module for accessing the system path
are "walkModules", "iterModules", and "getModule".
From most to least specific, here are the objects provided::
PythonPath # sys.path
|
v
PathEntry # one entry on sys.path: an importer
|
v
PythonModule # a module or package that can be loaded
|
v
PythonAttribute # an attribute of a module (function or class)
|
v
PythonAttribute # an attribute of a function or class
|
v
...
Here's an example of idiomatic usage: this is what you would do to list all of
the modules outside the standard library's python-files directory::
import os
stdlibdir = os.path.dirname(os.__file__)
from twisted.python.modules import iterModules
for modinfo in iterModules():
if (modinfo.pathEntry.filePath.path != stdlibdir
and not modinfo.isPackage()):
print('unpackaged: %s: %s' % (
modinfo.name, modinfo.filePath.path))
@var theSystemPath: The very top of the Python object space.
@type theSystemPath: L{PythonPath}
� )� annotationsN)�dirname�split)� Interface� implementer�� nativeString)�registerAdapter)�FilePath�UnlistableError)�namedAny)�
ZipArchivez.pyz.pyoz.pycc �8 � t | � }d|vxr
d|vxr d|vS )z�
cheezy fake test for proper identifier-ness.
@param string: a L{str} which might or might not be a valid python
identifier.
@return: True or False
� �.�-r )�string�
textStrings �8/usr/lib/python3/dist-packages/twisted/python/modules.py�_isPythonIdentifierr W s- � � �f�%�J� �j� � T�S�
�%:� T�s�*�?T�T� c �N � | j � d }t |� d }|dk( S )Nr � �__init__)�splitext� splitpath)�fpath�extless�basends r �_isPackagePathr c s/ � � �n�n� �q�!�G�
�w�
��
"�F� �Z� � r c �< � e Zd ZdZd� Zd
d�Zd� Zd� Zd� Zd� Z d� Z
y ) �_ModuleIteratorHelperz�
This mixin provides common behavior between python module and path entries,
since the mechanism for searching sys.path and __path__ attributes is
remarkably similar.
c # �T K � i }| j j � sy| j � D �]c } t |j � � }|D �]@ }|j
� d }|j � dt |� }|t v rft |� s�H| j |� }|j d� d dk( r�q||vs�vd||< t ||| j � � }|| k7 sJ �|�� ��|st |� r|j � s��| j |j � � }t D ]Y }|j! d|z � } | j � s�(||vs�-d||< t || | j � � }|| k7 sJ �|�� ��@ ��C ��f y# t
$ r Y ��tw xY w�w)a
Loop over the modules present below this entry or package on PYTHONPATH.
For modules which are not packages, this will yield nothing.
For packages and path entries, this will only yield modules one level
down; i.e. if there is a package a.b.c, iterModules on a will only
return a.b. If you want to descend deeply, use walkModules.
@return: a generator which yields PythonModule instances that describe
modules which can be, or have been, imported.
Nr r ���r T)�filePath�exists�
_packagePaths�sorted�childrenr r �basename�len�PYTHON_EXTENSIONSr �_subModuleNamer � PythonModule� _getEntry�isdir�child)
�self�yielded� placeToLookr) �potentialTopLevel�ext�potentialBasename�modname�pm�initpys
r � iterModulesz!_ModuleIteratorHelper.iterModulesr s� � �� � ���}�}�#�#�%� � �-�-�/� ( "�K�
�!�+�"6�"6�"8�9�� &.� "
"�!�'�0�0�2�1�5��$5�$>�$>�$@��C��H�9�$M�!��+�+� /�/@�A� � "� 1� 1�2C� D�G� �}�}�S�)�"�-��;� !� �g�-�+/���(� )�'�3D�d�n�n�FV� W�� !�T�z�)�z� �� � 2�3D� E� 0� 6� 6� 8� � "� 1� 1�2C�2L�2L�2N� O�G� 0� "��!2�!8�!8��c�9I�!J��!�=�=�?�w�g�/E�/3�G�G� ,�!-�g�v�t�~�~�?O�!P�B�#%��:� -�:�"$�H� !�"�7"
"�
( "�� #�
��
�s< �2F(�F�A7F(�BF(� F(�"6F(� F%�!F(�$F%�%F(c # �v K � | �� | j � D ] }|j |�� E d{ ��� � y7 ��w)z�
Similar to L{iterModules}, this yields self, and then every module in my
package or entry, and every submodule in each package or entry.
In other words, this is deep, and L{iterModules} is shallow.
��importPackagesN�r; � walkModules�r2 r> �packages r r@ z!_ModuleIteratorHelper.walkModules� sA � �� � �
��'�'�)� J�G� �*�*�.�*�I� I� I� J� I�s �-9�7�9c � � |S )z�
This is a hook to provide packages with the ability to specify their names
as a prefix to submodules here.
� �r2 �mns r r- z$_ModuleIteratorHelper._subModuleName� s � �
� r c � � t � �)z�
Implement in subclasses to specify where to look for modules.
@return: iterable of FilePath-like objects.
��NotImplementedError�r2 s r r' z#_ModuleIteratorHelper._packagePaths� s
� � "�#�#r c � � t � �)z�
Implement in subclasses to specify what path entry submodules will come
from.
@return: a PathEntry instance.
rH rJ s r r/ z _ModuleIteratorHelper._getEntry� s
� � "�#�#r c � � | j � D ]$ }|j | j |� k( s�"|c S t |� �)a(
Retrieve a module from below this path or package.
@param modname: a str naming a module to be loaded. For entries, this
is a top-level, undotted package name, and for packages it is the name
of the module without the package prefix. For example, if you have a
PythonModule representing the 'twisted' package, you could use::
twistedPackageObj['python']['modules']
to retrieve this module.
@raise KeyError: if the module is not found.
@return: a PythonModule.
)r; �namer- �KeyError)r2 r8 �modules r � __getitem__z!_ModuleIteratorHelper.__getitem__� sE � �" �&�&�(� �F��{�{�d� 1� 1�'� :�:� �
� � �w� � r c � � t � �)aD
Implemented to raise NotImplementedError for clarity, so that attempting to
loop over this object won't call __getitem__.
Note: in the future there might be some sensible default for iteration,
like 'walkEverything', so this is deliberately untested and undefined
behavior.
rH rJ s r �__iter__z _ModuleIteratorHelper.__iter__� s
� � "�#�#r N�F) �__name__�
__module__� __qualname__�__doc__r; r@ r- r' r/ rP rR rD r r r" r" k s, � �� 9"�v J��$�$� �, $r r" c �J � e Zd ZdZ dd�Zd d�Zd� Zefd�Zd� Z y)
�PythonAttributeag
I represent a function, class, or other object that is present.
@ivar name: the fully-qualified python name of this attribute.
@ivar onObject: a reference to a PythonModule or other PythonAttribute that
is this attribute's logical parent.
@ivar name: the fully qualified python name of the attribute represented by
this class.
c �< � || _ || _ || _ || _ y)aJ
Create a PythonAttribute. This is a private constructor. Do not construct
me directly, use PythonModule.iterAttributes.
@param name: the FQPN
@param onObject: see ivar
@param loaded: always True, for now
@param pythonValue: the value of the attribute we're pointing to.
N)rM �onObject�_loaded� pythonValue)r2 rM r[ �loadedr] s r r zPythonAttribute.__init__� s! � � �� � ��
� �� �&��r c �" � d| j �d�S )NzPythonAttribute<�>�rM rJ s r �__repr__zPythonAttribute.__repr__ s � �!�$�)�)� �a�0�0r c � � | j S )a
Return a boolean describing whether the attribute this describes has
actually been loaded into memory by importing its module.
Note: this currently always returns true; there is no Python parser
support in this module yet.
)r\ rJ s r �isLoadedzPythonAttribute.isLoaded s � � �|�|�r c � � | j S )z�
Load the value associated with this attribute.
@return: an arbitrary Python object, or 'default' if there is an error
loading it.
)r] �r2 �defaults r �loadzPythonAttribute.load s � � � � � r c # � K � t j | j � � D ]% \ }}t | j dz |z | d|� �� �' y �w)Nr T)�inspect�
getmembersrh rY rM �r2 rM �vals r �iterAttributesz PythonAttribute.iterAttributes& sJ � �� � �+�+�D�I�I�K�8� K�I�D�#�!�$�)�)�c�/�D�"8�$��c�J� J� K�s �A
AN)
rM �strr[ rY r^ �boolr] �object�return�None�rr ro )
rT rU rV rW r rb rd �_nothingrh rn rD r r rY rY � sN � �
�'��'�#2�'�<@�'�OU�'�
�'�"1� � $� �Kr rY c �z � � e Zd ZdZ d
d�Zd� Zdd�Zd� Zd� Zd� Z e
fd�Z dd �Z d� fd
� Z
d � Zd � Z� xZS )r. a?
Representation of a module which could be imported from sys.path.
@ivar name: the fully qualified python name of this module.
@ivar filePath: a FilePath-like object which points to the location of this
module.
@ivar pathEntry: a L{PathEntry} instance which this module was located
from.
c � � t |� }|j d� rJ �|| _ || _ |j � | _ || _ y)z�
Create a PythonModule. Do not construct this directly, instead inspect a
PythonPath or other PythonModule instances.
@param name: see ivar
@param filePath: see ivar
@param pathEntry: see ivar
z .__init__N)r �endswithrM r% �parent�
parentPath� pathEntry)r2 rM r% r{ �_names r r zPythonModule.__init__8 sC � � �T�"���>�>�+�.�.�.� �� � ��
�"�/�/�+���"��r c � � | j S �N)r{ rJ s r r/ zPythonModule._getEntryJ s � ��~�~� r c �" � d| j �d�S )zK
Return a string representation including the module name.
z
PythonModule<r` ra rJ s r rb zPythonModule.__repr__M s � � �t�y�y�m�1�-�-r c �x � | j j j j | j � duS )z�
Determine if the module is loaded into sys.modules.
@return: a boolean: true if loaded, false if not.
N)r{ �
pythonPath�
moduleDict�getrM rJ s r rd zPythonModule.isLoadedS s. � � �~�~�(�(�3�3�7�7�� � �B�$�N�Nr c # �� K � | j � s t d� �t j | j � � D ]% \ }}t | j dz |z | d|� �� �' y�w)a
List all the attributes defined in this module.
Note: Future work is planned here to make it possible to list python
attributes on a module without loading the module by inspecting ASTs or
bytecode, but currently any iteration of PythonModule objects insists
they must be loaded, and will use inspect.getmodule.
@raise NotImplementedError: if this module is not loaded.
@return: a generator yielding PythonAttribute instances describing the
attributes of this module.
z6You can't load attributes from non-loaded modules yet.r TN)rd rI rj rk rh rY rM rl s r rn zPythonModule.iterAttributes[ sg � �� � �}�}��%�H��
� !�+�+�D�I�I�K�8� K�I�D�#�!�$�)�)�c�/�D�"8�$��c�J� J� K�s �A(A*c �, � t | j � S )zt
Returns true if this module is also a package, and might yield something
from iterModules.
)r r% rJ s r � isPackagezPythonModule.isPackagep s � �
�d�m�m�,�,r c � � | j j j | j � S # t $ r |t
ur|cY S � w xY w)aX
Load this module.
@param default: if specified, the value to return in case of an error.
@return: a genuine python module.
@raise Exception: Importing modules is a risky business;
the erorrs of any code run at module scope may be raised from here, as
well as ImportError if something bizarre happened to the system path
between the discovery of this PythonModule object and the attempt to
import it. If you specify a default, the error will be swallowed
entirely, and not logged.
@rtype: types.ModuleType.
)r{ r� � moduleLoaderrM �
BaseExceptionru rf s r rh zPythonModule.loadw sE � �" ��>�>�,�,�9�9�$�)�)�D� D�� � ��h�&� �� � �s �.1 �A�Ac �` � t |t � r|j | j k( S t S )z=
PythonModules with the same name are equal.
)�
isinstancer. rM �NotImplemented)r2 �others r �__eq__zPythonModule.__eq__� s' � � �e�\� *��:�:����*� *� � r c �h �� |r | j � r| j � t �| �
|�� S )Nr= )r� rh �superr@ )r2 r> � __class__s �r r@ zPythonModule.walkModules� s+ �� � �d�n�n� .� �I�I�K��w�"�.�"�A�Ar c �& � | j dz |z S )zG
submodules of this module are prefixed with our name.
r ra rE s r r- zPythonModule._subModuleName� s � � �y�y�3���#�#r c # �� K � | j � sy| j � r�| j � }t |d� r�|j D ]� }|| j
j k( r+| j
j � sJ �| j
�� �G| j j j |� }|j � s�}|�� �� yy| j
�� y�w)zZ
Yield a sequence of FilePath-like objects which represent path segments.
N�__path__) r� rd rh �hasattrr� rz �pathr& r{ r� �
_smartPath)r2 rh �fn�smps r r' zPythonModule._packagePaths� s� � �� � �~�~� � � �=�=�?��9�9�;�D��t�Z�(� �-�-� &�B��T�_�_� 1� 1�1� #��� 5� 5� 7�7� 7� "�o�o�-� "�n�n� 7� 7� B� B�2� F�� �:�:�<�"%�I�&� )� �/�/� !�s �CC � C )rM ro r% z
FilePath[str]r{ � PathEntryrr rs rt )r� rq rr rp rS )rT rU rV rW r r/ rb rd rn r� ru rh r� r@ r- r' �
__classcell__)r� s @r r. r. + sg �� �
�#��#�#0�#�=F�#�
�#�$ �.� O�K�*-� $� �0 �B�
$� "r r. c �* � e Zd ZdZd� Zd� Zdd�Zd� Zy)r� z�
I am a proxy for a single entry on sys.path.
@ivar filePath: a FilePath-like object pointing at the filesystem location
or archive file where this path entry is stored.
@ivar pythonPath: a PythonPath instance.
c � � || _ || _ y)zE
Create a PathEntry. This is a private constructor.
N)r% r� )r2 r% r� s r r zPathEntry.__init__� s � � !��
�$��r c � � | S r~ rD rJ s r r/ zPathEntry._getEntry� s � �� r c �" � d| j �d�S )Nz
PathEntry<r` �r% rJ s r rb zPathEntry.__repr__� s � ��D�M�M�,�A�.�.r c # �( K � | j �� y �wr~ r� rJ s r r' zPathEntry._packagePaths� s � �� ��m�m��s �Nrt )rT rU rV rW r r/ rb r' rD r r r� r� � s � ��%��/� r r� c � � e Zd ZdZd� Zy)�IPathImportMapperzj
This is an internal interface, used to map importers to factories for
FilePath-like objects.
c � � y)a
Return a FilePath-like object.
@param pathLikeString: a path-like string, like one that might be
passed to an import hook.
@return: a L{FilePath}, or something like it (currently only a
L{ZipPath}, but more might be added later).
NrD )�pathLikeStrings r �mapPathzIPathImportMapper.mapPath� s � r N�rT rU rV rW r� rD r r r� r� � s � ��
r r� c � � e Zd ZdZd� Zy)�_DefaultMapImplz,Wrapper for the default importer, i.e. None.c � � t |� S r~ )r )r2 � fsPathStrings r r� z_DefaultMapImpl.mapPath� s
� �� �%�%r Nr� rD r r r� r� � s
� �6�&r r� c � � e Zd ZdZd� Zd� Zy)� _ZipMapImplz;IPathImportMapper implementation for zipimport.ZipImporter.c � � || _ y r~ )�importer)r2 r� s r r z_ZipMapImpl.__init__� s � � ��
r c � � t | j j � }t | j j � }t |� }||k( r|S |j |� }|}|D ] }|j |� }� |S )a
Map the given FS path to a ZipPath, by looking at the ZipImporter's
"archive" attribute and using it as our ZipArchive root, then walking
down into the archive from there.
@return: a L{zippath.ZipPath} or L{zippath.ZipArchive} instance.
)r r� �archiver � segmentsFromr1 )r2 r� �za�myPath�itsPath�segs�zp�segs r r� z_ZipMapImpl.mapPath� s{ � � ��
�
�-�-�
.���$�-�-�/�/�0���<�(�� �W� ��I�
�#�#�F�+��
��� �C����#� �B� �� r N)rT rU rV rW r r� rD r r r� r� � s � �E�!�r r� c �" � t j S )z�
Provide the default behavior of PythonPath's sys.path factory, which is to
return the current value of sys.path.
@return: L{sys.path}
)�sysr� rD r r �_defaultSysPathFactoryr� s
� � �8�8�Or c � � e Zd ZdZdej
ej ej edfd�Z e
d� � Z d� Z d� Z
d� Zd� Zd � Zd
d
�Zd � Zdd �Zy)�
PythonPatha�
I represent the very top of the Python object-space, the module list in
C{sys.path} and the modules list in C{sys.modules}.
@ivar _sysPath: A sequence of strings like C{sys.path}. This attribute is
read-only.
@ivar sysPath: The current value of the module search path list.
@type sysPath: C{list}
@ivar moduleDict: A dictionary mapping string module names to module
objects, like C{sys.modules}.
@ivar sysPathHooks: A list of PEP-302 path hooks, like C{sys.path_hooks}.
@ivar moduleLoader: A function that takes a fully-qualified python name and
returns a module, like L{twisted.python.reflect.namedAny}.
Nc �z �� ���fd�}n|�t }|| _ �| _ || _ || _ || _ || _ y)aJ
Create a PythonPath. You almost certainly want to use
modules.theSystemPath, or its aliased methods, rather than creating a
new instance yourself, though.
All parameters are optional, and if unspecified, will use 'system'
equivalents that makes this PythonPath like the global L{theSystemPath}
instance.
@param sysPath: a sys.path-like list to use for this PythonPath, to
specify where to load modules from.
@param moduleDict: a sys.modules-like dictionary to use for keeping
track of what modules this PythonPath has loaded.
@param sysPathHooks: sys.path_hooks-like list of PEP-302 path hooks to
be used for this PythonPath, to determie which importers should be
used.
@param importerCache: a sys.path_importer_cache-like list of PEP-302
importers. This will be used in conjunction with the given
sysPathHooks.
@param moduleLoader: a module loader function which takes a string and
returns a module. That is to say, it is like L{namedAny} - *not* like
L{__import__}.
@param sysPathFactory: a 0-argument callable which returns the current
value of a sys.path-like list of strings. Specify either this, or
sysPath, not both. This alternative interface is provided because the
way the Python import mechanism works, you can re-bind the 'sys.path'
name and that is what is used for current imports, so it must be a
factory rather than a value to deal with modification by rebinding
rather than modification by mutation. Note: it is not recommended to
rebind sys.path. Although this mechanism can deal with that, it is a
subtle point which some tools that it is easy for tools which interact
with sys.path to miss.
Nc � �� � S r~ rD )�sysPaths �r �<lambda>z%PythonPath.__init__.<locals>.<lambda>` s �� �W� r )r� �_sysPathFactory�_sysPathr� � sysPathHooks�
importerCacher� )r2 r� r� r� r� r� �sysPathFactorys ` r r zPythonPath.__init__0 sJ �� �^ � � ,�N�
�
#� 3�N� -�� � ��
�$��� (��� *��� (��r c �" � | j � S )zL
Retrieve the current value of the module search path list.
)r� rJ s r r� zPythonPath.sysPathj s � �
�#�#�%�%r c �� � |}d|j v rI| j dj |j j d� dd � }d|j v r�It t |j � � r t t |j � � }nt |j � }|| j vr't j |�d|j �d�d�� |S )zl
Determine where a given Python module object came from by looking at path
entries.
r Nr$ z
(for module zR) not in path importer cache (PEP 302 violation - check your local configuration).� )�
stacklevel) rT r� �joinr r r �__file__r r� �warnings�warn)r2 �modobj�
topPackageObj�rvals r �_findEntryPathStringz PythonPath._findEntryPathStringq s� � �
�
��]�+�+�+� �O�O���� �/�/�5�5�c�:�3�B�?�@� �M� �]�+�+�+� �(�=�#9�#9�:� ;� �7�=�#9�#9�:�;�D� �=�1�1�2�D� �t�)�)� )� �M�M� �� � �*� �
� � r c � � | j j |t � }|t u r$| j D ] } ||� }�
|t u rd}t |t � j |� S # t $ r Y �Bw xY w)z�
Given a path entry from sys.path which may refer to an importer,
return the appropriate FilePath-like instance.
@param pathName: a str describing the path.
@return: a FilePath-like object.
N)r� r� ru r� � ImportErrorr� �_theDefaultMapperr� )r2 �pathName�importr�hooks r r� zPythonPath._smartPath� s� � � �$�$�(�(��8�<�� �h� � �)�)�
��� "�8�n�G�
�
�(�"� �� ��*;�<�D�D�X�N�N�� #� ���s �A,�, A8�7A8c # �l K � | j D ]! }| j |� }t || � �� �# y�w)zm
Iterate the entries on my sysPath.
@return: a generator yielding PathEntry objects
N)r� r� r� )r2 r� �fps r � iterEntrieszPythonPath.iterEntries� s6 � �� � � � � &�H�� � ��*�B��B��%� %� &�s �24c � � | j j |� }|�Rt | j | j |� � | � }| j |j
� }t
|||� S d|v r | }|j d� D ] }|| }� |S | j � D ] }|j |k( s�|c S t |� �)a�
Get a python module by its given fully-qualified name.
@param modname: The fully-qualified Python module name to load.
@type modname: C{str}
@return: an object representing the module identified by C{modname}
@rtype: L{PythonModule}
@raise KeyError: if the module name is not a valid module name, or no
such module can be identified as loadable.
r ) r� r� r� r� r� r� r. r r; rM rN )r2 r8 � moduleObject�pe�mp�pkgrM rO s r rP zPythonPath.__getitem__� s� � � ���*�*�7�3� � � #������ 9� 9�,� G�H�$��B� � � � �!6�!6�7�B� ���R�0� 0� �'�>��C� �
�
�c�*�
���$�i��
��J� �&�&�(� �F��{�{�g�%� �
� � �w� � r c �F � | j |� y# t $ r Y yw xY w)z�
Check to see whether or not a module exists on my import path.
@param module: The name of the module to look for on my import path.
@type module: C{str}
TF)rP rN )r2 rO s r � __contains__zPythonPath.__contains__� s* � � � � � �V� $���� �� �s � � � c �< � d| j �d| j �d�S )zO
Display my sysPath and moduleDict in a string representation.
z PythonPath(�,�))r� r� rJ s r rb zPythonPath.__repr__� s# � � �T�\�\� ,�A�d�o�o�-@��B�Br c # �j K � | j � D ] }|j � E d{ ��� � y7 ��w)z<
Yield all top-level modules on my sysPath.
N)r� r; )r2 �entrys r r; zPythonPath.iterModules� s5 � �� � �%�%�'� +�E� �(�(�*� *� *� +� *�s �'3�1�3c # �n K � | j � D ] }|j d�� E d{ ��� � y7 ��w)z�
Similar to L{iterModules}, this yields every module on the path, then every
submodule in each package or entry.
Fr= Nr? rA s r r@ zPythonPath.walkModules� s< � �� �
�'�'�)� A�G� �*�*�%�*�@� @� @� A� @�s �)5�3�5rt rS )rT rU rV rW r� �modules�
path_hooks�path_importer_cacher
r �propertyr� r� r� r� rP r� rb r; r@ rD r r r� r� sp � ��* ��;�;��^�^��-�-� ��8)�t �&� �&� �DO�(&�$ �L �C� +�Ar r� c �. � t j | �� S )z}
Deeply iterate all modules on the global python path.
@param importPackages: Import packages as they are seen.
r= )�
theSystemPathr@ r= s r r@ r@ � s � � � $� $�N� $� C�Cr c �* � t j � S )zu
Iterate all modules and top-level packages on the global Python path, but
do not descend into packages.
)r� r; rD r r r; r; s � �
� $� $� &�&r c � � t | S )z1
Retrieve a module from the system path.
)r� )�
moduleNames r � getModuler� s � � �� $�$r rS )/rW �
__future__r rj r� r� � zipimport�os.pathr r r �zope.interfacer r �twisted.python.compatr �twisted.python.componentsr
�twisted.python.filepathr r �twisted.python.reflectr
�twisted.python.zippathr rq ru r, �OPTIMIZED_MODE�appendr r r" rY r. r� r� r� r� r� � zipimporterr� r� r� r@ r; r� rD r r �<module>r� sC ��
4�l #� �
� � � 0� 1� .� 5� =� +� -� �8���G� ��D� ���� � �V�$�� � �V�$� U� �D$� D$�N6K� 6K�rJ"�(� J"�Z �%� �6 � � �$
�
� �&� &� �&� $�%� �
�
� �� � ��< � �Y� 2� 2�4E� F��[A� [A�| � �
�D�'�%r |