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

snowflake/cli/api/commands/flags.py

@@ -15,19 +15,21 @@
 from __future__ import annotations
 
 import tempfile
-from dataclasses import dataclass
-from enum import Enum
-from inspect import signature
 from pathlib import Path
-from typing import Any, Callable, List, Optional, Tuple
+from typing import Any, Callable, Optional
 
 import click
 import typer
 from click import ClickException
-from snowflake.cli.api.cli_global_context import cli_context_manager
+from snowflake.cli.api.cli_global_context import 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.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
@@ -38,111 +40,6 @@ _CONNECTION_SECTION = "Connection configuration"
 _CLI_BEHAVIOUR = "Global configuration"
 
 
-class OnErrorType(Enum):
-    BREAK = "break"
-    CONTINUE = "continue"
-
-
-class OverrideableOption:
-    """
-    Class that allows you to generate instances of typer.models.OptionInfo with some default properties while allowing
-    specific values to be overridden.
-
-    Custom parameters:
-    - mutually_exclusive (Tuple[str]|List[str]): A list of parameter names that this Option is not compatible with. If this Option has
-     a truthy value and any of the other parameters in the mutually_exclusive list has a truthy value, a
-     ClickException will be thrown. Note that mutually_exclusive can contain an option's own name but does not require
-     it.
-    """
-
-    def __init__(
-        self,
-        default: Any,
-        *param_decls: str,
-        mutually_exclusive: Optional[List[str] | Tuple[str]] = None,
-        **kwargs,
-    ):
-        self.default = default
-        self.param_decls = param_decls
-        self.mutually_exclusive = mutually_exclusive
-        self.kwargs = kwargs
-
-    def __call__(self, **kwargs) -> typer.models.OptionInfo:
-        """
-        Returns a typer.models.OptionInfo instance initialized with the specified default values along with any overrides
-        from kwargs. Note that if you are overriding param_decls, you must pass an iterable of strings, you cannot use
-        positional arguments like you can with typer.Option. Does not modify the original instance.
-        """
-        default = kwargs.get("default", self.default)
-        param_decls = kwargs.get("param_decls", self.param_decls)
-        mutually_exclusive = kwargs.get("mutually_exclusive", self.mutually_exclusive)
-        if not isinstance(param_decls, list) and not isinstance(param_decls, tuple):
-            raise TypeError("param_decls must be a list or tuple")
-        passed_kwargs = self.kwargs.copy()
-        passed_kwargs.update(kwargs)
-        if passed_kwargs.get("callback", None) or mutually_exclusive:
-            passed_kwargs["callback"] = self._callback_factory(
-                passed_kwargs.get("callback", None), mutually_exclusive
-            )
-        for non_kwarg in ["default", "param_decls", "mutually_exclusive"]:
-            passed_kwargs.pop(non_kwarg, None)
-        return typer.Option(default, *param_decls, **passed_kwargs)
-
-    class InvalidCallbackSignature(ClickException):
-        def __init__(self, callback):
-            super().__init__(
-                f"Signature {signature(callback)} is not valid for an OverrideableOption callback function. Must have at most one parameter with each of the following types: (typer.Context, typer.CallbackParam, Any Other Type)"
-            )
-
-    def _callback_factory(
-        self, callback, mutually_exclusive: Optional[List[str] | Tuple[str]]
-    ):
-        callback = callback if callback else lambda x: x
-
-        # inspect existing_callback to make sure signature is valid
-        existing_params = signature(callback).parameters
-        # at most one parameter with each type in [typer.Context, typer.CallbackParam, any other type]
-        limits = [
-            lambda x: x == typer.Context,
-            lambda x: x == typer.CallbackParam,
-            lambda x: x != typer.Context and x != typer.CallbackParam,
-        ]
-        for limit in limits:
-            if len([v for v in existing_params.values() if limit(v.annotation)]) > 1:
-                raise self.InvalidCallbackSignature(callback)
-
-        def generated_callback(ctx: typer.Context, param: typer.CallbackParam, value):
-            if mutually_exclusive:
-                for name in mutually_exclusive:
-                    if value and ctx.params.get(
-                        name, False
-                    ):  # if the current parameter is set to True and a previous parameter is also Truthy
-                        curr_opt = param.opts[0]
-                        other_opt = [x for x in ctx.command.params if x.name == name][
-                            0
-                        ].opts[0]
-                        raise click.ClickException(
-                            f"Options '{curr_opt}' and '{other_opt}' are incompatible."
-                        )
-
-            # pass args to existing callback based on its signature (this is how Typer infers callback args)
-            passed_params = {}
-            for existing_param in existing_params:
-                annotation = existing_params[existing_param].annotation
-                if annotation == typer.Context:
-                    passed_params[existing_param] = ctx
-                elif annotation == typer.CallbackParam:
-                    passed_params[existing_param] = param
-                else:
-                    passed_params[existing_param] = value
-            return callback(**passed_params)
-
-        return generated_callback
-
-
-from snowflake.cli.api.config import get_all_connections
-
-
 def _callback(provide_setter: Callable[[], Callable[[Any], Any]]):
     def callback(value):
         set_value = provide_setter()
