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

cumulusci/tasks/bulkdata/tests/test_select_utils.py

@@ -1,3 +1,5 @@
+import sys
+
 import pytest
 
 from cumulusci.tasks.bulkdata.select_utils import (
@@ -618,6 +620,10 @@ def test_vectorize_records_mixed_numerical_boolean_categorical():
     not PANDAS_AVAILABLE or not OPTIONAL_DEPENDENCIES_AVAILABLE,
     reason="requires optional dependencies for annoy",
 )
+@pytest.mark.skipif(
+    sys.platform == "darwin" and sys.version_info[:2] in [(3, 11), (3, 13)],
+    reason="Annoy library has known compatibility issues on macOS with Python 3.11 and 3.13",
+)
 def test_annoy_post_process():
     # Test data
     load_records = [["Alice", "Engineer"], ["Bob", "Doctor"]]
@@ -648,6 +654,10 @@ def test_annoy_post_process():
     not PANDAS_AVAILABLE or not OPTIONAL_DEPENDENCIES_AVAILABLE,
     reason="requires optional dependencies for annoy",
 )
+@pytest.mark.skipif(
+    sys.platform == "darwin" and sys.version_info[:2] in [(3, 11), (3, 13)],
+    reason="Annoy library has known compatibility issues on macOS with Python 3.11 and 3.13",
+)
 def test_annoy_post_process__insert_records():
     # Test data
     load_records = [["Alice", "Engineer"], ["Bob", "Doctor"]]
@@ -689,6 +699,14 @@ def test_annoy_post_process__insert_records():
         assert insert_record in [["Alice", "Engineer"], ["Bob", "Doctor"]]
 
 
+@pytest.mark.skipif(
+    not PANDAS_AVAILABLE or not OPTIONAL_DEPENDENCIES_AVAILABLE,
+    reason="requires optional dependencies for annoy",
+)
+@pytest.mark.skipif(
+    sys.platform == "darwin" and sys.version_info[:2] in [(3, 11), (3, 13)],
+    reason="Annoy library has known compatibility issues on macOS with Python 3.11 and 3.13",
+)
 def test_annoy_post_process__no_query_records():
     # Test data
     load_records = [["Alice", "Engineer"], ["Bob", "Doctor"]]
@@ -721,6 +739,10 @@ def test_annoy_post_process__no_query_records():
     not PANDAS_AVAILABLE or not OPTIONAL_DEPENDENCIES_AVAILABLE,
     reason="requires optional dependencies for annoy",
 )
+@pytest.mark.skipif(
+    sys.platform == "darwin" and sys.version_info[:2] in [(3, 11), (3, 13)],
+    reason="Annoy library has known compatibility issues on macOS with Python 3.11 and 3.13",
+)
 def test_annoy_post_process__insert_records_with_polymorphic_fields():
     # Test data
     load_records = [
@@ -778,6 +800,10 @@ def test_annoy_post_process__insert_records_with_polymorphic_fields():
     not PANDAS_AVAILABLE or not OPTIONAL_DEPENDENCIES_AVAILABLE,
     reason="requires optional dependencies for annoy",
 )
+@pytest.mark.skipif(
+    sys.platform == "darwin" and sys.version_info[:2] in [(3, 11), (3, 13)],
+    reason="Annoy library has known compatibility issues on macOS with Python 3.11 and 3.13",
+)
 def test_single_record_match_annoy_post_process():
     # Mock data where only the first query record matches the first load record
     load_records = [["Alice", "Engineer"], ["Bob", "Doctor"]]

cumulusci/tasks/bulkdata/tests/test_snowfakery.py

@@ -824,6 +824,139 @@ class TestSnowfakery:
                 "Account",
             }
 
