Filtering and Combining Data in Jinja

In Jinja templates, you can dynamically filter dictionaries and combine them with new or existing data to construct customized structures. This is particularly useful when working with JSON objects that require modifications or additional attributes.

Filtering Data with dict_filter

The dict_filter filter allows you to extract specific key-value pairs from a dictionary based on the keys you want to keep.

Example: Filtering a Dictionary

Input:

{
  "request": {
   "body":{
    "userId": "12345",
    "userName": "john_doe",
    "email": "john@example.com",
    "status": "inactive"
   }
  }
}

Template:

{% set filtered_data = request.body | dict_filter("userId") -%}
{{ filtered_data | tojson }}

Result:

{
    "userId": "12345"
}

Explanation: The dict_filter("userId") extracts only the userId key and its value from the original dictionary.

Combining Data with combine

The combine filter merges two dictionaries into one. Keys from the second dictionary will overwrite keys in the first dictionary if they overlap.

Example: Adding New Key-Value Pairs

Building on the previous example, let's add a new key status with the value active to the filtered dictionary.

{% set filtered_data = request.body | dict_filter("userId") | combine({"status": "active"}) %}
{{ filtered_data | tojson }}

Result:

{
    "userId": "12345",
    "status": "active"
}

Explanation:

• dict_filter("userId"):
  • Filters the original dictionary to include only the userId key.
• combine({"status": "active"}):
  • Adds a new key-value pair to the filtered dictionary.

Advanced Example: Multiple filters and merges

You can combine multiple keys and dynamically add new ones. Template:

{% set filtered_data = request.body | dict_filter("userId", "email") | combine({"status": "active", "role": "admin"}) %}
{{ filtered_data | tojson }}

Output:

{
    "userId": "12345",
    "email": "john@example.com",
    "status": "active",
    "role": "admin"
}

Explanation:

• dict_filter("userId", "email"): extracts both userId and email from the original dictionary.
• combine({"status": "active", "role": "admin"}): adds two new key-value pairs.

Best Practices

• Order Matters:
  • Apply dict_filter first to reduce unnecessary data, then use combine to add or overwrite keys.
• Output Validation:
  • Use the | tojson filter to ensure the output is correctly formatted for downstream use.
• Reusability:
  • Store intermediate filtered data in a variable if you need to reuse it later in the template.
• Chaining:
  • Combine filtering, merging, and other transformations into a single pipeline for concise and efficient templates.

Summary

By leveraging dict_filter and combine, you can create tailored data structures dynamically in your Jinja templates. These filters are essential for workflows that require extracting and enhancing JSON objects on the fly.

Removing Attributes from a Dictionary

Jinja provides the pop method to remove attributes from a dictionary dynamically. This is particularly useful when you want to clean up a dictionary by removing specific keys based on conditions.

Example: Removing one Attribute

Input Data

{
  "test": {
    "k1": "hello",
    "k2": "world",
    "k3": "bla"
  }
}

Template

{% if test.k2 is defined -%}
    {% set _ = test.pop("k2") -%}
{% endif -%}
{{ test | pp_dict }}

Explanation

• Check if the Key Exists:

{% if test.k2 is defined -%}

This ensures the key k2 exists before attempting to remove it, preventing errors.

• Remove the Key Using pop:

{% set _ = test.pop("k2") -%}

The pop method removes the key k2 and its value (world) from the dictionary. The result is stored in _, which acts as a throwaway variable since the value is not needed.

• Output the Modified Dictionary:

{{ test | pp_dict }}

The pp_dict filter pretty-prints the dictionary for better readability.

Output

{
  "k1": "hello",
  "k3": "bla"
}