asyncmd 0.3.2__py3-none-any.whl → 0.3.3__py3-none-any.whl

asyncmd/gromacs/mdconfig.py

@@ -302,7 +302,7 @@ class MDP(LineBasedMDConfig):
             # option 2 (and 3 if the comment is before the equal sign)
             # comment sign is the first letter, so the whole line is
             # (most probably) a comment line
-            logger.debug(f"mdp line parsed as comment: {line}")
+            logger.debug("mdp line parsed as comment: %s", line)
             return {}
         if ((len(splits_at_equal) == 2 and len(splits_at_comment) == 1)  # option 1
             # or option 3 with equal sign before comment sign

asyncmd/gromacs/mdengine.py

@@ -626,8 +626,8 @@ class GmxEngine(MDEngine):
                                      + f"{cpt_fname} does not exist."
                                      )
                 starting_configuration = cpt_fname
-                logger.warning("Starting value for 'simulation-part' > 1 (=%s)"
-                               " and existing checkpoint file found (%s). "
+                logger.warning("Starting value for 'simulation-part' > 1 (=%s) "
+                               "and existing checkpoint file found (%s). "
                                "Using the checkpoint file as "
                                "`starting_configuration`.",
                                sim_part, cpt_fname)
@@ -712,7 +712,7 @@ class GmxEngine(MDEngine):
             stdout, stderr = await grompp_proc.communicate()
             return_code = grompp_proc.returncode
             logger.debug("gmx grompp command returned return code %s.",
-                         return_code)
+                         str(return_code) if return_code is not None else "not available")
             #logger.debug("grompp stdout:\n%s", stdout.decode())
             #logger.debug("grompp stderr:\n%s", stderr.decode())
             if return_code != 0:
@@ -754,9 +754,9 @@ class GmxEngine(MDEngine):
         last_partnum = int(last_trajname[len(deffnm) + 5:len(deffnm) + 9])
         if last_partnum != len(previous_trajs):
             logger.warning("Not all previous trajectory parts seem to be "
-                           + "present in the current workdir. Assuming the "
-                           + "highest part number corresponds to the "
-                           + "checkpoint file and continuing anyway."
+                           "present in the current workdir. Assuming the "
+                           "highest part number corresponds to the "
+                           "checkpoint file and continuing anyway."
                            )
         # load the 'old' mdp_in
         async with _SEMAPHORES["MAX_FILES_OPEN"]:
@@ -869,7 +869,7 @@ class GmxEngine(MDEngine):
             raise e from None  # reraise the error for encompassing coroutines
         else:
             logger.debug("gmx mdrun command returned return code %s.",
-                         returncode)
+                         str(returncode) if returncode is not None else "not available")
             #logger.debug("gmx mdrun stdout:\n%s", stdout.decode())
             #logger.debug("gmx mdrun stderr:\n%s", stderr.decode())
             if returncode == 0:
