ContextVariables

def get(self, key: str, default: Optional[Any] = None) -> Optional[Any]:
    """
    Get a value from the context by key.

    Args:
        key: The key to retrieve
        default: The default value to return if key is not found

    Returns:
        The value associated with the key or default if not found
    """
    return self.data.get(key, default)

def set(self, key: str, value: Any) -> None:
    """
    Set a value in the context by key.

    Args:
        key: The key to set
        value: The value to store
    """
    self.data[key] = value

def remove(self, key: str) -> bool:
    """
    Remove a key from the context.

    Args:
        key: The key to remove

    Returns:
        True if the key was removed, False if it didn't exist
    """
    if key in self.data:
        del self.data[key]
        return True
    return False

def keys(self) -> Iterable[str]:
    """
    Get all keys in the context.

    Returns:
        An iterable of all keys
    """
    return self.data.keys()

def values(self) -> Iterable[Any]:
    """
    Get all values in the context.

    Returns:
        An iterable of all values
    """
    return self.data.values()

def items(self) -> Iterable[tuple[str, Any]]:
    """
    Get all key-value pairs in the context.

    Returns:
        An iterable of all key-value pairs
    """
    return self.data.items()

def clear(self) -> None:
    """Clear all keys and values from the context."""
    self.data.clear()

def contains(self, key: str) -> bool:
    """
    Check if a key exists in the context.

    Args:
        key: The key to check

    Returns:
        True if the key exists, False otherwise
    """
    return key in self.data

def update(self, other: dict[str, Any]) -> None:
    """
    Update context with key-value pairs from another dictionary.

    Args:
        other: Dictionary containing key-value pairs to add
    """
    self.data.update(other)

def to_dict(self) -> dict[str, Any]:
    """
    Convert context variables to a dictionary.

    Returns:
        Dictionary representation of all context variables
    """
    return self.data.copy()

@classmethod
def from_dict(cls, data: dict[str, Any]) -> "ContextVariables":
    """
    Create a new ContextVariables instance from a dictionary.

    E.g.:
    my_context = {"user_id": "12345", "settings": {"theme": "dark"}}
    context = ContextVariables.from_dict(my_context)

    Args:
        data: Dictionary of key-value pairs

    Returns:
        New ContextVariables instance
    """
    return cls(data=data)