@@ -159,11 +56,11 @@ ConnectionOption = typer.Option(
     "--environment",
     help=f"Name of the connection, as defined in your `config.toml`. Default: `default`.",
     callback=_callback(
-        lambda: cli_context_manager.connection_context.set_connection_name
+        lambda: get_cli_context_manager().connection_context.set_connection_name
     ),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
-    autocompletion=lambda: list(get_all_connections()),
+    shell_complete=lambda _, __, ___: list(get_all_connections()),
 )
 
 TemporaryConnectionOption = typer.Option(
@@ -172,7 +69,7 @@ TemporaryConnectionOption = typer.Option(
     "-x",
     help="Uses connection defined with command line parameters, instead of one defined in config",
     callback=_callback(
-        lambda: cli_context_manager.connection_context.set_temporary_connection
+        lambda: get_cli_context_manager().connection_context.set_temporary_connection
     ),
     is_flag=True,
     rich_help_panel=_CONNECTION_SECTION,
@@ -183,7 +80,9 @@ AccountOption = typer.Option(
     "--account",
     "--accountname",
     help="Name assigned to your Snowflake account. Overrides the value specified for the connection.",
-    callback=_callback(lambda: cli_context_manager.connection_context.set_account),
+    callback=_callback(
+        lambda: get_cli_context_manager().connection_context.set_account
+    ),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
 )
@@ -193,7 +92,7 @@ UserOption = typer.Option(
     "--user",
     "--username",
     help="Username to connect to Snowflake. Overrides the value specified for the connection.",
-    callback=_callback(lambda: cli_context_manager.connection_context.set_user),
+    callback=_callback(lambda: get_cli_context_manager().connection_context.set_user),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
 )
@@ -206,7 +105,9 @@ def _password_callback(value: str):
     if value:
         cli_console.message(PLAIN_PASSWORD_MSG)
 
-    return _callback(lambda: cli_context_manager.connection_context.set_password)(value)
+    return _callback(lambda: get_cli_context_manager().connection_context.set_password)(
+        value
+    )
 
 
 PasswordOption = typer.Option(
@@ -225,7 +126,7 @@ AuthenticatorOption = typer.Option(
     help="Snowflake authenticator. Overrides the value specified for the connection.",
     hide_input=True,
     callback=_callback(
-        lambda: cli_context_manager.connection_context.set_authenticator
+        lambda: get_cli_context_manager().connection_context.set_authenticator
     ),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
@@ -233,11 +134,12 @@ AuthenticatorOption = typer.Option(
 
 PrivateKeyPathOption = typer.Option(
     None,
+    "--private-key-file",
     "--private-key-path",
-    help="Snowflake private key path. Overrides the value specified for the connection.",
+    help="Snowflake private key file path. Overrides the value specified for the connection.",
     hide_input=True,
     callback=_callback(
-        lambda: cli_context_manager.connection_context.set_private_key_path
+        lambda: get_cli_context_manager().connection_context.set_private_key_file
     ),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
@@ -252,7 +154,7 @@ SessionTokenOption = typer.Option(
     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: cli_context_manager.connection_context.set_session_token
+        lambda: get_cli_context_manager().connection_context.set_session_token
     ),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
@@ -267,7 +169,9 @@ 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: cli_context_manager.connection_context.set_master_token),
+    callback=_callback(
+        lambda: get_cli_context_manager().connection_context.set_master_token
+    ),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
     exists=True,
@@ -281,7 +185,7 @@ TokenFilePathOption = typer.Option(
     "--token-file-path",
     help="Path to file with an OAuth token that should be used when connecting to Snowflake",
     callback=_callback(
-        lambda: cli_context_manager.connection_context.set_token_file_path
+        lambda: get_cli_context_manager().connection_context.set_token_file_path
     ),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
@@ -295,7 +199,9 @@ DatabaseOption = typer.Option(
     "--database",
     "--dbname",
     help="Database to use. Overrides the value specified for the connection.",
-    callback=_callback(lambda: cli_context_manager.connection_context.set_database),
+    callback=_callback(
+        lambda: get_cli_context_manager().connection_context.set_database
+    ),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
 )
@@ -305,7 +211,7 @@ SchemaOption = typer.Option(
     "--schema",
     "--schemaname",
     help="Database schema to use. Overrides the value specified for the connection.",
-    callback=_callback(lambda: cli_context_manager.connection_context.set_schema),
+    callback=_callback(lambda: get_cli_context_manager().connection_context.set_schema),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
 )
@@ -315,7 +221,7 @@ RoleOption = typer.Option(
     "--role",
     "--rolename",
     help="Role to use. Overrides the value specified for the connection.",
-    callback=_callback(lambda: cli_context_manager.connection_context.set_role),
+    callback=_callback(lambda: get_cli_context_manager().connection_context.set_role),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
 )
@@ -324,7 +230,9 @@ WarehouseOption = typer.Option(
     None,
     "--warehouse",
     help="Warehouse to use. Overrides the value specified for the connection.",
-    callback=_callback(lambda: cli_context_manager.connection_context.set_warehouse),
+    callback=_callback(
+        lambda: get_cli_context_manager().connection_context.set_warehouse
+    ),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
 )
@@ -333,7 +241,9 @@ MfaPasscodeOption = typer.Option(
     None,
     "--mfa-passcode",
     help="Token to use for multi-factor authentication (MFA)",
-    callback=_callback(lambda: cli_context_manager.connection_context.set_mfa_passcode),
+    callback=_callback(
+        lambda: get_cli_context_manager().connection_context.set_mfa_passcode
+    ),
     prompt="MFA passcode",
     prompt_required=False,
     show_default=False,
@@ -344,18 +254,31 @@ EnableDiagOption = typer.Option(
     False,
     "--enable-diag",
     help="Run python connector diagnostic test",
-    callback=_callback(lambda: cli_context_manager.connection_context.set_enable_diag),
+    callback=_callback(
+        lambda: get_cli_context_manager().connection_context.set_enable_diag
+    ),
     show_default=False,
     is_flag=True,
     rich_help_panel=_CONNECTION_SECTION,
 )
 
+# Set default via callback to avoid including tempdir path in generated docs (snow --docs).
+# Use constant instead of None, as None is removed from telemetry data.
+_DIAG_LOG_DEFAULT_VALUE = "<temporary_directory>"
+
+
+def _diag_log_path_callback(path: str):
+    if path != _DIAG_LOG_DEFAULT_VALUE:
+        return path
+    return tempfile.gettempdir()
+
+
 DiagLogPathOption: Path = typer.Option(
-    tempfile.gettempdir(),
+    _DIAG_LOG_DEFAULT_VALUE,
     "--diag-log-path",
     help="Diagnostic report path",
     callback=_callback(
-        lambda: cli_context_manager.connection_context.set_diag_log_path
+        lambda: get_cli_context_manager().connection_context.set_diag_log_path
     ),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
@@ -368,7 +291,7 @@ DiagAllowlistPathOption: Path = typer.Option(
     "--diag-allowlist-path",
     help="Diagnostic report path to optional allowlist",
     callback=_callback(
-        lambda: cli_context_manager.connection_context.set_diag_allowlist_path
+        lambda: get_cli_context_manager().connection_context.set_diag_allowlist_path
     ),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
@@ -381,7 +304,7 @@ OutputFormatOption = typer.Option(
     "--format",
     help="Specifies the output format.",
     case_sensitive=False,
-    callback=_callback(lambda: cli_context_manager.set_output_format),
+    callback=_callback(lambda: get_cli_context_manager().set_output_format),
     rich_help_panel=_CLI_BEHAVIOUR,
 )
 
@@ -389,7 +312,7 @@ SilentOption = typer.Option(
     False,
     "--silent",
     help="Turns off intermediate output to console.",
-    callback=_callback(lambda: cli_context_manager.set_silent),
+    callback=_callback(lambda: get_cli_context_manager().set_silent),
     is_flag=True,
     rich_help_panel=_CLI_BEHAVIOUR,
     is_eager=True,
@@ -400,7 +323,7 @@ VerboseOption = typer.Option(
     "--verbose",
     "-v",
     help="Displays log entries for log levels `info` and higher.",
-    callback=_callback(lambda: cli_context_manager.set_verbose),
+    callback=_callback(lambda: get_cli_context_manager().set_verbose),
     is_flag=True,
     rich_help_panel=_CLI_BEHAVIOUR,
 )
@@ -409,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: cli_context_manager.set_enable_tracebacks),
+    callback=_callback(lambda: get_cli_context_manager().set_enable_tracebacks),
     is_flag=True,
     rich_help_panel=_CLI_BEHAVIOUR,
 )
@@ -450,6 +373,10 @@ OnErrorOption = typer.Option(
 NoInteractiveOption = typer.Option(False, "--no-interactive", help="Disable prompting.")
 
 
+def entity_argument(entity_type: str) -> typer.Argument:
+    return typer.Argument(None, help=f"ID of {entity_type} entity.")
+
+
 def variables_option(description: str):
     return typer.Option(
         None,
@@ -508,17 +435,46 @@ def experimental_option(
         "--experimental",
         help=help_text,
         hidden=True,
-        callback=_callback(lambda: cli_context_manager.set_experimental),
+        callback=_callback(lambda: get_cli_context_manager().set_experimental),
         is_flag=True,
         rich_help_panel=_CLI_BEHAVIOUR,
     )
 
 
-def identifier_argument(sf_object: str, example: str) -> typer.Argument:
+class IdentifierType(click.ParamType):
+    name = "TEXT"
+
+    def convert(self, value, param, ctx):
+        return FQN.from_string(value)
+
+
+class IdentifierStageType(click.ParamType):
+    name = "TEXT"
+
+    def convert(self, value, param, ctx):
+        return FQN.from_stage(value)
+
+
+def identifier_argument(
+    sf_object: str,
+    example: str,
+    click_type: click.ParamType = IdentifierType(),
+    callback: Callable | None = None,
+) -> typer.Argument:
     return typer.Argument(
         ...,
         help=f"Identifier of the {sf_object}. For example: {example}",
         show_default=False,
+        click_type=click_type,
+        callback=callback,
+    )
+
+
+def identifier_stage_argument(
+    sf_object: str, example: str, callback: Callable | None = None
+) -> typer.Argument:
+    return identifier_argument(
+        sf_object, example, click_type=IdentifierStageType(), callback=callback
     )
 
 
@@ -531,6 +487,7 @@ 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
 
@@ -551,7 +508,7 @@ def register_project_definition(is_optional: bool) -> None:
 
 def project_definition_option(is_optional: bool):
     def project_definition_callback(project_path: str) -> None:
-        cli_context_manager.set_project_path_arg(project_path)
+        get_cli_context_manager().set_project_path_arg(project_path)
         register_pre_execute_command(lambda: register_project_definition(is_optional))
 
     return typer.Option(
@@ -570,30 +527,17 @@ def project_env_overrides_option():
         env_overrides_args_map = {
             v.key: v.value for v in parse_key_value_variables(env_overrides_args_list)
         }
-        cli_context_manager.set_project_env_overrides_args(env_overrides_args_map)
+        get_cli_context_manager().set_project_env_overrides_args(env_overrides_args_map)
 
     return typer.Option(
         [],
         "--env",
-        help="String in format of key=value. Overrides variables from env section used for templating.",
+        help="String in format of key=value. Overrides variables from env section used for templates.",
         callback=_callback(lambda: project_env_overrides_callback),
         show_default=False,
     )
 
 
-def readable_file_option(param_name: str, help_str: str) -> typer.Option:
-    return typer.Option(
-        None,
-        param_name,
-        exists=True,
-        file_okay=True,
-        dir_okay=False,
-        readable=True,
-        help=help_str,
-        show_default=False,
-    )
-
-
 def deprecated_flag_callback(msg: str):
     def _warning_callback(ctx: click.Context, param: click.Parameter, value: Any):
         if ctx.get_parameter_source(param.name) != click.core.ParameterSource.DEFAULT:  # type: ignore[attr-defined]
@@ -612,29 +556,3 @@ def deprecated_flag_callback_enum(msg: str):
         return value.value
 
     return _warning_callback
-
-
-@dataclass
-class Variable:
-    key: str
-    value: str
-
-    def __init__(self, key: str, value: str):
-        self.key = key
-        self.value = value
-
-
-def parse_key_value_variables(variables: Optional[List[str]]) -> List[Variable]:
-    """Util for parsing key=value input. Useful for commands accepting multiple input options."""
-    if not variables:
-        return []
-    result: List[Variable] = []
-    if not variables:
-        return result
-    for p in variables:
-        if "=" not in p:
-            raise ClickException(f"Invalid variable: '{p}'")
-
-        key, value = p.split("=", 1)
-        result.append(Variable(key.strip(), value.strip()))
-    return result

snowflake/cli/api/commands/overrideable_parameter.py

@@ -0,0 +1,143 @@
+# 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
+
+from abc import ABC, abstractmethod
+from inspect import signature
+from typing import Any, List, Optional, Tuple
+
+import typer
+from click import ClickException
+from snowflake.cli.api.exceptions import IncompatibleParametersError
+
+
+class _OverrideableParameter(ABC):
+    """
+    Class that allows you to generate instances of typer.models.OptionInfo with some default properties while allowing
+    specific values to be overridden.
+
+    Custom parameters:
+    - mutually_exclusive (Tuple[str]|List[str]): A list of parameter names that this Option is not compatible with. If this Option has
+     a truthy value and any of the other parameters in the mutually_exclusive list has a truthy value, a
+     ClickException will be thrown. Note that mutually_exclusive can contain an option's own name but does not require
+     it.
+    """
+
+    def __init__(
+        self,
+        default: Any = ...,
+        *param_decls: str,
+        mutually_exclusive: Optional[List[str] | Tuple[str]] = None,
+        **kwargs,
+    ):
+        self.default = default
+        self.param_decls = param_decls
+        self.mutually_exclusive = mutually_exclusive
+        self.kwargs = kwargs
+
+    def __call__(self, **kwargs) -> typer.models.ParameterInfo:
+        """
+        Returns a typer.models.OptionInfo instance initialized with the specified default values along with any overrides
+        from kwargs. Note that if you are overriding param_decls, you must pass an iterable of strings, you cannot use
+        positional arguments like you can with typer.Option. Does not modify the original instance.
+        """
+        default = kwargs.get("default", self.default)
+        param_decls = kwargs.get("param_decls", self.param_decls)
+        mutually_exclusive = kwargs.get("mutually_exclusive", self.mutually_exclusive)
+        if not isinstance(param_decls, list) and not isinstance(param_decls, tuple):
+            raise TypeError("param_decls must be a list or tuple")
+        passed_kwargs = self.kwargs.copy()
+        passed_kwargs.update(kwargs)
+        if passed_kwargs.get("callback", None) or mutually_exclusive:
+            passed_kwargs["callback"] = self._callback_factory(
+                passed_kwargs.get("callback", None), mutually_exclusive
+            )
+        for non_kwarg in ["default", "param_decls", "mutually_exclusive"]:
+            passed_kwargs.pop(non_kwarg, None)
+
+        return self.get_parameter(default, *param_decls, **passed_kwargs)
+
+    @abstractmethod
+    def get_parameter(
+        self, default: Any = None, *param_decls: str, **kwargs
+    ) -> typer.models.ParameterInfo:
+        pass
+
+    class InvalidCallbackSignature(ClickException):
+        def __init__(self, callback):
+            super().__init__(
+                f"Signature {signature(callback)} is not valid for an OverrideableOption callback function. Must have "
+                f"at most one parameter with each of the following types: (typer.Context, typer.CallbackParam, "
+                f"Any Other Type)"
+            )
+
+    def _callback_factory(
+        self, callback, mutually_exclusive: Optional[List[str] | Tuple[str]]
+    ):
+        callback = callback if callback else lambda x: x
+
+        # inspect existing_callback to make sure signature is valid
+        existing_params = signature(callback).parameters
+        # at most one parameter with each type in [typer.Context, typer.CallbackParam, any other type]
+        limits = [
+            lambda x: x == typer.Context,
+            lambda x: x == typer.CallbackParam,
+            lambda x: x != typer.Context and x != typer.CallbackParam,
+        ]
+        for limit in limits:
+            if len([v for v in existing_params.values() if limit(v.annotation)]) > 1:
+                raise self.InvalidCallbackSignature(callback)
+
+        def generated_callback(ctx: typer.Context, param: typer.CallbackParam, value):
+            if mutually_exclusive:
+                for name in mutually_exclusive:
+                    if value and ctx.params.get(
+                        name, False
+                    ):  # if the current parameter is set to True and a previous parameter is also Truthy
+                        curr_opt = param.opts[0]
+                        other_opt = [x for x in ctx.command.params if x.name == name][
+                            0
+                        ].opts[0]
+                        raise IncompatibleParametersError([curr_opt, other_opt])
+
+            # pass args to existing callback based on its signature (this is how Typer infers callback args)
+            passed_params = {}
+            for existing_param in existing_params:
+                annotation = existing_params[existing_param].annotation
+                if annotation == typer.Context:
+                    passed_params[existing_param] = ctx
+                elif annotation == typer.CallbackParam:
+                    passed_params[existing_param] = param
+                else:
+                    passed_params[existing_param] = value
+            return callback(**passed_params)
+
+        return generated_callback
+
+
+class OverrideableArgument(_OverrideableParameter):
+    def get_parameter(
+        self, default: Any = ..., *param_decls: str, **kwargs
+    ) -> typer.models.ArgumentInfo:
+        return typer.Argument(default, *param_decls, **kwargs)
+
+
+# OverrideableOption doesn't work with flags with type List[Any] and default None, because typer executes the callback
+# function which converts the default value iterating over it, but None is not iterable.
+class OverrideableOption(_OverrideableParameter):
+    def get_parameter(
+        self, default: Any = ..., *param_decls: str, **kwargs
+    ) -> typer.models.OptionInfo:
+        return typer.Option(default, *param_decls, **kwargs)