Request config

aiohttp/helpers.py

@@ -14,6 +14,7 @@
 import time
 import weakref
 from collections import namedtuple
+from collections.abc import Mapping
 from contextlib import suppress
 from math import ceil
 from pathlib import Path
@@ -741,3 +742,63 @@ def set_result(fut, result):
 def set_exception(fut, exc):
     if not fut.done():
         fut.set_exception(exc)
+
+
+class ChainedProps(Mapping):
+    __slots__ = ('_maps',)
+
+    def __init__(self, maps):
+        self._maps = tuple(maps)
+
+    def __getitem__(self, key):
+        for mapping in self._maps:
+            try:
+                return mapping[key]
+            except KeyError:
+                pass
+        raise KeyError(key)
+
+    def get(self, key, default=None):
+        return self[key] if key in self else default
+
+    def __len__(self):
+        # reuses stored hash values if possible
+        return len(set().union(*self._maps))
+
+    def __iter__(self):
+        d = {}
+        for mapping in reversed(self._maps):
+            # reuses stored hash values if possible
+            d.update(mapping)
+        return iter(d)
+
+    def __contains__(self, key):
+        return any(key in m for m in self._maps)
+
+    def __bool__(self):
+        return any(self._maps)
+
+    def __repr__(self):
+        content = ", ".join(map(repr, self._maps))
+        return 'ChainedProps({})'.format(content)
+
+
+class Namespace:
+    __slots__ = ('_mapping')
+
+    def __init__(self, mapping):
+        self._mapping = mapping
+
+    def __dir__(self):
+        return dir(self.__class__) + list(self._mapping.keys())
+
+    def __getattr__(self, name):
+        try:
+            return self._mapping[name]
+        except KeyError:
+            raise AttributeError(name)
+
+    def __repr__(self):
+        content = ", ".join('{}={!r}'.format(k, v)
+                            for k, v in self._mapping.items())
+        return 'Namespace({})'.format(content)

aiohttp/web_request.py

@@ -19,7 +19,8 @@
 from yarl import URL
 
 from . import hdrs, multipart
-from .helpers import DEBUG, HeadersMixin, reify, sentinel
+from .helpers import (DEBUG, ChainedProps, HeadersMixin, Namespace, reify,
+                      sentinel)
 from .streams import EmptyStreamReader
 from .web_exceptions import HTTPRequestEntityTooLarge
 
@@ -664,6 +665,18 @@ def app(self):
         """Application instance."""
         return self._match_info.current_app
 
+    @property
+    def config_dict(self):
+        lst = self._match_info.apps
+        app = self.app
+        idx = lst.index(app)
+        sublist = list(reversed(lst[:idx + 1]))
+        return ChainedProps(sublist)
+
+    @property
+    def config(self):
+        return Namespace(self.config_dict)
+
     async def _prepare_hook(self, response):
         match_info = self._match_info
         if match_info is None:

tests/test_helpers.py

@@ -547,3 +547,123 @@ async def test_set_exception_cancelled(loop):
 
     with pytest.raises(asyncio.CancelledError):
         await fut
+
+
+# ----------- ChainedProps --------------------------
+
+class TestChainedProps:
+    def test_getitem(self):
+        d1 = {'a': 2, 'b': 3}
+        d2 = {'a': 1}
+        cp = helpers.ChainedProps([d1, d2])
+        assert cp['a'] == 2
+        assert cp['b'] == 3
+
+    def test_getitem_not_found(self):
+        d = {'a': 1}
+        cp = helpers.ChainedProps([d])
+        with pytest.raises(KeyError):
+            cp['b']
+
+    def test_get(self):
+        d1 = {'a': 2, 'b': 3}
+        d2 = {'a': 1}
+        cp = helpers.ChainedProps([d1, d2])
+        assert cp.get('a') == 2
+
+    def test_get_default(self):
+        d1 = {'a': 2, 'b': 3}
+        d2 = {'a': 1}
+        cp = helpers.ChainedProps([d1, d2])
+        assert cp.get('c', 4) == 4
+
+    def test_get_non_default(self):
+        d1 = {'a': 2, 'b': 3}
+        d2 = {'a': 1}
+        cp = helpers.ChainedProps([d1, d2])
+        assert cp.get('a', 4) == 2
+
+    def test_len(self):
+        d1 = {'a': 2, 'b': 3}
+        d2 = {'a': 1}
+        cp = helpers.ChainedProps([d1, d2])
+        assert len(cp) == 2
+
+    def test_iter(self):
+        d1 = {'a': 2, 'b': 3}
+        d2 = {'a': 1}
+        cp = helpers.ChainedProps([d1, d2])
+        assert set(cp) == {'a', 'b'}
+
+    def test_contains(self):
+        d1 = {'a': 2, 'b': 3}
+        d2 = {'a': 1}
+        cp = helpers.ChainedProps([d1, d2])
+        assert 'a' in cp
+        assert 'b' in cp
+        assert 'c' not in cp
+
+    def test_bool(self):
+        assert helpers.ChainedProps([{'a': 1}])
+        assert not helpers.ChainedProps([{}, {}])
+        assert not helpers.ChainedProps([])
+
+    def test_repr(self):
+        d1 = {'a': 2, 'b': 3}
+        d2 = {'a': 1}
+        cp = helpers.ChainedProps([d1, d2])
+        assert "ChainedProps({'a': 2, 'b': 3}, {'a': 1})" == repr(cp)
+
+
+# ----------- Namespace --------------------------
+
+
+class TestNamespace:
+    def test_dir(self):
+        d = {'a': 1, 'b': 2}
+        ns = helpers.Namespace(d)
+        assert ['__class__',
+                '__delattr__',
+                '__dir__',
+                '__doc__',
+                '__eq__',
+                '__format__',
+                '__ge__',
+                '__getattr__',
+                '__getattribute__',
+                '__gt__',
+                '__hash__',
+                '__init__',
+                '__init_subclass__',
+                '__le__',
+                '__lt__',
+                '__module__',
+                '__ne__',
+                '__new__',
+                '__reduce__',
+                '__reduce_ex__',
+                '__repr__',
+                '__setattr__',
+                '__sizeof__',
+                '__slots__',
+                '__str__',
+                '__subclasshook__',
+                '_mapping',
+                'a',
+                'b'] == dir(ns)
+
+    def test_getattr_found(self):
+        d = {'a': 1, 'b': 2}
+        ns = helpers.Namespace(d)
+        assert 1 == ns.a
+
+    def test_getattr_not_found(self):
+        d = {'a': 1, 'b': 2}
+        ns = helpers.Namespace(d)
+        with pytest.raises(AttributeError):
+            ns.c
+
+    def test_repr(self):
+        d = {'a': 1, 'b': 2}
+        ns = helpers.Namespace(d)
+        assert 'Namespace(a=1, b=2)' == repr(ns)

