pyrekordbox 0.4.2__py3-none-any.whl → 0.4.4__py3-none-any.whl

pyrekordbox/config.py

@@ -8,30 +8,18 @@ Contains all the path and settings handling of the Rekordbox installation(s) on
 the users machine.
 """
 
-import base64
 import json
 import logging
 import os
-import re
 import sys
-import textwrap
-import time
 import xml.etree.cElementTree as xml
 from pathlib import Path
-from typing import Union
+from typing import Any, Dict, List, Union
 
-import blowfish
-import frida
 import packaging.version
 
-from .utils import get_rekordbox_pid
-
 logger = logging.getLogger(__name__)
 
-# Cache file for pyrekordbox data
-_cache_file_version = 2
-_cache_file_name = "rb.cache"
-
 # Define empty pyrekordbox configuration
 __config__ = {
     "pioneer": {
@@ -48,29 +36,6 @@ class InvalidApplicationDirname(Exception):
     pass
 
 
-def get_appdata_dir() -> Path:
-    """Returns the path of the application data directory.
-
-    On Windows, the application data is stored in `/Users/user/AppData/Roaming`.
-    On macOS the application data is stored in `~/Libary/Application Support`.
-    """
-    if sys.platform == "win32":
-        # Windows: located in /Users/user/AppData/Roaming/
-        app_data = Path(os.environ["AppData"])
-    elif sys.platform == "darwin":
-        # MacOS: located in ~/Library/Application Support/
-        app_data = Path("~").expanduser() / "Library" / "Application Support"
-    else:
-        # Linux: not supported
-        logger.warning(f"OS {sys.platform} not supported!")
-        return Path("~").expanduser() / ".local" / "share"
-    return app_data
-
-
-def get_cache_file() -> Path:
-    return get_appdata_dir() / "pyrekordbox" / _cache_file_name
-
-
 def get_pioneer_install_dir(path: Union[str, Path] = None) -> Path:  # pragma: no cover
     """Returns the path of the Pioneer program installation directory.
 
@@ -151,7 +116,7 @@ def get_pioneer_app_dir(path: Union[str, Path] = None) -> Path:  # pragma: no co
     return path
 
 
-def _convert_type(s):
+def _convert_type(s: str) -> Union[str, int, float, List[int], List[float]]:
     # Try to parse as int, float, list of int, list of float
     types_ = int, float
     for type_ in types_:
@@ -167,7 +132,7 @@ def _convert_type(s):
     return s
 
 
-def read_rekordbox_settings(rekordbox_app_dir: Union[str, Path]) -> dict:
+def read_rekordbox_settings(rekordbox_app_dir: Union[str, Path]) -> Dict[str, Any]:
     """Finds and parses the 'rekordbox3.settings' file in the Rekordbox 5 or 6 app-dir.
 
     The settings file usually is called 'rekordbox3.settings' and is
@@ -197,12 +162,12 @@ def read_rekordbox_settings(rekordbox_app_dir: Union[str, Path]) -> dict:
             val = _convert_type(element.attrib["val"])
         except KeyError:
             device_setup = element.find("DEVICESETUP")
-            val = {k: _convert_type(v) for k, v in device_setup.attrib.items()}
+            val = {k: _convert_type(v) for k, v in device_setup.attrib.items()}  # type: ignore
         settings[name] = val
     return settings
 
 
-def read_rekordbox6_options(pioneer_app_dir: Union[str, Path]) -> dict:
+def read_rekordbox6_options(pioneer_app_dir: Union[str, Path]) -> Dict[str, Any]:
     """Finds and parses the Rekordbox 6 `options.json` file with additional settings.
 
     The options file contains additional settings used by Rekordbox 6, for example the
@@ -231,47 +196,7 @@ def read_rekordbox6_options(pioneer_app_dir: Union[str, Path]) -> dict:
     return options
 
 
