208 lines
7.1 KiB
Python
208 lines
7.1 KiB
Python
import httpx
|
|
import json
|
|
import signal
|
|
import time
|
|
import traceback
|
|
import urllib.parse
|
|
from ..parser.live import Parser
|
|
from .. import config
|
|
from .. import exceptions
|
|
from ..paramgen import liveparam, arcparam
|
|
from ..processors.default.processor import DefaultProcessor
|
|
from ..processors.combinator import Combinator
|
|
from ..util.extract_video_id import extract_video_id
|
|
|
|
headers = config.headers
|
|
MAX_RETRY = 10
|
|
|
|
|
|
class PytchatCore:
|
|
'''
|
|
|
|
Parameter
|
|
---------
|
|
video_id : str
|
|
|
|
seektime : int
|
|
start position of fetching chat (seconds).
|
|
This option is valid for archived chat only.
|
|
If negative value, chat data posted before the start of the broadcast
|
|
will be retrieved as well.
|
|
|
|
processor : ChatProcessor
|
|
|
|
interruptable : bool
|
|
Allows keyboard interrupts.
|
|
Set this parameter to False if your own threading program causes
|
|
the problem.
|
|
|
|
force_replay : bool
|
|
force to fetch archived chat data, even if specified video is live.
|
|
|
|
topchat_only : bool
|
|
If True, get only top chat.
|
|
|
|
hold_exception : bool [default:True]
|
|
If True, when exceptions occur, the exception is held internally,
|
|
and can be raised by raise_for_status().
|
|
|
|
Attributes
|
|
---------
|
|
_is_alive : bool
|
|
Flag to stop getting chat.
|
|
'''
|
|
|
|
_setup_finished = False
|
|
|
|
def __init__(self, video_id,
|
|
seektime=-1,
|
|
processor=DefaultProcessor(),
|
|
interruptable=True,
|
|
force_replay=False,
|
|
topchat_only=False,
|
|
hold_exception=True,
|
|
logger=config.logger(__name__),
|
|
):
|
|
self._video_id = extract_video_id(video_id)
|
|
self.seektime = seektime
|
|
if isinstance(processor, tuple):
|
|
self.processor = Combinator(processor)
|
|
else:
|
|
self.processor = processor
|
|
self._is_alive = True
|
|
self._is_replay = force_replay
|
|
self._hold_exception = hold_exception
|
|
self._exception_holder = None
|
|
self._parser = Parser(
|
|
is_replay=self._is_replay,
|
|
exception_holder=self._exception_holder
|
|
)
|
|
self._first_fetch = True
|
|
self._fetch_url = "live_chat/get_live_chat?continuation="
|
|
self._topchat_only = topchat_only
|
|
self._logger = logger
|
|
if interruptable:
|
|
signal.signal(signal.SIGINT, lambda a, b: self.terminate())
|
|
self._setup()
|
|
|
|
def _setup(self):
|
|
time.sleep(0.1) # sleep shortly to prohibit skipping fetching data
|
|
"""Fetch first continuation parameter,
|
|
create and start _listen loop.
|
|
"""
|
|
self.continuation = liveparam.getparam(self._video_id, 3)
|
|
|
|
def _get_chat_component(self):
|
|
|
|
''' Fetch chat data and store them into buffer,
|
|
get next continuaiton parameter and loop.
|
|
|
|
Parameter
|
|
---------
|
|
continuation : str
|
|
parameter for next chat data
|
|
'''
|
|
try:
|
|
with httpx.Client(http2=True) as client:
|
|
if self.continuation and self._is_alive:
|
|
contents = self._get_contents(self.continuation, client, headers)
|
|
metadata, chatdata = self._parser.parse(contents)
|
|
timeout = metadata['timeoutMs'] / 1000
|
|
chat_component = {
|
|
"video_id": self._video_id,
|
|
"timeout": timeout,
|
|
"chatdata": chatdata
|
|
}
|
|
self.continuation = metadata.get('continuation')
|
|
return chat_component
|
|
except exceptions.ChatParseException as e:
|
|
self._logger.debug(f"[{self._video_id}]{str(e)}")
|
|
self._raise_exception(e)
|
|
except (TypeError, json.JSONDecodeError) as e:
|
|
self._logger.error(f"{traceback.format_exc(limit=-1)}")
|
|
self._raise_exception(e)
|
|
|
|
self._logger.debug(f"[{self._video_id}]finished fetching chat.")
|
|
self._raise_exception(exceptions.ChatDataFinished)
|
|
|
|
def _get_contents(self, continuation, client, headers):
|
|
'''Get 'continuationContents' from livechat json.
|
|
If contents is None at first fetching,
|
|
try to fetch archive chat data.
|
|
|
|
Return:
|
|
-------
|
|
'continuationContents' which includes metadata & chat data.
|
|
'''
|
|
livechat_json = (
|
|
self._get_livechat_json(continuation, client, headers)
|
|
)
|
|
contents = self._parser.get_contents(livechat_json)
|
|
if self._first_fetch:
|
|
if contents is None or self._is_replay:
|
|
'''Try to fetch archive chat data.'''
|
|
self._parser.is_replay = True
|
|
self._fetch_url = "live_chat_replay/get_live_chat_replay?continuation="
|
|
continuation = arcparam.getparam(
|
|
self._video_id, self.seektime, self._topchat_only)
|
|
livechat_json = (self._get_livechat_json(continuation, client, headers))
|
|
reload_continuation = self._parser.reload_continuation(
|
|
self._parser.get_contents(livechat_json))
|
|
if reload_continuation:
|
|
livechat_json = (self._get_livechat_json(
|
|
reload_continuation, client, headers))
|
|
contents = self._parser.get_contents(livechat_json)
|
|
self._is_replay = True
|
|
self._first_fetch = False
|
|
return contents
|
|
|
|
def _get_livechat_json(self, continuation, client, headers):
|
|
'''
|
|
Get json which includes chat data.
|
|
'''
|
|
continuation = urllib.parse.quote(continuation)
|
|
livechat_json = None
|
|
err = None
|
|
url = f"https://www.youtube.com/{self._fetch_url}{continuation}&pbj=1"
|
|
for _ in range(MAX_RETRY + 1):
|
|
with client:
|
|
try:
|
|
livechat_json = client.get(url, headers=headers).json()
|
|
break
|
|
except (json.JSONDecodeError, httpx.ConnectTimeout, httpx.ReadTimeout, httpx.ConnectError) as e:
|
|
err = e
|
|
time.sleep(2)
|
|
continue
|
|
else:
|
|
self._logger.error(f"[{self._video_id}]"
|
|
f"Exceeded retry count. Last error: {str(err)}")
|
|
self._raise_exception(exceptions.RetryExceedMaxCount())
|
|
return livechat_json
|
|
|
|
def get(self):
|
|
if self.is_alive():
|
|
chat_component = self._get_chat_component()
|
|
return self.processor.process([chat_component])
|
|
else:
|
|
return []
|
|
|
|
def is_replay(self):
|
|
return self._is_replay
|
|
|
|
def is_alive(self):
|
|
return self._is_alive
|
|
|
|
def terminate(self):
|
|
self._is_alive = False
|
|
self.processor.finalize()
|
|
|
|
def raise_for_status(self):
|
|
if self._exception_holder is not None:
|
|
raise self._exception_holder
|
|
|
|
def _raise_exception(self, exception: Exception = None):
|
|
self._is_alive = False
|
|
if self._hold_exception is False:
|
|
raise exception
|
|
self._exception_holder = exception
|