| |
| """Build Hugging Face–ready Parquet files from the raw VK CSV exports. |
| |
| Input (raw/<category>_posts.csv): one row per post plus one row per comment; |
| comment rows repeat all fields of their parent post. |
| Output (data/<category>_<posts|comments>/train.parquet): six configs, |
| posts and comments split into separate tables linked by (group, post_id). |
| |
| Processing: |
| * posts and comments are separated, exact duplicates by ID are dropped; |
| * rows with empty text (media-only posts, sticker comments) are dropped; |
| * float-looking IDs/counters from the comment rows are cast to integers; |
| * dates are rebuilt from the Unix timestamps in UTC (the *_date columns in the |
| raw CSV are in the collector's local time); |
| * personal data in text is masked: user mentions, links to user profiles, |
| phone numbers, e-mail addresses; |
| * a heuristic language label is added (same rules as tuvan_detector.py |
| in the tuvan-lang-in-vk-posts project). |
| |
| Usage: python scripts/prepare.py (from the repository root) |
| """ |
| from __future__ import annotations |
|
|
| import csv |
| import json |
| import re |
| import sys |
| from pathlib import Path |
|
|
| import pandas as pd |
| import pyarrow as pa |
| import pyarrow.parquet as pq |
|
|
| ROOT = Path(__file__).resolve().parent.parent |
| RAW_DIR = ROOT / "raw" |
| DATA_DIR = ROOT / "data" |
|
|
| SOURCES = { |
| "official_media": "official_media_posts.csv", |
| "gov_institutions": "gov_institutions_posts.csv", |
| "community_media": "community_media_posts.csv", |
| } |
|
|
| csv.field_size_limit(sys.maxsize) |
|
|
| |
| |
| |
| USER_MENTION = re.compile(r"\[id\d+\|[^\]]*\]") |
| GROUP_MENTION = re.compile(r"\[(?:club|public|event)\d+\|([^\]]*)\]") |
| USER_LINK = re.compile(r"(?:https?://)?(?:m\.)?vk\.com/id\d+\b") |
| EMAIL = re.compile(r"\b[\w.+-]+@[\w-]+(?:\.[\w-]+)+\b") |
| PHONE = re.compile( |
| r"(?<![\d\w])(?:\+7|8)[\s\-(]*\d{3}[\s\-)]*\d{3}[\s\-]*\d{2}[\s\-]*\d{2}(?![\d\w])" |
| r"|(?<![\d\w+])9\d{2}[\s\-]?\d{3}[\s\-]?\d{2}[\s\-]?\d{2}(?![\d\w])" |
| ) |
|
|
|
|
| def mask(text: str) -> str: |
| text = USER_MENTION.sub("@user", text) |
| text = GROUP_MENTION.sub(r"\1", text) |
| text = USER_LINK.sub("<vk_user>", text) |
| text = EMAIL.sub("<email>", text) |
| text = PHONE.sub("<phone>", text) |
| return text |
|
|
|
|
| |
| |
| |
| TUVAN_CHARS = set("ңөүҢӨҮ") |
| TUVAN_RU_LAYOUT = re.compile("|".join([ |
| r"\bмен\b", r"\bсен\b", r"\bбис\b", r"\bсилер\b", |
| r"\bчуве\b", r"\bчок\b", r"\bбар\b", r"\bтур\b", |
| r"\bболур\b", r"\bдээш\b", r"\bкылыр\b", |
| r"\bбистин\b", r"\bмээн\b", r"\bсилернин\b", |
| r"\bачамнын\b", r"\bавамнын\b", r"\bачазы\b", r"\bавазы\b", |
| r"\bооренир\b", r"\bооренип\b", r"\bооредилге\b", r"\bоршээ\b", |
| r"\bог-буле\b", r"\bтыванын\b", r"\bог-буленин\b", |
| r"\bог-булезинге\b", r"\bог-булелиг\b", |
| r"\bменээ\b", r"\bортек\b", r"\bортээ\b", |
| r"\bкожууннун\b", r"\bторуттунген\b", |
| r"\bчуректиг\b", r"\bчуректеривиске\b", r"\bчурек\b", r"\bчуректер\b", |
| r"\bмонгеде\b", r"\bсоолгу\b", r"\bулегер\b", |
| r"\bбригадазынын\b", r"\bоглувустун\b", r"\bсумузунун\b", r"\bозуп\b", |
| r"\w+нын\b", r"\w+зы\b", r"\w+ынын\b", r"\w+устун\b", r"\w+узунун\b", |
| r"\w+ээ\b", r"\w+иг\b", r"\w+иске\b", r"\w+илге\b", r"\bоо\w+\b", |
| ])) |
|
|
|
|
| def lang_heuristic(text: str) -> str: |
| if any(ch in TUVAN_CHARS for ch in text): |
| return "tyv" |
| if TUVAN_RU_LAYOUT.search(text.lower()): |
| return "tyv_ru_layout" |
| return "ru" |
|
|
|
|
| |
| |
| |
| def as_int(value: str) -> int | None: |
| value = value.strip() |
| return int(float(value)) if value else None |
|
|
|
|
| def read_raw(path: Path, category: str) -> tuple[pd.DataFrame, pd.DataFrame, dict]: |
| posts, comments = [], [] |
| with path.open(encoding="utf-8-sig", newline="") as f: |
| for row in csv.DictReader(f): |
| if row["type"] == "post": |
| posts.append({ |
| "post_id": as_int(row["post_id"]), |
| "group": row["group"], |
| "category": category, |
| "text": row["post_text"], |
| "likes": as_int(row["post_likes"]), |
| "comments_count": as_int(row["post_comments_count"]), |
| "date_unix": as_int(row["post_date_unix"]), |
| }) |
| elif row["type"] == "comment": |
| comments.append({ |
| "comment_id": as_int(row["comment_id"]), |
| "post_id": as_int(row["post_id"]), |
| "group": row["group"], |
| "category": category, |
| "text": row["comment_text"], |
| "likes": as_int(row["comment_likes"]), |
| "date_unix": as_int(row["comment_date_unix"]), |
| }) |
| else: |
| raise ValueError(f"{path.name}: unknown row type {row['type']!r}") |
|
|
| stats = {"raw_posts": len(posts), "raw_comments": len(comments)} |
| return pd.DataFrame(posts), pd.DataFrame(comments), stats |
|
|
|
|
| def finalize(df: pd.DataFrame, id_col: str, stats: dict, kind: str) -> pd.DataFrame: |
| n = len(df) |
| df = df.drop_duplicates(["group", id_col], keep="last") |
| stats[f"{kind}_duplicates_dropped"] = n - len(df) |
|
|
| n = len(df) |
| df = df[df["text"].str.strip() != ""] |
| stats[f"{kind}_empty_dropped"] = n - len(df) |
|
|
| df = df.copy() |
| df["text"] = df["text"].map(mask) |
| df["lang_heuristic"] = df["text"].map(lang_heuristic) |
| df["date"] = pd.to_datetime(df["date_unix"], unit="s", utc=True) |
| df["year"] = df["date"].dt.year.astype("int16") |
| df = df.drop(columns="date_unix").sort_values(["date", id_col], ascending=False) |
| stats[kind] = len(df) |
| stats[f"{kind}_lang"] = df["lang_heuristic"].value_counts().to_dict() |
| return df.reset_index(drop=True) |
|
|
|
|
| POST_SCHEMA = pa.schema([ |
| ("post_id", pa.int64()), |
| ("group", pa.string()), |
| ("category", pa.string()), |
| ("text", pa.string()), |
| ("lang_heuristic", pa.string()), |
| ("likes", pa.int64()), |
| ("comments_count", pa.int64()), |
| ("date", pa.timestamp("s", tz="UTC")), |
| ("year", pa.int16()), |
| ]) |
|
|
| COMMENT_SCHEMA = pa.schema([ |
| ("comment_id", pa.int64()), |
| ("post_id", pa.int64()), |
| ("group", pa.string()), |
| ("category", pa.string()), |
| ("text", pa.string()), |
| ("lang_heuristic", pa.string()), |
| ("likes", pa.int64()), |
| ("date", pa.timestamp("s", tz="UTC")), |
| ("year", pa.int16()), |
| ]) |
|
|
|
|
| def write(df: pd.DataFrame, schema: pa.Schema, config: str) -> Path: |
| out = DATA_DIR / config / "train.parquet" |
| out.parent.mkdir(parents=True, exist_ok=True) |
| table = pa.Table.from_pandas(df[schema.names], schema=schema, preserve_index=False) |
| pq.write_table(table, out, row_group_size=10_000) |
| return out |
|
|
|
|
| def main() -> None: |
| all_stats = {} |
| for category, filename in SOURCES.items(): |
| print(f"→ {filename}") |
| posts, comments, stats = read_raw(RAW_DIR / filename, category) |
| posts = finalize(posts, "post_id", stats, "posts") |
| comments = finalize(comments, "comment_id", stats, "comments") |
| for df, schema, kind in ((posts, POST_SCHEMA, "posts"), (comments, COMMENT_SCHEMA, "comments")): |
| path = write(df, schema, f"{category}_{kind}") |
| print(f" {path.relative_to(ROOT)}: {len(df):,} rows, {path.stat().st_size / 1e6:.1f} MB") |
| all_stats[category] = stats |
|
|
| (ROOT / "scripts" / "stats.json").write_text(json.dumps(all_stats, indent=2, ensure_ascii=False)) |
| print(json.dumps(all_stats, indent=2, ensure_ascii=False)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
