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

Installed Modules (Perl)

2015-07-17T04:18:15-07:00

Perl recipe 579084 by Roger Mbiama Assogo (application, debugging, network).

Additional Perl modules are installed on the server (aside from the standard libraries) run from a web broswer.

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

Track Debug Package argument(s) are option(s) and/or a debug message to be saved to a file (Tcl)

2014-03-23T22:31:40-07:00

Tcl recipe 578855 by Bert Byfield (debugging, pdisplay, ptrack, trace, track, tracklst).

<h4 id="package-require-tracks">package require tracks</h4> <h4 id="ptrack-on-off-clear-overflow-overflowgo-abend-104-message-text">pTrack ?-on? ?-off? ?-clear? ?-overflow? ?-overflowGo? ?-abend? ?"104 message text"?</h4>

A user-specified text message is written to a file "tracklst.txt" in the same directory as the source program. Tracking can be turned on or off, and the clear option sets the file to zero bytes. The program defaults to raise an error if the tracklst.txt file gets too big (default is one megabyte), but the overflowGo option will cause it to just turn off tracking and continue. The abend option will raise an optional error. The message is whatever the user wants it to be, but suggested usage is to always start with three digits that identify a proc and a fourth alphabetic character that marks the track uniquely and allows searching for a specific track. Also includes pDisplay, which writes a debug message to a tk_messageBox dialog window.

e.g.: pTrack -clear "Start a new test by emptying the track file"
pTrack "140d date adjusted to $tMon of $tYear" pTrack "135b Current working directory is [pwd]"

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.

Komodo JS Macro: Execute JavaScript (JavaScript)

2012-05-07T13:21:30-07:00

JavaScript recipe 578120 by Patrick Cloke (debug, debugging, editor, komodo, macro).

Executes a JavaScript file (or the selected text) and display the results in the command output window.

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

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)