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

pyrekordbox/__init__.py

@@ -2,19 +2,19 @@
 # Author: Dylan Jones
 # Date:   2022-04-10
 
+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
 from .logger import logger
-from .config import show_config, get_config, update_config
-from .rbxml import RekordboxXml, XmlDuplicateError, XmlAttributeKeyError
-from .anlz import get_anlz_paths, walk_anlz_paths, read_anlz_files, AnlzFile
 from .mysettings import (
+    DevSettingFile,
+    DjmMySettingFile,
+    MySetting2File,
+    MySettingFile,
     get_mysetting_paths,
     read_mysetting_file,
-    MySettingFile,
-    MySetting2File,
-    DjmMySettingFile,
-    DevSettingFile,
 )
-from .db6 import Rekordbox6Database, open_rekordbox_database
+from .rbxml import RekordboxXml, XmlAttributeKeyError, XmlDuplicateError
 
 try:
     from ._version import version as __version__

pyrekordbox/__main__.py

@@ -4,11 +4,12 @@
 
 import os
 import re
-import sys
 import shutil
+import sys
 import urllib.request
 from pathlib import Path
-from pyrekordbox.config import write_db6_key_cache, _cache_file
+
+from pyrekordbox.config import _cache_file, write_db6_key_cache
 
 KEY_SOURCES = [
     {

pyrekordbox/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.3.2'
-__version_tuple__ = version_tuple = (0, 3, 2)
+__version__ = version = '0.4.0'
+__version_tuple__ = version_tuple = (0, 4, 0)

pyrekordbox/anlz/__init__.py

@@ -5,6 +5,7 @@
 import re
 from pathlib import Path
 from typing import Union
+
 from . import structs
 from .file import AnlzFile
 
@@ -77,7 +78,7 @@ def walk_anlz_dirs(root_dir: Union[str, Path]):
         The path of the root directory.
 
     Yields
-    -------
+    ------
     anlz_dir : str
         The path of a directory containing ANLZ files
     """
@@ -96,7 +97,7 @@ def walk_anlz_paths(root_dir: Union[str, Path]):
         The path of the root directory.
 
     Yields
-    -------
+    ------
     anlz_dir : str
         The path of a directory containing ANLZ files.
     anlz_files : Sequence of str

pyrekordbox/anlz/file.py

@@ -6,10 +6,12 @@ import logging
 from collections import abc
 from pathlib import Path
 from typing import Union
-from .tags import TAGS
-from . import structs
+
 from construct import Int16ub
 
+from . import structs
+from .tags import TAGS
+
 logger = logging.getLogger(__name__)
 
 XOR_MASK = bytearray.fromhex("CB E1 EE FA E5 EE AD EE E9 D2 E9 EB E1 E9 F3 E8 E9 F4 E1")

pyrekordbox/anlz/tags.py

@@ -4,7 +4,9 @@
 
 import logging
 from abc import ABC
+
 import numpy as np
+
 from . import structs
 
 logger = logging.getLogger(__name__)
@@ -439,7 +441,7 @@ class PWV5AnlzTag(AbstractAnlzTag):
     LEN_HEADER = 24
 
     def get(self):
-        """Parse the Waveform Color Detail Tag (PWV5)
+        """Parse the Waveform Color Detail Tag (PWV5).
 
         The format of the entries is:
 

pyrekordbox/config.py

@@ -40,6 +40,7 @@ __config__ = {
     },
     "rekordbox5": {},
     "rekordbox6": {},
+    "rekordbox7": {},
 }
 
 
@@ -50,7 +51,8 @@ class InvalidApplicationDirname(Exception):
 def get_pioneer_install_dir(path: Union[str, Path] = None) -> Path:  # pragma: no cover
     """Returns the path of the Pioneer program installation directory.
 
-    On Windows, the Pioneer program data is stored in `/ProgramFiles/Pioneer`
+    On Windows, the Pioneer program data is stored in `/ProgramFiles/Pioneer`.
+    For rekordbox version 7 this has changed to `/ProgramFiles/rekordbox`.
     On macOS the program data is somewhere in `/Applications/`.
 
     Parameters
@@ -68,7 +70,7 @@ def get_pioneer_install_dir(path: Union[str, Path] = None) -> Path:  # pragma: n
         if sys.platform == "win32":
             # Windows: located in /ProgramFiles/Pioneer
             program_files = os.environ["ProgramFiles"].replace("(x86)", "").strip()
-            path = Path(program_files) / "Pioneer"
+            path = Path(program_files)
         elif sys.platform == "darwin":
             # MacOS: located in /Applications/
             path = Path("/Applications")
@@ -284,6 +286,12 @@ def _get_rb_config(
     config : dict
         The program configuration.
     """
+    if sys.platform == "win32":
+        if major_version >= 7:
+            pioneer_install_dir = pioneer_install_dir / "rekordbox"
+        else:
+            pioneer_install_dir = pioneer_install_dir / "Pioneer"
+
     if application_dirname:
         # Applitcation dirname is given, only extract version from it
         # `major_version` is compared to the version string
@@ -328,7 +336,7 @@ def _get_rb_config(
     logger.debug("Found Rekordbox %s install-dir: '%s'", major_version, rb_prog_dir)
 
     # Get Rekordbox application directory path for major release `major_version`
-    name = "rekordbox6" if major_version == 6 else "rekordbox"
+    name = "rekordbox6" if major_version >= 6 else "rekordbox"
     rb_app_dir = pioneer_app_dir / name
     if not rb_app_dir.exists():
         raise FileNotFoundError(f"The directory '{rb_app_dir}' doesn't exist!")
@@ -337,7 +345,7 @@ def _get_rb_config(
     # Get Rekordbox database locations for major release `major_version`
     settings = read_rekordbox_settings(rb_app_dir)
     db_dir = Path(settings["masterDbDirectory"])
-    db_filename = "master.db" if major_version == 6 else "datafile.edb"
+    db_filename = "master.db" if major_version >= 6 else "datafile.edb"
     db_path = db_dir / db_filename
     if not db_path.exists():
         raise FileNotFoundError(f"The Rekordbox database '{db_path}' doesn't exist!")
@@ -363,7 +371,6 @@ def _get_rb5_config(
 
 def _extract_pw(pioneer_install_dir: Path) -> str:  # pragma: no cover
     """Extract the password for decrypting the Rekordbox 6 database key."""
-
     asar_data = read_rekordbox6_asar(pioneer_install_dir)
     match_result = re.search('pass: ".(.*?)"', asar_data)
     if match_result is None:
@@ -457,23 +464,13 @@ def write_db6_key_cache(key: str) -> None:  # pragma: no cover
     with open(_cache_file, "w") as fh:
         fh.write(text)
     # Set the config key to make sure the key is present after calling method
-    __config__["rekordbox6"]["dp"] = key
+    if __config__["rekordbox6"]:
+        __config__["rekordbox6"]["dp"] = key
+    if __config__["rekordbox7"]:
+        __config__["rekordbox7"]["dp"] = key
 
 
-def _get_rb6_config(
-    pioneer_prog_dir: Path, pioneer_app_dir: Path, dirname: str = ""
-) -> dict:
-    """Get the program configuration for Rekordbox v6.x.x."""
-    major_version = 6
-    conf = _get_rb_config(pioneer_prog_dir, pioneer_app_dir, major_version, dirname)
-
-    # Read Rekordbox 6 'options.json' and check db_path
-    opts = read_rekordbox6_options(pioneer_app_dir)
-    db_path = Path(opts["db-path"])
-    db_dir = db_path.parent
-    assert str(conf["db_dir"]) == str(db_dir)
-    assert str(conf["db_path"]) == str(db_path)
-
+def _update_sqlite_key(opts, conf):
     cache_version = 0
     pw, dp = "", ""
     if _cache_file.exists():  # pragma: no cover
@@ -520,9 +517,10 @@ def _get_rb6_config(
                 if sys.platform == "win32":
                     executable = conf["install_dir"] / "rekordbox.exe"
                 elif sys.platform == "darwin":
-                    executable = (
-                        conf["install_dir"] / "Contents" / "MacOS" / "rekordbox"
-                    )
+                    install_dir = conf["install_dir"]
+                    if not str(install_dir).endswith(".app"):
+                        install_dir = install_dir / "rekordbox.app"
+                    executable = install_dir / "Contents" / "MacOS" / "rekordbox"
                 else:
                     # Linux: not supported
                     logger.warning(f"OS {sys.platform} not supported!")
@@ -552,6 +550,44 @@ def _get_rb6_config(
     if dp:
         conf["dp"] = dp
 
+
+def _get_rb6_config(
+    pioneer_prog_dir: Path, pioneer_app_dir: Path, dirname: str = ""
+) -> dict:
+    """Get the program configuration for Rekordbox v6.x.x."""
+    major_version = 6
+    conf = _get_rb_config(pioneer_prog_dir, pioneer_app_dir, major_version, dirname)
+
+    # Read Rekordbox 6 'options.json' and check db_path
+    opts = read_rekordbox6_options(pioneer_app_dir)
+    db_path = Path(opts["db-path"])
+    db_dir = db_path.parent
+    assert str(conf["db_dir"]) == str(db_dir)
+    assert str(conf["db_path"]) == str(db_path)
+
+    # Update SQLite key
+    _update_sqlite_key(opts, conf)
+
+    return conf
+
+
+def _get_rb7_config(
+    pioneer_prog_dir: Path, pioneer_app_dir: Path, dirname: str = ""
+) -> dict:
+    """Get the program configuration for Rekordbox v7.x.x."""
+    major_version = 7
+    conf = _get_rb_config(pioneer_prog_dir, pioneer_app_dir, major_version, dirname)
+
+    # Read Rekordbox 6 'options.json' and check db_path
+    opts = read_rekordbox6_options(pioneer_app_dir)
+    db_path = Path(opts["db-path"])
+    db_dir = db_path.parent
+    assert str(conf["db_dir"]) == str(db_dir)
+    assert str(conf["db_path"]) == str(db_path)
+
+    # Update SQLite key
+    _update_sqlite_key(opts, conf)
+
     return conf
 
 
@@ -617,6 +653,7 @@ def update_config(
     pioneer_app_dir: Union[str, Path] = None,
     rb5_install_dirname: str = "",
     rb6_install_dirname: str = "",
+    rb7_install_dirname: str = "",
 ):
     """Update the pyrekordbox configuration.
 
@@ -643,6 +680,9 @@ def update_config(
     rb6_install_dirname : str, optional
         The name of the Rekordbox 6 installation directory. By default, the normal
         directory name is used (Windows: 'rekordbox 6.x.x', macOS: 'rekordbox 6.app').
+    rb7_install_dirname : str, optional
+        The name of the Rekordbox 7 installation directory. By default, the normal
+        directory name is used (Windows: 'rekordbox 7.x.x', macOS: 'rekordbox 7.app').
     """
     # Read config file
     conf = read_pyrekordbox_configuration()
@@ -654,6 +694,8 @@ def update_config(
         rb5_install_dirname = conf["rekordbox5-install-dirname"]
     if not rb6_install_dirname and "rekordbox6-install-dirname" in conf:
         rb6_install_dirname = conf["rekordbox6-install-dirname"]
+    if not rb7_install_dirname and "rekordbox7-install-dirname" in conf:
+        rb7_install_dirname = conf["rekordbox7-install-dirname"]
 
     # Pioneer installation directory
     try:
@@ -689,6 +731,15 @@ def update_config(
     except FileNotFoundError as e:
         logger.info(e)
 
+    # Update Rekordbox 7 config
+    try:
+        conf = _get_rb7_config(
+            pioneer_install_dir, pioneer_app_dir, rb7_install_dirname
+        )
+        __config__["rekordbox7"].update(conf)
+    except FileNotFoundError as e:
+        logger.info(e)
+
 
 def get_config(section: str, key: str = None):
     """Gets a section or value of the pyrekordbox configuration.
@@ -721,6 +772,7 @@ def pformat_config(indent: str = "   ", hw: int = 14, delim: str = " = ") -> str
     pioneer = get_config("pioneer")
     rb5 = get_config("rekordbox5")
     rb6 = get_config("rekordbox6")
+    rb7 = get_config("rekordbox7")
 
     lines = ["Pioneer:"]
     lines += [f"{indent}{k + delim:<{hw}} {pioneer[k]}" for k in sorted(pioneer.keys())]
@@ -731,6 +783,10 @@ def pformat_config(indent: str = "   ", hw: int = 14, delim: str = " = ") -> str
     if rb6:
         rb6_keys = [k for k in rb6.keys() if k not in ("dp", "p")]
         lines += [f"{indent}{k + delim:<{hw}} {rb6[k]}" for k in sorted(rb6_keys)]
+    lines.append("Rekordbox 7:")
+    if rb7:
+        rb7_keys = [k for k in rb7.keys() if k not in ("dp", "p")]
+        lines += [f"{indent}{k + delim:<{hw}} {rb7[k]}" for k in sorted(rb7_keys)]
     return "\n".join(lines)
 
 

pyrekordbox/db6/__init__.py

@@ -2,6 +2,8 @@
 # Author: Dylan Jones
 # Date:   2022-05-07
 
+from .database import Rekordbox6Database
+from .smartlist import SmartList
 from .tables import (
     AgentRegistry,
     CloudAgentRegistry,
@@ -41,5 +43,3 @@ from .tables import (
     SettingFile,
     UuidIDMap,
 )
-from .smartlist import SmartList
-from .database import Rekordbox6Database, open_rekordbox_database

pyrekordbox/db6/aux_files.py

@@ -2,9 +2,10 @@
 # Author: Dylan Jones
 # Date:   2023-09-10
 
-from pathlib import Path
-from datetime import datetime
 import xml.etree.cElementTree as xml
+from datetime import datetime
+from pathlib import Path
+
 from ..config import get_config
 from ..utils import pretty_xml
 

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
@@ -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)
@@ -813,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):
@@ -825,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_
@@ -1875,6 +1791,80 @@ 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):

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
 
@@ -320,11 +320,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