Popular Python recipes tagged "debugging"

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()

Print Hook (Python)

2015-12-04T02:51:42-08:00

Python recipe 579132 by kaulie (debugging).

Hook on stdout and stderr so that we can handle printing of text,error differently e.g in GUI base application divert text to a log window.

stupid trick: mimicking the python cgi library's FieldStorage() object for command line debuging (Python)

2015-06-18T20:46:32-07:00

Python recipe 579069 by Jon Crump (cgi, debugging, urls). Revision 6.

create dictionary-like object that mimics the cgi.FieldStorage() object having both a .value property, and a .getvalue() method

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

Caller and Callee (Python)

2013-03-07T08:37:32-08:00

Python recipe 578483 by Deepak (callee, caller, debugging).

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.

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.

Find what class an attribute - ie, myObj.myAttr - comes from, and how it's defined (Python)

2012-10-26T12:59:47-07:00

Python recipe 578305 by Paul Molodowitch (attribute, attributes, class, debugging, inspection, source, __dict__, __getattribute__, __getattr__, __slots__). Revision 3.

When inspecting new code (or when debugging), it can be handy to know exactly where a given attribute on an object or class comes from.

As a simple example, if you have a class MyClass, you might want to know where MyClass().myMethod is defined.

However, things can get tricky when things like __getattr__, __getattribute__, or even compiled objects come into play. That's where this function comes in. It returns what class a given attribute comes from, and what method was used to define it - ie, '__dict__' ('normal' definitions), '__slots__', '__getattr__', '__getattribute__', '(BUILTIN)'.

(Note - this function should't be relied on to be 100% accurate - rather, it's a best guess, for where to look to find it. It takes some pretty infrequent edge cases for it to be wrong, though...)

Delta Debug - DDMin (Python)

2012-05-25T07:07:04-07:00

Python recipe 578144 by stevenYANG (debugging, python).

Simplifying Failure-Inducing Input.The minimizing delta debugging algorithm ddmin implementation. Using a correct program a_pass and a fail one a_fail to minimize the test set. "testcases/ft.6" is the original test set. The result will be store in a file.

RPDB (RobotPythonDebugger) -- a smarter way to debug robotframework tests (Python)

2012-03-14T15:12:39-07:00

Python recipe 578073 by Daniel Cohn (debugging, decorator, pdb, redirect, robot, rpdb, stdin, stdout).

Robotframework (http://code.google.com/p/robotframework/) is a tool used to run functional tests against a variety of targets. Tests are organized in the form of keyword tsv or html files, which map input parameters to keyword-argument methods in the test suite. Robot includes a fairly advanced logging mechanism, which is cool -- until you try to debug anything. Debugging is made difficult because robot steals stdin and stdout when it is run, which means bye-bye debugging in the terminal. rpdb solves this in a KISS simple way.

objectsignature - debugging utility, will work with containers, classes, nested classes ... almost anything (Python)

2012-02-15T23:05:44-08:00

Python recipe 578039 by Boris Kats (debugging, objectsignature, objectview). Revision 3.

Small debug utility will help to detect unwonted changes of user's class during program execution.

Coloured / highlighted version of string (Python)

2014-06-03T17:54:33-07:00

Python recipe 577818 by Giampaolo Rodolà (color, debugging, highlighting, shell). Revision 3.

Ok, this is really simple but I think it worths a recipe as it's one of those things I always use in shell scripts and for debugging in general.

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.

Simple Regular Expression Tester (Python)

2010-12-25T00:12:44-08:00

Python recipe 577517 by Sunjay Varma (command, debugging, line, python, quick, re, regex, testing). Revision 2.

Is it possible to create a simple command line program that I can use to quickly test my regular expressions?

Yes it is. This simple regular expression tester uses Python's re module as well as others to quickly allow you to test your regular expression in one go.

TODO:

Add Support For Multiple Regular Expression Input

Recent Changes:

Made the output prettier with a little more whitespace. More bytes, but at least it's easier to read!

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).

LoggingWebMonitor - a central logging server and monitor. (Python)

2010-02-02T01:56:42-08:00

Python recipe 577025 by Gabriel Genellina (client_server, debugging, distributed, logging, remote, sysadmin, web). Revision 3.

LoggingWebMonitor listens for log records sent from other processes running in the same box or network. Collects and saves them concurrently in a log file. Shows a summary web page with the latest N records received.

A simple function benchmarking module (Python)

2010-08-27T09:26:48-07:00

Python recipe 577377 by Timothee Cezard (benchmark, debugging, function).

This module enable its user to monitor the amount of time spend in between two commands start and stop. The module is fairly imprecise if the monitored task is quick as the start and stop commands are fairly slow (2e-07 - 5e-07 second)

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.

Easy Exception, Error Handling and Debugging with Auto Logging (Python)

2010-04-06T20:40:05-07:00

Python recipe 577144 by AJ. Mayorga (debug, debugging, error_propagation, exception, logging). Revision 5.

Being new to Python and trying to chase where in my project exceptions were taking place always seems to take up a large amount of time. So I created this class that I now pretty use in all my projects to help me save time tracking exceptions and errors. its also has the ability to generate error logs or to output SQL query and data tuples for Database logging. Ive added sample code to give you an idea of how I normally use it. Hope this helps its saved me hours in tracking error/exception. Feed back would be great, mind you havent been Python all that long