Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/wrapt/wrappers.py: 31%

1"""Core object proxy and function wrapper implementations.""" 

2 

3import functools 

4import inspect 

5import math 

6import operator 

7import sys 

8import types 

9 

10from .exceptions import WrapperNotInitializedError 

11 

12 

13class _ObjectProxyMethods: 

14 

15 # We use properties to override the values of __module__ and 

16 # __doc__. If we add these in ObjectProxy, the derived class 

17 # __dict__ will still be setup to have string variants of these 

18 # attributes and the rules of descriptors means that they appear to 

19 # take precedence over the properties in the base class. To avoid 

20 # that, we copy the properties into the derived class type itself 

21 # via a meta class. In that way the properties will always take 

22 # precedence. 

23 # 

24 # Note that because these properties end up in the class __dict__, 

25 # type-level access (e.g. ObjectProxy.__module__) would return the 

26 # property object rather than a string, since CPython's 

27 # type.__module__ getter does a raw dict lookup without invoking the 

28 # descriptor protocol. The metaclass has its own __module__ and 

29 # __doc__ properties to handle type-level access correctly. 

30 

31 @property 

32 def __module__(self): 

33 return self.__wrapped__.__module__ 

34 

35 @__module__.setter 

36 def __module__(self, value): 

37 self.__wrapped__.__module__ = value 

38 

39 @__module__.deleter 

40 def __module__(self): 

41 del self.__wrapped__.__module__ 

42 

43 @property 

44 def __doc__(self): 

45 return self.__wrapped__.__doc__ 

46 

47 @__doc__.setter 

48 def __doc__(self, value): 

49 self.__wrapped__.__doc__ = value 

50 

51 @__doc__.deleter 

52 def __doc__(self): 

53 del self.__wrapped__.__doc__ 

54 

55 # We similar use a property for __dict__. We need __dict__ to be 

56 # explicit to ensure that vars() works as expected. 

57 

58 @property 

59 def __dict__(self): 

60 return self.__wrapped__.__dict__ 

61 

62 # Need to also propagate the special __weakref__ attribute for case 

63 # where decorating classes which will define this. If do not define 

64 # it and use a function like inspect.getmembers() on a decorator 

65 # class it will fail. This can't be in the derived classes. 

66 

67 @property 

68 def __weakref__(self): 

69 return self.__wrapped__.__weakref__ 

70 

71 

72class _ObjectProxyDictBase: 

73 """Base class whose sole purpose is to provide a ``getset_descriptor`` 

74 for ``__dict__`` that is valid for all ``ObjectProxy`` subclasses. 

75 The metaclass installs this descriptor as ``__self_dict__`` so that 

76 the real instance dictionary of the proxy can always be accessed, 

77 even though ``ObjectProxy`` replaces ``__dict__`` with a property 

78 that delegates to the wrapped object.""" 

79 

80 pass 

81 

82 

83_REAL_DICT_DESCRIPTOR = type.__dict__["__dict__"].__get__(_ObjectProxyDictBase)[ 

84 "__dict__" 

85] 

86 

87 

88def _get_self_dict(self): 

89 return _REAL_DICT_DESCRIPTOR.__get__(self) 

90 

91 

92# Wrapping the descriptor in a read-only property ensures that 

93# ``proxy.__self_dict__ = value`` raises AttributeError rather than 

94# replacing the real instance dictionary (which would break the proxy). 

95 

96_SELF_DICT_PROPERTY = property(_get_self_dict) 

97 

98# The default __doc__ property which delegates to the wrapped object. A 

99# derived class may define its own __doc__ descriptor in its class body 

100# to take control of what __doc__ reports for its instances, and that is 

101# preserved by the metaclass in place of this default. 

102 

103_DEFAULT_DOC_PROPERTY = vars(_ObjectProxyMethods)["__doc__"] 

104 

105 

106def _is_doc_descriptor(entry): 

107 # Every class carries a __doc__ entry in its dict, being the docstring 

108 # or None when there is none. Only a descriptor is taken to be a 

