Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

821

822

823

824

825

826

827

828

829

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847

848

849

850

851

852

853

854

855

856

857

858

859

860

861

862

863

864

865

866

867

868

869

870

871

872

873

874

875

876

877

878

879

880

881

882

883

884

885

886

import sys 

import functools 

import operator 

import weakref 

import inspect 

 

PY2 = sys.version_info[0] == 2 

PY3 = sys.version_info[0] == 3 

 

if PY3: 

    string_types = str, 

else: 

    string_types = basestring, 

 

def with_metaclass(meta, *bases): 

    """Create a base class with a metaclass.""" 

    return meta("NewBase", bases, {}) 

 

class _ObjectProxyMethods(object): 

 

     # We use properties to override the values of __module__ and 

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

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

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

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

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

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

     # precedence. 

 

    @property 

    def __module__(self): 

        return self.__wrapped__.__module__ 

 

    @__module__.setter 

    def __module__(self, value): 

        self.__wrapped__.__module__ = value 

 

    @property 

    def __doc__(self): 

        return self.__wrapped__.__doc__ 

 

    @__doc__.setter 

    def __doc__(self, value): 

        self.__wrapped__.__doc__ = value 

 

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

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

 

    @property 

    def __dict__(self): 

        return self.__wrapped__.__dict__ 

 

    # Need to also propagate the special __weakref__ attribute for case 

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

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

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

 

    @property 

    def __weakref__(self): 

        return self.__wrapped__.__weakref__ 

 

class _ObjectProxyMetaType(type): 

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

         # Copy our special properties into the class so that they 

         # always take precedence over attributes of the same name added 

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

         # duplicating the implementation for them in all derived classes. 

 

         dictionary.update(vars(_ObjectProxyMethods)) 

 

         return type.__new__(cls, name, bases, dictionary) 

 

