stb-reader 0.1.0__py3-none-any.whl

stb_reader/__init__.py

@@ -0,0 +1,10 @@
+from .client import STBClient
+from .models import Genre, Channel, Category, Content, Season, Episode, EpisodeFile, PagedResult
+from .exceptions import STBError, AuthError, StreamError, NotFoundError
+
+__all__ = [
+    "STBClient",
+    "Genre", "Channel", "Category", "Content",
+    "Season", "Episode", "EpisodeFile", "PagedResult",
+    "STBError", "AuthError", "StreamError", "NotFoundError",
+]

stb_reader/_http.py

@@ -0,0 +1,105 @@
+import logging
+import threading
+from collections.abc import Callable
+from urllib.parse import urlparse
+import requests
+from .exceptions import AuthError, STBError, StreamError
+
+_reauth_local = threading.local()
+
+logger = logging.getLogger(__name__)
+
+_USER_AGENT = "Mozilla/5.0 (QtEmbedded; U; Linux; C) AppleWebKit/533.3 (KHTML, like Gecko) MAG200 stbapp ver: 2 rev: 250 Safari/533.3"
+_X_USER_AGENT = "Model: MAG200; Link: WiFi"
+
+_AUTH_FAILURE_PHRASES = {"Authorization failed", "Access denied"}
+_REQUEST_TIMEOUT = 10
+
+
+def _as_list(data) -> list:
+    """Normalise portal responses that return either a list or {"data": [...]}."""
+    return data if isinstance(data, list) else data.get("data", [])
+
+
+def _is_auth_failure(text: str) -> bool:
+    return any(phrase in text for phrase in _AUTH_FAILURE_PHRASES)
+
+
+class STBSession:
+    def __init__(self, base_url: str, mac: str, serial: str, lang: str, timezone: str, portal_path: str = "stalker_portal/c/portal.php") -> None:
+        self.base_url = base_url.rstrip("/")
+        self.mac = mac
+        self.serial = serial
+        self.lang = lang
+        self.timezone = timezone
+        self.portal_path = portal_path.strip("/")
+        self.token = ""
+        self.signature = ""
+        self.extra_headers: dict = {}
+        self.reauth_fn: Callable[[], None] | None = None
+        self._reauth_lock = threading.Lock()
+        self._cookies = {"stb_lang": lang, "mac": mac, "timezone": timezone}
+        parsed = urlparse(self.base_url)
+        self._base_headers = {
+            "User-Agent": _USER_AGENT,
+            "X-User-Agent": _X_USER_AGENT,
+            "Accept-Language": "en,*",
+            "Connection": "Keep-Alive",
+            "Host": parsed.hostname,
+            "Referer": self.base_url + "/",
+        }
+        self._session = requests.Session()
+
+    def get(self, type_: str, action: str, _retry: bool = False, **params) -> dict:
+        url = f"{self.base_url}/{self.portal_path}"
+        query = {"JsHttpRequest": "1-xml", "type": type_, "action": action, **params}
+        self._cookies["token"] = self.token
+        headers = {**self._base_headers, "Authorization": f"Bearer {self.token}", **self.extra_headers}
+        resp = self._session.get(url, params=query, headers=headers, cookies=self._cookies, timeout=_REQUEST_TIMEOUT)
+        logger.debug("Response [%s %s]: %s", resp.status_code, action, resp.text[:500])
+        if not resp.ok:
+            raise STBError(f"HTTP {resp.status_code}: {resp.text[:200]}")
+        if _is_auth_failure(resp.text):
+            if self.reauth_fn and not _retry and not getattr(_reauth_local, 'active', False):
+                with self._reauth_lock:
+                    _reauth_local.active = True
+                    try:
+                        logger.debug("Auth failure on %s, re-authenticating", action)
+                        self.reauth_fn()
+                    finally:
+                        _reauth_local.active = False
+                return self.get(type_, action, _retry=True, **params)
+            raise AuthError(f"Portal rejected request ({action}): {resp.text[:100]}")
+        try:
+            return resp.json()["js"]
+        except (KeyError, ValueError):
+            raise STBError(f"Invalid JSON response (status {resp.status_code}): {resp.text[:200]}")
+
+    def open_url(self, url: str) -> requests.Response:
+        """Fetch a full URL for streaming (no portal auth needed, e.g. CDN URLs)."""
+        resp = self._session.get(url, stream=True, timeout=_REQUEST_TIMEOUT)
+        logger.debug("Stream response [%s]: %s", resp.status_code, resp.headers.get("content-type"))
+        if not resp.ok:
+            raise StreamError(f"stream fetch failed ({resp.status_code})")
+        return resp
+
+    def open_stream(self, cmd: str) -> requests.Response:
+        """Open a streaming request for a portal-relative ?token= URL.
+
+        Uses only base MAG device headers (no Authorization/X-Random) so
+        load.php sees a genuine STB stream request rather than an API call.
+        Session token travels in Cookie: token= for session validation;
+        play token travels in the URL (?token=) for media lookup.
+        """
+        full_url = f"{self.base_url}/{self.portal_path}{cmd}"
+        self._cookies["token"] = self.token
+        resp = self._session.get(full_url, headers=self._base_headers, cookies=self._cookies, stream=True, timeout=_REQUEST_TIMEOUT)
+        ct = resp.headers.get("content-type", "")
+        logger.debug("Stream response [%s]: %s", resp.status_code, ct)
+        if not resp.ok:
+            raise StreamError(f"stream fetch failed ({resp.status_code})")
+        if "json" in ct:
+            body = resp.json()
+            logger.error("load.php stream JSON: %s", body)
+            raise StreamError(f"portal rejected stream: {body}")
+        return resp