-def read_rekordbox6_asar(rb6_install_dir: Union[str, Path]) -> str:
-    """Finds and parses the Rekordbox 6 `app.asar` archive file.
-
-    An ASAR file is an archive used to package source code for an application
-    using Electron. Rekordbox 6 stores some useful information for opening the
-    new `master.db` database in this file.
-
-    Parameters
-    ----------
-    rb6_install_dir : str or Path
-        The path of the Rekordbox 6 installation directory.
-
-    Returns
-    -------
-    asar_data : str
-        The data of the Rekordbox 6 `app.asar` archive file as ANSI encoded string.
-    """
-    rb6_install_dir = Path(rb6_install_dir)
-    # Find location of app asar file
-    if sys.platform == "win32":
-        location = rb6_install_dir / "rekordboxAgent-win32-x64" / "resources"
-        encoding = "ANSI"
-    elif sys.platform == "darwin":
-        if not str(rb6_install_dir).endswith(".app"):
-            rb6_install_dir = rb6_install_dir / "rekordbox.app"
-        location = (
-            rb6_install_dir / "Contents" / "MacOS" / "rekordboxAgent.app" / "Contents" / "Resources"
-        )
-        encoding = "cp437"
-    else:
-        logger.warning(f"OS {sys.platform} not supported!")
-        return ""
-
-    # Read asar file
-    path = (location / "app.asar").absolute()
-    with open(path, "rb") as fh:
-        data = fh.read().decode(encoding, errors="replace")
-    return data
-
-
-def _extract_version(name, major_version):
+def _extract_version(name: str, major_version: int) -> str:
     name = name.replace(".app", "")  # Needed for MacOS
     ver_str = name.replace("rekordbox", "").strip()
     if not ver_str:
