Ytukyg

I was wondering if there is a standardized approach or best practice to scan/ autodiscover decorators like it is done here but also in several other libs like Django, Flask. Usually a decorator provides extra/ wrapped functionality right at the time the inner func is called.

In the example shown below but also in Flask/ Django (route decorators) the decorator is rather used to add overarching functionalities, e.g. spawning of a tcp client initially within the decorator logic and then call the inner func when there is a message received to process it.

Flask/ Django register for an url route where the inner func is only called later when the url is requested. All examples require an initial registration (scan/ discover) of decorator logic to also initially start the overarching functionality. To me this seems to be an alternative use of decorators and I would like to understand the best practice approach if there is any.

See Faust example below where decorator app.agent() automatically triggers a listening (kafka stream) client within asyncio event loop and incoming message is then processed by the inner function hello() later, only when there is a message received, requiring an initial check/ scan/ discovery of related decorator logic first at the start of the script.

import faust



class Greeting(faust.Record):

    from_name: str

    to_name: str



app = faust.App('hello-app', broker='kafka://localhost')

topic = app.topic('hello-topic', value_type=Greeting)



@app.agent(topic)

async def hello(greetings):

    async for greeting in greetings:

        print(f'Hello from {greeting.from_name} to {greeting.to_name}')



@app.timer(interval=1.0)

async def example_sender(app):

    await hello.send(

        value=Greeting(from_name='Faust', to_name='you'),

    )



if __name__ == '__main__':

    app.main()

Nothing is "discovered". When you import a module from a package, all of that code is executed. This is why we have if __name__ == '__main__' to stop certain code being executed on import. The decorators will be "discovered" when you run your code.

I think the Flask blueprint is a nice example. Here you can see how it registers the url endpoints when you import modules. All it's doing is appending to a list:

    def route(self, rule, **options):

        """Like :meth:`Flask.route` but for a blueprint.  The endpoint for the

        :func:`url_for` function is prefixed with the name of the blueprint.

        """

        def decorator(f):

            endpoint = options.pop("endpoint", f.__name__)

            self.add_url_rule(rule, endpoint, f, **options)

            return f

        return decorator

The code runs, the decorators are evaluated and they need only keep some internal list of all the functions they decorate. These are stored in the Blueprint object.