109 # deliberate override of the instance level __doc__ property. 

110 

111 if entry is None or isinstance(entry, str): 

112 return False 

113 return hasattr(type(entry), "__get__") 

114 

115 

116def _inherited_doc_descriptor(bases): 

117 # Find a custom __doc__ descriptor inherited from a base class. The 

118 # search stops at the first class which holds the default delegating 

119 # property, since a derived class of that should delegate as well. The 

120 # C extension performs the equivalent walk of the MRO at the time 

121 # __doc__ is accessed. 

122 

123 for base in bases: 

124 for klass in base.__mro__: 

125 entry = vars(klass).get("__doc__") 

126 if entry is _DEFAULT_DOC_PROPERTY: 

127 return None 

128 if _is_doc_descriptor(entry): 

129 return entry 

130 return None 

131 

132 

133class _ObjectProxyMetaType(type): 

134 # Properties on the metaclass control type-level access to __module__ 

135 # and __doc__ (e.g. ObjectProxy.__module__). Without these, the 

136 # instance-level properties copied from _ObjectProxyMethods into each 

137 # class dict would shadow the string values that type.__new__ sets, 

138 # causing type.__module__ to return a property object instead of a 

139 # string. The metaclass properties read from internal keys where the 

140 # real values are saved. 

141 

142 @property 

143 def __module__(cls): 

144 return cls.__dict__.get("_cls_real_module", "builtins") 

145 

146 @__module__.setter 

147 def __module__(cls, value): 

148 type.__setattr__(cls, "_cls_real_module", value) 

149 

150 @property 

151 def __doc__(cls): 

152 return cls.__dict__.get("_cls_real_doc") 

153 

154 @__doc__.setter 

155 def __doc__(cls, value): 

156 type.__setattr__(cls, "_cls_real_doc", value) 

157 

158 def __new__(cls, name, bases, dictionary): 

159 # Copy our special properties into the class so that they 

160 # always take precedence over attributes of the same name added 

161 # during construction of a derived class. This is to save 

162 # duplicating the implementation for them in all derived classes. 

163 # 

164 # Because this overwrites the __module__ and __doc__ strings 

165 # that would normally be in the class dict with property objects, 

166 # we save the original values first and store them under internal 

167 # keys. The metaclass properties above read from these keys to 

168 # ensure type-level access (e.g. MyProxy.__module__) returns a 

169 # string rather than a property object. 

170 

171 real_module = dictionary.get("__module__") 

172 real_doc = dictionary.get("__doc__") 

173 

174 # If the subclass defines its own __dict__ property, preserve it 

175 # rather than overwriting it with the default delegating property 

176 # from _ObjectProxyMethods. When __dict__ is not explicitly 

177 # defined in the class body, it will not be present in the 

178 # dictionary at this point. 

179 

180 custom_dict = dictionary.get("__dict__") 

181 

182 # Similarly, if the subclass defines __doc__ as a descriptor rather 

183 # than as a docstring, preserve it so the subclass controls what 

184 # __doc__ reports for its instances. Such a descriptor is not the 

185 # class docstring, so it is not recorded as one. A descriptor 

186 # defined by a base class is inherited, as it would be for any 

187 # class not using this metaclass, by copying it into the class 

188 # dictionary where it takes precedence over the None or docstring 

189 # entry the class body provides. 

190 

191 if _is_doc_descriptor(real_doc): 

192 custom_doc = real_doc 

193 real_doc = None 

194 else: 

195 custom_doc = _inherited_doc_descriptor(bases) 

196 

197 dictionary.update(vars(_ObjectProxyMethods)) 

198 

199 if custom_dict is not None: 

200 dictionary["__dict__"] = custom_dict 

201 

202 if custom_doc is not None: 

203 dictionary["__doc__"] = custom_doc 

204 

205 dictionary.setdefault("__self_dict__", _SELF_DICT_PROPERTY) 

206 

207 klass = type.__new__(cls, name, bases, dictionary) 

