LinkPython-extern 1.0.4__tar.gz → 1.1.0a1__tar.gz

linkpython_extern-1.1.0a1/.gitignore

@@ -0,0 +1,37 @@
+# IDE generated files and build outputs
+.vscode/
+/build/
+/ide/
+/output/
+/logs/
+/lib/
+.idea/*
+*.egg-info/
+dist/
+
+# System temporary files
+.DS_Store
+*~
+*.swp
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app

linkpython_extern-1.1.0a1/.gitmodules

@@ -0,0 +1,6 @@
+[submodule "modules/link"]
+	path = modules/link
+	url = https://github.com/Ableton/link.git
+[submodule "modules/pybind11"]
+	path = modules/pybind11
+	url = https://github.com/pybind/pybind11.git

{LinkPython-extern-1.0.4 → linkpython_extern-1.1.0a1}/CMakeLists.txt

@@ -6,6 +6,6 @@ include(modules/link/AbletonLinkConfig.cmake)
 
 add_subdirectory(modules/pybind11)
 
-pybind11_add_module(link src/Link.cpp)
+pybind11_add_module(_link src/Link.cpp)
 
-target_link_libraries(link PRIVATE Ableton::Link)
+target_link_libraries(_link PRIVATE Ableton::Link)

{LinkPython-extern-1.0.4 → linkpython_extern-1.1.0a1}/MANIFEST.in

@@ -1,5 +1,6 @@
 graft modules
 graft src
+graft src-py
 include CMakeLists.txt
 global-exclude *.pdf
 prune **/.github

{LinkPython-extern-1.0.4 → linkpython_extern-1.1.0a1}/PKG-INFO

@@ -1,16 +1,43 @@
 Metadata-Version: 2.1
 Name: LinkPython-extern
-Version: 1.0.4
+Version: 1.1.0a1
 Summary: A fork of the LinkPython wrapper for Ableton Link
-Home-page: https://github.com/thegamecracks/link-python
 Author: gonzaloflirt
 Maintainer: thegamecracks
+License: 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>
+Project-URL: Homepage, https://github.com/thegamecracks/link-python
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: C++
 Classifier: Programming Language :: Python
 Classifier: Topic :: System :: Networking
-Requires-Python: >=3.6,<3.13
+Requires-Python: <3.13,>=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 

linkpython_extern-1.1.0a1/example/LinkHut.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+
+import os
+import sys
+import time
+
+lib_dir = os.path.normpath(os.path.dirname(os.path.realpath(__file__)) + '/../lib/')
+sys.path.insert(0, lib_dir)
+
+import link
+
+l = link.Link(120)
+l.enabled = True
+l.startStopSyncEnabled = True
+
+try:
+  while True:
+    s = l.captureSessionState()
+    link_time = l.clock().micros()
+    tempo_str = '{0:.2f}'.format(s.tempo())
+    beats_str = '{0:.2f}'.format(s.beatAtTime(link_time, 0))
+    playing_str = str(s.isPlaying())
+    phase = s.phaseAtTime(link_time, 4)
+    phase_str = ''
+    for x in range(0, 4):
+      if x < phase:
+        phase_str += 'X'
+      else:
+        phase_str += '0'
+    sys.stdout.write(
+      'tempo ' + tempo_str + ' | playing: ' + playing_str + ' | beats ' + beats_str
+      + ' | ' + phase_str + '  \r')
+    sys.stdout.flush()
+    time.sleep(0.02)
+except KeyboardInterrupt:
+    pass

linkpython_extern-1.1.0a1/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=61", "setuptools-scm>=7", "wheel", "ninja", "cmake>=3.4"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "LinkPython-extern"
+description = "A fork of the LinkPython wrapper for Ableton Link"
+requires-python = ">=3.7,<3.13"
+authors = [{ name = "gonzaloflirt" }]
+maintainers = [{ name = "thegamecracks" }]
+readme = "README.md"
+license = { file = "LICENSE.md" }
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Programming Language :: C++",
+    "Programming Language :: Python",
+    "Topic :: System :: Networking",
+]
+dynamic = ["version"]
+
+[project.urls]
+Homepage = "https://github.com/thegamecracks/link-python"
+
+[tool.setuptools.packages.find]
+where = ["src-py"]
+
+[tool.setuptools_scm]

{LinkPython-extern-1.0.4 → linkpython_extern-1.1.0a1}/setup.py

@@ -128,25 +128,6 @@ class CMakeBuild(build_ext):
 
 
 setup(
-    name="LinkPython-extern",
-    description="A fork of the LinkPython wrapper for Ableton Link",
-    long_description=open("README.md").read(),
-    long_description_content_type="text/markdown",
-    version="1.0.4",
-    author="gonzaloflirt",
-    maintainer="thegamecracks",
-    license_files=["LICENSE.md"],
-    classifiers=[
-        "Development Status :: 5 - Production/Stable",
-        "Intended Audience :: Developers",
-        "Programming Language :: C++",
-        "Programming Language :: Python",
-        "Topic :: System :: Networking",
-    ],
-    url="https://github.com/thegamecracks/link-python",
-    python_requires=">=3.6,<3.13",
-    include_package_data=True,
     ext_modules=[CMakeExtension("LinkPython-extern")],
     cmdclass={"build_ext": CMakeBuild},
-    zip_safe=False,
 )

{LinkPython-extern-1.0.4 → linkpython_extern-1.1.0a1}/src/Link.cpp

@@ -2,7 +2,7 @@
 #include <pybind11/functional.h>
 #include <pybind11/pybind11.h>
 