@@ -1025,6 +1025,7 @@ class SlurmGmxEngine(GmxEngine):
     #       although the mdrun was successfull.
 
     def __init__(self, mdconfig, gro_file, top_file, sbatch_script, ndx_file=None,
+                 sbatch_options: dict | None = None,
                  **kwargs):
         """
         Initialize a :class:`SlurmGmxEngine`.
@@ -1047,6 +1048,19 @@ class SlurmGmxEngine(GmxEngine):
 
         ndx_file: str or None
             Optional, absolute or relative path to a gromacs index file.
+        sbatch_options : dict or None
+            Dictionary of sbatch options, keys are long names for options,
+            values are the correponding values. The keys/long names are given
+            without the dashes, e.g. to specify "--mem=1024" the dictionary
+            needs to be {"mem": "1024"}. To specify options without values use
+            keys with empty strings as values, e.g. to specify "--contiguous"
+            the dictionary needs to be {"contiguous": ""}.
+            See the SLURM documentation for a full list of sbatch options
+            (https://slurm.schedmd.com/sbatch.html).
+            Note: This argument is passed as is to the `SlurmProcess` in which
+            the computation is performed. Each call to the engines `run` method
+            triggers the creation of a new `SlurmProcess` and will use the then
+            current `sbatch_options`.
 
         Note that all attributes can be set at intialization by passing keyword
         arguments with their name, e.g. mdrun_extra_args="-ntomp 2" to instruct
@@ -1063,6 +1077,7 @@ class SlurmGmxEngine(GmxEngine):
             with open(sbatch_script, 'r') as f:
                 sbatch_script = f.read()
         self.sbatch_script = sbatch_script
+        self.sbatch_options = sbatch_options
 
     def _name_from_name_or_none(self, run_name: typing.Optional[str]) -> str:
         if run_name is not None:
@@ -1089,12 +1104,13 @@ class SlurmGmxEngine(GmxEngine):
             async with aiofiles.open(fname, 'w') as f:
                 await f.write(script)
         self._proc = await slurm.create_slurmprocess_submit(
-                                                jobname=name,
-                                                sbatch_script=fname,
-                                                workdir=workdir,
-                                                time=walltime,
-                                                stdfiles_removal="success",
-                                                stdin=None,
+                                        jobname=name,
+                                        sbatch_script=fname,
+                                        workdir=workdir,
+                                        time=walltime,
+                                        sbatch_options=self.sbatch_options,
+                                        stdfiles_removal="success",
+                                        stdin=None,
                                                             )
 
     async def _acquire_resources_gmx_mdrun(self, **kwargs):

asyncmd/gromacs/utils.py

@@ -172,12 +172,12 @@ def ensure_mdp_options(mdp: MDP, genvel: str = "no", continuation: str = "yes")
         # make sure we do not generate velocities with gromacs
         genvel_test = mdp["gen-vel"]
     except KeyError:
-        logger.info(f"Setting 'gen-vel = {genvel}' in mdp.")
+        logger.info("Setting 'gen-vel = %s' in mdp.", genvel)
         mdp["gen-vel"] = genvel
     else:
         if genvel_test != genvel:
-            logger.warning(f"Setting 'gen-vel = {genvel}' in mdp "
-                           + f"(was '{genvel_test}').")
+            logger.warning("Setting 'gen-vel = %s' in mdp "
+                           "(was '%s').", genvel, genvel_test)
             mdp["gen-vel"] = genvel
     try:
         # TODO/FIXME: this could also be 'unconstrained-start'!
@@ -186,12 +186,12 @@ def ensure_mdp_options(mdp: MDP, genvel: str = "no", continuation: str = "yes")
         #            so I think we can ignore that for now?!
         continuation_test = mdp["continuation"]
     except KeyError:
-        logger.info(f"Setting 'continuation = {continuation}' in mdp.")
+        logger.info("Setting 'continuation = %s' in mdp.", continuation)
         mdp["continuation"] = continuation
     else:
         if continuation_test != continuation:
-            logger.warning(f"Setting 'continuation = {continuation}' in mdp "
-                           + f"(was '{continuation_test}').")
+            logger.warning("Setting 'continuation = %s' in mdp "
+                           "(was '%s').", continuation, continuation_test)
             mdp["continuation"] = continuation
 
     return mdp

asyncmd/mdconfig.py

@@ -386,8 +386,8 @@ class LineBasedMDConfig(MDConfig):
                     else:
                         # warn that we will only keep the last occurenc of key
                         logger.warning("Parsed duplicate configuration option "
-                                       + f"({key}). Last values encountered "
-                                       + "take precedence.")
+                                       "(%s). Last values encountered take "
+                                       "precedence.", key)
                 parsed.update(line_parsed)
         # convert the known types
         self._config = {key: self._type_dispatch[key](value)

asyncmd/slurm.py

@@ -130,7 +130,7 @@ class SlurmClusterMediator:
     #             (here forever means until we reinitialize SlurmClusterMediator)
 
     def __init__(self, **kwargs) -> None:
-        self._exclude_nodes = []
+        self._exclude_nodes: list[str] = []
         # make it possible to set any attribute via kwargs
         # check the type for attributes with default values
         dval = object()
@@ -151,17 +151,17 @@ class SlurmClusterMediator:
         # this either checks for our defaults or whatever we just set via kwargs
         self.sacct_executable = ensure_executable_available(self.sacct_executable)
         self.sinfo_executable = ensure_executable_available(self.sinfo_executable)
-        self._node_job_fails = collections.Counter()
-        self._node_job_successes = collections.Counter()
+        self._node_job_fails: dict[str,int] = collections.Counter()
+        self._node_job_successes: dict[str,int] = collections.Counter()
         self._all_nodes = self.list_all_nodes()
-        self._jobids = []  # list of jobids of jobs we know about
-        self._jobids_sacct = []  # list of jobids we monitor actively via sacct
+        self._jobids: list[str] = []  # list of jobids of jobs we know about
+        self._jobids_sacct: list[str] = []  # list of jobids we monitor actively via sacct
         # we will store the info about jobs in a dict keys are jobids
         # values are dicts with key queried option and value the (parsed)
         # return value
         # currently queried options are: state, exitcode and nodelist
-        self._jobinfo = {}
-        self._last_sacct_call = 0  # make sure we dont call sacct too often
+        self._jobinfo: dict[str,dict] = {}
+        self._last_sacct_call = 0.  # make sure we dont call sacct too often
         # make sure we can only call sacct once at a time
         # (since there is only one ClusterMediator at a time we can create
         #  the semaphore here in __init__)
@@ -383,17 +383,18 @@ class SlurmClusterMediator:
                 self._jobinfo[jobid]["nodelist"] = nodelist
                 self._jobinfo[jobid]["exitcode"] = exitcode
                 self._jobinfo[jobid]["state"] = state
-                logger.debug(f"Extracted from sacct output: jobid {jobid},"
-                             + f" state {state}, exitcode {exitcode} and "
-                             + f"nodelist {nodelist}.")
+                logger.debug("Extracted from sacct output: jobid %s, state %s, "
+                             "exitcode %s and nodelist %s.",
+                             jobid, state, exitcode, nodelist,
+                            )
                 parsed_ec = self._parse_exitcode_from_slurm_state(slurm_state=state)
                 self._jobinfo[jobid]["parsed_exitcode"] = parsed_ec
                 if parsed_ec is not None:
-                    logger.debug("Parsed slurm state %s for job %s"
-                                 " as returncode %s. Removing job"
-                                 "from sacct calls because its state will"
-                                 " not change anymore.",
-                                 state, jobid, parsed_ec,
+                    logger.debug("Parsed slurm state %s for job %s as "
+                                 "returncode %s. Removing job from sacct calls "
+                                 "because its state will not change anymore.",
+                                 state, jobid, str(parsed_ec) if parsed_ec is not None
+                                 else "not available",
                                  )
                     self._jobids_sacct.remove(jobid)
                     self._node_fail_heuristic(jobid=jobid,
@@ -434,8 +435,8 @@ class SlurmClusterMediator:
             # make the string a list of single node hostnames
             hostnameprefix, nums = nodelist.split("[")
             nums = nums.rstrip("]")
-            nums = nums.split(",")
-            return [f"{hostnameprefix}{num}" for num in nums]
+            nums_list = nums.split(",")
+            return [f"{hostnameprefix}{num}" for num in nums_list]
 
     def _parse_exitcode_from_slurm_state(self,
                                          slurm_state: str,
@@ -443,8 +444,9 @@ class SlurmClusterMediator:
         for ecode, regexp in self._ecode_for_slurmstate_regexps.items():
             if regexp.search(slurm_state):
                 # regexp matches the given slurm_state
-                logger.debug("Parsed SLURM state %s as exitcode %d.",
-                             slurm_state, ecode,
+                logger.debug("Parsed SLURM state %s as exitcode %s.",
+                             slurm_state, str(ecode) if ecode is not None
+                             else "not available",
                              )
                 return ecode
         # we should never finish the loop, it means we miss a slurm job state
@@ -522,11 +524,11 @@ class SlurmClusterMediator:
         all_nodes = len(self._all_nodes)
         exclude_nodes = len(self._exclude_nodes)
         if exclude_nodes >= all_nodes / 4:
-            logger.error("We already declared 1/4 of the cluster as broken."
-                         + "Houston, we might have a problem?")
+            logger.error("We already declared 1/4 of the cluster as broken. "
+                         "Houston, we might have a problem?")
             if exclude_nodes >= all_nodes / 2:
-                logger.error("In fact we declared 1/2 of the cluster as broken."
-                             + "Houston, we *do* have a problem!")
+                logger.error("In fact we declared 1/2 of the cluster as broken. "
+                             "Houston, we *do* have a problem!")
                 if exclude_nodes >= all_nodes * 0.75:
                     raise RuntimeError("Houston? 3/4 of the cluster is broken?")
 
@@ -581,9 +583,9 @@ class SlurmProcess:
         _slurm_cluster_mediator = None
         # we raise a ValueError if sacct/sinfo are not available
         logger.warning("Could not initialize SLURM cluster handling. "
-                       "If you are sure SLURM (sinfo/sacct/etc) is available"
-                       " try calling `asyncmd.config.set_slurm_settings()`"
-                       " with the appropriate arguments.")
+                       "If you are sure SLURM (sinfo/sacct/etc) is available "
+                       "try calling `asyncmd.config.set_slurm_settings()` "
+                       "with the appropriate arguments.")
     # we can not simply wait for the subprocess, since slurm exits directly
     # so we will sleep for this long between checks if slurm-job completed
     sleep_time = 15  # TODO: heuristic? dynamically adapt?
@@ -597,8 +599,9 @@ class SlurmProcess:
     scancel_executable = "scancel"
 
     def __init__(self, jobname: str, sbatch_script: str,
-                 workdir: typing.Optional[str] = None,
-                 time: typing.Optional[float] = None,
+                 workdir: str | None = None,
+                 time: float | None = None,
+                 sbatch_options: dict | None = None,
                  stdfiles_removal: str = "success",
                  **kwargs) -> None:
         """