208 

209 if real_module is not None: 

210 type.__setattr__(klass, "_cls_real_module", real_module) 

211 if real_doc is not None: 

212 type.__setattr__(klass, "_cls_real_doc", real_doc) 

213 

214 return klass 

215 

216 

217def _unwrap_operand(other): 

218 # When the other operand of a binary operator is itself a proxy, apply 

219 # the operator to the two wrapped objects rather than passing the proxy 

220 # through to the wrapped object's own operator method. This mirrors 

221 # wrapt_unwrap_operand() in the C extension. Without it, a wrapped 

222 # type which raises TypeError for an unrecognised operand, rather 

223 # than returning NotImplemented, would never give the proxy on the 

224 # right hand side the chance to unwrap itself via the reflected 

225 # method, and Python would not see the real types of the operands 

226 # when deciding whether the reflected method of a subclass on the 

227 # right hand side takes priority. The real type is checked, and not 

228 # __class__, which the proxy reports as that of the wrapped object. 

229 

230 if issubclass(type(other), ObjectProxy): 

231 return other.__wrapped__ 

232 return other 

233 

234 

235class ObjectProxy(_ObjectProxyDictBase, metaclass=_ObjectProxyMetaType): 

236 """A transparent object proxy that delegates attribute access to a 

237 wrapped object.""" 

238 

239 @classmethod 

240 def __class_getitem__(cls, item, /): 

241 return types.GenericAlias(cls, item) 

242 

243 def __new__(cls, *args, **kwargs): 

244 # Accept and ignore any arguments. A derived class which adds 

245 # arguments to __init__() has the same arguments passed to 

246 # __new__(), and a derived class which overrides __new__() may 

247 # pass through whatever it was given, as it must when deriving 

248 # from AutoObjectProxy which needs the wrapped object in __new__(). 

249 # Without this, once __new__() is overridden anywhere in the class 

250 # hierarchy, the call falls through to object.__new__() which 

251 # rejects extra arguments. The C extension already ignores the 

252 # arguments in its tp_new slot, so this keeps the two consistent. 

253 

254 return super().__new__(cls) 

255 

256 def __init__(self, wrapped): 

257 """Create an object proxy around the given object.""" 

258 

259 if wrapped is None: 

260 try: 

261 callback = object.__getattribute__(self, "__wrapped_factory__") 

262 except AttributeError: 

263 callback = None 

264 

265 if callback is not None: 

266 # If wrapped is none and class has a __wrapped_factory__ 

267 # method, then we don't set __wrapped__ yet and instead will 

268 # defer creation of the wrapped object until it is first 

269 # needed. 

270 

271 pass 

272 

273 else: 

274 object.__setattr__(self, "__wrapped__", wrapped) 

275 else: 

276 object.__setattr__(self, "__wrapped__", wrapped) 

277 

278 object.__setattr__(self, "__init_called__", True) 

279 

280 # Python 3.2+ has the __qualname__ attribute, but it does not 

281 # allow it to be overridden using a property and it must instead 

282 # be an actual string object instead. 

283 

284 try: 

285 object.__setattr__(self, "__qualname__", wrapped.__qualname__) 

286 except AttributeError: 

287 pass 

288 

289 # Python 3.10 onwards also does not allow itself to be overridden 

290 # using a property and it must instead be set explicitly. Python 

291 # 3.14 onwards uses deferred evaluation of annotations via the 

292 # __annotate__ attribute, so we copy that instead to avoid 

293 # triggering eager evaluation which can fail if names referenced 

294 # in annotations have been shadowed. 

295 

296 if sys.version_info >= (3, 14): 

297 try: 

298 object.__setattr__(self, "__annotate__", wrapped.__annotate__) 

299 except AttributeError: 

300 pass 

301 else: 

302 try: 

303 object.__setattr__(self, "__annotations__", wrapped.__annotations__) 

304 except AttributeError: 

305 pass 

306 

307 @property 

308 def __object_proxy__(self): 

309 return ObjectProxy 

