golden hour

/opt/alt/python27/lib64/python2.7

File/Folder	Size	Actions
BaseHTTPServer.py	22.21 KB
BaseHTTPServer.pyc	21.47 KB
BaseHTTPServer.pyo	21.47 KB
Bastion.py	5.61 KB
Bastion.pyc	6.69 KB
Bastion.pyo	6.69 KB
CGIHTTPServer.py	12.78 KB
CGIHTTPServer.pyc	10.92 KB
CGIHTTPServer.pyo	10.92 KB
ConfigParser.py	27.1 KB
ConfigParser.pyc	25.37 KB
ConfigParser.pyo	25.37 KB
Cookie.py	25.92 KB
Cookie.pyc	22.61 KB
Cookie.pyo	22.61 KB
DocXMLRPCServer.py	10.52 KB
DocXMLRPCServer.pyc	10.2 KB
DocXMLRPCServer.pyo	10.09 KB
HTMLParser.py	16.77 KB
HTMLParser.pyc	13.81 KB
HTMLParser.pyo	13.51 KB
MimeWriter.py	6.33 KB
MimeWriter.pyc	7.31 KB
MimeWriter.pyo	7.31 KB
Queue.py	8.38 KB
Queue.pyc	9.56 KB
Queue.pyo	9.56 KB
SimpleHTTPServer.py	7.81 KB
SimpleHTTPServer.pyc	7.96 KB
SimpleHTTPServer.pyo	7.96 KB
SimpleXMLRPCServer.py	25.21 KB
SimpleXMLRPCServer.pyc	22.78 KB
SimpleXMLRPCServer.pyo	22.78 KB
SocketServer.py	23.39 KB
SocketServer.pyc	24.25 KB
SocketServer.pyo	24.25 KB
StringIO.py	10.41 KB
StringIO.pyc	11.45 KB
StringIO.pyo	11.45 KB
UserDict.py	6.89 KB
UserDict.pyc	10.05 KB
UserDict.pyo	10.05 KB
UserList.py	3.56 KB
UserList.pyc	6.85 KB
UserList.pyo	6.85 KB
UserString.py	9.47 KB
UserString.pyc	15.38 KB
UserString.pyo	15.38 KB
_LWPCookieJar.py	6.4 KB
_LWPCookieJar.pyc	5.38 KB
_LWPCookieJar.pyo	5.38 KB
_MozillaCookieJar.py	5.66 KB
_MozillaCookieJar.pyc	4.41 KB
_MozillaCookieJar.pyo	4.37 KB
__future__.py	4.28 KB
__future__.pyc	4.2 KB
__future__.pyo	4.2 KB
__phello__.foo.py	64 B
__phello__.foo.pyc	138 B
__phello__.foo.pyo	138 B
_abcoll.py	18.18 KB
_abcoll.pyc	26.4 KB
_abcoll.pyo	26.4 KB
_osx_support.py	18.65 KB
_osx_support.pyc	11.72 KB
_osx_support.pyo	11.72 KB
_pyio.py	68 KB
_pyio.pyc	65.41 KB
_pyio.pyo	65.41 KB
_strptime.py	20.24 KB
_strptime.pyc	15.07 KB
_strptime.pyo	15.07 KB
_sysconfigdata.py	18.9 KB
_sysconfigdata.pyc	22 KB
_sysconfigdata.pyo	22 KB
_threading_local.py	7.09 KB
_threading_local.pyc	6.34 KB
_threading_local.pyo	6.34 KB
_weakrefset.py	5.77 KB
_weakrefset.pyc	10.06 KB
_weakrefset.pyo	10.06 KB
abc.py	6.98 KB
abc.pyc	6.14 KB
abc.pyo	6.08 KB
aifc.py	33.77 KB
aifc.pyc	30.67 KB
aifc.pyo	30.67 KB
antigravity.py	60 B
antigravity.pyc	216 B
antigravity.pyo	216 B
anydbm.py	2.6 KB
anydbm.pyc	2.77 KB
anydbm.pyo	2.77 KB
argparse.py	87.14 KB
argparse.pyc	64.83 KB
argparse.pyo	64.67 KB
ast.py	11.53 KB
ast.pyc	12.94 KB
ast.pyo	12.94 KB
asynchat.py	11.31 KB
asynchat.pyc	8.98 KB
asynchat.pyo	8.98 KB
asyncore.py	20.45 KB
asyncore.pyc	19.2 KB
asyncore.pyo	19.2 KB
atexit.py	1.67 KB
atexit.pyc	2.23 KB
atexit.pyo	2.23 KB
audiodev.py	7.42 KB
audiodev.pyc	8.61 KB
audiodev.pyo	8.61 KB
base64.py	11.54 KB
base64.pyc	11.26 KB
base64.pyo	11.26 KB
bdb.py	21.21 KB
bdb.pyc	19.43 KB
bdb.pyo	19.43 KB
binhex.py	14.35 KB
binhex.pyc	15.75 KB
binhex.pyo	15.75 KB
bisect.py	2.53 KB
bisect.pyc	3.06 KB
bisect.pyo	3.06 KB
bsddb	-
cProfile.py	6.43 KB
cProfile.pyc	6.42 KB
cProfile.pyo	6.42 KB
calendar.py	22.84 KB
calendar.pyc	28.26 KB
calendar.pyo	28.26 KB
cgi.py	34.97 KB
cgi.pyc	33.24 KB
cgi.pyo	33.24 KB
cgitb.py	11.89 KB
cgitb.pyc	12.08 KB
cgitb.pyo	12.08 KB
chunk.py	5.29 KB
chunk.pyc	5.61 KB
chunk.pyo	5.61 KB
cmd.py	14.67 KB
cmd.pyc	13.98 KB
cmd.pyo	13.98 KB
code.py	9.95 KB
code.pyc	10.29 KB
code.pyo	10.29 KB
codecs.py	35.3 KB
codecs.pyc	37.15 KB
codecs.pyo	37.15 KB
codeop.py	5.86 KB
codeop.pyc	6.57 KB
codeop.pyo	6.57 KB
collections.py	27.15 KB
collections.pyc	26.21 KB
collections.pyo	26.16 KB
colorsys.py	3.6 KB
colorsys.pyc	4 KB
colorsys.pyo	4 KB
commands.py	2.49 KB
commands.pyc	2.49 KB
commands.pyo	2.49 KB
compileall.py	7.58 KB
compileall.pyc	6.93 KB
compileall.pyo	6.93 KB
compiler	-
config	-
contextlib.py	4.32 KB
contextlib.pyc	4.5 KB
contextlib.pyo	4.5 KB
cookielib.py	63.95 KB
cookielib.pyc	54.67 KB
cookielib.pyo	54.49 KB
copy.py	11.26 KB
copy.pyc	12.21 KB
copy.pyo	12.13 KB
copy_reg.py	6.81 KB
copy_reg.pyc	5.19 KB
copy_reg.pyo	5.14 KB
crypt.py	2.24 KB
crypt.pyc	2.95 KB
crypt.pyo	2.95 KB
csv.py	16.32 KB
csv.pyc	13.56 KB
csv.pyo	13.56 KB
ctypes	-
curses	-
dbhash.py	498 B
dbhash.pyc	744 B
dbhash.pyo	744 B
decimal.py	216.73 KB
decimal.pyc	171.36 KB
decimal.pyo	171.36 KB
difflib.py	80.4 KB
difflib.pyc	61.13 KB
difflib.pyo	61.08 KB
dircache.py	1.1 KB
dircache.pyc	1.59 KB
dircache.pyo	1.59 KB
dis.py	6.35 KB
dis.pyc	6.18 KB
dis.pyo	6.18 KB
distutils	-
doctest.py	102.63 KB
doctest.pyc	83.21 KB
doctest.pyo	82.93 KB
dumbdbm.py	8.93 KB
dumbdbm.pyc	6.83 KB
dumbdbm.pyo	6.83 KB
dummy_thread.py	4.31 KB
dummy_thread.pyc	5.46 KB
dummy_thread.pyo	5.46 KB
dummy_threading.py	2.74 KB
dummy_threading.pyc	1.27 KB
dummy_threading.pyo	1.27 KB
email	-
encodings	-
ensurepip	-
filecmp.py	9.36 KB
filecmp.pyc	9.65 KB
filecmp.pyo	9.65 KB
fileinput.py	13.42 KB
fileinput.pyc	14.54 KB
fileinput.pyo	14.54 KB
fnmatch.py	3.24 KB
fnmatch.pyc	3.61 KB
fnmatch.pyo	3.61 KB
formatter.py	14.56 KB
formatter.pyc	19.71 KB
formatter.pyo	19.71 KB
fpformat.py	4.62 KB
fpformat.pyc	4.69 KB
fpformat.pyo	4.69 KB
fractions.py	21.87 KB
fractions.pyc	19.74 KB
fractions.pyo	19.74 KB
ftplib.py	37.3 KB
ftplib.pyc	34.82 KB
ftplib.pyo	34.82 KB
functools.py	4.69 KB
functools.pyc	6.85 KB
functools.pyo	6.85 KB
genericpath.py	3.13 KB
genericpath.pyc	3.57 KB
genericpath.pyo	3.57 KB
getopt.py	7.15 KB
getopt.pyc	6.63 KB
getopt.pyo	6.58 KB
getpass.py	5.43 KB
getpass.pyc	4.72 KB
getpass.pyo	4.72 KB
gettext.py	22.13 KB
gettext.pyc	18.17 KB
gettext.pyo	18.17 KB
glob.py	3.04 KB
glob.pyc	2.98 KB
glob.pyo	2.98 KB
gzip.py	18.58 KB
gzip.pyc	15.26 KB
gzip.pyo	15.26 KB
hashlib.py	7.66 KB
hashlib.pyc	6.86 KB
hashlib.pyo	6.86 KB
heapq.py	17.87 KB
heapq.pyc	14.45 KB
heapq.pyo	14.45 KB
hmac.py	4.48 KB
hmac.pyc	4.56 KB
hmac.pyo	4.56 KB
hotshot	-
htmlentitydefs.py	17.63 KB
htmlentitydefs.pyc	6.23 KB
htmlentitydefs.pyo	6.23 KB
htmllib.py	12.57 KB
htmllib.pyc	20.99 KB
htmllib.pyo	20.99 KB
httplib.py	51.07 KB
httplib.pyc	37.88 KB
httplib.pyo	37.7 KB
idlelib	-
ihooks.py	18.54 KB
ihooks.pyc	21.75 KB
ihooks.pyo	21.75 KB
imaplib.py	47.23 KB
imaplib.pyc	45.19 KB
imaplib.pyo	42.49 KB
imghdr.py	3.46 KB
imghdr.pyc	4.93 KB
imghdr.pyo	4.93 KB
importlib	-
imputil.py	25.16 KB
imputil.pyc	15.74 KB
imputil.pyo	15.57 KB
inspect.py	42 KB
inspect.pyc	40.16 KB
inspect.pyo	40.16 KB
io.py	3.24 KB
io.pyc	3.57 KB
io.pyo	3.57 KB
json	-
keyword.py	1.96 KB
keyword.pyc	2.08 KB
keyword.pyo	2.08 KB
lib-dynload	-
lib2to3	-
linecache.py	3.93 KB
linecache.pyc	3.27 KB
linecache.pyo	3.27 KB
locale.py	100.42 KB
locale.pyc	55.69 KB
locale.pyo	55.69 KB
logging	-
macpath.py	6.14 KB
macpath.pyc	7.74 KB
macpath.pyo	7.74 KB
macurl2path.py	2.67 KB
macurl2path.pyc	2.24 KB
macurl2path.pyo	2.24 KB
mailbox.py	79.34 KB
mailbox.pyc	77.7 KB
mailbox.pyo	77.65 KB
mailcap.py	7.25 KB
mailcap.pyc	7.08 KB
mailcap.pyo	7.08 KB
markupbase.py	14.3 KB
markupbase.pyc	9.27 KB
markupbase.pyo	9.07 KB
md5.py	358 B
md5.pyc	391 B
md5.pyo	391 B
mhlib.py	32.65 KB
mhlib.pyc	33.98 KB
mhlib.pyo	33.98 KB
mimetools.py	7 KB
mimetools.pyc	8.26 KB
mimetools.pyo	8.26 KB
mimetypes.py	20.54 KB
mimetypes.pyc	18.3 KB
mimetypes.pyo	18.3 KB
mimify.py	14.68 KB
mimify.pyc	11.91 KB
mimify.pyo	11.91 KB
modulefinder.py	23.89 KB
modulefinder.pyc	19.12 KB
modulefinder.pyo	19.04 KB
multifile.py	4.71 KB
multifile.pyc	5.48 KB
multifile.pyo	5.44 KB
multiprocessing	-
mutex.py	1.83 KB
mutex.pyc	2.55 KB
mutex.pyo	2.55 KB
netrc.py	5.75 KB
netrc.pyc	4.72 KB
netrc.pyo	4.72 KB
new.py	610 B
new.pyc	875 B
new.pyo	875 B
nntplib.py	20.97 KB
nntplib.pyc	21.11 KB
nntplib.pyo	21.11 KB
ntpath.py	18.97 KB
ntpath.pyc	13.1 KB
ntpath.pyo	13.1 KB
nturl2path.py	2.36 KB
nturl2path.pyc	1.81 KB
nturl2path.pyo	1.81 KB
numbers.py	10.08 KB
numbers.pyc	14.47 KB
numbers.pyo	14.47 KB
opcode.py	5.35 KB
opcode.pyc	6.06 KB
opcode.pyo	6.06 KB
optparse.py	59.77 KB
optparse.pyc	54.41 KB
optparse.pyo	54.33 KB
os.py	25.3 KB
os.pyc	25.76 KB
os.pyo	25.76 KB
os2emxpath.py	4.53 KB
os2emxpath.pyc	4.53 KB
os2emxpath.pyo	4.53 KB
pdb.doc	7.73 KB
pdb.py	45.03 KB
pdb.pyc	44.09 KB
pdb.pyo	44.09 KB
pickle.py	44.42 KB
pickle.pyc	38.98 KB
pickle.pyo	38.79 KB
pickletools.py	72.78 KB
pickletools.pyc	56.1 KB
pickletools.pyo	55.26 KB
pipes.py	9.36 KB
pipes.pyc	9.29 KB
pipes.pyo	9.29 KB
pkgutil.py	19.77 KB
pkgutil.pyc	18.93 KB
pkgutil.pyo	18.93 KB
plat-linux2	-
platform.py	51.56 KB
platform.pyc	37.7 KB
platform.pyo	37.7 KB
plistlib.py	14.83 KB
plistlib.pyc	19.54 KB
plistlib.pyo	19.46 KB
popen2.py	8.22 KB
popen2.pyc	9.02 KB
popen2.pyo	8.98 KB
poplib.py	12.52 KB
poplib.pyc	13.45 KB
poplib.pyo	13.45 KB
posixfile.py	7.82 KB
posixfile.pyc	7.63 KB
posixfile.pyo	7.63 KB
posixpath.py	13.96 KB
posixpath.pyc	11.49 KB
posixpath.pyo	11.49 KB
pprint.py	11.5 KB
pprint.pyc	10.2 KB
pprint.pyo	10.02 KB
profile.py	22.26 KB
profile.pyc	16.57 KB
profile.pyo	16.32 KB
pstats.py	26.09 KB
pstats.pyc	25.19 KB
pstats.pyo	25.19 KB
pty.py	4.94 KB
pty.pyc	4.98 KB
pty.pyo	4.98 KB
py_compile.py	5.8 KB
py_compile.pyc	6.37 KB
py_compile.pyo	6.37 KB
pyclbr.py	13.07 KB
pyclbr.pyc	9.59 KB
pyclbr.pyo	9.59 KB
pydoc.py	93.43 KB
pydoc.pyc	92.69 KB
pydoc.pyo	92.63 KB
pydoc_data	-
quopri.py	6.81 KB
quopri.pyc	6.56 KB
quopri.pyo	6.56 KB
random.py	31.7 KB
random.pyc	25.65 KB
random.pyo	25.65 KB
re.py	13.11 KB
re.pyc	13.37 KB
re.pyo	13.37 KB
repr.py	4.2 KB
repr.pyc	5.47 KB
repr.pyo	5.47 KB
rexec.py	19.68 KB
rexec.pyc	24 KB
rexec.pyo	24 KB
rfc822.py	32.76 KB
rfc822.pyc	31.83 KB
rfc822.pyo	31.83 KB
rlcompleter.py	5.85 KB
rlcompleter.pyc	6.04 KB
rlcompleter.pyo	6.04 KB
robotparser.py	7.51 KB
robotparser.pyc	8.12 KB
robotparser.pyo	8.12 KB
runpy.py	10.82 KB
runpy.pyc	8.85 KB
runpy.pyo	8.85 KB
sched.py	4.97 KB
sched.pyc	4.99 KB
sched.pyo	4.99 KB
sets.py	18.6 KB
sets.pyc	17.21 KB
sets.pyo	17.21 KB
sgmllib.py	17.46 KB
sgmllib.pyc	15.67 KB
sgmllib.pyo	15.67 KB
sha.py	393 B
sha.pyc	434 B
sha.pyo	434 B
shelve.py	7.99 KB
shelve.pyc	10.36 KB
shelve.pyo	10.36 KB
shlex.py	10.9 KB
shlex.pyc	7.55 KB
shlex.pyo	7.55 KB
shutil.py	19.41 KB
shutil.pyc	19.19 KB
shutil.pyo	19.19 KB
site-packages	-
site.py	19.18 KB
site.pyc	19.35 KB
site.pyo	19.35 KB
smtpd.py	18.12 KB
smtpd.pyc	15.9 KB
smtpd.pyo	15.9 KB
smtplib.py	31.39 KB
smtplib.pyc	30.29 KB
smtplib.pyo	30.29 KB
sndhdr.py	5.83 KB
sndhdr.pyc	7.4 KB
sndhdr.pyo	7.4 KB
socket.py	20.13 KB
socket.pyc	16.15 KB
socket.pyo	16.07 KB
sqlite3	-
sre.py	384 B
sre.pyc	532 B
sre.pyo	532 B
sre_compile.py	19.36 KB
sre_compile.pyc	12.46 KB
sre_compile.pyo	12.3 KB
sre_constants.py	7.03 KB
sre_constants.pyc	6.11 KB
sre_constants.pyo	6.11 KB
sre_parse.py	29.98 KB
sre_parse.pyc	21.12 KB
sre_parse.pyo	21.12 KB
ssl.py	36.58 KB
ssl.pyc	32.24 KB
ssl.pyo	32.24 KB
stat.py	1.8 KB
stat.pyc	2.81 KB
stat.pyo	2.81 KB
statvfs.py	898 B
statvfs.pyc	633 B
statvfs.pyo	633 B
string.py	21.04 KB
string.pyc	20.63 KB
string.pyo	20.63 KB
stringold.py	12.16 KB
stringold.pyc	12.6 KB
stringold.pyo	12.6 KB
stringprep.py	13.21 KB
stringprep.pyc	14.4 KB
stringprep.pyo	14.33 KB
struct.py	82 B
struct.pyc	252 B
struct.pyo	252 B
subprocess.py	49.34 KB
subprocess.pyc	32.32 KB
subprocess.pyo	32.32 KB
sunau.py	16.82 KB
sunau.pyc	18.57 KB
sunau.pyo	18.57 KB
sunaudio.py	1.37 KB
sunaudio.pyc	2 KB
sunaudio.pyo	2 KB
symbol.py	2.02 KB
symbol.pyc	2.98 KB
symbol.pyo	2.98 KB
symtable.py	7.26 KB
symtable.pyc	12.14 KB
symtable.pyo	12.02 KB
sysconfig.py	22.32 KB
sysconfig.pyc	17.73 KB
sysconfig.pyo	17.73 KB
tabnanny.py	11.08 KB
tabnanny.pyc	8.31 KB
tabnanny.pyo	8.31 KB
tarfile.py	88.45 KB
tarfile.pyc	76.54 KB
tarfile.pyo	76.54 KB
telnetlib.py	26.4 KB
telnetlib.pyc	23.03 KB
telnetlib.pyo	23.03 KB
tempfile.py	19.09 KB
tempfile.pyc	20.55 KB
tempfile.pyo	20.55 KB
test	-
textwrap.py	16.88 KB
textwrap.pyc	11.99 KB
textwrap.pyo	11.9 KB
this.py	1002 B
this.pyc	1.2 KB
this.pyo	1.2 KB
threading.py	46.17 KB
threading.pyc	42.97 KB
threading.pyo	40.84 KB
timeit.py	12.5 KB
timeit.pyc	12.06 KB
timeit.pyo	12.06 KB
toaiff.py	3.07 KB
toaiff.pyc	3.08 KB
toaiff.pyo	3.08 KB
token.py	2.85 KB
token.pyc	3.79 KB
token.pyo	3.79 KB
tokenize.py	17.07 KB
tokenize.pyc	14.37 KB
tokenize.pyo	14.31 KB
trace.py	29.2 KB
trace.pyc	22.69 KB
trace.pyo	22.63 KB
traceback.py	11.02 KB
traceback.pyc	11.66 KB
traceback.pyo	11.66 KB
tty.py	879 B
tty.pyc	1.32 KB
tty.pyo	1.32 KB
types.py	2.04 KB
types.pyc	2.75 KB
types.pyo	2.75 KB
unittest	-
urllib.py	58.82 KB
urllib.pyc	51.35 KB
urllib.pyo	51.25 KB
urllib2.py	51.31 KB
urllib2.pyc	47.8 KB
urllib2.pyo	47.71 KB
urlparse.py	16.29 KB
urlparse.pyc	15.51 KB
urlparse.pyo	15.51 KB
user.py	1.59 KB
user.pyc	1.7 KB
user.pyo	1.7 KB
uu.py	6.55 KB
uu.pyc	4.35 KB
uu.pyo	4.35 KB
uuid.py	22.63 KB
uuid.pyc	23.22 KB
uuid.pyo	23.11 KB
warnings.py	14.48 KB
warnings.pyc	13.49 KB
warnings.pyo	12.71 KB
wave.py	18.15 KB
wave.pyc	20.19 KB
wave.pyo	20.05 KB
weakref.py	14.48 KB
weakref.pyc	16.73 KB
weakref.pyo	16.73 KB
webbrowser.py	22.2 KB
webbrowser.pyc	19.86 KB
webbrowser.pyo	19.81 KB
whichdb.py	3.31 KB
whichdb.pyc	2.21 KB
whichdb.pyo	2.21 KB
wsgiref	-
wsgiref.egg-info	187 B
xdrlib.py	5.93 KB
xdrlib.pyc	10.2 KB
xdrlib.pyo	10.2 KB
xml	-
xmllib.py	34.05 KB
xmllib.pyc	26.9 KB
xmllib.pyo	26.9 KB
xmlrpclib.py	50.91 KB
xmlrpclib.pyc	44.81 KB
xmlrpclib.pyo	44.63 KB
zipfile.py	58.08 KB
zipfile.pyc	41.92 KB
zipfile.pyo	41.92 KB

