dbt-common 1.23.0__py3-none-any.whl → 1.24.0__py3-none-any.whl

dbt_common/__about__.py

@@ -1 +1 @@
-version = "1.23.0"
+version = "1.24.0"

dbt_common/events/event_manager.py

@@ -1,11 +1,11 @@
 import os
 import traceback
-from typing import Any, List, Optional, Protocol, Tuple
+from typing import Any, List, Optional, Protocol, Tuple, Union
 
 from dbt_common.events.base_types import BaseEvent, EventLevel, msg_from_base_event, TCallback
 from dbt_common.events.logger import LoggerConfig, _Logger, _TextLogger, _JsonLogger, LineFormat
 from dbt_common.exceptions.events import EventCompilationError
-from dbt_common.helper_types import WarnErrorOptions
+from dbt_common.helper_types import WarnErrorOptions, WarnErrorOptionsV2
 
 
 class EventManager:
@@ -13,7 +13,7 @@ class EventManager:
         self.loggers: List[_Logger] = []
         self.callbacks: List[TCallback] = []
         self._warn_error: Optional[bool] = None
-        self._warn_error_options: Optional[WarnErrorOptions] = None
+        self._warn_error_options: Optional[Union[WarnErrorOptions, WarnErrorOptionsV2]] = None
         self.require_warn_or_error_handling: bool = False
 
     @property
@@ -29,15 +29,18 @@ class EventManager:
         self._warn_error = warn_error
 
     @property
-    def warn_error_options(self) -> WarnErrorOptions:
+    def warn_error_options(self) -> Union[WarnErrorOptions, WarnErrorOptionsV2]:
         if self._warn_error_options is None:
             from dbt_common.events.functions import WARN_ERROR_OPTIONS
 
-            return WARN_ERROR_OPTIONS
+            return WARN_ERROR_OPTIONS._warn_error_options_v2
+
         return self._warn_error_options
 
     @warn_error_options.setter
