cumulusci-plus 5.0.21__py3-none-any.whl → 5.0.43__py3-none-any.whl

cumulusci/cli/tests/utils.py

@@ -17,10 +17,7 @@ def run_click_command(cmd, *args, **kw):
 
 def run_cli_command(*args, runtime=None, input=None, **kw):
     """Run a click command with arg parsing and injected CCI runtime object."""
-    if tuple(map(int, click.__version__.split("."))) >= (8, 1, 0):
-        runner = CliRunner()
-    else:
-        runner = CliRunner(mix_stderr=False)
+    runner = CliRunner()
     result = runner.invoke(
         cli,
         args,

cumulusci/core/config/__init__.py

@@ -68,6 +68,7 @@ class TaskConfig(BaseConfig):
     name: str
     checks: list
     project_config: "BaseProjectConfig"
+    is_global: bool
 
     # TODO: What if an intermediate repo "allows" a downstream repo?
     #       Only the top repo should be allowed to do so.

cumulusci/core/config/base_task_flow_config.py

@@ -1,5 +1,5 @@
 from difflib import get_close_matches
-from typing import Any, Dict, List
+from typing import Any, Dict, List, cast
 
 from cumulusci.core.config import BaseConfig, FlowConfig, TaskConfig
 from cumulusci.core.exceptions import (
@@ -7,6 +7,8 @@ from cumulusci.core.exceptions import (
     FlowNotFoundError,
     TaskNotFoundError,
 )
+from cumulusci.core.utils import merge_config
+from cumulusci.plugins.plugin_loader import load_plugins
 
 
 def list_infos(infos: dict) -> List[Dict[str, str]]:
@@ -30,6 +32,7 @@ class BaseTaskFlowConfig(BaseConfig):
 
     tasks: dict
     flows: dict
+    config_plugins: dict = {}
 
     def list_tasks(self) -> List[Dict[str, str]]:
         """Returns a list of task info dictionaries with keys 'name' and 'description'"""
@@ -80,3 +83,25 @@ class BaseTaskFlowConfig(BaseConfig):
             return f'. Did you mean "{match_list[0]}"?'
         else:
             return ""
+
+    def _load_plugins_config(self):
+        """Loads the plugin configurations"""
+        plugins = load_plugins()
+        self.config_plugins = {}
+        for plugin in plugins:
+            if plugin.plugin_project_config:
+                self.config_plugins.update(plugin.plugin_project_config)
+            plugin.teardown()  # clean up the plugin
+
+    def merge_base_config(self, base_config: dict) -> dict:
+        """Merges the base config with the plugin configurations"""
+        self._load_plugins_config()
+        return cast(
+            dict,
+            merge_config(
+                {
+                    **base_config,
+                    "plugins_config": self.config_plugins,
+                }
+            ),
+        )

cumulusci/core/config/org_config.py

@@ -63,7 +63,7 @@ class OrgConfig(BaseConfig):
     client_secret: str
     connected_app: str
     serialization_format: str
-
+    org_name: str
     createable: Optional[bool] = None
 
     # make sure it can be mocked for tests
@@ -246,6 +246,7 @@ class OrgConfig(BaseConfig):
             "is_sandbox": self._org_sobject["IsSandbox"],
             "instance_name": self._org_sobject["InstanceName"],
             "namespace": self._org_sobject["NamespacePrefix"],
+            "org_name": self._org_sobject["Name"],
         }
         self.config.update(result)
 

cumulusci/core/config/project_config.py

@@ -14,12 +14,11 @@ from typing import TYPE_CHECKING, Any, Dict, Iterable, List, Optional, Union
 from cumulusci.core.config.base_config import BaseConfig
 from cumulusci.core.debug import get_debug_mode
 from cumulusci.core.versions import PackageVersionNumber
-from cumulusci.plugins.plugin_loader import load_plugins
 from cumulusci.utils.version_strings import LooseVersion
 
 API_VERSION_RE = re.compile(r"^\d\d+\.0$")
 
-from pydantic import ValidationError
+from pydantic.v1 import ValidationError
 
 from cumulusci.core.config import FlowConfig, TaskConfig
 from cumulusci.core.config.base_task_flow_config import BaseTaskFlowConfig
@@ -33,7 +32,6 @@ from cumulusci.core.exceptions import (
     VcsException,
 )
 from cumulusci.core.source import LocalFolderSource, NullSource
-from cumulusci.core.utils import merge_config
 from cumulusci.utils.fileutils import FSResource, open_fs_resource
 from cumulusci.utils.git import current_branch, generic_parse_repo_url, git_path
 from cumulusci.utils.yaml.cumulusci_yml import (
@@ -84,7 +82,6 @@ class BaseProjectConfig(BaseTaskFlowConfig, ProjectConfigPropertiesMixin):
     config_project: dict
     config_project_local: dict
     config_additional_yaml: dict
-    config_plugins_yaml: dict
     additional_yaml: Optional[str]
     source: Union[NullSource, VCSSource, LocalFolderSource]
     _cache_dir: Optional[Path]
@@ -114,7 +111,6 @@ class BaseProjectConfig(BaseTaskFlowConfig, ProjectConfigPropertiesMixin):
         self.config_project = {}
         self.config_project_local = {}
         self.config_additional_yaml = {}
-        self.config_plugins_yaml = {}
 
         # optionally pass in a kwarg named 'additional_yaml' that will
         # be added to the YAML merge stack.
@@ -184,27 +180,13 @@ class BaseProjectConfig(BaseTaskFlowConfig, ProjectConfigPropertiesMixin):
             if additional_yaml_config:
                 self.config_additional_yaml.update(additional_yaml_config)
 
-        # Loading plugins as classes are loaded and available.
-        plugins = load_plugins()
-
-        # Load the plugin yaml config file if it exists
-        for plugin in plugins:
-            if plugin.plugin_project_config:
-                self.config_plugins_yaml.update(plugin.plugin_project_config)
-                self.logger.info(
-                    f"Loaded plugin: {plugin.name} ({plugin.api_name}) v{plugin.version}"
-                )
-
-            plugin.teardown()  # clean up the plugin
-
-        self.config = merge_config(
+        self.config = self.merge_base_config(
             {
                 "universal_config": self.config_universal,
                 "global_config": self.config_global,
                 "project_config": self.config_project,
                 "project_local_config": self.config_project_local,
                 "additional_yaml": self.config_additional_yaml,
-                "plugins_config": self.config_plugins_yaml,
             }
         )
 
@@ -470,6 +452,18 @@ class BaseProjectConfig(BaseTaskFlowConfig, ProjectConfigPropertiesMixin):
                         ):
                             return parts[0]
 
+    @property
+    def is_dependency_flow(self) -> bool:
+        return (
+            False
+            if self.executing_dependency_flow is None
+            else self.executing_dependency_flow
+        )
+
+    @is_dependency_flow.setter
+    def is_dependency_flow(self, value: bool):
+        self.executing_dependency_flow = value
+
     def get_repo(self) -> AbstractRepo:
         repo = self.repo_service.get_repository()
         if repo is None:

cumulusci/core/config/scratch_org_config.py

@@ -162,6 +162,18 @@ class ScratchOrgConfig(SfdxOrgConfig):
             args += ["-a", self.sfdx_alias]
         with open(self.config_file, "r") as org_def:
             org_def_data = json.load(org_def)
+            if (
+                "orgName" in org_def_data
+                and org_def_data["orgName"] is not None
+                and self.keychain.project_config.project__name is not None
+            ):
+                org_def_data["orgName"] = (
+                    org_def_data["orgName"]
+                    .replace(
+                        "%%%PROJECT_NAME%%%", self.keychain.project_config.project__name
+                    )
+                    .replace("%%%CONFIG_NAME%%%", self.name.upper())
+                )
             org_def_has_email = "adminEmail" in org_def_data
         if self.email_address and not org_def_has_email:
             args += [f"--admin-email={self.email_address}"]

cumulusci/core/config/tests/test_config.py

@@ -1222,6 +1222,7 @@ class TestOrgConfig:
                 "IsSandbox": False,
                 "InstanceName": "cs420",
                 "NamespacePrefix": "ns",
+                "Name": "Test Org",
             },
         )
 