Edit: bdb.py

"""Debugger basics"""

import fnmatch
import sys
import os
import types

__all__ = ["BdbQuit","Bdb","Breakpoint"]

class BdbQuit(Exception):
    """Exception to give up completely"""

class Bdb:

"""Generic Python debugger base class.

This class takes care of details of the trace facility;
    a derived class should implement user interaction.
    The standard debugger class (pdb.Pdb) is an example.
    """

def __init__(self, skip=None):
        self.skip = set(skip) if skip else None
        self.breaks = {}
        self.fncache = {}
        self.frame_returning = None

def canonic(self, filename):
        if filename == "<" + filename[1:-1] + ">":
            return filename
        canonic = self.fncache.get(filename)
        if not canonic:
            canonic = os.path.abspath(filename)
            canonic = os.path.normcase(canonic)
            self.fncache[filename] = canonic
        return canonic

def reset(self):
        import linecache
        linecache.checkcache()
        self.botframe = None
        self._set_stopinfo(None, None)

def trace_dispatch(self, frame, event, arg):
        if self.quitting:
            return # None
        if event == 'line':
            return self.dispatch_line(frame)
        if event == 'call':
            return self.dispatch_call(frame, arg)
        if event == 'return':
            return self.dispatch_return(frame, arg)
        if event == 'exception':
            return self.dispatch_exception(frame, arg)
        if event == 'c_call':
            return self.trace_dispatch
        if event == 'c_exception':
            return self.trace_dispatch
        if event == 'c_return':
            return self.trace_dispatch
        print 'bdb.Bdb.dispatch: unknown debugging event:', repr(event)
        return self.trace_dispatch

