Initial code for watched subfolders

Author: Et0h

syncplay/client.py

@@ -73,6 +73,9 @@ def __init__(self, playerClass, ui, config):
         constants.FOLDER_SEARCH_TIMEOUT = config['folderSearchTimeout']
         constants.FOLDER_SEARCH_DOUBLE_CHECK_INTERVAL = config['folderSearchDoubleCheckInterval']
         constants.FOLDER_SEARCH_WARNING_THRESHOLD = config['folderSearchWarningThreshold']
+        constants.WATCHED_SUBFOLDER = config['watchedSubfolder']
+        constants.WATCHED_AUTOMOVE = config['watchedAutoMove'] if len(constants.WATCHED_SUBFOLDER) > 0 else False
+        constants.WATCHED_AUTOCREATESUBFOLDERS = config['watchedSubfolderAutocreate'] if len(constants.WATCHED_SUBFOLDER) > 0 else False
 
         self.controlpasswords = {}
         self.lastControlPasswordAttempt = None
@@ -81,7 +84,9 @@ def __init__(self, playerClass, ui, config):
         self.serverFeatures = {}
 
         self.lastRewindTime = None
+        self._pendingWatchedMoves = []
         self.lastUpdatedFileTime = None
+        self._lastWatchedMoveAttempt = 0.0 #Secs
         self.lastAdvanceTime = None
         self.fileOpenBeforeChangingPlaylistIndex = None
         self.waitingToLoadNewfile = False
@@ -248,6 +253,12 @@ def updatePlayerStatus(self, paused, position):
             ):
                 pauseChange = self._toggleReady(pauseChange, paused)
 
+        if self._pendingWatchedMoves and (time.time() - (self._lastWatchedMoveAttempt or 0.0)) >= constants.WATCHED_CHECKQUEUE_INTERVAL:
+            self._lastWatchedMoveAttempt = time.time()
+            try:
+                self._tryMovePendingWatchedFiles()
+            except Exception:
+                pass
         if self._lastGlobalUpdate:
             self._lastPlayerUpdate = time.time()
             if (pauseChange or seeked) and self._protocol:
@@ -263,6 +274,13 @@ def prepareToChangeToNewPlaylistItemAndRewind(self):
         self.fileOpenBeforeChangingPlaylistIndex = self.userlist.currentUser.file["path"] if self.userlist.currentUser.file else None
         self.waitingToLoadNewfile = True
         self.waitingToLoadNewfileSince = time.time()
+        position = self.getStoredPlayerPosition()
+        currentLength = self.userlist.currentUser.file["duration"] if self.userlist.currentUser.file else 0
+        if (
+                currentLength > constants.PLAYLIST_LOAD_NEXT_FILE_MINIMUM_LENGTH and
+                abs(position - currentLength) < constants.PLAYLIST_LOAD_NEXT_FILE_TIME_FROM_END_THRESHOLD
+        ):
+            self.markWatchedFilePendingMove()
 
     def prepareToAdvancePlaylist(self):
         if self.playlist.canSwitchToNextPlaylistIndex():
@@ -516,6 +534,88 @@ def getGlobalPaused(self):
             return True
         return self._globalPaused
 
