matebot 0.2.1__tar.gz → 0.2.2__tar.gz

{matebot-0.2.1 → matebot-0.2.2}/AGENTS.md

@@ -42,7 +42,7 @@ The decision tree:
    arrive within seconds of the shot ending.
 6. **Optional extras**, in ascending effort: journal repo + GitHub Pages
    (README "Publishing your journal"), dial-in hints (on by default), bean
-   bag tracking (`/newbag`), smart plug hooks for cold-start `/wake`
+   bag tracking (`/newbag`, multiple bags, `/tossbag`), smart plug hooks for cold-start `/wake`
    (README "Smart plug cold start").
 
 Common failure modes: token/chat id swapped or quoted wrong; bot and machine

{matebot-0.2.1 → matebot-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matebot
-Version: 0.2.1
+Version: 0.2.2
 Summary: The proactive companion for GaggiMate espresso machines: post-shot logging bot, .slog decoder, shot-journal site generator
 Project-URL: Homepage, https://github.com/AlexNly/matebot
 Project-URL: Issues, https://github.com/AlexNly/matebot/issues

{matebot-0.2.1 → matebot-0.2.2}/flake.nix

@@ -13,7 +13,7 @@
           default = matebot;
           matebot = pkgs.python3Packages.buildPythonApplication {
             pname = "matebot";
-            version = "0.2.1";
+            version = "0.2.2";
             pyproject = true;
             src = self;
             build-system = [ pkgs.python3Packages.hatchling ];

{matebot-0.2.1 → matebot-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "matebot"
-version = "0.2.1"
+version = "0.2.2"
 description = "The proactive companion for GaggiMate espresso machines: post-shot logging bot, .slog decoder, shot-journal site generator"
 readme = "README.md"
 license = "MIT"

{matebot-0.2.1 → matebot-0.2.2}/src/matebot/__init__.py

@@ -1,3 +1,3 @@
 """matebot — the proactive companion for GaggiMate espresso machines."""
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"

matebot-0.2.2/src/matebot/bags.py

@@ -0,0 +1,134 @@
+"""Bean bag tracking — strictly opt-in, multiple open bags supported.
+
+Nothing happens until the user registers a bag with ``/newbag``. Open bags
+appear as tap options in the questionnaire's bean question; a logged dose is
+subtracted from the bag whose name matches the answered bean. ``/bag`` shows
+all open bags, ``/tossbag`` closes one (emptied, binned, or gifted).
+
+State shape: ``bags = [{"name", "total_g", "used_g", "shots", "rating_sum",
+"warned"}, ...]`` (the legacy single-``bag`` key is migrated on first access).
+"""
+
+from __future__ import annotations
+
+DEFAULT_DOSE_G = 18.0
+WARN_DOSES = 3
+MAX_NAME_LEN = 40  # keeps bean names inside messenger option-id limits
+
+
+def _bags(state) -> list[dict]:
+    bags = state.get("bags")
+    if bags is None:
+        legacy = state.get("bag")
+        bags = [legacy] if legacy else []
+        state.set("bags", bags)
+        state.set("bag", None)
+    return bags
+
+
+def open_bag_names(state) -> list[str]:
+    return [b["name"] for b in _bags(state)]
+
+
+def open_bag(state, total_g: float, name: str) -> str:
+    name = name.strip()[:MAX_NAME_LEN]
+    bags = [b for b in _bags(state) if b["name"] != name]  # same name = new bag
+    bags.append({
+        "name": name, "total_g": total_g, "used_g": 0.0,
+        "shots": 0, "rating_sum": 0, "warned": False,
+    })
+    state.set("bags", bags)
+    return f"🫘 New bag registered: {name}, {total_g:.0f} g. I'll keep count."
+
+
+def toss_bag(state, name: str | None = None) -> str:
+    bags = _bags(state)
+    if not bags:
+        return "No open bags to toss."
+    if name:
+        matches = [b for b in bags if b["name"].lower() == name.strip().lower()]
+        if not matches:
+            return f"No open bag called “{name}”. Open bags: {', '.join(open_bag_names(state))}"
+        bag = matches[0]
+    elif len(bags) == 1:
+        bag = bags[0]
+    else:
+        return "Which one? /tossbag <name> — open bags: " + ", ".join(open_bag_names(state))
+    bags.remove(bag)
+    state.set("bags", bags)
+    left = max(0.0, bag["total_g"] - bag["used_g"])
+    line = f"🗑 Tossed “{bag['name']}” after {bag['shots']} shots"
+    if left > 20:
+        line += f" (~{left:.0f} g unused — a friend's gain, I hope)"
+    return line + "."
+
+
+def bag_status(state) -> str:
+    bags = _bags(state)
+    if not bags:
+        return "No bag registered. Start one with: /newbag <grams> [name]"
+    dose = _typical_dose(state)
+    lines = []
+    for bag in bags:
+        remaining = max(0.0, bag["total_g"] - bag["used_g"])
+        doses_left = int(remaining // dose) if dose else 0
+        line = (
+            f"🫘 {bag['name']}: {remaining:.0f} g of {bag['total_g']:.0f} g left"
+            f" (≈{doses_left} doses) · {bag['shots']} shots"
+        )
+        if bag["shots"] and bag["rating_sum"]:
+            line += f" · avg {'★' * round(bag['rating_sum'] / bag['shots'])}"
+        lines.append(line)
+    return "\n".join(lines)
+
+
+def track_shot(state, notes: dict) -> str | None:
+    """Subtract the logged dose from the matching bag; warn when running low.
+
+    The dose goes to the bag whose name equals the answered bean. With exactly
+    one open bag and no bean given, that bag gets it (the pre-multi-bag
+    behavior). Ambiguous cases are left untracked rather than guessed.
+    """
+    bags = _bags(state)
+    if not bags:
+        return None
+    try:
+        dose = float(notes.get("doseIn", ""))
+    except (TypeError, ValueError):
+        dose = 0.0
+    if dose <= 0:
+        return None
+
+    bean = (notes.get("beanType") or "").strip().lower()
+    matches = [b for b in bags if b["name"].lower() == bean]
+    if not matches and not bean and len(bags) == 1:
+        matches = bags
+    if not matches:
+        return None
+    bag = matches[0]
+
+    bag["used_g"] += dose
+    bag["shots"] += 1
+    rating = notes.get("rating")
+    if isinstance(rating, int):
+        bag["rating_sum"] += rating
+    remaining = bag["total_g"] - bag["used_g"]
+
+    message = None
+    if remaining <= 0:
+        message = f"🫘 That was the last of '{bag['name']}' by my count — bag empty."
+    elif remaining < WARN_DOSES * dose and not bag["warned"]:
+        bag["warned"] = True
+        message = (
+            f"🫘 Heads-up: '{bag['name']}' is down to ~{remaining:.0f} g "
+            f"(≈{int(remaining // dose)} doses). Time to restock?"
+        )
+    state.set("bags", bags)
+    return message
+
+
+def _typical_dose(state) -> float:
+    try:
+        return float(state.get("last_notes", {}).get("doseIn", DEFAULT_DOSE_G))
+    except (TypeError, ValueError):
+        return DEFAULT_DOSE_G

{matebot-0.2.1 → matebot-0.2.2}/src/matebot/commands.py

@@ -26,7 +26,8 @@ HELP = (
     "/last — the last logged shot\n"
     "/fix — redo the questionnaire for the last shot\n"
     "/newbag <grams> [name] — start tracking a bean bag (optional feature)\n"
-    "/bag — how much is left in the bag\n"
+    "/bag — how much is left in the open bags\n"
+    "/tossbag [name] — close out a bag (emptied, binned, or gifted)\n"
     "/digest — your last 7 days in espresso\n"
     "/help — this list"
 )
@@ -199,6 +200,11 @@ class CommandRouter:
 
         await self.messenger.send(bags.bag_status(self.state))
 
+    async def _cmd_tossbag(self) -> None:
+        from . import bags
+
+        await self.messenger.send(bags.toss_bag(self.state, " ".join(self._args) or None))
+
     async def _cmd_digest(self) -> None:
         text = await build_digest(self.client, self.config)
         await self.messenger.send(text or "No shots in the last 7 days. The machine misses you.")

{matebot-0.2.1 → matebot-0.2.2}/src/matebot/conversation.py

@@ -188,6 +188,13 @@ class Conversation:
             ]
         options = []
         default = self._defaults().get(NOTE_KEYS[step])
+        if step == "bean":
+            from . import bags
+
+            for name in bags.open_bag_names(self.state)[:3]:
+                options.append(mk("bean", name, f"🫘 {name}"[:60]))
+                if name == default:
+                    default = None  # avoid a duplicate "same as last" button
         if step == "dout" and self.pending.volume_g:
             grams = f"{self.pending.volume_g:.1f}"
             options.append(mk("dout", grams, f"Use {grams} g"))

{matebot-0.2.1 → matebot-0.2.2}/src/matebot/messengers/telegram.py

@@ -53,6 +53,7 @@ class TelegramMessenger(Messenger):
                 BotCommand("fix", "redo the last shot's log"),
                 BotCommand("bag", "how much is left in the bean bag"),
                 BotCommand("newbag", "start tracking a bean bag"),
+                BotCommand("tossbag", "close out a bag"),
                 BotCommand("help", "list commands"),
             ])
         await self.app.updater.start_polling(drop_pending_updates=True)

{matebot-0.2.1 → matebot-0.2.2}/tests/test_bags.py

@@ -45,3 +45,37 @@ def test_skipped_dose_not_counted(tmp_path):
     assert track_shot(state, {}) is None
     assert track_shot(state, {"doseIn": "garbage"}) is None
     assert "250 g of 250 g" in bag_status(state)
+
+
+def test_multi_bag_attribution(tmp_path):
+    state = make_state(tmp_path)
+    open_bag(state, 250, "Mondo Classico")
+    open_bag(state, 500, "Supermarket Blend")
+    track_shot(state, {"doseIn": "18", "beanType": "Mondo Classico", "rating": 5})
+    track_shot(state, {"doseIn": "20", "beanType": "supermarket blend"})  # case-insensitive
+    track_shot(state, {"doseIn": "18"})  # ambiguous with two bags: untracked
+    status = bag_status(state)
+    assert "232 g of 250 g" in status
+    assert "480 g of 500 g" in status
+
+
+def test_toss_bag(tmp_path):
+    from matebot.bags import open_bag_names, toss_bag
+
+    state = make_state(tmp_path)
+    assert "No open bags" in toss_bag(state)
+    open_bag(state, 250, "Mondo Classico")
+    open_bag(state, 250, "Gift Beans")
+    assert "Which one?" in toss_bag(state)  # ambiguous
+    assert "Gift Beans" in toss_bag(state, "gift beans")
+    assert open_bag_names(state) == ["Mondo Classico"]
+    assert "Tossed" in toss_bag(state)  # single bag: no name needed
+    assert open_bag_names(state) == []
+
+
+def test_legacy_single_bag_migrates(tmp_path):
+    state = make_state(tmp_path)
+    state.set("bag", {"name": "Old Beans", "total_g": 250, "used_g": 50,
+                      "shots": 3, "rating_sum": 12, "warned": False})
+    assert "Old Beans: 200 g" in bag_status(state)
+    assert state.get("bag") is None

{matebot-0.2.1 → matebot-0.2.2}/tests/test_conversation.py

@@ -168,3 +168,26 @@ def test_signoff_matches_time_of_day():
     assert "evening" in _signoff(19)
     assert "dreams" in _signoff(23)
     assert "dreams" in _signoff(2)
+
+
+@pytest.mark.asyncio
+async def test_bean_step_offers_open_bags(tmp_path):
+    from matebot.bags import open_bag
+
+    fm = FakeMessenger()
+    state = State(tmp_path / "state.json")
+    open_bag(state, 250, "Mondo Classico")
+    open_bag(state, 250, "Ethiopia Natural")
+    state.set("last_notes", {"beanType": "Mondo Classico"})
+    c = Conversation(fm, state, SaveRecorder())
+    await c.start_shot(70, "p", 30000, 0)
+    await answer(c, "g|70|r|4")
+    await answer(c, "g|70|bt|skip")
+    labels = [o.label for o in fm.last_options]
+    assert "🫘 Mondo Classico" in labels
+    assert "🫘 Ethiopia Natural" in labels
+    # no duplicate "Same as last: Mondo Classico" next to the bag button
+    assert not any("Same as last" in label for label in labels)
+    bag_option = next(o for o in fm.last_options if o.label == "🫘 Ethiopia Natural")
+    await c.handle_event(OptionSelected(bag_option.id))
+    assert c.pending.answers["beanType"] == "Ethiopia Natural"

matebot-0.2.1/src/matebot/bags.py

@@ -1,77 +0,0 @@
-"""Bean bag tracking — strictly opt-in.
-
-Nothing happens until the user registers a bag with ``/newbag``; from then on
-every logged dose-in is subtracted, and the bot warns once when roughly three
-doses are left. ``/bag`` shows the current state at any time.
-
-State shape (in the bot's state file):
-    bag = {"name": str, "total_g": float, "used_g": float,
-           "shots": int, "rating_sum": int, "warned": bool}
-"""
-
-from __future__ import annotations
-
-DEFAULT_DOSE_G = 18.0
-WARN_DOSES = 3
-
-
-def open_bag(state, total_g: float, name: str) -> str:
-    state.set("bag", {
-        "name": name, "total_g": total_g, "used_g": 0.0,
-        "shots": 0, "rating_sum": 0, "warned": False,
-    })
-    return f"🫘 New bag registered: {name}, {total_g:.0f} g. I'll keep count."
-
-
-def bag_status(state) -> str:
-    bag = state.get("bag")
-    if not bag:
-        return "No bag registered. Start one with: /newbag <grams> [name]"
-    remaining = max(0.0, bag["total_g"] - bag["used_g"])
-    dose = _typical_dose(state)
-    doses_left = int(remaining // dose) if dose else 0
-    line = (
-        f"🫘 {bag['name']}: {remaining:.0f} g of {bag['total_g']:.0f} g left"
-        f" (≈{doses_left} doses) · {bag['shots']} shots"
-    )
-    if bag["shots"] and bag["rating_sum"]:
-        line += f" · avg {'★' * round(bag['rating_sum'] / bag['shots'])}"
-    return line
-
-
-def track_shot(state, notes: dict) -> str | None:
-    """Subtract the logged dose; returns a warning message when running low."""
-    bag = state.get("bag")
-    if not bag:
-        return None
-    try:
-        dose = float(notes.get("doseIn", ""))
-    except (TypeError, ValueError):
-        dose = 0.0
-    if dose <= 0:
-        return None
-    bag["used_g"] += dose
-    bag["shots"] += 1
-    rating = notes.get("rating")
-    if isinstance(rating, int):
-        bag["rating_sum"] += rating
-    remaining = bag["total_g"] - bag["used_g"]
-
-    message = None
-    if remaining <= 0:
-        message = f"🫘 That was the last of '{bag['name']}' by my count — bag empty."
-    elif remaining < WARN_DOSES * dose and not bag["warned"]:
-        bag["warned"] = True
-        message = (
-            f"🫘 Heads-up: '{bag['name']}' is down to ~{remaining:.0f} g "
-            f"(≈{int(remaining // dose)} doses). Time to restock?"
-        )
-    state.set("bag", bag)
-    return message
-
-
-def _typical_dose(state) -> float:
-    try:
-        return float(state.get("last_notes", {}).get("doseIn", DEFAULT_DOSE_G))
-    except (TypeError, ValueError):
-        return DEFAULT_DOSE_G