Files
buryan-infra/ops/work/web/combine_core.py
T

980 lines
48 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/usr/bin/env python3
"""Ядро комбайна: модели данных и доменная логика.
Используется всеми сервисами (catalog, engine, draw, project, docs).
Никакого HTTP здесь — только данные и расчёты.
"""
import glob
import json
import os
import re
BASE = "/opt/work-hub/compat"
PROJECTS_DIR = os.path.join(BASE, "projects")
def norm(s):
return re.sub(r"[^a-z0-9]", "", str(s).lower())
def load(name):
import yaml
p = os.path.join(BASE, name)
if not os.path.exists(p):
return {}
try:
return yaml.safe_load(open(p, encoding="utf-8")) or {}
except Exception:
return {}
class Core:
"""Единая точка доступа к данным модели."""
POSITIONS_ROLE = {
"display": {"in": ["HDMI"], "out": []},
"camera": {"in": ["LAN"], "out": ["USB", "HDMI"]},
"audio": {"in": ["VCH"], "out": ["VCH"]},
"speaker": {"in": ["VCH"], "out": []},
"touch": {"in": ["LAN"], "out": ["USB"]},
"sharing_or_hub": {"in": ["USB"], "out": ["HDMI"]},
# ПК/BYOD — источник: отдаёт видео в комнату, принимает USB-периферию
"pc": {"in": ["USB", "USB-C"], "out": ["HDMI", "USB-C"]},
"power": {"in": ["220"], "out": ["220"]},
"charger": {"in": ["220"], "out": ["USB", "220"]},
"codec": {"in": ["LAN", "HDMI"], "out": ["HDMI", "USB", "VCH"]},
"mount": {"in": [], "out": []},
"infrastructure": {"in": ["LAN"], "out": ["LAN"]},
}
ROLE_PORT_PREF = {
"display": ["HDMI", "DP", "USB-C"],
"camera": ["USB", "USB-C", "LAN", "HDMI"],
"audio": ["VCH", "USB", "USB-C"],
"speaker": ["VCH"],
"touch": ["USB", "LAN", "USB-C"],
"sharing_or_hub": ["USB", "USB-C", "HDMI", "VCH"],
"pc": ["HDMI", "USB-C", "USB"],
}
PORT_RANK = {"USB": 0, "USB-C": 1, "VCH": 2, "RJ-9": 3, "3.5mm": 4,
"LAN": 5, "HDMI": 6, "DP": 7}
LINKABLE = {
("HDMI", "HDMI"): "видео",
("USB", "USB"): "данные",
("USB-C", "USB-C"): "данные+видео",
("USB", "USB-C"): "данные (переходник)",
("USB-C", "USB"): "данные (переходник)",
("VCH", "VCH"): "аудио+питание",
("LAN", "LAN"): "сеть/PoE",
("3.5mm", "3.5mm"): "аналоговый звук",
("DP", "DP"): "видео",
("WL", "WL"): "беспроводно",
("220", "220"): "питание 220В",
("RJ-9", "RJ-9"): "телефон",
}
FEATURE_ROLE = {
"aec": "audio", "anc": "audio", "dante": "audio", "aes67": "audio",
"autoframing": "camera", "speakertracking": "camera",
"presentertracking": "camera", "4k": "camera",
"airplay": "sharing_or_hub", "miracast": "sharing_or_hub",
"usbc": "sharing_or_hub", "poe": "infrastructure",
"teams": "codec", "zoom": "codec", "h323": "codec", "sip": "codec",
}
GROUP_DEFS = [
{"id": "mic", "name": "Микрофоны", "roles": ["audio"],
"static_role": "audio",
"skip": r"^CP50|^CP965|^CPE|^CP\d|^PA\d|^CS10-D|^CLS120"},
{"id": "speaker", "name": "Громкоговорители", "roles": ["speaker"],
"static_role": "speaker",
"extra": r"^CS10-D|^CLS120|^MSpeaker"},
{"id": "camera", "name": "Камеры", "roles": ["camera"], "static_role": "camera"},
{"id": "panel", "name": "Панели управления", "roles": ["touch", "remote"]},
{"id": "sharing", "name": "Презентация и хабы", "roles": ["sharing_or_hub"]},
{"id": "pc", "name": "ПК и источники (BYOD)", "roles": ["pc"], "static_role": "pc"},
{"id": "power", "name": "Питание (розетки, зарядки)", "roles": ["power", "charger"],
"static_role": "power"},
{"id": "phone", "name": "Аудиоустройства и телефоны", "roles": ["audio"],
"only": r"^CP50|^CP965|^CPE|^CP\d|^PA\d"},
{"id": "display", "name": "Дисплеи", "roles": ["display"], "static_role": "display"},
{"id": "mount", "name": "Кронштейны", "roles": ["mount"]},
{"id": "infra", "name": "Инфраструктура (PoE, хабы)", "roles": []},
]
def __init__(self):
self._stamp = 0.0
self.cat = load("catalog.yaml")
self.graph = load("graph.yaml")
self.values = load("values.yaml")
self.features = load("features.yaml")
self.protocols = load("protocols.yaml")
self.mounts = load("mounts.yaml")
self.dante = load("dante.yaml")
self.iface_v = load("interfaces_verified.yaml")
self.iface_a = load("interfaces.yaml")
self.pkg_v = load("package_verified.yaml")
self.pkg_a = load("package.yaml")
self.limits = load("limitations.yaml")
self.infra = load("infrastructure.yaml")
self.kits = load("kits.yaml")
self.extra = load("specs_extra.yaml")
self.overrides = load("overrides.yaml")
self.i_extract = load("interfaces_extract.yaml")
self.s_extract = load("specs_extract.yaml")
self.p_extract = load("package_extract.yaml")
self.rebuild()
WATCH = ("overrides.yaml", "values.yaml", "graph.yaml", "catalog.yaml",
"interfaces_verified.yaml", "infrastructure.yaml", "package_verified.yaml")
def reload_if_changed(self):
"""Перечитывает модель, если файлы изменились (ручной ввод, LLM-данные)."""
stamp = 0.0
for f in self.WATCH:
p = os.path.join(BASE, f)
try:
stamp = max(stamp, os.path.getmtime(p))
except OSError:
pass
if stamp > getattr(self, "_stamp", 0):
self.__init__()
self._stamp = stamp
return True
return False
def rebuild(self):
self.devices = {norm(d["name"]): {"name": d["name"], "role": d.get("role", "unknown")}
for d in self.cat.get("devices") or []}
self.edges = {}
for e in self.graph.get("edges") or []:
self.edges.setdefault(norm(e.get("from")), []).append(e)
self.attrs = {}
for x in self.values.get("devices") or []:
self.attrs[norm(x.get("device"))] = dict(x.get("attributes") or {})
for x in (self.extra.get("devices") or []):
k = norm(x["device"])
self.attrs.setdefault(k, {})
for ak, av in (x.get("attributes") or {}).items():
self.attrs[k].setdefault(ak, av)
for x in (self.s_extract.get("devices") or []):
k = norm(x["device"])
self.attrs.setdefault(k, {})
for ak, av in (x.get("attributes") or {}).items():
self.attrs[k].setdefault(ak, av)
# ручные значения — перекрывают всё
self.manual = {}
for x in (self.overrides.get("devices") or []):
k = norm(x["device"])
self.manual[k] = dict(x.get("attributes") or {})
self.feats = {}
for src in (self.features, self.protocols):
for x in src.get("devices") or []:
f = x.get("features") or {}
self.feats.setdefault(norm(x.get("device")), set()).update(
f.keys() if isinstance(f, dict) else f)
for x in self.dante.get("dante_devices") or []:
self.feats.setdefault(norm(x.get("device")), set()).add("Dante")
for k, v in getattr(self, "manual", {}).items():
self.attrs.setdefault(k, {})
self.attrs[k].update(v)
self.iface_map = {norm(x["device"]): x for x in self.iface_v.get("devices") or []}
self.iface_auto = {norm(x["device"]): x for x in self.iface_a.get("devices") or []}
self.iface_ext = {norm(x["device"]): x for x in self.i_extract.get("devices") or []
if x.get("in") or x.get("out")}
self.pkg_map = {norm(x["device"]): x for x in self.pkg_v.get("devices") or []}
self.pkg_llm = {norm(x["device"]): (x.get("items") or [])
for x in self.p_extract.get("devices") or []}
self.mounts_map = {}
for e in self.mounts.get("edges") or []:
self.mounts_map.setdefault(norm(e["host"]), []).append(e["mount"])
# ── сигналы и совместимость разъёмов ──
SIGNAL_OF = {
"HDMI": "video", "DP": "video", "USB": "data", "USB-C": "data",
"VCH": "audio", "3.5mm": "audio", "LAN": "network",
"RJ-9": "telephony", "PHOENIX": "control", "OPS": "data",
"WL": "беспроводно", "220": "питание 220В",
}
# какие соединения допустимы на уровне сигнала
SIGNAL_LINK = {
("video", "video"), ("data", "data"), ("audio", "audio"),
("network", "network"), ("telephony", "telephony"), ("control", "control"),
("беспроводно", "беспроводно"),
("питание 220В", "питание 220В"),
}
# разъём -> разъём (физическая совместимость)
PHYSICAL = {
("HDMI", "HDMI"), ("DP", "DP"), ("USB", "USB"), ("USB-C", "USB-C"),
("VCH", "VCH"), ("LAN", "LAN"), ("3.5mm", "3.5mm"), ("RJ-9", "RJ-9"),
("PHOENIX", "PHOENIX"),
# допустимые переходники
("USB", "USB-C"), ("USB-C", "USB"), ("USB-C", "DP"), ("DP", "USB-C"),
("WL", "WL"), ("220", "220"),
}
def vendor_of(self, name):
"""Вендор и направление устройства (пока yealink/vcs, структура готова)."""
return {"vendor": "yealink", "domain": "vcs"}
def vendors(self):
out = {}
for k, v in self.devices.items():
meta = self.vendor_of(v["name"])
key = (meta["vendor"], meta["domain"])
out.setdefault(key, []).append(v["name"])
return [{"vendor": k[0], "domain": k[1],
"devices": len(v), "examples": sorted(v)[:5]}
for k, v in sorted(out.items())]
def port_objects(self, name):
"""Порты как объекты: разъём, сигнал, направление, версия."""
ins, outs, src = self.ports(name)
objs = []
for i, p in enumerate(x for x in ins if x and x != "—"):
objs.append({"connector": p, "signal": self.SIGNAL_OF.get(p, "unknown"),
"direction": "in", "index": i, "source": src})
for i, p in enumerate(x for x in outs if x and x != "—"):
objs.append({"connector": p, "signal": self.SIGNAL_OF.get(p, "unknown"),
"direction": "out", "index": i, "source": src})
return objs
def signal_ok(self, a, b):
"""Совместимы ли два порта по физике и сигналу."""
if (a, b) not in self.PHYSICAL and (b, a) not in self.PHYSICAL:
return False, "разъёмы несовместимы: %s / %s" % (a, b)
sa, sb = self.SIGNAL_OF.get(a), self.SIGNAL_OF.get(b)
if (sa, sb) not in self.SIGNAL_LINK:
return False, "разные сигналы: %s / %s" % (sa, sb)
return True, "ok"
def signal_chains(self, host_key, items):
"""Проверка сигнальных цепочек для каждого устройства."""
plan = self.port_plan(host_key, items)
rows = []
for r in plan["rows"]:
if r.get("via"):
# устройство подключено через промежуточное (цепочка) —
# это не блокер, сигнал идёт через него
rows.append({"device": r["device"], "ok": True,
"reason": r.get("reason") or ("через " + r["via"]),
"from_port": r.get("needs_port"),
"to_port": r.get("needs_port"),
"via": r["via"],
"signal": self.SIGNAL_OF.get(r.get("needs_port") or "")})
continue
if not r["ok"]:
rows.append({"device": r["device"], "ok": False,
"reason": "нет подходящего порта", "from_port": None,
"to_port": None})
continue
hp = r["host_port"] or ""
hp = hp[4:] if hp.startswith("out:") else hp
ok, why = self.signal_ok(hp, r["needs_port"] or "")
rows.append({"device": r["device"], "ok": ok, "reason": why,
"from_port": hp, "to_port": r["needs_port"],
"signal": self.SIGNAL_OF.get(hp)})
return {"host": plan["host"], "chains": rows,
"ok": sum(1 for r in rows if r["ok"]), "total": len(rows)}
# ── порты ──
def ports(self, name):
k = norm(name)
if k in self.iface_map:
v = self.iface_map[k]
return list(v.get("in") or ["—"]), list(v.get("out") or ["—"]), "verified"
if k in self.iface_ext:
v = self.iface_ext[k]
return list(v.get("in") or ["—"]), list(v.get("out") or ["—"]), "datasheet-llm"
if k in self.iface_auto:
v = self.iface_auto[k]
ins = [p for p in (v.get("in") or []) if p]
outs = [p for p in (v.get("out") or []) if p]
if ins or outs:
return ins or ["—"], outs or ["—"], "auto"
role = self.devices.get(k, {}).get("role", "unknown")
d = self.POSITIONS_ROLE.get(role, {"in": ["LAN"], "out": ["—"]})
return list(d["in"]), list(d["out"]) or ["—"], "role"
# ── прослеживаемость данных (как lineage в data-платформах) ──
def lineage(self, name):
"""По каждому атрибуту: значение, источник, файл, свежесть."""
import os
import time
k = norm(name)
out = []
sources = [
("manual", "overrides.yaml", "ручной ввод"),
("verified", "interfaces_verified.yaml", "выверено по даташиту"),
("values", "values.yaml", "извлечено из даташита"),
("extra", "specs_extra.yaml", "доп. даташит"),
("llm", "specs_extract.yaml", "извлечено LLM"),
]
for kind, fname, label in sources:
p = os.path.join(BASE, fname)
try:
age_h = round((time.time() - os.path.getmtime(p)) / 3600, 1)
except OSError:
continue
out.append({"source": kind, "file": fname, "label": label,
"file_age_hours": age_h})
attrs = self.attrs.get(k, {})
rows = []
for attr, val in sorted(attrs.items()):
src = "values"
if (getattr(self, "manual", {}) or {}).get(k, {}).get(attr) is not None:
src = "manual"
elif (getattr(self, "iface_map", {}) or {}).get(k) and attr.startswith(("ports.", "network.")):
src = "verified"
rows.append({"attr": attr, "value": val, "source": src,
"verified": src in ("manual", "verified")})
verified_count = sum(1 for r in rows if r["verified"])
return {"device": self.devices.get(k, {}).get("name") or name,
"attributes": rows, "total": len(rows),
"verified": verified_count,
"trust_pct": round(100.0 * verified_count / max(len(rows), 1), 1),
"files": out,
"package": self.package(name),
"completeness": self.completeness(k)}
# ── единый список проблем (clash detection) ──
def issues(self, host_key, items, infra=None, hours=None):
hk = norm(host_key)
host = self.devices.get(hk, {}).get("name") or host_key
out = []
cap = self.capacity(hk, items, infra or [])
for i in cap["issues"]:
out.append({"level": "blocker", "kind": "capacity", "text": i})
if cap["missing_power"]:
out.append({"level": "warning", "kind": "data",
"text": "нет данных о питании: " + ", ".join(cap["missing_power"][:6])})
sig = self.signal_chains(hk, items)
for r in sig["chains"]:
if not r["ok"]:
out.append({"level": "blocker", "kind": "signal",
"text": "%s: %s" % (r["device"], r["reason"])})
plan = self.port_plan(hk, items)
if plan["unresolved"]:
out.append({"level": "blocker", "kind": "port",
"text": "нет порта для: " + ", ".join(plan["unresolved"])})
comp = self.completeness(hk)
if comp["level"] != "full":
out.append({"level": "warning", "kind": "data",
"text": "неполные данные: " + comp["note"]})
for row in items:
pk = self.package(row[0])
if not pk["items"]:
out.append({"level": "info", "kind": "package",
"text": "%s: комплектация неизвестна" % row[0]})
try:
for p in self.poe_check(items):
out.append({"level": "warning" if not p.get("ok") else "info",
"kind": "poe", "text": p["text"]})
except Exception:
pass
try:
for b in self.battery_check(items, hours or 8.0):
lvl = "warning" if not b.get("ok") else "info"
out.append({"level": lvl, "kind": "battery", "text": b["text"]})
except Exception:
pass
blockers = sum(1 for i in out if i["level"] == "blocker")
warnings = sum(1 for i in out if i["level"] == "warning")
return {"host": host, "issues": out, "blockers": blockers,
"warnings": warnings, "ready": blockers == 0,
"by_kind": {k: sum(1 for i in out if i["kind"] == k)
for k in {i["kind"] for i in out}}}
# ── PoE-бюджет ──
def poe_check(self, items):
"""Хватает ли PoE-бюджета коммутаторов на устройства в составе."""
switches, ports_total = [], 0
for row in items:
m = row[0]
q = int(row[1]) if len(row) > 1 else 1
info = self.iface_map.get(norm(m)) or {}
b = info.get("poe_budget_w")
if b:
switches.append((m, float(b) * q, q))
ports_total += int(info.get("poe_ports") or 0) * q
if not switches:
return []
budget = sum(b for _, b, _ in switches)
need, unknown, powered = 0.0, [], []
for row in items:
m = row[0]
q = int(row[1]) if len(row) > 1 else 1
k = norm(m)
role = (self.devices.get(k) or {}).get("role")
if role in ("infrastructure", "power", "charger", "display", "pc"):
continue
w = (self.attrs.get(k) or {}).get("power.consumption_w")
if w is None:
unknown.append(m)
else:
need += float(w) * q
powered.append(m)
out = [{"kind": "poe", "ok": need <= budget,
"text": "PoE: нужно %.0f Вт из %.0f Вт (портов PoE: %d)%s"
% (need, budget, ports_total,
"" if need <= budget else " — НЕ ХВАТАЕТ")}]
if unknown:
out.append({"kind": "poe", "ok": True,
"text": "нет данных о потреблении: " + ", ".join(unknown[:6])})
return out
# ── батарея беспроводных устройств ──
def battery_check(self, items, hours=8.0):
"""Хватит ли заряда на совещание заданной длительности."""
out = []
total_mah = 0
worst = None
for row in items:
model = row[0]
qty = int(row[1]) if len(row) > 1 else 1
k = norm(model)
info = (self.iface_map.get(k) or {})
bh = info.get("battery_hours")
if not bh:
continue
mah = info.get("battery_mah")
total_mah += int(mah or 0) * qty
if worst is None or bh < worst[1]:
worst = (model, bh, qty)
need = "хватит" if bh >= hours else "НЕ хватит (%.0f ч < %.0f ч)" % (bh, hours)
out.append({"kind": "battery", "device": model, "qty": qty,
"hours": bh, "mah": mah, "need_hours": hours,
"ok": bh >= hours,
"text": "%s ×%d: заряд %s ч — %s" % (model, qty, bh, need)})
if out and worst:
out.append({"kind": "battery", "ok": True,
"text": "суммарная ёмкость беспроводных: %d мА·ч; "
"минимальный запас — %s (%s ч)"
% (total_mah, worst[0], worst[1])})
return out
# ── ручной ввод характеристики ──
ALLOWED_ATTRS = {
"audio.pickup_m": "м", "audio.spl_max": "dB SPL",
"camera.fov_h": "°", "camera.fov_v": "°",
"camera.zoom_optical": "×", "camera.zoom_hybrid": "×",
"power.consumption_w": "Вт", "ports.vch": "шт",
"ports.hdmi_out": "шт", "ports.hdmi_in": "шт",
"ports.usb": "шт", "physical.weight_kg": "кг",
}
def set_override(self, device, attr, value):
import yaml as _yaml
if attr not in self.ALLOWED_ATTRS:
return {"error": "недопустимый параметр: %s" % attr}
try:
v = float(str(value).replace(",", "."))
except (TypeError, ValueError):
return {"error": "значение должно быть числом"}
if v < 0 or v > 100000:
return {"error": "значение вне допустимого диапазона"}
k = norm(device)
entry = None
for x in (self.overrides.get("devices") or []):
if norm(x["device"]) == k:
entry = x
break
if entry is None:
entry = {"device": self.devices.get(k, {}).get("name") or device,
"attributes": {}}
self.overrides.setdefault("devices", []).append(entry)
entry.setdefault("attributes", {})[attr] = v
entry["updated"] = __import__("time").strftime("%Y-%m-%dT%H:%M:%S")
p = os.path.join(BASE, "overrides.yaml")
with open(p, "w", encoding="utf-8") as f:
_yaml.safe_dump(self.overrides, f, allow_unicode=True, sort_keys=False, width=180)
# применить сразу
self.rebuild()
return {"ok": True, "device": entry["device"], "attr": attr, "value": v,
"unit": self.ALLOWED_ATTRS[attr]}
# ── тип установки устройства ──
CEILING = r"^VCM|^CM50|^CS10-D|^CLS120|^MSpeaker|^RCH|^AVHub"
TABLE = r"^CM20|^CS10\b|^CP50|^CPE|^CP965|^CTP|^MTouch|^PA\d|^VCR"
WALL = r"^UVC|^SmartVision|^MB-CAM|MeetingDisplay|^ETV"
RACK = r"^MCore|^MeetingEye|^MeetingBar|^MeetingBoard|^PVB|^PVT|^AP08|^AVBridge|^VCH|^WPP"
def mount_class(self, name):
n = str(name)
if re.match(self.CEILING, n, re.I):
return "ceiling"
if re.match(self.TABLE, n, re.I):
return "table"
if re.match(self.WALL, n, re.I):
return "wall"
if re.match(self.RACK, n, re.I):
return "rack"
return "other"
def coverage(self, name):
"""Радиус захвата микрофона и угол обзора камеры (из данных)."""
a = self.attrs.get(norm(name), {})
return {"pickup_m": a.get("audio.pickup_m"),
"fov_h": a.get("camera.fov_h"),
"zoom": a.get("camera.zoom_optical") or a.get("camera.zoom_hybrid")}
# ── покрытие по зонам (сетка) ──
def coverage_grid(self, host_key, items, w=8.0, l=10.0, cell=0.5):
"""Считает покрытие микрофонами по сетке комнаты.
Возвращает матрицу «сколько микрофонов достаёт до точки» и процент
площади с покрытием хотя бы одним микрофоном.
"""
mics = []
for r in items:
model, qty = r[0], int(r[1])
p = self.attrs.get(norm(model), {}).get("audio.pickup_m")
if p:
mics.append({"model": model, "qty": qty, "radius": float(p)})
built = self.attrs.get(norm(host_key), {}).get("audio.pickup_m")
if built:
mics.append({"model": "встроенный", "qty": 1, "radius": float(built)})
if not mics:
return {"ok": False, "reason": "нет данных о дальности микрофонов",
"grid": [], "covered_pct": 0}
nx, ny = max(1, int(w / cell)), max(1, int(l / cell))
# считаем, что микрофоны распределены по потолку равномерно
total_units = sum(m["radius"] and m["qty"] for m in mics) or 1
positions = []
idx = 0
for m in mics:
for _ in range(m["qty"]):
frac = (idx + 1) / (total_units + 1)
positions.append({"x": w * frac, "y": l * 0.5, "r": m["radius"],
"model": m["model"]})
idx += 1
grid, covered = [], 0
for j in range(ny):
row = []
for i in range(nx):
cx, cy = (i + 0.5) * cell, (j + 0.5) * cell
n = sum(1 for p in positions
if (p["x"] - cx) ** 2 + (p["y"] - cy) ** 2 <= p["r"] ** 2)
row.append(n)
if n:
covered += 1
grid.append(row)
return {"ok": True, "grid": grid, "nx": nx, "ny": ny, "cell": cell,
"w": w, "l": l, "positions": positions,
"covered_pct": round(100.0 * covered / (nx * ny), 1),
"mics": len(positions)}
# ── комплектация ──
def package(self, name):
k = norm(name)
p = self.pkg_map.get(k)
if p:
return {"items": p.get("items") or [],
"kits": p.get("optional_kits") or [], "source": "verified"}
if self.pkg_llm.get(k):
return {"items": self.pkg_llm[k], "kits": [], "source": "llm"}
for x in self.pkg_a.get("devices") or []:
if norm(x.get("device")) == k:
return {"items": x.get("items") or [], "kits": [], "source": "auto"}
return {"items": [], "kits": [], "source": None}
# ── крепление уже в комплекте? ──
def mount_included(self, name):
pkg = self.package(name)
for it in pkg.get("items") or []:
low = str(it).lower()
if any(w in low for w in ("кронштейн", "крепёж", "крепеж", "bracket",
"mount", "стойк")):
return True
return False
# ── полнота данных ──
def completeness(self, host_key):
hk = norm(host_key)
srcs = {}
for e in self.edges.get(hk, []):
s = e.get("source") or "?"
srcs[s] = srcs.get(s, 0) + 1
total = sum(srcs.values())
if "matrix" in srcs and "accessories_list" in srcs:
level, note = "full", "два источника: матрица + лист аксессуаров"
elif "matrix" in srcs:
level, note = "partial", "только матрица"
elif "accessories_list" in srcs:
level, note = "sparse", ("только лист аксессуаров (%d строк) — в матрице хоста нет"
% total)
else:
level, note = "none", "связей нет"
return {"level": level, "note": note, "edges": total, "sources": srcs}
# ── авто-сборка по выбору пользователя ──
def autofill(self, host_key, seats=8, include=None, need=None):
"""include: ['camera','panel','display','mount','sharing','mic']"""
include = set(include or ["mic", "camera", "panel", "display", "sharing"])
need = list(need or [])
hk = norm(host_key)
if hk not in self.devices:
return {"error": "хост не найден"}
host = self.devices[hk]["name"]
need_m = 3 if seats <= 6 else 6 if seats <= 12 else 8 if seats <= 16 else 10
items, notes = [], []
def by_role(role):
return [e for e in self.edges_of(hk)
if self.devices.get(norm(e["to"]), {}).get("role") == role]
items.append({"model": host, "qty": 1, "role": "Хост", "why": "основа"})
# микрофоны
if "mic" in include:
built = self.attrs.get(hk, {}).get("audio.pickup_m")
if built and built >= need_m:
notes.append("встроенный микрофон покрывает %s м (нужно %s м)"
% (built, need_m))
else:
cands = sorted(((self.attrs.get(norm(e["to"]), {}).get("audio.pickup_m") or 0, e)
for e in by_role("audio")), key=lambda x: -x[0])
if cands:
p, e = cands[0]
qty = max(1, -(-need_m // max(int(p), 1))) if p else 1
items.append({"model": e["to"], "qty": qty, "role": "Микрофон",
"why": "нужно %s м, у %s %s м" % (need_m, e["to"], p or "—")})
if "camera" in include:
cams = by_role("camera")
if cams:
def sc(e):
a = self.attrs.get(norm(e["to"]), {})
z = (a.get("camera.zoom_optical") or 0) + (a.get("camera.zoom_hybrid") or 0)
c = 1 if "content camera" in (e.get("condition") or "").lower() else 0
return z - c * 100
cams.sort(key=sc, reverse=True)
items.append({"model": cams[0]["to"], "qty": 1, "role": "Камера",
"why": "совместима"})
if "panel" in include:
p = by_role("touch")
if p:
items.append({"model": p[0]["to"], "qty": 1, "role": "Панель", "why": "совместима"})
if "sharing" in include:
sh = [e for e in by_role("sharing_or_hub")
if re.match(r"^WPP", e["to"], re.I) or re.match(r"^VCH", e["to"], re.I)]
if sh:
items.append({"model": sh[0]["to"], "qty": 1, "role": "Презентация",
"why": "совместима"})
if "display" in include:
d = by_role("display")
if d:
items.append({"model": d[0]["to"], "qty": 1, "role": "Дисплей", "why": "совместим"})
else:
notes.append("у Yealink нет дисплея для этого хоста — нужен внешний ТВ")
if "mount" in include:
mnts = self.mounts_map.get(hk) or []
chosen = None
for m in mnts:
if not self.mount_included(m):
chosen = m
break
if chosen:
items.append({"model": chosen, "qty": 1, "role": "Кронштейн",
"why": "совместим, не входит в комплект"})
elif mnts:
notes.append("все совместимые крепления уже входят в комплект")
else:
notes.append("совместимых креплений нет")
if any(norm(x) == "dante" for x in need):
notes.append("требуется Dante — добавьте комплект CM50+CS10-D+AP08")
cap = self.capacity(hk, [[i["model"], i["qty"]] for i in items
if not i["model"].startswith("встроенный")])
return {"host": host, "seats": seats, "need_pickup": need_m,
"items": items, "notes": notes, "capacity": cap,
"completeness": self.completeness(hk)}
# ── совместимость ──
def edges_of(self, host_key, supported_only=True):
out = []
for e in self.edges.get(norm(host_key), []):
if supported_only and (not e.get("supported") or not e.get("usable", True)):
continue
out.append(e)
return out
def check_pair(self, host_key, device):
hk, ak = norm(host_key), norm(device)
host = self.devices.get(hk, {}).get("name")
dev = self.devices.get(ak, {}).get("name") or device
if not host:
return {"error": "хост не найден"}
found = next((e for e in self.edges.get(hk, []) if norm(e["to"]) == ak), None)
if not found:
return {"host": host, "device": dev, "known": False, "supported": False,
"verdict": "нет в матрице для этого хоста"}
cond = re.sub(r"^[\u221a\u2713\u2714\u00d7\u2717\u2718\u2022\s]+", "",
found.get("condition") or "").strip()
if not found.get("usable", True):
verdict = "исключено: источники расходятся"
elif found.get("supported"):
q = found.get("max_qty")
verdict = "совместимо" + (" (до %s шт)" % q if q else "")
else:
verdict = "несовместимо"
return {"host": host, "device": dev, "known": True,
"supported": bool(found.get("supported")),
"usable": found.get("usable", True),
"max_qty": found.get("max_qty"), "condition": cond,
"source": found.get("source"), "verdict": verdict}
# ── ёмкость и подсчёт портов ──
def capacity(self, host_key, items, infra_items=None):
hk = norm(host_key)
host = self.devices.get(hk, {}).get("name")
ha = self.attrs.get(hk, {})
vch_ports = ha.get("ports.vch")
total_w, missing_w, vch_users = 0.0, [], 0
qtys = {}
for row in items:
model, qty = row[0], int(row[1])
qtys[model] = qtys.get(model, 0) + qty
limits = {norm(e["to"]): (e.get("max_qty"), e["to"])
for e in self.edges.get(hk, []) if e.get("supported")}
issues = []
for model, q in qtys.items():
lim, name = limits.get(norm(model), (None, model))
if lim and q > lim:
issues.append("%s: %d шт при лимите %d" % (name, q, lim))
a = self.attrs.get(norm(model), {})
w = a.get("power.consumption_w")
if w:
total_w += w * q
else:
missing_w.append(model)
if a.get("audio.pickup_m") or a.get("ports.vch"):
vch_users += q
# инфраструктура: порты с учётом каскада (каждый доп. коммутатор
# занимает 1 порт предыдущего)
total_infra_ports, extra_budget, n_switches = 0, 0.0, 0
for inf in (infra_items or []):
for x in (self.infra.get("devices") or []):
if norm(x["device"]) == norm(inf):
sp = x.get("specs") or {}
total_infra_ports += int(sp.get("poe_ports") or 0)
extra_budget += float(sp.get("poe_budget_w") or 0)
n_switches += 1
extra_ports = max(0, total_infra_ports - max(0, n_switches - 1))
chains_needed = None
if vch_users and vch_ports is not None:
total_ports = int(vch_ports) + extra_ports
chains_needed = vch_users if total_ports < vch_users else 1
if vch_users > total_ports:
issues.append("VCH: %d устройств на %d порт(а) — нужны цепочки или RCH40 E2"
% (vch_users, total_ports))
return {"host": host, "vch_ports": vch_ports, "vch_users": vch_users,
"extra_ports": extra_ports, "extra_budget_w": extra_budget,
"n_switches": n_switches, "raw_infra_ports": total_infra_ports,
"total_power_w": round(total_w, 1),
"power_budget_w": extra_budget or None,
"missing_power": sorted(set(missing_w)),
"issues": issues, "chains_needed": chains_needed}
# ── подсчёт портов (port accounting) ──
def port_plan(self, host_key, items):
hk = norm(host_key)
host = self.devices.get(hk, {}).get("name")
h_in, h_out, h_src = self.ports(host)
used_in, used_out = [], []
rows = []
for row in items:
model, qty = row[0], int(row[1]) if len(row) > 1 else 1
a_in, a_out, src = self.ports(model)
role_dev = self.devices.get(norm(model), {}).get("role")
need = [p for p in a_out if p != "—"] or [p for p in a_in if p != "—"]
port = need[0] if need else None
slot = None
if port:
cands = []
# устройство -> вход хоста
# инфраструктура (PoE-свитчи): сеть соединяется «порт-порт»,
# направление не важно — LAN есть и там, и там
if role_dev in ("infrastructure", None, "unknown") and "LAN" in (a_in + a_out):
for ap in [p for p in (a_in + a_out) if p != "—"]:
for hp in (h_in + h_out):
if (ap, hp) in self.LINKABLE or (hp, ap) in self.LINKABLE:
cands.append((self.PORT_RANK.get(ap, 9), ap,
"out:" + hp if hp in h_out else hp))
# устройство (выход) -> вход хоста
for ap in [p for p in a_out if p != "—"]:
for hp in h_in:
if (ap, hp) in self.LINKABLE or (hp, ap) in self.LINKABLE:
cands.append((self.PORT_RANK.get(ap, 9), ap, hp))
# выход хоста -> вход устройства (только входы, не выходы!)
for hp in h_out:
for ap in [p for p in a_in if p != "—"]:
if (hp, ap) in self.LINKABLE or (ap, hp) in self.LINKABLE:
cands.append((self.PORT_RANK.get(ap, 9) + 100, ap, "out:" + hp))
if cands:
role = self.devices.get(norm(model), {}).get("role")
pref = self.ROLE_PORT_PREF.get(role) or []
def rank(item):
r, ap, hp = item
# беспроводная связь приоритетнее любого кабеля
if ap == "WL" and str(hp) == "WL":
return -1000
base = 0
# дисплей принимает видео — подключаем к ВЫХОДУ хоста,
# иначе он цепляется к HDMI-входу кодека (BYOD).
if role == "display" and not str(hp).startswith("out:"):
base = 500
if ap in pref:
return base + pref.index(ap)
return base + 90 + r
cands.sort(key=rank)
_, port, slot = cands[0]
# матрица совместимости главнее портов: если связь «хост → устройство»
# помечена как неподдерживаемая, схема недействительна.
reason = None
in_matrix = None
for e in self.edges_of(hk, supported_only=False):
if norm(e.get("to")) == norm(model):
in_matrix = e
break
if in_matrix is not None and not in_matrix.get("supported"):
reason = "не поддерживается матрицей: " + \
((in_matrix.get("condition") or "").strip() or "×")
slot = None
elif in_matrix is None and self.devices.get(norm(model), {}).get("role") not in (
"display", "pc", "infrastructure"):
# устройство не из матрицы Yealink (ПК, проектор, свитч) — это нормально
reason = "нет в матрице — подключение по портам"
# ПК с беспроводным мостом (WPP30) в составе — только через мост:
# кабелем в терминал нельзя, там HDMI только выход.
if role_dev == "pc" and slot:
for m2, _q2 in items:
b_in, b_out, _ = self.ports(m2)
# мост = устройство с беспроводным выходом И USB-входом (донгл),
# иначе под правило попадали бы сами микрофоны
if "WL" in b_out and ("USB" in b_in or "USB-C" in b_in):
slot = None
break
if slot and slot.startswith("out:"):
used_out.append(slot[4:])
elif slot:
used_in.append(slot)
rows.append({"device": model, "qty": qty, "needs_port": port,
"host_port": slot, "source": src,
"ok": bool(slot), "reason": reason,
"matrix": (None if in_matrix is None
else bool(in_matrix.get("supported")))})
# ── второй проход: ЦЕПОЧКИ ──
# Если хост не может принять устройство напрямую (или матрица против),
# ищем промежуточное устройство в составе, которое это умеет.
# Пример: RoomCast E2 + UVC86 + VCM36-W×3 — микрофоны идут через камеру.
chains = []
by_name = {norm(r["device"]): r for r in rows}
for r in rows:
if r["ok"]:
continue
dn = norm(r["device"])
for cn, c_row in by_name.items():
if not c_row["ok"] or cn == dn:
continue
e = next((x for x in self.edges.get(cn, [])
if norm(x.get("to")) == dn and x.get("supported")), None)
if not e:
continue
# промежуточное устройство должно иметь подходящий порт;
# если порт не сходится, допускаем только когда матрица
# прямо разрешает (вендор знает лучше нашей модели портов).
v_in, v_out, _ = self.ports(self.devices.get(cn, {}).get("name") or cn)
a_in, a_out, _ = self.ports(model)
vports = [p for p in (v_in + v_out) if p != "—"]
aport = [p for p in (a_in + a_out) if p != "—"]
port_ok = any((p, q) in self.LINKABLE or (q, p) in self.LINKABLE
for p in aport for q in vports)
if not port_ok and cn not in by_name:
continue
mx = e.get("max_qty")
used = sum(int(x["qty"]) for x in rows
if x.get("via") and norm(x["via"]) == cn)
if mx is not None and used + int(r["qty"]) > int(mx):
continue
via = self.devices.get(cn, {}).get("name") or cn
r["via"] = via
r["ok"] = True
r["reason"] = ("через %s (до %s)" % (via, mx if mx is not None else "—")
+ ("" if port_ok else " · порт по матрице"))
chains.append({"via": via, "device": r["device"], "qty": r["qty"],
"max_qty": mx,
"condition": (e.get("condition") or "").strip()[:100]})
break
# ── третий проход: мост (2 шага) ──
# Пример: ПК подключается не кабелем в RoomCast (там HDMI только выход),
# а через беспроводной донгл WPP30: ПК ←USB← WPP30 ⇢WL⇢ RoomCast.
for r in rows:
if r["ok"]:
continue
for bn, b_row in by_name.items():
if not b_row["ok"] or bn == norm(r["device"]):
continue
b_in, b_out, _ = self.ports(self.devices.get(bn, {}).get("name") or bn)
# мост должен уметь беспроводную передачу и цепляться к хосту
if "WL" not in b_out:
continue
host_ok = ("WL" in h_in) or ("WL" in h_out)
if not host_ok:
continue
a_in, a_out, _ = self.ports(r["device"])
aport = [p for p in (a_in + a_out) if p != "—"]
bports = [p for p in (b_in + b_out) if p != "—"]
if not any((p, q) in self.LINKABLE or (q, p) in self.LINKABLE
for p in aport for q in bports):
continue
via = self.devices.get(bn, {}).get("name") or bn
r["via"] = via
r["ok"] = True
r["reason"] = "через %s (беспроводно)" % via
chains.append({"via": via, "device": r["device"], "qty": r["qty"],
"max_qty": None, "condition": "беспроводной мост"})
break
return {"host": host, "host_in": h_in, "host_out": h_out, "source": h_src,
"rows": rows, "chains": chains,
"used_in": used_in, "used_out": used_out,
"free_in": [p for p in h_in if p not in used_in],
"free_out": [p for p in h_out if p not in used_out],
"unresolved": [r["device"] for r in rows if not r["ok"]]}
# ── кабельный журнал ──
def cable_schedule(self, host_key, items):
plan = self.port_plan(host_key, items)
cables = []
for r in plan["rows"]:
if not r["ok"]:
continue
port = r["needs_port"]
if r.get("via"):
# цепочка: промежуточное устройство → аксессуар
cables.append({"from": r["via"], "from_port": "→ " + str(port),
"to": r["device"], "to_port": port,
"type": port, "qty": r["qty"],
"note": r.get("reason") or ""})
continue
cables.append({"from": plan["host"], "from_port": r["host_port"],
"to": r["device"], "to_port": port,
"type": port, "qty": r["qty"],
"note": "в комплекте" if self.package(r["device"])["items"] else ""})
return {"host": plan["host"], "cables": cables,
"count": len(cables), "unresolved": plan["unresolved"]}