GOG Galaxy Integrations Python API

This Python library allows developers to easily build community integrations for various gaming platforms with GOG Galaxy 2.0.

Features

Each integration in GOG Galaxy 2.0 comes as a separate Python script and is launched as a separate process that needs to communicate with the main instance of GOG Galaxy 2.0.

The provided features are:

multistep authorization using a browser built into GOG Galaxy 2.0
support for GOG Galaxy 2.0 features:
- importing owned and detecting installed games
- installing and launching games
- importing achievements and game time
- importing friends lists and statuses
- importing friends recommendations list
- receiving and sending chat messages
cache storage

Platform Id’s

Each integration can implement only one platform. Each integration must declare which platform it’s integrating.

PLATFORM ID LIST

Basic usage

Each integration should inherit from the Plugin class. Supported methods like get_owned_games() should be overwritten - they are called from the GOG Galaxy client at the appropriate times. Each of those methods can raise exceptions inherited from the ApplicationError. Communication between an integration and the client is also possible with the use of notifications, for example: update_local_game_status().

import sys
from galaxy.api.plugin import Plugin, create_and_run_plugin
from galaxy.api.consts import Platform
from galaxy.api.types import Authentication, Game, LicenseInfo, LicenseType


class PluginExample(Plugin):
    def __init__(self, reader, writer, token):
        super().__init__(
            Platform.Test,  # choose platform from available list
            "0.1",  # version
            reader,
            writer,
            token
        )

    # implement methods

    # required
    async def authenticate(self, stored_credentials=None):
        return Authentication('test_user_id', 'Test User Name')

    # required
    async def get_owned_games(self):
        return [
            Game('test', 'The Test', None, LicenseInfo(LicenseType.SinglePurchase))
        ]


def main():
    create_and_run_plugin(PluginExample, sys.argv)

# run plugin event loop
if __name__ == "__main__":
    main()

Deployment

The client has a built-in Python 3.7 interpreter, so integrations are delivered as Python modules. In order to be found by GOG Galaxy 2.0 an integration folder should be placed in lookup directory. Beside all the Python files, the integration folder must contain manifest.json and all third-party dependencies. See an exemplary structure.

Lookup directory

Windows:

%localappdata%\GOG.com\Galaxy\plugins\installed
macOS:

~/Library/Application Support/GOG.com/Galaxy/plugins/installed

Logging

Root logger is already setup by GOG Galaxy to store rotated log files in:

Windows:

%programdata%\GOG.com\Galaxy\logs
macOS:

/Users/Shared/GOG.com/Galaxy/Logs

Plugin logs are kept in plugin-<platform>-<guid>.log. When debugging, inspecting the other side of communication in the GalaxyClient.log can be helpful as well.

Manifest

Obligatory JSON file to be placed in an integration folder.

{
    "name": "Example plugin",
    "platform": "test",
    "guid": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
    "version": "0.1",
    "description": "Example plugin",
    "author": "Name",
    "email": "author@email.com",
    "url": "https://github.com/user/galaxy-plugin-example",
    "script": "plugin.py"
}

property	description
`guid`	custom Globally Unique Identifier
`version`	the same string as `version` in `Plugin` constructor
`script`	path of the entry point module, relative to the integration folder

Dependencies

All third-party packages (packages not included in the Python 3.7 standard library) should be deployed along with plugin files. Use the following command structure:

pip install DEP --target DIR --implementation cp --python-version 37

For example, a plugin that uses requests could have the following structure:

installed
└── my_integration
    ├── galaxy
    │   └── api
    ├── requests
    │   └── ...
    ├── plugin.py
    └── manifest.json

Legal Notice

By integrating or attempting to integrate any applications or content with or into GOG Galaxy 2.0 you represent that such application or content is your original creation (other than any software made available by GOG) and/or that you have all necessary rights to grant such applicable rights to the relevant community integration to GOG and to GOG Galaxy 2.0 end users for the purpose of use of such community integration and that such community integration comply with any third party license and other requirements including compliance with applicable laws.

galaxy.api

plugin

class galaxy.api.plugin.Plugin(platform, version, reader, writer, handshake_token)

Use and override methods of this class to create a new platform integration.

property persistent_cache: Dict[str, str]

The cache is only available after the handshake_complete() is called.

Return type: Dict[str, str]

coroutine run(): Plugin’s main coroutine.

close()

Return type: None

coroutine wait_closed(self)

Return type: None

create_task(coro, description): Wrapper around asyncio.create_task - takes care of canceling tasks on shutdown

store_credentials(credentials)

Notify the client to store authentication credentials. Credentials are passed on the next authenticate call.

Parameters: credentials (Dict[str, Any]) – credentials that client will store; they are stored locally on a user pc

Example use case of store_credentials:

