chefkoch-cli 0.1.1__py3-none-any.whl

chefkoch_cli/service.py

@@ -0,0 +1,360 @@
+"""Fachlogik: Suche, Namensauflösung, Skalierung und Einkaufsliste."""
+
+from __future__ import annotations
+
+import math
+import re
+import unicodedata
+from typing import Any
+from urllib.parse import urlsplit
+
+from .client import ApiClient
+from .errors import NoResultsError, NotFoundError, UsageError
+from .parsing import (
+    TAG_VEGAN,
+    TAG_VEGETARISCH,
+    normalize_recipe,
+    normalize_search_payload,
+    recipe_tag_ids,
+)
+
+SEARCH_WINDOW = 500
+LOOKUP_LIMIT = 10
+DEFAULT_LIMIT = 10
+DEFAULT_WATCH_LIMIT = 50
+SORT_CHOICES = ("bewertung", "zeit", "neu")
+DIFFICULTIES = {"simpel": 1, "normal": 2, "pfiffig": 3}
+CHEFKOCH_HOSTS = {"www.chefkoch.de", "chefkoch.de"}
+
+
+def _validate_limit(value: int, name: str = "--limit") -> int:
+    if value < 1 or value > 100:
+        raise UsageError(
+            f"{name} muss zwischen 1 und 100 liegen.",
+            next_step="Beispiel: --limit 10",
+        )
+    return value
+
+
+def _validate_page(value: int) -> int:
+    if value < 1:
+        raise UsageError(
+            "--seite muss mindestens 1 sein.",
+            next_step="Beispiel: --seite 1",
+        )
+    return value
+
+
+def _validate_max_time(value: int | None) -> int | None:
+    if value is not None and value < 0:
+        raise UsageError(
+            "--max-zeit darf nicht negativ sein.",
+            next_step="Beispiel: --max-zeit 30",
+        )
+    return value
+
+
+def _validate_min_rating(value: float | None) -> float | None:
+    if value is None:
+        return None
+    if value < 0 or value > 5:
+        raise UsageError(
+            "--min-bewertung muss zwischen 0 und 5 liegen.",
+            next_step="Beispiel: --min-bewertung 4.5",
+        )
+    return value
+
+
+def _validate_difficulty(value: str | None) -> int | None:
+    if value is None:
+        return None
+    if value not in DIFFICULTIES:
+        raise UsageError(
+            f"Unbekannte Schwierigkeit: {value!r}.",
+            next_step="Erlaubt sind simpel, normal oder pfiffig.",
+        )
+    return DIFFICULTIES[value]
+
+
+def sort_results(items: list[dict[str, Any]], sort: str) -> list[dict[str, Any]]:
+    if sort not in SORT_CHOICES:
+        raise UsageError(
+            f"Unbekannte Sortierung: {sort!r}.",
+            next_step="Erlaubt sind bewertung, zeit oder neu.",
+        )
+    if sort == "zeit":
+        return sorted(
+            items,
+            key=lambda item: (
+                item.get("preparationTime")
+                if item.get("preparationTime") is not None
+                else float("inf"),
+                -(item.get("rating") or 0.0),
+            ),
+        )
+    if sort == "neu":
+        return sorted(
+            items,
+            key=lambda item: (
+                str(item.get("createdAt") or ""),
+                str(item.get("id") or ""),
+            ),
+            reverse=True,
+        )
+    return sorted(
+        items,
+        key=lambda item: (
+            -(item.get("rating") or 0.0),
+            -int(item.get("numVotes") or 0),
+            str(item.get("title") or "").casefold(),
+        ),
+    )
+
+
+def search_recipes(
+    client: ApiClient,
+    query: str,
+    *,
+    vegetarisch: bool = False,
+    vegan: bool = False,
+    max_zeit: int | None = None,
+    min_bewertung: float | None = None,
+    schwierigkeit: str | None = None,
+    sort: str = "bewertung",
+    limit: int = DEFAULT_LIMIT,
+    seite: int = 1,
+) -> dict[str, Any]:
+    text = str(query or "").strip()
+    if not text:
+        raise UsageError(
+            "Der Suchbegriff fehlt.",
+            next_step="Beispiel: chefkoch suche lasagne",
+        )
+    _validate_limit(limit)
+    _validate_page(seite)
+    _validate_max_time(max_zeit)
+    _validate_min_rating(min_bewertung)
+    difficulty = _validate_difficulty(schwierigkeit)
+    if sort not in SORT_CHOICES:
+        raise UsageError(
+            f"Unbekannte Sortierung: {sort!r}.",
+            next_step="Erlaubt sind bewertung, zeit oder neu.",
+        )
+
+    tags = TAG_VEGAN if vegan else TAG_VEGETARISCH if vegetarisch else None
+    payload = client.search(
+        text,
+        limit=SEARCH_WINDOW,
+        offset=0,
+        minimum_rating=min_bewertung,
+        maximum_time=max_zeit,
+        tags=tags,
+    )
+    count, items = normalize_search_payload(payload)
+
+    filtered: list[dict[str, Any]] = []
+    for item in items:
+        if max_zeit is not None:
+            preparation = item.get("preparationTime")
+            if preparation is None or preparation > max_zeit:
+                continue
+        if min_bewertung is not None:
+            rating = item.get("rating")
+            if rating is None or rating < min_bewertung:
+                continue
+        if difficulty is not None and item.get("difficulty") != difficulty:
+            continue
+        filtered.append(item)
+
+    filtered = sort_results(filtered, sort)
+
+    if tags is not None:
+        wanted = {tags}
+        need = limit * seite
+        verified: list[dict[str, Any]] = []
+        for item in filtered:
+            if len(verified) >= need:
+                break
+            try:
+                detail = client.recipe(str(item.get("id")))
+            except NotFoundError:
+                continue
+            detail_tags = recipe_tag_ids(detail)
+            if not wanted.issubset(detail_tags):
+                continue
+            item = dict(item)
+            item["vegetarian"] = TAG_VEGETARISCH in detail_tags
+            item["vegan"] = TAG_VEGAN in detail_tags
+            verified.append(item)
+        filtered = verified
+
+    page_items = filtered[(seite - 1) * limit : seite * limit]
+    if not page_items:
+        raise NoResultsError(
+            f"Keine Treffer für {text!r} mit diesen Filtern.",
+            next_step="Entferne einen Filter oder nutze einen anderen Suchbegriff.",
+        )
+
+    return {
+        "query": text,
+        "page": seite,
+        "limit": limit,
+        "total": count,
+        "count": len(page_items),
+        "results": page_items,
+    }
+
+
+def search_candidates(client: ApiClient, name: str) -> list[dict[str, Any]]:
+    text = str(name or "").strip()
+    if not text:
+        raise UsageError(
+            "Der Rezeptname fehlt.",
+            next_step="Beispiel: chefkoch rezept \"vegane lasagne\"",
+        )
+    payload = client.search(text, limit=LOOKUP_LIMIT)
+    _count, items = normalize_search_payload(payload)
+    return sort_results(items, "bewertung")
+
+
+_URL_RE = re.compile(r"^/rezepte/(\d+)(?:/[^/]*)?$")
+
+
+def parse_recipe_reference(value: str) -> tuple[str, str]:
+    text = str(value or "").strip()
+    if not text:
+        raise UsageError(
+            "Die Rezeptangabe fehlt.",
+            next_step="Nutze einen Namen, eine ID oder eine Chefkoch-URL.",
+        )
+    if text.isdigit():
+        return "id", text
+
+    candidate = text
+    if "://" not in candidate and (
+        candidate.startswith("www.") or candidate.startswith("chefkoch.de/")
+    ):
+        candidate = "https://" + candidate
+    if "://" in candidate:
+        parts = urlsplit(candidate)
+        if parts.scheme not in {"http", "https"}:
+            raise UsageError(
+                f"Ungültige URL: {text!r}.",
+                next_step="Nutze eine https://www.chefkoch.de/rezepte/<id>/... URL.",
+            )
+        host = (parts.hostname or "").lower()
+        if host not in CHEFKOCH_HOSTS:
+            raise UsageError(
+                f"Fremder Host in der URL: {host or text!r}.",
+                next_step="Nutze eine URL von www.chefkoch.de.",
+            )
+        match = _URL_RE.match(parts.path)
+        if not match:
+            raise UsageError(
+                f"Die URL enthält keine Rezept-ID: {text!r}.",
+                next_step="Nutze eine URL der Form https://www.chefkoch.de/rezepte/<id>/...",
+            )
+        return "id", match.group(1)
+    return "name", text
+
+
+def validate_servings(value: int | None) -> int | None:
+    if value is None:
+        return None
+    if value < 1:
+        raise UsageError(
+            "--portionen muss mindestens 1 sein.",
+            next_step="Beispiel: --portionen 4",
+        )
+    return value
+
+
+def _normalize_key(value: object) -> str:
+    text = unicodedata.normalize("NFC", str(value or ""))
+    text = " ".join(text.split())
+    return text.casefold()
+
+
+def _optional_amount(value: object) -> float | None:
+    if value is None or isinstance(value, bool):
+        return None
+    try:
+        number = float(value)
+    except (TypeError, ValueError):
+        return None
+    if not math.isfinite(number) or number == 0:
+        return None
+    return number
+
+
+def build_shopping_list(
+    recipes: list[dict[str, Any]], portions: int | None
+) -> dict[str, Any]:
+    aggregates: dict[tuple[str, str], dict[str, Any]] = {}
+    recipe_rows: list[dict[str, Any]] = []
+    for recipe in recipes:
+        recipe_rows.append(
+            {
+                "id": recipe.get("id"),
+                "servings": recipe.get("servings"),
+                "requestedServings": recipe.get("requestedServings"),
+            }
+        )
+        recipe_id = str(recipe.get("id") or "")
+        for group in recipe.get("ingredientGroups") or []:
+            for ingredient in group.get("ingredients") or []:
+                name = str(ingredient.get("name") or "").strip()
+                unit = str(ingredient.get("unit") or "").strip()
+                key = (_normalize_key(name), _normalize_key(unit))
+                entry = aggregates.get(key)
+                if entry is None:
+                    entry = {
+                        "name": name,
+                        "unit": unit,
+                        "amount": None,
+                        "recipeIds": [],
+                    }
+                    aggregates[key] = entry
+                amount = _optional_amount(ingredient.get("amount"))
+                if amount is not None:
+                    if entry["amount"] is None:
+                        entry["amount"] = 0.0
+                    entry["amount"] += amount
+                if recipe_id and recipe_id not in entry["recipeIds"]:
+                    entry["recipeIds"].append(recipe_id)
+
+    items = sorted(
+        aggregates.values(),
+        key=lambda entry: (
+            str(entry["name"]).casefold(),
+            str(entry["unit"]).casefold(),
+        ),
+    )
+    for entry in items:
+        if entry["amount"] is not None:
+            entry["amount"] = round(entry["amount"], 2)
+    return {"recipes": recipe_rows, "items": items}
+
+
+def load_recipe(
+    client: ApiClient, reference: str, requested_servings: int | None
+) -> dict[str, Any]:
+    """Lädt ein Rezept per Name, ID oder URL ohne interaktive Auswahl."""
+    kind, value = parse_recipe_reference(reference)
+    if kind == "name":
+        candidates = search_candidates(client, value)
+        if not candidates:
+            raise NoResultsError(
+                f"Kein Rezept zu {value!r} gefunden.",
+                next_step="Nutze einen anderen Namen oder `chefkoch suche ...`.",
+            )
+        if len(candidates) > 1:
+            raise UsageError(
+                f"Der Name {value!r} ist mehrdeutig.",
+                next_step="Nutze eine ID/URL oder die interaktive Auswahl im Terminal.",
+            )
+        recipe_id = str(candidates[0]["id"])
+    else:
+        recipe_id = value
+    payload = client.recipe(recipe_id)
+    return normalize_recipe(payload, requested_servings)