-    def warn_error_options(self, warn_error_options: WarnErrorOptions) -> None:
+    def warn_error_options(
+        self, warn_error_options: Union[WarnErrorOptions, WarnErrorOptionsV2]
+    ) -> None:
         self._warn_error_options = warn_error_options
 
     def fire_event(
@@ -52,7 +55,7 @@ class EventManager:
         if force_warn_or_error_handling or (
             self.require_warn_or_error_handling and msg.info.level == "warn"
         ):
-            if self.warn_error or self.warn_error_options.includes(e):
+            if self.warn_error or self.warn_error_options.errors(e):
                 # This has the potential to create an infinite loop if the handling of the raised
                 # EventCompilationError fires an event as a warning instead of an error.
                 raise EventCompilationError(e.message(), node)
@@ -95,7 +98,7 @@ class IEventManager(Protocol):
     callbacks: List[TCallback]
     loggers: List[_Logger]
     warn_error: bool
-    warn_error_options: WarnErrorOptions
+    warn_error_options: Union[WarnErrorOptions, WarnErrorOptionsV2]
     require_warn_or_error_handling: bool
 
     def fire_event(

dbt_common/helper_types.py

@@ -65,109 +65,162 @@ class IncludeExclude(dbtClassMixin):
 
 
 class WarnErrorOptions(IncludeExclude):
+    """Deprecated, use WarnErrorOptionsV2 instead."""
+
+    DEPRECATIONS = "Deprecations"
+
+    def __init__(
+        self,
+        include: Union[str, List[str]],
+        exclude: Optional[List[str]] = None,
+        valid_error_names: Optional[Set[str]] = None,
+        silence: Optional[List[str]] = None,
+    ):
+        self.silence = silence or []
+        self._valid_error_names: Set[str] = valid_error_names or set()
+        self._valid_error_names.add(self.DEPRECATIONS)
+        super().__init__(include=include, exclude=(exclude or []))
+
+        self._warn_error_options_v2 = WarnErrorOptionsV2(
+            error=self.include,
+            warn=self.exclude,
+            silence=self.silence,
+            valid_error_names=self._valid_error_names,
+        )
+
+    def __post_init__(self):
+        # We don't want IncludeExclude's post_init to run, so we override it.
+        # We are fine with just having the WarnErrorOptionsV2's post_init run on instantiation.
+        pass
+
+    def includes(self, item_name: Union[str, BaseEvent]) -> bool:
+        return self._warn_error_options_v2.includes(item_name)
+
+    def errors(self, item_name: Union[str, BaseEvent]) -> bool:
+        """Exists for forward compatibility with WarnErrorOptionsV2."""
+        return self._warn_error_options_v2.errors(item_name)
+
+    def silenced(self, item_name: Union[str, BaseEvent]) -> bool:
+        return self._warn_error_options_v2.silenced(item_name)
+
+
+@dataclass
+class WarnErrorOptionsV2(dbtClassMixin):
     """
     This class is used to configure the behavior of the warn_error feature (now part of fire_event).
 
-    include: "all", "*", or a list of event names.
-    exclude: a list of event names.
+    error: "all", "*", or a list of event names.
+    warn: a list of event names.
     silence: a list of event names.
-    valid_error_names: a set of event names that can be named in include, exclude, and silence.
+    valid_error_names: a set of event names that can be named in error, warn, and silence.
 
     In a hierarchy of configuration, the following rules apply:
     1. named > Deprecations > "all"/"*"
-    2. silence > exclude > include
+    2. silence > warn > error
     3. (1) > (2)
     """
 
+    ERROR_ALL = ("all", "*")
     DEPRECATIONS = "Deprecations"
 
+    error: Union[str, List[str]]
+    warn: List[str]
+    silence: List[str]
+
     def __init__(
         self,
-        include: Union[str, List[str]],
-        exclude: Optional[List[str]] = None,
-        valid_error_names: Optional[Set[str]] = None,
+        error: Optional[Union[str, List[str]]] = None,
+        warn: Optional[List[str]] = None,
         silence: Optional[List[str]] = None,
+        valid_error_names: Optional[Set[str]] = None,
     ):
-        self.silence = silence or []
         self._valid_error_names: Set[str] = valid_error_names or set()
         self._valid_error_names.add(self.DEPRECATIONS)
-        super().__init__(include=include, exclude=(exclude or []))
 
-    def __post_init__(self):
-        if isinstance(self.include, str) and self.include not in self.INCLUDE_ALL:
-            raise ValidationError(
-                f"include must be one of {self.INCLUDE_ALL} or a list of strings"
-            )
+        # We can't do `= error or []` because if someone passes in an empty list, and latter appends to that list
+        # they would expect references to the original list to be updated.
+        self.error = error if error is not None else []
+        self.warn = warn if warn is not None else []
+        self.silence = silence if silence is not None else []
+
+        # since we're overriding the dataclass auto __init__, we need to call __post_init__ manually
+        self.__post_init__()
 
-        # To specify exclude, either `include` must be "all" or "deprecations" must be
-        # in `include` or `silence`.
-        if self.exclude and not (
-            self.include in self.INCLUDE_ALL
-            or self.DEPRECATIONS in self.include
+    def __post_init__(self):
+        if isinstance(self.error, str) and self.error not in self.ERROR_ALL:
+            raise ValidationError(f"error must be one of {self.ERROR_ALL} or a list of strings")
+
+        # To specify `warn`, one of the following must be true
+        # 1. `error` must be "all"/"*"
+        # 2. "deprecations" must be in either `error` or `silence`.
+        if self.warn and not (
+            self.error in self.ERROR_ALL
+            or self.DEPRECATIONS in self.error
             or self.DEPRECATIONS in self.silence
         ):
             raise ValidationError(
-                f"exclude can only be specified if include is one of {self.INCLUDE_ALL} or "
-                f"{self.DEPRECATIONS} is in include or silence."
+                f"`warn` can only be specified if `error` is one of {self.ERROR_ALL} or "
+                f"{self.DEPRECATIONS} is in `error` or silence."
             )
 
-        if isinstance(self.include, list):
-            self._validate_items(self.include)
+        if isinstance(self.error, list):
+            self._validate_items(self.error)
 
-        if isinstance(self.exclude, list):
-            self._validate_items(self.exclude)
+        if isinstance(self.warn, list):
+            self._validate_items(self.warn)
 
         if isinstance(self.silence, list):
             self._validate_items(self.silence)
 
-    def _includes_all(self) -> bool:
-        """Is `*` or `all` set as include?"""
-        return self.include in self.INCLUDE_ALL
+    def _validate_items(self, items: List[str]):
+        for item in items:
+            if item not in self._valid_error_names:
+                raise ValidationError(f"{item} is not a valid dbt error name.")
+
+    def _error_all(self) -> bool:
+        """Is `*` or `all` set as error?"""
+        return self.error in self.ERROR_ALL
 
-    def _named_inclusion(self, item_name: str) -> bool:
-        """Is the item_name named in the include list?"""
-        return item_name in self.include
+    def _named_error(self, item_name: str) -> bool:
+        """Is the item_name named in the error list?"""
+        return item_name in self.error
 
-    def _named_exclusion(self, item_name: str) -> bool:
-        """Is the item_name named in the exclude list?"""
-        return item_name in self.exclude
+    def _named_warn(self, item_name: str) -> bool:
+        """Is the item_name named in the warn list?"""
+        return item_name in self.warn
 
     def _named_silence(self, item_name: str) -> bool:
         """Is the item_name named in the silence list?"""
         return item_name in self.silence
 
-    def _include_as_deprecation(self, event: Optional[BaseEvent]) -> bool:
-        """Is event included as a deprecation?"""
+    def _error_as_deprecation(self, event: Optional[BaseEvent]) -> bool:
+        """Is the event a deprecation, and if so should it be treated as an error?"""
         return (
-            event is not None
-            and event.code().startswith("D")
-            and self.DEPRECATIONS in self.include
+            event is not None and event.code().startswith("D") and self.DEPRECATIONS in self.error
         )
 
-    def _exclude_as_deprecation(self, event: Optional[BaseEvent]) -> bool:
-        """Is event excluded as a deprecation?"""
+    def _warn_as_deprecation(self, event: Optional[BaseEvent]) -> bool:
+        """Is the event a deprecation, and if so should it be treated as an warning?"""
         return (
-            event is not None
-            and event.code().startswith("D")
-            and self.DEPRECATIONS in self.exclude
+            event is not None and event.code().startswith("D") and self.DEPRECATIONS in self.warn
         )
 
     def _silence_as_deprecation(self, event: Optional[BaseEvent]) -> bool:
-        """Is event silenced as a deprecation?"""
+        """Is the event a deprecation, and if so should it be silenced?"""
         return (
             event is not None
             and event.code().startswith("D")
             and self.DEPRECATIONS in self.silence
         )
 
-    def includes(self, item_name: Union[str, BaseEvent]) -> bool:
-        """Is the event included?
+    def errors(self, item_name: Union[str, BaseEvent]) -> bool:
+        """Should the event be treated as an error?
 
-        An event included if any of the following are true:
-        - The event is named in `include` and not named in `exclude` or `silence`
-        - "*" or "all" is specified for `include`, and the event is not named in `exclude` or `silence`
-        - The event is a deprecation, "deprecations" is in `include`, and the event is not named in `exclude` or `silence`
-          nor is "deprecations" in `exclude` or `silence`
+        An event should error if any of the following are true:
+        - The event is named in `error` and not named in `warn` or `silence`
+        - "*" or "all" is specified for `error`, and the event is not named in `warn` or `silence`
+        - The event is a deprecation, "deprecations" is in `error`, and the event is not named in `warn` or `silence`
+          nor is "deprecations" in `warn` or `silence`
         """
         # Setup based on item_name type
         if isinstance(item_name, str):
@@ -178,29 +231,31 @@ class WarnErrorOptions(IncludeExclude):
             event = item_name
 
         # Pre-compute checks that will be used multiple times
-        named_elsewhere = self._named_exclusion(event_name) or self._named_silence(event_name)
-        deprecation_elsewhere = self._exclude_as_deprecation(
+        named_elsewhere = self._named_warn(event_name) or self._named_silence(event_name)
+        deprecation_elsewhere = self._warn_as_deprecation(event) or self._silence_as_deprecation(
             event
-        ) or self._silence_as_deprecation(event)
+        )
 
         # Calculate result
-        if self._named_inclusion(event_name) and not named_elsewhere:
+        if self._named_error(event_name) and not named_elsewhere:
             return True
-        elif self._include_as_deprecation(event) and not (
-            named_elsewhere or deprecation_elsewhere
-        ):
+        elif self._error_as_deprecation(event) and not (named_elsewhere or deprecation_elsewhere):
             return True
-        elif self._includes_all() and not (named_elsewhere or deprecation_elsewhere):
+        elif self._error_all() and not (named_elsewhere or deprecation_elsewhere):
             return True
         else:
             return False
 
+    def includes(self, item_name: Union[str, BaseEvent]) -> bool:
+        """Deprecated, use `errors` instead."""
+        return self.errors(item_name)
+
     def silenced(self, item_name: Union[str, BaseEvent]) -> bool:
         """Is the event silenced?
 
         An event silenced if any of the following are true:
         - The event is named in `silence`
-        - "Deprecations" is in `silence` and the event is not named in `include` or `exclude`
+        - "Deprecations" is in `silence` and the event is not named in `error` or `warn`
         """
         # Setup based on item_name type
         if isinstance(item_name, str):
@@ -211,7 +266,7 @@ class WarnErrorOptions(IncludeExclude):
             event = item_name
 
         # Pre-compute checks that will be used multiple times
-        named_elsewhere = self._named_inclusion(event_name) or self._named_exclusion(event_name)
+        named_elsewhere = self._named_error(event_name) or self._named_warn(event_name)
 
         # Calculate result
         if self._named_silence(event_name):
@@ -221,11 +276,6 @@ class WarnErrorOptions(IncludeExclude):
         else:
             return False
 
-    def _validate_items(self, items: List[str]):
-        for item in items:
-            if item not in self._valid_error_names:
-                raise ValidationError(f"{item} is not a valid dbt error name.")
-
 
 FQNPath = Tuple[str, ...]
 PathSet = AbstractSet[FQNPath]

dbt_common/ui.py

@@ -1,7 +1,7 @@
 from os import getenv as os_getenv
 import sys
 import textwrap
-from typing import Dict
+from typing import Dict, Optional
 
 import colorama
 
@@ -78,13 +78,19 @@ def line_wrap_message(msg: str, subtract: int = 0, dedent: bool = True, prefix:
     return "\n".join(textwrap.fill(chunk, width=width, break_on_hyphens=False) for chunk in chunks)
 
 
-def warning_tag(msg: str) -> str:
-    return f'[{yellow("WARNING")}]: {msg}'
+def warning_tag(msg: str, event_name: Optional[str] = None) -> str:
+    tag = f'[{yellow("WARNING")}]'
+    if event_name:
+        tag += f"[{event_name}]"
+    return f"{tag}: {msg}"
 
 
-def deprecation_tag(msg: str) -> str:
-    return warning_tag(f"Deprecated functionality\n\n{msg}")
+def deprecation_tag(msg: str, event_name: Optional[str] = None) -> str:
+    return warning_tag(f"Deprecated functionality\n\n{msg}", event_name)
 
 
-def error_tag(msg: str) -> str:
-    return f'[{red("ERROR")}]: {msg}'
+def error_tag(msg: str, event_name: Optional[str] = None) -> str:
+    tag = f'[{red("ERROR")}]'
+    if event_name:
+        tag += f"[{event_name}]"
+    return f"{tag}: {msg}"

{dbt_common-1.23.0.dist-info → dbt_common-1.24.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbt-common
-Version: 1.23.0
+Version: 1.24.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.23.0.dist-info → dbt_common-1.24.0.dist-info}/RECORD

@@ -1,16 +1,16 @@
-dbt_common/__about__.py,sha256=aQAgejfvBJWgErscsekMI9-f-XZYA6Im-fYbFUo9xPI,19
+dbt_common/__about__.py,sha256=E8iFJObH8LUoUScRPYZad7ih455nH0reOnZSmEuNdh4,19
 dbt_common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbt_common/behavior_flags.py,sha256=hQzxCqQSweJbRp_xoQqNnlUF77PBuOdCdLOSdcBlkxk,4885
 dbt_common/constants.py,sha256=-Y5DIL1SDPQWtlCNizXRYxFgbx1D7LaLs1ysamvGMRk,278
 dbt_common/context.py,sha256=-ErtKG4xfOh1-Y569fwu6u2O381nRan18HhATrYDoZE,2950
 dbt_common/dataclass_schema.py,sha256=u2S0dxwxIghv8RMqC91HlWZJVxmsC_844yZQaGyOwdY,5563
-dbt_common/helper_types.py,sha256=v6ak-05SodNDxJM7BGXyCT4yPM-OUhcvznjemXRYT-g,9117
+dbt_common/helper_types.py,sha256=LuUILGUG_q35iULjtW-bb_UchLV2y7iQdSqpUKiLtAA,11200
 dbt_common/invocation.py,sha256=xw0NBIE-6LHd135cx4non-MkGGsia0mYN0lMkmNEucE,435
 dbt_common/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbt_common/record.py,sha256=QLrKppBHYuV7ZTckOMi4Gnz7jLQJcOa5kp4PwK0JmwY,21889
 dbt_common/semver.py,sha256=Znewz6tc_NBpXr4mZf20bK_RayPL4ODrnxDbkUZrrRo,15034
 dbt_common/tests.py,sha256=6lC_JuRtoYO6cbAF8-R5aTM4HtQiM_EH8X5m_97duGY,315
-dbt_common/ui.py,sha256=rC-d4J3u0sBH_0L1AZdQ-mDxPrTDYecTFn65mNqQ-ig,2668
+dbt_common/ui.py,sha256=geIk3ElFj5y_SG5EDc6RMJFEvYGdo-6C21l0pB8I-EU,2934
 dbt_common/clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbt_common/clients/_jinja_blocks.py,sha256=eUjZLBtLCASJRRj1G8b9u15A3PQMDCKvytIdWkTLSP4,15451
 dbt_common/clients/agate_helper.py,sha256=anKKgKV5PSnFRuFeBwRMdHK3JCaQoUqB2ZXHD0su0Wo,9123
@@ -30,7 +30,7 @@ dbt_common/events/__init__.py,sha256=av08vfpxo0ek7PqZNtMxY8FODJ3xwph4ehRxgInx4LA
 dbt_common/events/base_types.py,sha256=bdDMbawAV0FkxmvuxgsTev82vxTuyu6rJiSkvEQPsO8,5525
 dbt_common/events/contextvars.py,sha256=EIs1P6NrJzx_IAV17x5cVqOAS4Lqbu6oc0etHtWCJOo,3097
 dbt_common/events/event_handler.py,sha256=jfi0PyqIOGnXCG9HEa0VIVULqNvXs1RYmAg0b50ChQs,1385
-dbt_common/events/event_manager.py,sha256=ElltioymOwrDmSdYpiyTNPOEFIOWQMQ9b_hAARmf5aE,4528
+dbt_common/events/event_manager.py,sha256=jp91-qW7DmbAEHjmNzPUH8NrXpEOYNQVGeIyZBpkr8Y,4699
 dbt_common/events/event_manager_client.py,sha256=5IVdIuRVi5xCNQGiZqXdywlED2kLj1W_Pj0lh2HiDiI,1115
 dbt_common/events/format.py,sha256=x1RWDZ8G7ZMHmxdld6Q4VXca4kvnhiQOIaQXkC6Uo0Q,1609
 dbt_common/events/functions.py,sha256=R3DuyNy2TqOwNyMACVOYtiG1NjZ9FQa6FWKkzMeMCBY,4767
@@ -57,7 +57,7 @@ dbt_common/utils/encoding.py,sha256=6_kSY2FvGNYMg7oX7PrbvVioieydih3Kl7Ii802LaHI,
 dbt_common/utils/executor.py,sha256=pNY0UbPlwQmTE69Vt_Rj91YGCIOEaqeYU3CjAds0T70,2454
 dbt_common/utils/formatting.py,sha256=JUn5rzJ-uajs9wPCN0-f2iRFY1pOJF5YjTD9dERuLoc,165
 dbt_common/utils/jinja.py,sha256=JXgNmJArGGy0h7qkbNLA3zaEQmoF1CxsNBYTlIwFXDw,1101
-dbt_common-1.23.0.dist-info/METADATA,sha256=ba64BsaO0C5gCGrnpfKQ8IOxJsgdoX6ZKFJc7w3REMU,4946
-dbt_common-1.23.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dbt_common-1.23.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-dbt_common-1.23.0.dist-info/RECORD,,
+dbt_common-1.24.0.dist-info/METADATA,sha256=pMLQDmfri6a3jpg2HN8bct605SOz4SnRAW6J_ekNzDk,4946
+dbt_common-1.24.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dbt_common-1.24.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+dbt_common-1.24.0.dist-info/RECORD,,