def _sync_round_values(self):
    """
    Sync the current round step and cost.
    """
    self.set(ContextNames.CURRENT_ROUND_STEP, self.current_round_step)
    self.set(ContextNames.CURRENT_ROUND_COST, self.current_round_cost)
    self.set(
        ContextNames.CURRENT_ROUND_SUBTASK_AMOUNT, self.current_round_subtask_amount
    )

def add_to_structural_logs(self, data: Dict[str, Any]) -> None:
    """
    Add data to the structural logs.
    :param data: The data to add to the structural logs.
    """

    round_key = data.get("Round", None)
    subtask_key = data.get("SubtaskIndex", None)

    if round_key is None or subtask_key is None:
        return

    remaining_items = {key: data[key] for key in data}
    self._context[ContextNames.STRUCTURAL_LOGS.name][round_key][subtask_key].append(
        remaining_items
    )

def filter_structural_logs(
    self, round_key: int, subtask_key: int, keys: Union[str, List[str]]
) -> Union[List[Any], List[Dict[str, Any]]]:
    """
    Filter the structural logs.
    :param round_key: The round key.
    :param subtask_key: The subtask key.
    :param keys: The keys to filter.
    :return: The filtered structural logs.
    """

    structural_logs = self._context[ContextNames.STRUCTURAL_LOGS.name][round_key][
        subtask_key
    ]

    if isinstance(keys, str):
        return [log[keys] for log in structural_logs]
    elif isinstance(keys, list):
        return [{key: log[key] for key in keys} for log in structural_logs]
    else:
        raise TypeError(f"Keys should be a string or a list of strings.")

def from_dict(self, context_dict: Dict[str, Any]) -> None:
    """
    Load the context from a dictionary.
    :param context_dict: The dictionary of the context.
    """
    for key in ContextNames:
        if key.name in context_dict:
            self._context[key.name] = context_dict.get(key.name)

    # Sync the current round step and cost
    self._sync_round_values()

def get(self, key: ContextNames) -> Any:
    """
    Get the value from the context.
    :param key: The context name.
    :return: The value from the context.
    """
    # Sync the current round step and cost
    self._sync_round_values()
    return self._context.get(key.name)

def set(self, key: ContextNames, value: Any) -> None:
    """
    Set the value in the context.
    :param key: The context name.
    :param value: The value to set in the context.
    """
    if key.name in self._context:
        self._context[key.name] = value
        # Sync the current round step and cost
        if key == ContextNames.CURRENT_ROUND_STEP:
            self.current_round_step = value
        if key == ContextNames.CURRENT_ROUND_COST:
            self.current_round_cost = value
        if key == ContextNames.CURRENT_ROUND_SUBTASK_AMOUNT:
            self.current_round_subtask_amount = value
    else:
        raise KeyError(f"Key '{key}' is not a valid context name.")

def to_dict(self, ensure_serializable: bool = False) -> Dict[str, Any]:
    """
    Convert the context to a dictionary.
    :param ensure_serializable: Ensure the context is serializable.
    :return: The dictionary of the context.
    """

    import copy

    context_dict = copy.deepcopy(self._context)

    if ensure_serializable:

        for key in ContextNames:
            if key.name in context_dict:
                print_with_color(
                    f"Warn: The value of Context.{key.name} is not serializable.",
                    "yellow",
                )
                if not is_json_serializable(context_dict[key.name]):

                    context_dict[key.name] = None

    return context_dict

def update_dict(self, key: ContextNames, value: Dict[str, Any]) -> None:
    """
    Add a dictionary to a context key. The value and the context key should be dictionaries.
    :param key: The context key to update.
    :param value: The dictionary to add to the context key.
    """
    if key.name in self._context:
        context_value = self._context[key.name]
        if isinstance(value, dict) and isinstance(context_value, dict):
            self._context[key.name].update(value)
        else:
            raise TypeError(
                f"Value for key '{key.name}' is {key.value}, requires a dictionary."
            )
    else:
        raise KeyError(f"Key '{key.name}' is not a valid context name.")