async def pass_login_credentials(self, step, credentials, cookies):
    if self.got_everything(credentials,cookies):
        user_data = await self.parse_credentials(credentials,cookies)
    else:
        next_params = self.get_next_params(credentials,cookies)
        next_cookies = self.get_next_cookies(credentials,cookies)
        return NextStep("web_session", next_params, cookies=next_cookies)
    self.store_credentials(user_data['credentials'])
    return Authentication(user_data['userId'], user_data['username'])

Return type: None

add_game(game)

Notify the client to add game to the list of owned games of the currently authenticated user.

Parameters: game (Game) – Game to add to the list of owned games

Example use case of add_game:

async def check_for_new_games(self):
    games = await self.get_owned_games()
    for game in games:
        if game not in self.owned_games_cache:
            self.owned_games_cache.append(game)
            self.add_game(game)

Return type: None

remove_game(game_id)

Notify the client to remove game from the list of owned games of the currently authenticated user.

Parameters: game_id (str) – the id of the game to remove from the list of owned games

Example use case of remove_game:

async def check_for_removed_games(self):
    games = await self.get_owned_games()
    for game in self.owned_games_cache:
        if game not in games:
            self.owned_games_cache.remove(game)
            self.remove_game(game.game_id)

Return type: None

update_game(game)

Notify the client to update the status of a game owned by the currently authenticated user.

Parameters: game (Game) – Game to update
Return type: None

unlock_achievement(game_id, achievement)

Notify the client to unlock an achievement for a specific game.

Parameters

game_id (str) – the id of the game for which to unlock an achievement.
achievement (Achievement) – achievement to unlock.

Return type

None

update_local_game_status(local_game)

Notify the client to update the status of a local game.

Parameters: local_game (LocalGame) – the LocalGame to update

Example use case triggered by the tick() method:

async def _check_statuses(self):
    for game in await self._get_local_games():
        if game.status == self._cached_game_statuses.get(game.id):
            continue
        self.update_local_game_status(LocalGame(game.id, game.status))
        self._cached_games_statuses[game.id] = game.status
    await asyncio.sleep(5)  # interval

def tick(self):
    if self._check_statuses_task is None or self._check_statuses_task.done():
        self._check_statuses_task = asyncio.create_task(self._check_statuses())

Return type: None

add_friend(user)

Notify the client to add a user to friends list of the currently authenticated user.

Parameters: user (UserInfo) – UserInfo of a user that the client will add to friends list
Return type: None

remove_friend(user_id)

Notify the client to remove a user from friends list of the currently authenticated user.

Parameters: user_id (str) – id of the user to remove from friends list
Return type: None

update_friend_info(user)

Notify the client about the updated friend information.

Parameters: user (UserInfo) – UserInfo of a friend whose info was updated
Return type: None

update_game_time(game_time)

Notify the client to update game time for a game.

Parameters: game_time (GameTime) – game time to update
Return type: None

update_user_presence(user_id, user_presence)

Notify the client about the updated user presence information.

Parameters

user_id (str) – the id of the user whose presence information is updated
user_presence (UserPresence) – presence information of the specified user

Return type

None

lost_authentication()

Notify the client that integration has lost authentication for the current user and is unable to perform actions which would require it.

Return type: None

push_cache()

Push local copy of the persistent cache to the GOG Galaxy Client replacing existing one.

Return type: None

coroutine refresh_credentials(self, params, sensitive_params)

Return type: Dict[str, Any]

handshake_complete()

This method is called right after the handshake with the GOG Galaxy Client is complete and before any other operations are called by the GOG Galaxy Client. Persistent cache is available when this method is called. Override it if you need to do additional plugin initializations. This method is called internally.

Return type: None

tick()

This method is called periodically. Override it to implement periodical non-blocking tasks. This method is called internally.

Example of possible override of the method:

def tick(self):
    if not self.checking_for_new_games:
        asyncio.create_task(self.check_for_new_games())
    if not self.checking_for_removed_games:
        asyncio.create_task(self.check_for_removed_games())
    if not self.updating_game_statuses:
        asyncio.create_task(self.update_game_statuses())

Return type: None

coroutine shutdown(self)

This method is called on integration shutdown. Override it to implement tear down. This method is called by the GOG Galaxy Client.

Return type: None

coroutine authenticate(self, stored_credentials=None)

Override this method to handle user authentication. This method should either return Authentication if the authentication is finished or NextStep if it requires going to another url. This method is called by the GOG Galaxy Client.

Parameters: stored_credentials (Optional[Dict]) – If the client received any credentials to store locally in the previous session they will be passed here as a parameter.

Example of possible override of the method:

async def authenticate(self, stored_credentials=None):
    if not stored_credentials:
        return NextStep("web_session", PARAMS, cookies=COOKIES)
    else:
        try:
            user_data = self._authenticate(stored_credentials)
        except AccessDenied:
            raise InvalidCredentials()
    return Authentication(user_data['userId'], user_data['username'])

