Skip to content

override_dictionary

apply_overrides_to_dictionary(dictionary, overrides)

Apply multiple CLI overrides to dictionary.

Why

Users need to test configuration changes without editing YAML files. Batching overrides ensures all modifications happen before validation, preventing partial invalid states.

Example 
data = {"cv": {"name": "John", "phone": "123"}}
overrides = {"cv.name": "Jane", "cv.phone": "456"}
result = apply_overrides_to_dictionary(data, overrides)
assert result["cv"]["name"] == "Jane"

Parameters:

  • dictionary (T) –

    Source dictionary to modify.

  • overrides (dict[str, str]) –

    Map of dotted paths to new values.

Returns:

  • T –

    Deep copy with all overrides applied.

Source code in src/rendercv/schema/override_dictionary.py 
 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
121
122
123
124
def apply_overrides_to_dictionary[T: dict](
    dictionary: T,
    overrides: dict[str, str],
) -> T:
    """Apply multiple CLI overrides to dictionary.

    Why:
        Users need to test configuration changes without editing YAML files.
        Batching overrides ensures all modifications happen before validation,
        preventing partial invalid states.

    Example:
        ```py
        data = {"cv": {"name": "John", "phone": "123"}}
        overrides = {"cv.name": "Jane", "cv.phone": "456"}
        result = apply_overrides_to_dictionary(data, overrides)
        assert result["cv"]["name"] == "Jane"
        ```

    Args:
        dictionary: Source dictionary to modify.
        overrides: Map of dotted paths to new values.

    Returns:
        Deep copy with all overrides applied.
    """
    new_dictionary = copy.deepcopy(dictionary)
    for key, value in overrides.items():
        new_dictionary = update_value_by_location(new_dictionary, key, value, key)

    return new_dictionary

update_value_by_location(dict_or_list, key, value, full_key)

Navigate nested structure via dotted path and update value.

Why

CLI overrides like --cv.sections.education.0.institution MIT must modify deeply nested YAML values without requiring users to edit files. Recursive traversal handles arbitrary nesting with proper index validation and error context.

Example 
data = {"cv": {"sections": {"education": [{"institution": "A"}]}}}
result = update_value_by_location(
    data,
    "cv.sections.education.0.institution",
    "MIT",
    "cv.sections.education.0.institution",
)
assert result["cv"]["sections"]["education"][0]["institution"] == "MIT"

Parameters:

  • dict_or_list (T) –

    Target structure to modify.

  • key (str) –

    Remaining path segments to traverse.

  • value (str) –

    Replacement value.

  • full_key (str) –

    Original full path for error messages.

Returns:

  • T –

    Modified structure.

Source code in src/rendercv/schema/override_dictionary.py 
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
def update_value_by_location[T: dict | list](
    dict_or_list: T,
    key: str,
    value: str,
    full_key: str,
) -> T:
    """Navigate nested structure via dotted path and update value.

    Why:
        CLI overrides like `--cv.sections.education.0.institution MIT`
        must modify deeply nested YAML values without requiring users
        to edit files. Recursive traversal handles arbitrary nesting
        with proper index validation and error context.

    Example:
        ```py
        data = {"cv": {"sections": {"education": [{"institution": "A"}]}}}
        result = update_value_by_location(
            data,
            "cv.sections.education.0.institution",
            "MIT",
            "cv.sections.education.0.institution",
        )
        assert result["cv"]["sections"]["education"][0]["institution"] == "MIT"
        ```

    Args:
        dict_or_list: Target structure to modify.
        key: Remaining path segments to traverse.
        value: Replacement value.
        full_key: Original full path for error messages.

    Returns:
        Modified structure.
    """
    keys = key.split(".")
    first_key: str | int = keys[0]
    remaining_key = ".".join(keys[1:])

    # Calculate the parent path for error messages
    processed_count = len(full_key.split(".")) - len(key.split("."))
    previous_key = (
        ".".join(full_key.split(".")[:processed_count]) if processed_count > 0 else ""
    )

    if isinstance(dict_or_list, list):
        try:
            first_key = int(first_key)
        except ValueError as e:
            message = (
                f"`{previous_key}` corresponds to a list, but `{keys[0]}` is not an"
                " integer."
            )
            raise RenderCVUserError(message) from e

        if first_key >= len(dict_or_list):
            message = (
                f"Index {first_key} is out of range for the list `{previous_key}`."
            )
            raise RenderCVUserError(message)
    elif not isinstance(dict_or_list, dict):
        message = (
            f"It seems like there's something wrong with `{full_key}`, but we don't"
            " know what it is."
        )
        raise RenderCVUserError(message)

    if len(keys) == 1:
        new_value = value
    else:
        if isinstance(dict_or_list, dict) and first_key not in dict_or_list:
            # Safe: isinstance above guarantees dict, but ty cannot narrow T:
            dict_or_list[first_key] = {}  # ty: ignore[invalid-assignment]

        new_value = update_value_by_location(
            # Safe: first_key is validated as int for list, str for dict above:
            dict_or_list[first_key],  # ty: ignore[invalid-argument-type]
            remaining_key,
            value,
            full_key=full_key,
        )

    # Safe: first_key type matches dict_or_list indexing per isinstance checks:
    dict_or_list[first_key] = new_value  # ty: ignore[invalid-assignment]

    return dict_or_list