Greetings. I`m trying to use some code from your examples:

import asyncio

from growler import App
from growler.middleware import (Logger, Static, StringRenderer)

loop = asyncio.get_event_loop()

app = App('GrowlerServer', loop=loop)
app.use(Logger())

@app.post('/data')
def post_test(req, res):
    print(req.get_body())

Server = app.create_server(host='127.0.0.1', port=4000)

loop.run_forever()

but when I call this handler: curl -H "Content-Type: application/json" -X POST -d '{"somekey": "somevalue"}' http://127.0.0.1:4000/data I`m getting this errors in console:

ERROR:growler.router:140393215106800:Event loop is running. ERROR:growler.middleware_chain:140393229054640:Event loop is running. And then app exits with code 0.

Python - 3.5.2 asyncio (3.4.3) growler (0.7.5)

Do you have some advice, to aboid this problem. Cause it seems, like your framework is very interesting and perfect for my purposes. But this problem ruins all idea ;)

Thank you.

ETags are a core feature of web servers that users should expect to work out of the box. This should be a non-middleware feature baked into either Application or HTTPRequest classes, with the option to disable or swap implementations if the user so chooses.

I'm running into a problem with uploading binary data (longer than 32K) to a pygrowler-based service. It looks like the responder is not handling the 'EXPECT': '100-continue' header. Can this be added in? It can probably be handled similar to the aiohttp module.

Let's take a look at the documentation example:

from growler import App

app = App()

@app.use
def log_file(req, res):
    print("<{ip}> {req_path}".format(ip=req.ip, req_path=req.path))

@app.get("/")
def index_file(req, res):
    res.send_text("index.")

app.create_server_and_run_forever(host='0.0.0.0', port='8080')

Is index_file a coroutine from which I could do a yield from?

I recently came across Growler, it looks pretty good framework to move away from Flask that I am currently using.

But I have seen some improvements on the loop with https://github.com/MagicStack/uvloop - the benchmark seems to show it is better event loop as compared to Asyncio Event loop. so can I replace the Event loop from the current example to use Uvloop - just wanted to know if I am missing anything.

Asyncio Loop

loop = asyncio.get_event_loop()
app = App('GrowlerServer', loop=loop)

Uvloop

 loop = uvloop.new_event_loop()
 app = App('GrowlerServer', loop=loop)

I understand that #4 its been brought forward - but should it not be as straightforward as given above.

Very awesome project and i appreciate your great work. I am liking the project but the docstring based routing seems a bit unusual to me. Are you guys planning to keep it or change it to more simpler straight forward approach like other framework like falcon (another python framework to build REST API) does? For the newbie programmers, would that be confusing and harder to debug?

when i try to get get a param from a url, the app gave me this error

ERROR:growler.router:4441216280:'GrowlerHTTPResponder' object has no attribute 'client_query' ERROR:growler.middleware_chain:4437457384:'GrowlerHTTPResponder' object has no attribute 'client_query' https://gist.github.com/leonardoo/cc9c0ae4ac0593553b4bfea239758528

the fix is change:

....
    @property
    def query(self):
        return self._protocol.client_query

for this:

....
    @property
    def query(self):
        return self._protocol.parsed_query

Thank you for creating growler, I think it looks great!

I was trying the examples and they work fine, but I copied and pasted the example on the main README and it doesn't work with the pip version of growler (0.7.2).

Here's the error

File "hello.py", line 14, in <module>
    app.use(Renderer("views/", "jade"))
TypeError: __init__() takes 2 positional arguments but 3 were given

I saw this feature in your README, and was reminded of our experience with Django and doing magical imports etc. - back in the day, your own models would end up being imported from a Django namespace, rather than your own Python modules. This was unnecessary magic that caused complications of various kinds (similar to the way that you can't do normal imports such as from growler.ext import foo). The fact that you have to mention "it doesn't work quite the way you expect" tells you that you will have trouble with it.

The end result was that we removed this feature, along with a whole lot of unnecessary magic that required people to learn “the Django way” instead of just using "the Python way" which was perfectly adequate.

In this case, it seems like this mechanism just adds complications - like:

• "More than one way to do it" (you can import the middleware from the original module names or from growler.ext)
• Requiring people to put things in certain namespaces, instead of however they want to package their code.
• Making life hard for IDEs and other tools that want to do static analysis to provide help.

There doesn't seem to be a reason why it is needed. If you really need a registry of plugins, that could be explicit. You could almost certainly use setuptools entrypoints for this - http://stackoverflow.com/questions/774824/explain-python-entry-points#9615473 https://setuptools.readthedocs.io/en/latest/pkg_resources.html#entry-points

I'm copying tests from growler-mako into my extension, so it's probably a good idea to eventually consolidate common fixtures into a pytest plugin at some future point.

I'm trying to build a growler-jinja extension by copying growler-jade and growler.renderer.RendererEngine. However, I'm getting an import error running from the REPL (after a pip install -e .):

>>> from growler.ext import JinjaRenderer
ImportError: No module named 'growler_ext.JinjaRenderer

I don't fully understand setuptools namespaces, so this is partly my own ignorance.

I also see that the api for subclassing RenderEngine has changed subtly. Does the growler-jade source reflect the current api?

After using node's koa framework, I'm excited to try to port my Flask app to Growler.

ubuntu 16 python 3.5.2 virtualenv 15.0.2 setuptools 26.0.0 growler 0.7.5

This project is interesting to me.

I think python's library should not use root logger like:

import logging
 logging.warn('this is a warning')

refs: http://pieces.openpolitics.com/2012/04/python-logging-best-practices/

Would you replace root logger like:

from logging import getLogger

logger = getLogger(__name__)
logger.warn('this is a warning')

coming from HN (https://news.ycombinator.com/item?id=11634152 and https://news.ycombinator.com/item?id=11632650)

Could you please include something like aiopg in your setup instructions - not as a requirement, but as a recommendation. Too many of us are using something like Flask with postgres and we would love to try Growler out.

But the world of Python ORMs is problematic when it comes to asyncio compatible libraries. This includes mysql, postgresql and redis - three of the biggest ones which pretty much everyone uses.

As someone else put it on HN - https://news.ycombinator.com/item?id=11629444

One problem with this is that the entire ecosystem has to get on board with async. Maybe a new framework would make it compelling enough, who knows. This was/is the big issue with Tornado, IMO (and Tornado has been around for ages in framework time). Tornado is only async if the entire call stack all the way down to the http socket is async, using callbacks instead of returning values. This means that any 3rd party client library you use has to be completely written asynchronously, and none are in python. So you end up with a lot tedious work re-implementing http client libraries for Twilio or Stripe or whatever you're using. I'm curious to see where asyncio goes in python, but I'm a bit skeptical after seeing how much of a pain it was to use Tornado on a large web app. In the meantime I'll be using Gevent + Flask, which isn't perfect since it adds some magic & complexity but has the huge upside of letting you keep using all the libraries you're used to.