
Flask 0.7 Released (Python Web Framework) - hiddenbayes
http://flask.pocoo.org/docs/changelog/#version-0-7
======
hiddenbayes
Release Announcement:
[http://flask.pocoo.org/mailinglist/archive/2011/6/28/ann-
fla...](http://flask.pocoo.org/mailinglist/archive/2011/6/28/ann-
flask-0-7-released/)

------
atroche
Of particular interest are the generic or 'pluggable' class-based views. They
work in a very similar manner to the ones that came with Django 1.3.

<http://flask.pocoo.org/docs/views/>

It's good timing; I was just getting to the stage in my app where I was
noticing the need for some view refactoring.

~~~
ch0wn
Same for me. Class-based views were basically the only thing I missed from
django for my particular app.

------
loevborg
I've used it for small side-projects and liked it. What I would like to know
is how to do logging, both day-to-day ("user Joe created") and for debugging
(like JSON dumps of objects). It should work both with the built-in server and
with gunicorn, for deployment. I looked but wasn't able to find a solution
that worked. The documentation mentioned logging facilities, but I found no
working examples.

~~~
Semiapies
I believe that refers to the standard python "logging" module.

~~~
loevborg
Right, but do I have to manually add a logging handler? Where does my
logging.warn("...") end up?

------
dumbphone
Flask seems nice and simple until you need to access a database such as MySQL.
With SQLAlchemy it seems like there's a lot more code needed just to perform
simple CRUD operations, whereas Django's ORM is really simple. Is there a
better alternative to SQLAlchemy? Is it possible to use Django's ORM in Flask?

~~~
dumbphone
Gonna answer this one myself: Seems <http://www.sqlobject.org/> might be a
good alternative.

------
viandante
I take the occasion to ask here if someone could point or write some
documentation on unittest in Flask. I am trying to get that right using
mongodb...

~~~
johnpaulett
<http://flask.pocoo.org/docs/testing/>

For testing a MongoDB database, I wrote a simple unittest.TestCase subclass
that in the setUp and tearDown, creates and then deletes a test database.

~~~
viandante
Could you put an example on pastebin or somewhere? I would really appreciate
this.

~~~
johnpaulett
Along the lines of <http://flask.pocoo.org/docs/patterns/mongokit/>, I have a
MONGODB_DATABASE setting, which is set to my normal database name. Then access
the database via the connections' dictionary syntax, instead of attribute
syntax (I have a helper method to make this prettier):

    
    
      connection[app.config['MONGODB_DATABASE']].mycollection.find_one()
    
    

The unittest code just modifies the setting:

    
    
      import unittest
      def setUp(self):
        myapp.app.config['MONGODB_DATABASE'] = 'test'
        self.app = myapp.app.test_client()
    
      def tearDown(self):
        # can clean up here, e.g.
        connection.test.drop_collection('mycollection')

~~~
viandante
Thanks a lot man. This was really useful, I am on my first steps with
unittest.

------
mattdeboard
I really enjoy Flask's simplicity (relative to Django) and light-weightness.
It was the first web framework I used, actually. Armin Ronacher & team make
quality products.

~~~
retube
I've been looking at light-weight scripting-language frameworks, any
experience with Catalyst? I'm a fan of Perl.

~~~
draegtun
Catalyst is a full blown MVC web framework. For light-weight (micro) web
frameworks in Perl have a look at:

