Raschietto di gioco per Steam
Ho creato uno scraper per Steam che ottiene diverse informazioni su un gioco Steam, come il prezzo, le specifiche e le piattaforme supportate. Il motivo per cui l'ho fatto è perché ho un laptop super lento, quindi guardare molti giochi richiederebbe molto tempo :)
Alcune cose che vorrei migliorare sono una migliore gestione degli errori, poiché il Web è un posto disordinato e non tutte le pagine saranno uguali.
Un'altra cosa che stavo pensando di fare è avere una migliore gestione dei dati, come utilizzare classi e oggetti per ogni gioco invece di memorizzare tutti i valori in un dizionario, che renderebbe il codice più semplice e forse anche più breve.
from selenium import webdriver
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support.ui import Select
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.common.exceptions import NoSuchElementException
from selenium.webdriver.firefox.options import Options
from sys import exit
games = {}
x = 0
# ask for games
while True:
if x == 0:
game = input('Type the game you want to find here: ')
else:
game = input('Type the game you want to find here (or enter nothing to continue): ')
if not game:
break
games[game] = {}
x += 1
# configure browser
print('Starting Browser')
firefox_options = Options()
firefox_options.headless = True
browser = webdriver.Firefox(options=firefox_options, service_log_path='/tmp/geckodriver.log')
print('Retrieving website')
browser.get('https://store.steampowered.com/')
for a_game in games:
print('Finding info for "' + a_game + '"')
# input & click
print('Waiting for page to load')
WebDriverWait(browser, 20).until(EC.element_to_be_clickable((By.CSS_SELECTOR, "input#store_nav_search_term"))).send_keys(a_game)
WebDriverWait(browser, 20).until(EC.element_to_be_clickable((By.CSS_SELECTOR, "div#search_suggestion_contents>a"))).click()
print('Navigating to game page')
# if age-restricted:
try:
browser.find_element_by_css_selector('.agegate_birthday_selector')
age_query = input('"' + a_game + '" is age-restricted, do you want to continue? y/n ')
if age_query != 'y':
print('Abort')
exit()
select = Select(browser.find_element_by_id('ageYear'))
select.select_by_value('2000')
browser.find_element_by_css_selector('a.btnv6_blue_hoverfade:nth-child(1)').click()
except NoSuchElementException:
pass
print('Waiting for game page to load')
# name of game
games[a_game]['name'] = WebDriverWait(browser, 20).until(EC.element_to_be_clickable((By.CSS_SELECTOR, '.apphub_AppName'))).text
# supported platforms
print('Retrieving supported platforms')
mac = False
linux = False
try:
browser.find_element_by_css_selector('div.game_area_purchase_game_wrapper:nth-child(1) > div:nth-child(1) > div:nth-child(2) > '
'span:nth-child(2)')
mac = True
except NoSuchElementException:
pass
try:
browser.find_element_by_css_selector('div.game_area_purchase_game_wrapper:nth-child(1) > div:nth-child(1) > div:nth-child(2) > '
'span:nth-child(3)')
linux = True
except NoSuchElementException:
pass
if mac and linux:
games[a_game]['platform'] = 'all'
elif mac:
games[a_game]['platform'] = 'mac'
elif linux:
games[a_game]['platform'] = 'linux'
else:
games[a_game]['platform'] = 'windows'
# price
print('Retrieving price')
discounted = False
try:
games[a_game]['price'] = browser.find_element_by_css_selector('div.game_purchase_action:nth-child(4) > div:nth-child(1) > div:nth-child(1)').text
except NoSuchElementException:
try:
games[a_game]['before_price'] = browser.find_element_by_class_name('discount_original_price').text
games[a_game]['after_price'] = browser.find_element_by_class_name('discount_final_price').text
except NoSuchElementException:
try:
games[a_game]['price'] = 'FREE'
except NoSuchElementException:
games[a_game]['bundle_price'] = browser.find_element_by_css_selector('div.game_purchase_action_bg:nth-child(2) > div:nth-child(1)')
except Exception:
games[a_game]['price'] = 'Error: Unable to get price'
# system requirements
print('Retrieving system requirements')
games[a_game]['specs'] = browser.find_element_by_css_selector('.game_area_sys_req').text
# close browser
print('Finished Retrieving data, closing browser \n')
print('********************************************')
browser.close()
for each_game in games.keys():
print('GAME: ' + games[each_game]['name'].upper())
# printing supported platforms
if games[each_game]['platform'] == 'all':
print('Supported Platforms: Windows, Mac and Linux')
elif games[each_game]['platform'] == 'mac':
print('Supported Platforms: Windows and Mac')
elif games[each_game]['platform'] == 'linux':
print('Supported Platforms: Windows and Linux')
else:
print('Supported Platforms: Windows Only')
print('\n')
# printing price
try:
print('Price: Discounted ' + games[each_game]['after_price'] + ' from ' + games[each_game]['before_price'])
except KeyError:
print('Price: ' + games[each_game]['price'])
except Exception:
print('Bundled Price: ' + games[each_game]['bundle_price'])
print('\n')
# printing system requirements
print('System Requirements: \n')
print('-------------------------------- \n')
print(games[each_game]['specs'])
print('--------------------------------')
input('Press enter to continue ')
print('Finished Successfully')
Risposte
Suddividi la logica in funzioni
Avere funzioni separate per ciascuno dei seguenti passaggi renderà il codice più facile da leggere.
- Ottieni i nomi dei giochi
- Raschiare informazioni sul gioco
- Visualizza le informazioni sul gioco
Proteggi il punto di ingresso del tuo script
Consiglierei di spostare il flusso di esecuzione dello script sotto controllo if __name__ == "__main__":
. In questo modo è possibile importare le funzioni da questo file in altri file senza eseguire lo script.
Evitare l'uso sys.exit()
per il flusso di controllo
La chiamata sys.exit()
arresta l'interprete Python, il che rende difficile testare qualsiasi codice che lo chiama. Dovresti invece eseguire il refactoring dello script in modo che termini normalmente per tutti i casi recuperabili.
Ad esempio, se l'utente non desidera informazioni per un gioco soggetto a limiti di età, saltalo e passa al gioco successivo nell'elenco. Penso che questo renderebbe comunque un'esperienza utente migliore, perché se non exit()
riusciamo a elaborare gli altri giochi rimanenti nell'elenco.
Le piattaforme supportate dovrebbero essere un elenco
Nel determinare e stampare le piattaforme supportate per un gioco, hai valori booleani mac
che linux
alla fine vengono tradotti in una stringa che prende uno tra all
, mac
, linux
, windows
:
if mac and linux:
games[a_game]['platform'] = 'all' # windows, mac, linux
elif mac:
games[a_game]['platform'] = 'mac' # windows, mac
elif linux:
games[a_game]['platform'] = 'linux' # windows, linux
else:
games[a_game]['platform'] = 'windows' # windows
Penso che abbia più senso modellarlo come un elenco, ad esempio, ["windows", "mac"]
quindi è più esplicito quali piattaforme sono supportate. Questo ti eviterà anche di scrivere ulteriore logica if/elif/else quando li stampi.
Flat è meglio di nidificato
I blocchi try/except nidificati nella fase di recupero del prezzo sono molto difficili da leggere.
Se deleghi il recupero del prezzo a una funzione, puoi strutturare la logica in modo che sia piatta anziché nidificata, come nel seguente pseudocodice:
def get_price() -> str:
element = find_element_for_bundle_price()
if element:
return element.text
element = find_element_for_non_discounted_price()
if element:
return element.text
element = find_element_for_discounted_price()
if element:
return element.text
# If we don't find a price on the page, it's free?
# Actually this is not always true, but for this example
# we'll assume this is the case.
return 'FREE'
Uso improprio della gestione delle eccezioni
Lo script è accattivante KeyError
e Exception
gestisce la stampa di tre diversi tipi di prezzi: pacchetto, scontato e standard. Questo è probabilmente un uso improprio della gestione delle eccezioni, soprattutto perché catturare il generale Exception
è raramente una buona idea perché può nascondere altri errori che non ti aspettavi. Inoltre non è necessario qui; possiamo semplicemente usare un if/elif/else:
game_dict = games[each_game]
if 'bundle_price' in game_dict:
# print bundle price
elif 'before_price' in game_dict and 'after_price' in game_dict:
# print discounted price
else:
# print standard price
Gestione dati
Hai detto che stavi pensando di avere classi o oggetti per ogni gioco invece di usare un dizionario. Penso che questa sia una buona idea. Potrebbe non accorciare il codice, ma migliorerebbe sicuramente la leggibilità del codice.
Un buon candidato per questo sarebbe un semplice contenitore di dati come typing.NamedTuple. Come suggerito da @MaartenFabré nei commenti, dataclasses.dataclassè un'altra buona scelta per un contenitore di dati come questo.
Casi limite non gestiti
Le seguenti query di ricerca comporteranno il timeout dello script:
Qualsiasi query di ricerca che non restituisce suggerimenti su Steam. Questo potrebbe essere qualcosa come un gioco che non esiste (ancora), ad esempio
"funkytown"
, o una stringa non vuota composta solo da spazi bianchi, ad esempio" "
.Qualsiasi query di ricerca in cui il primo suggerimento è un pacchetto Steam, ad es
"the witcher 3 wild hunt game of the year"
.Qualsiasi query di ricerca in cui il primo suggerimento è un pacchetto Steam, ad es
"monkey island collection"
.
Ne ho parlato prima, ma lo script presuppone erroneamente che se un prezzo non viene visualizzato sulla pagina, il gioco è gratuito. Ma ci sono giochi inediti su Steam per i quali lo sviluppatore non ha fissato un prezzo, e allo stesso tempo non lo ha classificato come "gratuito" o come gioco "free-to-play" ("Spirit of Glace" è uno esempio concreto che ho trovato). Il prezzo da visualizzare in questo caso dovrebbe essere qualcosa come "TBD" o "Unknown".
Fortunatamente, e come modo per introdurre la prossima sezione, c'è un'API che possiamo usare per distinguere tra libero e non libero. Questa API espone un is_free
campo che indica true
quando un gioco è gratuito o free-to-play. Se salti alla fine di questa recensione puoi vedere come viene recuperato nel mio script di esempio.
Preferisci le API allo scraping
Con le API, il recupero dei dati è più veloce e spesso ordini di grandezza più veloce rispetto allo scraping con Selenium. Con le API, l'estrazione dei dati è più semplice poiché il formato della risposta è spesso JSON.
Tengo sempre a menzionarlo ogni volta che si presenta lo scraping perché il potenziale risparmio di tempo e fatica può essere enorme. Dedica un po' di tempo alla ricerca di un'API ufficiale o di un'API non ufficiale documentata. Se non viene fuori nulla, dai un'occhiata a un ispettore del traffico HTTP/S come Fiddler o Chrome DevTools e vedi se riesci a trovare API non ufficiali promettenti. Se alla fine non riesci a trovare nulla, torna a raschiare come ultima risorsa.
In questo caso, in realtà è disponibile un'API Steam Store non ufficiale . Per usarlo abbiamo bisogno dell'ID dell'app di Steam o dell'ID del pacchetto di Steam dell'articolo che ci interessa, ma possiamo ottenerlo dall'API che alimenta il menu a discesa dei suggerimenti di ricerca, https://store.steampowered.com/search/suggest
.
Script di esempio che utilizza l'API
Quello che segue è uno script di esempio che utilizza l'API non ufficiale di Steam Store.
#!/usr/bin/env python3
import re
import json
import requests
from enum import Enum
from bs4 import BeautifulSoup # type: ignore
from typing import Any, Dict, List, Optional, NamedTuple, Union
SEARCH_SUGGEST_API = "https://store.steampowered.com/search/suggest"
APP_DETAILS_API = "https://store.steampowered.com/api/appdetails"
PACKAGE_DETAILS_API = "https://store.steampowered.com/api/packagedetails"
class Platform(Enum):
WINDOWS = "windows"
MAC = "mac"
LINUX = "linux"
def __str__(self) -> str:
return str(self.value)
class Price(NamedTuple):
initial: int # price in cents
final: int # price in cents
class SteamGame(NamedTuple):
app_id: int
name: str
platforms: List[Platform]
is_released: bool
is_free: bool
price: Optional[Price]
pc_requirements: str
def __str__(self) -> str:
if self.is_free:
price = "Free"
elif self.price:
final = f"${self.price.final / 100}"
if self.price.initial == self.price.final:
price = final
else:
price = f"{final} (previously ${self.price.initial / 100})"
else:
price = "TBD"
platforms = ", ".join(str(p) for p in self.platforms)
is_released = "Yes" if self.is_released else "No"
return "\n".join(
(
f"Name: {self.name}",
f"Released: {is_released}",
f"Supported Platforms: {platforms}",
f"Price: {price}",
"",
"PC Requirements:",
self.pc_requirements,
)
)
class SteamBundle(NamedTuple):
bundle_id: int
name: str
price: Price
application_names: List[str]
def __str__(self) -> str:
final = f"${self.price.final / 100}"
if self.price.initial == self.price.final:
price = final
else:
price = f"{final} (without bundle: ${self.price.initial / 100})"
return "\n".join(
(
f"Name: {self.name}",
f"Price: {price}",
"",
"Items included in this bundle:",
*(f" - {name}" for name in self.application_names),
)
)
class SteamPackage(NamedTuple):
package_id: int
name: str
platforms: List[Platform]
is_released: bool
price: Optional[Price]
application_names: List[str]
def __str__(self) -> str:
if self.price:
final = f"${self.price.final / 100}"
if self.price.initial == self.price.final:
price = final
else:
initial = f"${self.price.initial / 100}"
price = f"{final} (without package: {initial})"
else:
price = "TBD"
platforms = ", ".join(str(p) for p in self.platforms)
is_released = "Yes" if self.is_released else "No"
return "\n".join(
(
f"Name: {self.name}",
f"Released: {is_released}",
f"Supported Platforms: {platforms}",
f"Price: {price}",
"",
"Items included in this package:",
*(f" - {name}" for name in self.application_names),
)
)
SteamItem = Union[SteamGame, SteamBundle, SteamPackage]
def deserialize_bundle_data(encoded_bundle_json: str) -> Any:
return json.loads(re.sub(r""", '"', encoded_bundle_json))
def extract_app_ids(bundle_data: Dict[str, Any]) -> List[int]:
return [
app_id
for item in bundle_data["m_rgItems"]
for app_id in item["m_rgIncludedAppIDs"]
]
def lookup_app_names(
session: requests.Session, app_ids: List[int]
) -> List[str]:
app_names = []
for app_id in app_ids:
params = {"appids": app_id, "filters": "basic"}
response = session.get(APP_DETAILS_API, params=params)
response.raise_for_status()
app_names.append(response.json()[str(app_id)]["data"]["name"])
return app_names
def extract_bundle_price(bundle_data: Dict[str, Any]) -> Price:
total_price = sum(
item["m_nFinalPriceInCents"] for item in bundle_data["m_rgItems"]
)
total_price_with_bundle_discount = sum(
item["m_nFinalPriceWithBundleDiscount"]
for item in bundle_data["m_rgItems"]
)
return Price(total_price, total_price_with_bundle_discount)
def extract_package_information(
package_id: int, package_data: Dict[str, Any]
) -> SteamPackage:
return SteamPackage(
package_id=package_id,
name=package_data["name"],
platforms=[p for p in Platform if package_data["platforms"][str(p)]],
is_released=not package_data["release_date"]["coming_soon"],
price=Price(
package_data["price"]["initial"], package_data["price"]["final"]
),
application_names=[app["name"] for app in package_data["apps"]],
)
def get_package(session: requests.Session, package_id: str) -> SteamPackage:
params = {"packageids": package_id}
response = session.get(PACKAGE_DETAILS_API, params=params)
response.raise_for_status()
return extract_package_information(
int(package_id), response.json()[package_id]["data"]
)
def extract_requirements_text(requirements_html: str) -> str:
soup = BeautifulSoup(requirements_html, "html.parser")
return "\n".join(tag.get_text() for tag in soup.find_all("li"))
def extract_game_information(game_data: Dict[str, Any]) -> SteamGame:
price_overview = game_data.get("price_overview")
price = (
Price(price_overview["initial"], price_overview["final"])
if price_overview
else None
)
requirements = game_data["pc_requirements"]
minimum = extract_requirements_text(requirements["minimum"])
recommended_html = requirements.get("recommended")
recommended = (
extract_requirements_text(recommended_html)
if recommended_html
else None
)
minimum_requirements = f"[Minimum]\n{minimum}"
if recommended:
recommended_requirements = f"[Recommended]\n{recommended}"
pc_requirements = (
minimum_requirements + "\n\n" + recommended_requirements
)
else:
pc_requirements = minimum_requirements
return SteamGame(
app_id=game_data["steam_appid"],
name=game_data["name"],
platforms=[p for p in Platform if game_data["platforms"][str(p)]],
is_released=not game_data["release_date"]["coming_soon"],
is_free=game_data["is_free"],
price=price,
pc_requirements=pc_requirements,
)
def get_game(session: requests.Session, app_id: str) -> SteamGame:
params = {"appids": app_id}
response = session.get(APP_DETAILS_API, params=params)
response.raise_for_status()
return extract_game_information(response.json()[app_id]["data"])
def get_game_information(games: List[str]) -> Dict[str, Optional[SteamItem]]:
game_to_info = {}
with requests.Session() as session:
for game in games:
params = {"term": game, "f": "games", "cc": "US", "l": "english"}
response = session.get(SEARCH_SUGGEST_API, params=params)
response.raise_for_status()
# get first search suggestion
result = BeautifulSoup(response.text, "html.parser").find("a")
if result:
bundle_id = result.get("data-ds-bundleid")
package_id = result.get("data-ds-packageid")
app_id = result.get("data-ds-appid")
if bundle_id:
name = result.find("div", class_="match_name").get_text()
bundle_data = deserialize_bundle_data(
result["data-ds-bundle-data"]
)
app_ids = extract_app_ids(bundle_data)
app_names = lookup_app_names(session, app_ids)
price = extract_bundle_price(bundle_data)
info: Optional[SteamItem] = SteamBundle(
bundle_id=int(bundle_id),
name=name,
price=price,
application_names=app_names,
)
elif package_id:
info = get_package(session, package_id)
elif app_id:
info = get_game(session, app_id)
else:
info = None
else:
info = None
game_to_info[game] = info
return game_to_info
def display_game_information(
game_information: Dict[str, Optional[SteamItem]]
) -> None:
arrow = " =>"
for game_query, game_info in game_information.items():
result_header = f"{game_query}{arrow}"
query_result = (
game_info if game_info else f"No results found for {game_query!r}."
)
result = "\n".join(
(
result_header,
"-" * (len(result_header) - len(arrow)),
"",
str(query_result),
"\n",
)
)
print(result)
if __name__ == "__main__":
games = [
"slay the spire",
"civ 6",
"funkytown",
"path of exile",
"bless unleashed",
"the witcher 3 wild hunt game of the year",
"divinity source",
"monkey island collection",
"star wars squadrons",
"spirit of glace",
]
game_info = get_game_information(games)
display_game_information(game_info)