כל Habr במסד נתונים אחד

אחר הצהריים טובים. עברו שנתיים מאז שהוא נכתב. מאמר אחרון לגבי ניתוח Habr, וכמה נקודות השתנו.

כשרציתי לקבל עותק של Habr, החלטתי לכתוב מנתח שישמור את כל התוכן של המחברים למאגר. איך זה קרה ובאילו שגיאות נתקלתי - תוכלו לקרוא מתחת לחתוך.

TLDR- קישור למסד הנתונים

הגרסה הראשונה של המנתח. שרשור אחד, הרבה בעיות

מלכתחילה, החלטתי להכין אב טיפוס של סקריפט בו ינותח המאמר וייכנס למסד הנתונים מיד עם ההורדה. בלי לחשוב פעמיים, השתמשתי ב-sqlite3, כי. זה היה פחות עתיר עבודה: אין צורך בשרת מקומי, נוצר-נראה-נמחק וכאלה.

one_thread.py

from bs4 import BeautifulSoup
import sqlite3
import requests
from datetime import datetime

def main(min, max):
    conn = sqlite3.connect('habr.db')
    c = conn.cursor()
    c.execute('PRAGMA encoding = "UTF-8"')
    c.execute("CREATE TABLE IF NOT EXISTS habr(id INT, author VARCHAR(255), title VARCHAR(255), content  TEXT, tags TEXT)")

    start_time = datetime.now()
    c.execute("begin")
    for i in range(min, max):
        url = "https://m.habr.com/post/{}".format(i)
        try:
            r = requests.get(url)
        except:
            with open("req_errors.txt") as file:
                file.write(i)
            continue
        if(r.status_code != 200):
            print("{} - {}".format(i, r.status_code))
            continue

        html_doc = r.text
        soup = BeautifulSoup(html_doc, 'html.parser')

        try:
            author = soup.find(class_="tm-user-info__username").get_text()
            content = soup.find(id="post-content-body")
            content = str(content)
            title = soup.find(class_="tm-article-title__text").get_text()
            tags = soup.find(class_="tm-article__tags").get_text()
            tags = tags[5:]
        except:
            author,title,tags = "Error", "Error {}".format(r.status_code), "Error"
            content = "При парсинге этой странице произошла ошибка."

        c.execute('INSERT INTO habr VALUES (?, ?, ?, ?, ?)', (i, author, title, content, tags))
        print(i)
    c.execute("commit")
    print(datetime.now() - start_time)

main(1, 490406)

הכל קלאסי - אנחנו משתמשים במרק יפה, בקשות ואב טיפוס מהיר מוכן. זה פשוט…

• הורדת העמוד נמצאת בשרשור אחד

• אם תפריע לביצוע הסקריפט, כל מסד הנתונים לא ילך לשום מקום. אחרי הכל, ה-commit מתבצע רק לאחר כל הניתוח.
  כמובן שניתן לבצע שינויים בבסיס הנתונים לאחר כל הכנסה, אבל אז זמן ביצוע הסקריפט יגדל משמעותית.

• ניתוח 100 המאמרים הראשונים לקח לי 000 שעות.

בשלב הבא אני מוצא את המאמר של המשתמש משולבת, שקראתי ומצאתי כמה פריצות לחיים כדי להאיץ את התהליך הזה:

• השימוש ב-multithreading מאיץ את ההורדה לפעמים.
• אתה לא יכול לקבל את הגרסה המלאה של ה-Habri, אלא את הגרסה הניידת שלו.
  לדוגמה, אם מאמר משולב בגרסת שולחן העבודה שוקל 378 קילו-בייט, אז בגרסה הניידת הוא כבר 126 קילו-בייט.

גרסה שניה. חוטים רבים, איסור זמני מהבר

כשחטטתי באינטרנט בנושא של ריבוי שרשורים בפיתון, בחרתי באפשרות הפשוטה ביותר עם multiprocessing.dummy, שמתי לב שהופיעו בעיות יחד עם ריבוי השרשורים.

SQLite3 לא רוצה לעבוד עם יותר משרשור אחד.
תוקן check_same_thread=False, אבל השגיאה הזו היא לא היחידה, כאשר מנסים להכניס למסד הנתונים, לפעמים מתרחשות שגיאות שלא הצלחתי לפתור.

לכן, אני מחליט לנטוש את ההכנסה המיידית של מאמרים ישירות למסד הנתונים, ובזכרתי את הפתרון המשולב, אני מחליט להשתמש בקבצים, כי אין בעיות עם כתיבה מרובה חוטים לקובץ.

