app/classes.py

@@ -80,7 +80,6 @@ class FileErrors(NamedTuple):
 
 @dataclass
 class Filter:
-    version: int = 1
     path_type: str = "contains"
     path: Optional[str] = None
     last_played_number: Optional[int] = None

app/config.py

@@ -49,18 +49,6 @@ class Config(object):
     FADEOUT_DB = -10
     FADEOUT_SECONDS = 5
     FADEOUT_STEPS_PER_SECOND = 5
-    FILTER_DURATION_LONGER = "longer than"
-    FILTER_DURATION_MINUTES = "minutes"
-    FILTER_DURATION_SECONDS = "seconds"
-    FILTER_DURATION_SHORTER = "shorter than"
-    FILTER_PATH_CONTAINS = "contains"
-    FILTER_PATH_EXCLUDING = "excluding"
-    FILTER_PLAYED_BEFORE = "before"
-    FILTER_PLAYED_DAYS = "days"
-    FILTER_PLAYED_MONTHS = "months"
-    FILTER_PLAYED_NEVER = "never"
-    FILTER_PLAYED_WEEKS = "weeks"
-    FILTER_PLAYED_YEARS = "years"
     FUZZYMATCH_MINIMUM_LIST = 60.0
     FUZZYMATCH_MINIMUM_SELECT_ARTIST = 80.0
     FUZZYMATCH_MINIMUM_SELECT_TITLE = 80.0

app/dbtables.py

@@ -154,7 +154,7 @@ class QueriesTable(Model):
 
     id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
     name: Mapped[str] = mapped_column(String(128), nullable=False)
-    _filter_data: Mapped[dict | None] = mapped_column("filter_data", JSONEncodedDict, nullable=False)
+    _filter_data: Mapped[dict | None] = mapped_column("filter_data", JSONEncodedDict, nullable=True)
     favourite: Mapped[bool] = mapped_column(Boolean, nullable=False, index=False, default=False)
 
     def _get_filter(self) -> Filter:

app/helpers.py

@@ -10,7 +10,7 @@ import ssl
 import tempfile
 
 # PyQt imports
-from PyQt6.QtWidgets import QInputDialog, QMainWindow, QMessageBox, QWidget
+from PyQt6.QtWidgets import QMainWindow, QMessageBox, QWidget
 
 # Third party imports
 from mutagen.flac import FLAC  # type: ignore
@@ -150,23 +150,6 @@ def get_audio_metadata(filepath: str) -> AudioMetadata:
         )
 
 
-def get_name(prompt: str, default: str = "") -> str | None:
-    """Get a name from the user"""
-
-    dlg = QInputDialog()
-    dlg.setInputMode(QInputDialog.InputMode.TextInput)
-    dlg.setLabelText(prompt)
-    while True:
-        if default:
-            dlg.setTextValue(default)
-        dlg.resize(500, 100)
-        ok = dlg.exec()
-        if ok:
-            return dlg.textValue()
-
-        return None
-
-
 def get_relative_date(
     past_date: Optional[dt.datetime], reference_date: Optional[dt.datetime] = None
 ) -> str:

app/menu.yaml

@@ -4,10 +4,10 @@ menus:
       - text: "Save as Template"
         handler: "save_as_template"
       - text: "Manage Templates"
-        handler: "manage_templates_wrapper"
+        handler: "manage_templates"
       - separator: true
       - text: "Manage Queries"
-        handler: "manage_queries_wrapper"
+        handler: "manage_queries"
       - separator: true
       - text: "Exit"
         handler: "close"

app/models.py

@@ -25,7 +25,7 @@ from sqlalchemy.orm.session import Session
 from sqlalchemy.engine.row import RowMapping
 
 # App imports
-from classes import ApplicationError, Filter
+from classes import ApplicationError
 from config import Config
 from dbmanager import DatabaseManager
 import dbtables
@@ -610,21 +610,11 @@ class Queries(dbtables.QueriesTable):
         session.commit()
 
     @classmethod
