lsst-ctrl-bps 29.2025.2900__tar.gz → 29.2025.3500__tar.gz

{lsst_ctrl_bps-29.2025.2900/python/lsst_ctrl_bps.egg-info → lsst_ctrl_bps-29.2025.3500}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-ctrl-bps
-Version: 29.2025.2900
+Version: 29.2025.3500
 Summary: Pluggable execution of workflow graphs from Rubin pipelines.
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
 License: BSD 3-Clause License

{lsst_ctrl_bps-29.2025.2900 → lsst_ctrl_bps-29.2025.3500}/doc/lsst.ctrl.bps/quickstart.rst

@@ -265,7 +265,7 @@ arguments, e.g.:
 .. code-block:: yaml
 
    customJob:
-     executable: "${HOME}/scripts/sleep.sh"
+     executable: "${HOME}/scripts/do_stuff.sh"
      arguments: "2"
 
    # Uncomment settings below to disable automatic memory scaling and retries
@@ -276,16 +276,62 @@ arguments, e.g.:
 
 where ``executable`` specifies the path to the executable to run and
 ``arguments`` is a list of arguments to be supplied to the executable as part
-of the command line.
+of the command line.  If your executable does not take any command line
+arguments set ``arguments`` to an empty string.
 
 .. note::
 
-   If your executable does not take any command line arguments set
-   ``arguments`` to an empty string.
+   The script specified by ``customJob.executable`` is copied to the run's
+   submit directory and this copy (not the original script) is being submitted
+   for execution.  As a result, making any changes to the original script after
+   the run has been submitted will have no effect even if the run is still
+   in the WMS work queue waiting for execution.
+
+If the script requires any input files that should be transferred to the
+execution site as well and/or produces output files that should be brought back
+specify them as follows:
+
+.. code-block:: yaml
+
+   customJob:
+     executable: "${HOME}/scripts/do_stuff.sh"
+     arguments: "-o {outfile} {infile}"
+     inputs:
+       infile: path/to/input/file
+     outputs:
+       outfile: path/to/output/file
 
