restage 0.9.0__py3-none-any.whl → 0.10.0__py3-none-any.whl

restage/emulate.py

@@ -3,7 +3,7 @@ from pathlib import Path
 def mccode_sim_io(instr, parameters, args: dict, detectors: list[str], file=None, grid: bool = False):
     from datetime import datetime
     from restage import __version__
-    from restage.range import parameters_to_scan
+    from mccode_antlr.run.range import parameters_to_scan
     if file is None:
         from io import StringIO
         file = StringIO()
@@ -44,7 +44,7 @@ def mccode_sim_io(instr, parameters, args: dict, detectors: list[str], file=None
 
 def mccode_dat_io(instr, parameters, args: dict, detectors: list[str], lines: list[str], file=None, grid: bool = False):
     from datetime import datetime
-    from restage.range import parameters_to_scan
+    from mccode_antlr.run.range import parameters_to_scan
     if file is None:
         from io import StringIO
         file = StringIO()
@@ -73,7 +73,6 @@ def mccode_dat_io(instr, parameters, args: dict, detectors: list[str], lines: li
 
 
 def mccode_dat_line(directory, parameters):
-    from math import sqrt
     from pathlib import Path
     from collections import namedtuple
     Detector = namedtuple('Detector', ['name', 'intensity', 'error', 'count', 'norm'])

restage/energy.py

@@ -35,9 +35,9 @@ def bifrost_translate_energy_to_chopper_parameters(parameters: dict):
     # names = [a+b for a, b in product(('ps', 'fo', 'bw'), ('1', '2'))]
     chopper_parameter_present = False
     for name in product(choppers, ('speed', 'phase')):
-        name = ''.join(name)
-        if name not in parameters:
-            parameters[name] = 0
+        n = ''.join(name)
+        if n not in parameters:
+            parameters[n] = 0
         else:
             chopper_parameter_present = True
     order = get_and_remove(parameters, 'order', 14)
@@ -51,9 +51,9 @@ def cspec_translate_energy_to_chopper_parameters(parameters: dict):
     choppers = ('bw1', 'bw2', 'bw3', 's', 'p', 'm1', 'm2')
     chopper_parameter_present = False
     for name in product(choppers, ('speed', 'phase')):
-        name = ''.join(name)
-        if name not in parameters:
-            parameters[name] = 0
+        n = ''.join(name)
+        if n not in parameters:
+            parameters[n] = 0
         else:
             chopper_parameter_present = True
     time = get_and_remove(parameters, 'time', 0.004)

restage/run.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from .range import Singular
+from mccode_antlr.run.range import Singular
 
 
 def make_run_parser():
@@ -19,7 +19,7 @@ def parse_run_parameters(unparsed: list[str]) -> dict[str, Singular]:
 
     :parameter unparsed: A list of parameters.
     """
-    from .range import parse_list
+    from mccode_antlr.run.range import parse_list
     return parse_list(Singular, unparsed)
 
 

restage/scan.py

@@ -15,7 +15,7 @@ def make_scan_parser():
 
 
 def parse_scan():
-    from .range import parse_scan_parameters
+    from mccode_antlr.run.range import parse_scan_parameters
     args = make_scan_parser().parse_args()
     parameters = parse_scan_parameters(args.parameters)
     return args, parameters
@@ -29,7 +29,7 @@ def run_point(args, parameters):
 def entrypoint():
     """Entrypoint for the restage_scan command."""
     from .energy import bifrost_translate_energy_to_chopper_parameters
-    from .range import parameters_to_scan
+    from mccode_antlr.run.range import parameters_to_scan
     args, parameters = parse_scan()
     n_points, names, scan = parameters_to_scan(parameters)
     for i, p in enumerate(scan):

restage/splitrun.py

@@ -41,11 +41,11 @@ def si_int_limits(s: str) -> tuple[Optional[int], int, Optional[int]]:
     low, high = None, None
     min_seps, max_seps = (']', '-', '}'), ('[', '+', '{')
     if any(x in s for x in min_seps):
-        low, s = s.split(next(x for x in min_seps if x in s), maxsplit=1)
-        low = si_int(low)
+        low_s, s = s.split(next(x for x in min_seps if x in s), maxsplit=1)
+        low = si_int(low_s)
     if any(x in s for x in max_seps):
-        s, high = s.split(next(x for x in max_seps if x in s), maxsplit=1)
-        high = si_int(high)
+        s, high_s = s.split(next(x for x in max_seps if x in s), maxsplit=1)
+        high = si_int(high_s)
     return low, si_int(s), high
 
 def make_splitrun_parser():
@@ -162,7 +162,7 @@ def args_fixup(args):
     return args
 
 def parse_splitrun(parser):
-    from .range import parse_scan_parameters
+    from mccode_antlr.run.range import parse_scan_parameters
     from mccode_antlr.run.runner import sort_args
     import sys
     sys.argv[1:] = sort_args(sys.argv[1:])
@@ -228,14 +228,18 @@ def splitrun(instr, parameters, precision: dict[str, float], split_at=None, grid
         log.error(f'The specified split-at component, {split_at}, does not exist in the instrument file')
     # splitting defines an instrument parameter in both returned instrument, 'mcpl_filename'.
     if mcpl_output_parameters is not None:
-        mcpl_output_parameters = tuple(ComponentParameter(k, Expr.parse(v)) for k, v in mcpl_output_parameters.items())
+        output_parameters = tuple(ComponentParameter(k, Expr.parse(v)) for k, v in mcpl_output_parameters.items())
+    else:
+        output_parameters = None
     if mcpl_input_parameters is not None:
-        mcpl_input_parameters = tuple(ComponentParameter(k, Expr.parse(v)) for k, v in mcpl_input_parameters.items())
+        input_parameters = tuple(ComponentParameter(k, Expr.parse(v)) for k, v in mcpl_input_parameters.items())
+    else:
+        input_parameters = None
     pre, post = instr.mcpl_split(split_at,
                                  output_component=mcpl_output_component,
-                                 output_parameters=mcpl_output_parameters,
+                                 output_parameters=output_parameters,
                                  input_component=mcpl_input_component,
-                                 input_parameters=mcpl_input_parameters,
+                                 input_parameters=input_parameters,
                                  remove_unused_parameters=True
                                  )
     if output_split_instrs:
@@ -270,7 +274,7 @@ def splitrun_pre(instr, parameters, grid, precision: dict[str, float],
     from functools import partial
     from .cache import cache_instr
     from .energy import energy_to_chopper_translator
-    from .range import parameters_to_scan
+    from mccode_antlr.run.range import parameters_to_scan
     # check if this instr is already represented in the module's cache database
     # if not, it is compiled and added to the cache with (hopefully sensible) defaults specified
     entry = cache_instr(instr, mpi=parallel, acc=gpu)
@@ -319,7 +323,7 @@ def splitrun_combined(pre_entry, pre, post, pre_parameters, post_parameters, gri
     from pathlib import Path
     from .cache import cache_instr, cache_get_simulation
     from .energy import energy_to_chopper_translator
-    from .range import parameters_to_scan
+    from mccode_antlr.run.range import parameters_to_scan
     from .instr import collect_parameter_dict
     from .tables import best_simulation_entry_match
     from .emulate import mccode_sim_io, mccode_dat_io, mccode_dat_line
@@ -488,7 +492,9 @@ def repeat_simulation_until(count, runner, args: dict, parameters, work_dir: Pat
     if 'seed' in args and args['seed'] is not None:
         random.seed(args['seed'])
 
-    files, outputs, counts = [], [], []
+    files: list[Path] = []
+    outputs: list[Path] = []
+    counts: list[int] = []
     total_count = 0
     while goal - sum(counts) > 0:
         if len(counts) and counts[-1] <= 0:

{restage-0.9.0.dist-info → restage-0.10.0.dist-info}/METADATA

@@ -1,23 +1,23 @@
 Metadata-Version: 2.4
 Name: restage
-Version: 0.9.0
+Version: 0.10.0
 Author-email: Gregory Tucker <gregory.tucker@ess.eu>
 License: BSD-3-Clause
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: zenlog>=1.1
 Requires-Dist: platformdirs>=3.11
 Requires-Dist: confuse
 Requires-Dist: psutil>=5.9.6
-Requires-Dist: mccode-antlr[hdf5]>=0.16.1
+Requires-Dist: mccode-antlr[hdf5]>=0.16.2
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: chopcal>=0.4.0; extra == "test"

restage-0.10.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+restage/__init__.py,sha256=HlqvPpL7DKet00NAFyqJBNg9UFO7o05Gt2tFyKBQcsY,744
+restage/bifrost_choppers.py,sha256=xQu21g2NcTLPpZ0ZWOuvN20zh07EWoO4QVoTnoORwZI,6443
+restage/cache.py,sha256=wh8b66aUDtOu38L-B-tqLs-bMtrnbWmuhy_HaKRYOsA,8102
+restage/cspec_choppers.py,sha256=ZWxyCcwYn4z9ZNqj_r6RC9ImbhVjYc1fmv-Ijm8A2Yk,206
+restage/database.py,sha256=anyOby31fUN7rGAVNsnWDUhAISV0vQ7en8aQwVS5ZwA,11051
+restage/emulate.py,sha256=dcxEZsOgNBtCpTQeIol9O-zZqq3bueAR0ig_Wl5oMMY,6156
+restage/energy.py,sha256=od_YiV6e6UJEJMHrxxIvUv6NxpgxitH80ycKjH7V3A8,3353
+restage/instr.py,sha256=9yiV7Pve4XJrh2mIKJkLGtLa1fjUJiECtPhC76HQM2g,2628
+restage/mcpl.py,sha256=u7ixerJs4lqKSW2MYndZ2Xpsk8O0S-ZVo735YIy86gc,3223
+restage/run.py,sha256=A7Q1x8FHbEcR2LedzI9H8tRzTjcGBV6vlwzgefSbPTk,1507
+restage/scan.py,sha256=2U6MHOoxr0X4ecBiTY5UThbJB6aqMXNALq92VeqVmwU,1464
+restage/splitrun.py,sha256=hUqVYlrpUrXIC3DHOmYoPxKtuuOUmxzHEQlKp5kkoBA,27957
+restage/tables.py,sha256=vQf0GkM7ojQbWee_P_Xqfx0-lXLym7x6kyam8CWpB5s,16373
+restage/config/__init__.py,sha256=zFRT9QXgpUJpBncELCQ6by1-kjYp8Li1yJDfqxkHxAA,965
+restage/config/default.yaml,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+restage-0.10.0.dist-info/METADATA,sha256=3rXkDG3ZBKGpoQ0q_FiCBCiXeSPZNAEPIBuvMzNV6B8,7443
+restage-0.10.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+restage-0.10.0.dist-info/entry_points.txt,sha256=vYNOPxJ4PzG-1GGFSd08jFxhrtKUWAdWzjJQeFBzFJE,116
+restage-0.10.0.dist-info/top_level.txt,sha256=iM_pb-taTZ0S2WMoDnt_qDMZoNMjmM19z3tTCuVm1IE,8
+restage-0.10.0.dist-info/RECORD,,

restage/range.py

@@ -1,231 +0,0 @@
-from __future__ import annotations
-
-from typing import Union
-
-
-class MRange:
-    """A range of values for a parameter in a MATLAB style.
-    The range is inclusive of the start and stop values, and the step is the difference between items in the range.
-    """
-    def __init__(self, start, stop, step):
-        self.start = start
-        self.stop = stop
-        self.step = step
-        if self.start == self.stop:
-            raise ValueError(f'MRange start and stop values are equal: {self.start} '
-                             f'`list(MRange)` will be empty! Use a `Singular({self.start}, 1)` range instead.')
-        if self.step == 0:
-            raise ZeroDivisionError('MRange step cannot be zero')
-
-    def __eq__(self, other):
-        return self.start == other.start and self.stop == other.stop and self.step == other.step
-
-    @property
-    def min(self):
-        return self.start
-
-    @property
-    def max(self):
-        return self.stop
-
-    def __iter__(self):
-        def range_gen(start, stop, step):
-            v = start
-            i = 0
-            while (step > 0 and v + step <= stop) or (step < 0 and v + step >= stop):
-                v = i * step + start
-                i += 1
-                yield v
-        return range_gen(self.start, self.stop, self.step)
-
-    def __getitem__(self, index: int):
-        if index < 0 or index >= len(self):
-            raise IndexError(f'Index {index} out of range')
-        return index * self.step + self.start
-
-    def __str__(self):
-        return f'{self.start}:{self.step}:{self.stop}'
-
-    def __repr__(self):
-        return f'MStyleRange({self})'
-
-    def __len__(self):
-        return int((self.stop - self.start) / self.step) + 1
-
-    @classmethod
-    def from_str(cls, string):
-        """Parse a string in MATLAB style into a range.
-        The string should be of the form start:step:stop
-        """
-        def float_or_int(s):
-            try:
-                return int(s)
-            except ValueError:
-                pass
-            return float(s)
-
-        if string.count(':') > 2:
-            raise ValueError(f'Range string {string} contains more than two colons')
-        step = '1'
-        if ':' not in string:
-            start, stop = string, string
-        elif string.count(':') == 1:
-            start, stop = string.split(':')
-        else:
-            start, step, stop = string.split(':')
-        return cls(float_or_int(start), float_or_int(stop), float_or_int(step))
-
-
-class Singular:
-    """A singular range parameter for use with other range parameters in, e.g., a zip.
-
-    Note:
-        The Singular range value will be repeated up to `maximum` times in an iterator.
-        If `maximum` is None, the Singular range will be repeated forever.
-        Therefore, care must be taken to ensure that the Singular range is used in a zip with a range that is
-        not infinite.
-    """
-    def __init__(self, value, maximum=None):
-        self.value = value
-        self.maximum = maximum
-
-    def __eq__(self, other):
-        return self.value == other.value and self.maximum == other.maximum
-
-    def __str__(self):
-        return f'{self.value}(up to {self.maximum} times)'
-
-    def __repr__(self):
-        return f'Singular({self.value}, {self.maximum})'
-
-    @property
-    def min(self):
-        return self.value
-
-    @property
-    def max(self):
-        return self.value
-
-    def __iter__(self):
-        def forever():
-            while True:
-                yield self.value
-
-        def until():
-            i = 0
-            while i < self.maximum:
-                i += 1
-                yield self.value
-
-        return until() if self.maximum is not None else forever()
-
-    def __len__(self):
-        return self.maximum
-
-    @classmethod
-    def from_str(cls, string):
-        def float_or_int_or_str(s):
-            try:
-                return int(s)
-            except ValueError:
-                pass
-            try:
-                return float(s)
-            except ValueError:
-                return s
-
-        if string.count(':') > 0:
-            raise ValueError(f'Singular string {string} contains a colon')
-        return cls(float_or_int_or_str(string))
-
-
-def parse_list(range_type, unparsed: list[str]):
-    ranges = {}
-    while len(unparsed):
-        if '=' in unparsed[0]:
-            k, v = unparsed[0].split('=', 1)
-            ranges[k.lower()] = range_type.from_str(v)
-        elif len(unparsed) > 1 and '=' not in unparsed[1]:
-            ranges[unparsed[0].lower()] = range_type.from_str(unparsed[1])
-            del unparsed[1]
-        else:
-            raise ValueError(f'Invalid parameter: {unparsed[0]}')
-        del unparsed[0]
-    return ranges
-
-
-def parameters_to_scan(parameters: dict[str, Union[list, MRange, Singular]], grid: bool = False):
-    """Convert a dictionary of ranged parameters to a list of parameter names and an iterable of parameter value tuples.
-
-    The ranged parameters can be either MRange objects or lists of values. If a list of values is provided, it will be
-    iterated over directly.
-
-    :parameter parameters: A dictionary of ranged parameters.
-    :parameter grid: Controls how the parameters are iterated; True implies a grid scan, False implies a linear scan.
-    """
-    if grid:
-        for k, v in parameters.items():
-            if isinstance(v, Singular):
-                parameters[k] = Singular(v.value, 1)
-
-    names = [x.lower() for x in parameters.keys()]
-    values = [x if hasattr(x, '__iter__') else [x] for x in parameters.values()]
-    if not len(values):
-        return 0, names, []
-    elif grid:
-        from itertools import product
-        from math import prod
-        # singular MRange objects *should* stop the grid along their axis:
-        n_pts = prod([len(v) for v in values])
-        return n_pts, names, product(*values)
-    else:
-        # replace singular MRange entries with Singular iterators, to avoid stopping the zip early:
-        n_max = max([len(v) for v in values])
-        for i, v in enumerate(values):
-            if len(v) > 1 and len(v) != n_max:
-                oth = [names[i] for i, n in enumerate(values) if len(n) == n_max]
-                par = 'parameters' if len(oth) > 1 else 'parameter'
-                have = 'have' if len(oth) > 1 else 'has'
-                raise ValueError(f'Parameter {names[i]} has {len(v)} values, but {par} {", ".join(oth)} {have} {n_max}')
-        return n_max, names, zip(*[v if len(v) > 1 else Singular(v[0] if isinstance(v, MRange) else v.value, n_max) for v in values])
-
-
-def _MRange_or_Singular(s: str):
-    if ':' in s:
-        return MRange.from_str(s)
-    return Singular.from_str(s)
-
-
-def parse_command_line_parameters(unparsed: list[str]) -> dict[str, Union[Singular, MRange]]:
-    """Parse a list of input parameters into a dictionary of MRange objects.
-
-    :parameter unparsed: A list of parameters.
-    """
-    ranges = {}
-    index = 0
-    while index < len(unparsed):
-        if '=' in unparsed[index]:
-            k, v = unparsed[index].split('=', 1)
-            ranges[k.lower()] = _MRange_or_Singular(v)
-        elif index + 1 < len(unparsed) and '=' not in unparsed[index + 1]:
-            ranges[unparsed[index].lower()] = _MRange_or_Singular(unparsed[index + 1])
-            index += 1
-        else:
-            raise ValueError(f'Invalid parameter: {unparsed[index]}')
-        index += 1
-    return ranges
-
-
-def parse_scan_parameters(unparsed: list[str]) -> dict[str, MRange | Singular]:
-    """Parse a list of input parameters into a dictionary of MRange or Singular objects.
-
-    :parameter unparsed: A list of parameters.
-    :return: A dictionary of MRange or Singular objects. The Singular objects have their maximum length set to the
-             maximum iterations of all the ranges to avoid infinite iterations.
-    """
-    ranges = parse_command_line_parameters(unparsed)
-    max_length = max(len(v) if isinstance(v, MRange) else 1 for v in ranges.values())
-    for k, v in ranges.items():
-        if isinstance(v, Singular) and v.maximum is None:
-            ranges[k] = Singular(v.value, max_length)
-    return ranges

restage-0.9.0.dist-info/RECORD

@@ -1,21 +0,0 @@
-restage/__init__.py,sha256=HlqvPpL7DKet00NAFyqJBNg9UFO7o05Gt2tFyKBQcsY,744
-restage/bifrost_choppers.py,sha256=xQu21g2NcTLPpZ0ZWOuvN20zh07EWoO4QVoTnoORwZI,6443
-restage/cache.py,sha256=wh8b66aUDtOu38L-B-tqLs-bMtrnbWmuhy_HaKRYOsA,8102
-restage/cspec_choppers.py,sha256=ZWxyCcwYn4z9ZNqj_r6RC9ImbhVjYc1fmv-Ijm8A2Yk,206
-restage/database.py,sha256=anyOby31fUN7rGAVNsnWDUhAISV0vQ7en8aQwVS5ZwA,11051
-restage/emulate.py,sha256=VrhfZJIbECdbDS-MHklqRuAIy9cRkjZkwPBTKQSQoe0,6164
-restage/energy.py,sha256=w78GUIWcHxANvBl2DTu73FQFawCXfzlK6L32TBQNt4g,3371
-restage/instr.py,sha256=9yiV7Pve4XJrh2mIKJkLGtLa1fjUJiECtPhC76HQM2g,2628
-restage/mcpl.py,sha256=u7ixerJs4lqKSW2MYndZ2Xpsk8O0S-ZVo735YIy86gc,3223
-restage/range.py,sha256=TjOf4DSKfgoAIcrWQvv6MrtksQpnGJHdsEjVI5K-UfI,8116
-restage/run.py,sha256=bTcQIN9edKMXU_eFdX3E_mtJjwemoARrIUmZqzEGf0E,1475
-restage/scan.py,sha256=Yx8OQSBG6I2_64sW0LIDb0glVKwWoxUQQznASXgDZFQ,1432
-restage/splitrun.py,sha256=5mTSkw-Mm0yq6GAq6oG0NNU7ajVkp_hvLvdcx_HlCj0,27793
-restage/tables.py,sha256=vQf0GkM7ojQbWee_P_Xqfx0-lXLym7x6kyam8CWpB5s,16373
-restage/config/__init__.py,sha256=zFRT9QXgpUJpBncELCQ6by1-kjYp8Li1yJDfqxkHxAA,965
-restage/config/default.yaml,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-restage-0.9.0.dist-info/METADATA,sha256=TXVZ4jlhvX8gqgMFqCqMAL3m1Yyg8uTpncnbFKe7l40,7441
-restage-0.9.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-restage-0.9.0.dist-info/entry_points.txt,sha256=vYNOPxJ4PzG-1GGFSd08jFxhrtKUWAdWzjJQeFBzFJE,116
-restage-0.9.0.dist-info/top_level.txt,sha256=iM_pb-taTZ0S2WMoDnt_qDMZoNMjmM19z3tTCuVm1IE,8
-restage-0.9.0.dist-info/RECORD,,