+    @mock.patch(
+        "cumulusci.tasks.bulkdata.snowfakery.Snowfakery._run_generate_and_load_subtask"
+    )
+    def test_validate_only_mode(self, mock_subtask, create_task):
+        """Test that validate_only mode validates without loading data"""
+        from cumulusci.tasks.bulkdata.mapping_parser import ValidationResult
+
+        # Mock subtask return value
+        validation_result = ValidationResult()
+        mock_subtask.return_value = {"validation_result": validation_result}
+
+        task = create_task(
+            Snowfakery,
+            {
+                "recipe": sample_yaml,
+                "validate_only": True,
+            },
+        )
+
+        task()
+
+        # Verify subtask was called with validate_only=True
+        mock_subtask.assert_called_once()
+        call_args = mock_subtask.call_args
+        assert call_args.kwargs.get("validate_only")
+
+        # Verify return values contain validation_result
+        assert "validation_result" in task.return_values
+        assert task.return_values["validation_result"] == validation_result
+
+    @mock.patch(
+        "cumulusci.tasks.bulkdata.snowfakery.Snowfakery._run_generate_and_load_subtask"
+    )
+    def test_validate_only_with_errors(self, mock_subtask, create_task):
+        """Test that validate_only mode returns errors without raising exception"""
+        from cumulusci.tasks.bulkdata.mapping_parser import ValidationResult
+
+        # Mock ValidationResult with errors
+        validation_result = ValidationResult()
+        validation_result.add_error("Test error: Field does not exist")
+        validation_result.add_warning("Test warning: Field has no permissions")
+        mock_subtask.return_value = {"validation_result": validation_result}
+
+        task = create_task(
+            Snowfakery,
+            {
+                "recipe": sample_yaml,
+                "validate_only": True,
+            },
+        )
+
+        # Should not raise exception even with errors
+        task()
+
+        # Verify subtask was called
+        mock_subtask.assert_called_once()
+
+        # Verify return values contain validation_result with errors
+        assert "validation_result" in task.return_values
+        assert task.return_values["validation_result"].has_errors()
+        assert len(task.return_values["validation_result"].errors) == 1
+        assert len(task.return_values["validation_result"].warnings) == 1
+
+    def test_validate_only_false_loads_data(self, mock_load_data, create_task):
+        """Test that validate_only=False performs normal data loading"""
+        task = create_task(
+            Snowfakery,
+            {
+                "recipe": sample_yaml,
+                "validate_only": False,
+            },
+        )
+
+        task()
+
+        # Verify load WAS called
+        assert len(mock_load_data.mock_calls) > 0
+
+        # Verify return values do not contain validation_result
+        assert "validation_result" not in task.return_values
+
+    @mock.patch(
+        "cumulusci.tasks.bulkdata.snowfakery.Snowfakery._run_generate_and_load_subtask"
+    )
+    def test_validate_only_with_working_directory(self, mock_subtask, snowfakery):
+        """Test that validate_only respects working_directory option"""
+        from cumulusci.tasks.bulkdata.mapping_parser import ValidationResult
+
+        validation_result = ValidationResult()
+        mock_subtask.return_value = {"validation_result": validation_result}
+
+        with TemporaryDirectory() as t:
+            working_dir = Path(t) / "snowfakery_validation"
+            task = snowfakery(
+                recipe=sample_yaml,
+                validate_only=True,
+                working_directory=str(working_dir),
+            )
+
+            task()
+
+            # Verify subtask was called
+            mock_subtask.assert_called_once()
+
+            # Verify working directory was created
+            assert working_dir.exists()
+
+            # Verify return values contain validation_result
+            assert "validation_result" in task.return_values
+
+    @mock.patch(
+        "cumulusci.tasks.bulkdata.snowfakery.Snowfakery._run_generate_and_load_subtask"
+    )
+    def test_validate_only_skips_channels_and_queues(self, mock_subtask, create_task):
+        """Test that validate_only does not set up channels and queues"""
+        from cumulusci.tasks.bulkdata.mapping_parser import ValidationResult
+
+        validation_result = ValidationResult()
+        mock_subtask.return_value = {"validation_result": validation_result}
+
+        task = create_task(
+            Snowfakery,
+            {
+                "recipe": sample_yaml,
+                "validate_only": True,
+            },
+        )
+
+        task()
+
+        # Verify queue_manager was never created
+        assert not hasattr(task, "queue_manager")
+
     @mock.patch("cumulusci.tasks.bulkdata.snowfakery.MIN_PORTION_SIZE", 2)
     def test_serial_mode(self, mock_load_data, create_task):
         task = create_task(

cumulusci/tasks/create_package_version.py

@@ -3,9 +3,9 @@ import io
 import json
 import pathlib
 import zipfile
-from typing import List, Optional
+from typing import Dict, List, Optional, Union
 
-from pydantic import BaseModel, validator
+from pydantic.v1 import BaseModel, validator
 from simple_salesforce.exceptions import SalesforceMalformedRequest
 
 from cumulusci.core.config.util import get_devhub_config
@@ -29,7 +29,7 @@ from cumulusci.core.exceptions import (
     VcsException,
 )
 from cumulusci.core.sfdx import convert_sfdx_source
-from cumulusci.core.utils import process_bool_arg
+from cumulusci.core.utils import process_bool_arg, process_list_arg
 from cumulusci.core.versions import PackageType, PackageVersionNumber, VersionTypeEnum
 from cumulusci.salesforce_api.package_zip import (
     BasePackageZipBuilder,
@@ -38,6 +38,10 @@ from cumulusci.salesforce_api.package_zip import (
 from cumulusci.salesforce_api.utils import get_simple_salesforce_connection
 from cumulusci.tasks.salesforce.BaseSalesforceApiTask import BaseSalesforceApiTask
 from cumulusci.tasks.salesforce.org_settings import build_settings_package
+from cumulusci.tasks.utility.copyContents import (
+    clean_temp_directory,
+    consolidate_metadata,
+)
 from cumulusci.utils.salesforce.soql import (
     format_subscriber_package_version_where_clause,
 )
@@ -68,6 +72,11 @@ class PackageConfig(BaseModel):
     version_name: str
     version_base: Optional[str] = None
     version_type: VersionTypeEnum = VersionTypeEnum.minor
+    apex_test_access: Optional[dict[str, list[str]]] = None
+    package_metadata_access: Optional[dict[str, list[str]]] = None
+    unpackaged_metadata_path: Optional[
+        Union[str, List[str], Dict[str, Union[str, List[str]]]]
+    ] = None
 
     @validator("org_dependent")
     def org_dependent_must_be_unlocked(cls, v, values):
@@ -87,6 +96,20 @@ class PackageConfig(BaseModel):
             raise ValueError("Only managed packages can have an uninstall script.")
         return v
 
+    @validator("apex_test_access")
+    def apex_test_access_must_be_managed(cls, v, values):
+        if v and values["package_type"] != PackageTypeEnum.managed:
+            raise ValueError(
+                "Only managed packages can have Apex Test Access. Assign permission sets and permission set licenses to the user in context when your Apex tests run at package version creation."
+            )
+        return v
+
+    @validator("package_metadata_access")
+    def package_metadata_access_must_be_managed(cls, v, values):
+        if v and values["package_type"] != PackageTypeEnum.managed:
+            raise ValueError("Only managed packages can have Package Metadata Access.")
+        return v
+
 
 class CreatePackageVersion(BaseSalesforceApiTask):
     """Creates a new second-generation package version.
@@ -114,15 +137,21 @@ class CreatePackageVersion(BaseSalesforceApiTask):
         "version_base": {
             "description": "The version number to use as a base before incrementing. "
             "Optional; defaults to the highest existing version number of this package. "
-            "Can be set to ``latest_vcs_release`` to use the version of the most recent release published to GitHub."
+            "Can be set to ``latest_vcs_release`` to use the version of the most recent release published to VCS."
+            "If version_number is set, version_base and version_type will be ignored"
         },
         "version_type": {
             "description": "The part of the version number to increment. "
             "Options are major, minor, patch, build.  Defaults to build"
+            "If version_number is set, version_base and version_type will be ignored"
+        },
+        "version_number": {
+            "description": "Set a fixed version number, if not using version_base and version_type"
         },
         "skip_validation": {
             "description": "If true, skip validation of the package version. Default: false. "
             "Skipping validation creates packages more quickly, but they cannot be promoted for release."
+            "And package version is created without reference to dependencies."
         },
         "org_dependent": {
             "description": "If true, create an org-dependent unlocked package. Default: false."
@@ -156,6 +185,17 @@ class CreatePackageVersion(BaseSalesforceApiTask):
             "description": "If True, create unlocked packages for unpackaged metadata in this project and dependencies. "
             "Defaults to False."
         },
+        "dependencies": {
+            "description": "The list of dependencies to use when creating the package version. Defaults to None."
+            "If not provided, the dependencies will be resolved using the resolution_strategy."
+            "The format should be a pcakge version Ids i.e '04t...,04t...'"
+        },
+        "async_validation": {
+            "description": "If True, validate the package version asynchronously. Defaults to False. You also can't specify both skip validation and async validation at the same time."
+        },
+        "is_dev_use_pkg_zip_requested": {
+            "description": "If True, request a dev use package zip. Defaults to False. If true, a downloadable package zip file containing package metadata is generated when a new package version is created."
+        },
     }
 
     def _init_options(self, kwargs):
@@ -190,16 +230,40 @@ class CreatePackageVersion(BaseSalesforceApiTask):
             version_name=self.options.get("version_name") or "Release",
             version_base=self.options.get("version_base"),
             version_type=self.options.get("version_type") or VersionTypeEnum("build"),
+            apex_test_access=self.project_config.project__package__apex_test_access,
+            package_metadata_access=self.project_config.project__package__package_metadata_access,
+            unpackaged_metadata_path=self.project_config.project__package__unpackaged_metadata_path,
         )
         self.options["skip_validation"] = process_bool_arg(
             self.options.get("skip_validation") or False
         )
+        self.options["async_validation"] = process_bool_arg(
+            self.options.get("async_validation") or False
+        )
+        self.options["is_dev_use_pkg_zip_requested"] = process_bool_arg(
+            self.options.get("is_dev_use_pkg_zip_requested") or False
+        )
         self.options["force_upload"] = process_bool_arg(
             self.options.get("force_upload") or False
         )
         self.options["create_unlocked_dependency_packages"] = process_bool_arg(
             self.options.get("create_unlocked_dependency_packages") or False
         )
+        self.options["version_number"] = (
+            PackageVersionNumber.parse(
+                self.options.get("version_number"), package_type=PackageType.SECOND_GEN
+            )
+            if self.options.get("version_number")
+            else None
+        )
+        self.options["dependencies"] = (
+            [
+                {"subscriberPackageVersionId": x}
+                for x in process_list_arg(self.options.get("dependencies"))
+            ]
+            if self.options.get("dependencies")
+            else None
+        )
 
     def _init_task(self):
         self.tooling = get_simple_salesforce_connection(
@@ -223,13 +287,7 @@ class CreatePackageVersion(BaseSalesforceApiTask):
         self.return_values["package_id"] = self.package_id
 
         # submit request to create package version
-        options = {
-            "package_type": self.package_config.package_type.value,
-            "namespace_inject": self.package_config.namespace,
-            "namespaced_org": self.package_config.namespace is not None,
-        }
-        if "static_resource_path" in self.options:
-            options["static_resource_path"] = self.options["static_resource_path"]
+        options = self._get_package_zip_builder_options()
 
         package_zip_builder = None
         with convert_sfdx_source(
@@ -292,6 +350,20 @@ class CreatePackageVersion(BaseSalesforceApiTask):
         self.logger.info(f"  Version Number: {self.return_values['version_number']}")
         self.logger.info(f"  Dependencies: {self.return_values['dependencies']}")
 
+    def _get_package_zip_builder_options(self):
+        if not self.package_config:
+            return {}
+
+        options = {
+            "package_type": self.package_config.package_type.value,
+            "namespace_inject": self.package_config.namespace,
+            "namespaced_org": self.package_config.namespace is not None,
+        }
+        if "static_resource_path" in self.options:
+            options["static_resource_path"] = self.options["static_resource_path"]
+
+        return options
+
     def _get_or_create_package(self, package_config: PackageConfig):
         """Find or create the Package2
 
@@ -384,9 +456,13 @@ class CreatePackageVersion(BaseSalesforceApiTask):
                     return res["records"][0]["Id"]
 
             # Create the package descriptor
-            version_number = self._get_base_version_number(
+            version_number = self.options.get(
+                "version_number"
+            ) or self._get_base_version_number(
                 package_config.version_base, package_id
-            ).increment(package_config.version_type)
+            ).increment(
+                package_config.version_type
+            )
 
             package_descriptor = {
                 "id": package_id,
@@ -403,6 +479,57 @@ class CreatePackageVersion(BaseSalesforceApiTask):
             if package_config.uninstall_script:
                 package_descriptor["uninstallScript"] = package_config.uninstall_script
 
+            if package_config.apex_test_access:
+                if "permission_set_names" in package_config.apex_test_access:
+                    perm_sets = package_config.apex_test_access["permission_set_names"]
+                    if isinstance(perm_sets, str):
+                        perm_sets = perm_sets.split(",")
+
+                    package_descriptor["permissionSetNames"] = [
+                        s.strip() for s in perm_sets
+                    ]
+                if "permission_set_license_names" in package_config.apex_test_access:
+                    psl = package_config.apex_test_access[
+                        "permission_set_license_names"
+                    ]
+                    if isinstance(psl, str):
+                        psl = psl.split(",")
+                    package_descriptor["permissionSetLicenseDeveloperNames"] = [
+                        s.strip() for s in psl
+                    ]
+
+            if package_config.package_metadata_access:
+                if "permission_set_names" in package_config.package_metadata_access:
+                    perm_sets = package_config.package_metadata_access[
+                        "permission_set_names"
+                    ]
+                    if isinstance(perm_sets, str):
+                        perm_sets = perm_sets.split(",")
+
+                    if isinstance(perm_sets, list):
+                        package_descriptor["packageMetadataPermissionSetNames"] = [
+                            s.strip() for s in perm_sets
+                        ]
+
+                if (
+                    "permission_set_license_names"
+                    in package_config.package_metadata_access
+                ):
+                    psl = package_config.package_metadata_access[
+                        "permission_set_license_names"
+                    ]
+                    if isinstance(psl, str):
+                        psl = psl.split(",")
+                    if isinstance(psl, list):
+                        package_descriptor[
+                            "packageMetadataPermissionSetLicenseNames"
+                        ] = [s.strip() for s in psl]
+
+            if package_config.unpackaged_metadata_path:
+                self._get_unpackaged_metadata_path(
+                    package_config.unpackaged_metadata_path, version_info
+                )
+
             # Add org shape
             with open(self.org_config.config_file, "r") as f:
                 scratch_org_def = json.load(f)
@@ -442,7 +569,9 @@ class CreatePackageVersion(BaseSalesforceApiTask):
                 and not is_dependency
             ):
                 self.logger.info("Determining dependencies for package")
-                dependencies = self._get_dependencies()
+                dependencies = (
+                    self.options.get("dependencies") or self._get_dependencies()
+                )
             if dependencies:
                 package_descriptor["dependencies"] = dependencies
 
@@ -458,12 +587,25 @@ class CreatePackageVersion(BaseSalesforceApiTask):
         )
         request = {
             "Package2Id": package_id,
-            "SkipValidation": skip_validation,
             "Tag": f"hash:{package_hash}",
             "VersionInfo": version_info,
-            "CalculateCodeCoverage": not skip_validation,
+            "IsDevUsePkgZipRequested": self.options.get("is_dev_use_pkg_zip_requested"),
         }
 
+        if self.options.get("async_validation") is not True:
+            request.update(
+                {
+                    "SkipValidation": skip_validation,
+                    "CalculateCodeCoverage": not skip_validation,
+                }
+            )
+        else:
+            request.update(
+                {
+                    "AsyncValidation": True,
+                }
+            )
+
         install_key = self.options.get("install_key")
         if install_key:
             request["InstallKey"] = install_key
@@ -785,3 +927,35 @@ class CreatePackageVersion(BaseSalesforceApiTask):
             ]
 
         return []
+
+    def _get_unpackaged_metadata_path(
+        self,
+        metadata_path: Union[str, List[str], Dict[str, Union[str, List[str]]]],
+        version_info: zipfile.ZipFile,
+    ) -> zipfile.ZipFile:
+
+        final_metadata_path, file_count = consolidate_metadata(
+            metadata_path, self.project_config.repo_root, logger=self.logger
+        )
+
+        if file_count == 0:
+            return version_info
+
+        # Use the consolidated temp directory with convert_sfdx_source
+        with convert_sfdx_source(
+            final_metadata_path, "unpackaged-metadata-package", self.logger
+        ) as src_path:
+            unpackaged_metadata_zip_builder = MetadataPackageZipBuilder(
+                path=src_path,
+                name="unpackaged-metadata-package",
+                context=self.context,
+                options=self._get_package_zip_builder_options(),
+            )
+            version_info.writestr(
+                "unpackaged-metadata-package.zip",
+                unpackaged_metadata_zip_builder.as_bytes(),
+            )
+
+        clean_temp_directory(final_metadata_path)
+
+        return version_info

cumulusci/tasks/datadictionary.py

@@ -5,7 +5,7 @@ from typing import List, Optional, Union
 from unittest.mock import Mock
 from zipfile import ZipFile
 
-from pydantic import BaseModel
+from pydantic.v1 import BaseModel
 
 from cumulusci.core.config.project_config import BaseProjectConfig
 from cumulusci.core.dependencies import parse_dependencies

cumulusci/tasks/metadata_etl/base.py

@@ -7,7 +7,11 @@ from cumulusci.core.config import TaskConfig
 from cumulusci.core.enums import StrEnum
 from cumulusci.core.exceptions import CumulusCIException, TaskOptionsError
 from cumulusci.core.tasks import BaseSalesforceTask
-from cumulusci.core.utils import process_bool_arg, process_list_arg, determine_managed_mode
+from cumulusci.core.utils import (
+    determine_managed_mode,
+    process_bool_arg,
+    process_list_arg,
+)
 from cumulusci.salesforce_api.metadata import ApiRetrieveUnpackaged
 from cumulusci.tasks.metadata.package import PackageXmlGenerator
 from cumulusci.utils import inject_namespace
@@ -74,8 +78,8 @@ class BaseMetadataETLTask(BaseSalesforceTask, metaclass=ABCMeta):
                 self.options["namespaced_org"] or False
             )
         else:
