circuitpython-keymanager 1.1.1__tar.gz → 1.2.0__tar.gz

{circuitpython_keymanager-1.1.1 → circuitpython_keymanager-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: circuitpython-keymanager
-Version: 1.1.1
+Version: 1.2.0
 Summary: Tools to manage notes in musical applications. Includes note priority, arpeggiation, and sequencing.
 Author-email: Cooper Dalrymple <me@dcdalrymple.com>
 License: MIT

{circuitpython_keymanager-1.1.1 → circuitpython_keymanager-1.2.0}/circuitpython_keymanager.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: circuitpython-keymanager
-Version: 1.1.1
+Version: 1.2.0
 Summary: Tools to manage notes in musical applications. Includes note priority, arpeggiation, and sequencing.
 Author-email: Cooper Dalrymple <me@dcdalrymple.com>
 License: MIT

{circuitpython_keymanager-1.1.1 → circuitpython_keymanager-1.2.0}/pyproject.toml

@@ -13,7 +13,7 @@ requires = [
 [project]
 name = "circuitpython-keymanager"
 description = "Tools to manage notes in musical applications. Includes note priority, arpeggiation, and sequencing."
-version = "1.1.1"
+version = "1.2.0"
 readme = "README.rst"
 authors = [
     {name = "Cooper Dalrymple", email = "me@dcdalrymple.com"}

{circuitpython_keymanager-1.1.1 → circuitpython_keymanager-1.2.0}/relic_keymanager.py

@@ -24,7 +24,7 @@ Implementation Notes
 
 # imports
 
-__version__ = "1.1.1"
+__version__ = "1.2.0"
 __repo__ = "https://github.com/relic-se/CircuitPython_KeyManager.git"
 
 import asyncio
@@ -331,10 +331,26 @@ class Timer:
 
     _last_press: list[int] = []
 
-    async def update(self):
+    def update(self) -> None:
         """Update the timer object and call any relevant callbacks if a new beat step or the end of
-        the gate of a step is reached. The actual functionality of this method will depend on the
-        child class that utilizes the :class:`Timer` parent class.
+        the gate of a step is reached. For best performance, call this method frequently! The
+        actual functionality of this method will depend on the child class that utilizes the
+        :class:`Timer` parent class.
+        """
+        if not self._active:
+            return
+        current = time.monotonic()
+        if self._last_press and current - self._now >= self._gate_duration:
+            self._do_release()
+        if current - self._now >= self._step_time:
+            self._update()
+            self._do_step()
+            self._now += self._step_time
+
+    async def update_async(self):
+        """Update the timer object using asyncio and call any relevant callbacks if a new beat step
+        or the end of the gate of a step is reached. The actual functionality of this method will
+        depend on the child class that utilizes the :class:`Timer` parent class.
         """
         while True:
             if not self._active:
@@ -534,6 +550,16 @@ class Arpeggiator(Timer):
             self._do_press(self._notes[self._pos].notenum, self._notes[self._pos].velocity)
 
 
+class LoopType:
+    """An enum-like class representing sequencer looping methods."""
+
+    LOOP: int = const(0)
+    """When the end of a loop is reached, return back to the start."""
+
+    SINGLE: int = const(1)
+    """When the end of a loop is reached, stop sequence."""
+
+
 class Sequencer(Timer):
     """Sequence notes using the :class:`Timer` class to create a multi-track note sequencer. By
     default, the Sequencer is set up for a single 4/4 measure of 16 notes with one track. Each note
@@ -551,6 +577,9 @@ class Sequencer(Timer):
         self.tracks = tracks
         self._data = [[None for j in range(self._length)] for i in range(self._tracks)]
 
+    def _get_end(self) -> int:
+        return min(self._loop_end, self._length) if self._loop_end is not None else self._length
+
     _data: list = None
 
     _length: int = 16
@@ -558,9 +587,10 @@ class Sequencer(Timer):
     @property
     def length(self) -> int:
         """The number of steps for each track. If the length is shortened, all of the step data
-        beyond the new length will be deleted, and if the sequencer is also currently running, it
-        should loop back around automatically to the start of the track data. The minimum allowed
-        is 1.
+        beyond the new length will be deleted and the :attr:`loop_start` and :attr:`loop_end`
+        properties may be altered. If the sequencer is currently running, it should loop back around
+        automatically to the start of the track data if :attr:`position` is beyond the new value.
+        The minimum length allowed is 1.
         """
         return self._length
 
@@ -575,6 +605,9 @@ class Sequencer(Timer):
                 for i in range(self._tracks):
                     del self._data[i][value:]
         self._length = value
+        if self._loop_end is not None:
+            self._loop_end = min(self._loop_end, self._length)
+        self._loop_start = min(self._loop_start, self._get_end() - 1)
 
     _tracks: int = 1
 
@@ -598,6 +631,47 @@ class Sequencer(Timer):
                 del self._data[value:]
         self._tracks = value
 
+    _loop_start: int = 0
+
+    @property
+    def loop_start(self) -> int:
+        """The index of the sequence of which to begin at when looping back. This occurs when
+        :attr:`position` reaches :attr:`loop_end`. Should be a value between 0 and :attr:`loop_end`
+        - 1.
+        """
+        return self._loop_start
+
+    @loop_start.setter
+    def loop_start(self, value: int) -> int:
+        self._loop_start = min(max(value, 0), self._get_end() - 1)
+
+    _loop_end: int | None = None
+
+    @property
+    def loop_end(self) -> int | None:
+        """The index of the sequence of which to loop back from when :attr:`position` reaches it.
+        Should be a value between :attr:`loop_start` + 1 and :attr:`length`. If set as `None`, this
+        value will be ignored and :attr:`length` will be used instead.
+        """
+        return self._loop_end
+
+    @loop_end.setter
+    def loop_end(self, value: int | None) -> None:
+        self._loop_end = (
+            min(max(value, self._loop_start + 1), self._length) if value is not None else value
+        )
+
+    _loop_type: int = LoopType.LOOP
+
+    @property
+    def loop_type(self) -> int:
+        """The method of looping through the sequence. See :class:`LoopType` for options."""
+        return self._mode
+
+    @loop_type.setter
+    def loop_type(self, value: int) -> None:
+        self._loop_type = value % 2
+
     _pos: int = 0
 
     @property
@@ -605,6 +679,12 @@ class Sequencer(Timer):
         """The current position of the sequencer within the track length (0-based)."""
         return self._pos
 
+    @position.setter
+    def position(self, value: int) -> None:
+        self._pos = value % self._length
+        if self._last_press:
+            self._do_release()
+
     def set_note(self, position: int, notenum: int, velocity: float = 1.0, track: int = 0) -> None:
         """Set the note value and velocity of a track at a specific step index.
 
@@ -663,7 +743,13 @@ class Sequencer(Timer):
     """
 
     def _update(self):
-        self._pos = (self._pos + 1) % self._length
+        self._pos += 1
+        end = self._get_end()
+        if self._pos >= end:
+            self._pos = min(max(self._loop_start, 0), end - 1)
+            if self._loop_type == LoopType.SINGLE:
+                self.active = False
+                return
         for i in range(self._tracks):
             note = self._data[i][self._pos]
             if note and note[0] > 0 and note[1] > 0:
@@ -843,8 +929,25 @@ class Keyboard:
             self._sustained = [note for note in self._sustained if note != notenum]
         self._update()
 
-    async def update(self, delay: float = 0.01) -> None:
-        """Update :attr:`keys` objects if they were provided during initialization.
+    def update(self) -> None:
+        """Update :attr:`keys` objects if they were provided during initialization. For best
+        performance, call frequently!
+
+        :param delay: The amount of time to sleep between polling in seconds.
+        """
+        if event := self._keys.events.get():
+            notenum = self.root + event.key_number
+            if event.pressed:
+                self.append(notenum, keynum=event.key_number)
+                if callable(self.on_key_press):
+                    self.on_key_press(event.key_number, notenum, 1.0)
+            elif event.released:
+                self.remove(notenum)
+                if callable(self.on_key_release):
+                    self.on_key_release(event.key_number, notenum)
+
+    async def update_async(self, delay: float = 0.01) -> None:
+        """Update :attr:`keys` objects if they were provided during initialization using asyncio.
 
         :param delay: The amount of time to sleep between polling in seconds.
         """