dbt-common 1.8.0__tar.gz → 1.10.0__tar.gz

{dbt_common-1.8.0 → dbt_common-1.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dbt-common
-Version: 1.8.0
+Version: 1.10.0
 Summary: The shared common utilities that dbt-core and adapter implementations use
 Project-URL: Homepage, https://github.com/dbt-labs/dbt-common
 Project-URL: Repository, https://github.com/dbt-labs/dbt-common.git

dbt_common-1.10.0/dbt_common/__about__.py

@@ -0,0 +1 @@
+version = "1.10.0"

{dbt_common-1.8.0 → dbt_common-1.10.0}/dbt_common/behavior_flags.py

@@ -9,8 +9,8 @@ except ImportError:
     from typing import Optional as NotRequired
 
 from dbt_common.events.functions import fire_event
-from dbt_common.events.types import BehaviorDeprecationEvent
-from dbt_common.exceptions import CompilationError
+from dbt_common.events.types import BehaviorChangeEvent
+from dbt_common.exceptions import CompilationError, DbtInternalError
 
 
 class BehaviorFlag(TypedDict):
@@ -20,16 +20,20 @@ class BehaviorFlag(TypedDict):
     Args:
         name: the name of the behavior flag
         default: default setting, starts as False, becomes True after a bake-in period
-        deprecation_version: the version when the default will change to True
-        deprecation_message: an additional message to send when the flag evaluates to False
+        description: an additional message to send when the flag evaluates to False
         docs_url: the url to the relevant docs on docs.getdbt.com
+
+    *Note*:
+        While `description` and `docs_url` are both listed as `NotRequired`, at least one of them is required.
+        This is validated when the flag is rendered in `BehaviorFlagRendered` below.
+        The goal of this restriction is to provide the end user with context so they can make an informed decision
+        about if, and when, to enable the behavior flag.
     """
 
     name: str
     default: bool
     source: NotRequired[str]
-    deprecation_version: NotRequired[str]
-    deprecation_message: NotRequired[str]
+    description: NotRequired[str]
     docs_url: NotRequired[str]
 
 
@@ -42,15 +46,37 @@ class BehaviorFlagRendered:
         user_overrides: a set of user settings, one of which may be an override on this behavior flag
     """
 
+    fired: bool = False
+
     def __init__(self, flag: BehaviorFlag, user_overrides: Dict[str, Any]) -> None:
+        self._validate(flag)
+
         self.name = flag["name"]
         self.setting = user_overrides.get(flag["name"], flag["default"])
-        self.deprecation_event = self._deprecation_event(flag)
+
+        default_description = (
+            f"""The behavior controlled by `{flag["name"]}` is currently turned off.\n"""
+        )
+        default_docs_url = "https://docs.getdbt.com/reference/global-configs/behavior-changes"
+        self._behavior_change_event = BehaviorChangeEvent(
+            flag_name=flag["name"],
+            flag_source=flag.get("source", self._default_source()),
+            description=flag.get("description", default_description),
+            docs_url=flag.get("docs_url", default_docs_url),
+        )
+
+    @staticmethod
+    def _validate(flag: BehaviorFlag) -> None:
+        if flag.get("description") is None and flag.get("docs_url") is None:
+            raise DbtInternalError(
+                "Behavior change flags require at least one of `description` and `docs_url`."
+            )
 
     @property
     def setting(self) -> bool:
-        if self._setting is False:
-            fire_event(self.deprecation_event)
+        if self._setting is False and not self.fired:
+            fire_event(self._behavior_change_event)
+            self.fired = True
         return self._setting
 
     @setting.setter
@@ -61,15 +87,6 @@ class BehaviorFlagRendered:
     def no_warn(self) -> bool:
         return self._setting
 
-    def _deprecation_event(self, flag: BehaviorFlag) -> BehaviorDeprecationEvent:
-        return BehaviorDeprecationEvent(
-            flag_name=flag["name"],
-            flag_source=flag.get("source", self._default_source()),
-            deprecation_version=flag.get("deprecation_version"),
-            deprecation_message=flag.get("deprecation_message"),
-            docs_url=flag.get("docs_url"),
-        )
-
     @staticmethod
     def _default_source() -> str:
         """
@@ -95,7 +112,7 @@ class Behavior:
         if adapter.behavior.my_flag:
             ...
 
-        if adapter.behavior.my_flag.no_warn:  # this will not fire the deprecation event
+        if adapter.behavior.my_flag.no_warn:  # this will not fire the behavior change event
             ...
         ```
         ```jinja
@@ -103,7 +120,7 @@ class Behavior:
             ...
         {% endif %}
 
-        {% if adapter.behavior.my_flag.no_warn %}  {# this will not fire the deprecation event #}
+        {% if adapter.behavior.my_flag.no_warn %}  {# this will not fire the behavior change event #}
             ...
         {% endif %}
         ```

{dbt_common-1.8.0 → dbt_common-1.10.0}/dbt_common/clients/jinja.py

@@ -6,7 +6,21 @@ from ast import literal_eval
 from collections import ChainMap
 from contextlib import contextmanager
 from itertools import chain, islice
-from typing import Any, Callable, Dict, Iterator, List, Mapping, Optional, Union, Set, Type
+from types import CodeType
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Iterator,
+    List,
+    Mapping,
+    Optional,
+    Union,
+    Set,
+    Type,
+    NoReturn,
+)
+
 from typing_extensions import Protocol
 
 import jinja2
@@ -39,10 +53,17 @@ from dbt_common.exceptions.macros import MacroReturn, UndefinedMacroError, Caugh
 SUPPORTED_LANG_ARG = jinja2.nodes.Name("supported_languages", "param")
 
 # Global which can be set by dependents of dbt-common (e.g. core via flag parsing)
-MACRO_DEBUGGING = False
+MACRO_DEBUGGING: Union[str, bool] = False
+
+_ParseReturn = Union[jinja2.nodes.Node, List[jinja2.nodes.Node]]
+
+
+# Temporary type capturing the concept the functions in this file expect for a "node"
+class _NodeProtocol(Protocol):
+    pass
 
 
-def _linecache_inject(source, write):
+def _linecache_inject(source: str, write: bool) -> str:
     if write:
         # this is the only reliable way to accomplish this. Obviously, it's
         # really darn noisy and will fill your temporary directory
@@ -58,18 +79,18 @@ def _linecache_inject(source, write):
     else:
         # `codecs.encode` actually takes a `bytes` as the first argument if
         # the second argument is 'hex' - mypy does not know this.
-        rnd = codecs.encode(os.urandom(12), "hex")  # type: ignore
+        rnd = codecs.encode(os.urandom(12), "hex")
         filename = rnd.decode("ascii")
 
     # put ourselves in the cache
     cache_entry = (len(source), None, [line + "\n" for line in source.splitlines()], filename)
     # linecache does in fact have an attribute `cache`, thanks
-    linecache.cache[filename] = cache_entry  # type: ignore
+    linecache.cache[filename] = cache_entry
     return filename
 
 
 class MacroFuzzParser(jinja2.parser.Parser):
-    def parse_macro(self):
+    def parse_macro(self) -> jinja2.nodes.Macro:
         node = jinja2.nodes.Macro(lineno=next(self.stream).lineno)
 
         # modified to fuzz macros defined in the same file. this way
@@ -83,16 +104,13 @@ class MacroFuzzParser(jinja2.parser.Parser):
 
 
 class MacroFuzzEnvironment(jinja2.sandbox.SandboxedEnvironment):
-    def _parse(self, source, name, filename):
+    def _parse(
+        self, source: str, name: Optional[str], filename: Optional[str]
+    ) -> jinja2.nodes.Template:
         return MacroFuzzParser(self, source, name, filename).parse()
 
-    def _compile(self, source, filename):
+    def _compile(self, source: str, filename: str) -> CodeType:
         """
-
-
-
-
-
         Override jinja's compilation. Use to stash the rendered source inside
         the python linecache for debugging when the appropriate environment
         variable is set.
@@ -108,7 +126,7 @@ class MacroFuzzEnvironment(jinja2.sandbox.SandboxedEnvironment):
 
 
 class MacroFuzzTemplate(jinja2.nativetypes.NativeTemplate):
-    environment_class = MacroFuzzEnvironment
+    environment_class = MacroFuzzEnvironment  # type: ignore
 
     def new_context(
         self,
@@ -171,11 +189,11 @@ class NumberMarker(NativeMarker):
     pass
 
 
-def _is_number(value) -> bool:
+def _is_number(value: Any) -> bool:
     return isinstance(value, (int, float)) and not isinstance(value, bool)
 
 
-def quoted_native_concat(nodes):
+def quoted_native_concat(nodes: Iterator[str]) -> Any:
     """Handle special case for native_concat from the NativeTemplate.
 
     This is almost native_concat from the NativeTemplate, except in the
@@ -213,7 +231,7 @@ def quoted_native_concat(nodes):
 class NativeSandboxTemplate(jinja2.nativetypes.NativeTemplate):  # mypy: ignore
     environment_class = NativeSandboxEnvironment  # type: ignore
 
-    def render(self, *args, **kwargs):
+    def render(self, *args: Any, **kwargs: Any) -> Any:
         """Render the template to produce a native Python type.
 
         If the result is a single node, its value is returned. Otherwise,
@@ -229,6 +247,11 @@ class NativeSandboxTemplate(jinja2.nativetypes.NativeTemplate):  # mypy: ignore
             return self.environment.handle_exception()
 
 
+class MacroProtocol(Protocol):
+    name: str
+    macro_sql: str
+
+
 NativeSandboxEnvironment.template_class = NativeSandboxTemplate  # type: ignore
 
 
@@ -236,7 +259,7 @@ class TemplateCache:
     def __init__(self) -> None:
         self.file_cache: Dict[str, jinja2.Template] = {}
 
-    def get_node_template(self, node) -> jinja2.Template:
+    def get_node_template(self, node: MacroProtocol) -> jinja2.Template:
         key = node.macro_sql
 
         if key in self.file_cache:
@@ -251,7 +274,7 @@ class TemplateCache:
         self.file_cache[key] = template
         return template
 
-    def clear(self):
+    def clear(self) -> None:
         self.file_cache.clear()
 
 
@@ -262,13 +285,13 @@ class BaseMacroGenerator:
     def __init__(self, context: Optional[Dict[str, Any]] = None) -> None:
         self.context: Optional[Dict[str, Any]] = context
 
-    def get_template(self):
+    def get_template(self) -> jinja2.Template:
         raise NotImplementedError("get_template not implemented!")
 
     def get_name(self) -> str:
         raise NotImplementedError("get_name not implemented!")
 
-    def get_macro(self):
+    def get_macro(self) -> Callable:
         name = self.get_name()
         template = self.get_template()
         # make the module. previously we set both vars and local, but that's
@@ -286,7 +309,7 @@ class BaseMacroGenerator:
         except (TypeError, jinja2.exceptions.TemplateRuntimeError) as e:
             raise CaughtMacroError(e)
 
-    def call_macro(self, *args, **kwargs):
+    def call_macro(self, *args: Any, **kwargs: Any) -> Any:
         # called from __call__ methods
         if self.context is None:
             raise DbtInternalError("Context is still None in call_macro!")
@@ -301,11 +324,6 @@ class BaseMacroGenerator:
                 return e.value
 
 
-class MacroProtocol(Protocol):
-    name: str
-    macro_sql: str
-
-
 class CallableMacroGenerator(BaseMacroGenerator):
     def __init__(
         self,
@@ -315,7 +333,7 @@ class CallableMacroGenerator(BaseMacroGenerator):
         super().__init__(context)
         self.macro = macro
 
-    def get_template(self):
+    def get_template(self) -> jinja2.Template:
         return template_cache.get_node_template(self.macro)
 
     def get_name(self) -> str:
@@ -332,14 +350,14 @@ class CallableMacroGenerator(BaseMacroGenerator):
             raise e
 
     # this makes MacroGenerator objects callable like functions
-    def __call__(self, *args, **kwargs):
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
         return self.call_macro(*args, **kwargs)
 
 
 class MaterializationExtension(jinja2.ext.Extension):
     tags = ["materialization"]
 
-    def parse(self, parser):
+    def parse(self, parser: jinja2.parser.Parser) -> _ParseReturn:
         node = jinja2.nodes.Macro(lineno=next(parser.stream).lineno)
         materialization_name = parser.parse_assign_target(name_only=True).name
 
@@ -382,7 +400,7 @@ class MaterializationExtension(jinja2.ext.Extension):
 class DocumentationExtension(jinja2.ext.Extension):
     tags = ["docs"]
 
-    def parse(self, parser):
+    def parse(self, parser: jinja2.parser.Parser) -> _ParseReturn:
         node = jinja2.nodes.Macro(lineno=next(parser.stream).lineno)
         docs_name = parser.parse_assign_target(name_only=True).name
 
@@ -396,7 +414,7 @@ class DocumentationExtension(jinja2.ext.Extension):
 class TestExtension(jinja2.ext.Extension):
     tags = ["test"]
 
-    def parse(self, parser):
+    def parse(self, parser: jinja2.parser.Parser) -> _ParseReturn:
         node = jinja2.nodes.Macro(lineno=next(parser.stream).lineno)
         test_name = parser.parse_assign_target(name_only=True).name
 
@@ -406,13 +424,19 @@ class TestExtension(jinja2.ext.Extension):
         return node
 
 
-def _is_dunder_name(name):
+def _is_dunder_name(name: str) -> bool:
     return name.startswith("__") and name.endswith("__")
 
 
-def create_undefined(node=None):
+def create_undefined(node: Optional[_NodeProtocol] = None) -> Type[jinja2.Undefined]:
     class Undefined(jinja2.Undefined):
-        def __init__(self, hint=None, obj=None, name=None, exc=None):
+        def __init__(
+            self,
+            hint: Optional[str] = None,
+            obj: Any = None,
+            name: Optional[str] = None,
+            exc: Any = None,
+        ) -> None:
             super().__init__(hint=hint, name=name)
             self.node = node
             self.name = name
@@ -422,12 +446,12 @@ def create_undefined(node=None):
             self.unsafe_callable = False
             self.alters_data = False
 
-        def __getitem__(self, name):
+        def __getitem__(self, name: Any) -> "Undefined":
             # Propagate the undefined value if a caller accesses this as if it
             # were a dictionary
             return self
 
-        def __getattr__(self, name):
+        def __getattr__(self, name: str) -> "Undefined":
             if name == "name" or _is_dunder_name(name):
                 raise AttributeError(
                     "'{}' object has no attribute '{}'".format(type(self).__name__, name)
@@ -437,11 +461,11 @@ def create_undefined(node=None):
 
             return self.__class__(hint=self.hint, name=self.name)
 
-        def __call__(self, *args, **kwargs):
+        def __call__(self, *args: Any, **kwargs: Any) -> "Undefined":
             return self
 
-        def __reduce__(self):
-            raise UndefinedCompilationError(name=self.name, node=node)
+        def __reduce__(self) -> NoReturn:
+            raise UndefinedCompilationError(name=self.name or "unknown", node=node)
 
     return Undefined
 
@@ -463,7 +487,7 @@ TEXT_FILTERS: Dict[str, Callable[[Any], Any]] = {
 
 
 def get_environment(
-    node=None,
+    node: Optional[_NodeProtocol] = None,
     capture_macros: bool = False,
     native: bool = False,
 ) -> jinja2.Environment:
@@ -472,7 +496,7 @@ def get_environment(
     }
 
     if capture_macros:
-        args["undefined"] = create_undefined(node)
+        args["undefined"] = create_undefined(node)  # type: ignore
 
     args["extensions"].append(MaterializationExtension)
     args["extensions"].append(DocumentationExtension)
@@ -493,7 +517,7 @@ def get_environment(
 
 
 @contextmanager
-def catch_jinja(node=None) -> Iterator[None]:
+def catch_jinja(node: Optional[_NodeProtocol] = None) -> Iterator[None]:
     try:
         yield
     except jinja2.exceptions.TemplateSyntaxError as e:
@@ -506,16 +530,16 @@ def catch_jinja(node=None) -> Iterator[None]:
         raise
 
 
-_TESTING_PARSE_CACHE: Dict[str, jinja2.Template] = {}
+_TESTING_PARSE_CACHE: Dict[str, jinja2.nodes.Template] = {}
 
 
-def parse(string):
+def parse(string: Any) -> jinja2.nodes.Template:
     str_string = str(string)
     if test_caching_enabled() and str_string in _TESTING_PARSE_CACHE:
         return _TESTING_PARSE_CACHE[str_string]
 
     with catch_jinja():
-        parsed = get_environment().parse(str(string))
+        parsed: jinja2.nodes.Template = get_environment().parse(str(string))
         if test_caching_enabled():
             _TESTING_PARSE_CACHE[str_string] = parsed
         return parsed
@@ -524,10 +548,10 @@ def parse(string):
 def get_template(
     string: str,
     ctx: Dict[str, Any],
-    node=None,
+    node: Optional[_NodeProtocol] = None,
     capture_macros: bool = False,
     native: bool = False,
-):
+) -> jinja2.Template:
     with catch_jinja(node):
         env = get_environment(node, capture_macros, native=native)
 
@@ -535,7 +559,9 @@ def get_template(
         return env.from_string(template_source, globals=ctx)
 
 
-def render_template(template, ctx: Dict[str, Any], node=None) -> str:
+def render_template(
+    template: jinja2.Template, ctx: Dict[str, Any], node: Optional[_NodeProtocol] = None
+) -> str:
     with catch_jinja(node):
         return template.render(ctx)
 

{dbt_common-1.8.0 → dbt_common-1.10.0}/dbt_common/contracts/config/base.py

@@ -96,10 +96,14 @@ class BaseConfig(AdditionalPropertiesAllowed, Replaceable):
                     return False
         return True
 
-    # This is used in 'add_config_call' to create the combined config_call_dict.
-    # 'meta' moved here from node
+    # This is used in 'merge_config_dicts' to create the combined orig_dict.
+    # Note: "clobber" fields aren't defined, because that's the default.
+    #    "access" is currently the only Clobber field.
+    # This shouldn't really be defined  here. It would be better to have it
+    # associated with the config definitions, but at the point we use it, we
+    # don't know which config we're dealing with.
     mergebehavior = {
-        "append": ["pre-hook", "pre_hook", "post-hook", "post_hook", "tags"],
+        "append": ["pre-hook", "pre_hook", "post-hook", "post_hook", "tags", "packages"],
         "update": [
             "quoting",
             "column_types",
@@ -108,6 +112,7 @@ class BaseConfig(AdditionalPropertiesAllowed, Replaceable):
             "contract",
         ],
         "dict_key_append": ["grants"],
+        "object": ["snapshot_meta_column_names"],
     }
 
     @classmethod
@@ -180,6 +185,7 @@ class MergeBehavior(Metadata):
     Update = 2
     Clobber = 3
     DictKeyAppend = 4
+    Object = 5
 
     @classmethod
     def default_field(cls) -> "MergeBehavior":
@@ -215,8 +221,10 @@ def _listify(value: Any) -> List[Any]:
 
 
 # There are two versions of this code. The one here is for config
-# objects, the one in _add_config_call in core context_config.py is for
-# config_call_dict dictionaries.
+# objects which can get the "MergeBehavior" from the field in the class,
+# the one below in 'merge_config_dicts' (formerly in
+# _add_config_call in core context_config.py) is for config_call dictionaries
+# where we need to get the MergeBehavior from someplace else.
 def _merge_field_value(
     merge_behavior: MergeBehavior,
     self_value: Any,
@@ -225,7 +233,8 @@ def _merge_field_value(
     if merge_behavior == MergeBehavior.Clobber:
         return other_value
     elif merge_behavior == MergeBehavior.Append:
-        return _listify(self_value) + _listify(other_value)
+        new_value = _listify(self_value) + _listify(other_value)
+        return new_value
     elif merge_behavior == MergeBehavior.Update:
         if not isinstance(self_value, dict):
             raise DbtInternalError(f"expected dict, got {self_value}")
@@ -258,6 +267,73 @@ def _merge_field_value(
                 # clobber the list
                 new_dict[new_key] = _listify(other_value[key])
         return new_dict
-
+    elif merge_behavior == MergeBehavior.Object:
+        # All fields in classes with MergeBehavior.Object should have a default of None
+        if not type(self_value).__name__ == type(other_value).__name__:
+            raise DbtInternalError(
+                f"got conflicting types: {type(self_value).__name__} and {type(other_value).__name__}"
+            )
+        new_value = self_value.copy()
+        new_value.update(other_value)
+        return new_value
     else:
         raise DbtInternalError(f"Got an invalid merge_behavior: {merge_behavior}")
+
+
+# This is used in ContextConfig._add_config_call. It updates the orig_dict in place.
+def merge_config_dicts(orig_dict: Dict[str, Any], new_dict: Dict[str, Any]) -> None:
+    # orig_dict is already encountered configs, new_dict is new
+    # This mirrors code in _merge_field_value in model_config.py which is similar but
+    # operates on config objects.
+    if orig_dict == {}:
+        orig_dict.update(new_dict)
+        return
+    for k, v in new_dict.items():
+        # MergeBehavior for post-hook and pre-hook is to collect all
+        # values, instead of overwriting
+        if k in BaseConfig.mergebehavior["append"]:
+            if k in orig_dict:  # should always be a list here
+                orig_dict[k] = _listify(orig_dict[k]) + _listify(v)
+            else:
+                orig_dict[k] = _listify(v)
+        elif k in BaseConfig.mergebehavior["update"]:
+            if not isinstance(v, dict):
+                raise DbtInternalError(f"expected dict, got {v}")
+            if k in orig_dict and isinstance(orig_dict[k], dict):
+                orig_dict[k].update(v)
+            else:
+                orig_dict[k] = v
+        elif k in BaseConfig.mergebehavior["dict_key_append"]:
+            if not isinstance(v, dict):
+                raise DbtInternalError(f"expected dict, got {v}")
+            if k in orig_dict:  # should always be a dict
+                for key in orig_dict[k].keys():
+                    orig_dict[k][key] = _listify(orig_dict[k][key])
+                for key, value in v.items():
+                    extend = False
+                    # This might start with a +, to indicate we should extend the list
+                    # instead of just clobbering it. We don't want to remove the + here
+                    # (like in the other method) because we want it preserved
+                    if key.startswith("+"):
+                        extend = True
+                    if key in orig_dict[k] and extend:
+                        # extend the list
+                        orig_dict[k][key].extend(_listify(value))
+                    else:
+                        # clobber the list
+                        orig_dict[k][key] = _listify(value)
+            else:
+                # This is always a dictionary
+                orig_dict[k] = v
+                # listify everything
+                for key, value in orig_dict[k].items():
+                    orig_dict[k][key] = _listify(value)
+        elif k in BaseConfig.mergebehavior["object"]:
+            if not isinstance(v, dict):
+                raise DbtInternalError(f"expected dict, got {v}")
+            if k not in orig_dict:
+                orig_dict[k] = {}
+            for obj_k, obj_v in v.items():
+                orig_dict[k][obj_k] = obj_v
+        else:  # Clobber
+            orig_dict[k] = v

{dbt_common-1.8.0 → dbt_common-1.10.0}/dbt_common/events/types.proto

@@ -26,17 +26,16 @@ message GenericMessage {
 // D - Deprecations
 
 // D018
-message BehaviorDeprecationEvent {
+message BehaviorChangeEvent {
     string flag_name = 1;
     string flag_source = 2;
-    string deprecation_version = 3;
-    string deprecation_message = 4;
-    string docs_url = 5;
+    string description = 3;
+    string docs_url = 4;
 }
 
-message BehaviorDeprecationEventMsg {
+message BehaviorChangeEventMsg {
     EventInfo info = 1;
-    BehaviorDeprecationEvent data = 2;
+    BehaviorChangeEvent data = 2;
 }
 
 // M - Deps generation

{dbt_common-1.8.0 → dbt_common-1.10.0}/dbt_common/events/types.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 from dbt_common.events.base_types import (
     DebugLevel,
     InfoLevel,
@@ -38,33 +36,16 @@ from dbt_common.ui import warning_tag
 # =======================================================
 
 
-class BehaviorDeprecationEvent(WarnLevel):
-    flag_name: str
-    flag_source: str
-    deprecation_version: Optional[str]
-    deprecation_message: Optional[str]
-    docs_url: Optional[str]
-
+class BehaviorChangeEvent(WarnLevel):
     def code(self) -> str:
         return "D018"
 
     def message(self) -> str:
-        msg = f"The legacy behavior controlled by `{self.flag_name}` is deprecated.\n"
-
-        if self.deprecation_version:
-            msg = (
-                f"The legacy behavior is expected to be retired in `{self.deprecation_version}`.\n"
-            )
-
-        msg += f"The new behavior can be turned on by setting `flags.{self.flag_name}` to `True` in `dbt_project.yml`.\n"
-
-        if self.deprecation_message:
-            msg += f"{self.deprecation_message}.\n"
-
-        docs_url = self.docs_url or f"https://docs.getdbt.com/search?q={self.flag_name}"
-        msg += f"Visit {docs_url} for more information."
-
-        return warning_tag(msg)
+        return warning_tag(
+            f"{self.description}\n"
+            f"You may opt into the new behavior sooner by setting `flags.{self.flag_name}` to `True` in `dbt_project.yml`.\n"
+            f"Visit {self.docs_url} for more information."
+        )
 
 
 # =======================================================