lexicon-python 0.1.0__tar.gz → 0.1.2__tar.gz

{lexicon_python-0.1.0/src/lexicon_python.egg-info → lexicon_python-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lexicon-python
-Version: 0.1.0
+Version: 0.1.2
 Summary: Python client for the Lexicon DJ API
 Author-email: Garrison Burger <burgerga123@gmail.com>
 License-Expression: MIT

{lexicon_python-0.1.0 → lexicon_python-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lexicon-python"
-version = "0.1.0"
+version = "0.1.2"
 description = "Python client for the Lexicon DJ API"
 readme = "README.md"
 license = "MIT"

{lexicon_python-0.1.0 → lexicon_python-0.1.2}/src/lexicon/lexicon.py

@@ -134,18 +134,24 @@ class LexiconClient:
     def get_playlist_by_path(
         self,
         playlist_path: Sequence[str],
-        playlist_type: Optional[int] = None,
+        playlist_type: int,
         *,
         timeout: Optional[int] = None,
     ) -> dict | None:
         """
         Get a playlist from the Lexicon library by its folder path. 
         Via ``/v1/playlist-by-path`` endpoint.
+
+        playlist_path: 
+            Sequence of folder/playlist names from the root.
+            E.g. ``["Genres", "Drum & Bass", "Dancefloor"]``.
+        
+        playlist_type: 
+            ``1=Folder``, ``2=Playlist``, ``3=Smartlist``.
         """
         endpoint = self._build_url("/v1/playlist-by-path")
         params: list[tuple[str, object]] = [("path", part) for part in playlist_path]
-        if playlist_type is not None:
-            params.append(("type", playlist_type))
+        params.append(("type", playlist_type))
 
         try:
             response = requests.get(
@@ -179,7 +185,7 @@ class LexiconClient:
         folder: dict,
         input_func: Callable[[str], str] = input,
         show_counts: bool = False,
-    ) -> Optional[tuple[list[str], dict]]:
+    ) -> Optional[dict]:
         """Interactively choose an item within ``folder``.
 
         ``0`` backs out (or cancels at the root). ``S`` selects the current folder.
@@ -256,14 +262,17 @@ class LexiconClient:
             choice = input_func("\nSelect number (Enter: current folder, C: cancel)").strip()
 
             # Handle special inputs
+            #   Enter: select current folder
             if not choice:
                 playlist = self.get_playlist(current_folder.get("id")) # Fetch full details
-                return playlist, current_path
+                return playlist
             
+            #   C/c: cancel
             if choice.lower() == "c":
                 print("Selection cancelled.")
                 return None
             
+            #   0: back out
             if choice == "0":
                 if len(stack) > 1:
                     stack.pop()
@@ -297,7 +306,7 @@ class LexiconClient:
             # Playlist/Smartlist
             if selected_type in {2, 3}:
                 playlist = self.get_playlist(selected.get("id")) # Fetch full details
-                return playlist, new_path
+                return playlist
             
             # Folder
             elif selected_type == 1:
@@ -356,10 +365,10 @@ class LexiconClient:
         show_counts: bool = True,
         timeout: Optional[int] = None,
         input_func: Callable[[str], str] = input,
-    ) -> Optional[tuple[dict, list[str]]]:
+    ) -> Optional[dict]:
         """Fetch playlists and interactively choose one via stdin.
 
-        Returns a tuple of (playlist_dict, path) or ``None`` if the user cancels.
+        Returns a playlist dict or ``None`` if the user cancels.
 
         Parameters
         ----------
@@ -391,6 +400,53 @@ class LexiconClient:
             self._logger.info("No playlist selected.")
         return selection
 
+    def get_playlist_path(self, playlist_input: int | dict, *, timeout: Optional[int] = None) -> Optional[list[str]]:
+        """
+        Fetch the full folder path for a playlist grabbing parent playlists.
+        Input is either a playlist ID or a playlist dictionary.
+        Returns a list of folder/playlist names from root to the target playlist.
+        """
+        path = []
+        playlist_parent = None
+        current_playlist = None
+        current_name = None
+
+        if isinstance(playlist_input, dict):
+            current_playlist = playlist_input
+        elif isinstance(playlist_input, int):
+            playlist_id = playlist_input
+            current_playlist = self.get_playlist(playlist_id)
+        
+        if not current_playlist:
+            self._logger.warning("Invalid playlist input; must be ID or playlist dict.")
+            return None
+        
+        while True:
+            parent_id = current_playlist.get("parentId")
+            if parent_id is None:
+                # Reached root, stop
+                break
+
+            # Prepend current name to path
+            current_name = current_playlist.get("name", "(unnamed)")
+            if isinstance(current_name, str):
+                path.insert(0, current_name)
+            else:
+                self._logger.warning("Playlist has invalid name: %s", current_name)
+                return None
+            
+            # Fetch parent playlist and continue
+            if isinstance(parent_id, int):
+                current_playlist = self.get_playlist(parent_id)
+                if not current_playlist:
+                    self._logger.warning("Could not fetch parent playlist with ID %s", parent_id)
+                    return None
+            else:
+                self._logger.warning("Playlist has invalid parentId: %s", parent_id)
+                return None
+            
+        return path
+
     #endregion
 
     # ------------------------------------------------------------------
@@ -477,7 +533,6 @@ class LexiconClient:
         while total_remaining is None or (total_remaining > 0 and get_all):
             page_params = list(params)
             page_params.append(("offset", next_offset))
-            print(page_params)  # DEBUG
 
             try:
                 response = requests.get(
@@ -612,25 +667,32 @@ class LexiconClient:
         track_ids: Iterable[int],
         *,
         max_workers: int = 5,
+        show_progress: bool = True,
         timeout: Optional[int] = None,
-    ) -> list[dict]:
-        """
-        Fetch metadata for a collection of tracks.
-        
-        Defaults to making 5 requests in parallel. 
-        Set ``max_workers=0`` to fetch one at a time.
-        More than 5 workers doesn't seem to improve speed but results may vary.
+    ) -> list[dict] | None:
+        """Fetch metadata for a collection of tracks, optionally in parallel.
+
+        Defaults to making 5 requests in parallel. Set ``max_workers=0`` to fetch
+        one at a time. More than 5 workers doesn't seem to improve speed but
+        results may vary. Progress bars can be disabled with
+        ``show_progress=False``.
         """
+
         track_ids = list(track_ids)
-        results: list[dict] = []
 
-        if not track_ids:
-            return results
+        if any(not isinstance(tid, int) for tid in track_ids):
+            self._logger.warning("track_ids must be an iterable of integers.")
+            return None
 
-        effective_timeout = timeout or self.default_timeout
+        results: list[dict] = []
 
+        effective_timeout = timeout or self.default_timeout
+    
         if max_workers == 0:
-            for track_id in tqdm(track_ids, desc="Fetching tracks", unit=" tracks"):
+            iterable = track_ids
+            if show_progress:
+                iterable = tqdm(track_ids, desc="Fetching tracks", unit=" tracks")
+            for track_id in iterable:
                 info = self.get_track(track_id, timeout=effective_timeout)
                 if info:
                     results.append(info)
@@ -641,8 +703,15 @@ class LexiconClient:
                 executor.submit(self.get_track, track_id, timeout=effective_timeout): track_id
                 for track_id in track_ids
             }
-            with tqdm(total=len(futures), desc="Fetching tracks (parallel)", unit=" tracks") as pbar:
-                for future in as_completed(futures):
+
+            completed = as_completed(futures)
+            if show_progress:
+                progress = tqdm(total=len(futures), desc="Fetching tracks (parallel)", unit=" tracks")
+            else:
+                progress = None
+
+            try:
+                for future in completed:
                     track_id = futures[future]
                     try:
                         info = future.result()
@@ -651,7 +720,11 @@ class LexiconClient:
                     except Exception as exc:  # noqa: BLE001 - handle worker failures gracefully
                         self._logger.warning("Track %s failed during fetch: %s", track_id, exc)
                     finally:
-                        pbar.update(1)
+                        if progress:
+                            progress.update(1)
+            finally:
+                if progress:
+                    progress.close()
 
         return results
     
@@ -684,6 +757,8 @@ class LexiconClient:
         self._logger.warning("Response did not contain expected tags structure")
         return None
 
+    #endregion
+
 __all__ = [
     "DEFAULT_HOST",
     "LEXICON_PORT",

{lexicon_python-0.1.0 → lexicon_python-0.1.2/src/lexicon_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lexicon-python
-Version: 0.1.0
+Version: 0.1.2
 Summary: Python client for the Lexicon DJ API
 Author-email: Garrison Burger <burgerga123@gmail.com>
 License-Expression: MIT

{lexicon_python-0.1.0 → lexicon_python-0.1.2}/tests/test_lexicon.py

@@ -13,7 +13,6 @@ if str(SRC_DIR) not in sys.path:
 
 from lexicon import LexiconClient  # noqa: E402  pylint: disable=wrong-import-position
 
-
 class DummyResponse:
     def __init__(self, payload):
         self._payload = payload
@@ -51,16 +50,17 @@ class LexiconApiTests(unittest.TestCase):
             "id": 1,
             "name": "ROOT",
             "type": "1",
+            "parentId": None,
             "playlists": [
-                {"id": 2, "name": "Folder 1", "type": "1", "playlists": [       # 1. 
-                    {"id": 5, "name": "Playlist 1", "type": "2"},                  # 1.
-                    {"id": 6, "name": "Smartlist 1", "type": "3"}                  # 2.  
+                {"id": 2, "name": "Folder 1", "type": "1", "parentId": 1, "playlists": [       # 1. 
+                    {"id": 5, "name": "Playlist 1", "type": "2", "parentId": 2},                  # 1.
+                    {"id": 6, "name": "Smartlist 1", "type": "3", "parentId": 2}                  # 2.  
                 ]},
-                {"id": 3, "name": "Playlist 2", "type": "2"},                   # 2.
-                {"id": 4, "name": "Folder 2", "type": "1", "playlists": [       # 3.
-                    {"id": 7, "name": "Playlist 3", "type": "2"},                   # 1.
-                    {"id": 8, "name": "Folder 3", "type": "1", "playlists": [       # 2.
-                        {"id": 9, "name": "Playlist 4", "type": "2"}                    # 1.
+                {"id": 3, "name": "Playlist 2", "type": "2", "parentId": 1},                   # 2.
+                {"id": 4, "name": "Folder 2", "type": "1", "parentId": 1, "playlists": [       # 3.
+                    {"id": 7, "name": "Playlist 3", "type": "2", "parentId": 4},                   # 1.
+                    {"id": 8, "name": "Folder 3", "type": "1", "parentId": 4, "playlists": [       # 2.
+                        {"id": 9, "name": "Playlist 4", "type": "2", "parentId": 8}                    # 1.
                     ]} 
                 ]},              
             ],
@@ -149,27 +149,29 @@ class LexiconApiTests(unittest.TestCase):
             return DummyErrorResponse(error_payload)
 
         with patch("lexicon.lexicon.requests.get", fake_get):
-            playlist = self.client.get_playlist_by_path(playlist_path)
+            playlist = self.client.get_playlist_by_path(playlist_path, playlist_type=2)
 
         self.assertIsNone(playlist)
 
     def test_lexicon_tree_to_flat_list_builds_paths(self, tree=tree):
         flattened = self.client._flatten_tree(tree)
+
         self.assertEqual(
             flattened,
             {
                 "id": 1, 
                 "name": "ROOT", 
                 "type": "1", 
+                "parentId": None,
                 "playlists": [
-                    {"id": 2, "name": "Folder 1", "type": "2", "path": ["Folder 1"]},
-                    {"id": 5, "name": "Playlist 1", "type": "2", "path": ["Folder 1", "Playlist 1"]},
-                    {"id": 6, "name": "Smartlist 1", "type": "3", "path": ["Folder 1", "Smartlist 1"]},
-                    {"id": 3, "name": "Playlist 2", "type": "2", "path": ["Playlist 2"]},
-                    {"id": 4, "name": "Folder 2", "type": "2", "path": ["Folder 2"]},
-                    {"id": 7, "name": "Playlist 3", "type": "2", "path": ["Folder 2", "Playlist 3"]},
-                    {"id": 8, "name": "Folder 3", "type": "2", "path": ["Folder 2", "Folder 3"]},
-                    {"id": 9, "name": "Playlist 4", "type": "2", "path": ["Folder 2", "Folder 3", "Playlist 4"]},
+                    {"id": 2, "name": "Folder 1", "type": "2", "parentId": 1, "path": ["Folder 1"]},
+                    {"id": 5, "name": "Playlist 1", "type": "2", "parentId": 2, "path": ["Folder 1", "Playlist 1"]},
+                    {"id": 6, "name": "Smartlist 1", "type": "3", "parentId": 2, "path": ["Folder 1", "Smartlist 1"]},
+                    {"id": 3, "name": "Playlist 2", "type": "2", "parentId": 1, "path": ["Playlist 2"]},
+                    {"id": 4, "name": "Folder 2", "type": "2", "parentId": 1, "path": ["Folder 2"]},
+                    {"id": 7, "name": "Playlist 3", "type": "2", "parentId": 4, "path": ["Folder 2", "Playlist 3"]},
+                    {"id": 8, "name": "Folder 3", "type": "2", "parentId": 4, "path": ["Folder 2", "Folder 3"]},
+                    {"id": 9, "name": "Playlist 4", "type": "2", "parentId": 8, "path": ["Folder 2", "Folder 3", "Playlist 4"]},
                 ]
             }
         )
@@ -179,39 +181,62 @@ class LexiconApiTests(unittest.TestCase):
 
         with patch.object(self.client, "get_playlists", return_value=tree), \
                 patch.object(self.client, "get_playlist", side_effect=self.fake_playlist):
-            playlist, path = self.client.choose_playlist(flat=False, show_counts=False, input_func=lambda _: next(inputs))
+            playlist = self.client.choose_playlist(flat=False, show_counts=False, input_func=lambda _: next(inputs))
 
         self.assertIsNotNone(playlist)
-        self.assertEqual((playlist, path), ({"id": 7, "trackIds": [1, 2, 3]}, ["Folder 2", "Playlist 3"]))
+        self.assertEqual(playlist, {"id": 7, "trackIds": [1, 2, 3]})
 
     def test_choose_playlist_handles_folder_selection(self, tree=tree):
         inputs = iter(["1", ""])  # Navigate to Folder 1 -> Select Folder 1
 
         with patch.object(self.client, "get_playlists", return_value=tree), \
                 patch.object(self.client, "get_playlist", side_effect=self.fake_playlist):
-            path, chosen = self.client.choose_playlist(flat=False, show_counts=False, input_func=lambda _: next(inputs))
+            playlist = self.client.choose_playlist(flat=False, show_counts=False, input_func=lambda _: next(inputs))
 
-        self.assertIsNotNone(chosen)
-        self.assertEqual((path, chosen), ({"id": 2, "trackIds": [1, 2, 3]}, ["Folder 1"]))
+        self.assertIsNotNone(playlist)
+        self.assertEqual(playlist, {"id": 2, "trackIds": [1, 2, 3]})
 
     def test_choose_playlist_flat_selection(self, tree=tree):
         inputs = iter(["7"])  # Select Playlist 1 directly from flat list
 
         with patch.object(self.client, "get_playlists", return_value=tree), \
                 patch.object(self.client, "get_playlist", side_effect=self.fake_playlist):
-            path, chosen = self.client.choose_playlist(flat=True, show_counts=False, input_func=lambda _: next(inputs))
+            playlist = self.client.choose_playlist(flat=True, show_counts=False, input_func=lambda _: next(inputs))
 
-        self.assertIsNotNone(chosen)
-        self.assertEqual((path, chosen), ({"id": 8, "trackIds": [1, 2, 3]}, ["Folder 2", "Folder 3"]))
+        self.assertIsNotNone(playlist)
+        self.assertEqual(playlist, {"id": 8, "trackIds": [1, 2, 3]})
 
     def test_choose_playlist_handles_cancel(self, tree=tree):
-        inputs = iter(["3", "c"])  # Select Folder 2 then Cancel
+        inputs = iter(["3", "c"])  # Select Folder 2 then cancel
 
         with patch.object(self.client, "get_playlists", return_value=tree):
             result = self.client.choose_playlist(show_counts=False, input_func=lambda _: next(inputs))
-        
+
         self.assertIsNone(result)
 
+    def test_get_playlist_path_returns_correct_path(self, tree=tree):
+        id_index: dict[int, dict] = {}
+
+        def index_tree(node: dict):
+            id_index[node["id"]] = {k: v for k, v in node.items() if k != "playlists"}
+            for child in node.get("playlists") or []:
+                index_tree(child)
+
+        index_tree(tree)
+
+        with patch.object(self.client, "get_playlist", side_effect=lambda playlist_id: id_index.get(playlist_id)):
+            path = self.client.get_playlist_path(7)
+
+        self.assertEqual(path, ["Folder 2", "Playlist 3"])
+
+    def test_get_playlist_path_handles_missing_parent(self):
+        orphan = {"id": 42, "name": "Orphan", "parentId": 999}
+
+        with patch.object(self.client, "get_playlist", return_value=None):
+            path = self.client.get_playlist_path(orphan)
+
+        self.assertIsNone(path)
+
     def test_get_track_info_returns_full_track(self):
         track_payload = {
             "id": 123,