recovery-lab-math 1.0.0__tar.gz

recovery_lab_math-1.0.0/PKG-INFO

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: recovery-lab-math
+Version: 1.0.0
+Summary: Home recovery purchase vs gym drop-in, in the terminal: true heater draw, per-session supplies, amortized hardware, and the break-even frequency
+Author: James Verlander
+License: MIT
+Project-URL: Homepage, https://hackedself.com/
+Project-URL: Source Code, https://github.com/scrapertweeter3-prog/recovery-lab-math
+Project-URL: Bug Tracker, https://github.com/scrapertweeter3-prog/recovery-lab-math/issues
+Keywords: sauna,cold-plunge,recovery,biohacking,cost-per-session,break-even,longevity,cli
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Recoveryspend - Home recovery lab cost-per-session + break-even
+
+A terminal calculator that answers one question: does the home unit beat
+the gym-studio drop-in, and when? Costs any home recovery purchase (sauna,
+cold plunge, red-light panel, massage gun, per-session amenity) against a
+drop-in price, using the exact method from the HackedSelf article: true
+energy draw from nameplate watts and your electric rate, filter/service
+supplies per session, amortized purchase over a realistic session count,
+and the weekly-frequency level where the home setup breaks even in years.
+
+Python 3.8+, standard library only. No install, no network, nothing leaves
+your machine.
+
+![recoveryspend terminal output](docs/terminal.png)
+
+## The method
+
+- **Energy per session** = heater draw (W) / 1000 x hours x $/kWh
+  (preheat counted at half draw)
+- **Supplies per session** = annual filter/treatment cost / sessions per year
+- **Amortized hardware** = purchase price / sessions before it's paid off,
+  shown separately so you can watch it fall toward zero
+- **Break even** = solve price / sessions-per-week for the frequency where
+  the home marginal cost equals the drop-in price, in weeks and years
+
+The gym comparison uses the drop-in price only. If you already pay for a
+membership that includes the amenity, the drop-in is $0 and the home unit
+never wins - recoveryspend tells you that plainly.
+
+## Usage
+
+```
+$ python3 recoveryspend.py --price 4500 --watts 6000 --kwh 0.17 \
+    --sessions-year 150 --dropin 35 --name "2-person infrared sauna"
+== 2-person infrared sauna vs drop-in
+Energy per session       5.78  (4.5 kW effective, 0.75 h, $0.170/kWh)
+Supplies per session     0.50  ($75/yr filters, 150 sessions/yr)
+Marginal cost/session    6.28
+Drop-in price           35.00
+Break even              2.6 sessions/wk  (0.7 yr)
+
+$ python3 recoveryspend.py --json ...
+{"verdict": "home wins", "marginal": 6.28, "dropin": 35.0, ...}
+```
+
+## Also check
+
+- `--preheat 1.0` full-draw preheat hour instead of the half-draw default
+- `--life-sessions 500` amortization window (default 500 sessions)
+- `--supplies-year 0` no filter/treatment line
+- Exit code 1 when the home unit loses at the current frequency, so the
+  check can gate a purchase decision in a script
+
+## Honest limits
+
+Energy math is nameplate math: real duty cycles, ambient temperature and
+insulation move the true number, so treat the figure as the optimistic
+floor and the break-even as the optimistic edge. Sessions-per-year is a
+behavioral guess only you can make; the break-even output is exactly the
+place that guess gets honest. No study effect sizes are cited anywhere in
+this repo, because there are none here - this tool is dollars, not dose.
+
+## Related
+
+The full protocol and the worked example behind this method:
+https://hackedself.com/recovery/home-recovery-lab-cost-per-session/

recovery_lab_math-1.0.0/README.md