* Dancer (<http://perldancer.org/>)

* Mojolicious::Lite (<http://mojolicio.us/>)

* Squatting (<http://p3rl.org/Squatting>)

* Web::Simple (<http://p3rl.org/Web::Simple>)

~~~
retube
Great, thanks for the suggestions

~~~
draegtun
Thats OK.

PS. Here is a presentation doing a loose comparison between Dancer & Flask
called "Dancer for Python programmers"
([http://www.slideshare.net/xSawyer/perl-dancer-for-python-
pro...](http://www.slideshare.net/xSawyer/perl-dancer-for-python-programmers))

------
minikomi
I'm always impressed by Flask - especially its documentation. In fact, this
seems like a good occasion to have a poke around and build something with it.

On a slightly related note - although jinja2 is already quite compact, I'm a
fan of haml and I'm always surprised by the lack of support for it in Python.
Is there something I'm missing? Uncanny valley for Pythonistas?

~~~
LeafStorm
There was a Haml-like language called GHRML a while back, but it seems to have
disappeared. There is something like it called SHPAML:
<http://shpaml.webfactional.com/>

Though I think Ruby has better markup libraries in general. For example, they
have Nokogiri, which is an absolute joy to use for XML parsing. And
implementations of Markdown and Textile with actual parsers, whereas Python
Markdown and Python Textile are straight regex-using ports of the Perl/PHP
versions. It's kinda sad really.

~~~
kbd
To learn Ruby I decided to redo my website in it, and I felt the complete
opposite. I was surprised there's nothing comparable in the Ruby world to
Jinja2 or Mako. Nothing supports blocks/macros or template inheritance, so I
wrote my own small template engine in Ruby that does.

------
louis14
How does Flask compare to Bottle (<http://bottlepy.org/docs/dev/index.html>)?
Any advantages/disadvantages?

~~~
DasIch
Flask has more features, more and better documentation, a bigger community and
ecosystem as well as more developers behind it.

Furthermore Bottle does magic that is frowned upon by some people.

~~~
dochtman
Then again, I also dislike some of the magic in Flask.

~~~
louis14
For what reason?

~~~
hackoder
Magic can come to haunt you when you get stuck. For e.g. flask has thread
locals where the request variable gets populated with the current request's
context dynamically.

For the most part though, Flask is very magic free and the source is small
enough to quickly figure out whats going on.

------
e1ven
Right now, I'm writing most of my projects in Tornado.. Not because I need the
async, but because I wanted a simple web.py like format that was under active
development.

Can someone help me understand where Flask fits into things? It would
essentially be a replacement for Tornado? What's the advantage of this over
Tornado? Ease of use?

I can understand the simplicity argument; I chose to avoid Django because it
was too heavy, so I'd love to hear more about how Flask compares.

~~~
jokull
Tornado is batteries included. Flask uses Werkzeug and Jinja2 and encourages
packaging extensions for localization, form processing, ORM's etc.. Flask,
Werkzeug and Jinja2 are all Pocoo projects that have a good community around
them and excellent documentation. Technically I would not like to argue the
superiority of either, although Flask seems to fit my tastes much better.

Flask's use and deployment of "magic" is pretty spot on. For example by making
the request object omnipresent (that is flask.request is always bound and has
the right context). That way it is not passed around the MVC stack but just
imported and introspected when needed.

Flask is probably the "healthiest" project I've encountered.

~~~
jimmybot
Why would it be good to avoid passing around the request object?

~~~
espeed
Armin explains the request object here
(<http://flask.pocoo.org/docs/reqcontext/>) and here
(<http://flask.pocoo.org/docs/quickstart/#id4>), and the concept of "context
locals" in detail here (<http://werkzeug.pocoo.org/docs/local/>).

------
old-gregg
Flask is awesome and can be easily supercharged by pairing it with Paste
Deploy: <http://pythonpaste.org/deploy>

This way you get Flask simplicity and elegance, but also you get Rails-like
separation of configuration test/development/production environments.

Another misconception people seem to have is that Flask means Jinja2.
Fortunately that's not the case, swapping Jinja with Mako is also extremely
easy.

Finally, Flask can run on top of any WSGI server, not just a built-in one: at
<http://mailgun.net> we have Flask services running on Tornado and on Paster
servers - the thing is rock solid.

~~~
sandGorgon
I notice that several projects (including Flask) do not build in support for
DB schema management- e.g. migrations.

For those of you who are writing apps in Flask, how do you guys manage changes
in DB schema ?

~~~
espeed
Flask has become my framework of choice because it's incredibly well designed,
the code is clean, and also because it's decoupled from an ORM.

Rails and Django emerged at a time when RDBMS ruled, and they were both built
around an ORM. Now you have more database options that have less of an
impedance mismatch, but because Rails and Django are so ORM-centric, forgoing
the RDBMS in favor of another option means you now have a framework mismatch.

Graphs are a much more elegant way of storing relational data. With graph
databases you don't have to mess with tables or joins -- everything is
explicitly joined.

For most Web development projects, I have shifted from a relational database
to a graph database as the primary datastore, and use Redis, Memcached, and
MongoDB for specialized purposes when called for.

Neo4j Community Edition (<http://neo4j.org/>) is open source and now free, and
pairing it with the TinkerPop stack (<http://www.tinkerpop.com/>) is ideal.

With Neo4j you can now store 32 billion nodes
([http://blog.neo4j.org/2011/03/neo4j-13-abisko-
lampa-m04-size...](http://blog.neo4j.org/2011/03/neo4j-13-abisko-
lampa-m04-size-really.html)) with 2 million traversals per second
(<http://www.infoq.com/news/2010/02/neo4j-10>), and you can use Gremlin with
it (the graph traversal language), which let's you calculate PageRank in 2
lines -- to see what you can do with Gremlin, check out this 10 min screencast
(<http://www.youtube.com/watch?v=5wpTtEBK4-E>).

For tabular data, relational databases rock. But the relational model doesn't
align well with object-orientated programming so you have an ORM layer that
adds complexity to your code. And with relational databases, the complexity of
your schema grows with the complexity of the data.

The graph-database model simplifies much of this and makes working with the
modern-day social graph so much cleaner. Graphs allow you to do powerful
things like find inferences inside the data in ways that would be hard to do
with relational databases.

There is an open-source Python persistence framework in the works called Bulbs
that connects to Neo4j through the Rexster REST server, and there are binary
bindings in the works as well. There is also a Python open-source Web
development framework for graph databases called Bulbflow that is built on
Bulbs and Flask, which will provide stuff like authentication and
authorization, in a graph-DB way. Both frameworks should be released in the
next few weeks.

~~~
draegtun
_Rails and Django emerged at a time when RDBMS ruled, and they were both built
around an ORM. Now you have more database options that have less of an
impedance mismatch, but because Rails and Django are so ORM-centric, forgoing
the RDBMS in favor of another option means you now have a framework mismatch._

And Rails & Django were (at the time) also built around a specific ORM.
Compare this to Catalyst, which also came out same time as Rails & Django, was
built from the ground up with an agnostic model and thus could use any ORM
available or easily adapt to different data models.

