async def context_a(state: dict = Depends(get_state)):
    state["context_a"] = "started a"
    try:
        yield state
    finally:
        state["context_a"] = "finished a"


async def context_b(state: dict = Depends(context_a)):
    state["context_b"] = "started b"
    try:
        yield state
    finally:
        state["context_b"] = f"finished b with a: {state['context_a']}"

          ]
        }
      }
    }
  },
  "mappings": {
    "_source": {
      "excludes": [
        "content_ar",
        "content_bg",
        "content_bn",
        "content_ca",
        "content_ckb-iq",
        "content_cs",
        "content_da",
        "content_de",
        "content_el",
        "content_en",
        "content_en-ie",
        "content_es",

        assertEquals("aaa;ctx._source.title_ja=ctx._source.title;ctx._source.content_ja=ctx._source.content",
                languageHelper.createScript(doc, "aaa").getIdOrCode());
    }

    @Test
    public void test_getReindexScriptSource() {
        assertEquals(
                "if(ctx._source.lang!=null){ctx._source['title_'+ctx._source.lang]=ctx._source.title;ctx._source['content_'+ctx._source.lang]=ctx._source.content}",

            contexts[2] = new TestCreateContextResponse("CONTEXT3".getBytes(StandardCharsets.UTF_8));

            // Decode each context
            for (int i = 0; i < contexts.length; i++) {
                contexts[i].decode(buffer, i * 100, 50);
            }

            // Verify each context
            for (int i = 0; i < contexts.length; i++) {
                assertNotNull(contexts[i].getName());

        FessConfig fessConfig = ComponentUtil.getFessConfig();
        QueryContext context1 = new QueryContext("test", true);
        QueryContext context2 = new QueryContext("test", true);

        // Using template method
        QueryBuilder result1 = queryCommand.convertWithFieldCheck(fessConfig, context1, "title", "test", 1.0f,
                (field, boost) -> QueryBuilders.matchQuery(field, "test").boost(boost),

                                                     bool use_tfrt);

// Returns the context_id from the EagerContext which is used by the
// EagerService to maintain consistency between client and worker. The
// context_id is initialized with a dummy value and is later set when the worker
// is initialized (either locally or remotely). The context_id can change during
// the process lifetime although this should cause the worker to be

                testEncryptionKey, testDecryptionKey);

        // When/Then - Multiple closes should be safe
        assertDoesNotThrow(() -> {
            context.close();
            context.close();
            context.close();
        });

        assertTrue(context.isClosed());
    }

  virtual bool UsesTFRT() = 0;

  // List attributes of available devices
  virtual void ListDevices(std::vector<DeviceAttributes>* devices) = 0;

  // Add `devices` into context's device manager. Context's device manager
  // will take ownership and maintain devices' lifetime.
  virtual absl::Status AddDevices(
      std::vector<std::unique_ptr<Device>> devices) = 0;

                new DERTaggedObject(true, 1, new ASN1Integer(14)), // msg-type
        });

        // Create CONTEXT tagged object instead of APPLICATION
        DERTaggedObject contextTag = new DERTaggedObject(false, 14, apReqSequence);

        // Build inner content with OID and magic bytes
        ByteArrayOutputStream innerContent = new ByteArrayOutputStream();

```jinja hl_lines="7"
{!../../docs_src/templates/templates/item.html!}
```

### Valeurs de contexte du template { #template-context-values }

Dans le HTML qui contient :

{% raw %}

```jinja
Item ID: {{ id }}
```

{% endraw %}

... il affichera l’`id` récupéré à partir du `dict` « context » que vous avez passé :

```Python
{"id": id}
```

Par exemple, avec un ID de `42`, cela rendrait :