pyrekordbox 0.3.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

pyrekordbox/db6/smartlist.py

@@ -0,0 +1,375 @@
+# -*- coding: utf-8 -*-
+# Author: Dylan Jones
+# Date:   2023-12-13
+
+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 dateutil.relativedelta import relativedelta  # noqa
+from sqlalchemy import and_, not_, or_
+from sqlalchemy.sql.elements import BooleanClauseList
+
+from .tables import DjmdContent
+
+logger = logging.getLogger(__name__)
+
+__all__ = [
+    "LogicalOperator",
+    "Property",
+    "Operator",
+    "Condition",
+    "SmartList",
+]
+
+
+class LogicalOperator(IntEnum):
+    ALL = 1
+    ANY = 2
+
+
+class Operator(IntEnum):
+    EQUAL = 1
+    NOT_EQUAL = 2
+    GREATER = 3
+    LESS = 4
+    IN_RANGE = 5
+    IN_LAST = 6
+    NOT_IN_LAST = 7
+    CONTAINS = 8
+    NOT_CONTAINS = 9
+    STARTS_WITH = 10
+    ENDS_WITH = 11
+
+
+class Property(str, Enum):
+    ARTIST = "artist"
+    ALBUM = "album"
+    ALBUM_ARTIST = "albumArtist"
+    ORIGINAL_ARTIST = "originalArtist"
+    BPM = "bpm"
+    GROUPING = "grouping"
+    COMMENTS = "comments"
+    PRODUCER = "producer"
+    STOCK_DATE = "stockDate"
+    DATE_CREATED = "dateCreated"
+    COUNTER = "counter"
+    FILENAME = "fileName"
+    GENRE = "genre"
+    KEY = "key"
+    LABEL = "label"
+    MIX_NAME = "mixName"
+    MYTAG = "myTag"
+    RATING = "rating"
+    DATE_RELEASED = "dateReleased"
+    REMIXED_BY = "remixedBy"
+    DURATION = "duration"
+    NAME = "name"
+    YEAR = "year"
+
+
+_STR_OPS = [
+    Operator.EQUAL,
+    Operator.NOT_EQUAL,
+    Operator.CONTAINS,
+    Operator.NOT_CONTAINS,
+    Operator.STARTS_WITH,
+    Operator.ENDS_WITH,
+]
+
+_NUM_OPS = [
+    Operator.EQUAL,
+    Operator.NOT_EQUAL,
+    Operator.GREATER,
+    Operator.LESS,
+    Operator.IN_RANGE,
+]
+
+_DATE_OPS = [
+    Operator.EQUAL,
+    Operator.NOT_EQUAL,
+    Operator.GREATER,
+    Operator.LESS,
+    Operator.IN_RANGE,
+    Operator.IN_LAST,
+    Operator.NOT_IN_LAST,
+]
+
+# Defines the valid operators for each property
+VALID_OPS = {
+    Property.ARTIST: _STR_OPS,
+    Property.ALBUM: _STR_OPS,
+    Property.ALBUM_ARTIST: _STR_OPS,
+    Property.ORIGINAL_ARTIST: _STR_OPS,
+    Property.BPM: _NUM_OPS,
+    Property.GROUPING: [Operator.EQUAL, Operator.NOT_EQUAL],
+    Property.COMMENTS: _STR_OPS,
+    Property.PRODUCER: _STR_OPS,
+    Property.STOCK_DATE: _DATE_OPS,
+    Property.DATE_CREATED: _DATE_OPS,
+    Property.COUNTER: _NUM_OPS,
+    Property.FILENAME: _STR_OPS,
+    Property.GENRE: _STR_OPS,
+    Property.KEY: _STR_OPS,
+    Property.LABEL: _STR_OPS,
+    Property.MIX_NAME: _STR_OPS,
+    Property.MYTAG: [Operator.CONTAINS, Operator.NOT_CONTAINS],
+    Property.RATING: _NUM_OPS,
+    Property.DATE_RELEASED: _DATE_OPS,
+    Property.REMIXED_BY: _STR_OPS,
+    Property.DURATION: _NUM_OPS,
+    Property.NAME: _STR_OPS,
+    Property.YEAR: _NUM_OPS,
+}
+
+# Defines the column names in the DB for properties that are directly mapped
+PROPERTY_COLUMN_MAP = {
+    Property.ARTIST: "ArtistName",
+    Property.ALBUM: "AlbumName",
+    Property.ALBUM_ARTIST: "AlbumArtistName",
+    Property.ORIGINAL_ARTIST: "OrgArtistName",
+    Property.BPM: "BPM",
+    Property.GROUPING: "ColorID",
+    Property.COMMENTS: "Commnt",
+    Property.PRODUCER: "ComposerName",
+    Property.STOCK_DATE: "StockDate",
+    Property.DATE_CREATED: "created_at",
+    Property.COUNTER: "DJPlayCount",
+    Property.FILENAME: "FileNameL",
+    Property.GENRE: "GenreName",
+    Property.KEY: "KeyName",
+    Property.LABEL: "LabelName",
+    # Property.MIX_NAME don't know what this maps to
+    Property.MYTAG: "MyTagIDs",
+    Property.RATING: "Rating",
+    Property.DATE_RELEASED: "ReleaseDate",
+    Property.REMIXED_BY: "RemixerName",
+    Property.DURATION: "Length",
+    Property.NAME: "Title",
+    Property.YEAR: "ReleaseYear",
+}
+
+TYPE_CONVERSION = {
+    Property.BPM: int,
+    Property.STOCK_DATE: lambda x: datetime.strptime(x, "%Y-%m-%d"),
+    Property.DATE_CREATED: lambda x: datetime.strptime(x, "%Y-%m-%d"),
+    Property.COUNTER: int,
+    Property.RATING: int,
+    Property.DATE_RELEASED: lambda x: datetime.strptime(x, "%Y-%m-%d"),
+    Property.DURATION: int,
+    Property.YEAR: int,
+}
+
+PROPERTIES = [str(p.value) for p in list(Property)]  # noqa
+
+
+@dataclass
+class Condition:
+    """Dataclass for a smart playlist condition."""
+
+    property: str
+    operator: int
+    unit: str
+    value_left: Union[str, int]
+    value_right: Union[str, int]
+
+    def __post_init__(self):
+        if self.property not in PROPERTIES:
+            raise ValueError(
+                f"Invalid property: '{self.property}'! "
+                f"Supported properties: {PROPERTIES}"
+            )
+
+        valid_ops = VALID_OPS[self.property]
+        if self.operator not in valid_ops:
+            raise ValueError(
+                f"Invalid operator '{self.operator}' for '{self.property}', "
+                f"must be one of {valid_ops}"
+            )
+
+        if self.operator == Operator.IN_RANGE:
+            if not self.value_right:
+                raise ValueError(f"Operator '{self.operator}' requires `value_right`")
+
+
+def left_bitshift(x: int, nbit: int = 32) -> int:
+    """Left shifts an N bit integer with sign change."""
+    return x - 2**nbit
+
+
+def right_bitshift(x: int, nbit: int = 32) -> int:
+    """Right shifts an N bit integer with sign change."""
+    return x + 2**nbit
+
+
+def _get_condition_values(cond):
+    val_left = cond.value_left
+    val_right = cond.value_right
+    func = None
+    if cond.operator in (Operator.IN_LAST, Operator.NOT_IN_LAST):
+        func = int
+    elif cond.property in TYPE_CONVERSION:
+        func = TYPE_CONVERSION[cond.property]
+
+    if func is not None:
+        if val_left != "":
+            val_left = func(val_left)
+        if val_right != "":
+            try:
+                val_right = func(val_right)
+            except ValueError:
+                pass
+
+    if val_left == "":
+        val_left = None
+
+    return val_left, val_right
+
+
+class SmartList:
+    """Rekordbox smart playlist XML handler."""
+
+    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
+        self.conditions: List[Condition] = list()
+
+    def parse(self, source: str) -> None:
+        """Parse the XML source of a smart playlist."""
+        tree = xml.ElementTree(xml.fromstring(source))
+        root = tree.getroot()
+        conditions = list()
+        for child in root.findall("CONDITION"):
+            condition = Condition(
+                property=child.attrib["PropertyName"],
+                operator=int(child.attrib["Operator"]),
+                unit=child.attrib["ValueUnit"],
+                value_left=child.attrib["ValueLeft"],
+                value_right=child.attrib["ValueRight"],
+            )
+            conditions.append(condition)
+
+        self.playlist_id = str(right_bitshift(int(root.attrib["Id"])))
+        self.logical_operator = int(root.attrib["LogicalOperator"])
+        self.auto_update = int(root.attrib["AutomaticUpdate"])
+        self.conditions = conditions
+
+    def to_xml(self) -> str:
+        """Convert the smart playlist conditions to XML."""
+        attrib = {
+            "Id": str(left_bitshift(int(self.playlist_id))),
+            "LogicalOperator": str(self.logical_operator),
+            "AutomaticUpdate": str(self.auto_update),
+        }
+        root = xml.Element("NODE", attrib=attrib)
+        for cond in self.conditions:
+            attrib = {
+                "PropertyName": str(cond.property),
+                "Operator": str(cond.operator),
+                "ValueUnit": str(cond.unit),
+                "ValueLeft": str(cond.value_left),
+                "ValueRight": str(cond.value_right),
+            }
+            xml.SubElement(root, "CONDITION", attrib=attrib)
+        return xml.tostring(root).decode("utf-8").replace(" /", "/")
+
+    def add_condition(
+        self,
+        prop: str,
+        operator: int,
+        value_left: str,
+        value_right: str = "",
+        unit: str = "",
+    ) -> None:
+        """Add a condition to the smart playlist.
+
+        Parameters
+        ----------
+        prop : str
+            The property to filter on.
+        operator : {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11} int
+            The operator to use. Must be in the range of 1-11
+        value_left : str
+            The left value to use.
+        value_right : str, optional
+            The right value to use, by default "".
+        unit : str, optional
+            The unit to use, by default "".
+        """
+        if isinstance(prop, Property):
+            prop = str(prop.value)
+        cond = Condition(prop, int(operator), unit, value_left, value_right)
+        self.conditions.append(cond)
+
+    def filter_clause(self) -> BooleanClauseList:
+        """Return a SQLAlchemy filter clause matching the content of the smart playlist.
+
+        Returns
+        -------
+        BooleanClauseList
+            A filter list macthing the contents of the smart playlist.
+        """
+        logical_op = and_ if self.logical_operator == LogicalOperator.ALL else or_
+
+        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:
+                    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
+                elif cond.operator == Operator.NOT_EQUAL:
+                    comp = getattr(DjmdContent, colum_name) != val_left
+                elif cond.operator == Operator.GREATER:
+                    comp = getattr(DjmdContent, colum_name) > val_left
+                elif cond.operator == Operator.LESS:
+                    comp = getattr(DjmdContent, colum_name) < val_left
+                elif cond.operator == Operator.IN_RANGE:
+                    comp = getattr(DjmdContent, colum_name).between(val_left, val_right)
+                elif cond.operator == Operator.CONTAINS:
+                    comp = getattr(DjmdContent, colum_name).contains(val_left)
+                elif cond.operator == Operator.NOT_CONTAINS:
+                    comp = not_(getattr(DjmdContent, colum_name).contains(val_left))
+                elif cond.operator == Operator.STARTS_WITH:
+                    comp = getattr(DjmdContent, colum_name).startswith(val_left)
+                elif cond.operator == Operator.ENDS_WITH:
+                    comp = getattr(DjmdContent, colum_name).endswith(val_left)
+                elif cond.operator == Operator.IN_LAST:
+                    now = datetime.now()
+                    if cond.unit == "day":
+                        t0 = now - relativedelta(days=val_left)
+                        comp = getattr(DjmdContent, colum_name) > t0
+                    elif cond.unit == "month":
+                        t0 = now - relativedelta(months=val_left)
+                        comp = getattr(DjmdContent, colum_name).month > t0
+                    else:
+                        raise ValueError(f"Unknown unit '{cond.unit}'")
+                elif cond.operator == Operator.NOT_IN_LAST:
+                    now = datetime.now()
+                    if cond.unit == "day":
+                        t0 = now - relativedelta(days=val_left)
+                        comp = getattr(DjmdContent, colum_name) < t0
+                    elif cond.unit == "month":
+                        t0 = now - relativedelta(months=val_left)
+                        comp = getattr(DjmdContent, colum_name).month < t0
+                    else:
+                        raise ValueError(f"Unknown unit '{cond.unit}'")
+                else:
+                    raise ValueError(f"Unknown operator '{cond.operator}'")
+                comps.append(comp)
+
+            else:
+                logger.warning(f"Unsupported property '{cond.property}'")
+
+        return logical_op(*comps)

