pyrekordbox 0.3.2__py3-none-any.whl → 0.4.1__py3-none-any.whl

pyrekordbox/db6/database.py

@@ -2,24 +2,26 @@
 # Author: Dylan Jones
 # Date:   2023-08-13
 
-import logging
 import datetime
+import logging
 import secrets
-from uuid import uuid4
 from pathlib import Path
 from typing import Optional
-from sqlalchemy import create_engine, or_, event, MetaData, select
-from sqlalchemy.orm import Session, Query
+from uuid import uuid4
+
+from sqlalchemy import MetaData, create_engine, event, or_, select
 from sqlalchemy.exc import NoResultFound
+from sqlalchemy.orm import Query, Session
 from sqlalchemy.sql.sqltypes import DateTime, String
-from ..utils import get_rekordbox_pid, warn_deprecated
+
+from ..anlz import AnlzFile, get_anlz_paths, read_anlz_files
 from ..config import get_config
-from ..anlz import get_anlz_paths, read_anlz_files, AnlzFile
-from .registry import RekordboxAgentRegistry
+from ..utils import get_rekordbox_pid
+from . import tables
 from .aux_files import MasterPlaylistXml
-from .tables import DjmdContent, PlaylistType
+from .registry import RekordboxAgentRegistry
 from .smartlist import SmartList
-from . import tables
+from .tables import DjmdContent, FileType, PlaylistType
 
 try:
     from sqlcipher3 import dbapi2 as sqlite3  # noqa
@@ -31,6 +33,10 @@ except ImportError:
     _sqlcipher_available = False
 
 MAX_VERSION = "6.6.5"
+SPECIAL_PLAYLIST_IDS = [
+    "100000",  # Cloud Library Sync
+    "200000",  # CUE Analysis Playlist
+]
 
 logger = logging.getLogger(__name__)
 
@@ -39,101 +45,6 @@ class NoCachedKey(Exception):
     pass
 
 
-def open_rekordbox_database(path=None, key="", unlock=True, sql_driver=None):
-    """Opens a connection to the Rekordbox v6 master.db SQLite3 database.
-
-    Parameters
-    ----------
-    path : str or Path, optional
-        The path of the Rekordbox v6 database file. By default, pyrekordbox
-        automatically finds the Rekordbox v6 master.db database file.
-        This parameter is only required for opening other databases or if the
-        configuration fails.
-    key : str, optional
-        The database key. By default, pyrekordbox automatically reads the database
-        key from the Rekordbox v6 configuration file. This parameter is only required
-        if the key extraction fails.
-    unlock: bool, optional
-        Flag if the database needs to be decrypted. Set to False if you are opening
-        an unencrypted test database.
-    sql_driver : Callable, optional
-        The SQLite driver to used for opening the database. The standard ``sqlite3``
-        package is used as default driver.
-
-    Returns
-    -------
-    con : sql_driver.Connection
-        The opened Rekordbox v6 database connection.
-
-    Examples
-    --------
-    Open the Rekordbox v6 master.db database:
-
-    >>> db = open_rekordbox_database()
-
-    Open a copy of the database:
-
-    >>> db = open_rekordbox_database("path/to/master_copy.db")
-
-    Open a decrypted copy of the database:
-
-    >>> db = open_rekordbox_database("path/to/master_unlocked.db", unlock=False)
-
-    To use the ``pysqlcipher3`` package as SQLite driver, either import it as
-
-    >>> from sqlcipher3 import dbapi2 as sqlite3  # noqa
-    >>> db = open_rekordbox_database("path/to/master_copy.db")
-
-    or supply the package as driver:
-
-    >>> from sqlcipher3 import dbapi2  # noqa
-    >>> db = open_rekordbox_database("path/to/master_copy.db", sql_driver=dbapi2)
-    """
-    warn_deprecated("open_rekordbox_database", remove_in="0.4.0")
-    rb6_config = get_config("rekordbox6")
-
-    if not path:
-        path = rb6_config["db_path"]
-    path = Path(path)
-    if not path.exists():
-        raise FileNotFoundError(f"File '{path}' does not exist!")
-    logger.info("Opening %s", path)
-
-    # Open database
-    if sql_driver is None:
-        # Use default sqlite3 package
-        # This requires that the 'sqlite3.dll' was replaced by the 'sqlcipher.dll'
-        sql_driver = sqlite3
-    con = sql_driver.connect(str(path))
-
-    if unlock:
-        if not key:
-            try:
-                key = rb6_config["dp"]
-            except KeyError:
-                raise NoCachedKey(
-                    "Could not unlock database: No key found\n"
-                    f"If you are using Rekordbox>{MAX_VERSION} the key can not be "
-                    f"extracted automatically!\n"
-                    "Please use the CLI of pyrekordbox to download the key or "
-                    "use the `key` parameter to manually provide the database key."
-                )
-            logger.info("Key: %s", key)
-        # Unlock database
-        con.execute(f"PRAGMA key='{key}'")
-
-    # Check connection
-    try:
-        con.execute("SELECT name FROM sqlite_master WHERE type='table';")
-    except sqlite3.DatabaseError as e:
-        msg = f"Opening database failed: '{e}'. Check if the database key is correct!"
-        raise sqlite3.DatabaseError(msg)
-    else:
-        logger.info("Database unlocked!")
-
-    return con
-
-
 def _parse_query_result(query, kwargs):
     if "ID" in kwargs or "registry_id" in kwargs:
         try:
@@ -193,17 +104,21 @@ class Rekordbox6Database:
     """
 
     def __init__(self, path=None, db_dir="", key="", unlock=True):
-        rb6_config = get_config("rekordbox6")
+        # get config of latest supported version
+        rb_config = get_config("rekordbox7")
+        if not rb_config:
+            rb_config = get_config("rekordbox6")
+
         pid = get_rekordbox_pid()
         if pid:
             logger.warning("Rekordbox is running!")
 
         if not path:
             # Get path from the RB config
-            path = rb6_config.get("db_path", "")
+            path = rb_config.get("db_path", "")
             if not path:
                 pdir = get_config("pioneer", "install_dir")
-                raise FileNotFoundError(f"No Rekordbox v6 directory found in '{pdir}'")
+                raise FileNotFoundError(f"No Rekordbox v6/v7 directory found in '{pdir}'")
         path = Path(path)
         # make sure file exists
         if not path.exists():
@@ -211,12 +126,10 @@ class Rekordbox6Database:
         # Open database
         if unlock:
             if not _sqlcipher_available:
-                raise ImportError(
-                    "Could not unlock database: 'sqlcipher3' package not found"
-                )
+                raise ImportError("Could not unlock database: 'sqlcipher3' package not found")
             if not key:
                 try:
-                    key = rb6_config["dp"]
+                    key = rb_config["dp"]
                 except KeyError:
                     raise NoCachedKey(
                         "Could not unlock database: No key found\n"
@@ -230,7 +143,7 @@ class Rekordbox6Database:
                 if not key.startswith("402fd"):
                     raise ValueError("The provided database key doesn't look valid!")
 
-            logger.info("Key: %s", key)
+            logger.debug("Key: %s", key)
             # Unlock database and create engine
             url = f"sqlite+pysqlcipher://:{key}@/{path}?"
             engine = create_engine(url, module=sqlite3)
@@ -491,17 +404,20 @@ class Rekordbox6Database:
             # Sync the updated_at values of the playlists in the DB and the XML file
             for pl in self.get_playlist():
                 plxml = self.playlist_xml.get(pl.ID)
-                if plxml is None:
-                    raise ValueError(
-                        f"Playlist {pl.ID} not found in masterPlaylists6.xml! "
-                        "Did you add it manually? "
-                        "Use the create_playlist method instead."
-                    )
-                ts = plxml["Timestamp"]
-                diff = pl.updated_at - ts
-                if abs(diff.total_seconds()) > 1:
-                    logger.debug("Updating updated_at of playlist %s in XML", pl.ID)
-                    self.playlist_xml.update(pl.ID, updated_at=pl.updated_at)
+                if plxml is not None:
+                    ts = plxml["Timestamp"]
+                    diff = pl.updated_at - ts
+                    if abs(diff.total_seconds()) > 1:
+                        logger.debug("Updating updated_at of playlist %s in XML", pl.ID)
+                        self.playlist_xml.update(pl.ID, updated_at=pl.updated_at)
+                else:
+                    # Dont warn for special playlists
+                    if pl.ID not in SPECIAL_PLAYLIST_IDS:
+                        logger.warning(
+                            f"Playlist {pl.ID} not found in masterPlaylists6.xml! "
+                            "Did you add it manually? "
+                            "Use the create_playlist method instead."
+                        )
 
             # Save the XML file if it was modified
             if self.playlist_xml.modified:
@@ -813,7 +729,7 @@ class Rekordbox6Database:
 
     # -- Database updates --------------------------------------------------------------
 
-    def generate_unused_id(self, table, is_28_bit: bool = True) -> int:
+    def generate_unused_id(self, table, is_28_bit: bool = True, id_field_name: str = "ID") -> int:
         """Generates an unused ID for the given table."""
         max_tries = 1000000
         for _ in range(max_tries):
@@ -825,7 +741,8 @@ class Rekordbox6Database:
             if id_ < 100:
                 continue
             # Check if ID is already used
-            query = self.query(table.ID).filter(table.ID == id_)
+            id_field = getattr(table, id_field_name)
+            query = self.query(id_field).filter(id_field == id_)
             used = self.query(query.exists()).scalar()
             if not used:
                 return id_
@@ -887,20 +804,14 @@ class Rekordbox6Database:
         uuid = str(uuid4())
         id_ = str(uuid4())
         now = datetime.datetime.now()
-        nsongs = (
-            self.query(tables.DjmdSongPlaylist)
-            .filter_by(PlaylistID=playlist.ID)
-            .count()
-        )
+        nsongs = self.query(tables.DjmdSongPlaylist).filter_by(PlaylistID=playlist.ID).count()
         if track_no is not None:
             insert_at_end = False
             track_no = int(track_no)
             if track_no < 1:
                 raise ValueError("Track number must be greater than 0")
             if track_no > nsongs + 1:
-                raise ValueError(
-                    f"Track number too high, parent contains {nsongs} items"
-                )
+                raise ValueError(f"Track number too high, parent contains {nsongs} items")
         else:
             insert_at_end = True
             track_no = nsongs + 1
@@ -976,9 +887,7 @@ class Rekordbox6Database:
             playlist = self.get_playlist(ID=playlist)
         if isinstance(song, (int, str)):
             song = self.query(tables.DjmdSongPlaylist).filter_by(ID=song).one()
-        logger.info(
-            "Removing song with ID=%s from playlist with ID=%s", song.ID, playlist.ID
-        )
+        logger.info("Removing song with ID=%s from playlist with ID=%s", song.ID, playlist.ID)
         now = datetime.datetime.now()
         # Remove track from playlist
         track_no = song.TrackNo
@@ -1049,11 +958,7 @@ class Rekordbox6Database:
             playlist = self.get_playlist(ID=playlist)
         if isinstance(song, (int, str)):
             song = self.query(tables.DjmdSongPlaylist).filter_by(ID=song).one()
-        nsongs = (
-            self.query(tables.DjmdSongPlaylist)
-            .filter_by(PlaylistID=playlist.ID)
-            .count()
-        )
+        nsongs = self.query(tables.DjmdSongPlaylist).filter_by(PlaylistID=playlist.ID).count()
         if new_track_no < 1:
             raise ValueError("Track number must be greater than 0")
         if new_track_no > nsongs + 1:
@@ -1103,9 +1008,7 @@ class Rekordbox6Database:
         self.registry.enable_tracking()
         self.registry.on_move(moved)
 
-    def _create_playlist(
-        self, name, seq, image_path, parent, smart_list=None, attribute=None
-    ):
+    def _create_playlist(self, name, seq, image_path, parent, smart_list=None, attribute=None):
         """Creates a new playlist object."""
         table = tables.DjmdPlaylist
         id_ = str(self.generate_unused_id(table, is_28_bit=True))
@@ -1130,9 +1033,7 @@ class Rekordbox6Database:
         else:
             # Check if parent exists and is a folder
             parent_id = parent
-            query = self.query(table.ID).filter(
-                table.ID == parent_id, table.Attribute == 1
-            )
+            query = self.query(table.ID).filter(table.ID == parent_id, table.Attribute == 1)
             if not self.query(query.exists()).scalar():
                 raise ValueError("Parent does not exist or is not a folder")
 
@@ -1191,9 +1092,7 @@ class Rekordbox6Database:
 
         # Update masterPlaylists6.xml
         if self.playlist_xml is not None:
-            self.playlist_xml.add(
-                id_, parent_id, attribute, now, lib_type=0, check_type=0
-            )
+            self.playlist_xml.add(id_, parent_id, attribute, now, lib_type=0, check_type=0)
 
         return playlist
 
@@ -1241,9 +1140,7 @@ class Rekordbox6Database:
         '123456'
         """
         logger.info("Creating playlist %s", name)