def dispatch_line(self, frame):
        if self.stop_here(frame) or self.break_here(frame):
            self.user_line(frame)
            if self.quitting: raise BdbQuit
        return self.trace_dispatch

def dispatch_call(self, frame, arg):
        # XXX 'arg' is no longer used
        if self.botframe is None:
            # First call of dispatch since reset()
            self.botframe = frame.f_back # (CT) Note that this may also be None!
            return self.trace_dispatch
        if not (self.stop_here(frame) or self.break_anywhere(frame)):
            # No need to trace this function
            return # None
        self.user_call(frame, arg)
        if self.quitting: raise BdbQuit
        return self.trace_dispatch

def dispatch_return(self, frame, arg):
        if self.stop_here(frame) or frame == self.returnframe:
            try:
                self.frame_returning = frame
                self.user_return(frame, arg)
            finally:
                self.frame_returning = None
            if self.quitting: raise BdbQuit
        return self.trace_dispatch

def dispatch_exception(self, frame, arg):
        if self.stop_here(frame):
            self.user_exception(frame, arg)
            if self.quitting: raise BdbQuit
        return self.trace_dispatch

# Normally derived classes don't override the following
    # methods, but they may if they want to redefine the
    # definition of stopping and breakpoints.

def is_skipped_module(self, module_name):
        for pattern in self.skip:
            if fnmatch.fnmatch(module_name, pattern):
                return True
        return False