class ObjectProxy(with_metaclass(_ObjectProxyMetaType)): 

 

    __slots__ = '__wrapped__' 

 

    def __init__(self, wrapped): 

        object.__setattr__(self, '__wrapped__', wrapped) 

 

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

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

        # be an actual string object instead. 

 

        try: 

            object.__setattr__(self, '__qualname__', wrapped.__qualname__) 

        except AttributeError: 

            pass 

 

    @property 

    def __name__(self): 

        return self.__wrapped__.__name__ 

 

    @__name__.setter 

    def __name__(self, value): 

        self.__wrapped__.__name__ = value 

 

    @property 

    def __class__(self): 

        return self.__wrapped__.__class__ 

 

    @__class__.setter 

    def __class__(self, value): 

        self.__wrapped__.__class__ = value 

 

    @property 

    def __annotations__(self): 

        return self.__wrapped__.__anotations__ 

 

    @__annotations__.setter 

    def __annotations__(self, value): 

        self.__wrapped__.__annotations__ = value 

 

    def __dir__(self): 

        return dir(self.__wrapped__) 

 

    def __str__(self): 

        return str(self.__wrapped__) 

 

    if PY3: 

        def __bytes__(self): 

            return bytes(self.__wrapped__) 

 

    def __repr__(self): 

        return '<%s at 0x%x for %s at 0x%x>' % ( 

                type(self).__name__, id(self), 

                type(self.__wrapped__).__name__, 

                id(self.__wrapped__)) 

 

    def __reversed__(self): 

        return reversed(self.__wrapped__) 

 

    if PY3: 

        def __round__(self): 

            return round(self.__wrapped__) 

 

    def __lt__(self, other): 

        return self.__wrapped__ < other 

 

    def __le__(self, other): 

        return self.__wrapped__ <= other 

 

    def __eq__(self, other): 

        return self.__wrapped__ == other 

 

    def __ne__(self, other): 

        return self.__wrapped__ != other 

 

    def __gt__(self, other): 

        return self.__wrapped__ > other 

 

    def __ge__(self, other): 

        return self.__wrapped__ >= other 

 

    def __hash__(self): 

        return hash(self.__wrapped__) 

 

    def __nonzero__(self): 

        return bool(self.__wrapped__) 

 

    def __bool__(self): 

        return bool(self.__wrapped__) 

 

    def __setattr__(self, name, value): 

        if name.startswith('_self_'): 

            object.__setattr__(self, name, value) 

 

        elif name == '__wrapped__': 

            object.__setattr__(self, name, value) 

            try: 

                object.__delattr__(self, '__qualname__') 

            except AttributeError: 

                pass 

            object.__setattr__(self, name, value) 

            try: 

                object.__setattr__(self, '__qualname__', value.__qualname__) 

            except AttributeError: 

                pass 

 

        elif name == '__qualname__': 

            setattr(self.__wrapped__, name, value) 

            object.__setattr__(self, name, value) 

 

        elif hasattr(type(self), name): 

            object.__setattr__(self, name, value) 

 

        else: 

            setattr(self.__wrapped__, name, value) 

 

    def __getattr__(self, name): 

        # If we are being to lookup '__wrapped__' then the 

        # '__init__()' method cannot have been called. 

 

        if name == '__wrapped__': 

            raise ValueError('wrapper has not been initialised') 

 

        return getattr(self.__wrapped__, name) 

 

    def __delattr__(self, name): 

        if name.startswith('_self_'): 

            object.__delattr__(self, name) 

 

        elif name == '__wrapped__': 

            raise TypeError('__wrapped__ must be an object') 

 

        elif name == '__qualname__': 

            object.__delattr__(self, name) 

            delattr(self.__wrapped__, name) 

 

        elif hasattr(type(self), name): 

            object.__delattr__(self, name) 

 

        else: 

            delattr(self.__wrapped__, name) 

 

    def __add__(self, other): 

        return self.__wrapped__ + other 

 

    def __sub__(self, other): 

        return self.__wrapped__ - other 

 

    def __mul__(self, other): 

        return self.__wrapped__ * other 

 

    def __div__(self, other): 

        return operator.div(self.__wrapped__, other) 

 

    def __truediv__(self, other): 

        return operator.truediv(self.__wrapped__, other) 

 

    def __floordiv__(self, other): 

        return self.__wrapped__ // other 

 

    def __mod__(self, other): 

        return self.__wrapped__ ^ other 

 

    def __divmod__(self, other): 

        return divmod(self.__wrapped__, other) 

 

    def __pow__(self, other, *args): 

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

 

    def __lshift__(self, other): 

        return self.__wrapped__ << other 

 

    def __rshift__(self, other): 

        return self.__wrapped__ >> other 

 

    def __and__(self, other): 

        return self.__wrapped__ & other 

 

    def __xor__(self, other): 

        return self.__wrapped__ ^ other 

 

    def __or__(self, other): 

        return self.__wrapped__ | other 

 

    def __radd__(self, other): 

        return other + self.__wrapped__ 

 

    def __rsub__(self, other): 

        return other - self.__wrapped__ 

 

    def __rmul__(self, other): 

        return other * self.__wrapped__ 

 

    def __rdiv__(self, other): 

        return operator.div(other, self.__wrapped__) 

 

    def __rtruediv__(self, other): 

        return operator.truediv(other, self.__wrapped__) 

 

    def __rfloordiv__(self, other): 

        return other // self.__wrapped__ 

 

    def __rmod__(self, other): 

        return other % self.__wrapped__ 

 

    def __rdivmod__(self, other): 

        return divmod(other, self.__wrapped__) 

 

    def __rpow__(self, other, *args): 

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

 

    def __rlshift__(self, other): 

        return other << self.__wrapped__ 

 

    def __rrshift__(self, other): 

        return other >> self.__wrapped__ 

 

    def __rand__(self, other): 

        return other & self.__wrapped__ 

 

    def __rxor__(self, other): 

        return other ^ self.__wrapped__ 

 

    def __ror__(self, other): 

        return other | self.__wrapped__ 

 

    def __iadd__(self, other): 

        self.__wrapped__ += other 

        return self 

 

    def __isub__(self, other): 

        self.__wrapped__ -= other 

        return self 

 

    def __imul__(self, other): 

        self.__wrapped__ *= other 

        return self 

 

    def __idiv__(self, other): 

        self.__wrapped__ = operator.idiv(self.__wrapped__, other) 

        return self 

 

    def __itruediv__(self, other): 

        self.__wrapped__ = operator.itruediv(self.__wrapped__, other) 

        return self 

 

    def __ifloordiv__(self, other): 

        self.__wrapped__ //= other 

        return self 

 

    def __imod__(self, other): 

        self.__wrapped__ %= other 

        return self 

 

    def __ipow__(self, other): 

        self.__wrapped__ **= other 

        return self 

 

    def __ilshift__(self, other): 

        self.__wrapped__ <<= other 

        return self 

 

    def __irshift__(self, other): 

        self.__wrapped__ >>= other 

        return self 

 

    def __iand__(self, other): 

        self.__wrapped__ &= other 

        return self 

 

    def __ixor__(self, other): 

        self.__wrapped__ ^= other 

        return self 

 

    def __ior__(self, other): 

        self.__wrapped__ |= other 

        return self 

 

    def __neg__(self): 

        return -self.__wrapped__ 

 

    def __pos__(self): 

        return +self.__wrapped__ 

 

    def __abs__(self): 

        return abs(self.__wrapped__) 

 

    def __invert__(self): 

        return ~self.__wrapped__ 

 

    def __int__(self): 

        return int(self.__wrapped__) 

 

    def __long__(self): 

        return long(self.__wrapped__) 

 

    def __float__(self): 

        return float(self.__wrapped__) 

 

    def __oct__(self): 

        return oct(self.__wrapped__) 

 

    def __hex__(self): 

        return hex(self.__wrapped__) 

 

    def __index__(self): 

        return operator.index(self.__wrapped__) 

 

    def __len__(self): 

        return len(self.__wrapped__) 

 

    def __contains__(self, value): 

        return value in self.__wrapped__ 

 

    def __getitem__(self, key): 

        return self.__wrapped__[key] 

 

    def __setitem__(self, key, value): 

        self.__wrapped__[key] = value 

 

    def __delitem__(self, key): 

        del self.__wrapped__[key] 

 

    def __getslice__(self, i, j): 

        return self.__wrapped__[i:j] 

 

    def __setslice__(self, i, j, value): 

        self.__wrapped__[i:j] = value 

 

    def __delslice__(self, i, j): 

        del self.__wrapped__[i:j] 

 

    def __enter__(self): 

        return self.__wrapped__.__enter__() 

 

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

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

 

    def __iter__(self): 

        return iter(self.__wrapped__) 

 