@@ -284,7 +209,7 @@ def _get_rb_config(
     pioneer_app_dir: Path,
     major_version: int,
     application_dirname: str = "",
-) -> dict:
+) -> Dict[str, Any]:
     """Get the program configuration for a given Rekordbox major version.
 
     Parameters
@@ -378,207 +303,18 @@ def _get_rb_config(
     return conf
 
 
-def _get_rb5_config(pioneer_prog_dir: Path, pioneer_app_dir: Path, dirname: str = "") -> dict:
+def _get_rb5_config(
+    pioneer_prog_dir: Path, pioneer_app_dir: Path, dirname: str = ""
+) -> Dict[str, Any]:
     """Get the program configuration for Rekordbox v5.x.x."""
     major_version = 5
     conf = _get_rb_config(pioneer_prog_dir, pioneer_app_dir, major_version, dirname)
     return conf
 
 
-def _extract_pw(pioneer_install_dir: Path) -> str:  # pragma: no cover
-    """Extract the password for decrypting the Rekordbox 6 database key."""
-    asar_data = read_rekordbox6_asar(pioneer_install_dir)
-    match_result = re.search('pass: ".(.*?)"', asar_data)
-    if match_result is None:
-        raise RuntimeError("Could not read `app.asar` file.")
-    match = match_result.group(0)
-    pw = match.replace("pass: ", "").strip('"')
-    return pw
-
-
-class KeyExtractor:
-    """Extracts the Rekordbox database key using code injection.
-
-    This method works by injecting code into the Rekordbox process and intercepting the
-    call to unlock the database. Works for any Rekordbox version.
-    """
-
-    # fmt: off
-    SCRIPT = textwrap.dedent("""
-    var sqlite3_key = Module.findExportByName(null, 'sqlite3_key');
-
-    Interceptor.attach(sqlite3_key, {
-        onEnter: function(args) {
-            var size = args[2].toInt32();
-            var key = args[1].readUtf8String(size);
-            send('sqlite3_key: ' + key);
-        }
-    });
-    """)
-    # fmt: on
-
-    def __init__(self, rekordbox_executable):
-        self.executable = str(rekordbox_executable)
-        self.key = ""
-
-    def on_message(self, message, data):
-        payload = message["payload"]
-        if payload.startswith("sqlite3_key"):
-            self.key = payload.split(": ")[1]
-
-    def run(self):
-        pid = get_rekordbox_pid()
-        if pid:
-            raise RuntimeError(
-                "Rekordbox is running. Please close Rekordbox before running the `KeyExtractor`."
-            )
-        # Spawn Rekordbox process and attach to it
-        pid = frida.spawn(self.executable)
-        frida.resume(pid)
-        session = frida.attach(pid)
-        script = session.create_script(self.SCRIPT)
-        script.on("message", self.on_message)
-        script.load()
-        # Wait for key to be extracted
-        while not self.key:
-            time.sleep(0.1)
-        # Kill Rekordbox process
-        frida.kill(pid)
-
-        return self.key
-
-
-def write_db6_key_cache(key: str) -> None:  # pragma: no cover
-    r"""Writes the decrypted Rekordbox6 database key to the cache file.
-
-    This method can also be used to manually cache the database key, provided
-    the user has found the key somewhere else. The key can be, for example,
-    found in some other projects that hard-coded it.
-
-    The cache file is stored in the application data directory of pyrekordbox:
-    Windows: `C:\Users\<user>\AppData\Roaming\pyrekordbox`
-    macOS: `~/Library/Application Support/pyrekordbox`
-
-    Parameters
-    ----------
-    key : str
-        The decrypted database key. To make sure the key is valid, the first
-        five characters are checked before writing the key to the cache file.
-        The key should start with '402fd'.
-
-    Examples
-    --------
-    >>> from pyrekordbox.config import write_db6_key_cache
-    >>> from pyrekordbox import Rekordbox6Database
-    >>> write_db6_key_cache("402fd...")
-    >>> db = Rekordbox6Database()  # The db can now be opened without providing the key
-    """
-    # Check if the key looks like a valid key
-    if not key.startswith("402fd"):
-        raise ValueError("The provided database key doesn't look valid!")
-    lines = list()
-    lines.append(f"version: {_cache_file_version}")
-    lines.append("dp: " + key)
-    text = "\n".join(lines)
-
-    cache_file = get_cache_file()
-    if not cache_file.parent.exists():
-        cache_file.parent.mkdir()
-
-    with open(cache_file, "w") as fh:
-        fh.write(text)
-    # Set the config key to make sure the key is present after calling method
-    if __config__["rekordbox6"]:
-        __config__["rekordbox6"]["dp"] = key
-    if __config__["rekordbox7"]:
-        __config__["rekordbox7"]["dp"] = key
-
-
-def _update_sqlite_key(opts, conf):
-    cache_version = 0
-    pw, dp = "", ""
-
-    cache_file = get_cache_file()
-
-    if cache_file.exists():  # pragma: no cover
-        logger.debug("Found cache file %s", cache_file)
-        # Read cache file
-        with open(cache_file, "r") as fh:
-            text = fh.read()
-        lines = text.splitlines()
-        if lines[0].startswith("version:"):
-            cache_version = int(lines[0].split(":")[1].strip())
-        else:
-            cache_version = 1
-        if cache_version == 1:
-            # Cache file introduced in pyrekordbox 0.1.6 contains only the password
-            pw = lines[0]
-            logger.debug("Found pw in cache file")
-        elif cache_version == 2:
-            # Cache file introduced in pyrekordbox 0.1.7 contains version and db key
-            dp = lines[1].split(":")[1].strip()
-            logger.debug("Found dp in cache file")
-        else:
-            raise ValueError(f"Invalid cache version: {cache_version}")
-    else:
-        logger.debug("No cache file found")
-
-    if cache_version < _cache_file_version:  # pragma: no cover
-        # Update cache file
-        if not pw:
-            logger.debug("Extracting pw")
-            try:
-                pw = _extract_pw(conf["install_dir"])
-                logger.debug("Extracted pw from 'app.asar'")
-            except (FileNotFoundError, RuntimeError):
-                logger.debug("Could not extract pw from 'app.asar'")
-                pw = ""
-
-        if not dp:
-            if pw:
-                cipher = blowfish.Cipher(pw.encode())
-                dp = base64.standard_b64decode(opts["dp"])
-                dp = b"".join(cipher.decrypt_ecb(dp)).decode()
-                logger.debug("Unlocked dp from pw: %s", dp)
-            else:
-                if sys.platform == "win32":
-                    executable = conf["install_dir"] / "rekordbox.exe"
-                elif sys.platform == "darwin":
-                    install_dir = conf["install_dir"]
-                    if not str(install_dir).endswith(".app"):
-                        install_dir = install_dir / "rekordbox.app"
-                    executable = install_dir / "Contents" / "MacOS" / "rekordbox"
-                else:
-                    # Linux: not supported
-                    logger.warning(f"OS {sys.platform} not supported!")
-                    executable = Path("")
-
-                if not executable.exists():
-                    logger.warning(f"Could not find Rekordbox executable: {executable}")
-                else:
-                    extractor = KeyExtractor(executable)
-                    try:
-                        dp = extractor.run()
-                        logger.debug("Extracted dp from Rekordbox process")
-                    except Exception as e:
-                        logger.info(f"`KeyExtractor` failed: {e}")
-
-        if dp:
-            logger.debug("Writing dp to cache file")
-            write_db6_key_cache(dp)
-        else:
-            logging.warning(
-                "Could not retrieve db-key or read it from cache file,"
-                "use the CLI to download it from external sources: "
-                "`python -m pyrekordbox download-key`"
-            )
-
-    # Add database key to config if found
-    if dp:
-        conf["dp"] = dp
-
-
-def _get_rb6_config(pioneer_prog_dir: Path, pioneer_app_dir: Path, dirname: str = "") -> dict:
+def _get_rb6_config(
+    pioneer_prog_dir: Path, pioneer_app_dir: Path, dirname: str = ""
+) -> Dict[str, Any]:
     """Get the program configuration for Rekordbox v6.x.x."""
     major_version = 6
     conf = _get_rb_config(pioneer_prog_dir, pioneer_app_dir, major_version, dirname)
@@ -590,13 +326,12 @@ def _get_rb6_config(pioneer_prog_dir: Path, pioneer_app_dir: Path, dirname: str
     assert str(conf["db_dir"]) == str(db_dir)
     assert str(conf["db_path"]) == str(db_path)
 
-    # Update SQLite key
-    _update_sqlite_key(opts, conf)
-
     return conf
 
 
-def _get_rb7_config(pioneer_prog_dir: Path, pioneer_app_dir: Path, dirname: str = "") -> dict:
+def _get_rb7_config(
+    pioneer_prog_dir: Path, pioneer_app_dir: Path, dirname: str = ""
+) -> Dict[str, Any]:
     """Get the program configuration for Rekordbox v7.x.x."""
     major_version = 7
     conf = _get_rb_config(pioneer_prog_dir, pioneer_app_dir, major_version, dirname)
@@ -608,76 +343,16 @@ def _get_rb7_config(pioneer_prog_dir: Path, pioneer_app_dir: Path, dirname: str
     assert str(conf["db_dir"]) == str(db_dir)
     assert str(conf["db_path"]) == str(db_path)
 
-    # Update SQLite key
-    _update_sqlite_key(opts, conf)
-
     return conf
 
 
-# noinspection PyPackageRequirements,PyUnresolvedReferences
-def _read_config_file(path: str) -> dict:
-    path = Path(path)
-    if not path.exists():
-        raise FileNotFoundError(f"No such file or directory: '{path}'")
-
-    ext = path.suffix.lower()
-    if ext == ".cfg":
-        from configparser import ConfigParser
-
-        parser = ConfigParser()
-        parser.read(path)
-        return parser
-    elif ext == ".toml":
-        import toml
-
-        return toml.load(path)
-    elif ext in (".yaml", ".yml"):
-        import yaml
-
-        with open(path, "r") as stream:
-            return yaml.safe_load(stream)
-    return dict()
-
-
-def read_pyrekordbox_configuration():
-    """Reads the pyrekordbox configuration.
-
-    So far only the `pioneer-install-dir` and `pioneer-app-dir` fileds in the
-    `rekordbox` section are supported. Supported configuration files are
-    pyproject.toml, setup.cfg, rekordbox.toml, rekordbox.cfg and rekordbox.yml.
-    The files are searched for in that order.
-
-    Returns
-    -------
-    pyrekordbox_config : dict
-        The pyrekordbox configuration data, if found.
-    """
-    files = ["pyproject.toml", "setup.cfg"]
-    for ext in [".toml", ".cfg", ".yaml", ".yml"]:
-        files.append("pyrekordbox" + ext)
-
-    for file in files:
-        try:
-            data = _read_config_file(file)
-            config = dict(data["rekordbox"])
-            logger.debug("Read configuration from '%s'", file)
-        except (ImportError, FileNotFoundError) as e:
-            logger.debug("Could not read config file '%s': %s", file, e)
-        except KeyError:
-            pass
-        else:
-            if config:
-                return config
-    return dict()
-
-
 def update_config(
     pioneer_install_dir: Union[str, Path] = None,
     pioneer_app_dir: Union[str, Path] = None,
     rb5_install_dirname: str = "",
     rb6_install_dirname: str = "",
     rb7_install_dirname: str = "",
-):
+) -> None:
     """Update the pyrekordbox configuration.
 
     This method scans the system for the Rekordbox installation and application data
