]>
git.proxmox.com Git - mirror_edk2.git/blob - AppPkg/Applications/Python/Python-2.7.10/Lib/inspect.py
1 # -*- coding: iso-8859-1 -*-
2 """Get useful information from live Python objects.
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.
8 Here are some of the useful functions provided by this module:
10 ismodule(), isclass(), ismethod(), isfunction(), isgeneratorfunction(),
11 isgenerator(), istraceback(), isframe(), iscode(), isbuiltin(),
12 isroutine() - check object types
13 getmembers() - get members of an object that satisfy a given condition
15 getfile(), getsourcefile(), getsource() - find an object's source code
16 getdoc(), getcomments() - get documentation on an object
17 getmodule() - determine the module that an object came from
18 getclasstree() - arrange classes so as to represent their hierarchy
20 getargspec(), getargvalues(), getcallargs() - get info about function arguments
21 formatargspec(), formatargvalues() - format an argument spec
22 getouterframes(), getinnerframes() - get info about frames
23 currentframe() - get the current stack frame
24 stack(), trace() - get info about frames on the stack or in a traceback
27 # This module is in the public domain. No warranties.
29 __author__
= 'Ka-Ping Yee <ping@lfw.org>'
30 __date__
= '1 Jan 2001'
41 from operator
import attrgetter
42 from collections
import namedtuple
44 # These constants are from Include/code.h.
45 CO_OPTIMIZED
, CO_NEWLOCALS
, CO_VARARGS
, CO_VARKEYWORDS
= 0x1, 0x2, 0x4, 0x8
46 CO_NESTED
, CO_GENERATOR
, CO_NOFREE
= 0x10, 0x20, 0x40
47 # See Include/object.h
48 TPFLAGS_IS_ABSTRACT
= 1 << 20
50 # ----------------------------------------------------------- type-checking
52 """Return true if the object is a module.
54 Module objects provide these attributes:
55 __doc__ documentation string
56 __file__ filename (missing for built-in modules)"""
57 return isinstance(object, types
.ModuleType
)
60 """Return true if the object is a class.
62 Class objects provide these attributes:
63 __doc__ documentation string
64 __module__ name of module in which this class was defined"""
65 return isinstance(object, (type, types
.ClassType
))
68 """Return true if the object is an instance method.
70 Instance method objects provide these attributes:
71 __doc__ documentation string
72 __name__ name with which this method was defined
73 im_class class object in which this method belongs
74 im_func function object containing implementation of method
75 im_self instance to which this method is bound, or None"""
76 return isinstance(object, types
.MethodType
)
78 def ismethoddescriptor(object):
79 """Return true if the object is a method descriptor.
81 But not if ismethod() or isclass() or isfunction() are true.
83 This is new in Python 2.2, and, for example, is true of int.__add__.
84 An object passing this test has a __get__ attribute but not a __set__
85 attribute, but beyond that the set of attributes varies. __name__ is
86 usually sensible, and __doc__ often is.
88 Methods implemented via descriptors that also pass one of the other
89 tests return false from the ismethoddescriptor() test, simply because
90 the other tests promise more -- you can, e.g., count on having the
91 im_func attribute (etc) when an object passes ismethod()."""
92 return (hasattr(object, "__get__")
93 and not hasattr(object, "__set__") # else it's a data descriptor
94 and not ismethod(object) # mutual exclusion
95 and not isfunction(object)
96 and not isclass(object))
98 def isdatadescriptor(object):
99 """Return true if the object is a data descriptor.
101 Data descriptors have both a __get__ and a __set__ attribute. Examples are
102 properties (defined in Python) and getsets and members (defined in C).
103 Typically, data descriptors will also have __name__ and __doc__ attributes
104 (properties, getsets, and members have both of these attributes), but this
105 is not guaranteed."""
106 return (hasattr(object, "__set__") and hasattr(object, "__get__"))
108 if hasattr(types
, 'MemberDescriptorType'):
109 # CPython and equivalent
110 def ismemberdescriptor(object):
111 """Return true if the object is a member descriptor.
113 Member descriptors are specialized descriptors defined in extension
115 return isinstance(object, types
.MemberDescriptorType
)
117 # Other implementations
118 def ismemberdescriptor(object):
119 """Return true if the object is a member descriptor.
121 Member descriptors are specialized descriptors defined in extension
125 if hasattr(types
, 'GetSetDescriptorType'):
126 # CPython and equivalent
127 def isgetsetdescriptor(object):
128 """Return true if the object is a getset descriptor.
130 getset descriptors are specialized descriptors defined in extension
132 return isinstance(object, types
.GetSetDescriptorType
)
134 # Other implementations
135 def isgetsetdescriptor(object):
136 """Return true if the object is a getset descriptor.
138 getset descriptors are specialized descriptors defined in extension
142 def isfunction(object):
143 """Return true if the object is a user-defined function.
145 Function objects provide these attributes:
146 __doc__ documentation string
147 __name__ name with which this function was defined
148 func_code code object containing compiled function bytecode
149 func_defaults tuple of any default values for arguments
150 func_doc (same as __doc__)
151 func_globals global namespace in which this function was defined
152 func_name (same as __name__)"""
153 return isinstance(object, types
.FunctionType
)
155 def isgeneratorfunction(object):
156 """Return true if the object is a user-defined generator function.
158 Generator function objects provides same attributes as functions.
160 See help(isfunction) for attributes listing."""
161 return bool((isfunction(object) or ismethod(object)) and
162 object.func_code
.co_flags
& CO_GENERATOR
)
164 def isgenerator(object):
165 """Return true if the object is a generator.
167 Generator objects provide these attributes:
168 __iter__ defined to support iteration over container
169 close raises a new GeneratorExit exception inside the
170 generator to terminate the iteration
172 gi_frame frame object or possibly None once the generator has
174 gi_running set to 1 when generator is executing, 0 otherwise
175 next return the next item from the container
176 send resumes the generator and "sends" a value that becomes
177 the result of the current yield-expression
178 throw used to raise an exception inside the generator"""
179 return isinstance(object, types
.GeneratorType
)
181 def istraceback(object):
182 """Return true if the object is a traceback.
184 Traceback objects provide these attributes:
185 tb_frame frame object at this level
186 tb_lasti index of last attempted instruction in bytecode
187 tb_lineno current line number in Python source code
188 tb_next next inner traceback object (called by this level)"""
189 return isinstance(object, types
.TracebackType
)
192 """Return true if the object is a frame object.
194 Frame objects provide these attributes:
195 f_back next outer frame object (this frame's caller)
196 f_builtins built-in namespace seen by this frame
197 f_code code object being executed in this frame
198 f_exc_traceback traceback if raised in this frame, or None
199 f_exc_type exception type if raised in this frame, or None
200 f_exc_value exception value if raised in this frame, or None
201 f_globals global namespace seen by this frame
202 f_lasti index of last attempted instruction in bytecode
203 f_lineno current line number in Python source code
204 f_locals local namespace seen by this frame
205 f_restricted 0 or 1 if frame is in restricted execution mode
206 f_trace tracing function for this frame, or None"""
207 return isinstance(object, types
.FrameType
)
210 """Return true if the object is a code object.
212 Code objects provide these attributes:
213 co_argcount number of arguments (not including * or ** args)
214 co_code string of raw compiled bytecode
215 co_consts tuple of constants used in the bytecode
216 co_filename name of file in which this code object was created
217 co_firstlineno number of first line in Python source code
218 co_flags bitmap: 1=optimized | 2=newlocals | 4=*arg | 8=**arg
219 co_lnotab encoded mapping of line numbers to bytecode indices
220 co_name name with which this code object was defined
221 co_names tuple of names of local variables
222 co_nlocals number of local variables
223 co_stacksize virtual machine stack space required
224 co_varnames tuple of names of arguments and local variables"""
225 return isinstance(object, types
.CodeType
)
227 def isbuiltin(object):
228 """Return true if the object is a built-in function or method.
230 Built-in functions and methods provide these attributes:
231 __doc__ documentation string
232 __name__ original name of this function or method
233 __self__ instance to which a method is bound, or None"""
234 return isinstance(object, types
.BuiltinFunctionType
)
236 def isroutine(object):
237 """Return true if the object is any kind of function or method."""
238 return (isbuiltin(object)
239 or isfunction(object)
241 or ismethoddescriptor(object))
243 def isabstract(object):
244 """Return true if the object is an abstract base class (ABC)."""
245 return bool(isinstance(object, type) and object.__flags
__ & TPFLAGS_IS_ABSTRACT
)
247 def getmembers(object, predicate
=None):
248 """Return all members of an object as (name, value) pairs sorted by name.
249 Optionally, only return members that satisfy a given predicate."""
251 for key
in dir(object):
253 value
= getattr(object, key
)
254 except AttributeError:
256 if not predicate
or predicate(value
):
257 results
.append((key
, value
))
261 Attribute
= namedtuple('Attribute', 'name kind defining_class object')
263 def classify_class_attrs(cls
):
264 """Return list of attribute-descriptor tuples.
266 For each name in dir(cls), the return list contains a 4-tuple
269 0. The name (a string).
271 1. The kind of attribute this is, one of these strings:
272 'class method' created via classmethod()
273 'static method' created via staticmethod()
274 'property' created via property()
275 'method' any other flavor of method
278 2. The class which defined this attribute (a class).
280 3. The object as obtained directly from the defining class's
281 __dict__, not via getattr. This is especially important for
282 data attributes: C.data is just a data object, but
283 C.__dict__['data'] may be a data descriptor with additional
284 info, like a __doc__ string.
291 # Get the object associated with the name, and where it was defined.
292 # Getting an obj from the __dict__ sometimes reveals more than
293 # using getattr. Static and class methods are dramatic examples.
294 # Furthermore, some objects may raise an Exception when fetched with
295 # getattr(). This is the case with some descriptors (bug #1785).
296 # Thus, we only use getattr() as a last resort.
298 for base
in (cls
,) + mro
:
299 if name
in base
.__dict
__:
300 obj
= base
.__dict
__[name
]
304 obj
= getattr(cls
, name
)
305 homecls
= getattr(obj
, "__objclass__", homecls
)
307 # Classify the object.
308 if isinstance(obj
, staticmethod):
309 kind
= "static method"
310 elif isinstance(obj
, classmethod):
311 kind
= "class method"
312 elif isinstance(obj
, property):
314 elif ismethoddescriptor(obj
):
316 elif isdatadescriptor(obj
):
319 obj_via_getattr
= getattr(cls
, name
)
320 if (ismethod(obj_via_getattr
) or
321 ismethoddescriptor(obj_via_getattr
)):
325 obj
= obj_via_getattr
327 result
.append(Attribute(name
, kind
, homecls
, obj
))
331 # ----------------------------------------------------------- class helpers
332 def _searchbases(cls
, accum
):
333 # Simulate the "classic class" search order.
337 for base
in cls
.__bases
__:
338 _searchbases(base
, accum
)
341 "Return tuple of base classes (including cls) in method resolution order."
342 if hasattr(cls
, "__mro__"):
346 _searchbases(cls
, result
)
349 # -------------------------------------------------- source code extraction
350 def indentsize(line
):
351 """Return the indent size, in spaces, at the start of a line of text."""
352 expline
= string
.expandtabs(line
)
353 return len(expline
) - len(string
.lstrip(expline
))
356 """Get the documentation string for an object.
358 All tabs are expanded to spaces. To clean up docstrings that are
359 indented to line up with blocks of code, any whitespace than can be
360 uniformly removed from the second line onwards is removed."""
363 except AttributeError:
365 if not isinstance(doc
, types
.StringTypes
):
370 """Clean up indentation from docstrings.
372 Any whitespace that can be uniformly removed from the second line
373 onwards is removed."""
375 lines
= string
.split(string
.expandtabs(doc
), '\n')
379 # Find minimum indentation of any non-blank lines after first line.
381 for line
in lines
[1:]:
382 content
= len(string
.lstrip(line
))
384 indent
= len(line
) - content
385 margin
= min(margin
, indent
)
386 # Remove indentation.
388 lines
[0] = lines
[0].lstrip()
389 if margin
< sys
.maxint
:
390 for i
in range(1, len(lines
)): lines
[i
] = lines
[i
][margin
:]
391 # Remove any trailing or leading blank lines.
392 while lines
and not lines
[-1]:
394 while lines
and not lines
[0]:
396 return string
.join(lines
, '\n')
399 """Work out which source or compiled file an object was defined in."""
401 if hasattr(object, '__file__'):
402 return object.__file
__
403 raise TypeError('{!r} is a built-in module'.format(object))
405 object = sys
.modules
.get(object.__module
__)
406 if hasattr(object, '__file__'):
407 return object.__file
__
408 raise TypeError('{!r} is a built-in class'.format(object))
410 object = object.im_func
411 if isfunction(object):
412 object = object.func_code
413 if istraceback(object):
414 object = object.tb_frame
416 object = object.f_code
418 return object.co_filename
419 raise TypeError('{!r} is not a module, class, method, '
420 'function, traceback, frame, or code object'.format(object))
422 ModuleInfo
= namedtuple('ModuleInfo', 'name suffix mode module_type')
424 def getmoduleinfo(path
):
425 """Get the module name, suffix, mode, and module type for a given file."""
426 filename
= os
.path
.basename(path
)
427 suffixes
= map(lambda info
:
428 (-len(info
[0]), info
[0], info
[1], info
[2]),
430 suffixes
.sort() # try longest suffixes first, in case they overlap
431 for neglen
, suffix
, mode
, mtype
in suffixes
:
432 if filename
[neglen
:] == suffix
:
433 return ModuleInfo(filename
[:neglen
], suffix
, mode
, mtype
)
435 def getmodulename(path
):
436 """Return the module name for a given file, or None."""
437 info
= getmoduleinfo(path
)
438 if info
: return info
[0]
440 def getsourcefile(object):
441 """Return the filename that can be used to locate an object's source.
442 Return None if no way can be identified to get the source.
444 filename
= getfile(object)
445 if string
.lower(filename
[-4:]) in ('.pyc', '.pyo'):
446 filename
= filename
[:-4] + '.py'
447 for suffix
, mode
, kind
in imp
.get_suffixes():
448 if 'b' in mode
and string
.lower(filename
[-len(suffix
):]) == suffix
:
449 # Looks like a binary file. We want to only return a text file.
451 if os
.path
.exists(filename
):
453 # only return a non-existent filename if the module has a PEP 302 loader
454 if hasattr(getmodule(object, filename
), '__loader__'):
456 # or it is in the linecache
457 if filename
in linecache
.cache
:
460 def getabsfile(object, _filename
=None):
461 """Return an absolute path to the source or compiled file for an object.
463 The idea is for each object to have a unique origin, so this routine
464 normalizes the result as much as possible."""
465 if _filename
is None:
466 _filename
= getsourcefile(object) or getfile(object)
467 return os
.path
.normcase(os
.path
.abspath(_filename
))
472 def getmodule(object, _filename
=None):
473 """Return the module an object was defined in, or None if not found."""
476 if hasattr(object, '__module__'):
477 return sys
.modules
.get(object.__module
__)
478 # Try the filename to modulename cache
479 if _filename
is not None and _filename
in modulesbyfile
:
480 return sys
.modules
.get(modulesbyfile
[_filename
])
481 # Try the cache again with the absolute file name
483 file = getabsfile(object, _filename
)
486 if file in modulesbyfile
:
487 return sys
.modules
.get(modulesbyfile
[file])
488 # Update the filename to module name cache and check yet again
489 # Copy sys.modules in order to cope with changes while iterating
490 for modname
, module
in sys
.modules
.items():
491 if ismodule(module
) and hasattr(module
, '__file__'):
493 if f
== _filesbymodname
.get(modname
, None):
494 # Have already mapped this module, so skip it
496 _filesbymodname
[modname
] = f
497 f
= getabsfile(module
)
498 # Always map to the name the module knows itself by
499 modulesbyfile
[f
] = modulesbyfile
[
500 os
.path
.realpath(f
)] = module
.__name
__
501 if file in modulesbyfile
:
502 return sys
.modules
.get(modulesbyfile
[file])
503 # Check the main module
504 main
= sys
.modules
['__main__']
505 if not hasattr(object, '__name__'):
507 if hasattr(main
, object.__name
__):
508 mainobject
= getattr(main
, object.__name
__)
509 if mainobject
is object:
512 builtin
= sys
.modules
['__builtin__']
513 if hasattr(builtin
, object.__name
__):
514 builtinobject
= getattr(builtin
, object.__name
__)
515 if builtinobject
is object:
518 def findsource(object):
519 """Return the entire source file and starting line number for an object.
521 The argument may be a module, class, method, function, traceback, frame,
522 or code object. The source code is returned as a list of all the lines
523 in the file and the line number indexes a line in that list. An IOError
524 is raised if the source code cannot be retrieved."""
526 file = getfile(object)
527 sourcefile
= getsourcefile(object)
528 if not sourcefile
and file[:1] + file[-1:] != '<>':
529 raise IOError('source code not available')
530 file = sourcefile
if sourcefile
else file
532 module
= getmodule(object, file)
534 lines
= linecache
.getlines(file, module
.__dict
__)
536 lines
= linecache
.getlines(file)
538 raise IOError('could not get source code')
544 name
= object.__name
__
545 pat
= re
.compile(r
'^(\s*)class\s*' + name
+ r
'\b')
546 # make some effort to find the best matching class definition:
547 # use the one with the least indentation, which is the one
548 # that's most probably not inside a function definition.
550 for i
in range(len(lines
)):
551 match
= pat
.match(lines
[i
])
553 # if it's at toplevel, it's already the best one
554 if lines
[i
][0] == 'c':
556 # else add whitespace to candidate list
557 candidates
.append((match
.group(1), i
))
559 # this will sort by whitespace, and by line number,
560 # less whitespace first
562 return lines
, candidates
[0][1]
564 raise IOError('could not find class definition')
567 object = object.im_func
568 if isfunction(object):
569 object = object.func_code
570 if istraceback(object):
571 object = object.tb_frame
573 object = object.f_code
575 if not hasattr(object, 'co_firstlineno'):
576 raise IOError('could not find function definition')
577 lnum
= object.co_firstlineno
- 1
578 pat
= re
.compile(r
'^(\s*def\s)|(.*(?<!\w)lambda(:|\s))|^(\s*@)')
580 if pat
.match(lines
[lnum
]): break
583 raise IOError('could not find code object')
585 def getcomments(object):
586 """Get lines of comments immediately preceding an object's source code.
588 Returns None when source can't be found.
591 lines
, lnum
= findsource(object)
592 except (IOError, TypeError):
596 # Look for a comment block at the top of the file.
598 if lines
and lines
[0][:2] == '#!': start
= 1
599 while start
< len(lines
) and string
.strip(lines
[start
]) in ('', '#'):
601 if start
< len(lines
) and lines
[start
][:1] == '#':
604 while end
< len(lines
) and lines
[end
][:1] == '#':
605 comments
.append(string
.expandtabs(lines
[end
]))
607 return string
.join(comments
, '')
609 # Look for a preceding block of comments at the same indentation.
611 indent
= indentsize(lines
[lnum
])
613 if end
>= 0 and string
.lstrip(lines
[end
])[:1] == '#' and \
614 indentsize(lines
[end
]) == indent
:
615 comments
= [string
.lstrip(string
.expandtabs(lines
[end
]))]
618 comment
= string
.lstrip(string
.expandtabs(lines
[end
]))
619 while comment
[:1] == '#' and indentsize(lines
[end
]) == indent
:
620 comments
[:0] = [comment
]
623 comment
= string
.lstrip(string
.expandtabs(lines
[end
]))
624 while comments
and string
.strip(comments
[0]) == '#':
626 while comments
and string
.strip(comments
[-1]) == '#':
628 return string
.join(comments
, '')
630 class EndOfBlock(Exception): pass
633 """Provide a tokeneater() method to detect the end of a code block."""
636 self
.islambda
= False
638 self
.passline
= False
641 def tokeneater(self
, type, token
, srow_scol
, erow_ecol
, line
):
642 srow
, scol
= srow_scol
643 erow
, ecol
= erow_ecol
645 # look for the first "def", "class" or "lambda"
646 if token
in ("def", "class", "lambda"):
647 if token
== "lambda":
650 self
.passline
= True # skip to the end of the line
651 elif type == tokenize
.NEWLINE
:
652 self
.passline
= False # stop skipping when a NEWLINE is seen
654 if self
.islambda
: # lambdas always end at the first NEWLINE
658 elif type == tokenize
.INDENT
:
659 self
.indent
= self
.indent
+ 1
661 elif type == tokenize
.DEDENT
:
662 self
.indent
= self
.indent
- 1
663 # the end of matching indent/dedent pairs end a block
664 # (note that this only works for "def"/"class" blocks,
665 # not e.g. for "if: else:" or "try: finally:" blocks)
668 elif self
.indent
== 0 and type not in (tokenize
.COMMENT
, tokenize
.NL
):
669 # any other token on the same indentation level end the previous
670 # block as well, except the pseudo-tokens COMMENT and NL.
674 """Extract the block of code at the top of the given list of lines."""
675 blockfinder
= BlockFinder()
677 tokenize
.tokenize(iter(lines
).next
, blockfinder
.tokeneater
)
678 except (EndOfBlock
, IndentationError):
680 return lines
[:blockfinder
.last
]
682 def getsourcelines(object):
683 """Return a list of source lines and starting line number for an object.
685 The argument may be a module, class, method, function, traceback, frame,
686 or code object. The source code is returned as a list of the lines
687 corresponding to the object and the line number indicates where in the
688 original source file the first line of code was found. An IOError is
689 raised if the source code cannot be retrieved."""
690 lines
, lnum
= findsource(object)
692 if ismodule(object): return lines
, 0
693 else: return getblock(lines
[lnum
:]), lnum
+ 1
695 def getsource(object):
696 """Return the text of the source code for an object.
698 The argument may be a module, class, method, function, traceback, frame,
699 or code object. The source code is returned as a single string. An
700 IOError is raised if the source code cannot be retrieved."""
701 lines
, lnum
= getsourcelines(object)
702 return string
.join(lines
, '')
704 # --------------------------------------------------- class tree extraction
705 def walktree(classes
, children
, parent
):
706 """Recursive helper function for getclasstree()."""
708 classes
.sort(key
=attrgetter('__module__', '__name__'))
710 results
.append((c
, c
.__bases
__))
712 results
.append(walktree(children
[c
], children
, c
))
715 def getclasstree(classes
, unique
=0):
716 """Arrange the given list of classes into a hierarchy of nested lists.
718 Where a nested list appears, it contains classes derived from the class
719 whose entry immediately precedes the list. Each entry is a 2-tuple
720 containing a class and a tuple of its base classes. If the 'unique'
721 argument is true, exactly one entry appears in the returned structure
722 for each class in the given list. Otherwise, classes using multiple
723 inheritance and their descendants will appear multiple times."""
728 for parent
in c
.__bases
__:
729 if not parent
in children
:
730 children
[parent
] = []
731 if c
not in children
[parent
]:
732 children
[parent
].append(c
)
733 if unique
and parent
in classes
: break
736 for parent
in children
:
737 if parent
not in classes
:
739 return walktree(roots
, children
, None)
741 # ------------------------------------------------ argument list extraction
742 Arguments
= namedtuple('Arguments', 'args varargs keywords')
745 """Get information about the arguments accepted by a code object.
747 Three things are returned: (args, varargs, varkw), where 'args' is
748 a list of argument names (possibly containing nested lists), and
749 'varargs' and 'varkw' are the names of the * and ** arguments or None."""
752 raise TypeError('{!r} is not a code object'.format(co
))
754 nargs
= co
.co_argcount
755 names
= co
.co_varnames
756 args
= list(names
[:nargs
])
759 # The following acrobatics are for anonymous (tuple) arguments.
760 for i
in range(nargs
):
761 if args
[i
][:1] in ('', '.'):
762 stack
, remain
, count
= [], [], []
763 while step
< len(co
.co_code
):
764 op
= ord(co
.co_code
[step
])
766 if op
>= dis
.HAVE_ARGUMENT
:
767 opname
= dis
.opname
[op
]
768 value
= ord(co
.co_code
[step
]) + ord(co
.co_code
[step
+1])*256
770 if opname
in ('UNPACK_TUPLE', 'UNPACK_SEQUENCE'):
773 elif opname
== 'STORE_FAST':
774 stack
.append(names
[value
])
776 # Special case for sublists of length 1: def foo((bar))
777 # doesn't generate the UNPACK_TUPLE bytecode, so if
778 # `remain` is empty here, we have such a sublist.
780 stack
[0] = [stack
[0]]
783 remain
[-1] = remain
[-1] - 1
784 while remain
[-1] == 0:
787 stack
[-size
:] = [stack
[-size
:]]
789 remain
[-1] = remain
[-1] - 1
794 if co
.co_flags
& CO_VARARGS
:
795 varargs
= co
.co_varnames
[nargs
]
798 if co
.co_flags
& CO_VARKEYWORDS
:
799 varkw
= co
.co_varnames
[nargs
]
800 return Arguments(args
, varargs
, varkw
)
802 ArgSpec
= namedtuple('ArgSpec', 'args varargs keywords defaults')
804 def getargspec(func
):
805 """Get the names and default values of a function's arguments.
807 A tuple of four things is returned: (args, varargs, varkw, defaults).
808 'args' is a list of the argument names (it may contain nested lists).
809 'varargs' and 'varkw' are the names of the * and ** arguments or None.
810 'defaults' is an n-tuple of the default values of the last n arguments.
815 if not isfunction(func
):
816 raise TypeError('{!r} is not a Python function'.format(func
))
817 args
, varargs
, varkw
= getargs(func
.func_code
)
818 return ArgSpec(args
, varargs
, varkw
, func
.func_defaults
)
820 ArgInfo
= namedtuple('ArgInfo', 'args varargs keywords locals')
822 def getargvalues(frame
):
823 """Get information about arguments passed into a particular frame.
825 A tuple of four things is returned: (args, varargs, varkw, locals).
826 'args' is a list of the argument names (it may contain nested lists).
827 'varargs' and 'varkw' are the names of the * and ** arguments or None.
828 'locals' is the locals dictionary of the given frame."""
829 args
, varargs
, varkw
= getargs(frame
.f_code
)
830 return ArgInfo(args
, varargs
, varkw
, frame
.f_locals
)
834 return '(' + seq
[0] + ',)'
836 return '(' + string
.join(seq
, ', ') + ')'
838 def strseq(object, convert
, join
=joinseq
):
839 """Recursively walk a sequence, stringifying each element."""
840 if type(object) in (list, tuple):
841 return join(map(lambda o
, c
=convert
, j
=join
: strseq(o
, c
, j
), object))
843 return convert(object)
845 def formatargspec(args
, varargs
=None, varkw
=None, defaults
=None,
847 formatvarargs
=lambda name
: '*' + name
,
848 formatvarkw
=lambda name
: '**' + name
,
849 formatvalue
=lambda value
: '=' + repr(value
),
851 """Format an argument spec from the 4 values returned by getargspec.
853 The first four arguments are (args, varargs, varkw, defaults). The
854 other four arguments are the corresponding optional formatting functions
855 that are called to turn names and values into strings. The ninth
856 argument is an optional function to format the sequence of arguments."""
859 firstdefault
= len(args
) - len(defaults
)
860 for i
, arg
in enumerate(args
):
861 spec
= strseq(arg
, formatarg
, join
)
862 if defaults
and i
>= firstdefault
:
863 spec
= spec
+ formatvalue(defaults
[i
- firstdefault
])
865 if varargs
is not None:
866 specs
.append(formatvarargs(varargs
))
867 if varkw
is not None:
868 specs
.append(formatvarkw(varkw
))
869 return '(' + string
.join(specs
, ', ') + ')'
871 def formatargvalues(args
, varargs
, varkw
, locals,
873 formatvarargs
=lambda name
: '*' + name
,
874 formatvarkw
=lambda name
: '**' + name
,
875 formatvalue
=lambda value
: '=' + repr(value
),
877 """Format an argument spec from the 4 values returned by getargvalues.
879 The first four arguments are (args, varargs, varkw, locals). The
880 next four arguments are the corresponding optional formatting functions
881 that are called to turn names and values into strings. The ninth
882 argument is an optional function to format the sequence of arguments."""
883 def convert(name
, locals=locals,
884 formatarg
=formatarg
, formatvalue
=formatvalue
):
885 return formatarg(name
) + formatvalue(locals[name
])
887 for i
in range(len(args
)):
888 specs
.append(strseq(args
[i
], convert
, join
))
890 specs
.append(formatvarargs(varargs
) + formatvalue(locals[varargs
]))
892 specs
.append(formatvarkw(varkw
) + formatvalue(locals[varkw
]))
893 return '(' + string
.join(specs
, ', ') + ')'
895 def getcallargs(func
, *positional
, **named
):
896 """Get the mapping of arguments to values.
898 A dict is returned, with keys the function argument names (including the
899 names of the * and ** arguments, if any), and values the respective bound
900 values from 'positional' and 'named'."""
901 args
, varargs
, varkw
, defaults
= getargspec(func
)
902 f_name
= func
.__name
__
905 # The following closures are basically because of tuple parameter unpacking.
906 assigned_tuple_params
= []
907 def assign(arg
, value
):
908 if isinstance(arg
, str):
909 arg2value
[arg
] = value
911 assigned_tuple_params
.append(arg
)
913 for i
, subarg
in enumerate(arg
):
915 subvalue
= next(value
)
916 except StopIteration:
917 raise ValueError('need more than %d %s to unpack' %
918 (i
, 'values' if i
> 1 else 'value'))
919 assign(subarg
,subvalue
)
922 except StopIteration:
925 raise ValueError('too many values to unpack')
926 def is_assigned(arg
):
927 if isinstance(arg
,str):
928 return arg
in arg2value
929 return arg
in assigned_tuple_params
930 if ismethod(func
) and func
.im_self
is not None:
931 # implicit 'self' (or 'cls' for classmethods) argument
932 positional
= (func
.im_self
,) + positional
933 num_pos
= len(positional
)
934 num_total
= num_pos
+ len(named
)
936 num_defaults
= len(defaults
) if defaults
else 0
937 for arg
, value
in zip(args
, positional
):
940 if num_pos
> num_args
:
941 assign(varargs
, positional
[-(num_pos
-num_args
):])
944 elif 0 < num_args
< num_pos
:
945 raise TypeError('%s() takes %s %d %s (%d given)' % (
946 f_name
, 'at most' if defaults
else 'exactly', num_args
,
947 'arguments' if num_args
> 1 else 'argument', num_total
))
948 elif num_args
== 0 and num_total
:
951 # XXX: We should use num_pos, but Python also uses num_total:
952 raise TypeError('%s() takes exactly 0 arguments '
953 '(%d given)' % (f_name
, num_total
))
955 raise TypeError('%s() takes no arguments (%d given)' %
958 if isinstance(arg
, str) and arg
in named
:
960 raise TypeError("%s() got multiple values for keyword "
961 "argument '%s'" % (f_name
, arg
))
963 assign(arg
, named
.pop(arg
))
964 if defaults
: # fill in any missing values with the defaults
965 for arg
, value
in zip(args
[-num_defaults
:], defaults
):
966 if not is_assigned(arg
):
971 unexpected
= next(iter(named
))
972 if isinstance(unexpected
, unicode):
973 unexpected
= unexpected
.encode(sys
.getdefaultencoding(), 'replace')
974 raise TypeError("%s() got an unexpected keyword argument '%s'" %
975 (f_name
, unexpected
))
976 unassigned
= num_args
- len([arg
for arg
in args
if is_assigned(arg
)])
978 num_required
= num_args
- num_defaults
979 raise TypeError('%s() takes %s %d %s (%d given)' % (
980 f_name
, 'at least' if defaults
else 'exactly', num_required
,
981 'arguments' if num_required
> 1 else 'argument', num_total
))
984 # -------------------------------------------------- stack frame extraction
986 Traceback
= namedtuple('Traceback', 'filename lineno function code_context index')
988 def getframeinfo(frame
, context
=1):
989 """Get information about a frame or traceback object.
991 A tuple of five things is returned: the filename, the line number of
992 the current line, the function name, a list of lines of context from
993 the source code, and the index of the current line within that list.
994 The optional second argument specifies the number of lines of context
995 to return, which are centered around the current line."""
996 if istraceback(frame
):
997 lineno
= frame
.tb_lineno
998 frame
= frame
.tb_frame
1000 lineno
= frame
.f_lineno
1001 if not isframe(frame
):
1002 raise TypeError('{!r} is not a frame or traceback object'.format(frame
))
1004 filename
= getsourcefile(frame
) or getfile(frame
)
1006 start
= lineno
- 1 - context
//2
1008 lines
, lnum
= findsource(frame
)
1010 lines
= index
= None
1012 start
= max(start
, 1)
1013 start
= max(0, min(start
, len(lines
) - context
))
1014 lines
= lines
[start
:start
+context
]
1015 index
= lineno
- 1 - start
1017 lines
= index
= None
1019 return Traceback(filename
, lineno
, frame
.f_code
.co_name
, lines
, index
)
1021 def getlineno(frame
):
1022 """Get the line number from a frame object, allowing for optimization."""
1023 # FrameType.f_lineno is now a descriptor that grovels co_lnotab
1024 return frame
.f_lineno
1026 def getouterframes(frame
, context
=1):
1027 """Get a list of records for a frame and all higher (calling) frames.
1029 Each record contains a frame object, filename, line number, function
1030 name, a list of lines of context, and index within the context."""
1033 framelist
.append((frame
,) + getframeinfo(frame
, context
))
1034 frame
= frame
.f_back
1037 def getinnerframes(tb
, context
=1):
1038 """Get a list of records for a traceback's frame and all lower frames.
1040 Each record contains a frame object, filename, line number, function
1041 name, a list of lines of context, and index within the context."""
1044 framelist
.append((tb
.tb_frame
,) + getframeinfo(tb
, context
))
1048 if hasattr(sys
, '_getframe'):
1049 currentframe
= sys
._getframe
1051 currentframe
= lambda _
=None: None
1053 def stack(context
=1):
1054 """Return a list of records for the stack above the caller's frame."""
1055 return getouterframes(sys
._getframe
(1), context
)
1057 def trace(context
=1):
1058 """Return a list of records for the stack below the current exception."""
1059 return getinnerframes(sys
.exc_info()[2], context
)