Changes, need to review PR

cmathews393 · cmathews393 · commit d723b64dedbf · 2024-04-27T17:41:22.000Z
diff --git a/poetry.lock b/poetry.lock
diff --git a/pyproject.toml b/pyproject.toml
@@ -13,6 +13,8 @@ requests = "^2.31.0"
 rtoml = "^0.10.0"
 schedule = "^1.2.1"
 flask = "^3.0.2"
+levenshtein = "^0.25.0"
+fuzzywuzzy = "^0.18.0"
 
 
 [build-system]
diff --git a/spotiplex/__init__.py b/spotiplex/__init__.py
@@ -1,9 +1,10 @@
-from flask import Flask, render_template, request, redirect, url_for, flash
+from flask import Flask, render_template, request, redirect, url_for, flash, jsonify
 from .web_ui import functions
 from .confighandler import read_config, write_config
 import os
 
-app = Flask(__name__)
+
+app = Flask(__name__, static_url_path='/static')
 
 web_functions = functions()
 
@@ -68,6 +69,54 @@ def settings():
     )
 
 
+def update_manual_match(track_element_id, match_id):
+    # Logic to update your data storage with the manual match
+    # This function should update the match so that future processing uses this information
+    print(f"Updating manual match for {track_element_id} with {match_id}")
+    return True
+
+@app.route('/manual-match', methods=['POST'])
+def manual_match():
+    matches_json = web_functions.man_match()
+    return jsonify(matches_json)
+
+@app.route('/confirm-match', methods=['POST'])
+def confirm_match():
+    data = request.json  # Get the JSON data sent with the POST request
+    track_element_id = data.get('trackElementId')
+    selected_match_id = data.get('selectedMatchId')
+
+    if not track_element_id or not selected_match_id:
+        # Missing data, return an error
+        return jsonify({"error": "Missing trackElementId or selectedMatchId"}), 400
+
+    # Call the function to update the match with the provided IDs
+    if update_manual_match(track_element_id, selected_match_id):
+        return jsonify({"success": True}), 200
+    else:
+        # If updating the match fails for some reason
+        return jsonify({"error": "Failed to update manual match"}), 500
+
+@app.route('/update-manual-match', methods=['POST'])
+def update_manual_match():
+    data = request.json
+    track_element_id = data.get('trackElementId')
+    selected_match_id = data.get('selectedMatchId')
+
+    # Here you would convert selected_match_id into track_name and artist_name
+    # For this example, let's assume selected_match_id contains both separated by a delimiter
+    track_name, artist_name = selected_match_id.split('|', 1)
+
+    # Now, assuming man_match can also handle updating a match (or you have a similar function for this)
+    success = Spotiplex.PlexService().update_match(track_name, artist_name)
+
+    if success:
+        return jsonify({"success": True, "message": "Manual match updated successfully."}), 200
+    else:
+        return jsonify({"success": False, "message": "Failed to update manual match."}), 500
+
+
+
 @app.route("/playlists")
 def playlists_view():
     playlists = web_functions.get_playlists_data()
diff --git a/spotiplex/main.py b/spotiplex/main.py
@@ -168,15 +168,19 @@ def fetch_playlist_data(playlist):
                 if playlist_name is None:
                     playlist_name = f"Error processing playlist ID {playlist_id}"
                 spotify_tracks = self.spotify_service.get_playlist_tracks(playlist_id)
-                return playlist_name, spotify_tracks
+                track_statuses = self.plex_service.exists_in_plex(
+                    spotify_tracks
+                )  # Updated method call
+                return (
+                    playlist_name,
+                    track_statuses,
+                )  # Return track_statuses instead of spotify_tracks
             except Exception as e:
                 print(f"Error processing playlist {playlist}: {e}")
-                # Return a tuple indicating an error with the playlist to handle later
                 return f"Error processing playlist ID {playlist_id}", None
 
         playlists_data = {}
         with ThreadPoolExecutor(max_workers=self.worker_count) as executor:
-            # Schedule the fetch_playlist_data function to be called for each playlist
             future_to_playlist = {
                 executor.submit(fetch_playlist_data, playlist): playlist
                 for playlist in self.sync_lists
@@ -185,11 +189,14 @@ def fetch_playlist_data(playlist):
             for future in concurrent.futures.as_completed(future_to_playlist):
                 playlist = future_to_playlist[future]
                 try:
-                    playlist_name, spotify_tracks = future.result()
+                    playlist_name, track_statuses = (
+                        future.result()
+                    )  # Use track_statuses here
                     if (
-                        spotify_tracks is not None
-                    ):  # Ensure there was no error fetching data
-                        playlists_data[playlist_name] = spotify_tracks
+                        track_statuses is not None
+                    ):  # Ensure data was fetched successfully
+                        # Store track_statuses directly as it already includes both Spotify data and Plex presence
+                        playlists_data[playlist_name] = track_statuses
                 except Exception as e:
                     print(f"Exception processing playlist {playlist}: {e}")
                     continue
