def get_runner_info(self, version=None): runner_api_url = 'https://lutris.net/api/runners/{}'.format(self.name) request = Request(runner_api_url) response = request.get() response_content = response.json if response_content: versions = response_content.get('versions') or [] if self.name == 'wine': arch = 'i386' else: arch = self.arch if version: if version.endswith('-i386') or version.endswith('-x86_64'): version, arch = version.rsplit('-', 1) versions = [v for v in versions if v['version'] == version] versions_for_arch = [ v for v in versions if v['architecture'] == arch ] if len(versions_for_arch) == 1: return versions_for_arch[0] elif len(versions_for_arch) > 1: default_version = [ v for v in versions_for_arch if v['default'] is True ] if default_version: return default_version[0] elif len(versions) == 1 and system.is_64bit: return versions[0] elif len(versions) > 1 and system.is_64bit: default_version = [v for v in versions if v['default'] is True] if default_version: return default_version[0]
def request_token(self, url="", refresh_token=""): """Get authentication token from GOG""" if refresh_token: grant_type = "refresh_token" extra_params = {"refresh_token": refresh_token} else: grant_type = "authorization_code" parsed_url = urlparse(url) response_params = dict(parse_qsl(parsed_url.query)) if "code" not in response_params: logger.error("code not received from GOG") logger.error(response_params) return extra_params = { "code": response_params["code"], "redirect_uri": self.redirect_uri, } params = { "client_id": self.client_id, "client_secret": self.client_secret, "grant_type": grant_type, } params.update(extra_params) url = "https://auth.gog.com/token?" + urlencode(params) request = Request(url) try: request.get() except HTTPError as ex: logger.error("Failed to get token, check your GOG credentials") return token = request.json with open(self.token_path, "w") as token_file: token_file.write(json.dumps(token))
def get_runner_info(self, version=None): runner_api_url = 'https://lutris.net/api/runners/{}'.format(self.name) request = Request(runner_api_url) response = request.get() response_content = response.json if response_content: versions = response_content.get('versions') or [] if version: versions = [ v for v in versions if v['version'] == version ] versions_for_arch = [ v for v in versions if v['architecture'] == get_arch_for_api() ] if len(versions_for_arch) == 1: return versions_for_arch[0] elif len(versions_for_arch) > 1: default_version = [ v for v in versions_for_arch if v['default'] is True ] if default_version: return default_version[0] elif len(versions) == 1 and system.is_64bit: return versions[0] elif len(versions) > 1 and system.is_64bit: default_version = [ v for v in versions if v['default'] is True ] if default_version: return default_version[0]
def request_token(self, url="", refresh_token=""): """Get authentication token from GOG""" if refresh_token: grant_type = "refresh_token" extra_params = {"refresh_token": refresh_token} else: grant_type = "authorization_code" parsed_url = urlparse(url) response_params = dict(parse_qsl(parsed_url.query)) if "code" not in response_params: logger.error("code not received from GOG") logger.error(response_params) return extra_params = { "code": response_params["code"], "redirect_uri": self.redirect_uri, } params = { "client_id": self.client_id, "client_secret": self.client_secret, "grant_type": grant_type, } params.update(extra_params) url = "https://auth.gog.com/token?" + urlencode(params) request = Request(url) try: request.get() except HTTPError: logger.error("Failed to get token, check your GOG credentials") return token = request.json with open(self.token_path, "w") as token_file: token_file.write(json.dumps(token))
def get_runner_info(self, version=None): runner_api_url = "{}/api/runners/{}".format(settings.SITE_URL, self.name) logger.info( "Getting runner information for %s%s", self.name, "(version: %s)" % version if version else "", ) request = Request(runner_api_url) response = request.get() response_content = response.json if response_content: versions = response_content.get("versions") or [] arch = self.arch if version: if version.endswith("-i386") or version.endswith("-x86_64"): version, arch = version.rsplit("-", 1) versions = [v for v in versions if v["version"] == version] versions_for_arch = [v for v in versions if v["architecture"] == arch] if len(versions_for_arch) == 1: return versions_for_arch[0] elif len(versions_for_arch) > 1: default_version = [v for v in versions_for_arch if v["default"] is True] if default_version: return default_version[0] elif len(versions) == 1 and system.LINUX_SYSTEM.is_64_bit: return versions[0] elif len(versions) > 1 and system.LINUX_SYSTEM.is_64_bit: default_version = [v for v in versions if v["default"] is True] if default_version: return default_version[0] # If we didn't find a proper version yet, return the first available. if len(versions_for_arch) >= 1: return versions_for_arch[0]
def get_runner_info(self, version=None): runner_api_url = '{}/api/runners/{}'.format(settings.SITE_URL, self.name) logger.info("Getting runner information for %s%s", self.name, '(version: %s)' % version if version else '') request = Request(runner_api_url) response = request.get() response_content = response.json if response_content: versions = response_content.get('versions') or [] logger.debug("Got %s versions", len(versions)) arch = self.arch if version: if version.endswith('-i386') or version.endswith('-x86_64'): version, arch = version.rsplit('-', 1) versions = [v for v in versions if v['version'] == version] versions_for_arch = [ v for v in versions if v['architecture'] == arch ] if len(versions_for_arch) == 1: return versions_for_arch[0] elif len(versions_for_arch) > 1: default_version = [ v for v in versions_for_arch if v['default'] is True ] if default_version: return default_version[0] elif len(versions) == 1 and system.is_64bit: return versions[0] elif len(versions) > 1 and system.is_64bit: default_version = [v for v in versions if v['default'] is True] if default_version: return default_version[0]
def make_request(self, url): """Send a cookie authenticated HTTP request to GOG""" request = Request(url, cookies=self.load_cookies()) request.get() if request.content.startswith(b"<"): raise AuthenticationError("Token expired, please log in again") return request.json
def make_api_request(self, url): """Send a token authenticated request to GOG""" try: token = self.load_token() except AuthenticationError: return if self.get_token_age() > 2600: self.request_token(refresh_token=token["refresh_token"]) token = self.load_token() if not token: logger.warning( "Request to %s cancelled because the GOG token could not be acquired", url, ) return headers = {"Authorization": "Bearer " + token["access_token"]} request = Request(url, headers=headers, cookies=self.load_cookies()) try: request.get() except HTTPError: logger.error( "Failed to request %s, check your GOG credentials and internet connectivity", url, ) return return request.json
def download_media(url, dest, overwrite=False): if os.path.exists(dest): if overwrite: os.remove(dest) else: return request = Request(url).get() request.write_to_file(dest)
def download_media(url, dest, overwrite=False): if os.path.exists(dest): if overwrite: os.remove(dest) else: return request = Request(url).get() request.write_to_file(dest)
def download_media(url, dest, overwrite=False): logger.debug("Downloading %s to %s", url, dest) if system.path_exists(dest): if overwrite: os.remove(dest) else: return request = Request(url).get() request.write_to_file(dest)
def download_media(url, dest, overwrite=False): """Save a remote media locally""" if system.path_exists(dest): if overwrite: os.remove(dest) else: return dest request = Request(url).get() request.write_to_file(dest) return dest
def get_runner_version(self, version=None): """Get the appropriate version for a runner Params: version (str): Optional version to lookup, will return this one if found Returns: dict: Dict containing version, architecture and url for the runner, None if the data can't be retrieved. """ logger.info( "Getting runner information for %s%s", self.name, " (version: %s)" % version if version else "", ) try: request = Request("{}/api/runners/{}".format( settings.SITE_URL, self.name)) runner_info = request.get().json if not runner_info: logger.error("Failed to get runner information") except HTTPError as ex: logger.error("Unable to get runner information: %s", ex) runner_info = None if not runner_info: return versions = runner_info.get("versions") or [] arch = LINUX_SYSTEM.arch if version: if version.endswith("-i386") or version.endswith("-x86_64"): version, arch = version.rsplit("-", 1) versions = [v for v in versions if v["version"] == version] versions_for_arch = [v for v in versions if v["architecture"] == arch] if len(versions_for_arch) == 1: return versions_for_arch[0] if len(versions_for_arch) > 1: default_version = [ v for v in versions_for_arch if v["default"] is True ] if default_version: return default_version[0] elif len(versions) == 1 and LINUX_SYSTEM.is_64_bit: return versions[0] elif len(versions) > 1 and LINUX_SYSTEM.is_64_bit: default_version = [v for v in versions if v["default"] is True] if default_version: return default_version[0] # If we didn't find a proper version yet, return the first available. if len(versions_for_arch) >= 1: return versions_for_arch[0]
def make_api_request(self, url): """Make an authenticated request to the Humble API""" request = Request(url, cookies=self.load_cookies()) try: request.get() except HTTPError: logger.error( "Failed to request %s, check your Humble Bundle credentials and internet connectivity", url, ) return return request.json
def download_media(url, dest, overwrite=False): """Save a remote media locally""" if system.path_exists(dest): if overwrite: os.remove(dest) else: return dest try: request = Request(url).get() except HTTPError: return request.write_to_file(dest) return dest
def make_api_request(self, url): """Send a token authenticated request to GOG""" try: token = self.load_token() except AuthenticationError: return if self.get_token_age() > 2600: self.request_token(refresh_token=token["refresh_token"]) token = self.load_token() headers = {"Authorization": "Bearer " + token["access_token"]} request = Request(url, headers=headers, cookies=self.load_cookies()) request.get() return request.json
def get_runner_version(self, version=None): """Get the appropriate version for a runner Params: version (str): Optional version to lookup, will return this one if found Returns: dict: Dict containing version, architecture and url for the runner """ logger.info( "Getting runner information for %s%s", self.name, " (version: %s)" % version if version else "", ) request = Request("{}/api/runners/{}".format(settings.SITE_URL, self.name)) runner_info = request.get().json if not runner_info: logger.error("Failed to get runner information") return system_architecture = system.LINUX_SYSTEM.arch runner_versions = runner_info.get("versions") or [] compatible_runner_versions = list( filter( lambda runner_version: bool( runner_version.get("architecture") == system_architecture), runner_versions)) logger.debug(compatible_runner_versions) runner_info_for_provided_version = [] if version: runner_info_for_provided_version = [ v for v in compatible_runner_versions if v["version"] == version ] if len(runner_info_for_provided_version) != 0: logger.info("Using provided version compatible for architecture") return runner_info_for_provided_version[0] if len(compatible_runner_versions) > 0: logger.info("Using latest version compatible for architecture") return compatible_runner_versions[len(compatible_runner_versions) - 1] logger.error( "The architecture of the system does not match any runner architecture currently provided by Lutris.net" ) return {}
def fetch_script(game_slug, revision=None): """Download install script(s) for matching game_slug.""" if revision: installer_url = settings.INSTALLER_REVISION_URL % (game_slug, revision) key = None else: installer_url = settings.INSTALLER_URL % game_slug key = 'results' logger.debug("Fetching installer %s", installer_url) request = Request(installer_url) request.get() response = request.json if key: return response[key] else: return response
def fetch_script(game_slug, revision=None): """Download install script(s) for matching game_slug.""" if revision: installer_url = settings.INSTALLER_REVISION_URL % (game_slug, revision) key = None else: installer_url = settings.INSTALLER_URL % game_slug key = 'results' logger.debug("Fetching installer %s", installer_url) request = Request(installer_url) request.get() response = request.json if key: return response[key] else: return response
def fetch_script(game_slug, revision=None): """Download install script(s) for matching game_slug.""" if revision: installer_url = settings.INSTALLER_REVISION_URL % (game_slug, revision) key = None else: installer_url = settings.INSTALLER_URL % game_slug key = "results" logger.debug("Fetching installer %s", installer_url) request = Request(installer_url) request.get() response = request.json if response is None: raise RuntimeError("Couldn't get installer at %s" % installer_url) if key: return response[key] return response
def make_api_request(self, url): """Send a token authenticated request to GOG""" try: token = self.load_token() except AuthenticationError: return if self.get_token_age() > 2600: self.request_token(refresh_token=token["refresh_token"]) token = self.load_token() if not token: logger.warning( "Request to %s cancelled because the GOG token could not be acquired", url ) return headers = {"Authorization": "Bearer " + token["access_token"]} request = Request(url, headers=headers, cookies=self.load_cookies()) request.get() return request.json
def make_api_request(self, url): """Send a token authenticated request to GOG""" try: token = self.load_token() except AuthenticationError: return if self.get_token_age() > 2600: self.request_token(refresh_token=token["refresh_token"]) token = self.load_token() if not token: logger.warning( "Request to %s cancelled because the GOG token could not be acquired", url) return headers = {"Authorization": "Bearer " + token["access_token"]} request = Request(url, headers=headers, cookies=self.load_cookies()) request.get() return request.json
def fetch_script(game_slug, revision=None): """Download install script(s) for matching game_slug.""" if revision: installer_url = settings.INSTALLER_REVISION_URL % (game_slug, revision) key = None else: installer_url = settings.INSTALLER_URL % game_slug key = "results" logger.debug("Fetching installer %s", installer_url) request = Request(installer_url) request.get() response = request.json if response is None: raise RuntimeError("Couldn't get installer at %s" % installer_url) if key: return response[key] return response
def fetch_script(game_slug, revision=None): """Download install script(s) for matching game_slug.""" if not game_slug: raise ValueError("No game_slug provided. Can't query an installer") if revision: installer_url = settings.INSTALLER_REVISION_URL % (game_slug, revision) else: installer_url = settings.INSTALLER_URL % game_slug logger.debug("Fetching installer %s", installer_url) request = Request(installer_url) request.get() response = request.json if response is None: raise RuntimeError("Couldn't get installer at %s" % installer_url) if not revision: return response["results"] # Revision requests return a single installer return [response]
def get_runner_info(self, version=None): runner_api_url = 'https://lutris.net/api/runners/{}'.format(self.name) request = Request(runner_api_url) response = request.get() response_content = response.json if response_content: versions = response_content.get('versions') or [] if self.name == 'wine': arch = 'i386' else: arch = self.arch if version: if version.endswith('-i386') or version.endswith('-x86_64'): version, arch = version.rsplit('-', 1) versions = [ v for v in versions if v['version'] == version ] versions_for_arch = [ v for v in versions if v['architecture'] == arch ] if len(versions_for_arch) == 1: return versions_for_arch[0] elif len(versions_for_arch) > 1: default_version = [ v for v in versions_for_arch if v['default'] is True ] if default_version: return default_version[0] elif len(versions) == 1 and system.is_64bit: return versions[0] elif len(versions) > 1 and system.is_64bit: default_version = [ v for v in versions if v['default'] is True ] if default_version: return default_version[0]
def fetch_script(game_ref): """Download install script(s) for matching game_ref.""" request = Request(settings.INSTALLER_URL % game_ref) request.get() return request.json
def fetch_script(game_ref): """Download install script(s) for matching game_ref.""" request = Request(settings.INSTALLER_URL % game_ref) request.get() return request.json
def make_request(self, url): """Send a cookie authenticated HTTP request to GOG""" request = Request(url, cookies=self.load_cookies()) request.get() return request.json
def get_runner_info(self): request = Request("{}/api/runners/{}".format(settings.SITE_URL, self.name)) return request.get().json
def get_runner_info(self): request = Request("{}/api/runners/{}".format(settings.SITE_URL, self.name)) return request.get().json
def do_command_line(self, command_line): # noqa: C901 # pylint: disable=arguments-differ # pylint: disable=too-many-locals,too-many-return-statements,too-many-branches # pylint: disable=too-many-statements # TODO: split into multiple methods to reduce complexity (35) options = command_line.get_options_dict() # Use stdout to output logs, only if no command line argument is # provided argc = len(sys.argv) - 1 if "-d" in sys.argv or "--debug" in sys.argv: argc -= 1 if not argc: # Switch back the log output to stderr (the default in Python) # to avoid messing with any output from command line options. # Use when targetting Python 3.7 minimum # console_handler.setStream(sys.stderr) # Until then... logger.removeHandler(log.console_handler) log.console_handler = logging.StreamHandler(stream=sys.stdout) log.console_handler.setFormatter(log.SIMPLE_FORMATTER) logger.addHandler(log.console_handler) # Set up logger if options.contains("debug"): log.console_handler.setFormatter(log.DEBUG_FORMATTER) logger.setLevel(logging.DEBUG) # Text only commands # Print Lutris version and exit if options.contains("version"): executable_name = os.path.basename(sys.argv[0]) print(executable_name + "-" + settings.VERSION) logger.setLevel(logging.NOTSET) return 0 logger.info("Running Lutris %s", settings.VERSION) migrate() run_all_checks() AsyncCall(init_dxvk_versions, None) # List game if options.contains("list-games"): game_list = pga.get_games() if options.contains("installed"): game_list = [game for game in game_list if game["installed"]] if options.contains("json"): self.print_game_json(command_line, game_list) else: self.print_game_list(command_line, game_list) return 0 # List Steam games if options.contains("list-steam-games"): self.print_steam_list(command_line) return 0 # List Steam folders if options.contains("list-steam-folders"): self.print_steam_folders(command_line) return 0 # Execute command in Lutris context if options.contains("exec"): command = options.lookup_value("exec").get_string() self.execute_command(command) return 0 if options.contains("submit-issue"): IssueReportWindow(application=self) return 0 try: url = options.lookup_value(GLib.OPTION_REMAINING) installer_info = self.get_lutris_action(url) except ValueError: self._print(command_line, "%s is not a valid URI" % url.get_strv()) return 1 game_slug = installer_info["game_slug"] action = installer_info["action"] revision = installer_info["revision"] installer_file = None if options.contains("install"): installer_file = options.lookup_value("install").get_string() if installer_file.startswith(("http:", "https:")): try: request = Request(installer_file).get() except HTTPError: self._print(command_line, "Failed to download %s" % installer_file) return 1 try: headers = dict(request.response_headers) file_name = headers["Content-Disposition"].split("=", 1)[-1] except (KeyError, IndexError): file_name = os.path.basename(installer_file) file_path = os.path.join(tempfile.gettempdir(), file_name) self._print( command_line, "download %s to %s started" % (installer_file, file_path)) with open(file_path, 'wb') as dest_file: dest_file.write(request.content) installer_file = file_path action = "install" else: installer_file = os.path.abspath(installer_file) action = "install" if not os.path.isfile(installer_file): self._print(command_line, "No such file: %s" % installer_file) return 1 db_game = None if game_slug: if action == "rungameid": # Force db_game to use game id self.run_in_background = True db_game = pga.get_game_by_field(game_slug, "id") elif action == "rungame": # Force db_game to use game slug self.run_in_background = True db_game = pga.get_game_by_field(game_slug, "slug") elif action == "install": # Installers can use game or installer slugs self.run_in_background = True db_game = pga.get_game_by_field( game_slug, "slug") or pga.get_game_by_field( game_slug, "installer_slug") else: # Dazed and confused, try anything that might works db_game = (pga.get_game_by_field(game_slug, "id") or pga.get_game_by_field(game_slug, "slug") or pga.get_game_by_field(game_slug, "installer_slug")) # Graphical commands self.activate() self.set_tray_icon() if not action: if db_game and db_game["installed"]: # Game found but no action provided, ask what to do dlg = InstallOrPlayDialog(db_game["name"]) if not dlg.action_confirmed: action = None elif dlg.action == "play": action = "rungame" elif dlg.action == "install": action = "install" elif game_slug or installer_file: # No game found, default to install if a game_slug or # installer_file is provided action = "install" if action == "install": self.show_window( InstallerWindow, parent=self.window, game_slug=game_slug, installer_file=installer_file, revision=revision, ) elif action in ("rungame", "rungameid"): if not db_game or not db_game["id"]: logger.warning("No game found in library") if not self.window.is_visible(): self.do_shutdown() return 0 self.launch(Game(db_game["id"])) return 0
def make_request(self, url): """Send a cookie authenticated HTTP request to GOG""" request = Request(url, cookies=self.load_cookies()) request.get() return request.json