class CallableObjectProxy(ObjectProxy): 

 

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

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

 

class _FunctionWrapperBase(ObjectProxy): 

 

    __slots__ = ('_self_instance', '_self_wrapper', '_self_enabled', 

            '_self_binding', '_self_parent') 

 

    def __init__(self, wrapped, instance, wrapper, enabled=None, 

            binding='function', parent=None): 

 

        super(_FunctionWrapperBase, self).__init__(wrapped) 

 

        object.__setattr__(self, '_self_instance', instance) 

        object.__setattr__(self, '_self_wrapper', wrapper) 

        object.__setattr__(self, '_self_enabled', enabled) 

        object.__setattr__(self, '_self_binding', binding) 

        object.__setattr__(self, '_self_parent', parent) 

 

    def __get__(self, instance, owner): 

        # This method is actually doing double duty for both unbound and 

        # bound derived wrapper classes. It should possibly be broken up 

        # and the distinct functionality moved into the derived classes. 

        # Can't do that straight away due to some legacy code which is 

        # relying on it being here in this base class. 

        # 

        # The distinguishing attribute which determines whether we are 

        # being called in an unbound or bound wrapper is the parent 

        # attribute. If binding has never occured, then the parent will 

        # be None. 

        # 

        # First therefore, is if we are called in an unbound wrapper. In 

        # this case we perform the binding. 

        # 

        # We have one special case to worry about here. This is where we 

        # are decorating a nested class. In this case the wrapped class 

        # would not have a __get__() method to call. In that case we 

        # simply return self. 

        # 

        # Note that we otherwise still do binding even if instance is 

        # None and accessing an unbound instance method from a class. 

        # This is because we need to be able to later detect that 

        # specific case as we will need to extract the instance from the 

        # first argument of those passed in. 

 

        if self._self_parent is None: 

            if not inspect.isclass(self.__wrapped__): 

                descriptor = self.__wrapped__.__get__(instance, owner) 

 

                return self.__bound_function_wrapper__(descriptor, instance, 

                        self._self_wrapper, self._self_enabled, 

                        self._self_binding, self) 

 

            return self 

 

        # Now we have the case of binding occuring a second time on what 

        # was already a bound function. In this case we would usually 

        # return ourselves again. This mirrors what Python does. 

        # 

        # The special case this time is where we were originally bound 

        # with an instance of None and we were likely an instance 

        # method. In that case we rebind against the original wrapped 

        # function from the parent again. 

 

        if self._self_instance is None and self._self_binding == 'function': 

            descriptor = self._self_parent.__wrapped__.__get__( 

                    instance, owner) 

 

            return self._self_parent.__bound_function_wrapper__( 

                    descriptor, instance, self._self_wrapper, 

                    self._self_enabled, self._self_binding, 

                    self._self_parent) 

 

        return self 

 

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

        # If enabled has been specified, then evaluate it at this point 

        # and if the wrapper is not to be executed, then simply return 

        # the bound function rather than a bound wrapper for the bound 

        # function. When evaluating enabled, if it is callable we call 

        # it, otherwise we evaluate it as a boolean. 

 

        if self._self_enabled is not None: 

            if callable(self._self_enabled): 

                if not self._self_enabled(): 

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

            elif not self._self_enabled: 

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

 

        # This can occur where initial function wrapper was applied to 

        # a function that was already bound to an instance. In that case 

        # we want to extract the instance from the function and use it. 

 

        if self._self_binding == 'function': 

            if self._self_instance is None: 

                instance = getattr(self.__wrapped__, '__self__', None) 

                if instance is not None: 

                    return self._self_wrapper(self.__wrapped__, instance, 

                            args, kwargs) 

 

        # This is generally invoked when the wrapped function is being 

        # called as a normal function and is not bound to a class as an 

        # instance method. This is also invoked in the case where the 

        # wrapped function was a method, but this wrapper was in turn 

        # wrapped using the staticmethod decorator. 

 

        return self._self_wrapper(self.__wrapped__, self._self_instance, 

                args, kwargs) 

 

