LinkPython-extern 1.3.0a2__cp312-cp312-win_arm64.whl

link/__init__.py

@@ -0,0 +1,12 @@
+"""""" # start delvewheel patch
+def _delvewheel_patch_1_13_0():
+    import os
+    if os.path.isdir(libs_dir := os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, '.'))):
+        os.add_dll_directory(libs_dir)
+
+
+_delvewheel_patch_1_13_0()
+del _delvewheel_patch_1_13_0
+# end delvewheel patch
+
+from _link import *

link/__init__.pyi

@@ -0,0 +1,257 @@
+# Docstrings derived from:
+# https://github.com/Ableton/link/blob/Link-3.0.6/include/ableton/Link.hpp
+
+from typing import Any, Callable
+
+class Clock:
+    def micros(self) -> int:
+        """Return the current system time in microseconds."""
+
+class SessionState:
+    def tempo(self) -> float:
+        """Return the tempo of the timeline, in Beats Per Minute.
+
+        This is a stable value that is appropriate for display
+        to the user. Beat time progress will not necessarily match this tempo
+        exactly because of clock drift compensation.
+
+        """
+
+    def setTempo(self, __tempo: float, __time: int) -> None:
+        """Set the timeline tempo to the given bpm value, taking
+        effect at the given time.
+        """
+
+    def beatAtTime(self, __time: int, __quantum: float) -> float:
+        """Get the beat value corresponding to the given time
+        for the given quantum.
+
+        The magnitude of the resulting beat value is
+        unique to this Link instance, but its phase with respect to
+        the provided quantum is shared among all session
+        peers. For non-negative beat values, the following
+        property holds: fmod(beatAtTime(t, q), q) == phaseAtTime(t, q)
+
+        """
+
+    def phaseAtTime(self, __time: int, __quantum: float) -> float:
+        """Get the session phase at the given time for the given
+        quantum.
+
+        The result is in the interval [0, quantum). The
+        result is equivalent to fmod(beatAtTime(t, q), q) for
+        non-negative beat values. This method is convenient if the
+        client is only interested in the phase and not the beat
+        magnitude. Also, unlike fmod, it handles negative beat values
+        correctly.
+
+        """
+
+    def timeAtBeat(self, __beat: float, __quantum: float) -> float:
+        """Get the time at which the given beat occurs for the
+        given quantum.
+
+        The inverse of beatAtTime, assuming a constant
+        tempo. beatAtTime(timeAtBeat(b, q), q) === b.
+
+        """
+
+    def requestBeatAtTime(self, __beat: float, __time: int, __quantum: float) -> None:
+        """Attempt to map the given beat to the given time in the
+        context of the given quantum.
+
+        This method behaves differently depending on the
+        state of the session. If no other peers are connected,
+        then this instance is in a session by itself and is free to
+        re-map the beat/time relationship whenever it pleases. In this
+        case, beatAtTime(time, quantum) == beat after this method has
+        been called.
+
+        If there are other peers in the session, this instance
+        should not abruptly re-map the beat/time relationship in the
+        session because that would lead to beat discontinuities among
+        the other peers. In this case, the given beat will be mapped
+        to the next time value greater than the given time with the
+        same phase as the given beat.
+
+        This method is specifically designed to enable the concept of
+        "quantized launch" in client applications. If there are no other
+        peers in the session, then an event (such as starting
+        transport) happens immediately when it is requested. If there
+        are other peers, however, we wait until the next time at which
+        the session phase matches the phase of the event, thereby
+        executing the event in-phase with the other peers in the
+        session. The client only needs to invoke this method to
+        achieve this behavior and should not need to explicitly check
+        the number of peers.
+
+        """
+
+    def isPlaying(self) -> bool:
+        """Return True if the transport is playing, False otherwise."""
+
+    def setIsPlaying(self, __isPlaying: bool, __time: int) -> None:
+        """Set if transport should be playing or stopped, taking effect
+        at the given time.
+        """
+
+    def forceBeatAtTime(self, __beat: float, __time: int, __quantum: float) -> None:
+        """Rudely re-map the beat/time relationship for all peers
+        in a session.
+
+        DANGER: This method should only be needed in
+        certain special circumstances. Most applications should not
+        use it. It is very similar to requestBeatAtTime except that it
+        does not fall back to the quantizing behavior when it is in a
+        session with other peers. Calling this method will
+        unconditionally map the given beat to the given time and
+        broadcast the result to the session. This is very anti-social
+        behavior and should be avoided.
+
+        One of the few legitimate uses of this method is to
+        synchronize a Link session with an external clock source. By
+        periodically forcing the beat/time mapping according to an
+        external clock source, a peer can effectively bridge that
+        clock into a Link session. Much care must be taken at the
+        application layer when implementing such a feature so that
+        users do not accidentally disrupt Link sessions that they may
+        join.
+
+        """
+
+    def timeForIsPlaying(self) -> int:
+        """Get the time in microseconds at which a transport start/stop occurs."""
+
+    def requestBeatAtStartPlayingTime(self, __beat: float, __quantum: float) -> None:
+        """Convenience function to attempt to map the given beat to the time
+        when transport is starting to play in context of the given quantum.
+
+        This function evaluates to a no-op if isPlaying() equals false.
+
+        """
+
+    def setIsPlayingAndRequestBeatAtTime(
+        self,
+        __isPlaying: bool,
+        __time: int,
+        __beat: float,
+        __quantum: float,
+    ) -> None:
+        """Convenience function to start or stop transport at a given time and
+        attempt to map the given beat to this time in context of the given quantum.
+        """
+
+class Link:
+    """Represents a participant in a Link session.
+
+    Each Link instance has its own session state which
+    represents a beat timeline and a transport start/stop state. The
+    timeline starts running from beat 0 at the initial tempo when
+    constructed. The timeline always advances at a speed defined by
+    its current tempo, even if transport is stopped. Synchronizing to the
+    transport start/stop state of Link is optional for every peer.
+    The transport start/stop state is only shared with other peers when
+    start/stop synchronization is enabled.
+
+    A Link instance is initially disabled after construction, which
+    means that it will not communicate on the network. Once enabled,
+    a Link instance initiates network communication in an effort to
+    discover other peers. When peers are discovered, they immediately
+    become part of a shared Link session.
+
+    """
+
+    enabled: bool
+    """Indicates if Link is currently enabled.
+
+    To start Link, set this attribute to True.
+
+    """
+
+    startStopSyncEnabled: bool
+    """Indicates if start/stop synchronization is enabled.
+
+    To enable start/stop synchronization, set this attribute to True.
+
+    """
+
+    def __init__(self, __bpm: float) -> None:
+        """
+        :param bpm: The initial tempo of the session.
+        """
+
+    def numPeers(self) -> int:
+        """Return the number of peers currently connected in the Link session."""
+
+    def clock(self) -> Clock:
+        """Return the clock used by Link.
+
+        The Clock type is a platform-dependent representation
+        of the system clock. It exposes a micros() method, which is a
+        normalized representation of the current system time in
+        microseconds.
+
+        """
+
+    def captureAppSessionState(self) -> SessionState:
+        """Capture the current Link Session State from an application thread.
+
+        Provides a mechanism for capturing the Link Session
+        State from an application thread (other than the audio thread).
+        The returned Session State stores a snapshot of the current Link
+        state, so it should be captured and used in a local scope.
+        Storing the it for later use in a different context is not
+        advised because it will provide an outdated view.
+
+        """
+
+    def commitAppSessionState(self, __state: SessionState) -> None:
+        """Commit the given Session State to the Link session from an
+        application thread.
+
+        The given Session State will replace the current Link
+        Session State. Modifications of the Session State will be
+        communicated to other peers in the session.
+
+        :param state: The session state to be committed.
+
+        """
+
+    captureSessionState = captureAppSessionState
+    commitSessionState = commitAppSessionState
+
+    def setNumPeersCallback(self, __callback: Callable[[int], Any]) -> None:
+        """Register a callback to be notified when the number of
+        peers in the Link session changes.
+
+        The callback is invoked on a Link-managed thread.
+
+        :param callback:
+            The callback to be invoked. It should take one argument,
+            the new number of peers.
+
+        """
+
+    def setTempoCallback(self, __callback: Callable[[float], Any]) -> None:
+        """Register a callback to be notified when the session
+        tempo changes.
+
+        The callback is invoked on a Link-managed thread.
+
+        :param callback:
+            The callback to be invoked. It should take one argument,
+            the new tempo.
+
+        """
+
+    def setStartStopCallback(self, __callback: Callable[[bool], Any]) -> None:
+        """Register a callback to be notified when the state of
+        start/stop isPlaying changes.
+
+        The callback is invoked on a Link-managed thread.
+
+        :param callback:
+            The callback to be invoked. It should take one argument,
+            the new start/stop state.
+
+        """