stb_reader/auth.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+import hashlib
+import os
+from typing import TYPE_CHECKING
+from .exceptions import AuthError
+
+if TYPE_CHECKING:
+    from ._http import STBSession
+
+
+def handshake(session: "STBSession") -> None:
+    data = session.get("stb", "handshake")
+    token = data.get("token", "")
+    if not token:
+        raise AuthError("handshake returned no token")
+    session.token = token
+    random_token = data.get("random")
+    if random_token:
+        signature = hashlib.sha256(random_token.encode()).hexdigest().upper()
+        session.extra_headers["X-Random"] = random_token
+        session.extra_headers["Random"] = random_token
+    else:
+        signature = hashlib.sha256(os.urandom(32)).hexdigest().upper()
+    session.signature = signature
+
+
+def get_profile(session: "STBSession") -> dict:
+    return session.get("stb", "get_profile")

stb_reader/client.py

@@ -0,0 +1,24 @@
+from ._http import STBSession
+from .auth import handshake, get_profile
+from .live_tv import ITVService
+from .vod import VODService
+
+
+class STBClient:
+    def __init__(
+        self,
+        base_url: str,
+        mac: str,
+        serial: str = "000000000000",
+        lang: str = "en",
+        timezone: str = "Europe/London",
+        portal_path: str = "stalker_portal/c/portal.php",
+    ) -> None:
+        self._session = STBSession(base_url, mac, serial, lang, timezone, portal_path)
+        self._session.reauth_fn = self.authenticate
+        self.live_tv = ITVService(self._session)
+        self.vod = VODService(self._session)
+
+    def authenticate(self) -> None:
+        handshake(self._session)
+        get_profile(self._session)

stb_reader/exceptions.py

@@ -0,0 +1,14 @@
+class STBError(Exception):
+    pass
+
+
+class AuthError(STBError):
+    pass
+
+
+class StreamError(STBError):
+    pass
+
+
+class NotFoundError(STBError):
+    pass