Return type: Union[NextStep, Authentication]

coroutine pass_login_credentials(self, step, credentials, cookies)

This method is called if we return NextStep from authenticate() or pass_login_credentials(). This method’s parameters provide the data extracted from the web page navigation that previous NextStep finished on. This method should either return Authentication if the authentication is finished or NextStep if it requires going to another cef url. This method is called by the GOG Galaxy Client.

Parameters

step (str) – deprecated.
credentials (Dict[str, str]) – end_uri previous NextStep finished on.
cookies (List[Dict[str, str]]) – cookies extracted from the end_uri site.

Example of possible override of the method:

async def pass_login_credentials(self, step, credentials, cookies):
    if self.got_everything(credentials,cookies):
        user_data = await self.parse_credentials(credentials,cookies)
    else:
        next_params = self.get_next_params(credentials,cookies)
        next_cookies = self.get_next_cookies(credentials,cookies)
        return NextStep("web_session", next_params, cookies=next_cookies)
    self.store_credentials(user_data['credentials'])
    return Authentication(user_data['userId'], user_data['username'])

Return type: Union[NextStep, Authentication]

coroutine get_owned_games(self)

Override this method to return owned games for currently logged in user. This method is called by the GOG Galaxy Client.

Example of possible override of the method:

async def get_owned_games(self):
    if not self.authenticated():
        raise AuthenticationRequired()

    games = self.retrieve_owned_games()
    return games

Return type: List[Game]

coroutine prepare_achievements_context(self, game_ids)

Override this method to prepare context for get_unlocked_achievements. This allows for optimizations like batch requests to platform API. Default implementation returns None.

Parameters: game_ids (List[str]) – the ids of the games for which achievements are imported
Return type: Any
Returns: context

coroutine get_unlocked_achievements(self, game_id, context)

Override this method to return list of unlocked achievements for the game identified by the provided game_id. This method is called by import task initialized by GOG Galaxy Client.

Parameters

game_id (str) – the id of the game for which the achievements are returned
context (Any) – the value returned from prepare_achievements_context()

Return type

List[Achievement]

Returns

list of Achievement objects

achievements_import_complete(): Override this method to handle operations after achievements import is finished (like updating cache).

coroutine get_local_games(self)

Override this method to return the list of games present locally on the users pc. This method is called by the GOG Galaxy Client.

Example of possible override of the method:

async def get_local_games(self):
    local_games = []
    for game in self.games_present_on_user_pc:
        local_game = LocalGame()
        local_game.game_id = game.id
        local_game.local_game_state = game.get_installation_status()
        local_games.append(local_game)
    return local_games

Return type: List[LocalGame]

coroutine launch_game(self, game_id)

Override this method to launch the game identified by the provided game_id. This method is called by the GOG Galaxy Client.

Parameters: game_id (str) – the id of the game to launch

Example of possible override of the method:

async def launch_game(self, game_id):
    await self.open_uri(f"start client://launchgame/{game_id}")

Return type: None

coroutine install_game(self, game_id)

Override this method to install the game identified by the provided game_id. This method is called by the GOG Galaxy Client.

Parameters: game_id (str) – the id of the game to install

Example of possible override of the method:

async def install_game(self, game_id):
    await self.open_uri(f"start client://installgame/{game_id}")

Return type: None

coroutine uninstall_game(self, game_id)

Override this method to uninstall the game identified by the provided game_id. This method is called by the GOG Galaxy Client.

Parameters: game_id (str) – the id of the game to uninstall

Example of possible override of the method:

async def uninstall_game(self, game_id):
    await self.open_uri(f"start client://uninstallgame/{game_id}")

Return type: None

coroutine shutdown_platform_client(self)

Override this method to gracefully terminate platform client. This method is called by the GOG Galaxy Client.

Return type: None

coroutine launch_platform_client(self)

Override this method to launch platform client. Preferably minimized to tray. This method is called by the GOG Galaxy Client.

Return type: None

coroutine get_friends(self)

Override this method to return the friends list of the currently authenticated user. This method is called by the GOG Galaxy Client.

Example of possible override of the method:

async def get_friends(self):
    if not self._http_client.is_authenticated():
        raise AuthenticationRequired()

    friends = self.retrieve_friends()
    return friends

Return type: List[UserInfo]

coroutine prepare_game_times_context(self, game_ids)

Override this method to prepare context for get_game_time. This allows for optimizations like batch requests to platform API. Default implementation returns None.

Parameters: game_ids (List[str]) – the ids of the games for which game time are imported
Return type: Any
Returns: context

coroutine get_game_time(self, game_id, context)

Override this method to return the game time for the game identified by the provided game_id. This method is called by import task initialized by GOG Galaxy Client.

Parameters

game_id (str) – the id of the game for which the game time is returned
context (Any) – the value returned from prepare_game_times_context()

Return type

GameTime

Returns

GameTime object

