Come raschiare i repository pubblici di GitHub usando Python?

In questo articolo analizzeremo come effettuare lo scraping dei repository GitHub utilizzando Python. Passeremo in rassegna librerie note come BeautifulSoup e Requests e forniremo una spiegazione dettagliata durante la creazione di uno script per lo scraping di GitHub, in modo che possiate seguirlo facilmente.

Perché fare lo scraping dei repository GitHub?

Cos'è lo scraping di Github e a cosa serve? Ci sono numerosi scopi per utilizzarlo, ma i più frequenti sono:

• Per monitorare i progressi tecnologici. Il monitoraggio delle stelle e dei repository è un ottimo modo per seguire le tendenze dei linguaggi di programmazione, dei framework e delle librerie. Queste informazioni possono essere molto importanti quando si tratta di prendere decisioni relative all'implementazione di tecnologie, allo sviluppo di competenze o all'allocazione di risorse.
• Utilizzare un repository di programmazione. Su GitHub è possibile trovare una pletora di progetti, esempi e soluzioni open-source. Pertanto, sulla piattaforma è disponibile un'enorme quantità di conoscenze e tecniche di programmazione utili per scopi didattici, per migliorare le competenze di programmazione e per comprendere l'implementazione della tecnologia.

GitHub non solo offre hosting per i repository, ma ha una base di utenti enorme e una grande reputazione che lo rende un'opzione affidabile.

Le informazioni archiviate su GitHub sono utili per tracciare i modelli di progressione della tecnologia e per migliorare lo sviluppo del software. Queste informazioni sono fondamentali per tenere il passo con i concorrenti nel mondo dell'informatica.

Librerie e strumenti essenziali per lo scraping di GitHub

Quando si tratta di fare lo scraping di una pagina web, il linguaggio più facile da usare è Python, poiché le sue librerie e i suoi moduli sono molto numerosi. Per effettuare lo scraping di Github in Python, è necessario aggiungere i seguenti moduli:

• requests: lib del client che contiene le richieste e le risposte HTTP e quella più utilizzata.
• BeautifulSoup: sofisticato quando si tratta di estrarre dettagli dall'HTML, in quanto dotato di funzioni avanzate per la navigazione e il recupero dei dati.
• Selenium: lancia un vero e proprio browser e consente di cliccare e digitare sugli elementi della pagina.

Questo può essere fatto facilmente con l'uso degli strumenti di scraping di Github. Tuttavia, spieghiamo meglio come fare.

Creare uno script di scraping del repository GitHub con Beautiful Soup

Questa parte mostrerà come effettuare lo scrape dei repository Github. I passi importanti per realizzare lo scraper consistono in:

1. Creazione del set di base - che comporta il download di Python e delle librerie pertinenti.
2. Il salvataggio del codice HTML della pagina GitHub.
3. Esaminare il layout della pagina per identificare gli elementi necessari.
4. La raccolta di informazioni comporta l'ottenimento dei nomi dei conti, delle descrizioni e della quantità di stelle ottenute, tra le altre cose.
5. Archiviazione dei dati in base ai tipi di file system.

D'ora in poi, condivideremo i dettagli di tutti questi passaggi insieme a uno script Github di scraping completamente formato.

Passo 1: Impostazione dell'ambiente del progetto Python

Assicuratevi di avere Python sul vostro computer. Quindi, creare un nuovo ambiente virtuale Python per iniziare il processo di scraping di Github.

python -m venv github_scraper
source github_scraper/bin/activate  # Per MacOS e Linux
github_scraper\Scripts\activate     # Per Windows

Passo 2: Installazione delle librerie Python necessarie

Come abbiamo detto prima, BeautifulSoup e Requests sono utili per lo scraping dei repository GitHub. Nell'ambiente virtuale attualmente attivato, eseguire questo comando per includerli nelle dipendenze del progetto:

pip install beautifulsoup4 requests

Passo 3: accesso e download della pagina GitHub di destinazione

Selezionare un repository da cui si desidera eseguire lo scraping di Github. Per prima cosa, definire il link in una variabile, quindi effettuare una richiesta HTTP per ottenere il codice della pagina.

url = "https://github.com/TheKevJames/coveralls-python"
response = requests.get(url)

Passo 4: comprensione e analisi della struttura HTML

Per analizzare l'HTML, lo si inserisce in BeautifulSoup.

