Back to index

python3.2  3.2.2
Public Member Functions
importlib.abc.InspectLoader Class Reference
Inheritance diagram for importlib.abc.InspectLoader:
Inheritance graph
[legend]
Collaboration diagram for importlib.abc.InspectLoader:
Collaboration graph
[legend]

List of all members.

Public Member Functions

def is_package
def get_code
def get_source
def load_module
def __new__
def register
def __instancecheck__
def __subclasscheck__

Detailed Description

Abstract base class for loaders which support inspection about the
modules they can load.

This ABC represents one of the optional protocols specified by PEP 302.

Definition at line 60 of file abc.py.


Member Function Documentation

def abc.ABCMeta.__instancecheck__ (   cls,
  instance 
) [inherited]
Override for isinstance(instance, cls).

Definition at line 158 of file abc.py.

00158 
00159     def __instancecheck__(cls, instance):
00160         """Override for isinstance(instance, cls)."""
00161         # Inline the cache checking
00162         subclass = instance.__class__
00163         if subclass in cls._abc_cache:
00164             return True
00165         subtype = type(instance)
00166         if subtype is subclass:
00167             if (cls._abc_negative_cache_version ==
00168                 ABCMeta._abc_invalidation_counter and
00169                 subclass in cls._abc_negative_cache):
00170                 return False
00171             # Fall back to the subclass check.
00172             return cls.__subclasscheck__(subclass)
00173         return any(cls.__subclasscheck__(c) for c in {subclass, subtype})

Here is the call graph for this function:

def abc.ABCMeta.__new__ (   mcls,
  name,
  bases,
  namespace 
) [inherited]

Definition at line 116 of file abc.py.

00116 
00117     def __new__(mcls, name, bases, namespace):
00118         cls = super().__new__(mcls, name, bases, namespace)
00119         # Compute set of abstract method names
00120         abstracts = {name
00121                      for name, value in namespace.items()
00122                      if getattr(value, "__isabstractmethod__", False)}
00123         for base in bases:
00124             for name in getattr(base, "__abstractmethods__", set()):
00125                 value = getattr(cls, name, None)
00126                 if getattr(value, "__isabstractmethod__", False):
00127                     abstracts.add(name)
00128         cls.__abstractmethods__ = frozenset(abstracts)
00129         # Set up inheritance registry
00130         cls._abc_registry = WeakSet()
00131         cls._abc_cache = WeakSet()
00132         cls._abc_negative_cache = WeakSet()
00133         cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
00134         return cls

Here is the call graph for this function:

def abc.ABCMeta.__subclasscheck__ (   cls,
  subclass 
) [inherited]
Override for issubclass(subclass, cls).

Definition at line 174 of file abc.py.

00174 
00175     def __subclasscheck__(cls, subclass):
00176         """Override for issubclass(subclass, cls)."""
00177         # Check cache
00178         if subclass in cls._abc_cache:
00179             return True
00180         # Check negative cache; may have to invalidate
00181         if cls._abc_negative_cache_version < ABCMeta._abc_invalidation_counter:
00182             # Invalidate the negative cache
00183             cls._abc_negative_cache = WeakSet()
00184             cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
00185         elif subclass in cls._abc_negative_cache:
00186             return False
00187         # Check the subclass hook
00188         ok = cls.__subclasshook__(subclass)
00189         if ok is not NotImplemented:
00190             assert isinstance(ok, bool)
00191             if ok:
00192                 cls._abc_cache.add(subclass)
00193             else:
00194                 cls._abc_negative_cache.add(subclass)
00195             return ok
00196         # Check if it's a direct subclass
00197         if cls in getattr(subclass, '__mro__', ()):
00198             cls._abc_cache.add(subclass)
00199             return True
00200         # Check if it's a subclass of a registered class (recursive)
00201         for rcls in cls._abc_registry:
00202             if issubclass(subclass, rcls):
00203                 cls._abc_cache.add(subclass)
00204                 return True
00205         # Check if it's a subclass of a subclass (recursive)
00206         for scls in cls.__subclasses__():
00207             if issubclass(subclass, scls):
00208                 cls._abc_cache.add(subclass)
00209                 return True
00210         # No dice; update negative cache
00211         cls._abc_negative_cache.add(subclass)
00212         return False

