dbt-common 1.14.0__py3-none-any.whl → 1.16.0__py3-none-any.whl

dbt_common/__about__.py

@@ -1 +1 @@
-version = "1.14.0"
+version = "1.16.0"

dbt_common/clients/jinja.py

@@ -1,4 +1,5 @@
 import codecs
+import dataclasses
 import linecache
 import os
 import tempfile
@@ -90,6 +91,12 @@ def _linecache_inject(source: str, write: bool) -> str:
     return filename
 
 
+@dataclasses.dataclass
+class MacroType:
+    name: str
+    type_params: List["MacroType"] = dataclasses.field(default_factory=list)
+
+
 class MacroFuzzParser(jinja2.parser.Parser):
     def parse_macro(self) -> jinja2.nodes.Macro:
         node = jinja2.nodes.Macro(lineno=next(self.stream).lineno)
@@ -103,6 +110,65 @@ class MacroFuzzParser(jinja2.parser.Parser):
         node.body = self.parse_statements(("name:endmacro",), drop_needle=True)
         return node
 
+    def parse_signature(self, node: Union[jinja2.nodes.Macro, jinja2.nodes.CallBlock]) -> None:
+        """Overrides the default jinja Parser.parse_signature method, modifying
+        the original implementation to allow macros to have typed parameters."""
+
+        # Jinja does not support extending its node types, such as Macro, so
+        # at least while typed macros are experimental, we will patch the
+        # information onto the existing types.
+        setattr(node, "arg_types", [])
+        setattr(node, "has_type_annotations", False)
+
+        args = node.args = []  # type: ignore
+        defaults = node.defaults = []  # type: ignore
+
+        self.stream.expect("lparen")
+        while self.stream.current.type != "rparen":
+            if args:
+                self.stream.expect("comma")
+
+            arg = self.parse_assign_target(name_only=True)
+            arg.set_ctx("param")
+
+            type_name: Optional[str]
+            if self.stream.skip_if("colon"):
+                node.has_type_annotations = True  # type: ignore
+                type_name = self.parse_type_name()
+            else:
+                type_name = ""
+
+            node.arg_types.append(type_name)  # type: ignore
+
+            if self.stream.skip_if("assign"):
+                defaults.append(self.parse_expression())
+            elif defaults:
+                self.fail("non-default argument follows default argument")
+
+            args.append(arg)
+        self.stream.expect("rparen")
+
+    def parse_type_name(self) -> MacroType:
+        # NOTE: Types syntax is validated here, but not whether type names
+        # are valid or have correct parameters.
+
+        # A type name should consist of a name (i.e. 'Dict')...
+        type_name = self.stream.expect("name").value
+        type = MacroType(type_name)
+
+        # ..and an optional comma-delimited list of type parameters
+        # as in the type declaration 'Dict[str, str]'
+        if self.stream.skip_if("lbracket"):
+            while self.stream.current.type != "rbracket":
+                if type.type_params:
+                    self.stream.expect("comma")
+                param_type = self.parse_type_name()
+                type.type_params.append(param_type)
+
+            self.stream.expect("rbracket")
+
+        return type
+
 
 class MacroFuzzEnvironment(jinja2.sandbox.SandboxedEnvironment):
     def _parse(

dbt_common/context.py

@@ -39,9 +39,16 @@ class InvocationContext:
         else:
             self._env = env_public
 
+        self.name = "unset"
         self._env_secrets: Optional[List[str]] = None
         self._env_private = env_private
         self.recorder: Optional[Recorder] = None
+
+        # If set to True later, this flag will prevent dbt from creating a new
+        # invocation context for every invocation, which is useful for testing
+        # scenarios.
+        self.do_not_reset = False
+
         # This class will also eventually manage the invocation_id, flags, event manager, etc.
 
     @property
@@ -84,3 +91,10 @@ def get_invocation_context() -> InvocationContext:
     invocation_var = reliably_get_invocation_var()
     ctx = invocation_var.get()
     return ctx
+
+
+def try_get_invocation_context() -> Optional[InvocationContext]:
+    try:
+        return get_invocation_context()
+    except Exception:
+        return None

dbt_common/invocation.py

@@ -1,12 +1,19 @@
 import uuid
+from datetime import datetime
 
 _INVOCATION_ID = str(uuid.uuid4())
+_INVOCATION_STARTED_AT = datetime.utcnow()
 
 
 def get_invocation_id() -> str:
     return _INVOCATION_ID
 
 
+def get_invocation_started_at() -> datetime:
+    return _INVOCATION_STARTED_AT
+
+
 def reset_invocation_id() -> None:
-    global _INVOCATION_ID
+    global _INVOCATION_ID, _INVOCATION_STARTED_AT
     _INVOCATION_ID = str(uuid.uuid4())
+    _INVOCATION_STARTED_AT = datetime.utcnow()

dbt_common/record.py

@@ -1,17 +1,28 @@
-"""The record module provides a mechanism for recording dbt's interaction with
-external systems during a command invocation, so that the command can be re-run
-later with the recording 'replayed' to dbt.
+"""The record module provides a record/replay mechanism for recording dbt's
+interactions with external systems during a command invocation, so that the
+command can be re-run later with the recording 'replayed' to dbt.
 
 The rationale for and architecture of this module are described in detail in the
 docs/guides/record_replay.md document in this repository.
 """
 import functools
 import dataclasses
+import inspect
 import json
 import os
 
 from enum import Enum
-from typing import Any, Callable, Dict, List, Mapping, Optional, Type
+from threading import Lock
+from typing import Any, Callable, Dict, List, Mapping, Optional, TextIO, Tuple, Type
+
+from mashumaro import field_options
+from mashumaro.mixins.json import DataClassJSONMixin
+from mashumaro.types import SerializationStrategy
+
+import contextvars
+
+
+RECORDED_BY_HIGHER_FUNCTION = contextvars.ContextVar("RECORDED_BY_HIGHER_FUNCTION", default=False)
 
 
 class Record:
@@ -23,9 +34,10 @@ class Record:
     result_cls: Optional[type] = None
     group: Optional[str] = None
 
-    def __init__(self, params, result) -> None:
+    def __init__(self, params, result, seq=None) -> None:
         self.params = params
         self.result = result
+        self.seq = seq
 
     def to_dict(self) -> Dict[str, Any]:
         return {
@@ -37,6 +49,7 @@ class Record:
             else dataclasses.asdict(self.result)
             if self.result is not None
             else None,
+            "seq": self.seq,
         }
 
     @classmethod
@@ -53,7 +66,8 @@ class Record:
             if cls.result_cls is not None
             else None
         )
-        return cls(params=p, result=r)
+        s = dct.get("seq", None)
+        return cls(params=p, result=r, seq=s)
 
 
 class Diff:
@@ -129,6 +143,7 @@ class RecorderMode(Enum):
 class Recorder:
     _record_cls_by_name: Dict[str, Type] = {}
     _record_name_by_params_name: Dict[str, str] = {}
+    _auto_serialization_strategies: Dict[Type, SerializationStrategy] = {}
 
     def __init__(
         self,
@@ -158,6 +173,9 @@ class Recorder:
             if self.mode == RecorderMode.REPLAY:
                 self._unprocessed_records_by_type = self.load(self.previous_recording_path)
 
+        self._counter = 0
+        self._counter_lock = Lock()
+
     @classmethod
     def register_record_type(cls, rec_type) -> Any:
         cls._record_cls_by_name[rec_type.__name__] = rec_type
@@ -168,6 +186,11 @@ class Recorder:
         rec_cls_name = record.__class__.__name__  # type: ignore
         if rec_cls_name not in self._records_by_type:
             self._records_by_type[rec_cls_name] = []
+
+        with self._counter_lock:
+            record.seq = self._counter
+            self._counter += 1
+
         self._records_by_type[rec_cls_name].append(record)
 
     def pop_matching_record(self, params: Any) -> Optional[Record]:
@@ -189,23 +212,38 @@ class Recorder:
 
         return match
 
+    def write_json(self, out_stream: TextIO):
+        d = self._to_list()
+        json.dump(d, out_stream)
+
     def write(self) -> None:
         with open(self.current_recording_path, "w") as file:
-            json.dump(self._to_dict(), file)
+            self.write_json(file)
 
-    def _to_dict(self) -> Dict:
-        dct: Dict[str, Any] = {}
+    def _to_list(self) -> List[Dict]:
+        def get_tagged_dict(record: Record, record_type: str) -> Dict:
+            d = record.to_dict()
+            d["type"] = record_type
+            return d
 
+        record_list: List[Dict] = []
         for record_type in self._records_by_type:
-            record_list = [r.to_dict() for r in self._records_by_type[record_type]]
-            dct[record_type] = record_list
+            record_list.extend(
+                get_tagged_dict(r, record_type) for r in self._records_by_type[record_type]
+            )
+
+        record_list.sort(key=lambda r: r["seq"])
 
-        return dct
+        return record_list
 
     @classmethod
     def load(cls, file_name: str) -> Dict[str, List[Dict[str, Any]]]:
         with open(file_name) as file:
-            return json.load(file)
+            return cls.load_json(file)
+
+    @classmethod
+    def load_json(cls, in_stream: TextIO) -> Dict[str, List[Dict[str, Any]]]:
+        return json.load(in_stream)
 
     def _ensure_records_processed(self, record_type_name: str) -> None:
         if record_type_name in self._records_by_type:
@@ -239,6 +277,12 @@ class Recorder:
         assert self.diff is not None
         print(repr(self.diff.calculate_diff()))
 
+    @classmethod
+    def register_serialization_strategy(
+        cls, t: Type, serialization_strategy: SerializationStrategy
+    ) -> None:
+        cls._auto_serialization_strategies[t] = serialization_strategy
+
 
 def get_record_mode_from_env() -> Optional[RecorderMode]:
     """
@@ -271,7 +315,7 @@ def get_record_types_from_env() -> Optional[List]:
 
     If no types are provided, there will be no filtering.
     Invalid types will be ignored.
-    Expected format: 'DBT_RECORDER_TYPES=QueryRecord,FileLoadRecord,OtherRecord'
+    Expected format: 'DBT_RECORDER_TYPES=Database,FileLoadRecord'
     """
     record_types_str = os.environ.get("DBT_RECORDER_TYPES")
 
@@ -283,74 +327,263 @@ def get_record_types_from_env() -> Optional[List]:
 
 
 def get_record_types_from_dict(fp: str) -> List:
-    """
-    Get the record subset from the dict.
-    """
+    """Get the record subset from the dict."""
     with open(fp) as file:
         loaded_dct = json.load(file)
     return list(loaded_dct.keys())
 
 
+def auto_record_function(
+    record_name: str,
+    method: bool = True,
+    group: Optional[str] = None,
+    index_on_thread_name: bool = True,
+) -> Callable:
+    """This is the @auto_record_function decorator. It works in a similar way to
+    the @record_function decorator, except automatically generates boilerplate
+    classes for the Record, Params, and Result classes which would otherwise be
+    needed. That makes it suitable for quickly adding record support to simple
+    functions with simple parameters."""
+    return functools.partial(
+        _record_function_inner,
+        record_name,
+        method,
+        False,
+        None,
+        group,
+        index_on_thread_name,
+        False,
+    )
+
+
 def record_function(
     record_type,
     method: bool = False,
     tuple_result: bool = False,
     id_field_name: Optional[str] = None,
+    index_on_thread_id: bool = False,
 ) -> Callable:
-    def record_function_inner(func_to_record):
-        # To avoid runtime overhead and other unpleasantness, we only apply the
-        # record/replay decorator if a relevant env var is set.
-        if get_record_mode_from_env() is None:
-            return func_to_record
-
-        @functools.wraps(func_to_record)
-        def record_replay_wrapper(*args, **kwargs) -> Any:
-            recorder: Optional[Recorder] = None
-            try:
-                from dbt_common.context import get_invocation_context
-
-                recorder = get_invocation_context().recorder
-            except LookupError:
-                pass
-
-            if recorder is None:
-                return func_to_record(*args, **kwargs)
-
-            if recorder.recorded_types is not None and not (
-                record_type.__name__ in recorder.recorded_types
-                or record_type.group in recorder.recorded_types
-            ):
-                return func_to_record(*args, **kwargs)
-
-            # For methods, peel off the 'self' argument before calling the
-            # params constructor.
-            param_args = args[1:] if method else args
-            if method and id_field_name is not None:
-                param_args = (getattr(args[0], id_field_name),) + param_args
+    """This is the @record_function decorator, which marks functions which will
+    have their function calls recorded during record mode, and mocked out with
+    previously recorded replay data during replay."""
+    return functools.partial(
+        _record_function_inner,
+        record_type,
+        method,
+        tuple_result,
+        id_field_name,
+        None,
+        index_on_thread_id,
+        False,
+    )
+
+
+def _get_arg_fields(
+    spec: inspect.FullArgSpec,
+    skip_first: bool = False,
+) -> List[Tuple[str, Optional[Type], dataclasses.Field]]:
+    arg_fields = []
+    defaults = len(spec.defaults) if spec.defaults else 0
+    for i, arg_name in enumerate(spec.args):
+        if skip_first and i == 0:
+            continue
+        annotation = spec.annotations.get(arg_name)
+        if annotation is None:
+            raise Exception("Recorded functions must have type annotations.")
+        field = _get_field(arg_name, annotation)
+        if i >= len(spec.args) - defaults:
+            field[2].default = (
+                spec.defaults[i - len(spec.args) + defaults] if spec.defaults else None
+            )
+        arg_fields.append(field)
+    return arg_fields
+
 
-            params = record_type.params_cls(*param_args, **kwargs)
+def _get_field(field_name: str, t: Type) -> Tuple[str, Optional[Type], dataclasses.Field]:
+    dc_field: dataclasses.Field = dataclasses.field()
+    strat = Recorder._auto_serialization_strategies.get(t)
+    if strat is not None:
+        dc_field.metadata = field_options(serialization_strategy=Recorder._auto_serialization_strategies[t])  # type: ignore
 
-            include = True
-            if hasattr(params, "_include"):
-                include = params._include()
+    return field_name, t, dc_field
 
-            if not include:
-                return func_to_record(*args, **kwargs)
 
-            if recorder.mode == RecorderMode.REPLAY:
-                return recorder.expect_record(params)
+@dataclasses.dataclass
+class AutoValues(DataClassJSONMixin):
+    def _to_dict(self):
+        return self.to_dict()
 
-            r = func_to_record(*args, **kwargs)
-            result = (
-                None
-                if record_type.result_cls is None
-                else record_type.result_cls(*r)
-                if tuple_result
-                else record_type.result_cls(r)
+    def _from_dict(self, data):
+        return self.from_dict(data)
+
+
+def _record_function_inner(
+    record_type,
+    method,
+    tuple_result,
+    id_field_name,
+    group,
+    index_on_thread_id,
+    is_classmethod,
+    func_to_record,
+):
+    if isinstance(record_type, str):
+        return_type = inspect.signature(func_to_record).return_annotation
+        fields = _get_arg_fields(inspect.getfullargspec(func_to_record), method)
+        if index_on_thread_id:
+            id_field_name = "thread_id"
+            fields.insert(0, _get_field("thread_id", str))
+        params_cls = dataclasses.make_dataclass(
+            f"{record_type}Params", fields, bases=(AutoValues,)
+        )
+        result_cls = (
+            None
+            if return_type is None or return_type == inspect._empty
+            else dataclasses.make_dataclass(
+                f"{record_type}Result",
+                [_get_field("return_val", return_type)],
+                bases=(AutoValues,),
             )
-            recorder.add_record(record_type(params=params, result=result))
-            return r
+        )
+
+        record_type = type(
+            f"{record_type}Record",
+            (Record,),
+            {"params_cls": params_cls, "result_cls": result_cls, "group": group},
+        )
+
+        Recorder.register_record_type(record_type)
+
+    @functools.wraps(func_to_record)
+    def record_replay_wrapper(*args, **kwargs) -> Any:
+        recorder: Optional[Recorder] = None
+        try:
+            from dbt_common.context import get_invocation_context
+
+            recorder = get_invocation_context().recorder
+        except LookupError:
+            pass
+
+        call_args = args[1:] if is_classmethod else args
+
+        if recorder is None:
+            return func_to_record(*call_args, **kwargs)
+
+        if recorder.recorded_types is not None and not (
+            record_type.__name__ in recorder.recorded_types
+            or record_type.group in recorder.recorded_types
+        ):
+            return func_to_record(*call_args, **kwargs)
+
+        # For methods, peel off the 'self' argument before calling the
+        # params constructor.
+        param_args = args[1:] if method else args
+        if method and id_field_name is not None:
+            if index_on_thread_id:
+                from dbt_common.events.contextvars import get_node_info
+
+                node_info = get_node_info()
+                if node_info and "unique_id" in node_info:
+                    thread_name = node_info["unique_id"]
+                else:
+                    from dbt_common.context import get_invocation_context
+
+                    thread_name = get_invocation_context().name
+                param_args = (thread_name,) + param_args
+            else:
+                param_args = (getattr(args[0], id_field_name),) + param_args
+
+        params = record_type.params_cls(*param_args, **kwargs)
+
+        include = True
+        if hasattr(params, "_include"):
+            include = params._include()
+
+        if not include:
+            return func_to_record(*call_args, **kwargs)
+
+        if recorder.mode == RecorderMode.REPLAY:
+            return recorder.expect_record(params)
+        if RECORDED_BY_HIGHER_FUNCTION.get():
+            return func_to_record(*call_args, **kwargs)
+
+        RECORDED_BY_HIGHER_FUNCTION.set(True)
+        r = func_to_record(*call_args, **kwargs)
+        result = (
+            None
+            if record_type.result_cls is None
+            else record_type.result_cls(*r)
+            if tuple_result
+            else record_type.result_cls(r)
+        )
+        RECORDED_BY_HIGHER_FUNCTION.set(False)
+        recorder.add_record(record_type(params=params, result=result))
+        return r
+
+    setattr(
+        record_replay_wrapper,
+        "_record_metadata",
+        {
+            "record_type": record_type,
+            "method": method,
+            "tuple_result": tuple_result,
+            "id_field_name": id_field_name,
+            "group": group,
+            "index_on_thread_id": index_on_thread_id,
+        },
+    )
+
+    return record_replay_wrapper
+
+
+def _is_classmethod(method):
+    b = inspect.ismethod(method) and isinstance(method.__self__, type)
+    return b
+
+
+def supports_replay(cls):
+    """Class decorator which adds record/replay support for a class. In particular,
+    this decorator ensures that calls to overriden functions are still recorded."""
+
+    # When record/replay is inactive, do nothing.
+    if get_record_mode_from_env() is None:
+        return cls
+
+    # Replace the __init_subclass__ method of this class so that when it
+    # is subclassed, methods on the new subclass which override recorded
+    # functions are modified to be recorded as well.
+    original_init_subclass = cls.__init_subclass__
+
+    @classmethod
+    def wrapping_init_subclass(sub_cls):
+        for method_name in dir(cls):
+            method = getattr(cls, method_name)
+            metadata = getattr(method, "_record_metadata", None)
+            if method and getattr(method, "_record_metadata", None):
+                sub_method = getattr(sub_cls, method_name, None)
+                recorded_sub_method = _record_function_inner(
+                    metadata["record_type"],
+                    metadata["method"],
+                    metadata["tuple_result"],
+                    metadata["id_field_name"],
+                    metadata["group"],
+                    metadata["index_on_thread_id"],
+                    _is_classmethod(method),
+                    sub_method,
+                )
+
+                if _is_classmethod(method):
+                    recorded_sub_method = classmethod(recorded_sub_method)
+
+                if sub_method is not None:
+                    setattr(
+                        sub_cls,
+                        method_name,
+                        recorded_sub_method,
+                    )
+
+        original_init_subclass()
 
-        return record_replay_wrapper
+    cls.__init_subclass__ = wrapping_init_subclass
 
-    return record_function_inner
+    return cls

{dbt_common-1.14.0.dist-info → dbt_common-1.16.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: dbt-common
-Version: 1.14.0
+Version: 1.16.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
@@ -8,7 +8,8 @@ Project-URL: Issues, https://github.com/dbt-labs/dbt-common/issues
 Project-URL: Changelog, https://github.com/dbt-labs/dbt-common/blob/main/CHANGELOG.md
 Author-email: dbt Labs <info@dbtlabs.com>
 Maintainer-email: dbt Labs <info@dbtlabs.com>
-License: Apache-2.0
+License-Expression: Apache-2.0
+License-File: LICENSE
 Classifier: Development Status :: 2 - Pre-Alpha
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: MacOS :: MacOS X
@@ -65,9 +66,7 @@ The shared common utilities for dbt-core and adapter implementations use
 
 ### Releasing dbt-common
 To release a new version of dbt-common to pypi, you'll need to: 
-1. Bump the `version` in [dbt_common_/__about__.py](https://github.com/dbt-labs/dbt-common/blob/main/dbt_common/__about__.py)
-2. Run the [release workflow](https://github.com/dbt-labs/dbt-common/actions/workflows/release.yml) to test pypi and confirm a successful test release in: https://test.pypi.org/project/dbt-common/
-3. Run the [release workflow](https://github.com/dbt-labs/dbt-common/actions/workflows/release.yml) to prod pypi and confirm a successful release in: https://pypi.org/project/dbt-common/
+1. Run the [release workflow](https://github.com/dbt-labs/dbt-common/actions/workflows/release.yml) to bump the version, generate changelogs and release to pypi
 4. Bump the version of `dbt-common` in `dbt-core` and `dbt-adapters` if you're releasing a new major version or a pre-release: 
    * `dbt-core`: [setup.py](https://github.com/dbt-labs/dbt-core/blob/main/core/setup.py)
    * `dbt-adapters`: [pyproject.toml](https://github.com/dbt-labs/dbt-adapters/blob/main/pyproject.toml)

{dbt_common-1.14.0.dist-info → dbt_common-1.16.0.dist-info}/RECORD

@@ -1,20 +1,20 @@
-dbt_common/__about__.py,sha256=jgA5fU_XZ5Gv-NyYGvOeyOvgy8rP58A_XiIlWHtvbZo,19
+dbt_common/__about__.py,sha256=6EsnLejJWxuMqRt_s2lK0ter3lZGaIm5OK1MPeLZC5M,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=rk4EYBU4SpDXRhqbSvDTJwojilxPSoaiEdOxkXow_BU,2549
+dbt_common/context.py,sha256=-ErtKG4xfOh1-Y569fwu6u2O381nRan18HhATrYDoZE,2950
 dbt_common/dataclass_schema.py,sha256=u2S0dxwxIghv8RMqC91HlWZJVxmsC_844yZQaGyOwdY,5563
 dbt_common/helper_types.py,sha256=FWJGPmp7Qp2iToHyI4uvhkBbu_d1tl2_oF-obi98_N4,3917
-dbt_common/invocation.py,sha256=2ZchIr4Wq7NwtAjjB-mxHP9ITD6-r45jEq4Zooso0gc,210
+dbt_common/invocation.py,sha256=xw0NBIE-6LHd135cx4non-MkGGsia0mYN0lMkmNEucE,435
 dbt_common/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dbt_common/record.py,sha256=vItvHEF2yl_NbvuaIXYHo-q6v0LUpCxR2twcTMVCeQ0,12698
+dbt_common/record.py,sha256=B5Ybpf-yzPRPyhxp4JNZyDAOGoSd2dr6VjLykH7VKN4,20247
 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=rc2TEM29raBFc_LXcg901pMDD07C2ohwp9qzkE-7pBY,2567
 dbt_common/clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbt_common/clients/_jinja_blocks.py,sha256=5I_VEWkkW_54uK09ErP_8ey7wj-OOXvt1OHqr73HLOk,14879
 dbt_common/clients/agate_helper.py,sha256=anKKgKV5PSnFRuFeBwRMdHK3JCaQoUqB2ZXHD0su0Wo,9123
-dbt_common/clients/jinja.py,sha256=Cc-6YWCXoyftzNhG-L3N4W8WiKBZZIWB6wV7-JPrQkg,20054
+dbt_common/clients/jinja.py,sha256=VpCYe_0seh6K4667-4TmQ2PP-T48UIcvDRT3miRyn4o,22488
 dbt_common/clients/system.py,sha256=aoUBtOuXVmkOyj6IhhJ3Y4a7JFzPO2F_zKyOtz3xy44,23932
 dbt_common/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbt_common/contracts/constraints.py,sha256=_f1q3Rkcg2UwA7zI5XBbUMXnPUg6pw17UC7l1HyhyQM,1352
@@ -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.14.0.dist-info/METADATA,sha256=VgvfWv6LGaTre2VQJqnIiJAhSYhG4AAPWiCjrKQd0Tk,5211
-dbt_common-1.14.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-dbt_common-1.14.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-dbt_common-1.14.0.dist-info/RECORD,,
+dbt_common-1.16.0.dist-info/METADATA,sha256=k7yyMmWSYXvX-1bT5gzMUphCMcqntoMMloji1mnszvg,4895
+dbt_common-1.16.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dbt_common-1.16.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+dbt_common-1.16.0.dist-info/RECORD,,

{dbt_common-1.14.0.dist-info → dbt_common-1.16.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.26.3
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any