def stop_here(self, frame):
        # (CT) stopframe may now also be None, see dispatch_call.
        # (CT) the former test for None is therefore removed from here.
        if self.skip and \
               self.is_skipped_module(frame.f_globals.get('__name__')):
            return False
        if frame is self.stopframe:
            if self.stoplineno == -1:
                return False
            return frame.f_lineno >= self.stoplineno
        while frame is not None and frame is not self.stopframe:
            if frame is self.botframe:
                return True
            frame = frame.f_back
        return False

def break_here(self, frame):
        filename = self.canonic(frame.f_code.co_filename)
        if not filename in self.breaks:
            return False
        lineno = frame.f_lineno
        if not lineno in self.breaks[filename]:
            # The line itself has no breakpoint, but maybe the line is the
            # first line of a function with breakpoint set by function name.
            lineno = frame.f_code.co_firstlineno
            if not lineno in self.breaks[filename]:
                return False

# flag says ok to delete temp. bp
        (bp, flag) = effective(filename, lineno, frame)
        if bp:
            self.currentbp = bp.number
            if (flag and bp.temporary):
                self.do_clear(str(bp.number))
            return True
        else:
            return False

def do_clear(self, arg):
        raise NotImplementedError, "subclass of bdb must implement do_clear()"

def break_anywhere(self, frame):
        return self.canonic(frame.f_code.co_filename) in self.breaks