@@ -619,6 +622,15 @@ class SlurmProcess:
         time : float or None
             Timelimit for the job in hours. None will result in using the
             default as either specified in the sbatch script or the partition.
+        sbatch_options : dict or None
+            Dictionary of sbatch options, keys are long names for options,
+            values are the correponding values. The keys/long names are given
+            without the dashes, e.g. to specify "--mem=1024" the dictionary
+            needs to be {"mem": "1024"}. To specify options without values use
+            keys with empty strings as values, e.g. to specify "--contiguous"
+            the dictionary needs to be {"contiguous": ""}.
+            See the SLURM documentation for a full list of sbatch options
+            (https://slurm.schedmd.com/sbatch.html).
         stdfiles_removal : str
             Whether to remove the stdout, stderr (and possibly stdin) files.
             Possible values are:
@@ -664,13 +676,136 @@ class SlurmProcess:
         if workdir is None:
             workdir = os.getcwd()
         self.workdir = os.path.abspath(workdir)
-        self.time = time
+        self._time = time
+        # Use the property to directly call _sanitize_sbatch_options when assigning
+        # Do this **after** setting self._time to ensure consistency
+        if sbatch_options is None:
+            sbatch_options = {}
+        self.sbatch_options = sbatch_options
         self.stdfiles_removal = stdfiles_removal
-        self._jobid = None
-        self._jobinfo = {}  # dict with jobinfo cached from slurm cluster mediator
-        self._stdout_data = None
-        self._stderr_data = None
-        self._stdin = None
+        self._jobid: None | str = None
+        # dict with jobinfo cached from slurm cluster mediator
+        self._jobinfo: dict[str,typing.Any] = {}
+        self._stdout_data: None | bytes = None
+        self._stderr_data: None | bytes = None
+        self._stdin: None | str = None
+
+    def _sanitize_sbatch_options(self, sbatch_options: dict) -> dict:
+        """
+        Return sane sbatch_options dictionary to be consistent (with self).
+
+        Parameters
+        ----------
+        sbatch_options : dict
+            Dictionary of sbatch options.
+
+        Returns
+        -------
+        dict
+            Dictionary with sanitized sbatch options.
+        """
+        # NOTE: this should be called every time we modify sbatch_options or self.time!
+        # This is the list of sbatch options we use ourself, they should not
+        # be in the dict to avoid unforseen effects. We treat 'time' special
+        # because we want to allow for it to be specified via sbtach_options if
+        # it is not set via the attribute self.time.
+        reserved_sbatch_options = ["job-name", "chdir", "output", "error",
+                                   "input", "exclude", "parsable"]
+        new_sbatch_options = sbatch_options.copy()
+        if "time" in sbatch_options:
+            if self._time is not None:
+                logger.warning("Removing sbatch option 'time' from 'sbatch_options'. "
+                               "Using the 'time' argument instead.")
+                del new_sbatch_options["time"]
+            else:
+                logger.debug("Using 'time' from 'sbatch_options' because "
+                             "self.time is None.")
+        for option in reserved_sbatch_options:
+            if option in sbatch_options:
+                logger.warning("Removing sbatch option '%s' from "
+                               "'sbatch_options' because it is used internaly "
+                               "by the `SlurmProcess`.", option)
+                del new_sbatch_options[option]
+
+        return new_sbatch_options
+
+    def _slurm_timelimit_from_time_in_hours(self, time: float) -> str:
+        """
+        Create timelimit in SLURM compatible format from time in hours.
+
+        Parameters
+        ----------
+        timelimit : float
+            Timelimit for job in hours
+
+        Returns
+        -------
+        str
+            Timelimit for job as SLURM compatible string.
+        """
+        timelimit = time * 60
+        timelimit_min = int(timelimit)  # take only the full minutes
+        timelimit_sec = round(60 * (timelimit - timelimit_min))
+        timelimit_str = f"{timelimit_min}:{timelimit_sec}"
+        return timelimit_str
+
+    @property
+    def time(self) -> float | None:
+        """
+        Timelimit for SLURM job in hours.
+
+        Can be a float or None (meaning do not specify a timelimit).
+        """
+        return self._time
+
+    @time.setter
+    def time(self, val: float | None) -> None:
+        self._time = val
+        self._sbatch_options: dict = self._sanitize_sbatch_options(self._sbatch_options)
+
+    @property
+    def sbatch_options(self) -> dict:
+        """
+        A copy of the sbatch_options dictionary.
+
+        Note that modifying single key, value pairs has no effect, to modify
+        (single) sbatch_options either use the `set_sbatch_option` and
+        `del_sbatch_option` methods or (re)assign a dictionary to
+        `sbatch_options`.
+        """
+        return self._sbatch_options.copy()
+
+    @sbatch_options.setter
+    def sbatch_options(self, val: dict) -> None:
+        self._sbatch_options = self._sanitize_sbatch_options(val)
+
+    def set_sbatch_option(self, key: str, value: str) -> None:
+        """
+        Set sbatch option with given key to value.
+
+        I.e. add/modify single key, value pair in sbatch_options.
+
+        Parameters
+        ----------
+        key : str
+            The name of the sbatch option.
+        value : str
+            The value for the sbatch option.
+        """
+        self._sbatch_options[key] = value
+        self._sbatch_options = self._sanitize_sbatch_options(self._sbatch_options)
+
+    def del_sbatch_option(self, key: str) -> None:
+        """
+        Delete sbatch option with given key from sbatch_options.
+
+        Parameters
+        ----------
+        key : str
+            The name of the sbatch option to delete.
+        """
+        del self._sbatch_options[key]
+        self._sbatch_options = self._sanitize_sbatch_options(self._sbatch_options)
 
     @property
     def stdfiles_removal(self) -> str:
@@ -734,10 +869,7 @@ class SlurmProcess:
         sbatch_cmd += f" --output=./{self._stdout_name(use_slurm_symbols=True)}"
         sbatch_cmd += f" --error=./{self._stderr_name(use_slurm_symbols=True)}"
         if self.time is not None:
-            timelimit = self.time * 60
-            timelimit_min = int(timelimit)  # take only the full minutes
-            timelimit_sec = round(60 * (timelimit - timelimit_min))
-            timelimit_str = f"{timelimit_min}:{timelimit_sec}"
+            timelimit_str = self._slurm_timelimit_from_time_in_hours(self.time)
             sbatch_cmd += f" --time={timelimit_str}"
         # keep a ref to the stdin value, we need it in communicate
         self._stdin = stdin
@@ -749,6 +881,11 @@ class SlurmProcess:
         exclude_nodes = self.slurm_cluster_mediator.exclude_nodes
         if len(exclude_nodes) > 0:
             sbatch_cmd += f" --exclude={','.join(exclude_nodes)}"
+        for key, val in self.sbatch_options.items():
+            if val == "":
+                sbatch_cmd += f" --{key}"
+            else:
+                sbatch_cmd += f" --{key}={val}"
         sbatch_cmd += f" --parsable {self.sbatch_script}"
         logger.debug("About to execute sbatch_cmd %s.", sbatch_cmd)
         # 3 file descriptors: stdin,stdout,stderr
@@ -908,7 +1045,7 @@ class SlurmProcess:
         RuntimeError
             If the job has never been submitted.
         """
-        if self._jobid is None:
+        if self.slurm_jobid is None:
             # make sure we can only wait after submitting, otherwise we would
             # wait indefinitively if we call wait() before submit()
             raise RuntimeError("Can only wait for submitted SLURM jobs with "
@@ -1012,8 +1149,10 @@ class SlurmProcess:
                         + f" and output {e.output}."
                         ) from e
             # if we got until here the job is successfuly canceled....
-            logger.debug(f"Canceled SLURM job with jobid {self.slurm_jobid}."
-                         + f"scancel returned {scancel_out}.")
+            logger.debug("Canceled SLURM job with jobid %s. "
+                         "scancel returned %s.",
+                         self.slurm_jobid, scancel_out,
+                         )
             # remove the job from the monitoring
             self.slurm_cluster_mediator.monitor_remove_job(jobid=self._jobid)
             if (self._stdfiles_removal == "yes"
@@ -1034,6 +1173,7 @@ async def create_slurmprocess_submit(jobname: str,
                                      sbatch_script: str,
                                      workdir: str,
                                      time: typing.Optional[float] = None,
+                                     sbatch_options: dict | None = None,
                                      stdfiles_removal: str = "success",
                                      stdin: typing.Optional[str] = None,
                                      **kwargs,
@@ -1055,6 +1195,15 @@ async def create_slurmprocess_submit(jobname: str,
     time : float or None
         Timelimit for the job in hours. None will result in using the
         default as either specified in the sbatch script or the partition.
+    sbatch_options : dict or None
+        Dictionary of sbatch options, keys are long names for options,
+        values are the correponding values. The keys/long names are given
+        without the dashes, e.g. to specify "--mem=1024" the dictionary
+        needs to be {"mem": "1024"}. To specify options without values use
+        keys with empty strings as values, e.g. to specify "--contiguous"
+        the dictionary needs to be {"contiguous": ""}.
+        See the SLURM documentation for a full list of sbatch options
+        (https://slurm.schedmd.com/sbatch.html).
     stdfiles_removal : str
         Whether to remove the stdout, stderr (and possibly stdin) files.
         Possible values are:
@@ -1078,6 +1227,7 @@ async def create_slurmprocess_submit(jobname: str,
     """
     proc = SlurmProcess(jobname=jobname, sbatch_script=sbatch_script,
                         workdir=workdir, time=time,
+                        sbatch_options=sbatch_options,
                         stdfiles_removal=stdfiles_removal,
                         **kwargs)
     await proc.submit(stdin=stdin)

asyncmd/trajectory/functionwrapper.py

@@ -305,6 +305,7 @@ class SlurmTrajectoryFunctionWrapper(TrajectoryFunctionWrapper):
     """
 
     def __init__(self, executable, sbatch_script,
+                 sbatch_options: dict | None = None,
                  call_kwargs: typing.Optional[dict] = None,
                  load_results_func=None, **kwargs):
         """
@@ -325,6 +326,19 @@ class SlurmTrajectoryFunctionWrapper(TrajectoryFunctionWrapper):
 
              - {cmd_str} : Replaced by the command to call the executable on a given trajectory.
 
+        sbatch_options : dict or None
+            Dictionary of sbatch options, keys are long names for options,
+            values are the correponding values. The keys/long names are given
+            without the dashes, e.g. to specify "--mem=1024" the dictionary
+            needs to be {"mem": "1024"}. To specify options without values use
+            keys with empty strings as values, e.g. to specify "--contiguous"
+            the dictionary needs to be {"contiguous": ""}.
+            See the SLURM documentation for a full list of sbatch options
+            (https://slurm.schedmd.com/sbatch.html).
+            Note: This argument is passed as is to the `SlurmProcess` in which
+            the computation is performed. Each call of the TrajectoryFunction
+            triggers the creation of a new `SlurmProcess` and will use the then
+            current `sbatch_options`.
         call_kwargs : dict, optional
             Dictionary of additional arguments to pass to the executable, they
             will be added to the call as pair ' {key} {val}', note that in case
@@ -352,6 +366,7 @@ class SlurmTrajectoryFunctionWrapper(TrajectoryFunctionWrapper):
                 sbatch_script = f.read()
         # (possibly) use properties to calc the id directly
         self.sbatch_script = sbatch_script
+        self.sbatch_options = sbatch_options
         self.executable = executable
         if call_kwargs is None:
             call_kwargs = {}
@@ -529,13 +544,14 @@ class SlurmTrajectoryFunctionWrapper(TrajectoryFunctionWrapper):
             await _SEMAPHORES["SLURM_MAX_JOB"].acquire()
         try:  # this try is just to make sure we always release the semaphore
             slurm_proc = await slurm.create_slurmprocess_submit(
-                                                jobname=self.slurm_jobname,
-                                                sbatch_script=sbatch_fname,
-                                                workdir=slurm_workdir,
-                                                stdfiles_removal="success",
-                                                stdin=None,
-                                                # sleep 5 s between checking
-                                                sleep_time=5,
+                                        jobname=self.slurm_jobname,
+                                        sbatch_script=sbatch_fname,
+                                        workdir=slurm_workdir,
+                                        sbatch_options=self.sbatch_options,
+                                        stdfiles_removal="success",
+                                        stdin=None,
+                                        # sleep 5 s between checking
+                                        sleep_time=5,
                                                                 )
             # wait for the slurm job to finish
             # also cancel the job when this future is canceled

asyncmd/trajectory/propagate.py

@@ -599,14 +599,14 @@ class ConditionalTrajectoryPropagator(_TrajectoryPropagator):
         # sort out if we use max_frames or max_steps
         if max_frames is not None and max_steps is not None:
             logger.warning("Both max_steps and max_frames given. Note that "
-                           + "max_steps will take precedence.")
+                           "max_steps will take precedence.")
         if max_steps is not None:
             self.max_steps = max_steps
         elif max_frames is not None:
             self.max_steps = max_frames * nstout
         else:
             logger.info("Neither max_frames nor max_steps given. "
-                        + "Setting max_steps to infinity.")
+                        "Setting max_steps to infinity.")
             # this is a float but can be compared to ints
             self.max_steps = np.inf
 