class BoundFunctionWrapper(_FunctionWrapperBase): 

 

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

        # If enabled has been specified, then evaluate it at this point 

        # and if the wrapper is not to be executed, then simply return 

        # the bound function rather than a bound wrapper for the bound 

        # function. When evaluating enabled, if it is callable we call 

        # it, otherwise we evaluate it as a boolean. 

 

        if self._self_enabled is not None: 

            if callable(self._self_enabled): 

                if not self._self_enabled(): 

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

            elif not self._self_enabled: 

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

 

        # We need to do things different depending on whether we are 

        # likely wrapping an instance method vs a static method or class 

        # method. 

 

        if self._self_binding == 'function': 

            if self._self_instance is None: 

                # This situation can occur where someone is calling the 

                # instancemethod via the class type and passing the instance 

                # as the first argument. We need to shift the args before 

                # making the call to the wrapper and effectively bind the 

                # instance to the wrapped function using a partial so the 

                # wrapper doesn't see anything as being different. 

 

                if not args: 

                    raise TypeError('missing 1 required positional argument') 

 

                instance, args = args[0], args[1:] 

                wrapped = functools.partial(self.__wrapped__, instance) 

                return self._self_wrapper(wrapped, instance, args, kwargs) 

 

            return self._self_wrapper(self.__wrapped__, self._self_instance, 

                    args, kwargs) 

 

        else: 

            # As in this case we would be dealing with a classmethod or 

            # staticmethod, then _self_instance will only tell us whether 

            # when calling the classmethod or staticmethod they did it via an 

            # instance of the class it is bound to and not the case where 

            # done by the class type itself. We thus ignore _self_instance 

            # and use the __self__ attribute of the bound function instead. 

            # For a classmethod, this means instance will be the class type 

            # and for a staticmethod it will be None. This is probably the 

            # more useful thing we can pass through even though we loose 

            # knowledge of whether they were called on the instance vs the 

            # class type, as it reflects what they have available in the 

            # decoratored function. 

 

            instance = getattr(self.__wrapped__, '__self__', None) 

 

            return self._self_wrapper(self.__wrapped__, instance, args, 

                    kwargs) 

 