-    def get_all(cls, session: Session) -> Sequence["Queries"]:
+    def get_all_queries(cls, session: Session) -> Sequence["Queries"]:
         """Returns a list of all queries ordered by name"""
 
         return session.scalars(select(cls).order_by(cls.name)).all()
 
-    @classmethod
-    def get_favourites(cls, session: Session) -> Sequence["Queries"]:
-        """Returns a list of favourite queries ordered by name"""
-
-        return session.scalars(
-            select(cls)
-            .where(cls.favourite.is_(True))
-            .order_by(cls.name)
-        ).all()
-
 
 class Settings(dbtables.SettingsTable):
     def __init__(self, session: Session, name: str) -> None:
@@ -710,40 +700,6 @@ class Tracks(dbtables.TracksTable):
             .all()
         )
 
-    @classmethod
-    def get_filtered_tracks(cls, session: Session, filter: Filter) -> Sequence["Tracks"]:
-        """
-        Return tracks matching filter
-        """
-
-        query = select(cls)
-        if filter.path:
-            if filter.path_type == "contains":
-                query = query.where(cls.path.ilike(f"%{filter.path}%"))
-            elif filter.path_type == "excluding":
-                query = query.where(cls.path.notilike(f"%{filter.path}%"))
-            else:
-                raise ApplicationError(f"Can't process filter path ({filter=})")
-        # TODO
-        # if last_played_number:
-            # need group_by track_id and having max/min lastplayed gt/lt, etc
-        seconds_duration = filter.duration_number
-        if filter.duration_unit == Config.FILTER_DURATION_MINUTES:
-            seconds_duration *= 60
-        elif filter.duration_unit != Config.FILTER_DURATION_SECONDS:
-            raise ApplicationError(f"Can't process filter duration ({filter=})")
-        if filter.duration_type == Config.FILTER_DURATION_LONGER:
-            query = query.where(cls.duration >= seconds_duration)
-        elif filter.duration_unit == Config.FILTER_DURATION_SHORTER:
-            query = query.where(cls.duration <= seconds_duration)
-        else:
-            raise ApplicationError(f"Can't process filter duration type ({filter=})")
-
-        records = session.scalars(
-            query).unique().all()
-
-        return records
-
     @classmethod
     def get_by_path(cls, session: Session, path: str) -> Optional["Tracks"]:
         """

app/querylistmodel.py

@@ -38,7 +38,7 @@ from helpers import (
     show_warning,
 )
 from log import log
-from models import db, Playdates, Tracks
+from models import db, Playdates
 from music_manager import RowAndTrack
 
 
@@ -228,20 +228,20 @@ class QuerylistModel(QAbstractTableModel):
         row = 0
 
         try:
-            results = Tracks.get_filtered_tracks(self.session, self.filter)
+            results = Tracks.get_filtered(self.session, self.filter)
             for result in results:
                 if hasattr(result, "lastplayed"):
                     lastplayed = result["lastplayed"]
                 else:
                     lastplayed = None
                 queryrow = QueryRow(
-                    artist=result.artist,
+                    artist=result["artist"],
-                    bitrate=result.bitrate or 0,
+                    bitrate=result["bitrate"],
-                    duration=result.duration,
+                    duration=result["duration"],
                     lastplayed=lastplayed,
-                    path=result.path,
+                    path=result["path"],
-                    title=result.title,
+                    title=result["title"],
-                    track_id=result.id,
+                    track_id=result["id"],
                 )
 
                 self.querylist_rows[row] = queryrow

migrations/versions/4fc2a9a82ab0_create_queries_table.py

@@ -33,7 +33,7 @@ def upgrade_() -> None:
     op.create_table('queries',
     sa.Column('id', sa.Integer(), autoincrement=True, nullable=False),
     sa.Column('name', sa.String(length=128), nullable=False),
-    sa.Column('filter_data', dbtables.JSONEncodedDict(), nullable=False),
+    sa.Column('filter_data', dbtables.JSONEncodedDict(), nullable=True),
     sa.Column('favourite', sa.Boolean(), nullable=False),
     sa.PrimaryKeyConstraint('id')
     )