cumulusci/core/config/tests/test_config_expensive.py

@@ -54,7 +54,9 @@ class TestUniversalConfig:
         with open(filename, "w") as f:
             f.write(content)
 
-    def test_load_universal_config_no_local(self, mock_class):
+    @mock.patch("cumulusci.core.config.base_task_flow_config.load_plugins")
+    def test_load_universal_config_no_local(self, mock_load_plugins, mock_class):
+        mock_load_plugins.return_value = []
         mock_class.return_value = self.tempdir_home
         # clear cache
         UniversalConfig.config = None
@@ -63,7 +65,9 @@ class TestUniversalConfig:
             expected_config = yaml.safe_load(f_expected_config)
         assert config.config == expected_config
 
-    def test_load_universal_config_empty_local(self, mock_class):
+    @mock.patch("cumulusci.core.config.base_task_flow_config.load_plugins")
+    def test_load_universal_config_empty_local(self, mock_load_plugins, mock_class):
+        mock_load_plugins.return_value = []
         self._create_universal_config_local("")
         # clear cache
         UniversalConfig.config = None
@@ -73,7 +77,9 @@ class TestUniversalConfig:
             expected_config = yaml.safe_load(f_expected_config)
         assert config.config == expected_config
 
-    def test_load_universal_config_with_local(self, mock_class):
+    @mock.patch("cumulusci.core.config.base_task_flow_config.load_plugins")
+    def test_load_universal_config_with_local(self, mock_load_plugins, mock_class):
+        mock_load_plugins.return_value = []
         local_yaml = "tasks:\n    newtesttask:\n        description: test description"
         self._create_universal_config_local(local_yaml)
         mock_class.return_value = self.tempdir_home