game_times_import_complete()

Override this method to handle operations after game times import is finished (like updating cache).

Return type: None

coroutine prepare_game_library_settings_context(self, game_ids)

Override this method to prepare context for get_game_library_settings. This allows for optimizations like batch requests to platform API. Default implementation returns None.

Parameters: game_ids (List[str]) – the ids of the games for which game library settings are imported
Return type: Any
Returns: context

coroutine get_game_library_settings(self, game_id, context)

Override this method to return the game library settings for the game identified by the provided game_id. This method is called by import task initialized by GOG Galaxy Client.

Parameters

game_id (str) – the id of the game for which the game library settings are imported
context (Any) – the value returned from prepare_game_library_settings_context()

Return type

GameLibrarySettings

Returns

GameLibrarySettings object

game_library_settings_import_complete()

Override this method to handle operations after game library settings import is finished (like updating cache).

Return type: None

coroutine prepare_os_compatibility_context(self, game_ids)

Override this method to prepare context for get_os_compatibility. This allows for optimizations like batch requests to platform API. Default implementation returns None.

Parameters: game_ids (List[str]) – the ids of the games for which game os compatibility is imported
Return type: Any
Returns: context

coroutine get_os_compatibility(self, game_id, context)

Override this method to return the OS compatibility for the game with the provided game_id. This method is called by import task initialized by GOG Galaxy Client.

Parameters

game_id (str) – the id of the game for which the game os compatibility is imported
context (Any) – the value returned from prepare_os_compatibility_context()

Return type

Optional[OSCompatibility]

Returns

OSCompatibility flags indicating compatible OSs, or None if compatibility is not know

os_compatibility_import_complete()

Override this method to handle operations after OS compatibility import is finished (like updating cache).

Return type: None

coroutine prepare_user_presence_context(self, user_id_list)

Override this method to prepare context for get_user_presence(). This allows for optimizations like batch requests to platform API. Default implementation returns None.

Parameters: user_id_list (List[str]) – the ids of the users for whom presence information is imported
Return type: Any
Returns: context

coroutine get_user_presence(self, user_id, context)

Override this method to return presence information for the user with the provided user_id. This method is called by import task initialized by GOG Galaxy Client.

Parameters

user_id (str) – the id of the user for whom presence information is imported
context (Any) – the value returned from prepare_user_presence_context()

Return type

UserPresence

Returns

UserPresence presence information of the provided user

user_presence_import_complete()

Override this method to handle operations after presence import is finished (like updating cache).

Return type: None

coroutine prepare_local_size_context(self, game_ids)

Override this method to prepare context for get_local_size() Default implementation returns None.

Parameters: game_ids (List[str]) – the ids of the games for which information about size is imported
Return type: Any
Returns: context

coroutine get_local_size(self, game_id, context)

Override this method to return installed game size.

Note

It is preferable to avoid iterating over local game files when overriding this method. If possible, please use a more efficient way of game size retrieval.

Parameters

game_id (str) – the id of the installed game
context (Any) – the value returned from prepare_local_size_context()

Return type

Optional[int]

Returns

the size of the game on a user-owned storage device (in bytes) or None if the size cannot be determined

local_size_import_complete()

Override this method to handle operations after local game size import is finished (like updating cache).

Return type: None

coroutine get_subscriptions(self)

Override this method to return a list of Subscriptions available on platform. This method is called by the GOG Galaxy Client.

Return type: List[Subscription]

coroutine prepare_subscription_games_context(self, subscription_names)

Override this method to prepare context for get_subscription_games() Default implementation returns None.

Parameters: subscription_names (List[str]) – the names of the subscriptions’ for which subscriptions games are imported
Return type: Any
Returns: context

coroutine get_subscription_games(self, subscription_name, context)

Override this method to provide SubscriptionGames for a given subscription. This method should yield a list of SubscriptionGames -> yield [sub_games]

This method will only be used if get_subscriptions() has been implemented.

Parameters: context (Any) – the value returned from prepare_subscription_games_context()
Return type: AsyncGenerator[List[SubscriptionGame], None]
Returns: a generator object that yields SubscriptionGames

async def get_subscription_games(subscription_name: str, context: Any):
    while True:
        games_page = await self._get_subscriptions_from_backend(subscription_name, i)
        if not games_pages:
            yield None
        yield [SubGame(game['game_id'], game['game_title']) for game in games_page]

subscription_games_import_complete()

Override this method to handle operations after subscription games import is finished (like updating cache).

Return type: None

galaxy.api.plugin.create_and_run_plugin(plugin_class, argv)

Call this method as an entry point for the implemented integration.

Parameters

plugin_class – your plugin class.
argv – command line arguments with which the script was started.

Example of possible use of the method:

def main():
    create_and_run_plugin(PlatformPlugin, sys.argv)

if __name__ == "__main__":
    main()

types

