iptv-stream-validator 0.1.0__py3-none-any.whl

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

iptv_stream_validator/Validator.py

@@ -0,0 +1,244 @@
+"""HTTP(S) validation for IPTV stream endpoints.
+
+`StreamValidator` sends one lightweight request per URL, records the
+HTTP status code and the time until the response status line arrives,
+and closes the connection without reading the media body.  Every check
+returns a `ValidationResult`, so network failures are reported as data
+instead of exceptions.
+"""
+
+from __future__ import annotations
+
+import json
+import socket
+import time
+import urllib.error
+import urllib.request
+from dataclasses import asdict, dataclass
+
+__all__ = ["StreamValidator", "ValidationResult", "summarize_results"]
+
+DEFAULT_USER_AGENT = "iptv-stream-validator/0.1.0"
+
+
+@dataclass
+class ValidationResult:
+    """Outcome of a single stream endpoint check.
+
+    Attributes:
+        url: The URL that was checked.
+        ok: True when the endpoint answered with a successful HTTP
+            response (urllib treats 2xx, and followed 3xx redirects,
+            as success).
+        status: HTTP status code, when one was received.
+        response_time: Seconds until the response status line arrived
+            (or until the failure was detected), when measurable.
+        error: Short description of why the check failed, else None.
+        final_url: The URL after redirects, when it differs from `url`.
+    """
+
+    url: str
+    ok: bool
+    status: int | None = None
+    response_time: float | None = None
+    error: str | None = None
+    final_url: str | None = None
+
+    def to_dict(self) -> dict:
+        """Return the result as a plain dictionary (JSON-compatible)."""
+        return asdict(self)
+
+    def to_json(self) -> str:
+        """Return the result as an indented JSON string."""
+        return json.dumps(self.to_dict(), indent=2)
+
+
+class StreamValidator:
+    """Check HTTP(S) stream endpoints with a configurable timeout.
+
+    Args:
+        timeout: Seconds to wait for each connection/response.  Values
+            below 0.01 are clamped to 0.01 to stay within the
+            resolution of `socket` timeouts.
+        method: HTTP method to use, ``"GET"`` (default) or ``"HEAD"``.
+            GET is more compatible with streaming servers that reject
+            HEAD; the body is never read either way, so the cost is one
+            round trip plus whatever the server starts sending before
+            the socket is closed.
+        user_agent: User-Agent header to send.  Defaults to
+            ``iptv-stream-validator/<version>``.
+
+    `validate` never raises for network-level problems; every failure
+    is described in the returned `ValidationResult`.
+    """
+
+    def __init__(
+        self,
+        timeout: float = 10.0,
+        method: str = "GET",
+        user_agent: str = DEFAULT_USER_AGENT,
+    ) -> None:
+        method = method.upper()
+        if method not in ("GET", "HEAD"):
+            raise ValueError(f"method must be 'GET' or 'HEAD', got {method!r}")
+        if not isinstance(timeout, (int, float)) or isinstance(timeout, bool):
+            raise TypeError("timeout must be a number")
+        if not isinstance(user_agent, str) or not user_agent:
+            raise ValueError("user_agent must be a non-empty string")
+        self.timeout = max(0.01, float(timeout))
+        self.method = method
+        self.user_agent = user_agent
+
+    def _open(self, url: str) -> urllib.request.OpenerDirector:
+        """Build an opener that does not read response bodies."""
+        request = urllib.request.Request(
+            url, method=self.method, headers={"User-Agent": self.user_agent}
+        )
+        return _NoBodyOpener().open(request, timeout=self.timeout)
+
+    def validate(self, url: str) -> ValidationResult:
+        """Check one stream endpoint.
+
+        Args:
+            url: An HTTP or HTTPS URL.
+
+        Returns:
+            A `ValidationResult`.  ``ok`` is True for 2xx responses
+            (and 3xx redirects that urllib follows to a 2xx); anything
+            else -- DNS failure, refused connection, timeout, HTTP
+            error -- yields ``ok=False`` with the status or error set.
+        """
+        start = time.perf_counter()
+        try:
+            with self._open(url) as response:
+                status = response.status
+                final_url = response.geturl()
+        except urllib.error.HTTPError as exc:
+            # HTTPError is also a response; it still proves the
+            # endpoint is alive, but a stream URL returning 4xx/5xx
+            # should not be reported as working.
+            elapsed = time.perf_counter() - start
+            return ValidationResult(
+                url,
+                ok=False,
+                status=exc.code,
+                response_time=round(elapsed, 6),
+                error=f"HTTP {exc.code} {exc.reason}",
+            )
+        except urllib.error.URLError as exc:
+            elapsed = time.perf_counter() - start
+            return ValidationResult(
+                url,
+                ok=False,
+                response_time=round(elapsed, 6),
+                error=_describe_url_error(exc),
+            )
+        except (TimeoutError, socket.timeout) as exc:
+            elapsed = time.perf_counter() - start
+            return ValidationResult(
+                url,
+                ok=False,
+                response_time=round(elapsed, 6),
+                error=f"timed out after {self.timeout:g}s"
+                + (f" ({exc})" if str(exc) and str(exc) != "timed out" else ""),
+            )
+        elapsed = time.perf_counter() - start
+        return ValidationResult(
+            url,
+            ok=True,
+            status=status,
+            response_time=round(elapsed, 6),
+            final_url=(final_url if final_url != url else None),
+        )
+
+    def validate_many(self, urls) -> list[ValidationResult]:
+        """Validate several endpoints, preserving the input order.
+
+        Args:
+            urls: An iterable of HTTP(S) URLs.
+
+        Returns:
+            One `ValidationResult` per input URL.
+        """
+        return [self.validate(url) for url in urls]
+
+
+class _NoBodyOpener(urllib.request.OpenerDirector):
+    """URL opener that returns responses without ever reading bodies.
+
+    Streaming endpoints serve live or on-demand media; a validating
+    client only needs the status line and headers.  Wrapping every
+    response in `_CloseOnlyResponse` guarantees the underlying socket
+    is closed immediately instead of downloading the stream.
+    """
+
+    def open(self, fullurl, data=None, timeout=socket._GLOBAL_DEFAULT_TIMEOUT):
+        response = super().open(fullurl, data, timeout)
+        return _CloseOnlyResponse(response)
+
+
+class _CloseOnlyResponse:
+    """Minimal forwarder around an ``http.client.HTTPResponse``.
+
+    It implements just the surface `StreamValidator` uses, and closes
+    the wrapped response on exit or garbage collection without reading
+    its body.
+    """
+
+    def __init__(self, response) -> None:
+        self._response = response
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
+        self.close()
+
+    def __getattr__(self, name):
+        return getattr(self._response, name)
+
+    def close(self) -> None:
+        self._response.close()
+
+
+def _describe_url_error(exc: urllib.error.URLError) -> str:
+    """Distill a URLError into a short, stable description."""
+    reason = exc.reason
+    if isinstance(reason, socket.timeout):
+        return "timed out"
+    if isinstance(reason, OSError) and reason.errno is not None:
+        return f"{reason.__class__.__name__}: {reason}"
+    return str(reason) or reason.__class__.__name__
+
+
+def summarize_results(results) -> dict:
+    """Summarize validation results for reports.
+
+    Args:
+        results: An iterable of `ValidationResult`.
+
+    Returns:
+        A dictionary with the URL count, how many checks succeeded,
+        and the URLs that failed.  Median and average response times
+        are computed over successful checks only, and are None when no
+        check succeeded.
+    """
+    results = list(results)
+    failures = [r.url for r in results if not r.ok]
+    times = sorted(
+        r.response_time for r in results if r.ok and r.response_time is not None
+    )
+    median = None
+    average = None
+    if times:
+        mid = len(times) // 2
+        median = times[mid] if len(times) % 2 else (times[mid - 1] + times[mid]) / 2
+        average = round(sum(times) / len(times), 6)
+    return {
+        "total": len(results),
+        "ok": len(results) - len(failures),
+        "failed": len(failures),
+        "failed_urls": failures,
+        "median_response_time": median,
+        "average_response_time": average,
+    }

