dbt-common 0.1.1__py3-none-any.whl → 0.1.5__py3-none-any.whl

dbt_common/__about__.py

@@ -1 +1 @@
-version = "0.1.1"
+version = "0.1.5"

dbt_common/clients/_jinja_blocks.py

@@ -28,7 +28,11 @@ class BlockData:
 
 class BlockTag:
     def __init__(
-        self, block_type_name: str, block_name: str, contents: Optional[str] = None, full_block: Optional[str] = None
+        self,
+        block_type_name: str,
+        block_name: str,
+        contents: Optional[str] = None,
+        full_block: Optional[str] = None,
     ) -> None:
         self.block_type_name = block_type_name
         self.block_name = block_name
@@ -106,7 +110,9 @@ class TagIterator:
         self.pos: int = 0
 
     def linepos(self, end: Optional[int] = None) -> str:
-        """Given an absolute position in the input text, return a pair of
+        """Return relative position in line.
+
+        Given an absolute position in the input data, return a pair of
         line number + relative position to the start of the line.
         """
         end_val: int = self.pos if end is None else end
@@ -148,7 +154,9 @@ class TagIterator:
         return match
 
     def handle_expr(self, match: re.Match) -> None:
-        """Handle an expression. At this point we're at a string like:
+        """Handle an expression.
+
+        At this point we're at a string like:
             {{ 1 + 2 }}
             ^ right here
 
@@ -180,6 +188,7 @@ class TagIterator:
 
     def _expect_block_close(self) -> None:
         """Search for the tag close marker.
