first commit
build / test (push) Canceled after 0s
build / deb (amd64) (push) Canceled after 0s
build / deb (arm64) (push) Canceled after 0s
build / deb (armhf) (push) Canceled after 0s

This commit is contained in:
Mateusz Gruszczyński committed 2026-11-16 16:19:21 +01:00
commit c30064b531
93 files changed
+26367

No files matched your search

+518
View File
@@ -0,0 +1,518 @@
#!/usr/bin/env python3
"""Copy the channel list layout from tvheadend to simply-dvb.
Reads tvheadend channels (number, name, enabled, tags) either from a running tvheadend
(HTTP API) or from its configuration directory, matches them with simply-dvb channels and
applies numbers – optionally also names, groups (from tags) and the enabled state.
Matching runs in passes, most reliable first (a weaker match never takes a channel that a
stronger one would get):
1. service by network ids: ONID + TSID + SID (works even if the transmitter frequency differs),
2. service: SID on the same frequency (±1 MHz),
3. exact channel/service name (case, diacritics, spaces, "HD"/"SD" ignored),
4. loose name without quality/test/prefix words ("Zet" = "Radio ZET", "PR1" = "PR1 emisja testowa"),
5. similar name (typos, spacing; --fuzzy threshold, numbers must agree: "PR1" never "PR2"),
6. SID alone when it is unique.
tvheadend duplicates (two tvh channels for one service) are listed separately and skipped.
Nothing is changed without --apply (dry run prints the plan).
Examples:
# tvheadend still running (stop it later, or run simply-dvb's stream port elsewhere)
scripts/import-tvheadend.py --tvh http://192.168.1.10:9981 --tvh-user admin \\
--url http://192.168.1.10:9980 --user admin
# tvheadend already stopped: read its configuration directory
sudo scripts/import-tvheadend.py --tvh-config /var/lib/tvheadend --url http://localhost:9980 --user admin
# apply, including names, groups and enabled/disabled state; disable channels tvheadend did not have
scripts/import-tvheadend.py --tvh-config ~/tvh-backup --user admin --names --groups --enabled \\
--unmatched disable --apply
Passwords: --tvh-pass / --password, the TVH_PASSWORD / SIMPLY_DVB_PASSWORD environment
variables, or an interactive prompt. Only the Python 3 standard library is needed.
"""
import argparse
import getpass
import gzip
import http.cookiejar
import json
import os
import re
import sys
import unicodedata
import urllib.error
import urllib.parse
import urllib.request
import zlib
# ---------------------------------------------------------------- helpers
def norm_name(s):
"""Same normalization as simply-dvb's XMLTV matching: "TVP 1 HD" == "tvp1"."""
s = unicodedata.normalize("NFKD", (s or "").lower().replace("ł", "l"))
s = "".join(c for c in s if c.isalnum() and not unicodedata.combining(c))
for suf in ("uhd", "fhd", "hd", "sd", "pl"):
if len(s) > len(suf) + 1 and s.endswith(suf):
s = s[: -len(suf)]
break
return s
def to_number(v):
try:
n = float(v)
except (TypeError, ValueError):
return 0
return int(round(n)) if n > 0 else 0
def mhz(hz):
try:
return round(float(hz) / 1e6)
except (TypeError, ValueError):
return None
def die(msg):
print("error: " + msg, file=sys.stderr)
sys.exit(1)
# ---------------------------------------------------------------- tvheadend sources
class Tvh:
"""tvheadend data: channels [{name, number, enabled, tags:[names], services:[(sid, mhz, name)]}]."""
def __init__(self):
self.channels = []
def tvh_from_api(base, user, password):
base = base.rstrip("/")
handlers = []
if user:
mgr = urllib.request.HTTPPasswordMgrWithDefaultRealm()
mgr.add_password(None, base, user, password)
# tvheadend uses digest or basic auth depending on its configuration
handlers += [urllib.request.HTTPDigestAuthHandler(mgr), urllib.request.HTTPBasicAuthHandler(mgr)]
opener = urllib.request.build_opener(*handlers)
def grid(path):
url = base + path + ("&" if "?" in path else "?") + "start=0&limit=999999"
try:
with opener.open(url, timeout=30) as r:
return json.load(r).get("entries", [])
except urllib.error.HTTPError as e:
if e.code in (401, 403):
die(f"tvheadend refused {path} (HTTP {e.code}) – check --tvh-user/--tvh-pass and the user's admin rights")
die(f"tvheadend {path}: HTTP {e.code}")
except urllib.error.URLError as e:
die(f"cannot reach tvheadend at {base}: {e.reason}")
tags = {t["uuid"]: t.get("name", "") for t in grid("/api/channeltag/grid")}
muxes = {m["uuid"]: m for m in grid("/api/mpegts/mux/grid")}
services = {}
for s in grid("/api/mpegts/service/grid"):
m = muxes.get(s.get("multiplex_uuid"), {})
services[s["uuid"]] = (s.get("sid"), mhz(m.get("frequency")), s.get("svcname", ""), m.get("onid"), m.get("tsid"))
t = Tvh()
for c in grid("/api/channel/grid"):
t.channels.append({
"name": c.get("name", ""),
"number": to_number(c.get("number")),
"enabled": bool(c.get("enabled", True)),
"autoname": bool(c.get("autoname", False)),
"tags": [tags[x] for x in c.get("tags", []) if tags.get(x)],
"services": [services[x] for x in c.get("services", []) if x in services],
})
return t
def read_tvh_file(path):
"""tvheadend config files are JSON, optionally compressed ("\\xff\\xffGZIP0x" header)."""
with open(path, "rb") as f:
data = f.read()
if data.startswith(b"\xff\xffGZIP"):
body = data[12:]
try:
data = gzip.decompress(body)
except OSError:
data = zlib.decompress(body)
try:
return json.loads(data.decode("utf-8"))
except ValueError:
return None
def tvh_from_config(root):
root = os.path.expanduser(root)
if not os.path.isdir(os.path.join(root, "channel", "config")):
die(f"{root}/channel/config not found – point --tvh-config to tvheadend's configuration directory "
"(usually /var/lib/tvheadend or ~hts/.hts/tvheadend)")
tags = {}
tag_dir = os.path.join(root, "channel", "tag")
if os.path.isdir(tag_dir):
for u in os.listdir(tag_dir):
j = read_tvh_file(os.path.join(tag_dir, u))
if j:
tags[u] = j.get("name", "")
services = {}
nets = os.path.join(root, "input", "dvb", "networks")
if os.path.isdir(nets):
for net in os.listdir(nets):
mdir = os.path.join(nets, net, "muxes")
if not os.path.isdir(mdir):
continue
for mux in os.listdir(mdir):
mcfg = read_tvh_file(os.path.join(mdir, mux, "config")) or {}
freq = mhz(mcfg.get("frequency"))
onid, tsid = mcfg.get("onid"), mcfg.get("tsid")
sdir = os.path.join(mdir, mux, "services")
if not os.path.isdir(sdir):
continue
for svc in os.listdir(sdir):
j = read_tvh_file(os.path.join(sdir, svc)) or {}
services[svc] = (j.get("sid"), freq, j.get("svcname", ""), onid, tsid)
t = Tvh()
cdir = os.path.join(root, "channel", "config")
for u in os.listdir(cdir):
c = read_tvh_file(os.path.join(cdir, u))
if not c:
continue
t.channels.append({
"name": c.get("name", ""),
"number": to_number(c.get("number")),
"enabled": bool(c.get("enabled", True)),
"autoname": bool(c.get("autoname", False)),
"tags": [tags[x] for x in c.get("tags", []) if tags.get(x)],
"services": [services[x] for x in c.get("services", []) if x in services],
})
return t
# ---------------------------------------------------------------- simply-dvb API
class SimplyDvb:
def __init__(self, base, user, password):
self.base = base.rstrip("/")
self.opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(http.cookiejar.CookieJar()))
self.call("POST", "/api/login", {"username": user, "password": password})
def call(self, method, path, body=None):
data = json.dumps(body).encode() if body is not None else None
req = urllib.request.Request(self.base + path, data=data, method=method)
req.add_header("X-Requested-With", "simply-dvb")
if data is not None:
req.add_header("Content-Type", "application/json")
try:
with self.opener.open(req, timeout=60) as r:
txt = r.read().decode()
return json.loads(txt) if txt else None
except urllib.error.HTTPError as e:
msg = e.read().decode(errors="replace")
try:
msg = json.loads(msg).get("error", msg)
except ValueError:
pass
die(f"simply-dvb {method} {path}: HTTP {e.code} {msg}")
except urllib.error.URLError as e:
die(f"cannot reach simply-dvb at {self.base}: {e.reason}")
# ---------------------------------------------------------------- matching
# words that do not identify a channel (quality, test transmissions, prefixes)
NOISE = re.compile(
r"\b(u?hd|fhd|sd|4k|pl|polska|poland|tv|telewizja|radio|polskie|kanal|channel|"
r"emisja|testowa|test|em|testowy|eksperymentalna|plus)\b"
)
def loose_name(s):
"""Name reduced to its identifying part: "Radio ZET em.test." -> "zet", "TVN 24 HD" -> "tvn24"."""
s = unicodedata.normalize("NFKD", (s or "").lower().replace("ł", "l"))
s = "".join(c for c in s if not unicodedata.combining(c))
s = s.replace("+", " plus ").replace("&", " and ")
s = re.sub(r"[^a-z0-9]+", " ", s)
s = NOISE.sub(" ", s)
s = re.sub(r"\s+", "", s)
return s or norm_name(s)
def digits(s):
"""Numbers in a name must agree: "PR1" never matches "PR2", "TVP3" never "TVP".."""
return re.findall(r"\d+", unicodedata.normalize("NFKD", s or ""))
def similar(a, b):
from difflib import SequenceMatcher
la, lb = loose_name(a), loose_name(b)
if not la or not lb or digits(a) != digits(b):
return 0.0
if la == lb:
return 1.0
return SequenceMatcher(None, la, lb).ratio()
def build_plan(tvh, channels, services, muxes, fuzzy=0.86):
"""Matches tvheadend channels with simply-dvb channels in passes, most reliable first,
so a weaker match can never take a channel that a stronger one would get."""
mux = {m["id"]: m for m in muxes}
chans = [c for c in channels]
used = {} # simply-dvb channel id -> tvheadend channel
result = {} # id(tvh channel) -> (simply-dvb channel, how)
def svc_of(c):
s = c.get("service") or {}
m = mux.get(s.get("mux_id"), {})
return s, m
def assign(t, c, how):
used[c["id"]] = t
result[id(t)] = (c, how)
order = sorted(tvh.channels, key=lambda x: (x["number"] == 0, x["number"], x["name"].lower()))
def run(match, how):
for t in order:
if id(t) in result:
continue
c = match(t)
if c is not None and c["id"] not in used:
assign(t, c, how)
# 1. network identity: ONID + TSID + SID (independent of the transmitter frequency)
def by_triplet(t):
for sid, _, _, onid, tsid in t["services"]:
if sid is None or onid is None or tsid is None:
continue
for c in chans:
s, m = svc_of(c)
if c["id"] not in used and s.get("sid") == sid and m.get("onid") == onid and m.get("ts_id") == tsid:
return c
return None
# 2. SID on the same frequency (±1 MHz)
def by_sid_freq(t):
for sid, f, *_ in t["services"]:
for c in chans:
s, m = svc_of(c)
cf = mhz(m.get("frequency_hz"))
if c["id"] not in used and s.get("sid") == sid and f is not None and cf is not None and abs(cf - f) <= 1:
return c
return None
# 3. exact (normalized) channel or service name
def by_name(t):
keys = {norm_name(t["name"])} | {norm_name(x[2]) for x in t["services"] if x[2]}
for c in chans:
if c["id"] in used:
continue
s, _ = svc_of(c)
if norm_name(c["name"]) in keys or (s.get("name") and norm_name(s["name"]) in keys):
return c
return None
# 4. loose name: without quality/test/prefix words ("Zet" == "Radio ZET", "PR1" == "PR1 emisja testowa")
def by_loose(t):
keys = {loose_name(t["name"])} | {loose_name(x[2]) for x in t["services"] if x[2]}
keys.discard("")
hits = [c for c in chans if c["id"] not in used and
(loose_name(c["name"]) in keys or loose_name((c.get("service") or {}).get("name", "")) in keys)
and digits(c["name"]) == digits(t["name"])]
return hits[0] if len(hits) == 1 else None
# 5. similar name (typos, spacing) – only a clear single best candidate
def by_similar(t):
if fuzzy >= 1:
return None
best, best_score, second = None, 0.0, 0.0
for c in chans:
if c["id"] in used:
continue
sc = max(similar(t["name"], c["name"]), similar(t["name"], (c.get("service") or {}).get("name", "")))
if sc > best_score:
best, best_score, second = c, sc, best_score
elif sc > second:
second = sc
return best if best_score >= fuzzy and best_score - second >= 0.05 else None
# 6. SID alone when it is unique in simply-dvb (frequency changed, no NIT ids in tvheadend)
def by_sid(t):
for sid, *_ in t["services"]:
hits = [c for c in chans if (c.get("service") or {}).get("sid") == sid]
if len(hits) == 1 and hits[0]["id"] not in used and similar(t["name"], hits[0]["name"]) >= 0.5:
return hits[0]
return None
run(by_triplet, "service (network ids)")
run(by_sid_freq, "service (SID + frequency)")
run(by_name, "name")
run(by_loose, "similar name")
run(by_similar, "similar name")
run(by_sid, "service (SID)")
# services without a channel (can be created with --create)
free = [s for s in services if s.get("channel_id") is None]
plan, missing, dups = [], [], []
for t in order:
if id(t) in result:
c, how = result[id(t)]
plan.append((t, c, how))
continue
# a tvheadend duplicate: same service or name as a channel already taken by another tvh channel
twin = None
for c in chans:
s, m = svc_of(c)
same_svc = any(s.get("sid") == sid and (f is None or abs((mhz(m.get("frequency_hz")) or 0) - f) <= 1)
for sid, f, *_ in t["services"])
if c["id"] in used and (same_svc or similar(t["name"], c["name"]) >= 0.95):
twin = c
break
if twin is not None:
dups.append((t, twin, used[twin["id"]]))
continue
create = None
for sid, f, *_ in t["services"]:
for sv in free:
if sv.get("sid") == sid and abs((mhz(mux.get(sv.get("mux_id"), {}).get("frequency_hz")) or 0) - (f or 0)) <= 1:
create = sv
break
if create:
break
if not create:
for sv in free:
if similar(t["name"], sv.get("name", "")) >= fuzzy:
create = sv
break
if create:
free.remove(create)
plan.append((t, None, "create", create))
else:
missing.append(t)
return plan, missing, dups, set(used)
def main():
ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
src = ap.add_mutually_exclusive_group(required=True)
src.add_argument("--tvh", metavar="URL", help="tvheadend address, e.g. http://192.168.1.10:9981")
src.add_argument("--tvh-config", metavar="DIR", help="tvheadend configuration directory (e.g. /var/lib/tvheadend)")
ap.add_argument("--tvh-user", help="tvheadend user (admin rights needed for the API)")
ap.add_argument("--tvh-pass", help="tvheadend password (or TVH_PASSWORD)")
ap.add_argument("--url", default="http://127.0.0.1:9980", help="simply-dvb panel address (default %(default)s)")
ap.add_argument("--user", default="admin", help="simply-dvb administrator (default %(default)s)")
ap.add_argument("--password", help="simply-dvb password (or SIMPLY_DVB_PASSWORD)")
ap.add_argument("--names", nargs="?", const="custom", choices=["custom", "all"],
help="copy channel names: 'custom' (default for --names) only names set by hand in "
"tvheadend (autoname off), 'all' every name – note tvheadend names may be stale "
"when a broadcaster renamed a channel")
ap.add_argument("--reset-names", action="store_true",
help="set every simply-dvb channel name back to its current broadcast (service) name")
ap.add_argument("--fuzzy", type=float, default=0.86,
help="similarity threshold 0–1 for similar names (default %(default)s, 1 = exact names only)")
ap.add_argument("--groups", action="store_true", help="set the group from the first tvheadend tag")
ap.add_argument("--enabled", action="store_true", help="copy the enabled/disabled state")
ap.add_argument("--create", action="store_true",
help="create channels for tvheadend channels whose service exists in simply-dvb but has no channel")
ap.add_argument("--unmatched", choices=["keep", "after", "disable"], default="after",
help="simply-dvb channels tvheadend does not have: keep numbers, number them after the "
"imported ones (default), or disable them (also numbered after)")
ap.add_argument("--apply", action="store_true", help="make the changes (default: dry run)")
a = ap.parse_args()
if a.tvh:
tpass = a.tvh_pass or os.environ.get("TVH_PASSWORD")
if a.tvh_user and tpass is None:
tpass = getpass.getpass(f"tvheadend password for {a.tvh_user}: ")
tvh = tvh_from_api(a.tvh, a.tvh_user, tpass or "")
else:
tvh = tvh_from_config(a.tvh_config)
if not tvh.channels:
die("no channels found in tvheadend")
pw = a.password or os.environ.get("SIMPLY_DVB_PASSWORD") or getpass.getpass(f"simply-dvb password for {a.user}: ")
sd = SimplyDvb(a.url, a.user, pw)
channels = sd.call("GET", "/api/channels")
services = sd.call("GET", "/api/services")
muxes = sd.call("GET", "/api/muxes")
plan, missing, dups, used = build_plan(tvh, channels, services, muxes, a.fuzzy)
print(f"tvheadend: {len(tvh.channels)} channels · simply-dvb: {len(channels)} channels, {len(services)} services\n")
print(f"{'tvh no.':>7} {'tvheadend name':<28} {'→':1} {'simply-dvb':<28} match")
print("-" * 82)
for item in plan:
t, c, how = item[0], item[1], item[2]
target = c["name"] if c else f"(new) {item[3]['name']}"
note = ""
if c and how.startswith("service") and similar(t["name"], c["name"]) < 0.6:
note = " (renamed by the broadcaster?)"
print(f"{t['number'] or '-':>7} {t['name'][:28]:<28} → {target[:28]:<28} {how}{note}")
if dups:
print("\nDuplicates in tvheadend (same service/name as a channel above – skipped):")
for t, c, first in dups:
print(f"{t['number'] or '-':>7} {t['name'][:28]:<28} = #{first['number']} {first['name']} → {c['name']}")
if missing:
print("\nNot found in simply-dvb (not received by the scan, or a different service):")
for t in missing:
print(f"{t['number'] or '-':>7} {t['name'][:28]:<28} ✗")
rest = [c for c in channels if c["id"] not in used]
if rest:
print(f"\nsimply-dvb channels without a tvheadend counterpart ({a.unmatched}): " +
", ".join(c["name"] for c in sorted(rest, key=lambda c: c["number"])))
if not a.apply:
print("\nDry run – nothing changed. Add --apply to make the changes.")
return
# imported channels keep tvheadend numbers; channels without a number go after the highest one
top = max([t["number"] for t, *_ in plan] + [0])
changed = created = 0
for item in plan:
t, c = item[0], item[1]
number = t["number"]
if not number:
top += 1
number = top
if c is None:
r = sd.call("POST", "/api/channels", {"service_ids": [item[3]["id"]]})
ids = (r or {}).get("ids") or []
if not ids:
print(f" could not create a channel for {t['name']}")
continue
c = {"id": ids[0], "service": item[3]}
created += 1
body = {"number": number}
if a.names and t["name"] and not t["name"].startswith("{") and (a.names == "all" or not t.get("autoname")):
body["name"] = t["name"]
elif a.reset_names and c.get("service", {}).get("name"):
body["name"] = c["service"]["name"]
if a.groups and t["tags"]:
body["grp"] = t["tags"][0]
if a.enabled:
body["enabled"] = t["enabled"]
sd.call("PUT", f"/api/channels/{c['id']}", body)
changed += 1
if a.unmatched != "keep":
for c in sorted(rest, key=lambda c: c["number"]):
top += 1
body = {"number": top}
if a.reset_names and (c.get("service") or {}).get("name"):
body["name"] = c["service"]["name"]
if a.unmatched == "disable":
body["enabled"] = False
sd.call("PUT", f"/api/channels/{c['id']}", body)
print(f"\nDone: {changed} channels updated ({created} created), {len(dups)} duplicates skipped, {len(missing)} not found"
+ (f", {len(rest)} others {'disabled and ' if a.unmatched == 'disable' else ''}numbered from {top - len(rest) + 1}"
if rest and a.unmatched != "keep" else "") + ".")
if __name__ == "__main__":
main()