+    def markWatchedFilePendingMove(self):
+        try:
+            currentFile = self.userlist.currentUser.file if self.userlist and self.userlist.currentUser else None
+            currentFilePath = currentFile.get("path") if currentFile else None
+            if currentFilePath and not utils.isURL(currentFilePath) and currentFilePath not in self._pendingWatchedMoves:
+                self._pendingWatchedMoves.append(currentFilePath)
+                self.ui.showDebugMessage("Marked for watched move: {}".format(currentFilePath))
+        except Exception as e:
+            self.ui.showDebugMessage("Could not mark watched file: {}".format(e))
+
+    def userInitiatedMarkWatched(self, fileSourcePath):
+        try:
+            directory = os.path.dirname(fileSourcePath)
+            filename = os.path.basename(fileSourcePath)
+            watchedDirectory = utils.getWatchedSubfolder(directory)
+            utils.createWatchedSubdirIfNeeded(watchedDirectory)
+            if not os.path.isdir(watchedDirectory):
+                self.ui.showErrorMessage("'{}' subfolder not found for this file.".format(constants.WATCHED_SUBFOLDER)) # TODO: Move to Language
+                return
+            watchedDirectoryFilepath = os.path.join(watchedDirectory, filename)
+            watchedDirectoryName = os.path.basename(os.path.dirname(watchedDirectoryFilepath))
+            if os.path.isfile(watchedDirectoryFilepath):
+                self.ui.showErrorMessage("A file with the same name already exists in '{}' subfolder.".format(watchedDirectoryName)) # TODO: Move to Language
+                return
+            utils.moveFile(fileSourcePath, watchedDirectoryFilepath)
+            self.fileSwitch.updateInfo()
+            self.ui.showMessage("Moved file '{}' to '\{}\\'".format(fileSourcePath, watchedDirectoryName))
+        except Exception as e:
+            self.ui.showErrorMessage("Could not mark as watched: {}".format(e)) # TODO: Move to language
+
+    def userInitiatedMarkUnwatched(self, fileSourcePath):
+        try:
+            watchedDirectoryPath = os.path.dirname(fileSourcePath)
+            filename = os.path.basename(fileSourcePath)
+            if not utils.isWatchedSubfolder(watchedDirectoryPath):
+                self.ui.showErrorMessage("This file is not in a '{}' subfolder.".format(constants.WATCHED_SUBFOLDER))
+                return
+            unwatchedDirectoryPath = utils.getUnwatchedParentfolder(watchedDirectoryPath)
+            unwatchedDirectoryPathName = os.path.basename(unwatchedDirectoryPath)
+            unwatchedFilePath = os.path.join(unwatchedDirectoryPath, filename)
+            if os.path.isfile(unwatchedFilePath):
+                self.ui.showErrorMessage("A file with the same name already exists in the parent folder.")
+                return
+            utils.moveFile(fileSourcePath, unwatchedFilePath)
+            self.fileSwitch.updateInfo()
+            self.ui.showMessage("Moved file '{}' to '\{}\\'".format(fileSourcePath, unwatchedDirectoryPathName))  # TODO: Move to Language
+        except Exception as e:
+            self.ui.showErrorMessage("Could not mark as unwatched: {}".format(e)) # TODO: Move to Language
+
+    def _tryMovePendingWatchedFiles(self):
+        if not constants.WATCHED_AUTOMOVE:
+            self._pendingWatchedMoves = []
+            return
+
+        if not self._pendingWatchedMoves:
+            return
+
+        for pendingWatchedMove in list(self._pendingWatchedMoves):
+            try:
+                if not os.path.exists(pendingWatchedMove):
+                    self._pendingWatchedMoves.remove(pendingWatchedMove)
+                    continue
+                originalDir = os.path.dirname(pendingWatchedMove)
+                watchedDir = utils.getWatchedSubfolder(originalDir)
+                utils.createWatchedSubdirIfNeeded(watchedDir)
+                if not os.path.isdir(watchedDir):
+                    self._pendingWatchedMoves.remove(pendingWatchedMove)
+                    continue
+                destFilepath = os.path.join(watchedDir, os.path.basename(pendingWatchedMove))
+                if os.path.exists(destFilepath):
+                    self.ui.showErrorMessage(getMessage("cannot-move-file-due-to-name-conflict-error").format(pendingWatchedMove, constants.WATCHED_SUBFOLDER))
+                    self._pendingWatchedMoves.remove(pendingWatchedMove)
+                    continue
+                utils.moveFile(pendingWatchedMove, destFilepath)
+                self.fileSwitch.updateInfo()
+                try:
+                    self.ui.showMessage("Moved '{}' to '{}' sub-folder".format(pendingWatchedMove, constants.WATCHED_SUBFOLDER))
+                    self._pendingWatchedMoves.remove(pendingWatchedMove)
+                except Exception:
+                    pass
+            except Exception as e:
+                self.ui.showDebugMessage("Deferring watched move for '{}': {}".format(pendingWatchedMove, e))
     def eofReportedByPlayer(self):
         if self.playlist.notJustChangedPlaylist() and self.userlist.currentUser.file:
             self.ui.showDebugMessage("Fixing file duration to allow for playlist advancement")
@@ -914,6 +1014,16 @@ def stop(self, promptForAction=False):
         self.destroyProtocol()
         if self._player:
             self._player.drop()
+
+        if self._pendingWatchedMoves:
+            for _ in range(constants.WATCHED_PLAYERWAIT_MAXRETRIES):
+                try:
+                    self._tryMovePendingWatchedFiles()
+                    if not self._pendingWatchedMoves:
+                        break
+                except Exception:
+                    pass
+                time.sleep(constants.WATCHED_PLAYERWAIT_INTERVAL)
         if self.ui:
             self.ui.drop()
         reactor.callLater(0.1, reactor.stop)
@@ -2091,7 +2201,8 @@ def advancePlaylistCheck(self):
             abs(position - currentLength) < constants.PLAYLIST_LOAD_NEXT_FILE_TIME_FROM_END_THRESHOLD and
             self.notJustChangedPlaylist()
         ):
-                self.loadNextFileInPlaylist()
+            self._client.markWatchedFilePendingMove()
+            self.loadNextFileInPlaylist()
 
     def notJustChangedPlaylist(self):
         secondsSinceLastChange = time.time() - self._lastPlaylistIndexChange
@@ -2278,20 +2389,22 @@ def findFilepath(self, filename, highPriority=False):
             return
 
         if self._client.userlist.currentUser.file and utils.sameFilename(filename, self._client.userlist.currentUser.file['name']):