-            self.options["namespaced_org"] = (
-                bool(namespace) and namespace == getattr(self.org_config, 'namespace', None)
+            self.options["namespaced_org"] = bool(namespace) and namespace == getattr(
+                self.org_config, "namespace", None
             )
 
     def _inject_namespace(self, text):

cumulusci/tasks/metadata_etl/layouts.py

@@ -1,6 +1,6 @@
 from typing import List, Optional
 
-from pydantic import BaseModel, root_validator
+from pydantic.v1 import BaseModel, root_validator
 from typing_extensions import Literal
 
 from cumulusci.core.exceptions import TaskOptionsError

cumulusci/tasks/metadata_etl/permissions.py

@@ -1,6 +1,6 @@
 import typing as T
 
-import pydantic
+import pydantic.v1 as pydantic
 
 from cumulusci.core.exceptions import TaskOptionsError
 from cumulusci.tasks.metadata_etl import MetadataSingleEntityTransformTask

cumulusci/tasks/metadata_etl/remote_site_settings.py

@@ -1,7 +1,7 @@
 from typing import List, Optional
 
-import pydantic
-from pydantic import BaseModel
+import pydantic.v1 as pydantic
+from pydantic.v1 import BaseModel
 
 from cumulusci.core.exceptions import TaskOptionsError
 from cumulusci.tasks.metadata_etl.base import BaseMetadataSynthesisTask

cumulusci/tasks/push/README.md

@@ -1,21 +1,20 @@
 # Push Upgrade API Scripts
 
-These scripts are designed to work with the Salesforce Push Upgrade API (in Pilot in Winter 16) which exposes new objects via the Tooling API that allow interacting with push upgrades in a packaging org.  The main purpose of these scripts is to use the Push Upgrade API to automate push upgrades through Jenkins.
+These scripts are designed to work with the Salesforce Push Upgrade API (in Pilot in Winter 16) which exposes new objects via the Tooling API that allow interacting with push upgrades in a packaging org. The main purpose of these scripts is to use the Push Upgrade API to automate push upgrades through Jenkins.
 
 # push_api.py - Python Wrapper for Push Upgrade API
 
-This python file provides wrapper classes around the Tooling API objects and abstracts interaction with them and their related data to make writing scripts easier.  All the other scripts in this directory use the SalesforcePushApi wrapper to interact with the Tooling API.
+This python file provides wrapper classes around the Tooling API objects and abstracts interaction with them and their related data to make writing scripts easier. All the other scripts in this directory use the SalesforcePushApi wrapper to interact with the Tooling API.
 
 Initializing the SalesforcePushApi wrapper can be done with the following python code:
 
     push_api = SalesforcePushApi(sf_user, sf_pass, sf_serverurl)
 
 You can also pass two optional keyword args to the initialization to control the wrapper's behavior
-    
-* **lazy**: A list of objects that should be lazily looked up.  Currently, the only implementations for this are 'jobs' and 'subscribers'.  If either are included in the list, they will be looked up on demand when needed by a referenced object.  For example, if you are querying all jobs and subscribers is not set to lazy, all subscribers will first be retrieved.  If lazy is enabled, subscriber orgs will only be retrieved when trying to resolve references for a particular job.  Generally, if you have a lot of subscribers and only expect your script to need to lookup a small number of them, enabling lazy for subscribers will reduce api calls and cause the script to run faster.
 
-* **default_where**: A dictionary with Push Upgrade API objects as key and a value containing a SOQL WHERE clause statement which is applied to all queries against the object to effectively set the universe for a given object.  For example:
-    
+-   **lazy**: A list of objects that should be lazily looked up. Currently, the only implementations for this are 'jobs' and 'subscribers'. If either are included in the list, they will be looked up on demand when needed by a referenced object. For example, if you are querying all jobs and subscribers is not set to lazy, all subscribers will first be retrieved. If lazy is enabled, subscriber orgs will only be retrieved when trying to resolve references for a particular job. Generally, if you have a lot of subscribers and only expect your script to need to lookup a small number of them, enabling lazy for subscribers will reduce api calls and cause the script to run faster.
+
+-   **default_where**: A dictionary with Push Upgrade API objects as key and a value containing a SOQL WHERE clause statement which is applied to all queries against the object to effectively set the universe for a given object. For example:
     default_where = {'PackageSubscriber': "OrgType = 'Sandbox'"}
 
 In the example above, the wrapper would never return a PackageSubscriber which is not a Sandbox org.
@@ -24,22 +23,22 @@ In the example above, the wrapper would never return a PackageSubscriber which i
 
 ## Common Environment Variables
 
-The push scripts are all designed to receive their arguments via environment variables.  The following are common amongst all of the Push Scripts
+The push scripts are all designed to receive their arguments via environment variables. The following are common amongst all of the Push Scripts
 
-* **SF_USERNAME**: The Salesforce username for the packaging org
-* **SF_PASSWORD**: The Salesforce password and security token for the packaging org
-* **SF_SERVERURL**: The login url for the Salesforce packaging org.
+-   **SF_USERNAME**: The Salesforce username for the packaging org
+-   **SF_PASSWORD**: The Salesforce password and security token for the packaging org
+-   **SF_SERVERURL**: The login url for the Salesforce packaging org.
 
 ## get_version_id.py
 
-Takes a namespace and version string and looks up the given version.  Returns the version's Salesforce Id.
+Takes a namespace and version string and looks up the given version. Returns the version's Salesforce Id.
 
 The script handles parsing the version number string into a SOQL query against the MetadataPackageVersion object with the correct MajorVersion, MinorVersion, PatchVersion, ReleaseState, and BuildNumber (i.e. Beta number).
 
 ### Required Environment Variables
 
-* **NAMESPACE**: The Package's namespace prefix
-* **VERSION_NUMBER**: The version number string.
+-   **NAMESPACE**: The Package's namespace prefix
+-   **VERSION_NUMBER**: The version number string.
 
 ## orgs_for_push.py
 
@@ -47,13 +46,12 @@ Takes a MetadataPackageVersion Id and optionally a where clause to filter Subscr
 
 ### Required Environment Variables
 
-* **VERSION**: The MetadataPackageVersion Id of the version you want to push upgrade.  This is used to look for all users not on the version or a newer version
+-   **VERSION**: The MetadataPackageVersion Id of the version you want to push upgrade. This is used to look for all users not on the version or a newer version
 
 ### Optional Environment Variables
 
-* **SUBSCRIBER_WHERE**: An extra filter to be applied to all Subscriber queries.  For example, setting this to OrgType = 'Sandbox' would find all Sandbox orgs eligible for push upgrade to the specified version
+-   **SUBSCRIBER_WHERE**: An extra filter to be applied to all Subscriber queries. For example, setting this to OrgType = 'Sandbox' would find all Sandbox orgs eligible for push upgrade to the specified version
 
 ## failed_orgs_for_push.py
 
-Takes a PackagePushRequest Id and optionally a where clause to filter Subscribers and returns a list of OrgId's one per line for all orgs which failed the 
-
+Takes a PackagePushRequest Id and optionally a where clause to filter Subscribers and returns a list of OrgId's one per line for all orgs which failed the