pyrekordbox/db6/tables.py

@@ -5,15 +5,28 @@
 """Rekordbox 6 `master.db` SQLAlchemy table declarations."""
 
 import math
+import re
 import struct
-import numpy as np
-from enum import IntEnum
 from datetime import datetime
-from sqlalchemy import Column, Integer, VARCHAR, BigInteger, SmallInteger, Text, Float
-from sqlalchemy import ForeignKey, TypeDecorator
-from sqlalchemy.orm import DeclarativeBase, relationship, backref, mapped_column, Mapped
+from enum import IntEnum
+from typing import List
+
+import numpy as np
+from sqlalchemy import (
+    VARCHAR,
+    BigInteger,
+    Column,
+    Float,
+    ForeignKey,
+    Integer,
+    SmallInteger,
+    Text,
+    TypeDecorator,
+)
 from sqlalchemy.ext.associationproxy import association_proxy
 from sqlalchemy.inspection import inspect
+from sqlalchemy.orm import DeclarativeBase, Mapped, backref, mapped_column, relationship
+
 from .registry import RekordboxAgentRegistry
 
 __all__ = [
@@ -106,7 +119,6 @@ class DateTime(TypeDecorator):
     """Custom datetime column with timezone support.
 
     The datetime format in the database is `YYYY-MM-DD HH:MM:SS.SSS +00:00`.
-    The timezone seems to always be `+00:00` (UTC).
     This format is not supported by the `DateTime` column of SQLAlchemy 2.
     """
 
@@ -125,7 +137,7 @@ class DateTime(TypeDecorator):
                     datestr, tzinfo = value[:23], value[23:]
                     datestr = datestr.strip()
                     tzinfo = tzinfo.strip()
-                    assert tzinfo == "+00:00", tzinfo
+                    assert re.match(r"^\+\d{2}:\d{2}$", tzinfo)
                 else:
                     datestr, tzinfo = value, ""
                 dt = datetime.fromisoformat(datestr)
@@ -139,6 +151,15 @@ class PlaylistType(IntEnum):
     SMART_PLAYLIST = 4
 
 
+class FileType(IntEnum):
+    MP3 = 1
+    M4A = 4
+    FLAC = 5
+    WAV = 11
+    AIFF = 12
+    AIF = 12
+
+
 # -- Base- and Mixin classes -----------------------------------------------------------
 
 
@@ -146,6 +167,7 @@ class Base(DeclarativeBase):
     """Base class used to initialize the declarative base for all tables."""
 
     __tablename__: str
+    __keys__: List[str] = []
 
     @classmethod
     def create(cls, **kwargs):
@@ -164,13 +186,23 @@ class Base(DeclarativeBase):
         """Returns a list of all relationship names."""
         return [column.key for column in inspect(cls).relationships]  # noqa
 
+    @classmethod
+    def __get_keys__(cls):
+        """Get all attributes of the table."""
+        items = cls.__dict__.items()
+        keys = [k for k, v in items if not callable(v) and not k.startswith("_")]
+        return keys
+
+    @classmethod
+    def keys(cls):
+        """Returns a list of all column names including the relationships."""
+        if not cls.__keys__:  # Cache the keys
+            cls.__keys__ = cls.__get_keys__()
+        return cls.__keys__
+
     def __iter__(self):
         """Iterates over all columns and relationship names."""
-        insp = inspect(self.__class__)
-        for column in insp.c:
-            yield column.name
-        for column in insp.relationships:  # noqa
-            yield column.key
+        return iter(self.keys())
 
     def __len__(self):
         return sum(1 for _ in self.__iter__())
@@ -184,10 +216,6 @@ class Base(DeclarativeBase):
             RekordboxAgentRegistry.on_update(self, key, value)
         super().__setattr__(key, value)
 
-    def keys(self):
-        """Returns a list of all column names including the relationships."""
-        return list(self.__iter__())
-
     def values(self):
         """Returns a list of all column values including the relationships."""
         return [self.__getitem__(key) for key in self.keys()]
@@ -455,7 +483,9 @@ class DjmdActiveCensor(Base, StatsFull):
     ContentUUID: Mapped[str] = mapped_column(VARCHAR(255), default=None)
     """The UUID of the :class:`DjmdContent` entry this censor belongs to."""
 
-    Content = relationship("DjmdContent")
+    Content = relationship(
+        "DjmdContent", foreign_keys=ContentID, back_populates="ActiveCensors"
+    )
     """The content entry this censor belongs to (links to :class:`DjmdContent`)."""
 
 
@@ -486,6 +516,8 @@ class DjmdAlbum(Base, StatsFull):
 
     AlbumArtist = relationship("DjmdArtist")
     """The artist entry of the artist of this album (links to :class:`DjmdArtist`)."""
+    AlbumArtistName = association_proxy("AlbumArtist", "Name")
+    """The name of the album artist (:class:`DjmdArtist`) of the track."""
 
     def __repr__(self):
         s = f"{self.ID: <10} Name={self.Name}"
@@ -751,6 +783,18 @@ class DjmdContent(Base, StatsFull):
     """The color entry of the track (links to :class:`DjmdColor`)."""
     Composer = relationship("DjmdArtist", foreign_keys=ComposerID)
     """The composer entry of the track (links to :class:`DjmdArtist`)."""
+    AlbumArtist = association_proxy("Album", "AlbumArtist")
+    """The album artist entry of the track (links to :class:`DjmdArtist`)."""
+    MyTags = relationship("DjmdSongMyTag", back_populates="Content")
+    """The my tags of the track (links to :class:`DjmdSongMyTag`)."""
+    Cues = relationship(
+        "DjmdCue", foreign_keys="DjmdCue.ContentID", back_populates="Content"
+    )
+    """The cues of the track (links to :class:`DjmdCue`)."""
+    ActiveCensors = relationship("DjmdActiveCensor", back_populates="Content")
+    """The active censors of the track (links to :class:`DjmdActiveCensor`)."""
+    MixerParams = relationship("DjmdMixerParam", back_populates="Content")
+    """The mixer parameters of the track (links to :class:`DjmdMixerParam`)."""
 
     ArtistName = association_proxy("Artist", "Name")
     """The name of the artist (:class:`DjmdArtist`) of the track."""
@@ -770,6 +814,12 @@ class DjmdContent(Base, StatsFull):
     """The name of the color (:class:`DjmdColor`) of the track."""
     ComposerName = association_proxy("Composer", "Name")
     """The name of the composer (:class:`DjmdArtist`) of the track."""
+    AlbumArtistName = association_proxy("Album", "AlbumArtistName")
+    """The name of the album artist (:class:`DjmdArtist`) of the track."""
+    MyTagNames = association_proxy("MyTags", "MyTagName")
+    """The names of the my tags (:class:`DjmdSongMyTag`) of the track."""
+    MyTagIDs = association_proxy("MyTags", "MyTagID")
+    """The IDs of the my tags (:class:`DjmdSongMyTag`) of the track."""
 
     def __repr__(self):
         s = f"{self.ID: <10} Title={self.Title}"
@@ -831,9 +881,17 @@ class DjmdCue(Base, StatsFull):
     )
     """The UUID of the content (:class:`DjmdContent`) containing the cue point."""
 