310 

311 def __self_setattr__(self, name, value): 

312 object.__setattr__(self, name, value) 

313 

314 @property 

315 def __name__(self): 

316 return self.__wrapped__.__name__ 

317 

318 @__name__.setter 

319 def __name__(self, value): 

320 self.__wrapped__.__name__ = value 

321 

322 @property 

323 def __class__(self): 

324 return self.__wrapped__.__class__ 

325 

326 @__class__.setter 

327 def __class__(self, value): 

328 self.__wrapped__.__class__ = value 

329 

330 def __dir__(self): 

331 return dir(self.__wrapped__) 

332 

333 def __str__(self): 

334 return str(self.__wrapped__) 

335 

336 def __bytes__(self): 

337 return bytes(self.__wrapped__) 

338 

339 def __repr__(self): 

340 return f"<{type(self).__name__} at 0x{id(self):x} for {type(self.__wrapped__).__name__} at 0x{id(self.__wrapped__):x}>" 

341 

342 def __format__(self, format_spec): 

343 return format(self.__wrapped__, format_spec) 

344 

345 def __reversed__(self): 

346 return reversed(self.__wrapped__) 

347 

348 def __round__(self, ndigits=None): 

349 return round(self.__wrapped__, ndigits) 

350 

351 def __trunc__(self): 

352 return math.trunc(self.__wrapped__) 

353 

354 def __floor__(self): 

355 return math.floor(self.__wrapped__) 

356 

357 def __ceil__(self): 

358 return math.ceil(self.__wrapped__) 

359 

360 def __mro_entries__(self, bases): 

361 if not isinstance(self.__wrapped__, type) and hasattr( 

362 self.__wrapped__, "__mro_entries__" 

363 ): 

364 return self.__wrapped__.__mro_entries__(bases) 

365 return (self.__wrapped__,) 

366 

367 def __lt__(self, other): 

368 return self.__wrapped__ < other 

369 

370 def __le__(self, other): 

371 return self.__wrapped__ <= other 

372 

373 def __eq__(self, other): 

374 return self.__wrapped__ == other 

375 

376 def __ne__(self, other): 

377 return self.__wrapped__ != other 

378 

379 def __gt__(self, other): 

380 return self.__wrapped__ > other 

381 

382 def __ge__(self, other): 

383 return self.__wrapped__ >= other 

384 

385 def __hash__(self): 

386 return hash(self.__wrapped__) 

387 

388 def __bool__(self): 

389 return bool(self.__wrapped__) 

390 

391 def __setattr__(self, name, value): 

392 if name.startswith("_self_"): 

393 object.__setattr__(self, name, value) 

394 

395 elif name == "__wrapped__": 

396 object.__setattr__(self, name, value) 

397 

398 try: 

399 object.__delattr__(self, "__qualname__") 

400 except AttributeError: 

401 pass 

402 try: 

403 object.__setattr__(self, "__qualname__", value.__qualname__) 

404 except AttributeError: 

405 pass 

406 if sys.version_info >= (3, 14): 

407 try: 

408 object.__delattr__(self, "__annotate__") 

409 except AttributeError: 

410 pass 

411 try: 

412 object.__setattr__(self, "__annotate__", value.__annotate__) 

413 except AttributeError: 

414 pass 

415 else: 

416 try: 

417 object.__delattr__(self, "__annotations__") 

418 except AttributeError: 

419 pass 

420 try: 

421 object.__setattr__(self, "__annotations__", value.__annotations__) 

422 except AttributeError: 

423 pass 

424 

425 __wrapped_setattr_fixups__ = getattr( 

426 self, "__wrapped_setattr_fixups__", None 

427 ) 

428 

429 if __wrapped_setattr_fixups__ is not None: 

430 __wrapped_setattr_fixups__() 

431 

432 elif name == "__qualname__": 

433 setattr(self.__wrapped__, name, value) 

434 object.__setattr__(self, name, value) 

435 

436 elif name == "__annotations__": 

