snowflake-cli-labs 3.0.0rc1__py3-none-any.whl → 3.0.0rc2__py3-none-any.whl

snowflake/cli/api/commands/flags.py

@@ -21,18 +21,18 @@ from typing import Any, Callable, Optional
 import click
 import typer
 from click import ClickException
-from snowflake.cli.api.cli_global_context import get_cli_context_manager
+from snowflake.cli.api.cli_global_context import (
+    _CliGlobalContextManager,
+    get_cli_context_manager,
+)
 from snowflake.cli.api.commands.common import OnErrorType
 from snowflake.cli.api.commands.overrideable_parameter import OverrideableOption
-from snowflake.cli.api.commands.typer_pre_execute import register_pre_execute_command
 from snowflake.cli.api.commands.utils import parse_key_value_variables
 from snowflake.cli.api.config import get_all_connections
+from snowflake.cli.api.connections import ConnectionContext
 from snowflake.cli.api.console import cli_console
-from snowflake.cli.api.exceptions import MissingConfiguration
 from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.output.formats import OutputFormat
-from snowflake.cli.api.project.definition_manager import DefinitionManager
-from snowflake.cli.api.rendering.jinja import CONTEXT_KEY
 
 DEFAULT_CONTEXT_SETTINGS = {"help_option_names": ["--help", "-h"]}
 
@@ -40,10 +40,39 @@ _CONNECTION_SECTION = "Connection configuration"
 _CLI_BEHAVIOUR = "Global configuration"
 
 
-def _callback(provide_setter: Callable[[], Callable[[Any], Any]]):
+def _connection_callback(prop: str):
+    """Generates a setter for a field on the current context manager's connection context."""
+    if prop not in ConnectionContext.__dataclass_fields__:
+        raise KeyError(
+            f"Cannot generate setter for non-existent connection attr {prop}"
+        )
+
     def callback(value):
-        set_value = provide_setter()
-        set_value(value)
+        try:
+            if click.get_current_context().resilient_parsing:
+                return
+        except RuntimeError:
+            pass
+
+        setattr(get_cli_context_manager().connection_context, prop, value)
+        return value
+
+    return callback
+
+
+def _context_callback(prop: str):
+    """Generates a setter for a field on the current context manager."""
+    if prop not in _CliGlobalContextManager.__dataclass_fields__:
+        raise KeyError(f"Cannot generate setter for non-existent context attr {prop}")
+
+    def callback(value):
+        try:
+            if click.get_current_context().resilient_parsing:
+                return
+        except RuntimeError:
+            pass
+
+        setattr(get_cli_context_manager(), prop, value)
         return value
 
     return callback