-    Content = relationship("DjmdContent", foreign_keys=ContentID)
+    Content = relationship("DjmdContent", foreign_keys=ContentID, back_populates="Cues")
     """The content entry of the cue point (links to :class:`DjmdContent`)."""
 
+    @property
+    def is_memory_cue(self):
+        return self.Kind == 0
+
+    @property
+    def is_hot_cue(self):
+        return self.Kind > 0
+
 
 class DjmdDevice(Base, StatsFull):
     """Table for storing the device data of the Rekordbox library contents."""
@@ -1115,7 +1173,7 @@ class DjmdMixerParam(Base, StatsFull):
     PeakLow: Mapped[int] = mapped_column(Integer, default=None)
     """The low peak of the mixer parameter."""
 
-    Content = relationship("DjmdContent")
+    Content = relationship("DjmdContent", back_populates="MixerParams")
     """The content this mixer parameters belong to (links to :class:`DjmdContent`)."""
 
     @staticmethod
@@ -1229,9 +1287,12 @@ class DjmdSongMyTag(Base, StatsFull):
 
     MyTag = relationship("DjmdMyTag", back_populates="MyTags")
     """The My-Tag list this item belongs to (links to :class:`DjmdMyTag`)."""
-    Content = relationship("DjmdContent")
+    Content = relationship("DjmdContent", back_populates="MyTags")
     """The content this item belongs to (links to :class:`DjmdContent`)."""
 