@@ -0,0 +1,66 @@
+# Recoveryspend - Home recovery lab cost-per-session + break-even
+
+A terminal calculator that answers one question: does the home unit beat
+the gym-studio drop-in, and when? Costs any home recovery purchase (sauna,
+cold plunge, red-light panel, massage gun, per-session amenity) against a
+drop-in price, using the exact method from the HackedSelf article: true
+energy draw from nameplate watts and your electric rate, filter/service
+supplies per session, amortized purchase over a realistic session count,
+and the weekly-frequency level where the home setup breaks even in years.
+
+Python 3.8+, standard library only. No install, no network, nothing leaves
+your machine.
+
+![recoveryspend terminal output](docs/terminal.png)
+
+## The method
+
+- **Energy per session** = heater draw (W) / 1000 x hours x $/kWh
+  (preheat counted at half draw)
+- **Supplies per session** = annual filter/treatment cost / sessions per year
+- **Amortized hardware** = purchase price / sessions before it's paid off,
+  shown separately so you can watch it fall toward zero
+- **Break even** = solve price / sessions-per-week for the frequency where
+  the home marginal cost equals the drop-in price, in weeks and years
+
+The gym comparison uses the drop-in price only. If you already pay for a
+membership that includes the amenity, the drop-in is $0 and the home unit
+never wins - recoveryspend tells you that plainly.
+
+## Usage
+
+```
+$ python3 recoveryspend.py --price 4500 --watts 6000 --kwh 0.17 \
+    --sessions-year 150 --dropin 35 --name "2-person infrared sauna"
+== 2-person infrared sauna vs drop-in
+Energy per session       5.78  (4.5 kW effective, 0.75 h, $0.170/kWh)
+Supplies per session     0.50  ($75/yr filters, 150 sessions/yr)
+Marginal cost/session    6.28
+Drop-in price           35.00
+Break even              2.6 sessions/wk  (0.7 yr)
+
+$ python3 recoveryspend.py --json ...
+{"verdict": "home wins", "marginal": 6.28, "dropin": 35.0, ...}
+```
+
+## Also check
+
+- `--preheat 1.0` full-draw preheat hour instead of the half-draw default
+- `--life-sessions 500` amortization window (default 500 sessions)
+- `--supplies-year 0` no filter/treatment line
+- Exit code 1 when the home unit loses at the current frequency, so the
+  check can gate a purchase decision in a script
+
+## Honest limits
+
+Energy math is nameplate math: real duty cycles, ambient temperature and
+insulation move the true number, so treat the figure as the optimistic
+floor and the break-even as the optimistic edge. Sessions-per-year is a
+behavioral guess only you can make; the break-even output is exactly the
+place that guess gets honest. No study effect sizes are cited anywhere in
+this repo, because there are none here - this tool is dollars, not dose.
+
+## Related
+
+The full protocol and the worked example behind this method:
+https://hackedself.com/recovery/home-recovery-lab-cost-per-session/

recovery_lab_math-1.0.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "recovery-lab-math"
+version = "1.0.0"
+description = "Home recovery purchase vs gym drop-in, in the terminal: true heater draw, per-session supplies, amortized hardware, and the break-even frequency"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+authors = [{name = "James Verlander"}]
+keywords = ["sauna", "cold-plunge", "recovery", "biohacking", "cost-per-session", "break-even", "longevity", "cli"]
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Environment :: Console",
+  "Intended Audience :: End Users/Desktop",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Topic :: Scientific/Engineering",
+  "Topic :: Utilities",
+]
+
+[project.urls]
+Homepage = "https://hackedself.com/"
+"Source Code" = "https://github.com/scrapertweeter3-prog/recovery-lab-math"
+"Bug Tracker" = "https://github.com/scrapertweeter3-prog/recovery-lab-math/issues"
+
+[project.scripts]
+recoveryspend = "recoveryspend:main"
+
+[tool.setuptools]
+py-modules = ["recoveryspend"]

