[three]Bean

import time
import random

@scached(cache_file='shelvecache.db', expiry=datetime.timedelta(seconds=5))
def f1(foo, bar='baz'):
    """ Example of using the cache decorator """

    print " ** starting in f1.. sleepy time"
    time.sleep(5)
    # The result of all my hard work
    result = random.random()
    print " ** woke up with", result
    return result

if __name__ == '__main__':
    print f1('hai') # slow
    print f1('hai') # fast
    print f1(foo='hai') # fast

    print "okay.. sleeping on the outside"
    time.sleep(5)

    print f1('hai') # slow again
    print f1('hai') # fast again

import datetime
import decorator
import shelve
from hashlib import md5

def scached(cache_file, expiry):
    """ Decorator setup """

    def scached_closure(func, *args, **kw):
        """ The actual decorator """
        key = md5(':'.join([func.__name__, str(args), str(kw)])).hexdigest()
        d = shelve.open(cache_file)

        # Expire old data if we have to
        if key in d:
            if d[key]['expires_on'] < datetime.datetime.now():
                del d[key]

        # Get new data if we have to
        if key not in d:
            data = func(*args, **kw)
            d[key] = {
                'expires_on' : datetime.datetime.now() + expiry,
                'data': data,
            }

        # Return what we got
        result = d[key]['data']
        d.close()

        return result

    return decorator.decorator(scached_closure)

#!/usr/bin/python

from blogcopypaste import VirtualenvContext

try:
    import kitchen
except ImportError as e:
    print "kitchen is definitely not installed in system-python"

with VirtaulenvContext("my-venv"):
    import kitchen
    print "But it *is* installed in my virtualenv"

try:
    import kitchen
except ImportError as e:
    print "But once I exit that block, I lose my powers again..."

""" Virtualenv context management! """

import os
import sys
import ihooks
import warnings
import imp

def _silent_load_source(name, filename, file=None):
    """ Helper function.  Overrides a import hook.  Suppresses warnings. """
    with warnings.catch_warnings():
        warnings.simplefilter("ignore")
        return imp.load_source(name, filename, file)

class VenvModuleLoader(ihooks.ModuleLoader):
    """ Overridden ModuleLoader.

    Checks for a virtualenv first and remembers imports.
    """

    remembered = []

    def __init__(self, venv, verbose=0):
        self.venv = venv
        ihooks.ModuleLoader.__init__(self, verbose=verbose)
        self.hooks.load_source = _silent_load_source

    def default_path(self):
        workon = os.getenv("WORKON_HOME", None)
        venv_location = "/".join([
            workon, self.venv, 'lib/python2.7/site-packages'])
        full = lambda i : "/".join([venv_location, i])
        venv_path = [venv_location] + [
            full(item) for item in os.listdir(venv_location)
            if os.path.isdir(full(item))] + sys.path
        return venv_path + sys.path

    def load_module(self, name, stuff):
        """ Overloaded just to remember what we load """
        self.remembered.append(name)
        return ihooks.ModuleLoader.load_module(self, name, stuff)

class VirtualenvContext(object):
    """ Context manager for entering a virtualenv """

    def __init__(self, venv_name):
        self.venv = venv_name
        self.loader = VenvModuleLoader(venv=self.venv)
        self.importer = ihooks.ModuleImporter(loader=self.loader)

    def __enter__(self):
        # Install our custom importer
        self.importer.install()

        # Pretend like our exectuable is really somewhere else
        self.old_exe = sys.executable
        workon = os.getenv("WORKON_HOME", None)
        sys.executable = "/".join([workon, self.venv, 'bin/python'])

    def __exit__(self, exc_type, exc_value, traceback):
        # Uninstall our custom importer
        self.importer.uninstall()

        # Reset our executable
        sys.exectuable = self.old_exe

        # Unload anything loaded while inside the context
        for name in self.importer.loader.remembered:
            if not name in sys.modules:
                continue
            del sys.modules[name]
        self.importer.loader.remembered = []
        sys.path_importer_cache.clear()

with VirtualenvContext('some-environment'):
    install_distributions(['Markdown'])

import pip.commands.install

def install_distributions(distributions):
    command = pip.commands.install.InstallCommand()
    opts, args = command.parser.parse_args()
    # TBD, why do we have to run the next part here twice before actual install
    requirement_set = command.run(opts, distributions)
    requirement_set = command.run(opts, distributions)
    requirement_set.install(opts)

#!/usr/bin/env python

from blogmodule import install_distributions

def run_test():
    try:
        import markdown
        print "Markdown is installed!  Aborting."
        assert(False)
    except ImportError as e:
        print "Markdown isn't yet installed.  That's good."

    install_distributions(["Markdown"])

    try:
        import markdown
        print "Markdown is now installed.  That's good!"
    except ImportError as e:
        print "Markdown never got installed.  That's bad."
        assert(False)

if __name__ == '__main__':
    run_test()

# This feels really old.
f = open('foo.txt')
handle_file(f)
f.close()

# This feels really great.
with open('foo.txt') as f:
    handle_file(f)

import shelve

class cmshelve(object):
    """ Context manager for shelve """

    def __init__(self, filename):
        self.filename = filename

    def __enter__(self):
        self.obj = shelve.open(self.filename)
        return self.obj

    def __exit__(self, exc_type, exc_value, traceback):
        self.obj.close()

>>> with cmshelve('foo.db') as d:
...     d['foo'] = "bar"
...     print d
{'foo': 'bar'}

>>> # This proves that the shelve was actually closed
>>> print d
Traceback (most recent call last):
File "<stdin>", line 1, in ?
ValueError: invalid operation on closed shelf

>>> # And as you'd expect, you can go back and re-open it just fine
>>> with cmshelve('foo.db') as d:
...     print d
{'foo': 'bar'}

% didit-remember -c work -m 'Wrote `diddit`.  Thank god.'
% didit-remember --message 'Helped L. User parallelize his ``Mathematica`` code.'
% didit-remember -c personal       # <-- This launches `vim` for me!

% didit-report --categories=work,general,personal
Category 'work, general, personal' over timespan 'week'
-------------------------------------------------------

----

2011-05-05:

  - Wrote `diddit`.  Thank god.
  - Helped L. User parallelize his ``Mathematica`` code.
  - Drank a beer.

% didit-report --category=work > thisweek.rst && rst2pdf thisweek.rst