redc 0.1.6__tar.gz → 0.1.7__tar.gz

{redc-0.1.6 → redc-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: redc
-Version: 0.1.6
+Version: 0.1.7
 Summary: RedC is a high-performance, asynchronous HTTP client library for Python, built on top of the powerful curl library
 Keywords: asyncio,http,client,http-client,curl,libcurl
 Author-Email: AYMEN Mohammed <let.me.code.safe@gmail.com>

{redc-0.1.6 → redc-0.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "redc"
-version = "0.1.6"
+version = "0.1.7"
 description = "RedC is a high-performance, asynchronous HTTP client library for Python, built on top of the powerful curl library"
 readme = "README.md"
 authors = [{ name = "AYMEN Mohammed", email = "let.me.code.safe@gmail.com" }]

{redc-0.1.6 → redc-0.1.7}/redc/__init__.py

@@ -15,7 +15,7 @@ __all__ = [
     "Response",
 ]
 
-__version__ = "0.1.6"
+__version__ = "0.1.7"
 __copyright__ = "Copyright (c) 2025 RedC, AYMENJD"
 __license__ = "MIT License"
 

{redc-0.1.6 → redc-0.1.7}/redc/ext/redc.cpp

@@ -162,42 +162,42 @@ py_object RedC::request(const char *method, const char *url, const char *raw_dat
 
     {
       std::unique_lock<std::mutex> lock(mutex_);
-      auto &d = transfers_[easy];
+      auto [it, inserted] =
+          transfers_.try_emplace(easy, Data{
+                                           future,
+                                           loop_,
+                                           stream_callback,
+                                           progress_callback,
+                                           file_stream,
+                                           !stream_callback.is_none() && !is_nobody,    // has_stream_callback
+                                           !progress_callback.is_none() && !is_nobody,  // has_progress_callback
+                                           {},                                          // response headers
+                                           std::move(slist_headers),
+                                           std::move(curl_mime_),
+                                           {}  // response
+                                       });
+      auto &d = it->second;
       lock.unlock();
 
-      d.future = future;
-      d.request_headers = std::move(slist_headers);
-      d.curl_mime_ = std::move(curl_mime_);
-
       curl_easy_setopt(easy, CURLOPT_HEADERDATA, &d);
 
       if (!is_nobody) {
         curl_easy_setopt(easy, CURLOPT_WRITEDATA, &d);
 
-        if (!file_stream.is_none()) {
-          d.file_stream = file_stream;
-
-          curl_easy_setopt(easy, CURLOPT_UPLOAD, 1L);
-          curl_easy_setopt(easy, CURLOPT_READDATA, &d);
-          curl_easy_setopt(easy, CURLOPT_READFUNCTION, &RedC::read_callback);
-          curl_easy_setopt(easy, CURLOPT_INFILESIZE_LARGE, (curl_off_t)file_size);
-        }
-
-        if (!stream_callback.is_none()) {
-          d.stream_callback = stream_callback;
-          d.has_stream_callback = true;
-        }
-
         if (!progress_callback.is_none()) {
-          d.progress_callback = progress_callback;
-          d.has_progress_callback = true;
-
           curl_easy_setopt(easy, CURLOPT_XFERINFODATA, &d);
           curl_easy_setopt(easy, CURLOPT_NOPROGRESS, 0L);
           curl_easy_setopt(easy, CURLOPT_XFERINFOFUNCTION, &RedC::progress_callback);
         } else {
           curl_easy_setopt(easy, CURLOPT_NOPROGRESS, 1L);
         }
+
+        if (!file_stream.is_none()) {
+          curl_easy_setopt(easy, CURLOPT_UPLOAD, 1L);
+          curl_easy_setopt(easy, CURLOPT_READDATA, &d);
+          curl_easy_setopt(easy, CURLOPT_READFUNCTION, &RedC::read_callback);
+          curl_easy_setopt(easy, CURLOPT_INFILESIZE_LARGE, (curl_off_t)file_size);
+        }
       }
     }
 
@@ -218,17 +218,15 @@ void RedC::worker_loop() {
       CURLMcode res = curl_multi_add_handle(multi_handle_, e);
       if (res != CURLM_OK) {
         std::unique_lock<std::mutex> lock(mutex_);
-        auto it = transfers_.find(e);
-        if (it != transfers_.end()) {
-          Data data = std::move(it->second);
-          transfers_.erase(it);
-          lock.unlock();
-          {
-            acq_gil gil;
-            call_soon_threadsafe_(nb::cpp_function([data = std::move(data), res]() {
-              data.future.attr("set_result")(nb::make_tuple(-1, NULL, NULL, (int)res, curl_multi_strerror(res)));
-            }));
-          }
+        auto node = transfers_.extract(e);
+        lock.unlock();
+
+        if (!node.empty()) {
+          Data &data = node.mapped();
+          acq_gil gil;
+          call_soon_threadsafe_(nb::cpp_function([data = std::move(data), res]() {
+            data.future.attr("set_result")(nb::make_tuple(-1, NULL, NULL, (int)res, curl_multi_strerror(res)));
+          }));
         }
         curl_easy_cleanup(e);
       }
@@ -248,18 +246,16 @@ void RedC::worker_loop() {
     while ((msg = curl_multi_info_read(multi_handle_, &msgs_left))) {
       if (msg->msg == CURLMSG_DONE) {
         std::unique_lock<std::mutex> lock(mutex_);
-        auto it = transfers_.find(msg->easy_handle);
-        if (it != transfers_.end()) {
-          Data data = std::move(it->second);
-          transfers_.erase(it);
-          lock.unlock();
+        auto node = transfers_.extract(msg->easy_handle);
+        lock.unlock();
 
-          {
-            acq_gil gil;
+        if (!node.empty()) {
+          Data &data = node.mapped();
+          acq_gil gil;
 
-            CURLcode res = msg->data.result;
+          CURLcode res = msg->data.result;
 
-            /*
+          /*
             * Result is allways Tuple:
 
             * 0: HTTP response status code.
@@ -274,24 +270,23 @@ void RedC::worker_loop() {
             *
             * 4: cURL error message string; can be null
             */
-            py_object result;
-            if (res == CURLE_OK) {
-              short status_code = 0;
-              curl_easy_getinfo(msg->easy_handle, CURLINFO_RESPONSE_CODE, &status_code);
-              result = nb::make_tuple(status_code, py_bytes(data.headers.data(), data.headers.size()),
-                                      py_bytes(data.response.data(), data.response.size()), (int)res, NULL);
-            } else {
-              result = nb::make_tuple(-1, NULL, NULL, (int)res, curl_easy_strerror(res));
-            }
-
-            call_soon_threadsafe_(nb::cpp_function([data = std::move(data), result = std::move(result)]() {
-              data.future.attr("set_result")(std::move(result));
-            }));
+          py_object result;
+          if (res == CURLE_OK) {
+            short status_code = 0;
+            curl_easy_getinfo(msg->easy_handle, CURLINFO_RESPONSE_CODE, &status_code);
+            result = nb::make_tuple(status_code, py_bytes(data.headers.data(), data.headers.size()),
+                                    py_bytes(data.response.data(), data.response.size()), (int)res, NULL);
+          } else {
+            result = nb::make_tuple(-1, NULL, NULL, (int)res, curl_easy_strerror(res));
           }
 
-          curl_multi_remove_handle(multi_handle_, msg->easy_handle);
-          curl_easy_cleanup(msg->easy_handle);
+          call_soon_threadsafe_(nb::cpp_function([data = std::move(data), result = std::move(result)]() {
+            data.future.attr("set_result")(std::move(result));
+          }));
         }
+
+        curl_multi_remove_handle(multi_handle_, msg->easy_handle);
+        curl_easy_cleanup(msg->easy_handle);
       }
     }
   }
@@ -300,13 +295,22 @@ void RedC::worker_loop() {
 void RedC::cleanup() {
   std::unique_lock<std::mutex> lock(mutex_);
   acq_gil gil;
-  for (auto &[easy, data] : transfers_) {
-    call_soon_threadsafe_(data.future.attr("cancel"));
 
+  std::vector<py_object> futures;
+  futures.reserve(transfers_.size());
+
+  for (auto &[easy, data] : transfers_) {
+    futures.push_back(data.future);
     curl_multi_remove_handle(multi_handle_, easy);
     curl_easy_cleanup(easy);
   }
+
   transfers_.clear();
+  lock.unlock();
+
+  for (auto &future : futures) {
+    call_soon_threadsafe_(future.attr("cancel"));
+  }
 }
 
 void RedC::CHECK_RUNNING() {
@@ -362,8 +366,29 @@ size_t RedC::write_callback(char *data, size_t size, size_t nmemb, Data *clientp
   return total_size;
 }
 
+int redc_tp_traverse(PyObject *self, visitproc visit, void *arg) {
+  Py_VISIT(Py_TYPE(self));
+
+  if (!nb::inst_ready(self))
+    return 0;
+
+  RedC *me = nb::inst_ptr<RedC>(self);
+  Py_VISIT(me->loop_.ptr());
+  Py_VISIT(me->call_soon_threadsafe_.ptr());
+  return 0;
+}
+
+int redc_tp_clear(PyObject *self) {
+  RedC *c = nb::inst_ptr<RedC>(self);
+  c->loop_ = {};
+  c->call_soon_threadsafe_ = {};
+  return 0;
+}
+
+PyType_Slot slots[] = {{Py_tp_traverse, (void *)redc_tp_traverse}, {Py_tp_clear, (void *)redc_tp_clear}, {0, 0}};
+
 NB_MODULE(redc_ext, m) {
-  nb::class_<RedC>(m, "RedC")
+  nb::class_<RedC>(m, "RedC", nb::type_slots(slots))
       .def(nb::init<const long &>())
       .def("is_running", &RedC::is_running)
       .def("request", &RedC::request, arg("method"), arg("url"), arg("raw_data") = "", arg("file_stream") = nb::none(),

{redc-0.1.6 → redc-0.1.7}/redc/ext/redc.h

@@ -33,6 +33,14 @@ bool isNullOrEmpty(const char *str) {
 }
 
 struct Data {
+  Data() = default;
+
+  Data(const Data &) = delete;
+  Data &operator=(const Data &) = delete;
+
+  Data(Data &&) = default;
+  Data &operator=(Data &&) = default;
+
   py_object future;
   py_object loop;
   py_object stream_callback{nb::none()};
@@ -90,6 +98,9 @@ class RedC {
   static size_t progress_callback(Data *clientp, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal,
                                   curl_off_t ulnow);
   static size_t write_callback(char *data, size_t size, size_t nmemb, Data *clientp);
+
+  friend int redc_tp_traverse(PyObject *, visitproc, void *);
+  friend int redc_tp_clear(PyObject *);
 };
 
 #endif  // REDC_H