437 setattr(self.__wrapped__, name, value) 

438 object.__setattr__(self, name, value) 

439 

440 elif name == "__annotate__": 

441 setattr(self.__wrapped__, name, value) 

442 object.__setattr__(self, name, value) 

443 

444 elif hasattr(type(self), name): 

445 object.__setattr__(self, name, value) 

446 

447 else: 

448 setattr(self.__wrapped__, name, value) 

449 

450 def __getattr__(self, name): 

451 # If we need to lookup `__wrapped__` then the `__init__()` method 

452 # cannot have been called, or this is a lazy object proxy which is 

453 # deferring creation of the wrapped object until it is first needed. 

454 

455 if name == "__wrapped__": 

456 # Note that we use existance of `__wrapped_factory__` to gate whether 

457 # we can attempt to initialize the wrapped object lazily, but it is 

458 # `__wrapped_get__` that we actually call to do the initialization. 

459 # This is so that we can handle multithreading correctly by having 

460 # `__wrapped_get__` use a lock to protect against multiple threads 

461 # trying to initialize the wrapped object at the same time. 

462 

463 try: 

464 object.__getattribute__(self, "__wrapped_factory__") 

465 except AttributeError: 

466 pass 

467 else: 

468 return object.__getattribute__(self, "__wrapped_get__")() 

469 

470 # If __init__ was called but __wrapped__ is not set, the wrapper 

471 # is in an inconsistent state. Raise WrapperNotInitializedError 

472 # (a ValueError, not AttributeError) so it is not silently 

473 # swallowed by hasattr/getattr patterns. 

474 

475 try: 

476 object.__getattribute__(self, "__init_called__") 

477 except AttributeError: 

478 raise AttributeError( 

479 f"'{type(self).__name__}' object has no attribute " f"'__wrapped__'" 

480 ) 

481 

482 raise WrapperNotInitializedError( 

483 "wrapper is in an inconsistent state: __wrapped__ is not set" 

484 ) 

485 

486 return getattr(self.__wrapped__, name) 

487 

488 def __delattr__(self, name): 

489 if name.startswith("_self_"): 

490 object.__delattr__(self, name) 

491 

492 elif name == "__wrapped__": 

493 raise TypeError("can't delete __wrapped__ attribute") 

494 

495 elif name == "__qualname__": 

496 object.__delattr__(self, name) 

497 delattr(self.__wrapped__, name) 

498 

499 elif name == "__annotations__": 

500 try: 

501 object.__delattr__(self, name) 

502 except AttributeError: 

503 pass 

504 delattr(self.__wrapped__, name) 

505 

506 elif name == "__annotate__": 

507 try: 

508 object.__delattr__(self, name) 

509 except AttributeError: 

510 pass 

511 delattr(self.__wrapped__, name) 

512 

513 elif hasattr(type(self), name): 

514 object.__delattr__(self, name) 

515 

516 else: 

517 delattr(self.__wrapped__, name) 

518 

519 def __add__(self, other): 

520 other = _unwrap_operand(other) 

521 return self.__wrapped__ + other 

522 

523 def __sub__(self, other): 

524 other = _unwrap_operand(other) 

525 return self.__wrapped__ - other 

526 

527 def __mul__(self, other): 

528 other = _unwrap_operand(other) 

529 return self.__wrapped__ * other 

530 

531 def __truediv__(self, other): 

532 other = _unwrap_operand(other) 

533 return operator.truediv(self.__wrapped__, other) 

534 

535 def __floordiv__(self, other): 

536 other = _unwrap_operand(other) 

537 return self.__wrapped__ // other 

538 

539 def __mod__(self, other): 

540 other = _unwrap_operand(other) 

541 return self.__wrapped__ % other 

542 

543 def __divmod__(self, other): 

544 other = _unwrap_operand(other) 

545 return divmod(self.__wrapped__, other) 

546 

547 def __pow__(self, other, *args): 

548 other = _unwrap_operand(other) 

549 return pow(self.__wrapped__, other, *args) 