tests/test_web_app.py

@@ -398,3 +398,116 @@ async def inner(app):
         await app.cleanup()
     assert "has more than one 'yield'" in str(ctx.value)
     assert out == ['pre_1', 'post_1']
+
+
+async def test_subapp_chained_config_dict_visibility(aiohttp_client):
+
+    async def main_handler(request):
+        assert request.config_dict['key1'] == 'val1'
+        assert 'key2' not in request.config_dict
+        return web.Response(status=200)
+
+    root = web.Application()
+    root['key1'] = 'val1'
+    root.add_routes([web.get('/', main_handler)])
+
+    async def sub_handler(request):
+        assert request.config_dict['key1'] == 'val1'
+        assert request.config_dict['key2'] == 'val2'
+        return web.Response(status=201)
+
+    sub = web.Application()
+    sub['key2'] = 'val2'
+    sub.add_routes([web.get('/', sub_handler)])
+    root.add_subapp('/sub', sub)
+
+    client = await aiohttp_client(root)
+
+    resp = await client.get('/')
+    assert resp.status == 200
+    resp = await client.get('/sub/')
+    assert resp.status == 201
+
+
+async def test_subapp_chained_config_dict_overriding(aiohttp_client):
+
+    async def main_handler(request):
+        assert request.config_dict['key'] == 'val1'
+        return web.Response(status=200)
+
+    root = web.Application()
+    root['key'] = 'val1'
+    root.add_routes([web.get('/', main_handler)])
+
+    async def sub_handler(request):
+        assert request.config_dict['key'] == 'val2'
+        return web.Response(status=201)
+
+    sub = web.Application()
+    sub['key'] = 'val2'
+    sub.add_routes([web.get('/', sub_handler)])
+    root.add_subapp('/sub', sub)
+
+    client = await aiohttp_client(root)
+
+    resp = await client.get('/')
+    assert resp.status == 200
+    resp = await client.get('/sub/')
+    assert resp.status == 201
+
+
+async def test_subapp_chained_config_visibility(aiohttp_client):
+
+    async def main_handler(request):
+        assert request.config.key1 == 'val1'
+        with pytest.raises(AttributeError):
+            request.config.key2
+        return web.Response(status=200)
+
+    root = web.Application()
+    root['key1'] = 'val1'
+    root.add_routes([web.get('/', main_handler)])
+
+    async def sub_handler(request):
+        assert request.config.key1 == 'val1'
+        assert request.config.key2 == 'val2'
+        return web.Response(status=201)
+
+    sub = web.Application()
+    sub['key2'] = 'val2'
+    sub.add_routes([web.get('/', sub_handler)])
+    root.add_subapp('/sub', sub)
+
+    client = await aiohttp_client(root)
+
+    resp = await client.get('/')
+    assert resp.status == 200
+    resp = await client.get('/sub/')
+    assert resp.status == 201
+
+
+async def test_subapp_chained_config_overriding(aiohttp_client):
+
+    async def main_handler(request):
+        assert request.config.key == 'val1'
+        return web.Response(status=200)
+
+    root = web.Application()
+    root['key'] = 'val1'
+    root.add_routes([web.get('/', main_handler)])
+
+    async def sub_handler(request):
+        assert request.config.key == 'val2'
+        return web.Response(status=201)
+
+    sub = web.Application()
+    sub['key'] = 'val2'
+    sub.add_routes([web.get('/', sub_handler)])
+    root.add_subapp('/sub', sub)
+
+    client = await aiohttp_client(root)
+
+    resp = await client.get('/')
+    assert resp.status == 200
+    resp = await client.get('/sub/')
+    assert resp.status == 201