lsst-ctrl-bps-parsl 27.2024.3100__tar.gz → 29.2025.4900__tar.gz

{lsst_ctrl_bps_parsl-27.2024.3100/python/lsst_ctrl_bps_parsl.egg-info → lsst_ctrl_bps_parsl-29.2025.4900}/PKG-INFO

@@ -1,17 +1,18 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: lsst-ctrl-bps-parsl
-Version: 27.2024.3100
+Version: 29.2025.4900
 Summary: Parsl-based plugin for lsst-ctrl-bps.
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
-License: BSD 3-Clause License
+License-Expression: BSD-3-Clause OR GPL-3.0-or-later
 Project-URL: Homepage, https://github.com/lsst/ctrl_bps_parsl
 Keywords: lsst
 Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: Astronomy
 Requires-Python: >=3.11.0
 Description-Content-Type: text/markdown
@@ -20,10 +21,11 @@ License-File: LICENSE
 License-File: bsd_license.txt
 License-File: gpl-v3.0.txt
 Requires-Dist: lsst-ctrl-bps
-Requires-Dist: parsl
+Requires-Dist: parsl>=2024.03.04
 Provides-Extra: test
 Requires-Dist: pytest>=3.2; extra == "test"
 Requires-Dist: pytest-openfiles>=0.5.0; extra == "test"
+Dynamic: license-file
 
 # ctrl_bps_parsl
 

{lsst_ctrl_bps_parsl-27.2024.3100 → lsst_ctrl_bps_parsl-29.2025.4900}/pyproject.toml

@@ -6,24 +6,26 @@ build-backend = "setuptools.build_meta"
 name = "lsst-ctrl-bps-parsl"
 requires-python = ">=3.11.0"
 description = "Parsl-based plugin for lsst-ctrl-bps."
-license = {text = "BSD 3-Clause License"}
+license = "BSD-3-Clause OR GPL-3.0-or-later"
+license-files = ["COPYRIGHT", "LICENSE", "bsd_license.txt", "gpl-v3.0.txt"]
 readme = "README.md"
 authors = [
     {name="Rubin Observatory Data Management", email="dm-admin@lists.lsst.org"},
 ]
 classifiers = [
     "Intended Audience :: Science/Research",
-    "License :: OSI Approved :: BSD License",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Topic :: Scientific/Engineering :: Astronomy",
 ]
 keywords = ["lsst"]
 dependencies = [
     "lsst-ctrl-bps",
-    "parsl",
+    "parsl >= 2024.03.04",
 ]
 dynamic = ["version"]
 
@@ -41,7 +43,6 @@ where = ["python"]
 
 [tool.setuptools]
 zip-safe = true
-license-files = ["COPYRIGHT", "LICENSE", "bsd_license.txt", "gpl-v3.0.txt"]
 
 [tool.setuptools.package-data]
 "lsst.ctrl.bps.parsl" = ["etc/*.yaml"]
@@ -94,6 +95,7 @@ target-version = ["py311"]
 [tool.isort]
 profile = "black"
 line_length = 110
+known_first_party = ["lsst"]
 
 [tool.lsst_versions]
 write_to = "python/lsst/ctrl/bps/parsl/version.py"
@@ -144,17 +146,28 @@ select = [
     "D",  # pydocstyle
     "UP",  # pyupgrade
     "C4",
+    "I",  # isort
+    "RUF022",  # sort __all__
+    "B",  # bugbear
 ]
 extend-select = [
     "RUF100", # Warn about unused noqa
 ]
 
+[tool.ruff.lint.isort]
+known-first-party = ["lsst"]
+known-third-party = ["parsl"]
+
 [tool.ruff.lint.pycodestyle]
 max-doc-length = 79
 
 [tool.ruff.lint.pydocstyle]
 convention = "numpy"
 
