Skip to content

render_context

Module handling rendering context variables (eg. for !expr and !j2)

context_providers: List[Union[Callable, List[ContextVar]]] = [base_provider, underscore_context_provider] module-attribute

Provides a list of context providers. See :func:get_render_context() for details

ContextVar

Bases: NamedTuple

A specification for a context variable used for rendering dynamic values.

Either if function is specified, we'll call the function to get the actual value.

Source code in gamma/config/render_context.py 
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class ContextVar(NamedTuple):
    """A specification for a context variable used for rendering dynamic values.

    Either if ``function`` is specified, we'll call the function to get the actual
    value.
    """

    name: str
    """The name of the variable"""

    value: Any = None
    """The value of the variable"""

    function: Optional[Callable[..., Any]] = None
    """Function to call to resolve the variable"""

    cacheable: bool = False
    """If True, will cache the function result, otherwise will call on each render."""

cacheable: bool = False class-attribute

If True, will cache the function result, otherwise will call on each render.

function: Optional[Callable[..., Any]] = None class-attribute

Function to call to resolve the variable

name: str class-attribute

The name of the variable

value: Any = None class-attribute

The value of the variable

base_provider(**kwargs)

Defaults to context

  • env -> os.environ
  • c -> the global RootConfig
Source code in gamma/config/render_context.py 
71
72
73
74
75
76
77
78
79
80
81
82
83
84
def base_provider(**kwargs):
    """Defaults to context

    - `env` -> os.environ
    - `c` -> the global RootConfig
    """
    import os

    from .globalconfig import get_config

    return [
        ContextVar("env", os.environ),
        ContextVar("c", function=partial(get_config, False)),
    ]

get_render_context(**kwargs)

Return the render context by calling each function in context_provider.

A context provider must be a function with the signature

(**kwargs) -> List[ContextVar]

or simply a list of ContextVar objects

The provided **kwargs are the same available in the render_node function

Source code in gamma/config/render_context.py 
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
def get_render_context(**kwargs):
    """Return the render context by calling each function in ``context_provider``.

    A context provider must be a function with the signature:
        `(**kwargs) -> List[ContextVar]`
    or simply a list of `ContextVar` objects

    The provided `**kwargs` are the same available in the `render_node` function
    """
    out = {}
    for provider in context_providers:
        var: ContextVar
        vars: List[ContextVar] = provider(**kwargs) if callable(provider) else provider
        for var in vars:
            if var.cacheable:
                cache_key = f"render_context/{var.name}"
                try:
                    out[var.name] = cache[cache_key]
                    continue
                except KeyError:
                    pass

            if var.function is not None:
                val = var.function()
            else:
                val = var.value

            if var.cacheable:
                cache[cache_key] = val

            out[var.name] = val

    return out

underscore_context_provider(*, config=None, **kwargs)

Look in parent config nodes and add all entries under the _context key

Source code in gamma/config/render_context.py 
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
def underscore_context_provider(*, config: ConfigNode = None, **kwargs):
    """Look in parent config nodes and add all entries under the `_context` key"""

    from .confignode import get_keys
    from .render import render_node

    if config is None:
        return []

    out = {}
    parents = set([config._node])

    cur = config

    while True:
        _context = cur.get("_context", None)

        if _context is not None and _context._node not in parents:
            for key in get_keys(_context):
                name = render_node(key)
                if name in out:
                    continue

                out[name] = ContextVar(
                    name, function=partial(_context.__getitem__, key)
                )

        cur = cur._parent
        if cur is None:
            break

        parents.add(cur._node)

    return list(out.values())