Repository: AB1908/GOG-Galaxy-Export-Script
Branch: master
Commit: 9d13805bbfb0
Files: 6
Total size: 30.8 KB
Directory structure:
gitextract_v_956o0z/
├── .gitignore
├── LICENSE
├── galaxy_library_export.py
├── helper_scripts/
│ └── print_gameDB.py
├── readme.md
└── settings.json
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
gameDB.csv
helper_scripts/my_games.txt
.idea/
================================================
FILE: LICENSE
================================================
MIT License
Copyright (c) 2020 AB1908
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: galaxy_library_export.py
================================================
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import csv
import json
import re
import sqlite3
import time
from enum import Enum
from os.path import exists
from sys import platform
from natsort import natsorted
class Arguments():
""" argparse wrapper, to reduce code verbosity """
__parser = None
__args = None
__bAll = False # Extract all fields
def __init__(self, args, **kwargs):
import argparse
self.__parser = argparse.ArgumentParser(**kwargs)
for arg in args:
self.__parser.add_argument(*arg[0], **arg[1])
self.__args = self.__parser.parse_args()
self.__bAll = getattr(self.__args, 'all')
def help(self):
self.__parser.print_help()
def anyOption(self, exceptions):
self.notExportOptions = exceptions
for k,v in self.__args.__dict__.items():
if (k not in exceptions) and v:
return True
return False
def extractAll(self):
self.__bAll = True
def __getitem__(self, name):
return self.__getattr__(name)
def __getattr__(self, name):
ret = getattr(self.__args, name)
if isinstance(ret, bool) and (name not in self.notExportOptions):
ret = self.__bAll or ret
elif isinstance(ret, list) and (1 == len(ret)):
ret = ret[0]
return ret
class Type(Enum):
""" used to specify the field type while parsing the raw data """
STRING = 0
STRING_JSON = 1
INTEGER = 10
DATE = 20
LIST = 30
class Positions(dict):
""" small dictionary to avoid errors while parsing non-exported field positions """
def __getitem__(self, key):
try:
return dict.__getitem__(self, key)
except KeyError:
return None
def extractData(args):
database_location = args.fileDB
platforms = {"3do": "3DO Interactive Multiplayer", "3ds": "Nintendo 3DS", "aion": "Aion", "aionl": "Aion: Legions of War", "amazon": "Amazon", "amiga": "Amiga", "arc": "ARC", "atari": "Atari 2600", "battlenet": "Battle.net", "bb": "BestBuy", "beamdog": "Beamdog", "bethesda": "Bethesda.net", "blade": "Blade & Soul", "c64": "Commodore 64", "d2d": "Direct2Drive", "dc": "Dreamcast", "discord": "Discord", "dotemu": "DotEmu", "egg": "Newegg", "elites": "Elite Dangerous", "epic": "Epic Games Store", "eso": "The Elder Scrolls Online", "fanatical": "Fanatical", "ffxi": "Final Fantasy XI", "ffxiv": "Final Fantasy XIV", "fxstore": "Placeholder", "gamehouse": "GameHouse", "gamesessions": "GameSessions", "gameuk": "GAME UK", "generic": "Other", "gg": "GamersGate", "glyph": "Trion World", "gmg": "Green Man Gaming", "gog": "GOG", "gw": "Guild Wars", "gw2": "Guild Wars 2", "humble": "Humble Bundle", "indiegala": "IndieGala", "itch": "Itch.io", "jaguar": "Atari Jaguar", "kartridge": "Kartridge", "lin2": "Lineage 2", "minecraft": "Minecraft", "n64": "Nintendo 64", "ncube": "Nintendo GameCube", "nds": "Nintendo DS", "neo": "NeoGeo", "nes": "Nintendo Entertainment System", "ngameboy": "Game Boy", "nswitch": "Nintendo Switch", "nuuvem": "Nuuvem", "nwii": "Wii", "nwiiu": "Wii U", "oculus": "Oculus", "origin": "Origin", "paradox": "Paradox Plaza", "pathofexile": "Path of Exile", "pce": "PC Engine", "playasia": "Play-Asia", "playfire": "Playfire", "ps2": "PlayStation 2", "psn": "PlayStation Network", "psp": "PlayStation Portable", "psvita": "PlayStation Vita", "psx": "PlayStation", "riot": "Riot", "rockstar": "Rockstar Games Launcher", "saturn": "Sega Saturn", "sega32": "32X", "segacd": "Sega CD", "segag": "Sega Genesis", "sms": "Sega Master System", "snes": "Super Nintendo Entertainment System", "stadia": "Google Stadia", "star": "Star Citizen", "steam": "Steam", "test": "Test", "totalwar": "Total War", "twitch": "Twitch", "unknown": "Unknown", "uplay": "Uplay", "vision": "ColecoVision", "wargaming": "Wargaming", "weplay": "WePlay", "winstore": "Windows Store", "xboxog": "Xbox", "xboxone": "Xbox Live", "zx": "ZX Spectrum PC"}
def loadOptions():
""" Loads options from `settings.json` and initialises defaults """
defaults = {"TreatDLCAsGame": [], "TreatReleaseAsDLC": {}}
# Load settings from disk
try:
with open('settings.json', 'r', encoding='utf-8') as f:
o = json.load(f)
except:
o = {}
# Initialise defaults
for k, v in defaults.items():
if k not in o:
o[k] = v
return o
def id(name):
""" Returns the numeric ID for the specified type """
return cursor.execute('SELECT id FROM GamePieceTypes WHERE type="{}"'.format(name)).fetchone()[0]
def clean(s):
""" Cleans strings for CSV consumption """
for f in clean.filters:
s = f.sub('\\\\n', s) # Convert CRLF, LF,
into '\n' string
return s
clean.filters = [
re.compile(r'\s*?(?:\r?\n|)')
]
def jld(name, bReturnParsed=False, object=None):
""" json.loads(`name`), optionally returning the purified sub-object of the same name,
for cases such as {`name`: {`name`: "string"}}
"""
v = json.loads((object if object else result)[positions[name]])
if not bReturnParsed:
return v
v = v[name]
return clean(v) if isinstance(v, str) else v
def prepare(resultName, fields, dbField=None, dbRef=None, dbCondition=None, dbCustomJoin=None, dbResultField=None, dbGroupBy=None):
""" Wrapper around the statement preparation and result parsing\n
`resultName` cli argument variable name\n
`fields` {`title` to be inserted in the CSV: `boolean condition`, …}\n
SELECT `dbField` FROM `dbRef` WHERE `dbCondition`\n
SELECT `dbResultField` FROM MasterDB GROUP BY `dbGroupBy`
"""
# CSV field names
for name,condition in fields.items():
if condition:
fieldnames.append(name)
if dbField:
og_fields.append(', {}'.format(dbField))
# Position of the results
positions[resultName] = prepare.nextPos
prepare.nextPos += 1
if dbRef:
og_references.append(', {}'.format(dbRef))
if dbCondition:
og_conditions.append(' AND ({})'.format(dbCondition))
if dbCustomJoin:
og_joins.append(' ' + dbCustomJoin)
if dbResultField:
og_resultFields.append(dbResultField)
if dbGroupBy:
og_resultGroupBy.append(dbGroupBy)
def includeField(object, columnName, fieldName=None, fieldType=Type.STRING, paramName=None, delimiter=','):
if args[columnName if not paramName else paramName]:
if None is fieldName:
fieldName = columnName
try:
if Type.INTEGER is fieldType:
row[columnName] = round(object[fieldName])
elif Type.DATE is fieldType:
row[columnName] = time.strftime("%Y-%m-%d", time.localtime(object[fieldName]))
elif Type.STRING is fieldType:
row[columnName] = object[fieldName]
elif Type.STRING_JSON is fieldType:
row[columnName] = jld(fieldName, True)
elif Type.LIST is fieldType:
s = object[fieldName].split(delimiter)
row[columnName] = set(s) if 1 < len(s) else objectFieldName
except:
row[columnName] = object[fieldName]
from contextlib import contextmanager
@contextmanager
def OpenDB():
# Prepare the DB connection
_connection = sqlite3.connect(database_location)
_cursor = _connection.cursor()
_exception = None
try:
yield _cursor
except Exception as e:
_exception = e
# Close the DB connection
_cursor.close()
_connection.close()
# Re-raise the unhandled exception if needed
if _exception:
raise _exception
# Load options before opening the DB
options = loadOptions()
with OpenDB() as cursor:
# Create a view of ProductPurchaseDates (= purchased/added games) joined on GamePieces for a full owned game data DB
owned_game_database = """CREATE TEMP VIEW MasterList AS
SELECT GamePieces.releaseKey, GamePieces.gamePieceTypeId, GamePieces.value FROM ProductPurchaseDates
JOIN GamePieces ON ProductPurchaseDates.gameReleaseKey = GamePieces.releaseKey;"""
# Set up default queries and processing metadata, and always extract the game title along with any parameters
prepare.nextPos = 2
positions = Positions({'releaseKey': 0, 'title': 1})
fieldnames = ['title']
og_fields = ["""CREATE TEMP VIEW MasterDB AS SELECT DISTINCT(MasterList.releaseKey) AS releaseKey, MasterList.value AS title, PLATFORMS.value AS platformList"""]
og_references = [""" FROM MasterList, MasterList AS PLATFORMS"""]
og_joins = []
og_conditions = [""" WHERE MasterList.gamePieceTypeId={} AND PLATFORMS.releaseKey=MasterList.releaseKey AND PLATFORMS.gamePieceTypeId={}""".format(
id('title'),
id('allGameReleases')
)]
og_order = """ ORDER BY title;"""
og_resultFields = ['GROUP_CONCAT(DISTINCT MasterDB.releaseKey)', 'MasterDB.title']
og_resultGroupBy = ['MasterDB.platformList']
# title can be customized by user, allow extraction of original title
if args.originalTitle:
prepare(
'originalTitle',
{'originalTitle': True},
dbField='ORIGINALTITLE.value AS originalTitle',
dbRef='MasterList AS ORIGINALTITLE',
dbCondition='ORIGINALTITLE.releaseKey=MasterList.releaseKey AND ORIGINALTITLE.gamePieceTypeId={}'.format(id('originalTitle')),
dbResultField='MasterDB.originalTitle'
)
# (User customised) sorting title, same export data sorting as in the Galaxy client
prepare(
'sortingTitle',
{'sortingTitle': args.sortingTitle},
dbField='SORTINGTITLE.value AS sortingTitle',
dbRef='MasterList AS SORTINGTITLE',
dbCondition='(SORTINGTITLE.releaseKey=MasterList.releaseKey) AND (SORTINGTITLE.gamePieceTypeId={})'.format(id('sortingTitle')),
dbResultField='MasterDB.sortingTitle'
)
# Create parameterised filtered view of owned games using multiple joins: the order
# in which we `prepare` them, is the same as they will appear as CSV columns
if args.summary:
prepare(
'summary',
{'summary': True},
dbField='SUMMARY.value AS summary',
dbRef='MasterList AS SUMMARY',
dbCondition='(SUMMARY.releaseKey=MasterList.releaseKey) AND (SUMMARY.gamePieceTypeId={})'.format(id('summary')),
dbResultField='MasterDB.summary'
)
if args.platforms:
prepare(
'platforms',
{'platformList': True},
)
if args.myRating:
prepare(
'myRating',
{'myRating': True},
dbField='MYRATING.value AS myRating',
dbRef='MasterList AS MYRATING',
dbCondition='(MYRATING.releaseKey=MasterList.releaseKey) AND (MYRATING.gamePieceTypeId={})'.format(id('myRating')),
dbResultField='MasterDB.myRating'
)
# add filednames of metadata and orginalMetadata
# this allows to order them in a way that metadata values are followed by their related originalMetadata value in the export
for name,condition in {
'criticsScore': args.criticsScore,
'developers': args.developers,
'genres': args.genres,
'publishers': args.publishers,
'releaseDate': args.releaseDate,
'originalReleaseDate': args.originalReleaseDate,
'themes': args.themes,
}.items():
if condition:
fieldnames.append(name)
if args.criticsScore or args.developers or args.genres or args.publishers or args.releaseDate or args.themes:
prepare(
'metadata',
{}, # fieldnames are added separateley together with their related originalMetadata fields
dbField='METADATA.value AS metadata',
dbRef='MasterList AS METADATA',
dbCondition='METADATA.releaseKey=MasterList.releaseKey AND METADATA.gamePieceTypeId={}'.format(id('meta')),
dbResultField='MasterDB.metadata'
)
if args.originalReleaseDate:
prepare(
'originalMetadata',
{}, # fieldnames are added separateley together with their related metadata fields
dbField='ORIGINALMETADATA.value AS originalMetadata',
dbRef='MasterList AS ORIGINALMETADATA',
dbCondition='ORIGINALMETADATA.releaseKey=MasterList.releaseKey AND ORIGINALMETADATA.gamePieceTypeId={}'.format(id('originalMeta')),
dbResultField='MasterDB.originalMetadata'
)
if args.playtime:
prepare(
'playtime',
{'gameMins': True},
dbField='GAMETIMES.minutesInGame AS time',
dbRef='GAMETIMES',
dbCondition='GAMETIMES.releaseKey=MasterList.releaseKey',
dbResultField='sum(MasterDB.time)'
)
if args.lastPlayed:
prepare(
'lastPlayed',
{'lastPlayed': True},
dbField='LASTPLAYEDDATES.lastPlayedDate as lastPlayed',
dbCustomJoin='LEFT JOIN LASTPLAYEDDATES ON LASTPLAYEDDATES.gameReleaseKey=MasterList.releaseKey',
dbResultField='MasterDB.lastPlayed'
)
if args.tags:
prepare(
'tags',
{'tags': True},
dbField='USERRELEASETAGS.tag AS tags',
dbCustomJoin='LEFT JOIN USERRELEASETAGS ON USERRELEASETAGS.releaseKey=MasterList.releaseKey',
dbResultField='GROUP_CONCAT(MasterDB.tags)'
)
prepare( # Grab a list of DLCs for filtering, regardless of whether we're exporting them or not
'dlcs',
{'dlcs': args.dlcs},
# concatenate all dlcs of the game in one list to make sure all dlcs from the different platforms are found
dbField="""DLC.value AS dlcs,
CASE
WHEN DLC.value IS NULL OR DLC.value IN ('{"dlcs":null}', '{"dlcs":[]}')
THEN NULL
ELSE REPLACE(REPLACE(DLC.value, '{"dlcs":[', ''), ']}', '')
END AS dlcList""",
dbRef='MasterList AS DLC',
dbCondition='(DLC.releaseKey=MasterList.releaseKey) AND (DLC.gamePieceTypeId={})'.format(id('dlcs')),
dbResultField="""'{"dlcs":[' || COALESCE(GROUP_CONCAT(MasterDB.dlcList), '') || ']}'"""
)
if args.isHidden:
prepare(
'isHidden',
{'isHidden': True},
dbField='UserReleaseProperties.isHidden AS isHidden',
dbCustomJoin='LEFT JOIN USERRELEASEPROPERTIES ON USERRELEASEPROPERTIES.releaseKey=MasterList.releaseKey',
dbResultField='CASE WHEN MasterDB.isHidden = 1 THEN \'True\' ELSE \'False\' END'
)
if args.osCompatibility:
prepare(
'osCompatibility',
{'osCompatibility': True},
# concatenate lists of operating systems because different platforms can support different systems
dbField="""OSCOMPATIBILITY.value AS osCompatibility,
CASE
WHEN OSCOMPATIBILITY.value IS NULL OR OSCOMPATIBILITY.value IN ('{"supported":[]}', '{"supported":null}')
THEN NULL
ELSE REPLACE(REPLACE(OSCOMPATIBILITY.value, '{"supported":[', ''), ']}', '')
END AS osList""",
dbRef='MasterList AS OSCOMPATIBILITY',
dbCondition='OSCOMPATIBILITY.releaseKey=MasterList.releaseKey AND OSCOMPATIBILITY.gamePieceTypeId={}'.format(id('osCompatibility')),
dbResultField="""'{"supported":[' || COALESCE(GROUP_CONCAT(MasterDB.osList), '') || ']}'"""
)
if args.imageBackground or args.imageSquare or args.imageVertical:
prepare(
'images',
{
'backgroundImage': args.imageBackground,
'squareIcon': args.imageSquare,
'verticalCover': args.imageVertical
},
dbField='IMAGES.value AS images',
dbRef='MasterList AS IMAGES',
dbCondition='(IMAGES.releaseKey=MasterList.releaseKey) AND (IMAGES.gamePieceTypeId={})'.format(id('originalImages')),
dbResultField='MasterDB.images'
)
# Display each game and its details along with corresponding release key grouped by releasesList
unique_game_data = """SELECT {} FROM MasterDB GROUP BY {} ORDER BY MasterDB.title;""".format(
', '.join(og_resultFields),
', '.join(og_resultGroupBy)
)
# Perform the queries
cursor.execute(owned_game_database)
cursor.execute(''.join(og_fields + og_references + og_joins + og_conditions) + og_order)
cursor.execute(unique_game_data)
# Prepare a list of games and DLCs
results = []
dlcs = set()
while True:
result = cursor.fetchone()
if not result: break
results.append((result[0].split(','), result))
d = jld('dlcs', True)
if d:
for dlc in d:
dlcs.add(dlc)
results = natsorted(results, key=lambda r: str.casefold(str(json.loads(r[1][positions['sortingTitle']])['title'])))
# Exclude games mistakenly treated as DLCs, such as "3 out of 10, EP2"
for dlc in options['TreatDLCAsGame']:
dlcs.discard(dlc)
# Add dlcs mistakenly treated as games, such as "Grey Goo - Emergence Campaign"
additionalDLCs = options['TreatReleaseAsDLC']
for game in additionalDLCs.keys():
dlcs.update(additionalDLCs[game])
# There are spurious random dlcNUMBERa entries in the library, plus a few DLCs which appear
# multiple times in different ways and are not attached to a game
titleExclusion = re.compile(r'^(?:'
r'dlc_?[0-9]+_?a'
r'|alternative look for yennefer(?:\s+\[[a-z]+\])?'
r'|beard and hairstyle set for geralt(?:\s+\[[a-z]+\])?'
r'|new quest - contract: missing miners(?:\s+\[[a-z]+\])?'
r'|temerian armor set(?:\s+\[[a-z]+\])?'
r')$')
# Compile the CSV
try:
with open(args.fileCSV, 'w', encoding='utf-8', newline='') as csvfile:
writer = csv.DictWriter(csvfile, fieldnames=fieldnames, delimiter=args.delimiter)
writer.writeheader()
for (ids, result) in results:
# Only consider games for the list, not DLCs
if not args.exportDlcDetails and 0 < len([x for x in ids if x in dlcs]):
continue
try:
# JSON string needs to be converted to dict
# For json.load() to work correctly, all double quotes must be correctly escaped
try:
row = {'title': jld('title', True)}
if (not row['title']) or (titleExclusion.match(str.casefold(row['title']))):
continue
except:
# No title or {'title': null}
continue
# SortingTitle
if args.sortingTitle:
try:
sortingTitle = jld('sortingTitle')
row['sortingTitle'] = sortingTitle['title']
except:
row['sortingTitle'] = ''
# OriginalTitle
if args.originalTitle:
try:
originalTitle = jld('originalTitle')
row['originalTitle'] = originalTitle['title']
except:
row['originalTitle'] = ''
# Playtime
includeField(result, 'gameMins', positions['playtime'], paramName='playtime')
# LastPlayed
includeField(result, 'lastPlayed', positions['lastPlayed'])
# Summaries
includeField(result, 'summary', fieldType=Type.STRING_JSON)
# Platforms
if args.platforms:
rkeys = result[positions['releaseKey']].split(',')
if any(platform in releaseKey for platform in platforms for releaseKey in rkeys):
row['platformList'] = set(platforms[platform] for releaseKey in rkeys for platform in platforms if releaseKey.startswith(platform))
else:
row['platformList'] = []
# User rating
includeField(result, 'myRating', fieldType=Type.STRING_JSON)
# Various metadata
if args.criticsScore or args.developers or args.genres or args.publishers or args.releaseDate or args.themes:
metadata = jld('metadata')
includeField(metadata, 'criticsScore', fieldType=Type.INTEGER)
includeField(metadata, 'developers')
includeField(metadata, 'genres')
includeField(metadata, 'publishers')
includeField(metadata, 'releaseDate', fieldType=Type.DATE)
includeField(metadata, 'themes')
# Original metadata
if args.originalReleaseDate:
originalMetadata = jld('originalMetadata')
includeField(originalMetadata, 'originalReleaseDate', 'releaseDate', fieldType=Type.DATE)
# Original images
if args.imageBackground or args.imageSquare or args.imageVertical:
images = jld('images')
includeField(images, 'backgroundImage', 'background', paramName='imageBackground')
includeField(images, 'squareIcon', paramName='imageSquare')
includeField(images, 'verticalCover', paramName='imageVertical')
# DLCs
if args.dlcs:
row['dlcs'] = set()
dlcList = jld('dlcs', True)
if dlcList == None:
dlcList = []
if options["TreatReleaseAsDLC"]:
rkeys = result[positions['releaseKey']].split(',')
for key in rkeys:
if options["TreatReleaseAsDLC"].get(key) != None:
dlcList.extend(options["TreatReleaseAsDLC"][key])
for dlc in dlcList:
try:
# Check the availability of the DLC in the games list (uncertain)
d = next(x[1] for x in results if dlc in x[0])
if d:
row['dlcs'].add(jld('title', True, d))
except StopIteration:
pass
# Tags
if args.tags:
includeField(result, 'tags', positions['tags'], fieldType=Type.LIST)
# isHidden
if args.isHidden:
includeField(result, 'isHidden', positions['isHidden'], fieldType=Type.STRING)
# osCompatibility
if args.osCompatibility:
row['osCompatibility'] = set()
osCompatibility = jld('osCompatibility')
osList = osCompatibility['supported']
if osList:
for operatingSystem in osList:
row['osCompatibility'].add(operatingSystem['name'])
# Set conversion, list sorting, empty value reset
for k,v in row.items():
if v:
if list == type(v) or set == type(v):
row[k] = natsorted(list(row[k]), key=str.casefold)
if not args.pythonLists:
row[k] = args.delimiter.join(row[k])
else:
row[k] = ''
writer.writerow(row)
except Exception as e:
print('Parsing failed on: {}'.format(result))
raise e
except FileNotFoundError:
print('Unable to write to “{}”, make sure that the path exists and that you have the write permissions'.format(args.fileCSV))
return
if __name__ == "__main__":
# macOS
if platform == "darwin":
defaultDBlocation = "/Users/Shared/GOG.com/Galaxy/Storage/galaxy-2.0.db"
# Windows
elif platform == "win32":
defaultDBlocation = "C:\\ProgramData\\GOG.com\\Galaxy\\storage\\galaxy-2.0.db"
def ba(variableName, description, defaultValue=False):
""" Boolean argument: creates a default boolean argument with the name of the storage variable and
the description to be shown in the help screen
"""
return {
'action': 'store_true',
'required': defaultValue,
'help': description,
'dest': variableName,
}
# Set up the arguments
args = Arguments(
[
[
['-i', '--input'],
{
'default': defaultDBlocation,
'type': str,
'nargs': 1,
'required': False,
'metavar': 'FN',
'help': 'pathname of the galaxy2 database',
'dest': 'fileDB',
}
],
[
['-o', '--output'],
{
'default': 'gameDB.csv',
'type': str,
'nargs': 1,
'required': False,
'metavar': 'FN',
'help': 'pathname of the generated CSV',
'dest': 'fileCSV',
}
],
[
['-d'],
{
'default': '\t',
'type': str,
'required': False,
'metavar': 'CHARACTER',
'help': 'CSV field separator, defaults to tab',
'dest': 'delimiter',
}
],
[['-a', '--all'], ba('all', '(default) extracts all the fields')],
[['--sorting-title'], ba('sortingTitle', '(user customised) sorting title')],
[['--title-original'], ba('originalTitle', 'original title independent of any user changes')],
[['--my-rating'], ba('myRating', 'user rating score')],
[['--critics-score'], ba('criticsScore', 'critics rating score')],
[['--developers'], ba('developers', 'list of developers')],
[['--dlcs'], ba('dlcs', 'list of dlc titles for the specified game')],
[['--genres'], ba('genres', 'game genres')],
[['--image-background'], ba('imageBackground', 'background image')],
[['--image-square'], ba('imageSquare', 'square icon')],
[['--image-vertical'], ba('imageVertical', 'vertical cover image')],
[['--platforms'], ba('platforms', 'list of platforms the game is available on')],
[['--publishers'], ba('publishers', 'list of publishers')],
[['--release-date'], ba('releaseDate', '(user customized) release date of the software')],
[['--release-date-original'], ba('originalReleaseDate', 'original release date independent of any user changes')],
[['--summary'], ba('summary', 'game summary')],
[['--tags'], ba('tags', 'user tags')],
[['--hidden'], ba('isHidden', 'is gamne hidden in galaxy client')],
[['--os-compatibility'], ba('osCompatibility', 'list of supported operating systems')],
[['--themes'], ba('themes', 'game themes')],
[['--playtime'], ba('playtime', 'time spent playing the game')],
[['--last-played'], ba('lastPlayed', 'last time the game was played')],
[['--dlcs-details'], ba('exportDlcDetails', 'add a separate entry for each dlc with all available information to the exported csv')],
[['--py-lists'], ba('pythonLists', 'export lists as Python parseable instead of delimiter separated strings')],
],
description='GOG Galaxy 2 exporter: scans the local Galaxy 2 database to export a list of games and related information into a CSV'
)
if not args.anyOption(['delimiter', 'fileCSV', 'fileDB', 'pythonLists', 'exportDlcDetails']):
args.extractAll()
if exists(args.fileDB):
extractData(args)
else:
print('Unable to find the DB “{}”, make sure that {}'.format(
args.fileDB,
'GOG Galaxy 2 is installed' if defaultDBlocation == args.fileDB else 'you specified the correct path'
))
================================================
FILE: helper_scripts/print_gameDB.py
================================================
# PRINTS NUMBERED LIST OF GAMES FROM CSV FILE TO TEXT FILE
import csv
# String that contains all the games.
my_games = ""
# Index for the game.
i = 0
# Open csv file to reader
with open('../gameDB.csv', 'r', encoding='utf-8') as csv_file:
reader = csv.reader(csv_file)
# The name of the game is on the first part of the row
for row in reader:
row_string = ' '.join([str(elem) for elem in row])
name = row[0].split('\t')
# Add the index to the game.
if i > 0:
my_games += str(i) + ". " + name[0] + "\n"
print(name[0])
i += 1
# Write the string to file.
with open('my_games.txt', 'w', encoding='utf-8') as games_file:
games_file.write(my_games)
# Close the file.
games_file.close()
================================================
FILE: readme.md
================================================
# GOG Galaxy 2.0 Export Script
This script helps a user export their GOG Galaxy 2.0 Library.
## TL;DR / brief how to use
1. Install Python 3, through Windows Store or manually if you prefer
2. Download the [source files](https://github.com/AB1908/GOG-Galaxy-Export-Script/archive/refs/heads/master.zip) and unzip it in a directory of your choice
3. Open the command prompt (`Win+R`, write `cmd` and press Enter) and enter the directory you chose with `cd /d DIRECTORY`, replacing `DIRECTORY` with the directory in which `galaxy_library_export.py` resides
4. Install python's requirements:
```
python -m pip install csv natsort
```
5. Export the CSV with:
```
python galaxy_library_export.py
```
By default this scripts export everything it can into the CSV. If you would like to customize the results, read below.
## Usage
Through the use of command line parameters, you can decide what data you want exported to the CSV. Some of the options include the list of platforms (`--platforms`), playtime in minutes (`--playtime`), developers, publishers, genres and much more. You can read the help manual by invoking the script without parameters, to find an up to date list of all the possible export options.
If you want to use the CSV in a different tool, such as the [HTML5 library exporter](https://github.com/Varstahl/GOG-Galaxy-HTML5-exporter), you can default to the `-a` parameter to export everything.
When a different locale wants a different CSV delimiter (such as the Italian), you can manually specify the character to use (`-d `).
Also, you can manually specify the database location (`-i`) and the CSV location (`-o`), instead of using the default ones.
If the CSV has to be read by a Python script, you can use the option `--py-lists` to export python compatible list strings that can be reconverted in python objects through `ast`'s `literal_eval`, which avoids several (potentially incorrect) string split/joins.
If you also want to export all available dlcs use the `--dlcs-details` argument. With that all dlcs are handled as "games" and will be exported with all available infos.
## settings.json
The settings.json allows to handle dlcs as game and export them accordingly or treat any release (game, dlc, soundtrack, goodies pack etc.) as dlc of another game, if they are not already linked in the database.
- *TreatDLCAsGame*: Aarray of release-keys which should be treated as a game instead of a dlc
- Used to mark games which are (mistakenly) treated as dlcs by the gog galaxy client as games.
- All entries with a matching release-key will be exported with all available data.
- This will not change the link between a dlc and his parent game if it really is a dlc.
- *TreatReleaseAsDLC*: Dictionary which maps the releaseKey of a game to a list of dlcs.
- Used to mark any release which is (mistakenly) treated as a game by the gog galaxy client as dlc.
- The dlcs specified in the settings.json are joined with the list of dlcs found in the database.
- *TreatReleaseAsDLC* is evaluated after *TreatDLCAsGame*. If a release-key is present in *TreatDLCAsGame* and also mapped to another release-key with *TreatReleaseAsDLC* than this release-key is handled as dlc.
- This will not override the original link between a dlc and it's parent game. If a dlc is mapped to another game it will be present in the dlc list of this game and the original game.
## Dependencies
- Python 3
- csv
- natsort
## Platform Support
All platforms from the [official list](https://github.com/gogcom/galaxy-integrations-python-api/blob/master/PLATFORM_IDs.md) are supported. Some are not listed at the moment but should still show up correctly in the output.
## Wiki
Check the [Wiki tab](https://github.com/AB1908/GOG-Galaxy-Export-Script/wiki).
## Roadmap
Check the [Projects tab](https://github.com/AB1908/GOG-Galaxy-Export-Script/projects).
## Contribution
Feel free to add issues and pull requests.
## License
This repository is licensed under the [MIT License](https://github.com/AB1908/GOG-Galaxy-Export-Script/blob/master/LICENSE).
================================================
FILE: settings.json
================================================
{
"TreatDLCAsGame": [
"epic_1317e4e3b3ed40c289dde85b194347d3"
],
"TreatReleaseAsDLC": {
"steam_290790": ["steam_357180","steam_341810"],
"steam_365450": ["steam_408710"]
}
}