Increment version

This reverts commit 55c7fcfd61e0391287e2717117da4fca03b77dec.

requirements.txt

@@ -2,7 +2,7 @@
 pytest==4.2.0
 pytest-asyncio==0.10.0
 pytest-mock==1.10.3
-pytest-mypy==0.3.2
+pytest-mypy==0.4.1
 pytest-flakes==4.0.0
 # because of pip bug https://github.com/pypa/pip/issues/4780
 aiohttp==3.5.4

setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="galaxy.plugin.api",
-    version="0.50",
+    version="0.52",
     description="GOG Galaxy Integrations Python API",
     author='Galaxy team',
     author_email='galaxy@gog.com',

src/galaxy/__init__.py

@@ -1 +1 @@
-__path__: str = __import__('pkgutil').extend_path(__path__, __name__)
+__path__: str = __import__('pkgutil').extend_path(__path__, __name__) # type: ignore

src/galaxy/api/consts.py

@@ -110,6 +110,7 @@ class Feature(Enum):
     ImportFriends = "ImportFriends"
     ShutdownPlatformClient = "ShutdownPlatformClient"
     LaunchPlatformClient = "LaunchPlatformClient"
+    ImportGameLibrarySettings = "ImportGameLibrarySettings"
 
 
 class LicenseType(Enum):

src/galaxy/api/plugin.py

@@ -10,7 +10,7 @@ from typing import Any, Dict, List, Optional, Set, Union
 from galaxy.api.consts import Feature
 from galaxy.api.errors import ImportInProgress, UnknownError
 from galaxy.api.jsonrpc import ApplicationError, NotificationClient, Server
-from galaxy.api.types import Achievement, Authentication, FriendInfo, Game, GameTime, LocalGame, NextStep
+from galaxy.api.types import Achievement, Authentication, FriendInfo, Game, GameTime, LocalGame, NextStep, GameLibrarySettings
 from galaxy.task_manager import TaskManager
 
 class JSONEncoder(json.JSONEncoder):
@@ -46,6 +46,7 @@ class Plugin:
 
         self._achievements_import_in_progress = False
         self._game_times_import_in_progress = False
+        self._game_library_settings_import_in_progress = False
 
         self._persistent_cache = dict()
 
@@ -109,6 +110,9 @@ class Plugin:
         self._register_method("start_game_times_import", self._start_game_times_import)
         self._detect_feature(Feature.ImportGameTime, ["get_game_time"])
 
+        self._register_method("start_game_library_settings_import", self._start_game_library_settings_import)
+        self._detect_feature(Feature.ImportGameLibrarySettings, ["get_game_library_settings"])
+
     async def __aenter__(self):
         return self
 
@@ -402,6 +406,20 @@ class Plugin:
     def _game_times_import_finished(self) -> None:
         self._notification_client.notify("game_times_import_finished", None)
 
+    def _game_library_settings_import_success(self, game_library_settings: GameLibrarySettings) -> None:
+        params = {"game_library_settings": game_library_settings}
+        self._notification_client.notify("game_library_settings_import_success", params)
+
+    def _game_library_settings_import_failure(self, game_id: str, error: ApplicationError) -> None:
+        params = {
+            "game_id": game_id,
+            "error": error.json()
+        }
+        self._notification_client.notify("game_library_settings_import_failure", params)
+
+    def _game_library_settings_import_finished(self) -> None:
+        self._notification_client.notify("game_library_settings_import_finished", None)
+
     def lost_authentication(self) -> None:
         """Notify the client that integration has lost authentication for the
          current user and is unable to perform actions which would require it.
@@ -750,6 +768,63 @@ class Plugin:
         (like updating cache).
         """
 
