Context Locals // Werkzeug Documentation

# Werkzeug

The Swiss Army Knife For Python Web Developers

## Context Locals

Sooner or later you have some things you want to have in every single view or helper function or whatever. In PHP the way to go are global variables. However that is not possible in WSGI applications without a major drawback: As soon as you operate on the global namespace your application is not thread safe any longer.

The python standard library comes with a utility called “thread locals”. A thread local is a global object where you can put stuff on and get back later in a thread safe way. That means whenever you set or get an object to / from a thread local object the thread local object checks in which thread you are and delivers the correct value.

This however has a few disadvantages. For example beside threads there are other ways to handle concurrency in Python. A very popular approach are greenlets. Also, whether every request gets its own thread is not guaranteed in WSGI. It could be that a request is reusing a thread from before and data is left in the thread local object.

### Nutshell

Here a simple example how you can use werkzeug.local:

    from werkzeug import Local, LocalManager

    local = Local()
    local_manager = LocalManager([local])

    def application(environ, start_response):
        local.request = request = Request(environ)
        ...

    application = local_manager.make_middleware(application)

Now what this code does is binding request to local.request. Every other piece of code executed after this assignment in the same context can safely access local.request and will get the same request object. The make_middleware method on the local manager ensures that everything is cleaned up after the request.

The same context means the same greenlet (if you’re using greenlets) in the same thread and same process.

If a request object is not yet set on the local object and you try to access it you will get an AttributeError. You can use getattr to avoid that:

    def get_request():
        return getattr(local, 'request', None)

This will try to get the request or return None if the request is not (yet?) available.

Note that local objects cannot manage themselves, for that you need a local manager. You can pass a local manager multiple locals or add additionals later by appending them to manager.locals and everytime the manager cleans up it will clean up all the data left in the locals for this context.

### Objects

class LocalManager

  Local objects cannot manage themselves. For that you need a local manager. You can pass a local manager multiple locals or add them later by appending them to manager.locals. Everytime the manager cleans up it, will clean up all the data left in the locals for this context.

  cleanup `()`
    Manually clean up the data in the locals for this context. Call this at the end of the request or use make_middleware().
  make_middleware `(app)`
    Wrap a WSGI application so that cleaning up happens after request end.
  middleware `(func)`

    Like make_middleware but for decorating functions.

    Example usage:

        @manager.middleware
        def application(environ, start_response):
            ...

    The difference to make_middleware is that the function passed will have all the arguments copied from the inner application (name, docstring, module).

  get_ident `()`
    Return the context identifier the local objects use internally for this context. You cannot override this method to change the behavior but use it to link other context local objects (such as SQLAlchemy’s scoped sessions) to the Werkzeug locals.

class LocalProxy

  Acts as a proxy for a werkzeug local. Forwards all operations to a proxied object. The only operations not supported for forwarding are right handed operands and any kind of assignment.

  Example usage:

      from werkzeug import Local
      l = Local()
      request = l('request')
      user = l('user')

  Whenever something is bound to l.user / l.request the proxy objects will forward all operations. If no object is bound a RuntimeError will be raised.

  _get_current_object `()`
    Return the current object. This is useful if you want the real object behind the proxy at a time for performance reasons or because you want to pass the object into a different context.

  Keep in mind that `repr()` is also forwarded, so if you want to find out if you are dealing with a proxy you can do an `isinstance()` check:

      >>> from werkzeug import LocalProxy
      >>> isinstance(request, LocalProxy)
      True

  You can also create proxy objects by hand:

      from werkzeug import Local, LocalProxy
      local = Local()
      request = LocalProxy(local, 'request')