redc 0.1.2__tar.gz → 0.1.4__tar.gz

{redc-0.1.2 → redc-0.1.4}/.github/workflows/before-all.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 
-CURL_VERSION="8.12.0"
+CURL_VERSION="8.13.0"
 
 # deps
 yum install wget gcc make libpsl-devel libidn-devel zlib-devel libnghttp2-devel perl-IPC-Cmd -y

{redc-0.1.2 → redc-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: redc
-Version: 0.1.2
+Version: 0.1.4
 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>
@@ -14,7 +14,7 @@ Description-Content-Type: text/markdown
   <img src="https://raw.githubusercontent.com/AYMENJD/redc/refs/heads/main/assets/images/redc-logo.png">
 </div>
 
-[![Version](https://img.shields.io/pypi/v/redc?style=flat&logo=curl&logoColor=red&color=red)](https://pypi.org/project/RedC) [![CURL version](https://img.shields.io/badge/Curl-v8.12.0-red?logo=curl)](https://curl.se/ch/8.12.0.html) [![Downloads](https://static.pepy.tech/personalized-badge/redc?period=month&units=none&left_color=grey&right_color=brightgreen&left_text=Downloads)](https://pepy.tech/project/redc)
+[![Version](https://img.shields.io/pypi/v/redc?style=flat&logo=curl&logoColor=red&color=red)](https://pypi.org/project/RedC) [![CURL version](https://img.shields.io/badge/Curl-v8.13.0-red?logo=curl)](https://curl.se/ch/8.13.0.html) [![Downloads](https://static.pepy.tech/personalized-badge/redc?period=month&units=none&left_color=grey&right_color=brightgreen&left_text=Downloads)](https://pepy.tech/project/redc)
 
 **RedC** is a **high-performance**, asynchronous **HTTP** client library for **Python**, built on top of the powerful **curl** library. It provides a simple and intuitive interface for making HTTP requests and handling responses
 

{redc-0.1.2 → redc-0.1.4}/README.md

@@ -2,7 +2,7 @@
   <img src="https://raw.githubusercontent.com/AYMENJD/redc/refs/heads/main/assets/images/redc-logo.png">
 </div>
 
-[![Version](https://img.shields.io/pypi/v/redc?style=flat&logo=curl&logoColor=red&color=red)](https://pypi.org/project/RedC) [![CURL version](https://img.shields.io/badge/Curl-v8.12.0-red?logo=curl)](https://curl.se/ch/8.12.0.html) [![Downloads](https://static.pepy.tech/personalized-badge/redc?period=month&units=none&left_color=grey&right_color=brightgreen&left_text=Downloads)](https://pepy.tech/project/redc)
+[![Version](https://img.shields.io/pypi/v/redc?style=flat&logo=curl&logoColor=red&color=red)](https://pypi.org/project/RedC) [![CURL version](https://img.shields.io/badge/Curl-v8.13.0-red?logo=curl)](https://curl.se/ch/8.13.0.html) [![Downloads](https://static.pepy.tech/personalized-badge/redc?period=month&units=none&left_color=grey&right_color=brightgreen&left_text=Downloads)](https://pepy.tech/project/redc)
 
 **RedC** is a **high-performance**, asynchronous **HTTP** client library for **Python**, built on top of the powerful **curl** library. It provides a simple and intuitive interface for making HTTP requests and handling responses
 

{redc-0.1.2 → redc-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "redc"
-version = "0.1.2"
+version = "0.1.4"
 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.2 → redc-0.1.4}/redc/__init__.py

@@ -1,21 +1,21 @@
-from .callbacks import StreamCallback, ProgressCallback
+from . import utils
+from .callbacks import ProgressCallback, StreamCallback
 from .client import Client
 from .codes import HTTPStatus
 from .exceptions import HTTPError
 from .response import Response
-from . import utils
 
 __all__ = [
+    "utils",
+    "ProgressCallback",
+    "StreamCallback",
     "Client",
-    "Response",
-    "HTTPError",
     "HTTPStatus",
-    "StreamCallback",
-    "ProgressCallback",
-    "utils",
+    "HTTPError",
+    "Response",
 ]
 
-__version__ = "0.1.2"
+__version__ = "0.1.4"
 __copyright__ = "Copyright (c) 2025 RedC, AYMENJD"
 __license__ = "MIT License"
 

{redc-0.1.2 → redc-0.1.4}/redc/client.py

@@ -1,12 +1,13 @@
+import asyncio
+from typing import BinaryIO, Union
 from urllib.parse import urlencode
 
-from .callbacks import StreamCallback, ProgressCallback
+import redc
+
+from .callbacks import ProgressCallback, StreamCallback
 from .redc_ext import RedC
 from .response import Response
-from .utils import json_dumps, parse_base_url, Headers
-
-import asyncio
-import redc
+from .utils import Headers, json_dumps, parse_base_url, get_fsize
 
 
 class Client:
@@ -117,7 +118,7 @@ class Client:
         url: str,
         form: dict = None,
         json: dict = None,
-        data: dict[str, str] = None,
+        data: Union[dict[str, str], BinaryIO] = None,
         files: dict[str, str] = None,
         headers: dict[str, str] = None,
         timeout: tuple = None,
@@ -149,8 +150,8 @@ class Client:
             json (``dict``, *optional*):
                 JSON data to send in the request body. Default is ``None``
 
-            data (``dict[str, str]``, *optional*):
-                Multipart form data to send in the request body. Default is ``None``
+            data (``dict[str, str]`` || ``BinaryIO``, *optional*):
+                Multipart form data dict or a binary file-like object (requires ``readinto``). Default is ``None``
 
             files (``dict[str, str]``, *optional*):
                 A dictionary specifying files to upload as part of a multipart form request, ``key`` is the form field and ``value`` is string containing the file path
@@ -211,9 +212,17 @@ class Client:
             else:
                 raise TypeError("json must be of type dict[str, str]")
 
+        file_stream = None
+        file_size = 0
         if data is not None:
-            if not isinstance(data, dict):
-                raise TypeError("data must be of type dict[str, str]")
+            if hasattr(data, "readinto"):
+                file_stream = data
+                file_size = get_fsize(file_stream)
+                data = None
+            elif not isinstance(data, dict):
+                raise TypeError(
+                    "data must be either dict[str, str] or a file-like object with readinto method"
+                )
 
         if files is not None:
             if not isinstance(files, dict):
@@ -247,6 +256,8 @@ class Client:
                     method=method,
                     url=url,
                     raw_data=form or json or "",
+                    file_stream=file_stream,
+                    file_size=file_size,
                     data=data,
                     files=files,
                     headers=headers,
@@ -391,7 +402,7 @@ class Client:
         url: str,
         form: dict = None,
         json: dict = None,
-        data: dict[str, str] = None,
+        data: Union[dict[str, str], BinaryIO] = None,
         files: dict[str, str] = None,
         headers: dict[str, str] = None,
         timeout: tuple = None,
@@ -424,8 +435,8 @@ class Client:
             json (``dict``, *optional*):
                 JSON data to send in the request body. Default is ``None``
 
-            data (``dict[str, str]``, *optional*):
-                Multipart form data to send in the request body. Default is ``None``
+            data (``dict[str, str]`` || ``BinaryIO``, *optional*):
+                Multipart form data dict or a binary file-like object (requires ``readinto``). Default is ``None``
 
             files (``dict[str, str]``, *optional*):
                 A dictionary specifying files to upload as part of a multipart form request, ``key`` is the form field and ``value`` is string containing the file path
@@ -481,7 +492,7 @@ class Client:
         url: str,
         form: dict = None,
         json: dict = None,
-        data: dict[str, str] = None,
+        data: Union[dict[str, str], BinaryIO] = None,
         files: dict[str, str] = None,
         headers: dict[str, str] = None,
         timeout: tuple = None,
@@ -514,8 +525,8 @@ class Client:
             json (``dict``, *optional*):
                 JSON data to send in the request body. Default is ``None``
 
-            data (``dict[str, str]``, *optional*):
-                Multipart form data to send in the request body. Default is ``None``
+            data (``dict[str, str]`` || ``BinaryIO``, *optional*):
+                Multipart form data dict or a binary file-like object (requires ``readinto``). Default is ``None``
 
             files (``dict[str, str]``, *optional*):
                 A dictionary specifying files to upload as part of a multipart form request, ``key`` is the form field and ``value`` is string containing the file path
@@ -571,7 +582,7 @@ class Client:
         url: str,
         form: dict = None,
         json: dict = None,
-        data: dict[str, str] = None,
+        data: Union[dict[str, str], BinaryIO] = None,
         files: dict[str, str] = None,
         headers: dict[str, str] = None,
         timeout: tuple = None,
@@ -604,8 +615,8 @@ class Client:
             json (``dict``, *optional*):
                 JSON data to send in the request body. Default is ``None``
 
-            data (``dict[str, str]``, *optional*):
-                Multipart form data to send in the request body. Default is ``None``
+            data (``dict[str, str]`` || ``BinaryIO``, *optional*):
+                Multipart form data dict or a binary file-like object (requires ``readinto``). Default is ``None``
 
             files (``dict[str, str]``, *optional*):
                 A dictionary specifying files to upload as part of a multipart form request, ``key`` is the form field and ``value`` is string containing the file path

{redc-0.1.2 → redc-0.1.4}/redc/ext/redc.cpp

@@ -1,5 +1,6 @@
 #include "redc.h"
 #include "utils/curl_utils.h"
+#include "utils/memoryview.h"
 #include <iostream>
 #include <stdexcept>
 
@@ -51,11 +52,11 @@ void RedC::close() {
   }
 }
 
-py_object RedC::request(const char *method, const char *url, const char *raw_data, const py_object &data,
-                        const py_object &files, const py_object &headers, const long &timeout_ms,
-                        const long &connect_timeout_ms, const bool &allow_redirect, const char *proxy_url,
-                        const bool &verify, const char *ca_cert_path, const py_object &stream_callback,
-                        const py_object &progress_callback, const bool &verbose) {
+py_object RedC::request(const char *method, const char *url, const char *raw_data, const py_object &file_stream,
+                        const long &file_size, const py_object &data, const py_object &files, const py_object &headers,
+                        const long &timeout_ms, const long &connect_timeout_ms, const bool &allow_redirect,
+                        const char *proxy_url, const bool &verify, const char *ca_cert_path,
+                        const py_object &stream_callback, const py_object &progress_callback, const bool &verbose) {
   CHECK_RUNNING();
 
   if (isNullOrEmpty(method) || isNullOrEmpty(url)) {
@@ -169,9 +170,19 @@ py_object RedC::request(const char *method, const char *url, const char *raw_dat
       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;
@@ -304,6 +315,15 @@ void RedC::CHECK_RUNNING() {
   }
 }
 
+size_t RedC::read_callback(char *buffer, size_t size, size_t nitems, Data *clientp) {
+  acq_gil gil;
+
+  auto memview = nb::memoryview::from_memory(buffer, size * nitems);
+  auto result = clientp->file_stream.attr("readinto")(memview);
+
+  return nb::cast<curl_off_t>(result);
+}
+
 size_t RedC::header_callback(char *buffer, size_t size, size_t nitems, Data *clientp) {
   size_t total_size = size * nitems;
   clientp->headers.insert(clientp->headers.end(), buffer, buffer + total_size);
@@ -346,10 +366,10 @@ NB_MODULE(redc_ext, m) {
   nb::class_<RedC>(m, "RedC")
       .def(nb::init<const long &>())
       .def("is_running", &RedC::is_running)
-      .def("request", &RedC::request, arg("method"), arg("url"), arg("raw_data") = "", arg("data") = nb::none(),
-           arg("files") = nb::none(), arg("headers") = nb::none(), arg("timeout_ms") = 60 * 1000,
-           arg("connect_timeout_ms") = 0, arg("allow_redirect") = true, arg("proxy_url") = "", arg("verify") = true,
-           arg("ca_cert_path") = "", arg("stream_callback") = nb::none(), arg("progress_callback") = nb::none(),
-           arg("verbose") = false)
+      .def("request", &RedC::request, arg("method"), arg("url"), arg("raw_data") = "", arg("file_stream") = nb::none(),
+           arg("file_size") = 0, arg("data") = nb::none(), arg("files") = nb::none(), arg("headers") = nb::none(),
+           arg("timeout_ms") = 60 * 1000, arg("connect_timeout_ms") = 0, arg("allow_redirect") = true,
+           arg("proxy_url") = "", arg("verify") = true, arg("ca_cert_path") = "", arg("stream_callback") = nb::none(),
+           arg("progress_callback") = nb::none(), arg("verbose") = false)
       .def("close", &RedC::close, nb::call_guard<nb::gil_scoped_release>());
 }

{redc-0.1.2 → redc-0.1.4}/redc/ext/redc.h

@@ -37,6 +37,7 @@ struct Data {
   py_object loop;
   py_object stream_callback{nb::none()};
   py_object progress_callback{nb::none()};
+  py_object file_stream{nb::none()};
 
   bool has_stream_callback{false};
   bool has_progress_callback{false};
@@ -56,12 +57,14 @@ class RedC {
   bool is_running();
   void close();
 
-  py_object request(const char *method, const char *url, const char *raw_data = "", const py_object &data = nb::none(),
-                    const py_object &files = nb::none(), const py_object &headers = nb::none(),
-                    const long &timeout_ms = 60 * 1000, const long &connect_timeout_ms = 0,
-                    const bool &allow_redirect = true, const char *proxy_url = "", const bool &verify = true,
-                    const char *ca_cert_path = "", const py_object &stream_callback = nb::none(),
-                    const py_object &progress_callback = nb::none(), const bool &verbose = false);
+  py_object request(const char *method, const char *url, const char *raw_data = "",
+                    const py_object &file_stream = nb::none(), const long &file_size = 0,
+                    const py_object &data = nb::none(), const py_object &files = nb::none(),
+                    const py_object &headers = nb::none(), const long &timeout_ms = 60 * 1000,
+                    const long &connect_timeout_ms = 0, const bool &allow_redirect = true, const char *proxy_url = "",
+                    const bool &verify = true, const char *ca_cert_path = "",
+                    const py_object &stream_callback = nb::none(), const py_object &progress_callback = nb::none(),
+                    const bool &verbose = false);
 
  private:
   int still_running_{0};
@@ -82,6 +85,7 @@ class RedC {
   void cleanup();
   void CHECK_RUNNING();
 
+  static size_t read_callback(char *buffer, size_t size, size_t nitems, Data *clientp);
   static size_t header_callback(char *buffer, size_t size, size_t nitems, Data *clientp);
   static size_t progress_callback(Data *clientp, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal,
                                   curl_off_t ulnow);

redc-0.1.4/redc/ext/utils/memoryview.h

@@ -0,0 +1,36 @@
+#include <nanobind/nanobind.h>
+
+NAMESPACE_BEGIN(NB_NAMESPACE)
+
+// https://github.com/lief-project/LIEF/blob/abcf929efb748c7846dd59007cbb807e108db311/api/python/src/nanobind/extra/memoryview.hpp
+class memoryview : public object {
+  using ssize_t = Py_ssize_t;
+
+ public:
+  NB_OBJECT(memoryview, object, "memoryview", PyMemoryView_Check)
+
+  memoryview(const object &o)
+      : object(check_(o) ? o.inc_ref().ptr() : PyMemoryView_FromObject(o.ptr()), detail::steal_t{}) {
+    if (!m_ptr)
+      detail::raise_python_error();
+  }
+
+  memoryview(object &&o) : object(check_(o) ? o.release().ptr() : PyMemoryView_FromObject(o.ptr()), detail::steal_t{}) {
+    if (!m_ptr)
+      detail::raise_python_error();
+  }
+
+  static memoryview from_memory(void *mem, ssize_t size, bool readonly = false) {
+    PyObject *ptr = PyMemoryView_FromMemory(reinterpret_cast<char *>(mem), size, (readonly) ? PyBUF_READ : PyBUF_WRITE);
+    if (!ptr) {
+      detail::fail("Could not allocate memoryview object!");
+    }
+    return memoryview(object(ptr, detail::steal_t{}));
+  }
+
+  static memoryview from_memory(const void *mem, ssize_t size) {
+    return memoryview::from_memory(const_cast<void *>(mem), size, true);
+  }
+};
+
+NAMESPACE_END(NB_NAMESPACE)

redc-0.1.4/redc/utils/__init__.py

@@ -0,0 +1,13 @@
+__all__ = [
+    "get_fsize",
+    "Headers",
+    "check_key_dict",
+    "parse_base_url",
+    "json_dumps",
+    "json_loads",
+]
+
+from ._io_utils import get_fsize
+from .headers import Headers, check_key_dict
+from .http import parse_base_url
+from .json_encoder import json_dumps, json_loads

redc-0.1.4/redc/utils/_io_utils.py

@@ -0,0 +1,11 @@
+from os import SEEK_END
+from typing import BinaryIO
+
+
+def get_fsize(f: BinaryIO) -> int:
+    """Get the size of a file-like object"""
+    current_pos = f.tell()
+    f.seek(0, SEEK_END)
+    f_size = f.tell()
+    f.seek(current_pos)
+    return f_size

redc-0.1.2/redc/utils/__init__.py

@@ -1,5 +0,0 @@
-__all__ = ["check_key_dict", "Headers", "json_dumps", "json_loads", "parse_base_url"]
-
-from .headers import check_key_dict, Headers
-from .json_encoder import json_dumps, json_loads
-from .http import parse_base_url