stb_reader/live_tv.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+from .models import Genre, Channel, PagedResult
+from .exceptions import NotFoundError, STBError, StreamError
+from ._http import _as_list
+
+if TYPE_CHECKING:
+    from ._http import STBSession
+
+
+def _clean_url(url: str) -> str:
+    for prefix in ("ffmpeg ", "auto "):
+        if url.startswith(prefix):
+            url = url[len(prefix):]
+    return url
+
+
+class ITVService:
+    def __init__(self, session: "STBSession") -> None:
+        self._s = session
+
+    def get_genres(self) -> list[Genre]:
+        data = self._s.get("itv", "get_genres")
+        return [
+            Genre(
+                id=str(g["id"]),
+                title=g.get("title", ""),
+                alias=g.get("alias", ""),
+                censored=bool(g.get("censored", False)),
+            )
+            for g in _as_list(data)
+        ]
+
+    def get_channels(
+        self,
+        genre_id: str = "*",
+        page: int = 1,
+        sort: str = "number",
+        hd: bool = False,
+        fav: bool = False,
+    ) -> PagedResult[Channel]:
+        raw = self._s.get(
+            "itv",
+            "get_ordered_list",
+            genre=genre_id,
+            p=page - 1,
+            sortby=sort,
+            hd=int(hd),
+            fav=int(fav),
+        )
+        items = [
+            Channel(
+                id=str(c["id"]),
+                number=str(c.get("number", "")),
+                name=c.get("name", ""),
+                cmd=c.get("cmd", ""),
+                logo=c.get("logo", ""),
+                genre_id=str(c.get("tv_genre_id", "")),
+                hd=bool(c.get("hd", False)),
+                censored=bool(c.get("censored", False)),
+            )
+            for c in raw.get("data", [])
+        ]
+        return PagedResult(
+            items=items,
+            total=int(raw.get("total_items", 0)),
+            page=page,
+            per_page=int(raw.get("max_page_items", len(items))),
+        )
+
+    def get_stream_url(self, cmd: str) -> str:
+        raw = self._s.get("itv", "create_link", cmd=cmd)
+        if raw.get("error"):
+            raise StreamError(raw["error"])
+        url = raw.get("cmd", "")
+        return _clean_url(url)
+
+    def get_stream_url_by_id(self, channel_id: str) -> str:
+        page = 1
+        while True:
+            result = self.get_channels(genre_id="*", page=page)
+            for ch in result.items:
+                if ch.id == str(channel_id):
+                    return self.get_stream_url(ch.cmd)
+            if not result.items or page * result.per_page >= result.total:
+                raise NotFoundError("channel not found")
+            page += 1

stb_reader/models.py

@@ -0,0 +1,77 @@
+from dataclasses import dataclass, field
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+
+
+@dataclass
+class Genre:
+    id: str
+    title: str
+    alias: str
+    censored: bool
+
+
+@dataclass
+class Channel:
+    id: str
+    number: str
+    name: str
+    cmd: str
+    logo: str
+    genre_id: str
+    hd: bool
+    censored: bool
+
+
+@dataclass
+class Category:
+    id: str
+    title: str
+    alias: str
+    censored: bool
+
+
+@dataclass
+class Content:
+    id: str
+    name: str
+    cmd: str
+    screenshot_uri: str
+    genres: str
+    year: str
+    description: str
+    rating: str
+    duration: str
+    is_series: bool
+    fav: bool
+
+
+@dataclass
+class Season:
+    id: str
+    name: str
+    video_id: str
+
+
+@dataclass
+class Episode:
+    id: str
+    name: str
+    series_number: str
+    cmd: str
+
+
+@dataclass
+class EpisodeFile:
+    id: str
+    name: str
+    cmd: str
+
+
+@dataclass
+class PagedResult(Generic[T]):
+    items: list[T]
+    total: int
+    page: int
+    per_page: int