iptv_stream_validator/__init__.py

@@ -0,0 +1,49 @@
+"""Validate IPTV stream endpoints and parse M3U playlists.
+
+This package provides two small modules:
+
+* :mod:`iptv_stream_validator.Validator` — check whether HTTP(S)
+  stream endpoints respond, and record status, response time, and
+  errors.
+* :mod:`iptv_stream_validator.Playlist` — parse M3U/M3U8 playlists
+  and inspect the URLs they contain.
+
+Typical use::
+
+    from iptv_stream_validator import StreamValidator, parse_m3u
+
+    entries = parse_m3u(playlist_text)
+    validator = StreamValidator(timeout=5)
+    results = validator.validate_many(entry.url for entry in entries)
+"""
+
+from .Playlist import (
+    PlaylistEntry,
+    PlaylistError,
+    extract_urls,
+    is_valid_stream_url,
+    parse_m3u,
+    parse_m3u_file,
+)
+from .Validator import (
+    DEFAULT_USER_AGENT,
+    StreamValidator,
+    ValidationResult,
+    summarize_results,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "DEFAULT_USER_AGENT",
+    "PlaylistEntry",
+    "PlaylistError",
+    "StreamValidator",
+    "ValidationResult",
+    "extract_urls",
+    "is_valid_stream_url",
+    "parse_m3u",
+    "parse_m3u_file",
+    "summarize_results",
+    "__version__",
+]

iptv_stream_validator-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,8 @@
+iptv_stream_validator/Playlist.py,sha256=qI0502LADpMj_4CASXXealkOoQFxZMHSyOPpj8qyHkM,6336
+iptv_stream_validator/Validator.py,sha256=jo0yPrNO-fQcLQK9fekLUoaNd7mbDXGgUuI_dW5OK9k,8627
+iptv_stream_validator/__init__.py,sha256=8jaqRjJAIay8zkad1eWeOEHa24Z_iP3w8OmC_jsrVz8,1132
+iptv_stream_validator-0.1.0.dist-info/licenses/LICENSE,sha256=uabJvcJm0LbjcybVymVZUh9o1WLPbfFfBooWFX3jhpk,1066
+iptv_stream_validator-0.1.0.dist-info/METADATA,sha256=nvXHOQ5fXyIIP5MCffkyA4jpYCId0TPXaMqggMGJRHw,8521
+iptv_stream_validator-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+iptv_stream_validator-0.1.0.dist-info/top_level.txt,sha256=MUcrVfvy66OYsQuq4GdgUxIdPJ775Nov9GA1CavW2Ko,22
+iptv_stream_validator-0.1.0.dist-info/RECORD,,

iptv_stream_validator-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

iptv_stream_validator-0.1.0.dist-info/licenses/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.dist-info/top_level.txt

@@ -0,0 +1 @@
+iptv_stream_validator