class galaxy.api.types.Authentication(user_id, user_name)

Return this from authenticate() or pass_login_credentials() to inform the client that authentication has successfully finished.

Parameters

user_id (str) – id of the authenticated user
user_name (str) – username of the authenticated user

user_id: str

user_name: str

class galaxy.api.types.Cookie(name, value, domain=None, path=None)

Parameters

name (str) – name of the cookie
value (str) – value of the cookie
domain (Optional[str]) – optional domain of the cookie
path (Optional[str]) – optional path of the cookie

name: str

value: str

domain: Optional[str] = None

path: Optional[str] = None

class galaxy.api.types.NextStep(next_step, auth_params, cookies=None, js=None)

Return this from authenticate() or pass_login_credentials() to open client built-in browser with given url. For example:

PARAMS = {
    "window_title": "Login to platform",
    "window_width": 800,
    "window_height": 600,
    "start_uri": URL,
    "end_uri_regex": r"^https://platform_website\.com/.*"
}

JS = {r"^https://platform_website\.com/.*": [
    r'''
        location.reload();
    '''
]}

COOKIES = [Cookie("Cookie1", "ok", ".platform.com"),
    Cookie("Cookie2", "ok", ".platform.com")
    ]

async def authenticate(self, stored_credentials=None):
    if not stored_credentials:
        return NextStep("web_session", PARAMS, cookies=COOKIES, js=JS)

Parameters

auth_params (Dict[str, str]) – configuration options: {“window_title”: str, “window_width”: str, “window_height”: int, “start_uri”: int, “end_uri_regex”: str}
cookies (Optional[List[Cookie]]) – browser initial set of cookies
js (Optional[Dict[str, List[str]]]) – a map of the url regex patterns into the list of js scripts that should be executed on every document at given step of internal browser authentication.

next_step: str

auth_params: Dict[str, str]

cookies: Optional[List[galaxy.api.types.Cookie]] = None

js: Optional[Dict[str, List[str]]] = None

class galaxy.api.types.LicenseInfo(license_type, owner=None)

Information about the license of related product.

Parameters

license_type (LicenseType) – type of license
owner (Optional[str]) – optional owner of the related product, defaults to currently authenticated user

license_type: galaxy.api.consts.LicenseType

owner: Optional[str] = None

class galaxy.api.types.Dlc(dlc_id, dlc_title, license_info)

Downloadable content object.

Parameters

dlc_id (str) – id of the dlc
dlc_title (str) – title of the dlc
license_info (LicenseInfo) – information about the license attached to the dlc

dlc_id: str

dlc_title: str

license_info: galaxy.api.types.LicenseInfo

class galaxy.api.types.Game(game_id, game_title, dlcs, license_info)

Game object.

Parameters

game_id (str) – unique identifier of the game, this will be passed as parameter for methods such as launch_game
game_title (str) – title of the game
dlcs (Optional[List[Dlc]]) – list of dlcs available for the game
license_info (LicenseInfo) – information about the license attached to the game

game_id: str

game_title: str

dlcs: Optional[List[galaxy.api.types.Dlc]]

license_info: galaxy.api.types.LicenseInfo

class galaxy.api.types.Achievement(unlock_time, achievement_id=None, achievement_name=None)

Achievement, has to be initialized with either id or name.

Parameters

unlock_time (int) – unlock time of the achievement
achievement_id (Optional[str]) – optional id of the achievement
achievement_name (Optional[str]) – optional name of the achievement

unlock_time: int

achievement_id: Optional[str] = None

achievement_name: Optional[str] = None

class galaxy.api.types.LocalGame(game_id, local_game_state)

Game locally present on the authenticated user’s computer.

Parameters

game_id (str) – id of the game
local_game_state (LocalGameState) – state of the game

game_id: str

local_game_state: galaxy.api.consts.LocalGameState

class galaxy.api.types.FriendInfo(user_id, user_name)

Deprecated since version 0.56: Use UserInfo.

Information about a friend of the currently authenticated user.

Parameters

user_id (str) – id of the user
user_name (str) – username of the user

user_id: str

user_name: str

class galaxy.api.types.UserInfo(user_id, user_name, avatar_url=None, profile_url=None)

Information about a user of related user.

Parameters

user_id (str) – id of the user
user_name (str) – username of the user
avatar_url (Optional[str]) – the URL of the user avatar
profile_url (Optional[str]) – the URL of the user profile

user_id: str

user_name: str

avatar_url: Optional[str] = None

profile_url: Optional[str] = None

class galaxy.api.types.GameTime(game_id, time_played, last_played_time)

Game time of a game, defines the total time spent in the game and the last time the game was played.

Parameters

game_id (str) – id of the related game
time_played (Optional[int]) – the total time spent in the game in minutes
last_played_time (Optional[int]) – last time the game was played (unix timestamp)

game_id: str

time_played: Optional[int]

last_played_time: Optional[int]

