xtream-api-client 0.1.0__py3-none-any.whl

xtream_api_client/__init__.py

@@ -0,0 +1,38 @@
+"""Xtream API Client - a small library for Xtream-style IPTV API endpoints.
+
+This package provides a Python interface for interacting with servers that
+implement the Xtream Codes-style API:
+
+* configuring and normalizing a server base URL
+* authenticating with a username/password pair supplied by the caller
+* retrieving account information
+* retrieving live, VOD, and series categories
+* retrieving basic stream lists
+* exporting results as JSON
+"""
+
+from .client import XtreamClient
+from .exceptions import (
+    XtreamAPIError,
+    XtreamAuthenticationError,
+    XtreamConnectionError,
+    XtreamHTTPError,
+    XtreamTimeoutError,
+    XtreamURLValidationError,
+)
+from .models import AccountInfo, Category, Channel
+
+__all__ = [
+    "XtreamClient",
+    "XtreamAPIError",
+    "XtreamAuthenticationError",
+    "XtreamConnectionError",
+    "XtreamHTTPError",
+    "XtreamTimeoutError",
+    "XtreamURLValidationError",
+    "AccountInfo",
+    "Category",
+    "Channel",
+]
+
+__version__ = "0.1.0"

xtream_api_client/client.py

@@ -0,0 +1,249 @@
+"""HTTP client for Xtream-style API endpoints.
+
+The client uses only the Python standard library (:mod:`urllib.request`)
+so the package has no runtime dependencies. All responses are parsed into
+Python dictionaries or lists; helper methods convert the most common
+responses into the dataclasses from :mod:`xtream_api_client.models`.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any, Dict, Iterable, List, Optional, Union
+
+from .exceptions import (
+    XtreamAPIError,
+    XtreamAuthenticationError,
+    XtreamConnectionError,
+    XtreamHTTPError,
+    XtreamTimeoutError,
+    XtreamURLValidationError,
+)
+from .models import AccountInfo, Category, Channel
+
+__all__ = ["XtreamClient", "normalize_server_url"]
+
+# Actions supported by the player_api endpoint of Xtream-style servers.
+_DEFAULT_ACTION_KEY = "action"
+
+_USER_AGENT = "xtream-api-client/0.1.0"
+
+
+def normalize_server_url(server_url: str) -> str:
+    """Validate and normalize a server base URL.
+
+    The function accepts URLs with or without a scheme, strips trailing
+    slashes and whitespace, and requires a hostname.
+
+    Args:
+        server_url: The base URL of an Xtream-compatible server, e.g.
+            ``"http://example.com:8080"`` or ``"example.com:8080"``.
+
+    Returns:
+        The normalized URL without a trailing slash. If no scheme was
+        given, ``http://`` is assumed.
+
+    Raises:
+        XtreamURLValidationError: If the URL is empty, has no hostname,
+            or uses a scheme other than ``http``/``https``.
+    """
+    if not server_url or not server_url.strip():
+        raise XtreamURLValidationError("Server URL must not be empty.")
+
+    url = server_url.strip()
+    if "://" not in url:
+        url = "http://" + url
+
+    parsed = urllib.parse.urlparse(url)
+    if parsed.scheme not in ("http", "https"):
+        raise XtreamURLValidationError(
+            f"Unsupported URL scheme {parsed.scheme!r}; expected http or https."
+        )
+    if not parsed.netloc:
+        raise XtreamURLValidationError(f"URL {server_url!r} has no hostname.")
+
+    return url.rstrip("/")
+
+
+class XtreamClient:
+    """A small client for Xtream-style IPTV API endpoints.
+
+    Example:
+        >>> client = XtreamClient("http://example.com:8080", "user", "pass")
+        >>> info = client.get_account_info()  # doctest: +SKIP
+
+    Args:
+        server_url: Base URL of the server (with or without scheme).
+        username: Username supplied by the user or their provider.
+        password: Password supplied by the user or their provider.
+        timeout: Request timeout in seconds (default 10.0).
+        verify_input: When True (default), URLs are normalized up front.
+    """
+
+    def __init__(
+        self,
+        server_url: str,
+        username: str,
+        password: str,
+        timeout: float = 10.0,
+        verify_input: bool = True,
+    ) -> None:
+        if verify_input:
+            self.server_url = normalize_server_url(server_url)
+        else:
+            self.server_url = (server_url or "").rstrip("/")
+        if not username or not password:
+            raise XtreamAuthenticationError("Username and password are required.")
+        self.username = username
+        self.password = password
+        self.timeout = float(timeout)
+
+    # ------------------------------------------------------------------
+    # Low-level request machinery
+    # ------------------------------------------------------------------
+
+    def _build_url(self, action: Optional[str] = None, extra_params: Optional[Dict[str, Any]] = None) -> str:
+        """Construct a player_api URL for the given action."""
+        params: Dict[str, Any] = {
+            "username": self.username,
+            "password": self.password,
+        }
+        if action is not None:
+            params[_DEFAULT_ACTION_KEY] = action
+        if extra_params:
+            params.update(extra_params)
+        query = urllib.parse.urlencode(params)
+        return f"{self.server_url}/player_api.php?{query}"
+
+    def _request_json(self, url: str) -> Union[Dict[str, Any], List[Any]]:
+        """Perform a GET request and parse the JSON body.
+
+        Raises:
+            XtreamTimeoutError: On timeout.
+            XtreamConnectionError: When the server cannot be reached.
+            XtreamHTTPError: On non-200 HTTP responses.
+            XtreamAPIError: When the body is not valid JSON.
+        """
+        req = urllib.request.Request(url, headers={"User-Agent": _USER_AGENT})
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as response:
+                body = response.read()
+        except urllib.error.HTTPError as exc:
+            raise XtreamHTTPError(exc.code, url) from exc
+        except urllib.error.URLError as exc:
+            reason = getattr(exc, "reason", exc)
+            if isinstance(reason, TimeoutError) or "timed out" in str(reason).lower():
+                raise XtreamTimeoutError(f"Request to {url} timed out.") from exc
+            raise XtreamConnectionError(f"Cannot reach {url}: {reason}") from exc
+        except TimeoutError as exc:
+            raise XtreamTimeoutError(f"Request to {url} timed out.") from exc
+
+        try:
+            data = json.loads(body.decode("utf-8", errors="replace"))
+        except (json.JSONDecodeError, UnicodeDecodeError) as exc:
+            raise XtreamAPIError(f"Server returned non-JSON content from {url}.") from exc
+        if not isinstance(data, (dict, list)):
+            raise XtreamAPIError(f"Unexpected JSON shape from {url}.")
+        return data
+
+    def _call(self, action: Optional[str] = None, extra_params: Optional[Dict[str, Any]] = None) -> Any:
+        """Call the player_api endpoint and apply basic auth checks."""
+        url = self._build_url(action=action, extra_params=extra_params)
+        data = self._request_json(url)
+        if isinstance(data, dict):
+            auth = data.get("user_info", {})
+            if isinstance(auth, dict) and auth.get("auth") in (0, False, "0"):
+                raise XtreamAuthenticationError(
+                    "Server rejected the supplied credentials."
+                )
+        return data
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def get_account_info(self) -> Dict[str, Any]:
+        """Return the raw account/user information dictionary.
+
+        Makes an unauthenticated-action call to ``player_api.php`` and
+        returns the parsed JSON, which typically contains ``user_info``
+        and ``server_info`` keys.
+        """
+        return self._call()
+
+    def get_account_info_parsed(self) -> AccountInfo:
+        """Return parsed :class:`~xtream_api_client.models.AccountInfo`."""
+        return AccountInfo.from_dict(self._call())
+
+    def get_live_categories(self) -> List[Dict[str, Any]]:
+        """Return live TV categories as a list of dictionaries."""
+        return self._call("get_live_categories")  # type: ignore[return-value]
+
+    def get_vod_categories(self) -> List[Dict[str, Any]]:
+        """Return VOD (movie) categories as a list of dictionaries."""
+        return self._call("get_vod_categories")  # type: ignore[return-value]
+
+    def get_series_categories(self) -> List[Dict[str, Any]]:
+        """Return series categories as a list of dictionaries."""
+        return self._call("get_series_categories")  # type: ignore[return-value]
+
+    def get_live_streams(self, category_id: Optional[str] = None) -> List[Dict[str, Any]]:
+        """Return the live channel list, optionally filtered by category."""
+        params = {"category_id": category_id} if category_id else None
+        return self._call("get_live_streams", extra_params=params)  # type: ignore[return-value]
+
+    def get_vod_streams(self, category_id: Optional[str] = None) -> List[Dict[str, Any]]:
+        """Return the VOD stream list, optionally filtered by category."""
+        params = {"category_id": category_id} if category_id else None
+        return self._call("get_vod_streams", extra_params=params)  # type: ignore[return-value]
+
+    def get_series(self, category_id: Optional[str] = None) -> List[Dict[str, Any]]:
+        """Return the series list, optionally filtered by category."""
+        params = {"category_id": category_id} if category_id else None
+        return self._call("get_series", extra_params=params)  # type: ignore[return-value]
+
+    # ------------------------------------------------------------------
+    # Model-based helpers
+    # ------------------------------------------------------------------
+
+    def list_live_categories(self) -> List[Category]:
+        """Return live categories as :class:`Category` objects."""
+        return [Category.from_dict(c, "live") for c in self.get_live_categories()]
+
+    def list_vod_categories(self) -> List[Category]:
+        """Return VOD categories as :class:`Category` objects."""
+        return [Category.from_dict(c, "vod") for c in self.get_vod_categories()]
+
+    def list_series_categories(self) -> List[Category]:
+        """Return series categories as :class:`Category` objects."""
+        return [Category.from_dict(c, "series") for c in self.get_series_categories()]
+
+    def list_live_streams(self, category_id: Optional[str] = None) -> List[Channel]:
+        """Return live streams as :class:`Channel` objects."""
+        return [Channel.from_dict(s) for s in self.get_live_streams(category_id)]
+
+    # ------------------------------------------------------------------
+    # Export helpers
+    # ------------------------------------------------------------------
+
+    def export_json(self, data: Any, path: Optional[str] = None, indent: int = 2) -> Union[str, None]:
+        """Serialize results to a JSON string and optionally write to a file.
+
+        Args:
+            data: Any JSON-serializable result from the client methods.
+            path: When given, the JSON is also written to this file path.
+            indent: Indentation level for the output (default 2).
+
+        Returns:
+            The JSON string, or ``None`` when ``path`` is given.
+        """
+        text = json.dumps(data, indent=indent, ensure_ascii=False, default=str)
+        if path:
+            with open(path, "w", encoding="utf-8") as fh:
+                fh.write(text)
+            return None
+        return text

xtream_api_client/exceptions.py

@@ -0,0 +1,40 @@
+"""Exception classes for the xtream_api_client package."""
+
+
+class XtreamAPIError(Exception):
+    """Base exception for all errors raised by this library.
+
+    Callers can catch this single type to handle any failure produced
+    by :class:`~xtream_api_client.XtreamClient`.
+    """
+
+
+class XtreamURLValidationError(XtreamAPIError):
+    """Raised when the server URL is missing, malformed, or unsupported."""
+
+
+class XtreamAuthenticationError(XtreamAPIError):
+    """Raised when the server rejects the supplied username/password."""
+
+
+class XtreamTimeoutError(XtreamAPIError):
+    """Raised when a request exceeds the configured timeout."""
+
+
+class XtreamConnectionError(XtreamAPIError):
+    """Raised when the server cannot be reached (DNS, refused, etc.)."""
+
+
+class XtreamHTTPError(XtreamAPIError):
+    """Raised when the server returns an unexpected HTTP status code.
+
+    Attributes:
+        status_code: The HTTP status code returned by the server.
+        url: The request URL that produced the error.
+    """
+
+    def __init__(self, status_code: int, url: str, message: str = "") -> None:
+        self.status_code = status_code
+        self.url = url
+        detail = message or f"HTTP {status_code} from {url}"
+        super().__init__(detail)

xtream_api_client/models.py

@@ -0,0 +1,123 @@
+"""Lightweight data models returned by the client.
+
+The raw API responses are plain dictionaries, and :meth:`dict` access is
+always available. These models add attribute-style access and light
+normalization for the most commonly used fields.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class AccountInfo:
+    """Parsed account information returned by the ``player_api`` login check.
+
+    Attributes:
+        username: The account username.
+        status: Server-reported account status (for example ``"Active"``).
+        exp_date: Optional expiration date as a Unix timestamp string.
+        is_trial: Whether the server reports this as a trial account.
+        active_connections: Currently active connections, when reported.
+        max_connections: Maximum allowed connections, when reported.
+        raw: The complete, unparsed response dictionary.
+    """
+
+    username: str
+    status: Optional[str] = None
+    exp_date: Optional[str] = None
+    is_trial: Optional[bool] = None
+    active_connections: Optional[int] = None
+    max_connections: Optional[int] = None
+    raw: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "AccountInfo":
+        """Build an :class:`AccountInfo` from a raw ``user_info`` dictionary."""
+        user = data.get("user_info", data) if isinstance(data, dict) else {}
+        return cls(
+            username=str(user.get("username", "")),
+            status=user.get("status"),
+            exp_date=user.get("exp_date"),
+            is_trial=_to_bool(user.get("is_trial")),
+            active_connections=_to_int(user.get("active_cons")),
+            max_connections=_to_int(user.get("max_connections")),
+            raw=dict(data),
+        )
+
+
+@dataclass
+class Category:
+    """A single category entry (live, VOD, or series).
+
+    Attributes:
+        category_id: The server-side category identifier.
+        name: Human-readable category name.
+        category_type: One of ``"live"``, ``"vod"``, or ``"series"``.
+    """
+
+    category_id: str
+    name: str
+    category_type: str = "live"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any], category_type: str = "live") -> "Category":
+        """Build a :class:`Category` from a raw category dictionary."""
+        return cls(
+            category_id=str(data.get("category_id", "")),
+            name=str(data.get("category_name", "")),
+            category_type=category_type,
+        )
+
+
+@dataclass
+class Channel:
+    """A single live channel / VOD item from a stream list.
+
+    Attributes:
+        stream_id: The server-side stream identifier.
+        name: Human-readable stream name.
+        category_id: Category this stream belongs to.
+        stream_type: Stream type reported by the server, when present.
+        raw: The complete, unparsed entry dictionary.
+    """
+
+    stream_id: str
+    name: str
+    category_id: Optional[str] = None
+    stream_type: Optional[str] = None
+    raw: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Channel":
+        """Build a :class:`Channel` from a raw stream-list entry."""
+        return cls(
+            stream_id=str(data.get("stream_id", data.get("series_id", ""))),
+            name=str(data.get("name", "")),
+            category_id=data.get("category_id"),
+            stream_type=data.get("stream_type"),
+            raw=dict(data),
+        )
+
+
+def _to_bool(value: Any) -> Optional[bool]:
+    """Coerce common server representations of booleans."""
+    if value is None:
+        return None
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, str):
+        return value.strip().lower() in ("true", "1", "yes")
+    return bool(value)
+
+
+def _to_int(value: Any) -> Optional[int]:
+    """Coerce common server representations of integers, returning None on failure."""
+    if value is None or value == "":
+        return None
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return None