# Derived classes should override the user_* methods
    # to gain control.

def user_call(self, frame, argument_list):
        """This method is called when there is the remote possibility
        that we ever need to stop in this function."""
        pass

def user_line(self, frame):
        """This method is called when we stop or break at this line."""
        pass

def user_return(self, frame, return_value):
        """This method is called when a return trap is set here."""
        pass

def user_exception(self, frame, exc_info):
        exc_type, exc_value, exc_traceback = exc_info
        """This method is called if an exception occurs,
        but only if we are to stop at or just below this level."""
        pass

def _set_stopinfo(self, stopframe, returnframe, stoplineno=0):
        self.stopframe = stopframe
        self.returnframe = returnframe
        self.quitting = 0
        # stoplineno >= 0 means: stop at line >= the stoplineno
        # stoplineno -1 means: don't stop at all
        self.stoplineno = stoplineno

# Derived classes and clients can call the following methods
    # to affect the stepping state.

def set_until(self, frame): #the name "until" is borrowed from gdb
        """Stop when the line with the line no greater than the current one is
        reached or when returning from current frame"""
        self._set_stopinfo(frame, frame, frame.f_lineno+1)

def set_step(self):
        """Stop after one line of code."""
        # Issue #13183: pdb skips frames after hitting a breakpoint and running
        # step commands.
        # Restore the trace function in the caller (that may not have been set
        # for performance reasons) when returning from the current frame.
        if self.frame_returning:
            caller_frame = self.frame_returning.f_back
            if caller_frame and not caller_frame.f_trace:
                caller_frame.f_trace = self.trace_dispatch
        self._set_stopinfo(None, None)

