cumulusci-plus 5.0.19__py3-none-any.whl → 5.0.35__py3-none-any.whl

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,
             }
         )
 

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

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():

cumulusci/core/tests/test_flowrunner.py

@@ -542,6 +542,106 @@ class TestSimpleTestFlowCoordinator(AbstractFlowCoordinatorTest):
         flow.run(self.org_config)
         assert len(flow.results) == 0
 
+    def test_run__when_condition_with_env_var_true(self):
+        """A flow step runs when env var condition evaluates to True"""
+        import os
+
+        with mock.patch.dict(os.environ, {"RUN_TASK": "true"}):
+            flow_config = FlowConfig(
+                {
+                    "steps": {
+                        1: {
+                            "task": "pass_name",
+                            "when": "env.get('RUN_TASK') == 'true'",
+                        }
+                    }
+                }
+            )
+            flow = FlowCoordinator(self.project_config, flow_config)
+            flow.run(self.org_config)
+            assert len(flow.results) == 1
+
+    def test_run__when_condition_with_env_var_false(self):
+        """A flow step is skipped when env var condition evaluates to False"""
+        import os
+
+        with mock.patch.dict(os.environ, {"RUN_TASK": "false"}):
+            flow_config = FlowConfig(
+                {
+                    "steps": {
+                        1: {
+                            "task": "pass_name",
+                            "when": "env.get('RUN_TASK') == 'true'",
+                        }
+                    }
+                }
+            )
+            flow = FlowCoordinator(self.project_config, flow_config)
+            flow.run(self.org_config)
+            assert len(flow.results) == 0
+
+    def test_run__when_condition_with_env_var_default(self):
+        """A flow step uses default value when env var is not set"""
+        import os
+
+        # Make sure the env var is not set
+        if "UNDEFINED_VAR" in os.environ:
+            del os.environ["UNDEFINED_VAR"]
+        flow_config = FlowConfig(
+            {
+                "steps": {
+                    1: {
+                        "task": "pass_name",
+                        "when": "env.get('UNDEFINED_VAR', 'default') == 'default'",
+                    }
+                }
+            }
+        )
+        flow = FlowCoordinator(self.project_config, flow_config)
+        flow.run(self.org_config)
+        assert len(flow.results) == 1
+
+    def test_run__when_condition_with_env_var_and_org_config(self):
+        """A flow step can combine env vars with org_config in when condition"""
+        import os
+
+        with mock.patch.dict(os.environ, {"DEPLOY_TO_SCRATCH": "true"}):
+            flow_config = FlowConfig(
+                {
+                    "steps": {
+                        1: {
+                            "task": "pass_name",
+                            "when": "org_config.scratch and env.get('DEPLOY_TO_SCRATCH') == 'true'",
+                        }
+                    }
+                }
+            )
+            flow = FlowCoordinator(self.project_config, flow_config)
+            # Set org_config.scratch to True
+            self.org_config.config["scratch"] = True
+            flow.run(self.org_config)
+            assert len(flow.results) == 1
+
+    def test_run__when_condition_with_missing_env_var_is_none(self):
+        """A flow step can check if env var exists using 'is not none'"""
+        import os
+
+        # Test when var is set
+        with mock.patch.dict(os.environ, {"MY_VAR": "value"}):
+            flow_config = FlowConfig(
+                {
+                    "steps": {
+                        1: {
+                            "task": "pass_name",
+                            "when": "env.get('MY_VAR') is not none",
+                        }
+                    }
+                }
+            )
+            flow = FlowCoordinator(self.project_config, flow_config)
+            flow.run(self.org_config)
+            assert len(flow.results) == 1
+
     def test_run__task_raises_exception_fail(self):
         """A flow aborts when a task raises an exception"""
 

cumulusci/core/tests/test_tasks.py

@@ -147,6 +147,71 @@ class TestBaseTaskCallable:
         task = BaseTask(self.project_config, self.task_config, self.org_config)
         assert task.options["test_option"] == "before baz after"
 