class galaxy.api.types.GameLibrarySettings(game_id, tags, hidden)

Library settings of a game, defines assigned tags and visibility flag.

Parameters

game_id (str) – id of the related game
tags (Optional[List[str]]) – collection of tags assigned to the game
hidden (Optional[bool]) – indicates if the game should be hidden in GOG Galaxy client

game_id: str

tags: Optional[List[str]]

hidden: Optional[bool]

class galaxy.api.types.UserPresence(presence_state, game_id=None, game_title=None, in_game_status=None, full_status=None)

Presence information of a user.

The GOG Galaxy client will prefer to generate user status basing on game_id (or game_title) and in_game_status fields but if plugin is not capable of delivering it then the full_status will be used if available

Parameters

presence_state (PresenceState) – the state of the user
game_id (Optional[str]) – id of the game a user is currently in
game_title (Optional[str]) – name of the game a user is currently in
in_game_status (Optional[str]) – status set by the game itself e.x. “In Main Menu”
full_status (Optional[str]) – full user status e.x. “Playing <title_name>: <in_game_status>”

presence_state: galaxy.api.consts.PresenceState

game_id: Optional[str] = None

game_title: Optional[str] = None

in_game_status: Optional[str] = None

full_status: Optional[str] = None

class galaxy.api.types.Subscription(subscription_name, owned=None, end_time=None, subscription_discovery=SubscriptionDiscovery.None)

Information about a subscription.

Parameters

subscription_name (str) – name of the subscription, will also be used as its identifier.
owned (Optional[bool]) – whether the subscription is owned or not, None if unknown.
end_time (Optional[int]) – unix timestamp of when the subscription ends, None if unknown.
subscription_discovery (SubscriptionDiscovery) – combination of settings that can be manually chosen by user to determine subscription handling behaviour. For example, if the integration cannot retrieve games for subscription when user doesn’t own it, then USER_ENABLED should not be used. If the integration cannot determine subscription ownership for a user then AUTOMATIC should not be used.

subscription_name: str

owned: Optional[bool] = None

end_time: Optional[int] = None

subscription_discovery: galaxy.api.consts.SubscriptionDiscovery = 3

class galaxy.api.types.SubscriptionGame(game_title, game_id, start_time=None, end_time=None)

Information about a game from a subscription.

Parameters

game_title (str) – title of the game
game_id (str) – id of the game
start_time (Optional[int]) – unix timestamp of when the game has been added to subscription
end_time (Optional[int]) – unix timestamp of when the game will be removed from subscription.

game_title: str

game_id: str

start_time: Optional[int] = None

end_time: Optional[int] = None

consts

class galaxy.api.consts.Platform(value)

Bases: enum.Enum

Supported gaming platforms

Unknown = 'unknown'

Gog = 'gog'

Steam = 'steam'

Psn = 'psn'

XBoxOne = 'xboxone'

Generic = 'generic'

Origin = 'origin'

Uplay = 'uplay'

Battlenet = 'battlenet'

Epic = 'epic'

Bethesda = 'bethesda'

ParadoxPlaza = 'paradox'

HumbleBundle = 'humble'

Kartridge = 'kartridge'

ItchIo = 'itch'

NintendoSwitch = 'nswitch'

NintendoWiiU = 'nwiiu'

NintendoWii = 'nwii'

NintendoGameCube = 'ncube'

RiotGames = 'riot'

Wargaming = 'wargaming'

NintendoGameBoy = 'ngameboy'

Atari = 'atari'

Amiga = 'amiga'

SuperNintendoEntertainmentSystem = 'snes'

Beamdog = 'beamdog'

Direct2Drive = 'd2d'

Discord = 'discord'

DotEmu = 'dotemu'

GameHouse = 'gamehouse'

GreenManGaming = 'gmg'

WePlay = 'weplay'

ZxSpectrum = 'zx'

ColecoVision = 'vision'

NintendoEntertainmentSystem = 'nes'

SegaMasterSystem = 'sms'

Commodore64 = 'c64'

PcEngine = 'pce'

SegaGenesis = 'segag'

NeoGeo = 'neo'

Sega32X = 'sega32'

SegaCd = 'segacd'

SegaSaturn = 'saturn'

PlayStation = 'psx'

PlayStation2 = 'ps2'

Nintendo64 = 'n64'

AtariJaguar = 'jaguar'

SegaDreamcast = 'dc'

Xbox = 'xboxog'

Amazon = 'amazon'

GamersGate = 'gg'

Newegg = 'egg'

BestBuy = 'bb'

GameUk = 'gameuk'

Fanatical = 'fanatical'

PlayAsia = 'playasia'

Stadia = 'stadia'

Arc = 'arc'

ElderScrollsOnline = 'eso'

Glyph = 'glyph'

AionLegionsOfWar = 'aionl'

Aion = 'aion'

