Upload 3 files

Added hydration script, requirement.txt file, and README.md file describing how to run the code

README.md

@@ -1,15 +1,23 @@
----
-license: apache-2.0
-task_categories:
-- video-classification
-- image-classification
-language:
-- de
-- en
-tags:
-- tiktok
-- video
-- social_media
-size_categories:
-- 100K<n<1M
----
+# Politok-DE Hydration Code
+
+The script `hydrate.py` must be in the same directory as the `politok-de.parquet` file.
+It will scrape the posts from the TikTok Website, and create for each post:
+
+1. A video or image + audio file in the `media/` directory.
+2. An entry entry in the `media_progress.csv` file, stating if the post was successfully scraped.
+3. An entry with post metadata in the `media_metadata.csv` file, only if the post was successfully scraped.
+
+Install dependencies:
+
+```shel
+pip install -r requirements.txt
+```
+
+Run the script:
+
+```shell
+python hydrate.py
+```
+
+Note: To interrupt the script, you might need to press `Ctrl+C` multiple times.
+I think its related to the concurrent nature of the scraping code.

hydrate.py

@@ -0,0 +1,434 @@
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import asdict, dataclass, field, replace
+from logging import getLogger
+import logging
+from pathlib import Path
+import time
+import random
+from typing import Any, Callable, Generic, Literal, TypeVar
+from decorator import decorator
+import pyktok as pyk
+import pandas as pd
+import requests
+from tenacity import retry, stop_after_attempt, wait_random
+import tenacity
+
+logger = getLogger(__name__)
+
+
+def main():
+    configure_logging()
+    target_paths = FilePaths(
+        media_dir=Path("./media"),
+        media_progress_csv=Path("./media_progress.csv"),
+        media_metadata_csv=Path("./media_metadata.csv"),
+    )
+    df = pd.read_parquet("./politok-de.parquet")
+    posts = [Post(content_id=id) for id in df["video_id"]]
+    download_post_in_parallel(tgt_paths=target_paths, posts=posts)
+
+
+def configure_logging(logfile: Path | None = None, level: int = logging.INFO) -> None:
+    fmt = "%(asctime)s [%(levelname)s] %(filename)s:%(lineno)d - %(message)s"
+    if logfile is not None:
+        print("Redirecting logs to file: %s" % logfile)
+    logging.basicConfig(level=level, format=fmt, filename=logfile, force=True)
+
+
+@decorator
+def safely(
+    f: Callable,
+    quiet: bool = False,
+    notify: bool = False,
+    metadata: dict = {},
+    *args,
+    **kwargs,
+):
+    """
+    Will catch any exception thrown by the function and return a Result object.
+    metadata is a dictionary that will be sent to bugsnag if notify is True.
+    """
+    try:
+        result = Result.from_value(f(*args, **kwargs))
+    except Exception as e:
+        if not quiet:
+            logger.error("Exception running function '%s' safely", f.__name__)
+            logger.exception(e)
+        if notify:
+            pass  # bugsnag logic
+        result = Result.from_error(unpack(e))
+    return result.flatten()
+
+
+def unpack(e: Exception) -> Exception:
+    """Unpacking is needed when a wrapping exception is non-informative"""
+    if isinstance(e, tenacity.RetryError):
+        return e.last_attempt.exception()
+    return e
+
+
+@dataclass
+class Post:
+    content_id: str
+    author: str = "placeholder"
+
+    def post_url(self, type_: Literal["video", "photo"]) -> str:
+        return f"https://www.tiktok.com/@{self.author}/{type_}/{self.content_id}"
+
+    def local_video_filename(self) -> str:
+        return f"video_{self.content_id}.mp4"
+
+    def local_audio_filename(self) -> str:
+        return f"audio_{self.content_id}.mp3"
+
+    def local_imgs_filenames(self, n_imgs: int) -> list[str]:
+        return [f"img_{self.content_id}_{i}.jpg" for i in range(1, n_imgs + 1)]
+
+
+@dataclass
+class DownloadReq:
+    """Request to download a video"""
+
+    post: Post
+    paths: "FilePaths"
+    hydrate_media: bool = True
+
+
+@dataclass
+class ImgPostInfo:
+    imgs: list[bytes]
+    data_row: pd.DataFrame
+    audio: bytes | None
+
+
+class PostUnretrievable(Exception):
+    pass
+
+
+class FilePaths:
+    def __init__(
+        self, media_dir: Path, media_progress_csv: Path, media_metadata_csv: Path
+    ):
+        self._media_dir = media_dir
+        self._media_progress_csv = media_progress_csv
+        self._media_metadata_csv = media_metadata_csv
+
+    def media_dir(self) -> Path:
+        return self._media_dir
+
+    def media_progress_csv(self) -> Path:
+        return self._media_progress_csv
+
+    def media_metadata_csv(self) -> Path:
+        return self._media_metadata_csv
+
+
+def download_post_in_parallel(
+    tgt_paths: FilePaths, posts: list[Post], hydrate_media=True
+):
+    if len(posts) == 0:
+        logger.info("Passed 0 posts to download.")
+        return
+
+    completed = 0
+    errored = 0
+    iter = (
+        DownloadReq(post=p, paths=tgt_paths, hydrate_media=hydrate_media) for p in posts
+    )
+
+    n_threads = min(10, len(posts))
+    logger.info(
+        "Concurrently downloading %d posts using %d threads.", len(posts), n_threads
+    )
+    # Using threads rather than processes because the workload is IO-bound, not CPU-bound
+    with ThreadPoolExecutor(max_workers=n_threads) as executor:
+        futures = [executor.submit(wait_and_download_post, req) for req in iter]
+        for idx, future in enumerate(as_completed(futures)):
+            result = future.result()
+            if not result.success:
+                errored += 1
+            completed += 1
+            logger.info(
+                f"Completed {completed} out of {len(posts)} posts."
+                f" CompletePct={idx / len(posts):.2%}."
+                f" ErrorPct={errored / completed:.2%}"
+            )
+            df = _mk_media_progress_df(result=result)
+            append_df_to_file(df, tgt_paths.media_progress_csv(), quiet=True)
+
+
+@dataclass
+class MediaProgressEntry:
+    post_video_url: str
+    success: bool
+    error_dict_as_str: str
+    timestamp: pd.Timestamp = field(default_factory=pd.Timestamp.now)
+
+
+def _mk_media_progress_df(result: "Result[Post]") -> pd.DataFrame:
+    post = result.info
+    assert isinstance(post, Post)
+    entry = MediaProgressEntry(
+        post_video_url=post.post_url("video"),
+        success=result.success,
+        error_dict_as_str="" if result.success else str(result.error),
+    )
+    df = pd.DataFrame(asdict(entry), index=pd.Index([0]))
+    return df[["timestamp", "success", "post_video_url", "error_dict_as_str"]]
+
+
+def wait_and_download_post(req: DownloadReq) -> "Result[Post]":
+    time.sleep(random.random() * 0.5)  # random delay of 0 to 0.5s
+    return download_post(req=req)
+
+
+def download_post(req: DownloadReq) -> "Result[Post]":
+    post = req.post
+    vresult: Result[bool] = safely(download_video, quiet=True)(req=req)
+    if vresult.success:
+        return vresult.with_info(info=post)
+
+    post_is_not_retrievable: bool = PostUnretrievable.__name__ in vresult.error
+    fail_msg = "Failed to download post with content_id=%s. Skipping. Error: %s"
+    if post_is_not_retrievable:
+        logger.error(fail_msg, post.content_id, repr(vresult.error))
+        return vresult.with_info(info=post)
+
+    msg = (
+        "Failed to download post with content_id=%s as video. Trying as imgs. Error: %s"
+    )
+    logger.info(msg, post.content_id, repr(vresult.error))
+    im_result: Result = safely(download_imgs_post, quiet=True)(req=req)
+    if not im_result.success:
+        logger.error(fail_msg, post.content_id, repr(vresult.error))
+    return im_result.with_info(info=post)
+
+
+def download_imgs_post(req: DownloadReq) -> "Result[ImgPostInfo]":
+    if not req.hydrate_media:
+        data_row = _extract_data_row(get_tiktok_json(req.post))
+        dump_data_row(data_row=data_row, paths=req.paths)
+        img_post_info = ImgPostInfo(imgs=[], data_row=data_row, audio=None)
+        return Result.from_value(value=img_post_info)
+
+    result: Result[ImgPostInfo] = fetch_img_post_info(p=req.post)
+    if not result.success:
+        return result  # type: ignore
+    info = result.value
+    assert isinstance(info, ImgPostInfo)
+    dump_post_media(p=req.post, info=info, paths=req.paths)
+    return result
+
+
+def dump_post_media(p: Post, info: ImgPostInfo, paths: FilePaths) -> None:
+    imgs: list[bytes] = info.imgs
+    imgs_filenames = p.local_imgs_filenames(n_imgs=len(imgs))
+    for img, filename in zip(imgs, imgs_filenames):
+        img_path = paths.media_dir() / filename
+        img_path.write_bytes(img)
+        logger.debug("Saved img to '%s'", img_path.absolute())
+
+    if info.audio is not None:
+        audio_path = paths.media_dir() / p.local_audio_filename()
+        audio_path.write_bytes(info.audio)
+        logger.debug("Saved audio to '%s'", audio_path.absolute())
+
+    dump_data_row(data_row=info.data_row, paths=paths)
+
+
+@safely(quiet=True)
+def fetch_img_post_info(p: Post) -> ImgPostInfo:
+    tt_json: dict = get_tiktok_json(p)
+    fail_if_unretrievable(tt_json)
+    data_row: pd.DataFrame = _extract_data_row(tt_json)
+    urls: list[str] = _extract_imgs_urls(tt_json)
+    logger.debug(
+        "For post author=%s, id=%s, found num_imgs=%d",
+        p.author,
+        p.content_id,
+        len(urls),
+    )
+    imgs: list[bytes] = [fetch_content(url) for url in urls]
+
+    audio_url = _extract_audio_url(tt_json)
+    if audio_url == "":
+        audio = None
+    else:
+        audio: bytes = fetch_content(audio_url)
+
+    info = ImgPostInfo(imgs=imgs, audio=audio, data_row=data_row)
+    return info
+
+
+def dump_data_row(data_row: pd.DataFrame, paths: FilePaths) -> None:
+    return append_df_to_file(data_row, paths.media_metadata_csv(), quiet=True)
+
+
+def _extract_data_row(tt_json: dict) -> pd.DataFrame:
+    data: dict = data_slot(tt_json)
+    data_row: pd.DataFrame = pyk.generate_data_row(data)
+    return data_row
+
+
+def _extract_audio_url(tt_json: dict) -> str:
+    data: dict = data_slot(tt_json)
+    return data["music"]["playUrl"]
+
+
+def _extract_imgs_urls(tt_json: dict) -> list[str]:
+    data: dict = data_slot(tt_json)
+    imgs: list[dict] = data["imagePost"]["images"]
+    return [img["imageURL"]["urlList"][0] for img in imgs]
+
+
+def data_slot(tt_json: dict) -> dict:
+    detail: dict = tt_json["__DEFAULT_SCOPE__"]["webapp.video-detail"]
+    return detail["itemInfo"]["itemStruct"]
+
+
+def get_tiktok_json(p: Post) -> dict:
+    return get_tiktok_json_from_url(video_url=p.post_url("video"))
+
+
+def get_tiktok_json_from_url(video_url: str) -> dict:
+    tt_json = pyk.alt_get_tiktok_json(video_url=video_url)
+    if tt_json is None:
+        raise PostUnretrievable("pyktok.alt_get_tiktok_json returned None")
+    return tt_json
+
+
+def fail_if_unretrievable(tt_json: dict) -> None:
+    msg = status_msg(tt_json)
+    if msg == "status_friend_see":
+        emsg = f"Post is presumably only visible to the author's friends: statusMsg='{msg}'"
+        raise PostUnretrievable(emsg)
+    if msg == "cross_border_violation":
+        raise PostUnretrievable(
+            f"This video isn't available in your country or region: statusMsg='{msg}'"
+        )
+    if msg == "status_self_see":
+        emsg = f"Post is presumably only visible to the author: statusMsg='{msg}'"
+        raise PostUnretrievable(emsg)
+    if msg == "item doesn't exist":
+        emsg = "Video currently unavailable. Post or user might have been deleted."
+        raise PostUnretrievable(emsg)
+    if msg == "author_secret":
+        emsg = "Account is private. Only approved users can view content."
+        raise PostUnretrievable(emsg)
+    if msg == "status_deleted":
+        raise PostUnretrievable(f"Post was deleted. StatusMsg='{msg}'")
+    if msg != "ok" and msg != "":
+        raise PostUnretrievable(f"Unknown status message: '{msg}'")
+    if is_content_classified(tt_json):  # this line requires checking 'itemInfo'
+        emsg = "Content is classified. User must be logged in to watch."
+        raise PostUnretrievable(emsg)
+
+
+def is_content_classified(tt_json: dict) -> bool:
+    key = "isContentClassified"
+    container = tt_json["__DEFAULT_SCOPE__"]["webapp.video-detail"]["itemInfo"][
+        "itemStruct"
+    ]
+    return key in container and container[key]
+
+
+def status_msg(tt_json: dict) -> str:
+    return tt_json["__DEFAULT_SCOPE__"]["webapp.video-detail"]["statusMsg"]
+
+
+def download_video(req: DownloadReq) -> None:
+    post = req.post
+    paths = req.paths
+    """Downloads he video without TikTok watermarks"""
+    tt_json = get_tiktok_json(p=post)
+    fail_if_unretrievable(tt_json)
+    data_row: pd.DataFrame = _extract_data_row(tt_json)
+    if req.hydrate_media:
+        video: bytes = fetch_content(_extract_video_url(tt_json))
+        video_path = paths.media_dir() / post.local_video_filename()
+        video_path.parent.mkdir(parents=True, exist_ok=True)
+        video_path.write_bytes(video)
+        logger.debug("Saved video to '%s'", video_path.absolute())
+
+    # only append the metadata if no error was raised before
+    append_df_to_file(df=data_row, path=paths.media_metadata_csv(), quiet=True)
+
+
+def _extract_video_url(tt_json: dict) -> str:
+    url: str | None = data_slot(tt_json)["video"]["playAddr"]
+    if url is None or url == "":
+        msg = "Video url is None or empty string."
+        raise ValueError(msg)
+    return url
+
+
+@retry(stop=stop_after_attempt(2), wait=wait_random(min=1, max=2))
+def fetch_content(url: str) -> bytes:
+    logger.debug("Fetching Content from: %s", url)
+    headers = pyk.headers | dict(referer="https://www.tiktok.com/")
+    from pyktok.pyktok import cookies
+
+    # proxy: dict = random.choice(load_listof_proxies_for_requests())
+    response = requests.get(url, headers=headers, cookies=cookies, timeout=30)
+    response.raise_for_status()
+    return response.content
+
+
+def append_df_to_file(
+    df: pd.DataFrame, path: Path, quiet: bool = False, jsonl: bool = False
+) -> None:
+    if len(df) == 0:
+        logger.info("df is empty, no rows to append to file")
+        return
+
+    data_dir = path.parent
+    data_dir.mkdir(parents=True, exist_ok=True)
+    if jsonl:
+        df_to_jsonl(df, path)
+    else:
+        df.to_csv(path, mode="a", header=not path.exists(), index=False)
+    if not quiet:
+        logger.info(f"Appended {len(df)} rows to '{path.absolute()}'")
+
+
+def df_to_jsonl(df: pd.DataFrame, path: Path, mode="a") -> None:
+    df.to_json(path, lines=True, mode=mode, orient="records")
+
+
+T = TypeVar("T")
+
+
+@dataclass(frozen=True)
+class Result(Generic[T]):
+    # TODO: success should be a computed value
+    success: bool
+    """Excatly one of value or error should be None"""
+    value: T | None
+    error: str | None
+
+    """info is optinal and can be used to include more information about the result"""
+    info: Any | None = None
+
+    @classmethod
+    def from_value(cls, val: T, info=None):
+        return cls(success=True, value=val, error=None, info=info)
+
+    @classmethod
+    def from_error(cls, err: Exception | str, info=None):
+        error_str = repr(err) if isinstance(err, Exception) else err
+        return cls(success=False, value=None, error=error_str, info=info)
+
+    def flatten(self):
+        if not self.success:
+            return self
+        if isinstance(self.value, Result):
+            return self.value.flatten()  # type: ignore
+        else:
+            return self
+
+    def with_info(self, info: Any | None):
+        return replace(self, info=info)
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,2 @@
+decorator
+pyktok