+    MyTagName = association_proxy("MyTag", "Name")
+    """The name of the My-Tag item (:class:`DjmdMyTag`)."""
+
 
 class DjmdPlaylist(Base, StatsFull):
     """Table for storing playlists in the Rekordbox library.

pyrekordbox/logger.py

@@ -20,4 +20,3 @@ logger.addHandler(sh)
 
 # Set logging level
 logger.setLevel(logging.WARNING)
-logging.root.setLevel(logging.NOTSET)

pyrekordbox/mysettings/__init__.py

@@ -4,14 +4,15 @@
 
 import re
 from pathlib import Path
+
 from . import structs
 from .file import (
     FILES,
-    SettingsFile,
-    MySettingFile,
-    MySetting2File,
-    DjmMySettingFile,
     DevSettingFile,
+    DjmMySettingFile,
+    MySetting2File,
+    MySettingFile,
+    SettingsFile,
 )
 
 RE_MYSETTING = re.compile(".*SETTING[0-9]?.DAT$")

pyrekordbox/mysettings/file.py

@@ -5,8 +5,10 @@
 """Rekordbox My-Setting file handlers."""
 
 import re
-from construct import Struct
 from collections.abc import MutableMapping
+
+from construct import Struct
+
 from . import structs
 
 # fmt: off

pyrekordbox/rbxml.py

@@ -7,10 +7,12 @@ r"""Rekordbox XML database file handler."""
 import logging
 import os.path
 import urllib.parse
+import xml.etree.cElementTree as xml
 from abc import abstractmethod
 from collections import abc
-import xml.etree.cElementTree as xml
+
 import bidict
+
 from .utils import pretty_xml
 
 logger = logging.getLogger(__name__)
@@ -658,7 +660,7 @@ class Node:
 
     @property
     def key_type(self):
-        """str: The type of key used by the playlist node"""
+        """str: The type of key used by the playlist node."""
         return NODE_KEYTYPE_MAPPING.get(self._element.attrib.get("KeyType"))
 
     @property
@@ -1280,7 +1282,7 @@ class RekordboxXml:
             The default is 3 spaces.
         """
         string = self.tostring(indent)
-        with open(path, "w") as fh:
+        with open(path, "w", encoding="utf-8") as fh:
             fh.write(string)
 
     def __repr__(self):

pyrekordbox/utils.py

@@ -6,9 +6,10 @@
 
 import os
 import warnings
-import psutil
-from xml.dom import minidom
 import xml.etree.cElementTree as xml
+from xml.dom import minidom
+
+import psutil
 
 warnings.simplefilter("always", DeprecationWarning)
 
@@ -122,7 +123,7 @@ def get_rekordbox_agent_pid(raise_exec=False):
 
 
 def pretty_xml(element, indent=None, encoding="utf-8"):
-    """Generates a formatted string of an XML element.
+    r"""Generates a formatted string of an XML element.
 
     Parameters
     ----------

{pyrekordbox-0.3.1.dist-info → pyrekordbox-0.4.0.dist-info}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022-2023, Dylan Jones
+Copyright (c) 2022-2024, Dylan Jones
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal