aboutsummaryrefslogtreecommitdiffstats
path: root/solo-tool-project
diff options
context:
space:
mode:
Diffstat (limited to 'solo-tool-project')
-rw-r--r--solo-tool-project/pyproject.toml4
-rw-r--r--solo-tool-project/src/solo_tool/abcontroller.py82
-rw-r--r--solo-tool-project/src/solo_tool/handlers.py35
-rw-r--r--solo-tool-project/src/solo_tool/midi_controller_launchpad_mini.py67
-rw-r--r--solo-tool-project/src/solo_tool/notifier.py3
-rw-r--r--solo-tool-project/src/solo_tool/session_manager.py35
-rw-r--r--solo-tool-project/src/solo_tool/solo_tool.py163
-rw-r--r--solo-tool-project/src/solo_tool/solo_tool_controller.py22
-rw-r--r--solo-tool-project/test/abcontroller_unittest.py272
-rw-r--r--solo-tool-project/test/midi_launchpad_mini_integrationtest.py156
-rw-r--r--solo-tool-project/test/notifier_unittest.py3
-rw-r--r--solo-tool-project/test/session_manager_unittest.py138
-rw-r--r--solo-tool-project/test/solo_tool_controller_integrationtest.py86
-rw-r--r--solo-tool-project/test/solo_tool_integrationtest.py476
-rw-r--r--solo-tool-project/test/test_session.json7
15 files changed, 402 insertions, 1147 deletions
diff --git a/solo-tool-project/pyproject.toml b/solo-tool-project/pyproject.toml
index 36d4891..7921be9 100644
--- a/solo-tool-project/pyproject.toml
+++ b/solo-tool-project/pyproject.toml
@@ -4,18 +4,18 @@ build-backend = "setuptools.build_meta"
[project]
name = "solo_tool"
+version = "2.0"
authors = [
{ name = "Eddy Pedroni", email = "epedroni@pm.me" },
]
description = "A library for dissecting guitar solos"
-requires-python = ">=3.12"
+requires-python = ">=3.13"
dependencies = [
"python-rtmidi",
"sip",
"mido",
"python-vlc"
]
-dynamic = ["version"]
[project.optional-dependencies]
dev = [
diff --git a/solo-tool-project/src/solo_tool/abcontroller.py b/solo-tool-project/src/solo_tool/abcontroller.py
deleted file mode 100644
index cec9fb2..0000000
--- a/solo-tool-project/src/solo_tool/abcontroller.py
+++ /dev/null
@@ -1,82 +0,0 @@
-from collections import namedtuple
-
-_AB = namedtuple("_AB", ["a", "b"])
-
-class ABController:
- def __init__(self, enabled=True, callback=None):
- self._setPositionCallback = callback
- self._limits = {} # dictionary of all songs
- self._songLimits = None # list of limits for selected song
- self._currentLimits = _AB(0.0, 0.0) # a/b positions of active limit
- self._loadedIndex = None
- self._enabled = enabled
-
- def _ensureSongExists(self, path):
- if path not in self._limits:
- self._limits[path] = []
-
- def setCurrentSong(self, path):
- self._ensureSongExists(path)
- self._songLimits = self._limits[path]
- self._loadedIndex = None
-
- def storeLimits(self, aLimit, bLimit, song=None):
- if song is not None:
- self._ensureSongExists(song)
- songLimits = self._limits[song]
- else:
- songLimits = self._songLimits
-
- if songLimits is None:
- return
-
- ab = _AB(aLimit, bLimit)
- songLimits.append(ab)
-
- def loadLimits(self, index):
- if not self._songLimits:
- return
-
- if index >= 0 and index < len(self._songLimits):
- self._currentLimits = self._songLimits[index]
- self._loadedIndex = index
-
- def nextStoredAbLimits(self):
- if self._loadedIndex is None:
- nextIndex = 0
- else:
- nextIndex = self._loadedIndex + 1
- self.loadLimits(nextIndex)
-
- def previousStoredAbLimits(self):
- if self._loadedIndex is None:
- previousIndex = 0
- else:
- previousIndex = self._loadedIndex - 1
- self.loadLimits(previousIndex)
-
- def setLimits(self, aLimit, bLimit):
- self._currentLimits = _AB(aLimit, bLimit)
- self._loadedIndex = None
-
- def positionChanged(self, position):
- if position > self._currentLimits.b and self._setPositionCallback and self._enabled:
- self._setPositionCallback(self._currentLimits.a)
-
- def setEnable(self, enable):
- self._enabled = enable
-
- def isEnabled(self):
- return self._enabled
-
- def getStoredLimits(self, song):
- return self._limits.get(song)
-
- def getCurrentLimits(self):
- return self._currentLimits
-
- def getLoadedIndex(self):
- return self._loadedIndex
-
- def clear(self):
- self.__init__(enabled=self._enabled, callback=self._setPositionCallback)
diff --git a/solo-tool-project/src/solo_tool/handlers.py b/solo-tool-project/src/solo_tool/handlers.py
new file mode 100644
index 0000000..0a4ee21
--- /dev/null
+++ b/solo-tool-project/src/solo_tool/handlers.py
@@ -0,0 +1,35 @@
+from collections.abc import Callable
+
+from solo_tool.solo_tool import SoloTool
+
+def changeSong(st: SoloTool, delta: int) -> Callable[[], None]:
+ def f():
+ if st.song is None:
+ st.song = 0
+ else:
+ st.song += delta
+ return f
+
+def seekRelative(st: SoloTool, delta: float) -> Callable[[], None]:
+ def f():
+ st.position += delta
+ return f
+
+def positionToKeyPoint(st: SoloTool) -> Callable[[], None]:
+ def f():
+ st.keyPoint = st.position
+ return f
+
+def changeKeyPoint(st: SoloTool, delta: int) -> Callable[[], None]:
+ from bisect import bisect_right, bisect_left
+ def f():
+ if delta > 0:
+ pivot = bisect_right(st.keyPoints, st.keyPoint) - 1
+ elif delta < 0:
+ pivot = bisect_left(st.keyPoints, st.keyPoint) - 1
+ else:
+ return
+ new = max(min(pivot + delta, len(st.keyPoints) - 1), 0)
+ st.keyPoint = st.keyPoints[new]
+ return f
+
diff --git a/solo-tool-project/src/solo_tool/midi_controller_launchpad_mini.py b/solo-tool-project/src/solo_tool/midi_controller_launchpad_mini.py
index 4fde8fc..6d2b5b2 100644
--- a/solo-tool-project/src/solo_tool/midi_controller_launchpad_mini.py
+++ b/solo-tool-project/src/solo_tool/midi_controller_launchpad_mini.py
@@ -1,5 +1,5 @@
from .midi_wrapper_mido import MidiWrapper
-from .solo_tool_controller import SoloToolController
+from . import handlers
class MidiController:
DEVICE_NAME = "Launchpad Mini MIDI 1"
@@ -20,7 +20,6 @@ class MidiController:
def __init__(self, soloTool, midiWrapperOverride=None):
self._soloTool = soloTool
- self._soloToolController = SoloToolController(soloTool)
if midiWrapperOverride is not None:
self._midiWrapper = midiWrapperOverride
else:
@@ -28,31 +27,25 @@ class MidiController:
self._registerHandlers()
self._soloTool.registerPlayingStateCallback(self._updatePlayPauseButton)
- self._soloTool.registerPlaybackVolumeCallback(self._updateVolumeRow)
- self._soloTool.registerPlaybackRateCallback(self._updateRateRow)
- self._soloTool.registerAbLimitEnabledCallback(self._updateToggleAbLimitEnableButton)
-
- self._aLimit = 0.0
- self._bLimit = 0.0
+ self._soloTool.registerVolumeCallback(self._updateVolumeRow)
+ self._soloTool.registerRateCallback(self._updateRateRow)
def _registerHandlers(self):
self._handlers = {
96 : self._soloTool.stop,
- 114 : self._soloTool.jumpToA,
+ 114 : self._soloTool.jump,
112 : self._playPause,
- 98 : self._toggleAbLimitEnable,
- 118 : self._soloTool.previousStoredAbLimits,
- 119 : self._soloTool.nextStoredAbLimits,
- 116 : self._setALimit,
- 117 : self._setBLimit,
- 48 : self._soloToolController.previousSong,
- 49 : self._createSeekHandler(-0.25),
- 50 : self._createSeekHandler(-0.05),
- 51 : self._createSeekHandler(-0.01),
- 52 : self._createSeekHandler(0.01),
- 53 : self._createSeekHandler(0.05),
- 54 : self._createSeekHandler(0.25),
- 55 : self._soloToolController.nextSong,
+ 118 : handlers.changeKeyPoint(self._soloTool, -1),
+ 119 : handlers.changeKeyPoint(self._soloTool, 1),
+ 117 : handlers.positionToKeyPoint(self._soloTool),
+ 48 : handlers.changeSong(self._soloTool, -1),
+ 49 : handlers.seekRelative(self._soloTool, -0.25),
+ 50 : handlers.seekRelative(self._soloTool, -0.05),
+ 51 : handlers.seekRelative(self._soloTool, -0.01),
+ 52 : handlers.seekRelative(self._soloTool, 0.01),
+ 53 : handlers.seekRelative(self._soloTool, 0.05),
+ 54 : handlers.seekRelative(self._soloTool, 0.25),
+ 55 : handlers.changeSong(self._soloTool, 1),
}
for i in range(0, 8):
@@ -84,24 +77,6 @@ class MidiController:
else:
self._soloTool.play()
- def _createSeekHandler(self, delta):
- def f():
- newPosition = self._soloTool.getPlaybackPosition() + delta
- newPosition = min(1.0, max(0.0, newPosition))
- self._soloTool.setPlaybackPosition(newPosition)
- return f
-
- def _setALimit(self):
- self._aLimit = self._soloTool.getPlaybackPosition()
- self._soloTool.setAbLimits(self._aLimit, self._bLimit)
-
- def _setBLimit(self):
- self._bLimit = self._soloTool.getPlaybackPosition()
- self._soloTool.setAbLimits(self._aLimit, self._bLimit)
-
- def _toggleAbLimitEnable(self):
- self._soloTool.setAbLimitEnable(not self._soloTool.isAbLimitEnabled())
-
def _updatePlayPauseButton(self, playing):
if playing:
self._setButtonLED(7, 0, MidiController.LED_GREEN)
@@ -128,12 +103,12 @@ class MidiController:
def _createSetPlaybackRateCallback(self, rate):
def f():
- self._soloTool.setPlaybackRate(rate)
+ self._soloTool.rate = rate
return f
def _createSetPlaybackVolumeCallback(self, volume):
def f():
- self._soloTool.setPlaybackVolume(volume)
+ self._soloTool.volume = volume
return f
def _setButtonLED(self, row, col, colour):
@@ -153,23 +128,19 @@ class MidiController:
self._allLEDsOff()
# volume buttons
- self._updateVolumeRow(self._soloTool.getPlaybackVolume())
+ self._updateVolumeRow(self._soloTool.volume)
# playback rate buttons
- self._updateRateRow(self._soloTool.getPlaybackRate())
+ self._updateRateRow(self._soloTool.rate)
# playback control
self._setButtonLED(6, 0, MidiController.LED_RED)
self._updatePlayPauseButton(self._soloTool.isPlaying())
- # AB repeat toggle
- self._updateToggleAbLimitEnableButton(self._soloTool.isAbLimitEnabled())
-
# AB control
self._setButtonLED(7, 2, MidiController.LED_YELLOW)
self._setButtonLED(7, 6, MidiController.LED_RED)
self._setButtonLED(7, 7, MidiController.LED_GREEN)
- self._setButtonLED(7, 4, MidiController.LED_YELLOW)
self._setButtonLED(7, 5, MidiController.LED_YELLOW)
# Song control
diff --git a/solo-tool-project/src/solo_tool/notifier.py b/solo-tool-project/src/solo_tool/notifier.py
index 9f445b6..73b84b7 100644
--- a/solo-tool-project/src/solo_tool/notifier.py
+++ b/solo-tool-project/src/solo_tool/notifier.py
@@ -3,8 +3,7 @@ class Notifier:
PLAYBACK_VOLUME_EVENT = 1
PLAYBACK_RATE_EVENT = 2
CURRENT_SONG_EVENT = 3
- CURRENT_AB_EVENT = 4
- AB_LIMIT_ENABLED_EVENT = 5
+ CURRENT_KEY_POINT_EVENT = 3
def __init__(self, player):
self._callbacks = dict()
diff --git a/solo-tool-project/src/solo_tool/session_manager.py b/solo-tool-project/src/solo_tool/session_manager.py
index a4dabc0..9744b57 100644
--- a/solo-tool-project/src/solo_tool/session_manager.py
+++ b/solo-tool-project/src/solo_tool/session_manager.py
@@ -1,29 +1,30 @@
import json
+from . import SoloTool
-def loadSession(file, songList, abController):
- jsonStr = file.read()
- session = json.loads(jsonStr)
+def loadSession(file: str) -> SoloTool:
+ with open(file, "r") as f:
+ session = json.load(f)
- songList.clear()
- abController.clear()
+ st = SoloTool()
- for entry in session:
+ for i, entry in enumerate(session):
songPath = entry["path"]
- abLimits = entry["ab_limits"]
- songList.append(songPath)
+ keyPoints = entry["key_points"]
- if abLimits is not None:
- for l in abLimits:
- abController.storeLimits(l[0], l[1], songPath)
+ st.addSong(songPath)
+ st._keyPoints[i] = keyPoints
+
+ return st
-def saveSession(file, songList, abController):
- session = list()
+def saveSession(soloTool: SoloTool, file: str) -> None:
+ session = []
- for s in songList:
+ for i, song in enumerate(soloTool.songs):
entry = {
- "path": s,
- "ab_limits" : abController.getStoredLimits(s)
+ "path": song,
+ "key_points" : soloTool._keyPoints[i]
}
session.append(entry)
- file.write(json.dumps(session))
+ with open(file, "w") as f:
+ json.dump(session, f)
diff --git a/solo-tool-project/src/solo_tool/solo_tool.py b/solo-tool-project/src/solo_tool/solo_tool.py
index a4c7af8..147a7b9 100644
--- a/solo-tool-project/src/solo_tool/solo_tool.py
+++ b/solo-tool-project/src/solo_tool/solo_tool.py
@@ -1,39 +1,37 @@
import os
-from .abcontroller import ABController
-from .session_manager import loadSession, saveSession
from .notifier import Notifier
from .player_vlc import Player
class SoloTool:
def __init__(self, playerOverride=None):
self._player = Player() if playerOverride is None else playerOverride
- self._abController = ABController(enabled=False, callback=self._abControllerCallback)
self._notifier = Notifier(self._player)
- self._songList = []
+ self._songs = []
self._song = None
+ self._keyPoints = []
+ self._keyPoint = None
def _updateSong(self, index):
self._song = index
- path = self._songList[index]
+ path = self._songs[index]
self._player.setCurrentSong(path)
- self._abController.setCurrentSong(path)
self._notifier.notify(Notifier.CURRENT_SONG_EVENT, index)
+ self._keyPoint = 0.0
- def _abControllerCallback(self, position):
- self._player.setPlaybackPosition(position)
-
- def tick(self):
- position = self._player.getPlaybackPosition()
- self._abController.positionChanged(position)
+ @staticmethod
+ def _keyPointValid(kp: float) -> bool:
+ return kp is not None and kp >= 0.0 and kp < 1.0
@property
- def songList(self) -> list[str]:
- return self._songList
+ def songs(self) -> list[str]:
+ return self._songs.copy()
def addSong(self, path: str) -> None:
- if os.path.isfile(path):
- self._songList.append(path)
+ if not os.path.isfile(path):
+ raise FileNotFoundError()
+ self._songs.append(path)
+ self._keyPoints.append([])
@property
def song(self) -> int:
@@ -41,64 +39,33 @@ class SoloTool:
@song.setter
def song(self, new: int) -> None:
- if new >= 0 and new < len(self._songList) and new != self._song:
+ if new is not None \
+ and new >= 0 \
+ and new < len(self._songs) \
+ and new != self._song:
self._updateSong(new)
- def storeAbLimits(self, aLimit, bLimit):
- self._abController.storeLimits(aLimit, bLimit)
-
- def loadAbLimits(self, index):
- previous = self._abController.getLoadedIndex()
- self._abController.loadLimits(index)
- new = self._abController.getLoadedIndex()
- if previous != new:
- self._notifier.notify(Notifier.CURRENT_AB_EVENT, new)
-
- def setAbLimits(self, aLimit, bLimit):
- self._abController.setLimits(aLimit, bLimit)
-
- def getStoredAbLimits(self):
- if self._song is not None:
- return self._abController.getStoredLimits(self.songList[self._song])
- else:
- return list()
-
- def setAbLimitEnable(self, enable):
- previous = self._abController.isEnabled()
- self._abController.setEnable(enable)
- new = self._abController.isEnabled()
- if previous != new:
- self._notifier.notify(Notifier.AB_LIMIT_ENABLED_EVENT, new)
-
- def isAbLimitEnabled(self):
- return self._abController.isEnabled()
-
- def nextStoredAbLimits(self):
- previous = self._abController.getLoadedIndex()
- self._abController.nextStoredAbLimits()
- new = self._abController.getLoadedIndex()
- if previous != new:
- self._notifier.notify(Notifier.CURRENT_AB_EVENT, new)
-
- def previousStoredAbLimits(self):
- previous = self._abController.getLoadedIndex()
- self._abController.previousStoredAbLimits()
- new = self._abController.getLoadedIndex()
- if previous != new:
- self._notifier.notify(Notifier.CURRENT_AB_EVENT, new)
-
- def jumpToA(self):
- a = self._abController.getCurrentLimits()[0]
- # XXX assumes that player.setPlaybackPosition is thread-safe!
- self._player.setPlaybackPosition(a)
-
- def loadSession(self, path):
- with open(path, "r") as f:
- loadSession(f, self._songList, self._abController)
-
- def saveSession(self, path):
- with open(path, "w") as f:
- saveSession(f, self._songList, self._abController)
+ @property
+ def keyPoints(self) -> list[float]:
+ if self._song is None:
+ return None
+ return self._keyPoints[self._song]
+
+ @keyPoints.setter
+ def keyPoints(self, new: list[float]) -> None:
+ if new is not None and self._song is not None:
+ sanitized = sorted(list(set([p for p in new if SoloTool._keyPointValid(p)])))
+ self._keyPoints[self._song] = sanitized
+
+ @property
+ def keyPoint(self) -> float:
+ return self._keyPoint
+
+ @keyPoint.setter
+ def keyPoint(self, new: float) -> None:
+ if self._song is not None and SoloTool._keyPointValid(new) and new != self._keyPoint:
+ self._keyPoint = new
+ self._notifier.notify(Notifier.CURRENT_KEY_POINT_EVENT, new)
def play(self):
self._player.play()
@@ -112,43 +79,51 @@ class SoloTool:
def isPlaying(self):
return self._player.isPlaying()
- def setPlaybackRate(self, rate):
- previous = self._player.getPlaybackRate()
- self._player.setPlaybackRate(rate)
- new = self._player.getPlaybackRate()
- if previous != new:
- self._notifier.notify(Notifier.PLAYBACK_RATE_EVENT, new)
+ def jump(self):
+ self._player.setPlaybackPosition(self._keyPoint)
- def getPlaybackRate(self):
+ @property
+ def rate(self) -> float:
return self._player.getPlaybackRate()
- def setPlaybackPosition(self, position):
- self._player.setPlaybackPosition(position)
+ @rate.setter
+ def rate(self, new: float) -> None:
+ if new is not None and new >= 0.0 and new != self._player.getPlaybackRate():
+ self._player.setPlaybackRate(new)
+ self._notifier.notify(Notifier.PLAYBACK_RATE_EVENT, new)
- def getPlaybackPosition(self):
- return self._player.getPlaybackPosition()
+ @property
+ def volume(self) -> float:
+ return self._player.getPlaybackVolume()
- def setPlaybackVolume(self, volume):
- self._player.setPlaybackVolume(volume)
+ @volume.setter
+ def volume(self, new: float) -> None:
+ if new is not None and new >= 0.0 and new != self._player.getPlaybackVolume():
+ self._player.setPlaybackVolume(new)
+ self._notifier.notify(Notifier.PLAYBACK_VOLUME_EVENT, new)
- def getPlaybackVolume(self):
- return self._player.getPlaybackVolume()
+ @property
+ def position(self) -> float:
+ return self._player.getPlaybackPosition()
+
+ @position.setter
+ def position(self, new: float) -> None:
+ # TODO stop playback before changing position?
+ if new is not None and new != self._player.getPlaybackPosition():
+ self._player.setPlaybackPosition(min(max(0.0, new), 1.0))
def registerPlayingStateCallback(self, callback):
self._notifier.registerCallback(Notifier.PLAYING_STATE_EVENT, callback)
- def registerPlaybackVolumeCallback(self, callback):
+ def registerVolumeCallback(self, callback):
self._notifier.registerCallback(Notifier.PLAYBACK_VOLUME_EVENT, callback)
- def registerPlaybackRateCallback(self, callback):
+ def registerRateCallback(self, callback):
self._notifier.registerCallback(Notifier.PLAYBACK_RATE_EVENT, callback)
def registerCurrentSongCallback(self, callback):
self._notifier.registerCallback(Notifier.CURRENT_SONG_EVENT, callback)
- def registerCurrentAbLimitsCallback(self, callback):
- self._notifier.registerCallback(Notifier.CURRENT_AB_EVENT, callback)
-
- def registerAbLimitEnabledCallback(self, callback):
- self._notifier.registerCallback(Notifier.AB_LIMIT_ENABLED_EVENT, callback)
+ def registerCurrentKeyPointCallback(self, callback):
+ self._notifier.registerCallback(Notifier.CURRENT_KEY_POINT_EVENT, callback)
diff --git a/solo-tool-project/src/solo_tool/solo_tool_controller.py b/solo-tool-project/src/solo_tool/solo_tool_controller.py
deleted file mode 100644
index 0529570..0000000
--- a/solo-tool-project/src/solo_tool/solo_tool_controller.py
+++ /dev/null
@@ -1,22 +0,0 @@
-import os
-
-from solo_tool.solo_tool import SoloTool
-
-class SoloToolController:
- def __init__(self, soloTool: SoloTool):
- self._soloTool = soloTool
-
- def nextSong(self):
- current = self._soloTool.song
- if current is None:
- self._soloTool.song = 0
- else:
- self._soloTool.song = current + 1
-
- def previousSong(self):
- current = self._soloTool.song
- if current is None:
- self._soloTool.song = 0
- else:
- self._soloTool.song = current - 1
-
diff --git a/solo-tool-project/test/abcontroller_unittest.py b/solo-tool-project/test/abcontroller_unittest.py
deleted file mode 100644
index d2b7d31..0000000
--- a/solo-tool-project/test/abcontroller_unittest.py
+++ /dev/null
@@ -1,272 +0,0 @@
-from solo_tool.abcontroller import ABController
-from collections import namedtuple
-
-TCase = namedtuple("TCase", ["currentPosition", "requestedPosition"])
-AB = namedtuple("AB", ["a", "b"])
-abLimits = AB(0.2, 0.4)
-
-def _checkLimits(uut, tests):
- requestedPosition = None
- def callback(newPosition):
- nonlocal requestedPosition
- requestedPosition = newPosition
-
- originalCallback = uut._setPositionCallback
- uut._setPositionCallback = callback
-
- for t in tests:
- uut.positionChanged(t.currentPosition)
- assert requestedPosition == t.requestedPosition
-
- uut._setPositionCallback = originalCallback
-
-def checkLimits(uut, aLimit, bLimit, fail=False):
- tests = [
- TCase(aLimit - 0.1, None),
- TCase(aLimit, None),
- TCase(bLimit - 0.1, None),
- TCase(bLimit, None),
- TCase(bLimit + 0.1, aLimit if not fail else None)
- ]
- _checkLimits(uut, tests)
- if not fail:
- assert uut.getCurrentLimits()[0] == aLimit
- assert uut.getCurrentLimits()[1] == bLimit
-
-def checkDefaultLimits(uut):
- tests = [
- TCase(0.0, None),
- TCase(0.1, 0.0),
- TCase(0.5, 0.0)
- ]
- _checkLimits(uut, tests)
-
-def test_oneSetOfLimits():
- song = "/path/to/song"
-
- uut = ABController()
- uut.setCurrentSong(song)
- uut.storeLimits(abLimits.a, abLimits.b)
- uut.loadLimits(0)
- assert uut.getLoadedIndex() == 0
-
- checkLimits(uut, abLimits.a, abLimits.b)
- assert uut.getStoredLimits(song) == [abLimits]
-
-def test_multipleSetsOfLimits():
- song = "/path/to/song"
- abLimits = [
- AB(0.2, 0.4),
- AB(0.3, 0.5),
- AB(0.0, 1.2)
- ]
-
- uut = ABController()
- uut.setCurrentSong(song)
- for l in abLimits:
- uut.storeLimits(l.a, l.b)
-
- for i, l in enumerate(abLimits):
- uut.loadLimits(i)
- assert uut.getLoadedIndex() == i
- checkLimits(uut, l.a, l.b)
-
- assert uut.getStoredLimits(song) == abLimits
-
-def test_multipleSongs():
- songs = [
- "/path/to/song",
- "/path/to/another/song"
- ]
- abLimits = [
- AB(0.2, 0.4),
- AB(0.3, 0.5)
- ]
- uut = ABController()
- for i, s in enumerate(songs):
- uut.storeLimits(abLimits[i].a, abLimits[i].b, s)
-
- for i, s in enumerate(songs):
- uut.setCurrentSong(s)
- uut.loadLimits(0)
- assert uut.getLoadedIndex() == 0
-
- checkLimits(uut, abLimits[i].a, abLimits[i].b)
- assert uut.getStoredLimits(s) == [abLimits[i]]
-
-def test_disableAbRepeat():
- song = "/path/to/song"
-
- uut = ABController()
- uut.setCurrentSong(song)
- uut.storeLimits(abLimits.a, abLimits.b)
- uut.loadLimits(0)
- assert uut.getLoadedIndex() == 0
-
- assert uut.isEnabled()
-
- uut.setEnable(False)
- checkLimits(uut, abLimits.a, abLimits.b, fail=True)
- assert not uut.isEnabled()
-
- uut.setEnable(True)
- checkLimits(uut, abLimits.a, abLimits.b)
- assert uut.isEnabled()
-
-def test_storeLimitsToSpecificSong():
- song = "/path/to/song"
-
- uut = ABController()
- uut.storeLimits(abLimits.a, abLimits.b, song)
- uut.setCurrentSong(song)
- uut.loadLimits(0)
- assert uut.getLoadedIndex() == 0
-
- checkLimits(uut, abLimits.a, abLimits.b)
-
-def test_storeLimitsWithoutCurrentSong():
- uut = ABController()
- uut.storeLimits(abLimits.a, abLimits.b)
- uut.loadLimits(0)
- assert uut.getLoadedIndex() == None
-
- checkDefaultLimits(uut)
-
-def test_storeLimitsToSongWithoutCurrentSong():
- song = "/path/to/song"
- uut = ABController()
- uut.storeLimits(abLimits.a, abLimits.b, song)
- uut.loadLimits(0)
- assert uut.getLoadedIndex() == None
-
- checkDefaultLimits(uut)
-
- uut.setCurrentSong(song)
-
- checkDefaultLimits(uut)
-
- uut.loadLimits(0)
- assert uut.getLoadedIndex() == 0
-
- checkLimits(uut, abLimits.a, abLimits.b)
-
-def test_storeLimitsToCurrentSongButDoNotSetCurrentLimits():
- song = "/path/to/song"
- uut = ABController()
- uut.setCurrentSong(song)
- uut.storeLimits(abLimits.a, abLimits.b)
- assert uut.getLoadedIndex() == None
-
- checkDefaultLimits(uut)
-
- uut.loadLimits(0)
- assert uut.getLoadedIndex() == 0
-
- checkLimits(uut, abLimits.a, abLimits.b)
-
-def test_getStoredLimitsOfInexistentSong():
- song = "/path/to/song"
- uut = ABController()
- assert uut.getStoredLimits(song) == None
-
-def test_clearAbController():
- songsWithLimits = [
- ("/path/to/song", AB(0.2, 0.4)),
- ("/path/to/another/song", AB(0.3, 0.5))
- ]
-
- uut = ABController()
- for s in songsWithLimits:
- uut.storeLimits(s[1].a, s[1].b, s[0])
-
- for i, s in enumerate(songsWithLimits):
- assert uut.getStoredLimits(s[0]) == [s[1]]
-
- uut.clear()
-
- for i, s in enumerate(songsWithLimits):
- assert uut.getStoredLimits(s[0]) == None
-
-def test_setTemporaryLimits():
- abLimits = [
- AB(0.2, 0.4),
- AB(0.3, 0.5),
- AB(0.0, 1.2)
- ]
- uut = ABController()
-
- for l in abLimits:
- uut.setLimits(l.a, l.b)
- assert uut.getLoadedIndex() == None
- checkLimits(uut, l.a, l.b)
-
-def test_setTemporaryLimitsWithCurrentSong():
- songLimits = AB(0.2, 0.4)
- abLimits = [
- AB(0.2, 0.4),
- AB(0.3, 0.5),
- AB(0.0, 1.2)
- ]
- song = "/path/to/song"
- uut = ABController()
- uut.setCurrentSong(song)
- uut.storeLimits(songLimits.a, songLimits.b)
- uut.loadLimits(0)
- assert uut.getLoadedIndex() == 0
-
- for l in abLimits:
- uut.setLimits(l.a, l.b)
- checkLimits(uut, l.a, l.b)
-
-def test_defaultBehaviour():
- uut = ABController()
- checkDefaultLimits(uut)
-
-def test_nextStoredLimit():
- song = "/path/to/song"
- abLimits = [
- AB(0.2, 0.4),
- AB(0.3, 0.5)
- ]
-
- uut = ABController()
- uut.setCurrentSong(song)
- for l in abLimits:
- uut.storeLimits(l.a, l.b)
-
- checkDefaultLimits(uut)
-
- uut.nextStoredAbLimits()
- checkLimits(uut, abLimits[0].a, abLimits[0].b)
-
- uut.nextStoredAbLimits()
- checkLimits(uut, abLimits[1].a, abLimits[1].b)
-
- uut.nextStoredAbLimits()
- checkLimits(uut, abLimits[1].a, abLimits[1].b)
-
-def test_previousStoredLimit():
- song = "/path/to/song"
- abLimits = [
- AB(0.2, 0.4),
- AB(0.3, 0.5)
- ]
-
- uut = ABController()
- uut.setCurrentSong(song)
- for l in abLimits:
- uut.storeLimits(l.a, l.b)
-
- checkDefaultLimits(uut)
-
- uut.previousStoredAbLimits()
- checkLimits(uut, abLimits[0].a, abLimits[0].b)
-
- uut.previousStoredAbLimits()
- checkLimits(uut, abLimits[0].a, abLimits[0].b)
-
- uut.loadLimits(1)
- checkLimits(uut, abLimits[1].a, abLimits[1].b)
-
- uut.previousStoredAbLimits()
- checkLimits(uut, abLimits[0].a, abLimits[0].b)
diff --git a/solo-tool-project/test/midi_launchpad_mini_integrationtest.py b/solo-tool-project/test/midi_launchpad_mini_integrationtest.py
index c0d2b47..9e8c92e 100644
--- a/solo-tool-project/test/midi_launchpad_mini_integrationtest.py
+++ b/solo-tool-project/test/midi_launchpad_mini_integrationtest.py
@@ -22,12 +22,10 @@ previousSongButton = 48
playPauseButton = 112
stopButton = 96
-nextLimitButton = 119
-previousLimitButton = 118
-abToggleButton = 98
-jumpToAButton = 114
-setAButton = 116
-setBButton = 117
+nextKeyPositionButton = 119
+previousKeyPositionButton = 118
+setKeyPositionButton = 117
+jumpToKeyPositionButton = 114
class MidiWrapperMock:
def __init__(self):
@@ -120,35 +118,16 @@ def test_startPauseButtonLed(uut, midiWrapperMock, playerMock, soloTool):
playerMock.simulatePlayingStateChanged()
assert midiWrapperMock.getLatestMessage() == (playPauseButton, MidiController.LED_GREEN, 0)
-def test_abToggleButton(uut, midiWrapperMock, soloTool):
- uut.connect()
-
- midiWrapperMock.simulateInput(abToggleButton)
- assert soloTool.isAbLimitEnabled()
- assert midiWrapperMock.getLatestMessage() == (abToggleButton, MidiController.LED_GREEN, 0)
-
- midiWrapperMock.simulateInput(abToggleButton)
- assert not soloTool.isAbLimitEnabled()
- assert midiWrapperMock.getLatestMessage() == (abToggleButton, MidiController.LED_RED, 0)
-
-def test_abToggleButtonLed(uut, midiWrapperMock, soloTool):
- uut.connect()
-
- soloTool.setAbLimitEnable(True)
- assert midiWrapperMock.getLatestMessage() == (abToggleButton, MidiController.LED_GREEN, 0)
-
- soloTool.setAbLimitEnable(False)
- assert midiWrapperMock.getLatestMessage() == (abToggleButton, MidiController.LED_RED, 0)
-
-def test_jumpToAButton(uut, midiWrapperMock, soloTool, playerMock):
- ab = (0.5, 0.6)
+def test_jumpToKeyPositionButton(uut, midiWrapperMock, soloTool, playerMock):
+ soloTool.addSong("test.flac")
+ soloTool.song = 0
uut.connect()
- soloTool.setAbLimits(ab[0], ab[1])
+ soloTool.keyPoint = 0.5
assert playerMock.position == 0.0
- midiWrapperMock.simulateInput(jumpToAButton)
- assert playerMock.position == ab[0]
+ midiWrapperMock.simulateInput(jumpToKeyPositionButton)
+ assert playerMock.position == 0.5
def test_previousAndNextSongButtons(uut, midiWrapperMock, soloTool, playerMock):
songs = [
@@ -166,53 +145,38 @@ def test_previousAndNextSongButtons(uut, midiWrapperMock, soloTool, playerMock):
midiWrapperMock.simulateInput(nextSongButton)
assert playerMock.currentSong == songs[1]
+ midiWrapperMock.simulateInput(nextSongButton)
+ assert playerMock.currentSong == songs[1]
+
midiWrapperMock.simulateInput(previousSongButton)
assert playerMock.currentSong == songs[0]
midiWrapperMock.simulateInput(previousSongButton)
assert playerMock.currentSong == songs[0]
-def test_previousAndNextAbButtons(uut, midiWrapperMock, soloTool, playerMock):
+def test_previousAndNextKeyPositionButtons(uut, midiWrapperMock, soloTool, playerMock):
song = "test.flac"
- abLimits = [
- [0.2, 0.4],
- [0.1, 0.3]
- ]
+ keyPoints = [0.2, 0.1]
soloTool.addSong(song)
soloTool.song = 0
- soloTool.setAbLimitEnable(True)
-
- for ab in abLimits:
- soloTool.storeAbLimits(ab[0], ab[1])
+ soloTool.keyPoints = keyPoints
uut.connect()
- def checkLimit(aLimit, bLimit):
- playerMock.position = bLimit - 0.1
- soloTool.tick()
- assert playerMock.position == bLimit - 0.1
-
- playerMock.position = bLimit + 0.1
- soloTool.tick()
- assert playerMock.position == aLimit
-
- checkLimit(0.0, 0.0)
-
- midiWrapperMock.simulateInput(nextLimitButton)
- checkLimit(abLimits[0][0], abLimits[0][1])
+ assert soloTool.keyPoint == 0.0
- midiWrapperMock.simulateInput(nextLimitButton)
- checkLimit(abLimits[1][0], abLimits[1][1])
+ midiWrapperMock.simulateInput(nextKeyPositionButton)
+ assert soloTool.keyPoint == 0.1
- midiWrapperMock.simulateInput(nextLimitButton)
- checkLimit(abLimits[1][0], abLimits[1][1])
+ midiWrapperMock.simulateInput(nextKeyPositionButton)
+ assert soloTool.keyPoint == 0.2
- midiWrapperMock.simulateInput(previousLimitButton)
- checkLimit(abLimits[0][0], abLimits[0][1])
+ midiWrapperMock.simulateInput(previousKeyPositionButton)
+ assert soloTool.keyPoint == 0.1
- midiWrapperMock.simulateInput(previousLimitButton)
- checkLimit(abLimits[0][0], abLimits[0][1])
+ midiWrapperMock.simulateInput(previousKeyPositionButton)
+ assert soloTool.keyPoint == 0.1
def test_playbackRateButtons(uut, midiWrapperMock, soloTool, playerMock):
playbackRateOptions = {
@@ -270,9 +234,10 @@ def test_playbackRateLeds(uut, midiWrapperMock, soloTool, playerMock):
assert playerMock.rate == 1.0
for t, (rate, leds) in enumerate(playbackRateOptions):
+ print(t)
midiWrapperMock.sentMessages.clear()
- soloTool.setPlaybackRate(rate)
+ soloTool.rate = rate
assert playerMock.rate == rate
for i, colour in enumerate(leds):
@@ -336,7 +301,7 @@ def test_playbackVolumeLeds(uut, midiWrapperMock, soloTool, playerMock):
for t, (volume, leds) in enumerate(playbackVolumeOptions):
midiWrapperMock.sentMessages.clear()
- soloTool.setPlaybackVolume(volume)
+ soloTool.volume = volume
assert playerMock.volume == volume
for i, colour in enumerate(leds):
@@ -356,22 +321,20 @@ def test_connectDisconnect(uut, midiWrapperMock):
[(i, LED_GREEN, 0) for i in range(0, 6)] + # volume row
[(i, LED_YELLOW, 0) for i in range(16, 22)] + # playback rate row
[
- (stopButton, LED_RED, 0),
- (playPauseButton, LED_YELLOW, 0),
- (abToggleButton, LED_RED, 0),
- (jumpToAButton, LED_YELLOW, 0),
- (previousLimitButton, LED_RED, 0),
- (nextLimitButton, LED_GREEN, 0),
- (setAButton, LED_YELLOW, 0),
- (setBButton, LED_YELLOW, 0),
- (previousSongButton, LED_RED, 0),
- (rwd1PcButton, LED_RED, 0),
- (rwd5PcButton, LED_RED, 0),
- (rwd25PcButton, LED_RED, 0),
- (nextSongButton, LED_GREEN, 0),
- (fwd1PcButton, LED_GREEN, 0),
- (fwd5PcButton, LED_GREEN, 0),
- (fwd25PcButton, LED_GREEN, 0),
+ (stopButton, LED_RED, 0),
+ (playPauseButton, LED_YELLOW, 0),
+ (jumpToKeyPositionButton, LED_YELLOW, 0),
+ (previousKeyPositionButton, LED_RED, 0),
+ (nextKeyPositionButton, LED_GREEN, 0),
+ (setKeyPositionButton, LED_YELLOW, 0),
+ (previousSongButton, LED_RED, 0),
+ (rwd1PcButton, LED_RED, 0),
+ (rwd5PcButton, LED_RED, 0),
+ (rwd25PcButton, LED_RED, 0),
+ (nextSongButton, LED_GREEN, 0),
+ (fwd1PcButton, LED_GREEN, 0),
+ (fwd5PcButton, LED_GREEN, 0),
+ (fwd25PcButton, LED_GREEN, 0),
])
teardownMessages = [(int(i / 8) * 16 + (i % 8), LED_OFF, 0) for i in range(0, 64)] # clear all
@@ -406,41 +369,24 @@ def test_playingFeedbackWhenChangingSong(uut, midiWrapperMock, soloTool, playerM
assert playerMock.state == PlayerMock.STOPPED
assert midiWrapperMock.getLatestMessage() == (playPauseButton, LED_YELLOW, 0)
-def test_setAbButtons(uut, midiWrapperMock, soloTool, playerMock):
+def test_setKeyPositionButton(uut, midiWrapperMock, soloTool, playerMock):
song = "test.flac"
soloTool.addSong(song)
soloTool.song = 0
- soloTool.setAbLimitEnable(True)
- abLimits = (0.6, 0.8)
- soloTool.storeAbLimits(abLimits[0], abLimits[1])
uut.connect()
- def checkLimit(aLimit, bLimit):
- playerMock.position = bLimit - 0.1
- soloTool.tick()
- assert playerMock.position == bLimit - 0.1
-
- playerMock.position = bLimit + 0.1
- soloTool.tick()
- assert playerMock.position == aLimit
-
- # Set A limit
playerMock.position = 0.3
- midiWrapperMock.simulateInput(setAButton)
- playerMock.position = 0.5
- midiWrapperMock.simulateInput(jumpToAButton)
+ midiWrapperMock.simulateInput(setKeyPositionButton)
+ assert soloTool.keyPoint == 0.3
- assert playerMock.position == 0.3
-
- # Set B limit
- playerMock.position = 0.4
- midiWrapperMock.simulateInput(setBButton)
- checkLimit(0.3, 0.4)
+ playerMock.position = 0.5
+ midiWrapperMock.simulateInput(setKeyPositionButton)
+ assert soloTool.keyPoint == 0.5
- # Selecting preset overrides manually set limits
- midiWrapperMock.simulateInput(nextLimitButton)
- checkLimit(abLimits[0], abLimits[1])
+ playerMock.position = 0.7
+ midiWrapperMock.simulateInput(jumpToKeyPositionButton)
+ assert playerMock.position == 0.5
def test_seekButtons(uut, midiWrapperMock, soloTool, playerMock):
song = "test.flac"
diff --git a/solo-tool-project/test/notifier_unittest.py b/solo-tool-project/test/notifier_unittest.py
index 8a6e988..115d21a 100644
--- a/solo-tool-project/test/notifier_unittest.py
+++ b/solo-tool-project/test/notifier_unittest.py
@@ -37,8 +37,7 @@ def test_allEvents(uut):
checkEvent(uut, Notifier.PLAYBACK_VOLUME_EVENT)
checkEvent(uut, Notifier.PLAYBACK_RATE_EVENT)
checkEvent(uut, Notifier.CURRENT_SONG_EVENT)
- checkEvent(uut, Notifier.CURRENT_AB_EVENT)
- checkEvent(uut, Notifier.AB_LIMIT_ENABLED_EVENT)
+ checkEvent(uut, Notifier.CURRENT_KEY_POINT_EVENT)
def test_eventWithoutRegisteredCallbacks(uut):
uut.notify(Notifier.PLAYING_STATE_EVENT, 0)
diff --git a/solo-tool-project/test/session_manager_unittest.py b/solo-tool-project/test/session_manager_unittest.py
index d89b82a..8658032 100644
--- a/solo-tool-project/test/session_manager_unittest.py
+++ b/solo-tool-project/test/session_manager_unittest.py
@@ -1,114 +1,58 @@
-from solo_tool.session_manager import loadSession, saveSession
-from json import loads, dumps
-
import pytest
+from json import loads
+import pathlib
+import shutil
-testSession = [
- {
- "path" : "/path/to/another/song",
- "ab_limits" : None
- },
- {
- "path" : "/path/to/song",
- "ab_limits" : [
- [0.1, 0.2],
- [0.3, 0.4]
- ]
- },
- {
- "path" : "/path/to/something",
- "ab_limits" : [
- [0.1, 0.2]
- ]
- }
-]
-
-class ABControllerMock:
- def __init__(self):
- self.limits = dict()
-
- def storeLimits(self, aLimit, bLimit, song="current"):
- if song not in self.limits:
- self.limits[song] = list()
- self.limits[song].append([aLimit, bLimit])
-
- def getStoredLimits(self, song):
- return self.limits.get(song)
-
- def clear(self):
- self.__init__()
-
-class MockFile:
- def __init__(self, init=""):
- self.contents = init
-
- def open(self, *args):
- pass
-
- def write(self, s):
- self.contents += s
-
- def read(self):
- return self.contents
-
-@pytest.fixture
-def playlistMock():
- return []
+from solo_tool.session_manager import loadSession, saveSession
+from solo_tool.solo_tool import SoloTool
@pytest.fixture
-def abControllerMock():
- return ABControllerMock()
+def prepared_tmp_path(tmp_path):
+ testFiles = [
+ "test.flac",
+ "test.mp3",
+ "test_session.json"
+ ]
+ for f in testFiles:
+ shutil.copy(pathlib.Path(f), tmp_path)
+ return tmp_path
-def test_loadSession(playlistMock, abControllerMock):
- sessionFile = MockFile(dumps(testSession))
- loadSession(sessionFile, playlistMock, abControllerMock)
+def test_loadSession(prepared_tmp_path):
+ soloTool = loadSession(prepared_tmp_path / "test_session.json")
- for i, entry in enumerate(testSession):
- expectedSong = entry["path"]
- expectedLimits = entry["ab_limits"]
- loadedSong = playlistMock[i]
- loadedLimits = abControllerMock.limits.get(expectedSong)
+ assert soloTool.songs == ["test.flac", "test.mp3"]
- assert loadedSong == expectedSong
- assert loadedLimits == expectedLimits
+ soloTool.song = 0
+ assert soloTool.keyPoints == []
-def test_saveSession(playlistMock, abControllerMock):
- for i, entry in enumerate(testSession):
- song = entry["path"]
- playlistMock.append(song)
+ soloTool.song = 1
+ assert soloTool.keyPoints == [0.1, 0.3]
- abLimits = entry["ab_limits"]
- if abLimits is not None:
- for l in abLimits:
- abControllerMock.storeLimits(l[0], l[1], song)
+def test_saveSession(prepared_tmp_path):
+ soloTool = SoloTool()
+ soloTool.addSong("test.flac")
+ soloTool.addSong("test.mp3")
+ soloTool.song = 1
+ soloTool.keyPoints = [0.1, 0.3]
- sessionFile = MockFile()
- saveSession(sessionFile, playlistMock, abControllerMock)
+ testFile = prepared_tmp_path / "test_session_saved.json"
+ saveSession(soloTool, testFile)
- savedSession = loads(sessionFile.read())
- assert savedSession == testSession
+ with open(testFile, "r") as f:
+ savedSession = loads(f.read())
-def test_loadAndSaveEmptySession(playlistMock, abControllerMock):
- sessionFile = MockFile()
+ with open(prepared_tmp_path / "test_session.json", "r") as f:
+ testSession = loads(f.read())
- saveSession(sessionFile, playlistMock, abControllerMock)
- assert loads(sessionFile.read()) == list()
+ assert savedSession == testSession
- loadSession(sessionFile, playlistMock, abControllerMock)
+def test_loadAndSaveEmptySession(prepared_tmp_path):
+ emptyFile = prepared_tmp_path / "empty_session.json"
- assert playlistMock == list()
- for s in playlistMock:
- assert abControllerMock.getStoredLimits(s) == None
+ soloTool = SoloTool()
-def test_loadSessionNotAdditive(playlistMock, abControllerMock):
- sessionFile = MockFile(dumps(testSession))
- loadSession(sessionFile, playlistMock, abControllerMock)
- loadSession(sessionFile, playlistMock, abControllerMock)
+ saveSession(soloTool, emptyFile)
+ reloadedTool = loadSession(emptyFile)
- songs = playlistMock
- assert len(songs) == len(set(songs))
- for s in songs:
- abLimits = abControllerMock.getStoredLimits(s)
- if abLimits is not None:
- abLimitStr = [f"[{l[0]}, {l[1]}] " for l in abLimits]
- assert len(abLimitStr) == len(set(abLimitStr))
+ assert reloadedTool.songs == []
+
diff --git a/solo-tool-project/test/solo_tool_controller_integrationtest.py b/solo-tool-project/test/solo_tool_controller_integrationtest.py
deleted file mode 100644
index 9311483..0000000
--- a/solo-tool-project/test/solo_tool_controller_integrationtest.py
+++ /dev/null
@@ -1,86 +0,0 @@
-import pathlib
-import shutil
-import pytest
-
-from solo_tool.solo_tool_controller import SoloToolController
-from solo_tool.solo_tool import SoloTool
-
-@pytest.fixture
-def prepared_tmp_path(tmp_path):
- testFiles = [
- "test.flac",
- "test.mp3",
- "test_session.json"
- ]
- for f in testFiles:
- shutil.copy(pathlib.Path(f), tmp_path)
- return tmp_path
-
-@pytest.fixture
-def soloTool(prepared_tmp_path):
- st = SoloTool()
- st.loadSession(prepared_tmp_path / "test_session.json")
- return st
-
-@pytest.fixture
-def uut(soloTool):
- return SoloToolController(soloTool)
-
-def test_previousSong(uut, soloTool):
- called = False
- receivedValue = None
- def callback(value):
- nonlocal called, receivedValue
- called = True
- receivedValue = value
-
- soloTool.registerCurrentSongCallback(callback)
-
- soloTool.song == None
- assert not called
-
- uut.previousSong()
- soloTool.song == 0
- assert called
- assert receivedValue == 0
- called = False
-
- uut.previousSong()
- soloTool.song == 0
- assert not called
-
- soloTool.song = 1
- uut.previousSong()
- soloTool.song == 0
- assert called
- assert receivedValue == 0
- called = False
-
-def test_nextSong(uut, soloTool):
- called = False
- receivedValue = None
- def callback(value):
- nonlocal called, receivedValue
- called = True
- receivedValue = value
-
- soloTool.registerCurrentSongCallback(callback)
-
- soloTool.song == None
- assert not called
-
- uut.nextSong()
- soloTool.song == 0
- assert called
- assert receivedValue == 0
- called = False
-
- uut.nextSong()
- soloTool.song == 1
- assert called
- assert receivedValue == 1
- called = False
-
- uut.nextSong()
- soloTool.song == 1
- assert not called
diff --git a/solo-tool-project/test/solo_tool_integrationtest.py b/solo-tool-project/test/solo_tool_integrationtest.py
index 3a15e36..2a818ed 100644
--- a/solo-tool-project/test/solo_tool_integrationtest.py
+++ b/solo-tool-project/test/solo_tool_integrationtest.py
@@ -25,15 +25,6 @@ def prepared_tmp_path(tmp_path):
return tmp_path
-def checkLimit(uut, mockPlayer, aLimit, bLimit):
- mockPlayer.position = bLimit - 0.1
- uut.tick()
- assert mockPlayer.position == bLimit - 0.1
-
- mockPlayer.position = bLimit + 0.1
- uut.tick()
- assert mockPlayer.position == aLimit
-
def test_playerControls(uut, mockPlayer):
assert mockPlayer.state == MockPlayer.STOPPED
assert uut.isPlaying() == False
@@ -48,306 +39,208 @@ def test_playerControls(uut, mockPlayer):
assert uut.isPlaying() == False
assert mockPlayer.rate == 1.0
- uut.setPlaybackRate(0.5)
+ uut.rate = 0.5
assert mockPlayer.rate == 0.5
+ assert uut.rate == 0.5
assert mockPlayer.position == 0.0
- uut.setPlaybackPosition(0.5)
+ uut.position = 0.5
assert mockPlayer.position == 0.5
+ assert uut.position == 0.5
assert mockPlayer.volume == 1.0
- uut.setPlaybackVolume(0.5)
+ uut.volume = 0.5
assert mockPlayer.volume == 0.5
+ assert uut.volume == 0.5
-def test_addAndSetSongs(uut, mockPlayer):
- songs = [
- "test.flac",
- "test.mp3"
- ]
+def test_sanitizePlaybackRate(uut):
+ # Initial value
+ assert uut.rate == 1.0
- for s in songs:
- uut.addSong(s)
- assert mockPlayer.currentSong == None
-
- for i, s in enumerate(songs):
- uut.song = i
- assert mockPlayer.currentSong == songs[i]
- assert uut.song == i
-
-def test_addAndSetAbLimits(uut, mockPlayer):
- song = "test.flac"
- abLimits = [
- [0.2, 0.4],
- [0.1, 0.3]
- ]
-
- uut.addSong(song)
- uut.song = 0
+ # Valid rates are >= 0.0, invalid is ignored
+ uut.rate = -0.1
+ assert uut.rate == 1.0
- for ab in abLimits:
- uut.storeAbLimits(ab[0], ab[1])
+ uut.rate = 0.0
+ assert uut.rate == 0.0
+
+ uut.rate = 0.0001
+ assert uut.rate == 0.0001
- mockPlayer.position = 0.0
- uut.tick()
- assert mockPlayer.position == 0.0
+ uut.rate = 150.0
+ assert uut.rate == 150.0
- mockPlayer.position = 0.5
- uut.tick()
- assert mockPlayer.position == 0.5
+def test_sanitizePlaybackPosition(uut):
+ # Initial value
+ assert uut.position == 0.0
- uut.loadAbLimits(0)
+ # Valid positions are in [0, 1], invalid is limited
+ uut.position = 0.2
+ assert uut.position == 0.2
- uut.tick()
- assert mockPlayer.position == 0.5
+ uut.position = -0.1
+ assert uut.position == 0.0
- uut.setAbLimitEnable(True)
+ uut.position = 1.0
+ assert uut.position == 1.0
- uut.tick()
- assert mockPlayer.position == 0.2
+ uut.position = 0.4
+ assert uut.position == 0.4
- uut.tick()
- assert mockPlayer.position == 0.2
+ uut.position = 1.5
+ assert uut.position == 1.0
- uut.loadAbLimits(1)
- uut.tick()
- assert mockPlayer.position == 0.2
+def test_sanitizePlaybackVolume(uut):
+ # Initial value
+ assert uut.volume == 1.0
- mockPlayer.position = 0.8
- uut.tick()
- assert mockPlayer.position == 0.1
+ # Valid volumes are >= 0.0, invalid is ignored
+ uut.volume = -0.1
+ assert uut.volume == 1.0
-def test_abLimitEnabledGetter(uut):
- assert not uut.isAbLimitEnabled()
+ uut.volume = 0.0
+ assert uut.volume == 0.0
- uut.setAbLimitEnable(True)
- assert uut.isAbLimitEnabled()
+ uut.volume = 1.0
+ assert uut.volume == 1.0
- uut.setAbLimitEnable(False)
- assert not uut.isAbLimitEnabled()
+ uut.volume = 150.0
+ assert uut.volume == 150.0
-def test_multipleSongsAndAbLimits(uut, mockPlayer):
+def test_addAndSelectSongs(uut, mockPlayer):
songs = [
- "test.flac",
- "test.mp3"
- ]
- abLimits = [
- [0.2, 0.4],
- [0.5, 0.7]
+ "test.mp3",
+ "test.flac"
]
-
- for s in songs:
- uut.addSong(s)
-
- for i, l in enumerate(abLimits):
- uut.song = i
- uut.storeAbLimits(l[0], l[1])
-
- uut.setAbLimitEnable(True)
-
- for i, l in enumerate(abLimits):
- uut.song = i
- uut.loadAbLimits(0)
-
- mockPlayer.position = l[0]
- uut.tick()
- assert mockPlayer.position == l[0]
- mockPlayer.position = l[1] + 0.1
- uut.tick()
- assert mockPlayer.position == l[0]
+ # Songs are added one by one
+ for song in songs:
+ uut.addSong(song)
-def test_storeAbLimitsWithoutSong(uut, mockPlayer):
- song = "test.flac"
- abLimit = [0.2, 0.4]
- overflow = abLimit[1] + 0.1
- default = 0.0
- mockPlayer.position = overflow
- uut.setAbLimitEnable(True)
-
- uut.storeAbLimits(abLimit[0], abLimit[1])
- uut.tick()
- assert mockPlayer.position == default
- mockPlayer.position = overflow
-
- uut.loadAbLimits(0)
- uut.tick()
- assert mockPlayer.position == default
- mockPlayer.position = overflow
-
- uut.addSong(song)
- uut.tick()
- assert mockPlayer.position == default
- mockPlayer.position = overflow
-
- uut.loadAbLimits(0)
- uut.tick()
- assert mockPlayer.position == default
- mockPlayer.position = overflow
-
- uut.song = 0
- uut.tick()
- assert mockPlayer.position == default
- mockPlayer.position = overflow
-
- uut.loadAbLimits(0)
- uut.tick()
- assert mockPlayer.position == default
- mockPlayer.position = overflow
-
- uut.storeAbLimits(abLimit[0], abLimit[1])
- uut.tick()
- assert mockPlayer.position == default
- mockPlayer.position = overflow
-
- uut.loadAbLimits(0)
- uut.tick()
- assert mockPlayer.position == abLimit[0]
-
-def test_nextAndPreviousAbLimit(uut, mockPlayer):
- song = "test.flac"
- abLimits = [
- [0.2, 0.4],
- [0.1, 0.3]
- ]
-
- uut.addSong(song)
- uut.song = 0
- uut.setAbLimitEnable(True)
+ # Songs are not selected automatically
+ assert mockPlayer.currentSong == None
+ assert uut.song == None
- for ab in abLimits:
- uut.storeAbLimits(ab[0], ab[1])
+ # Song order is preserved
+ assert uut.songs == songs
- checkLimit(uut, mockPlayer, 0.0, 0.0) # default limits
+ # Modifying the song list directly has no effect
+ uut.songs.append("something")
+ assert uut.songs == songs
- uut.nextStoredAbLimits()
- checkLimit(uut, mockPlayer, abLimits[0][0], abLimits[0][1])
+ # Songs are selected by index
+ for i, s in enumerate(uut.songs):
+ uut.song = i
+ assert mockPlayer.currentSong == uut.songs[i]
+ assert uut.song == i
- uut.nextStoredAbLimits()
- checkLimit(uut, mockPlayer, abLimits[1][0], abLimits[1][1])
+ # The current song cannot be de-selected
+ uut.song = None
+ assert uut.song == len(uut.songs) - 1
- uut.nextStoredAbLimits()
- checkLimit(uut, mockPlayer, abLimits[1][0], abLimits[1][1])
+ # Non-existent songs cannot be selected
+ uut.song = -1
+ assert uut.song == len(uut.songs) - 1
- uut.previousStoredAbLimits()
- checkLimit(uut, mockPlayer, abLimits[0][0], abLimits[0][1])
+ uut.song = 2
+ assert uut.song == len(uut.songs) - 1
- uut.previousStoredAbLimits()
- checkLimit(uut, mockPlayer, abLimits[0][0], abLimits[0][1])
+def test_addAndJumpToKeyPoints(uut, mockPlayer):
+ uut.addSong("test.flac")
+ uut.addSong("test.mp3")
-def test_abLimitsWhenChangingSongs(uut, mockPlayer):
- songs = [
- "test.flac",
- "test.mp3"
- ]
- abLimits = [
- [0.2, 0.4],
- [0.1, 0.3],
- [0.7, 0.8]
- ]
- uut.setAbLimitEnable(True)
+ def checkJump(before, expectedAfter):
+ mockPlayer.position = before
+ uut.jump()
+ assert mockPlayer.position == expectedAfter
- for s in songs:
- uut.addSong(s)
+ # Key points are None as long as no song is selected
+ uut.keyPoints = [0.1, 0.2]
+ uut.keyPoint = 0.5
+ assert uut.keyPoints is None
+ assert uut.keyPoint is None
uut.song = 0
- for ab in abLimits:
- uut.storeAbLimits(ab[0], ab[1])
- uut.song = 1
- uut.storeAbLimits(abLimits[0][0], abLimits[0][1])
+ # Once a song is selected, jump to start by default
+ assert uut.keyPoint == 0.0
+ checkJump(0.5, 0.0)
- uut.song = 0
- uut.loadAbLimits(len(abLimits) - 1)
- checkLimit(uut, mockPlayer, abLimits[-1][0], abLimits[-1][1])
+ # By default songs have an empty list of key points
+ assert uut.keyPoints == []
- uut.song = 1
- checkLimit(uut, mockPlayer, abLimits[-1][0], abLimits[-1][1])
-
- uut.previousStoredAbLimits()
- checkLimit(uut, mockPlayer, abLimits[0][0], abLimits[0][1])
-
-def test_loadAndSaveSession(prepared_tmp_path):
- mockPlayer = MockPlayer()
- uut = SoloTool(mockPlayer)
+ uut.keyPoints = [0.2, 0.4, 0.1, 0.2]
- loadedSessionFile = prepared_tmp_path / "test_session.json"
- savedSessionFile = prepared_tmp_path / "test_session_save.json"
+ # Added key points are not automatically selected
+ assert uut.keyPoint == 0.0
+ checkJump(0.1, 0.0)
- uut.loadSession(loadedSessionFile)
- uut.saveSession(savedSessionFile)
+ # Any key point can be selected
+ uut.keyPoint = uut.keyPoints[0]
+ checkJump(0.0, uut.keyPoints[0])
- import json
- with open(loadedSessionFile, "r") as f:
- loadedSession = json.loads(f.read())
-
- with open(savedSessionFile, "r") as f:
- savedSession = json.loads(f.read())
-
- assert loadedSession == savedSession
-
-def test_addInexistentFile(uut, mockPlayer):
- song = "not/a/real/file"
+ uut.keyPoint = 0.5
+ checkJump(0.0, 0.5)
+def test_sanitizeKeyPoint(uut):
+ song = "test.flac"
uut.addSong(song)
uut.song = 0
+ uut.keyPoints = [0.2, 0.4, 0.1, 0.2, None, -0.5, 1.0, 1.5]
- assert mockPlayer.currentSong == None
+ # Added key points are automatically de-duplicated, sanitized and sorted to ascending order
+ assert uut.keyPoints == [0.1, 0.2, 0.4]
-def test_getters(uut, mockPlayer):
- song = "test.flac"
- abLimit = [0.2, 0.4]
+ # Key point and key point list cannot be none
+ uut.keyPoint = 0.5
- uut.addSong(song)
- uut.song = 0
- uut.storeAbLimits(abLimit[0], abLimit[1])
+ uut.keyPoint = None
+ assert uut.keyPoint == 0.5
- assert uut.songList == [song]
+ uut.keyPoints = None
+ assert uut.keyPoints == [0.1, 0.2, 0.4]
- limits = uut.getStoredAbLimits()
- assert len(limits) == 1
- assert limits[0][0] == abLimit[0]
- assert limits[0][1] == abLimit[1]
+ # Valid key points are in [0, 1)
+ uut.keyPoint = -0.1
+ assert uut.keyPoint == 0.5
- mockPlayer.position = 0.8
- assert uut.getPlaybackPosition() == 0.8
+ uut.keyPoint = 1.0
+ assert uut.keyPoint == 0.5
- mockPlayer.volume = 0.8
- assert uut.getPlaybackVolume() == 0.8
+ uut.keyPoint = 0.999
+ assert uut.keyPoint == 0.999
- mockPlayer.rate = 0.5
- assert uut.getPlaybackRate() == 0.5
-
-def test_setTemporaryLimits(uut, mockPlayer):
- song = "test.flac"
- abLimits = [
- [0.2, 0.4],
- [0.1, 0.4]
+def test_keyPointsPerSong(uut, mockPlayer):
+ songs = [
+ ("test.flac", [0.0, 0.5]),
+ ("test.mp3", [0.1])
]
- overflow = 0.5
-
- uut.setAbLimitEnable(True)
- mockPlayer.position = overflow
- uut.addSong(song)
- uut.song = 0
- uut.storeAbLimits(abLimits[0][0], abLimits[0][1])
- uut.loadAbLimits(0)
+
+ # Key points list is set for the selected song
+ for i, (song, keyPoints) in enumerate(songs):
+ uut.addSong(song)
+ uut.song = i
+ uut.keyPoints = keyPoints
- uut.setAbLimits(abLimits[1][0], abLimits[1][1])
- uut.tick()
- assert mockPlayer.position == abLimits[1][0]
+ # Key points list is automatically loaded when the song selection changes
+ # Active key point is always reset to 0 when song selection changes
+ for i, (song, keyPoints) in enumerate(songs):
+ uut.keyPoint = 0.5
+ uut.song = i
+ assert uut.keyPoints == keyPoints
+ assert uut.keyPoint == 0.0
-def test_jumpToA(uut, mockPlayer):
- abLimits = (0.2, 0.4)
- initialPosition = 0.8
+ # Key points are copied, not stored by reference
+ for i, (song, keyPoints) in enumerate(songs):
+ uut.song = i
+ keyPoints.append(1.0)
+ assert 1.0 not in uut.keyPoints
- mockPlayer.position = initialPosition
-
- uut.jumpToA()
- assert mockPlayer.position == 0.0 # default AB controller A limit
+def test_addInexistentSong(uut, mockPlayer):
+ song = "not/a/real/file"
- uut.setAbLimits(abLimits[0], abLimits[1])
- uut.jumpToA()
- assert mockPlayer.position == abLimits[0]
+ with pytest.raises(FileNotFoundError):
+ uut.addSong(song)
def test_playingStateNotification(uut, mockPlayer):
song = "test.flac"
@@ -404,16 +297,16 @@ def test_playbackVolumeNotification(uut, mockPlayer):
called = True
receivedValue = value
- uut.registerPlaybackVolumeCallback(callback)
+ uut.registerVolumeCallback(callback)
assert not called
- uut.setPlaybackVolume(0.3)
+ uut.volume = 0.3
assert called
assert receivedValue == 0.3
called = False
- uut.setPlaybackVolume(0.3)
+ uut.volume = 0.3
assert not called
def test_playbackRateNotification(uut, mockPlayer):
@@ -428,16 +321,16 @@ def test_playbackRateNotification(uut, mockPlayer):
called = True
receivedValue = value
- uut.registerPlaybackRateCallback(callback)
+ uut.registerRateCallback(callback)
assert not called
- uut.setPlaybackRate(0.5)
+ uut.rate = 0.5
assert called
assert receivedValue == 0.5
called = False
- uut.setPlaybackRate(0.5)
+ uut.rate = 0.5
assert not called
def test_currentSongNotification(uut):
@@ -455,9 +348,12 @@ def test_currentSongNotification(uut):
"test.flac",
"test.mp3"
]
+
+ # Adding a song does not trigger a notification
uut.addSong(songs[0])
assert not called
+ # Selecting a song for the first time triggers
uut.song = 0
assert called
assert receivedValue == 0
@@ -466,6 +362,7 @@ def test_currentSongNotification(uut):
uut.addSong(songs[1])
assert not called
+ # Selecting the same song does not trigger
uut.song = 0
assert not called
@@ -474,7 +371,7 @@ def test_currentSongNotification(uut):
assert receivedValue == 1
called = False
-def test_currentAbNotification(uut):
+def test_currentKeyPointNotification(uut):
called = False
receivedValue = None
def callback(value):
@@ -482,76 +379,29 @@ def test_currentAbNotification(uut):
called = True
receivedValue = value
- uut.registerCurrentAbLimitsCallback(callback)
+ uut.registerCurrentKeyPointCallback(callback)
assert not called
song = "test.flac"
uut.addSong(song)
uut.song = 0
- abLimits = [
- (0.2, 0.3),
- (0.4, 0.5)
- ]
- uut.storeAbLimits(abLimits[0][0], abLimits[0][1])
- assert not called
- uut.storeAbLimits(abLimits[1][0], abLimits[1][1])
- assert not called
-
- uut.loadAbLimits(0)
- assert called
- assert receivedValue == 0
- called = False
-
- uut.loadAbLimits(0)
- assert not called
-
- uut.loadAbLimits(1)
+ # Selecting a song for the first time sets the key point to 0.0
assert called
- assert receivedValue == 1
+ assert receivedValue == 0.0
called = False
- uut.previousStoredAbLimits()
+ # Changing the key point triggers a notification
+ uut.keyPoint = 0.5
assert called
- assert receivedValue == 0
+ assert receivedValue == 0.5
called = False
- uut.previousStoredAbLimits()
+ # Adding list of key points does not trigger a notification
+ uut.keyPoints = [0.2, 0.4]
assert not called
-
- uut.nextStoredAbLimits()
- assert called
- assert receivedValue == 1
- called = False
- uut.nextStoredAbLimits()
+ # Assigning the same key point again does not trigger a notification
+ uut.keyPoint = 0.5
assert not called
-def test_abLimitEnabledNotification(uut):
- called = False
- receivedValue = None
- def callback(value):
- nonlocal called, receivedValue
- called = True
- receivedValue = value
-
- uut.registerAbLimitEnabledCallback(callback)
- assert not called
-
- uut.setAbLimitEnable(False)
- assert not called
- assert receivedValue is None
-
- uut.setAbLimitEnable(True)
- assert called
- assert receivedValue == True
- called = False
- receivedValue = None
-
- uut.setAbLimitEnable(True)
- assert not called
- assert receivedValue is None
-
- uut.setAbLimitEnable(False)
- assert called
- assert receivedValue == False
diff --git a/solo-tool-project/test/test_session.json b/solo-tool-project/test/test_session.json
index f48b792..49c2d42 100644
--- a/solo-tool-project/test/test_session.json
+++ b/solo-tool-project/test/test_session.json
@@ -1,13 +1,10 @@
[
{
"path" : "test.flac",
- "ab_limits" : null
+ "key_points" : []
},
{
"path" : "test.mp3",
- "ab_limits" : [
- [0.1, 0.2],
- [0.3, 0.4]
- ]
+ "key_points" : [0.1, 0.3]
}
]
generated by cgit v1.2.3 (git 2.25.1) at 2025-02-23 13:49:32 +0000