chefkoch_cli/watch.py

@@ -0,0 +1,188 @@
+"""Persistenter Watch-State und Vergleich neuer Treffer."""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from . import service
+from .client import ApiClient
+from .errors import StateError
+
+STATE_VERSION = 1
+
+
+def state_path() -> Path:
+    base = os.environ.get("XDG_STATE_HOME") or os.path.join(
+        os.path.expanduser("~"), ".local", "state"
+    )
+    return Path(base) / "chefkoch-cli" / "watch.json"
+
+
+def _watch_key(
+    query: str,
+    *,
+    vegetarisch: bool,
+    vegan: bool,
+    max_zeit: int | None,
+    min_bewertung: float | None,
+    schwierigkeit: str | None,
+    limit: int,
+) -> str:
+    return json.dumps(
+        {
+            "query": query,
+            "vegetarian": vegetarisch,
+            "vegan": vegan,
+            "maxTime": max_zeit,
+            "minRating": min_bewertung,
+            "difficulty": schwierigkeit,
+            "limit": limit,
+        },
+        ensure_ascii=False,
+        sort_keys=True,
+    )
+
+
+def load_state(path: Path) -> dict[str, Any]:
+    if not path.exists():
+        return {"version": STATE_VERSION, "watches": {}}
+    try:
+        raw = path.read_text(encoding="utf-8")
+    except OSError as exc:
+        raise StateError(
+            f"Watch-State konnte nicht gelesen werden: {exc}.",
+            next_step=f"Prüfe die Rechte von {path}.",
+        ) from None
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError:
+        raise StateError(
+            f"Watch-State ist beschädigt: {path}.",
+            next_step="Lösche die Datei oder repariere das JSON und versuche es erneut.",
+        ) from None
+    if not isinstance(data, dict) or not isinstance(data.get("watches"), dict):
+        raise StateError(
+            f"Watch-State hat ein unbekanntes Format: {path}.",
+            next_step="Lösche die Datei und versuche es erneut.",
+        )
+    return data
+
+
+def save_state(path: Path, state: dict[str, Any]) -> None:
+    directory = path.parent
+    try:
+        directory.mkdir(parents=True, exist_ok=True, mode=0o700)
+        os.chmod(directory, 0o700)
+    except OSError as exc:
+        raise StateError(
+            f"Watch-State-Verzeichnis konnte nicht angelegt werden: {exc}.",
+            next_step=f"Prüfe die Rechte von {directory}.",
+        ) from None
+
+    handle = None
+    temp_path = None
+    try:
+        handle, temp_name = tempfile.mkstemp(prefix=".watch-", dir=str(directory))
+        temp_path = Path(temp_name)
+        with os.fdopen(handle, "w", encoding="utf-8") as stream:
+            handle = None
+            json.dump(state, stream, ensure_ascii=False, indent=2)
+            stream.write("\n")
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.chmod(temp_path, 0o600)
+        os.replace(temp_path, path)
+        temp_path = None
+    except OSError as exc:
+        raise StateError(
+            f"Watch-State konnte nicht geschrieben werden: {exc}.",
+            next_step=f"Prüfe die Rechte von {directory}.",
+        ) from None
+    finally:
+        if handle is not None:
+            try:
+                os.close(handle)
+            except OSError:
+                pass
+        if temp_path is not None:
+            try:
+                temp_path.unlink()
+            except OSError:
+                pass
+
+
+def run_watch(
+    client: ApiClient,
+    query: str,
+    *,
+    vegetarisch: bool = False,
+    vegan: bool = False,
+    max_zeit: int | None = None,
+    min_bewertung: float | None = None,
+    schwierigkeit: str | None = None,
+    limit: int = service.DEFAULT_WATCH_LIMIT,
+    path: Path | None = None,
+) -> dict[str, Any]:
+    data = service.search_recipes(
+        client,
+        query,
+        vegetarisch=vegetarisch,
+        vegan=vegan,
+        max_zeit=max_zeit,
+        min_bewertung=min_bewertung,
+        schwierigkeit=schwierigkeit,
+        sort="bewertung",
+        limit=limit,
+        seite=1,
+    )
+    current = list(data.get("results") or [])
+    current_ids = [str(item.get("id")) for item in current]
+
+    target = path or state_path()
+    state = load_state(target)
+    key = _watch_key(
+        data["query"],
+        vegetarisch=vegetarisch,
+        vegan=vegan,
+        max_zeit=max_zeit,
+        min_bewertung=min_bewertung,
+        schwierigkeit=schwierigkeit,
+        limit=limit,
+    )
+    previous = state["watches"].get(key)
+    if previous is None:
+        previous_ids: set[str] = set()
+        changed = True
+    else:
+        previous_ids = {
+            str(item)
+            for item in previous.get("ids", [])
+            if isinstance(item, (str, int))
+        }
+        changed = False
+
+    new_items = [item for item in current if str(item.get("id")) not in previous_ids]
+    if previous is not None and not new_items:
+        changed = False
+    elif previous is not None and new_items:
+        changed = True
+
+    checked_at = datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+    state["version"] = STATE_VERSION
+    state["watches"][key] = {
+        "ids": current_ids,
+        "checkedAt": checked_at,
+    }
+    save_state(target, state)
+
+    return {
+        "query": data["query"],
+        "changed": bool(changed and new_items),
+        "new": new_items,
+        "checkedAt": checked_at,
+    }