linkpython_extern-1.3.0a2.dist-info/DELVEWHEEL

@@ -0,0 +1,2 @@
+Version: 1.13.0
+Arguments: ['C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-jwfxrg94\\cp312-win_arm64\\build\\venv\\Scripts\\delvewheel', 'repair', '-w', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-jwfxrg94\\cp312-win_arm64\\repaired_wheel', '-v', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-jwfxrg94\\cp312-win_arm64\\built_wheel\\linkpython_extern-1.3.0a2-cp312-cp312-win_arm64.whl']

linkpython_extern-1.3.0a2.dist-info/METADATA

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: LinkPython-extern
+Version: 1.3.0a2
+Summary: A Python wrapper for Ableton Link, wheels included!
+Keywords: ableton,ableton link,link,music,sync
+Author: gonzaloflirt
+Maintainer: thegamecracks
+License-Expression: Unlicense
+License-File: LICENSE.md
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python
+Classifier: Topic :: System :: Networking
+Project-URL: Homepage, https://github.com/thegamecracks/link-python
+Requires-Python: <3.15,>=3.9
+Description-Content-Type: text/markdown
+
+# LinkPython-extern
+
+[![PyPI](https://img.shields.io/pypi/v/LinkPython-extern?label=View%20on%20pypi&style=flat-square)](https://pypi.org/project/LinkPython-extern/)
+[![Build](https://github.com/thegamecracks/link-python/actions/workflows/build_wheels.yml/badge.svg)](https://github.com/thegamecracks/link-python/actions/workflows/build_wheels.yml)
+[![Tests](https://github.com/thegamecracks/link-python/actions/workflows/pytest.yml/badge.svg)](https://github.com/thegamecracks/link-python/actions/workflows/pytest.yml)
+
+A Python wrapper for [Ableton Link], forked from gonzaloflirt's [link-python]
+to streamline the user experience with new methods, type stubs, and pre-built
+wheels.
+
+```py
+from link import Link
+
+link = Link(120)
+clock = link.clock()
+micros = clock.micros()
+
+state = link.captureAppSessionState()
+beat = state.beatAtTime(micros, 4)
+phase = state.phaseAtTime(micros, 4)
+```
+
+You can see the full API documentation in [`__init__.pyi`], or look at
+the [LinkHut.py] example which is equivalent to Ableton Link's
+[linkhut] example.
+
+For asyncio usage, consider trying out the [aalink] project!
+
+## Installation
+
+This project can be installed from PyPI under the [LinkPython-extern] name:
+
+```sh
+pip install LinkPython-extern
+```
+
+Note that we are *not* the same as [LinkPython], which is a different fork
+of link-python by munshkr.
+
+## Python compatibility
+
+|                | v1.0.0 | v1.0.1 | v1.0.4 | v1.1.0 | v1.2.0 | v1.3.0a1 | main |
+|----------------|:------:|:------:|:------:|:------:|:------:|:--------:|:----:|
+| CPython 3.6    |  ✅   |  ✅    |  ✅   |  ❌    |  ❌   |    ❌    |  ❌  |
+| CPython 3.7    |  ✅   |  ✅    |  ✅   |  ✅    |  ❌   |    ❌    |  ❌  |
+| CPython 3.8    |  ✅   |  ✅    |  ✅   |  ✅    |  ✅   |    ❌    |  ❌  |
+| CPython 3.9    |  ✅   |  ✅    |  ✅   |  ✅    |  ✅   |    ✅    |  ✅  |
+| CPython 3.10   |  ✅   |  ✅    |  ✅   |  ✅    |  ✅   |    ✅    |  ✅  |
+| CPython 3.11   |  ❌   |  ✅    |  ✅   |  ✅    |  ✅   |    ✅    |  ✅  |
+| CPython 3.12   |  ❌   |  ❌    |  ✅   |  ✅    |  ✅   |    ✅    |  ✅  |
+| CPython 3.13\* |  ❌   |  ❌    |  ❌   |  ✅    |  ✅   |    ✅    |  ✅  |
+| CPython 3.14   |  ❌   |  ❌    |  ❌   |  ❌    |  ✅   |    ✅    |  ✅  |
+| CPython 3.15   |  ❌   |  ❌    |  ❌   |  ❌    |  ❌   |    ❌    |  ❌  |
+| CPython 3.16+  |  ❌   |  ❌    |  ❌   |  ❌    |  ❌   |    ❌    |  ❌  |
+
+\* CPython 3.13's experimental free-threading builds are not supported.
+
+## Building from source
+
+If you want to build this package from source, you will need CMake installed.
+You however do not need to manually build the project, as scikit-build-core will
+handle invoking cmake when you install it with pip. To install directly
+from the main branch:
+
+```sh
+pip install git+https://github.com/thegamecracks/link-python
+```
+
+If building from the repository directly, make sure to clone all submodules using:
+
+```sh
+git clone --recurse-submodules https://github.com/thegamecracks/link-python
+# or, if already cloned:
+git submodule update --init --recursive
+```
+
+## License
+
+This project is written under [Unlicense] but also depends on,
+among other libraries, [Ableton Link] and [pybind11].
+Please mind the licenses of those libraries and their dependencies.
+
+[Ableton Link]: https://github.com/ableton/link.git
+[link-python]: https://github.com/gonzaloflirt/link-python
+[`__init__.pyi`]: https://github.com/thegamecracks/link-python/blob/master/src-py/link/__init__.pyi
+[LinkHut.py]: https://github.com/thegamecracks/link-python/blob/master/example/LinkHut.py
+[linkhut]: https://github.com/Ableton/link/blob/master/examples/linkhut/main.cpp
+[aalink]: https://github.com/artfwo/aalink
+[LinkPython-extern]: https://pypi.org/project/LinkPython-extern/
+[LinkPython]: https://github.com/munshkr/link-python
+[Unlicense]: /LICENSE.md
+[pybind11]: https://github.com/pybind/pybind11

linkpython_extern-1.3.0a2.dist-info/RECORD

@@ -0,0 +1,10 @@
+_link.cp312-win_arm64.pyd,sha256=cmJvIPEj7F3k-8k24-55DkwR6yJkZsvRpVGpNtFkZBo,425472
+link/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+link/__init__.py,sha256=rGDu4Yax7gSRebC3oZgFR011dTuOhwNDbu64MyH6D2I,339
+link/__init__.pyi,sha256=iH9aWhrUkK1hlxRXA9Vj25O_oMnwQkhGTpWgDDOvzJA,10014
+linkpython_extern-1.3.0a2.data/platlib/msvcp140-5f1c5dd31916990d94181e07bc3afb32.dll,sha256=Xxxd0xkWmQ2UGB4HvDr7Mr49tY8EO5-NZJ4kFYYvZr8,1387552
+linkpython_extern-1.3.0a2.dist-info/DELVEWHEEL,sha256=K5EMwJOX-hpCzBbpzhMtj6chRmEgz5ztzy_wk02-yVg,418
+linkpython_extern-1.3.0a2.dist-info/METADATA,sha256=ddTInlH5ohPK1qhriPjJr57ap_aBfnMEguAe1CVgQjY,4592
+linkpython_extern-1.3.0a2.dist-info/RECORD,,
+linkpython_extern-1.3.0a2.dist-info/WHEEL,sha256=fnODF-PNtYcPmBGkQYuEMFUKmnTJrZGWNChBROEYn4E,106
+linkpython_extern-1.3.0a2.dist-info/licenses/LICENSE.md,sha256=q5WXlxI4JI6pfbYaXwRHcelpf_KquERaf3hwVuv7sOU,1415

linkpython_extern-1.3.0a2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 0.12.2
+Root-Is-Purelib: false
+Tag: cp312-cp312-win_arm64
+

linkpython_extern-1.3.0a2.dist-info/licenses/LICENSE.md

@@ -0,0 +1,27 @@
+This depends on [Link](https://github.com/ableton/link.git) and [pybind11](https://github.com/pybind/pybind11).
+Please mind the licenses of those libraries and their dependencies
+
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org>