def set_next(self, frame):
        """Stop on the next line in or below the given frame."""
        self._set_stopinfo(frame, None)

def set_return(self, frame):
        """Stop when returning from the given frame."""
        self._set_stopinfo(frame.f_back, frame)

def set_trace(self, frame=None):
        """Start debugging from `frame`.

If frame is not specified, debugging starts from caller's frame.
        """
        if frame is None:
            frame = sys._getframe().f_back
        self.reset()
        while frame:
            frame.f_trace = self.trace_dispatch
            self.botframe = frame
            frame = frame.f_back
        self.set_step()
        sys.settrace(self.trace_dispatch)

def set_continue(self):
        # Don't stop except at breakpoints or when finished
        self._set_stopinfo(self.botframe, None, -1)
        if not self.breaks:
            # no breakpoints; run without debugger overhead
            sys.settrace(None)
            frame = sys._getframe().f_back
            while frame and frame is not self.botframe:
                del frame.f_trace
                frame = frame.f_back

def set_quit(self):
        self.stopframe = self.botframe
        self.returnframe = None
        self.quitting = 1
        sys.settrace(None)

# Derived classes and clients can call the following methods
    # to manipulate breakpoints.  These methods return an
    # error message is something went wrong, None if all is well.
    # Set_break prints out the breakpoint line and file:lineno.
    # Call self.get_*break*() to see the breakpoints or better
    # for bp in Breakpoint.bpbynumber: if bp: bp.bpprint().

def set_break(self, filename, lineno, temporary=0, cond = None,
                  funcname=None):
        filename = self.canonic(filename)
        import linecache # Import as late as possible
        line = linecache.getline(filename, lineno)
        if not line:
            return 'Line %s:%d does not exist' % (filename,
                                   lineno)
        if not filename in self.breaks:
            self.breaks[filename] = []
        list = self.breaks[filename]
        if not lineno in list:
            list.append(lineno)
        bp = Breakpoint(filename, lineno, temporary, cond, funcname)

