ContextRepo

def set_global(self, key: str, v: Any) -> None:
    """Sets a value in the global context.

    Args:
        key: The key to set in the global context.
        v: The value to set.

    Returns:
        None.
    """
    self._global_context[key] = v

def reset_global(self, key: str) -> None:
    """Resets a key in the global context.

    Args:
        key (str): The key to reset in the global context.

    Returns:
        None
    """
    self._global_context.pop(key, None)

def set_local(self, key: str, value: Any) -> "Token[Any]":
    """Set a local context variable.

    Args:
        key (str): The key for the context variable.
        value (T): The value to set for the context variable.

    Returns:
        Token[T]: A token representing the context variable.
    """
    context_var = self._scope_context.get(key)
    if context_var is None:
        context_var = ContextVar(key, default=EMPTY)
        self._scope_context[key] = context_var
    return context_var.set(value)

def reset_local(self, key: str, tag: "Token[Any]") -> None:
    """Resets the local context for a given key.

    Args:
        key (str): The key to reset the local context for.
        tag (Token[Any]): The tag associated with the local context.

    Returns:
        None
    """
    self._scope_context[key].reset(tag)

def get_local(self, key: str, default: Any = None) -> Any:
    """Get the value of a local variable.

    Args:
        key: The key of the local variable to retrieve.
        default: The default value to return if the local variable is not found.

    Returns:
        The value of the local variable.
    """
    value = default
    if (context_var := self._scope_context.get(key)) is not None and (
        context_value := context_var.get()
    ) is not EMPTY:
        value = context_value
    return value

@contextmanager
def scope(self, key: str, value: Any) -> Iterator[None]:
    """Sets a local variable and yields control to the caller. After the caller is done, the local variable is reset.

    Args:
        key: The key of the local variable
        value: The value to set the local variable to

    Yields:
        None

    Returns:
        An iterator that yields None
    """
    token = self.set_local(key, value)
    try:
        yield
    finally:
        self.reset_local(key, token)

def get(self, key: str, default: Any = None) -> Any:
    """Get the value associated with a key.

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

    Returns:
        The value associated with the key.
    """
    if (glob := self._global_context.get(key, EMPTY)) is EMPTY:
        return self.get_local(key, default)
    else:
        return glob

def resolve(self, argument: str) -> Any:
    """Resolve the context of an argument.

    Args:
        argument: A string representing the argument.

    Returns:
        The resolved context of the argument.

    Raises:
        AttributeError, KeyError: If the argument does not exist in the context.
    """
    first, *keys = argument.split(".")

    if (v := self.get(first, EMPTY)) is EMPTY:
        raise KeyError(f"`{self.context}` does not contains `{first}` key")

    for i in keys:
        v = v[i] if isinstance(v, Mapping) else getattr(v, i)

    return v

def clear(self) -> None:
    self._global_context = {"context": self}
    self._scope_context.clear()