diff --git a/spotiplex/plex.py b/spotiplex/plex.py
@@ -2,6 +2,8 @@
 import urllib3
 from plexapi.server import PlexServer
 from .confighandler import read_config
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from fuzzywuzzy import process, fuzz
 
 
 class PlexService:
@@ -39,6 +41,116 @@ def check_tracks_in_plex(self, spotify_tracks):
                 continue
 
         return plex_tracks
+    
+    def manual_track_match(self, track_name, artist_name):
+        music_lib = self.plex.library.section("Music")
+        print(f"No automatic match found for: {track_name} by {artist_name}")
+
+        # Fuzzy search for artist in Plex
+        artist_matches = process.extract(
+            artist_name,
+            [artist.title for artist in music_lib.searchArtists()],
+            scorer=fuzz.token_set_ratio,
+            limit=5
+        )
+
+        print("Top artist matches:")
+        for i, (artist_match, score) in enumerate(artist_matches, 1):
+            print(f"{i}. {artist_match} (score: {score})")
+        artist_selection = input("Select the correct artist by number (or enter to skip): ")
+        
+        if artist_selection.isdigit():
+            selected_artist_name = artist_matches[int(artist_selection)-1][0]
+            artist_object = music_lib.searchArtists(title=selected_artist_name)[0]
+
+            # List tracks for the selected artist
+            print(f"Tracks by {selected_artist_name}:")
+            tracks = artist_object.tracks()
+            for i, track in enumerate(tracks, 1):
+                print(f"{i}. {track.title}")
+
+            track_selection = input("Select the correct track by number: ")
+            if track_selection.isdigit():
+                selected_track = tracks[int(track_selection)-1]
+                return selected_track
+        return None
+
+    def fuzzy_search_single_track(self, track_info, threshold=80):
+        track_name, artist_name = track_info
+        music_lib = self.plex.library.section("Music")
+        in_plex = False
+
+        # Fuzzy search for artist
+        artist_matches = process.extractOne(
+            artist_name,
+            [artist.title for artist in music_lib.searchArtists()],
+            scorer=fuzz.token_set_ratio,
+        )
+        if artist_matches and artist_matches[1] > threshold:
+            matched_artist_name = artist_matches[0]
+            artist_objects = music_lib.searchArtists(title=matched_artist_name)
+
+            for artist in artist_objects:
+                tracks = artist.tracks()
+                # Fuzzy search for track within the artist's tracks
+                track_matches = process.extractOne(
+                    track_name,
+                    [track.title for track in tracks],
+                    scorer=fuzz.token_set_ratio,
+                )
+
+                if track_matches and track_matches[1] > threshold:
+                    in_plex = True
+                    break  # Track found, no need to continue searching
+
+        return track_name, artist_name, in_plex
+
+    def fuzzy_exists_in_plex(self, spotify_tracks, threshold=80, max_workers=10):
+        track_statuses = []
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            # Create a future for each spotify track
+            future_to_track = {
+                executor.submit(
+                    self.fuzzy_search_single_track, track_info, threshold
+                ): track_info
+                for track_info in spotify_tracks
+            }
+
+            for future in as_completed(future_to_track):
+                print("processing track")
+                track_info = future_to_track[future]
+                try:
+                    result = future.result()
+                    track_statuses.append(result)
+                except Exception as exc:
+                    print(f"{track_info} generated an exception: {exc}")
+
+        return track_statuses
+
+    def exists_in_plex(self, spotify_tracks):
+        music_lib = self.plex.library.section("Music")
+        track_statuses = []
+
+        for track_name, artist_name in spotify_tracks:
+            in_plex = False
+
+            # Step 1: Search for artist objects by name
+            artist_objects = music_lib.searchArtists(title=artist_name)
+
+            # Step 2: For each artist, check if they have a track matching the track_name
+            for artist in artist_objects:
+                tracks = artist.tracks()
+                for track in tracks:
+                    if track.title.lower() == track_name.lower():
+                        in_plex = True
+                        break
+                if in_plex:
+                    break  # Found the track, no need to continue
+
+            track_statuses.append((track_name, artist_name, in_plex))
+
+        return track_statuses
+
 
     def create_or_update_playlist(self, playlist_name, playlist_id, tracks):
         existing_playlist = self.find_playlist_by_name(playlist_name)