class FunctionWrapper(_FunctionWrapperBase): 

 

    __bound_function_wrapper__ = BoundFunctionWrapper 

 

    def __init__(self, wrapped, wrapper, enabled=None): 

        # What it is we are wrapping here could be anything. We need to 

        # try and detect specific cases though. In particular, we need 

        # to detect when we are given something that is a method of a 

        # class. Further, we need to know when it is likely an instance 

        # method, as opposed to a class or static method. This can 

        # become problematic though as there isn't strictly a fool proof 

        # method of knowing. 

        # 

        # The situations we could encounter when wrapping a method are: 

        # 

        # 1. The wrapper is being applied as part of a decorator which 

        # is a part of the class definition. In this case what we are 

        # given is the raw unbound function, classmethod or staticmethod 

        # wrapper objects. 

        # 

        # The problem here is that we will not know we are being applied 

        # in the context of the class being set up. This becomes 

        # important later for the case of an instance method, because in 

        # that case we just see it as a raw function and can't 

        # distinguish it from wrapping a normal function outside of 

        # a class context. 

        # 

        # 2. The wrapper is being applied when performing monkey 

        # patching of the class type afterwards and the method to be 

        # wrapped was retrieved direct from the __dict__ of the class 

        # type. This is effectively the same as (1) above. 

        # 

        # 3. The wrapper is being applied when performing monkey 

        # patching of the class type afterwards and the method to be 

        # wrapped was retrieved from the class type. In this case 

        # binding will have been performed where the instance against 

        # which the method is bound will be None at that point. 

        # 

        # This case is a problem because we can no longer tell if the 

        # method was a static method, plus if using Python3, we cannot 

        # tell if it was an instance method as the concept of an 

        # unnbound method no longer exists. 

        # 

        # 4. The wrapper is being applied when performing monkey 

        # patching of an instance of a class. In this case binding will 

        # have been perfomed where the instance was not None. 

        # 

        # This case is a problem because we can no longer tell if the 

        # method was a static method. 

        # 

        # Overall, the best we can do is look at the original type of the 

        # object which was wrapped prior to any binding being done and 

        # see if it is an instance of classmethod or staticmethod. In 

        # the case where other decorators are between us and them, if 

        # they do not propagate the __class__  attribute so that the 

        # isinstance() checks works, then likely this will do the wrong 

        # thing where classmethod and staticmethod are used. 

        # 

        # Since it is likely to be very rare that anyone even puts 

        # decorators around classmethod and staticmethod, likelihood of 

        # that being an issue is very small, so we accept it and suggest 

        # that those other decorators be fixed. It is also only an issue 

        # if a decorator wants to actually do things with the arguments. 

        # 

        # As to not being able to identify static methods properly, we 

        # just hope that that isn't something people are going to want 

        # to wrap, or if they do suggest they do it the correct way by 

        # ensuring that it is decorated in the class definition itself, 

        # or patch it in the __dict__ of the class type. 

        # 

        # So to get the best outcome we can, whenever we aren't sure what 

        # it is, we label it as a 'function'. If it was already bound and 

        # that is rebound later, we assume that it will be an instance 

        # method and try an cope with the possibility that the 'self' 

        # argument it being passed as an explicit argument and shuffle 

        # the arguments around to extract 'self' for use as the instance. 

 

        if isinstance(wrapped, classmethod): 

            binding = 'classmethod' 

 

        elif isinstance(wrapped, staticmethod): 

            binding = 'staticmethod' 

 

        elif hasattr(wrapped, '__self__'): 

            if inspect.isclass(wrapped.__self__): 

                binding = 'classmethod' 

            else: 

                binding = 'function' 

 

        else: 

            binding = 'function' 

 

        super(FunctionWrapper, self).__init__(wrapped, None, wrapper, 

                enabled, binding) 

 

