Top-rated recipes tagged "debugging"

Caller and Callee (Python)

2010-03-26T20:04:11-07:00

Python recipe 576925 by Michael Grünewald (callee, caller, debugging). Revision 4.

A recipe to find out which function is the caller of the current function.

The caller function can be helpful for debugging — if there is no real debugger available. In terms of software engineering (loose coupling etc.) this should not be used in production code though.

Lightweight Unittester (Python)

2009-04-07T19:47:08-07:00

Python recipe 572194 by Raymond Hettinger (debugging). Revision 4.

Inspired by py.test, the unittester is a single, simple function that is easily customized. The main virtue is that tests are much clearer than with the unittest.py.

Metaclass for Interface Checking (Python)

2003-06-12T02:00:39-07:00

Python recipe 204349 by Raymond Hettinger (debugging). Revision 4.

Checks a class definition for required attributes <br> To use it, add two lines to your class, __metaclass__=InterfaceChecker and __implements__=[InterfaceName]. The example below generates the following error message: <br> InterfaceOmission: ['__delitem__'] <br> Verifying interfaces for an object becomes trivial. For instance, if you need to validate that variable 'x' implements a minimal sequence interface, verify that: <br> MinimalSequence in x.__implements__

Email pretty tracebacks to yourself (or someone you love) (Python)

2005-10-19T08:13:27-07:00

Python recipe 442459 by Cliff Wells (debugging).

Even production applications have bugs, and it would be nice to have Python tracebacks emailed to you rather than dumped to the hapless user's screen. This recipe shows you how.

doctest, unittest, and python 2.4's cool doctest.DocFileSuite (Python)

2004-09-16T08:59:32-07:00

Python recipe 305292 by John Nielsen (debugging).

Doctest and unittest are like 2 extremes of testing your python code. One is simple and intuitive and the other is powerful and requires more formality. In Python 2.4, doctest, builds in some of the power of unittest, perhaps bridging the gap between the two. This example shows you how to use doctest and the doctest.DocFileSuite feature.

Automatically start the debugger on an exception (Python)

2001-07-13T08:39:47-07:00

Python recipe 65287 by Thomas Heller (debugging). Revision 5.

When Python runs a script and an uncatched exception is raised, a traceback is printed and the script is terminated. Python2.1 has introduced sys.excepthook, which can be used to override the handling of uncaught exceptions. This allows to automatically start the debugger on an unexpected exception, even if python is not running in interactive mode.

Repeat procedure every X seconds (Tcl)

2001-09-10T15:20:39-07:00

Tcl recipe 68393 by Jeff Hobbs (debugging).

This is a cheap rescheduler that uses the built-in after command to repeat a command every X milliseconds. It has cancel and info commands similar to the after command.

Tiny trace/debug-logging tool with smart event filtering (Python)

2011-04-29T02:23:37-07:00

Python recipe 577429 by Jan Kaliszewski (debugging, logging, trace). Revision 3.

Just import, call and log your selected call/return/exception/etc. events.
You can use a standard Python logger from the logging module.
Quite flexible tool and about 50 efective SLOC only (excluding the example script).
For debugging rather than production environments (programs noticeably slow down).

Stack-based indentation of formatted logging (Python)

2005-04-28T23:27:16-07:00

Python recipe 412603 by Christopher Dunn (debugging). Revision 3.

Some people like to sprinkle stack trace information in their code, and it is always helpful to get a visual clue to the call stack depth. inspect.stack() contains the entire call stack.

To make this information available conditionally, on a per-subsystem basis, the logging module is helpful. Here is one way to combine the two ideas.

Using the logging module (Python)

2005-05-04T05:41:45-07:00

Python recipe 412552 by Christopher Dunn (debugging). Revision 7.

This amazingly powerful module is a mystery to novices. Once you figure it out, you'll use it everywhere.

In addition to examples, here are a couple of useful filters.

Use DebugView utility with standard python logging (Python)

2010-02-10T10:35:59-08:00

Python recipe 577040 by Christopher Prinos (debugging, debugview, logging, sysinternals, windows).

This is a custom logging.Handler class that lets you use standard logging calls to output messages to SysInternals' DebugView utility.

sane tab completion in pdb (Python)

2009-07-06T04:35:33-07:00

Python recipe 498182 by Stephen Emslie (complete, debugging, pdb, tab). Revision 6.

I make frequent use of python's built-in debugger, but one obvious feature seems to be missing - the bash-like tab completion that you can add to the interpreter. Fortunately pdb's interactive prompt is an instance of Cmd, so we can write our own completion function.

Note: this uses rlcompleter, which isn't available on windows

Edit (6 Jul 2009): import rlcompleter early and force output to stdout to ensure monkeypatch sticks Edit: updated to handle changes in local scope Edit: Fixed start via 'python -m pdb ...'. Check the comments for details.

Get the value of a cell from a closure (Python)

2005-08-11T14:46:42-07:00

Python recipe 439096 by paul cannon (debugging).