stb_reader/vod.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+import re
+from typing import TYPE_CHECKING
+from .models import Category, Content, Season, Episode, EpisodeFile, PagedResult
+from .exceptions import NotFoundError, STBError, StreamError
+from ._http import _as_list
+from .live_tv import _clean_url
+
+if TYPE_CHECKING:
+    from ._http import STBSession
+
+
+ADULT_TERMS = re.compile(r"adult|18\+", re.IGNORECASE)
+
+
+class VODService:
+    def __init__(self, session: "STBSession") -> None:
+        self._s = session
+
+    def get_categories(self) -> list[Category]:
+        data = self._s.get("vod", "get_categories")
+        return [
+            Category(
+                id=str(c["id"]),
+                title=c.get("title", ""),
+                alias=c.get("alias", ""),
+                censored=bool(c.get("censored", False)),
+            )
+            for c in _as_list(data)
+            if not ADULT_TERMS.search(c.get("title", ""))
+        ]
+
+    def get_content(
+        self,
+        category_id: str = "*",
+        page: int = 1,
+        sort: str = "added",
+        fav: bool = False,
+    ) -> PagedResult[Content]:
+        raw = self._s.get(
+            "vod",
+            "get_ordered_list",
+            category=category_id,
+            p=page,
+            sortby=sort,
+            fav=int(fav),
+            not_ended=0,
+        )
+        items = [
+            Content(
+                id=str(c["id"]),
+                name=c.get("name", ""),
+                cmd=c.get("cmd", ""),
+                screenshot_uri=c.get("screenshot_uri", ""),
+                genres=c.get("genres_str", ""),
+                year=str(c.get("year", "")),
+                description=c.get("description", ""),
+                rating=str(c.get("rating_imdb", "")),
+                duration=str(c.get("time", "")),
+                is_series=bool(int(c.get("is_series") or 0)),
+                fav=bool(c.get("fav", False)),
+            )
+            for c in raw.get("data", [])
+        ]
+        return PagedResult(
+            items=items,
+            total=int(raw.get("total_items", 0)),
+            page=page,
+            per_page=int(raw.get("max_page_items", len(items))),
+        )
+
+    def get_seasons(self, series_id: str) -> list[Season]:
+        raw = self._s.get(
+            "vod",
+            "get_ordered_list",
+            movie_id=series_id,
+            season_id=0,
+            episode_id=0,
+        )
+        return [
+            Season(
+                id=str(s["id"]),
+                name=s.get("name", ""),
+                video_id=str(s.get("video_id", "")),
+            )
+            for s in raw.get("data", [])
+        ]
+
+    def get_episodes(self, series_id: str, season_id: str, delay_s: float = 0) -> list[Episode]:
+        import time
+        episodes: list[Episode] = []
+        page = 1
+        while True:
+            if delay_s > 0 and page > 1:
+                time.sleep(delay_s)
+            raw = self._s.get(
+                "vod",
+                "get_ordered_list",
+                movie_id=series_id,
+                season_id=season_id,
+                episode_id=0,
+                p=page,
+            )
+            episodes.extend(
+                Episode(
+                    id=str(e["id"]),
+                    name=e.get("name", ""),
+                    series_number=str(e.get("series_number", "")),
+                    cmd=e.get("cmd", ""),
+                )
+                for e in raw.get("data", [])
+            )
+            total = int(raw.get("total_items", 0))
+            per_page = int(raw.get("max_page_items", total)) or total
+            if per_page == 0 or page * per_page >= total:
+                break
+            page += 1
+        return episodes
+
+    def get_episode_files(self, series_id: str, season_id: str, episode_id: str) -> list[EpisodeFile]:
+        raw = self._s.get(
+            "vod",
+            "get_ordered_list",
+            movie_id=series_id,
+            season_id=season_id,
+            episode_id=episode_id,
+        )
+        return [
+            EpisodeFile(
+                id=str(f["id"]),
+                name=f.get("name", ""),
+                cmd=f.get("cmd", ""),
+            )
+            for f in raw.get("data", [])
+        ]
+
+    def get_stream_url_by_file_id(
+        self, series_id: str, season_id: str, episode_id: str, file_id: str
+    ) -> str:
+        files = self.get_episode_files(series_id, season_id, episode_id)
+        for f in files:
+            if f.id == str(file_id):
+                return self.get_stream_url(f.cmd)
+        raise NotFoundError("file not found")
+
+    def get_stream_url(self, cmd: str) -> str:
+        raw = self._s.get("vod", "create_link", cmd=cmd)
+        if raw.get("error"):
+            raise StreamError(raw["error"])
+        url = raw.get("cmd", raw.get("url", ""))
+        return _clean_url(url)
+
+    def get_stream_url_by_first_file(self, series_id: str, season_id: str, episode_id: str) -> str:
+        files = self.get_episode_files(series_id, season_id, episode_id)
+        if not files:
+            raise NotFoundError("no files for episode")
+        return self.get_stream_url(files[0].cmd)
+
+    def get_stream_url_by_content_id(self, content_id: str) -> str:
+        return self.get_stream_url(f"/media/{content_id}.mpg")
+

