def apply(self, value: StreamMeta) -> StreamMeta:
"""Apply display epg filter
Arguments:
value {str} -- stream name
Returns:
Stream meta data
"""
epg: Epg = get_epg_index(self.filter_config.index_url)
if not epg:
raise AssertionError
ratio: float = 0.0
channel_epg: Optional[Channel] = None
epg_sources = list(
filter(
lambda e: value.tvg.group_title in e["names"],
self.filter_config.matching_groups,
))
if epg_sources:
epg_urls: List[str] = reduce(lambda x, y: x + y,
[e["sources"] for e in epg_sources])
for c in filter(lambda e: e.url in epg_urls, epg.tv.channel):
r = SequenceMatcher(
None,
translate_channel_name(f"{value.display_name}"),
translate_channel_name(f"{c.display_name.name}"),
).ratio()
if r > ratio:
ratio = r
channel_epg = c
if channel_epg and ratio > self.filter_config.matching_ratio:
value.tvg.tvg_id = channel_epg.id
value.tvg.tvg_name = channel_epg.id
value.tvg.tvg_logo = (channel_epg.icon.src
if channel_epg.icon and value.tvg.tvg_logo
else value.tvg.tvg_logo)
# Filter report
value.tvg[f"__{__name__}__dn_b"] = value.display_name
value.tvg[f"__{__name__}__dn_a"] = channel_epg.id
value.tvg[f"__{__name__}__matched"] = "True"
value.tvg[f"__{__name__}__matched_source"] = channel_epg.url
return value
def test_clean_name_filter_ok(self):
pl_filter = DisplayNameFilter(self.playlist_config)
test_suite = [
(StreamMeta("fr: name1"), "fr", "name1"),
(StreamMeta("|usa| name2"), "usa", "name2"),
(StreamMeta("ar| test 12"), "ar", "test 12"),
(StreamMeta("test 123 HD"), "", "test 123 HD"),
]
for val in test_suite:
with self.subTest(val=val):
res = pl_filter.apply(val[0])
self.assertTrue(res.display_name == val[2])
self.assertTrue(res[StreamMeta.CULTURE_KEY] == val[1])
def test_shift_filter_ok(self):
pl_filter = ShiftFilter(self.playlist_config)
test_suite = [
(StreamMeta("fr: name1 +1"), "1", "fr: name1"),
(StreamMeta("|usa| name2"), "", "|usa| name2"),
(StreamMeta("ar| test 12 +4 1080"), "4", "ar| test 12"),
(StreamMeta("test 123 HD +8"), "8", "test 123 HD"),
]
for val in test_suite:
with self.subTest(val=val):
res = pl_filter.apply(val[0])
self.assertTrue(res.display_name == val[2])
self.assertTrue(res.tvg.tvg_shift == val[1])
def apply(self, value: StreamMeta) -> StreamMeta:
"""Apply Remove headers filter
Arguments:
value {str} -- stream name
Returns:
Tuple[Optional[str], str] -- culture, clean stream name
"""
value.hidden = "False"
for r in self.filter_config.regex:
match = re.search(r, value.display_name, re.IGNORECASE)
if match:
value.hidden = "True"
break
return value
def test_quality_filter_ok(self):
pl_filter = QualityFilter(self.playlist_config)
test_suite = [
(StreamMeta("name1 1080p"), "fhd", "name1"),
(StreamMeta("fr: name1 4k"), "4k", "fr: name1"),
(StreamMeta("ar| test 12 hd1"), "hd", "ar| test 12 1"),
(StreamMeta("test 123"), "sd", "test 123"),
]
for val in test_suite:
with self.subTest(val=val):
res = pl_filter.apply(val[0])
self.assertTrue(val[0].display_name == val[2],
f"{res.display_name} isn't {val[2]}")
self.assertTrue(
val[0][StreamMeta.QUALITY_KEY] == val[1],
f"{res[StreamMeta.QUALITY_KEY]} isn't {val[1]}",
)
def apply(self, value: StreamMeta) -> StreamMeta:
"""Apply quality filter
Arguments:
value {str} -- Stream name
Returns:
Tuple[str, str] -- quality, clean stream name
"""
for k, v in self.filter_config.regex.__dict__.items():
match = re.search(v, value.display_name, re.IGNORECASE | re.DOTALL)
if match and len(match.groups()) > 1:
value.quality = k
ch_name, q, others = match.groups()
value.display_name = f"{ch_name.strip()} {others.strip()}".strip(
)
return value
value.quality = self.filter_config.default
return value
def apply(self, value: StreamMeta) -> StreamMeta:
"""Apply grouping streams filter
Arguments:
value {str} -- stream name
Returns:
Tuple[Optional[str], str] -- culture, clean stream name
"""
matched = any([
re.search(regex, value.tvg.group_title, re.IGNORECASE) is not None
for regex in self.filter_config.groups
])
if self.filter_config.strategy == "pessimist":
if not matched:
value.hidden = "True"
LOG.info(f"Hide {value.tvg.group_title}")
else:
if matched:
value.hidden = "True"
LOG.info(f"Hide {value.tvg.group_title}")
return value
def apply(self, value: StreamMeta) -> StreamMeta:
"""Apply Shift filter
Arguments:
value {str} -- Stream name
Returns:
Tuple[str, str] -- quality, clean stream name
"""
self.__logger.debug( # type: ignore
f"applying filter <{self.__class__.__name__}> on {str(value)} "
)
match = re.search(
self.filter_config.regex, value.display_name, re.IGNORECASE | re.DOTALL
)
if match and len(match.groups()) > 1:
value.tvg.tvg_shift = match.group(2).strip()
value.display_name = match.group(1).strip()
return value
return value
def apply(self, value: StreamMeta) -> StreamMeta:
for reg in self.filter_config.regex:
regex = re.compile(reg, re.IGNORECASE | re.DOTALL)
value.display_name = regex.sub("", value.display_name)
return value
def apply(self, value: StreamMeta) -> StreamMeta:
"""Apply display name filter
Arguments:
value {str} -- stream name
Returns:
Tuple[Optional[str], str] -- culture, clean stream name
"""
value.tvg[f"__{__name__}__dn_b"] = value.display_name
value.tvg[f"__{__name__}__cu_b"] = value.culture
for match in map(
lambda x: re.search(x, value.display_name, re.IGNORECASE),
self.filter_config.regex_clean_names,
):
if match and len(match.groups()) > 2:
value.culture = match.group(2)
value.display_name = match.group(3).strip()
value.tvg[f"__{__name__}__matched"] = "True"
value.tvg[f"__{__name__}__dn_a"] = value.display_name
value.tvg[f"__{__name__}__cu_a"] = value.culture
return value
value.culture = ""
value.display_name = value.display_name.translate(
{ord(c): " "
for c in "@#$%^&*{};,./?\\`~-=_"})
value.tvg[f"__{__name__}__dn_a"] = value.display_name
value.tvg[f"__{__name__}__cu_a"] = value.culture
return value