BladeAndSoul = 'blade'

GuildWars = 'gw'

GuildWars2 = 'gw2'

Lineage2 = 'lin2'

FinalFantasy11 = 'ffxi'

FinalFantasy14 = 'ffxiv'

TotalWar = 'totalwar'

WindowsStore = 'winstore'

EliteDangerous = 'elites'

StarCitizen = 'star'

PlayStationPortable = 'psp'

PlayStationVita = 'psvita'

NintendoDs = 'nds'

Nintendo3Ds = '3ds'

PathOfExile = 'pathofexile'

Twitch = 'twitch'

Minecraft = 'minecraft'

GameSessions = 'gamesessions'

Nuuvem = 'nuuvem'

FXStore = 'fxstore'

IndieGala = 'indiegala'

Playfire = 'playfire'

Oculus = 'oculus'

Test = 'test'

Rockstar = 'rockstar'

class galaxy.api.consts.LicenseType(value)

Bases: enum.Enum

Possible game license types, understandable for the GOG Galaxy client.

Unknown = 'Unknown'

SinglePurchase = 'SinglePurchase'

FreeToPlay = 'FreeToPlay'

OtherUserLicense = 'OtherUserLicense'

class galaxy.api.consts.LocalGameState(value)

Bases: enum.Flag

Possible states that a local game can be in. For example a game which is both installed and currently running should have its state set as a “bitwise or” of Running and Installed flags: local_game_state=<LocalGameState.Running|Installed: 3>

None_ = 0

Installed = 1

Running = 2

class galaxy.api.consts.OSCompatibility(value)

Bases: enum.Flag

Possible game OS compatibility. Use “bitwise or” to express multiple OSs compatibility, e.g. os=OSCompatibility.Windows|OSCompatibility.MacOS

Windows = 1

MacOS = 2

Linux = 4

class galaxy.api.consts.PresenceState(value)

Bases: enum.Enum

“Possible states of a user.

Unknown = 'unknown'

Online = 'online'

Offline = 'offline'

Away = 'away'

class galaxy.api.consts.SubscriptionDiscovery(value)

Bases: enum.Flag

Possible capabilities which inform what methods of subscriptions ownership detection are supported.

Parameters

AUTOMATIC – integration can retrieve the proper status of subscription ownership.
USER_ENABLED – integration can handle override of ~class::Subscription.owned value to True

AUTOMATIC = 1

USER_ENABLED = 2

errors

exception galaxy.api.jsonrpc.ApplicationError(code, message, data): Bases: galaxy.api.jsonrpc.JsonRpcError

exception galaxy.api.jsonrpc.UnknownError(message='Unknown error', data=None): Bases: galaxy.api.jsonrpc.ApplicationError

exception galaxy.api.errors.AuthenticationRequired(message='Authentication required', data=None): Bases: galaxy.api.jsonrpc.ApplicationError

exception galaxy.api.errors.BackendNotAvailable(message='Backend not available', data=None): Bases: galaxy.api.jsonrpc.ApplicationError

exception galaxy.api.errors.BackendTimeout(message='Backend timed out', data=None): Bases: galaxy.api.jsonrpc.ApplicationError

exception galaxy.api.errors.BackendError(message='Backend error', data=None): Bases: galaxy.api.jsonrpc.ApplicationError

exception galaxy.api.errors.TooManyRequests(message='Too many requests. Try again later', data=None): Bases: galaxy.api.jsonrpc.ApplicationError

exception galaxy.api.errors.UnknownBackendResponse(message='Backend responded in unknown way', data=None): Bases: galaxy.api.jsonrpc.ApplicationError

exception galaxy.api.errors.InvalidCredentials(message='Invalid credentials', data=None): Bases: galaxy.api.jsonrpc.ApplicationError

exception galaxy.api.errors.NetworkError(message='Network error', data=None): Bases: galaxy.api.jsonrpc.ApplicationError

exception galaxy.api.errors.ProtocolError(message='Protocol error', data=None): Bases: galaxy.api.jsonrpc.ApplicationError

exception galaxy.api.errors.TemporaryBlocked(message='Temporary blocked', data=None): Bases: galaxy.api.jsonrpc.ApplicationError

exception galaxy.api.errors.Banned(message='Banned', data=None): Bases: galaxy.api.jsonrpc.ApplicationError

exception galaxy.api.errors.AccessDenied(message='Access denied', data=None): Bases: galaxy.api.jsonrpc.ApplicationError

exception galaxy.api.errors.FailedParsingManifest(message='Failed parsing manifest', data=None): Bases: galaxy.api.jsonrpc.ApplicationError

exception galaxy.api.errors.TooManyMessagesSent(message='Too many messages sent', data=None): Bases: galaxy.api.jsonrpc.ApplicationError

exception galaxy.api.errors.IncoherentLastMessage(message='Different last message id on backend', data=None): Bases: galaxy.api.jsonrpc.ApplicationError

