Popular Python recipes tagged "meta:requires=inspect"

Auto assign self attributes in init using PEP 484 (Python)

2017-04-26T17:26:29-07:00

Python recipe 580790 by Ryan Gonzalez (annotations, class, self, type). Revision 2.

TL;DR: Short way of doing stuff like def __init__(self, a, b): self.a = a; self.b = b, using type annotations from PEP 484, inspired by Dart's MyConstructor(this.a, this.b) and Ruby's/Crystal's/(Moon|Coffee)Script's constructor/initialize(@a, @b).

Find the arity of a Python function (Python)

2017-01-30T14:09:47-08:00

Python recipe 580753 by Vasudev Ram (functions, introspection, python, python2, reflection).

This recipe shows how to find the arity of a given Python function. The arity of a function is the number of arguments the function takes. The recipe uses the inspect module of Python.

More details and sample output (including some limitations) here:

https://jugad2.blogspot.in/2017/01/finding-arity-of-python-function.html

Python2 keyword-only argument emulation as a decorator. Python3 compatible. (Python)

2016-04-15T13:25:20-07:00

Python recipe 580639 by István Pásztor (args, arguments, keyword, keyword_only, kwonly, only, python2). Revision 4.

Provides a very simple decorator (~40 lines of code) that can turn some or all of your default arguments into keyword-only arguments. You select one of your default arguments by name and the decorator turn this argument along with all default arguments on its right side into keyword only arguments. Check the docstring of the decorator or visit the github/pypi page for detailed documentation:

$ pip install kwonly-args

Python: Determine Name and Directory of the Top Level Running Script (Python)

2015-02-03T01:37:09-08:00

Python recipe 579018 by Harald Lieder .

Yet another way to provide this information. I wanted to get the right answers in ANY situation: Python 2 or 3, compiled or interpreted (interactive or batch). The following code has been tested under Windows, Python 2.7, Python 3.4, IDLE, IPython (sh and Qt), PyInstaller, cx_Freeze, py2exe.

Keyword-only arguments in Python 2.x (Python)

2015-09-22T18:16:40-07:00

Python recipe 578993 by Cara (arguments, decorator, keyword, keyword_only). Revision 10.

This is a decorator that makes some of a function's or method's arguments into keyword-only arguments. As much as it possible, it emulates the Python 3 handling of keyword-only arguments, including messages for TypeErrors. It's compatible with Python 3 so it can be used in code bases that support both versions.

Python 2 nonlocal (Python)

2015-09-08T01:27:04-07:00

Python recipe 578965 by Ryan Gonzalez (backport, nonlocal, python2). Revision 2.

This implements nonlocal in Python 2...albeit in a slightly ugly way. Tested with CPython 2.7 and PyPy.

Easy attribute setting and pretty representation (Python)

2014-12-03T09:55:06-08:00

Python recipe 578973 by Joakim Pettersson (attributes, lazy, traits). Revision 2.

Mix in one or more of these classes to avoid those tedious lines of administrative code for setting attributes and getting useful representations.

If you inherit HasInitableAttributes, your should be able to obj = eval(repr(obj)) without loosing data.

enthought.traits.api.HasTraits seems to mix in well also.

NondurableLogger class for use with concurrent.futures.ProcessPoolExecutor's submit and map methods (Python)

2014-02-10T17:50:59-08:00

Python recipe 578827 by Peter Santoro (logging, multiprocessing). Revision 2.

I needed a simple logging solution that I could use with with concurrent.futures.ProcessPoolExecutor and this is my initial recipe.

More strict unittests using a validator (Python)

2014-03-01T12:37:47-08:00

Python recipe 578793 by Thomas Lehmann (decorator, unittests, validator). Revision 4.

The main point is that there was no binding between a unit tests and the concrete class. It did happend often that you are indirectly testing a class using it also the concrete test class has missed some concrete test methods. I found this fact sometimes very irritating seeing 100% coverage.

Therefor I now provide this class decorator where you can specify the class that will be tested. If you do not specify test methods for each method of the testable class an exception will be thrown providing a list of missed tests.

Here some examples how it works: You implemented a

method "__eq__", then write a "testEqual" method
method "__init__", then write a testInit" method
method "scalar_product", then write a testScalarProduct" method
and so on ...

The way to use this class decorator you can see in the doctest area (see below in the code) The only point to be aware of is that when you use the decorator you have to implement all test to get rid of the thrown execption. Of course you can implement more tests for same class.

New in revision 4 (1st march 2014):

Bugfix: the algorithm were not correctly detecting which methods were really overwritten forcing to implement tests for methods which were base class only.
Bugfix: decorated classes which contain the attribute "decorated_object" can be handled properly.
A new second parameter now allows you to implement several classes in same test class forcing you to include the class name in the test method:
- @ValidateTestResponsibilityFor(Square, True)
- @ValidateTestResponsibilityFor(Sin, True)
- => testSquareInit, testSquareGet, testSinInit, testSinGet, ...
- This for smaller classes to avoid too many files (at least ... you decided)

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.

Evaluates string embedded expressions (rubstr module) (v 0.91) (Python)

2013-03-09T12:22:00-08:00

Python recipe 578487 by SnarkTurne . Revision 2.

This recipe allow you to write :

