Published in: Python

This attribute specifies whether or not the request's body (request.rfile, which is
POST or PUT data) will be handled by CherryPy. If True (the default for POST and PUT
requests), then request.rfile will be consumed by CherryPy (and unreadable after that).
If the request Content-Type is "application/x-www-form-urlencoded", then the rfile will
be parsed and placed into request.params; otherwise, it will be available in
request.body. If cherrypy.request.processRequestBody is False, then the rfile is not
consumed, but will be readable by the exposed method.

Scrape!

For an example, let's say you want a list of popular/anticipated DVD releases for the week. The website VideoETA features a very comprehensive list of new releases each week. However, their RSS feed is only news, not the releases themselves. So we'll scrape their listings for what we need. Here's the code:

Cloning Methods

These methods return a modified copy of the SelectResult instance
they are called on, so successive calls can chained, eg
results = MyClass.selectBy(city='Boston').filter(MyClass.q.commute_distance>10).orderBy('vehicle_mileage')
or used independently later on.

Beautiful
Soup is an HTML/XML parser for Python that can turn even invalid
markup into a parse tree. It provides simple, idiomatic ways of
navigating, searching, and modifying the parse tree. It commonly saves
programmers hours or days of work. There's also a Ruby port called Rubyful Soup.

This document illustrates all major features of Beautiful Soup
version 3.0, with examples. It shows you what the library is good for,
how it works, how to use it, how to make it do what you want, and what
to do when it violates your expectations.

PyPy JIT for dummies

As you surely know, the key idea of PyPy is that we are too lazy to write a
JIT of our own: so, instead of passing nights writing a JIT, we pass years
coding a JIT generator that writes the JIT for us :-).

I'm not going to explain how the JIT generator does its job, (perhaps this
will be the subject of another blog post), but how the generated JIT
works.

There are values that, if known at compile-time (i.e., when the JIT compiler
runs), let the JIT to produce very efficient code. In a dynamic language,
types are the primary example: for instance, suppose you are a compiler and
you have to compile to following Python function:

def mysum(a):
  return a + 1

At compile time, you don't have any knowledge about the type of the parameter:
it could be integer, float, an user defined object, etc. In this situation,
the only safe choice is to emit code which does the usual, slow, full lookup
to know how to perform the operations.

On the other hand, suppose that you knew in advance that the parameter is an
integer: this time, you could emit code that exploits this extra
knowledge, by performing directly a fast integer addition.

The idea behind PyPy JIT is that if you don't have enough knowledge to
generate efficient code, you stop compiling and wait until you know
exactly what you need. Concretely, you emit code that runs until the point
where you stopped the compilation, then it triggers a special procedure that
restarts the compiler. This time the JIT compiler knows everything
you need, because you can inspect the state of the running program.

Let's see an example: the first time the JIT compiles mysum, it produces
something like this pseudo-code:

have a dict, which I need to pass key/values as keyword arguments.. For example..

d_args = {'kw1': 'value1', 'kw2': 'value2'}
example(**d_args)

This works fine, but if there are values in the d_args dict that are not accepted by the example function, it obviously dies.. Say, if the example function is defined as def example(kw2):

This is a problem since I don't control either the generation of the d_args, or the example function.. They both come from external modules, and example only accepts some of the keyword-arguments from the dict..

Ideally I would just do