+    def test_init_options__org_config_substitution(self):
+        self.task_config.config["options"] = {"test_option": "$org_config.username"}
+        task = BaseTask(self.project_config, self.task_config, self.org_config)
+        assert task.options["test_option"] == USERNAME
+
+    def test_init_options__org_config_substitution_org_id(self):
+        self.task_config.config["options"] = {"test_option": "$org_config.org_id"}
+        task = BaseTask(self.project_config, self.task_config, self.org_config)
+        assert task.options["test_option"] == ORG_ID
+
+    def test_init_options__org_config_substitution_nested(self):
+        self.task_config.config["options"] = {
+            "test_option": "$org_config.username",
+            "nested": [
+                {"user": "$org_config.username"},
+                {"org": "$org_config.org_id"},
+            ],
+        }
+        task = BaseTask(self.project_config, self.task_config, self.org_config)
+        assert task.options["test_option"] == USERNAME
+        assert task.options["nested"][0]["user"] == USERNAME
+        assert task.options["nested"][1]["org"] == ORG_ID
+
+    def test_init_options__org_config_substitution__substring(self):
+        self.task_config.config["options"] = {
+            "test_option": "User: $org_config.username, Org: $org_config.org_id"
+        }
+        task = BaseTask(self.project_config, self.task_config, self.org_config)
+        assert task.options["test_option"] == f"User: {USERNAME}, Org: {ORG_ID}"
+
+    def test_init_options__org_config_substitution__no_org(self):
+        """Test that $org_config substitution is skipped when org_config is None"""
+        self.task_config.config["options"] = {"test_option": "$org_config.username"}
+        task = BaseTask(self.project_config, self.task_config, org_config=None)
+        # Should remain unchanged when org_config is None
+        assert task.options["test_option"] == "$org_config.username"
+
+    def test_init_options__mixed_substitution(self):
+        """Test that both $project_config and $org_config work together"""
+        self.project_config.config["foo"] = {"bar": "baz"}
+        self.task_config.config["options"] = {
+            "test_option": "Project: $project_config.foo__bar, User: $org_config.username"
+        }
+        task = BaseTask(self.project_config, self.task_config, self.org_config)
+        assert task.options["test_option"] == f"Project: baz, User: {USERNAME}"
+
+    def test_init_options__mixed_substitution_nested(self):
+        """Test mixed substitution in nested structures"""
+        self.project_config.config["project"] = {"name": "TestProject"}
+        self.task_config.config["options"] = {
+            "config": {
+                "project_name": "$project_config.project__name",
+                "username": "$org_config.username",
+                "items": [
+                    "$project_config.project__name",
+                    "$org_config.org_id",
+                ],
+            }
+        }
+        task = BaseTask(self.project_config, self.task_config, self.org_config)
+        assert task.options["config"]["project_name"] == "TestProject"
+        assert task.options["config"]["username"] == USERNAME
+        assert task.options["config"]["items"][0] == "TestProject"
+        assert task.options["config"]["items"][1] == ORG_ID
+
     def test_validates_missing_options(self):
         class Task(BaseTask):
             task_options = {"test_option": {"required": True}}

cumulusci/core/utils.py

@@ -379,7 +379,9 @@ def determine_managed_mode(options, project_config, org_config):
     Note: The changes allows multiple package development under same namespace.
     """
     if "managed" in options:
-        return process_bool_arg(options["managed"])
+        return process_bool_arg(
+            options["managed"] if options["managed"] is not None else False
+        )
 
     # Get package and namespace information
     package_name = getattr(project_config, "project__package__name", None)

cumulusci/core/versions.py

@@ -1,7 +1,7 @@
 import re
 from typing import Optional, Union
 
-from pydantic import BaseModel
+from pydantic.v1 import BaseModel
 
 from cumulusci.core.enums import StrEnum