>>> a,b=5,6
>>> rstr("If you add #{a} and #{b}, you'll get #{a+b}.")
If you add 5 and 6, you'll get 11.

This is more readble, from my point of view, than :

"If you add {} and {}, you'll get {}.".format(a,b,a+b)

This recipe is inspired from the way Ruby evaluates strings :

irb> a,b=5,6
irb> "If you add #{a} and #{b}, you'll get #{a+b}."
==> If you add 5 and 6, you'll get 11.

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

A Class Decorator that Adds a copy() Method (Python)

2013-02-14T20:43:20-08:00

Python recipe 578457 by Eric Snow (metaprogramming).

Here's a class decorator that adds a rudimentary copy() method onto the decorated class. Use it like this:

@copiable
class SomethingDifferent:
    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c

or like this:

@copiable("a b c")
class SomethingDifferent:
    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c

s = SomethingDifferent(1,2,3)
sc = s.copy()
assert vars(s) == vars(sc)

(Python 3.3)

Peek at Python value stack (Python)

2013-01-08T22:15:21-08:00

Python recipe 578412 by Dima Tisnek (python, python2, stack).

Poking at value stack, a.k.a. evaluation stack is not allowed in Python, however everything is doable with ctypes.

I think this could be useful in debugging complex statements.

Code to source and back (Python)

2012-12-01T08:59:49-08:00

Python recipe 578353 by Oren Tirosh (ast, decompile, recompile, uncompile).

Converts a code object to a source code snippet and back: c == recompile(*uncompile(c))

This is useful, for example, if you want to apply an AST transformation to the code.

Print an object only a limited number of times (Python)

2012-12-09T19:41:20-08:00

Python recipe 578374 by Filippo Squillace .

The psome function detects the position into the source files where the function itself is called. It prints the object according a counter variable. Therefore, whenever the psome function is called inside a loop the object will be printed only a limited number of times. This can useful for debugging code in particular when the data structure we want to scan is quite big and we want to print only the first elements of it.

Sequence Builder (Python)

2012-03-03T17:50:03-08:00

Python recipe 578061 by Thomas Lehmann (builder, sequence). Revision 2.

Why?

Thinking about a sequence of odd numbers where numbers divisible by 3 are not part of it I came to a sequence starting with 5, 7, 11, 13, 17, 19, ...
The interesting property of this sequence is that the sequence of differences between the individual elements are 2,4,2,4,2,...

How?

I'm not a math expert (unfortunately) but I could imagine that there is a quite simple formula to get this.
However I thought that using different combinations of defined functions a script could do the favour for me.

Result?

Formula: (((-1)**(x-1))+1)+2 -> Simplified -> -1**(x-1) + 3 (now clear to you?)
You have to look for the sequence [4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2]

Out of scope:

Does not check for using lambda functions only and "x" only in the lambda functions.
The Python script does not simplify functions like changing ((x+1)+1) to x+2 - would be an interesting recipe - by the way :)

Please note

You should not add other functions than lambda.
You should always use "x" in your formular.
Be aware that the actual setup runs a few minutes (about 3 minutes) and you can imagine - surely - that adding further functions will definitely increase the runtime.

Side effects?

Quite funny to produce a sequence of nines with (((-1)**(2*x))+2)**2.
If you apply the first binomial theorem (a+b)^2 = a^2 + 2ab + b^2 then you see why!

What I have learned from this?

The biggest nightmare I did have with the Sequence class because of not knowing how to generate unique elements of this in a set (__eq__ and __hash__ are required); and I have to ensure that the hash code is calculated once only.
The 'combineFunctions' was interesting to me. I have never used 'inspect.getsource' before.
A few minutes does not sound much but for developing all times with more than 30 seconds are not comfortable. There are just 325 sequences and to investigate for certain sequences you probably have to have some more formula. Maybe I would have to take another approach for that.

Bunch class created from attributes in class (Python)

2011-12-31T18:03:02-08:00

Python recipe 577999 by Fabio Zadrozny (attributes, bunch, metaclass). Revision 3.

Provide a way to construct class __init__, __slots__, __eq__, __ne__, __repr__ for the class and makes explicit which attributes each instance will have (and providing defaults).

The __main__ session shows an example of how it should be used.

Simple enum mechanism (Python)

2012-01-15T12:30:31-08:00

Python recipe 578015 by Thomas Lehmann (enum).

Here are the basic ideas (orientation: C++):

You are responsible to find names for constants and this code provides a way to give values which differ from each other
The context is to allow different enums with values starting by 0
If you like to use constants like here: "Orientation.TOP" then place those constants in the relating class
You still can assign your own values

About the code:

It's not much code also it might look like (implementation + documentation + unittests)
The __docformat__ is for epydoc. Temporarily remove the "@singleton" when trying to generate the HTML documentation (can not yet be handled by epydoc).

Example(s): Have a look at the unittests please.

Improved Signals/Slots implementation in Python (Python)

2011-12-12T22:47:25-08:00

Python recipe 577980 by Christopher S. Case (events, qt4, signal, slot).

I've modified the excellent recipe 576477 to allow for non method functions as well as method functions. This implementation also uses a WeakKeyDictionary instead of a WeakValueDictionary for reasons of code simplification/style.