@@ -55,9 +84,7 @@ ConnectionOption = typer.Option(
     "-c",
     "--environment",
     help=f"Name of the connection, as defined in your `config.toml`. Default: `default`.",
-    callback=_callback(
-        lambda: get_cli_context_manager().connection_context.set_connection_name
-    ),
+    callback=_connection_callback("connection_name"),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
     shell_complete=lambda _, __, ___: list(get_all_connections()),
@@ -68,9 +95,7 @@ TemporaryConnectionOption = typer.Option(
     "--temporary-connection",
     "-x",
     help="Uses connection defined with command line parameters, instead of one defined in config",
-    callback=_callback(
-        lambda: get_cli_context_manager().connection_context.set_temporary_connection
-    ),
+    callback=_connection_callback("temporary_connection"),
     is_flag=True,
     rich_help_panel=_CONNECTION_SECTION,
 )
@@ -80,9 +105,7 @@ AccountOption = typer.Option(
     "--account",
     "--accountname",
     help="Name assigned to your Snowflake account. Overrides the value specified for the connection.",
-    callback=_callback(
-        lambda: get_cli_context_manager().connection_context.set_account
-    ),
+    callback=_connection_callback("account"),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
 )
@@ -92,7 +115,7 @@ UserOption = typer.Option(
     "--user",
     "--username",
     help="Username to connect to Snowflake. Overrides the value specified for the connection.",
-    callback=_callback(lambda: get_cli_context_manager().connection_context.set_user),
+    callback=_connection_callback("user"),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
 )
@@ -105,9 +128,7 @@ def _password_callback(value: str):
     if value:
         cli_console.message(PLAIN_PASSWORD_MSG)
 
-    return _callback(lambda: get_cli_context_manager().connection_context.set_password)(
-        value
-    )
+    return _connection_callback("password")(value)
 
 
 PasswordOption = typer.Option(
@@ -125,9 +146,7 @@ AuthenticatorOption = typer.Option(
     "--authenticator",
     help="Snowflake authenticator. Overrides the value specified for the connection.",
     hide_input=True,
-    callback=_callback(
-        lambda: get_cli_context_manager().connection_context.set_authenticator
-    ),
+    callback=_connection_callback("authenticator"),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
 )
@@ -138,9 +157,7 @@ PrivateKeyPathOption = typer.Option(
     "--private-key-path",
     help="Snowflake private key file path. Overrides the value specified for the connection.",
     hide_input=True,
-    callback=_callback(
-        lambda: get_cli_context_manager().connection_context.set_private_key_file
-    ),
+    callback=_connection_callback("private_key_file"),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
     exists=True,
@@ -153,9 +170,7 @@ SessionTokenOption = typer.Option(
     "--session-token",
     help="Snowflake session token. Can be used only in conjunction with --master-token. Overrides the value specified for the connection.",
     hide_input=True,
-    callback=_callback(
-        lambda: get_cli_context_manager().connection_context.set_session_token
-    ),
+    callback=_connection_callback("session_token"),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
     exists=True,
@@ -169,9 +184,7 @@ MasterTokenOption = typer.Option(
     "--master-token",
     help="Snowflake master token. Can be used only in conjunction with --session-token. Overrides the value specified for the connection.",
     hide_input=True,
-    callback=_callback(
-        lambda: get_cli_context_manager().connection_context.set_master_token
-    ),
+    callback=_connection_callback("master_token"),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
     exists=True,
@@ -184,9 +197,7 @@ TokenFilePathOption = typer.Option(
     None,
     "--token-file-path",
     help="Path to file with an OAuth token that should be used when connecting to Snowflake",
-    callback=_callback(
-        lambda: get_cli_context_manager().connection_context.set_token_file_path
-    ),
+    callback=_connection_callback("token_file_path"),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
     exists=True,
@@ -199,9 +210,7 @@ DatabaseOption = typer.Option(
     "--database",
     "--dbname",
     help="Database to use. Overrides the value specified for the connection.",
-    callback=_callback(
-        lambda: get_cli_context_manager().connection_context.set_database
-    ),
+    callback=_connection_callback("database"),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
 )
@@ -211,7 +220,7 @@ SchemaOption = typer.Option(
     "--schema",
     "--schemaname",
     help="Database schema to use. Overrides the value specified for the connection.",
-    callback=_callback(lambda: get_cli_context_manager().connection_context.set_schema),
+    callback=_connection_callback("schema"),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
 )
@@ -221,7 +230,7 @@ RoleOption = typer.Option(
     "--role",
     "--rolename",
     help="Role to use. Overrides the value specified for the connection.",
-    callback=_callback(lambda: get_cli_context_manager().connection_context.set_role),
+    callback=_connection_callback("role"),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
 )
@@ -230,9 +239,7 @@ WarehouseOption = typer.Option(
     None,
     "--warehouse",
     help="Warehouse to use. Overrides the value specified for the connection.",
-    callback=_callback(
-        lambda: get_cli_context_manager().connection_context.set_warehouse
-    ),
+    callback=_connection_callback("warehouse"),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
 )
@@ -241,9 +248,7 @@ MfaPasscodeOption = typer.Option(
     None,
     "--mfa-passcode",
     help="Token to use for multi-factor authentication (MFA)",
-    callback=_callback(
-        lambda: get_cli_context_manager().connection_context.set_mfa_passcode
-    ),
+    callback=_connection_callback("mfa_passcode"),
     prompt="MFA passcode",
     prompt_required=False,
     show_default=False,
@@ -254,9 +259,7 @@ EnableDiagOption = typer.Option(
     False,
     "--enable-diag",
     help="Run python connector diagnostic test",
-    callback=_callback(
-        lambda: get_cli_context_manager().connection_context.set_enable_diag
-    ),
+    callback=_connection_callback("enable_diag"),
     show_default=False,
     is_flag=True,
     rich_help_panel=_CONNECTION_SECTION,
@@ -268,18 +271,17 @@ _DIAG_LOG_DEFAULT_VALUE = "<temporary_directory>"
 
 
 def _diag_log_path_callback(path: str):
-    if path != _DIAG_LOG_DEFAULT_VALUE:
-        return path
-    return tempfile.gettempdir()
+    if path == _DIAG_LOG_DEFAULT_VALUE:
+        path = tempfile.gettempdir()
+    get_cli_context_manager().connection_context.diag_log_path = Path(path)
+    return path
 
 
 DiagLogPathOption: Path = typer.Option(
     _DIAG_LOG_DEFAULT_VALUE,
     "--diag-log-path",
     help="Diagnostic report path",
-    callback=_callback(
-        lambda: get_cli_context_manager().connection_context.set_diag_log_path
-    ),
+    callback=_diag_log_path_callback,
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
     exists=True,
@@ -290,9 +292,7 @@ DiagAllowlistPathOption: Path = typer.Option(
     None,
     "--diag-allowlist-path",
     help="Diagnostic report path to optional allowlist",
-    callback=_callback(
-        lambda: get_cli_context_manager().connection_context.set_diag_allowlist_path
-    ),
+    callback=_connection_callback("diag_allowlist_path"),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
     exists=True,
@@ -304,7 +304,7 @@ OutputFormatOption = typer.Option(
     "--format",
     help="Specifies the output format.",
     case_sensitive=False,
-    callback=_callback(lambda: get_cli_context_manager().set_output_format),
+    callback=_context_callback("output_format"),
     rich_help_panel=_CLI_BEHAVIOUR,
 )
 
@@ -312,7 +312,7 @@ SilentOption = typer.Option(
     False,
     "--silent",
     help="Turns off intermediate output to console.",
-    callback=_callback(lambda: get_cli_context_manager().set_silent),
+    callback=_context_callback("silent"),
     is_flag=True,
     rich_help_panel=_CLI_BEHAVIOUR,
     is_eager=True,
@@ -323,7 +323,7 @@ VerboseOption = typer.Option(
     "--verbose",
     "-v",
     help="Displays log entries for log levels `info` and higher.",
-    callback=_callback(lambda: get_cli_context_manager().set_verbose),
+    callback=_context_callback("verbose"),
     is_flag=True,
     rich_help_panel=_CLI_BEHAVIOUR,
 )
@@ -332,7 +332,7 @@ DebugOption = typer.Option(
     False,
     "--debug",
     help="Displays log entries for log levels `debug` and higher; debug logs contains additional information.",
-    callback=_callback(lambda: get_cli_context_manager().set_enable_tracebacks),
+    callback=_context_callback("enable_tracebacks"),
     is_flag=True,
     rich_help_panel=_CLI_BEHAVIOUR,
 )
@@ -435,7 +435,7 @@ def experimental_option(
         "--experimental",
         help=help_text,
         hidden=True,
-        callback=_callback(lambda: get_cli_context_manager().set_experimental),
+        callback=_context_callback("experimental"),
         is_flag=True,
         rich_help_panel=_CLI_BEHAVIOUR,
     )
@@ -486,30 +486,12 @@ def execution_identifier_argument(sf_object: str, example: str) -> typer.Argumen
     )
 
 
-def register_project_definition(is_optional: bool) -> None:
-    cli_context_manager = get_cli_context_manager()
-    project_path = cli_context_manager.project_path_arg
-    env_overrides_args = cli_context_manager.project_env_overrides_args
-
-    dm = DefinitionManager(project_path, {CONTEXT_KEY: {"env": env_overrides_args}})
-    project_definition = dm.project_definition
-    project_root = dm.project_root
-    template_context = dm.template_context
-
-    if not dm.has_definition_file and not is_optional:
-        raise MissingConfiguration(
-            "Cannot find project definition (snowflake.yml). Please provide a path to the project or run this command in a valid project directory."
-        )
-
-    cli_context_manager.set_project_definition(project_definition)
-    cli_context_manager.set_project_root(project_root)
-    cli_context_manager.set_template_context(template_context)
-
-
 def project_definition_option(is_optional: bool):
-    def project_definition_callback(project_path: str) -> None:
-        get_cli_context_manager().set_project_path_arg(project_path)
-        register_pre_execute_command(lambda: register_project_definition(is_optional))
+    def project_path_callback(project_path: str) -> str:
+        ctx_mgr = get_cli_context_manager()
+        ctx_mgr.project_path_arg = project_path
+        ctx_mgr.project_is_optional = is_optional
+        return project_path
 
     return typer.Option(
         None,
@@ -517,23 +499,26 @@ def project_definition_option(is_optional: bool):
         "--project",
         help=f"Path where Snowflake project resides. "
         f"Defaults to current working directory.",
-        callback=_callback(lambda: project_definition_callback),
+        callback=project_path_callback,
         show_default=False,
     )
 
 
 def project_env_overrides_option():
-    def project_env_overrides_callback(env_overrides_args_list: list[str]) -> None:
+    def project_env_overrides_callback(
+        env_overrides_args_list: list[str],
+    ) -> dict[str, str]:
         env_overrides_args_map = {
             v.key: v.value for v in parse_key_value_variables(env_overrides_args_list)
         }
-        get_cli_context_manager().set_project_env_overrides_args(env_overrides_args_map)
+        get_cli_context_manager().project_env_overrides_args = env_overrides_args_map
+        return env_overrides_args_map
 
     return typer.Option(
         [],
         "--env",
         help="String in format of key=value. Overrides variables from env section used for templates.",
-        callback=_callback(lambda: project_env_overrides_callback),
+        callback=project_env_overrides_callback,
         show_default=False,
     )
 

snowflake/cli/api/commands/snow_typer.py

@@ -30,11 +30,11 @@ from snowflake.cli.api.commands.execution_metadata import (
     ExecutionStatus,
 )
 from snowflake.cli.api.commands.flags import DEFAULT_CONTEXT_SETTINGS
-from snowflake.cli.api.commands.typer_pre_execute import run_pre_execute_commands
 from snowflake.cli.api.exceptions import CommandReturnTypeError
 from snowflake.cli.api.output.types import CommandResult
 from snowflake.cli.api.sanitizers import sanitize_for_terminal
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
+from snowflake.connector import DatabaseError
 
 log = logging.getLogger(__name__)
 
@@ -107,8 +107,8 @@ class SnowTyper(typer.Typer):
                     execution.complete(ExecutionStatus.SUCCESS)
                 except Exception as err:
                     execution.complete(ExecutionStatus.FAILURE)
-                    self.exception_handler(err, execution)
-                    raise
+                    exception = self.exception_handler(err, execution)
+                    raise exception
                 finally:
                     self.post_execute(execution)
 
@@ -128,7 +128,6 @@ class SnowTyper(typer.Typer):
         from snowflake.cli._app.telemetry import log_command_usage
 
         log.debug("Executing command pre execution callback")
-        run_pre_execute_commands()
         log_command_usage(execution)
         if require_warehouse and not SqlExecutionMixin().session_has_warehouse():
             raise ClickException(
@@ -157,6 +156,9 @@ class SnowTyper(typer.Typer):
 
         log.debug("Executing command exception callback")
         log_command_execution_error(exception, execution)
+        if isinstance(exception, DatabaseError):
+            return ClickException(exception.msg)
+        return exception
 
     @staticmethod
     def post_execute(execution: ExecutionMetadata):

snowflake/cli/api/config.py

@@ -296,7 +296,7 @@ def _initialise_config(config_file: Path) -> None:
 
 
 def get_env_variable_name(*path, key: str) -> str:
-    return "SNOWFLAKE_" + "_".join(p.upper() for p in path) + f"_{key.upper()}"
+    return ("_".join(["snowflake", *path, key])).upper()
 
 
 def get_env_value(*path, key: str) -> str | None:

snowflake/cli/api/connections.py

@@ -0,0 +1,214 @@
+# Copyright (c) 2024 Snowflake Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import re
+import warnings
+from dataclasses import asdict, dataclass, field, fields, replace
+from pathlib import Path
+from typing import Optional
+
+from snowflake.cli.api.config import get_default_connection_name
+from snowflake.cli.api.exceptions import InvalidSchemaError
+from snowflake.connector import SnowflakeConnection
+from snowflake.connector.compat import IS_WINDOWS
+
+logger = logging.getLogger(__name__)
+
+schema_pattern = re.compile(r".+\..+")
+
+
+@dataclass
+class ConnectionContext:
+    # FIXME: can reduce duplication using config.ConnectionConfig
+    connection_name: Optional[str] = None
+    account: Optional[str] = None
+    database: Optional[str] = None
+    role: Optional[str] = None
+    schema: Optional[str] = None
+    user: Optional[str] = None
+    password: Optional[str] = field(default=None, repr=False)
+    authenticator: Optional[str] = None
+    private_key_file: Optional[str] = None
+    warehouse: Optional[str] = None
+    mfa_passcode: Optional[str] = None
+    enable_diag: Optional[bool] = False
+    diag_log_path: Optional[Path] = None
+    diag_allowlist_path: Optional[Path] = None
+    temporary_connection: bool = False
+    session_token: Optional[str] = None
+    master_token: Optional[str] = None
+    token_file_path: Optional[Path] = None
+
+    VALIDATED_FIELD_NAMES = ["schema"]
+
+    def present_values_as_dict(self) -> dict:
+        """Dictionary representation of this ConnectionContext for values that are not None"""
+        return {k: v for (k, v) in asdict(self).items() if v is not None}
+
+    def clone(self) -> ConnectionContext:
+        return replace(self)
+
+    def update(self, **updates):
+        """
+        Given a dictionary of property (key, value) mappings, update properties
+        of this context object with equivalent names to the keys.
+
+        Raises KeyError if a non-property is specified as a key.
+        """
+        field_map = {field.name: field for field in fields(self)}
+        for (key, value) in updates.items():
+            # ensure key represents a property
+            if key not in field_map:
+                raise KeyError(f"{key} is not a field of {self.__class__.__name__}")
+            setattr(self, key, value)
+
+    def __repr__(self) -> str:
+        """Minimal repr where None values have their keys omitted."""
+        items = [f"{k}={repr(v)}" for (k, v) in self.present_values_as_dict().items()]
+        return f"{self.__class__.__name__}({', '.join(items)})"
+
+    def __setattr__(self, prop, val):
+        """Runs registered validators before setting fields."""
+        if prop in self.VALIDATED_FIELD_NAMES:
+            validate = getattr(self, f"validate_{prop}")
+            validate(val)
+        super().__setattr__(prop, val)
+
+    def validate_schema(self, value: Optional[str]):
+        if (
+            value
+            and not (value.startswith('"') and value.endswith('"'))
+            # if schema is fully qualified name (db.schema)
+            and schema_pattern.match(value)
+        ):
+            raise InvalidSchemaError(value)
+
+    def validate_and_complete(self):
+        """
+        Ensure we can create a connection from this context.
+        """
+        if not self.temporary_connection and not self.connection_name:
+            self.connection_name = get_default_connection_name()
+
+    def build_connection(self):
+        from snowflake.cli._app.snow_connector import connect_to_snowflake
+
+        # Ignore warnings about bad owner or permissions on Windows
+        # Telemetry omit our warning filter from config.py
+        if IS_WINDOWS:
+            warnings.filterwarnings(
+                action="ignore",
+                message="Bad owner or permissions.*",
+                module="snowflake.connector.config_manager",
+            )
+
+        return connect_to_snowflake(**self.present_values_as_dict())
+
+
+class OpenConnectionCache:
+    """
+    A connection cache that transparently manages SnowflakeConnection objects
+    and is keyed by ConnectionContext objects, e.g. cache[ctx].execute_string(...).
+    Connections are automatically closed after CONNECTION_CLEANUP_SEC, but
+    are guaranteed to be open (if config is valid) when returned by the cache.
+    """
+
+    connections: dict[str, SnowflakeConnection]
+    cleanup_futures: dict[str, asyncio.TimerHandle]
+
+    CONNECTION_CLEANUP_SEC: float = 10.0 * 60
+    """Connections are closed this many seconds after the last time they are accessed."""
+
+    def __init__(self):
+        self.connections = {}
+        self.cleanup_futures = {}
+
+    def __getitem__(self, ctx):
+        if not isinstance(ctx, ConnectionContext):
+            raise ValueError(
+                f"Expected key to be ConnectionContext but got {repr(ctx)}"
+            )
+        key = repr(ctx)
+        if not self._has_open_connection(key):
+            self._insert(key, ctx)
+        self._touch(key)
+        return self.connections[key]
+
+    def clear(self):
+        """Closes all connections and resets the cache to its initial state."""
+        connection_keys = list(self.connections.keys())
+        for key in connection_keys:
+            self._cleanup(key)
+
+        # if any orphaned futures still exist, clean them up too
+        for future in self.cleanup_futures.values():
+            future.cancel()
+        self.cleanup_futures.clear()
+
+    def _has_open_connection(self, key: str):
+        return key in self.connections
+
+    def _insert(self, key: str, ctx: ConnectionContext):
+        try:
+            # N.B. build_connection ultimately calls connect_to_snowflake, which
+            # interpolates in connection dicts (from config) and environment variables.
+            # This means that we could return a stale (incorrect) connection for the
+            # given ConnectionContext if get_env_value or get_connection_dict would
+            # have returned different values (i.e. env / config have changed).
+            self.connections[key] = ctx.build_connection()
+        except Exception:
+            logger.debug(
+                "ConnectionCache: failed to connect using %s; not caching.", key
+            )
+            raise
+
+    def _cancel_cleanup_future_if_exists(self, key: str):
+        if key in self.cleanup_futures:
+            self.cleanup_futures.pop(key).cancel()
+
+    def _touch(self, key: str):
+        """
+        Extend the lifetime of the cached connection at the given key.
+        """
+        loop = None
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            # Python 3.11+ will throw when no event loop;
+            # Python 3.10 will issue a DeprecationWarning and return None
+            pass
+
+        if not loop:
+            logger.debug(
+                "ConnectionCache: no event loop; connections will close at exit."
+            )
+            return
+
+        self._cancel_cleanup_future_if_exists(key)
+        self.cleanup_futures[key] = loop.call_later(
+            self.CONNECTION_CLEANUP_SEC, lambda: self._cleanup(key)
+        )
+
+    def _cleanup(self, key: str):
+        """Closes the cached connection at the given key."""
+        if key not in self.connections:
+            logger.debug("Cleaning up connection %s, but not found in cache!", key)
+
+        # doesn't cancel in-flight async queries
+        self._cancel_cleanup_future_if_exists(key)
+        self.connections.pop(key).close()

snowflake/cli/api/console/abc.py

@@ -37,14 +37,16 @@ class AbstractConsole(ABC):
     """
 
     _print_fn: Callable[[str], None]
-    _cli_context: _CliGlobalContextAccess
     _in_phase: bool
 
     def __init__(self):
         super().__init__()
-        self._cli_context = get_cli_context()
         self._in_phase = False
 
+    @property
+    def _cli_context(self) -> _CliGlobalContextAccess:
+        return get_cli_context()
+
     @property
     def is_silent(self) -> bool:
         """Returns information whether intermediate output is muted."""