soup = BeautifulSoup(page.text, 'html.parser')

Il costruttore BeautifulSoup() deve essere dotato di due elementi.

1. Una stringa contenente il contenuto HTML, memorizzato nella variabile page.text.
2. Il parser che Beautiful Soup utilizzerà: "html.parser" è il nome del parser HTML integrato in Python.

L'HTML verrà analizzato da BeautifulSoup e verrà generata una struttura ad albero. In particolare, la variabile soup contiene tutti i metodi necessari per selezionare gli elementi rilevanti dall'albero DOM, come ad esempio:

• find(): restituisce il primo elemento HTML che corrisponde alla strategia del selettore fornita.
• find_all(): restituisce un elenco di elementi HTML che corrispondono alla strategia del selettore di input.
• select_one(): restituisce il primo elemento HTML che corrisponde al selettore CSS inserito.
• select(): restituisce un elenco di elementi HTML corrispondenti al selettore CSS fornito.

Passo 5: analisi della pagina di destinazione alla ricerca di dati rilevanti

Ecco un altro passo importante: scegliere semplici elementi HTML e fare lo scraping dei dati Github da essi. Questo passo precede la scrittura dello script Python per i repository Github.

Prima di eseguire lo scraping di Github, è necessario familiarizzare con la pagina web stessa. Quindi, aprire gli strumenti per gli sviluppatori facendo clic su F12. Dopo aver aperto il codice, si noterà che molti elementi della pagina non hanno classi o attributi unici che facilitino la navigazione verso l'elemento appropriato. Esaminare la pagina e prepararsi a estrarre i dati.

Passo 6: Estrazione dei dettagli del repository

Ora siamo pronti a creare uno script Python che ci aiuterà a fare lo scraping dei repository GitHub. Questo script può estrarre informazioni utili memorizzate in GitHub come stelle, descrizioni, ultimi commit, ecc. Per questo, dobbiamo specificare le caratteristiche richieste e recuperare i valori di testo corrispondenti.

• Nome del repository:

  
  repo_title = soup.select_one('[itemprop="name"]').text.strip()
  

  L'attributo itemprop="name" ha un valore di attributo che ha un'identità unica, quindi lo recuperiamo. I campi di testo su GitHub hanno in genere spazi e caratteri newline e possono essere puliti usando strip().

• Filiale attuale:

  
  git_branch_icon_html_element = soup.select_one('[class="Box-sc-g0xbh4-0 ffLUq ref-selector-button-text-container"]').text.split()
  

  Fate attenzione al fatto che non esiste un metodo più semplice per selezionare il componente HTML che contiene il titolo del ramo principale. Cosa si può fare? Scegliere una classe unica e ottenere il testo.

• Ultimo impegno:

  
  relative_time_html_element = soup.select_one('relative-time')
  latest_commit = relative_time_html_element['datetime']
  

  Abbiamo notato che il tag relative-time, in cui era memorizzato l'ultimo commit dell'utente, era già selezionato e la data era selezionata tramite datetime.

Raccogliere le informazioni che si trovano sul lato sinistro: descrizione, stelle, panorami, bivi.

• Descrizione:

  
  bordergrid_html_element = soup.select_one('.BorderGrid')
  about_html_element = bordergrid_html_element.select_one('h2')
  description_html_element = about_html_element.find_next_sibling('p')
  description = description_html_element.get_text().strip()
  

• Stelle:

  
  star_icon_html_element = bordergrid_html_element.select_one('.octicon-star')
  stars_html_element = star_icon_html_element.find_next_sibling('strong')
  stars = stars_html_element.get_text().strip().replace(',', '')
  

• Visualizzazioni:

  
  eye_icon_html_element = bordergrid_html_element.select_one('.octicon-eye')
  watchers_html_element = eye_icon_html_element.find_next_sibling('strong')
  watchers = watchers_html_element.get_text().strip().replace(',', '')
  

• Forchette:

  
  fork_icon_html_element = bordergrid_html_element.select_one('.octicon-repo-forked')
  forks_html_element = fork_icon_html_element.find_next_sibling('strong')
  forks = forks_html_element.get_text().strip().replace(',', '')
  

Passo 7: Raccolta e analisi dei file Readme

Il file readme è molto importante. Fornisce descrizioni dei repository e istruzioni su come implementare il codice. Se si controlla il file readme.md, si può notare quale collegamento ha:

https://raw.githubusercontent.com///readme.md

Dal momento che abbiamo , possiamo creare programmaticamente l'URL usando una stringa f, usarla e fare una richiesta HTTP per ottenere il codice del file.

readme_url = f'https://github.com/TheKevJames/coveralls-python/blob/{main_branch}/readme.rst'
readme_page = requests.get(readme_url)

readme = None
if readme_page.status_code != 404:
    readme = readme_page.text

Ricordarsi di controllare l'errore 404 per evitare di salvare il contenuto della pagina web 404 di GitHub se il repository non ha un file readme.

Passo 8: organizzazione e archiviazione efficiente dei dati di scraping

Tutte le informazioni saranno memorizzate in un unico dizionario, in modo da poterle scrivere facilmente in un file JSON.

repo = {}
repo['name'] = repo_title
repo['latest_commit'] = latest_commit
repo['main_branch'] = main_branch
repo['description'] = description
repo['stars'] = stars
repo['watchers'] = watchers
repo['forks'] = forks
repo['readme'] = readme

Passo 9: Esportazione dei dati di scraping in formato JSON

Sfrutteremo la libreria integrata di Python per analizzare i dati e memorizzarli nel formato JSON, che è perfetto per le strutture annidate, come nel nostro caso, quando gli articoli hanno delle liste.

with open('github_data.json', 'w', encoding='utf-8') as json_file:
  json.dump(repo, json_file, ensure_ascii=False, indent=4)

Passo 10: Integrare tutti i passaggi in una sceneggiatura completa

import json
import requests
from bs4 import BeautifulSoup

url = "https://github.com/TheKevJames/coveralls-python"
response = requests.get(url)
soup = BeautifulSoup(response.text, "lxml")

repo_title = soup.select_one('[itemprop="name"]').text.strip()

# ramo
main_branch = soup.select_one(
   '[class="Box-sc-g0xbh4-0 ffLUq ref-selector-button-text-container"]').text.split()

# ultimo commit
relative_time_html_element = soup.select_one('relative-time')
latest_commit = relative_time_html_element['datetime']

# descrizione
bordergrid_html_element = soup.select_one('.BorderGrid')
about_html_element = bordergrid_html_element.select_one('h2')
description_html_element = about_html_element.find_next_sibling('p')
description = description_html_element.get_text().strip()

# stelle
star_icon_html_element = bordergrid_html_element.select_one('.octicon-star')
stars_html_element = star_icon_html_element.find_next_sibling('strong')
stars = stars_html_element.get_text().strip().replace(',', '')

# osservatori
eye_icon_html_element = bordergrid_html_element.select_one('.octicon-eye')
watchers_html_element = eye_icon_html_element.find_next_sibling('strong')
watchers = watchers_html_element.get_text().strip().replace(',', '')

# forchette
fork_icon_html_element = bordergrid_html_element.select_one('.octicon-repo-forked')
forks_html_element = fork_icon_html_element.find_next_sibling('strong')
forks = forks_html_element.get_text().strip().replace(',', '')

# readme
readme_url = f'https://github.com/TheKevJames/coveralls-python/blob/{main_branch}/readme.rst'
readme_page = requests.get(readme_url)

readme = None
if readme_page.status_code != 404:
   readme = readme_page.text

repo = {}
repo['name'] = repo_title
repo['latest_commit'] = latest_commit
repo['main_branch'] = main_branch
repo['description'] = description
repo['stars'] = stars
repo['watchers'] = watchers
repo['forks'] = forks
repo['readme'] = readme

with open('github_data.json', 'w', encoding='utf-8') as json_file:
   json.dump(repo, json_file, ensure_ascii=False, indent=4)

Scraping di Github: Conclusione

Abbiamo esaminato il processo di costruzione di uno script di scraping di GitHub per i repository con l'aiuto di BeautifulSoup e Requests. Ora sapete come accedere alle pagine web, estrarre i dati rilevanti e codificarli in modo semplice. Queste competenze sono utili per analizzare progetti ben noti, tracciare le modifiche al codice o generare report.

Ciononostante, è bene prestare attenzione a un uso sensato. Nella maggior parte dei casi, è disponibile un'API da utilizzare su GitHub, che sarà più semplice e pratica da utilizzare. Se decidete di fare web scraping, assicuratevi di rispettare le linee guida del sito e di non bombardare i server con troppe richieste.