2104ed879b
Replace unweighted AVG(deals_total_avg_area_m2) and AVG(deals_total_avg_price_thousand_rub_per_m2) with SUM(x * count) / NULLIF(SUM(count), 0) pattern in _INLINE_VELOCITY_SQL. Months with zero deals no longer dilute the weighted mean 2-4x. P0 follow-up to PR #290 (mv fix, issue #21).
734 lines
30 KiB
Python
734 lines
30 KiB
Python
"""Анализ лучших планировок конкурентов по velocity (Issue #113 Phase 2.1).
|
||
|
||
Источники:
|
||
cad_parcels_geom / cad_quarters_geom — центроид участка
|
||
domrf_kn_objects — ЖК в радиусе (latitude/longitude → geography)
|
||
objective_corpus_room_month — ежемесячные сделки по (project_name, room_bucket)
|
||
objective_complex_mapping — domrf_obj_id ↔ objective_complex_name
|
||
domrf_kn_flats — supply count по (room_bucket, area_bin)
|
||
|
||
Алгоритм:
|
||
Step 1: центроид участка (cad_parcels_geom → cad_quarters_geom fallback).
|
||
Step 2: obj_id конкурентов в радиусе (domrf_kn_objects + фильтры).
|
||
Step 3: inline SQL из objective_corpus_room_month с честным WHERE report_month фильтром.
|
||
Step 4: velocity_per_month = deals_window / months_in_window (честный time_window).
|
||
Step 5: supply side из domrf_kn_flats — один батч-запрос.
|
||
Step 6: per-row signature + sold_pct.
|
||
Step 7: фильтр min_velocity + sort + rank.
|
||
Step 8: build recommendation_for_tz (unit-mix, price, rationale).
|
||
Step 9: data_quality (coverage + confidence).
|
||
|
||
Fix SF-01: раньше mv_layout_velocity (24 мес) делился на divisor (4/12) — данные
|
||
не менялись при смене time_window. Теперь inline SQL с реальным фильтром report_month.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import datetime as dt
|
||
import logging
|
||
from typing import Any
|
||
|
||
from sqlalchemy import text
|
||
from sqlalchemy.orm import Session
|
||
|
||
from app.schemas.parcel import (
|
||
BestLayoutsRequest,
|
||
BestLayoutsResponse,
|
||
LayoutDataQuality,
|
||
LayoutTzMixRow,
|
||
LayoutTzRecommendation,
|
||
TopLayoutRow,
|
||
)
|
||
from app.services.site_finder.layout_signature import area_bin, layout_signature
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
# Confidence thresholds (per coverage % of objects with MV velocity data)
|
||
# Tune via PR if business feedback требует.
|
||
LAYOUT_CONFIDENCE_HIGH_PCT = 50.0
|
||
LAYOUT_CONFIDENCE_MEDIUM_PCT = 20.0
|
||
|
||
# Fix SF-09: cap доминирующего bucket чтобы рекомендация не зеркалила перекос рынка.
|
||
# Избыток перераспределяется пропорционально остальным bucket'ам.
|
||
MAX_BUCKET_SHARE_PCT = 35
|
||
|
||
# Параметры time_window: (PostgreSQL interval string, months divisor для velocity_per_month).
|
||
# Используются в _INLINE_VELOCITY_SQL — реальный фильтр по report_month.
|
||
# Fix SF-01: убраны _VELOCITY_DIVISORS, которые делили MV (24 мес) без изменения данных.
|
||
_TIME_WINDOW_PARAMS: dict[str, tuple[str, float]] = {
|
||
"last_month": ("1 month", 1.0),
|
||
"last_quarter": ("3 months", 3.0),
|
||
"last_year": ("12 months", 12.0),
|
||
}
|
||
|
||
# ── SQL: центроид участка ─────────────────────────────────────────────────────
|
||
|
||
_PARCEL_CENTROID_SQL = text("""
|
||
SELECT ST_X(pt) AS center_lon,
|
||
ST_Y(pt) AS center_lat
|
||
FROM (
|
||
SELECT ST_Centroid(geom) AS pt
|
||
FROM cad_parcels_geom
|
||
WHERE cad_num = :cad_num AND geom IS NOT NULL
|
||
UNION ALL
|
||
SELECT ST_Centroid(geom) AS pt
|
||
FROM cad_quarters_geom
|
||
WHERE cad_number = :quarter AND geom IS NOT NULL
|
||
) sub
|
||
LIMIT 1
|
||
""")
|
||
|
||
# ── SQL: obj_id конкурентов в радиусе ─────────────────────────────────────────
|
||
# Геометрия domrf_kn_objects вычисляется on-the-fly из (latitude, longitude)
|
||
# как ST_SetSRID(ST_MakePoint(longitude, latitude), 4326)::geography
|
||
# (consistency с competitors.py).
|
||
# obj_class_filter: NULL = все классы.
|
||
# filter_competitor_obj_ids: NULL = не фильтровать по списку.
|
||
|
||
_COMPETITORS_IN_RADIUS_SQL = text("""
|
||
SELECT DISTINCT ON (obj_id) obj_id
|
||
FROM domrf_kn_objects
|
||
WHERE latitude IS NOT NULL AND longitude IS NOT NULL
|
||
AND ST_DWithin(
|
||
ST_SetSRID(ST_MakePoint(longitude, latitude), 4326)::geography,
|
||
ST_SetSRID(
|
||
ST_MakePoint(CAST(:center_lon AS float), CAST(:center_lat AS float)),
|
||
4326
|
||
)::geography,
|
||
CAST(:radius_m AS float)
|
||
)
|
||
AND (
|
||
CAST(:obj_class_filter AS text) IS NULL
|
||
OR obj_class = CAST(:obj_class_filter AS text)
|
||
)
|
||
ORDER BY obj_id, snapshot_date DESC NULLS LAST
|
||
""")
|
||
|
||
# ── SQL: inline velocity из objective_corpus_room_month + mapping ─────────────
|
||
# Fix SF-01: честный фильтр по report_month вместо деления mv_layout_velocity (24 мес).
|
||
# Параметры:
|
||
# :window_interval — PostgreSQL interval string ('1 month', '3 months', '12 months')
|
||
# :competitor_obj_ids — list[int] obj_id конкурентов в радиусе
|
||
# CAST(:window_interval AS interval) — psycopg v3 / SQLAlchemy 2.0 safe (не ::interval).
|
||
|
||
_INLINE_VELOCITY_SQL = text("""
|
||
SELECT
|
||
CASE
|
||
WHEN crm.room_bucket = 'студия' THEN 'studio'
|
||
ELSE crm.room_bucket
|
||
END AS room_bucket,
|
||
SUM(crm.deals_total_count) AS deals_window,
|
||
COALESCE(
|
||
SUM(crm.deals_total_avg_area_m2 * crm.deals_total_count)
|
||
/ NULLIF(SUM(crm.deals_total_count), 0),
|
||
0
|
||
)::numeric(10, 2) AS avg_area_m2,
|
||
COALESCE(
|
||
SUM(crm.deals_total_avg_price_thousand_rub_per_m2 * crm.deals_total_count)
|
||
/ NULLIF(SUM(crm.deals_total_count), 0),
|
||
0
|
||
)::numeric(12, 2) * 1000.0 AS avg_price_per_m2_rub,
|
||
array_agg(DISTINCT cm.domrf_obj_id) AS competitor_obj_ids,
|
||
COUNT(DISTINCT cm.domrf_obj_id) AS competitor_count,
|
||
MIN(crm.report_month) AS window_start,
|
||
MAX(crm.report_month) AS window_end
|
||
FROM objective_corpus_room_month crm
|
||
JOIN objective_complex_mapping cm
|
||
ON cm.objective_complex_name = crm.project_name
|
||
WHERE crm.report_month >= (NOW() - CAST(:window_interval AS interval))::date
|
||
AND cm.domrf_obj_id = ANY(:competitor_obj_ids)
|
||
AND crm.room_bucket IS NOT NULL
|
||
GROUP BY
|
||
CASE
|
||
WHEN crm.room_bucket = 'студия' THEN 'studio'
|
||
ELSE crm.room_bucket
|
||
END
|
||
""")
|
||
|
||
# ── SQL: supply по (room_bucket, area_bin) за последний снимок ───────────────
|
||
# Один батч-запрос вместо N — возвращает map (rb, ab) → count.
|
||
# room_bucket и area_bin вычисляются в SQL аналогично layout_signature.py.
|
||
|
||
_SUPPLY_BATCH_SQL = text("""
|
||
SELECT
|
||
CASE
|
||
WHEN f.is_studio = TRUE OR f.flat_type = 'Квартира-студия' THEN 'studio'
|
||
WHEN f.rooms = 0 THEN 'studio'
|
||
-- Fix SF-08: euro-форматы — DOM.РФ маркирует малогабаритные квартиры как 2-комн.
|
||
-- rooms=2 + area<35 → euro-1 (студия с отдельной кухней ~26м²)
|
||
-- rooms=2 + area<50 → euro-2 (~35-50м², евро-двушка)
|
||
WHEN f.rooms = 2 AND f.total_area < 35 THEN 'euro-1'
|
||
WHEN f.rooms = 2 AND f.total_area < 50 THEN 'euro-2'
|
||
WHEN f.rooms IN (1, 2, 3) THEN f.rooms::text
|
||
WHEN f.rooms >= 4 THEN '4+'
|
||
ELSE '1'
|
||
END AS rb,
|
||
CASE
|
||
WHEN f.total_area < 25 THEN '<25'
|
||
WHEN f.total_area < 40 THEN '25-40'
|
||
WHEN f.total_area < 60 THEN '40-60'
|
||
WHEN f.total_area < 80 THEN '60-80'
|
||
WHEN f.total_area < 100 THEN '80-100'
|
||
ELSE '100+'
|
||
END AS ab,
|
||
COUNT(*) AS units
|
||
FROM domrf_kn_flats f
|
||
JOIN domrf_kn_objects o ON f.obj_id = o.obj_id
|
||
WHERE o.latitude IS NOT NULL AND o.longitude IS NOT NULL
|
||
AND ST_DWithin(
|
||
ST_SetSRID(ST_MakePoint(o.longitude, o.latitude), 4326)::geography,
|
||
ST_SetSRID(
|
||
ST_MakePoint(CAST(:center_lon AS float), CAST(:center_lat AS float)),
|
||
4326
|
||
)::geography,
|
||
CAST(:radius_m AS float)
|
||
)
|
||
AND f.snapshot_date = CAST(:latest_snap AS date)
|
||
GROUP BY rb, ab
|
||
""")
|
||
|
||
|
||
# ── Вспомогательные функции ───────────────────────────────────────────────────
|
||
|
||
|
||
def _quarter_from_cad(cad_num: str) -> str:
|
||
"""Извлечь кадастровый квартал: '66:41:0303161:123' → '66:41:0303161'."""
|
||
parts = cad_num.split(":")
|
||
if len(parts) >= 3:
|
||
return ":".join(parts[:3])
|
||
return cad_num
|
||
|
||
|
||
def _normalize_pct(buckets: dict[str, float]) -> dict[str, int]:
|
||
"""Нормировать доли до целых процентов с суммой ровно 100.
|
||
|
||
Алгоритм largest-remainder (Hamilton method):
|
||
1. Floor каждого значения.
|
||
2. Остаток 100 − sum_floors распределить в top-bucket по дробной части.
|
||
"""
|
||
if not buckets:
|
||
return {}
|
||
|
||
total = sum(buckets.values())
|
||
if total <= 0:
|
||
n = len(buckets)
|
||
base = 100 // n
|
||
result = {k: base for k in buckets}
|
||
# распределить остаток
|
||
remainder = 100 - base * n
|
||
for k in list(buckets.keys())[:remainder]:
|
||
result[k] += 1
|
||
return result
|
||
|
||
raw = {k: v / total * 100.0 for k, v in buckets.items()}
|
||
floors = {k: int(v) for k, v in raw.items()}
|
||
remainder = 100 - sum(floors.values())
|
||
# sort by fractional part desc
|
||
fracs = sorted(buckets.keys(), key=lambda k: -(raw[k] - floors[k]))
|
||
for k in fracs[:remainder]:
|
||
floors[k] += 1
|
||
return floors
|
||
|
||
|
||
def _cap_and_redistribute(pct_map: dict[str, int]) -> tuple[dict[str, int], bool]:
|
||
"""Fix SF-09 round 2: capacity-aware redistribute, bounded iterations.
|
||
|
||
Round 1 bug: surplus распределялся пропорционально текущему `v` free bucket'а,
|
||
что переливало его выше cap — на 2-bucket вход цикл осциллировал бесконечно.
|
||
|
||
Round 2 fix: surplus распределяется пропорционально **available capacity**
|
||
`(cap - v)` каждого free bucket'а. Тогда free никогда не вылетит выше cap →
|
||
цикл сходится за ≤ len(pct_map) итераций. Hard guard `for _ in range(N+1)`.
|
||
|
||
Если surplus > total_capacity (геометрически невозможно поместить излишек ниже
|
||
cap) — забиваем все free к cap, возвращаем `cap_skipped=True` + warning log.
|
||
|
||
Returns:
|
||
(result_map, cap_skipped) — cap_skipped=True если cap не удержан
|
||
(pathological: всё хочет > cap, или surplus > available capacity).
|
||
"""
|
||
if not pct_map:
|
||
return pct_map, False
|
||
|
||
cap = MAX_BUCKET_SHARE_PCT
|
||
|
||
# Быстрый path: нет доминирующих
|
||
if all(v <= cap for v in pct_map.values()):
|
||
return pct_map, False
|
||
|
||
work: dict[str, float] = {k: float(v) for k, v in pct_map.items()}
|
||
|
||
# Bounded iteration: после k-й итерации число clamped не убывает только если
|
||
# surplus > capacity (тогда — pathological). При корректном capacity-aware
|
||
# redistribute достаточно ≤ len(pct_map) итераций.
|
||
for _ in range(len(pct_map) + 1):
|
||
clamped = [k for k, v in work.items() if v > cap]
|
||
if not clamped:
|
||
break
|
||
|
||
free = [k for k, v in work.items() if v < cap]
|
||
if not free:
|
||
# Все bucket'ы либо >cap либо ровно =cap — некуда переливать.
|
||
logger.warning(
|
||
"MAX_BUCKET_SHARE cap: нет free bucket'ов (%d total) — cap_skipped",
|
||
len(pct_map),
|
||
)
|
||
return pct_map, True
|
||
|
||
surplus = sum(work[k] - cap for k in clamped)
|
||
capacities = {k: cap - work[k] for k in free}
|
||
total_capacity = sum(capacities.values())
|
||
|
||
for k in clamped:
|
||
work[k] = float(cap)
|
||
|
||
if surplus > total_capacity + 1e-9:
|
||
# Излишек не помещается ниже cap — pathological.
|
||
# Возвращаем оригинал (sum=100 invariant) + флаг для frontend banner.
|
||
logger.warning(
|
||
"MAX_BUCKET_SHARE cap: surplus %.2f > total_capacity %.2f — cap_skipped",
|
||
surplus,
|
||
total_capacity,
|
||
)
|
||
return pct_map, True
|
||
|
||
for k in free:
|
||
work[k] += capacities[k] / total_capacity * surplus
|
||
else:
|
||
# Hard guard: не сошлись за N+1 итераций — bug. Лог + cap_skipped.
|
||
logger.error(
|
||
"MAX_BUCKET_SHARE cap: не сошлись за %d итераций — algorithm bug",
|
||
len(pct_map) + 1,
|
||
)
|
||
return pct_map, True
|
||
|
||
return _hamilton_round(work), False
|
||
|
||
|
||
def _hamilton_round(work: dict[str, float]) -> dict[str, int]:
|
||
"""Hamilton apportionment: float → integer pct с суммой ровно 100."""
|
||
floors = {k: int(v) for k, v in work.items()}
|
||
remainder = 100 - sum(floors.values())
|
||
fracs = sorted(work.keys(), key=lambda k: -(work[k] - floors[k]))
|
||
for k in fracs[: max(0, remainder)]:
|
||
floors[k] += 1
|
||
return floors
|
||
|
||
|
||
# ── Главная функция ───────────────────────────────────────────────────────────
|
||
|
||
|
||
def get_best_layouts(
|
||
db: Session,
|
||
cad_num: str,
|
||
request: BestLayoutsRequest,
|
||
) -> BestLayoutsResponse:
|
||
"""Top layouts (rooms × area_bin) конкурентов с рейтингом по velocity.
|
||
|
||
Raises:
|
||
ValueError: если центроид участка не найден (caller → HTTP 404).
|
||
"""
|
||
quarter = _quarter_from_cad(cad_num)
|
||
radius_m = request.radius_km * 1000.0
|
||
|
||
# time_window → (interval_str, months divisor)
|
||
window_interval, months_in_window = _TIME_WINDOW_PARAMS.get(
|
||
request.time_window, ("3 months", 3.0)
|
||
)
|
||
|
||
# ── Step 1: центроид участка ─────────────────────────────────────────────
|
||
try:
|
||
coord_row = (
|
||
db.execute(
|
||
_PARCEL_CENTROID_SQL,
|
||
{"cad_num": cad_num, "quarter": quarter},
|
||
)
|
||
.mappings()
|
||
.first()
|
||
)
|
||
except Exception:
|
||
logger.exception("best_layouts: centroid query failed for cad_num=%s", cad_num)
|
||
raise
|
||
|
||
if not coord_row:
|
||
raise ValueError(f"Геометрия для {cad_num} не найдена")
|
||
|
||
center_lon = float(coord_row["center_lon"])
|
||
center_lat = float(coord_row["center_lat"])
|
||
|
||
# ── Step 2: obj_id конкурентов в радиусе ────────────────────────────────
|
||
try:
|
||
id_rows = (
|
||
db.execute(
|
||
_COMPETITORS_IN_RADIUS_SQL,
|
||
{
|
||
"center_lon": center_lon,
|
||
"center_lat": center_lat,
|
||
"radius_m": radius_m,
|
||
"obj_class_filter": request.obj_class_filter,
|
||
},
|
||
)
|
||
.mappings()
|
||
.all()
|
||
)
|
||
except Exception:
|
||
logger.exception("best_layouts: competitors-in-radius query failed for cad_num=%s", cad_num)
|
||
raise
|
||
|
||
all_obj_ids: list[int] = [int(r["obj_id"]) for r in id_rows]
|
||
objects_total_in_radius = len(all_obj_ids)
|
||
|
||
# Применить exclude / filter из request
|
||
exclude_set = set(request.exclude_competitor_obj_ids)
|
||
if exclude_set:
|
||
all_obj_ids = [oid for oid in all_obj_ids if oid not in exclude_set]
|
||
|
||
if request.filter_competitor_obj_ids is not None:
|
||
filter_set = set(request.filter_competitor_obj_ids)
|
||
all_obj_ids = [oid for oid in all_obj_ids if oid in filter_set]
|
||
|
||
if not all_obj_ids:
|
||
return _empty_response(
|
||
radius_km=request.radius_km,
|
||
time_window=request.time_window,
|
||
objects_total_in_radius=objects_total_in_radius,
|
||
)
|
||
|
||
# ── Step 3: inline velocity из objective_corpus_room_month ──────────────
|
||
# Fix SF-01: честный фильтр report_month >= NOW() - window_interval.
|
||
# Разные time_window → разные deals_window, разный mix.
|
||
try:
|
||
vel_rows = (
|
||
db.execute(
|
||
_INLINE_VELOCITY_SQL,
|
||
{
|
||
"window_interval": window_interval,
|
||
"competitor_obj_ids": all_obj_ids,
|
||
},
|
||
)
|
||
.mappings()
|
||
.all()
|
||
)
|
||
except Exception:
|
||
logger.exception(
|
||
"best_layouts: inline velocity query failed for cad_num=%s obj_count=%d",
|
||
cad_num,
|
||
len(all_obj_ids),
|
||
)
|
||
raise
|
||
|
||
if not vel_rows:
|
||
return _empty_response(
|
||
radius_km=request.radius_km,
|
||
time_window=request.time_window,
|
||
objects_total_in_radius=objects_total_in_radius,
|
||
)
|
||
|
||
# ── Step 5: supply side (батч-запрос) ────────────────────────────────────
|
||
# Pre-compute последний snapshot_date один раз — избегаем subquery на каждый scan.
|
||
latest_snap: dt.date | None = db.scalar(text("SELECT MAX(snapshot_date) FROM domrf_kn_flats"))
|
||
if latest_snap is None:
|
||
logger.warning("best_layouts: domrf_kn_flats пустой (нет snapshot_date), supply=0 fallback")
|
||
supply_rows = []
|
||
else:
|
||
try:
|
||
supply_rows = (
|
||
db.execute(
|
||
_SUPPLY_BATCH_SQL,
|
||
{
|
||
"center_lon": center_lon,
|
||
"center_lat": center_lat,
|
||
"radius_m": radius_m,
|
||
"latest_snap": latest_snap,
|
||
},
|
||
)
|
||
.mappings()
|
||
.all()
|
||
)
|
||
except Exception:
|
||
logger.warning("best_layouts: supply query failed, supply=0 fallback")
|
||
supply_rows = []
|
||
|
||
supply_map: dict[tuple[str, str], int] = {
|
||
(str(r["rb"]), str(r["ab"])): int(r["units"]) for r in supply_rows
|
||
}
|
||
|
||
# ── Step 4 + 6: velocity из реального окна и enrichment per row ─────────
|
||
# Fix SF-01: velocity_per_month = deals_window / months_in_window.
|
||
# deals_window уже отфильтрован по report_month — разные time_window дают разные данные.
|
||
|
||
enriched: list[dict[str, Any]] = []
|
||
window_start: dt.date | None = None
|
||
window_end: dt.date | None = None
|
||
|
||
# Собираем obj_ids с данными в objective_corpus_room_month (для data_quality)
|
||
obj_ids_with_data: set[int] = set()
|
||
|
||
for r in vel_rows:
|
||
room_bucket = str(r["room_bucket"])
|
||
deals_window = float(r["deals_window"]) if r["deals_window"] is not None else 0.0
|
||
avg_area = float(r["avg_area_m2"]) if r["avg_area_m2"] is not None else 0.0
|
||
price_rub = (
|
||
float(r["avg_price_per_m2_rub"]) if r["avg_price_per_m2_rub"] is not None else None
|
||
)
|
||
competitor_obj_ids: list[int] = (
|
||
[int(oid) for oid in r["competitor_obj_ids"]] if r["competitor_obj_ids"] else []
|
||
)
|
||
competitor_count = int(r["competitor_count"])
|
||
|
||
obj_ids_with_data.update(competitor_obj_ids)
|
||
|
||
# Step 4: честный velocity = сделки за окно / длина окна в месяцах
|
||
velocity_per_month = round(deals_window / months_in_window, 2)
|
||
|
||
# Step 6: area_bin по avg_area (layout_signature.area_bin)
|
||
ab = area_bin(avg_area) if avg_area > 0 else "<25"
|
||
sig = layout_signature(room_bucket, ab) # type: ignore[arg-type]
|
||
|
||
supply_count = supply_map.get((room_bucket, ab), 0)
|
||
sold_pct: float | None = None
|
||
is_oversold = False
|
||
if supply_count > 0:
|
||
sold_pct_raw = deals_window / supply_count * 100.0
|
||
is_oversold = sold_pct_raw > 100.0
|
||
# Clamp at 100%: сделки за 24 мес / текущий snapshot supply несопоставимы.
|
||
# Значения >100% артефакт окна, не реальная «распроданность».
|
||
sold_pct = round(min(sold_pct_raw, 100.0), 1)
|
||
|
||
# data window
|
||
if r["window_start"] is not None:
|
||
ws = r["window_start"]
|
||
if isinstance(ws, str):
|
||
ws = dt.date.fromisoformat(ws)
|
||
elif isinstance(ws, dt.datetime):
|
||
ws = ws.date()
|
||
window_start = ws if window_start is None else min(window_start, ws)
|
||
|
||
if r["window_end"] is not None:
|
||
we = r["window_end"]
|
||
if isinstance(we, str):
|
||
we = dt.date.fromisoformat(we)
|
||
elif isinstance(we, dt.datetime):
|
||
we = we.date()
|
||
window_end = we if window_end is None else max(window_end, we)
|
||
|
||
enriched.append(
|
||
{
|
||
"room_bucket": room_bucket,
|
||
"area_bin": ab,
|
||
"signature": sig,
|
||
"competitor_obj_ids": competitor_obj_ids,
|
||
"competitor_count": competitor_count,
|
||
"sum_deals": deals_window,
|
||
"velocity_per_month": velocity_per_month,
|
||
"avg_price_per_m2_rub": price_rub,
|
||
"avg_area_m2": avg_area,
|
||
"supply_units_in_radius": supply_count,
|
||
"sold_pct_of_supply": sold_pct,
|
||
"is_oversold": is_oversold,
|
||
}
|
||
)
|
||
|
||
# ── Step 7: фильтр min_velocity + sort + rank ────────────────────────────
|
||
filtered = [
|
||
row for row in enriched if row["velocity_per_month"] >= request.min_velocity_per_month
|
||
]
|
||
filtered.sort(key=lambda r: r["velocity_per_month"], reverse=True)
|
||
|
||
top_layouts: list[TopLayoutRow] = []
|
||
for rank_idx, row in enumerate(filtered, start=1):
|
||
top_layouts.append(
|
||
TopLayoutRow(
|
||
rank=rank_idx,
|
||
room_bucket=row["room_bucket"],
|
||
area_bin=row["area_bin"],
|
||
signature=row["signature"],
|
||
competitor_obj_ids=row["competitor_obj_ids"],
|
||
competitor_count=row["competitor_count"],
|
||
total_sold_in_window=int(row["sum_deals"]),
|
||
velocity_per_month=row["velocity_per_month"],
|
||
avg_price_per_m2_rub=row["avg_price_per_m2_rub"],
|
||
avg_area_m2=round(row["avg_area_m2"], 1),
|
||
supply_units_in_radius=row["supply_units_in_radius"],
|
||
sold_pct_of_supply=row["sold_pct_of_supply"],
|
||
is_oversold=row["is_oversold"],
|
||
)
|
||
)
|
||
|
||
# ── Step 8: build recommendation_for_tz ─────────────────────────────────
|
||
# Используем filtered (только > min_velocity) для recommendation.
|
||
# Если после фильтрации всё пустое — используем enriched (все данные без фильтра).
|
||
rec_source = filtered if filtered else enriched
|
||
|
||
today = dt.date.today()
|
||
ws_date = window_start if window_start is not None else today
|
||
we_date = window_end if window_end is not None else today
|
||
|
||
recommendation = _build_recommendation(
|
||
rows=rec_source,
|
||
radius_km=request.radius_km,
|
||
time_window=request.time_window,
|
||
target_total_flats=request.target_total_flats,
|
||
window_start=ws_date,
|
||
window_end=we_date,
|
||
all_enriched=enriched,
|
||
)
|
||
|
||
# ── Step 9: data_quality ─────────────────────────────────────────────────
|
||
# Denominator = post-filter set (effective consideration set после exclude/filter).
|
||
objects_total_after_filter = len(all_obj_ids)
|
||
objects_with_data = len(obj_ids_with_data & set(all_obj_ids))
|
||
coverage_pct = (
|
||
round(objects_with_data / objects_total_after_filter * 100.0, 1)
|
||
if objects_total_after_filter > 0
|
||
else 0.0
|
||
)
|
||
if coverage_pct >= LAYOUT_CONFIDENCE_HIGH_PCT:
|
||
confidence: str = "high"
|
||
elif coverage_pct >= LAYOUT_CONFIDENCE_MEDIUM_PCT:
|
||
confidence = "medium"
|
||
else:
|
||
confidence = "low"
|
||
|
||
data_quality = LayoutDataQuality(
|
||
objects_with_velocity_data=objects_with_data,
|
||
objects_total_in_radius=objects_total_after_filter,
|
||
velocity_coverage_pct=coverage_pct,
|
||
confidence=confidence, # type: ignore[arg-type]
|
||
)
|
||
|
||
return BestLayoutsResponse(
|
||
top_layouts=top_layouts,
|
||
recommendation_for_tz=recommendation,
|
||
data_quality=data_quality,
|
||
)
|
||
|
||
|
||
def _build_recommendation(
|
||
rows: list[dict[str, Any]],
|
||
radius_km: float,
|
||
time_window: str,
|
||
target_total_flats: int | None,
|
||
window_start: dt.date,
|
||
window_end: dt.date,
|
||
all_enriched: list[dict[str, Any]],
|
||
) -> LayoutTzRecommendation:
|
||
"""Собрать LayoutTzRecommendation из enriched rows."""
|
||
if not rows:
|
||
return LayoutTzRecommendation(
|
||
rationale_text=(
|
||
f"В радиусе {radius_km}км: нет layout-паттернов с достаточной velocity."
|
||
),
|
||
mix=[],
|
||
weighted_avg_price_per_m2_rub=None,
|
||
based_on_obj_count=0,
|
||
based_on_total_deals=0,
|
||
data_window_start=window_start,
|
||
data_window_end=window_end,
|
||
)
|
||
|
||
# Группировка по room_bucket (строки уже могут быть per-bucket из MV GROUP BY)
|
||
rb_deals: dict[str, float] = {}
|
||
rb_area_weighted: dict[str, float] = {}
|
||
rb_price_weighted: dict[str, float] = {}
|
||
rb_price_total_deals: dict[str, float] = {}
|
||
all_competitor_ids: set[int] = set()
|
||
|
||
for row in rows:
|
||
rb = row["room_bucket"]
|
||
sd = float(row["sum_deals"])
|
||
rb_deals[rb] = rb_deals.get(rb, 0.0) + sd
|
||
rb_area_weighted[rb] = rb_area_weighted.get(rb, 0.0) + row["avg_area_m2"] * sd
|
||
all_competitor_ids.update(row["competitor_obj_ids"])
|
||
if row["avg_price_per_m2_rub"] is not None:
|
||
rb_price_weighted[rb] = rb_price_weighted.get(rb, 0.0) + (
|
||
row["avg_price_per_m2_rub"] * sd
|
||
)
|
||
rb_price_total_deals[rb] = rb_price_total_deals.get(rb, 0.0) + sd
|
||
|
||
total_deals = sum(rb_deals.values())
|
||
pct_map = _normalize_pct(rb_deals)
|
||
pct_map, cap_skipped = _cap_and_redistribute(pct_map)
|
||
|
||
mix: list[LayoutTzMixRow] = []
|
||
for rb, pct in sorted(pct_map.items(), key=lambda x: -x[1]):
|
||
avg_area = (
|
||
round(rb_area_weighted[rb] / rb_deals[rb], 1) if rb_deals.get(rb, 0) > 0 else None
|
||
)
|
||
abs_units: int | None = None
|
||
if target_total_flats is not None:
|
||
abs_units = round(pct / 100.0 * target_total_flats)
|
||
mix.append(
|
||
LayoutTzMixRow(
|
||
room_bucket=rb,
|
||
pct=pct,
|
||
abs_units=abs_units,
|
||
avg_target_area_m2=avg_area,
|
||
)
|
||
)
|
||
|
||
# Weighted avg price across all room_buckets
|
||
total_price_deals = sum(rb_price_total_deals.values())
|
||
weighted_price: float | None = None
|
||
if total_price_deals > 0:
|
||
weighted_price = round(sum(rb_price_weighted.values()) / total_price_deals, 0)
|
||
|
||
# Rationale
|
||
competitor_count = len(all_competitor_ids)
|
||
tw_label = {"last_month": "1 мес", "last_quarter": "квартал", "last_year": "год"}.get(
|
||
time_window, time_window
|
||
)
|
||
rationale_text = (
|
||
f"В радиусе {radius_km}км за {tw_label}: "
|
||
f"{len(rows)} активных layout-паттернов, "
|
||
f"total {int(total_deals)} продаж в {competitor_count} ЖК"
|
||
)
|
||
|
||
# based_on_obj_count из all_enriched (уникальные obj_id с данными MV)
|
||
all_mv_obj_ids: set[int] = set()
|
||
for row in all_enriched:
|
||
all_mv_obj_ids.update(row["competitor_obj_ids"])
|
||
|
||
return LayoutTzRecommendation(
|
||
rationale_text=rationale_text,
|
||
mix=mix,
|
||
weighted_avg_price_per_m2_rub=weighted_price,
|
||
based_on_obj_count=len(all_mv_obj_ids),
|
||
based_on_total_deals=int(total_deals),
|
||
data_window_start=window_start,
|
||
data_window_end=window_end,
|
||
cap_skipped=cap_skipped,
|
||
)
|
||
|
||
|
||
def _empty_response(
|
||
radius_km: float,
|
||
time_window: str,
|
||
objects_total_in_radius: int,
|
||
) -> BestLayoutsResponse:
|
||
"""Ответ когда нет конкурентов или нет MV данных."""
|
||
today = dt.date.today()
|
||
tw_label = {"last_month": "1 мес", "last_quarter": "квартал", "last_year": "год"}.get(
|
||
time_window, time_window
|
||
)
|
||
return BestLayoutsResponse(
|
||
top_layouts=[],
|
||
recommendation_for_tz=LayoutTzRecommendation(
|
||
rationale_text=(
|
||
f"В радиусе {radius_km}км за {tw_label}: "
|
||
f"конкуренты не найдены или нет данных velocity."
|
||
),
|
||
mix=[],
|
||
weighted_avg_price_per_m2_rub=None,
|
||
based_on_obj_count=0,
|
||
based_on_total_deals=0,
|
||
data_window_start=today,
|
||
data_window_end=today,
|
||
),
|
||
data_quality=LayoutDataQuality(
|
||
objects_with_velocity_data=0,
|
||
objects_total_in_radius=objects_total_in_radius,
|
||
velocity_coverage_pct=0.0,
|
||
confidence="low",
|
||
),
|
||
)
|