easylink 0.1.17__tar.gz → 0.1.18__tar.gz

{easylink-0.1.17 → easylink-0.1.18}/CHANGELOG.rst

@@ -1,3 +1,7 @@
+**0.1.18 - 5/14/25**
+
+ - Refactor to use a single pipeline schema rather than multiple potential schemas
+
 **0.1.17 - 5/14/25**
 
  - Support directories as step intermediates

{easylink-0.1.17 → easylink-0.1.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easylink
-Version: 0.1.17
+Version: 0.1.18
 Summary: Research repository for the EasyLink ER ecosystem project.
 Home-page: https://github.com/ihmeuw/easylink
 Author: The EasyLink developers

easylink-0.1.18/src/easylink/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.18"

{easylink-0.1.17 → easylink-0.1.18}/src/easylink/cli.py

@@ -91,6 +91,11 @@ SHARED_OPTIONS = [
         default=False,
         help="Do not save the results in a timestamped sub-directory of ``--output-dir``.",
     ),
+    click.option(
+        "--schema",
+        hidden=True,
+        default="main",
+    ),
 ]
 
 VERBOSE_WITH_DEBUGGER_OPTIONS = [
@@ -165,6 +170,7 @@ def run(
     input_data: str,
     output_dir: str | None,
     no_timestamp: bool,
+    schema: str,
     computing_environment: str | None,
     verbose: int,
     with_debugger: bool,
@@ -190,6 +196,7 @@ def run(
         input_data=input_data,
         computing_environment=computing_environment,
         results_dir=results_dir,
+        schema_name=schema,
     )
     logger.info("*** FINISHED ***")
 
@@ -201,6 +208,7 @@ def generate_dag(
     input_data: str,
     output_dir: str | None,
     no_timestamp: bool,
+    schema: str,
     verbose: int,
     with_debugger: bool,
 ) -> None:
@@ -223,6 +231,7 @@ def generate_dag(
         input_data=input_data,
         computing_environment=None,
         results_dir=results_dir,
+        schema_name=schema,
     )
     logger.info("*** DAG saved to result directory ***")
 

{easylink-0.1.17 → easylink-0.1.18}/src/easylink/configuration.py

@@ -14,7 +14,7 @@ from typing import Any
 
 from layered_config_tree import LayeredConfigTree
 
-from easylink.pipeline_schema import PIPELINE_SCHEMAS, PipelineSchema
+from easylink.pipeline_schema import PipelineSchema
 from easylink.utilities.data_utils import load_yaml
 from easylink.utilities.general_utils import exit_with_validation_error
 
@@ -67,9 +67,8 @@ class Config(LayeredConfigTree):
         A dictionary of all specifications required to run the pipeline. This
         includes the pipeline, input data, and computing environment specifications,
         as well as the results directory.
-    potential_schemas
-        A list of potential schemas to validate the pipeline configuration against.
-        This is primarily used for testing purposes. Defaults to the supported schemas.
+    schema_name
+        The name of the schema to validate the pipeline configuration against.
 
     Attributes
     ----------
@@ -82,22 +81,14 @@ class Config(LayeredConfigTree):
     input_data
         The input data filepaths.
     schema
-        The :class:`~easylink.pipeline_schema.PipelineSchema` that successfully
-        validated the requested pipeline.
-
-    Notes
-    -----
-    The requested pipeline is checked against a set of supported
-    ``PipelineSchemas``. The first schema that successfully validates is assumed
-    to be the correct one and is attached to the ``Config`` object and its
-    :meth:`~easylink.pipeline_schema.PipelineSchema.configure_pipeline`
-    method is called.
+        The :class:`~easylink.pipeline_schema.PipelineSchema`.
+
     """
 
     def __init__(
         self,
         config_params: dict[str, Any],
-        potential_schemas: PipelineSchema | list[PipelineSchema] = PIPELINE_SCHEMAS,
+        schema_name: str = "main",
     ) -> None:
         super().__init__(layers=["initial_data", "default", "user_configured"])
         self.update(DEFAULT_ENVIRONMENT, layer="default")
@@ -108,9 +99,7 @@ class Config(LayeredConfigTree):
             # Set slurm defaults to empty dict instead of None so that we don't get errors
             # in slurm_resources property
             self.update({"environment": {"slurm": {}}}, layer="default")
-        if not isinstance(potential_schemas, list):
-            potential_schemas = [potential_schemas]
-        self.update({"schema": self._get_schema(potential_schemas)}, layer="initial_data")
+        self.update({"schema": self._get_schema(schema_name)}, layer="initial_data")
         self.schema.configure_pipeline(self.pipeline, self.input_data)
         self._validate()
         self.freeze()
@@ -173,22 +162,22 @@ class Config(LayeredConfigTree):
     # Setup Methods #
     #################
 
-    def _get_schema(self, potential_schemas: list[PipelineSchema]) -> PipelineSchema:
+    def _get_schema(self, schema_name: str = "main") -> PipelineSchema:
         """Returns the first :class:`~easylink.pipeline_schema.PipelineSchema` that validates the requested pipeline.
 
         Parameters
         ----------
-        potential_schemas
-            ``PipelineSchemas`` to validate the pipeline configuration against.
+        schema_name
+            The name of the specific ``PipelineSchema`` to validate the pipeline configuration against.
 
         Returns
         -------
-            The first ``PipelineSchema`` that validates the requested pipeline configuration.
+            The requested ``PipelineSchema`` if it validates the requested pipeline configuration.
 
         Raises
         ------
         SystemExit
-            If the pipeline configuration is not valid for any of the ``potential_schemas``,
+            If the pipeline configuration is not valid for the requested schema,
             the program exits with a non-zero code and all validation errors found
             are logged.
 
@@ -197,20 +186,15 @@ class Config(LayeredConfigTree):
         This acts as the pipeline configuration file's validation method since
         we can only find a matching ``PipelineSchema`` if that file is valid.
 
-        This method returns the *first* ``PipelineSchema`` that validates and does
-        not attempt to check additional ones.
         """
         errors = defaultdict(dict)
         # Try each schema until one is validated
-        for schema in potential_schemas:
-            logs = schema.validate_step(self.pipeline, self.input_data)
-            if logs:
-                errors[PIPELINE_ERRORS_KEY][schema.name] = logs
-                pass  # try the next schema
-            else:  # schema was validated
-                return schema
-        # No schemas were validated
-        exit_with_validation_error(dict(errors))
+        schema = PipelineSchema.get_schema(schema_name)
+        logs = schema.validate_step(self.pipeline, self.input_data)
+        if logs:
+            errors[PIPELINE_ERRORS_KEY][schema.name] = logs
+            exit_with_validation_error(dict(errors))
+        return schema
 
     def _validate(self) -> None:
         """Validates the ``Config``.

{easylink-0.1.17 → easylink-0.1.18}/src/easylink/devtools/implementation_creator.py

@@ -19,7 +19,7 @@ from typing import cast
 import yaml
 from loguru import logger
 
-from easylink.pipeline_schema_constants import ALLOWED_SCHEMA_PARAMS
+from easylink.pipeline_schema_constants import SCHEMA_PARAMS
 from easylink.step import (
     ChoiceStep,
     EmbarrassinglyParallelStep,
@@ -244,17 +244,17 @@ class ImplementationCreator:
     @staticmethod
     def _extract_output_slot(script_path: Path, step_name: str) -> str:
         """Extracts the name of the output slot that this script is implementing."""
-        schema = ImplementationCreator._extract_pipeline_schema(script_path)
-        implementable_steps = ImplementationCreator._extract_implementable_steps(schema)
+        schema_name = ImplementationCreator._extract_pipeline_schema_name(script_path)
+        implementable_steps = ImplementationCreator._extract_implementable_steps(schema_name)
         step_names = [step.name for step in implementable_steps]
         if step_name not in step_names:
             raise ValueError(
-                f"'{step_name}' does not exist as an implementable step in the '{schema}' pipeline schema. "
+                f"'{step_name}' does not exist as an implementable step in the '{schema_name}' pipeline schema. "
             )
         duplicates = list(set([step for step in step_names if step_names.count(step) > 1]))
         if duplicates:
             raise ValueError(
-                f"Multiple implementable steps with the same name found in the '{schema}' "
+                f"Multiple implementable steps with the same name found in the '{schema_name}' "
                 f"pipeline schema: {duplicates}."
             )
         implemented_step = [step for step in implementable_steps if step.name == step_name][0]
@@ -266,7 +266,7 @@ class ImplementationCreator:
         return list(implemented_step.output_slots)[0]
 
     @staticmethod
-    def _extract_implementable_steps(schema: str) -> list[Step]:
+    def _extract_implementable_steps(schema_name: str) -> list[Step]:
         """Extracts all implementable steps from the pipeline schema.
 
         This method recursively traverses the pipeline schema specified in the script
@@ -296,8 +296,7 @@ class ImplementationCreator:
                 implementable_steps.append(node)
                 return
 
-        schema_steps = ALLOWED_SCHEMA_PARAMS[schema][0]
-
+        schema_steps, _edges = SCHEMA_PARAMS[schema_name]
         implementable_steps: list[Step] = []
         for schema_step in schema_steps:
             _process_step(schema_step)
@@ -305,7 +304,7 @@ class ImplementationCreator:
         return implementable_steps
 
     @staticmethod
-    def _extract_pipeline_schema(script_path: Path) -> str:
+    def _extract_pipeline_schema_name(script_path: Path) -> str:
         """Extracts the relevant pipeline schema name.
 
         The expectation is that the output slot's name is specified within the script
@@ -316,8 +315,11 @@ class ImplementationCreator:
 
         If no pipeline schema is specified, "main" will be used by default.
         """
-        schema = _extract_metadata("PIPELINE_SCHEMA", script_path)
-        return "main" if len(schema) == 0 else schema[0]
+        schema_name_list: list[str] = _extract_metadata("PIPELINE_SCHEMA", script_path)
+        schema_name = "main" if len(schema_name_list) == 0 else schema_name_list[0]
+        if schema_name not in SCHEMA_PARAMS:
+            raise ValueError(f"Pipeline schema '{schema_name}' is not supported.")
+        return schema_name
 
     @staticmethod
     def _write_metadata(info: dict[str, dict[str, str]]) -> None:

{easylink-0.1.17 → easylink-0.1.18}/src/easylink/implementation_metadata.yaml

@@ -204,9 +204,6 @@ dummy_step_1_for_output_dir_example_default:
   - step_1_for_output_dir_example
   image_path: /mnt/team/simulation_science/priv/engineering/er_ecosystem/images/zmbc/dummy_step_1_for_output_dir_example.sif
   script_cmd: python /dummy_step_1_for_output_dir_example.py
-  # leave outputs out for testing purposes
-  # outputs:
-  #   step_1_main_output_directory: output_dir/
 dummy_step_2_for_output_dir_example:
   steps:
   - step_2_for_output_dir_example

{easylink-0.1.17 → easylink-0.1.18}/src/easylink/pipeline_schema.py

@@ -14,7 +14,7 @@ from pathlib import Path
 from layered_config_tree import LayeredConfigTree
 
 from easylink.graph_components import EdgeParams, ImplementationGraph
-from easylink.pipeline_schema_constants import ALLOWED_SCHEMA_PARAMS
+from easylink.pipeline_schema_constants import SCHEMA_PARAMS
 from easylink.step import HierarchicalStep, NonLeafConfigurationState, Step
 
 
@@ -39,7 +39,7 @@ class PipelineSchema(HierarchicalStep):
 
     Notes
     -----
-    All ``PipelineSchema`` instances are intended to be created by the :meth:`_get_schemas`
+    A ``PipelineSchema`` is intended to be constructed by the :meth:`get_schema`
     class method.
 
     The ``PipelineSchema`` is a high-level abstraction; it represents the desired
@@ -159,22 +159,21 @@ class PipelineSchema(HierarchicalStep):
         )
 
     @classmethod
-    def _get_schemas(cls) -> list["PipelineSchema"]:
+    def get_schema(cls, name: str = "main") -> list["PipelineSchema"]:
         """Gets all allowable ``PipelineSchemas``.
 
         These ``PipelineSchemas`` represent the fully supported pipelines and are
         used to validate the user-requested pipeline.
 
+        Parameters
+        ----------
+        name
+            The name of the ``PipelineSchema`` to get.
+
         Returns
         -------
-            All allowable ``PipelineSchemas``.
+            The requested ``PipelineSchema``.
         """
-        return [
-            cls(name, nodes=nodes, edges=edges)
-            for name, (nodes, edges) in ALLOWED_SCHEMA_PARAMS.items()
-        ]
-
-
-PIPELINE_SCHEMAS = PipelineSchema._get_schemas()
-"""All allowable :class:`PipelineSchemas<PipelineSchema>` to validate the requested
-pipeline against."""
+        if name not in SCHEMA_PARAMS:
+            raise ValueError(f"Pipeline schema '{name}' is not supported.")
+        return cls(name, *SCHEMA_PARAMS[name])

{easylink-0.1.17 → easylink-0.1.18}/src/easylink/pipeline_schema_constants/__init__.py

@@ -11,11 +11,10 @@ package defines the nodes and edges required to instantiate such ``PipelineSchem
 
 from easylink.pipeline_schema_constants import development, testing
 
-ALLOWED_SCHEMA_PARAMS = {
+SCHEMA_PARAMS = {
+    "main": "TODO",
+    # development and testing
     "development": development.SCHEMA_PARAMS,
-}
-
-TESTING_SCHEMA_PARAMS = {
     "integration": testing.SCHEMA_PARAMS_ONE_STEP,
     "output_dir": testing.SCHEMA_PARAMS_OUTPUT_DIR,
     "combine_bad_topology": testing.SCHEMA_PARAMS_BAD_COMBINED_TOPOLOGY,

{easylink-0.1.17 → easylink-0.1.18}/src/easylink/runner.py

@@ -19,7 +19,6 @@ from snakemake.cli import main as snake_main
 
 from easylink.configuration import Config, load_params_from_specification
 from easylink.pipeline import Pipeline
-from easylink.pipeline_schema import PIPELINE_SCHEMAS, PipelineSchema
 from easylink.utilities.data_utils import (
     copy_configuration_files_to_results_directory,
     create_results_directory,
@@ -35,8 +34,8 @@ def main(
     input_data: str | Path,
     computing_environment: str | Path | None,
     results_dir: str | Path,
-    debug=False,
-    potential_schemas: PipelineSchema | list[PipelineSchema] = PIPELINE_SCHEMAS,
+    schema_name: str = "main",
+    debug: bool = False,
 ) -> None:
     """Runs an EasyLink command.
 
@@ -60,17 +59,16 @@ def main(
         to run the pipeline on. If None, the pipeline will be run locally.
     results_dir
         The directory to write results and incidental files (logs, etc.) to.
+    schema_name
+        The name of the schema to validate the pipeline configuration against.
     debug
         If False (the default), will suppress some of the workflow output. This
         is intended to only be used for testing and development purposes.
-    potential_schemas
-        A list of potential schemas to validate the pipeline configuration against.
-        This is primarily used for testing purposes. Defaults to the supported schemas.
     """
     config_params = load_params_from_specification(
         pipeline_specification, input_data, computing_environment, results_dir
     )
-    config = Config(config_params, potential_schemas)
+    config = Config(config_params, schema_name)
     pipeline = Pipeline(config)
     # After validation is completed, create the results directory
     create_results_directory(Path(results_dir))

{easylink-0.1.17 → easylink-0.1.18}/src/easylink.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easylink
-Version: 0.1.17
+Version: 0.1.18
 Summary: Research repository for the EasyLink ER ecosystem project.
 Home-page: https://github.com/ihmeuw/easylink
 Author: The EasyLink developers

{easylink-0.1.17 → easylink-0.1.18}/tests/e2e/test_easylink_run.py

@@ -63,7 +63,8 @@ def test_easylink_run(
             f"-i {SPECIFICATIONS_DIR / input_data} "
             f"-e {SPECIFICATIONS_DIR / computing_environment} "
             f"-o {str(test_specific_results_dir)} "
-            "--no-timestamp"
+            "--no-timestamp "
+            "--schema development "
         )
         subprocess.run(
             cmd,

{easylink-0.1.17 → easylink-0.1.18}/tests/e2e/test_step_types.py

@@ -57,7 +57,8 @@ def test_step_types(
             f"-i {SPECIFICATIONS_DIR / input_data} "
             f"-e {SPECIFICATIONS_DIR / computing_environment} "
             f"-o {str(test_specific_results_dir)} "
-            "--no-timestamp"
+            "--no-timestamp "
+            "--schema development "
         )
         subprocess.run(
             cmd,

{easylink-0.1.17 → easylink-0.1.18}/tests/integration/test_compositions.py

@@ -6,7 +6,7 @@ import pyarrow.parquet as pq
 import pytest
 
 from easylink.pipeline_schema import PipelineSchema
-from easylink.pipeline_schema_constants import TESTING_SCHEMA_PARAMS
+from easylink.pipeline_schema_constants import SCHEMA_PARAMS
 from easylink.runner import main
 from easylink.utilities.data_utils import load_yaml
 from tests.conftest import SPECIFICATIONS_DIR
@@ -20,11 +20,8 @@ def test_looping_embarrassingly_parallel_step(test_specific_results_dir: Path) -
     pipeline_specification = EP_SPECIFICATIONS_DIR / "pipeline_loop_step.yaml"
     input_data = COMMON_SPECIFICATIONS_DIR / "input_data.yaml"
 
-    # Load the schema to test against
-    schema = PipelineSchema("looping_ep_step", *TESTING_SCHEMA_PARAMS["looping_ep_step"])
-
     _run_pipeline_and_confirm_finished(
-        schema, test_specific_results_dir, pipeline_specification, input_data
+        "looping_ep_step", test_specific_results_dir, pipeline_specification, input_data
     )
 
     intermediate_results_dir = test_specific_results_dir / "intermediate"
@@ -137,11 +134,8 @@ def test_embarrassingly_parallel_sections(
     pipeline_specification = EP_SPECIFICATIONS_DIR / pipeline_spec
     input_data = COMMON_SPECIFICATIONS_DIR / "input_data.yaml"
 
-    # Load the schema to test against
-    schema = PipelineSchema(schema_name, *TESTING_SCHEMA_PARAMS[schema_name])
-
     _run_pipeline_and_confirm_finished(
-        schema, test_specific_results_dir, pipeline_specification, input_data
+        schema_name, test_specific_results_dir, pipeline_specification, input_data
     )
 
     intermediate_results_dir = test_specific_results_dir / "intermediate"
@@ -185,7 +179,7 @@ def test_embarrassingly_parallel_sections(
 
 
 def _run_pipeline_and_confirm_finished(
-    schema: PipelineSchema,
+    schema_name: str,
     results_dir: Path,
     pipeline_specification: Path,
     input_data: Path,
@@ -199,7 +193,7 @@ def _run_pipeline_and_confirm_finished(
             input_data=input_data,
             computing_environment=computing_environment,
             results_dir=results_dir,
-            potential_schemas=schema,
+            schema_name=schema_name,
         )
     assert pytest_wrapped_e.value.code == 0
 

{easylink-0.1.17 → easylink-0.1.18}/tests/integration/test_snakemake.py

@@ -2,7 +2,7 @@
 import pytest
 
 from easylink.pipeline_schema import PipelineSchema
-from easylink.pipeline_schema_constants import TESTING_SCHEMA_PARAMS
+from easylink.pipeline_schema_constants import SCHEMA_PARAMS
 from easylink.runner import main
 from tests.conftest import SPECIFICATIONS_DIR
 
@@ -10,8 +10,7 @@ from tests.conftest import SPECIFICATIONS_DIR
 @pytest.mark.slow
 def test_missing_results(test_specific_results_dir, mocker, caplog):
     """Test that the pipeline fails when a step is missing output files."""
-    nodes, edges = TESTING_SCHEMA_PARAMS["integration"]
-    mocker.patch("easylink.pipeline_schema.ALLOWED_SCHEMA_PARAMS", TESTING_SCHEMA_PARAMS)
+    nodes, edges = SCHEMA_PARAMS["integration"]
     mocker.patch(
         "easylink.configuration.Config._get_schema",
         return_value=PipelineSchema("integration", nodes=nodes, edges=edges),
@@ -39,8 +38,7 @@ def test_missing_results(test_specific_results_dir, mocker, caplog):
 @pytest.mark.parametrize("outputs_specified", [True, False])
 def test_outputting_a_directory(outputs_specified: bool, test_specific_results_dir, mocker):
     """Test that the pipeline fails when a step is missing output files."""
-    nodes, edges = TESTING_SCHEMA_PARAMS["output_dir"]
-    mocker.patch("easylink.pipeline_schema.ALLOWED_SCHEMA_PARAMS", TESTING_SCHEMA_PARAMS)
+    nodes, edges = SCHEMA_PARAMS["output_dir"]
     mocker.patch(
         "easylink.configuration.Config._get_schema",
         return_value=PipelineSchema("output_dir", nodes=nodes, edges=edges),

{easylink-0.1.17 → easylink-0.1.18}/tests/integration/test_snakemake_slurm.py

@@ -6,7 +6,7 @@ import pytest
 from pytest_mock import MockerFixture
 
 from easylink.pipeline_schema import PipelineSchema
-from easylink.pipeline_schema_constants import TESTING_SCHEMA_PARAMS
+from easylink.pipeline_schema_constants import SCHEMA_PARAMS
 from easylink.runner import main
 from easylink.utilities.general_utils import is_on_slurm
 from tests.conftest import SPECIFICATIONS_DIR
@@ -21,8 +21,7 @@ def test_slurm(
     test_specific_results_dir: Path, mocker: MockerFixture, caplog: pytest.LogCaptureFixture
 ) -> None:
     """Test that the pipeline runs on SLURM with appropriate resources."""
-    nodes, edges = TESTING_SCHEMA_PARAMS["integration"]
-    mocker.patch("easylink.pipeline_schema.ALLOWED_SCHEMA_PARAMS", TESTING_SCHEMA_PARAMS)
+    nodes, edges = SCHEMA_PARAMS["integration"]
     mocker.patch(
         "easylink.configuration.Config._get_schema",
         return_value=PipelineSchema("integration", nodes=nodes, edges=edges),

{easylink-0.1.17 → easylink-0.1.18}/tests/integration/test_snakemake_spark.py

@@ -6,7 +6,7 @@ import pytest
 import yaml
 
 from easylink.pipeline_schema import PipelineSchema
-from easylink.pipeline_schema_constants import TESTING_SCHEMA_PARAMS
+from easylink.pipeline_schema_constants import SCHEMA_PARAMS
 from easylink.runner import main
 from easylink.utilities.general_utils import is_on_slurm
 from tests.conftest import SPECIFICATIONS_DIR
@@ -19,8 +19,7 @@ from tests.conftest import SPECIFICATIONS_DIR
 )
 def test_spark_slurm(test_specific_results_dir, mocker, caplog):
     """Test that the pipeline runs spark on SLURM with appropriate resources."""
-    nodes, edges = TESTING_SCHEMA_PARAMS["integration"]
-    mocker.patch("easylink.pipeline_schema.ALLOWED_SCHEMA_PARAMS", TESTING_SCHEMA_PARAMS)
+    nodes, edges = SCHEMA_PARAMS["integration"]
     mocker.patch(
         "easylink.configuration.Config._get_schema",
         return_value=PipelineSchema("integration", nodes=nodes, edges=edges),

{easylink-0.1.17 → easylink-0.1.18}/tests/unit/conftest.py

@@ -155,4 +155,4 @@ def default_config_params(default_config_paths) -> dict[str, Path]:
 @pytest.fixture()
 def default_config(default_config_params) -> Config:
     """A good/known Config object"""
-    return Config(default_config_params)
+    return Config(default_config_params, schema_name="development")

{easylink-0.1.17 → easylink-0.1.18}/tests/unit/test_config.py

@@ -12,12 +12,28 @@ from easylink.configuration import (
     _load_computing_environment,
     _load_input_data_paths,
 )
-from easylink.pipeline_schema import PIPELINE_SCHEMAS
+from easylink.pipeline_schema import PipelineSchema
+from easylink.step import NonLeafConfigurationState
 
 
 def test__get_schema(default_config: Config) -> None:
     """Test default config gets "development schema", without errors"""
-    assert default_config.schema == PIPELINE_SCHEMAS[0]
+    # We cannot assert equality of the config's schema object and a different instance
+    # from PipelineSchema.get_schema("development"), so instead just check that
+    # some of the attrs are the same.
+    schema = default_config.schema
+    assert isinstance(schema, PipelineSchema)
+    assert schema.name == schema.step_name == "development"
+    assert schema.config_key == "substeps"
+    assert isinstance(schema.configuration_state, NonLeafConfigurationState)
+    assert [node.name for node in schema.nodes] == [
+        "input_data",
+        "step_1",
+        "step_2",
+        "step_3",
+        "choice_section",
+        "results",
+    ]
 
 
 def test_load_params_from_specification(
@@ -121,7 +137,7 @@ def test_required_attributes(mocker, default_config_params, key, value):
     if value:
         config_params["environment"][key] = value
     env_dict = {key: value} if value else {}
-    retrieved = Config(config_params).environment[key]
+    retrieved = Config(config_params, "development").environment[key]
     expected = DEFAULT_ENVIRONMENT["environment"].copy()
     expected.update(env_dict)
     assert retrieved == expected[key]
@@ -143,7 +159,7 @@ def test_implementation_resource_requests(default_config_params, resource_reques
     config_params = default_config_params
     if resource_request:
         config_params["environment"][key] = resource_request
-    config = Config(config_params)
+    config = Config(config_params, "development")
     env_dict = {key: resource_request.copy()} if resource_request else {}
     retrieved = config.environment[key].to_dict()
     expected = DEFAULT_ENVIRONMENT["environment"][key].copy()
@@ -191,7 +207,7 @@ def test_spark_requests(default_config_params, spark_request, requires_spark):
 
     if spark_request:
         config_params["environment"][key] = spark_request
-    retrieved = Config(config_params).environment[key].to_dict()
+    retrieved = Config(config_params, "development").environment[key].to_dict()
     expected_env_dict = {key: spark_request.copy()} if spark_request else {}
     expected = LayeredConfigTree(SPARK_DEFAULTS, layers=["initial_data", "user"])
     if spark_request:
@@ -206,6 +222,8 @@ def test_combined_implementations(default_config_params, is_default):
     config_params = default_config_params
     if not is_default:
         config_params["pipeline"]["combined_implementations"] = combined_dict
-    combined_implementations = Config(config_params).pipeline.combined_implementations
+    combined_implementations = Config(
+        config_params, "development"
+    ).pipeline.combined_implementations
     expected = {} if is_default else combined_dict
     assert combined_implementations.to_dict() == expected

{easylink-0.1.17 → easylink-0.1.18}/tests/unit/test_implementation_creator.py

@@ -30,7 +30,6 @@ MULTIPLE_METADATA = """
 # STEP_NAME: step_1
 # REQUIREMENTS: pandas==2.1.2 pyarrow pyyaml"""
 
-
 MULTIPLE_STEPS_METADATA = """
 # STEP_NAME: step_1, step_2
 # REQUIREMENTS: pandas==2.1.2 pyarrow pyyaml"""
@@ -89,11 +88,22 @@ def test__extract_requirements_raises(tmp_path: Path) -> None:
         (MISSING_METADATA, "main"),
     ],
 )
-def test__extract_pipeline_schema(script_content: str, expected: str, tmp_path: Path) -> None:
+def test__extract_pipeline_schema_name(
+    script_content: str, expected: str, tmp_path: Path
+) -> None:
     script_path = tmp_path / "foo_step.py"
     with open(script_path, "w") as file:
         file.write(script_content)
-    assert ImplementationCreator._extract_pipeline_schema(script_path) == expected
+    assert ImplementationCreator._extract_pipeline_schema_name(script_path) == expected
+
+
+def test__extract_pipeline_schema_name_raises(tmp_path: Path) -> None:
+    script_path = tmp_path / "foo_step.py"
+    metadata_str = GOOD_METADATA.replace("development", "some-non-existing-schema")
+    with open(script_path, "w") as file:
+        file.write(metadata_str)
+    with pytest.raises(ValueError, match="is not supported"):
+        ImplementationCreator._extract_pipeline_schema_name(script_path)
 
 
 def test__extract_implementable_steps(tmp_path: Path) -> None:

{easylink-0.1.17 → easylink-0.1.18}/tests/unit/test_pipeline.py

@@ -27,7 +27,7 @@ def test_build_snakefile(
         config_paths["computing_environment"] = f"{test_dir}/spark_environment.yaml"
 
     config_params = load_params_from_specification(**config_paths)
-    config = Config(config_params)
+    config = Config(config_params, "development")
     mocker.patch("easylink.implementation.Implementation.validate", return_value={})
     pipeline = Pipeline(config)
     create_results_directory(results_dir)