
Juno: A Lightweight and Simple Web Framework for Python - jaydub
http://brianreily.com/project/juno
======
RommeDeSerieux
I don't understand why almost every (except for Django) framework author
insists on hiding regular expressions in his routing scheme and instead
forcing developers to use his homegrown language with slashes hardcoded. It's
not like the developers are afraid of regular expressions, are they? This is
so painful, i have to undo the work of those routers sometimes to get the
results i want.

Luckily this is Python so it's possible to monkeypatch the implementation.

~~~
intranation
Regular expressions are overkill in most cases, and clutter the code. Do you
really always know you need a 6 character long integer in a URL? what you
really want is an ID, which _may_ be a 6 character integer. Simple keyword-
based routing is fine for 99% of cases.

~~~
RommeDeSerieux
Here is a simple example which pops up too often: i need a "flatpages"
controller which will display a page based on its url. Or, as another example,
a category tree. With regexes, this is a piece of cake. With routers that try
to hide regexes, i have to undo the work done by the router.

------
FraaJad
Juno looks to be simple and the developer has chosen a good set of libraries
to build it on. It is a demonstration of the inherent simplicity in using well
written, WSGI aware python libraries.

IMO, web.py qualifies to be called "really lightweight"

take for instance the hello world code:

    
    
        import web
    
        urls = (
            '/(.*)', 'hello'
        )
        
        app = web.application(urls, globals())
    
        class hello:        
            def GET(self, name):
                if not name: 
                    name = 'world'
                return 'Hello, ' + name + '!'
     
        if __name__ == "__main__":
            app.run()
    
    

This has two advantages over the Juno code..

1\. more `REST`y (GET/POST)

2\. `app` object is a wsgi callable..

More importantly, web.py does not need have any external library dependencies
unless you choose to use mysql/postgresql when you have to install the db
interface libraries. I had problem running the hello world Juno code because I
did not have pysqlite2 installed.. huh? why do I need pysqlite2 to return a
string?

While some may object saying that web.py has a case of NIH, the code of web.py
itself does not reflect any such attitude. The whole library is just a
directory of aptly named modules. You can plop it anywhere in the python path
and start coding ..

------
petercooper
Very cute. Reminds me of a cross between Ruby's Sinatra
(<http://sintrarb.com/>) and Ramaze (<http://ramaze.net/>) without obviously
being inspired by those :)

------
sandGorgon
Pylons: Python... check MVC...check SQLAlchemy...check Mako....check

Umm... can somebody compare Juno to Pylons please - I'm kind of confused here

~~~
RommeDeSerieux
To me Pylons looks very Rails-like, except for configuration files, which are
in .ini files (painful).

------
KrisJordan
The idea of routing annotations is used extensively in the Recess PHP
Framework, except that in Recess the annotation also takes the HTTP verb (GET,
PUT, POST, etc.) to make beautiful, RESTful URLs even easier to work with.

[http://www.recessframework.org/page/routing-in-recess-
screen...](http://www.recessframework.org/page/routing-in-recess-screencast)

~~~
jrockway
You know you have a good programming language when comments are a key part of
the control flow.

~~~
KrisJordan
PHP has its flaws, no doubt.

It's little known that doccomments are a PHP language construct that can be
reflected over just as Python's doc strings can be introspected with __doc__.

[http://us3.php.net/manual/en/language.oop5.reflection.php#la...](http://us3.php.net/manual/en/language.oop5.reflection.php#language.oop5.reflection.reflectionclass)

Thus _!Route GET, a/good/$programmer_ is just as much a language construct in
a PHP program as @route('a/good/:programmer') is in a Python program. The key
difference is Python defines at the language level how that particular bit of
script is expanded as a decorator. Recess does its expansion of annotations at
the framework level.

Python is a much better and more thoughtfully designed programming language
than PHP, for sure. PHP has loop holes, doccomments is one of them. PHP does
not do anything, by default, with a doccomment, but it does give an
opportunity to introduce meta-data on classes, methods, and properties and
easily reflect over that meta-data and then it's up to the programmer to
define a 'DSL'.

In this sense PHP offers something powerful and dangerous. Recess choose a
simple data format, such that parsing can be expressed in a regexp that is
then processed by essentially 'Constructing a class of type [FirstWord] and
call init method with array of [Following words as a PHP array] - finally make
these annotations available through reflection'. Not too much different than
annotations in Java/C#. Simple enough that the danger is mostly negated and
the utility makes the 'hack' justifiable.

For a better-written justification of why this design decision was made for
Recess: [http://www.recessframework.org/page/on-hiding-our-dick-
tracy...](http://www.recessframework.org/page/on-hiding-our-dick-tracy-
underwear-under-annotations)

(Aside: This is why I'm a huge fan of Scala - extending a language _with_ the
language is awesome.)

~~~
intranation
Just an aside, @someting(blah) isn't a comment or docstring--it's a decorator.
So apples to oranges and all that.

The equivalent in Python would be:

def my_controller(request): """route: /thing/:var/""" pass

or similar.

------
kqr2
Earlier discussion:

<http://news.ycombinator.com/item?id=506352>

------
cnlwsu
wow init({'middleware': [('paste.gzipper.middleware', {'compress_level':
1})]})

dict holding list holding tuple holding dict :) no biggy to throw a wrapper
over it though. Is it possible to place all the routes in one place you think
with this? I am worried with a larger project I will forget which module
contains what url... Unless there is some convention for url path->module name
(if there isnt I would suggest establishing one). A suggestion I would have is
standardize on some templating so if people end up using this there wont be a
person using a different available one.
(<http://wiki.python.org/moin/Templating>) I noticed
<http://karrigell.sourceforge.net/en/pythoninsidehtml.htm> was not on that
page though... albeit its more like php.

------
intranation
I really like Juno. It's very small, and quite elegant, and it mostly feels
like Python (rather than a DSL-ish framework). My only issues are that the
URLs are tightly coupled to the controllers--from a stylistic point of view I
prefer to manage the URLs in a single place (since they're both related but
different).

------
grandalf
very cool... i have started to like the webapp framework for app engine but i
wish it were more like juno.

------
mattmichielsen
Juno: A really outdated dial-up email service turned ISP that my grandma is
most likely the last remaining user of.