@@ -629,10 +629,10 @@ class ConditionalTrajectoryPropagator(_TrajectoryPropagator):
             # and warn if it is not a corotinefunction
             logger.warning(
                     "It is recommended to use coroutinefunctions for all "
-                    + "conditions. This can easily be achieved by wrapping any"
-                    + " function in a TrajectoryFunctionWrapper. All "
-                    + "non-coroutine condition functions will be blocking when"
-                    + " applied! ([c is coroutine for c in conditions] = %s)",
+                    "conditions. This can easily be achieved by wrapping any "
+                    "function in a TrajectoryFunctionWrapper. All "
+                    "non-coroutine condition functions will be blocking when "
+                    "applied! ([c is coroutine for c in conditions] = %s)",
                     self._condition_func_is_coroutine
                            )
         self._conditions = conditions
@@ -744,9 +744,10 @@ class ConditionalTrajectoryPropagator(_TrajectoryPropagator):
             # gets the frame with the lowest idx where any condition is True
             min_idx = np.argmin(frame_nums)
             first_condition_fullfilled = conds_fullfilled[min_idx]
-            logger.error(f"Starting configuration ({starting_configuration}) "
-                         + "is already fullfilling the condition with idx"
-                         + f" {first_condition_fullfilled}.")
+            logger.error("Starting configuration (%s) is already fullfilling "
+                         "the condition with idx %s.",
+                         starting_configuration, first_condition_fullfilled,
+                        )
             # we just return the starting configuration/trajectory
             trajs = [starting_configuration]
             return trajs, first_condition_fullfilled