550 

551 def __lshift__(self, other): 

552 other = _unwrap_operand(other) 

553 return self.__wrapped__ << other 

554 

555 def __rshift__(self, other): 

556 other = _unwrap_operand(other) 

557 return self.__wrapped__ >> other 

558 

559 def __and__(self, other): 

560 other = _unwrap_operand(other) 

561 return self.__wrapped__ & other 

562 

563 def __xor__(self, other): 

564 other = _unwrap_operand(other) 

565 return self.__wrapped__ ^ other 

566 

567 def __or__(self, other): 

568 other = _unwrap_operand(other) 

569 return self.__wrapped__ | other 

570 

571 def __radd__(self, other): 

572 other = _unwrap_operand(other) 

573 return other + self.__wrapped__ 

574 

575 def __rsub__(self, other): 

576 other = _unwrap_operand(other) 

577 return other - self.__wrapped__ 

578 

579 def __rmul__(self, other): 

580 other = _unwrap_operand(other) 

581 return other * self.__wrapped__ 

582 

583 def __rtruediv__(self, other): 

584 other = _unwrap_operand(other) 

585 return operator.truediv(other, self.__wrapped__) 

586 

587 def __rfloordiv__(self, other): 

588 other = _unwrap_operand(other) 

589 return other // self.__wrapped__ 

590 

591 def __rmod__(self, other): 

592 other = _unwrap_operand(other) 

593 return other % self.__wrapped__ 

594 

595 def __rdivmod__(self, other): 

596 other = _unwrap_operand(other) 

597 return divmod(other, self.__wrapped__) 

598 

599 def __rpow__(self, other, *args): 

600 other = _unwrap_operand(other) 

601 return pow(other, self.__wrapped__, *args) 

602 

603 def __rlshift__(self, other): 

604 other = _unwrap_operand(other) 

605 return other << self.__wrapped__ 

606 

607 def __rrshift__(self, other): 

608 other = _unwrap_operand(other) 

609 return other >> self.__wrapped__ 

610 

611 def __rand__(self, other): 

612 other = _unwrap_operand(other) 

613 return other & self.__wrapped__ 

614 

615 def __rxor__(self, other): 

616 other = _unwrap_operand(other) 

617 return other ^ self.__wrapped__ 

618 

619 def __ror__(self, other): 

620 other = _unwrap_operand(other) 

621 return other | self.__wrapped__ 

622 

623 def __iadd__(self, other): 

624 other = _unwrap_operand(other) 

625 if hasattr(self.__wrapped__, "__iadd__"): 

626 self.__wrapped__ += other 

627 return self 

628 else: 

629 return self.__object_proxy__(self.__wrapped__ + other) 

630 

631 def __isub__(self, other): 

632 other = _unwrap_operand(other) 

633 if hasattr(self.__wrapped__, "__isub__"): 

634 self.__wrapped__ -= other 

635 return self 

636 else: 

637 return self.__object_proxy__(self.__wrapped__ - other) 

638 

639 def __imul__(self, other): 

640 other = _unwrap_operand(other) 

641 if hasattr(self.__wrapped__, "__imul__"): 

642 self.__wrapped__ *= other 

643 return self 

644 else: 

645 return self.__object_proxy__(self.__wrapped__ * other) 

646 

647 def __itruediv__(self, other): 

648 other = _unwrap_operand(other) 

649 if hasattr(self.__wrapped__, "__itruediv__"): 

650 self.__wrapped__ /= other 

651 return self 

652 else: 

653 return self.__object_proxy__(self.__wrapped__ / other) 

654 

655 def __ifloordiv__(self, other): 

656 other = _unwrap_operand(other) 

657 if hasattr(self.__wrapped__, "__ifloordiv__"): 

658 self.__wrapped__ //= other 

659 return self 

660 else: 

