#!/usr/bin/env python3 # 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. """Open Food Facts (Datenauszug) → Lebensmittel-Datenbank für die Emivita-App. Open Food Facts data dump → food database for the Emivita app. python3 scripts/lebensmittel_off.py openfoodfacts-products.jsonl.gz --stand 2026-10-01 python3 scripts/lebensmittel_off.py en.openfoodfacts.org.products.csv.gz --stand 2026-10-01 --laender de,at Liest den vollständigen Auszug von Open Food Facts (JSONL oder CSV, auch gzip), die Datei, die du selbst von den Download-Seiten von Open Food Facts geladen hast. Das Skript fragt nie die Live-Schnittstelle von Open Food Facts ab und baut keine Netzverbindung auf: Eine Abfrage würde dort die IP-Adresse und den gescannten Strichcode preisgeben (deploy/ERNAEHRUNG-DSB.md 8.4 c). Was geschieht: 1. Nur Produkte, die in Deutschland, Österreich oder der Schweiz verkauft werden (`--laender`). 2. Nur Produkte mit allen vier Nährwerten je 100 g: Energie (kcal), Eiweiß, Fett, Kohlenhydrate. Fehlt kcal, aber kJ ist da, wird umgerechnet. Werte außerhalb des Möglichen (mehr als 100 g, Summe über 100 g, Energie weit weg von dem, was die Nährstoffe ergeben) fallen weg. 3. Nur gültige Strichcodes (EAN-8 und EAN-13 mit richtiger Prüfziffer), ein Eintrag je Strichcode. 4. Die Marke steht standardmäßig nicht im Namen: Die Marken des Produkts (Feld `brands`) werden nur dazu gelesen, sie aus dem Namen zu entfernen. Die Marke selbst wird nie ausgegeben. Die Rechtsprüfung (7g Nr. 10) und die Datenschutzberatung (9.2 N2) erlauben Markennamen als Produktbezeichnung im Namen; weil die App den Namen unverändert in den Eintrag übernimmt und ein eigenes Feld für die Marke nie entsteht, ist der Name ohne Marke die sparsamere Form. Mit `--marken-behalten` bleibt der Name, wie ihn Open Food Facts führt. 5. Ausgegeben werden nur: Strichcode (nur zum Nachschlagen), Name, Einheit (g oder ml), vier Werte, Portionsgröße. Die Dateien sind nach Strichcode in je rund 100 Dateien geteilt; ohne `--namenssuche` wird in Open Food Facts in der App nicht gesucht, nur ein Strichcode wird nachgeschlagen (Datenschutzberatung 9.1). Gelesen wird nur das, was unter FELDER_JSONL und FELDER_CSV steht (Positivliste). Alles andere im Auszug, vor allem die Felder zu Mitwirkenden (`creator`, `editors`, `editors_tags`, `last_editor`, `last_modified_by`, `contributors`, `photographers`, `informers`, `checkers`, `correctors`) und alle Bilder (`images`, `image_*_url`), wird nie in den Speicher übernommen. Die Ausgabe enthält danach keine personenbezogenen Angaben (Datenschutzberatung N5). 6. Der Stand der Ausgangsdaten (`--stand`, Pflicht) steht im Manifest und in OFF-LIZENZ.txt. 7. Mit `--namenssuche` (ab 1.5) entstehen zusätzlich die Suchdateien off-s-NN.json für die Suche nach dem Produktnamen in der App. Darin steht der Name so, wie Open Food Facts ihn führt (also mit einer Marke, wenn sie dort zum Namen gehört: nur so findet man ein Produkt unter dem Namen, der auf der Packung steht; Rechtsprüfung 7g Nr. 10 und Datenschutzberatung N2 erlauben Markennamen als Teil des Namens), dazu Einheit, die vier Werte und die Portionsgröße. Kein Strichcode. Gleiche Namen stehen einmal da (siehe lebensmittel_format.py, `such_eintraege`). Die Strichcode-Dateien bleiben dabei unverändert. Mit `--namenssuche-marke` steht in den Suchdateien zusätzlich die Marke als Text (Feld `brands`, höchstens zwei Marken, nur soweit sie nicht schon im Namen stehen), damit sich gleich lautende Produkte in der Trefferliste unterscheiden lassen. Die App zeigt sie nur an und ü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 geht deshalb erst nach ihrer Freigabe in einen Release (lebensmittel_pruefen.py --release hält ihn sonst an). Lizenz / License Die Daten von Open Food Facts stehen unter der Open Database License (ODbL) 1.0, die einzelnen Inhalte unter der Database Contents License 1.0. Die hier erzeugte Datenbank ist eine abgeleitete Datenbank im Sinne der ODbL: Sie wird unter der ODbL angeboten und nennt die Quelle („Contains information from Open Food Facts, which is made available here under the Open Database License (ODbL)“). Dieses Skript ist das Filterverfahren, das die ODbL (4.6) als Alternative zur Weitergabe der Datei nennt; zusammen mit dem Stand der Ausgangsdaten lässt sich der Auszug damit nachbauen. Wer den Auszug in der App ausliefert, bietet ihn zusätzlich kostenlos und maschinenlesbar zum Download an (Rechtsprüfung 7g Nr. 10; Seite und Link: Emivita, nicht Teil dieses Skripts). The data of Open Food Facts is available under the Open Database License (ODbL) 1.0; the individual contents under the Database Contents License 1.0. The database produced by this script is a derived database and is offered under the ODbL with attribution. This script is the filtering procedure described in ODbL 4.6. Voraussetzungen / requirements: Python 3.9+, nur die Standardbibliothek. """ from __future__ import annotations import argparse import csv import gzip import html import io import json import re import sys from pathlib import Path # angehängt, nicht vorangestellt: Ein Name aus scripts/ (etwa auskunft.py) darf kein gleichnamiges Modul der App verdecken, # wenn ein Test diese Skripte importiert. if str(Path(__file__).resolve().parent) not in sys.path: sys.path.append(str(Path(__file__).resolve().parent)) import lebensmittel_format as fmt # noqa: E402 QUELLE_NAME = "Open Food Facts" QUELLE_HERKUNFT = "Open Food Facts" # Lizenzhinweise nach der Rechtsprüfung 7g Nr. 10 (Nachtrag 07.10.2026): ODbL 1.0 für die Datenbank, # DbCL 1.0 für die einzelnen Inhalte; der Hinweis steht in jeder Schale, im Manifest und in OFF-LIZENZ.txt. LIZENZ_TEXT = "Open Database License (ODbL) 1.0" LIZENZ_URL = "https://opendatacommons.org/licenses/odbl/1-0/" DBCL_URL = "https://opendatacommons.org/licenses/dbcl/1-0/" QUELLE_URL = "https://openfoodfacts.org" HINWEIS = ("Enthält Informationen aus Open Food Facts, die hier unter der Open Database License (ODbL) " "verfügbar sind. Einzelne Inhalte stehen unter der Database Contents License (DbCL).") ATTRIBUTION_EN = ("Contains information from Open Food Facts, which is made available here under the " "Open Database License (ODbL). Individual contents are available under the Database " "Contents License (DbCL).") LINKS = f"{QUELLE_URL} (Open Food Facts), {LIZENZ_URL} (ODbL), {DBCL_URL} (DbCL)" LAENDER = {"de": "en:germany", "at": "en:austria", "ch": "en:switzerland"} # Positivliste: nur diese Felder werden aus dem Auszug gelesen. FELDER_JSONL = ("code", "product_name_de", "product_name", "generic_name_de", "generic_name", "brands", "countries_tags", "serving_size", "serving_quantity", "quantity", "nutriments") NAEHRWERT_SCHLUESSEL = ("energy-kcal_100g", "energy_100g", "proteins_100g", "fat_100g", "carbohydrates_100g") FELDER_CSV = ("code", "product_name", "generic_name", "brands", "countries_tags", "serving_size", "serving_quantity", "quantity", "energy-kcal_100g", "energy_100g", "proteins_100g", "fat_100g", "carbohydrates_100g") # Nur mit --mikro (Release 1.5) gelesen, dazu: iodine_100g, selenium_100g, iron_100g, zinc_100g, vitamin-d_100g, # vitamin-b12_100g (MIKRO_FELDER unten). Ohne --mikro kommen sie nie in die Ausgabe. # Mikronährstoffe (Release 1.5, nur mit --mikro; Inhaberentscheidung Florian 14.10.2026, MDR 7g Nr. 14): Open Food Facts führt # sie in Gramm je 100 g. Umgerechnet in die Maßeinheit aus lebensmittel_format.MIKRO_SCHLUESSEL (µg bzw. mg). Nur was das # Produkt nennt; fehlt ein Wert, bleibt er null (nie geschätzt oder aufgefüllt). MIKRO_FELDER = (("iodine_100g", 1e6), ("selenium_100g", 1e6), ("iron_100g", 1e3), ("zinc_100g", 1e3), ("vitamin-d_100g", 1e6), ("vitamin-b12_100g", 1e6)) KJ_JE_KCAL = 4.184 _ML = re.compile(r"\d\s*(ml|cl|dl|l|ltr|liter|litre)\b", re.IGNORECASE) _MENGE = re.compile(r"(\d+(?:[.,]\d+)?)\s*(kg|gram|g|ml|cl|dl|litre|liter|l)\b", re.IGNORECASE) _FAKTOR = {"g": 1, "gram": 1, "kg": 1000, "ml": 1, "cl": 10, "dl": 100, "l": 1000, "liter": 1000, "litre": 1000} _NICHT_NAME = re.compile(r"https?:|www\.|@|\d{6,}", re.IGNORECASE) def oeffnen(pfad: Path): """Textdatei, auch gzip, zeilenweise zu lesen.""" if str(pfad).lower().endswith(".gz"): return io.TextIOWrapper(gzip.open(pfad, "rb"), encoding="utf-8", errors="replace", newline="") return open(pfad, encoding="utf-8", errors="replace", newline="") def art_der_datei(pfad: Path) -> str: name = str(pfad).lower() if name.endswith(".gz"): name = name[:-3] if name.endswith((".jsonl", ".ndjson", ".json")): return "jsonl" if name.endswith((".csv", ".tsv")): return "csv" raise SystemExit("Dateiart unbekannt: erwartet .jsonl, .ndjson, .csv oder .tsv (jeweils auch .gz).") # ── Datensätze aus den beiden Dateiarten, vereinheitlicht ──────────────────── def datensaetze_jsonl(datei, zaehler: dict): for zeile in datei: zeile = zeile.strip() if not zeile: continue try: roh = json.loads(zeile) except ValueError: zaehler["zeile_defekt"] = zaehler.get("zeile_defekt", 0) + 1 continue if not isinstance(roh, dict): continue n = roh.get("nutriments") if isinstance(roh.get("nutriments"), dict) else {} laender = roh.get("countries_tags") yield { "code": roh.get("code"), "name": roh.get("product_name_de") or roh.get("product_name"), "allgemein": roh.get("generic_name_de") or roh.get("generic_name"), "marken": roh.get("brands"), "laender": laender if isinstance(laender, list) else str(laender or "").split(","), "portion_text": roh.get("serving_size"), "portion_zahl": roh.get("serving_quantity"), "menge_text": roh.get("quantity"), "kcal": n.get("energy-kcal_100g"), "kj": n.get("energy_100g"), "eiweiss": n.get("proteins_100g"), "fett": n.get("fat_100g"), "kh": n.get("carbohydrates_100g"), "mikro": [n.get(f) for f, _ in MIKRO_FELDER], } def datensaetze_csv(datei, zaehler: dict): csv.field_size_limit(10_000_000) leser = csv.DictReader(datei, delimiter="\t", quoting=csv.QUOTE_NONE) for roh in leser: yield { "code": roh.get("code"), "name": roh.get("product_name"), "allgemein": roh.get("generic_name"), "marken": roh.get("brands"), "laender": str(roh.get("countries_tags") or "").split(","), "portion_text": roh.get("serving_size"), "portion_zahl": roh.get("serving_quantity"), "menge_text": roh.get("quantity"), "kcal": roh.get("energy-kcal_100g"), "kj": roh.get("energy_100g"), "eiweiss": roh.get("proteins_100g"), "fett": roh.get("fat_100g"), "kh": roh.get("carbohydrates_100g"), "mikro": [roh.get(f) for f, _ in MIKRO_FELDER], } def mikro_umrechnen(roh) -> "list | None": """Die sechs Werte aus Open Food Facts (Gramm je 100 g) in µg bzw. mg je 100 g; fehlende als None.""" if not roh: return None aus = [] for (_, faktor), w in zip(MIKRO_FELDER, roh): z = fmt.zahl_oder_none(w) aus.append(z * faktor if z is not None else None) return aus # ── Umwandlung eines Datensatzes ───────────────────────────────────────────── def entitaeten(text) -> str: """HTML-Zeichen („&“) in Namen und Marken auflösen: Der CSV-Auszug führt sie so.""" return html.unescape(str(text or "")) def marken_entfernen(name: str, marken) -> str: """Den Namen ohne die Marken des Produkts. `marken` ist die Liste aus dem Feld `brands` (Komma getrennt); sie wird nur dazu gelesen und nirgends ausgegeben.""" teile = marken if isinstance(marken, list) else entitaeten(marken).split(",") # längere zuerst: „Dr. Oetker“ vor „Oetker“ for marke in sorted((m.strip() for m in teile if m and len(m.strip()) >= 2), key=len, reverse=True): name = re.sub(r"(? "list[str]": """Die Marken aus dem Feld `brands`, bereinigt und ohne Doppelte, in der Reihenfolge des Feldes.""" teile = marken if isinstance(marken, list) else entitaeten(marken).split(",") aus: "list[str]" = [] gesehen: "set[str]" = set() for teil in teile: m = name_aufbereiten(teil) k = " ".join(fmt.woerter(m)) if len(m) < 2 or not k or k in gesehen or _NICHT_NAME.search(m): continue gesehen.add(k) aus.append(m) return aus def marke_zur_anzeige(name: str, marken) -> str: """Die Marke für die Trefferliste der Namenssuche: höchstens zwei Marken des Produkts, mit Komma, ohne die, die schon im Namen stehen („Beispielmarke Müsli“ von „Beispielmarke“ ergibt eine leere Marke).""" im_namen = " " + " ".join(fmt.woerter(name)) + " " rest = [m for m in marken_liste(marken) if " " + " ".join(fmt.woerter(m)) + " " not in im_namen] return fmt.marke_bereinigen(", ".join(rest[:2])) def name_aufbereiten(roh) -> str: s = fmt.name_bereinigen(roh) # Nur Großbuchstaben: „HAFERFLOCKEN ZART“ → „Haferflocken Zart“ if len(s) > 3 and s.upper() == s and any(c.isalpha() for c in s): s = s.title() return s def einheit_und_portion(satz: dict) -> "tuple[int, int]": """(Einheit, Portion in g bzw. ml). ml, sobald Menge oder Portion in einer Flüssigkeitseinheit steht.""" text = f"{satz.get('menge_text') or ''} {satz.get('portion_text') or ''}" einheit = fmt.EINHEIT_ML if _ML.search(text) else fmt.EINHEIT_G portion = fmt.zahl_oder_none(satz.get("portion_zahl")) if not portion: m = _MENGE.search(str(satz.get("portion_text") or "")) portion = float(m.group(1).replace(",", ".")) * _FAKTOR[m.group(2).lower()] if m else 0 return einheit, int(round(portion)) if portion and 0 < portion <= fmt.PORTION_MAX else 0 def energie_passt(kcal: float, eiweiss: float, fett: float, kh: float) -> bool: """Die Energie liegt in dem Bereich, den Eiweiß, Fett, Kohlenhydrate (und etwas Alkohol) hergeben.""" schaetzung = 4 * eiweiss + 9 * fett + 4 * kh return 0.5 * schaetzung - 20 <= kcal <= 1.6 * schaetzung + 250 def brauchbarer_name(satz: dict, ohne) -> str: """Der Name des Produkts (Produktname, sonst die allgemeine Bezeichnung), nachdem `ohne` darauf angewandt ist; leer, wenn nichts Brauchbares übrig bleibt.""" name = name_aufbereiten(ohne(entitaeten(satz["name"]))) if not fmt.woerter(name) or len(name) < 3 or _NICHT_NAME.search(name): name = name_aufbereiten(ohne(entitaeten(satz["allgemein"]))) if len(name) < 3 or _NICHT_NAME.search(name) or not fmt.woerter(name): return "" return name def verarbeiten(saetze, sammlung: fmt.Sammlung, laender_tags: "set[str]", marken_behalten: bool = False, namenssuche: bool = False, marke_in_der_suche: bool = False) -> dict: """Nimmt die Datensätze durch den Filter; zählt, was aus welchem Grund wegfällt. Mit `namenssuche` kommt jedes Produkt, das Land, Werte und Strichcode besteht, zusätzlich mit dem Namen, den Open Food Facts führt, in die Namenssuche (auch wenn der Name ohne Marke leer wäre: „Beispielmarke“ von „Beispielmarke“).""" z = {"gelesen": 0, "anderes_land": 0} such_codes: "set[str]" = set() for satz in saetze: z["gelesen"] += 1 if not laender_tags.intersection(t.strip() for t in satz["laender"] or []): z["anderes_land"] += 1 continue name = brauchbarer_name(satz, (lambda t: t) if marken_behalten else (lambda t: marken_entfernen(t, satz["marken"]))) such_name = brauchbarer_name(satz, lambda t: t) if namenssuche else "" if not name: sammlung.verwerfen("name") if not such_name: continue kcal = fmt.zahl_oder_none(satz["kcal"]) if kcal is None: kj = fmt.zahl_oder_none(satz["kj"]) kcal = kj / KJ_JE_KCAL if kj is not None else None werte = [fmt.zahl_oder_none(satz[f]) for f in ("eiweiss", "fett", "kh")] grund = None if kcal is None or any(w is None for w in werte): grund = "wert_fehlt" elif not (0 <= kcal <= fmt.KCAL_MAX and all(0 <= w <= fmt.NAEHRSTOFF_MAX for w in werte)): grund = "wert_ausser_bereich" elif not energie_passt(kcal, *werte): grund = "energie_unplausibel" if grund: if name: sammlung.verwerfen(grund) continue einheit, portion = einheit_und_portion(satz) mikro = mikro_umrechnen(satz.get("mikro")) if sammlung.mit_mikro else None if name: sammlung.hinzu(name, einheit, kcal, *werte, portion=portion, strichcode=satz["code"], mikro=mikro) if such_name: # Dieselbe Hürde wie beim Strichcode (gültige Prüfziffer, jeder Strichcode einmal); der Strichcode selbst # kommt nicht in die Suchdateien. code = fmt.strichcode_normalisieren(satz["code"]) if code and fmt.gtin_gueltig(code) and code not in such_codes: marke = marke_zur_anzeige(such_name, satz["marken"]) if marke_in_der_suche else "" if sammlung.suche_hinzu(such_name, einheit, kcal, *werte, portion=portion, marke=marke, mikro=mikro): such_codes.add(code) z["uebernommen"] = len(sammlung.eintraege) return z def lizenz_datei(ordner: Path, stand: str, ausgangsdatei: str, laender: "list[str]", marken: bool = False, namenssuche: bool = False, marke_in_der_suche: bool = False) -> None: marke_de = "Marke im Namen belassen" if marken else "Marke aus dem Namen entfernt" marke_en = "brand kept in the name" if marken else "brand removed from the name" suche = "" auszug_de, auszug_en = "Der Auszug enthält", "Each entry contains" if namenssuche: auszug_de, auszug_en = "Die Strichcode-Dateien off-b-NN.json enthalten", "Each entry of the barcode files off-b-NN.json contains" marke_de += " (Strichcode-Dateien)" marke_en += " (barcode files)" mit_de = (" und die Marke als Text (höchstens zwei Marken, nur soweit sie nicht im Namen stehen)" if marke_in_der_suche else "; keine Marke als eigenes Feld") mit_en = (" and the brand as text (at most two brands, only where the name does not contain them)" if marke_in_der_suche else "; no brand as a separate field") suche = f""" Suchdateien off-s-NN.json (Suche nach dem Produktnamen in der App): je Produkt der Name, wie Open Food Facts ihn führt, Einheit, Energie (kcal), Eiweiß, Fett, Kohlenhydrate je 100 g und die Portionsgröße{mit_de}. Kein Strichcode. Gleiche Namen stehen einmal da, mit der Angabe, die am häufigsten vorkommt (bei Gleichstand die mittlere). Search files off-s-NN.json (search by product name in the app): per product the name as listed by Open Food Facts, unit, energy (kcal), protein, fat, carbohydrates per 100 g and the serving size{mit_en}. No barcode. Identical names appear once, with the most frequent set of values (the middle one if several are equally frequent). """ text = f"""Open Food Facts: Auszug für die Emivita-App / extract for the Emivita app {ATTRIBUTION_EN} {HINWEIS}. Stand der Ausgangsdaten / date of the source data: {stand} Ausgangsdatei / source file: {ausgangsdatei} Länder / countries: {", ".join(x.upper() for x in laender)} Filter / filter: nur Produkte dieser Länder mit Strichcode (gültige Prüfziffer) und allen vier Nährwerten je 100 g; {marke_de}; keine Bilder, keine Personenfelder. / only products of these countries with a valid barcode and all four values per 100 g; {marke_en}; no images, no personal fields. Filterverfahren / filtering procedure: scripts/lebensmittel_off.py (Emivita), ODbL 4.6. Lizenz der Datenbank / licence of the database: {LIZENZ_TEXT} Links: {LINKS} {auszug_de} je Produkt nur Strichcode, Name, Einheit, Energie (kcal), Eiweiß, Fett, Kohlenhydrate je 100 g und die Portionsgröße. Keine Bilder, keine Angaben zu Mitwirkenden, keine Marke als eigenes Feld. {auszug_en} only barcode, name, unit, energy (kcal), protein, fat, carbohydrates per 100 g and the serving size. No images, no information about contributors, no brand as a separate field. {suche} Die Angaben stammen aus einer offenen Mitmach-Datenbank und können ungenau sein. The information comes from an open, community-edited database and may be inaccurate. """ (ordner / "OFF-LIZENZ.txt").write_text(text, encoding="utf-8") def main(argv=None) -> int: p = argparse.ArgumentParser(description="Open-Food-Facts-Auszug → Lebensmittel-Datenbank (nur lokal, ohne Netz)") p.add_argument("eingabe", type=Path, help="Auszug als .jsonl(.gz) oder .csv(.gz)") p.add_argument("--stand", required=True, help="Stand der Ausgangsdaten, JJJJ-MM-TT (Pflicht)") p.add_argument("--ausgabe", type=Path, default=Path("app_client/public/lebensmittel")) p.add_argument("--laender", default="de,at,ch", help="Komma getrennt: de, at, ch") p.add_argument("--marken-behalten", action="store_true", help="Name so lassen, wie Open Food Facts ihn führt (Standard: Marke aus dem Namen entfernen)") p.add_argument("--namenssuche", action="store_true", help="zusätzlich die Suchdateien off-s-NN.json für die Suche nach dem Produktnamen schreiben") p.add_argument("--mikro", action="store_true", help="Release 1.5: auch Jod, Selen, Eisen, Zink, Vitamin D und Vitamin B12 je 100 g, nur wo das Produkt sie nennt") p.add_argument("--namenssuche-marke", action="store_true", help="wie --namenssuche, dazu die Marke als Text in den Suchdateien (braucht vor einem Release die " "Freigabe der Datenschutzberatung, N5)") a = p.parse_args(argv) laender = [x.strip().lower() for x in a.laender.split(",") if x.strip()] unbekannt = [x for x in laender if x not in LAENDER] if unbekannt or not laender: p.error("--laender: nur de, at, ch") tags = {LAENDER[x] for x in laender} namenssuche = bool(a.namenssuche or a.namenssuche_marke) sammlung = fmt.Sammlung("off", mit_strichcode=True, mit_mikro=a.mikro) zaehler: dict = {} with oeffnen(a.eingabe) as datei: quelle = (datensaetze_jsonl if art_der_datei(a.eingabe) == "jsonl" else datensaetze_csv)(datei, zaehler) z = verarbeiten(quelle, sammlung, tags, a.marken_behalten, namenssuche, a.namenssuche_marke) z.update(zaehler) if not sammlung.eintraege: raise SystemExit("Kein einziger Eintrag ist brauchbar: Dateiart, Länder und Spalten prüfen.") eintrag = fmt.schreiben( sammlung, a.ausgabe, name=QUELLE_NAME, herkunft=QUELLE_HERKUNFT, stand=a.stand, lizenz=LIZENZ_TEXT, lizenz_url=LIZENZ_URL, hinweis=HINWEIS, zitat=ATTRIBUTION_EN, suche_mit_marke=bool(a.namenssuche_marke), beschreibung={"laender": [x.upper() for x in laender], "ausgangsdatei": a.eingabe.name, "marken_im_namen": bool(a.marken_behalten), "namenssuche": namenssuche, "skript": "scripts/lebensmittel_off.py", "gelesen": z["gelesen"], "anderes_land": z["anderes_land"]}) lizenz_datei(a.ausgabe, a.stand, a.eingabe.name, laender, a.marken_behalten, namenssuche, a.namenssuche_marke) print(f"{a.ausgabe}: {z['gelesen']} Produkte gelesen, {z['anderes_land']} aus anderen Ländern, " f"{fmt.zusammenfassung(eintrag)}") return 0 if __name__ == "__main__": raise SystemExit(main())