batbelt 0.5.1

A collection of gagdets that makes Python even more powerful.

*************************************************************
A collection of gagdets that makes Python even more powerful
*************************************************************

There is not real structure for this lib, it's just a bunch of snippets I put together because I use them often.

Not all of them are documented here, few of them have tests, it's zlib licence, you know the drill...


To timestamp
=============

<code>datetime.fromtimestamp</code> exists but not the other away around, and it's not likely to change anytime soon (see: http://bugs.python.org/issue2736). In the meantime::

>>> from datetime import datetime
>>> to_timestamp(datetime(2000, 1, 1, 2, 1, 1))
946692061
>>> datetime.fromtimestamp(946688461) # tu as codé celle là et pas l'autre connard !
datetime.datetime(2000, 1, 1, 2, 1, 1)


Get this nest value or a default
=================================

Don't::

try:
res = data['key'][0]['other key'][1]
except (KeyError, IndexError):
res = "value"


Do::

get(data, 'key', 0, 'other key, 1, default="value")


For attributes::

devise = attr(car, 'insurance', 'expiration_date', 'timezone')


Iteration tools missing in itertools
===================================================================================


Iteration by chunk or with a sliding window::

>>> for chunk in chunks(l, 3):
... print list(chunk)
...
[0, 1, 2]
[3, 4, 5]
[6, 7, 8]
[9]
>>> for slide in window(l, 3):
... print list(slide)
...
[0, 1, 2]
[1, 2, 3]
[2, 3, 4]
[3, 4, 5]
[4, 5, 6]
[5, 6, 7]
[6, 7, 8]
[7, 8, 9]


Get the first element an any iterable (not just indexable) or the first one to be True::

>>> first(xrange(10))
0
>>> first_true(xrange(10))
1
>>> first([], default="What the one thing we say to the God of Death ?")
'What the one thing we say to the God of Death ?'

Sorted Set
===================================================================================

Slow but useful data structure::

>>> for x in sset((3, 2, 2, 2, 1, 2)):
... print x
...
3
2
1


Dictionaries one liners
===================================================================================


I wish <code>+</code> was overloaded for dicts::

>>> dmerge({"a": 1, "b": 2}, {"b": 2, "c": 3})
{'a': 1, 'c': 3, 'b': 2}


Sometimes you do not want to simply overwrite the values inside the original dict, but merge them in custom fashion::

>>> def my_merge(v1, v2):
... if isinstance(v1, dict) and isinstance(v2, dict):
... return dmerge(v1, v2)
... return v2
>>> dmerge({"a": 1, "b": {'ok': 5}}, {"b": {'ko': 5 }, "c": 3}, my_merge)
{'a': 1, 'c': 3, 'b': {'ko': 5, 'ok': 5}}

Original dicts are not modified, but this will modify them::

>>> from batbelt.structs import rename
>>> rename({"a": 1, "b": 2})
>>> rename({"a": 1, "b": 2}, 'b', 'z')
{u'a': 1, u'z': 2}

(not thread safe).

Twited but satisfying::

>>> from batbelt.structs import unpack
>>> dct = {'a': 2, 'b': 4, 'z': 42}
>>> a, b, c = unpack(dct, 'a', 'b', 'c', default=1)
>>> a
2
>>> b
4
>>> c
1


String tools
===================================================================================

The mandatory "slufigy"::

>>> slugify(u"Hélo Whorde")
helo-whorde

You get better slugification if you install the `unidecode` lib, but it's optional. You can specify `separator` if you don't like `-` or call directly `normalize()` (the underlying function) if you wish more control.

The module also feature html_escape/unescape that is not useless and json_dumps/loads that understand datetime by default. Look at the source for these, I'm lazy (PL for documentation are welcome).

There is also a poor man template system using the `format()` string method on a file content. No loop, but still nice for quick and dirty file generation :

from batbelt.strings import render

render('stuff.conf.tpl', {"var": "value"}, "/etc/stuff.conf")


Import this
===================================================================================


`__import__` is weird. Let's abstract that ::

TaClasse = import_from_path('foo.bar.TaClasse')
ton_obj = TaClasse()


Catpure prints
===================================================================================


A context manager to deal with this libs that print the result instead of returning it :


>>> with capture_ouput() as (stdout, stderr):
... print "hello",
...
>>> print stdout.read()
hello
>>> stdout.close()


Create a decorator that accept arguments
===================================================================================


I never remember how to do this. And I don't have to anymore.

First, write the decorator::

# all arguments after 'func' are your decorator argument
@decorator_with_args()
def your_decorator(func, arg1, arg2=None):

if arg1:
# do stuff here

# do your usual decorator jimbo jumbo, wrapping, calling, returning...
def wrapper():
return func(arg2)


return wrapper



Enjoy :

@your_decorator(False, 1)
def hop(un_arg):
# do stuff in the decorated function



Add a any directory to the PYTHON PATH
===========================================

Accepts shell variables and relative paths :

from batbelt.utils import add_to_pythonpath
add_to_pythonpath("~/..")

You can (and probably wants) specify a starting point if you pass a relative path. The default starting point is the result is `os.getcwd()` while you probably wants the directory containing you script. To to so, pass `__file__`:

add_to_pythonpath("../..", starting_point=__file__)

`starting_point` can be a file path (basename will be stripped) or a directory name. If will be from there that the reltive path will be calculated.

You can also choose where in the `sys.path` list the your path will be added by passing `insertion_index`, which default to the after the last existing item.


Poor man task queue
===================================================================================================


You don't always need the guaranty of a big lib, you just need a little worker to do the job outside of the main thread::



from batbelt.parallel import worker

@worker()
def task(arg):
arg = arg + 10
return arg


# start the worker
process = task.start()

# send tasks
for x in range(10):
process.put(x)

# (optionaly) get results
for x in range(10):
print process.get()

## 10
## 11
## 12
## 13
## 14
## 15
## 16
## 17
## 18
## 19

# stop the worker
process.stop()

Le worker use subprocess by default, but if you prefer threads: `@worker(method="tread")`.

If you look for it in the source code, you'll see goodies such as Singletong, Null Pattern implementation and other things you don't use that often.