try: 

    from ._wrappers import (ObjectProxy, CallableObjectProxy, FunctionWrapper, 

        BoundFunctionWrapper, _FunctionWrapperBase) 

except ImportError: 

    pass 

 

# Helper functions for applying wrappers to existing functions. 

 

def resolve_path(module, name): 

    if isinstance(module, string_types): 

        __import__(module) 

        module = sys.modules[module] 

 

    parent = module 

 

    path = name.split('.') 

    attribute = path[0] 

 

    original = getattr(parent, attribute) 

    for attribute in path[1:]: 

        parent = original 

 

        # We can't just always use getattr() because in doing 

        # that on a class it will cause binding to occur which 

        # will complicate things later and cause some things not 

        # to work. For the case of a class we therefore access 

        # the __dict__ directly. To cope though with the wrong 

        # class being given to us, or a method being moved into 

        # a base class, we need to walk the class heirarchy to 

        # work out exactly which __dict__ the method was defined 

        # in, as accessing it from __dict__ will fail if it was 

        # not actually on the class given. Fallback to using 

        # getattr() if we can't find it. If it truly doesn't 

        # exist, then that will fail. 

 

        if inspect.isclass(original): 

            for cls in inspect.getmro(original): 

                if attribute in vars(original): 

                    original = vars(original)[attribute] 

                    break 

            else: 

                original = getattr(original, attribute) 

 

        else: 

            original = getattr(original, attribute) 

 

    return (parent, attribute, original) 

 

def apply_patch(parent, attribute, replacement): 

    setattr(parent, attribute, replacement) 

 

def wrap_object(module, name, factory, args=(), kwargs={}): 

    (parent, attribute, original) = resolve_path(module, name) 

    wrapper = factory(original, *args, **kwargs) 

    apply_patch(parent, attribute, wrapper) 

    return wrapper 

 

# Function for applying a proxy object to an attribute of a class 

# instance. The wrapper works by defining an attribute of the same name 

# on the class which is a descriptor and which intercepts access to the 

# instance attribute. Note that this cannot be used on attributes which 

# are themselves defined by a property object. 

 

class AttributeWrapper(object): 

 

    def __init__(self, attribute, factory, args, kwargs): 

        self.attribute = attribute 

        self.factory = factory 

        self.args = args 

        self.kwargs = kwargs 

 

    def __get__(self, instance, owner): 

        value = instance.__dict__[self.attribute] 

        return self.factory(value, *self.args, **self.kwargs) 

 

    def __set__(self, instance, value): 

        instance.__dict__[self.attribute] = value 

 

    def __delete__(self, instance): 

        del instance.__dict__[self.attribute] 

 

def wrap_object_attribute(module, name, factory, args=(), kwargs={}): 

    path, attribute = name.rsplit('.', 1) 

    parent = resolve_path(module, path)[2] 

    wrapper = AttributeWrapper(attribute, factory, args, kwargs) 

    apply_patch(parent, attribute, wrapper) 

    return wrapper 

 

# Functions for creating a simple decorator using a FunctionWrapper, 

# plus short cut functions for applying wrappers to functions. These are 

# for use when doing monkey patching. For a more featured way of 

# creating decorators see the decorator decorator instead. 

 

def function_wrapper(wrapper): 

    def _wrapper(wrapped, instance, args, kwargs): 

        target_wrapped = args[0] 

        if instance is None: 

            target_wrapper = wrapper 

        elif inspect.isclass(instance): 

            target_wrapper = wrapper.__get__(None, instance) 

        else: 

            target_wrapper = wrapper.__get__(instance, type(instance)) 

        return FunctionWrapper(target_wrapped, target_wrapper) 

    return FunctionWrapper(wrapper, _wrapper) 

 