Habr מתחיל לאסור על שימוש ביותר משלושה שרשורים.
ניסיונות נלהבים במיוחד לעבור להבר עלולים להסתיים באיסור ip למשך כמה שעות. אז אתה צריך להשתמש רק ב-3 שרשורים, אבל זה כבר טוב, מכיוון שהזמן לחזור על 100 מאמרים מצטמצם מ-26 ל-12 שניות.

ראוי לציין כי גרסה זו אינה יציבה למדי, וההורדות נושרות מעת לעת על מספר רב של מאמרים.

async_v1.py

from bs4 import BeautifulSoup
import requests
import os, sys
import json
from multiprocessing.dummy import Pool as ThreadPool
from datetime import datetime
import logging

def worker(i):
    currentFile = "files\{}.json".format(i)

    if os.path.isfile(currentFile):
        logging.info("{} - File exists".format(i))
        return 1

    url = "https://m.habr.com/post/{}".format(i)

    try: r = requests.get(url)
    except:
        with open("req_errors.txt") as file:
            file.write(i)
        return 2

    # Запись заблокированных запросов на сервер
    if (r.status_code == 503):
        with open("Error503.txt", "a") as write_file:
            write_file.write(str(i) + "n")
            logging.warning('{} / 503 Error'.format(i))

    # Если поста не существует или он был скрыт
    if (r.status_code != 200):
        logging.info("{} / {} Code".format(i, r.status_code))
        return r.status_code

    html_doc = r.text
    soup = BeautifulSoup(html_doc, 'html5lib')

    try:
        author = soup.find(class_="tm-user-info__username").get_text()

        timestamp = soup.find(class_='tm-user-meta__date')
        timestamp = timestamp['title']

        content = soup.find(id="post-content-body")
        content = str(content)
        title = soup.find(class_="tm-article-title__text").get_text()
        tags = soup.find(class_="tm-article__tags").get_text()
        tags = tags[5:]

        # Метка, что пост является переводом или туториалом.
        tm_tag = soup.find(class_="tm-tags tm-tags_post").get_text()

        rating = soup.find(class_="tm-votes-score").get_text()
    except:
        author = title = tags = timestamp = tm_tag = rating = "Error" 
        content = "При парсинге этой странице произошла ошибка."
        logging.warning("Error parsing - {}".format(i))
        with open("Errors.txt", "a") as write_file:
            write_file.write(str(i) + "n")

    # Записываем статью в json
    try:
        article = [i, timestamp, author, title, content, tm_tag, rating, tags]
        with open(currentFile, "w") as write_file:
            json.dump(article, write_file)
    except:
        print(i)
        raise

if __name__ == '__main__':
    if len(sys.argv) < 3:
        print("Необходимы параметры min и max. Использование: async_v1.py 1 100")
        sys.exit(1)
    min = int(sys.argv[1])
    max = int(sys.argv[2])

    # Если потоков >3
    # то хабр банит ipшник на время
    pool = ThreadPool(3)

    # Отсчет времени, запуск потоков
    start_time = datetime.now()
    results = pool.map(worker, range(min, max))

    # После закрытия всех потоков печатаем время
    pool.close()
    pool.join()
    print(datetime.now() - start_time)

גרסה שלישית. סופי

תוך כדי ניפוי באגים בגרסה השנייה, גיליתי של-Habr, פתאום, יש API שהגרסה הניידת של האתר ניגשת אליו. הוא נטען מהר יותר מהגרסה הניידת, מכיוון שזה רק json, שאפילו לא צריך לנתח. בסופו של דבר, החלטתי לשכתב את התסריט שלי שוב.

אז, לאחר שמצאתי קישור זה API, אתה יכול להתחיל לנתח אותו.

async_v2.py

import requests
import os, sys
import json
from multiprocessing.dummy import Pool as ThreadPool
from datetime import datetime
import logging

def worker(i):
    currentFile = "files\{}.json".format(i)

    if os.path.isfile(currentFile):
        logging.info("{} - File exists".format(i))
        return 1

    url = "https://m.habr.com/kek/v1/articles/{}/?fl=ru%2Cen&hl=ru".format(i)

    try:
        r = requests.get(url)
        if r.status_code == 503:
            logging.critical("503 Error")
            return 503
    except:
        with open("req_errors.txt") as file:
            file.write(i)
        return 2

    data = json.loads(r.text)

    if data['success']:
        article = data['data']['article']

        id = article['id']
        is_tutorial = article['is_tutorial']
        time_published = article['time_published']
        comments_count = article['comments_count']
        lang = article['lang']
        tags_string = article['tags_string']
        title = article['title']
        content = article['text_html']
        reading_count = article['reading_count']
        author = article['author']['login']
        score = article['voting']['score']

        data = (id, is_tutorial, time_published, title, content, comments_count, lang, tags_string, reading_count, author, score)
        with open(currentFile, "w") as write_file:
            json.dump(data, write_file)