exception galaxy.api.errors.MessageNotFound(message='Message not found', data=None): Bases: galaxy.api.jsonrpc.ApplicationError

exception galaxy.api.errors.ImportInProgress(message='Import already in progress', data=None): Bases: galaxy.api.jsonrpc.ApplicationError

galaxy.http

This module standardizes http traffic and the error handling for further communication with the GOG Galaxy 2.0.

It is recommended to use provided convenient methods for HTTP requests, especially when dealing with authorized sessions. Exemplary simple web service could looks like:

from galaxy.http import create_client_session, handle_exception

class BackendClient:
    AUTH_URL = 'my-integration.com/auth'
    HEADERS = {
        "My-Custom-Header": "true",
    }
    def __init__(self):
        self._session = create_client_session(headers=self.HEADERS)

    async def authenticate(self):
        await self._session.request('POST', self.AUTH_URL)

    async def close(self):
        # to be called on plugin shutdown
        await self._session.close()

    async def _authorized_request(self, method, url, *args, **kwargs):
        with handle_exceptions():
            return await self._session.request(method, url, *args, **kwargs)

galaxy.http.DEFAULT_LIMIT = 20: Default limit of the simultaneous connections for ssl connector.

galaxy.http.DEFAULT_TIMEOUT = 60: Default timeout in seconds used for client session.

class galaxy.http.HttpClient(limit=20, timeout=aiohttp.ClientTimeout, cookie_jar=None)

Bases: object

Deprecated since version 0.41: Use http module functions instead

__init__(limit=20, timeout=aiohttp.ClientTimeout, cookie_jar=None)

coroutine close(): Closes connection. Should be called in shutdown()

coroutine request(method, url, *args, **kwargs)

galaxy.http.create_tcp_connector(*args, **kwargs)

Creates TCP connector with reasonable defaults. For details about available parameters refer to aiohttp.TCPConnector

Return type: TCPConnector

galaxy.http.create_client_session(*args, **kwargs)

Creates client session with reasonable defaults. For details about available parameters refer to aiohttp.ClientSession

Exemplary customization:

from galaxy.http import create_client_session, create_tcp_connector

session = create_client_session(
    headers={
        "Keep-Alive": "true"
    },
    connector=create_tcp_connector(limit=40),
    timeout=100)

Return type: ClientSession

galaxy.http.handle_exception(): Context manager translating network related exceptions to custom errors.

PLATFORM ID LIST

Platform ID list for GOG Galaxy 2.0 Integrations

ID	Name
test	Testing purposes
steam	Steam
psn	PlayStation Network
xboxone	Xbox Live
origin	Origin
uplay	Uplay
battlenet	Battle.net
epic	Epic Games Store
bethesda	Bethesda.net
paradox	Paradox Plaza
humble	Humble Bundle
kartridge	Kartridge
itch	Itch.io
nswitch	Nintendo Switch
nwiiu	Nintendo Wii U
nwii	Nintendo Wii
ncube	Nintendo GameCube
riot	Riot
wargaming	Wargaming
ngameboy	Nintendo Game Boy
atari	Atari
amiga	Amiga
snes	SNES
beamdog	Beamdog
d2d	Direct2Drive
discord	Discord
dotemu	DotEmu
gamehouse	GameHouse
gmg	Green Man Gaming
weplay	WePlay
zx	Zx Spectrum PC
vision	ColecoVision
nes	NES
sms	Sega Master System
c64	Commodore 64
pce	PC Engine
segag	Sega Genesis
neo	NeoGeo
sega32	Sega 32X
segacd	Sega CD
3do	3DO Interactive
saturn	SegaSaturn
psx	Sony PlayStation
ps2	Sony PlayStation 2
n64	Nintendo64
jaguar	Atari Jaguar
dc	Sega Dreamcast
xboxog	Original Xbox games
amazon	Amazon
gg	GamersGate
egg	Newegg
bb	BestBuy
gameuk	Game UK
fanatical	Fanatical store
playasia	Play-Asia
stadia	Google Stadia
arc	ARC
eso	ESO
glyph	Trion World
aionl	Aion: Legions of War
aion	Aion
blade	Blade & Soul
gw	Guild Wars
gw2	Guild Wars 2
lin2	Lineage 2
ffxi	Final Fantasy XI
ffxiv	Final Fantasy XIV
totalwar	Total War
winstore	Windows Store
elites	Elite Dangerous
star	Star Citizen
psp	PlayStation Portable
psvita	PlayStation Vita
nds	Nintendo DS
3ds	Nintendo 3DS
pathofexile	Path of Exile
twitch	Twitch
minecraft	Minecraft
gamesessions	GameSessions
nuuvem	Nuuvem
fxstore	FX Store
indiegala	IndieGala
playfire	Playfire
oculus	Oculus
rockstar	Rockstar

Index

Index