+[tool.ruff.format]
+docstring-code-format = true
+docstring-code-line-length = 79
+
 [tool.numpydoc_validation]
 checks = [
     "all",  # All except the rules listed below.

{lsst_ctrl_bps_parsl-27.2024.3100 → lsst_ctrl_bps_parsl-29.2025.4900}/python/lsst/ctrl/bps/parsl/job.py

@@ -34,13 +34,14 @@ from functools import partial
 from textwrap import dedent
 from typing import Any
 
-from lsst.ctrl.bps import BpsConfig, GenericWorkflow, GenericWorkflowJob
 from parsl.app.bash import BashApp
 from parsl.app.futures import Future
 
+from lsst.ctrl.bps import BpsConfig, GenericWorkflow, GenericWorkflowJob
+
 from .configuration import get_bps_config_value
 
-__all__ = ("get_file_paths", "ParslJob")
+__all__ = ("ParslJob", "get_file_paths")
 
 _env_regex = re.compile(r"<ENV:(\S+)>")  # Regex for replacing <ENV:WHATEVER> in BPS job command-lines
 _file_regex = re.compile(r"<FILE:(\S+)>")  # Regex for replacing <FILE:WHATEVER> in BPS job command-lines
@@ -282,12 +283,12 @@ class ParslJob:
             command = self.evaluate_command_line(command)
             if command_prefix:
                 command = command_prefix + "\n" + command
-            resources = self.get_resources() if add_resources else None
+            resources = self.get_resources() if add_resources else {}
 
             # Add a layer of indirection to which we can add a useful name.
             # This name is used by parsl for tracking workflow status.
             func = partial(run_command)
-            setattr(func, "__name__", self.generic.label)
+            func.__name__ = self.generic.label  # type: ignore
 
             self.future = app(func)(
                 command,

{lsst_ctrl_bps_parsl-27.2024.3100 → lsst_ctrl_bps_parsl-29.2025.4900}/python/lsst/ctrl/bps/parsl/site.py

@@ -30,12 +30,13 @@ from types import ModuleType
 from typing import TYPE_CHECKING
 
 import parsl.config
-from lsst.ctrl.bps import BpsConfig
-from lsst.utils import doImport
 from parsl.addresses import address_by_hostname
 from parsl.executors.base import ParslExecutor
 from parsl.monitoring import MonitoringHub
 
+from lsst.ctrl.bps import BpsConfig
+from lsst.utils import doImport
+
 from .configuration import get_bps_config_value, get_workflow_name
 from .environment import export_environment
 

{lsst_ctrl_bps_parsl-27.2024.3100 → lsst_ctrl_bps_parsl-29.2025.4900}/python/lsst/ctrl/bps/parsl/sites/__init__.py

@@ -27,4 +27,5 @@
 
 from .local import *
 from .slurm import *
+from .torque import *
 from .work_queue import *

lsst_ctrl_bps_parsl-29.2025.4900/python/lsst/ctrl/bps/parsl/sites/ccin2p3.py

@@ -0,0 +1,363 @@
+import copy
+import platform
+from typing import TYPE_CHECKING, Any
+
+import parsl.config
+from parsl.executors import HighThroughputExecutor
+from parsl.executors.base import ParslExecutor
+from parsl.providers import SlurmProvider
+
+from ..configuration import get_bps_config_value
+from ..site import SiteConfig
+
+if TYPE_CHECKING:
+    from .job import ParslJob
+
+__all__ = ("Ccin2p3",)
+
+Kwargs = dict[str, Any]
+
+
+class Ccin2p3(SiteConfig):
+    """Configuration for executing Parsl jobs in CC-IN2P3 Slurm batch farm.
+
+    This class provides four job slot sizes each with its specific
+    requirements, in particular in terms of memory. Those slot sizes are named
+    "small", "medium", "large" and "xlarge".
+
+    Sensible default values for those requirements are provided for each
+    job slot but you can overwrite those defaults either in the
+    the BPS submission file or in a site configuration file that you
+    include in your BPS submission file.
+
+    If you don't need to modify the default requirements for the job slot
+    sizes, use the site specification below in your BPS configuration
+    file:
+
+    .. code-block:: yaml
+
+        wmsServiceClass: lsst.ctrl.bps.parsl.ParslService
+        computeSite: ccin2p3
+
+        site:
+          ccin2p3:
+            class: lsst.ctrl.bps.parsl.sites.ccin2p3.Ccin2p3
+
+    If you do need to modify those defaults, you can overwrite them for
+    all job slots or for specific each job slots. Requirements specified
+    for a job slot take priority over those specified for all job slots
+    at the level of entry '.site.ccin2p3:'.
+
+    This is an example of how to overwrite selected requirements in your BPS
+    submission file:
+
+    .. code-block:: yaml
+
+        wmsServiceClass: lsst.ctrl.bps.parsl.ParslService
+        computeSite: ccin2p3
+
+        site:
+          ccin2p3:
+            class: lsst.ctrl.bps.parsl.sites.ccin2p3.Ccin2p3
+            walltime: "72:00:00"
+            scheduler_options:
+              - "--licenses=sps"
+              - "--qos=normal"
+            small:
+              memory: 6
+              partition: "flash"
+            medium:
+              memory: 10
+              partition: "lsst,htc"
+            large:
+              memory: 80
+            xlarge:
+              memory: 180
+              partition: "lsst"
+              scheduler_options:
+                - "--constraint=el7"
+                - "--licenses=my_product"
+                - "--reservation=my_reservation"
+
+    At the level of entry 'site.ccin2p3:' in the BPS submission file, the
+    following configuration parameters are accepted, which apply to all slot
+    sizes:
+
+    - `partition` (`str`): name of the one or more configured partitions. If
+       more than one, separate them with comma (',').
+       (Default: "lsst,htc")
+    - `walltime` (`str`): walltime to require for the job (Default: "72:00:00")
+    - `scheduler_options` (`list` [`str`] ): scheduler options to send to Slurm
+       for scheduling purposes.
+       (Default: "--licenses=sps")
+
+    In addition, as shown in the previous example, for each job slot (i.e.
+    "small", "medium", etc.) you can specify the requirements above as well as
+    the following:
+
+    - `max_blocks` (`int`): maximum number of Slurm jobs that your workflow can
+       simultaneously use.
+    - `memory` (`int`): required amount of memory for each job, in Gigabytes.
+       (Defaults: 4 for "small", 10 for "medium", 50 fo "large" and
+       150 for "xlarge").
+
+    Parameters
+    ----------
+    *args : optional
+        Arguments to initialize the super-class.
+    **kwargs : optional
+        Keyword arguments to initialize the super-class.
+
+    Returns
+    -------
+    Ccin2p3 : `SiteConfig`
+        Concrete instance of a `SiteConfig` specific for the CC-IN2P3 Slurm
+        farm.
+    """
+
+    DEFAULT_ACCOUNT: str = "lsst"
+    DEFAULT_WALLTIME: str = "72:00:00"
+    DEFAULT_SCHEDULER_OPTIONS: list[str] = [
+        "--licenses=sps",
+    ]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._account = get_bps_config_value(self.site, ".account", str, self.DEFAULT_ACCOUNT)
+        self._scheduler_options = get_bps_config_value(
+            self.site, ".scheduler_options", list, self.DEFAULT_SCHEDULER_OPTIONS
+        )
+        self._slot_size = {
+            "small": {
+                "memory": get_bps_config_value(self.site, ".small.memory", int, 4),
+                "walltime": self._get_walltime_for_slot("small"),
+                "partition": self._get_partition_for_slot("small"),
+                "max_blocks": get_bps_config_value(self.site, ".small.max_blocks", int, 3_000),
+                "scheduler_options": get_bps_config_value(self.site, ".small.scheduler_options", list, []),
+            },
+            "medium": {
+                "memory": get_bps_config_value(self.site, ".medium.memory", int, 10),
+                "walltime": self._get_walltime_for_slot("medium"),
+                "partition": self._get_partition_for_slot("medium"),
+                "max_blocks": get_bps_config_value(self.site, ".medium.max_blocks", int, 1_000),
+                "scheduler_options": get_bps_config_value(self.site, ".medium.scheduler_options", list, []),
+            },
+            "large": {
+                "memory": get_bps_config_value(self.site, ".large.memory", int, 50),
+                "walltime": self._get_walltime_for_slot("large"),
+                "partition": self._get_partition_for_slot("large"),
+                "max_blocks": get_bps_config_value(self.site, ".large.max_blocks", int, 100),
+                "scheduler_options": get_bps_config_value(self.site, ".large.scheduler_options", list, []),
+            },
+            "xlarge": {
+                "memory": get_bps_config_value(self.site, ".xlarge.memory", int, 150),
+                "walltime": self._get_walltime_for_slot("xlarge"),
+                "partition": self._get_partition_for_slot("xlarge"),
+                "max_blocks": get_bps_config_value(self.site, ".xlarge.max_blocks", int, 10),
+                "scheduler_options": get_bps_config_value(self.site, ".xlarge.scheduler_options", list, []),
+            },
+        }
+
+    def _get_partition_for_slot(self, slot: str) -> str:
+        """Return the Slurm partition Parsl must use to submit jobs for the
+        job slot `slot`. Values of `slot` can be "small", "medium", "large"
+        or "xlarge".
+        """
+        # The target Slurm partition must be selected according to the type of
+        # the job slot but also according to the CPU architecture of the
+        # compute node.
+        #
+        # Parsl requires that the CPU architecture of its orchestrator to
+        # be identical to the architecture of its executors. Therefore,
+        # we need to ensure that Slurm schedules our Parsl executors on
+        # compute nodes with the same architecture as the host where this
+        # orchestrator runs.
+
+        # Default target Slurm partitions per CPU architecture
+        default_partition = {
+            "aarch64": {
+                "small": "htc_arm",
+                "medium": "htc_arm",
+                "large": "htc_arm",
+                "xlarge": "htc_arm",
+            },
+            "x86_64": {
+                "small": "lsst,htc",
+                "medium": "lsst",
+                "large": "lsst",
+                "xlarge": "lsst",
+            },
+        }
+        architecture = platform.machine()
+        if architecture not in default_partition:
+            raise ValueError(f"architecture {architecture} is not supported")
+
+        # If a partition was specified in the workflow description file
+        # specifically for this job slot, use that partition. For instance:
+        #
+        # site:
+        #   ccin2p3:
+        #     class: lsst.ctrl.bps.parsl.sites.ccin2p3.Ccin2p3
+        #     small:
+        #       partition: htc
+        slot_partition = get_bps_config_value(self.site, f".{slot}.partition", str, "")
+        if slot_partition != "":
+            return slot_partition
+
+        # If a partition was specified in the workflow description file at
+        # the site level, use that partition. For instance:
+        #
+        # site:
+        #   ccin2p3:
+        #     class: lsst.ctrl.bps.parsl.sites.ccin2p3.Ccin2p3
+        #     partition: htc
+        #
+        # Otherwise, use the default for this slot on this architecture.
+        return get_bps_config_value(self.site, ".partition", str, default_partition[architecture][slot])
+
+    def _get_walltime_for_slot(self, slot: str) -> str:
+        """Return the value for walltime Parsl must use to submit jobs for the
+        job slot `slot`. Values of `slot` can be "small", "medium", "large"
+        or "xlarge".
+        """
+        # If a specific walltime value was specified for this job slot in the
+        # configuration use that value. For instance:
+        #
+        # site:
+        #   ccin2p3:
+        #     class: lsst.ctrl.bps.parsl.sites.ccin2p3.Ccin2p3
+        #     small:
+        #       walltime: "3:00:00"
+        slot_walltime = get_bps_config_value(self.site, f".{slot}.walltime", str, "")
+        if slot_walltime != "":
+            return slot_walltime
+
+        # If a walltime value was specified for the site use that value.
+        # Otherwise, use the default walltime. For instance:
+        #
+        # site:
+        #   ccin2p3:
+        #     class: lsst.ctrl.bps.parsl.sites.ccin2p3.Ccin2p3
+        #     walltime: "3:00:00"
+        return get_bps_config_value(self.site, ".walltime", str, self.DEFAULT_WALLTIME)
+
+    def get_executors(self) -> list[ParslExecutor]:
+        """Get a list of Parsl executors that can be used for processing a
+        workflow.
+
+        Each executor must have a unique ``label``.
+        """
+        executors: list[ParslExecutor] = []
+        for label, slot in self._slot_size.items():
+            # Compute the scheduler options for this job slot. Options
+            # specified at the slot level in the configuration file
+            # overwrite those specified at the site level.
+            scheduler_options = copy.deepcopy(self._scheduler_options)
+            if slot_scheduler_options := slot.get("scheduler_options", []):
+                scheduler_options = copy.deepcopy(slot_scheduler_options)
+
+            options = f"#SBATCH {' '.join(opt for opt in scheduler_options)}" if scheduler_options else ""
+
+            executor = HighThroughputExecutor(
+                label,
+                provider=SlurmProvider(
+                    # Slurm partition to request blocks from.
+                    partition=slot["partition"],
+                    # Slurm account to which to charge resources used by the
+                    # job.
+                    account=self._account,
+                    # Nodes to provision per block (1 block = 1 CPU core).
+                    nodes_per_block=1,
+                    # Number of CPU cores to provision per node.
+                    cores_per_node=1,
+                    # Memory per node (GB) for each Slurm job.
+                    mem_per_node=slot["memory"],
+                    # Initial number of blocks.
+                    init_blocks=0,
+                    # Minimum number of blocks to maintain.
+                    min_blocks=0,
+                    # Maximum number of blocks to maintain.
+                    max_blocks=slot["max_blocks"],
+                    # Time limit for each Slurm job.
+                    walltime=slot["walltime"],
+                    # '#SBATCH' directives to prepend to the Slurm submission
+                    # script.
+                    scheduler_options=options,
+                    # Set the number of file descriptors and processes to
+                    # the maximum allowed.
+                    worker_init="ulimit -n hard && ulimit -u hard",
+                    # Requests nodes which are not shared with other running
+                    # jobs.
+                    exclusive=False,
+                ),
+                # Address to connect to the main Parsl process.
+                address=self.get_address(),
+                # GB of memory required per worker. If specified the node
+                # manager will check the available memory at startup and limit
+                # the number of workers such that the there’s sufficient memory
+                # for each worker.
+                mem_per_worker=None,
+                # Caps the number of workers launched per node.
+                max_workers_per_node=1,
+                # Timeout period (in milliseconds) to be used by the
+                # executor components.
+                poll_period=1_000,
+                # Retry submitting to Slurm in case of submission error.
+                block_error_handler=False,
+            )
+            executors.append(executor)
+
+        return executors
+
+    def select_executor(self, job: "ParslJob") -> str:
+        """Get the ``label`` of the executor to use to execute ``job``.
+
+        Parameters
+        ----------
+        job : `ParslJob`
+            Job to be executed.
+
+        Returns
+        -------
+        label : `str`
+            Label of executor to use to execute ``job``.
+        """
+        # We choose the executor to use based only on the memory required
+        # by the job.
+        memory = job.generic.request_memory / 1024  # Convert to GB
+        for label in ("small", "medium", "large"):
+            if memory <= self._slot_size[label]["memory"]:
+                return label
+
+        return "xlarge"
+
+    def get_parsl_config(self) -> parsl.config.Config:
+        """Get Parsl configuration for using CC-IN2P3 Slurm farm as a
+        Parsl execution site.
+
+        Returns
+        -------
+        config : `parsl.config.Config`
+            The configuration to be used to initialize Parsl for this site.
+        """
+        executors = self.get_executors()
+        monitor = self.get_monitor()
+
+        # Number of retries in case of job failure.
+        retries = get_bps_config_value(self.site, ".retries", int, 0)
+
+        # Path to run directory.
+        run_dir = get_bps_config_value(self.site, ".run_dir", str, "parsl_runinfo")
+
+        # Strategy for scaling blocks according to workflow needs.
+        # Use a strategy that allows for scaling up and down Parsl workers.
+        strategy = get_bps_config_value(self.site, ".strategy", str, "htex_auto_scale")
+
+        return parsl.config.Config(
+            executors=executors,
+            monitoring=monitor,
+            retries=retries,
+            checkpoint_mode="task_exit",
+            run_dir=run_dir,
+            strategy=strategy,
+        )

{lsst_ctrl_bps_parsl-27.2024.3100 → lsst_ctrl_bps_parsl-29.2025.4900}/python/lsst/ctrl/bps/parsl/sites/local.py

@@ -53,7 +53,7 @@ class Local(SiteConfig):
         Each executor should have a unique ``label``.
         """
         cores = get_bps_config_value(self.site, "cores", int, required=True)
-        return [HighThroughputExecutor("local", provider=LocalProvider(), max_workers=cores)]
+        return [HighThroughputExecutor("local", provider=LocalProvider(), max_workers_per_node=cores)]
 
     def select_executor(self, job: "ParslJob") -> str:
         """Get the ``label`` of the executor to use to execute a job.

{lsst_ctrl_bps_parsl-27.2024.3100 → lsst_ctrl_bps_parsl-29.2025.4900}/python/lsst/ctrl/bps/parsl/sites/princeton.py

@@ -58,19 +58,8 @@ class Tiger(Slurm):
       ``True``.
 
     When running on the Tiger cluster, you should operate on the
-    ``/scratch/gpfs`` filesystem, rather than ``/projects`` or ``/tigress``,
-    as the latter are much slower on the cluster nodes than they are on the
-    head nodes. Your BPS config should contain::
-
-        includeConfigs:
-          - ${CTRL_BPS_PARSL_DIR}/etc/execution_butler_copy_files.yaml
-
-    This will cause the necessary files to be transferred from your repo
-    (presumably on ``/projects`` or ``/tigress``) to the execution butler in
-    your submission directory (presumably on ``/scratch/gpfs``). Failure to do
-    so will result in about a 6x slowdown, and probably degrading performance
-    for other users. The results will be copied back to the original repo when
-    everything has completed.
+    ``/scratch/gpfs`` filesystem, rather than ``/projects`` or ``/tigress``;
+    the latter are not even mounted on the cluster nodes any more.
     """
 
     def get_executors(self) -> list[ParslExecutor]:
@@ -94,9 +83,9 @@ class Tiger(Slurm):
             self.make_executor(
                 "tiger",
                 nodes=4,
-                cores_per_node=40,
+                cores_per_node=112,
                 walltime="05:00:00",  # Ensures we get into qos=tiger-vshort, which cuts off at 5h
-                mem_per_node=187,  # Ensures all nodes are queried, reserving 5GB for OS services
+                mem_per_node=980,  # Ensures all nodes are available, reserving a little for OS services
                 singleton=True,
                 provider_options={
                     "init_blocks": 1,

{lsst_ctrl_bps_parsl-27.2024.3100 → lsst_ctrl_bps_parsl-29.2025.4900}/python/lsst/ctrl/bps/parsl/sites/slurm.py

@@ -75,6 +75,7 @@ class Slurm(SiteConfig):
       default we use whatever Slurm gives us.
     - ``singleton`` (`bool`): allow only one job to run at a time; by default
       ``False``.
+    - ``account`` (`str`): account to use for Slurm jobs.
     - ``scheduler_options`` (`str`): text to prepend to the Slurm submission
       script (each line usually starting with ``#SBATCH``).
     """
@@ -135,6 +136,7 @@ class Slurm(SiteConfig):
         mem_per_node = get_bps_config_value(self.site, "mem_per_node", int, mem_per_node)
         qos = get_bps_config_value(self.site, "qos", str, qos)
         singleton = get_bps_config_value(self.site, "singleton", bool, singleton)
+        account = get_bps_config_value(self.site, "account", str)
         scheduler_options = get_bps_config_value(self.site, "scheduler_options", str, scheduler_options)
 
         job_name = get_workflow_name(self.config)
@@ -163,6 +165,7 @@ class Slurm(SiteConfig):
                 cores_per_node=cores_per_node,
                 mem_per_node=mem_per_node,
                 walltime=walltime,
+                account=account,
                 scheduler_options=scheduler_options,
                 **(provider_options or {}),
             ),

lsst_ctrl_bps_parsl-29.2025.4900/python/lsst/ctrl/bps/parsl/sites/torque.py

@@ -0,0 +1,273 @@
+# This file is part of ctrl_bps_parsl.
+#
+# Developed for the LSST Data Management System.
+# This product includes software developed by the LSST Project
+# (https://www.lsst.org) and the LSST DESC (https://www.lsstdesc.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/>.
+
+from typing import TYPE_CHECKING, Any
+
+from parsl.executors import HighThroughputExecutor
+from parsl.executors.base import ParslExecutor
+from parsl.launchers import MpiRunLauncher
+from parsl.providers import TorqueProvider
+
+from ..configuration import get_bps_config_value, get_workflow_name
+from ..site import SiteConfig
+
+if TYPE_CHECKING:
+    from ..job import ParslJob
+
+__all__ = ("Torque",)
+
+
+Kwargs = dict[str, Any]
+
+
+class Torque(SiteConfig):
+    """Configuration for generic Torque cluster.
+
+    This can be used directly as the site configuration for a Torque cluster by
+    setting the BPS config, e.g.:
+
+    .. code-block:: yaml
+
+        computeSite: torque
+        site:
+          torque:
+            class: lsst.ctrl.bps.parsl.sites.Torque
+            nodes: 4
+            tasks_per_node: 20
+            walltime: "00:59:00"  # Note: always quote walltime in YAML
+
+    Alternatively, it can be used as a base class for Torque cluster
+    configurations.
+
+    The following BPS configuration parameters are recognised (and required
+    unless there is a default mentioned here, or provided by a subclass):
+
+    - ``queue`` (`int`): Queue for the Torque job.
+    - ``nodes`` (`int`): number of nodes for each Torque job.
+    - ``tasks_per_node`` (`int`): number of cores per node for each Torque job;
+      by default we use all cores on the node.
+    - ``walltime`` (`str`): time limit for each Torque job.
+    - ``scheduler_options`` (`str`): text to prepend to the Torque submission
+      script (each line usually starting with ``#PBS``).
+    """
+
+    def make_executor(
+        self,
+        label: str,
+        *,
+        queue: str | None = None,
+        nodes: int | None = None,
+        tasks_per_node: int | None = None,
+        walltime: str | None = None,
+        mem_per_worker: float | None = None,
+        scheduler_options: str | None = None,
+        worker_init: str | None = None,
+        provider_options: Kwargs | None = None,
+        executor_options: Kwargs | None = None,
+    ) -> ParslExecutor:
+        """Return an executor for running on a Torque cluster.
+
+        Parameters
+        ----------
+        label : `str`
+            Label for executor.
+        queue : `str`, optional
+            Queue for the Torque job.
+        nodes : `int`, optional
+            Default number of nodes for each Torque job.
+        tasks_per_node : `int`, optional
+            Default number of cores per node for each Torque job.
+        walltime : `str`, optional
+            Default time limit for each Torque job.
+        mem_per_worker : `float`, optional
+            Minimum memory per worker (GB), limited by the executor.
+        worker_init : `str`, optional
+            Environment initiation command
+        scheduler_options : `str`, optional
+            ``#SBATCH`` directives to prepend to the Torque submission script.
+        provider_options : `dict`, optional
+            Additional arguments for `TorqueProvider` constructor.
+        executor_options : `dict`, optional
+            Additional arguments for `HighThroughputExecutor` constructor.
+
+        Returns
+        -------
+        executor : `HighThroughputExecutor`
+            Executor for Torque jobs.
+        """
+        nodes = get_bps_config_value(self.site, "nodes", int, nodes, required=True)
+        walltime = get_bps_config_value(self.site, "walltime", str, walltime, required=True)
+        queue = get_bps_config_value(self.site, "queue", str, queue)
+        tasks_per_node = get_bps_config_value(self.site, "tasks_per_node", int, tasks_per_node)
+        worker_init = get_bps_config_value(self.site, "worker_init", str, "")
+        scheduler_options = get_bps_config_value(self.site, "scheduler_options", str, scheduler_options)
+
+        if tasks_per_node is None:
+            tasks_per_node = 1
+
+        job_name = get_workflow_name(self.config)
+
+        if scheduler_options is None:
+            scheduler_options = ""
+        else:
+            scheduler_options += "\n"
+        scheduler_options += f"#PBS -N {job_name}\n"
+        if queue:
+            scheduler_options += f"#PBS -q {queue}\n"
+
+        if worker_init is None:
+            worker_init = ""
+
+        launcher = PbsMpiRunLauncher(overrides=f"--map-by core:{tasks_per_node}")
+
+        return HighThroughputExecutor(
+            label,
+            provider=PbsTorqueProvider(
+                nodes_per_block=nodes,
+                tasks_per_node=tasks_per_node,
+                queue=queue,
+                walltime=walltime,
+                scheduler_options=scheduler_options,
+                worker_init=worker_init,
+                launcher=launcher,
+                **(provider_options or {}),
+            ),
+            max_workers_per_node=1,
+            mem_per_worker=mem_per_worker,
+            address=self.get_address(),
+            **(executor_options or {}),
+        )
+
+    def get_executors(self) -> list[ParslExecutor]:
+        """Get a list of executors to be used in processing.
+
+        Each executor should have a unique ``label``.
+        """
+        return [self.make_executor("torque")]
+
+    def select_executor(self, job: "ParslJob") -> str:
+        """Get the ``label`` of the executor to use to execute a job.
+
+        Parameters
+        ----------
+        job : `ParslJob`
+            Job to be executed.
+
+        Returns
+        -------
+        label : `str`
+            Label of executor to use to execute ``job``.
+        """
+        return "torque"
+
+
+class PbsTorqueProvider(TorqueProvider):
+    """Torque Execution Provider
+
+    This provider uses qsub to submit, qstat for status, and qdel to cancel
+    jobs. The qsub script to be used is created from a template file in this
+    same module.
+
+    This subclass allows the ``tasks_per_node`` to be set at construction time
+    instead of at submission time.
+    """
+
+    def __init__(self, *args, tasks_per_node: int = 1, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.tasks_per_node = tasks_per_node
+
+    def submit(self, command, tasks_per_node, job_name="parsl.torque"):
+        """Submit the command onto an Local Resource Manager job.
+
+        This function returns an ID that corresponds to the task that was just
+        submitted.
+
+        The ``tasks_per_node`` parameter is ignored in this provider, as it is
+        set at construction time.
+
+        Parameters
+        ----------
+        command : `str`
+            Command-line invocation to be made on the remote side.
+        tasks_per_node : `int`
+            Number of tasks to be launched per node. This is ignored in this
+            provider.
+        job_name : `str`:
+            Name for job, must be unique.
+
+        Returns
+        -------
+            None: At capacity, cannot provision more
+            job_id (string): Identifier for the job
+
+        """
+        return super().submit(
+            command=command,
+            tasks_per_node=self.tasks_per_node,
+            job_name=job_name,
+        )
+
+
+class PbsMpiRunLauncher(MpiRunLauncher):
+    """Worker launcher that wraps the user's command with the framework to
+    launch multiple command invocations via ``mpirun``.
+
+    This wrapper sets the bash env variable ``CORES`` to the number of cores on
+    the machine.
+
+    This launcher makes the following assumptions:
+    - mpirun is installed and can be located in ``$PATH``
+    - The provider makes available the ``$PBS_NODEFILE`` environment variable
+    """
+
+    def __init__(
+        self,
+        debug: bool = True,
+        bash_location: str = "/bin/bash",
+        overrides: str = "",
+    ):
+        super().__init__(debug=debug, bash_location=bash_location, overrides=overrides)
+
+    def __call__(self, command: str, tasks_per_node: int, nodes_per_block: int) -> str:
+        """Wrap the user's command with mpirun invocation"""
+        worker_count = nodes_per_block * tasks_per_node
+        debug_num = int(self.debug)
+
+        return f"""set -e
+export CORES=$(getconf _NPROCESSORS_ONLN)
+[[ "{debug_num}" == "1" ]] && echo "Found cores : $CORES"
+WORKERCOUNT={worker_count}
+
+cat << MPIRUN_EOF > cmd_$JOBNAME.sh
+{command}
+MPIRUN_EOF
+chmod u+x cmd_$JOBNAME.sh
+
+mpirun -np $WORKERCOUNT {self.overrides} {self.bash_location} cmd_$JOBNAME.sh
+
+[[ "{debug_num}" == "1" ]] && echo "All workers done"
+"""

{lsst_ctrl_bps_parsl-27.2024.3100 → lsst_ctrl_bps_parsl-29.2025.4900}/python/lsst/ctrl/bps/parsl/sites/work_queue.py

@@ -43,7 +43,7 @@ from ..site import SiteConfig
 if TYPE_CHECKING:
     from ..job import ParslJob
 
-__all__ = ("WorkQueue", "LocalSrunWorkQueue")
+__all__ = ("LocalSrunWorkQueue", "WorkQueue")
 
 
 class WorkQueue(SiteConfig):

lsst_ctrl_bps_parsl-29.2025.4900/python/lsst/ctrl/bps/parsl/version.py

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

{lsst_ctrl_bps_parsl-27.2024.3100 → lsst_ctrl_bps_parsl-29.2025.4900}/python/lsst/ctrl/bps/parsl/workflow.py

@@ -32,11 +32,12 @@ from collections.abc import Iterable, Mapping
 
 import parsl
 import parsl.config
-from lsst.ctrl.bps import BaseWmsWorkflow, BpsConfig, GenericWorkflow, GenericWorkflowJob
 from parsl.app.app import bash_app
 from parsl.app.bash import BashApp
 from parsl.app.futures import Future
 
+from lsst.ctrl.bps import BaseWmsWorkflow, BpsConfig, GenericWorkflow, GenericWorkflowJob
+
 from .configuration import get_workflow_filename, set_parsl_logging
 from .job import ParslJob, get_file_paths
 from .site import SiteConfig

{lsst_ctrl_bps_parsl-27.2024.3100 → lsst_ctrl_bps_parsl-29.2025.4900/python/lsst_ctrl_bps_parsl.egg-info}/PKG-INFO

@@ -1,17 +1,18 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: lsst-ctrl-bps-parsl
-Version: 27.2024.3100
+Version: 29.2025.4900
 Summary: Parsl-based plugin for lsst-ctrl-bps.
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
-License: BSD 3-Clause License
+License-Expression: BSD-3-Clause OR GPL-3.0-or-later
 Project-URL: Homepage, https://github.com/lsst/ctrl_bps_parsl
 Keywords: lsst
 Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: Astronomy
 Requires-Python: >=3.11.0
 Description-Content-Type: text/markdown
@@ -20,10 +21,11 @@ License-File: LICENSE
 License-File: bsd_license.txt
 License-File: gpl-v3.0.txt
 Requires-Dist: lsst-ctrl-bps
-Requires-Dist: parsl
+Requires-Dist: parsl>=2024.03.04
 Provides-Extra: test
 Requires-Dist: pytest>=3.2; extra == "test"
 Requires-Dist: pytest-openfiles>=0.5.0; extra == "test"
+Dynamic: license-file
 
 # ctrl_bps_parsl
 

{lsst_ctrl_bps_parsl-27.2024.3100 → lsst_ctrl_bps_parsl-29.2025.4900}/python/lsst_ctrl_bps_parsl.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ python/lsst/ctrl/bps/parsl/sites/nersc.py
 python/lsst/ctrl/bps/parsl/sites/princeton.py
 python/lsst/ctrl/bps/parsl/sites/slac.py
 python/lsst/ctrl/bps/parsl/sites/slurm.py
+python/lsst/ctrl/bps/parsl/sites/torque.py
 python/lsst/ctrl/bps/parsl/sites/work_queue.py
 python/lsst_ctrl_bps_parsl.egg-info/PKG-INFO
 python/lsst_ctrl_bps_parsl.egg-info/SOURCES.txt

{lsst_ctrl_bps_parsl-27.2024.3100 → lsst_ctrl_bps_parsl-29.2025.4900}/python/lsst_ctrl_bps_parsl.egg-info/requires.txt

@@ -1,5 +1,5 @@
 lsst-ctrl-bps
-parsl
+parsl>=2024.03.04
 
 [test]
 pytest>=3.2

lsst_ctrl_bps_parsl-27.2024.3100/python/lsst/ctrl/bps/parsl/sites/ccin2p3.py

@@ -1,245 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-import parsl.config
-from parsl.executors import HighThroughputExecutor
-from parsl.executors.base import ParslExecutor
-from parsl.providers import SlurmProvider
-
-from ..configuration import get_bps_config_value
-from ..site import SiteConfig
-
-if TYPE_CHECKING:
-    from .job import ParslJob
-
-__all__ = ("Ccin2p3",)
-
-Kwargs = dict[str, Any]
-
-
-class Ccin2p3(SiteConfig):
-    """Configuration for running Parsl jobs in CC-IN2P3 Slurm batch farm.
-
-    This class provides 4 job slot sizes with different requirements, in
-    particular in terms of memory. Those slot sizes are named "small",
-    "medium", "large" and "xlarge".
-
-    Sensible default values for those requirements are provided for each
-    kind of job but you can specify different values either in the
-    the BPS submission file or in a site configuration file that you
-    include in your BPS submission file.
-
-    This is an example of how to modify the specifications for those job
-    slot sizes in the BPS submission file:
-
-    .. code-block:: yaml
-
-        wmsServiceClass: lsst.ctrl.bps.parsl.ParslService
-        computeSite: ccin2p3
-
-        site:
-          ccin2p3:
-            class: lsst.ctrl.bps.parsl.sites.Ccin2p3
-            walltime: "72:00:00"
-            qos: "normal"
-            small:
-                memory: 4
-                partition: "flash"
-            medium:
-                memory: 10
-                partition: "lsst,htc"
-            large:
-                memory: 50
-            xlarge:
-                memory: 150
-                partition: "lsst"
-
-    At the level of 'site:' entry in the BPS submission file, the following
-    configuration parameters are accepted, which apply to all slot sizes:
-
-    - `partition` (`str`): name of the one or more configured partitions. If
-       more than one, separate them with comma (',').
-       (Default: "lsst,htc")
-    - `qos` (`str`): quality of service to use (Default: "normal")
-    - `walltime` (`str`): walltime to require for the job (Default: "72:00:00")
-
-    For each kind of job slot (i.e. "small", "medium", etc.) you can specify
-    the parameters above as well as:
-
-    - `max_blocks` (`int`): maximum number of Slurm jobs that your workflow can
-       simultaneously use.
-    - ``memory`` (`int`): required amount of memory in Gigabytes.
-
-    as shown in the example above.
-
-    If you don't need to modify those values and use the default configuration
-    for all the job slot sizes use:
-
-    .. code-block:: yaml
-
-        wmsServiceClass: lsst.ctrl.bps.parsl.ParslService
-        computeSite: ccin2p3
-
-        site:
-        ccin2p3:
-            class: lsst.ctrl.bps.parsl.sites.Ccin2p3
-
-    Parameters
-    ----------
-    *args : optional
-        Arguments to initialize the super-class.
-    **kwargs : optional
-        Keyword arguments to initialize the super-class.
-
-    Returns
-    -------
-    Ccin2p3 : `SiteConfig`
-        Concrete instance of a `SiteConfig` specific for the CC-IN2P3 Slurm
-        farm.
-    """
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-        self._account = get_bps_config_value(self.site, "account", str, "lsst")
-        default_partition = get_bps_config_value(self.site, "partition", str, "lsst,htc")
-        default_qos = get_bps_config_value(self.site, "qos", str, "normal")
-        default_walltime = get_bps_config_value(self.site, "walltime", str, "72:00:00")
-
-        self._slot_size = {
-            "small": {
-                "max_blocks": get_bps_config_value(self.site, "small.max_blocks", int, 3_000),
-                "memory": get_bps_config_value(self.site, "small.memory", int, 4),
-                "partition": get_bps_config_value(self.site, "small.partition", str, default_partition),
-                "qos": get_bps_config_value(self.site, "small.qos", str, default_qos),
-                "walltime": get_bps_config_value(self.site, "small.walltime", str, default_walltime),
-            },
-            "medium": {
-                "max_blocks": get_bps_config_value(self.site, "medium.max_blocks", int, 1_000),
-                "memory": get_bps_config_value(self.site, "medium.memory", int, 10),
-                "partition": get_bps_config_value(self.site, "medium.partition", str, "lsst"),
-                "qos": get_bps_config_value(self.site, "medium.qos", str, default_qos),
-                "walltime": get_bps_config_value(self.site, "medium.walltime", str, default_walltime),
-            },
-            "large": {
-                "max_blocks": get_bps_config_value(self.site, "large.max_blocks", int, 100),
-                "memory": get_bps_config_value(self.site, "large.memory", int, 50),
-                "partition": get_bps_config_value(self.site, "large.partition", str, "lsst"),
-                "qos": get_bps_config_value(self.site, "large.qos", str, default_qos),
-                "walltime": get_bps_config_value(self.site, "large.walltime", str, default_walltime),
-            },
-            "xlarge": {
-                "max_blocks": get_bps_config_value(self.site, "xlarge.max_blocks", int, 10),
-                "memory": get_bps_config_value(self.site, "xlarge.memory", int, 150),
-                "partition": get_bps_config_value(self.site, "xlarge.partition", str, "lsst"),
-                "qos": get_bps_config_value(self.site, "xlarge.qos", str, default_qos),
-                "walltime": get_bps_config_value(self.site, "xlarge.walltime", str, default_walltime),
-            },
-        }
-
-    def get_executors(self) -> list[ParslExecutor]:
-        """Get a list of executors to be used for processing a workflow.
-        Each executor must have a unique ``label``.
-        """
-        executors: list[ParslExecutor] = []
-        for label, slot in self._slot_size.items():
-            qos = slot["qos"]
-            executor = HighThroughputExecutor(
-                label,
-                provider=SlurmProvider(
-                    # Slurm partition to request blocks from.
-                    partition=slot["partition"],
-                    # Slurm account to which to charge resources used by the
-                    # job.
-                    account=self._account,
-                    # Nodes to provision per block (1 block = 1 CPU core).
-                    nodes_per_block=1,
-                    # Number of CPU cores to provision per node.
-                    cores_per_node=1,
-                    # Memory per node (GB) for each Slurm job.
-                    mem_per_node=slot["memory"],
-                    # Initial number of blocks.
-                    init_blocks=0,
-                    # Minimum number of blocks to maintain.
-                    min_blocks=0,
-                    # Maximum number of blocks to maintain.
-                    max_blocks=slot["max_blocks"],
-                    # Time limit for each Slurm job.
-                    walltime=slot["walltime"],
-                    # '#SBATCH' directives to prepend to the Slurm submission
-                    # script.
-                    scheduler_options=f"#SBATCH --qos={qos} --licenses=sps",
-                    # Set the number of file descriptors and processes to
-                    # the maximum allowed.
-                    worker_init="ulimit -n hard && ulimit -u hard",
-                    # Requests nodes which are not shared with other running
-                    # jobs.
-                    exclusive=False,
-                    # Should files be moved by Parsl?
-                    move_files=False,
-                ),
-                # Address to connect to the main Parsl process.
-                address=self.get_address(),
-                # GB of memory required per worker. If specified the node
-                # manager will check the available memory at startup and limit
-                # the number of workers such that the there’s sufficient memory
-                # for each worker.
-                mem_per_worker=None,
-                # Caps the number of workers launched per node.
-                max_workers=1,
-                # Timeout period (in milliseconds) to be used by the
-                # executor components.
-                poll_period=1_000,
-                # Retry submitting to Slurm in case of submission error.
-                block_error_handler=False,
-            )
-            executors.append(executor)
-
-        return executors
-
-    def select_executor(self, job: "ParslJob") -> str:
-        """Get the ``label`` of the executor to use to execute ``job``.
-
-        Parameters
-        ----------
-        job : `ParslJob`
-            Job to be executed.
-
-        Returns
-        -------
-        label : `str`
-            Label of executor to use to execute ``job``.
-        """
-        # We choose the executor to use based only on the memory required
-        # by the job.
-        memory = job.generic.request_memory / 1024  # Convert to GB
-        for label in ("small", "medium", "large"):
-            if memory <= self._slot_size[label]["memory"]:
-                return label
-
-        return "xlarge"
-
-    def get_parsl_config(self) -> parsl.config.Config:
-        """Get Parsl configuration for using CC-IN2P3 Slurm farm as a
-        Parsl execution site.
-
-        Returns
-        -------
-        config : `parsl.config.Config`
-            The configuration to be used to initialize Parsl for this site.
-        """
-        executors = self.get_executors()
-        monitor = self.get_monitor()
-        retries = get_bps_config_value(self.site, "retries", int, 1)
-        run_dir = get_bps_config_value(self.site, "run_dir", str, "parsl_runinfo")
-        # Strategy for scaling blocks according to workflow needs.
-        # Use a strategy that allows for scaling in and out Parsl
-        # workers.
-        strategy = get_bps_config_value(self.site, "strategy", str, "htex_auto_scale")
-        return parsl.config.Config(
-            executors=executors,
-            monitoring=monitor,
-            retries=retries,
-            checkpoint_mode="task_exit",
-            run_dir=run_dir,
-            strategy=strategy,
-        )

lsst_ctrl_bps_parsl-27.2024.3100/python/lsst/ctrl/bps/parsl/version.py

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

{lsst_ctrl_bps_parsl-27.2024.3100 → lsst_ctrl_bps_parsl-29.2025.4900}/python/lsst/ctrl/bps/parsl/configuration.py

@@ -33,8 +33,8 @@ from lsst.ctrl.bps import BpsConfig
 
 __all__ = (
     "get_bps_config_value",
-    "get_workflow_name",
     "get_workflow_filename",
+    "get_workflow_name",
     "set_parsl_logging",
 )