source file: /System/Library/Frameworks/Python.framework/Versions/2.3/lib/python2.3/inspect.py
file stats: 438 lines, 98 executed: 22.4% covered
1. # -*- coding: iso-8859-1 -*- 2. """Get useful information from live Python objects. 3. 4. This module encapsulates the interface provided by the internal special 5. attributes (func_*, co_*, im_*, tb_*, etc.) in a friendlier fashion. 6. It also provides some help for examining source code and class layout. 7. 8. Here are some of the useful functions provided by this module: 9. 10. ismodule(), isclass(), ismethod(), isfunction(), istraceback(), 11. isframe(), iscode(), isbuiltin(), isroutine() - check object types 12. getmembers() - get members of an object that satisfy a given condition 13. 14. getfile(), getsourcefile(), getsource() - find an object's source code 15. getdoc(), getcomments() - get documentation on an object 16. getmodule() - determine the module that an object came from 17. getclasstree() - arrange classes so as to represent their hierarchy 18. 19. getargspec(), getargvalues() - get info about function arguments 20. formatargspec(), formatargvalues() - format an argument spec 21. getouterframes(), getinnerframes() - get info about frames 22. currentframe() - get the current stack frame 23. stack(), trace() - get info about frames on the stack or in a traceback 24. """ 25. 26. # This module is in the public domain. No warranties. 27. 28. __author__ = 'Ka-Ping Yee <ping@lfw.org>' 29. __date__ = '1 Jan 2001' 30. 31. import sys, os, types, string, re, dis, imp, tokenize, linecache 32. 33. # ----------------------------------------------------------- type-checking 34. def ismodule(object): 35. """Return true if the object is a module. 36. 37. Module objects provide these attributes: 38. __doc__ documentation string 39. __file__ filename (missing for built-in modules)""" 40. return isinstance(object, types.ModuleType) 41. 42. def isclass(object): 43. """Return true if the object is a class. 44. 45. Class objects provide these attributes: 46. __doc__ documentation string 47. __module__ name of module in which this class was defined""" 48. return isinstance(object, types.ClassType) or hasattr(object, '__bases__') 49. 50. def ismethod(object): 51. """Return true if the object is an instance method. 52. 53. Instance method objects provide these attributes: 54. __doc__ documentation string 55. __name__ name with which this method was defined 56. im_class class object in which this method belongs 57. im_func function object containing implementation of method 58. im_self instance to which this method is bound, or None""" 59. return isinstance(object, types.MethodType) 60. 61. def ismethoddescriptor(object): 62. """Return true if the object is a method descriptor. 63. 64. But not if ismethod() or isclass() or isfunction() are true. 65. 66. This is new in Python 2.2, and, for example, is true of int.__add__. 67. An object passing this test has a __get__ attribute but not a __set__ 68. attribute, but beyond that the set of attributes varies. __name__ is 69. usually sensible, and __doc__ often is. 70. 71. Methods implemented via descriptors that also pass one of the other 72. tests return false from the ismethoddescriptor() test, simply because 73. the other tests promise more -- you can, e.g., count on having the 74. im_func attribute (etc) when an object passes ismethod().""" 75. return (hasattr(object, "__get__") 76. and not hasattr(object, "__set__") # else it's a data descriptor 77. and not ismethod(object) # mutual exclusion 78. and not isfunction(object) 79. and not isclass(object)) 80. 81. def isdatadescriptor(object): 82. """Return true if the object is a data descriptor. 83. 84. Data descriptors have both a __get__ and a __set__ attribute. Examples are 85. properties (defined in Python) and getsets and members (defined in C). 86. Typically, data descriptors will also have __name__ and __doc__ attributes 87. (properties, getsets, and members have both of these attributes), but this 88. is not guaranteed.""" 89. return (hasattr(object, "__set__") and hasattr(object, "__get__")) 90. 91. def isfunction(object): 92. """Return true if the object is a user-defined function. 93. 94. Function objects provide these attributes: 95. __doc__ documentation string 96. __name__ name with which this function was defined 97. func_code code object containing compiled function bytecode 98. func_defaults tuple of any default values for arguments 99. func_doc (same as __doc__) 100. func_globals global namespace in which this function was defined 101. func_name (same as __name__)""" 102. return isinstance(object, types.FunctionType) 103. 104. def istraceback(object): 105. """Return true if the object is a traceback. 106. 107. Traceback objects provide these attributes: 108. tb_frame frame object at this level 109. tb_lasti index of last attempted instruction in bytecode 110. tb_lineno current line number in Python source code 111. tb_next next inner traceback object (called by this level)""" 112. return isinstance(object, types.TracebackType) 113. 114. def isframe(object): 115. """Return true if the object is a frame object. 116. 117. Frame objects provide these attributes: 118. f_back next outer frame object (this frame's caller) 119. f_builtins built-in namespace seen by this frame 120. f_code code object being executed in this frame 121. f_exc_traceback traceback if raised in this frame, or None 122. f_exc_type exception type if raised in this frame, or None 123. f_exc_value exception value if raised in this frame, or None 124. f_globals global namespace seen by this frame 125. f_lasti index of last attempted instruction in bytecode 126. f_lineno current line number in Python source code 127. f_locals local namespace seen by this frame 128. f_restricted 0 or 1 if frame is in restricted execution mode 129. f_trace tracing function for this frame, or None""" 130. return isinstance(object, types.FrameType) 131. 132. def iscode(object): 133. """Return true if the object is a code object. 134. 135. Code objects provide these attributes: 136. co_argcount number of arguments (not including * or ** args) 137. co_code string of raw compiled bytecode 138. co_consts tuple of constants used in the bytecode 139. co_filename name of file in which this code object was created 140. co_firstlineno number of first line in Python source code 141. co_flags bitmap: 1=optimized | 2=newlocals | 4=*arg | 8=**arg 142. co_lnotab encoded mapping of line numbers to bytecode indices 143. co_name name with which this code object was defined 144. co_names tuple of names of local variables 145. co_nlocals number of local variables 146. co_stacksize virtual machine stack space required 147. co_varnames tuple of names of arguments and local variables""" 148. return isinstance(object, types.CodeType) 149. 150. def isbuiltin(object): 151. """Return true if the object is a built-in function or method. 152. 153. Built-in functions and methods provide these attributes: 154. __doc__ documentation string 155. __name__ original name of this function or method 156. __self__ instance to which a method is bound, or None""" 157. return isinstance(object, types.BuiltinFunctionType) 158. 159. def isroutine(object): 160. """Return true if the object is any kind of function or method.""" 161. return (isbuiltin(object) 162. or isfunction(object) 163. or ismethod(object) 164. or ismethoddescriptor(object)) 165. 166. def getmembers(object, predicate=None): 167. """Return all members of an object as (name, value) pairs sorted by name. 168. Optionally, only return members that satisfy a given predicate.""" 169. results = [] 170. for key in dir(object): 171. value = getattr(object, key) 172. if not predicate or predicate(value): 173. results.append((key, value)) 174. results.sort() 175. return results 176. 177. def classify_class_attrs(cls): 178. """Return list of attribute-descriptor tuples. 179. 180. For each name in dir(cls), the return list contains a 4-tuple 181. with these elements: 182. 183. 0. The name (a string). 184. 185. 1. The kind of attribute this is, one of these strings: 186. 'class method' created via classmethod() 187. 'static method' created via staticmethod() 188. 'property' created via property() 189. 'method' any other flavor of method 190. 'data' not a method 191. 192. 2. The class which defined this attribute (a class). 193. 194. 3. The object as obtained directly from the defining class's 195. __dict__, not via getattr. This is especially important for 196. data attributes: C.data is just a data object, but 197. C.__dict__['data'] may be a data descriptor with additional 198. info, like a __doc__ string. 199. """ 200. 201. mro = getmro(cls) 202. names = dir(cls) 203. result = [] 204. for name in names: 205. # Get the object associated with the name. 206. # Getting an obj from the __dict__ sometimes reveals more than 207. # using getattr. Static and class methods are dramatic examples. 208. if name in cls.__dict__: 209. obj = cls.__dict__[name] 210. else: 211. obj = getattr(cls, name) 212. 213. # Figure out where it was defined. 214. homecls = getattr(obj, "__objclass__", None) 215. if homecls is None: 216. # search the dicts. 217. for base in mro: 218. if name in base.__dict__: 219. homecls = base 220. break 221. 222. # Get the object again, in order to get it from the defining 223. # __dict__ instead of via getattr (if possible). 224. if homecls is not None and name in homecls.__dict__: 225. obj = homecls.__dict__[name] 226. 227. # Also get the object via getattr. 228. obj_via_getattr = getattr(cls, name) 229. 230. # Classify the object. 231. if isinstance(obj, staticmethod): 232. kind = "static method" 233. elif isinstance(obj, classmethod): 234. kind = "class method" 235. elif isinstance(obj, property): 236. kind = "property" 237. elif (ismethod(obj_via_getattr) or 238. ismethoddescriptor(obj_via_getattr)): 239. kind = "method" 240. else: 241. kind = "data" 242. 243. result.append((name, kind, homecls, obj)) 244. 245. return result 246. 247. # ----------------------------------------------------------- class helpers 248. def _searchbases(cls, accum): 249. # Simulate the "classic class" search order. 250. if cls in accum: 251. return 252. accum.append(cls) 253. for base in cls.__bases__: 254. _searchbases(base, accum) 255. 256. def getmro(cls): 257. "Return tuple of base classes (including cls) in method resolution order." 258. if hasattr(cls, "__mro__"): 259. return cls.__mro__ 260. else: 261. result = [] 262. _searchbases(cls, result) 263. return tuple(result) 264. 265. # -------------------------------------------------- source code extraction 266. def indentsize(line): 267. """Return the indent size, in spaces, at the start of a line of text.""" 268. expline = string.expandtabs(line) 269. return len(expline) - len(string.lstrip(expline)) 270. 271. def getdoc(object): 272. """Get the documentation string for an object. 273. 274. All tabs are expanded to spaces. To clean up docstrings that are 275. indented to line up with blocks of code, any whitespace than can be 276. uniformly removed from the second line onwards is removed.""" 277. try: 278. doc = object.__doc__ 279. except AttributeError: 280. return None 281. if not isinstance(doc, types.StringTypes): 282. return None 283. try: 284. lines = string.split(string.expandtabs(doc), '\n') 285. except UnicodeError: 286. return None 287. else: 288. # Find minimum indentation of any non-blank lines after first line. 289. margin = sys.maxint 290. for line in lines[1:]: 291. content = len(string.lstrip(line)) 292. if content: 293. indent = len(line) - content 294. margin = min(margin, indent) 295. # Remove indentation. 296. if lines: 297. lines[0] = lines[0].lstrip() 298. if margin < sys.maxint: 299. for i in range(1, len(lines)): lines[i] = lines[i][margin:] 300. # Remove any trailing or leading blank lines. 301. while lines and not lines[-1]: 302. lines.pop() 303. while lines and not lines[0]: 304. lines.pop(0) 305. return string.join(lines, '\n') 306. 307. def getfile(object): 308. """Work out which source or compiled file an object was defined in.""" 309. if ismodule(object): 310. if hasattr(object, '__file__'): 311. return object.__file__ 312. raise TypeError('arg is a built-in module') 313. if isclass(object): 314. object = sys.modules.get(object.__module__) 315. if hasattr(object, '__file__'): 316. return object.__file__ 317. raise TypeError('arg is a built-in class') 318. if ismethod(object): 319. object = object.im_func 320. if isfunction(object): 321. object = object.func_code 322. if istraceback(object): 323. object = object.tb_frame 324. if isframe(object): 325. object = object.f_code 326. if iscode(object): 327. return object.co_filename 328. raise TypeError('arg is not a module, class, method, ' 329. 'function, traceback, frame, or code object') 330. 331. def getmoduleinfo(path): 332. """Get the module name, suffix, mode, and module type for a given file.""" 333. filename = os.path.basename(path) 334. suffixes = map(lambda (suffix, mode, mtype): 335. (-len(suffix), suffix, mode, mtype), imp.get_suffixes()) 336. suffixes.sort() # try longest suffixes first, in case they overlap 337. for neglen, suffix, mode, mtype in suffixes: 338. if filename[neglen:] == suffix: 339. return filename[:neglen], suffix, mode, mtype 340. 341. def getmodulename(path): 342. """Return the module name for a given file, or None.""" 343. info = getmoduleinfo(path) 344. if info: return info[0] 345. 346. def getsourcefile(object): 347. """Return the Python source file an object was defined in, if it exists.""" 348. filename = getfile(object) 349. if string.lower(filename[-4:]) in ['.pyc', '.pyo']: 350. filename = filename[:-4] + '.py' 351. for suffix, mode, kind in imp.get_suffixes(): 352. if 'b' in mode and string.lower(filename[-len(suffix):]) == suffix: 353. # Looks like a binary file. We want to only return a text file. 354. return None 355. if os.path.exists(filename): 356. return filename 357. 358. def getabsfile(object): 359. """Return an absolute path to the source or compiled file for an object. 360. 361. The idea is for each object to have a unique origin, so this routine 362. normalizes the result as much as possible.""" 363. return os.path.normcase( 364. os.path.abspath(getsourcefile(object) or getfile(object))) 365. 366. modulesbyfile = {} 367. 368. def getmodule(object): 369. """Return the module an object was defined in, or None if not found.""" 370. if ismodule(object): 371. return object 372. if isclass(object): 373. return sys.modules.get(object.__module__) 374. try: 375. file = getabsfile(object) 376. except TypeError: 377. return None 378. if file in modulesbyfile: 379. return sys.modules.get(modulesbyfile[file]) 380. for module in sys.modules.values(): 381. if hasattr(module, '__file__'): 382. modulesbyfile[getabsfile(module)] = module.__name__ 383. if file in modulesbyfile: 384. return sys.modules.get(modulesbyfile[file]) 385. main = sys.modules['__main__'] 386. if not hasattr(object, '__name__'): 387. return None 388. if hasattr(main, object.__name__): 389. mainobject = getattr(main, object.__name__) 390. if mainobject is object: 391. return main 392. builtin = sys.modules['__builtin__'] 393. if hasattr(builtin, object.__name__): 394. builtinobject = getattr(builtin, object.__name__) 395. if builtinobject is object: 396. return builtin 397. 398. def findsource(object): 399. """Return the entire source file and starting line number for an object. 400. 401. The argument may be a module, class, method, function, traceback, frame, 402. or code object. The source code is returned as a list of all the lines 403. in the file and the line number indexes a line in that list. An IOError 404. is raised if the source code cannot be retrieved.""" 405. file = getsourcefile(object) or getfile(object) 406. lines = linecache.getlines(file) 407. if not lines: 408. raise IOError('could not get source code') 409. 410. if ismodule(object): 411. return lines, 0 412. 413. if isclass(object): 414. name = object.__name__ 415. pat = re.compile(r'^\s*class\s*' + name + r'\b') 416. for i in range(len(lines)): 417. if pat.match(lines[i]): return lines, i 418. else: 419. raise IOError('could not find class definition') 420. 421. if ismethod(object): 422. object = object.im_func 423. if isfunction(object): 424. object = object.func_code 425. if istraceback(object): 426. object = object.tb_frame 427. if isframe(object): 428. object = object.f_code 429. if iscode(object): 430. if not hasattr(object, 'co_firstlineno'): 431. raise IOError('could not find function definition') 432. lnum = object.co_firstlineno - 1 433. pat = re.compile(r'^(\s*def\s)|(.*\slambda(:|\s))') 434. while lnum > 0: 435. if pat.match(lines[lnum]): break 436. lnum = lnum - 1 437. return lines, lnum 438. raise IOError('could not find code object') 439. 440. def getcomments(object): 441. """Get lines of comments immediately preceding an object's source code. 442. 443. Returns None when source can't be found. 444. """ 445. try: 446. lines, lnum = findsource(object) 447. except (IOError, TypeError): 448. return None 449. 450. if ismodule(object): 451. # Look for a comment block at the top of the file. 452. start = 0 453. if lines and lines[0][:2] == '#!': start = 1 454. while start < len(lines) and string.strip(lines[start]) in ['', '#']: 455. start = start + 1 456. if start < len(lines) and lines[start][:1] == '#': 457. comments = [] 458. end = start 459. while end < len(lines) and lines[end][:1] == '#': 460. comments.append(string.expandtabs(lines[end])) 461. end = end + 1 462. return string.join(comments, '') 463. 464. # Look for a preceding block of comments at the same indentation. 465. elif lnum > 0: 466. indent = indentsize(lines[lnum]) 467. end = lnum - 1 468. if end >= 0 and string.lstrip(lines[end])[:1] == '#' and \ 469. indentsize(lines[end]) == indent: 470. comments = [string.lstrip(string.expandtabs(lines[end]))] 471. if end > 0: 472. end = end - 1 473. comment = string.lstrip(string.expandtabs(lines[end])) 474. while comment[:1] == '#' and indentsize(lines[end]) == indent: 475. comments[:0] = [comment] 476. end = end - 1 477. if end < 0: break 478. comment = string.lstrip(string.expandtabs(lines[end])) 479. while comments and string.strip(comments[0]) == '#': 480. comments[:1] = [] 481. while comments and string.strip(comments[-1]) == '#': 482. comments[-1:] = [] 483. return string.join(comments, '') 484. 485. class ListReader: 486. """Provide a readline() method to return lines from a list of strings.""" 487. def __init__(self, lines): 488. self.lines = lines 489. self.index = 0 490. 491. def readline(self): 492. i = self.index 493. if i < len(self.lines): 494. self.index = i + 1 495. return self.lines[i] 496. else: return '' 497. 498. class EndOfBlock(Exception): pass 499. 500. class BlockFinder: 501. """Provide a tokeneater() method to detect the end of a code block.""" 502. def __init__(self): 503. self.indent = 0 504. self.started = 0 505. self.last = 0 506. 507. def tokeneater(self, type, token, (srow, scol), (erow, ecol), line): 508. if not self.started: 509. if type == tokenize.NAME: self.started = 1 510. elif type == tokenize.NEWLINE: 511. self.last = srow 512. elif type == tokenize.INDENT: 513. self.indent = self.indent + 1 514. elif type == tokenize.DEDENT: 515. self.indent = self.indent - 1 516. if self.indent == 0: 517. raise EndOfBlock, self.last 518. elif type == tokenize.NAME and scol == 0: 519. raise EndOfBlock, self.last 520. 521. def getblock(lines): 522. """Extract the block of code at the top of the given list of lines.""" 523. try: 524. tokenize.tokenize(ListReader(lines).readline, BlockFinder().tokeneater) 525. except EndOfBlock, eob: 526. return lines[:eob.args[0]] 527. # Fooling the indent/dedent logic implies a one-line definition 528. return lines[:1] 529. 530. def getsourcelines(object): 531. """Return a list of source lines and starting line number for an object. 532. 533. The argument may be a module, class, method, function, traceback, frame, 534. or code object. The source code is returned as a list of the lines 535. corresponding to the object and the line number indicates where in the 536. original source file the first line of code was found. An IOError is 537. raised if the source code cannot be retrieved.""" 538. lines, lnum = findsource(object) 539. 540. if ismodule(object): return lines, 0 541. else: return getblock(lines[lnum:]), lnum + 1 542. 543. def getsource(object): 544. """Return the text of the source code for an object. 545. 546. The argument may be a module, class, method, function, traceback, frame, 547. or code object. The source code is returned as a single string. An 548. IOError is raised if the source code cannot be retrieved.""" 549. lines, lnum = getsourcelines(object) 550. return string.join(lines, '') 551. 552. # --------------------------------------------------- class tree extraction 553. def walktree(classes, children, parent): 554. """Recursive helper function for getclasstree().""" 555. results = [] 556. classes.sort(lambda a, b: cmp(a.__name__, b.__name__)) 557. for c in classes: 558. results.append((c, c.__bases__)) 559. if c in children: 560. results.append(walktree(children[c], children, c)) 561. return results 562. 563. def getclasstree(classes, unique=0): 564. """Arrange the given list of classes into a hierarchy of nested lists. 565. 566. Where a nested list appears, it contains classes derived from the class 567. whose entry immediately precedes the list. Each entry is a 2-tuple 568. containing a class and a tuple of its base classes. If the 'unique' 569. argument is true, exactly one entry appears in the returned structure 570. for each class in the given list. Otherwise, classes using multiple 571. inheritance and their descendants will appear multiple times.""" 572. children = {} 573. roots = [] 574. for c in classes: 575. if c.__bases__: 576. for parent in c.__bases__: 577. if not parent in children: 578. children[parent] = [] 579. children[parent].append(c) 580. if unique and parent in classes: break 581. elif c not in roots: 582. roots.append(c) 583. for parent in children: 584. if parent not in classes: 585. roots.append(parent) 586. return walktree(roots, children, None) 587. 588. # ------------------------------------------------ argument list extraction 589. # These constants are from Python's compile.h. 590. CO_OPTIMIZED, CO_NEWLOCALS, CO_VARARGS, CO_VARKEYWORDS = 1, 2, 4, 8 591. 592. def getargs(co): 593. """Get information about the arguments accepted by a code object. 594. 595. Three things are returned: (args, varargs, varkw), where 'args' is 596. a list of argument names (possibly containing nested lists), and 597. 'varargs' and 'varkw' are the names of the * and ** arguments or None.""" 598. 599. if not iscode(co): 600. raise TypeError('arg is not a code object') 601. 602. code = co.co_code 603. nargs = co.co_argcount 604. names = co.co_varnames 605. args = list(names[:nargs]) 606. step = 0 607. 608. # The following acrobatics are for anonymous (tuple) arguments. 609. for i in range(nargs): 610. if args[i][:1] in ['', '.']: 611. stack, remain, count = [], [], [] 612. while step < len(code): 613. op = ord(code[step]) 614. step = step + 1 615. if op >= dis.HAVE_ARGUMENT: 616. opname = dis.opname[op] 617. value = ord(code[step]) + ord(code[step+1])*256 618. step = step + 2 619. if opname in ['UNPACK_TUPLE', 'UNPACK_SEQUENCE']: 620. remain.append(value) 621. count.append(value) 622. elif opname == 'STORE_FAST': 623. stack.append(names[value]) 624. 625. # Special case for sublists of length 1: def foo((bar)) 626. # doesn't generate the UNPACK_TUPLE bytecode, so if 627. # `remain` is empty here, we have such a sublist. 628. if not remain: 629. stack[0] = [stack[0]] 630. break 631. else: 632. remain[-1] = remain[-1] - 1 633. while remain[-1] == 0: 634. remain.pop() 635. size = count.pop() 636. stack[-size:] = [stack[-size:]] 637. if not remain: break 638. remain[-1] = remain[-1] - 1 639. if not remain: break 640. args[i] = stack[0] 641. 642. varargs = None 643. if co.co_flags & CO_VARARGS: 644. varargs = co.co_varnames[nargs] 645. nargs = nargs + 1 646. varkw = None 647. if co.co_flags & CO_VARKEYWORDS: 648. varkw = co.co_varnames[nargs] 649. return args, varargs, varkw 650. 651. def getargspec(func): 652. """Get the names and default values of a function's arguments. 653. 654. A tuple of four things is returned: (args, varargs, varkw, defaults). 655. 'args' is a list of the argument names (it may contain nested lists). 656. 'varargs' and 'varkw' are the names of the * and ** arguments or None. 657. 'defaults' is an n-tuple of the default values of the last n arguments. 658. """ 659. 660. if ismethod(func): 661. func = func.im_func 662. if not isfunction(func): 663. raise TypeError('arg is not a Python function') 664. args, varargs, varkw = getargs(func.func_code) 665. return args, varargs, varkw, func.func_defaults 666. 667. def getargvalues(frame): 668. """Get information about arguments passed into a particular frame. 669. 670. A tuple of four things is returned: (args, varargs, varkw, locals). 671. 'args' is a list of the argument names (it may contain nested lists). 672. 'varargs' and 'varkw' are the names of the * and ** arguments or None. 673. 'locals' is the locals dictionary of the given frame.""" 674. args, varargs, varkw = getargs(frame.f_code) 675. return args, varargs, varkw, frame.f_locals 676. 677. def joinseq(seq): 678. if len(seq) == 1: 679. return '(' + seq[0] + ',)' 680. else: 681. return '(' + string.join(seq, ', ') + ')' 682. 683. def strseq(object, convert, join=joinseq): 684. """Recursively walk a sequence, stringifying each element.""" 685. if type(object) in [types.ListType, types.TupleType]: 686. return join(map(lambda o, c=convert, j=join: strseq(o, c, j), object)) 687. else: 688. return convert(object) 689. 690. def formatargspec(args, varargs=None, varkw=None, defaults=None, 691. formatarg=str, 692. formatvarargs=lambda name: '*' + name, 693. formatvarkw=lambda name: '**' + name, 694. formatvalue=lambda value: '=' + repr(value), 695. join=joinseq): 696. """Format an argument spec from the 4 values returned by getargspec. 697. 698. The first four arguments are (args, varargs, varkw, defaults). The 699. other four arguments are the corresponding optional formatting functions 700. that are called to turn names and values into strings. The ninth 701. argument is an optional function to format the sequence of arguments.""" 702. specs = [] 703. if defaults: 704. firstdefault = len(args) - len(defaults) 705. for i in range(len(args)): 706. spec = strseq(args[i], formatarg, join) 707. if defaults and i >= firstdefault: 708. spec = spec + formatvalue(defaults[i - firstdefault]) 709. specs.append(spec) 710. if varargs is not None: 711. specs.append(formatvarargs(varargs)) 712. if varkw is not None: 713. specs.append(formatvarkw(varkw)) 714. return '(' + string.join(specs, ', ') + ')' 715. 716. def formatargvalues(args, varargs, varkw, locals, 717. formatarg=str, 718. formatvarargs=lambda name: '*' + name, 719. formatvarkw=lambda name: '**' + name, 720. formatvalue=lambda value: '=' + repr(value), 721. join=joinseq): 722. """Format an argument spec from the 4 values returned by getargvalues. 723. 724. The first four arguments are (args, varargs, varkw, locals). The 725. next four arguments are the corresponding optional formatting functions 726. that are called to turn names and values into strings. The ninth 727. argument is an optional function to format the sequence of arguments.""" 728. def convert(name, locals=locals, 729. formatarg=formatarg, formatvalue=formatvalue): 730. return formatarg(name) + formatvalue(locals[name]) 731. specs = [] 732. for i in range(len(args)): 733. specs.append(strseq(args[i], convert, join)) 734. if varargs: 735. specs.append(formatvarargs(varargs) + formatvalue(locals[varargs])) 736. if varkw: 737. specs.append(formatvarkw(varkw) + formatvalue(locals[varkw])) 738. return '(' + string.join(specs, ', ') + ')' 739. 740. # -------------------------------------------------- stack frame extraction 741. def getframeinfo(frame, context=1): 742. """Get information about a frame or traceback object. 743. 744. A tuple of five things is returned: the filename, the line number of 745. the current line, the function name, a list of lines of context from 746. the source code, and the index of the current line within that list. 747. The optional second argument specifies the number of lines of context 748. to return, which are centered around the current line.""" 749. if istraceback(frame): 750. lineno = frame.tb_lineno 751. frame = frame.tb_frame 752. else: 753. lineno = frame.f_lineno 754. if not isframe(frame): 755. raise TypeError('arg is not a frame or traceback object') 756. 757. filename = getsourcefile(frame) or getfile(frame) 758. if context > 0: 759. start = lineno - 1 - context//2 760. try: 761. lines, lnum = findsource(frame) 762. except IOError: 763. lines = index = None 764. else: 765. start = max(start, 1) 766. start = min(start, len(lines) - context) 767. lines = lines[start:start+context] 768. index = lineno - 1 - start 769. else: 770. lines = index = None 771. 772. return (filename, lineno, frame.f_code.co_name, lines, index) 773. 774. def getlineno(frame): 775. """Get the line number from a frame object, allowing for optimization.""" 776. # FrameType.f_lineno is now a descriptor that grovels co_lnotab 777. return frame.f_lineno 778. 779. def getouterframes(frame, context=1): 780. """Get a list of records for a frame and all higher (calling) frames. 781. 782. Each record contains a frame object, filename, line number, function 783. name, a list of lines of context, and index within the context.""" 784. framelist = [] 785. while frame: 786. framelist.append((frame,) + getframeinfo(frame, context)) 787. frame = frame.f_back 788. return framelist 789. 790. def getinnerframes(tb, context=1): 791. """Get a list of records for a traceback's frame and all lower frames. 792. 793. Each record contains a frame object, filename, line number, function 794. name, a list of lines of context, and index within the context.""" 795. framelist = [] 796. while tb: 797. framelist.append((tb.tb_frame,) + getframeinfo(tb, context)) 798. tb = tb.tb_next 799. return framelist 800. 801. currentframe = sys._getframe 802. 803. def stack(context=1): 804. """Return a list of records for the stack above the caller's frame.""" 805. return getouterframes(sys._getframe(1), context) 806. 807. def trace(context=1): 808. """Return a list of records for the stack below the current exception.""" 809. return getinnerframes(sys.exc_info()[2], context)