looper 1.6.0a2__tar.gz → 1.7.0__tar.gz

{looper-1.6.0a2/looper.egg-info → looper-1.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: looper
-Version: 1.6.0a2
+Version: 1.7.0
 Summary: A pipeline submission engine that parses sample inputs and submits pipelines for each sample.
 Home-page: https://github.com/pepkit/looper
 Author: Nathan Sheffield, Vince Reuter, Michal Stolarczyk, Johanna Klughammer, Andre Rendeiro
@@ -22,8 +22,8 @@ Requires-Dist: jinja2
 Requires-Dist: logmuse>=0.2.0
 Requires-Dist: pandas>=2.0.2
 Requires-Dist: pephubclient>=0.1.2
-Requires-Dist: peppy>=0.40.0.a4
-Requires-Dist: pipestat>=0.6.0a9
+Requires-Dist: peppy>=0.40.0
+Requires-Dist: pipestat>=0.8.0
 Requires-Dist: pyyaml>=3.12
 Requires-Dist: rich>=9.10.0
 Requires-Dist: ubiquerg>=0.5.2

looper-1.7.0/looper/_version.py

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

{looper-1.6.0a2 → looper-1.7.0}/looper/cli_looper.py

@@ -219,19 +219,27 @@ def build_parser():
         for subparser in [run_subparser, rerun_subparser]:
             subparser.add_argument(
                 "-u",
-                "--lump",
+                "--lump-s",
                 default=None,
                 metavar="X",
                 type=html_range(min_val=0, max_val=100, step=0.1, value=0),
-                help="Total input file size (GB) to batch into one job",
+                help="Lump by size: total input file size (GB) to batch into one job",
             )
             subparser.add_argument(
                 "-n",
-                "--lumpn",
+                "--lump-n",
                 default=None,
                 metavar="N",
                 type=html_range(min_val=1, max_val="num_samples", value=1),
-                help="Number of commands to batch into one job",
+                help="Lump by number: number of samples to batch into one job",
+            )
+            subparser.add_argument(
+                "-j",
+                "--lump-j",
+                default=None,
+                metavar="J",
+                type=int,
+                help="Lump samples into number of jobs.",
             )
 
         check_subparser.add_argument(
@@ -495,6 +503,18 @@ def build_parser():
             help="Number of attributes to display",
             type=int,
         )
+        parser.add_argument(
+            "--commands",
+            action="version",
+            version="{}".format(" ".join(subparsers.choices.keys())),
+        )
+
+        report_subparser.add_argument(
+            "--portable",
+            help="Makes html report portable.",
+            action="store_true",
+        )
+
         result.append(parser)
     return result
 

{looper-1.6.0a2 → looper-1.7.0}/looper/conductor.py

@@ -6,6 +6,7 @@ import os
 import subprocess
 import time
 import yaml
+from math import ceil
 from copy import copy, deepcopy
 from json import loads
 from subprocess import check_output
@@ -132,6 +133,7 @@ class SubmissionConductor(object):
         compute_variables=None,
         max_cmds=None,
         max_size=None,
+        max_jobs=None,
         automatic=True,
         collate=False,
     ):
@@ -166,6 +168,8 @@ class SubmissionConductor(object):
             include in a single job script.
         :param int | float | NoneType max_size: Upper bound on total file
             size of inputs used by the commands lumped into single job script.
+        :param int | float | NoneType max_jobs: Upper bound on total number of jobs to
+            group samples for submission.
         :param bool automatic: Whether the submission should be automatic once
             the pool reaches capacity.
         :param bool collate: Whether a collate job is to be submitted (runs on
@@ -200,6 +204,16 @@ class SubmissionConductor(object):
                 "{}".format(self.extra_pipe_args)
             )
 
+        if max_jobs:
+            if max_jobs == 0 or max_jobs < 0:
+                raise ValueError(
+                    "If specified, max job command count must be a positive integer, greater than zero."
+                )
+
+            num_samples = len(self.prj.samples)
+            samples_per_job = num_samples / max_jobs
+            max_cmds = ceil(samples_per_job)
+
         if not self.collate:
             self.automatic = automatic
             if max_cmds is None and max_size is None:

{looper-1.6.0a2 → looper-1.7.0}/looper/looper.py

@@ -404,8 +404,9 @@ class Runner(Executor):
                 extra_args=args.command_extra,
                 extra_args_override=args.command_extra_override,
                 ignore_flags=args.ignore_flags,