chefkoch_cli-0.1.1.dist-info/METADATA

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: chefkoch-cli
+Version: 0.1.1
+Summary: Chefkoch.de-Rezepte im Terminal: Suche, Rezeptdetails, Einkaufsliste und Watch
+Author-email: smlfg <186922365+smlfg@users.noreply.github.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/smlfg/chefkoch-cli
+Project-URL: Repository, https://github.com/smlfg/chefkoch-cli
+Keywords: chefkoch,recipes,cli,terminal
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.24
+Dynamic: license-file
+
+# chefkoch-cli
+
+Chefkoch.de-Rezepte im Terminal: Suche mit Filtern, Rezeptdetails mit auf
+Portionen skalierten Zutaten, Einkaufsliste aus mehreren Rezepten und Watch auf
+neue Rezepte. Ausschließlich lesend, ohne Login.
+
+## Schnellstart
+
+Voraussetzung: Python 3.10+ und `pipx`.
+
+```bash
+pipx install git+https://github.com/smlfg/chefkoch-cli
+chefkoch suche lasagne --limit 5
+chefkoch rezept "vegane lasagne" --portionen 4
+chefkoch einkaufsliste "die ultimative vegane lasagne" "vegetarische spinat gemüse lasagne" --portionen 4
+```
+
+Die Suche nimmt den Begriff positional. `chefkoch rezept` und
+`chefkoch einkaufsliste` akzeptieren Namen, IDs oder Chefkoch-URLs; bei
+mehreren Treffern erscheint im Terminal eine nummerierte Auswahl.
+
+## Befehle und Beispiele
+
+### Suchen
+
+```bash
+chefkoch suche lasagne --limit 5
+chefkoch suche chili --vegetarisch --max-zeit 30 --min-bewertung 4.5
+chefkoch suche suppe --vegan --sort zeit
+chefkoch suche kuchen --sort neu --limit 10 --seite 2
+```
+
+Filter: `--vegetarisch`, `--vegan`, `--max-zeit N`, `--min-bewertung X`,
+`--schwierigkeit simpel|normal|pfiffig`, `--sort bewertung|zeit|neu`,
+`--limit N`, `--seite N`.
+
+### Rezept anzeigen
+
+```bash
+chefkoch rezept "vegane lasagne" --portionen 4
+chefkoch rezept 745721177147257
+chefkoch rezept https://www.chefkoch.de/rezepte/745721177147257/Lasagne.html --portionen 8
+```
+
+Ein Name sucht und zeigt bei mehreren Treffern eine nummerierte Auswahl. Eine
+ID oder URL lädt das Rezept direkt. `--portionen` skaliert die Zutaten.
+
+### Einkaufsliste
+
+```bash
+chefkoch einkaufsliste "die ultimative vegane lasagne" "vegetarische spinat gemüse lasagne" --portionen 4
+```
+
+Mehrere Namen, IDs oder URLs ergeben eine zusammengefasste Liste. Gleiche
+Zutaten mit gleicher Einheit werden summiert, unterschiedliche Einheiten
+bleiben getrennt.
+
+### Watch
+
+```bash
+chefkoch watch "vegane lasagne" --min-bewertung 4.5
+```
+
+Watch merkt sich die zuletzt gesehenen IDs pro Suchbegriff und Filter und zeigt
+beim nächsten Lauf nur neue Treffer.
+
+## Ausgabe und JSON
+
+Im Terminal ist die Ausgabe lesbar (Trefferliste, Rezept, Einkaufsliste). JSON
+erscheint nur mit `--json` oder wenn stdout kein Terminal ist. Im JSON-Modus
+steht genau ein Objekt auf stdout, auch bei Fehlern:
+
+```bash
+chefkoch suche lasagne --limit 5 --json
+chefkoch rezept "vegane lasagne" --json
+```
+
+## Konfiguration
+
+| Variable | Default | Bedeutung |
+|---|---|---|
+| `CHEFKOCH_BASE_URL` | `https://api.chefkoch.de` | API-Basis (Test/Fake-Server) |
+| `CHEFKOCH_MIN_INTERVAL` | `1` | Mindestabstand zwischen Requests in Sekunden; `0` nur für Tests |
+| `XDG_STATE_HOME` | `~/.local/state` | Basis für den Watch-State |
+
+Der Watch-State liegt unter
+`$XDG_STATE_HOME/chefkoch-cli/watch.json` (Fallback
+`~/.local/state/chefkoch-cli/watch.json`) und enthält nur IDs, Suchschlüssel
+und Zeitstempel. Weitere Config-Dateien gibt es nicht.
+
+## Exit-Codes
+
+| Exit | Bedeutung |
+|---|---|
+| 0 | Erfolg, inklusive `--help` und `--version` |
+| 1 | Allgemeiner Fehler (z. B. kaputter Watch-State) |
+| 2 | Usage: fehlende/ungültige Argumente, mehrdeutiger Name ohne TTY |
+| 3 | Netz/Quelle: Timeout, HTTP-Fehler, Rezept-404, keine Treffer |
+| 4 | Login erforderlich (nicht verwendet) bzw. Daten-/Parse-Fehler |
+
+## Datenquelle und Grenzen
+
+`chefkoch` nutzt die inoffizielle API `https://api.chefkoch.de` über
+`GET /v2/recipes` und `GET /v2/recipes/<id>`. Die Website
+`www.chefkoch.de/rezepte/*?*` und `/v2/search/suggestions` werden nicht
+abgerufen. Das Tool sendet keine Cookies, speichert keine Zugangsdaten und
+führt keine schreibenden Web-Aktionen aus.
+
+Die API ist nicht offiziell dokumentiert und kann sich jederzeit ändern.
+Details und Befehlsvertrag stehen in `ANFORDERUNGEN.md`, `INTERFACE.md` und
+`docs/UX.md`.
+
+## Lizenz
+
+MIT, Copyright smlfg. Siehe `LICENSE`.

