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,307 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
from decimal import Decimal
|
||||
from typing import Any
|
||||
|
||||
from app.domain.constraints import operator_allowed_for
|
||||
from app.domain.enums import (
|
||||
ConstraintOperator,
|
||||
OfferCondition,
|
||||
PreferenceDirection,
|
||||
PreferenceStrategy,
|
||||
ValueType,
|
||||
)
|
||||
from app.domain.models import (
|
||||
AttributeDefinition,
|
||||
Budget,
|
||||
ClassificationBound,
|
||||
Constraint,
|
||||
Preference,
|
||||
Profile,
|
||||
ScoringModel,
|
||||
)
|
||||
|
||||
SNAKE_CASE = r"^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$"
|
||||
CURRENCY = r"^[A-Z]{3}$"
|
||||
SUPPORTED_ALGORITHM = "linear-budget-history-v1"
|
||||
|
||||
|
||||
class DomainValidationError(ValueError):
|
||||
def __init__(self, message: str, details: dict[str, Any] | None = None) -> None:
|
||||
super().__init__(message)
|
||||
self.details = details or {}
|
||||
|
||||
|
||||
def canonical_json(data: Any) -> str:
|
||||
return json.dumps(data, sort_keys=True, separators=(",", ":"), ensure_ascii=False)
|
||||
|
||||
|
||||
def sha256_text(text: str) -> str:
|
||||
return hashlib.sha256(text.encode("utf-8")).hexdigest()
|
||||
|
||||
|
||||
def _decimal(value: Any, field: str) -> Decimal:
|
||||
if isinstance(value, bool) or value is None:
|
||||
raise DomainValidationError(f"{field} must be a decimal", {"field": field})
|
||||
try:
|
||||
return Decimal(str(value))
|
||||
except Exception as exc:
|
||||
raise DomainValidationError(f"{field} must be a decimal", {"field": field}) from exc
|
||||
|
||||
|
||||
def _require(mapping: dict[str, Any], key: str) -> Any:
|
||||
if key not in mapping:
|
||||
raise DomainValidationError(f"missing field {key}", {"field": key})
|
||||
return mapping[key]
|
||||
|
||||
|
||||
def validate_attribute_key(key: str) -> None:
|
||||
import re
|
||||
|
||||
if not re.fullmatch(SNAKE_CASE, key):
|
||||
raise DomainValidationError("attribute key must be snake_case", {"key": key})
|
||||
|
||||
|
||||
def validate_currency(value: str) -> str:
|
||||
import re
|
||||
|
||||
if not re.fullmatch(CURRENCY, value):
|
||||
raise DomainValidationError("currency must be a 3-letter uppercase code", {"currency": value})
|
||||
return value
|
||||
|
||||
|
||||
def parse_scoring_model(definition: dict[str, Any]) -> ScoringModel:
|
||||
version = str(_require(definition, "version"))
|
||||
algorithm_id = str(_require(definition, "algorithm_id"))
|
||||
if algorithm_id != SUPPORTED_ALGORITHM:
|
||||
raise DomainValidationError("unsupported algorithm_id", {"algorithm_id": algorithm_id})
|
||||
strategies = tuple(str(item) for item in _require(definition, "supported_preference_strategies"))
|
||||
if not strategies:
|
||||
raise DomainValidationError("supported_preference_strategies must not be empty")
|
||||
if PreferenceStrategy.NUMERIC_LINEAR.value not in strategies:
|
||||
raise DomainValidationError("generic-v1 must support numeric_linear")
|
||||
|
||||
min_conf = _decimal(_require(definition, "minimum_confidence"), "minimum_confidence")
|
||||
if not Decimal("0") <= min_conf <= Decimal("1"):
|
||||
raise DomainValidationError("minimum_confidence must be between 0 and 1")
|
||||
|
||||
max_age = int(_require(definition, "maximum_price_age_hours"))
|
||||
history_window = int(_require(definition, "history_window_days"))
|
||||
min_history = int(_require(definition, "minimum_history_days"))
|
||||
if max_age <= 0 or history_window <= 0 or min_history <= 0:
|
||||
raise DomainValidationError("time windows must be positive")
|
||||
|
||||
product_weight = _decimal(_require(definition, "product_weight"), "product_weight")
|
||||
price_weight = _decimal(_require(definition, "price_weight"), "price_weight")
|
||||
budget_weight = _decimal(_require(definition, "budget_weight"), "budget_weight")
|
||||
history_weight = _decimal(_require(definition, "history_weight"), "history_weight")
|
||||
for name, weight in (
|
||||
("product_weight", product_weight),
|
||||
("price_weight", price_weight),
|
||||
("budget_weight", budget_weight),
|
||||
("history_weight", history_weight),
|
||||
):
|
||||
if weight < 0:
|
||||
raise DomainValidationError(f"{name} must be non-negative")
|
||||
if product_weight + price_weight != Decimal("1"):
|
||||
raise DomainValidationError("product_weight + price_weight must equal 1")
|
||||
if budget_weight + history_weight != Decimal("1"):
|
||||
raise DomainValidationError("budget_weight + history_weight must equal 1")
|
||||
|
||||
bounds_raw = _require(definition, "classification_upper_bounds")
|
||||
bounds: list[ClassificationBound] = []
|
||||
previous = Decimal("0")
|
||||
for index, raw in enumerate(bounds_raw):
|
||||
upper = _decimal(raw["upper"], f"classification_upper_bounds[{index}].upper")
|
||||
inclusive = bool(raw["inclusive"])
|
||||
label = str(raw["label"])
|
||||
if upper < previous or (index and upper == previous):
|
||||
raise DomainValidationError("classification bounds must be strictly ascending")
|
||||
if index == 0 and upper <= 0:
|
||||
raise DomainValidationError("classification bounds must start above 0")
|
||||
bounds.append(ClassificationBound(upper=upper, inclusive=inclusive, label=label))
|
||||
previous = upper
|
||||
if not bounds or bounds[-1].upper != Decimal("100"):
|
||||
raise DomainValidationError("classification bounds must end at 100")
|
||||
|
||||
canonical = json.loads(canonical_json(definition))
|
||||
return ScoringModel(
|
||||
version=version,
|
||||
algorithm_id=algorithm_id,
|
||||
supported_preference_strategies=strategies,
|
||||
minimum_confidence=min_conf,
|
||||
maximum_price_age_hours=max_age,
|
||||
optional_constraint_penalty_points=_decimal(
|
||||
_require(definition, "optional_constraint_penalty_points"),
|
||||
"optional_constraint_penalty_points",
|
||||
),
|
||||
missing_preference_score=_decimal(
|
||||
_require(definition, "missing_preference_score"),
|
||||
"missing_preference_score",
|
||||
),
|
||||
product_weight=product_weight,
|
||||
price_weight=price_weight,
|
||||
budget_weight=budget_weight,
|
||||
history_weight=history_weight,
|
||||
history_window_days=history_window,
|
||||
minimum_history_days=min_history,
|
||||
history_discount_for_max_score=_decimal(
|
||||
_require(definition, "history_discount_for_max_score"),
|
||||
"history_discount_for_max_score",
|
||||
),
|
||||
classification_upper_bounds=tuple(bounds),
|
||||
definition=canonical,
|
||||
definition_hash=sha256_text(canonical_json(canonical)),
|
||||
)
|
||||
|
||||
|
||||
def parse_profile(
|
||||
definition: dict[str, Any],
|
||||
*,
|
||||
attribute_definitions: dict[str, AttributeDefinition],
|
||||
scoring_versions: set[str],
|
||||
supported_strategies: set[str],
|
||||
) -> Profile:
|
||||
profile_id = str(_require(definition, "id"))
|
||||
version = int(_require(definition, "version"))
|
||||
if version <= 0:
|
||||
raise DomainValidationError("profile version must be > 0")
|
||||
name = str(_require(definition, "name"))
|
||||
category = str(_require(definition, "category"))
|
||||
if not category:
|
||||
raise DomainValidationError("category is required")
|
||||
currency = validate_currency(str(_require(definition, "currency")))
|
||||
market = str(_require(definition, "market"))
|
||||
if not market:
|
||||
raise DomainValidationError("market is required")
|
||||
raw_conditions = _require(definition, "allowed_conditions")
|
||||
if not raw_conditions:
|
||||
raise DomainValidationError("allowed_conditions is required")
|
||||
conditions = tuple(OfferCondition(item) for item in raw_conditions)
|
||||
scoring_version = str(_require(definition, "scoring_version"))
|
||||
if scoring_version not in scoring_versions:
|
||||
raise DomainValidationError("unknown scoring_version", {"scoring_version": scoring_version})
|
||||
|
||||
budget_raw = _require(definition, "budget")
|
||||
target = _decimal(_require(budget_raw, "target"), "budget.target")
|
||||
maximum = _decimal(_require(budget_raw, "maximum"), "budget.maximum")
|
||||
if not (Decimal("0") < target < maximum):
|
||||
raise DomainValidationError("budget must satisfy 0 < target < maximum")
|
||||
|
||||
constraints = _parse_constraints(_require(definition, "constraints"), attribute_definitions)
|
||||
preferences = _parse_preferences(
|
||||
_require(definition, "preferences"),
|
||||
attribute_definitions,
|
||||
supported_strategies,
|
||||
)
|
||||
canonical = json.loads(canonical_json(definition))
|
||||
return Profile(
|
||||
id=profile_id,
|
||||
version=version,
|
||||
name=name,
|
||||
category=category,
|
||||
currency=currency,
|
||||
market=market,
|
||||
allowed_conditions=conditions,
|
||||
budget=Budget(target=target, maximum=maximum),
|
||||
scoring_version=scoring_version,
|
||||
constraints=constraints,
|
||||
preferences=preferences,
|
||||
definition=canonical,
|
||||
definition_hash=sha256_text(canonical_json(canonical)),
|
||||
)
|
||||
|
||||
|
||||
def _parse_constraints(
|
||||
raw_items: list[dict[str, Any]],
|
||||
attribute_definitions: dict[str, AttributeDefinition],
|
||||
) -> tuple[Constraint, ...]:
|
||||
seen: set[str] = set()
|
||||
items: list[Constraint] = []
|
||||
for raw in raw_items:
|
||||
constraint_id = str(_require(raw, "id"))
|
||||
if constraint_id in seen:
|
||||
raise DomainValidationError("duplicate constraint id", {"id": constraint_id})
|
||||
seen.add(constraint_id)
|
||||
attribute = str(_require(raw, "attribute"))
|
||||
definition = attribute_definitions.get(attribute)
|
||||
if definition is None:
|
||||
raise DomainValidationError("unknown attribute key", {"attribute": attribute})
|
||||
operator = ConstraintOperator(str(_require(raw, "operator")))
|
||||
if not operator_allowed_for(definition.value_type, operator):
|
||||
raise DomainValidationError(
|
||||
"operator is not valid for attribute type",
|
||||
{"attribute": attribute, "operator": operator.value, "value_type": definition.value_type.value},
|
||||
)
|
||||
value = raw.get("value")
|
||||
if operator == ConstraintOperator.EXISTS:
|
||||
if "value" in raw and raw["value"] is not None:
|
||||
raise DomainValidationError("exists must not have a value", {"id": constraint_id})
|
||||
value = None
|
||||
elif operator == ConstraintOperator.IN:
|
||||
if not isinstance(value, list) or not value:
|
||||
raise DomainValidationError("in requires a non-empty list", {"id": constraint_id})
|
||||
elif operator == ConstraintOperator.CONTAINS:
|
||||
if not isinstance(value, str):
|
||||
raise DomainValidationError("contains requires a string", {"id": constraint_id})
|
||||
items.append(
|
||||
Constraint(
|
||||
id=constraint_id,
|
||||
attribute=attribute,
|
||||
operator=operator,
|
||||
value=value,
|
||||
mandatory=bool(raw.get("mandatory", True)),
|
||||
)
|
||||
)
|
||||
return tuple(items)
|
||||
|
||||
|
||||
def _parse_preferences(
|
||||
raw_items: list[dict[str, Any]],
|
||||
attribute_definitions: dict[str, AttributeDefinition],
|
||||
supported_strategies: set[str],
|
||||
) -> tuple[Preference, ...]:
|
||||
if not raw_items:
|
||||
raise DomainValidationError("at least one preference is required")
|
||||
seen: set[str] = set()
|
||||
items: list[Preference] = []
|
||||
for raw in raw_items:
|
||||
preference_id = str(_require(raw, "id"))
|
||||
if preference_id in seen:
|
||||
raise DomainValidationError("duplicate preference id", {"id": preference_id})
|
||||
seen.add(preference_id)
|
||||
attribute = str(_require(raw, "attribute"))
|
||||
definition = attribute_definitions.get(attribute)
|
||||
if definition is None:
|
||||
raise DomainValidationError("unknown attribute key", {"attribute": attribute})
|
||||
strategy = str(_require(raw, "strategy"))
|
||||
if strategy not in supported_strategies:
|
||||
raise DomainValidationError("unsupported preference strategy", {"strategy": strategy})
|
||||
if strategy != PreferenceStrategy.NUMERIC_LINEAR.value:
|
||||
raise DomainValidationError("v0.1 only supports numeric_linear", {"strategy": strategy})
|
||||
if definition.value_type != ValueType.NUMBER:
|
||||
raise DomainValidationError("numeric_linear requires a number attribute", {"attribute": attribute})
|
||||
direction = PreferenceDirection(str(_require(raw, "direction")))
|
||||
acceptable = _decimal(_require(raw, "acceptable"), "acceptable")
|
||||
ideal = _decimal(_require(raw, "ideal"), "ideal")
|
||||
weight = _decimal(_require(raw, "weight"), "weight")
|
||||
if weight <= 0:
|
||||
raise DomainValidationError("preference weight must be positive", {"id": preference_id})
|
||||
if direction == PreferenceDirection.HIGHER and not ideal > acceptable:
|
||||
raise DomainValidationError("higher requires ideal > acceptable", {"id": preference_id})
|
||||
if direction == PreferenceDirection.LOWER and not ideal < acceptable:
|
||||
raise DomainValidationError("lower requires ideal < acceptable", {"id": preference_id})
|
||||
items.append(
|
||||
Preference(
|
||||
id=preference_id,
|
||||
attribute=attribute,
|
||||
strategy=PreferenceStrategy.NUMERIC_LINEAR,
|
||||
direction=direction,
|
||||
acceptable=acceptable,
|
||||
ideal=ideal,
|
||||
weight=weight,
|
||||
)
|
||||
)
|
||||
return tuple(items)
|
||||
Reference in new issue
Block a user