DEV Community: Yanic K

Parsing EPG/XMLTV TV Schedules in Python: Build a Smart Programme Guide (September 2026)

Yanic K — Tue, 22 Sep 2026 18:10:18 +0000

A dependency-free Python toolkit for parsing XMLTV/EPG television schedules — filter by channel and time window, regex-search titles, detect overlapping broadcasts, and export normalized JSON.

Disclosure: This technical/educational article may include reference or affiliate links. We only link to verified services and official platforms tested for performance and security.

Every streaming setup eventually hits the same wall: the guide. Players can open streams, but knowing what is on right now, and what airs next, requires EPG (Electronic Programme Guide) data — and almost all of it moves around in one format: XMLTV.

In this tutorial, we build a smart programme-guide layer in pure Python: parse an XMLTV document into typed dataclasses, filter programmes by channel and time window, search titles with regular expressions, detect overlapping broadcasts, and export a normalized JSON schedule — using the new tvnow-epg package, which runs on the standard library alone (Python 3.9+, zero dependencies).

📺 What EPG/XMLTV Data Actually Is

An Electronic Programme Guide is a structured listing of which programmes air on which channels at which times. XMLTV is the de-facto XML interchange format for these listings. A minimal document looks like this:

<tv>
  <channel id="example.news">
    <display-name>Example News HD</display-name>
  </channel>
  <programme start="20240610060000 +0000" stop="20240610090000 +0000"
             channel="example.news">
    <title>Morning News Desk</title>
    <category>News</category>
  </programme>
</tv>

Two things make real-world EPG files messy rather than fun:

Timestamps arrive as YYYYMMDDHHMMSS +ZZZZ strings with (sometimes) explicit UTC offsets.
Malformed entries — channels without ids, programmes missing start times — are routine in guides scraped from broadcasters.

A production parser must skip broken entries instead of crashing, and treat naive timestamps deterministically. That is exactly the contract tvnow-epg implements.

💻 Installation & Quick Start

pip install tvnow-epg

from tvnow_epg import parse_xmltv_file, filter_by_channel, to_json

schedule = parse_xmltv_file("guide.xml")

for channel in schedule.channels:
    print(channel.channel_id, "-", channel.display_name)

programmes = filter_by_channel(schedule.programmes, "example.news")
for p in programmes:
    print(p.start, "-", p.title)

print(to_json(schedule, channel_id="example.news"))

parse_xmltv_file() returns a Schedule holding .channels (list of Channel) and .programmes (list of Programme, conveniently sorted by channel then start time).

🔍 Searching and Filtering Programmes

The two filters you will use most:

from tvnow_epg import filter_by_channel, search_titles

# All programmes on one channel
news = filter_by_channel(schedule.programmes, "example.news")

# Case-insensitive substring search over titles
matches = search_titles(schedule.programmes, "ocean")

# Regular-expression search
import re
matches = search_titles(schedule.programmes, r"^The\b", regex=True)

The regex mode is more useful than it looks: r"^The\b" pulls every title starting with "The", and patterns like r"(?i)(premiere|finale)" surface season events a plain substring search would scatter across casing variants.

⏰ Time-Window Filtering That Behaves

EPG tooling usually wants "what's airing in this window" — for example, prime time:

from datetime import datetime, timezone
from tvnow_epg import filter_by_time

start = datetime(2026, 9, 22, 19, 0, tzinfo=timezone.utc)
stop  = datetime(2026, 9, 22, 23, 0, tzinfo=timezone.utc)

window = filter_by_time(schedule.programmes, start=start, stop=stop)

A programme is included when its air time intersects the [start, stop) window — so a film that started at 18:30 still appears in your 19:00–23:00 prime-time view. Naive datetime objects are assumed to be UTC; use timezone-aware datetimes when your source feed uses a local offset.

⚠️ Detecting Overlapping Broadcasts

Overlapping programmes on the same channel are the classic symptom of malformed or stale guide data. One function surfaces them:

from tvnow_epg import find_overlaps

for earlier, later in find_overlaps(schedule.programmes):
    print(f"{earlier.title} overlaps {later.title} on {earlier.channel_id}")

This is a first-class validation primitive: schedule a nightly find_overlaps() run over your guide and you have an early-warning system for provider data rot.

🧹 Normalizing Messy Metadata