661 return self.__object_proxy__(self.__wrapped__ // other) 

662 

663 def __imod__(self, other): 

664 other = _unwrap_operand(other) 

665 if hasattr(self.__wrapped__, "__imod__"): 

666 self.__wrapped__ %= other 

667 return self 

668 else: 

669 return self.__object_proxy__(self.__wrapped__ % other) 

670 

671 def __ipow__(self, other): # type: ignore[misc] 

672 other = _unwrap_operand(other) 

673 if hasattr(self.__wrapped__, "__ipow__"): 

674 self.__wrapped__ **= other 

675 return self 

676 else: 

677 return self.__object_proxy__(self.__wrapped__**other) 

678 

679 def __ilshift__(self, other): 

680 other = _unwrap_operand(other) 

681 if hasattr(self.__wrapped__, "__ilshift__"): 

682 self.__wrapped__ <<= other 

683 return self 

684 else: 

685 return self.__object_proxy__(self.__wrapped__ << other) 

686 

687 def __irshift__(self, other): 

688 other = _unwrap_operand(other) 

689 if hasattr(self.__wrapped__, "__irshift__"): 

690 self.__wrapped__ >>= other 

691 return self 

692 else: 

693 return self.__object_proxy__(self.__wrapped__ >> other) 

694 

695 def __iand__(self, other): 

696 other = _unwrap_operand(other) 

697 if hasattr(self.__wrapped__, "__iand__"): 

698 self.__wrapped__ &= other 

699 return self 

700 else: 

701 return self.__object_proxy__(self.__wrapped__ & other) 

702 

703 def __ixor__(self, other): 

704 other = _unwrap_operand(other) 

705 if hasattr(self.__wrapped__, "__ixor__"): 

706 self.__wrapped__ ^= other 

707 return self 

708 else: 

709 return self.__object_proxy__(self.__wrapped__ ^ other) 

710 

711 def __ior__(self, other): 

712 other = _unwrap_operand(other) 

713 if hasattr(self.__wrapped__, "__ior__"): 

714 self.__wrapped__ |= other 

715 return self 

716 else: 

717 return self.__object_proxy__(self.__wrapped__ | other) 

718 

719 def __neg__(self): 

720 return -self.__wrapped__ 

721 

722 def __pos__(self): 

723 return +self.__wrapped__ 

724 

725 def __abs__(self): 

726 return abs(self.__wrapped__) 

727 

728 def __invert__(self): 

729 return ~self.__wrapped__ 

730 

731 def __int__(self): 

732 return int(self.__wrapped__) 

733 

734 def __float__(self): 

735 return float(self.__wrapped__) 

736 

737 def __complex__(self): 

738 return complex(self.__wrapped__) 

739 

740 def __index__(self): 

741 return operator.index(self.__wrapped__) 

742 

743 def __matmul__(self, other): 

744 other = _unwrap_operand(other) 

745 return self.__wrapped__ @ other 

746 

747 def __rmatmul__(self, other): 

748 other = _unwrap_operand(other) 

749 return other @ self.__wrapped__ 

750 

751 def __imatmul__(self, other): 

752 other = _unwrap_operand(other) 

753 if hasattr(self.__wrapped__, "__imatmul__"): 

754 self.__wrapped__ @= other 

755 return self 

756 else: 

757 return self.__object_proxy__(self.__wrapped__ @ other) 

758 

759 def __len__(self): 

760 return len(self.__wrapped__) 

761 

762 def __contains__(self, value): 

763 return value in self.__wrapped__ 

764 

765 def __getitem__(self, key): 

766 return self.__wrapped__[key] 

767 

768 def __setitem__(self, key, value): 

769 self.__wrapped__[key] = value 

770 

771 def __delitem__(self, key): 

772 del self.__wrapped__[key] 

773 

774 def __enter__(self): 

775 return self.__wrapped__.__enter__() 

776 

777 def __exit__(self, *args, **kwargs): 

778 return self.__wrapped__.__exit__(*args, **kwargs) 

779 

780 def __aenter__(self): 

781 return self.__wrapped__.__aenter__() 

782 

783 def __aexit__(self, *args, **kwargs): 

784 return self.__wrapped__.__aexit__(*args, **kwargs) 

785 

786 def __copy__(self): 

787 raise NotImplementedError("object proxy must define __copy__()") 

788 

789 def __deepcopy__(self, memo): 

790 raise NotImplementedError("object proxy must define __deepcopy__()") 

791 

792 def __reduce__(self): 

793 raise NotImplementedError("object proxy must define __reduce__()") 

794 

795 def __instancecheck__(self, instance): 

796 return isinstance(instance, self.__wrapped__) 

797 

798 def __subclasscheck__(self, subclass): 

799 if hasattr(subclass, "__wrapped__"): 

800 return issubclass(subclass.__wrapped__, self.__wrapped__) 

801 else: 

802 return issubclass(subclass, self.__wrapped__) 

803 

804 

805class CallableObjectProxy(ObjectProxy): 

806 """An object proxy for callable objects that also forwards calls.""" 

807 

808 def __call__(*args, **kwargs): 

809 def _unpack_self(self, *args): 

810 return self, args 

811 

812 self, args = _unpack_self(*args) 

813 

814 return self.__wrapped__(*args, **kwargs) 

815 

816 

817class _PartialSignatureDescriptor: 

818 """Descriptor providing the ``__signature__`` attribute of instances of 

819 ``PartialCallableObjectProxy``. 

820 

821 The signature reported is that of the wrapped callable with the bound 

822 positional and keyword arguments removed, matching what ``inspect`` 

823 reports for ``functools.partial``. It must be defined on the proxy type 

824 itself, since attribute lookup on the proxy would otherwise be forwarded 

825 to the wrapped callable, and ``inspect.signature()`` stops following 

826 ``__wrapped__`` at the first object which has a ``__signature__`` 

827 attribute. 

828 

829 A plain property cannot be used because it would also be visible when 

830 accessed on the class, and ``inspect.signature()`` applied to the class 

831 itself would then fail on finding a property object rather than a 

832 ``Signature``. Raising ``AttributeError`` on class access leaves the 

833 signature of the class unchanged. 

834 """ 

835 

836 def __get__(self, instance, owner=None): 

837 if instance is None: 

838 raise AttributeError("__signature__") 

839 

840 partial = functools.partial( 

841 instance.__wrapped__, *instance._self_args, **instance._self_kwargs 

842 ) 

843 

844 return inspect.signature(partial) 

845 

846 

847class PartialCallableObjectProxy(ObjectProxy): 

848 """A callable object proxy that supports partial application of arguments 

849 and keywords. 

850 """ 

851 

852 __signature__ = _PartialSignatureDescriptor() 

853 

854 def __init__(*args, **kwargs): 

855 """Create a callable object proxy with partial application of the given 

856 arguments and keywords. This behaves the same as `functools.partial`, but 

857 implemented using the `ObjectProxy` class to provide better support for 

858 introspection. 

859 """ 

860 

861 def _unpack_self(self, *args): 

862 return self, args 

863 

864 self, args = _unpack_self(*args) 

865 

866 if len(args) < 1: 

867 raise TypeError("partial type takes at least one argument") 

868 

869 wrapped, args = args[0], args[1:] 

870 

871 if not callable(wrapped): 

872 raise TypeError("the first argument must be callable") 

873 

874 # Explicit class in super() is used because the proxy overrides 

875 # __class__ and MRO-related methods to delegate to the wrapped 

876 # object, which can interfere with bare super(). 

877 super(PartialCallableObjectProxy, self).__init__(wrapped) 

878 

879 self._self_args = args 

880 self._self_kwargs = kwargs 

881 

882 def __call__(*args, **kwargs): 

883 def _unpack_self(self, *args): 

884 return self, args 

885 

886 self, args = _unpack_self(*args) 

887 

888 _args = self._self_args + args 

889 

890 _kwargs = dict(self._self_kwargs) 

891 _kwargs.update(kwargs) 

892 

893 return self.__wrapped__(*_args, **_kwargs) 

894 

895