pytq-cxx 1.0.2__tar.gz → 1.1.1__tar.gz

{pytq_cxx-1.0.2/pytq_cxx.egg-info → pytq_cxx-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pytq-cxx
-Version: 1.0.2
+Version: 1.1.1
 Summary: single-threaded timer demultiplexer backed by C++ implementation
 Author-email: Nikita Vaganov <nikita.e.vaganov@gmail.com>
 Project-URL: Homepage, https://github.com/vaganov/yatq
@@ -18,4 +18,9 @@ see [yatq homepage](https://github.com/vaganov/yatq)
 
 **NB:** Module name is, however, **pytq**
 
-    from pytq import ThreadPool, TimerQueue, AwaitableFuture
+    from pytq import ThreadPool, TimerQueue, pythonize
+
+**NB:** On _macOS_ one may need to specify **MACOSX_DEPLOYMENT_TARGET** environment variable on install. Do not set
+higher than the current _macOS_ version. Minimal supported version is **13.4**
+
+    (venv) $ MACOSX_DEPLOYMENT_TARGET=13.4 pip install pytq-cxx

{pytq_cxx-1.0.2 → pytq_cxx-1.1.1}/README_pytq.md

@@ -6,4 +6,9 @@ see [yatq homepage](https://github.com/vaganov/yatq)
 
 **NB:** Module name is, however, **pytq**
 
-    from pytq import ThreadPool, TimerQueue, AwaitableFuture
+    from pytq import ThreadPool, TimerQueue, pythonize
+
+**NB:** On _macOS_ one may need to specify **MACOSX_DEPLOYMENT_TARGET** environment variable on install. Do not set
+higher than the current _macOS_ version. Minimal supported version is **13.4**
+
+    (venv) $ MACOSX_DEPLOYMENT_TARGET=13.4 pip install pytq-cxx

{pytq_cxx-1.0.2 → pytq_cxx-1.1.1}/_yatq/bind.cpp

@@ -3,6 +3,8 @@
 #include <pybind11/chrono.h>
 #include <pybind11/functional.h>
 
+#include <functional>
+
 #ifndef YATQ_DISABLE_FUTURES
 #define BOOST_THREAD_PROVIDES_FUTURE
 #define BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION
@@ -18,7 +20,9 @@
 namespace py = pybind11;
 
 using result_type = py::object;
+#ifndef YATQ_DISABLE_FUTURES
 using Future = boost::future<result_type>;
+#endif
 using Executable = std::function<result_type(void)>;
 using ThreadPool = yatq::ThreadPool<Executable>;
 using TimerQueue = yatq::TimerQueue<ThreadPool>;
@@ -26,10 +30,38 @@ using TimerQueue = yatq::TimerQueue<ThreadPool>;
 PYBIND11_MODULE(_yatq, m) {
 #ifndef YATQ_DISABLE_FUTURES
     auto boost_submodule = m.def_submodule("boost");
+
+    py::enum_<boost::launch>(boost_submodule, "launch")
+        .value("none", boost::launch::none)
+        .value("async_", boost::launch::async)  // sic!
+        .value("deferred", boost::launch::deferred)
+#ifdef BOOST_THREAD_PROVIDES_EXECUTORS
+        .value("executor", boost::launch::executor)
+#endif
+        .value("inherit", boost::launch::inherit)
+        .value("sync", boost::launch::sync)
+        .value("any", boost::launch::any)
+        .export_values();
+
     py::class_<Future>(boost_submodule, "future")
         .def("get", &Future::get, py::call_guard<py::gil_scoped_release>())
         .def("wait", &Future::wait, py::call_guard<py::gil_scoped_release>())
-        .def("is_ready", py::overload_cast<>(&Future::is_ready, py::const_));
+        .def("is_ready", py::overload_cast<>(&Future::is_ready, py::const_))
+        .def(
+            "then",
+            [] (Future& _this, std::function<result_type(Future&&)>&& func) {
+                return _this.then(std::move(func));
+            },
+            py::arg("func")
+        )
+        .def(
+            "then",
+            [] (Future& _this, boost::launch policy, std::function<result_type(Future&&)>&& func) {
+                return _this.then(policy, std::move(func));
+            },
+            py::arg("policy"),
+            py::arg("func")
+        );
 #endif
 
 #ifndef YATQ_DISABLE_PTHREAD

{pytq_cxx-1.0.2 → pytq_cxx-1.1.1}/_yatq/include/yatq/internal/promise_utils.h

@@ -3,28 +3,50 @@
 
 #include <type_traits>
 
+#include <boost/exception_ptr.hpp>
+
 namespace yatq::internal {
 
 template<typename result_type, typename Job, typename Promise>
 std::enable_if_t<!std::is_void_v<result_type>> run_and_set_value(Job job, Promise promise) {
-    promise.set_value(job());
+    try {
+        promise.set_value(job());
+    }
+    catch (...) {
+        promise.set_exception(boost::current_exception());
+    }
 }
 
 template<typename result_type, typename Job, typename Promise>
 std::enable_if_t<std::is_void_v<result_type>> run_and_set_value(Job job, Promise promise) {
-    job();
-    promise.set_value();
+    try {
+        job();
+        promise.set_value();
+    }
+    catch (...) {
+        promise.set_exception(boost::current_exception());
+    }
 }
 
 template<typename result_type, typename Future, typename Promise>
 std::enable_if_t<!std::is_void_v<result_type>> get_and_set_value(Future future, Promise promise) {
-    promise.set_value(future.get());
+    try {
+        promise.set_value(future.get());
+    }
+    catch (...) {
+        promise.set_exception(boost::current_exception());
+    }
 }
 
 template<typename result_type, typename Future, typename Promise>
 std::enable_if_t<std::is_void_v<result_type>> get_and_set_value(Future future, Promise promise) {
-    future.get();
-    promise.set_value();
+    try {
+        future.get();
+        promise.set_value();
+    }
+    catch (...) {
+        promise.set_exception(boost::current_exception());
+    }
 }
 
 }

{pytq_cxx-1.0.2 → pytq_cxx-1.1.1}/_yatq/include/yatq/thread_pool.h

@@ -2,8 +2,8 @@
 #define _YATQ_THREAD_POOL_H
 
 #include <condition_variable>
-#include <cstdlib>
 #include <deque>
+#include <format>
 #include <functional>
 #include <mutex>
 #include <string>
@@ -17,7 +17,9 @@
 #endif
 
 #include "yatq/internal/concepts.h"
+#ifndef YATQ_DISABLE_FUTURES
 #include "yatq/internal/promise_utils.h"
+#endif
 #include "yatq/internal/log4cxx_proxy.h"
 
 namespace yatq {
@@ -65,8 +67,8 @@ public:
         if (!_running) {
             _running = true;
             for (int i = 0; i < num_threads; ++i) {
-                std::string thread_tag = "pool thread #" + std::to_string(i);
-                auto thread = std::thread(&ThreadPool::thread_routine, this, thread_tag);
+                std::string thread_tag = std::format("pool thread #{}", i);
+                auto thread = std::thread(&ThreadPool::thread_routine, this, std::move(thread_tag));
                 _pool.push_back(std::move(thread));
             }
         }
@@ -119,7 +121,7 @@ public:
     }
 
 private:
-    void thread_routine(const std::string& thread_tag) {
+    void thread_routine(std::string&& thread_tag) {
 #ifndef YATQ_DISABLE_LOGGING
         static auto logger = log4cxx::Logger::getLogger("yatq.thread_pool");
 #endif

{pytq_cxx-1.0.2 → pytq_cxx-1.1.1}/_yatq/include/yatq/timer_queue.h

@@ -4,6 +4,7 @@
 #include <algorithm>
 #include <chrono>
 #include <condition_variable>
+#include <format>
 #include <mutex>
 #include <thread>
 #include <unordered_map>
@@ -16,7 +17,9 @@
 #endif
 
 #include "yatq/internal/concepts.h"
+#ifndef YATQ_DISABLE_FUTURES
 #include "yatq/internal/promise_utils.h"
+#endif
 #include "yatq/internal/log4cxx_proxy.h"
 #include "yatq/utils/logging_utils.h"
 #ifndef YATQ_DISABLE_PTHREAD
@@ -171,7 +174,7 @@ public:
         if (is_first) {
             _cond.notify_one();
         }
-        LOG4CXX_DEBUG(logger, "New timer uid=" + std::to_string(uid));
+        LOG4CXX_DEBUG(logger, std::format("New timer uid={}", uid));
         return {
             uid
             , deadline
@@ -197,7 +200,7 @@ public:
             std::lock_guard<std::mutex> guard(_lock);
             auto i = _jobs.find(uid);
             if (i != _jobs.end()) {
-                LOG4CXX_DEBUG(logger, "Canceling timer uid=" + std::to_string(uid));
+                LOG4CXX_DEBUG(logger, std::format("Canceling timer uid={}", uid));
                 _jobs.erase(i);
                 was_removed = true;
                 was_first = (_heap[0].uid == uid);
@@ -233,7 +236,7 @@ public:
             _cond.notify_one();
         }
         auto canceled_timers = total_timers - total_jobs;
-        LOG4CXX_DEBUG(logger, "Cleared " + std::to_string(total_jobs) + " timers and " + std::to_string(canceled_timers) + " canceled timers");
+        LOG4CXX_DEBUG(logger, std::format("Cleared {} timers and {} canceled timers", total_jobs, canceled_timers));
     }
 
     /**
@@ -258,7 +261,7 @@ public:
                         *i++ = std::move(heap_entry);
                     }
                     else {
-                        LOG4CXX_DEBUG(logger, "Timer uid=" + std::to_string(heap_entry.uid) + " has been canceled");
+                        LOG4CXX_DEBUG(logger, std::format("Timer uid={} has been canceled", heap_entry.uid));
                     }
                 }
                 std::make_heap(heap.begin(), heap.end(), TimerQueue::heap_cmp);
@@ -266,7 +269,7 @@ public:
             }
         }
         // NB: 'demux()' never waits on a canceled timer => no need to notify
-        LOG4CXX_DEBUG(logger, "Purged " + std::to_string(canceled_timers) + " canceled timers");
+        LOG4CXX_DEBUG(logger, std::format("Purged {} canceled timers", canceled_timers));
     }
 
     /**
@@ -298,7 +301,7 @@ private:
                 auto current_uid = _heap[0].uid;
                 auto i = _jobs.find(current_uid);
                 if (i == _jobs.end()) {
-                    LOG4CXX_DEBUG(logger, "Timer uid=" + std::to_string(current_uid) + " has been canceled");
+                    LOG4CXX_DEBUG(logger, std::format("Timer uid={} has been canceled", current_uid));
                     std::pop_heap(_heap.begin(), _heap.end(), TimerQueue::heap_cmp);
                     _heap.pop_back();
                     deadline_expired = false;
@@ -309,7 +312,7 @@ private:
                     deadline_expired = (_heap[0].deadline <= now);
                 }
                 if (deadline_expired) {
-                    LOG4CXX_DEBUG(logger, "Executing timer uid=" + std::to_string(current_uid));
+                    LOG4CXX_DEBUG(logger, std::format("Executing timer uid={}", current_uid));
                     auto node = _jobs.extract(i);
                     std::pop_heap(_heap.begin(), _heap.end(), TimerQueue::heap_cmp);
                     _heap.pop_back();
@@ -336,7 +339,7 @@ private:
                     // NB: without this explicit cast duration type may be deduced incorrectly
                     // on Linux this leads to waiting for a random time point
                     std::chrono::time_point<Clock, typename Clock::duration> deadline = _heap[0].deadline;
-                    LOG4CXX_TRACE(logger, "Wait until " + utils::time_point_to_string(deadline));
+                    LOG4CXX_TRACE(logger, std::format("Wait until {}", utils::time_point_to_string(deadline)));
                     bool notified = _cond.wait_until(
                             guard,
                             deadline,

{pytq_cxx-1.0.2 → pytq_cxx-1.1.1}/_yatq/include/yatq/utils/sched_utils.h

@@ -2,6 +2,7 @@
 #define _YATQ_UTILS_SCHED_UTILS_H
 
 #include <cerrno>
+#include <format>
 #include <string>
 
 #include <pthread.h>
@@ -13,6 +14,14 @@ namespace yatq::utils {
 
 typedef enum {min_priority = 0, max_priority = -1} priority_t;
 
+/**
+ * set scheduling parameters for a thread
+ * @param handle thread handle
+ * @param sched_policy \a SCHED_OTHER | \a SCHED_RR | \a SCHED_FIFO
+ * @param priority explicit priority
+ * @param thread_tag thread tag (used for logging purposes only)
+ * @return \a true if scheduling parameters have been set and \a false otherwise
+ */
 inline bool set_sched_params(pthread_t handle, int sched_policy, int priority, const std::string& thread_tag = "unspecified") {
 #ifndef YATQ_DISABLE_LOGGING
     static auto logger = log4cxx::Logger::getLogger("yatq.utils.sched");
@@ -23,15 +32,29 @@ inline bool set_sched_params(pthread_t handle, int sched_policy, int priority, c
     pthread_getschedparam(handle, &prev_sched_policy, &sched);
     sched.sched_priority = priority;
     if (pthread_setschedparam(handle, sched_policy, &sched) == 0) {
-        LOG4CXX_INFO(logger, "Set sched params thread=" + thread_tag + " policy=" + sched_policy_to_string(sched_policy) + " priority=" + std::to_string(priority));
+        LOG4CXX_INFO(
+            logger,
+            std::format(
+                "Set sched params thread='{}' policy={} priority={}",
+                thread_tag, sched_policy_to_string(sched_policy), priority
+            )
+        );
         return true;
     }
     else {
-        LOG4CXX_WARN(logger, "Failed to set sched params thread=" + thread_tag + ": " + std::string(std::strerror(errno)));
+        LOG4CXX_WARN(logger, std::format("Failed to set sched params thread='{}': {}", thread_tag, std::strerror(errno)));
         return false;
     }
 }
 
+/**
+ * set scheduling parameters for a thread
+ * @param handle thread handle
+ * @param sched_policy \a SCHED_OTHER | \a SCHED_RR | \a SCHED_FIFO
+ * @param priority_tag \a yatq::utils::max_priority | \a yatq::utils::min_priority
+ * @param thread_tag thread tag (used for logging purposes only)
+ * @return \a true if scheduling parameters have been set and \a false otherwise
+ */
 inline bool set_sched_params(pthread_t handle, int sched_policy, priority_t priority_tag, const std::string& thread_tag = "unspecified") {
     int priority;
     switch (priority_tag) {

{pytq_cxx-1.0.2 → pytq_cxx-1.1.1}/_yatq/include/yatq/version.h

@@ -1,6 +1,6 @@
 #ifndef _YATQ_VERSION_H
 #define _YATQ_VERSION_H
 
-#define YATQ_VERSION "1.0.2"
+#define YATQ_VERSION "1.1.1"
 
 #endif

{pytq_cxx-1.0.2 → pytq_cxx-1.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pytq-cxx"
-version = "1.0.2"
+version = "1.1.1"
 authors = [{name="Nikita Vaganov", email="nikita.e.vaganov@gmail.com"}]
 description = "single-threaded timer demultiplexer backed by C++ implementation"
 readme = "README_pytq.md"

{pytq_cxx-1.0.2 → pytq_cxx-1.1.1}/pytq/__init__.py

@@ -1,5 +1,5 @@
 from _yatq import __version__, TimerQueue, TimerHandle, ThreadPool, utils
-from .awaitable_future import AwaitableFuture
+from .pythonize import pythonize
 
 
-__all__ = ['__version__', 'TimerQueue', 'TimerHandle', 'ThreadPool', 'utils', 'AwaitableFuture']
+__all__ = ['__version__', 'TimerQueue', 'TimerHandle', 'ThreadPool', 'utils', 'pythonize']

pytq_cxx-1.1.1/pytq/pythonize.py

@@ -0,0 +1,22 @@
+import asyncio
+from typing import Any
+
+import _yatq.boost
+
+
+__all__ = ['pythonize']
+
+
+def pythonize(src: _yatq.boost.future) -> asyncio.Future[Any]:
+    chained = asyncio.Future()
+
+    def on_done(future: _yatq.boost.future):
+        try:
+            result = future.get()
+        except Exception as exc:
+            chained.get_loop().call_soon_threadsafe(chained.set_exception, exc)
+        else:
+            chained.get_loop().call_soon_threadsafe(chained.set_result, result)
+
+    src.then(func=on_done, policy=_yatq.boost.launch.sync)
+    return chained

{pytq_cxx-1.0.2 → pytq_cxx-1.1.1/pytq_cxx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pytq-cxx
-Version: 1.0.2
+Version: 1.1.1
 Summary: single-threaded timer demultiplexer backed by C++ implementation
 Author-email: Nikita Vaganov <nikita.e.vaganov@gmail.com>
 Project-URL: Homepage, https://github.com/vaganov/yatq
@@ -18,4 +18,9 @@ see [yatq homepage](https://github.com/vaganov/yatq)
 
 **NB:** Module name is, however, **pytq**
 
-    from pytq import ThreadPool, TimerQueue, AwaitableFuture
+    from pytq import ThreadPool, TimerQueue, pythonize
+
+**NB:** On _macOS_ one may need to specify **MACOSX_DEPLOYMENT_TARGET** environment variable on install. Do not set
+higher than the current _macOS_ version. Minimal supported version is **13.4**
+
+    (venv) $ MACOSX_DEPLOYMENT_TARGET=13.4 pip install pytq-cxx

{pytq_cxx-1.0.2 → pytq_cxx-1.1.1}/pytq_cxx.egg-info/SOURCES.txt

@@ -13,7 +13,7 @@ _yatq/include/yatq/internal/promise_utils.h
 _yatq/include/yatq/utils/logging_utils.h
 _yatq/include/yatq/utils/sched_utils.h
 pytq/__init__.py
-pytq/awaitable_future.py
+pytq/pythonize.py
 pytq_cxx.egg-info/PKG-INFO
 pytq_cxx.egg-info/SOURCES.txt
 pytq_cxx.egg-info/dependency_links.txt

pytq_cxx-1.0.2/pytq/awaitable_future.py

@@ -1,19 +0,0 @@
-import asyncio
-
-
-__all__ = ['AwaitableFuture']
-
-
-class AwaitableFuture:
-    def __init__(self, future):
-        self._future = future
-
-    def __await__(self):
-        while not self._future.is_ready():
-            yield
-        return self._future.get()  # NB: return, not yield
-
-    async def get(self):
-        while not self._future.is_ready():
-            await asyncio.sleep(0)
-        return self._future.get()