asyncmd/trajectory/trajectory.py

@@ -820,9 +820,9 @@ class Trajectory:
                 # default cache is set to h5py (as above)
                 logger.warning("Trying to unpickle %s with cache_type "
                                "'h5py' not possible without a registered "
-                               "cache. Falling back to global default type."
-                               "See 'asyncmd.config.register_h5py_cache' and"
-                               " 'asyncmd.config.set_default_cache_type'.",
+                               "cache. Falling back to global default type. "
+                               "See 'asyncmd.config.register_h5py_cache' and "
+                               "'asyncmd.config.set_default_cache_type'.",
                                 self
                                )
                 self.cache_type = None  # this calls _setup_cache
@@ -949,9 +949,9 @@ class TrajectoryFunctionValueCacheNPZ(collections.abc.Mapping):
         # now if the old npz did not match we should remove it
         # then we will rewrite it with the first cached CV values
         if not existing_npz_matches:
-            logger.debug("Found existing npz file (%s) but the"
-                         " trajectory hash does not match."
-                         " Recreating the npz cache from scratch.",
+            logger.debug("Found existing npz file (%s) but the "
+                         "trajectory hash does not match. "
+                         "Recreating the npz cache from scratch.",
                          self.fname_npz
                          )
             os.unlink(self.fname_npz)

{asyncmd-0.3.2.dist-info → asyncmd-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: asyncmd
-Version: 0.3.2
+Version: 0.3.3
 Summary: asyncmd is a library to write concurrent code to run and analyze molecular dynamics simulations using pythons async/await synthax.
 Author-email: Hendrik Jung <hendrik.jung@biophys.mpg.de>
 Maintainer-email: Hendrik Jung <hendrik.jung@biophys.mpg.de>
@@ -24,6 +24,7 @@ License-File: LICENSE
 Requires-Dist: aiofiles
 Requires-Dist: mdanalysis
 Requires-Dist: numpy
+Requires-Dist: scipy
 Provides-Extra: docs
 Requires-Dist: sphinx; extra == "docs"
 Provides-Extra: tests
@@ -36,6 +37,7 @@ Requires-Dist: coverage; extra == "tests-all"
 Requires-Dist: pytest-cov; extra == "tests-all"
 Provides-Extra: dev
 Requires-Dist: asyncmd[docs,tests-all]; extra == "dev"
+Dynamic: license-file
 
 # asyncmd
 
@@ -50,7 +52,7 @@ This library addresses the tedious, error-prone and boring part of setting up ma
 
 ## Code Example
 
-Run `N` gromacs engines concurently from configurations randomly picked up along a trajectory (`traj.trr`) for `n_steps` integration steps each, drawing random Maxwell-Boltzmann velocities for each configuration on the way. Finally turn the python function `func` (which acts on `Trajectory` objects) into an asyncronous and cached function by wrapping it and apply it on all generated trajectories concurrently:
+Run `N` [GROMACS] engines concurently from configurations randomly picked up along a trajectory (`traj.trr`) for `n_steps` integration steps each, drawing random Maxwell-Boltzmann velocities for each configuration on the way. Finally turn the python function `func` (which acts on `Trajectory` objects) into an asyncronous and cached function by wrapping it and apply it on all generated trajectories concurrently:
 
 ```python
 import asyncio
@@ -103,6 +105,14 @@ For an in-depth introduction see also the `examples` folder in this repository w
 
 ## Installation
 
+### pip install from PyPi
+
+asyncmd is published on [PyPi] (since v0.3.2), installing is as easy as:
+
+```bash
+pip install asyncmd
+```
+
 ### pip install directly from the repository
 
 Please note that you need to have [git-lfs] (an open source git extension) setup to get all input files needed to run the notebooks in the `examples` folder. However, no [git-lfs] is needed to get a working version of the library.
@@ -113,7 +123,7 @@ cd asyncmd
 pip install .
 ```
 
-## API Reference
+## Documentation and API Reference
 
 The documentation can be build with [sphinx], use e.g. the following to build it in html format:
 
@@ -132,6 +142,9 @@ Tests use [pytest]. To run them just install asycmd with the test requirements
 git clone https://github.com/bio-phys/asyncmd.git
 cd asyncmd
 pip install .\[tests\]
+# or use
+pip install .\[tests-all\]
+# to also install optional dependencies needed to run all tests
 ```
 
 And then run the tests (against the installed version) as
@@ -173,6 +186,8 @@ asyncmd is under the terms of the GNU general public license version 3 or later,
 
 [coverage]: https://pypi.org/project/coverage/
 [git-lfs]: https://git-lfs.com/
+[GROMACS]: https://www.gromacs.org/
+[PyPi]: https://pypi.org/project/asyncmd/
 [pytest]: https://docs.pytest.org/en/latest/
 [pytest-cov]: https://pypi.org/project/pytest-cov/
 [SLURM]: https://slurm.schedmd.com/documentation.html

asyncmd-0.3.3.dist-info/RECORD

@@ -0,0 +1,23 @@
+asyncmd/__init__.py,sha256=0xkOmcT5JP7emeGl9ixPSPsdHylHtiWqvZGnzDC2GqM,768
+asyncmd/_config.py,sha256=PpPYgsZyPmC5uybMc0pdAMj_6jUcm8AfME1hAvYy3DE,1140
+asyncmd/_version.py,sha256=14Lpt2lrPMrGonuCi12MdigFAFaEhXYlip7X18BJQwc,2981
+asyncmd/config.py,sha256=Jf_XTvXPkWdefuB9xVfCUzW4Fe3zGaUB-ZifC-oZ-yQ,7701
+asyncmd/mdconfig.py,sha256=rV1eaYakFnxP8aG4_86M1uv3vtFqvLwpd7YbN3bSSQc,17482
+asyncmd/mdengine.py,sha256=PPWphMBSkIoinbUpLHxbEn1yI02VHrCHGKzJlSOhYq4,4127
+asyncmd/slurm.py,sha256=fHXb3B4MR8c6J97T-X_t6p-4BnWG4kANfGu8HqhmPCA,60851
+asyncmd/tools.py,sha256=JS4Cn2Elm6miJmPf88ZDTaUIIFqb9bhHLlZKmJOOpC0,2554
+asyncmd/utils.py,sha256=cVWgZlAa3I4eE3EacIfz82HIBznldqoxyUZ7M36hMXs,5331
+asyncmd/gromacs/__init__.py,sha256=Rp_FQq_ftynX1561oD1X2Rby3Y4EBtXkgNgqa4jQk2o,726
+asyncmd/gromacs/mdconfig.py,sha256=6odhq8-xw6DRwQmiZIWCt5TwheyiC_7v5iUinG2T7J8,18225
+asyncmd/gromacs/mdengine.py,sha256=rV5-ugbaWtmDXiNHEq8dWlpBybMwE8zWESeikal2lHU,54276
+asyncmd/gromacs/utils.py,sha256=nmpP1ZS9sYPnrJGTVam6uDBb3CjKn-s0Nn3666ynnCo,6718
+asyncmd/trajectory/__init__.py,sha256=m2mP6YxMpXTpU_NQ-wID4UVEgZd7e0mkSaCCLLeo75Q,1195
+asyncmd/trajectory/convert.py,sha256=3DYpt7w_AIryShT59dTPM1s9s7ND3AMqgF5z8pfUViM,26036
+asyncmd/trajectory/functionwrapper.py,sha256=_atGGe2Dwu_EkyC6eNkONbc0KCDLegw0GqHfoc5MGLs,25788
+asyncmd/trajectory/propagate.py,sha256=LvO3vj9JHv5EiZkuNB9PTLpHuS6qy3nzZTxge5byW20,45344
+asyncmd/trajectory/trajectory.py,sha256=TouClq90m__q2qkBNNCZP2p59zWeqDa5TykdUpk7WPE,50700
+asyncmd-0.3.3.dist-info/licenses/LICENSE,sha256=tqi_Y64slbCqJW7ndGgNe9GPIfRX2nVGb3YQs7FqzE4,34670
+asyncmd-0.3.3.dist-info/METADATA,sha256=tQ0wPLn1GTRMOysb9cUQznSHeWCMQywbGB2aKerJmAo,8389
+asyncmd-0.3.3.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+asyncmd-0.3.3.dist-info/top_level.txt,sha256=YG6cpLOyBjjelv7a8p2xYEHNVBgXSW8PvM8-9S9hMb8,8
+asyncmd-0.3.3.dist-info/RECORD,,

{asyncmd-0.3.2.dist-info → asyncmd-0.3.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (80.3.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

asyncmd-0.3.2.dist-info/RECORD

@@ -1,23 +0,0 @@
-asyncmd/__init__.py,sha256=0xkOmcT5JP7emeGl9ixPSPsdHylHtiWqvZGnzDC2GqM,768
-asyncmd/_config.py,sha256=PpPYgsZyPmC5uybMc0pdAMj_6jUcm8AfME1hAvYy3DE,1140
-asyncmd/_version.py,sha256=14Lpt2lrPMrGonuCi12MdigFAFaEhXYlip7X18BJQwc,2981
-asyncmd/config.py,sha256=Jf_XTvXPkWdefuB9xVfCUzW4Fe3zGaUB-ZifC-oZ-yQ,7701
-asyncmd/mdconfig.py,sha256=07TL4EJs-d_34PBSINUas3creopJX8VHfcgmuW-Wd-E,17485
-asyncmd/mdengine.py,sha256=PPWphMBSkIoinbUpLHxbEn1yI02VHrCHGKzJlSOhYq4,4127
-asyncmd/slurm.py,sha256=IgnWv6Jhu-PSdHTy0GB3AIlwkFcHZ12bBZy2VggSmKs,54642
-asyncmd/tools.py,sha256=JS4Cn2Elm6miJmPf88ZDTaUIIFqb9bhHLlZKmJOOpC0,2554
-asyncmd/utils.py,sha256=cVWgZlAa3I4eE3EacIfz82HIBznldqoxyUZ7M36hMXs,5331
-asyncmd/gromacs/__init__.py,sha256=Rp_FQq_ftynX1561oD1X2Rby3Y4EBtXkgNgqa4jQk2o,726
-asyncmd/gromacs/mdconfig.py,sha256=rxhp5W3Cc0KuLN_P43ItlXI_xnAiJeh3DLeTjHp57kc,18224
-asyncmd/gromacs/mdengine.py,sha256=JZA3c0i2I1SK2iivNavqg_i3QFdtOOuUHbcKNlKJFho,53164
-asyncmd/gromacs/utils.py,sha256=TCQ3OAtUNN7cVGjJGkEdmhZF2QvnnmazvklbQrW0AB8,6716
-asyncmd/trajectory/__init__.py,sha256=m2mP6YxMpXTpU_NQ-wID4UVEgZd7e0mkSaCCLLeo75Q,1195
-asyncmd/trajectory/convert.py,sha256=3DYpt7w_AIryShT59dTPM1s9s7ND3AMqgF5z8pfUViM,26036
-asyncmd/trajectory/functionwrapper.py,sha256=6Oeoqi8IiffNO6egh1aRX6QSy4RyIPEYi3j64pbg-4I,24785
-asyncmd/trajectory/propagate.py,sha256=TSpMw4dYodRowltdPWf5styZtUBkQJ5HlSKaV38yUuw,45335
-asyncmd/trajectory/trajectory.py,sha256=HSPwEIdRZuxteRmxEi8lC4ZjCMxbPVy7QjpGBkSAKBI,50699
-asyncmd-0.3.2.dist-info/LICENSE,sha256=tqi_Y64slbCqJW7ndGgNe9GPIfRX2nVGb3YQs7FqzE4,34670
-asyncmd-0.3.2.dist-info/METADATA,sha256=4SlYWFxOj9lsGDF12HtYwgt8-kr2fJ9aKdwnDwX79zQ,8014
-asyncmd-0.3.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-asyncmd-0.3.2.dist-info/top_level.txt,sha256=YG6cpLOyBjjelv7a8p2xYEHNVBgXSW8PvM8-9S9hMb8,8
-asyncmd-0.3.2.dist-info/RECORD,,