Here is the call graph for this function:

def importlib.abc.InspectLoader.get_code (   self,
  fullname 
)
Abstract method which when implemented should return the code object
for the module.  The fullname is a str.  Returns a types.CodeType.

Reimplemented in importlib.test.source.test_abc_loader.AbstractMethodImplTests.InspectLoader, importlib.abc.PyPycLoader, and importlib.test.source.test_abc_loader.PyPycLoaderMock.

Definition at line 76 of file abc.py.

00076 
00077     def get_code(self, fullname):
00078         """Abstract method which when implemented should return the code object
00079         for the module.  The fullname is a str.  Returns a types.CodeType."""
00080         raise NotImplementedError

Here is the caller graph for this function:

def importlib.abc.InspectLoader.get_source (   self,
  fullname 
)
Abstract method which should return the source code for the
module.  The fullname is a str.  Returns a str.

Reimplemented in importlib.test.source.test_abc_loader.AbstractMethodImplTests.InspectLoader.

Definition at line 82 of file abc.py.

00082 
00083     def get_source(self, fullname):
00084         """Abstract method which should return the source code for the
00085         module.  The fullname is a str.  Returns a str."""
00086         raise NotImplementedError
00087 
00088 InspectLoader.register(machinery.BuiltinImporter)
00089 InspectLoader.register(machinery.FrozenImporter)
00090 

Here is the caller graph for this function:

def importlib.abc.InspectLoader.is_package (   self,
  fullname 
)
Abstract method which when implemented should return whether the
module is a package.  The fullname is a str.  Returns a bool.

Reimplemented in importlib.test.source.test_abc_loader.AbstractMethodImplTests.InspectLoader, importlib.test.source.test_abc_loader.PyPycLoaderMock, importlib.abc.PyLoader, and importlib.test.source.test_abc_loader.PyLoaderMock.

Definition at line 70 of file abc.py.

00070 
00071     def is_package(self, fullname):
00072         """Abstract method which when implemented should return whether the
00073         module is a package.  The fullname is a str.  Returns a bool."""
00074         raise NotImplementedError

def importlib.abc.Loader.load_module (   self,
  fullname 
) [inherited]
Abstract method which when implemented should load a module.
The fullname is a str.

Reimplemented in importlib.test.source.test_abc_loader.AbstractMethodImplTests.Loader.

Definition at line 21 of file abc.py.

00021 
00022     def load_module(self, fullname):
00023         """Abstract method which when implemented should load a module.
00024         The fullname is a str."""
00025         raise NotImplementedError
00026 

Here is the caller graph for this function:

def abc.ABCMeta.register (   cls,
  subclass 
) [inherited]
Register a virtual subclass of an ABC.

Definition at line 135 of file abc.py.

00135 
00136     def register(cls, subclass):
00137         """Register a virtual subclass of an ABC."""
00138         if not isinstance(subclass, type):
00139             raise TypeError("Can only register classes")
00140         if issubclass(subclass, cls):
00141             return  # Already a subclass
00142         # Subtle: test for cycles *after* testing for "already a subclass";
00143         # this means we allow X.register(X) and interpret it as a no-op.
00144         if issubclass(cls, subclass):
00145             # This would create a cycle, which is bad for the algorithm below
00146             raise RuntimeError("Refusing to create an inheritance cycle")
00147         cls._abc_registry.add(subclass)
00148         ABCMeta._abc_invalidation_counter += 1  # Invalidate negative cache

Here is the caller graph for this function:


The documentation for this class was generated from the following file: