Scraper.py

import latest_user_agents
import threading
import requests
import pathlib
import tarfile
import urllib.parse as urlparse
import random
import pickle
import json
import time
import bs4
import PIL.Image as Image
import io
import re


c_imaging_threads = 30
c_paging_threads = 12
c_state_file = "state.pickle"
c_output_file = "./data.tar"


class Query:
	name = None
	mode = None
	query_hash = None

	def __init__(self, name, mode, query_hash):
		self.name = name
		self.mode = mode
		self.query_hash = query_hash

	def __repr__(self):
		return f"Query<{self.name}, {self.mode}, {self.query_hash}>"
	
	def _build_extension(self):
		return json.dumps({
			"persistedQuery": {
				"version": 1,
				"sha256Hash": self.query_hash
			}
		})
	
	def build(self, url, variables):
		return f"{urlparse.urljoin(url, self.mode)}?operationName={self.name}&variables={json.dumps(variables)}&extensions={self._build_extension()}"
	

class Client:
	session = requests.session()

	client_version = None
	client_token = None
	client_auth = None
	client_id = None

	queries = {}

	_client_token_expiration = 0
	_client_token_renewal = 0
	_client_auth_expiration = 0

	def _setup_session(self):
		self.session.headers = {
			"User-Agent": latest_user_agents.get_random_user_agent(),
			"Accept-Encoding": "gzip, deflate, br, zstd",
			"Accept-Language": "en-US,en;q=0.5",
			"Accept": "*/*",
			"Connection": "keep-alive",
			"Sec-Fetch-Dest": "empty",
			"Sec-Fetch-Mode": "no-cors",
			"Sec-Fetch-Site": "same-origin",
			"Referer": "https://open.spotify.com/",
			"Origin": "https://open.spotify.com",
			"Priority": "u=4",
			"Sec-GPC": "1",
			"DNT": "1"
		}

	def _acquire_client(self):
		def get_key(source, name):
			result = re.search(name + r":\s*['\"](.+?)['\"]", source, re.UNICODE)
			
			if result:
				return result.group(1)
			else:
				return None
			
		def get_queries(source):
			queries = {}
			for section in re.finditer(r"\(\s*?['\"](\w+?)['\"],\s*?['\"](\w+?)['\"],\s*?['\"]([a-z\d]+?)['\"]", source, re.UNICODE):
				query = Query(*section.groups())
				queries[query.name] = query

			return queries

		document = bs4.BeautifulSoup(self.session.get("https://open.spotify.com/").text, "html.parser")

		client_version = None
		client_id = None

		for script in document.find_all("script"):
			source_link = script.get("src")
			if source_link and "web-player" in source_link:
				source = self.session.get(source_link).text

				client_version = get_key(source, "clientVersion")
				client_id = get_key(source, "clientID")

				self.queries.update(get_queries(source))
				
				if client_version and client_id:
					break

		assert client_version and client_id, "Couldn't find keys"
		assert len(client_id) + len(client_version) < 1024, "Keys are too big (regex failure?)"

		self.session.headers.update({
			"Spotify-App-Version": client_version,
			"App-Platform": "WebPlayer"
		})

		result = self.session.get("https://open.spotify.com/get_access_token?reason=transport&productType=web-player", headers={ "Accept": "application/json" })
		assert result.status_code == 200, "Status code for get_access_token isn't 200"

		parsed = result.json()
		assert parsed["clientId"] == client_id, "client_id mismatch"
		
		self.client_auth = parsed["accessToken"]
		self._client_auth_expiration = float(parsed["accessTokenExpirationTimestampMs"]) / 1000

		self.client_version = client_version
		self.client_id = client_id


	def _get_client_token(self):
		result = self.session.options("https://clienttoken.spotify.com/v1/clienttoken", headers = {
			"Access-Control-Request-Method": "POST",
			"Access-Control-Request-Headers": "content-type"
		})
		assert result.status_code == 200, "Failed to configure v1/clienttoken for request"

		result = self.session.post(
			"https://clienttoken.spotify.com/v1/clienttoken",
			headers = {
				"Accept": "application/json",
				"TE": "trailers"
			},
			json = {
				"client_data": {
					"client_version": self.client_version,
					"client_id": self.client_id,
					"js_sdk_data": {
						"device_brand": "unknown",
						"device_model": "unknown",
						"os": "windows",
						"os_version": "NT 10.0",
						"device_id": random.randbytes(16).hex(),
						"device_type": "computer"
					}
				}
			}
		)
		assert result.status_code, "Failed to acquire authorization from v1/clienttoken"
		parsed = result.json()

		response_type = "response_type" in parsed and parsed["response_type"]
		assert response_type == "RESPONSE_GRANTED_TOKEN_RESPONSE", f"Expected RESPONSE_GRANTED_TOKEN_RESPONSE got {response_type}"
		
		granted_token = parsed["granted_token"]

		self._client_token_expiration = time.time() + int(granted_token["expires_after_seconds"])
		self._client_token_renewal = time.time() + int(granted_token["refresh_after_seconds"])
		self.client_token = granted_token["token"]

	def is_authenticated(self, slack=10):
		return self._client_token_renewal > time.time() + slack and self._client_auth_expiration > time.time() + slack

	def authenticate(self):
		if not self.is_authenticated():
			self._setup_session()
			self._acquire_client()
			self._get_client_token()

	def request(self, name, variables):
		assert name in self.queries, f"Operation {name} not found"

		self.authenticate()

		return self.session.get(
			self.queries[name].build("https://api-partner.spotify.com/pathfinder/v1/", variables),
			headers = {
				"authorization": f"Bearer {self.client_auth}",
				"client-token": self.client_token,
				"Accept": "application/json"
			}
		)

class ImageWriter:
	def __init__(self, output_file="data.tar"):
		self.current_file_index = 0
		self.current_file = tarfile.open(output_file, mode="a")
		self._lock = threading.Lock()

	def write_file(self, name, value):
		with self._lock:
			value.seek(0)

			info = tarfile.TarInfo(name.format(index = self.current_file_index))
			info.size = value.getbuffer().nbytes

			self.current_file.addfile(info, value)
			self.current_file_index += 1

	def close(self):
		with self._lock:
			self.current_file.close()


def can_iterate(obj):
	return "__iter__" in dir(obj) and "__next__" in dir(obj) or "__getitem__" in dir(obj)

def traverse(obj, path):
	current = obj
	for name in path.split('.'):
		current = current.get(name)
		if not current:
			break
		
	return current

def recursive_scraping(parent, uri_list, url_list):
	if isinstance(parent, list):
		for child in parent:
			if can_iterate(child):
				recursive_scraping(child, uri_list, url_list)
	elif isinstance(parent, dict):
		if "width" in parent and "height" in parent:
			if int(parent["width"] or 0) > 500 and int(parent["height"] or 0) > 500:
				uri_list.add(parent["url"])
			return

		for key, child in parent.items():
			if key == "uri" or key == "_uri":
				uri_list.add(child)
			elif key == "url":
				url_list.add(child)
			elif can_iterate(child):
				recursive_scraping(child, uri_list, url_list)

def parse_uri(uri, offset=0, limit=50):
	if not uri or uri.count(':') != 2:
		return None, None, None

	[_spotify, section, _index] = uri.split(':')

	total_count = None
	variables = None
	query = None

	match section:
		case "episode" | "chapter":
			query = "getEpisodeOrChapter"
			variables = { "uri": uri }
		case "show":
			query = "queryPodcastEpisodes"
			variables = { "uri": uri, "offset": offset, "limit": limit }
			total_count = "data.podcastUnionV2.episodesV2.totalCount"
		case "album":
			query = "getAlbum"
			variables = { "uri": uri, "offset": offset, "limit": limit, "locale": "intl-pt" }
			total_count = "data.albumUnion.tracks.totalCount"
		case "playlist":
			query = "fetchPlaylist"
			variables = { "uri": uri, "offset": offset, "limit": limit }
			total_count = "data.playlistV2.content.totalCount"
		case "artist":
			query = "queryArtistOverview"
			variables = { "uri": uri, "includePrerelease": True, "locale": "intl-pt" }
		
		case "track" | "section" | "concert" | "page" | "user" | "merch" | "prerelease":
			query = None
			variables = None

		case _:
			raise RuntimeError(f"Unknown section type \"{section}\" found in {uri}")
		
	
	return query, variables, total_count


def evaluate_uri(client, uri):
	current = 0
	limit = 50

	uri_list = set()
	url_list = set()

	error_count = 0
	while 10 > error_count:
		[query, variables, total_count_path] = parse_uri(uri, current, limit)

		if not query:
			break

		result = None
		parsed = None

		try:
			result = client.request(query, variables)
			parsed = result.json()
		except (requests.exceptions.ConnectionError, requests.exceptions.JSONDecodeError) as error:
			if result:
				print(f"Failed to query uri {uri} with code {result.status_code}, error {error}")
			else:
				print(f"Failed to query uri {uri} (no result), error {error}")

			error_count += 1
			continue
		
		
		recursive_scraping(parsed, uri_list, url_list)

		total = 0
		if total_count_path:
			total = traverse(parsed, total_count_path)

		if not total or current + limit > total:
			break

		current += limit
	
	return uri_list, url_list


class _Queue:
	pages_done = set()
	pages = set()
	
	sources_done = set()
	sources = set()

	def copy(self):
		val = type(self)

		val.pages = self.pages.copy()
		val.pages_done = self.pages_done.copy()
		val.sources = self.sources.copy()
		val.sources_done = self.sources_done.copy()
		
		return val

class _State:
	update_event = threading.Condition()
	running = True

g_image_writer = ImageWriter(c_output_file)
g_queue = _Queue()
g_state = _State()


def atomic_wait_item(lock, iterable):
	target = None
	
	
	while not target and g_state.running:
		if len(iterable):
			target = iterable.pop()
		else:
			with lock:
				lock.wait()
	return target

def paging_worker_logic(thread_id):
	global g_queue, g_state

	client = Client()

	update_event = g_state.update_event

	pages_done = g_queue.pages_done
	pages = g_queue.pages
	sources_done = g_queue.sources_done
	sources = g_queue.sources

	print(f"W[{thread_id}] Started")
	try:
		while g_state.running:
			#print(f"[{thread_id}] Waiting...")
			target = atomic_wait_item(update_event, pages)

			pages_done.add(target)

			if not client.is_authenticated():
				print(f"W[{thread_id}] Token renewal...")
				try:
					client.authenticate()
					print(f"W[{thread_id}] Acquired new tokens")
				except RuntimeError as error:
					print(error)

			#print(f"[{thread_id}] Eval...")
			[uri_list, url_list] = evaluate_uri(client, target)
				
			pages.update(uri_list.difference(pages_done))
			sources.update(url_list.difference(sources_done))

			#print(f"[{thread_id}] Fire...")
			with update_event:
				update_event.notify_all()
	finally:
		print(f"W[{thread_id}] Halted")

def imaging_worker_logic(thread_id):
	global g_queue, g_state

	update_event = g_state.update_event

	sources_done = g_queue.sources_done
	sources = g_queue.sources

	session = requests.session()
	session.headers["User-Agent"] = latest_user_agents.get_random_user_agent()

	print(f"I[{thread_id}] Started")
	try:
		while g_state.running:
			target = atomic_wait_item(update_event, sources)
			if not target:
				continue

			sources_done.add(target)
			
			match = re.fullmatch(r"https?:\/\/(.*\.scdn\.co|image-cdn-ak.spotifycdn.com)\/image\/([a-z\d]+)", target)
			if not match:
				continue

			(_domain, name) = match.groups()
			
			data = None
			for _ in range(3):
				try:
					data = io.BytesIO(session.get(target).content)
					break
				except (requests.exceptions.ConnectionError, requests.exceptions.ChunkedEncodingError):
					pass
			if not data:
				print(f"I[{thread_id}] Failed to download image")
				continue
			
			image = None
			try:
				image = Image.open(data)
			except (Image.UnidentifiedImageError):
				pass

			if not image:
				print(f"I[{thread_id}] Failed to identify image")
				continue

			(x, y) = image.size
			if x < 500 or y < 500:
				continue

			g_image_writer.write_file(f"{name}-{{index}}.{image.format.lower()}", data)
	finally:
		print(f"I[{thread_id}] Halted")



def save_state(path, queue, image_writer):
	file = open(path, "wb")
	pickle.dump({
		"sources_done": queue.sources_done,
		"sources": queue.sources,
		"pages_done": queue.pages_done,
		"pages": queue.pages,
		"current_file_index": image_writer.current_file_index,
	}, file)
	file.close()

def load_state(path, queue, image_writer):
	global g_queue, g_state

	file = open(path, "rb")
	loaded = pickle.load(file)

	queue.sources_done = loaded["sources_done"]
	queue.sources = loaded["sources"]
	queue.pages_done = loaded["pages_done"]
	queue.pages = loaded["pages"]

	image_writer.current_file_index = loaded["current_file_index"]
	
	file.close()

def main():
	global g_queue, g_state

	if pathlib.Path(c_state_file).is_file():
		load_state(c_state_file, g_queue, g_image_writer)
	else:
		client = Client()
		client.authenticate()

		print("Client:")
		print("\tVersion:", client.client_version)
		print("\tID:", client.client_id)
		print("\tToken:", client.client_token)
		print("\tAuth:", client.client_auth)


		result = client.request("home", {
			"timeZone": "UTC",
			"sp_t": random.randbytes(16).hex(),
			"country": "US",
			"facet": None,
			"sectionItemsLimit": 15
		})

		recursive_scraping(result.json(), g_queue.pages, g_queue.sources)

	threads = []

	for thread_id in range(c_paging_threads):
		thread = threading.Thread(target=paging_worker_logic, args=(thread_id,))
		thread.start()
		threads.append(thread)

	for thread_id in range(c_imaging_threads):
		thread = threading.Thread(target=imaging_worker_logic, args=(thread_id,))
		thread.start()
		threads.append(thread)
	
	try:
		start = time.time()
		while g_state.running:
			with g_state.update_event:
				g_state.update_event.wait()
			
			print(f"URIs: {len(g_queue.pages)}/{len(g_queue.pages_done)} images: {len(g_queue.sources)}/{len(g_queue.sources_done)} written: {g_image_writer.current_file_index}")
			if time.time() > start + 60 * 30:
				start = time.time()
				save_state(c_state_file + ".bak", g_queue.copy(), g_image_writer)
	except KeyboardInterrupt:
		print("Halting tasks...")
		g_state.running = False

	for thread in threads:
		with g_state.update_event:
			g_state.update_event.notify_all()
		
		if thread.is_alive():
			thread.join()
	
	print("Saving state...")
	g_image_writer.close()
	save_state(c_state_file, g_queue, g_image_writer)


if __name__ == "__main__":
	main()