# SPDX-License-Identifier: MIT # Copyright (c) 2026 Florian Hubert, Emivita # # Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated # documentation files (the "Software"), to deal in the Software without restriction, including without limitation the # rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit # persons to whom the Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in all copies or substantial portions of the # Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. # # Nur dieses Skript steht unter der MIT-Lizenz. Die Daten, die es erzeugt, behalten die Lizenz ihrer Quelle # (Open Food Facts: ODbL 1.0, einzelne Inhalte DbCL 1.0; BLS: CC BY 4.0). # Only this script is MIT-licensed. The data it produces keeps the license of its source. """Gemeinsames Ausgabeformat der Lebensmittel-Datenbank für die Emivita-App (Stufe 2 von „Essen und Trinken“). Die drei Skripte lebensmittel_bls.py, lebensmittel_off.py und lebensmittel_testdaten.py lesen je eine Quelle und schreiben mit diesem Modul dieselbe Dateistruktur. Die App (app_client/src/lebensmitteldb.js) liest sie ohne Datenbank-Bibliothek und ohne jede Netzabfrage: reine JSON-Dateien, die mit der App ausgeliefert werden (DSB ERNAEHRUNG N4: keine Abfrage bei Dritten, auch nicht im Hintergrund). This module is part of the Emivita food-database build scripts. It contains no network code and reads only the files it is given. Dateistruktur (Ordner `lebensmittel/`) manifest.json welche Quellen es gibt, Stand, Anzahl, Lizenz, welche Dateien vorhanden sind bls.json Quellen ohne Strichcode (BLS): eine Datei mit allen Einträgen. Die App lädt sie einmal beim ersten Suchen aus dem Paket und sucht dann im Speicher: Es wird nichts je Suchbegriff nachgeladen. off-b-.json Quellen mit Strichcode (Open Food Facts): ein Strichcode lädt genau eine dieser Dateien aus dem Paket; sind die zwei Ziffern vor der Prüfziffer, so bleibt jede Datei klein (bei 250.000 Produkten rund 150 KB), und die App hält nie die ganze Datenbank im Speicher. Ohne Suchdateien wird in Open Food Facts nicht gesucht (Datenschutzberatung 9.1: Open Food Facts dient nur für Strichcodes). off-s-.json Suchdateien (ab 1.5, nur wenn das Skript der Quelle sie schreibt, bei Open Food Facts mit `--namenssuche`): die Produkte für die Suche nach dem Namen, nach Name sortiert und in Teile von SUCH_TEIL Einträgen geschnitten. Die App liest sie beim ersten Suchen einmal als Ganzes aus dem Paket und sucht dann im Speicher; je Suchbegriff wird nichts nachgeladen, und kein Suchbegriff verlässt das Gerät (N4). Fehlen sie, gibt es die Namenssuche nicht. Jede Datei ist ein JSON-Objekt mit dem Lizenzhinweis der Quelle in der Datei selbst (ODbL 4.2: der Hinweis steht in der Datei, nicht nur daneben) und der Liste `eintraege`: {"quelle": "off", "lizenz": "", "stand": "JJJJ-MM-TT", "hinweis": "…", "erfunden": false, "eintraege": [...]} Ein Eintrag ist ein JSON-Array. Alle Nährwerte gelten je 100 g (einheit 0) oder je 100 ml (einheit 1). Quelle ohne Strichcode: [name, einheit, kcal, eiweiss, fett, kh, portion] Quelle mit Strichcode: [strichcode, name, einheit, kcal, eiweiss, fett, kh, portion] Suchdatei: [name, einheit, kcal, eiweiss, fett, kh, portion] und, nur wenn das Manifest `suche_marke` nennt, als achter Wert die Marke als Text (leer, wenn sie schon im Namen steht). Kein Strichcode: Die Suchdateien verweisen nicht auf die Strichcode-Dateien. `portion` ist die Portionsgröße in g bzw. ml, 0 = unbekannt. Der Strichcode steht nur zum Nachschlagen in der Datei; die App nimmt ihn nie in einen Eintrag auf (DSB N2). Art des Lebensmittels (2.1, deploy/KONZEPT-EINHEITEN.md): Nennt das Skript einer Quelle ohne Strichcode die Art je Eintrag (BLS: aus der Hauptgruppe des BLS-Codes), steht in der Datei zusätzlich `"arten": "gbou…"`, ein Buchstabe je Eintrag in derselben Reihenfolge wie `eintraege` (Buchstaben: ARTEN unten) und im Manifest `"arten": true`. Die App wählt danach die Einheiten (Tasse, Scheibe …, einheitenarten.js). Fehlt die Liste, gilt für die Auswahl die Namensregel von 1.5; es bricht nichts. Jede Quelle hat ihre eigenen Dateien (`bls…`, `off-…`) und wird nie mit einer anderen zusammengeführt: Eine gemeinsame Tabelle stünde ganz unter der ODbL (Rechtsprüfung 7g Nr. 10, ODbL 4.5a; DSB 9.1 Nr. 3). Nicht in der Ausgabe, nie (DSB N2, N5, MDR 7g Nr. 10): Bild, Ersteller, Bearbeiter, Mitwirkende, weitere Nährstoffe, Zutaten, Allergene, Nutri-Score. Die Skripte lesen nur die Felder, die unten ausdrücklich genannt sind (Positivliste), und kopieren nichts anderes. Die Marke steht nie in den Strichcode-Dateien. In den Suchdateien steht sie nur, wenn das Skript der Quelle ausdrücklich so gestartet wird (Open Food Facts: `--namenssuche-marke`), und nur als Text zur Anzeige in der Trefferliste; die App übernimmt sie nie in einen Eintrag. Die Auflage N5 der Datenschutzberatung nennt Marken unter dem, was aus dem Auszug entfernt wird; ein Auszug mit Marke braucht deshalb vor einem Release ihre Freigabe (lebensmittel_pruefen.py --release verlangt dafür `--marke-freigegeben`). Die Normalisierung (`normalisieren`) und die Schlüsselbildung stehen genauso in lebensmitteldb.js; tests/test_lebensmittel_daten.py prüft beide Seiten gegeneinander. """ from __future__ import annotations import json import re import unicodedata from datetime import date from pathlib import Path FORMAT = 1 EINHEIT_G = 0 EINHEIT_ML = 1 NAME_MAX = 140 # Länge der Namen in den Daten (der BLS hat Namen bis 132 Zeichen, damit gleich lautende Anfänge unterscheidbar # bleiben); im Eintrag speichert die App höchstens essen.LEBENSMITTEL_MAX = 80 und kürzt dazu am Wortende KCAL_MAX = 1000 # je 100 g; reines Fett hat 900 NAEHRSTOFF_MAX = 100.0 # je 100 g SUMME_MAX = 100.5 # Eiweiß + Fett + Kohlenhydrate je 100 g, mit Rundungsspielraum PORTION_MAX = 2000 SUCH_TEIL = 20_000 # Einträge je Suchdatei (rund 1 MB): Die App liest die Teile nacheinander und bleibt dazwischen bedienbar MARKE_MAX = 40 # Länge der Marke in einer Suchdatei # Mikronährstoffe (Release 1.5, Inhaberentscheidung 14.10.2026; nur mit `--mikro` im Skript der Quelle): je 100 g bzw. 100 ml # in der Maßeinheit aus mikronaehrstoffe.MIKRO (Jod, Selen, Vitamin D, Vitamin B12 in µg; Eisen und Zink in mg). Fehlt ein # Wert in der Quelle, steht null: Nichts wird geschätzt oder aufgefüllt. Mit `--mikro` trägt der Manifest-Eintrag der Quelle # `"mikro": [Schlüssel]`, und jeder Eintrag hat als LETZTEN Wert eine Liste in dieser Reihenfolge (oder null, wenn die Quelle # für das Lebensmittel keinen der Werte nennt). Kein anderer Wert eines Eintrags ist eine Liste. MIKRO_SCHLUESSEL = ("jod", "selen", "eisen", "zink", "vitamin_d", "vitamin_b12") MIKRO_MAX_100 = 100000.0 _KEIN_ZEICHEN = re.compile(r"[^a-z0-9]+") # ── Normalisierung (identisch in lebensmitteldb.js) ────────────────────────── def normalisieren(text: str) -> str: """Kleinschreibung, Umlaute und Akzente weg, ß = ss, „ae/oe/ue“ = „a/o/u“: „Käse“, „Kase“ und „Kaese“ ergeben dasselbe. Übrig bleiben a–z, 0–9 und alles andere als Trenner.""" s = str(text or "").lower().replace("ß", "ss") s = "".join(c for c in unicodedata.normalize("NFD", s) if not 0x300 <= ord(c) <= 0x36F) return s.replace("ae", "a").replace("oe", "o").replace("ue", "u") def woerter(text: str) -> "list[str]": """Die normalisierten Wörter eines Textes (nur a–z und 0–9), ohne leere.""" return [w for w in _KEIN_ZEICHEN.split(normalisieren(text)) if w] def strichcode_normalisieren(code) -> "str | None": """Nur Ziffern; UPC-A (12) wird EAN-13 mit führender 0; GTIN-14 mit führender 0 wird EAN-13. Erlaubt sind 8 oder 13 Stellen, sonst None.""" z = re.sub(r"\D", "", str(code or "")) if len(z) == 12: z = "0" + z if len(z) == 14 and z.startswith("0"): z = z[1:] return z if len(z) in (8, 13) else None def gtin_gueltig(code: str) -> bool: """Prüfziffer nach GS1 (EAN-8, EAN-13).""" if not code or not code.isdigit() or len(code) not in (8, 13): return False summe = 0 for i, ziffer in enumerate(reversed(code[:-1])): summe += int(ziffer) * (3 if i % 2 == 0 else 1) return (10 - summe % 10) % 10 == int(code[-1]) def strichcode_schluessel(code: str) -> str: """Name der Strichcode-Schale: die zwei Ziffern vor der Prüfziffer (gleichmäßig verteilt, ohne die ersten Ziffern, die das Land und die Firma tragen).""" return code[-3:-1] # ── Prüfen und Runden ──────────────────────────────────────────────────────── def zahl_oder_none(wert) -> "float | None": """Dezimalzahl aus Zahl oder Text (Komma oder Punkt); sonst None. Nicht endliche Werte sind None.""" if wert is None or isinstance(wert, bool): return None if isinstance(wert, str): t = wert.strip().replace(",", ".") if not re.fullmatch(r"-?\d+(\.\d+)?", t): return None wert = float(t) try: z = float(wert) except (TypeError, ValueError): return None return z if z == z and abs(z) != float("inf") else None def _rund(z: float, stellen: int): r = round(z, stellen) return int(r) if stellen == 0 or r == int(r) else r def name_bereinigen(name) -> str: """Leerzeichen zusammengezogen, Steuerzeichen weg, auf NAME_MAX gekürzt (am Wortende).""" s = re.sub(r"[\x00-\x1f\x7f]", " ", str(name or "")) s = re.sub(r"\s+", " ", s).strip(" \t-–—,;:|/") if len(s) > NAME_MAX: s = s[:NAME_MAX].rsplit(" ", 1)[0] if " " in s[:NAME_MAX] else s[:NAME_MAX] return s.strip(" -–—,;:|/") def marke_bereinigen(marke) -> str: """Die Marke als kurzer Text: wie ein Name bereinigt, höchstens MARKE_MAX Zeichen (am Wortende gekürzt).""" s = name_bereinigen(marke) if len(s) > MARKE_MAX: s = s[:MARKE_MAX].rsplit(" ", 1)[0] if " " in s[:MARKE_MAX] else s[:MARKE_MAX] return s.strip(" -–—,;:|/") def eintrag_pruefen(name, einheit, kcal, eiweiss, fett, kh, portion=0): """(bereinigter Eintrag als Liste, None) oder (None, Grund). Alle vier Nährwerte sind Pflicht.""" name = name_bereinigen(name) if len(name) < 2 or not woerter(name): return None, "name" if einheit not in (EINHEIT_G, EINHEIT_ML): return None, "einheit" werte = [zahl_oder_none(w) for w in (kcal, eiweiss, fett, kh)] if any(w is None for w in werte): return None, "wert_fehlt" kc, ei, fe, ch = werte if not (0 <= kc <= KCAL_MAX and all(0 <= w <= NAEHRSTOFF_MAX for w in (ei, fe, ch))): return None, "wert_ausser_bereich" if ei + fe + ch > SUMME_MAX: return None, "summe_ueber_100" p = zahl_oder_none(portion) or 0 p = int(round(p)) if 0 < p <= PORTION_MAX else 0 return [name, einheit, _rund(kc, 0), _rund(ei, 1), _rund(fe, 1), _rund(ch, 1), p], None def mikro_pruefen(werte) -> "list | None": """Sechs Werte je 100 g (Reihenfolge MIKRO_SCHLUESSEL) → Liste mit Zahlen (zwei Nachkommastellen) oder null je Wert; None, wenn keiner da ist. Negative, nicht endliche oder zu große Werte gelten als „keine Angabe“ (null), nicht als 0.""" if not werte: return None aus = [] for w in list(werte)[:len(MIKRO_SCHLUESSEL)]: z = zahl_oder_none(w) aus.append(_rund(z, 2) if z is not None and 0 <= z <= MIKRO_MAX_100 else None) aus += [None] * (len(MIKRO_SCHLUESSEL) - len(aus)) return aus if any(w is not None for w in aus) else None # ── Sammeln und Schreiben ──────────────────────────────────────────────────── # Art des Lebensmittels (einheitenarten.js hat dieselben Buchstaben; tests/test_einheiten_arten.py prüft beide Seiten). ARTEN = {"g": "getraenk", "b": "brot", "o": "obst_gemuese", "a": "aufstrich", "w": "aufschnitt", "s": "stueckware", "k": "beilage", "u": "unbekannt"} class Sammlung: """Die Einträge einer Quelle, noch nicht auf Schalen verteilt.""" def __init__(self, quelle_id: str, mit_strichcode: bool = False, mit_mikro: bool = False): if not re.fullmatch(r"[a-z]{2,8}", quelle_id): raise ValueError("Die Kennung der Quelle besteht aus 2 bis 8 Kleinbuchstaben.") self.id = quelle_id self.mit_strichcode = mit_strichcode # Release 1.5: Mikronährstoffe als letzter Wert jedes Eintrags (nur mit `--mikro`). self.mit_mikro = mit_mikro self.eintraege: "list[list]" = [] self.arten: "list[str]" = [] # ein Buchstabe aus ARTEN je Eintrag (2.1), gleiche Reihenfolge wie eintraege self.mit_arten = False # wird wahr, sobald ein Eintrag eine Art nennt self.codes: "dict[str, int]" = {} # Strichcode → Index in eintraege self.verworfen: "dict[str, int]" = {} self.suche: "list[list]" = [] # Namenssuche: [name, einheit, kcal, eiweiss, fett, kh, portion, marke] def verwerfen(self, grund: str) -> None: self.verworfen[grund] = self.verworfen.get(grund, 0) + 1 def hinzu(self, name, einheit, kcal, eiweiss, fett, kh, portion=0, strichcode=None, mikro=None, art=None) -> bool: """Nimmt einen Eintrag auf, wenn er stimmt. Zu einem Strichcode gilt der erste Eintrag. `mikro`: sechs Werte je 100 g (nur mit `mit_mikro`), fehlende als None. `art`: ein Buchstabe aus ARTEN (2.1) oder None (= unbekannt).""" if art is not None and art not in ARTEN: raise ValueError(f"Unbekannte Art {art!r}: erlaubt sind {', '.join(ARTEN)}.") eintrag, grund = eintrag_pruefen(name, einheit, kcal, eiweiss, fett, kh, portion) if eintrag is None: self.verwerfen(grund) return False if self.mit_mikro: eintrag.append(mikro_pruefen(mikro)) if self.mit_strichcode: code = strichcode_normalisieren(strichcode) if not code or not gtin_gueltig(code): self.verwerfen("strichcode") return False if code in self.codes: self.verwerfen("doppelter_strichcode") return False self.codes[code] = len(self.eintraege) self.eintraege.append(eintrag) self.arten.append(art or "u") if art is not None: self.mit_arten = True return True def suche_hinzu(self, name, einheit, kcal, eiweiss, fett, kh, portion=0, marke="", mikro=None) -> bool: """Nimmt ein Produkt in die Namenssuche auf, wenn es stimmt (dieselbe Prüfung wie `hinzu`). `marke`: Text zur Anzeige in der Trefferliste oder leer. `mikro` wie bei `hinzu`.""" eintrag, _ = eintrag_pruefen(name, einheit, kcal, eiweiss, fett, kh, portion) if eintrag is None: return False self.suche.append(eintrag + [marke_bereinigen(marke)] + ([mikro_pruefen(mikro)] if self.mit_mikro else [])) return True def such_eintraege(self, mit_marke: bool = False) -> "list[list]": """Die Einträge der Namenssuche, nach Name sortiert. Je Name (mit `mit_marke`: je Name und Marke) und Einheit steht ein Eintrag da: Dasselbe Produkt kommt in Open Food Facts oft mehrfach vor (mehrere Packungsgrößen, doppelt angelegt), und ohne Strichcode ließen sich die Zeilen in der Trefferliste nicht unterscheiden. Es bleibt die Schreibweise, die am häufigsten vorkommt, und die Angabe, die am häufigsten vorkommt; kommen mehrere Angaben gleich oft vor, die mittlere davon (nach Energie geordnet). Zwei Läufe mit denselben Daten ergeben dasselbe. Das ist keine Auswahl nach Marke oder Hersteller und keine Rangfolge. Ohne `mit_marke` fällt der achte Wert weg.""" gruppen: "dict[tuple, dict[tuple, int]]" = {} schreibweisen: "dict[tuple, dict[tuple, int]]" = {} for name, einheit, kcal, eiweiss, fett, kh, portion, marke, *rest in self.suche: marke = marke if mit_marke else "" k = (" ".join(woerter(name)), " ".join(woerter(marke)), einheit) # Mit Mikronährstoffen (Release 1.5) gehören sie zur Angabe; als Tupel, damit sie sich zählen lassen. mikro = tuple(rest[0]) if rest and rest[0] else None werte = (kcal, eiweiss, fett, kh, portion) + ((mikro,) if self.mit_mikro else ()) zaehlung = gruppen.setdefault(k, {}) zaehlung[werte] = zaehlung.get(werte, 0) + 1 formen = schreibweisen.setdefault(k, {}) formen[(name, marke)] = formen.get((name, marke), 0) + 1 aus = [] for k, zaehlung in gruppen.items(): meiste = max(zaehlung.values()) haeufigste = sorted((w for w, n in zaehlung.items() if n == meiste), key=lambda w: (w[:5], repr(w[5:]))) werte = haeufigste[(len(haeufigste) - 1) // 2] formen = schreibweisen[k] name, marke = min(formen, key=lambda f: (-formen[f], f)) mikro = [list(werte[5]) if werte[5] else None] if self.mit_mikro else [] aus.append([name, k[2], *werte[:5]] + ([marke] if mit_marke else []) + mikro) aus.sort(key=lambda e: (normalisieren(e[0]), e[0], e[7] if mit_marke else "", e[1:7])) # nie nach den Mikronährstoffen return aus def strichcode_schalen(self) -> "dict[str, list]": """Die Einträge mit Strichcode nach Schale (zwei Ziffern vor der Prüfziffer), jede nach Strichcode sortiert, damit zwei Läufe mit denselben Daten dieselben Dateien ergeben.""" strich: "dict[str, list]" = {} for code, i in self.codes.items(): strich.setdefault(strichcode_schluessel(code), []).append([code, *self.eintraege[i]]) for liste in strich.values(): liste.sort(key=lambda z: z[0]) return strich def sortiert(self) -> "list[list]": """Alle Einträge einer Quelle ohne Strichcode, nach Name sortiert.""" return sorted(self.eintraege, key=lambda e: (e[0].lower(), e[0], e[2:7])) def sortiert_mit_arten(self) -> "tuple[list[list], str]": """Wie `sortiert`, dazu die Arten als Zeichenkette in derselben Reihenfolge (ein Buchstabe je Eintrag).""" reihe = sorted(range(len(self.eintraege)), key=lambda i: (self.eintraege[i][0].lower(), self.eintraege[i][0], self.eintraege[i][2:7])) return [self.eintraege[i] for i in reihe], "".join(self.arten[i] for i in reihe) def _json(daten) -> str: return json.dumps(daten, ensure_ascii=False, separators=(",", ":")) + "\n" def manifest_lesen(ordner: Path) -> dict: pfad = Path(ordner) / "manifest.json" if pfad.exists(): try: m = json.loads(pfad.read_text(encoding="utf-8")) if isinstance(m, dict) and isinstance(m.get("quellen"), list): return m except ValueError: pass return {"format": FORMAT, "quellen": []} def schreiben(sammlung: Sammlung, ordner, *, name: str, herkunft: str, stand: str, lizenz: str, lizenz_url: str = "", erfunden: bool = False, hinweis: str = "", zitat: str = "", aenderung: str = "", beschreibung: "dict | None" = None, suche_mit_marke: bool = False) -> dict: """Schreibt die Schalen der Quelle und trägt sie ins Manifest ein (andere Quellen bleiben stehen). Alte Schalen derselben Quelle werden vorher entfernt. Gibt den Manifest-Eintrag zurück. `lizenz`: Name der Lizenz, `lizenz_url`: Link darauf, `zitat`: Zitierweise der Quelle, `aenderung`: der Hinweis, was an den Daten geändert wurde (CC BY 4.0, 3a1B).""" if not re.fullmatch(r"\d{4}-\d{2}-\d{2}", stand or ""): raise ValueError("Der Stand der Daten gehört als JJJJ-MM-TT dazu (Datum der Ausgangsdatei).") date.fromisoformat(stand) ordner = Path(ordner) ordner.mkdir(parents=True, exist_ok=True) for alt in (list(ordner.glob(f"{sammlung.id}-b-*.json")) + list(ordner.glob(f"{sammlung.id}-s-*.json")) + [ordner / f"{sammlung.id}.json"]): if alt.exists(): alt.unlink() kopf = {"quelle": sammlung.id, "lizenz": lizenz_url or lizenz, "stand": stand, "hinweis": hinweis or herkunft, "erfunden": bool(erfunden)} gesamt = 0 datei = "" strichcodes: "list[str]" = [] if sammlung.mit_strichcode: for k, liste in sammlung.strichcode_schalen().items(): text = _json({**kopf, "eintraege": liste}) (ordner / f"{sammlung.id}-b-{k}.json").write_text(text, encoding="utf-8") gesamt += len(text.encode("utf-8")) strichcodes.append(k) else: datei = f"{sammlung.id}.json" if sammlung.mit_arten: liste, arten = sammlung.sortiert_mit_arten() text = _json({**kopf, "arten": arten, "eintraege": liste}) else: text = _json({**kopf, "eintraege": sammlung.sortiert()}) (ordner / datei).write_text(text, encoding="utf-8") gesamt += len(text.encode("utf-8")) # Suchdateien der Namenssuche: dieselbe Quelle, eigener Dateiname, derselbe Lizenzkopf in jeder Datei (ODbL 4.2) such_teile: "list[str]" = [] such_liste = sammlung.such_eintraege(suche_mit_marke) if sammlung.suche else [] for nr, anfang in enumerate(range(0, len(such_liste), SUCH_TEIL)): k = f"{nr:02d}" text = _json({**kopf, "eintraege": such_liste[anfang:anfang + SUCH_TEIL]}) (ordner / f"{sammlung.id}-s-{k}.json").write_text(text, encoding="utf-8") gesamt += len(text.encode("utf-8")) such_teile.append(k) eintrag = { "id": sammlung.id, "name": name, "herkunft": herkunft, "stand": stand, "lizenz": lizenz, "lizenz_url": lizenz_url, "zitat": zitat, "aenderung": aenderung, "hinweis": hinweis, "anzahl": len(sammlung.eintraege), "erfunden": bool(erfunden), "strichcode": bool(sammlung.mit_strichcode), "datei": datei, "strichcodes": sorted(strichcodes), "bytes": gesamt, "verworfen": dict(sorted(sammlung.verworfen.items())), } if sammlung.mit_mikro: eintrag["mikro"] = list(MIKRO_SCHLUESSEL) if sammlung.mit_arten and not sammlung.mit_strichcode: eintrag["arten"] = True if such_teile: eintrag["suche"] = such_teile eintrag["suche_anzahl"] = len(such_liste) eintrag["suche_marke"] = bool(suche_mit_marke) if beschreibung: eintrag["beschreibung"] = beschreibung m = manifest_lesen(ordner) m["format"] = FORMAT m["quellen"] = [q for q in m["quellen"] if q.get("id") != sammlung.id] + [eintrag] m["quellen"].sort(key=lambda q: q["id"]) (ordner / "manifest.json").write_text(json.dumps(m, ensure_ascii=False, indent=1) + "\n", encoding="utf-8") return eintrag def zusammenfassung(eintrag: dict) -> str: """Eine Zeile für die Konsole: Anzahl, Dateien, Größe.""" mb = eintrag["bytes"] / 1_048_576 teile = [f"{eintrag['anzahl']} Einträge"] teile.append(f"{len(eintrag['strichcodes'])} Strichcode-Dateien" if eintrag["strichcode"] else f"Datei {eintrag['datei']}") if eintrag.get("suche"): teile.append(f"{eintrag['suche_anzahl']} Einträge in {len(eintrag['suche'])} Suchdateien" + (" mit Marke" if eintrag.get("suche_marke") else "")) teile.append(f"{mb:.1f} MB unkomprimiert") if eintrag["verworfen"]: teile.append("verworfen: " + ", ".join(f"{k} {v}" for k, v in eintrag["verworfen"].items())) return ", ".join(teile)