def drawnow(draw_fig, show_once=False, confirm=False, *argv, **kwargs):
"""A function to refresh the current figure.
Depends on matplotlib's interactive mode. Similar functionality to MATLAB's
drawnow.
Parameters
----------
draw_fig : callable
the function that draws the figure you want to update
*argv : any
the list of parameters to pass ``draw_fig()``
**kwargs : any
the keywords to pass to ``draw_fig()``
show_once, optional : bool, default == False.
If True, will call show() instead of draw().
confirm, optional : bool, default == False
If True, wait for user input after each iteration and present
option to drop to python debugger (pdb).
Limitations
-----------
- Occaisonally ignores Ctrl-C.
- If two figures open and focus moved between figures, then other figure
gets cleared.
Usage Example
-------------
>>> def draw_fig_real():
>>> #figure() # don't call, otherwise opens new window
>>> imshow(z, interpolation='nearest')
>>> colorbar()
>>> #show()
>>> N = 16
>>> z = zeros((N,N))
>>> ion()
>>> figure()
>>> for i in arange(N*N):
>>> z.flat[i] = 0
>>> drawnow(draw_fig_real)
"""
# unpacking kw args (found online)
kw = dict()
kw.update(kwargs)
# replace the current figure w/o opening new GUI
clf()
draw_fig(*argv, **kw)
if show_once: show()
else: draw()
if confirm:
string = raw_input('Hit <Enter> to continue, "d<Enter>" for debugger: ')
if string == 'd':
print 'Type "exit" to continue program\n'
pdb.runeval('u')
def drawnow(draw_fig, show_once=False, confirm=False, *argv, **kwargs):
"""A function to refresh the current figure.
Depends on matplotlib's interactive mode. Similar functionality to MATLAB's
drawnow.
Parameters
----------
draw_fig : callable
the function that draws the figure you want to update
*argv : any
the list of parameters to pass ``draw_fig()``
**kwargs : any
the keywords to pass to ``draw_fig()``
show_once, optional : bool, default == False.
If True, will call show() instead of draw().
confirm, optional : bool, default == False
If True, wait for user input after each iteration and present
option to drop to python debugger (pdb).
Limitations
-----------
- Occaisonally ignores Ctrl-C especially while processing LaTeX.
- Does not work in IPython's QtConsole. This depends on pylab's
interactivity (implemented via ion()) working in QtConsole.
- The initial processing of Latex labels (typically on the x/y axis and
title) is slow. However, matplotlib caches the results so any subsequent
animations are pretty fast.
- If two figures open and focus moved between figures, then other figure
gets cleared.
Usage Example
-------------
>>> from pylab import * # import matplotlib before drawnow
>>> from drawnow import drawnow, figure
>>> def draw_fig_real():
>>> #figure() # don't call, otherwise opens new window
>>> imshow(z, interpolation='nearest')
>>> colorbar()
>>> #show()
>>> N = 16
>>> z = zeros((N,N))
>>> figure()
>>> for i in arange(N*N):
>>> z.flat[i] = 0
>>> drawnow(draw_fig_real)
"""
# replace the current figure w/o opening new GUI
plt.clf()
draw_fig(*argv, **kwargs)
if show_once: plt.show()
else: plt.draw_all()
plt.pause(1e-3) # allows time to draw
if confirm:
string = raw_input('Hit <Enter> to continue ("d" for debugger and "x" to exit): ')
if string == 'x' or string=='exit':
sys.exit()
if string == 'd' or string=='debug':
print('\nType "exit" to continue program execution\n')
pdb.runeval('u')
def execTemplate(code, data, pageFormat=None):
# code is tuple (complied_code, source_code)
if not pageFormat:
pageFormat = CPageFormat(pageSize=CPageFormat.A4,
orientation=CPageFormat.Portrait,
leftMargin=5,
topMargin=5,
rightMargin=5,
bottomMargin=5)
try:
infoContext = None
for item in data.itervalues():
if isinstance(item, CInfo):
infoContext = item.context
if infoContext:
break
if not infoContext:
infoContext = CInfoContext()
stream = StringIO.StringIO()
canvases = {}
try:
execContext = CTemplateContext(data, infoContext, stream,
pageFormat)
if QtGui.qApp.preferences.appPrefs.get('templateDebug', False):
import pdb
pdb.runeval(code[0], execContext, execContext.locals)
sys.stdout = stream
exec code[0] in execContext.locals, execContext
canvases = execContext.getCanvases()
finally:
sys.stdout = sys.__stdout__
return stream.getvalue(), canvases
except ExTemplateContext, ex:
QtGui.QMessageBox.critical(None, u'Печатная форма', ex.getRusMessage(),
QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
QtGui.qApp.logCurrentException()
raise
# Debugging pakage pdb
import pdb
def some_div(some_int):
print("Start int", some_int)
ret_int = 10 / some_int
print("End some int", some_int)
return ret_int
#different ways of calling debugger
pdb.run("some_div(2)") #will not say what the function returns
print(pdb.runeval("some_div(2)")) # will show what the function returns
print(pdb.runcall(
some_div,
2)) # will run same as runeval but should pass as function, parameter list
# pdb commands c
if __name__ == "__main__":
try:
some_div(0)
except:
import sys
tb = sys.exc_info()[2] #exception info
pdb.post_mortem(tb) # returns exception info in pdp prompt
print b.cor
print b.get("cor")
b.set("cor","branca")
print b.cor
#---------------------------------------------------------------------------------------------
import pdb
def pyramid1(n):
for i in range(1, n+1):
print((str(i)+" ")*i)
pdb.run("pyramid1(4)")
print pdb.runeval("2+3")
pdb.set_trace()
print "oioioi"
#---------------------------------------------------------------------------------------------
import traceback
import sys
def produce_exception(recursion_level=2):
sys.stdout.flush()
if recursion_level:
produce_exception(recursion_level-1)
else:
raise RuntimeError()
def call_function(f, recursion_level=2):
# s(tep) : execute exactly one line (smallest possible step forward)
# n(ext) : execute exactly one line in the current function
# unt(il) : continue executing until a higher line number is reached
# r(eturn) : continue executing until the current function returns
# c(ont(inue)) : continue executing until next break
# j(ump) lineno : lets you go back or forward to any line
# q(uit) : quit the debugger
#
# There are a few other commands that I don't use much (like setting
# conditional breakpoints etc.).
# Test out some of those commands
print bm.func3()
pdb.pm()
# The command 'pdb.set_trace()' sets an explicit breakpoint at some
# point in your code:
print bm.func2(4)
# You can also run a function under debugger control from the outset using:
pdb.run("bm.func3()")
# In effect, this puts a breakpoint before the function's first statement
# Two variants of 'run' are:
pdb.runeval("X")
# and
def func0(X):
Z = 10 - Y
return Z
pdb.runcall(func0, 3)
import pdb
#pdb.run()
pdb.run("""
for i in range(0,10,3):
i+=2
print(i)
""")
#pdb.runeval()
pdb.runeval('(3+5)*2-6')
#pdb.runcall()
def sum(*args):
s = 0
for x in args:
s += x
return s
pdb.runcall(sum, 2, 4, 6, 8)
#pdb.set_trace()
pdb.set_trace()
for i in range(6):
i *= i
print(i)
def drawnow(draw_fig, show_once=False, confirm=False, stop_on_close=False,
*args, **kwargs):
"""A function to refresh the current figure.
Depends on matplotlib's interactive mode. Similar functionality to MATLAB's
drawnow.
Parameters
----------
draw_fig : callable
The function that draws the figure you want to update
show_once, optional : bool (default: False)
If True, will call show() instead of draw().
confirm, optional : bool, (default: False)
If True, wait for user input after each iteration and present
option to drop to python debugger (pdb).
stop_on_close, optional : bool (default: False)
When the figure is closed, stop the program execution.
*args : list
The list of parameters to pass ``draw_fig()``
**kwargs : dict
The keywords to pass to ``draw_fig()``
Notes
-----
This function does not work with the inline plotting mode, which is
common in Jupyter notebooks/lab, Spyder and the QTConsole. To
disable this, run the following "magic" command:
%matplotlib
This will disable the Matplotlib inline mode and use the default plotting backend. For more detail, see `IPython's plotting documentation`_.
Some limitations are the following:
- Occaisonally ignores Ctrl-C especially while processing LaTeX.
- The initial processing of Latex labels (typically on the x/y axis and
title) is slow. However, matplotlib caches the results so any subsequent
animations are pretty fast.
- If two figures open and focus moved between figures, then other figure
gets cleared.
Usage Example
-------------
>>> from pylab import * # import matplotlib before drawnow
>>> from drawnow import drawnow, figure
>>> def draw_fig_real():
>>> #figure() # don't call, otherwise opens new window
>>> imshow(z, interpolation='nearest')
>>> colorbar()
>>> #show()
>>>
>>> N = 16
>>> z = zeros((N,N))
>>>
>>> figure()
>>> for i in arange(N*N):
>>> z.flat[i] = 0
>>> drawnow(draw_fig_real)
.. _IPython's plotting documentation: https://ipython.readthedocs.io/en/stable/interactive/plotting.html#id1
"""
# replace the current figure w/o opening new GUI
plt.clf()
draw_fig(*args, **kwargs)
if show_once:
plt.show()
else:
plt.draw_all()
plt.pause(1e-3) # allows time to draw
figures = plt.get_fignums()
if stop_on_close and not figures:
sys.exit()
if confirm:
string = raw_input('Hit <Enter> to continue, "d" for debugger and "x" '
'to exit: ')
if string == 'x' or string == 'exit':
sys.exit()
if string == 'd' or string == 'debug':
print('\nType "exit" to continue program execution\n')
pdb.runeval('u')
def update_event(self, inp=-1):
self.set_output_val(
0, pdb.runeval(self.input(0), self.input(1), self.input(2)))
# c(ont(inue)) : continue executing until next break
# j(ump) lineno : lets you go back or forward to any line
# q(uit) : quit the debugger
#
# There are a few other commands that I don't use much (like setting
# conditional breakpoints etc.).
# Test out some of those commands
print bm.func3()
pdb.pm()
# The command 'pdb.set_trace()' sets an explicit breakpoint at some
# point in your code:
print bm.func2(4)
# You can also run a function under debugger control from the outset using:
pdb.run("bm.func3()")
# In effect, this puts a breakpoint before the function's first statement
# Two variants of 'run' are:
pdb.runeval("X")
# and
def func0(X):
Z = 10 - Y
return Z
pdb.runcall(func0, 3)
def test_runeval():
# same as run but return the value
pdb.runeval("test_debugger(0)")
def drawnow(draw_fig, show_once=False, confirm=False, *argv, **kwargs):
"""A function to refresh the current figure.
Depends on matplotlib's interactive mode. Similar functionality to MATLAB's
drawnow.
Parameters
----------
draw_fig : callable
the function that draws the figure you want to update
*argv : any
the list of parameters to pass ``draw_fig()``
**kwargs : any
the keywords to pass to ``draw_fig()``
show_once, optional : bool, default == False.
If True, will call show() instead of draw().
confirm, optional : bool, default == False
If True, wait for user input after each iteration and present
option to drop to python debugger (pdb).
Limitations
-----------
- Occaisonally ignores Ctrl-C especially while processing LaTeX.
- Does not work in IPython's QtConsole. This depends on pylab's
interactivity (implemented via ion()) working in QtConsole.
- The initial processing of Latex labels (typically on the x/y axis and
title) is slow. However, matplotlib caches the results so any subsequent
animations are pretty fast.
- If two figures open and focus moved between figures, then other figure
gets cleared.
Usage Example
-------------
>>> from pylab import * # import matplotlib before drawnow
>>> from drawnow import drawnow, figure
>>> def draw_fig_real():
>>> #figure() # don't call, otherwise opens new window
>>> imshow(z, interpolation='nearest')
>>> colorbar()
>>> #show()
>>> N = 16
>>> z = zeros((N,N))
>>> figure()
>>> for i in arange(N*N):
>>> z.flat[i] = 0
>>> drawnow(draw_fig_real)
"""
# replace the current figure w/o opening new GUI
plt.clf()
draw_fig(*argv, **kwargs)
if show_once: plt.show()
else: plt.draw_all()
plt.pause(1e-3) # allows time to draw
if confirm:
string = raw_input('Hit <Enter> to continue ("d" for debugger and "x" to exit): ')
if string == 'x' or string=='exit':
sys.exit()
if string == 'd' or string=='debug':
print('\nType "exit" to continue program execution\n')
pdb.runeval('u')
def test_runeval():
# same as run but return the value
pdb.runeval("test_debugger(0)")
# module for debugging - pdb
# command used with pdb - r (return), c (continue), h(help)
import pdb, sys
#print(dir(pdb))
def some_div(some_int):
print("Start int", some_int)
ret_int = 10 / some_int
print("End some int", some_int)
return ret_int
#print(pdb.run("some_div(0)")) # returns none object when c is pressed, doesn't return the actual o/p of the program
print(pdb.runeval("some_div(2)")
) # returns the actual value of the program when c is pressed
#pdb.runcall(some_div, 2) # the way of syntax differs from runeval()
# pdb.post_mortem() debugs the remaining program
if __name__ == '__main__':
try:
some_div(0)
except:
tb = sys.exc_info()[2]
pdb.post_mortem(
tb
) # takes the result of the exception as argument and debugs the dead program
# after the exception