Broadcasters are inconsistent with categories — "kids", "Film", "Children", "Movie". Normalizers fold the common variants together:

from tvnow_epg import normalize_title, normalize_category

normalize_title("  The   News  ")   # "the news"
normalize_category("kids")          # "Children"
normalize_category("Film")          # "Movie"

Normalized titles/categories are what make downstream grouping, deduplication, and "movies tonight" filters reliable.

📤 JSON Export

from tvnow_epg import to_json

text = to_json(schedule)                             # whole schedule
text = to_json(schedule, channel_id="example.news")  # one channel
text = to_json(schedule, indent=None)                # compact output

Timestamps export as ISO-8601 strings with their UTC offset — ready for a web dashboard, a mobile app, or a scheduled cron job.

🧪 Testing and Data Hygiene

The test suite runs entirely offline, and the bundled data/sample_epg.xml contains synthetic example data only — no real broadcaster's schedule. The parser is lenient by design: entries missing an id, a valid start time, or a title are skipped, not fatal, and a document that isn't valid XML (or isn't rooted in <tv>) raises tvnow_epg.ParseError, a ValueError subclass.

⚠️ Limitations to Keep in Mind

Supports the common core of XMLTV (channels, programmes, titles, descriptions, categories, episode numbers, ratings); exotic extensions are ignored.
Timestamps without an explicit offset are assumed to be UTC.
The whole document is held in memory; very large multi-week guides (hundreds of MB) are not the design target.
No network functionality of any kind — you supply the EPG data, the library processes it.

🌐 Resources

tvnow-epg on PyPI — install with pip install tvnow-epg
XMLTV project & format specification
tvnow.live — online TV schedule and EPG resource hub
IPTV2Live — IPTV playlist and player reference
VideoLAN VLC — playing M3U playlists and network streams

What does your EPG validation pipeline look like? Drop a comment — especially if you've had to deal with week-long guides in odd timezones.

Building an Interactive Biology Simulation & Genetics Parser in Python (September 2026)

Yanic K — Thu, 17 Sep 2026 23:30:59 +0000

Visualizing biological mechanisms—such as protein synthesis, DNA transcription, and codon translation—is a classic challenge in secondary science education. Rather than relying solely on static 2D textbook diagrams, developers and science educators can leverage simple Python algorithms to model molecular genetics and build interactive student quizzes.

In this tutorial, we will build a modular Python simulation that transcribes DNA sequences to mRNA, translates nucleotide triplets into amino acid polypeptide chains, and generates self-grading biological evaluation questions.

🧬 Biological Logic & Codon Mapping Architecture

Protein biosynthesis follows the central dogma of molecular biology:

Transcription: DNA sequence ($5' \to 3'$) template is converted to messenger RNA (mRNA), substituting Thymine ($T$) with Uracil ($U$).
Translation: The ribosome reads mRNA in triplets (codons) starting from the initiation codon (AUG / Methionine) until encountering a stop codon (UAA, UAG, UGA).
Interactive Evaluation: Automatic question generation to test student comprehension of genetic mutation consequences.

💻 Python Implementation: Molecular Genetics Engine

from typing import List, Dict, Tuple

GENETIC_CODE: Dict[str, str] = {
    'AUG': 'Methionine (START)', 'UUU': 'Phenylalanine', 'UUC': 'Phenylalanine',
    'UUA': 'Leucine', 'UUG': 'Leucine', 'UCU': 'Serine', 'UCC': 'Serine',
    'UCA': 'Serine', 'UCG': 'Serine', 'UAU': 'Tyrosine', 'UAC': 'Tyrosine',
    'UGU': 'Cysteine', 'UGC': 'Cysteine', 'UGG': 'Tryptophan',
    'CCU': 'Proline', 'CCC': 'Proline', 'CCA': 'Proline', 'CCG': 'Proline',
    'CAU': 'Histidine', 'CAC': 'Histidine', 'CAA': 'Glutamine', 'CAG': 'Glutamine',
    'AAU': 'Asparagine', 'AAC': 'Asparagine', 'AAA': 'Lysine', 'AAG': 'Lysine',
    'GAU': 'Aspartate', 'GAC': 'Aspartate', 'GAA': 'Glutamate', 'GAG': 'Glutamate',
    'GUU': 'Valine', 'GUC': 'Valine', 'GUA': 'Valine', 'GUG': 'Valine',
    'GCU': 'Alanine', 'GCC': 'Alanine', 'GCA': 'Alanine', 'GCG': 'Alanine',
    'UAA': 'STOP', 'UAG': 'STOP', 'UGA': 'STOP'
}

def transcribe_dna_to_mrna(dna_sequence: str) -> str:
    """Converts a coding DNA strand to single-stranded mRNA."""
    dna = dna_sequence.upper().strip().replace(" ", "")
    return dna.replace('T', 'U')

def translate_mrna_to_protein(mrna_sequence: str) -> List[str]:
    """Translates mRNA sequence codons into amino acids until reaching a stop codon."""
    protein = []
    # Read in triplets
    for i in range(0, len(mrna_sequence) - 2, 3):
        codon = mrna_sequence[i:i+3]
        amino_acid = GENETIC_CODE.get(codon, "Unknown")
        if amino_acid == 'STOP':
            protein.append("[STOP CODON]")
            break
        protein.append(amino_acid)
    return protein

# Interactive Execution Demo
if __name__ == "__main__":
    sample_dna = "ATGGCCAAATTTGGCTAA"
    mrna = transcribe_dna_to_mrna(sample_dna)
    polypeptide = translate_mrna_to_protein(mrna)
    print(f"DNA Sequence:  {sample_dna}")
    print(f"mRNA Strand:   {mrna}")
    print(f"Protein Chain: {' -> '.join(polypeptide)}")

📚 Educational Integration & Curricular Resources

Simulations like this bridge computational thinking with core secondary science curricula (including high school biology, Algerian Baccalaureate natural science units, and university molecular genetics).

For comprehensive lesson summaries, interactive Baccalaureate science quizzes (ملخصات واختبارات تفاعلية في علوم الطبيعة والحياة وفق المنهاج الجزائري), and detailed exam methodology guides, visit the specialized educational portal at 3oloumdz — علوم ديزاد للتعليم الثانوي.

Xtream Codes API Protocol: Architecture, Endpoints, and Python Client Implementation (September 2026)

Yanic K — Thu, 17 Sep 2026 23:23:19 +0000

The Xtream Codes API standard remains the universal middleware protocol for IPTV players, OTT set-top boxes, and media streaming middleware. Understanding its endpoint lifecycle allows developers to build robust client players, proxy caches, and stream validation services.

🔑 Authentication Handshake (/player_api.php)

All authentication flows originate via a simple GET/POST query to /player_api.php. A valid request carries username and password parameters.

The server returns a structured JSON payload containing two primary dictionaries:

user_info: status, max active connections, expiry timestamp, active trial flags.
server_info: base URL, port, protocol, RTMP port, timezone, server timestamp.

💻 Python Implementation: Async Xtream Client SDK

Below is an asynchronous client SDK built on top of aiohttp:

import aiohttp
import asyncio
from typing import Dict, Any, Optional

class XtreamCodesClient:
    def __init__(self, host: str, port: int, username: str, password: str, use_https: bool = False):
        protocol = "https" if use_https else "http"
        self.base_url = f"{protocol}://{host}:{port}/player_api.php"
        self.auth_params = {"username": username, "password": password}
        self.session: Optional[aiohttp.ClientSession] = None

    async def __aenter__(self):
        self.session = aiohttp.ClientSession(headers={"User-Agent": "XtreamTech-SDK/1.0"})
        return self

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        if self.session:
            await self.session.close()

    async def authenticate(self) -> Dict[str, Any]:
        async with self.session.get(self.base_url, params=self.auth_params) as resp:
            data = await resp.json(content_type=None)
            if data.get("user_info", {}).get("auth") == 1:
                return data
            raise PermissionError("Xtream authentication failed or expired account.")

    async def get_live_categories(self):
        params = {**self.auth_params, "action": "get_live_categories"}
        async with self.session.get(self.base_url, params=params) as resp:
            return await resp.json(content_type=None)

    async def get_live_streams(self, category_id: Optional[str] = None):
        params = {**self.auth_params, "action": "get_live_streams"}
        if category_id:
            params["category_id"] = category_id
        async with self.session.get(self.base_url, params=params) as resp:
            return await resp.json(content_type=None)

⚡ Optimization & Stream Caching Strategies

To reduce backend load during peak streaming hours, implement in-memory caching (e.g. Redis) for category trees and EPG XML dumps. Set an automated TTL of 3,600 seconds on category metadata while refreshing stream health statuses asynchronously.

🌐 Technical Reference & Middleware Documentation

For in-depth middleware architectures, Xtream API code generators, and streaming technology benchmarks, visit the developer hub at XtreamTech Engineering Portal.

Building an Automated IPTV Stream & M3U Health Checker in Python (September 2026)

Yanic K — Thu, 17 Sep 2026 23:19:02 +0000

Managing extensive IPTV playlists and multimedia streaming endpoints often leads to broken channels, timeout lag, and stream buffer freezes. Relying on manual channel testing inside players like TiviMate or OTT Navigator is inefficient when handling thousands of entries.

In this technical tutorial, we will construct an asynchronous Python utility that parses M3U8 playlists, audits HLS/MPEG-TS stream availability, measures TTFB (Time to First Byte), and logs live stream health metrics.

🛠️ Architecture of an M3U8 Stream Validator

An M3U playlist file is fundamentally structured with #EXTM3U headers and #EXTINF track directives containing channel metadata and stream URLs:

Playlist Ingestion: Regex parsing of channel attributes (tvg-id, group-title, channel title) and stream source URLs.
Async Socket & HTTP Probing: Concurrent aiohttp GET/HEAD stream chunk requests with custom timeouts.
Health Diagnostics: Filtering valid 200 OK responses versus geo-restricted, expired, or overloaded portal endpoints.

💻 Python Implementation: Async Stream Auditor

Below is the complete, modular Python script using asyncio and aiohttp:

import asyncio
import aiohttp
import re
import time

STREAM_REGEX = re.compile(r'#EXTINF:-1.*?,(.*?)\n(http[s]?://[^ \t\r\n]+)')

async def check_stream(session, channel_name, url, timeout_sec=5):
    start_time = time.time()
    try:
        async with session.get(url, timeout=aiohttp.ClientTimeout(total=timeout_sec), headers={"User-Agent": "VLC/3.0.18 LibVLC/3.0.18"}) as resp:
            latency = round((time.time() - start_time) * 1000, 2)
            if resp.status == 200:
                return {"channel": channel_name.strip(), "status": "ONLINE", "latency_ms": latency, "url": url}
            else:
                return {"channel": channel_name.strip(), "status": f"HTTP_{resp.status}", "latency_ms": latency, "url": url}
    except asyncio.TimeoutError:
        return {"channel": channel_name.strip(), "status": "TIMEOUT", "latency_ms": None, "url": url}
    except Exception as e:
        return {"channel": channel_name.strip(), "status": f"ERROR_{type(e).__name__}", "latency_ms": None, "url": url}

async def audit_playlist(m3u_content, max_concurrency=20):
    matches = STREAM_REGEX.findall(m3u_content)
    print(f"Parsed {len(matches)} stream channels.")

    connector = aiohttp.TCPConnector(limit=max_concurrency, ssl=False)
    async with aiohttp.ClientSession(connector=connector) as session:
        tasks = [check_stream(session, name, url) for name, url in matches]
        results = await asyncio.gather(*tasks)
        return results

# Example Execution
if __name__ == "__main__":
    sample_m3u = """#EXTM3U
#EXTINF:-1 tvg-id="test1" group-title="News",Demo News 1080p
http://sample.vod.stream/live/ch1.m3u8
"""
    loop = asyncio.run(audit_playlist(sample_m3u))
    print(loop)

🔒 Handling ISP Throttling & Geo-Restrictions

When auditing global streaming endpoints, requests frequently fail due to ISP packet throttling or CDN geo-fencing. To maintain clean connectivity and prevent packet inspection bottlenecks during continuous testing, implementing an encrypted high-speed tunnel is strongly recommended.

💡 Recommended Streaming Privacy & Latency Solutions

For zero-buffer streaming and unthrottled endpoint diagnostics, tested high-speed solutions include:

Surfshark VPN: Unlimited device connections, WireGuard protocol, and automated bypass for strict ISP throttling.

PureVPN: Dedicated streaming servers with 10Gbps port speeds and specialized bypass configs.

🌐 Integration with Verified Portals & Playlists

For verified daily playlist formats, Stalker portal credentials, and updated configuration guides for Smart TVs and media boxes, explore the comprehensive reference hub at IPTV2Live Portal & Resource Hub.