def _prune_breaks(self, filename, lineno):
        if (filename, lineno) not in Breakpoint.bplist:
            self.breaks[filename].remove(lineno)
        if not self.breaks[filename]:
            del self.breaks[filename]

def clear_break(self, filename, lineno):
        filename = self.canonic(filename)
        if not filename in self.breaks:
            return 'There are no breakpoints in %s' % filename
        if lineno not in self.breaks[filename]:
            return 'There is no breakpoint at %s:%d' % (filename,
                                    lineno)
        # If there's only one bp in the list for that file,line
        # pair, then remove the breaks entry
        for bp in Breakpoint.bplist[filename, lineno][:]:
            bp.deleteMe()
        self._prune_breaks(filename, lineno)

def clear_bpbynumber(self, arg):
        try:
            number = int(arg)
        except:
            return 'Non-numeric breakpoint number (%s)' % arg
        try:
            bp = Breakpoint.bpbynumber[number]
        except IndexError:
            return 'Breakpoint number (%d) out of range' % number
        if not bp:
            return 'Breakpoint (%d) already deleted' % number
        bp.deleteMe()
        self._prune_breaks(bp.file, bp.line)

def clear_all_file_breaks(self, filename):
        filename = self.canonic(filename)
        if not filename in self.breaks:
            return 'There are no breakpoints in %s' % filename
        for line in self.breaks[filename]:
            blist = Breakpoint.bplist[filename, line]
            for bp in blist:
                bp.deleteMe()
        del self.breaks[filename]

def clear_all_breaks(self):
        if not self.breaks:
            return 'There are no breakpoints'
        for bp in Breakpoint.bpbynumber:
            if bp:
                bp.deleteMe()
        self.breaks = {}

def get_break(self, filename, lineno):
        filename = self.canonic(filename)
        return filename in self.breaks and \
            lineno in self.breaks[filename]

def get_breaks(self, filename, lineno):
        filename = self.canonic(filename)
        return filename in self.breaks and \
            lineno in self.breaks[filename] and \
            Breakpoint.bplist[filename, lineno] or []

def get_file_breaks(self, filename):
        filename = self.canonic(filename)
        if filename in self.breaks:
            return self.breaks[filename]
        else:
            return []

def get_all_breaks(self):
        return self.breaks

# Derived classes and clients can call the following method
    # to get a data structure representing a stack trace.

def get_stack(self, f, t):
        stack = []
        if t and t.tb_frame is f:
            t = t.tb_next
        while f is not None:
            stack.append((f, f.f_lineno))
            if f is self.botframe:
                break
            f = f.f_back
        stack.reverse()
        i = max(0, len(stack) - 1)
        while t is not None:
            stack.append((t.tb_frame, t.tb_lineno))
            t = t.tb_next
        if f is None:
            i = max(0, len(stack) - 1)
        return stack, i

def format_stack_entry(self, frame_lineno, lprefix=': '):
        import linecache, repr
        frame, lineno = frame_lineno
        filename = self.canonic(frame.f_code.co_filename)
        s = '%s(%r)' % (filename, lineno)
        if frame.f_code.co_name:
            s = s + frame.f_code.co_name
        else:
            s = s + "<lambda>"
        if '__args__' in frame.f_locals:
            args = frame.f_locals['__args__']
        else:
            args = None
        if args:
            s = s + repr.repr(args)
        else:
            s = s + '()'
        if '__return__' in frame.f_locals:
            rv = frame.f_locals['__return__']
            s = s + '->'
            s = s + repr.repr(rv)
        line = linecache.getline(filename, lineno, frame.f_globals)
        if line: s = s + lprefix + line.strip()
        return s

# The following two methods can be called by clients to use
    # a debugger to debug a statement, given as a string.

def run(self, cmd, globals=None, locals=None):
        if globals is None:
            import __main__
            globals = __main__.__dict__
        if locals is None:
            locals = globals
        self.reset()
        sys.settrace(self.trace_dispatch)
        if not isinstance(cmd, types.CodeType):
            cmd = cmd+'\n'
        try:
            exec cmd in globals, locals
        except BdbQuit:
            pass
        finally:
            self.quitting = 1
            sys.settrace(None)

def runeval(self, expr, globals=None, locals=None):
        if globals is None:
            import __main__
            globals = __main__.__dict__
        if locals is None:
            locals = globals
        self.reset()
        sys.settrace(self.trace_dispatch)
        if not isinstance(expr, types.CodeType):
            expr = expr+'\n'
        try:
            return eval(expr, globals, locals)
        except BdbQuit:
            pass
        finally:
            self.quitting = 1
            sys.settrace(None)

def runctx(self, cmd, globals, locals):
        # B/W compatibility
        self.run(cmd, globals, locals)

# This method is more useful to debug a single function call.

def runcall(self, func, *args, **kwds):
        self.reset()
        sys.settrace(self.trace_dispatch)
        res = None
        try:
            res = func(*args, **kwds)
        except BdbQuit:
            pass
        finally:
            self.quitting = 1
            sys.settrace(None)
        return res

def set_trace():
    Bdb().set_trace()

class Breakpoint:

"""Breakpoint class

Implements temporary breakpoints, ignore counts, disabling and
    (re)-enabling, and conditionals.

Breakpoints are indexed by number through bpbynumber and by
    the file,line tuple using bplist.  The former points to a
    single instance of class Breakpoint.  The latter points to a
    list of such instances since there may be more than one
    breakpoint per line.

"""

