195 lines
9.6 KiB
Python
195 lines
9.6 KiB
Python
#!/usr/bin/env python3
|
||
"""Атрибуты v2: расширенный реестр + нормализация единиц.
|
||
|
||
Добавлено: вес, габариты, питание, PoE-класс, температура, PTZ-предустановки,
|
||
диапазоны поворота, SNR, пропускная способность, число портов.
|
||
Нормализация: футы -> метры, мм -> см, кВт -> Вт.
|
||
"""
|
||
import glob
|
||
import os
|
||
import re
|
||
import sys
|
||
|
||
BASE = "/opt/work-hub/compat"
|
||
DEV_DIRS = ["/opt/work-hub/devices/yealink"]
|
||
|
||
# Границы правдоподобия: значения вне диапазона — ошибка извлечения, отбрасываем.
|
||
PLAUSIBLE = {
|
||
"audio.spl_max": (60, 140), "audio.snr": (40, 120),
|
||
"audio.freq_min": (20, 400), "audio.freq_max_khz": (4, 48),
|
||
"audio.pickup_m": (0.5, 30), "audio.mic_count": (1, 64),
|
||
"audio.expansion_mics": (1, 16),
|
||
"camera.zoom_optical": (1, 60), "camera.zoom_hybrid": (1, 60),
|
||
"camera.zoom_digital": (1, 30),
|
||
"camera.fov_h": (20, 180), "camera.fov_v": (10, 180),
|
||
"camera.tilt_range": (5, 180), "camera.pan_range": (10, 360),
|
||
"camera.presets": (1, 255), "camera.dof_min": (0.1, 10),
|
||
"network.ethernet_mbps": (10, 100000),
|
||
"ports.hdmi_out": (1, 8), "ports.hdmi_in": (1, 8),
|
||
"ports.usb": (1, 12), "ports.vch": (1, 8),
|
||
"physical.weight_kg": (0.05, 100), "physical.temp_min": (-30, 40),
|
||
}
|
||
|
||
# id: (группа, название, единица, тип, [паттерны])
|
||
ATTRS = {
|
||
# ── камера ──
|
||
"camera.zoom_optical": ("Камера", "Оптический зум", "×", "number",
|
||
[r"(\d+(?:\.\d+)?)\s*[x×]\s*optical\s*zoom",
|
||
r"optical\s*zoom[:\s]*(\d+(?:\.\d+)?)"]),
|
||
"camera.zoom_hybrid": ("Камера", "Гибридный зум", "×", "number",
|
||
[r"hybrid\s*zoom[:\s]*(\d+(?:\.\d+)?)",
|
||
r"(\d+(?:\.\d+)?)\s*[x×]\s*hybrid"]),
|
||
"camera.zoom_digital": ("Камера", "Цифровой зум", "×", "number",
|
||
[r"(\d+)\s*x\s*digital\s*zoom",
|
||
r"digital\s*zoom[:\s]*(\d+(?:\.\d+)?)"]),
|
||
"camera.fov_h": ("Камера", "FOV по горизонтали", "°", "number",
|
||
[r"HFOV[:\s]*(\d+(?:\.\d+)?)", r"horizontal\s*FOV[:\s]*(\d+(?:\.\d+)?)"]),
|
||
"camera.fov_v": ("Камера", "FOV по вертикали", "°", "number",
|
||
[r"VFOV[:\s]*(\d+(?:\.\d+)?)", r"vertical\s*FOV[:\s]*(\d+(?:\.\d+)?)"]),
|
||
"camera.presets": ("Камера", "PTZ-предустановок", "шт", "number",
|
||
[r"(?:preset\s*positions|number\s*of\s*presets?)[:\s]*(\d+)"]),
|
||
"camera.pan_range": ("Камера", "Диапазон поворота", "°", "number",
|
||
[r"pan\s*(?:range|angle)[:\s]*[±]?(\d+(?:\.\d+)?)"]),
|
||
"camera.tilt_range": ("Камера", "Диапазон наклона", "°", "number",
|
||
[r"tilt\s*(?:range|angle)[:\s]*[±]?(\d+(?:\.\d+)?)"]),
|
||
"camera.max_resolution": ("Камера", "Максимальное разрешение", "px", "text",
|
||
[r"maximum\s*resolution[:\s]*([\d\*x×]+)"]),
|
||
"camera.dof_min": ("Камера", "Глубина резкости от", "м", "number",
|
||
[r"depth\s*of\s*field[:\s]*(\d+(?:\.\d+)?)"]),
|
||
# ── аудио ──
|
||
"audio.pickup_m": ("Аудио", "Дальность захвата", "м", "number",
|
||
[r"(\d+(?:\.\d+)?)\s*[- ]?met(?:er|re)s?\s*pickup",
|
||
r"pickup\s*(?:distance|range)[:\s]*(\d+(?:\.\d+)?)\s*m",
|
||
r"(\d+(?:\.\d+)?)\s*m\s*pickup"]),
|
||
"audio.spl_max": ("Аудио", "Макс. звуковое давление", "dB SPL", "number",
|
||
[r"(\d+)\s*dB\s*SPL"]),
|
||
"audio.mic_count": ("Аудио", "Микрофонных элементов", "шт", "number",
|
||
[r"(\d+)\s*(?:MEMS\s*)?microphone\s*array"]),
|
||
"audio.snr": ("Аудио", "Отношение сигнал/шум", "dB", "number",
|
||
[r"signal[-\s]*to[-\s]*noise\s*ratio[:\s]*(\d+)"]),
|
||
"audio.freq_min": ("Аудио", "Нижняя граница частот", "Гц", "number",
|
||
[r"frequency\s*response[:\s]*(\d+)\s*[-\u2013]"]),
|
||
"audio.freq_max_khz": ("Аудио", "Верхняя граница частот", "кГц", "number",
|
||
[r"frequency\s*response[:\s]*\d+\s*[-\u2013]\s*(\d+)\s*kHz"]),
|
||
"audio.expansion_mics": ("Аудио", "Расширительных микрофонов", "шт", "number",
|
||
[r"supports?\s*(\d+)\s*expansion\s*microphone"]),
|
||
# ── сеть и интерфейсы ──
|
||
"network.poe": ("Сеть", "PoE-питание", "—", "bool", [r"PoE", r"802\.3af", r"802\.3at"]),
|
||
"network.usb_c": ("Сеть", "USB-C", "—", "bool", [r"USB[-\s]?C"]),
|
||
"network.ethernet_mbps": ("Сеть", "Ethernet до", "Мбит/с", "number",
|
||
[r"10/100/(\d+)\s*Mbps"]),
|
||
"network.bluetooth": ("Сеть", "Bluetooth", "—", "bool", [r"Bluetooth\s*\d"]),
|
||
"network.wifi": ("Сеть", "Wi-Fi", "—", "bool", [r"Wi-Fi\s*\d?"]),
|
||
"ports.hdmi_out": ("Интерфейсы", "HDMI-выходов", "шт", "number",
|
||
[r"(\d+)\s*x\s*HDMI[-\s]?out"]),
|
||
"ports.hdmi_in": ("Интерфейсы", "HDMI-входов", "шт", "number",
|
||
[r"(\d+)\s*x\s*HDMI[-\s]?in"]),
|
||
"ports.usb": ("Интерфейсы", "USB-портов", "шт", "number",
|
||
[r"(\d+)\s*x\s*USB"]),
|
||
"ports.vch": ("Интерфейсы", "VCH-портов", "шт", "number",
|
||
[r"(\d+)\s*x\s*(?:Yealink\s*)?VCH"]),
|
||
# ── физика ──
|
||
"physical.weight_kg": ("Физика", "Вес", "кг", "number",
|
||
[r"weight[:\s]*(\d+(?:\.\d+)?)\s*kg"]),
|
||
"physical.temp_min": ("Физика", "Температура от", "°C", "number",
|
||
[r"(?:operating\s*)?temperature[:\s]*(-?\d+)\s*°?C"]),
|
||
}
|
||
|
||
|
||
def fix(s):
|
||
if s is None:
|
||
return ""
|
||
s = str(s)
|
||
for enc in ("cp1251", "cp866"):
|
||
try:
|
||
return s.encode(enc).decode("utf-8")
|
||
except Exception:
|
||
continue
|
||
return s
|
||
|
||
|
||
def norm_units(attr, val, blob):
|
||
"""Нормализация: футы -> метры, мм -> см."""
|
||
if attr.endswith("_m") and isinstance(val, float):
|
||
m = re.search(r"(\d+(?:\.\d+)?)\s*ft", blob, re.I)
|
||
if m: # если в тексте футы — переводим и сверяем
|
||
ft_m = float(m.group(1)) * 0.3048
|
||
if abs(ft_m - val) < 3:
|
||
return round(ft_m, 2)
|
||
return val
|
||
|
||
|
||
def load_datasheets():
|
||
out = {}
|
||
for d in DEV_DIRS:
|
||
for f in glob.glob(os.path.join(d, "*.yaml")):
|
||
try:
|
||
import yaml
|
||
data = yaml.safe_load(open(f, encoding="utf-8"))["device"]
|
||
except Exception:
|
||
continue
|
||
model = (data.get("model") or os.path.basename(f)).strip()
|
||
lines = []
|
||
for k, vals in (data.get("specs") or {}).items():
|
||
for v in vals:
|
||
lines.append("%s: %s" % (k, v))
|
||
out[model] = lines
|
||
return out
|
||
|
||
|
||
def main():
|
||
import yaml
|
||
ds = load_datasheets()
|
||
values, stats = [], {a: 0 for a in ATTRS}
|
||
for model, lines in ds.items():
|
||
blob = "\n".join(lines)
|
||
found = {}
|
||
for aid, (g, n, u, typ, pats) in ATTRS.items():
|
||
for pat in pats:
|
||
m = re.search(pat, blob, re.I)
|
||
if not m:
|
||
continue
|
||
if typ == "bool":
|
||
found[aid] = True
|
||
elif typ == "number":
|
||
try:
|
||
v = float(m.group(1))
|
||
except (ValueError, IndexError):
|
||
continue
|
||
lo, hi = PLAUSIBLE.get(aid, (-1e9, 1e9))
|
||
if not (lo <= v <= hi):
|
||
continue # вне правдоподобных границ
|
||
found[aid] = norm_units(aid, v, blob)
|
||
else:
|
||
found[aid] = m.group(1) if m.groups() else m.group(0)
|
||
break
|
||
if found:
|
||
for a in found:
|
||
stats[a] += 1
|
||
values.append({"device": model, "attributes": found})
|
||
|
||
reg = {"groups": sorted({v[0] for v in ATTRS.values()}),
|
||
"attributes": [{"id": a, "group": g, "name": n, "unit": u, "type": t}
|
||
for a, (g, n, u, t, _) in ATTRS.items()]}
|
||
with open(os.path.join(BASE, "attributes.yaml"), "w", encoding="utf-8") as f:
|
||
yaml.safe_dump(reg, f, allow_unicode=True, sort_keys=False, width=140)
|
||
with open(os.path.join(BASE, "values.yaml"), "w", encoding="utf-8") as f:
|
||
yaml.safe_dump({"vendor": "yealink", "devices": values},
|
||
f, allow_unicode=True, sort_keys=False, width=160)
|
||
|
||
print("атрибутов в реестре: %d" % len(ATTRS))
|
||
print("устройств со значениями: %d" % len(values))
|
||
print("\nзаполненность:")
|
||
for a, n in sorted(stats.items(), key=lambda x: -x[1]):
|
||
if n:
|
||
g, name, u, t, _ = ATTRS[a]
|
||
print(" %-26s %-30s %2d" % (a, name, n))
|
||
empty = [a for a, n in stats.items() if not n]
|
||
if empty:
|
||
print("\nне заполнено (%d): %s" % (len(empty), ", ".join(empty[:10])))
|
||
return 0
|
||
|
||
|
||
if __name__ == "__main__":
|
||
sys.exit(main())
|