pyrekordbox 0.3.1__py3-none-any.whl → 0.4.0__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
-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
-from .registry import RekordboxAgentRegistry
-from .aux_files import MasterPlaylistXml
-from .tables import DjmdContent
-from .smart_playlist import SmartList
+from ..utils import get_rekordbox_pid
 from . import tables
+from .aux_files import MasterPlaylistXml
+from .registry import RekordboxAgentRegistry
+from .smartlist import SmartList
+from .tables import DjmdContent, FileType, PlaylistType
 
 try:
     from sqlcipher3 import dbapi2 as sqlite3  # noqa
@@ -39,101 +41,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 +100,23 @@ 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():
@@ -216,7 +129,7 @@ class Rekordbox6Database:
                 )
             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)
@@ -724,32 +637,13 @@ class Rekordbox6Database:
             smartlist.parse(playlist.SmartList)
             filter_clause = smartlist.filter_clause()
         else:
-            items = list()
-            for song in playlist.Songs:
-                items.append(DjmdContent.ID == song.ContentID)
-            filter_clause = or_(*items)
+            sub_query = self.query(tables.DjmdSongPlaylist.ContentID).filter(
+                tables.DjmdSongPlaylist.PlaylistID == playlist.ID
+            )
+            filter_clause = DjmdContent.ID.in_(select(sub_query.subquery()))
 
         return self.query(*entities).filter(filter_clause)
 
-    def get_smartlist_content(self, playlist):
-        """Creates a filtered query for the contents in smart palylists.
-
-        Parameters
-        ----------
-        playlist : DjmdPlaylist or int or str
-            The playlist instance. Can either be a :class:`DjmdPlaylist`
-            object or a playlist ID.
-        """
-        if isinstance(playlist, (int, str)):
-            playlist = self.get_playlist(ID=playlist)
-        if not playlist.is_smart_playlist:
-            raise ValueError(f"Playlist {playlist} is not a smart playlist.")
-
-        smartlist = SmartList()
-        smartlist.parse(playlist.SmartList)
-        clause_list = smartlist.filter_clause()
-        return self.query(DjmdContent).filter(clause_list)
-
     def get_property(self, **kwargs):
         """Creates a filtered query for the ``DjmdProperty`` table."""
         query = self.query(tables.DjmdProperty).filter_by(**kwargs)
@@ -832,7 +726,9 @@ 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):
@@ -844,7 +740,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_
@@ -1129,7 +1026,14 @@ class Rekordbox6Database:
         table = tables.DjmdPlaylist
         id_ = str(self.generate_unused_id(table, is_28_bit=True))
         uuid = str(uuid4())
+        attribute = int(attribute)
         now = datetime.datetime.now()
+        if smart_list is not None:
+            # Set the playlist ID in the smart list and generate XML
+            smart_list.playlist_id = id_
+            smart_list_xml = smart_list.to_xml()
+        else:
+            smart_list_xml = None
 
         if parent is None:
             # If no parent is given, use root playlist
@@ -1169,7 +1073,7 @@ class Rekordbox6Database:
         logger.debug("Parent ID:   %s", parent_id)
         logger.debug("Seq:         %s", seq)
         logger.debug("Attribute:   %s", attribute)
-        logger.debug("Smart List:  %s", smart_list)
+        logger.debug("Smart List:  %s", smart_list_xml)
         logger.debug("Image Path:  %s", image_path)
 
         # Update seq numbers higher than the new seq number
@@ -1192,7 +1096,7 @@ class Rekordbox6Database:
             ImagePath=image_path,
             Attribute=attribute,
             ParentID=parent_id,
-            SmartList=smart_list,
+            SmartList=smart_list_xml,
             UUID=uuid,
             created_at=now,
             updated_at=now,
@@ -1253,7 +1157,9 @@ class Rekordbox6Database:
         '123456'
         """
         logger.info("Creating playlist %s", name)
-        return self._create_playlist(name, seq, image_path, parent, attribute=0)
+        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.
@@ -1293,7 +1199,56 @@ class Rekordbox6Database:
         '123456'
         """
         logger.info("Creating playlist folder %s", name)