@@ -707,19 +382,6 @@ def update_config(
         The name of the Rekordbox 7 installation directory. By default, the normal
         directory name is used (Windows: 'rekordbox 7.x.x', macOS: 'rekordbox 7.app').
     """
-    # Read config file
-    conf = read_pyrekordbox_configuration()
-    if pioneer_install_dir is None and "pioneer-install-dir" in conf:
-        pioneer_install_dir = conf["pioneer-install-dir"]
-    if pioneer_app_dir is None and "pioneer-app-dir" in conf:
-        pioneer_app_dir = conf["pioneer-app-dir"]
-    if not rb5_install_dirname and "rekordbox5-install-dirname" in conf:
-        rb5_install_dirname = conf["rekordbox5-install-dirname"]
-    if not rb6_install_dirname and "rekordbox6-install-dirname" in conf:
-        rb6_install_dirname = conf["rekordbox6-install-dirname"]
-    if not rb7_install_dirname and "rekordbox7-install-dirname" in conf:
-        rb7_install_dirname = conf["rekordbox7-install-dirname"]
-
     # Pioneer installation directory
     try:
         pioneer_install_dir = get_pioneer_install_dir(pioneer_install_dir)
@@ -758,7 +420,7 @@ def update_config(
         logger.info(e)
 
 
-def get_config(section: str, key: str = None):
+def get_config(section: str, key: str = None) -> Any:
     """Gets a section or value of the pyrekordbox configuration.
 
     Parameters

pyrekordbox/db6/aux_files.py

@@ -5,10 +5,20 @@
 import xml.etree.cElementTree as xml
 from datetime import datetime
 from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
 
 from ..config import get_config
 from ..utils import pretty_xml
 
+Attribs = Dict[str, Any]
+
+
+class XmlElementNotInitializedError(Exception):
+    """Raised when an XML element is not initialized."""
+
+    def __init__(self, name: str) -> None:
+        super().__init__(f"XML element {name} is not initialized!")
+
 
 class MasterPlaylistXml:
     """Rekordbox v6 masterPlaylists6.xml file handler.
@@ -26,7 +36,7 @@ class MasterPlaylistXml:
 
     KEYS = ["Id", "ParentId", "Attributes", "Timestamp", "Lib_Type", "CheckType"]
 
-    def __init__(self, path=None, db_dir=None):
+    def __init__(self, path: Union[str, Path] = None, db_dir: Union[str, Path] = None):
         if path is None:
             if db_dir is None:
                 db_dir = get_config("rekordbox6", "db_dir")
@@ -40,29 +50,33 @@ class MasterPlaylistXml:
         self._changed = False
 
     @property
-    def version(self):
+    def version(self) -> str:
         return self.root.attrib["Version"]
 
     @property
-    def automatic_sync(self):
+    def automatic_sync(self) -> str:
         return self.root.attrib["AutomaticSync"]
 
     @property
-    def rekordbox_version(self):
+    def rekordbox_version(self) -> str:
+        if self.product is None:
+            raise XmlElementNotInitializedError("product")
         return self.product.attrib["Version"]
 
     @property
-    def modified(self):
+    def modified(self) -> bool:
         return self._changed
 
-    def get_playlists(self):
+    def get_playlists(self) -> List[Dict[str, Any]]:
         """Returns a list of the attributes of all playlist elements."""
+        if self.playlists is None:
+            raise XmlElementNotInitializedError("playlists")
         items = list()
         for playlist in self.playlists:
             items.append(playlist.attrib)
         return items
 
-    def get(self, playlist_id):
+    def get(self, playlist_id: Union[str, int]) -> Optional[Attribs]:
         """Returns element attribs with the PlaylistID used in the `master.db` database.
 
         Parameters
@@ -75,11 +89,13 @@ class MasterPlaylistXml:
         -------
         playlist : dict
         """
+        if self.playlists is None:
+            raise XmlElementNotInitializedError("playlists")
         hex_id = f"{int(playlist_id):X}"
         element = self.playlists.find(f'.//NODE[@Id="{hex_id}"]')
         if element is None:
             return None
-        attribs = dict(element.attrib)
+        attribs: Attribs = dict(element.attrib)
         attribs["Attribute"] = int(attribs["Attribute"])
         attribs["Timestamp"] = datetime.fromtimestamp(int(attribs["Timestamp"]) / 1000)
         attribs["Lib_Type"] = int(attribs["Lib_Type"])
@@ -94,7 +110,7 @@ class MasterPlaylistXml:
         updated_at: datetime,
         lib_type: int = 0,
         check_type: int = 0,
-    ):
+    ) -> xml.Element:
         """Adds a new element with the PlaylistID used in the `master.db` database.
 
         Parameters
@@ -119,6 +135,9 @@ class MasterPlaylistXml:
         element : xml.Element
             The newly created element.
         """
+        if self.playlists is None:
+            raise XmlElementNotInitializedError("playlists")
+
         hex_id = f"{int(playlist_id):X}"
         parent_id = f"{int(parent_id):X}" if parent_id != "root" else "0"
         timestamp = int(updated_at.timestamp() * 1000)
@@ -136,7 +155,7 @@ class MasterPlaylistXml:
         self._changed = True
         return element
 
-    def remove(self, playlist_id):
+    def remove(self, playlist_id: Union[str, int]) -> None:
         """Removes the element with the PlaylistID used in the `master.db` database.
 
         Parameters
@@ -145,6 +164,9 @@ class MasterPlaylistXml:
             The playlist ID used in the main `master.db` database. This id is converted
             to hexadecimal format before searching.
         """
+        if self.playlists is None:
+            raise XmlElementNotInitializedError("playlists")
+
         hex_id = f"{int(playlist_id):X}"
         element = self.playlists.find(f'.//NODE[@Id="{hex_id}"]')
         if element is None:
@@ -160,7 +182,7 @@ class MasterPlaylistXml:
         updated_at: datetime = None,
         lib_type: int = None,
         check_type: int = None,
-    ):
+    ) -> None:
         """Updates the element with the PlaylistID used in the `master.db` database.
 
         Parameters
@@ -180,6 +202,9 @@ class MasterPlaylistXml:
         check_type : int, optional
             The check type. It seems to be always 0.
         """
+        if self.playlists is None:
+            raise XmlElementNotInitializedError("playlists")
+
         hex_id = f"{int(playlist_id):X}"
         element = self.playlists.find(f'.//NODE[@Id="{hex_id}"]')
         if element is None:
@@ -200,10 +225,11 @@ class MasterPlaylistXml:
         element.attrib.update(attribs)
         self._changed = True
 
-    def to_string(self, indent=None):
-        return pretty_xml(self.root, indent, encoding="utf-8")
+    def to_string(self, indent: str = None) -> str:
+        text: str = pretty_xml(self.root, indent, encoding="utf-8")
+        return text
 
-    def save(self, path=None, indent=None):
+    def save(self, path: Union[str, Path] = None, indent: str = None) -> None:
         if path is None:
             path = self.path
         path = str(path)