-            return self._client.userlist.currentUser.file['path']
+            return utils.getCorrectedPathForFile(self._client.userlist.currentUser.file['path'])
 
         if self.mediaFilesCache is not None:
             for directory in self.mediaFilesCache:
                 files = self.mediaFilesCache[directory]
                 if len(files) > 0 and filename in files:
                     filepath = os.path.join(directory, filename)
+                    filepath = utils.getCorrectedPathForFile(filepath)
                     if os.path.isfile(filepath):
                         return filepath
 
         if self.folderSearchEnabled and self.mediaDirectories is not None:
             directoryList = self.mediaDirectories
             for directory in directoryList:
                 filepath = os.path.join(directory, filename)
+                filepath = utils.getCorrectedPathForFile(filepath)
                 if os.path.isfile(filepath):
                     return filepath
 
@@ -2313,7 +2426,13 @@ def getDirectoryOfFilenameInCache(self, filename):
             for directory in self.mediaFilesCache:
                 files = self.mediaFilesCache[directory]
                 if filename in files:
-                    return directory
+                    filepath = os.path.join(directory, filename)
+                    if os.path.isfile(filepath):
+                        return directory
+                    watched_directory = os.path.join(directory, constants.WATCHED_SUBFOLDER)
+                    watched_filepath = os.path.join(directory, constants.WATCHED_SUBFOLDER, filename)
+                    if os.path.isfile(watched_filepath):
+                        return watched_directory
         return None
 
     def isDirectoryInList(self, directoryToFind, folderList):

syncplay/constants.py

@@ -110,6 +110,11 @@ def getValueForOS(constantDict):
 FOLDER_SEARCH_WARNING_THRESHOLD = 2.0 # Secs - how long until a warning saying how many files have been scanned
 FOLDER_SEARCH_DOUBLE_CHECK_INTERVAL = 30.0  # Secs - Frequency of updating cache
 
+# Changable values for watched features (you usually don't need to change these)
+WATCHED_CHECKQUEUE_INTERVAL = 1.0 # Secs
+WATCHED_PLAYERWAIT_INTERVAL = 0.1 # Secs
+WATCHED_PLAYERWAIT_MAXRETRIES = 80
+
 # Usually there's no need to adjust these
 DOUBLE_CHECK_REWIND = True
 LAST_PAUSED_DIFF_THRESHOLD = 2
@@ -332,6 +337,10 @@ def getValueForOS(constantDict):
 
 VLC_EOF_DURATION_THRESHOLD = 2.0
 
+WATCHED_SUBFOLDER = "Watched"
+WATCHED_AUTOMOVE = False
+WATCHED_AUTOCREATESUBFOLDERS = False
+
 PRIVACY_HIDDENFILENAME = "**Hidden filename**"
 INVERTED_STATE_MARKER = "*"
 ERROR_MESSAGE_MARKER = "*"

syncplay/messages_de.py

@@ -554,4 +554,20 @@
 
     "playlist-empty-error": "Wiedergabeliste is aktuell leer.",
     "playlist-invalid-index-error": "Ungültiger Wiedergabelisten-Index",
+
+    # Watched file functionality
+    # TODO: Please double-check these translations and remove this message if they are fine
+    "folders-label": "Ordner",
+    "syncplay-watchedfiles-title": "Gesehene Dateien",
+    "syncplay-watchedautomove-label": "Gesehene Dateien automatisch in Unterordner verschieben (falls vorhanden)",
+    "syncplay-watchedmovesubfolder-label": "Unterordner für gesehene Dateien",
+    "syncplay-watchedsubfolderautocreate-label": "Unterordner für gesehene Dateien bei Bedarf automatisch erstellen",
+    "mark-as-watched-menu-label": "Als gesehen markieren",
+    "mark-as-unwatched-menu-label": "Als ungesehen markieren",
+    "watchedautomove-tooltip": "Verschiebt die Datei automatisch in den Unterordner für gesehene Dateien, wenn das Ende der Datei erreicht ist. Dies funktioniert nur, wenn der übergeordnete Ordner ein Medienordner ist.",
+    "watchedsubfolder-tooltip": "Unterordner (relativ zum Ordner der Datei), in den gesehene Dateien verschoben werden (der Unterordner muss existieren, damit die Datei verschoben werden kann). Dies funktioniert nur, wenn der übergeordnete Ordner ein Medienordner ist.",
+    "watchedsubfolderautocreate-tooltip": "Erstellt den Unterordner für gesehene Dateien beim Verschieben automatisch, falls er noch nicht existiert. Dies funktioniert nur, wenn der übergeordnete Ordner ein Medienordner ist.",
+    "cannot-move-file-due-to-name-conflict-error": "Konnte '{}' nicht in den Unterordner '{}' verschieben, da bereits eine Datei mit diesem Namen existiert.", # Path, subfolder
+    "moved-file-to-subfolder-notification": "Verschoben: '{}' in den Unterordner '{}'.", # Path, subfolder
+
 }