stb_reader-0.1.0.dist-info/METADATA

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: stb-reader
+Version: 0.1.0
+Summary: Python client library for Ministra/Stalker STB portals
+Project-URL: Homepage, https://github.com/shubhsheth/stb-reader
+Project-URL: Repository, https://github.com/shubhsheth/stb-reader
+Author: shubhsheth
+License: MIT License
+        
+        Copyright (c) 2024 shubhsheth
+        
+        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.
+License-File: LICENSE
+Keywords: iptv,ministra,portal,stalker,stb
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Requires-Dist: requests
+Provides-Extra: test
+Requires-Dist: httpx; extra == 'test'
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-cov; extra == 'test'
+Requires-Dist: responses; extra == 'test'
+Requires-Dist: twine; extra == 'test'
+Description-Content-Type: text/markdown
+
+# stb-reader
+
+Python client library for [Ministra/Stalker](https://ministra.com/) STB portals. Retrieve live-TV channels, VOD content, series, episodes, and stream URLs with simple method calls.
+
+## Installation
+
+```bash
+pip install stb-reader
+```
+
+Requires Python 3.11+ and has a single runtime dependency: `requests`.
+
+## Quick start
+
+```python
+from stb_reader import STBClient
+
+client = STBClient(
+    base_url="http://your-portal.example.com",
+    mac="00:1A:79:XX:XX:XX",
+)
+client.authenticate()
+
+# Live TV
+genres = client.live_tv.get_genres()
+channels = client.live_tv.get_channels(genre_id="*", page=1)
+stream_url = client.live_tv.get_stream_url(channels.items[0].cmd)
+
+# VOD
+categories = client.vod.get_categories()
+content = client.vod.get_content(category_id="*", page=1)
+
+# Series
+seasons = client.vod.get_seasons(series_id="123")
+episodes = client.vod.get_episodes(series_id="123", season_id=seasons[0].id)
+stream_url = client.vod.get_stream_url_by_first_file(
+    series_id="123",
+    season_id=seasons[0].id,
+    episode_id=episodes[0].id,
+)
+```
+
+## API reference
+
+### `STBClient(base_url, mac, serial, lang, timezone, portal_path)`
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `base_url` | required | Portal base URL |
+| `mac` | required | Device MAC address |
+| `serial` | `"000000000000"` | Device serial |
+| `lang` | `"en"` | Portal language |
+| `timezone` | `"Europe/London"` | Portal timezone |
+| `portal_path` | `"stalker_portal/c/portal.php"` | Path to portal PHP endpoint |
+
+### `client.live_tv`
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `get_genres()` | `list[Genre]` | All channel genres |
+| `get_channels(genre_id, page, sort, hd, fav)` | `PagedResult[Channel]` | Paginated channel list |
+| `get_stream_url(cmd)` | `str` | Resolved stream URL for a channel `cmd` |
+| `get_stream_url_by_id(channel_id)` | `str` | Resolved stream URL by channel ID |
+
+### `client.vod`
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `get_categories()` | `list[Category]` | All VOD categories |
+| `get_content(category_id, page, sort, fav)` | `PagedResult[Content]` | Paginated VOD content |
+| `get_seasons(series_id)` | `list[Season]` | Seasons for a series |
+| `get_episodes(series_id, season_id)` | `list[Episode]` | All episodes in a season |
+| `get_episode_files(series_id, season_id, episode_id)` | `list[EpisodeFile]` | Quality variants for an episode |
+| `get_stream_url(cmd)` | `str` | Resolved stream URL for a VOD `cmd` |
+| `get_stream_url_by_content_id(content_id)` | `str` | Stream URL for a movie by ID |
+| `get_stream_url_by_first_file(series_id, season_id, episode_id)` | `str` | Stream URL for first file of an episode |
+| `get_stream_url_by_file_id(series_id, season_id, episode_id, file_id)` | `str` | Stream URL for a specific file |
+
+## Exceptions
+
+All exceptions are importable from `stb_reader`:
+
+| Exception | Raised when |
+|-----------|-------------|
+| `STBError` | Base class for all library errors |
+| `AuthError` | Authentication / token failure |
+| `StreamError` | Portal rejects a stream request |
+| `NotFoundError` | Requested item not found |
+
+## Documentation
+
+Full guides are in [`docs/guide/`](docs/guide/):
+
+- [Getting started](docs/guide/getting-started.md) — installation, configuration, first call
+- [Authentication](docs/guide/authentication.md) — token lifecycle, auto-reauth, error handling
+- [Live TV](docs/guide/live-tv.md) — genres, channels, stream URLs
+- [VOD — Movies](docs/guide/vod.md) — categories, content listing, movie streams
+- [Series](docs/guide/series.md) — seasons, episodes, quality selection
+- [Pagination](docs/guide/pagination.md) — `PagedResult`, fetch-all-pages pattern
+- [Error handling](docs/guide/error-handling.md) — all exceptions, recovery patterns
+- [API reference](docs/guide/api-reference.md) — complete method, model, and exception reference
+
+## License
+
+MIT

stb_reader-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+stb_reader/__init__.py,sha256=UckQyZYtvb-JxAt-3xFG01Y2ykk3Q444_AFmM7jliXg,394
+stb_reader/_http.py,sha256=1di6ERDMKjQK9I9gd4s3MugRiwwfoVObXrpGgsAMunc,4819
+stb_reader/auth.py,sha256=X98xjNWJN7Mm9vzuDLuOsyS6TPYCD-NtVnBIhpG688k,863
+stb_reader/client.py,sha256=nBxJT1EjRH_G4lxAMHQrTmmbsBZPIQmNaxW1I8jl22I,739
+stb_reader/exceptions.py,sha256=6x8PR4rDvpkCHyT7Haqh6fih-jqoNwyndk2EdN2kl7s,156
+stb_reader/live_tv.py,sha256=A5zV4cEVwUQVodJV9N6RD-wIbbqzyYpHO5HNnh7EIgk,2655
+stb_reader/models.py,sha256=3iLkVqyLw7mauDDVHtDCYwtayWz6Q6CgKdJEg9Ekudc,971
+stb_reader/vod.py,sha256=CRVSosARKCAHCgjMVSi6kDIpd-llpR2bF03smbC0sT8,5239
+stb_reader-0.1.0.dist-info/METADATA,sha256=lsQM3L-izjVlIBbvgWKpDmH8q_n_7-IpxsS96HDNPEQ,6229
+stb_reader-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+stb_reader-0.1.0.dist-info/licenses/LICENSE,sha256=ugSjSVoNnMFluHM6mhnMGPiBefvxaqlVR3MzjL4oXzE,1067
+stb_reader-0.1.0.dist-info/RECORD,,

stb_reader-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

stb_reader-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 shubhsheth
+
+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.