-        return self._create_playlist(name, seq, image_path, parent, attribute=1)
+        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
+    ):
+        """Creates a new smart playlist in the database.
+
+        Parameters
+        ----------
+        name : str
+            The name of the new smart playlist.
+        smart_list : SmartList
+            The smart list conditions to use for the new playlist.
+        parent : DjmdPlaylist or int or str, optional
+            The parent playlist of the new playlist. If not given, the playlist will be
+            added to the root playlist. Can either be a :class:`DjmdPlaylist` object or
+            a playlist ID.
+        seq : int, optional
+            The sequence number of the new playlist. If not given, the playlist will be
+            added at the end of the parent playlist.
+        image_path : str, optional
+            The path to the image file of the new playlist.
+
+        Returns
+        -------
+        playlist : DjmdPlaylist
+            The newly created playlist.
+
+        Examples
+        --------
+        Create a new smart list which we will use for the new smart playlist:
+
+        >>> smart = SmartList(logical_operator=1)  # ALL conditions must be met
+        >>> smart.add_condition("genre", operator=1, value_left="House")  # is House
+
+        Create a new smart playlist in the root playlist:
+        >>> db = Rekordbox6Database()
+        >>> pl = db.create_smart_playlist("My Smart Playlist", smart)
+        >>> pl.ID
+        '123456789'
+
+        >>> pl.SmartList[:72]
+        '<NODE Id="123456789" LogicalOperator="1" AutomaticUpdate="1"><CONDITION '
+        """
+        logger.info("Creating smart playlist %s", name)
+        return self._create_playlist(
+            name, seq, image_path, parent, smart_list, PlaylistType.SMART_PLAYLIST
+        )
 
     def delete_playlist(self, playlist):
         """Deletes a playlist or playlist folder from the database.
@@ -1662,13 +1617,16 @@ class Rekordbox6Database:
                 artist = self.get_artist(ID=artist)
             artist = artist.ID
 
+        id_ = self.generate_unused_id(tables.DjmdAlbum)
+        uuid = str(uuid4())
         album = tables.DjmdAlbum.create(
-            ID=self.generate_unused_id(tables.DjmdAlbum),
+            ID=id_,
             Name=name,
             AlbumArtistID=artist,
             ImagePath=image_path,
             Compilation=compilation,
             SearchStr=search_str,
+            UUID=str(uuid),
         )
         self.add(album)
         self.flush()
@@ -1725,7 +1683,10 @@ class Rekordbox6Database:
             raise ValueError(f"Artist '{name}' already exists in database")
 
         id_ = self.generate_unused_id(tables.DjmdArtist)
-        artist = tables.DjmdArtist.create(ID=id_, Name=name, SearchStr=search_str)
+        uuid = str(uuid4())
+        artist = tables.DjmdArtist.create(
+            ID=id_, Name=name, SearchStr=search_str, UUID=uuid
+        )
         self.add(artist)
         self.flush()
         return artist
@@ -1774,7 +1735,8 @@ class Rekordbox6Database:
             raise ValueError(f"Genre '{name}' already exists in database")
 
         id_ = self.generate_unused_id(tables.DjmdGenre)
-        genre = tables.DjmdGenre.create(ID=id_, Name=name)
+        uuid = str(uuid4())
+        genre = tables.DjmdGenre.create(ID=id_, Name=name, UUID=uuid)
         self.add(genre)
         self.flush()
         return genre
@@ -1823,11 +1785,86 @@ class Rekordbox6Database:
             raise ValueError(f"Label '{name}' already exists in database")
 
         id_ = self.generate_unused_id(tables.DjmdLabel)
-        label = tables.DjmdLabel.create(ID=id_, Name=name)
+        uuid = str(uuid4())
+        label = tables.DjmdLabel.create(ID=id_, Name=name, UUID=uuid)
         self.add(label)
         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):
@@ -1903,6 +1940,53 @@ class Rekordbox6Database:
         root = self.get_anlz_dir(content)
         return read_anlz_files(root)
 
+    def get_anlz_path(self, content, type_):
+        """Returns the file path of an ANLZ analysis file of a track.
+
+        Parameters
+        ----------
+        content : DjmdContent or int or str
+            The content corresponding to a track in the Rekordbox v6 database.
+            If an integer is passed the database is queried for the ``DjmdContent``
+            entry.
+        type_ : str, optional
+            The type of the analysis file to return. Must be one of "DAT", "EXT" or
+            "EX2". "DAT" by default.
+
+        Returns
+        -------
+        anlz_path : Path or None
+            The file path of the analysis file for the content. If the file does not
+            exist, None is returned.
+        """
+        root = self.get_anlz_dir(content)
+        paths = get_anlz_paths(root)
+        return paths.get(type_.upper(), "")
+
+    def read_anlz_file(self, content, type_):
+        """Reads an ANLZ analysis file of a track.
+
+        Parameters
+        ----------
+        content : DjmdContent or int or str
+            The content corresponding to a track in the Rekordbox v6 database.
+            If an integer is passed the database is queried for the ``DjmdContent``
+            entry.
+        type_ : str, optional
+            The type of the analysis file to return. Must be one of "DAT", "EXT" or
+            "EX2". "DAT" by default.
+
+        Returns
+        -------
+        anlz_file : AnlzFile or None
+            The analysis file for the content. If the file does not exist, None is
+            returned.
+        """
+        path = self.get_anlz_path(content, type_)
+        if path:
+            return AnlzFile.parse_file(path)
+        return None
+
     def update_content_path(
         self, content, path, save=True, check_path=True, commit=True
     ):

pyrekordbox/db6/registry.py

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