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

pyrekordbox/__init__.py

@@ -2,6 +2,7 @@
 # Author: Dylan Jones
 # Date:   2022-04-10
 
+# mypy: disable-error-code="attr-defined"
 from .anlz import AnlzFile, get_anlz_paths, read_anlz_files, walk_anlz_paths
 from .config import get_config, show_config, update_config
 from .db6 import Rekordbox6Database

pyrekordbox/__main__.py

@@ -3,30 +3,10 @@
 # Date:   2023-08-15
 
 import os
-import re
 import shutil
 import sys
-import urllib.request
 from pathlib import Path
 
-from pyrekordbox.config import get_cache_file, write_db6_key_cache
-
-KEY_SOURCES = [
-    {
-        "url": r"https://raw.githubusercontent.com/mganss/CueGen/19878e6eb3f586dee0eb3eb4f2ce3ef18309de9d/CueGen/Generator.cs",  # noqa: E501
-        "regex": re.compile(
-            r'((.|\n)*)Config\.UseSqlCipher.*\?.*"(?P<dp>.*)".*:.*null',
-            flags=re.IGNORECASE | re.MULTILINE,
-        ),
-    },
-    {
-        "url": r"https://raw.githubusercontent.com/dvcrn/go-rekordbox/8be6191ba198ed7abd4ad6406d177ed7b4f749b5/cmd/getencryptionkey/main.go",  # noqa: E501
-        "regex": re.compile(
-            r'((.|\n)*)fmt\.Print\("(?P<dp>.*)"\)', flags=re.IGNORECASE | re.MULTILINE
-        ),
-    },
-]
-
 
 class WorkingDir:
     def __init__(self, path):
