|
| 1 | +""" |
| 2 | +Define names for built-in types that aren't directly accessible as a builtin. |
| 3 | +""" |
| 4 | +import sys |
| 5 | + |
| 6 | +# Iterators in Python aren't a matter of type but of protocol. A large |
| 7 | +# and changing number of builtin types implement *some* flavor of |
| 8 | +# iterator. Don't check the type! Use hasattr to check for both |
| 9 | +# "__iter__" and "__next__" attributes instead. |
| 10 | + |
| 11 | +def _f(): pass |
| 12 | +FunctionType = type(_f) |
| 13 | +LambdaType = type(lambda: None) # Same as FunctionType |
| 14 | +CodeType = type(_f.__code__) |
| 15 | +MappingProxyType = type(type.__dict__) |
| 16 | +SimpleNamespace = type(sys.implementation) |
| 17 | + |
| 18 | +def _g(): |
| 19 | + yield 1 |
| 20 | +GeneratorType = type(_g()) |
| 21 | + |
| 22 | +async def _c(): pass |
| 23 | +_c = _c() |
| 24 | +CoroutineType = type(_c) |
| 25 | +_c.close() # Prevent ResourceWarning |
| 26 | + |
| 27 | +async def _ag(): |
| 28 | + yield |
| 29 | +_ag = _ag() |
| 30 | +AsyncGeneratorType = type(_ag) |
| 31 | + |
| 32 | +class _C: |
| 33 | + def _m(self): pass |
| 34 | +MethodType = type(_C()._m) |
| 35 | + |
| 36 | +BuiltinFunctionType = type(len) |
| 37 | +BuiltinMethodType = type([].append) # Same as BuiltinFunctionType |
| 38 | + |
| 39 | +WrapperDescriptorType = type(object.__init__) |
| 40 | +MethodWrapperType = type(object().__str__) |
| 41 | +MethodDescriptorType = type(str.join) |
| 42 | +ClassMethodDescriptorType = type(dict.__dict__['fromkeys']) |
| 43 | + |
| 44 | +ModuleType = type(sys) |
| 45 | + |
| 46 | +try: |
| 47 | + raise TypeError |
| 48 | +except TypeError: |
| 49 | + tb = sys.exc_info()[2] |
| 50 | + TracebackType = type(tb) |
| 51 | + FrameType = type(tb.tb_frame) |
| 52 | + tb = None; del tb |
| 53 | + |
| 54 | +# For Jython, the following two types are identical |
| 55 | +GetSetDescriptorType = type(FunctionType.__code__) |
| 56 | +MemberDescriptorType = type(FunctionType.__globals__) |
| 57 | + |
| 58 | +del sys, _f, _g, _C, _c, _ag # Not for export |
| 59 | + |
| 60 | + |
| 61 | +# Provide a PEP 3115 compliant mechanism for class creation |
| 62 | +def new_class(name, bases=(), kwds=None, exec_body=None): |
| 63 | + """Create a class object dynamically using the appropriate metaclass.""" |
| 64 | + resolved_bases = resolve_bases(bases) |
| 65 | + meta, ns, kwds = prepare_class(name, resolved_bases, kwds) |
| 66 | + if exec_body is not None: |
| 67 | + exec_body(ns) |
| 68 | + if resolved_bases is not bases: |
| 69 | + ns['__orig_bases__'] = bases |
| 70 | + return meta(name, resolved_bases, ns, **kwds) |
| 71 | + |
| 72 | +def resolve_bases(bases): |
| 73 | + """Resolve MRO entries dynamically as specified by PEP 560.""" |
| 74 | + new_bases = list(bases) |
| 75 | + updated = False |
| 76 | + shift = 0 |
| 77 | + for i, base in enumerate(bases): |
| 78 | + if isinstance(base, type): |
| 79 | + continue |
| 80 | + if not hasattr(base, "__mro_entries__"): |
| 81 | + continue |
| 82 | + new_base = base.__mro_entries__(bases) |
| 83 | + updated = True |
| 84 | + if not isinstance(new_base, tuple): |
| 85 | + raise TypeError("__mro_entries__ must return a tuple") |
| 86 | + else: |
| 87 | + new_bases[i+shift:i+shift+1] = new_base |
| 88 | + shift += len(new_base) - 1 |
| 89 | + if not updated: |
| 90 | + return bases |
| 91 | + return tuple(new_bases) |
| 92 | + |
| 93 | +def prepare_class(name, bases=(), kwds=None): |
| 94 | + """Call the __prepare__ method of the appropriate metaclass. |
| 95 | +
|
| 96 | + Returns (metaclass, namespace, kwds) as a 3-tuple |
| 97 | +
|
| 98 | + *metaclass* is the appropriate metaclass |
| 99 | + *namespace* is the prepared class namespace |
| 100 | + *kwds* is an updated copy of the passed in kwds argument with any |
| 101 | + 'metaclass' entry removed. If no kwds argument is passed in, this will |
| 102 | + be an empty dict. |
| 103 | + """ |
| 104 | + if kwds is None: |
| 105 | + kwds = {} |
| 106 | + else: |
| 107 | + kwds = dict(kwds) # Don't alter the provided mapping |
| 108 | + if 'metaclass' in kwds: |
| 109 | + meta = kwds.pop('metaclass') |
| 110 | + else: |
| 111 | + if bases: |
| 112 | + meta = type(bases[0]) |
| 113 | + else: |
| 114 | + meta = type |
| 115 | + if isinstance(meta, type): |
| 116 | + # when meta is a type, we first determine the most-derived metaclass |
| 117 | + # instead of invoking the initial candidate directly |
| 118 | + meta = _calculate_meta(meta, bases) |
| 119 | + if hasattr(meta, '__prepare__'): |
| 120 | + ns = meta.__prepare__(name, bases, **kwds) |
| 121 | + else: |
| 122 | + ns = {} |
| 123 | + return meta, ns, kwds |
| 124 | + |
| 125 | +def _calculate_meta(meta, bases): |
| 126 | + """Calculate the most derived metaclass.""" |
| 127 | + winner = meta |
| 128 | + for base in bases: |
| 129 | + base_meta = type(base) |
| 130 | + if issubclass(winner, base_meta): |
| 131 | + continue |
| 132 | + if issubclass(base_meta, winner): |
| 133 | + winner = base_meta |
| 134 | + continue |
| 135 | + # else: |
| 136 | + raise TypeError("metaclass conflict: " |
| 137 | + "the metaclass of a derived class " |
| 138 | + "must be a (non-strict) subclass " |
| 139 | + "of the metaclasses of all its bases") |
| 140 | + return winner |
| 141 | + |
| 142 | +class DynamicClassAttribute: |
| 143 | + """Route attribute access on a class to __getattr__. |
| 144 | +
|
| 145 | + This is a descriptor, used to define attributes that act differently when |
| 146 | + accessed through an instance and through a class. Instance access remains |
| 147 | + normal, but access to an attribute through a class will be routed to the |
| 148 | + class's __getattr__ method; this is done by raising AttributeError. |
| 149 | +
|
| 150 | + This allows one to have properties active on an instance, and have virtual |
| 151 | + attributes on the class with the same name (see Enum for an example). |
| 152 | +
|
| 153 | + """ |
| 154 | + def __init__(self, fget=None, fset=None, fdel=None, doc=None): |
| 155 | + self.fget = fget |
| 156 | + self.fset = fset |
| 157 | + self.fdel = fdel |
| 158 | + # next two lines make DynamicClassAttribute act the same as property |
| 159 | + self.__doc__ = doc or fget.__doc__ |
| 160 | + self.overwrite_doc = doc is None |
| 161 | + # support for abstract methods |
| 162 | + self.__isabstractmethod__ = bool(getattr(fget, '__isabstractmethod__', False)) |
| 163 | + |
| 164 | + def __get__(self, instance, ownerclass=None): |
| 165 | + if instance is None: |
| 166 | + if self.__isabstractmethod__: |
| 167 | + return self |
| 168 | + raise AttributeError() |
| 169 | + elif self.fget is None: |
| 170 | + raise AttributeError("unreadable attribute") |
| 171 | + return self.fget(instance) |
| 172 | + |
| 173 | + def __set__(self, instance, value): |
| 174 | + if self.fset is None: |
| 175 | + raise AttributeError("can't set attribute") |
| 176 | + self.fset(instance, value) |
| 177 | + |
| 178 | + def __delete__(self, instance): |
| 179 | + if self.fdel is None: |
| 180 | + raise AttributeError("can't delete attribute") |
| 181 | + self.fdel(instance) |
| 182 | + |
| 183 | + def getter(self, fget): |
| 184 | + fdoc = fget.__doc__ if self.overwrite_doc else None |
| 185 | + result = type(self)(fget, self.fset, self.fdel, fdoc or self.__doc__) |
| 186 | + result.overwrite_doc = self.overwrite_doc |
| 187 | + return result |
| 188 | + |
| 189 | + def setter(self, fset): |
| 190 | + result = type(self)(self.fget, fset, self.fdel, self.__doc__) |
| 191 | + result.overwrite_doc = self.overwrite_doc |
| 192 | + return result |
| 193 | + |
| 194 | + def deleter(self, fdel): |
| 195 | + result = type(self)(self.fget, self.fset, fdel, self.__doc__) |
| 196 | + result.overwrite_doc = self.overwrite_doc |
| 197 | + return result |
| 198 | + |
| 199 | + |
| 200 | +class _GeneratorWrapper: |
| 201 | + # TODO: Implement this in C. |
| 202 | + def __init__(self, gen): |
| 203 | + self.__wrapped = gen |
| 204 | + self.__isgen = gen.__class__ is GeneratorType |
| 205 | + self.__name__ = getattr(gen, '__name__', None) |
| 206 | + self.__qualname__ = getattr(gen, '__qualname__', None) |
| 207 | + def send(self, val): |
| 208 | + return self.__wrapped.send(val) |
| 209 | + def throw(self, tp, *rest): |
| 210 | + return self.__wrapped.throw(tp, *rest) |
| 211 | + def close(self): |
| 212 | + return self.__wrapped.close() |
| 213 | + @property |
| 214 | + def gi_code(self): |
| 215 | + return self.__wrapped.gi_code |
| 216 | + @property |
| 217 | + def gi_frame(self): |
| 218 | + return self.__wrapped.gi_frame |
| 219 | + @property |
| 220 | + def gi_running(self): |
| 221 | + return self.__wrapped.gi_running |
| 222 | + @property |
| 223 | + def gi_yieldfrom(self): |
| 224 | + return self.__wrapped.gi_yieldfrom |
| 225 | + cr_code = gi_code |
| 226 | + cr_frame = gi_frame |
| 227 | + cr_running = gi_running |
| 228 | + cr_await = gi_yieldfrom |
| 229 | + def __next__(self): |
| 230 | + return next(self.__wrapped) |
| 231 | + def __iter__(self): |
| 232 | + if self.__isgen: |
| 233 | + return self.__wrapped |
| 234 | + return self |
| 235 | + __await__ = __iter__ |
| 236 | + |
| 237 | +def coroutine(func): |
| 238 | + """Convert regular generator function to a coroutine.""" |
| 239 | + |
| 240 | + if not callable(func): |
| 241 | + raise TypeError('types.coroutine() expects a callable') |
| 242 | + |
| 243 | + if (func.__class__ is FunctionType and |
| 244 | + getattr(func, '__code__', None).__class__ is CodeType): |
| 245 | + |
| 246 | + co_flags = func.__code__.co_flags |
| 247 | + |
| 248 | + # Check if 'func' is a coroutine function. |
| 249 | + # (0x180 == CO_COROUTINE | CO_ITERABLE_COROUTINE) |
| 250 | + if co_flags & 0x180: |
| 251 | + return func |
| 252 | + |
| 253 | + # Check if 'func' is a generator function. |
| 254 | + # (0x20 == CO_GENERATOR) |
| 255 | + if co_flags & 0x20: |
| 256 | + # TODO: Implement this in C. |
| 257 | + co = func.__code__ |
| 258 | + func.__code__ = CodeType( |
| 259 | + co.co_argcount, co.co_kwonlyargcount, co.co_nlocals, |
| 260 | + co.co_stacksize, |
| 261 | + co.co_flags | 0x100, # 0x100 == CO_ITERABLE_COROUTINE |
| 262 | + co.co_code, |
| 263 | + co.co_consts, co.co_names, co.co_varnames, co.co_filename, |
| 264 | + co.co_name, co.co_firstlineno, co.co_lnotab, co.co_freevars, |
| 265 | + co.co_cellvars) |
| 266 | + return func |
| 267 | + |
| 268 | + # The following code is primarily to support functions that |
| 269 | + # return generator-like objects (for instance generators |
| 270 | + # compiled with Cython). |
| 271 | + |
| 272 | + # Delay functools and _collections_abc import for speeding up types import. |
| 273 | + import functools |
| 274 | + import _collections_abc |
| 275 | + @functools.wraps(func) |
| 276 | + def wrapped(*args, **kwargs): |
| 277 | + coro = func(*args, **kwargs) |
| 278 | + if (coro.__class__ is CoroutineType or |
| 279 | + coro.__class__ is GeneratorType and coro.gi_code.co_flags & 0x100): |
| 280 | + # 'coro' is a native coroutine object or an iterable coroutine |
| 281 | + return coro |
| 282 | + if (isinstance(coro, _collections_abc.Generator) and |
| 283 | + not isinstance(coro, _collections_abc.Coroutine)): |
| 284 | + # 'coro' is either a pure Python generator iterator, or it |
| 285 | + # implements collections.abc.Generator (and does not implement |
| 286 | + # collections.abc.Coroutine). |
| 287 | + return _GeneratorWrapper(coro) |
| 288 | + # 'coro' is either an instance of collections.abc.Coroutine or |
| 289 | + # some other object -- pass it through. |
| 290 | + return coro |
| 291 | + |
| 292 | + return wrapped |
| 293 | + |
| 294 | + |
| 295 | +__all__ = [n for n in globals() if n[:1] != '_'] |
0 commit comments