repwise 2.0.0__tar.gz → 2.1.0__tar.gz

{repwise-2.0.0/src/repwise.egg-info → repwise-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: repwise
-Version: 2.0.0
+Version: 2.1.0
 Summary: Advance Garmin strength workout targets using double progression
 Author-email: Adam Żmuda <adam@zmuda.pro>
 License-Expression: MIT

{repwise-2.0.0 → repwise-2.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "repwise"
-version = "2.0.0"
+version = "2.1.0"
 description = "Advance Garmin strength workout targets using double progression"
 readme = "README.md"
 license = "MIT"

{repwise-2.0.0 → repwise-2.1.0}/src/repwise/__init__.py

@@ -1,4 +1,4 @@
 """Advance Garmin strength workout targets using double progression."""
 
 __all__ = ["__version__"]
-__version__ = "2.0.0"
+__version__ = "2.1.0"

{repwise-2.0.0 → repwise-2.1.0}/src/repwise/config.py

@@ -50,17 +50,21 @@ _REQUIRED = ("name", "garmin_name", "rep_low", "rep_high", "sets", "load")
 
 @dataclass(frozen=True)
 class LoadRules:
-    """What a load type does: how big its steps are, and how light it can go.
+    """What a load type does: its step size, and how light and heavy it goes.
 
-    Both are properties of the equipment rather than of any one exercise - a
-    dumbbell rack goes up in ones and starts at one - so they are declared once
-    per load type and only overridden where an exercise really differs.
+    All three are properties of the equipment rather than of any one exercise -
+    a dumbbell rack goes up in ones, starts at one and ends at whatever the
+    heaviest pair is - so they are declared once per load type and only
+    overridden where an exercise really differs.
     """
 
     steps: dict[str, float] = field(default_factory=dict)
     #: Missing entries mean no floor, so a config written before deloads
     #: existed keeps loading and simply never stops a deload.
     minimums: dict[str, float] = field(default_factory=dict)
+    #: Missing entries mean no ceiling, which is the usual case: a gym's rack
+    #: outlasts you, and only equipment you own runs out.
+    maximums: dict[str, float] = field(default_factory=dict)
 
 
 def _xdg_config_home() -> str:
@@ -285,6 +289,57 @@ class Problems:
         raise ConfigError(f"{len(self.found)} problems:\n{listed}")
 
 
+def _bounds(
+    raw: dict, load: str, loads: LoadRules, where: str, problems: Problems
+) -> tuple[float, float | None]:
+    """How light and how heavy this exercise may be loaded.
+
+    Resolved together because they only mean anything against each other: a
+    ceiling under its own floor leaves progression choosing between two
+    impossible loads, and that is only visible once both are known.
+
+    The two ends default differently, and deliberately. No floor is zero, which
+    is the honest answer for anything lifted with no equipment of its own. No
+    ceiling is `None` rather than zero, because zero is a real maximum -
+    nothing may be added at all - and equipment that does not run out before
+    you do is the common case. Either way a config written before deloads or
+    ceilings existed keeps its meaning exactly.
+
+    Anything contradictory is dropped rather than honoured. The file will not
+    load either way - `problems` sees to that - so the only question is which
+    spec the rest of the checks get to run against.
+    """
+    declared_minimum = raw.get("min_weight")
+    if declared_minimum is None:
+        minimum = float(loads.minimums.get(load, 0.0))
+    else:
+        minimum = float(declared_minimum)
+    if minimum < 0:
+        problems.add(f"{where}: {raw['name']!r} has a negative min_weight")
+        minimum = 0.0
+
+    declared_maximum = raw.get("max_weight")
+    if declared_maximum is None:
+        ceiling = loads.maximums.get(load)
+        if ceiling is None:
+            return minimum, None
+        maximum = float(ceiling)
+    else:
+        maximum = float(declared_maximum)
+
+    if maximum < 0:
+        problems.add(f"{where}: {raw['name']!r} has a negative max_weight")
+        return minimum, None
+    if maximum < minimum:
+        problems.add(
+            f"{where}: {raw['name']!r} has a max_weight of {maximum:g} below "
+            f"its min_weight of {minimum:g}, so no load fits between them"
+        )
+        return minimum, None
+
+    return minimum, maximum
+
+
 def _bodyweight_factor(raw: dict, where: str, problems: Problems) -> float:
     """The share of the lifter this exercise carries, if it says.
 
@@ -352,17 +407,16 @@ def _build_exercise(
         problems.add(f"{where}: {raw['name']!r} has a negative start_weight")
         start_weight = 0.0
 
-    # The lightest this can be loaded. Unset is no floor rather than an error:
-    # a config predating deloads should keep working, and zero is the honest
-    # answer for anything lifted with no equipment of its own.
-    declared_minimum = raw.get("min_weight")
-    if declared_minimum is None:
-        min_weight = float(loads.minimums.get(load, 0.0))
-    else:
-        min_weight = float(declared_minimum)
-    if min_weight < 0:
-        problems.add(f"{where}: {raw['name']!r} has a negative min_weight")
-        min_weight = 0.0
+    min_weight, max_weight = _bounds(raw, load, loads, where, problems)
+    if max_weight is not None and start_weight > max_weight:
+        # `start_weight` is read only when the step is created, which is the
+        # one moment nothing else could catch this: no session has been logged
+        # yet, so progression never gets a chance to refuse the weight.
+        problems.add(
+            f"{where}: {raw['name']!r} would start at {start_weight:g} kg, "
+            f"above its own max_weight of {max_weight:g}"
+        )
+        max_weight = None
 
     bodyweight_factor = _bodyweight_factor(raw, where, problems)
 
@@ -382,6 +436,7 @@ def _build_exercise(
         notes=raw.get("notes"),
         start_weight=start_weight,
         min_weight=min_weight,
+        max_weight=max_weight,
         bodyweight_factor=bodyweight_factor,
     )
 
@@ -473,6 +528,7 @@ def load_config(path: str | None = None) -> Config:
     loads = LoadRules(
         steps=settings.get("weight_steps") or {},
         minimums=settings.get("min_weights") or {},
+        maximums=settings.get("max_weights") or {},
     )
     garmin_raw = settings.get("garmin") or {}
     defaults = GarminSettings()

{repwise-2.0.0 → repwise-2.1.0}/src/repwise/domain/models.py

@@ -38,6 +38,12 @@ class ExerciseSpec:
     #: the lightest pair of dumbbells, the top plate of the stack. A deload
     #: stops here rather than prescribing a weight that does not exist.
     min_weight: float = 0.0
+    #: The heaviest this exercise can be loaded: the largest pair of dumbbells
+    #: you own, the last plate in the bag, the bottom of the stack. Topping out
+    #: the rep range stops here rather than prescribing a weight you cannot
+    #: load. `None` is no ceiling, and is the right default - a gym rack runs
+    #: out long after you do, and it is home equipment that really ends.
+    max_weight: float | None = None
     #: The share of your bodyweight this movement carries: 1.0 for a calf raise
     #: or a weighted pull-up, 0 for anything you lie or sit down to do. Never
     #: guessed from the category - a lat pull-down is categorised `PULL_UP` and

{repwise-2.0.0 → repwise-2.1.0}/src/repwise/domain/progression.py

@@ -304,8 +304,39 @@ def _advance(
         # different weight moves the prescription by more than one step. Name
         # what was lifted, otherwise the jump looks arbitrary.
         lifted = f" at {weight:g} kg" if rebased else ""
+        heavier = weight + spec.weight_step
+        # `max_weight` is the heaviest load that exists to be prescribed, so a
+        # step past it is shortened to land *on* it rather than refused. The
+        # last pair on the rack is still a pair, and stopping short of a weight
+        # you own would leave the top of your equipment permanently unused for
+        # the sake of a step size the equipment never promised to divide into.
+        #
+        # Not the mirror of the deload's floor, deliberately. A short step up
+        # is a smaller increase than usual, which is always safe to prescribe;
+        # a short step *down* is a smaller decrease than usual, which may not
+        # be enough to break the stall that asked for it. So the ceiling is
+        # rounded to and the floor is refused.
+        if spec.max_weight is not None and heavier > spec.max_weight:
+            if weight >= spec.max_weight:
+                # Nothing left to add. The target settles at the top of the
+                # range, which is where bodyweight work already lives: once
+                # the load has run out, the range is all there is to progress.
+                # "past" rather than "at" for a load above the ceiling, which
+                # is what a target set before the ceiling was declared leaves
+                # behind. Rule 3 does not pull it down - taking load off is the
+                # deload's job - so the report has to be able to say so.
+                sits = "already at" if weight == spec.max_weight else "past"
+                return (
+                    Target(spec.rep_high, weight),
+                    f"top of the range, {sits} the {spec.max_weight:g} kg maximum",
+                )
+            return (
+                Target(spec.rep_low, spec.max_weight),
+                f"hit {floor} on every set{lifted}, top of the range, "
+                f"up to the {spec.max_weight:g} kg maximum",
+            )
         return (
-            Target(spec.rep_low, weight + spec.weight_step),
+            Target(spec.rep_low, heavier),
             f"hit {floor} on every set{lifted}, top of the range",
         )
 
@@ -330,6 +361,11 @@ def _advance(
     if not rebased and floor > current.reps:
         beat = f"beat target ({floor} on every set), "
     stalled = f"hit after {streak} miss{'es' if streak > 1 else ''}, " if streak else ""
+    # A timed hold is progressed in seconds -- `as_time` put them where the
+    # reps go -- so the step has to be named in the unit the exercise is
+    # actually measured in. "add 1 rep" beside a 25 s -> 26 s target names
+    # something the exercise does not have.
+    unit = "second" if spec.time_based else "rep"
     plural = "" if spec.rep_step == 1 else "s"
 
     if lead >= spec.sets:
@@ -338,12 +374,12 @@ def _advance(
         reps = min(base + spec.rep_step, spec.rep_high)
         return (
             Target(reps, weight),
-            f"{beat}{stalled}add {spec.rep_step} rep{plural}{moved}",
+            f"{beat}{stalled}add {spec.rep_step} {unit}{plural}{moved}",
         )
 
     return (
         Target(base, weight, lead),
-        f"{beat}{stalled}add {spec.rep_step} rep{plural} on "
+        f"{beat}{stalled}add {spec.rep_step} {unit}{plural} on "
         f"{units} of {spec.sets} sets{moved}",
     )
 

{repwise-2.0.0 → repwise-2.1.0/src/repwise.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: repwise
-Version: 2.0.0
+Version: 2.1.0
 Summary: Advance Garmin strength workout targets using double progression
 Author-email: Adam Żmuda <adam@zmuda.pro>
 License-Expression: MIT

{repwise-2.0.0 → repwise-2.1.0}/tests/test_config.py

@@ -698,6 +698,72 @@ def test_a_negative_min_weight_is_rejected(write_config):
         load_config(write_config(text))
 
 
+# --- how heavy a load can go ----------------------------------------------
+
+
+def test_max_weights_come_from_the_load_type(write_config):
+    text = FIXTURE.replace(
+        "  weight_steps:",
+        "  max_weights:\n    barbell: 100.0\n\n  weight_steps:",
+    )
+    config = load_config(write_config(text))
+    assert config["Workout A"].exercises[0].max_weight == 100.0
+
+
+def test_an_exercise_can_set_its_own_max_weight(write_config):
+    text = FIXTURE.replace(
+        "        load: barbell", "        load: barbell\n        max_weight: 60.0"
+    )
+    config = load_config(write_config(text))
+    assert config["Workout A"].exercises[0].max_weight == 60.0
+
+
+def test_an_exercise_max_weight_beats_the_load_type(write_config):
+    """Only this one movement is capped, and the rack is not."""
+    text = FIXTURE.replace(
+        "  weight_steps:",
+        "  max_weights:\n    barbell: 100.0\n\n  weight_steps:",
+    ).replace(
+        "        load: barbell", "        load: barbell\n        max_weight: 60.0"
+    )
+    config = load_config(write_config(text))
+    assert config["Workout A"].exercises[0].max_weight == 60.0
+
+
+def test_no_max_weights_at_all_means_no_ceiling(write_config):
+    """Unset is None rather than zero: zero would be a real maximum."""
+    config = load_config(write_config(FIXTURE))
+    assert config["Workout A"].exercises[0].max_weight is None
+
+
+def test_a_negative_max_weight_is_rejected(write_config):
+    text = FIXTURE.replace(
+        "        load: barbell", "        load: barbell\n        max_weight: -5"
+    )
+    with pytest.raises(ConfigError, match="negative max_weight"):
+        load_config(write_config(text))
+
+
+def test_a_max_weight_below_the_min_weight_is_rejected(write_config):
+    """Nothing could be prescribed between them, so neither end is honoured."""
+    text = FIXTURE.replace(
+        "        load: barbell",
+        "        load: barbell\n        min_weight: 20.0\n        max_weight: 10.0",
+    )
+    with pytest.raises(ConfigError, match="below its min_weight"):
+        load_config(write_config(text))
+
+
+def test_a_start_weight_above_the_max_weight_is_rejected(write_config):
+    """The one moment no session exists yet to correct it."""
+    text = FIXTURE.replace(
+        "        load: barbell",
+        "        load: barbell\n        start_weight: 30.0\n        max_weight: 10.0",
+    )
+    with pytest.raises(ConfigError, match="above its own max_weight"):
+        load_config(write_config(text))
+
+
 # --- reading a stored weight as a real load --------------------------------
 
 

{repwise-2.0.0 → repwise-2.1.0}/tests/test_progression.py

@@ -433,6 +433,17 @@ def test_a_timed_hold_ramps_in_seconds():
     assert target.spread(3) == "47+2"
 
 
+def test_a_timed_hold_says_what_it_adds_in_seconds():
+    """The step is a second, not a rep: a hold has no reps to add one to."""
+    _, why = next_target(PLANK, Target(47, 0.0), held(47, 47, 47))
+    assert "add 1 second" in why, why
+
+
+def test_a_timed_hold_names_seconds_on_a_partial_advance():
+    _, why = next_target(PLANK, Target(47, 0.0), held(47, 47, 47), streak=1)
+    assert "add 1 second on 2 of 3 sets" in why, why
+
+
 # --- how a target is written ----------------------------------------------
 
 
@@ -645,3 +656,84 @@ def test_a_deload_and_the_climb_back_are_the_same_ladder():
         BARBELL_SQUAT, eased, [P(9, 20.0), P(9, 20.0), P(8, 20.0)], streak=0
     )
     assert back == Target(9, 20.0), "levelled up, flat again"
+
+
+# --- topping out ----------------------------------------------------------
+#
+# The mirror of the deload's floor. Rule 3 adds a step every time the range is
+# cleared, and equipment you own runs out; without a ceiling the target climbs
+# to a weight no session can be logged against.
+
+HOME_PRESS = spec(
+    name="Dumbbell Floor Press",
+    garmin_name="DUMBBELL_FLOOR_PRESS",
+    garmin_category="BENCH_PRESS",
+    rep_low=10,
+    rep_high=16,
+    sets=3,
+    load="dumbbell",
+    weight_step=2.5,
+    min_weight=2.5,
+    max_weight=10.0,
+)
+
+
+def test_the_weight_never_goes_above_the_maximum():
+    """12.5 kg dumbbells you do not own is a target no session can answer."""
+    target, why = next_target(HOME_PRESS, Target(16, 10.0), [P(16, 10.0)] * 3)
+    assert target == Target(16, 10.0), why
+    assert "already at the 10 kg maximum" in why
+
+
+def test_a_capped_exercise_holds_at_the_top_of_the_range():
+    """The same ending as bodyweight: the range is all there is left."""
+    target, _ = next_target(HOME_PRESS, Target(16, 10.0), [P(18, 10.0)] * 3)
+    assert target == Target(HOME_PRESS.rep_high, 10.0)
+
+
+def test_the_last_step_is_shortened_to_land_on_the_maximum():
+    """9 + 2.5 is 11.5, which does not exist - but the 10 kg pair does."""
+    target, why = next_target(HOME_PRESS, Target(16, 9.0), [P(16, 9.0)] * 3)
+    assert target == Target(HOME_PRESS.rep_low, 10.0), why
+    assert "up to the 10 kg maximum" in why
+
+
+def test_the_shortened_step_is_taken_once_and_then_holds():
+    """Reaching the ceiling is a rung to climb, not a place to hover below."""
+    stepped, why = next_target(HOME_PRESS, Target(16, 9.0), [P(16, 9.0)] * 3)
+    assert stepped == Target(10, 10.0), why
+
+    held, why = next_target(HOME_PRESS, stepped, [P(16, 10.0)] * 3)
+    assert held == Target(HOME_PRESS.rep_high, 10.0), why
+
+
+def test_a_load_already_past_the_maximum_is_not_pulled_down():
+    """Rule 3 is the rule that adds load; taking it off is the deload's job."""
+    target, why = next_target(HOME_PRESS, Target(16, 12.5), [P(16, 12.5)] * 3)
+    assert target == Target(16, 12.5), why
+    assert "past the 10 kg maximum" in why, "past it, rather than at it"
+
+
+def test_below_the_maximum_the_weight_still_climbs():
+    """The ceiling is a stop, not a brake: every step under it is taken."""
+    target, why = next_target(HOME_PRESS, Target(16, 7.5), [P(16, 7.5)] * 3)
+    assert target == Target(HOME_PRESS.rep_low, 10.0), why
+
+
+def test_no_maximum_means_the_weight_keeps_climbing():
+    """The default, and what every config written before ceilings did."""
+    assert SQUAT.max_weight is None
+    target, _ = next_target(SQUAT, Target(10, 20.0), [P(10, 20.0)] * 3)
+    assert target == Target(SQUAT.rep_low, 25.0)
+
+
+def test_a_capped_exercise_still_deloads():
+    """Running out of weight upwards says nothing about coming back down."""
+    target, why = next_target(HOME_PRESS, Target(10, 10.0), [P(8, 10.0)] * 3, streak=1)
+    assert target == Target(HOME_PRESS.rep_low, 7.5), why
+
+
+def test_a_session_at_the_cap_rebases_off_an_impossible_target():
+    """The way back from a target already past the ceiling: lift what you have."""
+    target, why = next_target(HOME_PRESS, Target(10, 12.5), [P(12, 10.0)] * 3)
+    assert target.weight == 10.0, why