First release

channel.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+import re
+import json
+import logging
+from copy import copy
+from base64 import b64encode
+from datetime import datetime, timezone
+from typing import Any, Optional, Dict, TYPE_CHECKING
+
+from inventory import Game
+from exceptions import MinerException
+from constants import BASE_URL, GQL_OPERATIONS
+
+if TYPE_CHECKING:
+    from twitch import Twitch
+
+
+logger = logging.getLogger("TwitchDrops")
+
+
+class Stream:
+    def __init__(self, channel: Channel, data: Dict[str, Any]):
+        self._twitch = channel._twitch
+        self.channel = channel
+        stream = data["stream"]
+        self.broadcast_id = int(stream["id"])
+        self.viewer_count = stream["viewersCount"]
+        self.drops_enabled = any(tag["localizedName"] == "Drops Enabled" for tag in stream["tags"])
+        settings = data["broadcastSettings"]
+        self.game: Game = Game(settings["game"])
+        self.title = settings["title"]
+        self._timestamp = datetime.now(timezone.utc)
+
+
+class Channel:
+    async def __new__(cls, *args, **kwargs):
+        """
+        Enables __init__ to be async.
+        The instance is returned after initialization completes.
+        """
+        self = super().__new__(cls)
+        await self.__init__(*args, **kwargs)
+        return self
+
+    async def __init__(self, twitch: Twitch, channel_name: str):  # type: ignore
+        self._twitch: Twitch = twitch
+        self.id: int = 0  # temp, to be filled by get_stream
+        self.name: str = channel_name
+        self.url: str = f"{BASE_URL}/{channel_name}"
+        self._spade_url: str = await self.get_spade_url()
+        self.stream: Optional[Stream] = None
+        await self.get_stream()
+
+    @property
+    def online(self) -> bool:
+        """
+        Returns True if the streamer is online and is currently streaming, False otherwise.
+        """
+        return self.stream is not None
+
+    async def get_spade_url(self) -> str:
+        """
+        To get this monstrous thing, you have to walk a chain of requests.
+        Streamer page (HTML) --parse-> Streamer Settings (JavaScript) --parse-> Spade URL
+        """
+        async with self._twitch._session.get(self.url) as response:
+            streamer_html = await response.text(encoding="utf8")
+        match = re.search(
+            r'src="(https://static\.twitchcdn\.net/config/settings\.[0-9a-f]{32}\.js)"',
+            streamer_html,
+            re.I,
+        )
+        if not match:
+            raise MinerException("Error while spade_url extraction: step #1")
+        streamer_settings = match.group(1)
+        async with self._twitch._session.get(streamer_settings) as response:
+            settings_js = await response.text(encoding="utf8")
+        match = re.search(
+            r'"spade_url": ?"(https://video-edge-[.\w\-/]+\.ts)"', settings_js, re.I
+        )
+        if not match:
+            raise MinerException("Error while spade_url extraction: step #2")
+        return match.group(1)
+
+    async def get_stream(self) -> Optional[Stream]:
+        op = copy(GQL_OPERATIONS["GetStreamInfo"].with_variables({"channel": self.name}))
+        response = await self._twitch.gql_request(op)
+        if response:
+            stream_data = response["data"]["user"]
+            self.id = int(stream_data["id"])  # fill channel_id
+            if stream_data["stream"]:
+                self.stream = Stream(self, stream_data)
+            else:
+                self.stream = None
+        return self.stream
+
+    async def check_online(self) -> bool:
+        stream = await self.get_stream()
+        if stream is None:
+            return False
+        return True
+
+    def set_offline(self):
+        # to be called externally, if we receive an event about this happening
+        self.stream = None
+
+    def _encode_payload(self):
+        assert self.stream is not None
+        assert self._twitch._user_id is not None
+        payload = [
+            {
+                "event": "minute-watched",
+                "properties": {
+                    "channel_id": self.id,
+                    "broadcast_id": self.stream.broadcast_id,
+                    "player": "site",
+                    "user_id": self._twitch._user_id,
+                }
+            }
+        ]
+        json_event = json.dumps(payload, separators=(",", ":"))
+        return {"data": (b64encode(json_event.encode("utf8"))).decode("utf8")}
+
+    async def _send_watch(self):
+        """
+        This uses the encoded payload on spade url to simulate watching the stream.
+        Optimally, send every 60 seconds to advance drops.
+        """
+        if not self.online:
+            return
+        logger.debug(f"Sending minute-watched to {self.name}")
+        async with self._twitch._session.post(
+            self._spade_url, data=self._encode_payload()
+        ) as response:
+            return response.status == 204