xtream_api_client-0.1.0.dist-info/METADATA

@@ -0,0 +1,187 @@
+Metadata-Version: 2.4
+Name: xtream-api-client
+Version: 0.1.0
+Summary: A small Python client for Xtream-style IPTV API endpoints using only the standard library.
+Author: XtreamTech
+License-Expression: MIT
+Project-URL: Homepage, https://xtreamtech.net
+Project-URL: Documentation, https://xtreamtech.net
+Keywords: xtream,iptv,api,client,player_api
+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 :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Internet
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Dynamic: license-file
+
+# xtream-api-client
+
+A small Python client for working with Xtream-style IPTV API endpoints (`player_api.php`). It is built entirely on the Python standard library — no third-party runtime dependencies — and returns plain dictionaries, lists, and optional lightweight dataclass models.
+
+The library handles URL validation/normalization, query construction, JSON parsing, and error mapping so you can work with an Xtream-compatible server from a few lines of Python.
+
+## What the package does
+
+- Configures and validates an Xtream-compatible server base URL
+- Authenticates with a username/password pair that you supply
+- Retrieves account information
+- Retrieves live, VOD, and series categories
+- Retrieves basic live, VOD, and series stream lists
+- Maps HTTP, connection, timeout, and authentication failures to dedicated exception classes
+- Exports any result as JSON (to a string or a file)
+
+This client only calls documented read-style endpoints (`player_api.php` actions). It does not implement stream playback, does not bypass authentication, and does not attempt to circumvent any provider restriction.
+
+## Installation
+
+```bash
+pip install xtream-api-client
+```
+
+Requires Python 3.9 or newer.
+
+Or from source:
+
+```bash
+git clone <your-repo-url>
+cd xtreamtech
+py -m pip install -e .
+```
+
+## Quick-start example
+
+```python
+from xtream_api_client import XtreamClient
+
+client = XtreamClient(
+    server_url="http://example.com:8080",
+    username="your-username",
+    password="your-password",
+)
+
+account = client.get_account_info()
+print(account["user_info"]["status"])
+
+for category in client.get_live_categories():
+    print(category["category_id"], category["category_name"])
+```
+
+## Configuration
+
+`XtreamClient` accepts:
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `server_url` | `str` | required | Base URL, with or without a scheme (`http://` is assumed). Trailing slashes and whitespace are stripped. |
+| `username` | `str` | required | Your account username. |
+| `password` | `str` | required | Your account password. |
+| `timeout` | `float` | `10.0` | Per-request timeout in seconds. |
+| `verify_input` | `bool` | `True` | Validate/normalize the URL on construction. |
+
+## Authentication
+
+Credentials are sent as query parameters on every `player_api.php` request, matching the Xtream API convention. If the server reports `user_info.auth` as falsy, an `XtreamAuthenticationError` is raised.
+
+There are no hard-coded credentials or servers — supply your own.
+
+## Retrieving account information
+
+```python
+info = client.get_account_info()          # raw dict with user_info / server_info
+parsed = client.get_account_info_parsed() # AccountInfo dataclass
+print(parsed.username, parsed.status, parsed.max_connections)
+```
+
+## Retrieving categories and streams
+
+```python
+client.get_live_categories()    # list[dict]
+client.get_vod_categories()     # list[dict]
+client.get_series_categories()  # list[dict]
+
+client.get_live_streams(category_id="1")  # optional category filter
+client.get_vod_streams(category_id="2")
+client.get_series(category_id="3")
+```
+
+Model-based equivalents:
+
+```python
+cats = client.list_live_categories()   # list[Category]
+streams = client.list_live_streams()   # list[Channel]
+```
+
+## Error handling
+
+All exceptions derive from `XtreamAPIError`:
+
+| Exception | Raised when |
+|---|---|
+| `XtreamURLValidationError` | The server URL is empty, malformed, or uses an unsupported scheme. |
+| `XtreamAuthenticationError` | Credentials are missing or the server rejects them. |
+| `XtreamTimeoutError` | A request exceeds the configured timeout. |
+| `XtreamConnectionError` | The server cannot be reached (DNS failure, connection refused, etc.). |
+| `XtreamHTTPError` | The server returns a non-200 status (`status_code` and `url` attributes). |
+| `XtreamAPIError` | Base class; also raised for non-JSON or unexpected responses. |
+
+```python
+from xtream_api_client.exceptions import XtreamAPIError, XtreamTimeoutError
+
+try:
+    categories = client.get_live_categories()
+except XtreamTimeoutError:
+    ...
+except XtreamAPIError as exc:
+    ...
+```
+
+## Timeout configuration
+
+```python
+client = XtreamClient(url, user, password, timeout=5.0)  # seconds
+```
+
+The timeout applies per request to both connection establishment and reading.
+
+## Exporting results as JSON
+
+```python
+text = client.export_json(client.get_live_categories())      # returns str
+client.export_json(data, path="categories.json")             # writes a file
+```
+
+## Testing
+
+Tests use mocked HTTP responses only — no real servers are contacted.
+
+```bash
+py -m pip install -e ".[test]"
+py -m pytest
+```
+
+## Limitations
+
+- Read-style `player_api.php` actions only; no episode/stream URL building or playback.
+- Error detection relies on the server returning well-formed JSON; behavior varies between server implementations and versions.
+- Credentials appear in query strings, matching the API convention; avoid logging full request URLs.
+- Synchronous `urllib` based I/O only; no async support or connection pooling.
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+## Additional Xtream/IPTV technical resources
+
+- Project documentation and resources: [https://xtreamtech.net](https://xtreamtech.net)
+- Python `urllib.request` documentation: https://docs.python.org/3/library/urllib.request.html

xtream_api_client-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+xtream_api_client/__init__.py,sha256=3heqP4VP9kaUH4GSxN75diCn6fprcZUaB60ZWIbvBPo,991
+xtream_api_client/client.py,sha256=oH4CBm74YXX3qdZpNeH4pztUbokuTJGoy0x0ixUyaGE,10419
+xtream_api_client/exceptions.py,sha256=uvc4mTwFit1mYa5eO3veJFA4kD0A9sjHUeOy86eUqWo,1253
+xtream_api_client/models.py,sha256=SmrUgj9ZRhqHdqc3l9qzeG9q2KCyJavL5nkNXCjZ3Es,4112
+xtream_api_client-0.1.0.dist-info/licenses/LICENSE,sha256=0FFfT2Q1WBS3zQTM74B2X8ns2mYEBe1NnqD_-I-XZOo,1067
+xtream_api_client-0.1.0.dist-info/METADATA,sha256=ClmGQcJPRfCsSUphTAFNNhNaRL521-5F5AiIKpOw23s,6565
+xtream_api_client-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+xtream_api_client-0.1.0.dist-info/top_level.txt,sha256=XXZLto4CLmQ9ZmBTo94u1jyIyE0GSC7FPtAhX4-CUSY,18
+xtream_api_client-0.1.0.dist-info/RECORD,,

xtream_api_client-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
+

xtream_api_client-0.1.0.dist-info/licenses/LICENSE

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

xtream_api_client-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+xtream_api_client