iptv-stream-validator 0.1.0__tar.gz

iptv_stream_validator-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 iptv2live
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

iptv_stream_validator-0.1.0/PKG-INFO

@@ -0,0 +1,206 @@
+Metadata-Version: 2.4
+Name: iptv-stream-validator
+Version: 0.1.0
+Summary: Check whether IPTV/M3U stream endpoints respond, and parse M3U playlists.
+Author: iptv2live
+License-Expression: MIT
+Project-URL: Homepage, https://iptv2live.com
+Project-URL: Documentation, https://iptv2live.com
+Keywords: iptv,m3u,m3u8,playlist,stream,validator
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# iptv-stream-validator
+
+A small Python package for validating IPTV stream endpoints and parsing M3U / M3U8 playlists. It uses only the Python standard library, has no runtime dependencies, and supports Python 3.9+.
+
+## What the package does
+
+- **Parses M3U / M3U8 playlists** — extended playlists with `#EXTINF` metadata (title, duration, `tvg-id`, `group-title`, and other `key="value"` attributes) as well as plain URL-only lists.
+- **Checks stream endpoints over HTTP(S)** — one lightweight request per URL that stops after the response status line and headers, without downloading the media body.
+- **Records HTTP status and response time** for every check.
+- **Applies configurable timeouts** so dead endpoints cannot stall a validation run.
+- **Reports failures as data** — every check returns a `ValidationResult`, so DNS errors, refused connections, timeouts, and HTTP errors are results, not exceptions.
+- **Produces JSON-ready output** — results and playlist entries serialize to plain dictionaries, and `summarize_results()` aggregates a whole run into counts, failed URLs, and median/average response times.
+
+## Installation
+
+The distribution name is `iptv-stream-validator`. Once published on PyPI:
+
+```bash
+pip install iptv-stream-validator
+```
+
+To install from a checkout of this repository (the package is pure Python, standard library only):
+
+```bash
+pip install .
+```
+
+There are no runtime dependencies.
+
+## Basic Python usage
+
+```python
+from iptv_stream_validator import StreamValidator, summarize_results
+
+validator = StreamValidator(timeout=5)
+
+results = validator.validate_many(
+    [
+        "https://example.com/streams/news.m3u8",
+        "http://example.com:8080/live/sports.ts",
+    ]
+)
+
+for result in results:
+    print(result.to_json())
+
+print(summarize_results(results))
+```
+
+`StreamValidator` sends a `GET` request by default (many streaming servers reject `HEAD`) but never reads the response body — the connection is closed as soon as the status line and headers arrive. Pass `method="HEAD"` if you prefer HEAD requests.
+
+## M3U playlist validation example
+
+Parse a playlist and check the syntactic validity of its URLs before doing any network I/O:
+
+```python
+from iptv_stream_validator import parse_m3u, is_valid_stream_url
+
+playlist_text = """#EXTM3U
+#EXTINF:-1 tvg-id="cnn.us" group-title="News",CNN
+https://example.com/streams/cnn.m3u8
+#EXTINF:-1 tvg-id="bbc.uk",BBC One
+https://example.com/streams/bbc.m3u8
+"""
+
+entries = parse_m3u(playlist_text)
+
+for entry in entries:
+    print(entry.title, entry.attributes, entry.url)
+    print("  URL looks valid:", is_valid_stream_url(entry.url))
+```
+
+Output:
+
+```
+CNN {'tvg-id': 'cnn.us', 'group-title': 'News'} https://example.com/streams/cnn.m3u8
+  URL looks valid: True
+BBC One {'tvg-id': 'bbc.uk'} https://example.com/streams/bbc.m3u8
+  URL looks valid: True
+```
+
+Playlists can also be read straight from a file with `parse_m3u_file(path)`, and `extract_urls(text)` returns just the URL list. A playlist whose text contains no URL lines raises `PlaylistError`.
+
+## Stream endpoint validation example
+
+Combining the two modules — parse a playlist, then validate every endpoint it contains:
+
+```python
+from iptv_stream_validator import StreamValidator, parse_m3u, summarize_results
+
+with open("playlist.m3u", "r", encoding="utf-8") as handle:
+    entries = parse_m3u(handle.read())
+
+validator = StreamValidator(timeout=5)
+results = validator.validate_many(entry.url for entry in entries)
+
+for entry, result in zip(entries, results):
+    state = "OK" if result.ok else "FAIL"
+    print(f"{state}  {entry.title or entry.url}  {result.error or result.status}")
+
+summary = summarize_results(results)
+print(f"{summary['ok']}/{summary['total']} endpoints responded")
+print(f"median response time: {summary['median_response_time']}s")
+```
+
+## Timeout and error handling
+
+- The timeout (default 10 seconds, configurable via `StreamValidator(timeout=...)`) covers DNS resolution, connection setup, and waiting for the response status line.
+- `validate()` catches network-level problems (`URLError`, DNS failures, refused connections, socket timeouts) and HTTP error statuses, and returns them inside the `ValidationResult` — it does not raise for a broken endpoint.
+- HTTP `4xx`/`5xx` responses are reported as failures with their status code, since the endpoint answered but the URL is not usable as a stream.
+- Redirects are followed by default; if the final URL differs from the requested one it is recorded in `result.final_url`.
+- Invalid constructor arguments (unknown method, non-numeric timeout, empty user agent) raise `ValueError`/`TypeError` immediately.
+
+```python
+result = validator.validate("https://example.com/streams/down.m3u8")
+if not result.ok:
+    print(result.error)  # e.g. "timed out after 5s" or "HTTP 404 Not Found"
+```
+
+## Example output
+
+A single result (`result.to_json()`):
+
+```json
+{
+  "url": "https://example.com/streams/news.m3u8",
+  "ok": true,
+  "status": 200,
+  "response_time": 0.184371,
+  "error": null,
+  "final_url": null
+}
+```
+
+A failed check:
+
+```json
+{
+  "url": "https://example.com/streams/down.m3u8",
+  "ok": false,
+  "status": null,
+  "response_time": 5.001293,
+  "error": "timed out after 5s",
+  "final_url": null
+}
+```
+
+A run summary (`summarize_results(results)`):
+
+```python
+{
+    "total": 3,
+    "ok": 2,
+    "failed": 1,
+    "failed_urls": ["https://example.com/streams/down.m3u8"],
+    "median_response_time": 0.211054,
+    "average_response_time": 0.197713,
+}
+```
+
+## Limitations
+
+- Checks are sequential; validating thousands of URLs takes correspondingly long. Run multiple processes or threads yourself if you need concurrency.
+- A successful HTTP response does not prove the payload is playable media — the content is not inspected or decoded. Some servers accept any request path with a 200 response; treat results as a first-pass filter, not a guarantee.
+- Endpoints that require specific headers (cookies, referers, unusual user agents) can be configured via `user_agent`, but anything more elaborate needs custom code on top of this package.
+- `is_valid_stream_url()` is a syntactic check only (HTTP/HTTPS scheme, non-empty host); it performs no network requests.
+- The parser covers the common `#EXTINF`-based IPTV playlist layout. Other directives (`#EXTVLCOPT`, `#EXTGRP`, `#KODIPROP`, ...) are ignored rather than interpreted.
+- No M3U variant-specific handling beyond `#EXTINF` metadata: no XMLTV merging, no EPG lookup, no deduplication of streams.
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+## Additional IPTV playlist / player resources
+
+- [IPTV2Live](https://iptv2live.com) — IPTV playlist and player reference site; this project's homepage and documentation are hosted there.
+- [HLS (HTTP Live Streaming), RFC 8216](https://datatracker.ietf.org/doc/html/rfc8216) — the specification behind `.m3u8` media playlists.
+- [VideoLAN VLC](https://www.videolan.org/vlc/) — a widely used player for M3U playlists and network streams.
+- [FFmpeg](https://ffmpeg.org/) — the standard toolkit for inspecting and re-streaming media (e.g. `ffprobe` for checking whether a URL yields playable media).
+- [iptv-org/iptv](https://github.com/iptv-org/iptv) — a large, publicly maintained collection of M3U playlists, useful as realistic test input.

iptv_stream_validator-0.1.0/README.md

@@ -0,0 +1,180 @@
+# iptv-stream-validator
+
+A small Python package for validating IPTV stream endpoints and parsing M3U / M3U8 playlists. It uses only the Python standard library, has no runtime dependencies, and supports Python 3.9+.
+
+## What the package does
+
+- **Parses M3U / M3U8 playlists** — extended playlists with `#EXTINF` metadata (title, duration, `tvg-id`, `group-title`, and other `key="value"` attributes) as well as plain URL-only lists.
+- **Checks stream endpoints over HTTP(S)** — one lightweight request per URL that stops after the response status line and headers, without downloading the media body.
+- **Records HTTP status and response time** for every check.
+- **Applies configurable timeouts** so dead endpoints cannot stall a validation run.
+- **Reports failures as data** — every check returns a `ValidationResult`, so DNS errors, refused connections, timeouts, and HTTP errors are results, not exceptions.
+- **Produces JSON-ready output** — results and playlist entries serialize to plain dictionaries, and `summarize_results()` aggregates a whole run into counts, failed URLs, and median/average response times.
+
+## Installation
+
+The distribution name is `iptv-stream-validator`. Once published on PyPI:
+
+```bash
+pip install iptv-stream-validator
+```
+
+To install from a checkout of this repository (the package is pure Python, standard library only):
+
+```bash
+pip install .
+```
+
+There are no runtime dependencies.
+
+## Basic Python usage
+
+```python
+from iptv_stream_validator import StreamValidator, summarize_results
+
+validator = StreamValidator(timeout=5)
+
+results = validator.validate_many(
+    [
+        "https://example.com/streams/news.m3u8",
+        "http://example.com:8080/live/sports.ts",
+    ]
+)
+
+for result in results:
+    print(result.to_json())
+
+print(summarize_results(results))
+```
+
+`StreamValidator` sends a `GET` request by default (many streaming servers reject `HEAD`) but never reads the response body — the connection is closed as soon as the status line and headers arrive. Pass `method="HEAD"` if you prefer HEAD requests.
+
+## M3U playlist validation example
+
+Parse a playlist and check the syntactic validity of its URLs before doing any network I/O:
+
+```python
+from iptv_stream_validator import parse_m3u, is_valid_stream_url
+
+playlist_text = """#EXTM3U
+#EXTINF:-1 tvg-id="cnn.us" group-title="News",CNN
+https://example.com/streams/cnn.m3u8
+#EXTINF:-1 tvg-id="bbc.uk",BBC One
+https://example.com/streams/bbc.m3u8
+"""
+
+entries = parse_m3u(playlist_text)
+
+for entry in entries:
+    print(entry.title, entry.attributes, entry.url)
+    print("  URL looks valid:", is_valid_stream_url(entry.url))
+```
+
+Output:
+
+```
+CNN {'tvg-id': 'cnn.us', 'group-title': 'News'} https://example.com/streams/cnn.m3u8
+  URL looks valid: True
+BBC One {'tvg-id': 'bbc.uk'} https://example.com/streams/bbc.m3u8
+  URL looks valid: True
+```
+
+Playlists can also be read straight from a file with `parse_m3u_file(path)`, and `extract_urls(text)` returns just the URL list. A playlist whose text contains no URL lines raises `PlaylistError`.
+
+## Stream endpoint validation example
+
+Combining the two modules — parse a playlist, then validate every endpoint it contains:
+
+```python
+from iptv_stream_validator import StreamValidator, parse_m3u, summarize_results
+
+with open("playlist.m3u", "r", encoding="utf-8") as handle:
+    entries = parse_m3u(handle.read())
+
+validator = StreamValidator(timeout=5)
+results = validator.validate_many(entry.url for entry in entries)
+
+for entry, result in zip(entries, results):
+    state = "OK" if result.ok else "FAIL"
+    print(f"{state}  {entry.title or entry.url}  {result.error or result.status}")
+
+summary = summarize_results(results)
+print(f"{summary['ok']}/{summary['total']} endpoints responded")
+print(f"median response time: {summary['median_response_time']}s")
+```
+
+## Timeout and error handling
+
+- The timeout (default 10 seconds, configurable via `StreamValidator(timeout=...)`) covers DNS resolution, connection setup, and waiting for the response status line.
+- `validate()` catches network-level problems (`URLError`, DNS failures, refused connections, socket timeouts) and HTTP error statuses, and returns them inside the `ValidationResult` — it does not raise for a broken endpoint.
+- HTTP `4xx`/`5xx` responses are reported as failures with their status code, since the endpoint answered but the URL is not usable as a stream.
+- Redirects are followed by default; if the final URL differs from the requested one it is recorded in `result.final_url`.
+- Invalid constructor arguments (unknown method, non-numeric timeout, empty user agent) raise `ValueError`/`TypeError` immediately.
+
+```python
+result = validator.validate("https://example.com/streams/down.m3u8")
+if not result.ok:
+    print(result.error)  # e.g. "timed out after 5s" or "HTTP 404 Not Found"
+```
+
+## Example output
+
+A single result (`result.to_json()`):
+
+```json
+{
+  "url": "https://example.com/streams/news.m3u8",
+  "ok": true,
+  "status": 200,
+  "response_time": 0.184371,
+  "error": null,
+  "final_url": null
+}
+```
+
+A failed check:
+
+```json
+{
+  "url": "https://example.com/streams/down.m3u8",
+  "ok": false,
+  "status": null,
+  "response_time": 5.001293,
+  "error": "timed out after 5s",
+  "final_url": null
+}
+```
+
+A run summary (`summarize_results(results)`):
+
+```python
+{
+    "total": 3,
+    "ok": 2,
+    "failed": 1,
+    "failed_urls": ["https://example.com/streams/down.m3u8"],
+    "median_response_time": 0.211054,
+    "average_response_time": 0.197713,
+}
+```
+
+## Limitations
+
+- Checks are sequential; validating thousands of URLs takes correspondingly long. Run multiple processes or threads yourself if you need concurrency.
+- A successful HTTP response does not prove the payload is playable media — the content is not inspected or decoded. Some servers accept any request path with a 200 response; treat results as a first-pass filter, not a guarantee.
+- Endpoints that require specific headers (cookies, referers, unusual user agents) can be configured via `user_agent`, but anything more elaborate needs custom code on top of this package.
+- `is_valid_stream_url()` is a syntactic check only (HTTP/HTTPS scheme, non-empty host); it performs no network requests.
+- The parser covers the common `#EXTINF`-based IPTV playlist layout. Other directives (`#EXTVLCOPT`, `#EXTGRP`, `#KODIPROP`, ...) are ignored rather than interpreted.
+- No M3U variant-specific handling beyond `#EXTINF` metadata: no XMLTV merging, no EPG lookup, no deduplication of streams.
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+## Additional IPTV playlist / player resources
+
+- [IPTV2Live](https://iptv2live.com) — IPTV playlist and player reference site; this project's homepage and documentation are hosted there.
+- [HLS (HTTP Live Streaming), RFC 8216](https://datatracker.ietf.org/doc/html/rfc8216) — the specification behind `.m3u8` media playlists.
+- [VideoLAN VLC](https://www.videolan.org/vlc/) — a widely used player for M3U playlists and network streams.
+- [FFmpeg](https://ffmpeg.org/) — the standard toolkit for inspecting and re-streaming media (e.g. `ffprobe` for checking whether a URL yields playable media).
+- [iptv-org/iptv](https://github.com/iptv-org/iptv) — a large, publicly maintained collection of M3U playlists, useful as realistic test input.

iptv_stream_validator-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=77.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "iptv-stream-validator"
+version = "0.1.0"
+description = "Check whether IPTV/M3U stream endpoints respond, and parse M3U playlists."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "iptv2live" }]
+requires-python = ">=3.9"
+keywords = ["iptv", "m3u", "m3u8", "playlist", "stream", "validator"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Internet",
+    "Topic :: Multimedia :: Video",
+    "Topic :: Software Development :: Quality Assurance",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://iptv2live.com"
+Documentation = "https://iptv2live.com"
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]

iptv_stream_validator-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

iptv_stream_validator-0.1.0/src/iptv_stream_validator/Playlist.py

@@ -0,0 +1,194 @@
+"""Parsing and validation of M3U / M3U8 playlists.
+
+An *extended* M3U playlist starts with ``#EXTM3U`` and describes each
+stream with an ``#EXTINF`` line followed by the media URL.  Plain M3U
+files contain only URLs.  This module parses both forms and offers a
+cheap syntactic URL check suitable for filtering obviously broken
+entries before any network request is made.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from urllib.parse import urlparse
+
+__all__ = [
+    "PlaylistEntry",
+    "PlaylistError",
+    "extract_urls",
+    "is_valid_stream_url",
+    "parse_m3u",
+    "parse_m3u_file",
+]
+
+_EXTINF_ATTRIBUTES = r'([A-Za-z0-9_-]+)="([^"]*)"'
+
+
+class PlaylistError(ValueError):
+    """Raised when a playlist's structure is invalid."""
+
+
+@dataclass
+class PlaylistEntry:
+    """One stream entry from a playlist.
+
+    Attributes:
+        url: The media URL (M3U line following an ``#EXTINF`` line, or
+            a standalone non-comment line).
+        title: Display name from the ``#EXTINF`` line, if present.
+        duration: Declared duration in seconds; live streams usually
+            declare ``-1``.  None when the playlist is plain M3U.
+        attributes: ``key="value"`` pairs from the ``#EXTINF`` line,
+            such as ``tvg-id`` or ``group-title``.  Values keep the
+            original spelling of their keys.
+    """
+
+    url: str
+    title: str | None = None
+    duration: float | None = None
+    attributes: dict[str, str] = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        """Return the entry as a plain dictionary (JSON-compatible)."""
+        return {
+            "url": self.url,
+            "title": self.title,
+            "duration": self.duration,
+            "attributes": dict(self.attributes),
+        }
+
+
+def parse_m3u(text: str) -> list[PlaylistEntry]:
+    """Parse M3U / M3U8 playlist text.
+
+    Args:
+        text: The full playlist content, UTF-8 decoded.
+
+    Returns:
+        Entries in playlist order.
+
+    Raises:
+        TypeError: If `text` is not a string.
+        PlaylistError: If the text is empty or has no URL lines.
+
+    A leading ``#EXTM3U`` header is recognized but optional, so plain
+    URL lists are accepted as well.  ``#EXTINF`` metadata is attached
+    to the URL line that follows it; other directives (``#EXTVLCOPT``,
+    ``#EXTGRP``, comments) are ignored.
+    """
+    if not isinstance(text, str):
+        raise TypeError(f"playlist text must be str, got {type(text).__name__}")
+    entries: list[PlaylistEntry] = []
+    pending_title = None
+    pending_duration: float | None = None
+    pending_attributes: dict[str, str] = {}
+    for raw_line in text.splitlines():
+        line = raw_line.strip()
+        if not line:
+            continue
+        if line.startswith("#EXTINF:"):
+            pending_duration, pending_attributes, pending_title = _parse_extinf(line)
+        elif not line.startswith("#"):
+            entry = PlaylistEntry(
+                url=line,
+                title=pending_title,
+                duration=pending_duration,
+                attributes=pending_attributes,
+            )
+            entries.append(entry)
+            pending_title = None
+            pending_duration = None
+            pending_attributes = {}
+    if not entries:
+        raise PlaylistError("no stream URLs found in playlist")
+    return entries
+
+
+def parse_m3u_file(path, encoding: str = "utf-8") -> list[PlaylistEntry]:
+    """Parse an M3U / M3U8 playlist from a file path.
+
+    Args:
+        path: Path to the playlist file.
+        encoding: Encoding of the file; many playlists in the wild are
+            UTF-8, which is the default.
+
+    Returns:
+        Entries in playlist order.
+
+    Raises:
+        OSError: If the file cannot be read.
+        PlaylistError: If the content is not a parseable playlist.
+    """
+    with open(path, "r", encoding=encoding) as handle:
+        return parse_m3u(handle.read())
+
+
+def extract_urls(text: str) -> list[str]:
+    """Return the URL of every entry in playlist text, in order.
+
+    Args:
+        text: The full playlist content.
+
+    Raises:
+        PlaylistError: If the text is not a parseable playlist.
+
+    This is a convenience wrapper around `parse_m3u` for callers that
+    only need the URLs.
+    """
+    return [entry.url for entry in parse_m3u(text)]
+
+
+def is_valid_stream_url(url: str) -> bool:
+    """Return True if `url` is a syntactically valid HTTP(S) stream URL.
+
+    This is a structural check only -- it verifies scheme, host, and
+    the absence of spaces or control characters.  It performs no
+    network I/O and says nothing about whether the endpoint works; use
+    ``StreamValidator`` for that.
+
+    Accepted: ``http`` and ``https`` URLs with a non-empty host, e.g.
+    ``http://example.com:8080/live/stream.m3u8?token=x``.
+    """
+    if not isinstance(url, str) or not url:
+        return False
+    if any(char.isspace() for char in url):
+        return False
+    try:
+        parts = urlparse(url)
+    except ValueError:
+        return False
+    return (
+        parts.scheme in ("http", "https")
+        and parts.netloc != ""
+        and "." in parts.netloc.rsplit("@", 1)[-1].split(":", 1)[0]
+    )
+
+
+def _parse_extinf(line: str) -> tuple[float | None, dict[str, str], str | None]:
+    """Split an ``#EXTINF:<duration> [attrs] [,title]`` line.
+
+    Returns:
+        A ``(duration, attributes, title)`` tuple; duration and title
+        are None when absent.  Unparseable durations are treated as
+        None rather than raising, because malformed metadata should not
+        hide a possibly working URL.
+    """
+    body = line[len("#EXTINF:") :].strip()
+    # duration: digits up to the first attribute, comma, or whitespace
+    duration: float | None = None
+    first_break = re.search(r'[,\s]', body)
+    token = body[: first_break.start()] if first_break else body
+    try:
+        duration = float(token)
+    except ValueError:
+        duration = None
+        metadata = body
+    else:
+        metadata = body[first_break.start() :] if first_break else ""
+    metadata = metadata.strip()
+    attributes: dict[str, str] = dict(re.findall(_EXTINF_ATTRIBUTES, metadata))
+    title: str | None = None
+    if "," in metadata:
+        title = metadata.rsplit(",", 1)[1].strip() or None
+    return duration, attributes, title