diff --git a/spotiplex/static/js/script.js b/spotiplex/static/js/script.js
@@ -0,0 +1,89 @@
+function fetchMatches(trackName, artistName, trackElementId) {
+    fetch('/get-matches', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({trackName: trackName, artistName: artistName}),
+    })
+    .then(response => response.json())
+    .then(data => {
+        const dropdown = createDropdown(data.matches, trackElementId);
+        document.getElementById(trackElementId).appendChild(dropdown);
+    })
+    .catch((error) => {
+        console.error('Error:', error);
+    });
+}
+
+function createDropdown(matches, trackElementId) {
+    const select = document.createElement('select');
+    select.id = `match-select-${trackElementId}`;
+    matches.forEach(match => {
+        const option = document.createElement('option');
+        option.value = match.id; // Assuming each match has an ID
+        option.textContent = `${match.title} by ${match.artist}`;
+        select.appendChild(option);
+    });
+
+    // Optional: add a default "Select a match" option
+    const defaultOption = document.createElement('option');
+    defaultOption.selected = true;
+    defaultOption.disabled = true;
+    defaultOption.textContent = "Select a match";
+    select.insertBefore(defaultOption, select.firstChild);
+
+    // Append a checkmark button for confirming the selection
+    const checkButton = document.createElement('button');
+    checkButton.textContent = '✔';
+    checkButton.onclick = () => confirmMatch(trackElementId, select.value);
+
+    const container = document.createElement('div');
+    container.appendChild(select);
+    container.appendChild(checkButton);
+    return container;
+}
+
+function confirmMatch(trackElementId, matchId) {
+    // Implement the logic to confirm the match
+    // This might involve sending the matchId back to the server to update the database
+    console.log(`Confirmed match ${matchId} for track ${trackElementId}`);
+    // Example of sending the confirmed match back to the server
+    fetch('/confirm-match', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({trackElementId: trackElementId, matchId: matchId}),
+    })
+    .then(response => response.json())
+    .then(data => {
+        // Handle response, e.g., update UI to show the match is confirmed
+        console.log(data.message); // Assuming the server sends back a confirmation message
+    })
+    .catch((error) => {
+        console.error('Error:', error);
+    });
+}
+
+
+function manualMatch(trackName, artistName, trackElementId) {
+    fetch('/manual-match', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({trackName: trackName, artistName: artistName}),
+    })
+    .then(response => response.json())
+    .then(data => {
+        // Assuming `data` contains the list of possible matches
+        // Update the DOM with these matches and allow the user to select one
+        // This is an example and would need to be expanded based on your application's structure
+        const trackElement = document.getElementById(trackElementId);
+        trackElement.innerHTML += "<select onchange='submitMatch(this.value)'>" + data.matches.map(match => `<option value="${match.id}">${match.title} by ${match.artist}</option>`).join('') + "</select>";
+    })
+    .catch((error) => {
+        console.error('Error:', error);
+    });
+}
diff --git a/spotiplex/templates/playlists.html.j2 b/spotiplex/templates/playlists.html.j2
@@ -5,7 +5,9 @@
 {% block content %}
 <script>
     var startTime = new Date();
+    {% include "js/script.js" %}
 </script>
+<script src="{{ url_for('static', filename='js/script.js')}}"> </script>
 
 <div class="container mt-4">
     <h1>Playlists</h1>
@@ -37,23 +39,35 @@
                 <div class="tracks">
                     <h3>Tracks</h3>
                     <ul>
-                        {% for track in tracks %}
-                        <li>
-                            <span class="track-name">{{ track[0] }}</span>
-                            <span class="by-text">by</span>
-                            <span class="artist-name">{{ track[1] }}</span>
-                        </li>
-                        {% endfor %}
+                        <ul>
+                            {% for track in tracks %}
+                            <li>
+                                <span class="track-name">{{ track[0] }}</span> {# track name #}
+                                <span class="by-text">by</span>
+                                <span class="artist-name">{{ track[1] }}</span> {# artist name #}
+                                {% if track[2] %}
+                                <span class="track-status">&#10003;</span> {# Checkmark symbol #}
+                                {% else %}
+                                <span class="track-status">&#10007;</span> {# "X" symbol #}
+                                <button onclick="manualMatch('{{ track[0] | tojson }}', '{{ track[1] | tojson }}', 'track{{ loop.index }}')">Manual Match</button>
+                                {% endif %}
+                            </li>
+                            {% endfor %}
+                        </ul>
+
                     </ul>
                 </div>
+
             </div>
+
+
         </div>
         {% else %}
 
         {% endif %}
     </div>
     {% endfor %}
-    
+
 </div>
 
 
diff --git a/spotiplex/web_ui.py b/spotiplex/web_ui.py