-This config file will instruct BPS to create a special single-job *workflow* to
-run your script.  That workflow will be submitted for execution as any other
-workflow.
+   # Uncomment settings below to disable automatic memory scaling and retries
+   # which BPS enables by default.
+   #
+   # memoryMultiplier: 1
+   # numberOfRetries: 1
+
+The paths in ``inputs`` specify files as they are accessed on the submit site.
+They can be absolute or relative to the current working directory as the run is
+submitted.  The input files will be copied to the run's submit directory.
+These copies (not the original files) will be submitted along with the script's
+copy for execution.  During the execution BPS will transfer these copies into a
+single flat directory -- job's scratch directory on the execute machine.
+
+The paths in ``outputs`` specifies the paths on the submit site the output
+files will be copied to after job's completion.  As input paths they can be
+either absolute or relative.  However, on the execution site, the script is
+expected to write all its output files directly to job's scratch directory
+(assumed to be the current working directory when the job starts unless stated
+otherwise in the WMS-specific documentation).
+
+As a result, both input and output files base names *must* be unique.
+
+.. note::
+
+   Currently, BPS itself doesn't verify if the file declared in ``outputs`` was
+   produced by the script.  Whether a missing output file will be considered an
+   error depends entirely on WMS in use.
+
+The config files shown above will instruct BPS to create a special single-job
+*workflow* to run your script.  That workflow will be submitted for execution
+as any other workflow.
 
 As a result, the submission process for a custom script looks quite similar
 to the submission process of regular payload jobs (i.e. jobs running
@@ -305,15 +351,6 @@ There are few things you need to keep in mind though:
    instructions exist in the submit YAML.  If you need the quantum graph, use
    ``bps submit``.
 
-#. At the moment, the mechanism does not support transferring files other than
-   executable.
-
-#. The script specified by ``customJob.executable`` is copied to the run's
-   submit directory and this copy (not the original script) is being submitted
-   for execution.  As a result, making any changes to the original script after
-   the run has been submitted will have no effect even if the run is still in
-   the WMS work queue waiting for execution.
-
 #. Some BPS plugins may require inclusion of plugin-specific settings for this
    mechanism to work.  Consult the documentation of the plugin you use for
    details.

{lsst_ctrl_bps-29.2025.2900 → lsst_ctrl_bps-29.2025.3500}/python/lsst/ctrl/bps/construct.py

@@ -31,9 +31,16 @@ __all__ = ["construct"]
 
 import logging
 import shutil
+from collections.abc import Callable
 from pathlib import Path
 
-from lsst.ctrl.bps import BpsConfig, GenericWorkflow, GenericWorkflowExec, GenericWorkflowJob
+from lsst.ctrl.bps import (
+    BpsConfig,
+    GenericWorkflow,
+    GenericWorkflowExec,
+    GenericWorkflowFile,
+    GenericWorkflowJob,
+)
 from lsst.ctrl.bps.transform import _get_job_values
 
 _LOG = logging.getLogger(__name__)
@@ -73,7 +80,7 @@ def create_custom_workflow(config: BpsConfig) -> tuple[GenericWorkflow, BpsConfi
     generic_workflow_config : `lsst.ctrl.BpsConfig`
         Configuration to accompany created generic workflow.
     """
-    gwjob = create_custom_job(config)
+    gwjob, inputs, outputs = create_custom_job(config)
 
     _, name = config.search("uniqProcName", opt={"required": True})
     generic_workflow = GenericWorkflow(name)
@@ -90,6 +97,10 @@ def create_custom_workflow(config: BpsConfig) -> tuple[GenericWorkflow, BpsConfi
             "bps_runsite": config["computeSite"],
         }
     )
+    if inputs:
+        generic_workflow.add_job_inputs(gwjob.name, inputs)
+    if outputs:
+        generic_workflow.add_job_outputs(gwjob.name, outputs)
 
     generic_workflow_config = BpsConfig(config)
     generic_workflow_config["workflowName"] = config["uniqProcName"]
@@ -98,7 +109,9 @@ def create_custom_workflow(config: BpsConfig) -> tuple[GenericWorkflow, BpsConfi
     return generic_workflow, generic_workflow_config
 
 
-def create_custom_job(config: BpsConfig) -> GenericWorkflowJob:
+def create_custom_job(
+    config: BpsConfig,
+) -> tuple[GenericWorkflowJob, list[GenericWorkflowFile], list[GenericWorkflowFile]]:
     """Create a job that will run a custom command or script.
 
     Parameters
@@ -110,6 +123,10 @@ def create_custom_job(config: BpsConfig) -> GenericWorkflowJob:
     -------
     job : `lsst.ctrl.bps.GenericWorkflowJob`
         A custom job responsible for running the command.
+    inputs : `list` [`lsst.ctrl.bps.GenericWorkflowFile`]
+        List of job's input files, empty if the job has no input files.
+    outputs : `list` [`lsst.ctrl.bps.GenericWorkflowFile`]
+        List of job's output files, empty if the job has no output files.
     """
     prefix = Path(config["submitPath"])
     job_label = "customJob"
@@ -135,6 +152,92 @@ def create_custom_job(config: BpsConfig) -> GenericWorkflowJob:
     job.executable = GenericWorkflowExec(
         name=script_name, src_uri=str(prefix / script_name), transfer_executable=True
     )
-    job.arguments = config[f".{job_label}.arguments"]
+    _, job.arguments = config.search("arguments", opt=search_opts | {"replaceVars": False})
 
-    return job
+    inputs = []
+    found, mapping = config.search("inputs", opt=search_opts)
+    if found:
+        inputs = create_job_files(mapping, prefix, path_creator=create_input_path)
+
+    outputs = []
+    found, mapping = config.search("outputs", opt=search_opts)
+    if found:
+        outputs = create_job_files(mapping, prefix, path_creator=create_output_path)
+
+    for gwfile in inputs + outputs:
+        job.arguments = job.arguments.replace(f"{{{gwfile.name}}}", f"<FILE:{gwfile.name}>")
+
+    return job, inputs, outputs
+
+
+def create_job_files(
+    file_specs: BpsConfig, prefix: str | Path, path_creator: Callable[[Path, Path], Path]
+) -> list[GenericWorkflowFile]:
+    """Create files for a job.
+
+    Parameters
+    ----------
+    file_specs : `lsst.ctrl.bps.BpsConfig`
+        The mapping between file keys and file paths.
+    prefix : `str` | `pathlib.Path`
+        The root directory to which the files will be written.
+    path_creator : `Callable` [[`Path`, `Path`], `Path`]
+        File category that determines actions that need to be taken during
+        file creation.
+
+    Returns
+    -------
+    gwfiles : `list` [`lsst.ctrl.bps.GenericWorkflowFile`]
+        List of files created for the job.
+    """
+    prefix = Path(prefix)
+
+    gwfiles = []
+    for key, path in file_specs.items():
+        src = Path(path)
+        dest = path_creator(src, prefix)
+        gwfiles.append(GenericWorkflowFile(name=key, src_uri=str(dest), wms_transfer=True))
+    return gwfiles
+
+
+def create_input_path(path: Path, prefix: Path) -> Path:
+    """Process an input path.
+
+    Parameters
+    ----------
+    path : `pathlib.Path`
+        The input path.
+    prefix : `pathlib.Path`
+        The root directory to which the file will be written.
+
+    Raises
+    ------
+    ValueError
+        Raised if the input path does not exist or is a directory.
+    """
+    if path.exists():
+        if path.is_dir():
+            raise ValueError(f"input path '{path} is a directory, must be file")
+    else:
+        raise ValueError(f"input path '{path}' does not exist")
+    dest = prefix / path.name
+    shutil.copy2(path, dest)
+    return dest
+
+
+def create_output_path(path: Path, prefix: Path) -> Path:
+    """Process an output path.
+
+    Parameters
+    ----------
+    path : `pathlib.Path`
+        The output path.
+    prefix : `pathlib.Path`
+        The root directory to which the file will be written.
+    """
+    if path.is_absolute():
+        dest = path
+    else:
+        dest = prefix / path
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    return dest

{lsst_ctrl_bps-29.2025.2900 → lsst_ctrl_bps-29.2025.3500}/python/lsst/ctrl/bps/transform.py

@@ -316,13 +316,7 @@ def _fill_arguments(use_shared, generic_workflow, arguments, cmdvals):
                 # Have shared filesystems and jobs can share file.
                 uri = gwfile.src_uri
             else:
-                # Taking advantage of inside knowledge.  Not future-proof.
-                # Temporary fix until have job wrapper that pulls files
-                # within job.
-                if gwfile.name == "butlerConfig" and os.path.splitext(gwfile.src_uri)[1] != ".yaml":
-                    uri = "butler.yaml"
-                else:
-                    uri = os.path.basename(gwfile.src_uri)
+                uri = os.path.basename(gwfile.src_uri)
         else:  # Using push transfer
             uri = os.path.basename(gwfile.src_uri)
 

lsst_ctrl_bps-29.2025.3500/python/lsst/ctrl/bps/version.py

@@ -0,0 +1,2 @@
+__all__ = ["__version__"]
+__version__ = "29.2025.3500"

{lsst_ctrl_bps-29.2025.2900 → lsst_ctrl_bps-29.2025.3500/python/lsst_ctrl_bps.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-ctrl-bps
-Version: 29.2025.2900
+Version: 29.2025.3500
 Summary: Pluggable execution of workflow graphs from Rubin pipelines.
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
 License: BSD 3-Clause License

lsst_ctrl_bps-29.2025.3500/tests/test_construct.py

@@ -0,0 +1,371 @@
+# This file is part of ctrl_bps.
+#
+# Developed for the LSST Data Management System.
+# This product includes software developed by the LSST Project
+# (https://www.lsst.org).
+# See the COPYRIGHT file at the top-level directory of this distribution
+# for details of code ownership.
+#
+# This software is dual licensed under the GNU General Public License and also
+# under a 3-clause BSD license. Recipients may choose which of these licenses
+# to use; please see the files gpl-3.0.txt and/or bsd_license.txt,
+# respectively.  If you choose the GPL option then the following text applies
+# (but note that there is still no warranty even if you opt for BSD instead):
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""Unit tests for the methods in construct.py."""
+
+import os
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+from lsst.ctrl.bps import BpsConfig, GenericWorkflowFile, GenericWorkflowJob
+from lsst.ctrl.bps.construct import (
+    construct,
+    create_custom_job,
+    create_custom_workflow,
+    create_input_path,
+    create_job_files,
+    create_output_path,
+)
+
+
+class ConstructTestCase(unittest.TestCase):
+    """Tests for the main construct function."""
+
+    def setUp(self):
+        self.script = tempfile.NamedTemporaryFile(prefix="foo", suffix=".sh")
+        self.submit_dir = tempfile.TemporaryDirectory()
+        self.config = BpsConfig(
+            {
+                "submitPath": self.submit_dir.name,
+                "uniqProcName": "test_workflow",
+                "project": "test_project",
+                "campaign": "test_campaign",
+                "operator": "test_operator",
+                "payloadName": "test_payload",
+                "computeSite": "test_site",
+                "customJob": {
+                    "executable": self.script.name,
+                    "arguments": "test_arg",
+                },
+            },
+            defaults={},
+        )
+
+    def tearDown(self):
+        self.script.close()
+        self.submit_dir.cleanup()
+
+    def testConstructSuccess(self):
+        """Test that construct returns a workflow and config."""
+        workflow, config = construct(self.config)
+
+        self.assertIsNotNone(workflow)
+        self.assertIsNotNone(config)
+        self.assertEqual(workflow.name, "test_workflow")
+        self.assertEqual(config["workflowName"], "test_workflow")
+
+
+class CreateCustomWorkflowTestCase(unittest.TestCase):
+    """Tests for creating a custom workflow."""
+
+    def setUp(self):
+        self.script = tempfile.NamedTemporaryFile(prefix="bar", suffix=".sh")
+        self.submit_dir = tempfile.TemporaryDirectory()
+        self.config = BpsConfig(
+            {
+                "submitPath": self.submit_dir.name,
+                "customJob": {
+                    "executable": self.script.name,
+                    "arguments": "arg",
+                },
+                "project": "dev",
+                "campaign": "test",
+                "operator": "tester",
+                "payloadName": "custom/workflow",
+                "computeCloud": "test_cloud",
+                "computeSite": "test_site",
+            },
+            defaults={},
+        )
+
+    def tearDown(self):
+        self.script.close()
+        self.submit_dir.cleanup()
+
+    def testSuccess(self):
+        self.config["uniqProcName"] = self.config["submitPath"]
+
+        workflow, config = create_custom_workflow(self.config)
+
+        self.assertEqual(workflow.name, self.config["uniqProcName"])
+        self.assertEqual(workflow.job_counts, {"customJob": 1})
+        self.assertTrue(workflow.run_attrs["bps_isjob"])
+        self.assertTrue(workflow.run_attrs["bps_iscustom"])
+        self.assertEqual(workflow.run_attrs["bps_project"], "dev")
+        self.assertEqual(workflow.run_attrs["bps_campaign"], "test")
+        self.assertEqual(workflow.run_attrs["bps_operator"], "tester")
+        self.assertEqual(workflow.run_attrs["bps_payload"], "custom/workflow")
+        self.assertEqual(workflow.run_attrs["bps_run"], workflow.name)
+        self.assertEqual(workflow.run_attrs["bps_runsite"], "test_site")
+        self.assertEqual(config["workflowName"], self.config["uniqProcName"])
+        self.assertEqual(config["workflowPath"], self.config["submitPath"])
+
+    def testEmptyInputs(self):
+        """Test workflow creation when job has no inputs files."""
+        with patch("lsst.ctrl.bps.construct.create_custom_job") as mock_create:
+            self.config["uniqProcName"] = "test_custom"
+
+            job = GenericWorkflowJob(name="test_job", label="test_job")
+            gwfile = GenericWorkflowFile(name="test_output", src_uri="test_output")
+            mock_create.return_value = (job, [], [gwfile])
+
+            workflow, config = create_custom_workflow(self.config)
+
+            self.assertEqual(len(workflow.get_job_inputs(job.name)), 0)
+            self.assertGreater(len(workflow.get_job_outputs(job.name)), 0)
+
+    def testEmptyOutputs(self):
+        """Test workflow creation when job has no output files."""
+        with patch("lsst.ctrl.bps.construct.create_custom_job") as mock_create:
+            self.config["uniqProcName"] = "test_custom"
+
+            job = GenericWorkflowJob(name="test_job", label="test_job")
+            gwfile = GenericWorkflowFile(name="test_input", src_uri="test_input")
+            mock_create.return_value = (job, [gwfile], [])
+
+            workflow, config = create_custom_workflow(self.config)
+
+            self.assertGreater(len(workflow.get_job_inputs(job.name)), 0)
+            self.assertEqual(len(workflow.get_job_outputs(job.name)), 0)
+
+    def testEmptyInputsAndOutputs(self):
+        """Test workflow creation when job has no input nor output files."""
+        with patch("lsst.ctrl.bps.construct.create_custom_job") as mock_create:
+            self.config["uniqProcName"] = "test_custom"
+
+            job = GenericWorkflowJob(name="test_job", label="test_job")
+            mock_create.return_value = (job, [], [])
+
+            workflow, config = create_custom_workflow(self.config)
+
+            self.assertEqual(len(workflow.get_job_inputs(job.name)), 0)
+            self.assertEqual(len(workflow.get_job_outputs(job.name)), 0)
+
+
+class CreateCustomJobTestCase(unittest.TestCase):
+    """Tests for creating a custom job."""
+
+    def setUp(self):
+        self.script = tempfile.NamedTemporaryFile(prefix="foo", suffix=".sh")
+        self.submit_dir = tempfile.TemporaryDirectory()
+        self.config = BpsConfig(
+            {
+                "submitPath": self.submit_dir.name,
+                "computeCloud": "test_cloud",
+                "computeSite": "test_site",
+                "customJob": {
+                    "executable": self.script.name,
+                    "arguments": "arg",
+                },
+            },
+            defaults={},
+        )
+
+    def tearDown(self):
+        self.script.close()
+        self.submit_dir.cleanup()
+
+    def testJobCreationNoFilesSuccess(self):
+        """Test successful creation of a custom job."""
+        script_file = self.script.name
+        script_name = Path(script_file).name
+
+        job, inputs, outputs = create_custom_job(self.config)
+
+        self.assertEqual(job.name, script_name)
+        self.assertEqual(job.label, "customJob")
+        self.assertEqual(job.compute_cloud, "test_cloud")
+        self.assertEqual(job.compute_site, "test_site")
+        self.assertEqual(job.executable.name, script_name)
+        self.assertEqual(job.executable.src_uri, f"{self.submit_dir.name}/{script_name}")
+        self.assertTrue(job.executable.transfer_executable)
+        self.assertTrue(Path(f"{self.submit_dir.name}/{script_name}").exists())
+        self.assertEqual(job.arguments, "arg")
+        self.assertEqual(inputs, [])
+        self.assertEqual(outputs, [])
+
+    def testJobCreationWithFilesSuccess(self):
+        """Test custom job creation with input and output files."""
+        # Create a temporary input file
+        input_file = tempfile.NamedTemporaryFile(prefix="input", suffix=".txt", delete=False)
+        input_file.write(b"test input data")
+        input_file.close()
+
+        self.config[".customJob.arguments"] = "--input {input1} --output {output1}"
+        self.config[".customJob.inputs.input1"] = input_file.name
+        self.config[".customJob.outputs.output1"] = "output.txt"
+
+        try:
+            job, inputs, outputs = create_custom_job(self.config)
+
+            self.assertEqual(len(inputs), 1)
+            self.assertEqual(len(outputs), 1)
+            self.assertEqual(inputs[0].name, "input1")
+            self.assertEqual(outputs[0].name, "output1")
+            self.assertIn("<FILE:input1>", job.arguments)
+            self.assertIn("<FILE:output1>", job.arguments)
+        finally:
+            os.unlink(input_file.name)
+
+    def testJobCreationMissingExecutable(self):
+        """Test custom job creation fails with missing executable."""
+        self.config[".customJob.executable"] = "/nonexistent/script.sh"
+
+        with self.assertRaises(FileNotFoundError):
+            create_custom_job(self.config)
+
+
+class CreateJobFilesTestCase(unittest.TestCase):
+    """Tests for create_job_files function."""
+
+    def setUp(self):
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.prefix = Path(self.temp_dir.name)
+
+    def tearDown(self):
+        self.temp_dir.cleanup()
+
+    def testJobFileCreationNoFiles(self):
+        """Test create_job_files with empty file specs."""
+        config = BpsConfig({"inputs": {}})
+        _, filespecs = config.search("inputs")
+        files = create_job_files(filespecs, self.prefix, lambda path, prefix: prefix / path.name)
+
+        self.assertEqual(files, [])
+
+    def testJobFileCreationWithFiles(self):
+        """Test create_job_files with file specifications."""
+        config = BpsConfig(
+            {
+                "inputs": {
+                    "file1": "/path/to/file1.txt",
+                    "file2": "/path/to/file2.txt",
+                }
+            }
+        )
+        _, filespecs = config.search("inputs")
+        files = create_job_files(filespecs, self.prefix, lambda path, prefix: prefix / path.name)
+
+        self.assertEqual(len(files), 2)
+        self.assertEqual(files[0].name, "file1")
+        self.assertEqual(files[1].name, "file2")
+        self.assertTrue(files[0].wms_transfer)
+        self.assertTrue(files[1].wms_transfer)
+
+
+class CreateInputPathTestCase(unittest.TestCase):
+    """Tests for create_input_path function."""
+
+    def setUp(self):
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.prefix = Path(self.temp_dir.name)
+
+        # Create a test input file
+        self.input_file = tempfile.NamedTemporaryFile(prefix="input_", suffix=".txt", delete=False)
+        self.input_file.write(b"test content")
+        self.input_file.close()
+
+    def tearDown(self):
+        self.temp_dir.cleanup()
+
+    def testInputPathCreationSuccess(self):
+        """Test successful input path creation."""
+        input_path = Path(self.input_file.name)
+        result_path = create_input_path(input_path, self.prefix)
+
+        expected_path = self.prefix / input_path.name
+        self.assertEqual(result_path, expected_path)
+        self.assertTrue(result_path.exists())
+
+        # Verify file content was copied
+        with open(result_path) as f:
+            content = f.read()
+        self.assertEqual(content, "test content")
+
+    def testInputPathCreationFileIsMissing(self):
+        """Test input path creation fails if file does not exist."""
+        nonexistent_path = Path("/nonexistent/file.txt")
+
+        with self.assertRaisesRegex(ValueError, "does not exist"):
+            create_input_path(nonexistent_path, self.prefix)
+
+    def testInputPathCreationFileIsDirectory(self):
+        """Test input path creation fails if path is a directory."""
+        dir_path = Path(self.temp_dir.name)
+
+        with self.assertRaisesRegex(ValueError, "is a directory"):
+            create_input_path(dir_path, self.prefix)
+
+    def testInputPathCreationPermissionError(self):
+        """Test input path creation with permission denied."""
+        with patch("shutil.copy2", side_effect=PermissionError("Permission denied")):
+            with self.assertRaises(PermissionError):
+                create_input_path(Path(self.input_file.name), self.prefix)
+
+
+class CreateOutputPathTestCase(unittest.TestCase):
+    """Tests for create_output_path function."""
+
+    def setUp(self):
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.prefix = Path(self.temp_dir.name)
+
+    def tearDown(self):
+        self.temp_dir.cleanup()
+
+    def testOutputPathCreationRelativePathNew(self):
+        """Test output path creation."""
+        output_path = Path("foo/bar.txt")
+        result_path = create_output_path(output_path, self.prefix)
+        expected_path = self.prefix / "foo/bar.txt"
+
+        self.assertEqual(result_path, expected_path)
+        self.assertTrue(result_path.parent.exists())
+
+    def testOutputPathCreationRelativePathParentExits(self):
+        """Test output path creation when directory already exists."""
+        # Create the directory first
+        subdir = self.prefix / "foo"
+        subdir.mkdir()
+
+        output_path = Path("foo/bar.txt")
+        result_path = create_output_path(output_path, self.prefix)
+        expected_path = self.prefix / "foo/bar.txt"
+
+        self.assertEqual(result_path, expected_path)
+        self.assertTrue(result_path.parent.exists())
+
+    def testOutputPathCreationAbsolutePath(self):
+        """Test that absolute output paths are handled properly."""
+        output_path = self.prefix / "foo/bar.txt"
+        expected_path = output_path
+        result_path = create_output_path(output_path, self.prefix)
+
+        self.assertEqual(result_path, expected_path)
+        self.assertTrue(result_path.parent.exists())

lsst_ctrl_bps-29.2025.2900/python/lsst/ctrl/bps/version.py

@@ -1,2 +0,0 @@
-__all__ = ["__version__"]
-__version__ = "29.2025.2900"

lsst_ctrl_bps-29.2025.2900/tests/test_construct.py

@@ -1,122 +0,0 @@
-# This file is part of ctrl_bps.
-#
-# Developed for the LSST Data Management System.
-# This product includes software developed by the LSST Project
-# (https://www.lsst.org).
-# See the COPYRIGHT file at the top-level directory of this distribution
-# for details of code ownership.
-#
-# This software is dual licensed under the GNU General Public License and also
-# under a 3-clause BSD license. Recipients may choose which of these licenses
-# to use; please see the files gpl-3.0.txt and/or bsd_license.txt,
-# respectively.  If you choose the GPL option then the following text applies
-# (but note that there is still no warranty even if you opt for BSD instead):
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-"""Unit tests for the methods in construct.py."""
-
-import tempfile
-import unittest
-from pathlib import Path
-
-from lsst.ctrl.bps import BpsConfig
-from lsst.ctrl.bps.construct import create_custom_job, create_custom_workflow
-
-
-class CreateCustomJobTestCase(unittest.TestCase):
-    """Tests for creating a custom job."""
-
-    def setUp(self):
-        self.script = tempfile.NamedTemporaryFile(prefix="foo", suffix=".sh")
-        self.submit_dir = tempfile.TemporaryDirectory()
-        self.config = BpsConfig(
-            {
-                "submitPath": self.submit_dir.name,
-                "computeCloud": "testcloud",
-                "computeSite": "testsite",
-                "customJob": {
-                    "executable": self.script.name,
-                    "arguments": "arg",
-                },
-            },
-            defaults={},
-        )
-
-    def tearDown(self):
-        self.script.close()
-        self.submit_dir.cleanup()
-
-    def testSuccess(self):
-        script_file = self.script.name
-        script_name = Path(script_file).name
-
-        job = create_custom_job(self.config)
-
-        self.assertEqual(job.name, script_name)
-        self.assertEqual(job.label, "customJob")
-        self.assertEqual(job.compute_cloud, "testcloud")
-        self.assertEqual(job.compute_site, "testsite")
-        self.assertEqual(job.executable.name, script_name)
-        self.assertEqual(job.executable.src_uri, f"{self.submit_dir.name}/{script_name}")
-        self.assertTrue(job.executable.transfer_executable)
-        self.assertTrue(Path(f"{self.submit_dir.name}/{script_name}").exists())
-        self.assertEqual(job.arguments, "arg")
-
-
-class CreateCustomWorkflowTestSuite(unittest.TestCase):
-    """Tests for creating a custom workflow."""
-
-    def setUp(self):
-        self.script = tempfile.NamedTemporaryFile(prefix="bar", suffix=".sh")
-        self.submit_dir = tempfile.TemporaryDirectory()
-        self.config = BpsConfig(
-            {
-                "submitPath": self.submit_dir.name,
-                "customJob": {
-                    "executable": self.script.name,
-                    "arguments": "arg",
-                },
-                "project": "dev",
-                "campaign": "test",
-                "operator": "tester",
-                "payloadName": "custom/workflow",
-                "computeCloud": "testcloud",
-                "computeSite": "testsite",
-            },
-            defaults={},
-        )
-
-    def tearDown(self):
-        self.script.close()
-        self.submit_dir.cleanup()
-
-    def testSuccess(self):
-        self.config["uniqProcName"] = self.config["submitPath"]
-
-        workflow, config = create_custom_workflow(self.config)
-
-        self.assertEqual(workflow.name, self.config["uniqProcName"])
-        self.assertEqual(workflow.job_counts, {"customJob": 1})
-        self.assertTrue(workflow.run_attrs["bps_isjob"])
-        self.assertTrue(workflow.run_attrs["bps_iscustom"])
-        self.assertEqual(workflow.run_attrs["bps_project"], "dev")
-        self.assertEqual(workflow.run_attrs["bps_campaign"], "test")
-        self.assertEqual(workflow.run_attrs["bps_operator"], "tester")
-        self.assertEqual(workflow.run_attrs["bps_payload"], "custom/workflow")
-        self.assertEqual(workflow.run_attrs["bps_run"], workflow.name)
-        self.assertEqual(workflow.run_attrs["bps_runsite"], "testsite")
-
-        self.assertEqual(config["workflowName"], self.config["uniqProcName"])
-        self.assertEqual(config["workflowPath"], self.config["submitPath"])