+    async def _start_game_library_settings_import(self, game_ids: List[str]) -> None:
+        if self._game_library_settings_import_in_progress:
+            raise ImportInProgress()
+
+        context = await self.prepare_game_library_settings_context(game_ids)
+
+        async def import_game_library_settings(game_id, context_):
+            try:
+                game_library_settings = await self.get_game_library_settings(game_id, context_)
+                self._game_library_settings_import_success(game_library_settings)
+            except ApplicationError as error:
+                self._game_library_settings_import_failure(game_id, error)
+            except Exception:
+                logging.exception("Unexpected exception raised in import_game_library_settings")
+                self._game_library_settings_import_failure(game_id, UnknownError())
+
+        async def import_game_library_settings_set(game_ids_, context_):
+            try:
+                imports = [import_game_library_settings(game_id, context_) for game_id in game_ids_]
+                await asyncio.gather(*imports)
+            finally:
+                self._game_library_settings_import_finished()
+                self._game_library_settings_import_in_progress = False
+                self.game_library_settings_import_complete()
+
+        self._external_task_manager.create_task(
+            import_game_library_settings_set(game_ids, context),
+            "game library settings import",
+            handle_exceptions=False
+        )
+        self._game_library_settings_import_in_progress = True
+
+    async def prepare_game_library_settings_context(self, game_ids: List[str]) -> Any:
+        """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.
+
+        :param game_ids: the ids of the games for which game time are imported
+        :return: context
+        """
+        return None
+
+    async def get_game_library_settings(self, game_id: str, context: Any) -> GameLibrarySettings:
+        """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.
+
+        :param game_id: the id of the game for which the game time is returned
+        :param context: the value returned from :meth:`prepare_game_library_settings_context`
+        :return: GameLibrarySettings object
+        """
+        raise NotImplementedError()
+
+    def game_library_settings_import_complete(self) -> None:
+        """Override this method to handle operations after game times import is finished
+        (like updating cache).
+        """
 
 def create_and_run_plugin(plugin_class, argv):
     """Call this method as an entry point for the implemented integration.

src/galaxy/api/types.py

@@ -151,3 +151,15 @@ class GameTime():
     game_id: str
     time_played: Optional[int]
     last_played_time: Optional[int]
+
+@dataclass
+class GameLibrarySettings():
+    """Library settings of a game, defines assigned tags and visibility flag.
+
+    :param game_id: id of the related game
+    :param tags: collection of tags assigned to the game
+    :param hidden: indicates if the game should be hidden in GOG Galaxy application
+    """
+    game_id: str
+    tags: Optional[List[str]]
+    hidden: Optional[bool]

src/galaxy/registry_monitor.py

@@ -0,0 +1,98 @@
+import sys
+if sys.platform == "win32":
+    import logging
+    import ctypes
+    from ctypes.wintypes import LONG, HKEY, LPCWSTR, DWORD, BOOL, HANDLE, LPVOID
+
+    LPSECURITY_ATTRIBUTES = LPVOID
+
+    RegOpenKeyEx = ctypes.windll.advapi32.RegOpenKeyExW
+    RegOpenKeyEx.restype = LONG
+    RegOpenKeyEx.argtypes = [HKEY, LPCWSTR, DWORD, DWORD, ctypes.POINTER(HKEY)]
+
+    RegCloseKey = ctypes.windll.advapi32.RegCloseKey
+    RegCloseKey.restype = LONG
+    RegCloseKey.argtypes = [HKEY]
+
+    RegNotifyChangeKeyValue = ctypes.windll.advapi32.RegNotifyChangeKeyValue
+    RegNotifyChangeKeyValue.restype = LONG
+    RegNotifyChangeKeyValue.argtypes = [HKEY, BOOL, DWORD, HANDLE, BOOL]
+
+    CloseHandle = ctypes.windll.kernel32.CloseHandle
+    CloseHandle.restype = BOOL
+    CloseHandle.argtypes = [HANDLE]
+
+    CreateEvent = ctypes.windll.kernel32.CreateEventW
+    CreateEvent.restype = BOOL
+    CreateEvent.argtypes = [LPSECURITY_ATTRIBUTES, BOOL, BOOL, LPCWSTR]
+
+    WaitForSingleObject = ctypes.windll.kernel32.WaitForSingleObject
+    WaitForSingleObject.restype = DWORD
+    WaitForSingleObject.argtypes = [HANDLE, DWORD]
+
+    ERROR_SUCCESS = 0x00000000
+
+    KEY_READ = 0x00020019
+    KEY_QUERY_VALUE = 0x00000001
+
+    REG_NOTIFY_CHANGE_NAME = 0x00000001
+    REG_NOTIFY_CHANGE_LAST_SET = 0x00000004
+
+    WAIT_OBJECT_0 = 0x00000000
+    WAIT_TIMEOUT = 0x00000102
+
+class RegistryMonitor:
+
+    def __init__(self, root, subkey):
+        self._root = root
+        self._subkey = subkey
+        self._event = CreateEvent(None, False, False, None)
+
+        self._key = None
+        self._open_key()
+        if self._key:
+            self._set_key_update_notification()
+
+    def close(self):
+        CloseHandle(self._event)
+        if self._key:
+            RegCloseKey(self._key)
+            self._key = None
+
+    def is_updated(self):
+        wait_result = WaitForSingleObject(self._event, 0)
+
+        # previously watched
+        if wait_result == WAIT_OBJECT_0:
+            self._set_key_update_notification()
+            return True
+
+        # no changes or no key before
+        if wait_result != WAIT_TIMEOUT:
+            # unexpected error
+            logging.warning("Unexpected WaitForSingleObject result %s", wait_result)
+            return False
+
+        if self._key is None:
+            self._open_key()
+
+        if self._key is None:
+            return False
+
+        self._set_key_update_notification()
+        return True
+
+    def _set_key_update_notification(self):
+        filter_ = REG_NOTIFY_CHANGE_NAME | REG_NOTIFY_CHANGE_LAST_SET
+        status = RegNotifyChangeKeyValue(self._key, True, filter_, self._event, True)
+        if status != ERROR_SUCCESS:
+            # key was deleted
+            RegCloseKey(self._key)
+            self._key = None
+
+    def _open_key(self):
+        access = KEY_QUERY_VALUE | KEY_READ
+        self._key = HKEY()
+        rc = RegOpenKeyEx(self._root, self._subkey, 0, access, ctypes.byref(self._key))
+        if rc != ERROR_SUCCESS:
+            self._key = None

tests/conftest.py

@@ -49,7 +49,10 @@ async def plugin(reader, writer):
         "game_times_import_complete",
         "shutdown_platform_client",
         "shutdown",
-        "tick"
+        "tick",
+        "get_game_library_settings",
+        "prepare_game_library_settings_context",
+        "game_library_settings_import_complete",
     )
 
     with ExitStack() as stack:

tests/test_features.py

@@ -14,7 +14,8 @@ def test_base_class():
         Feature.ImportGameTime,
         Feature.ImportFriends,
         Feature.ShutdownPlatformClient,
-        Feature.LaunchPlatformClient
+        Feature.LaunchPlatformClient,
+        Feature.ImportGameLibrarySettings
     }
 
 

tests/test_game_library_settings.py

@@ -0,0 +1,196 @@
+from unittest.mock import call
+
+import pytest
+from galaxy.api.types import GameLibrarySettings
+from galaxy.api.errors import BackendError
+from galaxy.unittest.mock import async_return_value
+
+from tests import create_message, get_messages
+
+
+@pytest.mark.asyncio
+async def test_get_game_time_success(plugin, read, write):
+    plugin.prepare_game_library_settings_context.return_value = async_return_value("abc")
+    request = {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "method": "start_game_library_settings_import",
+        "params": {
+            "game_ids": ["3", "5", "7"]
+        }
+    }
+    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    plugin.get_game_library_settings.side_effect = [
+        async_return_value(GameLibrarySettings("3", None, True)),
+        async_return_value(GameLibrarySettings("5", [], False)),
+        async_return_value(GameLibrarySettings("7", ["tag1", "tag2", "tag3"], None)),
+    ]
+    await plugin.run()
+    plugin.get_game_library_settings.assert_has_calls([
+        call("3", "abc"),
+        call("5", "abc"),
+        call("7", "abc"),
+    ])
+    plugin.game_library_settings_import_complete.assert_called_once_with()
+
+    assert get_messages(write) == [
+        {
+            "jsonrpc": "2.0",
+            "id": "3",
+            "result": None
+        },
+        {
+            "jsonrpc": "2.0",
+            "method": "game_library_settings_import_success",
+            "params": {
+                "game_library_settings": {
+                    "game_id": "3",
+                    "hidden": True
+                }
+            }
+        },
+        {
+            "jsonrpc": "2.0",
+            "method": "game_library_settings_import_success",
+            "params": {
+                "game_library_settings": {
+                    "game_id": "5",
+                    "tags": [],
+                    "hidden": False
+                }
+            }
+        },
+        {
+            "jsonrpc": "2.0",
+            "method": "game_library_settings_import_success",
+            "params": {
+                "game_library_settings": {
+                    "game_id": "7",
+                    "tags": ["tag1", "tag2", "tag3"]
+                }
+            }
+        },
+        {
+            "jsonrpc": "2.0",
+            "method": "game_library_settings_import_finished",
+            "params": None
+        }
+    ]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("exception,code,message", [
+    (BackendError, 4, "Backend error"),
+    (KeyError, 0, "Unknown error")
+])
+async def test_get_game_library_settings_error(exception, code, message, plugin, read, write):
+    plugin.prepare_game_library_settings_context.return_value = async_return_value(None)
+    request = {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "method": "start_game_library_settings_import",
+        "params": {
+            "game_ids": ["6"]
+        }
+    }
+    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    plugin.get_game_library_settings.side_effect = exception
+    await plugin.run()
+    plugin.get_game_library_settings.assert_called()
+    plugin.game_library_settings_import_complete.assert_called_once_with()
+
+    assert get_messages(write) == [
+        {
+            "jsonrpc": "2.0",
+            "id": "3",
+            "result": None
+        },
+        {
+            "jsonrpc": "2.0",
+            "method": "game_library_settings_import_failure",
+            "params": {
+                "game_id": "6",
+                "error": {
+                    "code": code,
+                    "message": message
+                }
+            }
+        },
+        {
+            "jsonrpc": "2.0",
+            "method": "game_library_settings_import_finished",
+            "params": None
+        }
+    ]
+
+
+@pytest.mark.asyncio
+async def test_prepare_get_game_library_settings_context_error(plugin, read, write):
+    plugin.prepare_game_library_settings_context.side_effect = BackendError()
+    request = {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "method": "start_game_library_settings_import",
+        "params": {
+            "game_ids": ["6"]
+        }
+    }
+    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    await plugin.run()
+
+    assert get_messages(write) == [
+        {
+            "jsonrpc": "2.0",
+            "id": "3",
+            "error": {
+                "code": 4,
+                "message": "Backend error"
+            }
+        }
+    ]
+
+
+@pytest.mark.asyncio
+async def test_import_in_progress(plugin, read, write):
+    plugin.prepare_game_library_settings_context.return_value = async_return_value(None)
+    requests = [
+        {
+            "jsonrpc": "2.0",
+            "id": "3",
+            "method": "start_game_library_settings_import",
+            "params": {
+                "game_ids": ["6"]
+            }
+        },
+        {
+            "jsonrpc": "2.0",
+            "id": "4",
+            "method": "start_game_library_settings_import",
+            "params": {
+                "game_ids": ["7"]
+            }
+        }
+    ]
+    read.side_effect = [
+        async_return_value(create_message(requests[0])),
+        async_return_value(create_message(requests[1])),
+        async_return_value(b"", 10)
+    ]
+
+    await plugin.run()
+
+    messages = get_messages(write)
+    assert {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "result": None
+    } in messages
+    assert {
+        "jsonrpc": "2.0",
+        "id": "4",
+        "error": {
+            "code": 600,
+            "message": "Import already in progress"
+        }
+    } in messages
+