init commit

README.md

@@ -1,3 +1,46 @@
----
-license: mit
----
+# Pitchfork Music Reviews Dataset
+
+This repository contains the code and dataset for scraping music reviews from Pitchfork.
+
+## Dataset Overview
+
+The Pitchfork Music Reviews dataset is a collection of music album reviews from the Pitchfork website. Each entry in the dataset represents a single review and includes the following attributes:
+
+-   `artist`: The artist of the album.
+-   `album`: The name of the album.
+-   `year_released`: The year the album was released.
+-   `rating`: The rating given to the album by the reviewer.
+-   `small_text`: A short snippet from the review.
+-   `review`: The full text of the review.
+-   `reviewer`: The name of the reviewer.
+-   `genre`: The genre(s) of the album.
+-   `label`: The record label that released the album.
+-   `release_date`: The release date of the review.
+-   `album_art_url`: The URL of the album art.
+
+## Usage
+
+This dataset is publicly available for research. The data is provided 'as is', and you assume full responsibility for any legal or ethical issues that may arise from the use of the data.
+
+## Scraping Process
+
+The dataset was generated by scraping the Pitchfork website. The Python script uses the `requests` and `BeautifulSoup` libraries to send HTTP requests to the website and parse the resulting HTML content.
+
+The script saves the data in an SQLite database and can also export the data to a CSV file. Duplicate entries are avoided by checking for existing entries with the same artist and album name before inserting new ones into the database.
+
+## Potential Applications
+
+This dataset can be used for a variety of research purposes, such as:
+
+- Music information retrieval
+- Text mining and sentiment analysis
+- Music recommendation systems
+- Music trend analysis
+
+## Acknowledgments
+
+The dataset is sourced from [Pitchfork](https://pitchfork.com/), a website that publishes daily reviews, features, and news stories about music.
+
+## License
+
+Please ensure you comply with Pitchfork's terms of service before using or distributing this data.

get_url.py

@@ -0,0 +1,59 @@
+import requests
+import pandas as pd
+
+from concurrent.futures import ThreadPoolExecutor
+from bs4 import BeautifulSoup
+from os.path import isfile
+from sys import argv
+
+
+def fetch(args):
+  ''' Fetch a single url '''
+  url, session = args
+  response = session.get(url)
+  page_number = url.split('=')[-1]
+  soup = BeautifulSoup(response.text, 'lxml')
+  error = soup.find('div', {'class': 'error-page'})
+  if error:
+    print(f'Error page: {url} does not exist')
+    return []
+  print('.', end='', flush=True)
+  return [(page_number, f"https://pitchfork.com{e['href']}") for e in soup.find_all('a', {'class': 'review__link'})]
+
+def get_urls(start, end):
+  ''' Return a list of urls from the Pitchfork reviews page '''
+  urls = [f'https://pitchfork.com/reviews/albums/?page={i}' for i in range(start, end+1)]
+  reviews = []
+  session = requests.Session()
+  with ThreadPoolExecutor(max_workers=5) as executor:
+    for result in executor.map(fetch, ((url, session) for url in urls)):
+      reviews.extend(result)
+  print()
+  return reviews
+
+def insert_into_df(data):
+  ''' Insert data into a pandas dataframe '''
+  df = pd.DataFrame(data, columns=['page', 'url'])
+  df.drop_duplicates(subset='url', keep='first', inplace=True)
+  return df
+
+def main():
+  start, end = int(argv[1]), int(argv[2])
+  print(f'Fetching urls from pages {start} to {end}')
+  data = get_urls(start, end)
+  print(f'Fetched {len(data)} urls')
+  df = insert_into_df(data)
+
+  print(f'Writing to urls.csv')
+  if isfile('urls.csv'):
+    df_existing = pd.read_csv('urls.csv')
+    df_combined = pd.concat([df_existing, df])
+  else:
+    df_combined = df
+
+  df_combined.drop_duplicates(subset='url', keep='first', inplace=True)
+  df_combined.to_csv('urls.csv', index=False)
+  print('Done')
+
+if __name__ == '__main__':
+  main()

scrape_pitchfork.py

@@ -0,0 +1,149 @@
+import re
+import requests
+import sqlite3
+import pandas as pd
+
+from concurrent.futures import ThreadPoolExecutor
+from bs4 import BeautifulSoup, SoupStrainer
+from sys import argv
+
+regexes = {
+  'artist': re.compile(r'SplitScreenContentHeaderArtist-\w*'),
+  'album': re.compile(r'SplitScreenContentHeaderHed-\w*'),
+  'year_released': re.compile(r'SplitScreenContentHeaderReleaseYear-\w*'),
+  'rating': re.compile(r'Rating-\w*'),
+  'small_text': re.compile(r'SplitScreenContentHeaderDekDown-\w*'),
+  'review': re.compile(r'body__inner-container'),
+  'reviewer': re.compile(r'BylineName'),
+  'genre': re.compile(r'SplitScreenContentHeaderInfoSlice-\w*'),
+  'label': re.compile(r'SplitScreenContentHeaderInfoSlice-\w*'),
+  'reviewed': re.compile(r'SplitScreenContentHeaderInfoSlice-\w*'),
+  'album_art_url': re.compile(r'SplitScreenContentHeaderImage-\w*'),
+}
+
+def fetch(args):
+  ''' Fetch a single url and return a dictionary of data from a Pitchfork review '''
+  url, session = args
+  response = session.get(url)
+  if response.status_code == 200:
+    soup_strainer = SoupStrainer('article', {'data-testid': 'ReviewPageArticle'})
+    soup = BeautifulSoup(response.content, 'lxml', parse_only=soup_strainer)
+    if soup.find('article', {'data-testid': 'ReviewPageArticle'}) is None:
+      with open('not_done.txt', 'a') as f:
+        f.write(url + '\n')
+      return None
+    print('.', end='', flush=True)
+    result = data_from_soup(soup)
+    if result is None:
+      with open('not_done.txt', 'a') as f:
+        f.write(url + '\n')
+    return result
+  else:
+    with open('errors.txt', 'a') as f:
+      f.write(url + '\n')
+    return None
+
+def get_reviews(urls):
+  ''' Return a list of review data dictionaries from the provided urls '''
+  reviews = []
+  session = requests.Session()
+  with ThreadPoolExecutor() as executor:
+    for result in executor.map(fetch, ((url, session) for url in urls)):
+      if result:  # Check if result is not None
+        reviews.append(result)
+  print()
+  return reviews
+
+def data_from_soup(soup):
+  ''' Return a dictionary of data from a Pitchfork review '''
+  artist = soup.find('div', {'class': regexes['artist']}).text.strip()
+  album = soup.find('h1', {'class': regexes['album']}).text.strip()
+  year_released = soup.find('time', {'class': regexes['year_released']})
+  if year_released:
+    year_released = int(year_released.text.strip())
+  else:
+    return None
+  rating = float(soup.find('p', {'class': regexes['rating']}).text.strip())
+  small_text = soup.find('div', {'class': regexes['small_text']})
+  small_text = small_text.text.strip() if small_text else 'N/A'
+  review = "".join(e.text for e in soup.find('div', {'class': regexes['review']}).descendants if e.name == 'p')
+  reviewer = soup.find('span', {'data-testid': regexes['reviewer']})
+  reviewer = reviewer.text.strip()[3:] if reviewer else 'N/A'
+  misc = [e.text for e in soup.find('div', {'class': regexes['genre']}).descendants if e.name == 'li']
+  misc = {'genre': 'N/A', 'label': 'N/A', 'reviewed': 'N/A'} | {e.split(':')[0].strip().lower(): e.split(':')[1].strip() for e in misc}
+  album_art_url = soup.find('source', {'media': '(max-width: 767px)'})
+  album_art_url = album_art_url['srcset'].split(',')[-2].strip() if album_art_url else 'N/A'
+  return {
+    'artist': artist, 'album': album, 'year_released': year_released,
+    'rating': rating, 'small_text': small_text, 'review': review,
+    'reviewer': reviewer, 'genre': misc['genre'], 'label': misc['label'],
+    'reviewed': misc['reviewed'], 'album_art_url': album_art_url,
+  }
+
+def insert_into_db(data, cursor):
+  ''' Insert data into a sqlite3 database '''
+  for review in data:
+    artist = review.get('artist')
+    album = review.get('album')
+    year_released = review.get('year_released')
+    rating = review.get('rating')
+    small_text = review.get('small_text')
+    review_text = review.get('review')  # 'review' is a reserved word in Python
+    reviewer = review.get('reviewer')
+    genre = review.get('genre')
+    label = review.get('label')
+    reviewed = review.get('reviewed')
+    album_art_url = review.get('album_art_url')
+
+    cursor.execute('SELECT * FROM reviews WHERE artist=? AND album=?', (artist, album))
+    result = cursor.fetchone()
+    if result is None:
+      # Insert new review into database
+      cursor.execute('''
+        INSERT INTO reviews (
+          artist, album, year_released, rating, small_text,
+          review, reviewer, genre, label, reviewed, album_art_url
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ''', (
+        artist, album, year_released, rating, small_text, review_text,
+        reviewer, genre, label, reviewed, album_art_url
+      ))
+
+def main(start, end):
+  conn = sqlite3.connect('reviews.db')
+  c = conn.cursor()
+
+  # Create table with all necessary fields
+  c.execute('''
+    CREATE TABLE IF NOT EXISTS reviews (
+      artist TEXT,
+      album TEXT,
+      year_released INTEGER,
+      rating REAL,
+      small_text TEXT,
+      review TEXT,
+      reviewer TEXT,
+      genre TEXT,
+      label TEXT,
+      reviewed TEXT,
+      album_art_url TEXT
+    )
+  ''')
+
+  # Read URLs from a CSV file into a list
+  df = pd.read_csv('urls.csv')
+  urls = df['url'].tolist()  # replace 'url' with your actual column name
+  start, end = max(0, start), min(len(urls), end)
+  urls = urls[start:end]
+
+  print(f'Fetching {len(urls)} reviews')
+  data = get_reviews(urls)
+  print(f'Fetching complete. Inserting into database')
+  insert_into_db(data, c)
+  print('Done')
+
+  conn.commit()
+  conn.close()
+
+if __name__ == '__main__':
+  main(int(argv[1]), int(argv[2]))