Python closures hold closed-over values in a special datatype called a "cell"; a sort of indirect pointer. It's not simple, though, to see what values are stored there. Here's the key.

Integrating Twisted reactor with IPython (Python)

2005-04-22T01:26:20-07:00

Python recipe 410670 by Matthew Scott (debugging).

Runs the Twisted reactor event loop in a thread alongside an IPython shell, for introspecting a running Twisted process.

Testing Tkinter or Selenium for Tkinter (Python)

2017-01-24T20:34:52-08:00

Python recipe 580751 by Miguel Martínez López (debugging, rpyc, selenium, tkinter). Revision 3.

This code is a little variation of my other trick:

https://code.activestate.com/recipes/580721-tkinter-remote-debugging

It makes more easy to create tests for Tkinter.

Install rpyc:

pip install rpyc

Save the code below to a file named for example tkinter_selenium.py.

This is the usage:

python tkinter_selenium.py [-h] [-p PORT] filename

where filename is the path to main file of Tkinter application, and port is an optional port number for the remote interpreter. Otherwise it uses default port.

Then in another python interpreter you can interact with the application. For example, write:

import rpyc
c = rpyc.classic.connect("localhost")
c.execute("""
from Tkinter import Button, Toplevel
import tkMessageBox 

responsive_button = Button(Toplevel(), text="It's responsive", command = lambda:tkMessageBox.showinfo("alert window", "It's responsive!"))

responsive_button.pack()
""")

responsive_button = c.eval("responsive_button")
responsive_button.invoke()

(This example only works for Python 2. For python 3 use "tkinter" instead of "Tkinter" and so on)

Use port keyword argument to "repyc.classic.connect" if you want a different port number than default port. For example:

import rpyc
c = rpyc.classic.connect("localhost", port=8000)

For the selection of tkinter widgets, I have this other trick:

https://code.activestate.com/recipes/580738-tkinter-selectors

Using this remote debugging utility and selectors makes easy to test tkinter applications similar to selenium.

This utility could be used not only for Tkinter applications. It could be used also for wxpython, pygtk and pyqt applications.

NOTE: Interact with remote application using python of same version. If the application is running using a Python 2 interpreter, use a python 2 interpreter for remote interaction. Similarly use a python 3 interpreter for remote interaction with a python 3 application.

Two quick functions for object introspection (Python)

2017-01-14T22:35:17-08:00

Python recipe 580747 by Vasudev Ram (attributes, debugging, functions, introspection, methods, objects, reflection).

This recipe shows two quick-and-clean :) utility functions for introspection of Python objects. They are meant to be used while working interactively in the reular Python shell or in the IPython shell. Both of them display attributes of any given object passed as the argument. The first function displays all attributes. The second function only displays atttributes that do not begin and end with a double underscore, so as to filter out "dunder" methods a.k.a. "special" methods - like __len__, __str__, __repr__, etc. The first function - oa(o) , where o is some object - does the same as dir(o), but is useful - in IPython - because, dir(o) output will scroll off the screen if the output is long, since it prints the attributes vertically, one per line, while oa(o) prints them horizontally, so has less chance of the output scrolling off, and the output also occupies fewer lines on the screen, so is easier to scan quickly. The second function - oar(o) - is like oa(o), but filters out attribute names that begin and end with a dunder. So it is useful in both IPython and Python.

More information and outputs here:

https://jugad2.blogspot.in/2017/01/two-simple-python-object-introspection.html

Tkinter remote debugging (Python)

2017-01-24T20:23:45-08:00

Python recipe 580721 by Miguel Martínez López (debugging, remote, tkinter). Revision 6.

This trick requires rpyc.

You can install rpyc typing:

pip install rpyc

Run the code below and in another interpreter write:

import rpyc
c = rpyc.classic.connect("localhost")
c.execute("from Tkinter import Label; label=Label(app, text='a label')")
c.execute("label.pack()")
app = c.eval("app")
app.responsive_button.invoke()

RecursionError exception: concise and informative output (Python)

2015-07-05T23:46:59-07:00

Python recipe 578660 by elazar (debugging, exception, handler, recursion). Revision 3.

Replaces the default exception hook with one that, upon "infinite recursion", removes the last cycle. This results in a significantly cleaner and shorter error message.

Usage: simply import <module> as _

For more details see the descussion here: https://mail.python.org/pipermail/python-ideas/2013-September/023190.html

type Checking in Python using decorators (version 2.0) (Python)

2012-11-19T13:15:35-08:00

Python recipe 578330 by LL Snark (checking, debugging, decorators, type). Revision 2.

The two decorators checkparams and checkreturn allow you to check (at execution time) that function parameters or a function return value are the right type.

Trace decorator for debugging (Python)

2011-01-24T18:40:51-08:00

Python recipe 577551 by Kevin L. Sitze (classes, debug, debugging, decorators, functions, inspection, modules, trace). Revision 2.

This package provides a decorator for tracing function and method calls in your applications. The tracing capabilities are managed through the logging package, and several mechanisms are provided for controlling the destination of the trace output.

It also provides functionality for adding decorators to existing classes or modules.