feat: Rezepte beim Zuordnen anlegen und offene Zutaten listen
Lebensmittel oder Rezept wählbar; gemappte Zutaten werden übernommen, offene erscheinen in der Liste. Dazu Fettgehalt-Suche, EPA-Stoffe, Rezept-CRUD und Wechsel bestehender Zuordnungen. Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
1 parent
132a364a3a
commit
a7e5511039
26 files changed
+1234
-147
No files matched your search
@@ -0,0 +1,128 @@
|
||||
"""Catalog attribute definitions and numeric values (BLS EAV + extensions)."""
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any
|
||||
|
||||
MACRO_TO_KEY = {
|
||||
"kcal": "ENERCC",
|
||||
"protein_g": "PROT625",
|
||||
"fat_g": "FAT",
|
||||
"carbs_g": "CHO",
|
||||
}
|
||||
|
||||
|
||||
def scale_to_per_100g(value: float, serving_g: float | None) -> float:
|
||||
if not serving_g or serving_g <= 0 or serving_g == 100:
|
||||
return float(value)
|
||||
return float(value) * (100.0 / float(serving_g))
|
||||
|
||||
|
||||
def list_numeric_attributes(cur, query: str = "", limit: int = 40) -> list[dict[str, Any]]:
|
||||
q = (query or "").strip()
|
||||
lim = min(max(int(limit or 40), 1), 80)
|
||||
if q:
|
||||
like = f"%{q}%"
|
||||
cur.execute(
|
||||
"""
|
||||
SELECT id, attr_key, name_de, name_en, unit, category, origin
|
||||
FROM food_attributes
|
||||
WHERE is_active = true AND data_type = 'num_per_100g'
|
||||
AND (
|
||||
attr_key ILIKE %s OR name_de ILIKE %s
|
||||
OR COALESCE(name_en, '') ILIKE %s
|
||||
)
|
||||
ORDER BY
|
||||
CASE WHEN attr_key ILIKE %s THEN 0
|
||||
WHEN name_de ILIKE %s THEN 1
|
||||
ELSE 2 END,
|
||||
sort_order, attr_key
|
||||
LIMIT %s
|
||||
""",
|
||||
(like, like, like, q, f"{q}%", lim),
|
||||
)
|
||||
else:
|
||||
cur.execute(
|
||||
"""
|
||||
SELECT id, attr_key, name_de, name_en, unit, category, origin
|
||||
FROM food_attributes
|
||||
WHERE is_active = true AND data_type = 'num_per_100g'
|
||||
ORDER BY sort_order, attr_key
|
||||
LIMIT %s
|
||||
""",
|
||||
(lim,),
|
||||
)
|
||||
return [dict(r) for r in cur.fetchall()]
|
||||
|
||||
|
||||
def write_numeric_attributes(cur, food_id: str, values: dict[str, Any] | None) -> int:
|
||||
if not values:
|
||||
return 0
|
||||
written = 0
|
||||
for raw_key, raw_val in values.items():
|
||||
key = str(raw_key or "").strip()
|
||||
if not key or raw_val is None or raw_val == "":
|
||||
continue
|
||||
try:
|
||||
num = float(raw_val)
|
||||
except (TypeError, ValueError):
|
||||
continue
|
||||
cur.execute(
|
||||
"""
|
||||
SELECT id FROM food_attributes
|
||||
WHERE attr_key = %s AND is_active = true AND data_type = 'num_per_100g'
|
||||
""",
|
||||
(key,),
|
||||
)
|
||||
row = cur.fetchone()
|
||||
if not row:
|
||||
continue
|
||||
cur.execute(
|
||||
"""
|
||||
INSERT INTO food_attribute_values (food_id, attribute_id, value_num, is_trace)
|
||||
VALUES (%s, %s, %s, false)
|
||||
ON CONFLICT (food_id, attribute_id)
|
||||
DO UPDATE SET value_num = EXCLUDED.value_num, updated_at = NOW()
|
||||
""",
|
||||
(food_id, row["id"], num),
|
||||
)
|
||||
written += 1
|
||||
return written
|
||||
|
||||
|
||||
def macros_and_attributes_to_values(
|
||||
macros: dict[str, Any] | None,
|
||||
attributes: dict[str, Any] | None,
|
||||
serving_g: float | None = None,
|
||||
) -> dict[str, float]:
|
||||
out: dict[str, float] = {}
|
||||
for field, key in MACRO_TO_KEY.items():
|
||||
if not macros or field not in macros or macros[field] is None or macros[field] == "":
|
||||
continue
|
||||
try:
|
||||
out[key] = scale_to_per_100g(float(macros[field]), serving_g)
|
||||
except (TypeError, ValueError):
|
||||
continue
|
||||
for key, raw in (attributes or {}).items():
|
||||
if raw is None or raw == "":
|
||||
continue
|
||||
try:
|
||||
out[str(key)] = scale_to_per_100g(float(raw), serving_g)
|
||||
except (TypeError, ValueError):
|
||||
continue
|
||||
return out
|
||||
|
||||
|
||||
def extra_attributes_for_food(cur, food_id: str) -> dict[str, float]:
|
||||
cur.execute(
|
||||
"""
|
||||
SELECT a.attr_key, v.value_num
|
||||
FROM food_attribute_values v
|
||||
JOIN food_attributes a ON a.id = v.attribute_id
|
||||
WHERE v.food_id = %s AND a.data_type = 'num_per_100g'
|
||||
AND v.value_num IS NOT NULL AND v.is_trace = false
|
||||
AND NOT (a.attr_key = ANY(%s))
|
||||
ORDER BY a.sort_order, a.attr_key
|
||||
""",
|
||||
(food_id, list(MACRO_TO_KEY.values())),
|
||||
)
|
||||
return {r["attr_key"]: float(r["value_num"]) for r in cur.fetchall()}
|
||||
@@ -22,13 +22,19 @@ BUNDLE_VERSION = 1
|
||||
def _jsonable(value: Any) -> Any:
|
||||
if value is None:
|
||||
return None
|
||||
if isinstance(value, (str, int, float, bool)):
|
||||
return value
|
||||
if isinstance(value, Decimal):
|
||||
return float(value)
|
||||
if isinstance(value, UUID):
|
||||
return str(value)
|
||||
if isinstance(value, dict):
|
||||
return {str(k): _jsonable(v) for k, v in value.items()}
|
||||
if isinstance(value, (list, tuple)):
|
||||
return [_jsonable(v) for v in value]
|
||||
if hasattr(value, "isoformat"):
|
||||
return value.isoformat()
|
||||
return value
|
||||
return str(value)
|
||||
|
||||
|
||||
def parse_food_knowledge_bundle(data: Any) -> dict[str, Any]:
|
||||
@@ -54,7 +60,7 @@ def portable_mapping(row: dict[str, Any]) -> dict[str, Any]:
|
||||
"food_name_de": row.get("food_name_de") or row.get("name_de"),
|
||||
"catalog_kind": row.get("catalog_kind"),
|
||||
"external_key": row.get("external_key"),
|
||||
"grams_per_unit": row.get("grams_per_unit"),
|
||||
"grams_per_unit": _jsonable(row.get("grams_per_unit")),
|
||||
"source_unit": row.get("source_unit"),
|
||||
}
|
||||
|
||||
@@ -126,12 +132,14 @@ def export_food_knowledge(cur, profile_id: str) -> dict[str, Any]:
|
||||
manuals = []
|
||||
for food in cur.fetchall():
|
||||
macros = catalog_macros_for_item(cur, food["id"], 100.0)
|
||||
from data_layer.food_attributes import extra_attributes_for_food
|
||||
manuals.append({
|
||||
"name_de": food["name_de"],
|
||||
"name_en": food.get("name_en"),
|
||||
"catalog_kind": food["catalog_kind"],
|
||||
"external_key": food.get("external_key"),
|
||||
"macros_per_100g": macros,
|
||||
"attributes": extra_attributes_for_food(cur, food["id"]),
|
||||
})
|
||||
cur.execute(
|
||||
"""
|
||||
@@ -165,14 +173,14 @@ def export_food_knowledge(cur, profile_id: str) -> dict[str, Any]:
|
||||
for ing in rec.get("ingredients") or []
|
||||
],
|
||||
})
|
||||
return {
|
||||
return _jsonable({
|
||||
"format": BUNDLE_FORMAT,
|
||||
"version": BUNDLE_VERSION,
|
||||
"exported_at": datetime.now(timezone.utc).isoformat(),
|
||||
"manual_foods": manuals,
|
||||
"mappings": mappings,
|
||||
"recipes": recipes,
|
||||
}
|
||||
})
|
||||
|
||||
|
||||
def _upsert_manual_food(cur, profile_id: str, food: dict[str, Any]) -> str | None:
|
||||
@@ -180,9 +188,10 @@ def _upsert_manual_food(cur, profile_id: str, food: dict[str, Any]) -> str | Non
|
||||
if not name:
|
||||
return None
|
||||
existing = resolve_catalog_food(cur, profile_id, {**food, "food_name_de": name, "catalog_kind": "manual_user"})
|
||||
from data_layer.food_attributes import macros_and_attributes_to_values, write_numeric_attributes
|
||||
values = macros_and_attributes_to_values(food.get("macros_per_100g"), food.get("attributes"))
|
||||
if existing:
|
||||
from routers.admin_bls import _write_manual_macros
|
||||
_write_manual_macros(cur, existing, food.get("macros_per_100g"))
|
||||
write_numeric_attributes(cur, existing, values)
|
||||
return existing
|
||||
key = (food.get("external_key") or "").strip() or f"man-user-{normalize_food_name(name)[:40]}"
|
||||
cur.execute(
|
||||
@@ -195,8 +204,7 @@ def _upsert_manual_food(cur, profile_id: str, food: dict[str, Any]) -> str | Non
|
||||
(name, food.get("name_en"), profile_id, key),
|
||||
)
|
||||
food_id = str(cur.fetchone()["id"])
|
||||
from routers.admin_bls import _write_manual_macros
|
||||
_write_manual_macros(cur, food_id, food.get("macros_per_100g"))
|
||||
write_numeric_attributes(cur, food_id, values)
|
||||
return food_id
|
||||
|
||||
|
||||
|
||||
@@ -31,6 +31,17 @@ def normalize_food_name(raw: str | None) -> str:
|
||||
return s.lower()
|
||||
|
||||
|
||||
_LIST_COMMA_RE = re.compile(r",(?!\s*\d)")
|
||||
|
||||
|
||||
def primary_search_query(query: str | None) -> str:
|
||||
"""Use the name before a list-comma, but keep decimal commas (9,5 %)."""
|
||||
q = (query or "").strip()
|
||||
if not q:
|
||||
return ""
|
||||
return _LIST_COMMA_RE.split(q, maxsplit=1)[0].strip()
|
||||
|
||||
|
||||
def merge_unmapped_rows(rows: list[dict]) -> list[dict]:
|
||||
merged: dict[str, dict] = {}
|
||||
for row in rows:
|
||||
@@ -359,17 +370,50 @@ def _value_origin_for_food(cur, food_id: str) -> str:
|
||||
return "manual_catalog"
|
||||
|
||||
|
||||
_SEARCH_NUM_RE = re.compile(r"\d+(?:[.,]\d+)?")
|
||||
|
||||
|
||||
def _catalog_must_tokens(query: str) -> list[list[str]]:
|
||||
"""AND-groups for catalog search: first word plus each number (with 9,5/10 aliases)."""
|
||||
text = normalize_food_name(primary_search_query(query))
|
||||
nums = [m.replace(",", ".") for m in _SEARCH_NUM_RE.findall(text)]
|
||||
words = [t for t in re.split(r"[^a-z0-9äöüß]+", _SEARCH_NUM_RE.sub(" ", text)) if len(t) >= 2]
|
||||
groups: list[list[str]] = []
|
||||
if words:
|
||||
groups.append([words[0]])
|
||||
for num in nums[:3]:
|
||||
variants = {num, num.replace(".", ",")}
|
||||
try:
|
||||
value = float(num)
|
||||
except ValueError:
|
||||
value = None
|
||||
if value is not None and (abs(value - 10) <= 0.6 or abs(value - 9.5) <= 0.6):
|
||||
variants.update({"10", "9.5", "9,5"})
|
||||
groups.append(list(variants))
|
||||
return groups
|
||||
|
||||
|
||||
def suggest_catalog_foods(cur, query: str, profile_id: str | None, limit: int = 8) -> list[dict]:
|
||||
q = (query or "").strip()
|
||||
if not q:
|
||||
return []
|
||||
primary = q.split(",")[0].strip() or q
|
||||
primary = primary_search_query(q) or q
|
||||
like_full = f"%{q}%"
|
||||
like_primary = f"%{primary}%"
|
||||
prefix = f"{primary}%"
|
||||
norm = normalize_food_name(primary)
|
||||
extra_sql = ""
|
||||
extra_params: list[str] = []
|
||||
must = _catalog_must_tokens(q)
|
||||
if len(must) >= 2:
|
||||
parts = []
|
||||
for group in must:
|
||||
ors = " OR ".join(["name_de ILIKE %s"] * len(group))
|
||||
parts.append(f"({ors})")
|
||||
extra_params.extend(f"%{v}%" for v in group)
|
||||
extra_sql = " OR (" + " AND ".join(parts) + ")"
|
||||
cur.execute(
|
||||
"""
|
||||
f"""
|
||||
SELECT id, bls_code, name_de, name_en, catalog_kind, food_group
|
||||
FROM food_catalog
|
||||
WHERE is_active = true
|
||||
@@ -382,6 +426,7 @@ def suggest_catalog_foods(cur, query: str, profile_id: str | None, limit: int =
|
||||
OR COALESCE(name_en, '') ILIKE %s OR COALESCE(name_en, '') ILIKE %s
|
||||
OR COALESCE(bls_code, '') ILIKE %s
|
||||
OR lower(name_de) = %s
|
||||
{extra_sql}
|
||||
)
|
||||
ORDER BY
|
||||
CASE
|
||||
@@ -395,6 +440,7 @@ def suggest_catalog_foods(cur, query: str, profile_id: str | None, limit: int =
|
||||
(
|
||||
profile_id,
|
||||
like_full, like_primary, like_full, like_primary, like_full, norm,
|
||||
*extra_params,
|
||||
norm, prefix, q, limit,
|
||||
),
|
||||
)
|
||||
|
||||
@@ -108,12 +108,12 @@ def list_recipes(cur, profile_id: str) -> list[dict[str, Any]]:
|
||||
recipes = [dict(r) for r in cur.fetchall()]
|
||||
if not recipes:
|
||||
return []
|
||||
ids = [r["id"] for r in recipes]
|
||||
ids = [str(r["id"]) for r in recipes]
|
||||
cur.execute(
|
||||
"""
|
||||
SELECT recipe_id, source_name_raw, source_name_normalized, quantity_raw, quantity_g, sort_order
|
||||
FROM food_recipe_ingredients
|
||||
WHERE recipe_id = ANY(%s)
|
||||
WHERE recipe_id = ANY(%s::uuid[])
|
||||
ORDER BY sort_order, source_name_raw
|
||||
""",
|
||||
(ids,),
|
||||
@@ -122,10 +122,109 @@ def list_recipes(cur, profile_id: str) -> list[dict[str, Any]]:
|
||||
for row in cur.fetchall():
|
||||
by_r.setdefault(str(row["recipe_id"]), []).append(dict(row))
|
||||
for rec in recipes:
|
||||
rec["ingredients"] = by_r.get(str(rec["id"]), [])
|
||||
rec["id"] = str(rec["id"])
|
||||
rec["ingredients"] = by_r.get(rec["id"], [])
|
||||
return recipes
|
||||
|
||||
|
||||
def get_recipe(cur, profile_id: str, recipe_id: str) -> dict[str, Any] | None:
|
||||
for rec in list_recipes(cur, profile_id):
|
||||
if rec["id"] == str(recipe_id):
|
||||
return rec
|
||||
return None
|
||||
|
||||
|
||||
def save_recipe(cur, profile_id: str, rec: dict[str, Any], recipe_id: str | None = None) -> dict[str, Any]:
|
||||
name_raw = (rec.get("name_raw") or "").strip()
|
||||
norm = rec.get("name_normalized") or normalize_food_name(name_raw)
|
||||
if not name_raw or not norm:
|
||||
raise ValueError("Rezeptname fehlt")
|
||||
try:
|
||||
portions = float(rec.get("portions") or 1)
|
||||
except (TypeError, ValueError):
|
||||
portions = 1.0
|
||||
if portions <= 0:
|
||||
portions = 1.0
|
||||
description = rec.get("description")
|
||||
source = (rec.get("source") or "manual").strip() or "manual"
|
||||
if recipe_id:
|
||||
cur.execute(
|
||||
"SELECT id FROM food_recipes WHERE id = %s AND profile_id = %s",
|
||||
(recipe_id, profile_id),
|
||||
)
|
||||
if not cur.fetchone():
|
||||
raise KeyError("Rezept nicht gefunden")
|
||||
cur.execute(
|
||||
"""
|
||||
SELECT id FROM food_recipes
|
||||
WHERE profile_id = %s AND name_normalized = %s AND id <> %s
|
||||
""",
|
||||
(profile_id, norm, recipe_id),
|
||||
)
|
||||
if cur.fetchone():
|
||||
raise ValueError("Ein Rezept mit diesem Namen existiert bereits")
|
||||
cur.execute(
|
||||
"""
|
||||
UPDATE food_recipes
|
||||
SET name_raw=%s, name_normalized=%s, portions=%s, description=%s, updated_at=NOW()
|
||||
WHERE id=%s AND profile_id=%s
|
||||
""",
|
||||
(name_raw, norm, portions, description, recipe_id, profile_id),
|
||||
)
|
||||
cur.execute("DELETE FROM food_recipe_ingredients WHERE recipe_id = %s", (recipe_id,))
|
||||
rid = recipe_id
|
||||
else:
|
||||
cur.execute(
|
||||
"SELECT id FROM food_recipes WHERE profile_id = %s AND name_normalized = %s",
|
||||
(profile_id, norm),
|
||||
)
|
||||
existing = cur.fetchone()
|
||||
if existing:
|
||||
return save_recipe(cur, profile_id, rec, str(existing["id"]))
|
||||
rid = str(uuid.uuid4())
|
||||
cur.execute(
|
||||
"""
|
||||
INSERT INTO food_recipes
|
||||
(id, profile_id, name_raw, name_normalized, portions, description, source)
|
||||
VALUES (%s,%s,%s,%s,%s,%s,%s)
|
||||
""",
|
||||
(rid, profile_id, name_raw, norm, portions, description, source),
|
||||
)
|
||||
for i, ing in enumerate(rec.get("ingredients") or []):
|
||||
raw = (ing.get("source_name_raw") or "").strip()
|
||||
inorm = ing.get("source_name_normalized") or normalize_food_name(raw)
|
||||
if not inorm:
|
||||
continue
|
||||
qty = ing.get("quantity_g")
|
||||
try:
|
||||
qty = float(qty) if qty not in (None, "") else None
|
||||
except (TypeError, ValueError):
|
||||
qty = None
|
||||
cur.execute(
|
||||
"""
|
||||
INSERT INTO food_recipe_ingredients
|
||||
(id, recipe_id, source_name_raw, source_name_normalized,
|
||||
quantity_raw, quantity_g, sort_order)
|
||||
VALUES (%s,%s,%s,%s,%s,%s,%s)
|
||||
""",
|
||||
(str(uuid.uuid4()), rid, raw or inorm, inorm, ing.get("quantity_raw"), qty, i),
|
||||
)
|
||||
link_recipes_to_items(cur, profile_id)
|
||||
saved = get_recipe(cur, profile_id, rid)
|
||||
if not saved:
|
||||
raise ValueError("Rezept konnte nicht gelesen werden")
|
||||
return saved
|
||||
|
||||
|
||||
def delete_recipe(cur, profile_id: str, recipe_id: str) -> None:
|
||||
cur.execute(
|
||||
"DELETE FROM food_recipes WHERE id = %s AND profile_id = %s RETURNING id",
|
||||
(recipe_id, profile_id),
|
||||
)
|
||||
if not cur.fetchone():
|
||||
raise KeyError("Rezept nicht gefunden")
|
||||
|
||||
|
||||
def apply_recipe_to_items(cur, profile_id: str, source_name_normalized: str, recipe_id: str) -> int:
|
||||
cur.execute(
|
||||
"""
|
||||
|
||||
@@ -5,7 +5,7 @@ import re
|
||||
import time
|
||||
from typing import Any
|
||||
|
||||
from data_layer.food_mapping import normalize_food_name
|
||||
from data_layer.food_mapping import normalize_food_name, primary_search_query
|
||||
|
||||
_INDEX_TTL_SEC = 300
|
||||
_index_cache: dict[str, tuple[float, dict[str, Any]]] = {}
|
||||
@@ -14,32 +14,106 @@ MAX_BUCKET = 40
|
||||
|
||||
SPLIT_RE = re.compile(r"[^a-z0-9äöüß]+")
|
||||
COLLAPSE_RE = re.compile(r"[^a-z0-9äöüß]")
|
||||
NUM_RE = re.compile(r"\d+(?:[.,]\d+)?")
|
||||
NUM_TOKEN_RE = re.compile(r"^\d+(?:\.\d+)?$")
|
||||
MIN_SCORE = 45
|
||||
FAT_CLOSE = 0.6
|
||||
|
||||
|
||||
def collapse_key(raw: str | None) -> str:
|
||||
return COLLAPSE_RE.sub("", normalize_food_name(raw))
|
||||
|
||||
|
||||
def number_tokens(raw: str | None) -> list[str]:
|
||||
return [m.replace(",", ".") for m in NUM_RE.findall(normalize_food_name(raw))]
|
||||
|
||||
|
||||
def is_number_token(tok: str) -> bool:
|
||||
return bool(NUM_TOKEN_RE.fullmatch(tok or ""))
|
||||
|
||||
|
||||
def number_search_aliases(tok: str) -> list[str]:
|
||||
"""9.5 and 10 are the same fat class in dairy; keep both searchable."""
|
||||
if not is_number_token(tok):
|
||||
return [tok]
|
||||
aliases = {tok}
|
||||
try:
|
||||
value = float(tok)
|
||||
except ValueError:
|
||||
return [tok]
|
||||
if abs(value - 10) <= FAT_CLOSE or abs(value - 9.5) <= FAT_CLOSE:
|
||||
aliases.update({"9.5", "10"})
|
||||
if value == int(value):
|
||||
aliases.add(str(int(value)))
|
||||
return list(aliases)
|
||||
|
||||
|
||||
def numbers_compatible(query_nums: list[str], name_nums: list[str]) -> bool | None:
|
||||
if not query_nums:
|
||||
return None
|
||||
if not name_nums:
|
||||
return False
|
||||
for qn in query_nums:
|
||||
try:
|
||||
qv = float(qn)
|
||||
except ValueError:
|
||||
continue
|
||||
for nn in name_nums:
|
||||
try:
|
||||
if abs(qv - float(nn)) <= FAT_CLOSE:
|
||||
return True
|
||||
except ValueError:
|
||||
if qn == nn:
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def name_tokens(raw: str | None) -> list[str]:
|
||||
return [t for t in SPLIT_RE.split(normalize_food_name(raw)) if len(t) >= 2]
|
||||
text = normalize_food_name(raw)
|
||||
nums = number_tokens(text)
|
||||
words = [t for t in SPLIT_RE.split(NUM_RE.sub(" ", text)) if len(t) >= 2]
|
||||
return words + nums
|
||||
|
||||
|
||||
def score_name_match(query: str, name_de: str, name_en: str | None = None) -> int:
|
||||
qn = normalize_food_name((query or "").split(",")[0])
|
||||
qn = normalize_food_name(primary_search_query(query))
|
||||
nn = normalize_food_name(name_de)
|
||||
if not qn or not nn:
|
||||
return 0
|
||||
qc, nc = collapse_key(qn), collapse_key(nn)
|
||||
q_nums, n_nums = number_tokens(qn), number_tokens(nn)
|
||||
fat_ok = numbers_compatible(q_nums, n_nums)
|
||||
if qn == nn:
|
||||
return 100
|
||||
if qc and qc == nc:
|
||||
return 95
|
||||
qt, nt = set(name_tokens(qn)), set(name_tokens(nn))
|
||||
q_words = {t for t in qt if not is_number_token(t)}
|
||||
n_words = {t for t in nt if not is_number_token(t)}
|
||||
words_overlap = bool(q_words and n_words and (q_words & n_words or q_words <= n_words))
|
||||
if fat_ok and words_overlap:
|
||||
return 96
|
||||
if fat_ok is False:
|
||||
base = 0
|
||||
if qc and nc.startswith(qc) and len(qc) >= 4:
|
||||
base = 82
|
||||
elif nc and qc.startswith(nc) and len(nc) >= 4:
|
||||
base = 78
|
||||
elif qt and qt <= nt:
|
||||
base = 72
|
||||
elif nt and nt <= qt:
|
||||
base = 68
|
||||
elif qt and nt:
|
||||
overlap = len(qt & nt) / len(qt | nt)
|
||||
if overlap >= 0.5:
|
||||
base = 50 + int(overlap * 20)
|
||||
elif qc and nc and len(qc) >= 4 and (qc in nc or nc in qc):
|
||||
base = 55 if abs(len(qc) - len(nc)) <= 8 else 46
|
||||
return min(base, 52) if base else 0
|
||||
if qc and nc.startswith(qc) and len(qc) >= 4:
|
||||
return 82
|
||||
if nc and qc.startswith(nc) and len(nc) >= 4:
|
||||
return 78
|
||||
qt, nt = set(name_tokens(qn)), set(name_tokens(nn))
|
||||
if qt and qt <= nt:
|
||||
return 72
|
||||
if nt and nt <= qt:
|
||||
@@ -148,15 +222,27 @@ def _candidate_foods(index: dict[str, Any], query: str) -> list[dict[str, Any]]:
|
||||
if len(suffix_hits) <= MAX_BUCKET:
|
||||
for food in suffix_hits:
|
||||
add(food)
|
||||
q_words = [t for t in name_tokens(query) if not is_number_token(t)]
|
||||
seen_tok: set[str] = set()
|
||||
for tok in name_tokens(query):
|
||||
token_hits = index["by_token"].get(tok, [])
|
||||
if len(token_hits) > MAX_BUCKET:
|
||||
token_hits = sorted(token_hits, key=lambda f: len(f.get("name_de") or ""))[:MAX_BUCKET]
|
||||
for food in token_hits:
|
||||
add(food)
|
||||
if len(out) >= MAX_CANDIDATES:
|
||||
probes = number_search_aliases(tok) if is_number_token(tok) else [tok]
|
||||
for probe in probes:
|
||||
if probe in seen_tok:
|
||||
continue
|
||||
seen_tok.add(probe)
|
||||
token_hits = index["by_token"].get(probe, [])
|
||||
if is_number_token(probe) and q_words:
|
||||
token_hits = [
|
||||
food for food in token_hits
|
||||
if set(q_words) & set(food.get("_t") or [])
|
||||
]
|
||||
elif not is_number_token(probe) and len(token_hits) > MAX_BUCKET:
|
||||
token_hits = sorted(token_hits, key=lambda f: len(f.get("name_de") or ""))[:MAX_BUCKET]
|
||||
for food in token_hits:
|
||||
add(food)
|
||||
if len(out) >= MAX_CANDIDATES and not any(is_number_token(t) for t in name_tokens(query)):
|
||||
break
|
||||
return out[:MAX_CANDIDATES]
|
||||
return out[:MAX_CANDIDATES] if not number_tokens(query) else out
|
||||
|
||||
|
||||
def suggest_for_name(index: dict[str, Any], query: str, limit: int = 3) -> dict[str, Any]:
|
||||
@@ -196,11 +282,22 @@ def suggest_catalog_foods_ranked(cur, query: str, profile_id: str | None, limit:
|
||||
if len(q) < 2:
|
||||
return []
|
||||
index = get_suggest_index(cur, profile_id)
|
||||
packed = suggest_for_name(index, q, limit=limit)
|
||||
if packed["suggestions"]:
|
||||
return packed["suggestions"]
|
||||
packed = suggest_for_name(index, q, limit=max(limit, 8))
|
||||
hits = list(packed["suggestions"])
|
||||
from data_layer.food_mapping import suggest_catalog_foods
|
||||
return suggest_catalog_foods(cur, q, profile_id, limit=limit)
|
||||
if number_tokens(q) or not hits:
|
||||
seen = {str(h["id"]) for h in hits}
|
||||
for row in suggest_catalog_foods(cur, q, profile_id, limit=max(limit, 20)):
|
||||
fid = str(row["id"])
|
||||
if fid in seen:
|
||||
continue
|
||||
seen.add(fid)
|
||||
score = score_name_match(q, row.get("name_de") or "", row.get("name_en"))
|
||||
if score < MIN_SCORE and not number_tokens(q):
|
||||
continue
|
||||
hits.append(_public(row, score or 40))
|
||||
hits.sort(key=lambda h: (-int(h.get("score") or 0), h.get("name_de") or ""))
|
||||
return hits[:limit]
|
||||
|
||||
|
||||
def suggest_batch(cur, profile_id: str | None, names: list[str], limit: int = 3) -> dict[str, dict[str, Any]]:
|
||||
|
||||
Reference in new issue
Block a user