pyrekordbox 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

build/lib/build/lib/pyrekordbox/anlz/__init__.py

@@ -1,127 +0,0 @@
-# -*- coding: utf-8 -*-
-# Author: Dylan Jones
-# Date:   2023-02-01
-
-import re
-from pathlib import Path
-from typing import Union
-from . import structs
-from .file import AnlzFile
-
-RE_ANLZ = re.compile("ANLZ[0-9]{4}.(DAT|EXT|2EX)")
-
-
-def is_anlz_file(path: Union[str, Path]) -> bool:
-    """Checks if the name of a file matches the ANLZ file name pattern.
-
-    Parameters
-    ----------
-    path : str or Path
-        The file path to check
-
-    Returns
-    -------
-    is_anlz : bool
-        True if the file is an ANLZ file.
-
-    Examples
-    --------
-    >>> is_anlz_file("ANLZ0000.DAT")
-    True
-
-    >>> is_anlz_file("/path/to/ANLZ0000.DAT")
-    False
-
-    >>> is_anlz_file("ANLZ.DAT")
-    False
-    """
-    path = Path(path)
-    if not path.exists() or not path.is_file():
-        return False
-    return bool(RE_ANLZ.match(path.name))
-
-
-def get_anlz_paths(root: Union[str, Path]) -> dict:
-    """Returns the paths of all existing ANLZ files in a directory.
-
-    Parameters
-    ----------
-    root : str or Path
-        The path of the directory containing ANLZ files.
-
-    Returns
-    -------
-    anlz_paths : dict[str, Path]
-        The file paths stored as dictionary with the type of ANLZ file as keys
-        ("DAT", "EXT", "EX2")
-
-    Examples
-    --------
-    >>> p = get_anlz_paths("directory/")
-    >>> p["DAT"]
-    directory/ANLZ0000.DAT
-    """
-    paths = {"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]):
-    """Finds all ANLZ directory paths recursively.
-
-    Parameters
-    ----------
-    root_dir : str or Path
-        The path of the root directory.
-
-    Yields
-    -------
-    anlz_dir : str
-        The path of a directory containing ANLZ files
-    """
-    for path in Path(root_dir).rglob("*"):
-        if path.is_dir():
-            if any(is_anlz_file(f) for f in path.iterdir()):
-                yield path
-
-
-def walk_anlz_paths(root_dir: Union[str, Path]):
-    """Finds all ANLZ directory paths and the containing file paths recursively.
-
-    Parameters
-    ----------
-    root_dir : str or Path
-        The path of the root directory.
-
-    Yields
-    -------
-    anlz_dir : str
-        The path of a directory containing ANLZ files.
-    anlz_files : Sequence of str
-        The file paths of the ANLZ files in `anlz_dir`.
-    """
-    root_dir = Path(root_dir)
-    assert root_dir.exists()
-    for anlz_dir in walk_anlz_dirs(root_dir):
-        files = {k: path for k, path in get_anlz_paths(anlz_dir).items() if path}
-        yield anlz_dir, files
-
-
-def read_anlz_files(root: Union[str, Path] = "") -> dict:
-    """Open all ANLZ files in the given root directory.
-
-    Parameters
-    ----------
-    root : str or Path, optional
-        The root directory of the ANLZ files to open.
-
-    Returns
-    -------
-    anlz_files : dict
-        The opened ANLZ files stored in a dict with the corresponding file paths
-        as keys.
-    """
-    paths = get_anlz_paths(root)
-    return {path: AnlzFile.parse_file(path) for path in paths.values() if path}

build/lib/build/lib/pyrekordbox/anlz/file.py

@@ -1,186 +0,0 @@
-# -*- coding: utf-8 -*-
-# Author: Dylan Jones
-# Date:   2023-02-01
-
-import logging
-from collections import abc
-from pathlib import Path
-from typing import Union
-from .tags import TAGS
-from . import structs
-
-logger = logging.getLogger(__name__)
-
-
-class BuildFileLengthError(Exception):
-    def __init__(self, struct, len_data):
-        super().__init__(
-            f"`len_file` ({struct.len_file}) of '{struct.type}' does not "
-            f"match the data-length ({len_data})!"
-        )
-
-
-class AnlzFile(abc.Mapping):
-    """Rekordbox `ANLZnnnn.xxx` binary file handler."""
-
-    def __init__(self):
-        self._path = ""
-        self.file_header = None
-        self.tags = list()
-
-    @property
-    def num_tags(self):
-        return len(self.tags)
-
-    @property
-    def tag_types(self):
-        return [tag.type for tag in self.tags]
-
-    @property
-    def path(self):
-        return self._path
-
-    @classmethod
-    def parse(cls, data: bytes):
-        """Parses the in-memory data of a Rekordbox analysis binary file.
-
-        Parameters
-        ----------
-        data : bytes
-            The in-memory binary contents of a Rekordbox analysis file.
-
-        Returns
-        -------
-        self : AnlzFile
-            The new instance with the parsed file content.
-        """
-        self = cls()
-        self._parse(data)
-        return self
-
-    @classmethod
-    def parse_file(cls, path: Union[str, Path]):
-        """Reads and parses a Rekordbox analysis binary file.
-
-        Parameters
-        ----------
-        path : str or Path
-            The path of a Rekordbox analysis file which is used to read
-            the file contents before parsing the binary data.
-
-        Returns
-        -------
-        self : AnlzFile
-            The new instance with the parsed file content.
-
-        See Also
-        --------
-        AnlzFile.parse: Parses the data of a Rekordbox analysis file.
-        """
-        path = Path(path)
-        ext = path.suffix.upper()
-        if ext not in (".DAT", ".EXT", ".2EX"):
-            raise ValueError(f"File type '{ext}' not supported!")
-
-        logger.debug(f"Reading file {path.name}")
-        with open(path, "rb") as fh:
-            data = fh.read()
-
-        self = cls.parse(data)
-        self._path = path
-        return self
-
-    def _parse(self, data: bytes):
-        file_header = structs.AnlzFileHeader.parse(data)
-        tag_type = file_header.type
-        assert tag_type == "PMAI"
-
-        tags = list()
-        i = file_header.len_header
-        while i < file_header.len_file:
-            # Get data starting from struct
-            tag_data = data[i:]
-            # Get the four byte struct type
-            tag_type = tag_data[:4].decode("ascii")
-
-            try:
-                # Parse the struct
-                tag = TAGS[tag_type](tag_data)
-                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,
-                    len_header,
-                    len_tag,
-                )
-            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):
-        # Update struct lengths
-        tags_len = 0
-        for tag in self.tags:
-            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):
-        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
-        # Check `len_file`
-        len_file = self.file_header.len_file
-        len_data = len(data)
-        if len_file != len_data:
-            raise BuildFileLengthError(self.file_header, len_file)
-
-        return data
-
-    def save(self, path=""):
-        path = path or self._path
-
-        data = self.build()
-        with open(path, "wb") as fh:
-            fh.write(data)
-
-    def get_tag(self, key):
-        return self.__getitem__(key)[0]
-
-    def getall_tags(self, key):
-        return self.__getitem__(key)
-
-    def get(self, key):
-        return self.__getitem__(key)[0].get()
-
-    def getall(self, key):
-        return [tag.get() for tag in self.__getitem__(key)]
-
-    def __len__(self):
-        return len(self.keys())
-
-    def __iter__(self):
-        return iter(set(tag.type for tag in self.tags))
-
-    def __getitem__(self, item):
-        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 __repr__(self):
-        return f"{self.__class__.__name__}({self.tag_types})"
-
-    def set_path(self, path):
-        tag = self.get_tag("PPTH")
-        tag.set(path)

