Popular recipes tagged "debug" but not "dummy"

Get full caller name (package.module.function) (Python)

2012-11-30T21:54:46-08:00

Python recipe 578352 by anatoly techtonik (caller, debug, logging).

This function allows to get fully qualified name of the calling function. I expected this field to be available from logging module, but it is not here http://docs.python.org/2/library/logging.html#logrecord-attributes It might be that it is too expensive for performance or just doesn't play well in some situations. I don't know. I use it solely when debugging and it is convenient.

Also here: https://gist.github.com/2151727

Attempt to estimate a size of Python object (Python)

2013-02-02T12:09:23-08:00

Python recipe 578447 by Andrew (debug). Revision 6.

This function is built on assumption, that no custom types was implemented. Function traversing the tree of given object and summing sizes of pointers and basic-types objects got with sys.getsizeof() function. For example, for this two dicts {'key': 'shortstring'} and {'key': 'veryverylongandconsumingstring'} my function will return different sizes, while sys.getsizeof() will return same. TODO - make that calculation of size covers pointers of circular references which for now is just passed by

Recipe With No Name Yet (Python)

2012-08-22T17:57:12-07:00

Python recipe 578221 by Cyril (check, debug, decorator, wrapper). Revision 9.

Not a very new recipe, but a short one and (I hope) useful :

wrapping any function "f" with two decorators "enter_event" and "exit_event" that will trigger calling of user functions when, ... hum ... evidently, just before entering and just after exiting the "f" function.

Typical usages :

debugging on a function by function basis :
- emit a trace in log file to see when functions are called and check sequences correctness (very usefull when programming by events)
- feed a profile analyzer (by fine tuning which functions are enabled)
- feed a code coverage analyzer ( " )
kind of validator on function calling :
- implement programming by contracts :
  - check that parameters values of "f" function will not have an unexpected value or be of an unexpected type
  - this allow to increase code robustness by narrowing
- implement invariants (eg. check that returned value is always in the excepted range, ...)
- insure that a function follow specifications by meta-checking that has always predictable results (eg. return the fixed expected value for each possible input value, ...)
minimum modification of existing code
in the same thinking line as the "monkey patching" concept

Notes on usage :

recipe works on functions and any kind of methods (methods, class methods, and static methods)
the usage order of "@enter_event" and "@exit_event" decorators doesn't matter : the result will be the same

PLEASE VOTE FOR THIS RECIPE if you like it !

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.

Conditionnal Breakpoint (Python)

2011-09-20T18:49:23-07:00

Python recipe 577874 by s_h_a_i_o (breakpoint, debug). Revision 2.

Decorates a class so that it encounters a breakpoint for any call to class.method_name(self,args,*kwargs), where

method_name is given by string
only if arguments meet a test: arg_test(self,args,*kwargs) -> bool [default -> True]

Behaviour easily changed for other actions than breakpoint (logging,...)

How to debug (deadlocked) multi threaded programs (Python)

2010-07-26T15:39:15-07:00

Python recipe 577334 by Laszlo Nagy (dead, debug, lock, stack, thread, trace).

Simple module that allows you to explore deadlocks in multi threaded programs.

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.

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

Debugging a running python process by interrupting and providing an interactive prompt (Python)

2008-09-25T11:23:29-07:00

Python recipe 576515 by Brian McErlean (debug, interactive, remote, signal). Revision 2.

This provides code to allow any python program which uses it to be interrupted at the current point, and communicated with via a normal python interactive console. This allows the locals, globals and associated program state to be investigated, as well as calling arbitrary functions and classes.

To use, a process should import the module, and call listen() at any point during startup. To interrupt this process, the script can be run directly, giving the process Id of the process to debug as the parameter.

Sensible Loop Status (Python)

2008-10-05T02:14:52-07:00

Python recipe 576528 by David Lambert (debug, debugging, logging, progress, status).

A LoopStatus object tests true according to geometric progression or time intervals. This enables rapid time estimates for long running codes, typically in a loop, without producing copious highly repetitive output.