recovery_lab_math-1.0.0/recovery_lab_math.egg-info/PKG-INFO

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: recovery-lab-math
+Version: 1.0.0
+Summary: Home recovery purchase vs gym drop-in, in the terminal: true heater draw, per-session supplies, amortized hardware, and the break-even frequency
+Author: James Verlander
+License: MIT
+Project-URL: Homepage, https://hackedself.com/
+Project-URL: Source Code, https://github.com/scrapertweeter3-prog/recovery-lab-math
+Project-URL: Bug Tracker, https://github.com/scrapertweeter3-prog/recovery-lab-math/issues
+Keywords: sauna,cold-plunge,recovery,biohacking,cost-per-session,break-even,longevity,cli
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Recoveryspend - Home recovery lab cost-per-session + break-even
+
+A terminal calculator that answers one question: does the home unit beat
+the gym-studio drop-in, and when? Costs any home recovery purchase (sauna,
+cold plunge, red-light panel, massage gun, per-session amenity) against a
+drop-in price, using the exact method from the HackedSelf article: true
+energy draw from nameplate watts and your electric rate, filter/service
+supplies per session, amortized purchase over a realistic session count,
+and the weekly-frequency level where the home setup breaks even in years.
+
+Python 3.8+, standard library only. No install, no network, nothing leaves
+your machine.
+
+![recoveryspend terminal output](docs/terminal.png)
+
+## The method
+
+- **Energy per session** = heater draw (W) / 1000 x hours x $/kWh
+  (preheat counted at half draw)
+- **Supplies per session** = annual filter/treatment cost / sessions per year
+- **Amortized hardware** = purchase price / sessions before it's paid off,
+  shown separately so you can watch it fall toward zero
+- **Break even** = solve price / sessions-per-week for the frequency where
+  the home marginal cost equals the drop-in price, in weeks and years
+
+The gym comparison uses the drop-in price only. If you already pay for a
+membership that includes the amenity, the drop-in is $0 and the home unit
+never wins - recoveryspend tells you that plainly.
+
+## Usage
+
+```
+$ python3 recoveryspend.py --price 4500 --watts 6000 --kwh 0.17 \
+    --sessions-year 150 --dropin 35 --name "2-person infrared sauna"
+== 2-person infrared sauna vs drop-in
+Energy per session       5.78  (4.5 kW effective, 0.75 h, $0.170/kWh)
+Supplies per session     0.50  ($75/yr filters, 150 sessions/yr)
+Marginal cost/session    6.28
+Drop-in price           35.00
+Break even              2.6 sessions/wk  (0.7 yr)
+
+$ python3 recoveryspend.py --json ...
+{"verdict": "home wins", "marginal": 6.28, "dropin": 35.0, ...}
+```
+
+## Also check
+
+- `--preheat 1.0` full-draw preheat hour instead of the half-draw default
+- `--life-sessions 500` amortization window (default 500 sessions)
+- `--supplies-year 0` no filter/treatment line
+- Exit code 1 when the home unit loses at the current frequency, so the
+  check can gate a purchase decision in a script
+
+## Honest limits
+
+Energy math is nameplate math: real duty cycles, ambient temperature and
+insulation move the true number, so treat the figure as the optimistic
+floor and the break-even as the optimistic edge. Sessions-per-year is a
+behavioral guess only you can make; the break-even output is exactly the
+place that guess gets honest. No study effect sizes are cited anywhere in
+this repo, because there are none here - this tool is dollars, not dose.
+
+## Related
+
+The full protocol and the worked example behind this method:
+https://hackedself.com/recovery/home-recovery-lab-cost-per-session/

recovery_lab_math-1.0.0/recovery_lab_math.egg-info/SOURCES.txt

@@ -0,0 +1,8 @@
+README.md
+pyproject.toml
+recoveryspend.py
+recovery_lab_math.egg-info/PKG-INFO
+recovery_lab_math.egg-info/SOURCES.txt
+recovery_lab_math.egg-info/dependency_links.txt
+recovery_lab_math.egg-info/entry_points.txt
+recovery_lab_math.egg-info/top_level.txt

recovery_lab_math-1.0.0/recovery_lab_math.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

recovery_lab_math-1.0.0/recovery_lab_math.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+recoveryspend = recoveryspend:main

recovery_lab_math-1.0.0/recovery_lab_math.egg-info/top_level.txt

@@ -0,0 +1 @@
+recoveryspend