+
         To the right of the type name, there are a few possiblities:
            - a name (handled by the regex's 'block_name')
            - any number of: `=`, `(`, `)`, strings, etc (arguments)
@@ -191,7 +200,9 @@ class TagIterator:
         are quote and `%}` - nothing else can hide the %} and be valid jinja.
         """
         while True:
-            end_match = self._expect_match('tag close ("%}")', QUOTE_START_PATTERN, TAG_CLOSE_PATTERN)
+            end_match = self._expect_match(
+                'tag close ("%}")', QUOTE_START_PATTERN, TAG_CLOSE_PATTERN
+            )
             self.advance(end_match.end())
             if end_match.groupdict().get("tag_close") is not None:
                 return
@@ -207,7 +218,9 @@ class TagIterator:
         return match.end()
 
     def handle_tag(self, match: re.Match) -> Tag:
-        """The tag could be one of a few things:
+        """Determine tag type.
+
+        The tag could be one of a few things:
 
             {% mytag %}
             {% mytag x = y %}
@@ -229,11 +242,15 @@ class TagIterator:
         else:
             self.advance(match.end())
             self._expect_block_close()
-        return Tag(block_type_name=block_type_name, block_name=block_name, start=start_pos, end=self.pos)
+        return Tag(
+            block_type_name=block_type_name, block_name=block_name, start=start_pos, end=self.pos
+        )
 
     def find_tags(self) -> Iterator[Tag]:
         while True:
-            match = self._first_match(BLOCK_START_PATTERN, COMMENT_START_PATTERN, EXPR_START_PATTERN)
+            match = self._first_match(
+                BLOCK_START_PATTERN, COMMENT_START_PATTERN, EXPR_START_PATTERN
+            )
             if match is None:
                 break
 
@@ -253,7 +270,8 @@ class TagIterator:
                 yield self.handle_tag(match)
             else:
                 raise DbtInternalError(
-                    "Invalid regex match in next_block, expected block start, " "expr start, or comment start"
+                    "Invalid regex match in next_block, expected block start, "
+                    "expr start, or comment start"
                 )
 
     def __iter__(self) -> Iterator[Tag]:
@@ -349,4 +367,6 @@ class BlockIterator:
     def lex_for_blocks(
         self, allowed_blocks: Optional[Set[str]] = None, collect_raw_data: bool = True
     ) -> List[Union[BlockData, BlockTag]]:
-        return list(self.find_blocks(allowed_blocks=allowed_blocks, collect_raw_data=collect_raw_data))
+        return list(
+            self.find_blocks(allowed_blocks=allowed_blocks, collect_raw_data=collect_raw_data)
+        )

dbt_common/clients/agate_helper.py

@@ -1,13 +1,13 @@
 from codecs import BOM_UTF8
 
-import agate
+import agate  # type: ignore
 import datetime
 import isodate
 import json
 from typing import Iterable, List, Dict, Union, Optional, Any
 
 from dbt_common.exceptions import DbtRuntimeError
-from dbt_common.utils import ForgivingJSONEncoder
+from dbt_common.utils.encoding import ForgivingJSONEncoder
 
 BOM = BOM_UTF8.decode("utf-8")  # '\ufeff'
 
@@ -17,7 +17,7 @@ class Integer(agate.data_types.DataType):
         # by default agate will cast none as a Number
         # but we need to cast it as an Integer to preserve
         # the type when merging and unioning tables
-        if type(d) == int or d is None:
+        if type(d) == int or d is None:  # noqa [E721]
             return d
         else:
             raise agate.exceptions.CastError('Can not parse value "%s" as Integer.' % d)
@@ -30,7 +30,7 @@ class Number(agate.data_types.Number):
     # undo the change in https://github.com/wireservice/agate/pull/733
     # i.e. do not cast True and False to numeric 1 and 0
     def cast(self, d):
-        if type(d) == bool:
+        if type(d) == bool:  # noqa [E721]
             raise agate.exceptions.CastError("Do not cast True to 1 or False to 0.")
         else:
             return super().cast(d)
@@ -59,14 +59,15 @@ class ISODateTime(agate.data_types.DateTime):
 def build_type_tester(
     text_columns: Iterable[str], string_null_values: Optional[Iterable[str]] = ("null", "")
 ) -> agate.TypeTester:
-
     types = [
         Integer(null_values=("null", "")),
         Number(null_values=("null", "")),
         agate.data_types.Date(null_values=("null", ""), date_format="%Y-%m-%d"),
         agate.data_types.DateTime(null_values=("null", ""), datetime_format="%Y-%m-%d %H:%M:%S"),
         ISODateTime(null_values=("null", "")),
-        agate.data_types.Boolean(true_values=("true",), false_values=("false",), null_values=("null", "")),
+        agate.data_types.Boolean(
+            true_values=("true",), false_values=("false",), null_values=("null", "")
+        ),
         agate.data_types.Text(null_values=string_null_values),
     ]
     force = {k: agate.data_types.Text(null_values=string_null_values) for k in text_columns}
@@ -92,13 +93,13 @@ def table_from_rows(
 
 
 def table_from_data(data, column_names: Iterable[str]) -> agate.Table:
-    "Convert a list of dictionaries into an Agate table"
+    """Convert a list of dictionaries into an Agate table.
 
-    # The agate table is generated from a list of dicts, so the column order
-    # from `data` is not preserved. We can use `select` to reorder the columns
-    #
-    # If there is no data, create an empty table with the specified columns
+    The agate table is generated from a list of dicts, so the column order
+    from `data` is not preserved. We can use `select` to reorder the columns
 
+    If there is no data, create an empty table with the specified columns
+    """
     if len(data) == 0:
         return agate.Table([], column_names=column_names)
     else:
@@ -107,13 +108,13 @@ def table_from_data(data, column_names: Iterable[str]) -> agate.Table:
 
 
 def table_from_data_flat(data, column_names: Iterable[str]) -> agate.Table:
-    """
-    Convert a list of dictionaries into an Agate table. This method does not
+    """Convert a list of dictionaries into an Agate table.
+
+    This method does not
     coerce string values into more specific types (eg. '005' will not be
     coerced to '5'). Additionally, this method does not coerce values to
     None (eg. '' or 'null' will retain their string literal representations).
     """
-
     rows = []
     text_only_columns = set()
     for _row in data:
@@ -130,18 +131,21 @@ def table_from_data_flat(data, column_names: Iterable[str]) -> agate.Table:
 
         rows.append(row)
 
-    return table_from_rows(rows=rows, column_names=column_names, text_only_columns=text_only_columns)
+    return table_from_rows(
+        rows=rows, column_names=column_names, text_only_columns=text_only_columns
+    )
 
 
 def empty_table():
-    "Returns an empty Agate table. To be used in place of None"
+    """Returns an empty Agate table.
 
+    To be used in place of None
+    """
     return agate.Table(rows=[])
 
 
 def as_matrix(table):
-    "Return an agate table as a matrix of data sans columns"
-
+    """Return an agate table as a matrix of data sans columns."""
     return [r.values() for r in table.rows.values()]
 
 
@@ -176,7 +180,8 @@ class ColumnTypeBuilder(Dict[str, NullableAgateType]):
         elif isinstance(value, _NullMarker):
             # use the existing value
             return
-        # when one table column is Number while another is Integer, force the column to Number on merge
+        # when one table column is Number while another is Integer,
+        # force the column to Number on merge
         elif isinstance(value, Integer) and isinstance(existing_type, agate.data_types.Number):
             # use the existing value
             return
@@ -203,8 +208,11 @@ class ColumnTypeBuilder(Dict[str, NullableAgateType]):
 
 
 def _merged_column_types(tables: List[agate.Table]) -> Dict[str, agate.data_types.DataType]:
-    # this is a lot like agate.Table.merge, but with handling for all-null
-    # rows being "any type".
+    """Custom version of agate.Table.merge.
+
+    this is a lot like agate.Table.merge, but with handling for all-null
+    rows being "any type".
+    """
     new_columns: ColumnTypeBuilder = ColumnTypeBuilder()
     for table in tables:
         for i in range(len(table.columns)):
@@ -219,8 +227,9 @@ def _merged_column_types(tables: List[agate.Table]) -> Dict[str, agate.data_type
 
 
 def merge_tables(tables: List[agate.Table]) -> agate.Table:
-    """This is similar to agate.Table.merge, but it handles rows of all 'null'
-    values more gracefully during merges.
+    """This is similar to agate.Table.merge.
+
+    This handles rows of all 'null' values more gracefully during merges.
     """
     new_columns = _merged_column_types(tables)
     column_names = tuple(new_columns.keys())

dbt_common/clients/jinja.py

@@ -9,14 +9,15 @@ from itertools import chain, islice
 from typing import Any, Callable, Dict, Iterator, List, Mapping, Optional, Union, Set, Type
 from typing_extensions import Protocol
 
-import jinja2
-import jinja2.ext
+import jinja2  # type: ignore
+import jinja2.ext  # type: ignore
 import jinja2.nativetypes  # type: ignore
-import jinja2.nodes
-import jinja2.parser
-import jinja2.sandbox
+import jinja2.nodes  # type: ignore
+import jinja2.parser  # type: ignore
+import jinja2.sandbox  # type: ignore
 
-from dbt_common.utils import (
+from dbt_common.tests import test_caching_enabled
+from dbt_common.utils.jinja import (
     get_dbt_macro_name,
     get_docs_macro_name,
     get_materialization_macro_name,
@@ -86,7 +87,13 @@ class MacroFuzzEnvironment(jinja2.sandbox.SandboxedEnvironment):
         return MacroFuzzParser(self, source, name, filename).parse()
 
     def _compile(self, source, filename):
-        """Override jinja's compilation to stash the rendered source inside
+        """
+
+
+
+
+
+        Override jinja's compilation. Use to stash the rendered source inside
         the python linecache for debugging when the appropriate environment
         variable is set.
 
@@ -112,7 +119,10 @@ class MacroFuzzTemplate(jinja2.nativetypes.NativeTemplate):
         # This custom override makes the assumption that the locals and shared
         # parameters are not used, so enforce that.
         if shared or locals:
-            raise Exception("The MacroFuzzTemplate.new_context() override cannot use the shared or locals parameters.")
+            raise Exception(
+                "The MacroFuzzTemplate.new_context() override cannot use the "
+                "shared or locals parameters."
+            )
 
         parent = ChainMap(vars, self.globals) if self.globals else vars
 
@@ -120,7 +130,9 @@ class MacroFuzzTemplate(jinja2.nativetypes.NativeTemplate):
 
     def render(self, *args: Any, **kwargs: Any) -> Any:
         if kwargs or len(args) != 1:
-            raise Exception("The MacroFuzzTemplate.render() override requires exactly one argument.")
+            raise Exception(
+                "The MacroFuzzTemplate.render() override requires exactly one argument."
+            )
 
         ctx = self.new_context(args[0])
 
@@ -140,16 +152,14 @@ class NativeSandboxEnvironment(MacroFuzzEnvironment):
 
 
 class TextMarker(str):
-    """A special native-env marker that indicates a value is text and is
-    not to be evaluated. Use this to prevent your numbery-strings from becoming
-    numbers!
+    """A special native-env marker that indicates a value is text and is not to be evaluated.
+
+    Use this to prevent your numbery-strings from becoming numbers!
     """
 
 
 class NativeMarker(str):
-    """A special native-env marker that indicates the field should be passed to
-    literal_eval.
-    """
+    """A special native-env marker that indicates the field should be passed to literal_eval."""
 
 
 class BoolMarker(NativeMarker):
@@ -165,7 +175,9 @@ def _is_number(value) -> bool:
 
 
 def quoted_native_concat(nodes):
-    """This is almost native_concat from the NativeTemplate, except in the
+    """Handle special case for native_concat from the NativeTemplate.
+
+    This is almost native_concat from the NativeTemplate, except in the
     special case of a single argument that is a quoted string and returns a
     string, the quotes are re-inserted.
     """
@@ -201,9 +213,10 @@ class NativeSandboxTemplate(jinja2.nativetypes.NativeTemplate):  # mypy: ignore
     environment_class = NativeSandboxEnvironment  # type: ignore
 
     def render(self, *args, **kwargs):
-        """Render the template to produce a native Python type. If the
-        result is a single node, its value is returned. Otherwise, the
-        nodes are concatenated as strings. If the result can be parsed
+        """Render the template to produce a native Python type.
+
+        If the result is a single node, its value is returned. Otherwise,
+        the nodes are concatenated as strings. If the result can be parsed
         with :func:`ast.literal_eval`, the parsed value is returned.
         Otherwise, the string is returned.
         """
@@ -415,7 +428,9 @@ def create_undefined(node=None):
 
         def __getattr__(self, name):
             if name == "name" or _is_dunder_name(name):
-                raise AttributeError("'{}' object has no attribute '{}'".format(type(self).__name__, name))
+                raise AttributeError(
+                    "'{}' object has no attribute '{}'".format(type(self).__name__, name)
+                )
 
             self.name = name
 
@@ -463,7 +478,6 @@ def get_environment(
     args["extensions"].append(TestExtension)
 
     env_cls: Type[jinja2.Environment]
-    text_filter: Type
     if native:
         env_cls = NativeSandboxEnvironment
         filters = NATIVE_FILTERS
@@ -491,9 +505,19 @@ def catch_jinja(node=None) -> Iterator[None]:
         raise
 
 
+_TESTING_PARSE_CACHE: Dict[str, jinja2.Template] = {}
+
+
 def parse(string):
+    str_string = str(string)
+    if test_caching_enabled() and str_string in _TESTING_PARSE_CACHE:
+        return _TESTING_PARSE_CACHE[str_string]
+
     with catch_jinja():
-        return get_environment().parse(str(string))
+        parsed = get_environment().parse(str(string))
+        if test_caching_enabled():
+            _TESTING_PARSE_CACHE[str_string] = parsed
+        return parsed
 
 
 def get_template(
@@ -515,15 +539,25 @@ def render_template(template, ctx: Dict[str, Any], node=None) -> str:
         return template.render(ctx)
 
 
+_TESTING_BLOCKS_CACHE: Dict[int, List[Union[BlockData, BlockTag]]] = {}
+
+
+def _get_blocks_hash(text: str, allowed_blocks: Optional[Set[str]], collect_raw_data: bool) -> int:
+    """Provides a hash function over the arguments to extract_toplevel_blocks, in order to support caching."""
+    allowed_tuple = tuple(sorted(allowed_blocks) or [])
+    return text.__hash__() + allowed_tuple.__hash__() + collect_raw_data.__hash__()
+
+
 def extract_toplevel_blocks(
     text: str,
     allowed_blocks: Optional[Set[str]] = None,
     collect_raw_data: bool = True,
 ) -> List[Union[BlockData, BlockTag]]:
-    """Extract the top-level blocks with matching block types from a jinja
-    file, with some special handling for block nesting.
+    """Extract the top-level blocks with matching block types from a jinja file.
+
+    Includes some special handling for block nesting.
 
-    :param data: The data to extract blocks from.
+    :param text: The data to extract blocks from.
     :param allowed_blocks: The names of the blocks to extract from the file.
         They may not be nested within if/for blocks. If None, use the default
         values.
@@ -534,5 +568,19 @@ def extract_toplevel_blocks(
     :return: A list of `BlockTag`s matching the allowed block types and (if
         `collect_raw_data` is `True`) `BlockData` objects.
     """
+
+    if test_caching_enabled():
+        hash = _get_blocks_hash(text, allowed_blocks, collect_raw_data)
+        if hash in _TESTING_BLOCKS_CACHE:
+            return _TESTING_BLOCKS_CACHE[hash]
+
     tag_iterator = TagIterator(text)
-    return BlockIterator(tag_iterator).lex_for_blocks(allowed_blocks=allowed_blocks, collect_raw_data=collect_raw_data)
+    blocks = BlockIterator(tag_iterator).lex_for_blocks(
+        allowed_blocks=allowed_blocks, collect_raw_data=collect_raw_data
+    )
+
+    if test_caching_enabled():
+        hash = _get_blocks_hash(text, allowed_blocks, collect_raw_data)
+        _TESTING_BLOCKS_CACHE[hash] = blocks
+
+    return blocks

dbt_common/clients/system.py

@@ -41,7 +41,8 @@ def find_matching(
     file_pattern: str,
     ignore_spec: Optional[PathSpec] = None,
 ) -> List[Dict[str, Any]]:
-    """
+    """Return file info from paths and patterns.
+
     Given an absolute `root_path`, a list of relative paths to that
     absolute root path (`relative_paths_to_search`), and a `file_pattern`
     like '*.sql', returns information about the files. For example:
@@ -78,7 +79,9 @@ def find_matching(
                 relative_path_to_root = os.path.join(relative_path_to_search, relative_path)
 
                 modification_time = os.path.getmtime(absolute_path)
-                if reobj.match(local_file) and (not ignore_spec or not ignore_spec.match_file(relative_path_to_root)):
+                if reobj.match(local_file) and (
+                    not ignore_spec or not ignore_spec.match_file(relative_path_to_root)
+                ):
                     matching.append(
                         {
                             "searched_path": relative_path_to_search,
@@ -104,7 +107,8 @@ def load_file_contents(path: str, strip: bool = True) -> str:
 
 @functools.singledispatch
 def make_directory(path=None) -> None:
-    """
+    """Handle directory creation with threading.
+
     Make a directory and any intermediate directories that don't already
     exist. This function handles the case where two threads try to create
     a directory at once.
@@ -133,7 +137,8 @@ def _(path: Path) -> None:
 
 
 def make_file(path: str, contents: str = "", overwrite: bool = False) -> bool:
-    """
+    """Make a file with `contents` at `path`.
+
     Make a file at `path` assuming that the directory it resides in already
     exists. The file is saved with contents `contents`
     """
@@ -147,9 +152,7 @@ def make_file(path: str, contents: str = "", overwrite: bool = False) -> bool:
 
 
 def make_symlink(source: str, link_path: str) -> None:
-    """
-    Create a symlink at `link_path` referring to `source`.
-    """
+    """Create a symlink at `link_path` referring to `source`."""
     if not supports_symlinks():
         # TODO: why not import these at top?
         raise dbt_common.exceptions.SymbolicLinkError()
@@ -209,9 +212,7 @@ def _windows_rmdir_readonly(func: Callable[[str], Any], path: str, exc: Tuple[An
 
 
 def resolve_path_from_base(path_to_resolve: str, base_path: str) -> str:
-    """
-    If path_to_resolve is a relative path, create an absolute path
-    with base_path as the base.
+    """If path_to_resolve is a relative path, create an absolute path with base_path as the base.
 
     If path_to_resolve is an absolute path or a user path (~), just
     resolve it to an absolute path and return.
@@ -220,8 +221,9 @@ def resolve_path_from_base(path_to_resolve: str, base_path: str) -> str:
 
 
 def rmdir(path: str) -> None:
-    """
-    Recursively deletes a directory. Includes an error handler to retry with
+    """Recursively deletes a directory.
+
+    Includes an error handler to retry with
     different permissions on Windows. Otherwise, removing directories (eg.
     cloned via git) can cause rmtree to throw a PermissionError exception
     """
@@ -235,9 +237,7 @@ def rmdir(path: str) -> None:
 
 
 def _win_prepare_path(path: str) -> str:
-    """Given a windows path, prepare it for use by making sure it is absolute
-    and normalized.
-    """
+    """Given a windows path, prepare it for use by making sure it is absolute and normalized."""
     path = os.path.normpath(path)
 
     # if a path starts with '\', splitdrive() on it will return '' for the
@@ -281,7 +281,9 @@ def _supports_long_paths() -> bool:
 
 
 def convert_path(path: str) -> str:
-    """Convert a path that dbt has, which might be >260 characters long, to one
+    """Handle path length for windows.
+
+    Convert a path that dbt has, which might be >260 characters long, to one
     that will be writable/readable on Windows.
 
     On other platforms, this is a no-op.
@@ -387,14 +389,18 @@ def _handle_windows_error(exc: OSError, cwd: str, cmd: List[str]) -> NoReturn:
     cls: Type[dbt_common.exceptions.DbtBaseException] = dbt_common.exceptions.base.CommandError
     if exc.errno == errno.ENOENT:
         message = (
-            "Could not find command, ensure it is in the user's PATH " "and that the user has permissions to run it"
+            "Could not find command, ensure it is in the user's PATH "
+            "and that the user has permissions to run it"
         )
         cls = dbt_common.exceptions.ExecutableError
     elif exc.errno == errno.ENOEXEC:
         message = "Command was not executable, ensure it is valid"
         cls = dbt_common.exceptions.ExecutableError
     elif exc.errno == errno.ENOTDIR:
-        message = "Unable to cd: path does not exist, user does not have" " permissions, or not a directory"
+        message = (
+            "Unable to cd: path does not exist, user does not have"
+            " permissions, or not a directory"
+        )
         cls = dbt_common.exceptions.WorkingDirectoryError
     else:
         message = 'Unknown error: {} (errno={}: "{}")'.format(
@@ -415,7 +421,9 @@ def _interpret_oserror(exc: OSError, cwd: str, cmd: List[str]) -> NoReturn:
         _handle_posix_error(exc, cwd, cmd)
 
     # this should not be reachable, raise _something_ at least!
-    raise dbt_common.exceptions.DbtInternalError("Unhandled exception in _interpret_oserror: {}".format(exc))
+    raise dbt_common.exceptions.DbtInternalError(
+        "Unhandled exception in _interpret_oserror: {}".format(exc)
+    )
 
 
 def run_cmd(cwd: str, cmd: List[str], env: Optional[Dict[str, Any]] = None) -> Tuple[bytes, bytes]:
@@ -434,7 +442,9 @@ def run_cmd(cwd: str, cmd: List[str], env: Optional[Dict[str, Any]] = None) -> T
         exe_pth = shutil.which(cmd[0])
         if exe_pth:
             cmd = [os.path.abspath(exe_pth)] + list(cmd[1:])
-        proc = subprocess.Popen(cmd, cwd=cwd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=full_env)
+        proc = subprocess.Popen(
+            cmd, cwd=cwd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=full_env
+        )
 
         out, err = proc.communicate()
     except OSError as exc:
@@ -450,7 +460,9 @@ def run_cmd(cwd: str, cmd: List[str], env: Optional[Dict[str, Any]] = None) -> T
     return out, err
 
 
-def download_with_retries(url: str, path: str, timeout: Optional[Union[float, tuple]] = None) -> None:
+def download_with_retries(
+    url: str, path: str, timeout: Optional[Union[float, tuple]] = None
+) -> None:
     download_fn = functools.partial(download, url, path, timeout)
     connection_exception_retry(download_fn, 5)
 
@@ -496,6 +508,7 @@ def untar_package(tar_path: str, dest_dir: str, rename_to: Optional[str] = None)
 
 def chmod_and_retry(func, path, exc_info):
     """Define an error handler to pass to shutil.rmtree.
+
     On Windows, when a file is marked read-only as git likes to do, rmtree will
     fail. To handle that, on errors try to make the file writable.
     We want to retry most operations here, but listdir is one that we know will
@@ -513,7 +526,9 @@ def _absnorm(path):
 
 
 def move(src, dst):
-    """A re-implementation of shutil.move that properly removes the source
+    """A re-implementation of shutil.move for windows fun.
+
+    A re-implementation of shutil.move that properly removes the source
     directory on windows when it has read-only files in it and the move is
     between two drives.
 
@@ -541,7 +556,9 @@ def move(src, dst):
         if os.path.isdir(src):
             if _absnorm(dst + "\\").startswith(_absnorm(src + "\\")):
                 # dst is inside src
-                raise EnvironmentError("Cannot move a directory '{}' into itself '{}'".format(src, dst))
+                raise EnvironmentError(
+                    "Cannot move a directory '{}' into itself '{}'".format(src, dst)
+                )
             shutil.copytree(src, dst, symlinks=True)
             rmtree(src)
         else:
@@ -550,8 +567,9 @@ def move(src, dst):
 
 
 def rmtree(path):
-    """Recursively remove the path. On permissions errors on windows, try to remove
-    the read-only flag and try again.
+    """Recursively remove the path.
+
+    On permissions errors on windows, try to remove the read-only flag and try again.
     """
     path = convert_path(path)
     return shutil.rmtree(path, onerror=chmod_and_retry)

dbt_common/context.py

@@ -0,0 +1,48 @@
+from contextvars import ContextVar, copy_context
+from typing import List, Mapping, Optional
+
+from dbt_common.constants import SECRET_ENV_PREFIX
+
+
+class InvocationContext:
+    def __init__(self, env: Mapping[str, str]):
+        self._env = env
+        self._env_secrets: Optional[List[str]] = None
+        # This class will also eventually manage the invocation_id, flags, event manager, etc.
+
+    @property
+    def env(self) -> Mapping[str, str]:
+        return self._env
+
+    @property
+    def env_secrets(self) -> List[str]:
+        if self._env_secrets is None:
+            self._env_secrets = [
+                v for k, v in self.env.items() if k.startswith(SECRET_ENV_PREFIX) and v.strip()
+            ]
+        return self._env_secrets
+
+
+_INVOCATION_CONTEXT_VAR: ContextVar[InvocationContext] = ContextVar("DBT_INVOCATION_CONTEXT_VAR")
+
+
+def reliably_get_invocation_var() -> ContextVar:
+    invocation_var: Optional[ContextVar] = next(
+        (cv for cv in copy_context() if cv.name == _INVOCATION_CONTEXT_VAR.name), None
+    )
+
+    if invocation_var is None:
+        invocation_var = _INVOCATION_CONTEXT_VAR
+
+    return invocation_var
+
+
+def set_invocation_context(env: Mapping[str, str]) -> None:
+    invocation_var = reliably_get_invocation_var()
+    invocation_var.set(InvocationContext(env))
+
+
+def get_invocation_context() -> InvocationContext:
+    invocation_var = reliably_get_invocation_var()
+    ctx = invocation_var.get()
+    return ctx