@@ -130,40 +110,12 @@ def install_pysqlcipher(
             print(f"Could not remove temporary directory '{tmpdir}'!")
 
 
-def download_db6_key():
-    dp = ""
-    for source in KEY_SOURCES:
-        url = source["url"]
-        regex = source["regex"]
-        print(f"Looking for key: {url}")
-
-        res = urllib.request.urlopen(url)
-        data = res.read().decode("utf-8")
-        match = regex.match(data)
-        if match:
-            dp = match.group("dp")
-            break
-    if dp:
-        cache_file = get_cache_file()
-        print(f"Found key, updating cache file {cache_file}")
-        write_db6_key_cache(dp)
-    else:
-        print("No key found in the online sources.")
-
-
 def main():
     from argparse import ArgumentParser
 
     parser = ArgumentParser("pyrekordbox")
     subparsers = parser.add_subparsers(dest="command")
 
-    # Download Rekordbx 6 database key command
-    subparsers.add_parser(
-        "download-key",
-        help="Download the Rekordbox 6 database key from the internet "
-        "and write it to the cache file.",
-    )
-
     # Install pysqlcipher3 command (Windows only)
     install_parser = subparsers.add_parser(
         "install-sqlcipher",
@@ -192,9 +144,7 @@ def main():
 
     # Parse args and handle command
     args = parser.parse_args(sys.argv[1:])
-    if args.command == "download-key":
-        download_db6_key()
-    elif args.command == "install-sqlcipher":
+    if args.command == "install-sqlcipher":
         install_pysqlcipher(args.tmpdir, args.cryptolib, install=not args.buildonly)
 
 

pyrekordbox/_version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '0.4.2'
-__version_tuple__ = version_tuple = (0, 4, 2)
+__version__ = version = '0.4.4'
+__version_tuple__ = version_tuple = (0, 4, 4)
+
+__commit_id__ = commit_id = None

pyrekordbox/anlz/__init__.py

@@ -4,7 +4,7 @@
 
 import re
 from pathlib import Path
-from typing import Union
+from typing import Dict, Iterator, Tuple, Union
 
 from . import structs
 from .file import AnlzFile
@@ -42,7 +42,7 @@ def is_anlz_file(path: Union[str, Path]) -> bool:
     return bool(RE_ANLZ.match(path.name))
 
 
-def get_anlz_paths(root: Union[str, Path]) -> dict:
+def get_anlz_paths(root: Union[str, Path]) -> Dict[str, Union[Path, None]]:
     """Returns the paths of all existing ANLZ files in a directory.
 
     Parameters
@@ -62,14 +62,14 @@ def get_anlz_paths(root: Union[str, Path]) -> dict:
     >>> p["DAT"]
     directory/ANLZ0000.DAT
     """
-    paths = {"DAT": None, "EXT": None, "2EX": None}
+    paths: Dict[str, Union[Path, None]] = {"DAT": None, "EXT": None, "2EX": None}
     for path in Path(root).iterdir():
         if RE_ANLZ.match(path.name):
             paths[path.suffix[1:].upper()] = path
     return paths
 
 
-def walk_anlz_dirs(root_dir: Union[str, Path]):
+def walk_anlz_dirs(root_dir: Union[str, Path]) -> Iterator[Path]:
     """Finds all ANLZ directory paths recursively.
 
     Parameters
@@ -88,7 +88,7 @@ def walk_anlz_dirs(root_dir: Union[str, Path]):
                 yield path
 
 
-def walk_anlz_paths(root_dir: Union[str, Path]):
+def walk_anlz_paths(root_dir: Union[str, Path]) -> Iterator[Tuple[Path, Dict[str, Path]]]:
     """Finds all ANLZ directory paths and the containing file paths recursively.
 
     Parameters
@@ -110,7 +110,7 @@ def walk_anlz_paths(root_dir: Union[str, Path]):
         yield anlz_dir, files
 
 
-def read_anlz_files(root: Union[str, Path] = "") -> dict:
+def read_anlz_files(root: Union[str, Path] = "") -> Dict[Path, AnlzFile]:
     """Open all ANLZ files in the given root directory.
 
     Parameters

pyrekordbox/anlz/file.py

@@ -5,12 +5,12 @@
 import logging
 from collections import abc
 from pathlib import Path
-from typing import Union
+from typing import Any, Iterator, List, Union
 
-from construct import Int16ub
+from construct import Int16ub, Struct
 
 from . import structs
-from .tags import TAGS
+from .tags import TAGS, AbstractAnlzTag, StructNotInitializedError
 
 logger = logging.getLogger(__name__)
 
@@ -18,35 +18,35 @@ XOR_MASK = bytearray.fromhex("CB E1 EE FA E5 EE AD EE E9 D2 E9 EB E1 E9 F3 E8 E9
 
 
 class BuildFileLengthError(Exception):
-    def __init__(self, struct, len_data):
+    def __init__(self, struct: Struct, len_data: int) -> None:
         super().__init__(
             f"`len_file` ({struct.len_file}) of '{struct.type}' does not "
             f"match the data-length ({len_data})!"
         )
 
 
-class AnlzFile(abc.Mapping):
+class AnlzFile(abc.Mapping):  # type: ignore[type-arg]
     """Rekordbox `ANLZnnnn.xxx` binary file handler."""
 
-    def __init__(self):
-        self._path = ""
-        self.file_header = None
-        self.tags = list()
+    def __init__(self) -> None:
+        self._path: str = ""
+        self.file_header: Union[Struct, None] = None
+        self.tags: List[AbstractAnlzTag] = list()
 
     @property
-    def num_tags(self):
+    def num_tags(self) -> int:
         return len(self.tags)
 
     @property
-    def tag_types(self):
+    def tag_types(self) -> List[str]:
         return [tag.type for tag in self.tags]
 
     @property
-    def path(self):
+    def path(self) -> str:
         return self._path
 
     @classmethod
-    def parse(cls, data: bytes):
+    def parse(cls, data: bytes) -> "AnlzFile":
         """Parses the in-memory data of a Rekordbox analysis binary file.
 
         Parameters
@@ -64,7 +64,7 @@ class AnlzFile(abc.Mapping):
         return self
 
     @classmethod
-    def parse_file(cls, path: Union[str, Path]):
+    def parse_file(cls, path: Union[str, Path]) -> "AnlzFile":
         """Reads and parses a Rekordbox analysis binary file.
 
         Parameters
@@ -92,10 +92,10 @@ class AnlzFile(abc.Mapping):
             data = fh.read()
 
         self = cls.parse(data)
-        self._path = path
+        self._path = str(path)
         return self
 
-    def _parse(self, data: bytes):
+    def _parse(self, data: bytes) -> None:
         file_header = structs.AnlzFileHeader.parse(data)
         tag_type = file_header.type
         assert tag_type == "PMAI"
@@ -108,37 +108,45 @@ class AnlzFile(abc.Mapping):
             # Get the four byte struct type
             tag_type = tag_data[:4].decode("ascii")
 
+            # Get tag length from generic tag header
+            tag_struct = structs.AnlzTag.parse(tag_data)
+            len_tag = tag_struct.len_tag
+
             if tag_type == "PSSI":
                 # The version that rekordbox 6 *exports* is garbled with an XOR mask.
+                # Determine if the tag is garbled by checking the initial (masked) mood value.
                 # All bytes after byte 17 (len_e) are XOR-masked with a pattern that is
                 # generated by adding the value of len_e to each byte of XOR_MASK
 
                 # Check if the file is garbled (only on exported files)
                 # For this we check the validity of mood and bank
                 # Mood: High=1, Mid=2, Low=3
-                # Bank: 0-8
                 mood = Int16ub.parse(tag_data[18:20])
-                bank = Int16ub.parse(tag_data[28:30])
-                if 1 <= mood <= 3 and 0 <= bank <= 8:
+                if 1 <= mood <= 3:
                     logger.debug("PSSI is not garbled!")
                 else:
-                    logger.debug("PSSI is garbled!")
-                    # deobfuscate tag_data[18:] using xor with XOR_MASK+len_entries
-                    len_entries = Int16ub.parse(tag_data[16:])
-                    tag_data = bytearray(data[i : i + len(tag_data)])
-                    for x in range(len(tag_data[18:])):
+                    logger.debug("PSSI is garbled! (raw_mood=%s)", mood)
+                    len_entries = Int16ub.parse(tag_data[16:18])
+
+                    # Copy only this tag's data so we don't mutate the remainder of file slice
+                    mutable_tag_data = bytearray(tag_data[:len_tag])
+
+                    for x in range(len(mutable_tag_data) - 18):
                         mask = XOR_MASK[x % len(XOR_MASK)] + len_entries
                         if mask > 255:
                             mask -= 256
-                        tag_data[x + 18] ^= mask
-                    tag_data = bytes(tag_data)
+                        mutable_tag_data[18 + x] ^= mask
+
+                    tag_data = bytes(mutable_tag_data)
 
             try:
                 # Parse the struct
                 tag = TAGS[tag_type](tag_data)
+                if tag.struct is None:
+                    raise StructNotInitializedError()
                 tags.append(tag)
                 len_header = tag.struct.len_header
-                len_tag = tag.struct.len_tag
+
                 logger.debug(
                     "Parsed struct '%s' (len_header=%s, len_tag=%s)",
                     tag_type,
@@ -147,28 +155,33 @@ class AnlzFile(abc.Mapping):
                 )
             except KeyError:
                 logger.warning("Tag '%s' not supported!", tag_type)
-                tag = structs.AnlzTag.parse(tag_data)
-                len_tag = tag.len_tag
+
             i += len_tag
 
         self.file_header = file_header
         self.tags = tags
 
-    def update_len(self):
+    def update_len(self) -> None:
         # Update struct lengths
+        if self.file_header is None:
+            raise StructNotInitializedError()
         tags_len = 0
         for tag in self.tags:
+            if tag.struct is None:
+                raise StructNotInitializedError()
             tag.update_len()
             tags_len += tag.struct.len_tag
         # Update file length
         len_file = self.file_header.len_header + tags_len
         self.file_header.len_file = len_file
 
-    def build(self):
+    def build(self) -> bytes:
+        if self.file_header is None:
+            raise StructNotInitializedError()
         self.update_len()
         header_data = structs.AnlzFileHeader.build(self.file_header)
         section_data = b"".join(tag.build() for tag in self.tags)
-        data = header_data + section_data
+        data: bytes = header_data + section_data
         # Check `len_file`
         len_file = self.file_header.len_file
         len_data = len(data)
@@ -177,38 +190,38 @@ class AnlzFile(abc.Mapping):
 
         return data
 
-    def save(self, path=""):
+    def save(self, path: Union[str, Path] = "") -> None:
         path = path or self._path
 
         data = self.build()
         with open(path, "wb") as fh:
             fh.write(data)
 
-    def get_tag(self, key):
+    def get_tag(self, key: str) -> AbstractAnlzTag:
         return self.__getitem__(key)[0]
 
-    def getall_tags(self, key):
+    def getall_tags(self, key: str) -> List[AbstractAnlzTag]:
         return self.__getitem__(key)
 
-    def get(self, key):
+    def get(self, key: str) -> Any:  # type: ignore[override]
         return self.__getitem__(key)[0].get()
 
-    def getall(self, key):
+    def getall(self, key: str) -> List[Any]:
         return [tag.get() for tag in self.__getitem__(key)]
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self.keys())
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[str]:
         return iter(set(tag.type for tag in self.tags))
 
-    def __getitem__(self, item):
+    def __getitem__(self, item: str) -> List[AbstractAnlzTag]:
         if item.isupper() and len(item) == 4:
             return [tag for tag in self.tags if tag.type == item]
         else:
             return [tag for tag in self.tags if tag.name == item]
 
-    def __contains__(self, item):
+    def __contains__(self, item: str) -> bool:  # type: ignore[override]
         if item.isupper() and len(item) == 4:
             for tag in self.tags:
                 if item == tag.type:
@@ -219,9 +232,9 @@ class AnlzFile(abc.Mapping):
                     return True
         return False
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"{self.__class__.__name__}({self.tag_types})"
 
-    def set_path(self, path):
+    def set_path(self, path: Union[Path, str]) -> None:
         tag = self.get_tag("PPTH")
         tag.set(path)