-PYBIND11_MODULE(link, m)
+PYBIND11_MODULE(_link, m)
 {
   using namespace ableton;
   using namespace pybind11;
@@ -29,15 +29,29 @@ PYBIND11_MODULE(link, m)
            { sessionState.requestBeatAtTime(beat, micros(time), quantum); })
       .def("isPlaying", &SessionState::isPlaying)
       .def("setIsPlaying", [](SessionState &sessionState, const bool isPlaying, const uint64_t time)
-           { sessionState.setIsPlaying(isPlaying, micros(time)); });
+           { sessionState.setIsPlaying(isPlaying, micros(time)); })
+      .def("forceBeatAtTime", [](SessionState &sessionState, double beat, uint64_t time, double quantum)
+           { sessionState.forceBeatAtTime(beat, micros(time), quantum); })
+      .def("timeForIsPlaying", [](SessionState &sessionState)
+           { return sessionState.timeForIsPlaying().count(); })
+      .def("requestBeatAtStartPlayingTime", [](SessionState &sessionState, double beat, double quantum)
+           { sessionState.requestBeatAtStartPlayingTime(beat, quantum); })
+      .def("setIsPlayingAndRequestBeatAtTime", [](SessionState &sessionState, bool isPlaying, uint64_t time, double beat, double quantum)
+           { sessionState.setIsPlayingAndRequestBeatAtTime(isPlaying, micros(time), beat, quantum); })
+  ;
 
   class_<Link>(m, "Link")
       .def(init<const double &>())
       .def_property("enabled", &Link::isEnabled, &Link::enable)
       .def("numPeers", &Link::numPeers)
       .def("clock", &Link::clock)
+
+      .def("captureAppSessionState", &Link::captureAppSessionState)
+      .def("commitAppSessionState", &Link::commitAppSessionState)
+      // Aliases for backwards-compatibility
       .def("captureSessionState", &Link::captureAppSessionState)
       .def("commitSessionState", &Link::commitAppSessionState)
+
       .def_property("startStopSyncEnabled",
                     &Link::isStartStopSyncEnabled, &Link::enableStartStopSync)
       .def("setNumPeersCallback", [](Link &link, const std::function<void(std::size_t)> &callback)
@@ -45,5 +59,6 @@ PYBIND11_MODULE(link, m)
       .def("setTempoCallback", [](Link &link, const std::function<void(double)> &callback)
            { link.setTempoCallback(callback); })
       .def("setStartStopCallback", [](Link &link, const std::function<void(bool)> &callback)
-           { link.setStartStopCallback(callback); });
+           { link.setStartStopCallback(callback); })
+  ;
 }

{LinkPython-extern-1.0.4 → linkpython_extern-1.1.0a1/src-py}/LinkPython_extern.egg-info/PKG-INFO

@@ -1,16 +1,43 @@
 Metadata-Version: 2.1
 Name: LinkPython-extern
-Version: 1.0.4
+Version: 1.1.0a1
 Summary: A fork of the LinkPython wrapper for Ableton Link
-Home-page: https://github.com/thegamecracks/link-python
 Author: gonzaloflirt
 Maintainer: thegamecracks
+License: 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>
+Project-URL: Homepage, https://github.com/thegamecracks/link-python
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: C++
 Classifier: Programming Language :: Python
 Classifier: Topic :: System :: Networking
-Requires-Python: >=3.6,<3.13
+Requires-Python: <3.13,>=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 

{LinkPython-extern-1.0.4 → linkpython_extern-1.1.0a1/src-py}/LinkPython_extern.egg-info/SOURCES.txt

@@ -1,14 +1,12 @@
+.gitignore
+.gitmodules
 CMakeLists.txt
 LICENSE.md
 MANIFEST.in
 README.md
 pyproject.toml
 setup.py
-LinkPython_extern.egg-info/PKG-INFO
-LinkPython_extern.egg-info/SOURCES.txt
-LinkPython_extern.egg-info/dependency_links.txt
-LinkPython_extern.egg-info/not-zip-safe
-LinkPython_extern.egg-info/top_level.txt
+example/LinkHut.py
 modules/link/.appveyor.yml
 modules/link/.clang-format
 modules/link/.git
@@ -1046,4 +1044,11 @@ modules/pybind11/tools/pybind11Tools.cmake
 modules/pybind11/tools/pyproject.toml
 modules/pybind11/tools/setup_global.py.in
 modules/pybind11/tools/setup_main.py.in
-src/Link.cpp
+src/Link.cpp
+src-py/LinkPython_extern.egg-info/PKG-INFO
+src-py/LinkPython_extern.egg-info/SOURCES.txt
+src-py/LinkPython_extern.egg-info/dependency_links.txt
+src-py/LinkPython_extern.egg-info/top_level.txt
+src-py/link/__init__.py
+src-py/link/__init__.pyi
+src-py/link/py.typed

{LinkPython-extern-1.0.4 → linkpython_extern-1.1.0a1/src-py}/LinkPython_extern.egg-info/top_level.txt

@@ -1 +1,2 @@
 LinkPython-extern
+link

linkpython_extern-1.1.0a1/src-py/link/__init__.py

@@ -0,0 +1 @@
+from _link import *

linkpython_extern-1.1.0a1/src-py/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.0.4/LinkPython_extern.egg-info/not-zip-safe

@@ -1 +0,0 @@
-

LinkPython-extern-1.0.4/pyproject.toml

@@ -1,3 +0,0 @@
-[build-system]
-requires = ["setuptools", "wheel", "ninja", "cmake>=3.4"]
-build-backend = "setuptools.build_meta"