# XXX Keeping state in the class is a mistake -- this means
    # you cannot have more than one active Bdb instance.

next = 1        # Next bp to be assigned
    bplist = {}     # indexed by (file, lineno) tuple
    bpbynumber = [None] # Each entry is None or an instance of Bpt
                # index 0 is unused, except for marking an
                # effective break .... see effective()

def __init__(self, file, line, temporary=0, cond=None, funcname=None):
        self.funcname = funcname
        # Needed if funcname is not None.
        self.func_first_executable_line = None
        self.file = file    # This better be in canonical form!
        self.line = line
        self.temporary = temporary
        self.cond = cond
        self.enabled = 1
        self.ignore = 0
        self.hits = 0
        self.number = Breakpoint.next
        Breakpoint.next = Breakpoint.next + 1
        # Build the two lists
        self.bpbynumber.append(self)
        if (file, line) in self.bplist:
            self.bplist[file, line].append(self)
        else:
            self.bplist[file, line] = [self]

def deleteMe(self):
        index = (self.file, self.line)
        self.bpbynumber[self.number] = None   # No longer in list
        self.bplist[index].remove(self)
        if not self.bplist[index]:
            # No more bp for this f:l combo
            del self.bplist[index]

def enable(self):
        self.enabled = 1

def disable(self):
        self.enabled = 0

def bpprint(self, out=None):
        if out is None:
            out = sys.stdout
        if self.temporary:
            disp = 'del  '
        else:
            disp = 'keep '
        if self.enabled:
            disp = disp + 'yes  '
        else:
            disp = disp + 'no   '
        print >>out, '%-4dbreakpoint   %s at %s:%d' % (self.number, disp,
                                                       self.file, self.line)
        if self.cond:
            print >>out, '\tstop only if %s' % (self.cond,)
        if self.ignore:
            print >>out, '\tignore next %d hits' % (self.ignore)
        if (self.hits):
            if (self.hits > 1): ss = 's'
            else: ss = ''
            print >>out, ('\tbreakpoint already hit %d time%s' %
                          (self.hits, ss))

# -----------end of Breakpoint class----------

def checkfuncname(b, frame):
    """Check whether we should break here because of `b.funcname`."""
    if not b.funcname:
        # Breakpoint was set via line number.
        if b.line != frame.f_lineno:
            # Breakpoint was set at a line with a def statement and the function
            # defined is called: don't break.
            return False
        return True

# Breakpoint set via function name.

if frame.f_code.co_name != b.funcname:
        # It's not a function call, but rather execution of def statement.
        return False

# We are in the right frame.
    if not b.func_first_executable_line:
        # The function is entered for the 1st time.
        b.func_first_executable_line = frame.f_lineno

if  b.func_first_executable_line != frame.f_lineno:
        # But we are not at the first line number: don't break.
        return False
    return True

# Determines if there is an effective (active) breakpoint at this
# line of code.  Returns breakpoint number or 0 if none
def effective(file, line, frame):
    """Determine which breakpoint for this file:line is to be acted upon.

Called only if we know there is a bpt at this
    location.  Returns breakpoint that was triggered and a flag
    that indicates if it is ok to delete a temporary bp.

"""
    possibles = Breakpoint.bplist[file,line]
    for i in range(0, len(possibles)):
        b = possibles[i]
        if b.enabled == 0:
            continue
        if not checkfuncname(b, frame):
            continue
        # Count every hit when bp is enabled
        b.hits = b.hits + 1
        if not b.cond:
            # If unconditional, and ignoring,
            # go on to next, else break
            if b.ignore > 0:
                b.ignore = b.ignore -1
                continue
            else:
                # breakpoint and marker that's ok
                # to delete if temporary
                return (b,1)
        else:
            # Conditional bp.
            # Ignore count applies only to those bpt hits where the
            # condition evaluates to true.
            try:
                val = eval(b.cond, frame.f_globals,
                       frame.f_locals)
                if val:
                    if b.ignore > 0:
                        b.ignore = b.ignore -1
                        # continue
                    else:
                        return (b,1)
                # else:
                #   continue
            except:
                # if eval fails, most conservative
                # thing is to stop on breakpoint
                # regardless of ignore count.
                # Don't delete temporary,
                # as another hint to user.
                return (b,0)
    return (None, None)

# -------------------- testing --------------------

class Tdb(Bdb):
    def user_call(self, frame, args):
        name = frame.f_code.co_name
        if not name: name = '???'
        print '+++ call', name, args
    def user_line(self, frame):
        import linecache
        name = frame.f_code.co_name
        if not name: name = '???'
        fn = self.canonic(frame.f_code.co_filename)
        line = linecache.getline(fn, frame.f_lineno, frame.f_globals)
        print '+++', fn, frame.f_lineno, name, ':', line.strip()
    def user_return(self, frame, retval):
        print '+++ return', retval
    def user_exception(self, frame, exc_stuff):
        print '+++ exception', exc_stuff
        self.set_continue()

def foo(n):
    print 'foo(', n, ')'
    x = bar(n*10)
    print 'bar returned', x

def bar(a):
    print 'bar(', a, ')'
    return a/2

def test():
    t = Tdb()
    t.run('import bdb; bdb.foo(10)')

# end