chefkoch_cli-0.1.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+chefkoch_cli/__init__.py,sha256=FDmOf5BkpFBnN9MjsK3h81We20yUK0q56HC7rUpuLpI,89
+chefkoch_cli/__main__.py,sha256=XbauCIYrA6-e--k62SiZF9OlIottxtHf5BNNAdvHVq8,164
+chefkoch_cli/cli.py,sha256=tIedQmABNe4Ad6ouy0vALFrIKH5G4jevdTCs9MFFB04,13350
+chefkoch_cli/client.py,sha256=Gi_6RSWu6iBztCD85KMWNw7WLRGeb9xa5717e2cXHIY,6869
+chefkoch_cli/errors.py,sha256=3JHCcwhUyMWeGm-4pg1EXXAZhIlct3k73E7-96TlTAw,1185
+chefkoch_cli/formatting.py,sha256=MSmrRd069B6wxhu2cNfcEsJOMFWZK5whmc3zSyrFF_U,4109
+chefkoch_cli/parsing.py,sha256=de_PqaAsggTZjzVwe-7cYeR33VdzX7PbncWJwGHl35c,6820
+chefkoch_cli/service.py,sha256=-1vEWPGGL89VmgzCyjmtF-ScyXwvB162594tpLwhSOU,11338
+chefkoch_cli/watch.py,sha256=nyg03o3I2XVD9T9AVi31O7E0MYBp1aP0Kb32z_rZKXI,5332
+chefkoch_cli-0.1.1.dist-info/licenses/LICENSE,sha256=PgaoXcbUpXfpF2HoZaVO_1YL1NL_swFlxDUrvrO5dgk,1062
+chefkoch_cli-0.1.1.dist-info/METADATA,sha256=_LJpEFRu2k0W3FCl74nq91XR5fL5-vDwa8cX-Otn2wI,4616
+chefkoch_cli-0.1.1.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+chefkoch_cli-0.1.1.dist-info/entry_points.txt,sha256=1kJRU6ayeD0Izau_ZiaIzOY956-VN9zKCh6lmtKkiOU,51
+chefkoch_cli-0.1.1.dist-info/top_level.txt,sha256=oPqi9JlEK4DvRwTllcbQt_g1PEBtoa3rFJSCBODcAfs,13
+chefkoch_cli-0.1.1.dist-info/RECORD,,

chefkoch_cli-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+