cumulusci/core/config/universal_config.py

@@ -1,12 +1,12 @@
 import os
 from pathlib import Path
+from typing import Optional
 
 from cumulusci.core.config import BaseTaskFlowConfig
 from cumulusci.core.config.project_config import (
     BaseProjectConfig,
     ProjectConfigPropertiesMixin,
 )
-from cumulusci.core.utils import merge_config
 from cumulusci.utils.yaml.cumulusci_yml import cci_safe_load
 
 __location__ = os.path.dirname(os.path.realpath(__file__))
@@ -18,10 +18,9 @@ class UniversalConfig(BaseTaskFlowConfig, ProjectConfigPropertiesMixin):
     project_local_dir: str
     cli: dict
 
-    config = None
+    config: Optional[dict] = None
     config_filename = "cumulusci.yml"
     project_config_class = BaseProjectConfig
-    universal_config_obj = None
 
     def __init__(self, config=None):
         self._init_logger()
@@ -80,7 +79,7 @@ class UniversalConfig(BaseTaskFlowConfig, ProjectConfigPropertiesMixin):
             config = {}
         UniversalConfig.config_global = config
 
-        UniversalConfig.config = merge_config(
+        UniversalConfig.config = self.merge_base_config(
             {
                 "universal_config": UniversalConfig.config_universal,
                 "global_config": UniversalConfig.config_global,

cumulusci/core/dependencies/base.py

@@ -4,7 +4,7 @@ from datetime import datetime
 from typing import List, Optional, Type
 from zipfile import ZipFile
 
-from pydantic import AnyUrl, PrivateAttr, root_validator, validator
+from pydantic.v1 import AnyUrl, PrivateAttr, root_validator, validator
 
 from cumulusci.core.config import OrgConfig
 from cumulusci.core.config.project_config import BaseProjectConfig
@@ -738,11 +738,15 @@ class UnmanagedVcsDependencyFlow(UnmanagedStaticDependency, ABC):
             )
         )
 
+        project_config.is_dependency_flow = True
+
         start_time = datetime.now()
         coordinator.run(org)
         duration = datetime.now() - start_time
         context.logger.info(f"Ran {self.flow_name} in {format_duration(duration)}")
 
+        project_config.is_dependency_flow = False
+
 
 class BasePackageVersionDependency(StaticDependency, ABC):
     @abstractmethod

cumulusci/core/dependencies/dependencies.py

@@ -3,7 +3,7 @@ import logging
 import os
 from typing import List, Optional, Type
 
-from pydantic import AnyUrl, ValidationError
+from pydantic.v1 import AnyUrl, ValidationError
 
 import cumulusci.core.dependencies.base as base_dependency
 from cumulusci.core.config import OrgConfig

cumulusci/core/dependencies/github.py

@@ -3,8 +3,7 @@ from abc import ABC
 from functools import lru_cache
 from typing import Optional, Type
 
-from pydantic import root_validator
-from pydantic.networks import AnyUrl
+from pydantic.v1 import AnyUrl, root_validator
 
 import cumulusci.core.dependencies.base as base_dependency
 from cumulusci.core.exceptions import DependencyResolutionError, GithubApiNotFoundError

cumulusci/core/dependencies/resolvers.py

@@ -5,7 +5,7 @@ from collections.abc import Mapping
 from enum import StrEnum
 from typing import Callable, Iterable, List, Optional, Tuple, Type
 
-from pydantic import AnyUrl
+from pydantic.v1 import AnyUrl
 
 from cumulusci.core.config.project_config import BaseProjectConfig
 from cumulusci.core.dependencies.base import (

cumulusci/core/dependencies/tests/test_dependencies.py

@@ -5,7 +5,7 @@ from unittest import mock
 from zipfile import ZipFile
 
 import pytest
-from pydantic import ValidationError, root_validator
+from pydantic.v1 import ValidationError, root_validator
 
 from cumulusci.core.config.org_config import OrgConfig, VersionInfo
 from cumulusci.core.config.project_config import BaseProjectConfig

cumulusci/core/dependencies/tests/test_resolvers.py

@@ -3,7 +3,7 @@ from unittest import mock
 
 import pytest
 from github3.exceptions import NotFoundError
-from pydantic import root_validator
+from pydantic.v1 import root_validator
 
 from cumulusci.core.config import UniversalConfig
 from cumulusci.core.config.project_config import BaseProjectConfig

cumulusci/core/flowrunner.py

@@ -53,6 +53,7 @@ Option values/overrides can be passed in at a number of levels, in increasing or
 
 import copy
 import logging
+import os
 from collections import defaultdict
 from operator import attrgetter
 from typing import (
@@ -164,6 +165,11 @@ class StepSpec:
         )
 
 
+class FlowStepSpec(StepSpec):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+
 class StepResult(NamedTuple):
     step_num: StepVersion
     task_name: str
@@ -356,6 +362,10 @@ class FlowCoordinator:
 
         self.logger = self._init_logger()
         self.steps = self._init_steps()
+        self._expression_cache = {}
+        self._jinja2_context = None
+        self._context_project_config = None
+        self._context_org_config = None
 
     @classmethod
     def from_steps(
@@ -403,6 +413,9 @@ class FlowCoordinator:
         previous_parts = []
         previous_source = None
         for step in self.steps:
+            if isinstance(step, FlowStepSpec):
+                continue
+
             parts = step.path.split(".")
             steps = str(step.step_num).split("/")
             if len(parts) > len(steps):
@@ -491,7 +504,27 @@ class FlowCoordinator:
         self._rule(new_line=True)
 
         try:
+            # Pre-evaluate all flow conditions
+            skipped_flows_set = set()
             for step in self.steps:
+                if isinstance(step, FlowStepSpec):
+                    if not self._evaluate_flow_step(step):
+                        skipped_flows_set.add(step.path)
+
+            # Main execution loop with optimized path checking
+            for step in self.steps:
+                if isinstance(step, FlowStepSpec):
+                    self.logger.info(
+                        f"Skipping Flow {step.task_name} (skipped unless {step.when})"
+                    )
+                    continue
+
+                if self._is_task_in_skipped_flow(step.path, skipped_flows_set):
+                    self.logger.info(
+                        f"Skipping Task {step.task_name} in flow {step.path} (parent flow is skipped)"
+                    )
+                    continue
+
                 self._run_step(step)
             flow_name = f"'{self.name}' " if self.name else ""
             self.logger.info(
@@ -500,6 +533,46 @@ class FlowCoordinator:
         finally:
             self.callbacks.post_flow(self)
 
+    def _get_jinja2_context(self, project_config, org_config):
+        """Get or create jinja2 context, reusing when possible."""
+        if (
+            self._jinja2_context is None
+            or self._context_project_config != project_config
+            or self._context_org_config != org_config
+        ):
+
+            self._jinja2_context = {
+                "project_config": project_config,
+                "org_config": org_config,
+                "env": dict(os.environ),
+            }
+            self._context_project_config = project_config
+            self._context_org_config = org_config
+
+        return self._jinja2_context
+
+    def _evaluate_flow_step(self, step: StepSpec) -> bool:
+        if not step.when:
+            return True
+
+        # Check cache first
+        if step.when in self._expression_cache:
+            expr = self._expression_cache[step.when]
+        else:
+            expr = jinja2_env.compile_expression(step.when)
+            self._expression_cache[step.when] = expr
+
+        jinja2_context = self._get_jinja2_context(step.project_config, self.org_config)
+
+        return expr(**jinja2_context)
+
+    def _is_task_in_skipped_flow(self, task_path: str, skipped_flows_set: set) -> bool:
+        """Check if task belongs to any skipped flow using O(1) set lookup."""
+        for skipped_path in skipped_flows_set:
+            if task_path.startswith(skipped_path + "."):
+                return True
+        return False
+
     def _run_step(self, step: StepSpec):
         if step.skip:
             self._rule(fill="*")
@@ -508,12 +581,7 @@ class FlowCoordinator:
             return
 
         if step.when:
-            jinja2_context = {
-                "project_config": step.project_config,
-                "org_config": self.org_config,
-            }
-            expr = jinja2_env.compile_expression(step.when)
-            value = expr(**jinja2_context)
+            value = self._evaluate_flow_step(step)
             if not value:
                 self.logger.info(
                     f"Skipping task {step.task_name} (skipped unless {step.when})"
@@ -681,8 +749,24 @@ class FlowCoordinator:
             else:
                 path = name
             step_options = step_config.get("options", {})
+            parent_task_options = parent_options.get(name, {})
+            step_options.update(parent_task_options)
             step_ui_options = step_config.get("ui_options", {})
             flow_config = project_config.get_flow(name)
+
+            if step_config.get("when"):
+                visited_steps.append(
+                    FlowStepSpec(
+                        task_config={},
+                        step_num=step_number,
+                        task_name=path,
+                        task_class=None,
+                        project_config=flow_config.project_config,
+                        allow_failure=step_config.get("ignore_failure", False),
+                        when=step_config.get("when"),
+                    )
+                )
+
             for sub_number, sub_stepconf in flow_config.steps.items():
                 # append the flow number to the child number, since its a LooseVersion.
                 # e.g. if we're in step 2.3 which references a flow with steps 1-5, it

cumulusci/core/github.py

@@ -189,7 +189,7 @@ def validate_service(options: dict, keychain) -> dict:
     server_domain = options.get("server_domain", None)
 
     gh = _determine_github_client(server_domain, {"token": token})
-    if type(gh) == GitHubEnterprise:
+    if isinstance(gh, GitHubEnterprise):
         validate_gh_enterprise(server_domain, keychain)
     try:
         authed_user = gh.me()

cumulusci/core/sfdx.py

@@ -14,10 +14,12 @@ import sarge
 
 # Fix for TextIOWrapper flush issue with sarge.Capture objects
 # Add flush method to sarge.Capture to prevent AttributeError during garbage collection
-if not hasattr(sarge.Capture, 'flush'):
+if not hasattr(sarge.Capture, "flush"):
+
     def _capture_flush(self):
         """No-op flush method for sarge.Capture compatibility with TextIOWrapper"""
         pass
+
     sarge.Capture.flush = _capture_flush
 
 from cumulusci.core.enums import StrEnum

cumulusci/core/source_transforms/tests/test_transforms.py

@@ -8,7 +8,7 @@ from zipfile import ZipFile
 
 import pytest
 from lxml import etree as ET
-from pydantic import ValidationError
+from pydantic.v1 import ValidationError
 
 from cumulusci.core.exceptions import CumulusCIException, TaskOptionsError
 from cumulusci.core.source_transforms.transforms import (

cumulusci/core/source_transforms/transforms.py

@@ -10,7 +10,7 @@ from pathlib import Path
 from zipfile import ZipFile
 
 from lxml import etree as ET
-from pydantic import BaseModel, root_validator
+from pydantic.v1 import BaseModel, root_validator
 
 from cumulusci.core.dependencies.utils import TaskContext
 from cumulusci.core.enums import StrEnum

cumulusci/core/tasks.py

@@ -11,7 +11,7 @@ import time
 from contextlib import nullcontext
 from typing import Any, Callable, Dict, List, Optional, Type, Union
 
-from pydantic.error_wrappers import ValidationError
+from pydantic.v1.error_wrappers import ValidationError
 
 from cumulusci import __version__
 from cumulusci.core.config import TaskConfig
@@ -33,6 +33,7 @@ from cumulusci.utils.options import CCIOptions, ReadOnlyOptions
 CURRENT_TASK = threading.local()
 
 PROJECT_CONFIG_RE = re.compile(r"\$project_config.(\w+)")
+ORG_CONFIG_RE = re.compile(r"\$org_config.(\w+)")
 CAPTURE_TASK_OUTPUT = os.environ.get("CAPTURE_TASK_OUTPUT")
 
 
@@ -135,12 +136,22 @@ class BaseTask:
             self.options.update(kwargs)
 
         # Handle dynamic lookup of project_config values via $project_config.attr
+        # and org_config values via $org_config.attr
         def process_options(option):
             if isinstance(option, str):
-                return PROJECT_CONFIG_RE.sub(
+                # Replace $project_config.attr patterns
+                option = PROJECT_CONFIG_RE.sub(
                     lambda match: str(self.project_config.lookup(match.group(1), None)),
                     option,
                 )
+                # Replace $org_config.attr patterns if org_config is available
+                if self.org_config is not None:
+                    org_config = self.org_config  # Capture for type narrowing
+                    option = ORG_CONFIG_RE.sub(
+                        lambda match: str(org_config.lookup(match.group(1), None)),
+                        option,
+                    )
+                return option
             elif isinstance(option, dict):
                 processed_dict = {}
                 for key, value in option.items():