Stelle den Frontend-MVP und die v0.3-API auf develop bereit, damit Dev API und PWA zusammen deployen.
Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
1 parent
827e6a2a11
commit
b276758ee1
152 files changed
+25846
-34
No files matched your search
@@ -0,0 +1,545 @@
|
||||
from collections.abc import Sequence
|
||||
from datetime import datetime, timedelta
|
||||
from decimal import Decimal
|
||||
from typing import Any
|
||||
|
||||
from app.domain.attributes import select_attribute_snapshot
|
||||
from app.domain.constraints import evaluate_constraint
|
||||
from app.domain.enums import (
|
||||
Availability,
|
||||
ConstraintStatus,
|
||||
Eligibility,
|
||||
PriceReferenceScope,
|
||||
)
|
||||
from app.domain.models import (
|
||||
AttributeDefinition,
|
||||
AttributeStatement,
|
||||
ConstraintResult,
|
||||
EvaluationResult,
|
||||
GateResult,
|
||||
Offer,
|
||||
PriceObservation,
|
||||
Product,
|
||||
ProductVariant,
|
||||
Profile,
|
||||
Reason,
|
||||
ScoreComponent,
|
||||
ScoringModel,
|
||||
)
|
||||
from app.domain.serialize import jsonable
|
||||
from app.scoring.deal import classification_for, derive_eligible, eligibility_from_parts, score_deal
|
||||
from app.scoring.mathutil import round_score
|
||||
from app.scoring.price import (
|
||||
build_offer_reference_history,
|
||||
price_statistics_from_windows,
|
||||
score_price,
|
||||
select_current_observation,
|
||||
)
|
||||
from app.scoring.product import score_product
|
||||
|
||||
|
||||
def evaluate_deal(
|
||||
*,
|
||||
profile: Profile,
|
||||
scoring_model: ScoringModel,
|
||||
product: Product,
|
||||
variant: ProductVariant,
|
||||
offer: Offer,
|
||||
attributes: tuple[AttributeStatement, ...],
|
||||
observations: tuple[PriceObservation, ...],
|
||||
definitions: dict[str, AttributeDefinition],
|
||||
as_of: datetime,
|
||||
snapshot_cutoff: datetime,
|
||||
engine_build: str,
|
||||
) -> EvaluationResult:
|
||||
observations = tuple(item for item in observations if item.offer_id == offer.id)
|
||||
snapshot = select_attribute_snapshot(attributes, as_of=as_of, snapshot_cutoff=snapshot_cutoff)
|
||||
constraint_results = tuple(
|
||||
evaluate_constraint(
|
||||
constraint,
|
||||
snapshot.get(constraint.attribute),
|
||||
definitions[constraint.attribute],
|
||||
scoring_model.minimum_confidence,
|
||||
)
|
||||
for constraint in profile.constraints
|
||||
)
|
||||
product_gates, product_eligibility = _product_eligibility(profile, product, constraint_results)
|
||||
product_score_raw, coverage, preference_components = score_product(
|
||||
profile.preferences,
|
||||
snapshot,
|
||||
constraint_results,
|
||||
scoring_model,
|
||||
)
|
||||
|
||||
current = select_current_observation(observations, as_of=as_of, snapshot_cutoff=snapshot_cutoff)
|
||||
offer_gates, offer_eligibility = _offer_eligibility(profile, offer, current, scoring_model, as_of)
|
||||
overall = eligibility_from_parts(product_eligibility, offer_eligibility)
|
||||
|
||||
windows: dict[int, Any] = {}
|
||||
price_score_raw: Decimal | None = None
|
||||
budget_score: Decimal | None = None
|
||||
history_score: Decimal | None = None
|
||||
price_basis = None
|
||||
history_warning: str | None = None
|
||||
if _can_score_price(current, profile, scoring_model, as_of):
|
||||
windows = build_offer_reference_history(observations, current, scoring_model)
|
||||
price_score_raw, budget_score, history_score, price_basis, history_warning = score_price(
|
||||
current_price=current.total_price,
|
||||
reference_history=windows[90].values,
|
||||
budget=profile.budget,
|
||||
model=scoring_model,
|
||||
)
|
||||
|
||||
stats = price_statistics_from_windows(current, windows)
|
||||
deal_score_raw = None
|
||||
if overall == Eligibility.ELIGIBLE and price_score_raw is not None:
|
||||
deal_score_raw = score_deal(product_score_raw, price_score_raw, scoring_model)
|
||||
|
||||
classification = classification_for(overall, deal_score_raw, scoring_model)
|
||||
reasons, warnings = _reasons(
|
||||
constraint_results,
|
||||
product_gates,
|
||||
offer_gates,
|
||||
stats,
|
||||
current,
|
||||
history_warning,
|
||||
price_score_raw,
|
||||
)
|
||||
components = _all_components(
|
||||
preference_components,
|
||||
product_gates,
|
||||
offer_gates,
|
||||
budget_score,
|
||||
history_score,
|
||||
scoring_model,
|
||||
)
|
||||
input_snapshot = {
|
||||
"profile": profile.definition,
|
||||
"scoring_model": scoring_model.definition,
|
||||
"product": jsonable(_product_dict(product)),
|
||||
"variant": jsonable(_variant_dict(variant)),
|
||||
"offer": jsonable(_offer_dict(offer)),
|
||||
"attribute_snapshot": {
|
||||
key: jsonable(_attribute_dict(value))
|
||||
for key, value in snapshot.items()
|
||||
},
|
||||
"current_observation": None if current is None else jsonable(_observation_dict(current)),
|
||||
"history_observation_ids": [str(item) for item in stats.used_observation_ids],
|
||||
"as_of": jsonable(as_of),
|
||||
"snapshot_cutoff": jsonable(snapshot_cutoff),
|
||||
"price_reference_scope": PriceReferenceScope.OFFER.value,
|
||||
"unrounded": {
|
||||
"product_score": jsonable(product_score_raw),
|
||||
"price_score": jsonable(price_score_raw),
|
||||
"deal_score": jsonable(deal_score_raw),
|
||||
"budget_score": jsonable(budget_score),
|
||||
"history_score": jsonable(history_score),
|
||||
},
|
||||
}
|
||||
return EvaluationResult(
|
||||
profile_id=profile.id,
|
||||
profile_version=profile.version,
|
||||
scoring_version=scoring_model.version,
|
||||
scoring_hash=scoring_model.definition_hash,
|
||||
engine_build=engine_build,
|
||||
variant_id=variant.id,
|
||||
offer_id=offer.id,
|
||||
as_of=as_of,
|
||||
snapshot_cutoff=snapshot_cutoff,
|
||||
product_eligibility=product_eligibility,
|
||||
offer_eligibility=offer_eligibility,
|
||||
overall_eligibility=overall,
|
||||
eligible=derive_eligible(overall),
|
||||
product_score=round_score(product_score_raw),
|
||||
product_score_raw=product_score_raw,
|
||||
price_score=None if price_score_raw is None else round_score(price_score_raw),
|
||||
price_score_raw=price_score_raw,
|
||||
deal_score=None if deal_score_raw is None else round_score(deal_score_raw),
|
||||
deal_score_raw=deal_score_raw,
|
||||
classification=classification,
|
||||
price_basis=price_basis,
|
||||
product_coverage=coverage,
|
||||
constraint_results=constraint_results,
|
||||
product_gates=product_gates,
|
||||
offer_gates=offer_gates,
|
||||
components=components,
|
||||
price_statistics=stats,
|
||||
price_reference_scope=PriceReferenceScope.OFFER,
|
||||
reasons=reasons,
|
||||
warnings=warnings,
|
||||
input_snapshot=input_snapshot,
|
||||
failed_constraints=tuple(
|
||||
item for item in constraint_results if item.status == ConstraintStatus.FAIL.value
|
||||
),
|
||||
unknown_constraints=tuple(
|
||||
item for item in constraint_results if item.status == ConstraintStatus.UNKNOWN.value
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
def statement_price_confidence(observation: PriceObservation, model: ScoringModel) -> bool:
|
||||
return observation.confidence >= model.minimum_confidence
|
||||
|
||||
|
||||
def _fresh_enough(observation: PriceObservation, as_of: datetime, model: ScoringModel) -> bool:
|
||||
return as_of - observation.observed_at <= timedelta(hours=model.maximum_price_age_hours)
|
||||
|
||||
|
||||
def _product_eligibility(
|
||||
profile: Profile,
|
||||
product: Product,
|
||||
constraint_results: tuple[ConstraintResult, ...],
|
||||
) -> tuple[tuple[GateResult, ...], Eligibility]:
|
||||
category_ok = product.category == profile.category
|
||||
category_gate = GateResult(
|
||||
key="category",
|
||||
status="PASS" if category_ok else "FAIL",
|
||||
reason_code="CATEGORY_MATCH" if category_ok else "CATEGORY_MISMATCH",
|
||||
details={"expected": profile.category, "actual": product.category},
|
||||
)
|
||||
mandatory = [item for item in constraint_results if item.mandatory]
|
||||
if not category_ok or any(item.status == ConstraintStatus.FAIL.value for item in mandatory):
|
||||
eligibility = Eligibility.INELIGIBLE
|
||||
elif any(item.status == ConstraintStatus.UNKNOWN.value for item in mandatory):
|
||||
eligibility = Eligibility.UNKNOWN
|
||||
else:
|
||||
eligibility = Eligibility.ELIGIBLE
|
||||
return (category_gate,), eligibility
|
||||
|
||||
|
||||
def _offer_eligibility(
|
||||
profile: Profile,
|
||||
offer: Offer,
|
||||
current: PriceObservation | None,
|
||||
model: ScoringModel,
|
||||
as_of: datetime,
|
||||
) -> tuple[tuple[GateResult, ...], Eligibility]:
|
||||
gates: list[GateResult] = []
|
||||
|
||||
market_ok = offer.market == profile.market
|
||||
gates.append(_gate("market", market_ok, "MARKET_MATCH", "MARKET_MISMATCH", offer.market, profile.market))
|
||||
|
||||
condition_ok = offer.condition in profile.allowed_conditions
|
||||
gates.append(
|
||||
_gate(
|
||||
"condition",
|
||||
condition_ok,
|
||||
"CONDITION_ALLOWED",
|
||||
"CONDITION_NOT_ALLOWED",
|
||||
offer.condition.value,
|
||||
[item.value for item in profile.allowed_conditions],
|
||||
)
|
||||
)
|
||||
|
||||
currency_ok = offer.currency == profile.currency
|
||||
gates.append(_gate("currency", currency_ok, "CURRENCY_MATCH", "CURRENCY_MISMATCH", offer.currency, profile.currency))
|
||||
|
||||
if current is None:
|
||||
gates.append(GateResult("price_present", "UNKNOWN", "PRICE_MISSING", {}))
|
||||
gates.append(GateResult("price_fresh", "UNKNOWN", "PRICE_MISSING", {}))
|
||||
gates.append(GateResult("price_confidence", "UNKNOWN", "PRICE_MISSING", {}))
|
||||
gates.append(GateResult("shipping", "UNKNOWN", "SHIPPING_UNKNOWN", {}))
|
||||
gates.append(GateResult("budget", "UNKNOWN", "PRICE_MISSING", {}))
|
||||
gates.append(GateResult("availability", "UNKNOWN", "AVAILABILITY_UNKNOWN", {}))
|
||||
return tuple(gates), _combine_offer_gates(gates)
|
||||
|
||||
fresh = _fresh_enough(current, as_of, model)
|
||||
if not fresh:
|
||||
gates.append(GateResult("price_present", "UNKNOWN", "PRICE_STALE", {"observed_at": current.observed_at.isoformat()}))
|
||||
gates.append(GateResult("price_fresh", "UNKNOWN", "PRICE_STALE", {}))
|
||||
else:
|
||||
gates.append(GateResult("price_present", "PASS", "PRICE_PRESENT", {"observation_id": str(current.id)}))
|
||||
gates.append(GateResult("price_fresh", "PASS", "PRICE_FRESH", {}))
|
||||
|
||||
confident = statement_price_confidence(current, model)
|
||||
gates.append(
|
||||
GateResult(
|
||||
"price_confidence",
|
||||
"PASS" if confident else "UNKNOWN",
|
||||
"PRICE_CONFIDENCE_OK" if confident else "PRICE_LOW_CONFIDENCE",
|
||||
{"confidence": str(current.confidence)},
|
||||
)
|
||||
)
|
||||
|
||||
shipping_known = current.shipping_price is not None
|
||||
gates.append(
|
||||
GateResult(
|
||||
"shipping",
|
||||
"PASS" if shipping_known else "UNKNOWN",
|
||||
"SHIPPING_KNOWN" if shipping_known else "SHIPPING_UNKNOWN",
|
||||
{},
|
||||
)
|
||||
)
|
||||
|
||||
total = current.total_price
|
||||
if total is None or not currency_ok:
|
||||
gates.append(GateResult("budget", "UNKNOWN", "PRICE_INCOMPLETE", {}))
|
||||
elif total <= profile.budget.maximum:
|
||||
gates.append(GateResult("budget", "PASS", "WITHIN_BUDGET", {"total": str(total)}))
|
||||
else:
|
||||
gates.append(GateResult("budget", "FAIL", "OVER_BUDGET", {"total": str(total)}))
|
||||
|
||||
if current.availability == Availability.IN_STOCK:
|
||||
gates.append(GateResult("availability", "PASS", "IN_STOCK", {}))
|
||||
elif current.availability == Availability.OUT_OF_STOCK:
|
||||
gates.append(GateResult("availability", "FAIL", "OUT_OF_STOCK", {}))
|
||||
else:
|
||||
gates.append(GateResult("availability", "UNKNOWN", "AVAILABILITY_UNKNOWN", {}))
|
||||
|
||||
if current.currency != offer.currency:
|
||||
gates.append(GateResult("observation_currency", "FAIL", "CURRENCY_MISMATCH", {}))
|
||||
|
||||
if current.source_id != offer.source_id:
|
||||
gates.append(GateResult("observation_source", "FAIL", "SOURCE_MISMATCH", {}))
|
||||
|
||||
return tuple(gates), _combine_offer_gates(gates)
|
||||
|
||||
|
||||
def _gate(key: str, ok: bool, pass_code: str, fail_code: str, actual: Any, expected: Any) -> GateResult:
|
||||
return GateResult(
|
||||
key=key,
|
||||
status="PASS" if ok else "FAIL",
|
||||
reason_code=pass_code if ok else fail_code,
|
||||
details={"actual": actual, "expected": expected},
|
||||
)
|
||||
|
||||
|
||||
def _can_score_price(
|
||||
current: PriceObservation | None,
|
||||
profile: Profile,
|
||||
model: ScoringModel,
|
||||
as_of: datetime,
|
||||
) -> bool:
|
||||
if current is None:
|
||||
return False
|
||||
if current.currency != profile.currency:
|
||||
return False
|
||||
if current.total_price is None:
|
||||
return False
|
||||
if not _fresh_enough(current, as_of, model):
|
||||
return False
|
||||
return statement_price_confidence(current, model)
|
||||
|
||||
|
||||
def _combine_offer_gates(gates: Sequence[GateResult]) -> Eligibility:
|
||||
statuses = [gate.status for gate in gates]
|
||||
if "FAIL" in statuses:
|
||||
return Eligibility.INELIGIBLE
|
||||
if "UNKNOWN" in statuses:
|
||||
return Eligibility.UNKNOWN
|
||||
return Eligibility.ELIGIBLE
|
||||
|
||||
|
||||
def _reasons(
|
||||
constraints: tuple[ConstraintResult, ...],
|
||||
product_gates: tuple[GateResult, ...],
|
||||
offer_gates: tuple[GateResult, ...],
|
||||
stats,
|
||||
current: PriceObservation | None,
|
||||
history_warning: str | None,
|
||||
price_score_raw: Decimal | None,
|
||||
) -> tuple[tuple[Reason, ...], tuple[str, ...]]:
|
||||
reasons: list[Reason] = []
|
||||
warnings: list[str] = []
|
||||
for gate in (*product_gates, *offer_gates):
|
||||
if gate.status != "PASS":
|
||||
reasons.append(Reason(gate.reason_code, _gate_message(gate)))
|
||||
for item in constraints:
|
||||
if item.status != ConstraintStatus.PASS.value:
|
||||
reasons.append(Reason(item.reason_code, _constraint_message(item)))
|
||||
if history_warning:
|
||||
warnings.append(history_warning)
|
||||
reasons.append(Reason(history_warning, "Zu wenige Historientage für den 90-Tage-Median."))
|
||||
if stats.lowest_365d is not None and not stats.lowest_365d_is_full_year:
|
||||
warnings.append("LOWEST_365D_PARTIAL")
|
||||
reasons.append(
|
||||
Reason(
|
||||
"LOWEST_365D_PARTIAL",
|
||||
f"lowest_365d {stats.lowest_365d} ist das Minimum der vorhandenen {stats.lowest_365d_days} Tage, kein belegtes Jahrestief.",
|
||||
)
|
||||
)
|
||||
if (
|
||||
price_score_raw is not None
|
||||
and current is not None
|
||||
and current.total_price is not None
|
||||
and stats.median_90d is not None
|
||||
and stats.median_90d != 0
|
||||
):
|
||||
delta = (stats.median_90d - current.total_price) / stats.median_90d * Decimal("100")
|
||||
percent = round_score(delta)
|
||||
if current.total_price < stats.median_90d:
|
||||
reasons.append(
|
||||
Reason(
|
||||
"PRICE_BELOW_MEDIAN",
|
||||
f"Gesamtpreis {_de_decimal(percent)} % unter dem Median der beobachteten 90-Tage-Historie.",
|
||||
)
|
||||
)
|
||||
elif current.total_price > stats.median_90d:
|
||||
reasons.append(
|
||||
Reason(
|
||||
"PRICE_ABOVE_MEDIAN",
|
||||
f"Gesamtpreis {_de_decimal(percent.copy_abs())} % über dem Median der beobachteten 90-Tage-Historie.",
|
||||
)
|
||||
)
|
||||
else:
|
||||
reasons.append(Reason("PRICE_AT_MEDIAN", "Gesamtpreis entspricht dem Median der 90-Tage-Historie."))
|
||||
return tuple(reasons), tuple(warnings)
|
||||
|
||||
|
||||
def _de_decimal(value: Decimal) -> str:
|
||||
return format(value, "f").replace(".", ",")
|
||||
|
||||
|
||||
def _gate_message(gate: GateResult) -> str:
|
||||
messages = {
|
||||
"CATEGORY_MISMATCH": "Die Produktkategorie entspricht nicht dem Profil.",
|
||||
"MARKET_MISMATCH": "Der Angebotsmarkt entspricht nicht dem Profil.",
|
||||
"CONDITION_NOT_ALLOWED": "Der Angebotszustand ist im Profil nicht erlaubt.",
|
||||
"CURRENCY_MISMATCH": "Die Währung entspricht nicht dem Profil.",
|
||||
"PRICE_MISSING": "Es liegt keine aktuelle Preisbeobachtung vor.",
|
||||
"PRICE_STALE": "Die aktuelle Preisbeobachtung ist nicht frisch genug.",
|
||||
"PRICE_LOW_CONFIDENCE": "Die Preis-Confidence liegt unter der Mindestschwelle.",
|
||||
"SHIPPING_UNKNOWN": "Obligatorische Versandkosten sind unbekannt.",
|
||||
"OVER_BUDGET": "Der Gesamtpreis liegt über dem Budgetmaximum.",
|
||||
"OUT_OF_STOCK": "Das Angebot ist nicht lieferbar.",
|
||||
"AVAILABILITY_UNKNOWN": "Die Verfügbarkeit ist unbekannt.",
|
||||
"SOURCE_MISMATCH": "Die Beobachtungsquelle weicht vom Angebot ab.",
|
||||
}
|
||||
return messages.get(gate.reason_code, gate.reason_code)
|
||||
|
||||
|
||||
def _constraint_message(item: ConstraintResult) -> str:
|
||||
if item.status == ConstraintStatus.FAIL.value:
|
||||
return f"Constraint {item.constraint_id} ist nicht erfüllt."
|
||||
return f"Constraint {item.constraint_id} kann nicht bewertet werden."
|
||||
|
||||
|
||||
def _all_components(
|
||||
preference_components: tuple[ScoreComponent, ...],
|
||||
product_gates: tuple[GateResult, ...],
|
||||
offer_gates: tuple[GateResult, ...],
|
||||
budget_score: Decimal | None,
|
||||
history_score: Decimal | None,
|
||||
model: ScoringModel,
|
||||
) -> tuple[ScoreComponent, ...]:
|
||||
extra: list[ScoreComponent] = list(preference_components)
|
||||
if budget_score is not None:
|
||||
extra.append(
|
||||
ScoreComponent(
|
||||
kind="budget",
|
||||
component_key="budget",
|
||||
raw_score=budget_score,
|
||||
weight=model.budget_weight,
|
||||
contribution=model.budget_weight * budget_score,
|
||||
details={},
|
||||
)
|
||||
)
|
||||
if history_score is not None:
|
||||
extra.append(
|
||||
ScoreComponent(
|
||||
kind="history",
|
||||
component_key="history",
|
||||
raw_score=history_score,
|
||||
weight=model.history_weight,
|
||||
contribution=model.history_weight * history_score,
|
||||
details={},
|
||||
)
|
||||
)
|
||||
for gate in product_gates:
|
||||
extra.append(
|
||||
ScoreComponent(
|
||||
kind="product_gate",
|
||||
component_key=gate.key,
|
||||
raw_score=None,
|
||||
weight=None,
|
||||
contribution=None,
|
||||
details={"status": gate.status, "reason_code": gate.reason_code, **gate.details},
|
||||
)
|
||||
)
|
||||
for gate in offer_gates:
|
||||
extra.append(
|
||||
ScoreComponent(
|
||||
kind="offer_gate",
|
||||
component_key=gate.key,
|
||||
raw_score=None,
|
||||
weight=None,
|
||||
contribution=None,
|
||||
details={"status": gate.status, "reason_code": gate.reason_code, **gate.details},
|
||||
)
|
||||
)
|
||||
return tuple(extra)
|
||||
|
||||
|
||||
def _product_dict(product: Product) -> dict[str, Any]:
|
||||
return {
|
||||
"id": product.id,
|
||||
"category": product.category,
|
||||
"brand": product.brand,
|
||||
"name": product.name,
|
||||
"model": product.model,
|
||||
"created_at": product.created_at,
|
||||
}
|
||||
|
||||
|
||||
def _variant_dict(variant: ProductVariant) -> dict[str, Any]:
|
||||
return {
|
||||
"id": variant.id,
|
||||
"product_id": variant.product_id,
|
||||
"name": variant.name,
|
||||
"manufacturer_sku": variant.manufacturer_sku,
|
||||
"identifiers": variant.identifiers,
|
||||
"created_at": variant.created_at,
|
||||
}
|
||||
|
||||
|
||||
def _offer_dict(offer: Offer) -> dict[str, Any]:
|
||||
return {
|
||||
"id": offer.id,
|
||||
"variant_id": offer.variant_id,
|
||||
"source_id": offer.source_id,
|
||||
"external_id": offer.external_id,
|
||||
"seller": offer.seller,
|
||||
"url": offer.url,
|
||||
"market": offer.market,
|
||||
"currency": offer.currency,
|
||||
"condition": offer.condition,
|
||||
"created_at": offer.created_at,
|
||||
}
|
||||
|
||||
|
||||
def _attribute_dict(statement: AttributeStatement) -> dict[str, Any]:
|
||||
return {
|
||||
"id": statement.id,
|
||||
"variant_id": statement.variant_id,
|
||||
"attribute": statement.attribute,
|
||||
"raw_value": statement.raw_value,
|
||||
"normalized_value": statement.normalized_value,
|
||||
"unit": statement.unit,
|
||||
"normalization_status": statement.normalization_status,
|
||||
"normalizer_version": statement.normalizer_version,
|
||||
"confidence": statement.confidence,
|
||||
"source_id": statement.source_id,
|
||||
"source_reference": statement.source_reference,
|
||||
"observed_at": statement.observed_at,
|
||||
"ingested_at": statement.ingested_at,
|
||||
"normalization_error": statement.normalization_error,
|
||||
}
|
||||
|
||||
|
||||
def _observation_dict(observation: PriceObservation) -> dict[str, Any]:
|
||||
return {
|
||||
"id": observation.id,
|
||||
"offer_id": observation.offer_id,
|
||||
"source_id": observation.source_id,
|
||||
"external_observation_id": observation.external_observation_id,
|
||||
"observed_at": observation.observed_at,
|
||||
"ingested_at": observation.ingested_at,
|
||||
"item_price": observation.item_price,
|
||||
"shipping_price": observation.shipping_price,
|
||||
"currency": observation.currency,
|
||||
"availability": observation.availability,
|
||||
"raw_payload": observation.raw_payload,
|
||||
"confidence": observation.confidence,
|
||||
"total_price": observation.total_price,
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user