def wrap_function_wrapper(module, name, wrapper): 

    return wrap_object(module, name, FunctionWrapper, (wrapper,)) 

 

def patch_function_wrapper(module, name): 

    def _wrapper(wrapper): 

        return wrap_object(module, name, FunctionWrapper, (wrapper,)) 

    return _wrapper 

 

def transient_function_wrapper(module, name): 

    def _decorator(wrapper): 

        def _wrapper(wrapped, instance, args, kwargs): 

            target_wrapped = args[0] 

            if instance is None: 

                target_wrapper = wrapper 

            elif inspect.isclass(instance): 

                target_wrapper = wrapper.__get__(None, instance) 

            else: 

                target_wrapper = wrapper.__get__(instance, type(instance)) 

            def _execute(wrapped, instance, args, kwargs): 

                (parent, attribute, original) = resolve_path(module, name) 

                replacement = FunctionWrapper(original, target_wrapper) 

                setattr(parent, attribute, replacement) 

                try: 

                    return wrapped(*args, **kwargs) 

                finally: 

                    setattr(parent, attribute, original) 

            return FunctionWrapper(target_wrapped, _execute) 

        return FunctionWrapper(wrapper, _wrapper) 

    return _decorator 

 

# A weak function proxy. This will work on instance methods, class 

# methods, static methods and regular functions. Special treatment is 

# needed for the method types because the bound method is effectively a 

# transient object and applying a weak reference to one will immediately 

# result in it being destroyed and the weakref callback called. The weak 

# reference is therefore applied to the instance the method is bound to 

# and the original function. The function is then rebound at the point 

# of a call via the weak function proxy. 

 

def _weak_function_proxy_callback(ref, proxy, callback): 

    if proxy._self_expired: 

        return 

 

    proxy._self_expired = True 

 

    # This could raise an exception. We let it propagate back and let 

    # the weakref.proxy() deal with it, at which point it generally 

    # prints out a short error message direct to stderr and keeps going. 

 

    if callback is not None: 

        callback(proxy) 

 

class WeakFunctionProxy(ObjectProxy): 

 

    __slots__ = ('_self_expired', '_self_instance') 

 

    def __init__(self, wrapped, callback=None): 

        # We need to determine if the wrapped function is actually a 

        # bound method. In the case of a bound method, we need to keep a 

        # reference to the original unbound function and the instance. 

        # This is necessary because if we hold a reference to the bound 

        # function, it will be the only reference and given it is a 

        # temporary object, it will almost immediately expire and 

        # the weakref callback triggered. So what is done is that we 

        # hold a reference to the instance and unbound function and 

        # when called bind the function to the instance once again and 

        # then call it. Note that we avoid using a nested function for 

        # the callback here so as not to cause any odd reference cycles. 

 

        _callback = callback and functools.partial( 

                _weak_function_proxy_callback, proxy=self, 

                callback=callback) 

 

        self._self_expired = False 

 

        try: 

            self._self_instance = weakref.ref(wrapped.__self__, _callback) 

 

            super(WeakFunctionProxy, self).__init__( 

                    weakref.proxy(wrapped.__func__, _callback)) 

 

        except AttributeError: 

            self._self_instance = None 

 

            super(WeakFunctionProxy, self).__init__( 

                    weakref.proxy(wrapped, _callback)) 

 

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

        # We perform a boolean check here on the instance and wrapped 

        # function as that will trigger the reference error prior to 

        # calling if the reference had expired. 

 

        instance = self._self_instance and self._self_instance() 

        function = self.__wrapped__ and self.__wrapped__ 

 

        # If the wrapped function was originally a bound function, for 

        # which we retained a reference to the instance and the unbound 

        # function we need to rebind the function and then call it. If 

        # not just called the wrapped function. 

 

        if instance is None: 

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

 

        return function.__get__(instance, type(instance))(*args, **kwargs)