Replace Ref constants with RefType enum

Author: jodal

pyproject.toml

@@ -14,7 +14,7 @@ classifiers = [
 ]
 dynamic = ["version"]
 dependencies = [
-    "mopidy >= 4.0.0a1",
+    "mopidy >= 4.0.0a3",
     "pykka >= 4",
     "setuptools >= 66",
     "uritools >= 4",

src/mopidy_local/library.py

@@ -4,7 +4,7 @@
 
 import uritools
 from mopidy import backend, models
-from mopidy.models import Ref, SearchResult
+from mopidy.models import Ref, RefType, SearchResult
 from mopidy.types import Uri
 
 from . import Extension, schema
@@ -52,11 +52,11 @@ def load(self):
     def lookup(self, uri):
         try:
             if uri.startswith("local:album"):
-                return list(schema.lookup(self._connect(), Ref.ALBUM, uri))
+                return list(schema.lookup(self._connect(), RefType.ALBUM, uri))
             if uri.startswith("local:artist"):
-                return list(schema.lookup(self._connect(), Ref.ARTIST, uri))
+                return list(schema.lookup(self._connect(), RefType.ARTIST, uri))
             if uri.startswith("local:track"):
-                return list(schema.lookup(self._connect(), Ref.TRACK, uri))
+                return list(schema.lookup(self._connect(), RefType.TRACK, uri))
             msg = "Invalid lookup URI"
             raise ValueError(msg)  # noqa: TRY301
         except Exception as e:
@@ -127,27 +127,27 @@ def _connect(self):
         return self._connection
 
     def _browse_album(self, uri, order=("disc_no", "track_no", "name")):
-        return schema.browse(self._connect(), Ref.TRACK, order, album=uri)
+        return schema.browse(self._connect(), RefType.TRACK, order, album=uri)
 
     def _browse_artist(self, uri, order=("type", "name COLLATE NOCASE")):
         with self._connect() as c:
-            albums = schema.browse(c, Ref.ALBUM, order, albumartist=uri)
+            albums = schema.browse(c, RefType.ALBUM, order, albumartist=uri)
             refs = schema.browse(c, order=order, artist=uri)
         album_uris, tracks = {ref.uri for ref in albums}, []
         for ref in refs:
-            if ref.type == Ref.ALBUM and ref.uri not in album_uris:
+            if ref.type == RefType.ALBUM and ref.uri not in album_uris:
                 albums.append(
                     Ref.directory(
                         uri=uritools.uricompose(
                             "local",
                             None,
                             "directory",
-                            dict(type=Ref.TRACK, album=ref.uri, artist=uri),  # noqa: C408
+                            dict(type=RefType.TRACK, album=ref.uri, artist=uri),  # noqa: C408
                         ),
                         name=ref.name,
                     ),
                 )
-            elif ref.type == Ref.TRACK:
+            elif ref.type == RefType.TRACK:
                 tracks.append(ref)
             else:
                 logger.debug("Skipped SQLite browse result %s", ref.uri)
@@ -168,29 +168,29 @@ def _browse_directory(self, uri, order=("type", "name COLLATE NOCASE")):
 
         # Fix #38: keep sort order of album tracks; this also applies
         # to composers and performers
-        if type_ == Ref.TRACK and "album" in query:
+        if type_ == RefType.TRACK and "album" in query:
             order = ("disc_no", "track_no", "name")
-        if type_ == Ref.ARTIST and self._config["use_artist_sortname"]:
+        if type_ == RefType.ARTIST and self._config["use_artist_sortname"]:
             order = ("coalesce(sortname, name) COLLATE NOCASE",)
         roles = role or ("artist", "albumartist")  # TODO: re-think 'roles'...
 
         refs = []
         for ref in schema.browse(self._connect(), type_, order, role=roles, **query):
-            if ref.type == Ref.TRACK or (not query and not role):
+            if ref.type == RefType.TRACK or (not query and not role):
                 refs.append(ref)
-            elif ref.type == Ref.ALBUM:
+            elif ref.type == RefType.ALBUM:
                 refs.append(
                     Ref.directory(
                         uri=uritools.uricompose(
                             "local",
                             None,
                             "directory",
-                            dict(query, type=Ref.TRACK, album=ref.uri),
+                            dict(query, type=RefType.TRACK, album=ref.uri),
                         ),
                         name=ref.name,
                     ),
                 )
-            elif ref.type == Ref.ARTIST:
+            elif ref.type == RefType.ARTIST:
                 refs.append(
                     Ref.directory(
                         uri=uritools.uricompose(

src/mopidy_local/schema.py

@@ -4,7 +4,7 @@
 import re
 import sqlite3
 
-from mopidy.models import Album, Artist, Image, Ref, Track
+from mopidy.models import Album, Artist, Image, Ref, RefType, Track
 
 _IMAGE_SIZE_RE = re.compile(r".*-(\d+)x(\d+)\.(?:png|gif|jpeg)$")
 
@@ -22,28 +22,28 @@
 _BROWSE_QUERIES = {
     None: f"""
     SELECT CASE WHEN album.uri IS NULL THEN
-           '{Ref.TRACK}' ELSE '{Ref.ALBUM}' END AS type,
+           '{RefType.TRACK}' ELSE '{RefType.ALBUM}' END AS type,
            coalesce(album.uri, track.uri) AS uri,
            coalesce(album.name, track.name) AS name
       FROM track LEFT OUTER JOIN album ON track.album = album.uri
      WHERE %s
      GROUP BY coalesce(album.uri, track.uri)
      ORDER BY %s
     """,  # noqa: S608
-    Ref.ALBUM: f"""
-    SELECT '{Ref.ALBUM}' AS type, uri AS uri, name AS name
+    RefType.ALBUM: f"""
+    SELECT '{RefType.ALBUM}' AS type, uri AS uri, name AS name
       FROM album
      WHERE %s
      ORDER BY %s
     """,  # noqa: S608
-    Ref.ARTIST: f"""
-    SELECT '{Ref.ARTIST}' AS type, uri AS uri, name AS name
+    RefType.ARTIST: f"""
+    SELECT '{RefType.ARTIST}' AS type, uri AS uri, name AS name
       FROM artist
      WHERE %s
      ORDER BY %s
-    """,  # noqa: S608
-    Ref.TRACK: f"""
-    SELECT '{Ref.TRACK}' AS type, uri AS uri, name AS name
+     """,  # noqa: S608
+    RefType.TRACK: f"""
+    SELECT '{RefType.TRACK}' AS type, uri AS uri, name AS name
       FROM track
      WHERE %s
      ORDER BY %s
@@ -61,7 +61,7 @@
         "performer": "track.performers = ?",
         "max-age": "track.last_modified >= (strftime('%s', 'now') - ?) * 1000",
     },
-    Ref.ARTIST: {
+    RefType.ARTIST: {
         "role": {
             "albumartist": """EXISTS (
                 SELECT * FROM album WHERE album.artists = artist.uri
@@ -77,7 +77,7 @@
             )""",
         },
     },
-    Ref.ALBUM: {
+    RefType.ALBUM: {
         "albumartist": "artists = ?",
         "artist": """? IN (
             SELECT artists FROM track WHERE album = album.uri
@@ -101,7 +101,7 @@
                AND last_modified >= (strftime('%s', 'now') - ?) * 1000
         )""",
     },
-    Ref.TRACK: {
+    RefType.TRACK: {
         "album": "album = ?",
         "albumartist": """? IN (
             SELECT artists FROM album WHERE uri = track.album
@@ -116,13 +116,13 @@
 }
 
 _LOOKUP_QUERIES = {
-    Ref.ALBUM: """
+    RefType.ALBUM: """
     SELECT * FROM tracks WHERE album_uri = ?
     """,
-    Ref.ARTIST: """
+    RefType.ARTIST: """
     SELECT * FROM tracks WHERE ? IN (artist_uri, albumartist_uri)
     """,
-    Ref.TRACK: """
+    RefType.TRACK: """
     SELECT * FROM tracks WHERE uri = ?
     """,
 }

tests/test_schema.py

@@ -2,7 +2,7 @@
 import unittest
 from uuid import UUID
 
-from mopidy.models import Album, Artist, Ref, Track
+from mopidy.models import Album, Artist, Ref, RefType, Track
 
 from mopidy_local import schema
 
@@ -133,26 +133,26 @@ def test_dates(self):
     def test_lookup_track(self):
         with self.connection as c:
             for track in self.tracks:
-                result = schema.lookup(c, Ref.TRACK, track.uri)
+                result = schema.lookup(c, RefType.TRACK, track.uri)
                 assert [track] == list(result)
 
     def test_lookup_album(self):
         with self.connection as c:
-            result = schema.lookup(c, Ref.ALBUM, self.albums[0].uri)
+            result = schema.lookup(c, RefType.ALBUM, self.albums[0].uri)
             assert [self.tracks[2]] == list(result)
 
-            result = schema.lookup(c, Ref.ALBUM, self.albums[1].uri)
+            result = schema.lookup(c, RefType.ALBUM, self.albums[1].uri)
             assert [self.tracks[3]] == list(result)
 
-            result = schema.lookup(c, Ref.ALBUM, self.albums[2].uri)
+            result = schema.lookup(c, RefType.ALBUM, self.albums[2].uri)
             assert [self.tracks[4]] == list(result)
 
     def test_lookup_artist(self):
         with self.connection as c:
-            result = schema.lookup(c, Ref.ARTIST, self.artists[0].uri)
+            result = schema.lookup(c, RefType.ARTIST, self.artists[0].uri)
             assert [self.tracks[1], self.tracks[3]] == list(result)
 
-            result = schema.lookup(c, Ref.ARTIST, self.artists[1].uri)
+            result = schema.lookup(c, RefType.ARTIST, self.artists[1].uri)
             assert [self.tracks[4]] == list(result)
 
     @unittest.SkipTest  # TODO: check indexed search
@@ -208,30 +208,30 @@ def ref(artist):
             return Ref.artist(name=artist.name, uri=artist.uri)
 
         with self.connection as c:
-            assert list(map(ref, self.artists)) == schema.browse(c, Ref.ARTIST)
+            assert list(map(ref, self.artists)) == schema.browse(c, RefType.ARTIST)
             assert list(map(ref, self.artists)) == schema.browse(
                 c,
-                Ref.ARTIST,
+                RefType.ARTIST,
                 role=["artist", "albumartist"],
             )
             assert list(map(ref, self.artists[0:1])) == schema.browse(
                 c,
-                Ref.ARTIST,
+                RefType.ARTIST,
                 role="artist",
             )
             assert list(map(ref, self.artists[0:1])) == schema.browse(
                 c,
-                Ref.ARTIST,
+                RefType.ARTIST,
                 role="composer",
             )
             assert list(map(ref, self.artists[0:1])) == schema.browse(
                 c,
-                Ref.ARTIST,
+                RefType.ARTIST,
                 role="performer",
             )
             assert list(map(ref, self.artists)) == schema.browse(
                 c,
-                Ref.ARTIST,
+                RefType.ARTIST,
                 role="albumartist",
             )
 
@@ -240,15 +240,15 @@ def ref(album):
             return Ref.album(name=album.name, uri=album.uri)
 
         with self.connection as c:
-            assert list(map(ref, self.albums)) == schema.browse(c, Ref.ALBUM)
+            assert list(map(ref, self.albums)) == schema.browse(c, RefType.ALBUM)
             assert list(map(ref, [])) == schema.browse(
                 c,
-                Ref.ALBUM,
+                RefType.ALBUM,
                 artist=self.artists[0].uri,
             )
             assert list(map(ref, self.albums[1:2])) == schema.browse(
                 c,
-                Ref.ALBUM,
+                RefType.ALBUM,
                 albumartist=self.artists[0].uri,
             )
 
@@ -257,25 +257,25 @@ def ref(track):
             return Ref.track(name=track.name, uri=track.uri)
 
         with self.connection as c:
-            assert list(map(ref, self.tracks)) == schema.browse(c, Ref.TRACK)
+            assert list(map(ref, self.tracks)) == schema.browse(c, RefType.TRACK)
             assert list(map(ref, self.tracks[1:2])) == schema.browse(
                 c,
-                Ref.TRACK,
+                RefType.TRACK,
                 artist=self.artists[0].uri,
             )
             assert list(map(ref, self.tracks[2:3])) == schema.browse(
                 c,
-                Ref.TRACK,
+                RefType.TRACK,
                 album=self.albums[0].uri,
             )
             assert list(map(ref, self.tracks[3:4])) == schema.browse(
                 c,
-                Ref.TRACK,
+                RefType.TRACK,
                 albumartist=self.artists[0].uri,
             )
             assert list(map(ref, self.tracks[4:5])) == schema.browse(
                 c,
-                Ref.TRACK,
+                RefType.TRACK,
                 composer=self.artists[0].uri,
                 performer=self.artists[0].uri,
             )