cumulusci-plus 5.0.14__py3-none-any.whl → 5.0.16__py3-none-any.whl

cumulusci/__about__.py

@@ -1 +1 @@
-__version__ = "5.0.14"
+__version__ = "5.0.16"

cumulusci/cli/cci.py

@@ -1,5 +1,6 @@
 import code
 import contextlib
+import os
 import pdb
 import runpy
 import signal
@@ -79,8 +80,33 @@ def _cleanup_on_signal(signum):
         except Exception as e:
             console.print(f"[red]Error during cleanup: {e}[/red]")
 
-    # The parent process's trap is now responsible for killing the process group.
-    # This process will exit gracefully after receiving the signal from the parent.
+    # Terminate child processes in the process group
+    try:
+        console.print("[yellow]Terminating child processes...[/yellow]")
+
+        # Temporarily ignore the signal to prevent recursion
+        old_handler = signal.signal(signum, signal.SIG_IGN)
+
+        try:
+            # Only use process group termination on Unix systems
+            if hasattr(os, "getpgrp") and hasattr(os, "killpg"):
+                pgrp = os.getpgrp()
+                # Send signal to all processes in the group except ourselves
+                os.killpg(pgrp, signum)
+            else:
+                # On Windows, we can't use process groups, so just log the attempt
+                console.print(
+                    "[yellow]Process group termination not supported on this platform[/yellow]"
+                )
+        finally:
+            # Restore the original signal handler
+            signal.signal(signum, old_handler)
+
+    except ProcessLookupError:
+        # Process group may not exist or may already be terminated
+        pass
+    except Exception as e:
+        console.print(f"[red]Warning: Error terminating child processes: {e}[/red]")
 
     # Exit with appropriate failure code
     exit_code = 143 if signum == signal.SIGTERM else 130  # Standard exit codes
@@ -104,8 +130,15 @@ def main(args=None):
     """
     global _exit_stack
 
-    # By not creating a new process group, cci remains in the parent's group.
-    # This allows the parent's trap command to correctly terminate cci and its children.
+    # Create a new process group so we can terminate all child processes
+    # when we receive a termination signal
+    try:
+        if hasattr(os, "setpgrp"):
+            # On Unix systems, create a new process group
+            os.setpgrp()
+    except Exception:
+        # On Windows or if setpgrp fails, continue without process group
+        pass
 
     # Set up signal handlers for graceful termination
     signal.signal(signal.SIGTERM, _signal_handler)
@@ -152,7 +185,10 @@ def main(args=None):
             try:
                 cli(args[1:], standalone_mode=False, obj=runtime)
             except click.Abort:  # Keyboard interrupt
-                _cleanup_on_signal(signal.SIGINT)
+                if _exit_stack:
+                    _exit_stack.close()
+                Console(stderr=True).print("[yellow]Aborted![/yellow]")
+                sys.exit(1)
             except Exception as e:
                 if debug:
                     console = Console()

cumulusci/core/dependencies/base.py

@@ -24,7 +24,11 @@ from cumulusci.core.sfdx import (
 from cumulusci.core.utils import format_duration
 from cumulusci.salesforce_api.metadata import ApiDeploy
 from cumulusci.salesforce_api.package_zip import MetadataPackageZipBuilder
-from cumulusci.utils import download_extract_vcs_from_repo, temporary_dir
+from cumulusci.utils import (
+    download_extract_vcs_from_repo,
+    get_tasks_with_options,
+    temporary_dir,
+)
 from cumulusci.utils.yaml.model_parser import HashableBaseModel
 from cumulusci.utils.ziputils import zip_subfolder
 from cumulusci.vcs.models import AbstractRepo
@@ -676,15 +680,15 @@ class UnmanagedVcsDependencyFlow(UnmanagedStaticDependency, ABC):
             "namespace_strip": self.namespace_strip,
         }
 
+        coordinator_opts = get_tasks_with_options(
+            project_config, frozenset(pre_post_options.items())
+        )
+
         coordinator = FlowCoordinator(
             project_config,
             flow_config,
             name=flow_config.name,
-            options={
-                "deploy_pre": pre_post_options,
-                "deploy_post": pre_post_options,
-                "update_admin_profile": pre_post_options,
-            },
+            options=coordinator_opts,
             skip=None,
             callbacks=self.callback_class(),
         )

cumulusci/core/dependencies/tests/test_dependencies.py

@@ -1018,6 +1018,7 @@ class TestUnmanagedVcsDependencyFlow:
         # Setup flow config mock
         mock_flow_config = mock.Mock()
         mock_project_config.get_flow.return_value = mock_flow_config
+        mock_project_config.list_tasks.return_value = []
 
         # Setup coordinator mock
         mock_coordinator_instance = mock.Mock()
@@ -1076,11 +1077,7 @@ class TestUnmanagedVcsDependencyFlow:
         assert args[0] == mock_project_config
         assert args[1] == mock_flow_config
         assert kwargs["name"] == "install_deps"
-        assert kwargs["options"] == {
-            "unmanaged": True,  # _get_unmanaged should return True for empty installed_packages
-            "namespace_inject": "test_ns",
-            "namespace_strip": "old_ns",
-        }
+        assert kwargs["options"] == {}
         assert kwargs["skip"] is None
         assert isinstance(kwargs["callbacks"], type(flow_dep.callback_class()))
 

cumulusci/cumulusci.yml

@@ -749,6 +749,10 @@ tasks:
         options:
             level: info
         group: Utilities
+    configure_env:
+        description: Get or set environment variables.
+        class_path: cumulusci.tasks.utility.env_management.EnvManagement
+        group: Utilities
     download_extract:
         description: Downloads files and folders from a VCS repository.
         class_path: cumulusci.tasks.vcs.download_extract.DownloadExtract

cumulusci/tasks/utility/env_management.py

@@ -0,0 +1,157 @@
+import json
+import os
+from datetime import date
+from pathlib import Path
+from typing import Any, List, Optional
+
+from pydantic import BaseModel, validator
+
+from cumulusci.core.config import BaseProjectConfig, OrgConfig, TaskConfig
+from cumulusci.core.tasks import BaseTask
+from cumulusci.utils.options import CCIOptions, Field
+from cumulusci.vcs.bootstrap import get_repo_from_url
+
+
+class EnvManagementOption(CCIOptions):
+    name: str = Field(
+        ...,
+        description="The name of the environment variable to get the value from the environment",
+    )
+    default: Any = Field(
+        default=None,
+        description="The default value of the environment variable. Defaults to None",
+    )
+    datatype: str = Field(
+        default="string",
+        description="The datatype of the environment variable. Defaults to string. Valid values are string, bool, int, float, date, list, dict, path, directory, filename, vcs_branch",
+    )
+    set: bool = Field(
+        default=False,
+        description="If True, sets the value of the environment variable if it is not already set. Defaults to False",
+    )
+    url: str = Field(
+        default="",
+        description="The url of the repository to get the branch value from, Applicable only for vcs_branch datatype. Defaults to empty string",
+    )
+
+    @validator("datatype")
+    def validate_datatype(cls, v):
+        if v not in [
+            "string",
+            "bool",
+            "int",
+            "float",
+            "date",
+            "list",
+            "dict",
+            "path",
+            "directory",
+            "filename",
+            "vcs_branch",
+        ]:
+            raise ValueError(f"Invalid datatype: {v}")
+        return v
+
+    def formated_value(
+        self,
+        project_config: Optional[BaseProjectConfig],
+        org_config: Optional[OrgConfig],
+    ) -> tuple[Any, str]:
+        value = os.getenv(self.name, self.default)
+        datatype = self.datatype or "string"
+
+        try:
+            match datatype:
+                case "string":
+                    return str(value), str(value)
+                case "bool":
+                    v = DummyValidatorModel(b=value).b
+                    return v, str(v)
+                case "int":
+                    v = DummyValidatorModel(i=value).i
+                    return v, str(v)
+                case "float":
+                    v = DummyValidatorModel(f=value).f
+                    return v, str(v)
+                case "date":
+                    v = DummyValidatorModel(d=date.fromisoformat(str(value))).d
+                    return v, str(v)
+                case "list":
+                    v = value if isinstance(value, list) else value.split(",")
+                    return v, str(v)
+                case "dict":
+                    v = value if isinstance(value, dict) else json.loads(str(value))
+                    return v, str(v)
+                case "path":
+                    v = Path(str(value))
+                    return v.absolute(), str(v.absolute())
+                case "directory":
+                    v = Path(str(value)).parent.absolute()
+                    return v, str(v.absolute())
+                case "filename":
+                    v = Path(str(value)).name
+                    return v, str(v)
+                case "vcs_branch":
+                    task_config = TaskConfig({"options": {"url": self.url}})
+                    task = VcsRemoteBranch(project_config, task_config, org_config)
+                    result = task()
+                    return result["remote_branch"], str(result["remote_branch"])
+                case _:
+                    raise ValueError(f"Invalid datatype: {datatype}")
+        except Exception as e:
+            raise ValueError(
+                f"Formatting Error: {value} for datatype: {datatype} - {e}"
+            )
+
+
+class DummyValidatorModel(BaseModel):
+    b: Optional[bool]
+    i: Optional[int]
+    f: Optional[float]
+    d: Optional[date]
+
+
+class EnvManagement(BaseTask):
+    class Options(CCIOptions):
+        envs: List[EnvManagementOption] = Field(
+            default=[],
+            description="A list of environment variables definitions.",
+        )
+
+    parsed_options: Options
+
+    def _run_task(self):
+        self.return_values = {}
+
+        for env_option in self.parsed_options.envs:
+            self.return_values[env_option.name], str_value = env_option.formated_value(
+                self.project_config, self.org_config
+            )
+            if env_option.set and env_option.name not in os.environ:
+                os.environ[env_option.name] = str_value
+
+        return self.return_values
+
+
+class VcsRemoteBranch(BaseTask):
+    class Options(CCIOptions):
+        url: str = Field(
+            ...,
+            description="Gets if the remote branch name exist with the same name in the remote repository.",
+        )
+
+    parsed_options: Options
+
+    def _run_task(self):
+        self.return_values = {}
+        # Get current branch name.
+        local_branch = self.project_config.repo_branch
+        repo = get_repo_from_url(self.project_config, self.parsed_options.url)
+
+        try:
+            branch = repo.branch(local_branch)
+            self.return_values["remote_branch"] = branch.name
+        except Exception:
+            self.return_values["remote_branch"] = repo.default_branch
+
+        return self.return_values

cumulusci/tasks/utility/tests/test_env_management.py

@@ -0,0 +1,220 @@
+import os
+import unittest
+from datetime import date
+from pathlib import Path
+from unittest.mock import Mock, patch
+
+from cumulusci.core.config import TaskConfig
+from cumulusci.tasks.utility.env_management import (
+    EnvManagement,
+    EnvManagementOption,
+    VcsRemoteBranch,
+)
+from cumulusci.tests.util import create_project_config
+
+
+class TestVcsRemoteBranch(unittest.TestCase):
+    def test_run_task_branch_exists(self):
+        project_config = create_project_config()
+        project_config.repo_info["branch"] = "feature/branch-1"
+        task_config = TaskConfig(
+            {"options": {"url": "https://github.com/TestOwner/TestRepo"}}
+        )
+
+        with patch(
+            "cumulusci.tasks.utility.env_management.get_repo_from_url"
+        ) as get_repo_mock:
+            repo_mock = Mock()
+            branch_mock = Mock()
+            branch_mock.name = "feature/branch-1"
+            repo_mock.branch.return_value = branch_mock
+            get_repo_mock.return_value = repo_mock
+
+            task = VcsRemoteBranch(project_config, task_config)
+            task()
+            self.assertEqual(task.return_values["remote_branch"], "feature/branch-1")
+            repo_mock.branch.assert_called_once_with("feature/branch-1")
+
+    def test_run_task_branch_not_exist(self):
+        project_config = create_project_config()
+        project_config.repo_info["branch"] = "feature/branch-1"
+        task_config = TaskConfig(
+            {"options": {"url": "https://github.com/TestOwner/TestRepo"}}
+        )
+
+        with patch(
+            "cumulusci.tasks.utility.env_management.get_repo_from_url"
+        ) as get_repo_mock:
+            repo_mock = Mock()
+            repo_mock.branch.side_effect = Exception("Branch not found")
+            repo_mock.default_branch = "main"
+            get_repo_mock.return_value = repo_mock
+
+            task = VcsRemoteBranch(project_config, task_config)
+            task()
+            self.assertEqual(task.return_values["remote_branch"], "main")
+            repo_mock.branch.assert_called_once_with("feature/branch-1")
+
+
+class TestEnvManagement(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.project_config = create_project_config()
+        cls.org_config = Mock()
+
+    def test_init_options(self):
+        task_config = TaskConfig(
+            {
+                "options": {
+                    "envs": [
+                        {"name": "MY_VAR", "default": "default_val"},
+                        {"name": "MY_BOOL", "datatype": "bool", "default": "true"},
+                    ]
+                }
+            }
+        )
+        task = EnvManagement(self.project_config, task_config)
+        self.assertEqual(len(task.parsed_options.envs), 2)
+        self.assertIsInstance(task.parsed_options.envs[0], EnvManagementOption)
+
+    @patch.dict(os.environ, {}, clear=True)
+    def test_run_task_get_values(self):
+        os.environ["MY_VAR"] = "env_val"
+        os.environ["MY_INT"] = "123"
+        os.environ["MY_DATE"] = "2023-10-26"
+        os.environ["MY_LIST"] = "a,b,c"
+
+        task_config = TaskConfig(
+            {
+                "options": {
+                    "envs": [
+                        {"name": "MY_VAR"},
+                        {"name": "MY_INT", "datatype": "int"},
+                        {"name": "MY_DATE", "datatype": "date"},
+                        {"name": "MY_LIST", "datatype": "list"},
+                        {"name": "NOT_SET", "default": "default_val"},
+                    ]
+                }
+            }
+        )
+        task = EnvManagement(self.project_config, task_config, self.org_config)
+        result = task()
+
+        self.assertEqual(
+            result,
+            {
+                "MY_VAR": "env_val",
+                "MY_INT": 123,
+                "MY_DATE": date(2023, 10, 26),
+                "MY_LIST": ["a", "b", "c"],
+                "NOT_SET": "default_val",
+            },
+        )
+        self.assertNotIn("NOT_SET", os.environ)
+
+    @patch.dict(os.environ, {}, clear=True)
+    def test_run_task_set_values(self):
+        os.environ["EXISTING_VAR"] = "original_value"
+        task_config = TaskConfig(
+            {
+                "options": {
+                    "envs": [
+                        {"name": "NEW_VAR", "default": "new_value", "set": True},
+                        {
+                            "name": "EXISTING_VAR",
+                            "default": "new_default",
+                            "set": True,
+                        },
+                    ]
+                }
+            }
+        )
+        task = EnvManagement(self.project_config, task_config, self.org_config)
+        task()
+
+        self.assertEqual(os.environ.get("NEW_VAR"), "new_value")
+        self.assertEqual(os.environ.get("EXISTING_VAR"), "original_value")
+
+    def test_datatype_validation(self):
+        with self.assertRaises(ValueError):
+            EnvManagementOption(name="test", datatype="invalid")
+
+    @patch.dict(os.environ, {}, clear=True)
+    def _test_datatype_conversion(self, datatype, env_value, expected_value):
+        os.environ["TEST_VAR"] = str(env_value)
+        task_config = TaskConfig(
+            {"options": {"envs": [{"name": "TEST_VAR", "datatype": datatype}]}}
+        )
+        task = EnvManagement(self.project_config, task_config, self.org_config)
+        result = task()
+        self.assertEqual(result["TEST_VAR"], expected_value)
+
+    def test_datatypes(self):
+        test_cases = [
+            ("string", "hello", "hello"),
+            ("bool", "true", True),
+            ("bool", "0", False),
+            ("int", "42", 42),
+            ("float", "3.14", 3.14),
+            ("date", "2024-01-01", date(2024, 1, 1)),
+            ("list", "one,two", ["one", "two"]),
+            ("dict", '{"key": "value"}', {"key": "value"}),
+            ("path", "/tmp/test", Path("/tmp/test").absolute()),
+            ("directory", "/tmp/test/file.txt", Path("/tmp/test").absolute()),
+            ("filename", "/tmp/test/file.txt", "file.txt"),
+        ]
+        for datatype, env_value, expected_value in test_cases:
+            with self.subTest(datatype=datatype):
+                self._test_datatype_conversion(datatype, env_value, expected_value)
+
+    def test_formatting_error(self):
+        os.environ["TEST_VAR"] = "not-an-int"
+        task_config = TaskConfig(
+            {"options": {"envs": [{"name": "TEST_VAR", "datatype": "int"}]}}
+        )
+        task = EnvManagement(self.project_config, task_config, self.org_config)
+        with self.assertRaises(ValueError):
+            task()
+
+    @patch("cumulusci.tasks.utility.env_management.VcsRemoteBranch")
+    def test_vcs_branch_datatype(self, vcs_mock):
+        os.environ["TEST_VAR"] = ""  # vcs_branch doesn't use env var
+
+        vcs_instance_mock = vcs_mock.return_value
+        vcs_instance_mock.return_value = {"remote_branch": "my-feature-branch"}
+
+        task_config = TaskConfig(
+            {
+                "options": {
+                    "envs": [
+                        {
+                            "name": "VCS_BRANCH",
+                            "datatype": "vcs_branch",
+                            "url": "https://github.com/TestOwner/TestRepo",
+                        }
+                    ]
+                }
+            }
+        )
+        task = EnvManagement(self.project_config, task_config, self.org_config)
+        result = task()
+
+        self.assertEqual(result["VCS_BRANCH"], "my-feature-branch")
+        vcs_mock.assert_called_once()
+
+    @patch.dict(os.environ, {}, clear=True)
+    def test_run_task_with_default_types(self):
+        task_config = TaskConfig(
+            {
+                "options": {
+                    "envs": [
+                        {"name": "MY_LIST", "datatype": "list", "default": ["a", "b"]},
+                        {"name": "MY_DICT", "datatype": "dict", "default": {"x": 1}},
+                    ]
+                }
+            }
+        )
+        task = EnvManagement(self.project_config, task_config, self.org_config)
+        result = task()
+        self.assertEqual(result["MY_LIST"], ["a", "b"])
+        self.assertEqual(result["MY_DICT"], {"x": 1})

cumulusci/utils/__init__.py

@@ -9,6 +9,7 @@ import sys
 import tempfile
 import textwrap
 import zipfile
+import functools
 from datetime import datetime
 from pathlib import Path
 from typing import Union, Optional
@@ -729,3 +730,18 @@ def filter_namelist(includes, namelist):
             if name.startswith(tuple(included_dirs)) or name in includes
         }
     )
+
+
+@functools.lru_cache(50)
+def get_tasks_with_options(project_config, frozen_options: frozenset):
+    coordinator_opts = {}
+    options = dict(frozen_options)
+    for task_config in project_config.list_tasks():
+        if any(
+            key in options.keys()
+            for key in project_config.get_task(task_config["name"])
+            .get_class()
+            .task_options.keys()
+        ):
+            coordinator_opts[task_config["name"]] = options
+    return coordinator_opts

{cumulusci_plus-5.0.14.dist-info → cumulusci_plus-5.0.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cumulusci-plus
-Version: 5.0.14
+Version: 5.0.16
 Summary: Build and release tools for Salesforce developers
 Project-URL: Homepage, https://github.com/jorgesolebur/CumulusCI
 Project-URL: Changelog, https://cumulusci.readthedocs.io/en/stable/history.html
@@ -127,7 +127,7 @@ license](https://github.com/SFDO-Tooling/CumulusCI/blob/main/LICENSE)
 and is not covered by the Salesforce Master Subscription Agreement.
 
 <!-- Changelog -->
-## v5.0.14 (2025-07-30)
+## v5.0.16 (2025-08-20)
 
 <!-- Release notes generated using configuration in .github/release.yml at main -->
 
@@ -135,6 +135,6 @@ and is not covered by the Salesforce Master Subscription Agreement.
 
 ### Changes
 
-- Fix docutils version. by [@rupeshjSFDC](https://github.com/rupeshjSFDC) in [#53](https://github.com/jorgesolebur/CumulusCI/pull/53)
+- Add configure_env task and fix failing test classes. by [@rupeshjSFDC](https://github.com/rupeshjSFDC) in [#57](https://github.com/jorgesolebur/CumulusCI/pull/57)
 
-**Full Changelog**: https://github.com/jorgesolebur/CumulusCI/compare/v5.0.13...v5.0.14
+**Full Changelog**: https://github.com/jorgesolebur/CumulusCI/compare/v5.0.15...v5.0.16

{cumulusci_plus-5.0.14.dist-info → cumulusci_plus-5.0.16.dist-info}/RECORD

@@ -1,10 +1,10 @@
-cumulusci/__about__.py,sha256=1jzVR6O2nP6q8w5IHCni1R8c27ny9HfXrhDs3nYzb5k,23
+cumulusci/__about__.py,sha256=6Zfa5_jynCBYIvtkYN0Ygch4VWXnobnaeed612gFG18,23
 cumulusci/__init__.py,sha256=jdanFQ_i8vbdO7Eltsf4pOfvV4mwa_Osyc4gxWKJ8ng,764
 cumulusci/__main__.py,sha256=kgRH-n5AJrH_daCK_EJwH7azAUxdXEmpi-r-dPGMR6Y,43
 cumulusci/conftest.py,sha256=AIL98BDwNAQtdo8YFmLKwav0tmrQ5dpbw1cX2FyGouQ,5108
-cumulusci/cumulusci.yml,sha256=qJscpADSMzcxNYYapfbsZO2LXqjjyv7QLs62Pn2qALI,72445
+cumulusci/cumulusci.yml,sha256=h4Ywck_HV5PXqjdTvA6jMm8dxPLZi2tmFdwGmssnhdo,72617
 cumulusci/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cumulusci/cli/cci.py,sha256=ZSebArvNvIcHdoUQiNXhCpJroTn9MXE8xiBW3h1WLoQ,10548
+cumulusci/cli/cci.py,sha256=yAq8jFoGde6g_1TeAAjzZYsk77itiONCQGBFe3g3nOs,11836
 cumulusci/cli/error.py,sha256=znj0YN8D2Grozm1u7mZAsJlmmdGebbuy0c1ofQluL4Q,4410
 cumulusci/cli/flow.py,sha256=rN_9WL2Z6dcx-oRngChIgei3E5Qmg3XVzk5ND1o0i3s,6171
 cumulusci/cli/logger.py,sha256=bpzSD0Bm0BAwdNbVR6yZXMREh2vm7jOytZevEaNoVR4,2267
@@ -65,7 +65,7 @@ cumulusci/core/config/tests/test_config.py,sha256=ZtIQSIzQWebw7mYXgehnp3CvoatC_t
 cumulusci/core/config/tests/test_config_expensive.py,sha256=__3JEuoAQ8s5njTcbyZlpXHr0jR0Qtne96xyF7fzqjQ,30137
 cumulusci/core/config/tests/test_config_util.py,sha256=X1SY9PIhLoQuC8duBKgs804aghN3n12DhqiC_f6jSmM,3177
 cumulusci/core/dependencies/__init__.py,sha256=Txf4VCrRW-aREKHqzK3ZyauQMsgtCXjiLkQzpMQT0kI,1533
-cumulusci/core/dependencies/base.py,sha256=I2-UrkYdpMlnoT21iSlSuDdmKjDoK-hCxaviwUFNgSE,23420
+cumulusci/core/dependencies/base.py,sha256=JBLma_3fB5q-ee5zs-WpSX6hfbGJ09UYgs6vquROjiQ,23433
 cumulusci/core/dependencies/dependencies.py,sha256=74KjrCRn7AjKPBSGOm4pU34eJd8GSp1wNs7EFIC0wBE,8689
 cumulusci/core/dependencies/github.py,sha256=ozpRc5ADJsRDD5C_T-TLFygnBDE5Y9_03ZLCtZ-qr98,5897
 cumulusci/core/dependencies/github_resolvers.py,sha256=Em8p41Q-npoKv1ZAYNxXVrluQmYitzVfLLXlmln-MGw,9196
@@ -73,7 +73,7 @@ cumulusci/core/dependencies/resolvers.py,sha256=xWVijK6Eu-WFyGnQPFANLkZFTjq4NQYh
 cumulusci/core/dependencies/utils.py,sha256=y54fWqLZ8IUIV9i1b6WcDXIJsK0ygny5DTsZCXbgeoM,369
 cumulusci/core/dependencies/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cumulusci/core/dependencies/tests/conftest.py,sha256=rd0ZqpV6GTk7IRtPYJ7jyLWHM1g_xtZ4PABuvkN-TZY,11004
-cumulusci/core/dependencies/tests/test_dependencies.py,sha256=MiKet_2xCMhzyo3oz_DzBnwVBjfCetmbmpBVQVKMEpg,40705
+cumulusci/core/dependencies/tests/test_dependencies.py,sha256=1nE1dkhwOSWyIP3KWyy5GJrUa-DMDOGcoWxcoSRV3D0,40572
 cumulusci/core/dependencies/tests/test_github.py,sha256=_JiUh-xgGmnsA2X_57i3gOwcDv_xBj66mdhitcZ-APU,2765
 cumulusci/core/dependencies/tests/test_resolvers.py,sha256=kLnvs0QTDKQwkxZ_lAAcetWZUNwBoP-TJYp9fdgRbHU,36271
 cumulusci/core/keychain/__init__.py,sha256=UbuaIrKZSczVVqbG_7BHFTkQukbqinGJlJlQGIpIsOI,595
@@ -611,6 +611,8 @@ cumulusci/tasks/tests/test_pushfails.py,sha256=9JG9D0iD4dR-1fKheaRN7BEy3lzzuOKeR
 cumulusci/tasks/tests/test_salesforce.py,sha256=yCGtuHapxyAEmXQhuF2g2fh2naknTu7Md4OfEJQvGAA,2594
 cumulusci/tasks/tests/test_sfdx.py,sha256=oUbHo28d796m5RuskXMLitJw2rCLjjXIfxggzr4gsso,3545
 cumulusci/tasks/tests/test_util.py,sha256=D1T0QnvPTS0PHeZWo2xiVgE1jVTYcLzGTGHwEIoVmxk,7296
+cumulusci/tasks/utility/env_management.py,sha256=RIxciQHPVMnJjwNvYkeq30QrMISagF4qx2zSRiXjExQ,5382
+cumulusci/tasks/utility/tests/test_env_management.py,sha256=e0cVAohNzpDUPDvS5LrIcd2Cqv0pkQ_KYvjX6qsREj8,8155
 cumulusci/tasks/vcs/__init__.py,sha256=ZzpMZnhooXZ6r_ywBVTS3UNw9uMcXW6h33LylRqTDK0,700
 cumulusci/tasks/vcs/commit_status.py,sha256=hgPUVHeQyIfMsCuwrw2RI-ufnbjdRARc6HI3BEgdcxI,2332
 cumulusci/tasks/vcs/create_commit_status.py,sha256=kr_OFM3J32jxusS1og-K91Kl1F_Nr7SlevRsJKBhifs,1565
@@ -663,7 +665,7 @@ cumulusci/tests/shared_cassettes/vcr_string_templates/batchInfoList_xml.tpl,sha2
 cumulusci/tests/shared_cassettes/vcr_string_templates/batchInfo_xml.tpl,sha256=QVliMmBsCaTLx6ichcTSJEk58ejkNmKQfYchr8a62kE,553
 cumulusci/tests/shared_cassettes/vcr_string_templates/jobInfo_insert_xml.tpl,sha256=MELjgmEaKPEVMcZNO3s8fn5QjvN5qU7F1svg8tc5yoA,1113
 cumulusci/tests/shared_cassettes/vcr_string_templates/jobInfo_upsert_xml.tpl,sha256=Pk2twM954A_jndsGJXLhe1S00Sd64O6a2QNlnfj83Dw,1152
-cumulusci/utils/__init__.py,sha256=TbsOvc6CKWz4mV_ERaP_8LXMeTBMuU_mfs2Qq-02t08,25136
+cumulusci/utils/__init__.py,sha256=5_gbnBhl1MtXqzVT-8fhM9rA1eZ4811sk5wHuJWv5_I,25639
 cumulusci/utils/classutils.py,sha256=paXwI8ZkwLr0Wv2fhs99GXh4Jhoinye6m1UJPPrtJFM,322
 cumulusci/utils/collections.py,sha256=4XcsBCyDhNcxSL589Y6gjNONKeB7YLqQ-nlWmiZjIlo,691
 cumulusci/utils/deprecation.py,sha256=MDQ4kbAS3RhpVAA_WVCXRMDDEjJj3pq9eeBDyPNcEoc,216
@@ -736,9 +738,9 @@ cumulusci/vcs/tests/dummy_service.py,sha256=RltOUpMIhSDNrfxk0LhLqlH4ppC0sK6NC2cO
 cumulusci/vcs/tests/test_vcs_base.py,sha256=9mp6uZ3lTxY4onjUNCucp9N9aB3UylKS7_2Zu_hdAZw,24331
 cumulusci/vcs/tests/test_vcs_bootstrap.py,sha256=N0NA48-rGNIIjY3Z7PtVnNwHObSlEGDk2K55TQGI8g4,27954
 cumulusci/vcs/utils/__init__.py,sha256=py4fEcHM7Vd0M0XWznOlywxaeCtG3nEVGmELmEKVGU8,869
-cumulusci_plus-5.0.14.dist-info/METADATA,sha256=j6HdlytG8kBesRDoXxxoPH6DpsqTc8RPhpsP9m57nT0,5742
-cumulusci_plus-5.0.14.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cumulusci_plus-5.0.14.dist-info/entry_points.txt,sha256=nTtu04b9iLXhzADcTrb5PwmdXE6e2MTUAMh9OK6Z2pg,80
-cumulusci_plus-5.0.14.dist-info/licenses/AUTHORS.rst,sha256=PvewjKImdKPhhJ6xR2EEZ4T7GbpY2ZeAeyWm2aLtiMQ,676
-cumulusci_plus-5.0.14.dist-info/licenses/LICENSE,sha256=NFsF_s7RVXk2dU6tmRAN8wF45pnD98VZ5IwqOsyBcaU,1499
-cumulusci_plus-5.0.14.dist-info/RECORD,,
+cumulusci_plus-5.0.16.dist-info/METADATA,sha256=1w8L_cNeKkI7tHu_r8PY7nltM-adAck3ZpmjDqihHCk,5773
+cumulusci_plus-5.0.16.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cumulusci_plus-5.0.16.dist-info/entry_points.txt,sha256=nTtu04b9iLXhzADcTrb5PwmdXE6e2MTUAMh9OK6Z2pg,80
+cumulusci_plus-5.0.16.dist-info/licenses/AUTHORS.rst,sha256=PvewjKImdKPhhJ6xR2EEZ4T7GbpY2ZeAeyWm2aLtiMQ,676
+cumulusci_plus-5.0.16.dist-info/licenses/LICENSE,sha256=NFsF_s7RVXk2dU6tmRAN8wF45pnD98VZ5IwqOsyBcaU,1499
+cumulusci_plus-5.0.16.dist-info/RECORD,,