if __name__ == '__main__':
    if len(sys.argv) < 3:
        print("Необходимы параметры min и max. Использование: asyc.py 1 100")
        sys.exit(1)
    min = int(sys.argv[1])
    max = int(sys.argv[2])

    # Если потоков >3
    # то хабр банит ipшник на время
    pool = ThreadPool(3)

    # Отсчет времени, запуск потоков
    start_time = datetime.now()
    results = pool.map(worker, range(min, max))

    # После закрытия всех потоков печатаем время
    pool.close()
    pool.join()
    print(datetime.now() - start_time)

הוא מכיל שדות הקשורים הן למאמר עצמו והן למחבר שכתב אותו.

API.png

לא זרקתי את ה-json המלא של כל מאמר, אלא שמרתי רק את השדות שהייתי צריך:

• id
• is_tutorial
• זמן_פורסם
• כותרת
• תוכן
• ספירת_תגובות
• lang היא השפה בה נכתב המאמר. עד כה, יש לו רק en ו-ru.
• tags_string - כל התגים מהפוסט
• ספירת_קריאה
• מחבר
• ציון - דירוג מאמר.

לפיכך, באמצעות ה-API, צמצמתי את זמן ביצוע הסקריפט ל-8 שניות לכל 100 url.

לאחר שהורדנו את הנתונים שאנו צריכים, עלינו לעבד אותם ולהזין אותם למסד הנתונים. גם עם זה לא היו לי בעיות:

parser.py

import json
import sqlite3
import logging
from datetime import datetime

def parser(min, max):
    conn = sqlite3.connect('habr.db')
    c = conn.cursor()
    c.execute('PRAGMA encoding = "UTF-8"')
    c.execute('PRAGMA synchronous = 0') # Отключаем подтверждение записи, так скорость увеличивается в разы.
    c.execute("CREATE TABLE IF NOT EXISTS articles(id INTEGER, time_published TEXT, author TEXT, title TEXT, content TEXT, 
    lang TEXT, comments_count INTEGER, reading_count INTEGER, score INTEGER, is_tutorial INTEGER, tags_string TEXT)")
    try:
        for i in range(min, max):
            try:
                filename = "files\{}.json".format(i)
                f = open(filename)
                data = json.load(f)

                (id, is_tutorial, time_published, title, content, comments_count, lang,
                 tags_string, reading_count, author, score) = data

                # Ради лучшей читаемости базы можно пренебречь читаемостью кода. Или нет?
                # Если вам так кажется, можно просто заменить кортеж аргументом data. Решать вам.

                c.execute('INSERT INTO articles VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)', (id, time_published, author,
                                                                                        title, content, lang,
                                                                                        comments_count, reading_count,
                                                                                        score, is_tutorial,
                                                                                        tags_string))
                f.close()

            except IOError:
                logging.info('FileNotExists')
                continue

    finally:
        conn.commit()

start_time = datetime.now()
parser(490000, 490918)
print(datetime.now() - start_time)

סטטיסטיקה

ובכן, באופן מסורתי, לבסוף, אתה יכול לחלץ כמה נתונים סטטיסטיים מהנתונים:

• מתוך 490 ההורדות הצפויות, הורדו רק 406 מאמרים. מסתבר שיותר ממחצית (228) מהמאמרים על Habré הוסתרו או נמחקו.
• המאגר כולו, המורכב מכמעט חצי מיליון מאמרים, שוקל 2.95 ג'יגה-בייט. בצורה דחוסה - 495 מגה.
• בסך הכל, 37804 אנשים הם המחברים של Habré. אני מזכיר לך שהסטטיסטיקה הזו היא רק מפוסטים חיים.
• המחבר הכי פרודוקטיבי על Habré - אליזר - 8774 מאמרים.
• מאמר בעל דירוג גבוה - 1448 פלוסים
• המאמר הנקרא ביותר – 1660841 צפיות
• המאמר הנדון ביותר - 2444 הערות

ובכן, בצורה של צמרות15 הסופרים המובילים
15 המובילים לפי דירוג
15 הקריאה המובילה
15 המובילים שנידונו

מקור: www.habr.com