recovery_lab_math-1.0.0/recoveryspend.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+"""recoveryspend: home recovery purchase vs drop-in price, per session.
+
+Costs a home sauna / cold plunge / red-light panel against a studio drop-in
+using nameplate energy math, per-session supplies, and amortized hardware,
+then reports payoff time at your weekly frequency.
+
+Stdlib only. Python 3.8+. No network.
+"""
+import argparse
+import json
+import sys
+
+AMORT_SESSIONS_DEFAULT = 500  # sessions before hardware is considered paid off
+
+
+def money(x):
+    return round(x + 1e-9, 2)
+
+
+def cost_model(price, watts, hours, preheat_frac, kwh, supplies_year,
+               sessions_year, life_sessions):
+    kw = watts / 1000.0
+    energy = money(kw * (hours + preheat_frac) * kwh)
+    supplies = money(supplies_year / sessions_year)
+    marginal = money(energy + supplies)
+    amortized = money(price / max(life_sessions, 1))
+    allin = money(marginal + amortized)
+    return {
+        "kw": round(kw, 2),
+        "hours_incl_preheat": round(hours + preheat_frac, 2),
+        "kwh_rate": kwh,
+        "energy_per_session": energy,
+        "supplies_per_session": supplies,
+        "marginal_per_session": marginal,
+        "amortized_per_session": amortized,
+        "allin_per_session": allin,
+    }
+
+
+def payoff(price, marginal, dropin, freq, life_sessions):
+    """Weeks/years to pay off the purchase at `freq` sessions per week.
+
+    Returns (weeks, years, note). weeks is None when it never pays off.
+    """
+    gap = dropin - marginal
+    if dropin <= 0:
+        return None, None, "gym is free (membership includes it): home never wins"
+    if gap <= 0:
+        return None, None, "energy+supplies already exceed the drop-in price"
+    weeks = price / (gap * freq)
+    return round(weeks, 1), round(weeks / 52.0, 1), None
+
+
+def verdict_for(m, dropin, freq, life_sessions):
+    """Honest verdict: does the purchase pay off inside the amortization
+    window? That happens iff dropin >= marginal + amortized (the all-in)."""
+    if dropin <= 0:
+        return "keep the membership: the amenity is already free", 0
+    if m["marginal_per_session"] >= dropin:
+        return "home loses: running cost alone exceeds the drop-in", 1
+    if m["allin_per_session"] <= dropin:
+        return "home wins", 0
+    return ("never amortizes in %d sessions: ownership play only"
+            % life_sessions), 0
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser(
+        description="Home recovery purchase vs drop-in: cost per session "
+                    "and payoff time.")
+    p.add_argument("--price", type=float, required=True,
+                   help="purchase price of the home unit ($)")
+    p.add_argument("--watts", type=float, required=True,
+                   help="nameplate heater draw (W)")
+    p.add_argument("--hours", type=float, default=0.75,
+                   help="session length in hours (default 0.75)")
+    p.add_argument("--preheat", type=float, default=0.5,
+                   help="preheat draw in full-draw hours (default 0.5)")
+    p.add_argument("--kwh", type=float, required=True,
+                   help="your electric rate ($/kWh)")
+    p.add_argument("--supplies-year", type=float, default=0.0,
+                   help="annual filter/treatment cost ($)")
+    p.add_argument("--sessions-year", type=int, default=100,
+                   help="expected sessions per year (supplies divisor)")
+    p.add_argument("--life-sessions", type=int,
+                   default=AMORT_SESSIONS_DEFAULT,
+                   help="sessions over which to amortize the purchase")
+    p.add_argument("--dropin", type=float, required=True,
+                   help="studio/gym drop-in price per session ($)")
+    p.add_argument("--freq", type=float, default=1.0,
+                   help="planned sessions per week for the payoff clock "
+                        "(default 1.0)")
+    p.add_argument("--name", default="home unit", help="label for output")
+    p.add_argument("--json", action="store_true", help="JSON output")
+    args = p.parse_args(argv)
+
+    if args.sessions_year <= 0:
+        p.error("--sessions-year must be positive")
+    if args.life_sessions <= 0:
+        p.error("--life-sessions must be positive")
+    if args.freq <= 0:
+        p.error("--freq must be positive")
+
+    m = cost_model(args.price, args.watts, args.hours, args.preheat,
+                   args.kwh, args.supplies_year, args.sessions_year,
+                   args.life_sessions)
+    weeks, years, note = payoff(args.price, m["marginal_per_session"],
+                                args.dropin, args.freq, args.life_sessions)
+    verdict, rc = verdict_for(m, args.dropin, args.freq, args.life_sessions)
+
+    out = {
+        "name": args.name,
+        "dropin": args.dropin,
+        "freq_per_week": args.freq,
+        **m,
+        "payoff_weeks_at_freq": weeks,
+        "payoff_years_at_freq": years,
+        "note": note,
+        "verdict": verdict,
+    }
+
+    if args.json:
+        print(json.dumps(out, indent=2))
+        return rc
+
+    print("== %s vs drop-in" % args.name)
+    print("Energy per session     %6.2f  (%.2f kW, %.2f h incl. preheat, "
+          "$%.3f/kWh)" % (m["energy_per_session"], m["kw"],
+                          m["hours_incl_preheat"], args.kwh))
+    print("Supplies per session   %6.2f  ($%.0f/yr, %d sessions/yr)"
+          % (m["supplies_per_session"], args.supplies_year,
+             args.sessions_year))
+    print("Marginal cost/session  %6.2f" % m["marginal_per_session"])
+    print("Amortized/session      %6.2f  (over %d sessions)"
+          % (m["amortized_per_session"], args.life_sessions))
+    print("All-in/session         %6.2f" % m["allin_per_session"])
+    print("Drop-in price          %6.2f" % args.dropin)
+    if note:
+        print("Payoff                 %s" % note)
+    else:
+        print("Payoff at %.1f/wk     %6.1f wk  (%.1f yr)"
+              % (args.freq, weeks, years))
+    print("Verdict: %s" % verdict)
+    return rc
+
+
+if __name__ == "__main__":
+    sys.exit(main())

recovery_lab_math-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+