-                max_cmds=args.lumpn,
-                max_size=args.lump,
+                max_cmds=args.lump_n,
+                max_size=args.lump_s,
+                max_jobs=args.lump_j,
             )
             submission_conductors[piface.pipe_iface_file] = conductor
 
@@ -547,12 +548,16 @@ class Reporter(Executor):
         p = self.prj
         project_level = args.project
 
+        portable = args.portable
+
         if project_level:
             psms = self.prj.get_pipestat_managers(project_level=True)
             print(psms)
             for name, psm in psms.items():
                 # Summarize will generate the static HTML Report Function
-                report_directory = psm.summarize(looper_samples=self.prj.samples)
+                report_directory = psm.summarize(
+                    looper_samples=self.prj.samples, portable=portable
+                )
                 print(f"Report directory: {report_directory}")
         else:
             for piface_source_samples in self.prj._samples_by_piface(
@@ -567,7 +572,9 @@ class Reporter(Executor):
                 print(psms)
                 for name, psm in psms.items():
                     # Summarize will generate the static HTML Report Function
-                    report_directory = psm.summarize(looper_samples=self.prj.samples)
+                    report_directory = psm.summarize(
+                        looper_samples=self.prj.samples, portable=portable
+                    )
                     print(f"Report directory: {report_directory}")
 
 

{looper-1.6.0a2 → looper-1.7.0}/looper/project.py

@@ -111,9 +111,7 @@ class Project(peppyProject):
         compute settings.
     """
 
-    def __init__(
-        self, cfg=None, amendments=None, divcfg_path=None, runp=False, **kwargs
-    ):
+    def __init__(self, cfg=None, amendments=None, divcfg_path=None, **kwargs):
         super(Project, self).__init__(cfg=cfg, amendments=amendments)
         prj_dict = kwargs.get("project_dict")
         pep_config = kwargs.get("pep_config", None)
@@ -122,7 +120,7 @@ class Project(peppyProject):
 
         # init project from pephub pep_config:
         if prj_dict is not None and cfg is None:
-            self.from_dict(prj_dict)
+            self._from_dict(prj_dict)
             self["_config_file"] = os.getcwd()  # for finding pipeline interface
             self["pep_config"] = pep_config
 
@@ -916,7 +914,7 @@ def make_set(items):
     try:
         # Check if user input single integer value for inclusion/exclusion criteria
         if len(items) == 1:
-            items = list(map(int, items))  # list(int(items[0]))
+            items = list(map(str, items))  # list(int(items[0]))
     except:
         if isinstance(items, str):
             items = [items]

{looper-1.6.0a2 → looper-1.7.0/looper.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: looper
-Version: 1.6.0a2
+Version: 1.7.0
 Summary: A pipeline submission engine that parses sample inputs and submits pipelines for each sample.
 Home-page: https://github.com/pepkit/looper
 Author: Nathan Sheffield, Vince Reuter, Michal Stolarczyk, Johanna Klughammer, Andre Rendeiro
@@ -22,8 +22,8 @@ Requires-Dist: jinja2
 Requires-Dist: logmuse>=0.2.0
 Requires-Dist: pandas>=2.0.2
 Requires-Dist: pephubclient>=0.1.2
-Requires-Dist: peppy>=0.40.0.a4
-Requires-Dist: pipestat>=0.6.0a9
+Requires-Dist: peppy>=0.40.0
+Requires-Dist: pipestat>=0.8.0
 Requires-Dist: pyyaml>=3.12
 Requires-Dist: rich>=9.10.0
 Requires-Dist: ubiquerg>=0.5.2

{looper-1.6.0a2 → looper-1.7.0}/looper.egg-info/requires.txt

@@ -5,8 +5,8 @@ jinja2
 logmuse>=0.2.0
 pandas>=2.0.2
 pephubclient>=0.1.2
-peppy>=0.40.0.a4
-pipestat>=0.6.0a9
+peppy>=0.40.0
+pipestat>=0.8.0
 pyyaml>=3.12
 rich>=9.10.0
 ubiquerg>=0.5.2

{looper-1.6.0a2 → looper-1.7.0}/requirements/requirements-all.txt

@@ -5,8 +5,8 @@ jinja2
 logmuse>=0.2.0
 pandas>=2.0.2
 pephubclient>=0.1.2
-peppy>=0.40.0.a4
-pipestat>=0.6.0a9
+peppy>=0.40.0
+pipestat>=0.8.0
 pyyaml>=3.12
 rich>=9.10.0
 ubiquerg>=0.5.2

{looper-1.6.0a2 → looper-1.7.0}/requirements/requirements-test.txt

@@ -1,4 +1,4 @@
-hypothesis
+hypothesis >= 6.84.3
 mock
 pytest
 pytest-cov

looper-1.7.0/tests/test_natural_range.py

@@ -0,0 +1,206 @@
+"""Tests for the natural numbers range data type"""
+
+from typing import *
+import pytest
+from hypothesis import given, strategies as st
+from looper.utils import NatIntervalException, NatIntervalInclusive
+
+
+gen_pos_int = st.integers(min_value=1)
+gen_opt_int = st.one_of(st.integers(), st.none())
+
+
+def is_non_pos(opt_int: Optional[int]) -> bool:
+    """Determine whether the given value is non-positive (and non-null)."""
+    return opt_int is not None and opt_int < 1
+
+
+def pytest_generate_tests(metafunc):
+    if "legit_delim" in metafunc.fixturenames:
+        metafunc.parametrize("legit_delim", [":", "-"])
+
+
+def nondecreasing_pair_strategy(**kwargs):
+    """Generate a pair of values in which first respects given upper bound and second is no more than first."""
+    return st.tuples(st.integers(**kwargs), st.integers(**kwargs)).filter(
+        lambda p: p[0] <= p[1]
+    )
+
+
+class NaturalRangePureConstructorTests:
+    """Tests for direct use of natural range primary constructor"""
+
+    @given(upper_bound=gen_pos_int)
+    def test_zero_is_prohibited(self, upper_bound):
+        """Separate this case since it's an edge case."""
+        with pytest.raises(NatIntervalException):
+            NatIntervalInclusive(0, upper_bound)
+
+    @given(bounds=nondecreasing_pair_strategy(max_value=0))
+    def test_non_positive_is_prohibited(self, bounds):
+        lo, hi = bounds
+        with pytest.raises(NatIntervalException):
+            NatIntervalInclusive(lo, hi)
+
+    @given(bounds=st.tuples(st.integers(), st.integers()).filter(lambda p: p[0] > p[1]))
+    def test_upper_less_than_lower__fails_as_expected(self, bounds):
+        lo, hi = bounds
+        with pytest.raises(NatIntervalException):
+            NatIntervalInclusive(lo, hi)
+
+
+class NaturalRangeFromStringTests:
+    """Tests for parsing of natural number range from text, like CLI arg"""
+
+
+@pytest.mark.parametrize(
+    "arg_template", ["0{sep}0", "{sep}0", "0{sep}", "0{sep}0", "{sep}0", "0{sep}"]
+)
+@given(upper_bound=gen_pos_int)
+def test_from_string__zero__does_not_parse(arg_template, legit_delim, upper_bound):
+    arg = arg_template.format(sep=legit_delim)
+    with pytest.raises(NatIntervalException):
+        NatIntervalInclusive.from_string(arg, upper_bound=upper_bound)
+
+
+@given(upper_bound=st.integers())
+def test_from_string__just_delimiter__does_not_parse(legit_delim, upper_bound):
+    with pytest.raises(NatIntervalException):
+        NatIntervalInclusive.from_string(legit_delim, upper_bound=upper_bound)
+
+
+@given(
+    lo_hi_upper=st.tuples(gen_opt_int, gen_opt_int, st.integers()).filter(
+        lambda t: (t[0] is not None or t[1] is not None)
+        and any(is_non_pos(n) for n in t)
+    )
+)
+def test_from_string__nonpositive_values__fail_with_expected_error(
+    lo_hi_upper, legit_delim
+):
+    lo, hi, upper_bound = lo_hi_upper
+    if lo is None and hi is None:
+        raise ValueError("Both lower and upper bound generated are null.")
+    if lo is None:
+        arg = legit_delim + str(hi)
+    elif hi is None:
+        arg = str(lo) + legit_delim
+    else:
+        arg = str(lo) + legit_delim + str(hi)
+    with pytest.raises(NatIntervalException):
+        NatIntervalInclusive.from_string(arg, upper_bound=upper_bound)
+
+
+@pytest.mark.parametrize("arg", ["1,2", "1;2", "1_2", "1/2", "1.2", "1~2"])
+@given(upper_bound=st.integers(min_value=3))
+def test_from_string__illegal_delimiter__fail_with_expected_error(arg, upper_bound):
+    with pytest.raises(NatIntervalException):
+        NatIntervalInclusive.from_string(arg, upper_bound=upper_bound)
+
+
+@given(
+    lower_and_limit=st.tuples(st.integers(), st.integers()).filter(
+        lambda p: p[1] < p[0]
+    )
+)
+def test_from_string__one_sided_lower_with_samples_lt_bound__fails(
+    lower_and_limit, legit_delim
+):
+    lower, limit = lower_and_limit
+    arg = str(lower) + legit_delim
+    with pytest.raises(NatIntervalException):
+        NatIntervalInclusive.from_string(arg, upper_bound=limit)
+
+
+@given(lower_and_upper=nondecreasing_pair_strategy(min_value=1))
+def test_from_string__one_sided_lower_with_samples_gteq_bound__succeeds(
+    lower_and_upper, legit_delim
+):
+    lo, upper_bound = lower_and_upper
+    exp = NatIntervalInclusive(lo, upper_bound)
+    arg = str(lo) + legit_delim
+    obs = NatIntervalInclusive.from_string(arg, upper_bound=upper_bound)
+    assert obs == exp
+
+
+@given(upper_and_limit=nondecreasing_pair_strategy(min_value=1))
+def test_from_string__one_sided_upper_with_samples_gteq_bound__succeeds(
+    upper_and_limit, legit_delim
+):
+    upper, limit = upper_and_limit
+    exp = NatIntervalInclusive(1, upper)
+    arg = legit_delim + str(upper)
+    obs = NatIntervalInclusive.from_string(arg, upper_bound=limit)
+    assert obs == exp
+
+
+@given(
+    upper_and_limit=st.tuples(
+        st.integers(min_value=1), st.integers(min_value=1)
+    ).filter(lambda p: p[1] < p[0])
+)
+def test_from_string__one_sided_upper_with_samples_lt_bound__uses_bound(
+    upper_and_limit, legit_delim
+):
+    upper, limit = upper_and_limit
+    exp = NatIntervalInclusive(1, limit)
+    arg = legit_delim + str(upper)
+    obs = NatIntervalInclusive.from_string(arg, upper_bound=limit)
+    assert obs == exp
+
+
+@given(
+    lower_upper_limit=st.tuples(gen_pos_int, gen_pos_int, gen_pos_int).filter(
+        lambda t: t[1] < t[0] or t[2] < t[0]
+    )
+)
+def test_from_string__two_sided_parse_upper_lt_lower(lower_upper_limit, legit_delim):
+    lo, hi, lim = lower_upper_limit
+    arg = str(lo) + legit_delim + str(hi)
+    with pytest.raises(NatIntervalException):
+        NatIntervalInclusive.from_string(arg, upper_bound=lim)
+
+
+@given(
+    lo_hi_limit=st.tuples(st.integers(min_value=2), gen_pos_int, gen_pos_int).filter(
+        lambda t: t[2] < t[0] <= t[1]
+    )
+)
+def test_from_string__two_sided_parse_upper_gteq_lower_with_upper_limit_lt_lower(
+    lo_hi_limit, legit_delim
+):
+    lo, hi, limit = lo_hi_limit
+    arg = str(lo) + legit_delim + str(hi)
+    with pytest.raises(NatIntervalException):
+        NatIntervalInclusive.from_string(arg, upper_bound=limit)
+
+
+@given(
+    lo_hi_limit=st.tuples(gen_pos_int, gen_pos_int, gen_pos_int).filter(
+        lambda t: t[0] < t[2] < t[1]
+    )
+)
+def test_from_string__two_sided_parse_upper_gteq_lower_with_upper_limit_between_lower_and_upper(
+    lo_hi_limit,
+    legit_delim,
+):
+    lo, hi, limit = lo_hi_limit
+    exp = NatIntervalInclusive(lo, limit)
+    arg = str(lo) + legit_delim + str(hi)
+    obs = NatIntervalInclusive.from_string(arg, upper_bound=limit)
+    assert obs == exp
+
+
+@given(
+    lo_hi_upper=st.tuples(gen_pos_int, gen_pos_int, gen_pos_int).filter(
+        lambda t: t[0] <= t[1] <= t[2]
+    )
+)
+def test_from_string__two_sided_parse_upper_gteq_lower_with_upper_limit_gteq_upper(
+    lo_hi_upper, legit_delim
+):
+    lo, hi, upper_bound = lo_hi_upper
+    exp = NatIntervalInclusive(lo, hi)
+    arg = f"{str(lo)}{legit_delim}{str(hi)}"
+    obs = NatIntervalInclusive.from_string(arg, upper_bound=upper_bound)
+    assert obs == exp

looper-1.6.0a2/looper/_version.py

@@ -1 +0,0 @@
-__version__ = "1.6.0a2"

looper-1.6.0a2/tests/test_natural_range.py

@@ -1,196 +0,0 @@
-"""Tests for the natural numbers range data type"""
-
-from typing import *
-import pytest
-from hypothesis import Phase, given, settings, strategies as st
-from looper.utils import NatIntervalException, NatIntervalInclusive
-
-
-gen_pos_int = st.integers(min_value=1)
-gen_opt_int = st.one_of(st.integers(), st.none())
-
-
-def is_non_pos(opt_int: Optional[int]) -> bool:
-    """Determine whether the given value is non-positive (and non-null)."""
-    return opt_int is not None and opt_int < 1
-
-
-def pytest_generate_tests(metafunc):
-    if "legit_delim" in metafunc.fixturenames:
-        metafunc.parametrize("legit_delim", [":", "-"])
-
-
-def nondecreasing_pair_strategy(**kwargs):
-    """Generate a pair of values in which first respects given upper bound and second is no more than first."""
-    return st.tuples(st.integers(**kwargs), st.integers(**kwargs)).filter(
-        lambda p: p[0] <= p[1]
-    )
-
-
-class NaturalRangePureConstructorTests:
-    """Tests for direct use of natural range primary constructor"""
-
-    @given(upper_bound=gen_pos_int)
-    def test_zero_is_prohibited(self, upper_bound):
-        """Separate this case since it's an edge case."""
-        with pytest.raises(NatIntervalException):
-            NatIntervalInclusive(0, upper_bound)
-
-    @given(bounds=nondecreasing_pair_strategy(max_value=0))
-    def test_non_positive_is_prohibited(self, bounds):
-        lo, hi = bounds
-        with pytest.raises(NatIntervalException):
-            NatIntervalInclusive(lo, hi)
-
-    @given(bounds=st.tuples(st.integers(), st.integers()).filter(lambda p: p[0] > p[1]))
-    def test_upper_less_than_lower__fails_as_expected(self, bounds):
-        lo, hi = bounds
-        with pytest.raises(NatIntervalException):
-            NatIntervalInclusive(lo, hi)
-
-
-@pytest.mark.skip(reason="Unable to reproduce test failing locally.")
-class NaturalRangeFromStringTests:
-    """Tests for parsing of natural number range from text, like CLI arg"""
-
-    @pytest.mark.parametrize(
-        "arg_template", ["0{sep}0", "{sep}0", "0{sep}", "0{sep}0", "{sep}0", "0{sep}"]
-    )
-    @given(upper_bound=gen_pos_int)
-    def test_zero__does_not_parse(self, arg_template, legit_delim, upper_bound):
-        arg = arg_template.format(sep=legit_delim)
-        with pytest.raises(NatIntervalException):
-            NatIntervalInclusive.from_string(arg, upper_bound=upper_bound)
-
-    @given(upper_bound=st.integers())
-    def test_just_delimiter__does_not_parse(self, legit_delim, upper_bound):
-        with pytest.raises(NatIntervalException):
-            NatIntervalInclusive.from_string(legit_delim, upper_bound=upper_bound)
-
-    @given(
-        lo_hi_upper=st.tuples(gen_opt_int, gen_opt_int, st.integers()).filter(
-            lambda t: (t[0] is not None or t[1] is not None)
-            and any(is_non_pos(n) for n in t)
-        )
-    )
-    def test_nonpositive_values__fail_with_expected_error(
-        self, lo_hi_upper, legit_delim
-    ):
-        lo, hi, upper_bound = lo_hi_upper
-        if lo is None and hi is None:
-            raise ValueError("Both lower and upper bound generated are null.")
-        if lo is None:
-            arg = legit_delim + str(hi)
-        elif hi is None:
-            arg = str(lo) + legit_delim
-        else:
-            arg = str(lo) + legit_delim + str(hi)
-        with pytest.raises(NatIntervalException):
-            NatIntervalInclusive.from_string(arg, upper_bound=upper_bound)
-
-    @pytest.mark.parametrize("arg", ["1,2", "1;2", "1_2", "1/2", "1.2", "1~2"])
-    @given(upper_bound=st.integers(min_value=3))
-    def test_illegal_delimiter__fail_with_expected_error(self, arg, upper_bound):
-        with pytest.raises(NatIntervalException):
-            NatIntervalInclusive.from_string(arg, upper_bound=upper_bound)
-
-    @given(
-        lower_and_limit=st.tuples(st.integers(), st.integers()).filter(
-            lambda p: p[1] < p[0]
-        )
-    )
-    def test_one_sided_lower_with_samples_lt_bound__fails(
-        self, lower_and_limit, legit_delim
-    ):
-        lower, limit = lower_and_limit
-        arg = str(lower) + legit_delim
-        with pytest.raises(NatIntervalException):
-            NatIntervalInclusive.from_string(arg, upper_bound=limit)
-
-    @given(lower_and_upper=nondecreasing_pair_strategy(min_value=1))
-    def test_one_sided_lower_with_samples_gteq_bound__succeeds(
-        self, lower_and_upper, legit_delim
-    ):
-        lo, upper_bound = lower_and_upper
-        exp = NatIntervalInclusive(lo, upper_bound)
-        arg = str(lo) + legit_delim
-        obs = NatIntervalInclusive.from_string(arg, upper_bound=upper_bound)
-        assert obs == exp
-
-    @given(upper_and_limit=nondecreasing_pair_strategy(min_value=1))
-    def test_one_sided_upper_with_samples_gteq_bound__succeeds(
-        self, upper_and_limit, legit_delim
-    ):
-        upper, limit = upper_and_limit
-        exp = NatIntervalInclusive(1, upper)
-        arg = legit_delim + str(upper)
-        obs = NatIntervalInclusive.from_string(arg, upper_bound=limit)
-        assert obs == exp
-
-    @given(
-        upper_and_limit=st.tuples(
-            st.integers(min_value=1), st.integers(min_value=1)
-        ).filter(lambda p: p[1] < p[0])
-    )
-    def test_one_sided_upper_with_samples_lt_bound__uses_bound(
-        self, upper_and_limit, legit_delim
-    ):
-        upper, limit = upper_and_limit
-        exp = NatIntervalInclusive(1, limit)
-        arg = legit_delim + str(upper)
-        obs = NatIntervalInclusive.from_string(arg, upper_bound=limit)
-        assert obs == exp
-
-    @given(
-        lower_upper_limit=st.tuples(gen_pos_int, gen_pos_int, gen_pos_int).filter(
-            lambda t: t[1] < t[0] or t[2] < t[0]
-        )
-    )
-    def test_two_sided_parse_upper_lt_lower(self, lower_upper_limit, legit_delim):
-        lo, hi, lim = lower_upper_limit
-        arg = str(lo) + legit_delim + str(hi)
-        with pytest.raises(NatIntervalException):
-            NatIntervalInclusive.from_string(arg, upper_bound=lim)
-
-    @given(
-        lo_hi_limit=st.tuples(
-            st.integers(min_value=2), gen_pos_int, gen_pos_int
-        ).filter(lambda t: t[2] < t[0] <= t[1])
-    )
-    def test_two_sided_parse_upper_gteq_lower_with_upper_limit_lt_lower(
-        self, lo_hi_limit, legit_delim
-    ):
-        lo, hi, limit = lo_hi_limit
-        arg = str(lo) + legit_delim + str(hi)
-        with pytest.raises(NatIntervalException):
-            NatIntervalInclusive.from_string(arg, upper_bound=limit)
-
-    @given(
-        lo_hi_limit=st.tuples(gen_pos_int, gen_pos_int, gen_pos_int).filter(
-            lambda t: t[0] < t[2] < t[1]
-        )
-    )
-    def test_two_sided_parse_upper_gteq_lower_with_upper_limit_between_lower_and_upper(
-        self,
-        lo_hi_limit,
-        legit_delim,
-    ):
-        lo, hi, limit = lo_hi_limit
-        exp = NatIntervalInclusive(lo, limit)
-        arg = str(lo) + legit_delim + str(hi)
-        obs = NatIntervalInclusive.from_string(arg, upper_bound=limit)
-        assert obs == exp
-
-    @given(
-        lo_hi_upper=st.tuples(gen_pos_int, gen_pos_int, gen_pos_int).filter(
-            lambda t: t[0] <= t[1] <= t[2]
-        )
-    )
-    def test_two_sided_parse_upper_gteq_lower_with_upper_limit_gteq_upper(
-        self, lo_hi_upper, legit_delim
-    ):
-        lo, hi, upper_bound = lo_hi_upper
-        exp = NatIntervalInclusive(lo, hi)
-        arg = f"{str(lo)}{legit_delim}{str(hi)}"
-        obs = NatIntervalInclusive.from_string(arg, upper_bound=upper_bound)
-        assert obs == exp