-        return self._create_playlist(
-            name, seq, image_path, parent, attribute=PlaylistType.PLAYLIST
-        )
+        return self._create_playlist(name, seq, image_path, parent, attribute=PlaylistType.PLAYLIST)
 
     def create_playlist_folder(self, name, parent=None, seq=None, image_path=None):
         """Creates a new playlist folder in the database.
@@ -1283,9 +1180,7 @@ class Rekordbox6Database:
         '123456'
         """
         logger.info("Creating playlist folder %s", name)
-        return self._create_playlist(
-            name, seq, image_path, parent, attribute=PlaylistType.FOLDER
-        )
+        return self._create_playlist(name, seq, image_path, parent, attribute=PlaylistType.FOLDER)
 
     def create_smart_playlist(
         self, name, smart_list: SmartList, parent=None, seq=None, image_path=None
@@ -1360,9 +1255,7 @@ class Rekordbox6Database:
             playlist = self.get_playlist(ID=playlist)
 
         if playlist.Attribute == 1:
-            logger.info(
-                "Deleting playlist folder '%s' with ID=%s", playlist.Name, playlist.ID
-            )
+            logger.info("Deleting playlist folder '%s' with ID=%s", playlist.Name, playlist.ID)
         else:
             logger.info("Deleting playlist '%s' with ID=%s", playlist.Name, playlist.ID)
 
@@ -1475,9 +1368,7 @@ class Rekordbox6Database:
         else:
             # Check if parent exists and is a folder
             parent_id = str(parent)
-            query = self.query(table.ID).filter(
-                table.ID == parent_id, table.Attribute == 1
-            )
+            query = self.query(table.ID).filter(table.ID == parent_id, table.Attribute == 1)
             if not self.query(query.exists()).scalar():
                 raise ValueError("Parent does not exist or is not a folder")
 
@@ -1498,9 +1389,7 @@ class Rekordbox6Database:
                 if seq < 1:
                     raise ValueError("Sequence number must be greater than 0")
                 elif seq > n + 1:
-                    raise ValueError(
-                        f"Sequence number too high, parent contains {n} items"
-                    )
+                    raise ValueError(f"Sequence number too high, parent contains {n} items")
 
             if not insert_at_end:
                 # Get all playlists with seq between old_seq and seq
@@ -1634,9 +1523,7 @@ class Rekordbox6Database:
         with self.registry.disabled():
             playlist.updated_at = now
 
-    def add_album(
-        self, name, artist=None, image_path=None, compilation=None, search_str=None
-    ):
+    def add_album(self, name, artist=None, image_path=None, compilation=None, search_str=None):
         """Adds a new album to the database.
 
         Parameters
@@ -1768,9 +1655,7 @@ class Rekordbox6Database:
 
         id_ = self.generate_unused_id(tables.DjmdArtist)
         uuid = str(uuid4())
-        artist = tables.DjmdArtist.create(
-            ID=id_, Name=name, SearchStr=search_str, UUID=uuid
-        )
+        artist = tables.DjmdArtist.create(ID=id_, Name=name, SearchStr=search_str, UUID=uuid)
         self.add(artist)
         self.flush()
         return artist
@@ -1875,6 +1760,78 @@ class Rekordbox6Database:
         self.flush()
         return label
 
+    def add_content(self, path, **kwargs):
+        """Adds a new track to the database.
+
+        Parameters
+        ----------
+        path : str
+            Absolute path to the music file to be added.
+
+        **kwargs:
+            Keyword arguments passed to DjmdContent on creation. These arguments
+            should be a valid DjmdContent field.
+
+        Returns
+        -------
+        content : DjmdContent
+            The newly created track.
+
+        Raises
+        ------
+        ValueError : If a track with the same path already exists in the database.
+        ValueError : If the file type is invalid.
+
+        Examples
+        --------
+        Add a new track to the database:
+
+        >>> db = Rekordbox6Database()
+        >>> db.add_content("/Users/foo/Downloads/banger.mp3", Title="Banger")
+        <DjmdContent(123456789 Title=Banger)>
+        """
+        path = Path(path)
+        path_string = str(path)
+        query = self.query(tables.DjmdContent).filter_by(FolderPath=path_string)
+        if query.count() > 0:
+            raise ValueError(f"Track with path '{path}' already exists in database")
+
+        id_ = self.generate_unused_id(tables.DjmdContent)
+        file_id = self.generate_unused_id(tables.DjmdContent, id_field_name="rb_file_id")
+        uuid = str(uuid4())
+        content_link = self.get_menu_items(Name="TRACK").one()
+        date_created = datetime.date.today()
+        device = self.get_device().first()
+        file_name_l = path.name
+        file_size = path.stat().st_size
+
+        file_type_string = path.suffix.lstrip(".").upper()
+        try:
+            file_type = getattr(FileType, file_type_string)
+        except ValueError:
+            raise ValueError(f"Invalid file type: {path.suffix}")
+
+        content = tables.DjmdContent.create(
+            ID=id_,
+            UUID=uuid,
+            ContentLink=content_link.rb_local_usn,
+            DateCreated=date_created,
+            DeviceID=device.ID,
+            FileNameL=file_name_l,
+            FileSize=file_size,
+            FileType=file_type.value,
+            FolderPath=path_string,
+            HotCueAutoLoad="on",
+            MasterDBID=device.MasterDBID,
+            MasterSongID=id_,
+            StockDate=date_created,
+            rb_file_id=file_id,
+            **kwargs,
+        )
+        self.add(content)
+        self.flush()
+        return content
+
     # ----------------------------------------------------------------------------------
 
     def get_mysetting_paths(self):
@@ -1997,9 +1954,7 @@ class Rekordbox6Database:
             return AnlzFile.parse_file(path)
         return None
 
-    def update_content_path(
-        self, content, path, save=True, check_path=True, commit=True
-    ):
+    def update_content_path(self, content, path, save=True, check_path=True, commit=True):
         """Update the file path of a track in the Rekordbox v6 database.
 
         This changes the `FolderPath` entry in the ``DjmdContent`` table and the
@@ -2090,9 +2045,7 @@ class Rekordbox6Database:
             logger.debug("Committing changes to the database")
             self.commit()
 
-    def update_content_filename(
-        self, content, name, save=True, check_path=True, commit=True
-    ):
+    def update_content_filename(self, content, name, save=True, check_path=True, commit=True):
         """Update the file name of a track in the Rekordbox v6 database.
 
         This changes the `FolderPath` entry in the ``DjmdContent`` table and the

pyrekordbox/db6/registry.py

@@ -4,6 +4,7 @@
 
 import logging
 from contextlib import contextmanager
+
 from sqlalchemy.orm.exc import ObjectDeletedError
 
 logger = logging.getLogger(__name__)

pyrekordbox/db6/smartlist.py

@@ -4,14 +4,14 @@
 
 import logging
 import xml.etree.cElementTree as xml
+from dataclasses import dataclass
+from datetime import datetime
 from enum import Enum, IntEnum
 from typing import List, Union
-from datetime import datetime
-from dataclasses import dataclass
 
-from sqlalchemy import or_, and_, not_
-from sqlalchemy.sql.elements import BooleanClauseList
 from dateutil.relativedelta import relativedelta  # noqa
+from sqlalchemy import and_, not_, or_
+from sqlalchemy.sql.elements import BooleanClauseList
 
 from .tables import DjmdContent
 
@@ -179,8 +179,7 @@ class Condition:
     def __post_init__(self):
         if self.property not in PROPERTIES:
             raise ValueError(
-                f"Invalid property: '{self.property}'! "
-                f"Supported properties: {PROPERTIES}"
+                f"Invalid property: '{self.property}'! Supported properties: {PROPERTIES}"
             )
 
         valid_ops = VALID_OPS[self.property]
@@ -232,9 +231,7 @@ def _get_condition_values(cond):
 class SmartList:
     """Rekordbox smart playlist XML handler."""
 
-    def __init__(
-        self, logical_operator: int = LogicalOperator.ALL, auto_update: int = 0
-    ):
+    def __init__(self, logical_operator: int = LogicalOperator.ALL, auto_update: int = 0):
         self.playlist_id: Union[int, str] = ""
         self.logical_operator: int = int(logical_operator)
         self.auto_update: int = auto_update
@@ -320,11 +317,12 @@ class SmartList:
         comps = list()
         for cond in self.conditions:
             val_left, val_right = _get_condition_values(cond)
-
+            # val_left = str(-abs(int(val_left))) if val_left is not None else ""
             if cond.property in PROPERTY_COLUMN_MAP:
                 colum_name = PROPERTY_COLUMN_MAP[cond.property]
                 if cond.property == Property.MYTAG:
-                    val_left = str(right_bitshift(int(val_left)))
+                    if int(val_left) < 0:
+                        val_left = str(right_bitshift(int(val_left)))
 
                 if cond.operator == Operator.EQUAL:
                     comp = getattr(DjmdContent, colum_name) == val_left