build/lib/build/lib/pyrekordbox/anlz/structs.py

@@ -1,299 +0,0 @@
-# -*- coding: utf-8 -*-
-# Author: Dylan Jones
-# Date:   2022-10-24
-
-"""Binary structures of Rekordbox ANLZ-files.
-
-References
-----------
-.. [1] Rekordbox Export Structure Analysis: Analysis Files,
-   https://djl-analysis.deepsymmetry.org/rekordbox-export-analysis/anlz.html
-"""
-
-from construct import Int8ub, Int16ub, Int32ub, PaddedString, Int32sb, StopIf
-from construct import Const, Array, Padding, Bytes
-from construct import Default, Enum, GreedyRange, Struct, Switch, this
-
-
-# -- Beat Grid Tag (PQTZ) --------------------------------------------------------------
-
-AnlzQuantizeTick = Struct(
-    "beat" / Int16ub,
-    "tempo" / Int16ub,
-    "time" / Int32ub  # in ms from start
-)
-
-# len_header: 24
-PQTZ = Struct(
-    "u1" / Padding(4),
-    "u2" / Const(0x80000, Int32ub),
-    "entry_count" / Int32ub,
-    "entries" / Array(this.entry_count, AnlzQuantizeTick),
-)
-
-
-# Extended Beat Grid Tag (PQT2)
-
-AnlzQuantizeTick2 = Struct(
-    "beat" / Int8ub,    # 1 byte
-    "unkown" / Int8ub,    # 1 byte
-)
-
-# len_header: 56
-PQT2 = Struct(
-    Padding(4), # -> 16
-    "u1" / Const(0x01000002, Int32ub),  # -> 20, count of "bpm" objects?
-    Padding(4), # -> 24
-    "bpm" / Array(2, AnlzQuantizeTick),  # -> 40 (2 * 8 bytes = 16 bytes)
-    "entry_count" / Int32ub,  # -> 44 number of entries of 2 bytes
-    "u3" / Int32ub,  # -> 48
-    "u4" / Int32ub,  # -> 52
-    "u5" / Int32ub,  # -> 56
-    # End header
-    StopIf(this.entry_count == 0),
-    # "entries" / Array(this.entry_count, Bytes(2)),
-    "entries" / Array(this.entry_count, AnlzQuantizeTick2),
-)
-
-
-# -- Cue List Tag (PCOB) ---------------------------------------------------------------
-
-AnlzCuePointType = Enum(Int8ub, single=1, loop=2)
-
-AnlzCuePointStatus = Enum(Int32ub, disabled=0, enabled=4)
-
-AnlzTagCueObjectType = Enum(Int32ub, memory=0, hotcue=1)
-
-AnlzCuePoint = Struct(
-    "type" / Const("PCPT", PaddedString(4, encoding="ascii")),
-    "len_header" / Int32ub,
-    "len_entry" / Int32ub,
-    "hot_cue" / Int32ub,  # 0 for memory
-    "status" / AnlzCuePointStatus,
-    "u1" / Const(0x10000, Int32ub),
-    "order_first" / Int16ub,  # 0xffff for first cue, 0,1,3 for next
-    "order_last" / Int16ub,  # 1,2,3 for first, second, third cue, 0xffff for last
-    "type" / AnlzCuePointType,
-    Padding(1),
-    "u2" / Const(1000, Int16ub),
-    "time" / Int32ub,
-    "loop_time" / Default(Int32ub, -1),
-    Padding(16),
-)
-
-# len_header: 24
-PCOB = Struct(
-    "cue_type" / AnlzTagCueObjectType,
-    "unk" / Int16ub,
-    "count" / Int16ub,
-    "memory_count" / Int32sb,
-    "entries" / Array(this.count, AnlzCuePoint),
-)
-
-
-# Extended (nxs2) Cue List Tag (PCO2)
-
-AnlzCuePoint2 = Struct(
-    "type" / Const("PCP2", PaddedString(4, encoding="ascii")),
-    "len_header" / Int32ub,
-    "len_entry" / Int32ub,
-    "hot_cue" / Int32ub,  # 0 for memory
-    "type" / Int8ub,  # spotted: 0x010003e8 0x020003e8
-    Padding(3),
-    "time" / Int32ub,
-    "loop_time" / Default(Int32ub, -1),
-    "color_id" / Int8ub,
-    Padding(7),
-    "loop_enumerator" / Int16ub,
-    "loop_denominator" / Int16ub,
-    "len_comment" / Int32ub,
-    "comment" / PaddedString(this.len_comment, encoding="utf-16-be"),
-    "color_code" / Int8ub,
-    "color_red" / Int8ub,
-    "color_green" / Int8ub,
-    "color_blue" / Int8ub,
-    Padding(this.len_entry - 48 - this.len_comment),
-)
-
-# len_header: 20
-PCO2 = Struct(
-    "type" / AnlzTagCueObjectType,
-    "count" / Int16ub,
-    "unknown" / Int16ub,
-    "entries" / Array(this.count, AnlzCuePoint2),
-)
-
-
-# -- Path Tag (PPTH) -------------------------------------------------------------------
-
-# len_header: 16
-PPTH = Struct(
-    "len_path" / Int32ub,  # is 0 for some tag types
-    "path" / PaddedString(this.len_path - 2, encoding="utf-16-be"),
-    Padding(2),
-)
-
-
-# -- VBR Tag (PVBR) --------------------------------------------------------------------
-
-# len_header: 16
-PVBR = Struct(
-    "u1" / Int32ub,
-    "idx" / Array(400, Int32ub),
-    "u2" / Int32ub
-)
-
-
-# -- (Tiny) Waveform Preview Tag (PWAV / PWV2) -----------------------------------------
-
-# len_header: 20
-PWAV = Struct(
-    "len_preview" / Int32ub,  # is 0 for some tag types
-    "unknown" / Const(0x10000, Int32ub),
-    "entries" / Array(this.len_preview, Int8ub),
-)
-
-# len_header: 20
-PWV2 = Struct(
-    "len_preview" / Int32ub,  # is 0 for some tag types
-    "unknown" / Const(0x10000, Int32ub),
-    "entries" / Array(this.len_preview, Int8ub),
-)
-
-
-# -- Waveform Detail Tag (PWV3) --------------------------------------------------------
-
-# len_header: 24
-PWV3 = Struct(
-    "len_entry_bytes" / Const(1, Int32ub),
-    "len_entries" / Int32ub,
-    "u1" / Const(0x00960000, Int32ub),
-    "entries" / Array(this.len_entries, Int8ub),
-)
-
-
-# -- Waveform Color Preview Tag (PWV4) -------------------------------------------------
-
-# len_header: 24
-PWV4 = Struct(
-    "len_entry_bytes" / Const(0x00000006, Int32ub),
-    "len_entries" / Int32ub,
-    "unknown" / Int32ub,
-    "entries" / Bytes(this.len_entry_bytes * this.len_entries),
-)
-
-
-# -- Waveform Color Detail Tag (PWV5) --------------------------------------------------
-
-# len_header: 24
-PWV5 = Struct(
-    "len_entry_bytes" / Const(0x00000002, Int32ub),
-    "len_entries" / Int32ub,
-    "unknown" / Int32ub,
-    "entries" / Array(this.len_entries, Int16ub),
-)
-
-# -- Song Structure Tag (PSSI) ---------------------------------------------------------
-
-# FixMe: Implement reverse XOR mask to descramble values
-
-SongStructureEntry = Struct(
-    "index" / Int16ub,
-    "beat" / Int16ub,
-    "kind" / Int16ub,
-    "u1" / Int8ub,
-    "k1" / Int8ub,
-    "u2" / Int8ub,
-    "k2" / Int8ub,
-    "u3" / Int8ub,
-    "b" / Int8ub,
-    "beat_2" / Int16ub,
-    "beat_3" / Int16ub,
-    "beat_4" / Int16ub,
-    "u4" / Int8ub,
-    "k3" / Int8ub,
-    "u5" / Int8ub,
-    "fill" / Int8ub,
-    "beat_fill" / Int16ub,
-)
-
-# len_header: 32
-PSSI = Struct(
-    "len_entry_bytes" /  Const(24, Int32ub),
-    "len_entries" / Int16ub,
-    "mood" / Bytes(2),
-    "u1" / Bytes(6),
-    "end_beat" / Bytes(2),
-    "u2" / Bytes(2),
-    "bank" / Bytes(1),
-    "u3" / Bytes(1),
-    "entries" / Array(this.len_entries, SongStructureEntry),
-)
-
-# -- PWV6 ------------------------------------------------------------------------------
-
-# len_header: 20
-PWV6 = Struct(
-    "len_entry_bytes" /  Const(0x00000003, Int32ub),
-    "len_entries" / Int32ub,
-    "entries" /  Bytes(this.len_entry_bytes * this.len_entries),
-)
-
-# -- PWV7 ------------------------------------------------------------------------------
-
-# len_header: 24
-PWV7 = Struct(
-    "len_entry_bytes" /  Const(0x00000003, Int32ub),
-    "len_entries" / Int32ub,
-    "unknown" / Const(0x00960000, Int32ub),
-    "entries" / Bytes(this.len_entry_bytes * this.len_entries),
-)
-
-# -- PWVC ------------------------------------------------------------------------------
-
-# len_header: 14
-PWVC = Struct(
-    "unknown" /  Int16ub,
-    "data" / Array(3, Int16ub)
-)
-
-
-# -- Main Items ------------------------------------------------------------------------
-
-AnlzFileHeader = Struct(
-    "type" / PaddedString(4, encoding="ascii"),
-    "len_header" / Int32ub,
-    "len_file" / Int32ub,
-    "u1" / Int32ub,
-    "u2" / Int32ub,
-    "u3" / Int32ub,
-    "u4" / Int32ub,
-)
-
-
-AnlzTag = Struct(
-    "type" / PaddedString(4, encoding="ascii"),
-    "len_header" / Int32ub,
-    "len_tag" / Int32ub,
-    "content" / Switch(
-        this.type,
-        {
-            "PQTZ": PQTZ,
-            "PQT2": PQT2,
-            "PCOB": PCOB,  # seen in both DAT and EXT files
-            "PCO2": PCO2,  # seen in EXT files
-            "PPTH": PPTH,
-            "PVBR": PVBR,
-            "PSSI": PSSI,  # seen in EXT files
-            "PWAV": PWAV,
-            "PWV2": PWV2,
-            "PWV3": PWV3,  # seen in EXT files
-            "PWV4": PWV4,  # seen in EXT files
-            "PWV5": PWV5,  # seen in EXT files
-            "PWV6": PWV6,  # seen in 2EX files
-            "PWV7": PWV7,  # seen in 2EX files
-            "PWVC": PWVC,  # seen in 2EX files
-        },
-        default=Bytes(this.len_tag - 12),
-    ),
-)