redc 0.1.0.dev5__tar.gz → 0.1.1.dev1__tar.gz

redc-0.1.1.dev1/.github/workflows/before-all.sh

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+
+CURL_VERSION="8.11.1"
+
+# deps
+yum install wget gcc make libpsl-devel libidn-devel zlib-devel libnghttp2-devel perl-IPC-Cmd -y
+
+# openssl from source
+git clone --depth 1 https://github.com/openssl/openssl
+cd openssl
+./Configure
+make -j100
+make install
+ldconfig
+cd .. && rm -rf openssl
+
+# curl from source
+wget https://curl.se/download/curl-$CURL_VERSION.tar.gz
+tar -xzvf curl-$CURL_VERSION.tar.gz
+rm curl-$CURL_VERSION.tar.gz
+
+cd curl-$CURL_VERSION
+./configure --with-openssl --enable-cookies --with-zlib --enable-threaded-resolver --enable-ipv6 --enable-proxy --with-ca-fallback --with-ca-bundle=/etc/ssl/certs/ca-certificates.crt
+make -j100
+make install
+ldconfig
+curl --version
+
+cd ..
+rm -rf curl-$CURL_VERSION

{redc-0.1.0.dev5 → redc-0.1.1.dev1}/CMakeLists.txt

@@ -43,7 +43,7 @@ if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
     set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
 endif()
 
-nanobind_add_module(redc_ext STABLE_ABI LTO redc/ext/redc.cpp)
+nanobind_add_module(redc_ext STABLE_ABI FREE_THREADED LTO redc/ext/redc.cpp)
 
 target_link_libraries(redc_ext PRIVATE CURL::libcurl)
 

{redc-0.1.0.dev5 → redc-0.1.1.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: redc
-Version: 0.1.0.dev5
+Version: 0.1.1.dev1
 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>
@@ -11,10 +11,10 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 
 <div align="center">
-  <img src="/assets/images/redc-logo.png">
+  <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) [![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.11.1-red?logo=curl)](https://curl.se/ch/8.11.1.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
 
@@ -43,6 +43,7 @@ async def main():
     async with Client(base_url="https://jsonplaceholder.typicode.com") as client:
         # Make a GET request
         response = await client.get("/posts/1")
+        response.raise_for_status()
         print(response.status_code)  # 200
         print(response.json())  # {'userId': 1, 'id': 1, 'title': '...', 'body': '...'}
 
@@ -51,6 +52,7 @@ async def main():
             "/posts",
             json={"title": "foo", "body": "bar", "userId": 1},
         )
+        response.raise_for_status()
         print(response.status_code)  # 201
         print(response.json())  # {'id': 101, ...}
 
@@ -59,4 +61,4 @@ asyncio.run(main())
 
 ## License
 
-MIT [LICENSE](LICENSE)
+MIT [LICENSE](https://github.com/AYMENJD/redc/blob/main/LICENSE)

{redc-0.1.0.dev5 → redc-0.1.1.dev1}/README.md

@@ -1,8 +1,8 @@
 <div align="center">
-  <img src="/assets/images/redc-logo.png">
+  <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) [![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.11.1-red?logo=curl)](https://curl.se/ch/8.11.1.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
 
@@ -31,6 +31,7 @@ async def main():
     async with Client(base_url="https://jsonplaceholder.typicode.com") as client:
         # Make a GET request
         response = await client.get("/posts/1")
+        response.raise_for_status()
         print(response.status_code)  # 200
         print(response.json())  # {'userId': 1, 'id': 1, 'title': '...', 'body': '...'}
 
@@ -39,6 +40,7 @@ async def main():
             "/posts",
             json={"title": "foo", "body": "bar", "userId": 1},
         )
+        response.raise_for_status()
         print(response.status_code)  # 201
         print(response.json())  # {'id': 101, ...}
 
@@ -47,4 +49,4 @@ asyncio.run(main())
 
 ## License
 
-MIT [LICENSE](LICENSE)
+MIT [LICENSE](https://github.com/AYMENJD/redc/blob/main/LICENSE)

{redc-0.1.0.dev5 → redc-0.1.1.dev1}/pyproject.toml

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["scikit-build-core >=0.10", "nanobind >=1.3.2"]
+requires = ["scikit-build-core >=0.10", "nanobind >=2.2.0"]
 build-backend = "scikit_build_core.build"
 
 [project]
 name = "redc"
-version = "0.1.0.dev5"
+version = "0.1.1.dev1"
 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" }]
@@ -23,9 +23,10 @@ wheel.py-api = "cp312"
 [tool.cibuildwheel]
 build-verbosity = 1
 build = "cp39* cp310* cp311* cp312* cp313*"
+free-threaded-support = true
 skip = "*musllinux*"
 archs = ["x86_64"]
 
 [tool.cibuildwheel.linux]
-before-all = "yum install wget gcc openssl-devel make libpsl-devel -y && wget https://curl.se/download/curl-8.11.1.tar.gz && tar -xzvf curl-8.11.1.tar.gz && rm curl-8.11.1.tar.gz && cd curl-8.11.1 && ./configure --with-openssl --with-ca-fallback --with-ca-bundle=/etc/ssl/certs/ca-certificates.crt && make -j && make install && ldconfig && curl --version && cd .. && rm -rf curl-8.11.1"
+before-all = ".github/workflows/before-all.sh"
 manylinux-x86_64-image = "manylinux2014"

{redc-0.1.0.dev5 → redc-0.1.1.dev1}/redc/__init__.py

@@ -1,4 +1,4 @@
-from .callbacks import StreamCallback
+from .callbacks import StreamCallback, ProgressCallback
 from .client import Client
 from .codes import HTTPStatus
 from .exceptions import HTTPError
@@ -11,10 +11,11 @@ __all__ = [
     "HTTPError",
     "HTTPStatus",
     "StreamCallback",
+    "ProgressCallback",
     "utils",
 ]
 
-__version__ = "0.1.0.dev5"
+__version__ = "0.1.1.dev1"
 __copyright__ = "Copyright (c) 2025 RedC, AYMENJD"
 __license__ = "MIT License"
 

redc-0.1.1.dev1/redc/callbacks.py

@@ -0,0 +1,81 @@
+import inspect
+from typing import Callable
+
+
+class StreamCallback:
+    """A class for creating a stream callback"""
+
+    def __init__(self, callback: Callable[[bytes, int], None]):
+        """A callback handler for streaming data
+
+        Example:
+            .. code-block:: python
+
+                >>> def callback(data: bytes, data_size: int):
+                ...     print(f"Received {len(data)}")
+                >>> stream_callback = StreamCallback(callback)
+                >>> client.get("https://example.com/", stream_callback=stream_callback)
+
+        Parameters:
+            callback (``Callable[[bytes, int], None]``):
+                A function that accepts two arguments: data (``bytes``) and data_size (``int``)
+                The function cannot be asynchronous
+        """
+
+        self.callback = callback
+        self._validate_callback()
+
+    def _validate_callback(self):
+        if inspect.iscoroutinefunction(self.callback):
+            raise TypeError("Callback function cannot be asynchronous")
+
+        signature = inspect.signature(self.callback)
+
+        parameters = signature.parameters
+        num_parameters = len(parameters)
+
+        if num_parameters != 2:
+            raise TypeError(
+                f"Callback function must accept two arguments only callback(data: bytes, data_size: int) but it accepts {num_parameters}."
+            )
+
+
+class ProgressCallback:
+    """A class for creating a progress callback"""
+
+    def __init__(self, callback: Callable[[int, int, int, int], None]):
+        """A callback handler for progress updates
+
+        Example:
+            .. code-block:: python
+
+                >>> def callback(dltotal: int, dlnow: int, ultotal: int, ulnow: int):
+                ...     print(f"Downloaded {dlnow}/{dltotal}, Uploaded {ulnow}/{ultotal}")
+                >>> progress_callback = ProgressCallback(callback)
+                >>> client.get("https://example.com/", progress_callback=progress_callback)
+
+        Parameters:
+            callback (``Callable[[int, int, int, int], None]``):
+                A function that accepts four arguments:
+                - dltotal (``int``): Total bytes expected to be downloaded
+                - dlnow (``int``): Bytes downloaded so far
+                - ultotal (``int``): Total bytes expected to be uploaded
+                - ulnow (``int``): Bytes uploaded so far
+                The function cannot be asynchronous.
+        """
+
+        self.callback = callback
+        self._validate_callback()
+
+    def _validate_callback(self):
+        if inspect.iscoroutinefunction(self.callback):
+            raise TypeError("Callback function cannot be asynchronous")
+
+        signature = inspect.signature(self.callback)
+        parameters = signature.parameters
+        num_parameters = len(parameters)
+
+        if num_parameters != 4:
+            raise TypeError(
+                f"Callback function must accept exactly four arguments (dltotal: int, dlnow: int, ultotal: int, ulnow: int) but it accepts {num_parameters}."
+            )

{redc-0.1.0.dev5 → redc-0.1.1.dev1}/redc/client.py

@@ -1,9 +1,12 @@
 from urllib.parse import urlencode
 
-from .callbacks import StreamCallback
+from .callbacks import StreamCallback, ProgressCallback
 from .redc_ext import RedC
 from .response import Response
-from .utils import json_dumps, parse_base_url
+from .utils import json_dumps, parse_base_url, Headers
+
+import asyncio
+import redc
 
 
 class Client:
@@ -13,7 +16,11 @@ class Client:
         self,
         base_url: str = None,
         buffer_size: int = 16384,
+        headers: dict = None,
+        timeout: tuple = (30.0, 0.0),
+        ca_cert_path: str = None,
         force_verbose: bool = None,
+        raise_for_status: bool = False,
         json_encoder=json_dumps,
     ):
         """
@@ -32,35 +39,78 @@ class Client:
             buffer_size (``int``, *optional*):
                 The buffer size for libcurl. Must be greater than ``1024`` bytes. Default is ``16384`` (16KB)
 
+            headers (``dict``, *optional*):
+                Headers to include in every request. Default is ``None``
+
+            timeout (``tuple``, *optional*):
+                A tuple of `(total_timeout, connect_timeout)` in seconds to include in every request. Default is ``(30.0, 0.0)``
+
+            ca_cert_path (``str``, *optional*):
+                Path to a CA certificate bundle file for SSL/TLS verification. Default is ``None``
+
             force_verbose (``bool``, *optional*):
                 Force verbose output for all requests. Default is ``None``
 
+            raise_for_status (``bool``, *optional*):
+                If ``True``, automatically raises an :class:`redc.HTTPError` for responses with HTTP status codes
+                indicating an error (i.e., 4xx or 5xx) or for CURL errors (e.g., network issues, timeouts). Default is ``False``
+
             json_encoder (``Callable`` , *optional*):
-                A callable for encoding JSON data. Default is ``json_dumps``
+                A callable for encoding JSON data. Default is :class:`redc.utils.json_dumps`
         """
 
         assert isinstance(base_url, (str, type(None))), "base_url must be string"
         assert isinstance(buffer_size, int), "buffer_size must be int"
-        assert buffer_size >= 1024, "buffer_size must be bigger than 1024 bytes"
-
+        assert isinstance(ca_cert_path, (str, type(None))), (
+            "ca_cert_path must be string"
+        )
+        assert isinstance(timeout, tuple) and len(timeout) == 2, (
+            "timeout must be a tuple of (total_timeout, connect_timeout)"
+        )
         assert isinstance(force_verbose, (bool, type(None))), (
             "force_verbose must be bool or None"
         )
+        assert isinstance(raise_for_status, bool), "raise_for_status must be bool"
+
+        assert buffer_size >= 1024, "buffer_size must be bigger than 1024 bytes"
 
         self.force_verbose = force_verbose
+        self.raise_for_status = raise_for_status
 
         self.__base_url = (
-            None if not isinstance(base_url, str) else parse_base_url(base_url)
+            parse_base_url(base_url) if isinstance(base_url, str) else None
         )
+        self.__default_headers = Headers(headers if isinstance(headers, dict) else {})
+        self.__timeout = timeout
+        self.__ca_cert_path = ca_cert_path if isinstance(ca_cert_path, str) else ""
         self.__json_encoder = json_encoder
+        self.__loop = asyncio.get_event_loop()
         self.__redc_ext = RedC(buffer_size)
 
+        self.__set_default_headers()
+
     async def __aenter__(self):
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         await self.close()
 
+    @property
+    def is_running(self):
+        """Checks if RedC is currently running
+
+        Returns:
+            ``bool``: ``True`` if RedC is running, False otherwise
+        """
+
+        return self.__redc_ext.is_running()
+
+    @property
+    def default_headers(self):
+        """Returns default headers that are set on all requests"""
+
+        return self.__default_headers
+
     async def request(
         self,
         method: str,
@@ -70,12 +120,12 @@ class Client:
         data: dict[str, str] = None,
         files: dict[str, str] = None,
         headers: dict[str, str] = None,
-        timeout: float = 30.0,
-        connect_timeout: float = 0.0,
+        timeout: tuple = None,
         allow_redirect: bool = True,
         proxy_url: str = "",
         verify: bool = True,
         stream_callback: StreamCallback = None,
+        progress_callback: ProgressCallback = None,
         verbose: bool = False,
     ):
         """
@@ -108,11 +158,9 @@ class Client:
             headers (``dict[str, str]``, *optional*):
                 Headers to include in the request. Default is ``None``
 
-            timeout (``float``, *optional*):
-                The total timeout for the request in seconds. Default is ``30.0``
-
-            connect_timeout (``float``, *optional*):
-                The connection timeout for the request in seconds. Default is ``0.0``
+            timeout (``tuple``, *optional*):
+                A tuple of ``(total_timeout, connect_timeout)`` in seconds to override the default timeout.
+                If ``None``, the default timeout specified in ``Client`` is used.
 
             allow_redirect (``bool``, *optional*):
                 Whether to allow redirects. Default is ``True``
@@ -126,6 +174,9 @@ class Client:
             stream_callback (:class:`redc.StreamCallback`, *optional*):
                 Callback for streaming response data. Default is ``None``
 
+            progress_callback (:class:`redc.ProgressCallback`, *optional*):
+                Callback for tracking upload and download progress. Default is ``None``
+
             verbose (``bool``, *optional*):
                 Whether to enable verbose output for the request. Default is ``False``
 
@@ -139,6 +190,12 @@ class Client:
 
             stream_callback = stream_callback.callback
 
+        if progress_callback is not None:
+            if not isinstance(progress_callback, ProgressCallback):
+                raise TypeError("progress_callback must be of type ProgressCallback")
+
+            progress_callback = progress_callback.callback
+
         if form is not None:
             if isinstance(form, dict):
                 form = urlencode(form)
@@ -162,6 +219,8 @@ class Client:
             if not isinstance(files, dict):
                 raise TypeError("files must be of type dict[str, str]")
 
+        timeout, connect_timeout = timeout if timeout is not None else self.__timeout
+
         if timeout <= 0:
             raise ValueError("timeout must be greater than 0")
 
@@ -172,9 +231,12 @@ class Client:
 
         if headers is not None:
             if isinstance(headers, dict):
+                headers = {**self.__default_headers, **headers}
                 headers = [f"{k}: {v}" for k, v in headers.items()]
             else:
                 raise TypeError("headers must be of type dict[str, str]")
+        else:
+            headers = [f"{k}: {v}" for k, v in self.__default_headers.items()]
 
         if self.__base_url:
             url = f"{self.__base_url}{url.lstrip('/')}"
@@ -193,22 +255,25 @@ class Client:
                     allow_redirect=allow_redirect,
                     proxy_url=proxy_url,
                     verify=verify,
+                    ca_cert_path=self.__ca_cert_path,
                     stream_callback=stream_callback,
+                    progress_callback=progress_callback,
                     verbose=self.force_verbose or verbose,
                 )
-            )
+            ),
+            raise_for_status=self.raise_for_status,
         )
 
     async def get(
         self,
         url: str,
         headers: dict[str, str] = None,
-        timeout: float = 30.0,
-        connect_timeout: float = 0.0,
+        timeout: tuple = None,
         allow_redirect: bool = True,
         proxy_url: str = "",
         verify: bool = True,
         stream_callback: StreamCallback = None,
+        progress_callback: ProgressCallback = None,
         verbose: bool = False,
     ):
         """
@@ -226,11 +291,9 @@ class Client:
             headers (``dict[str, str]``, *optional*):
                 Headers to include in the request. Default is ``None``
 
-            timeout (``float``, *optional*):
-                The total timeout for the request in seconds. Default is ``30.0``
-
-            connect_timeout (``float``, *optional*):
-                The connection timeout for the request in seconds. Default is ``0.0``
+            timeout (``tuple``, *optional*):
+                A tuple of ``(total_timeout, connect_timeout)`` in seconds to override the default timeout.
+                If ``None``, the default timeout specified in ``Client`` is used.
 
             allow_redirect (``bool``, *optional*):
                 Whether to allow redirects. Default is ``True``
@@ -244,22 +307,26 @@ class Client:
             stream_callback (:class:`redc.StreamCallback`, *optional*):
                 Callback for streaming response data. Default is ``None``
 
+            progress_callback (:class:`redc.ProgressCallback`, *optional*):
+                Callback for tracking upload and download progress. Default is ``None``
+
             verbose (``bool``, *optional*):
                 Whether to enable verbose output for the request. Default is ``False``
 
         Returns:
             :class:`redc.Response`
         """
+
         return await self.request(
             method="GET",
             url=url,
             headers=headers,
             timeout=timeout,
-            connect_timeout=connect_timeout,
             allow_redirect=allow_redirect,
             proxy_url=proxy_url,
             verify=verify,
             stream_callback=stream_callback,
+            progress_callback=progress_callback,
             verbose=self.force_verbose or verbose,
         )
 
@@ -267,8 +334,7 @@ class Client:
         self,
         url: str,
         headers: dict[str, str] = None,
-        timeout: float = 30.0,
-        connect_timeout: float = 0.0,
+        timeout: tuple = None,
         allow_redirect: bool = True,
         proxy_url: str = "",
         verify: bool = True,
@@ -289,11 +355,9 @@ class Client:
             headers (``dict[str, str]``, *optional*):
                 Headers to include in the request. Default is ``None``
 
-            timeout (``float``, *optional*):
-                The total timeout for the request in seconds. Default is ``30.0``
-
-            connect_timeout (``float``, *optional*):
-                The connection timeout for the request in seconds. Default is ``0.0``
+            timeout (``tuple``, *optional*):
+                A tuple of ``(total_timeout, connect_timeout)`` in seconds to override the default timeout.
+                If ``None``, the default timeout specified in ``Client`` is used.
 
             allow_redirect (``bool``, *optional*):
                 Whether to allow redirects. Default is ``True``
@@ -310,12 +374,12 @@ class Client:
         Returns:
             :class:`redc.Response`
         """
+
         return await self.request(
             method="HEAD",
             url=url,
             headers=headers,
             timeout=timeout,
-            connect_timeout=connect_timeout,
             allow_redirect=allow_redirect,
             proxy_url=proxy_url,
             verify=verify,
@@ -330,12 +394,12 @@ class Client:
         data: dict[str, str] = None,
         files: dict[str, str] = None,
         headers: dict[str, str] = None,
-        timeout: float = 30.0,
-        connect_timeout: float = 0.0,
+        timeout: tuple = None,
         allow_redirect: bool = True,
         proxy_url: str = "",
         verify: bool = True,
         stream_callback: StreamCallback = None,
+        progress_callback: ProgressCallback = None,
         verbose: bool = False,
     ):
         """
@@ -369,11 +433,9 @@ class Client:
             headers (``dict[str, str]``, *optional*):
                 Headers to include in the request. Default is ``None``
 
-            timeout (``float``, *optional*):
-                The total timeout for the request in seconds. Default is ``30.0``
-
-            connect_timeout (``float``, *optional*):
-                The connection timeout for the request in seconds. Default is ``0.0``
+            timeout (``tuple``, *optional*):
+                A tuple of ``(total_timeout, connect_timeout)`` in seconds to override the default timeout.
+                If ``None``, the default timeout specified in ``Client`` is used.
 
             allow_redirect (``bool``, *optional*):
                 Whether to allow redirects. Default is ``True``
@@ -387,12 +449,16 @@ class Client:
             stream_callback (:class:`redc.StreamCallback`, *optional*):
                 Callback for streaming response data. Default is ``None``
 
+            progress_callback (:class:`redc.ProgressCallback`, *optional*):
+                Callback for tracking upload and download progress. Default is ``None``
+
             verbose (``bool``, *optional*):
                 Whether to enable verbose output for the request. Default is ``False``
 
         Returns:
             :class:`redc.Response`
         """
+
         return await self.request(
             method="POST",
             url=url,
@@ -402,11 +468,11 @@ class Client:
             files=files,
             headers=headers,
             timeout=timeout,
-            connect_timeout=connect_timeout,
             allow_redirect=allow_redirect,
             proxy_url=proxy_url,
             verify=verify,
             stream_callback=stream_callback,
+            progress_callback=progress_callback,
             verbose=self.force_verbose or verbose,
         )
 
@@ -418,12 +484,12 @@ class Client:
         data: dict[str, str] = None,
         files: dict[str, str] = None,
         headers: dict[str, str] = None,
-        timeout: float = 30.0,
-        connect_timeout: float = 0.0,
+        timeout: tuple = None,
         allow_redirect: bool = True,
         proxy_url: str = "",
         verify: bool = True,
         stream_callback: StreamCallback = None,
+        progress_callback: ProgressCallback = None,
         verbose: bool = False,
     ):
         """
@@ -457,11 +523,9 @@ class Client:
             headers (``dict[str, str]``, *optional*):
                 Headers to include in the request. Default is ``None``
 
-            timeout (``float``, *optional*):
-                The total timeout for the request in seconds. Default is ``30.0``
-
-            connect_timeout (``float``, *optional*):
-                The connection timeout for the request in seconds. Default is ``0.0``
+            timeout (``tuple``, *optional*):
+                A tuple of ``(total_timeout, connect_timeout)`` in seconds to override the default timeout.
+                If ``None``, the default timeout specified in ``Client`` is used.
 
             allow_redirect (``bool``, *optional*):
                 Whether to allow redirects. Default is ``True``
@@ -475,12 +539,16 @@ class Client:
             stream_callback (:class:`redc.StreamCallback`, *optional*):
                 Callback for streaming response data. Default is ``None``
 
+            progress_callback (:class:`redc.ProgressCallback`, *optional*):
+                Callback for tracking upload and download progress. Default is ``None``
+
             verbose (``bool``, *optional*):
                 Whether to enable verbose output for the request. Default is ``False``
 
         Returns:
             :class:`redc.Response`
         """
+
         return await self.request(
             method="PUT",
             url=url,
@@ -490,11 +558,11 @@ class Client:
             files=files,
             headers=headers,
             timeout=timeout,
-            connect_timeout=connect_timeout,
             allow_redirect=allow_redirect,
             proxy_url=proxy_url,
             verify=verify,
             stream_callback=stream_callback,
+            progress_callback=progress_callback,
             verbose=self.force_verbose or verbose,
         )
 
@@ -506,12 +574,12 @@ class Client:
         data: dict[str, str] = None,
         files: dict[str, str] = None,
         headers: dict[str, str] = None,
-        timeout: float = 30.0,
-        connect_timeout: float = 0.0,
+        timeout: tuple = None,
         allow_redirect: bool = True,
         proxy_url: str = "",
         verify: bool = True,
         stream_callback: StreamCallback = None,
+        progress_callback: ProgressCallback = None,
         verbose: bool = False,
     ):
         """
@@ -545,11 +613,9 @@ class Client:
             headers (``dict[str, str]``, *optional*):
                 Headers to include in the request. Default is ``None``
 
-            timeout (``float``, *optional*):
-                The total timeout for the request in seconds. Default is ``30.0``
-
-            connect_timeout (``float``, *optional*):
-                The connection timeout for the request in seconds. Default is ``0.0``
+            timeout (``tuple``, *optional*):
+                A tuple of ``(total_timeout, connect_timeout)`` in seconds to override the default timeout.
+                If ``None``, the default timeout specified in ``Client`` is used.
 
             allow_redirect (``bool``, *optional*):
                 Whether to allow redirects. Default is ``True``
@@ -563,6 +629,9 @@ class Client:
             stream_callback (:class:`redc.StreamCallback`, *optional*):
                 Callback for streaming response data. Default is ``None``
 
+            progress_callback (:class:`redc.ProgressCallback`, *optional*):
+                Callback for tracking upload and download progress. Default is ``None``
+
             verbose (``bool``, *optional*):
                 Whether to enable verbose output for the request. Default is ``False``
 
@@ -579,11 +648,11 @@ class Client:
             files=files,
             headers=headers,
             timeout=timeout,
-            connect_timeout=connect_timeout,
             allow_redirect=allow_redirect,
             proxy_url=proxy_url,
             verify=verify,
             stream_callback=stream_callback,
+            progress_callback=progress_callback,
             verbose=self.force_verbose or verbose,
         )
 
@@ -591,12 +660,12 @@ class Client:
         self,
         url: str,
         headers: dict[str, str] = None,
-        timeout: float = 30.0,
-        connect_timeout: float = 0.0,
+        timeout: tuple = None,
         allow_redirect: bool = True,
         proxy_url: str = "",
         verify: bool = True,
         stream_callback: StreamCallback = None,
+        progress_callback: ProgressCallback = None,
         verbose: bool = False,
     ):
         """
@@ -614,11 +683,9 @@ class Client:
             headers (``dict[str, str]``, *optional*):
                 Headers to include in the request. Default is ``None``
 
-            timeout (``float``, *optional*):
-                The total timeout for the request in seconds. Default is ``30.0``
-
-            connect_timeout (``float``, *optional*):
-                The connection timeout for the request in seconds. Default is ``0.0``
+            timeout (``tuple``, *optional*):
+                A tuple of ``(total_timeout, connect_timeout)`` in seconds to override the default timeout.
+                If ``None``, the default timeout specified in ``Client`` is used.
 
             allow_redirect (``bool``, *optional*):
                 Whether to allow redirects. Default is ``True``
@@ -632,22 +699,26 @@ class Client:
             stream_callback (:class:`redc.StreamCallback`, *optional*):
                 Callback for streaming response data. Default is ``None``
 
+            progress_callback (:class:`redc.ProgressCallback`, *optional*):
+                Callback for tracking upload and download progress. Default is ``None``
+
             verbose (``bool``, *optional*):
                 Whether to enable verbose output for the request. Default is ``False``
 
         Returns:
             :class:`redc.Response`
         """
+
         return await self.request(
             method="DELETE",
             url=url,
             headers=headers,
             timeout=timeout,
-            connect_timeout=connect_timeout,
             allow_redirect=allow_redirect,
             proxy_url=proxy_url,
             verify=verify,
             stream_callback=stream_callback,
+            progress_callback=progress_callback,
             verbose=self.force_verbose or verbose,
         )
 
@@ -655,8 +726,7 @@ class Client:
         self,
         url: str,
         headers: dict[str, str] = None,
-        timeout: float = 30.0,
-        connect_timeout: float = 0.0,
+        timeout: tuple = None,
         allow_redirect: bool = True,
         proxy_url: str = "",
         verify: bool = True,
@@ -677,11 +747,9 @@ class Client:
             headers (``dict[str, str]``, *optional*):
                 Headers to include in the request. Default is ``None``
 
-            timeout (``float``, *optional*):
-                The total timeout for the request in seconds. Default is ``30.0``
-
-            connect_timeout (``float``, *optional*):
-                The connection timeout for the request in seconds. Default is ``0.0``
+            timeout (``tuple``, *optional*):
+                A tuple of ``(total_timeout, connect_timeout)`` in seconds to override the default timeout.
+                If ``None``, the default timeout specified in ``Client`` is used.
 
             allow_redirect (``bool``, *optional*):
                 Whether to allow redirects. Default is ``True``
@@ -698,12 +766,12 @@ class Client:
         Returns:
             :class:`redc.Response`
         """
+
         return await self.request(
             method="OPTIONS",
             url=url,
             headers=headers,
             timeout=timeout,
-            connect_timeout=connect_timeout,
             allow_redirect=allow_redirect,
             proxy_url=proxy_url,
             verify=verify,
@@ -717,4 +785,12 @@ class Client:
         This method must be called when the client is no longer needed to avoid memory leaks
         or unexpected behavior
         """
-        self.__redc_ext.close()
+
+        return await self.__loop.run_in_executor(None, self.__redc_ext.close)
+
+    def __set_default_headers(self):
+        if "user-agent" not in self.__default_headers:
+            self.__default_headers["user-agent"] = f"redc/{redc.__version__}"
+
+        if "connection" not in self.__default_headers:
+            self.__default_headers["connection"] = "keep-alive"

redc-0.1.1.dev1/redc/exceptions/__init__.py

@@ -0,0 +1,22 @@
+from ..codes import HTTPStatus
+
+
+class HTTPError(Exception):
+    """Exception raised for HTTP and CURL-related errors"""
+
+    def __init__(self, status_code: int, curl_error_code: int, curl_error_message: str):
+        self.status_code = status_code
+        self.curl_error_code = curl_error_code
+        self.curl_error_message = curl_error_message
+        self.is_curl_error = status_code == -1
+
+        if self.is_curl_error:
+            super().__init__(f"CURL {self.curl_error_code}: {self.curl_error_message}")
+        else:
+            short_description = HTTPStatus.get_description(self.status_code)
+
+            super().__init__(
+                self.status_code
+                if not short_description
+                else f"{self.status_code} - {short_description}"
+            )

{redc-0.1.0.dev5 → redc-0.1.1.dev1}/redc/ext/redc.cpp

@@ -7,6 +7,7 @@ RedC::RedC(const long &buffer) {
   {
     acq_gil gil;
     loop_ = nb::module_::import_("asyncio").attr("get_event_loop")();
+    call_soon_threadsafe_ = loop_.attr("call_soon_threadsafe");
   }
 
   static CurlGlobalInit g;
@@ -38,24 +39,26 @@ bool RedC::is_running() {
 void RedC::close() {
   if (running_) {
     running_ = false;
-    curl_multi_wakeup(multi_handle_);
 
     if (worker_thread_.joinable()) {
+      curl_multi_wakeup(multi_handle_);
       worker_thread_.join();
     }
 
     cleanup();
+
     curl_multi_cleanup(multi_handle_);
   }
 }
 
-py_object RedC::request(const string &method, const string &url, const char *raw_data, const py_object &data,
+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 string &proxy_url,
-                        const bool &verify, const py_object &stream_callback, const bool &verbose) {
+                        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 (method.empty() || url.empty()) {
+  if (isNullOrEmpty(method) || isNullOrEmpty(url)) {
     throw std::invalid_argument("method or url must be non-empty");
   }
 
@@ -64,12 +67,14 @@ py_object RedC::request(const string &method, const string &url, const char *raw
     throw std::runtime_error("Failed to create CURL easy handle");
   }
 
+  bool is_nobody = (strcmp(method, "HEAD") == 0 || strcmp(method, "OPTIONS") == 0);
+
   try {
     curl_easy_setopt(easy, CURLOPT_BUFFERSIZE, buffer_size_);
-    curl_easy_setopt(easy, CURLOPT_URL, url.c_str());
-    curl_easy_setopt(easy, CURLOPT_CUSTOMREQUEST, method.c_str());
+    curl_easy_setopt(easy, CURLOPT_URL, url);
+    curl_easy_setopt(easy, CURLOPT_CUSTOMREQUEST, method);
+    curl_easy_setopt(easy, CURLOPT_NOSIGNAL, 1L);
 
-    curl_easy_setopt(easy, CURLOPT_NOPROGRESS, 1L);
     curl_easy_setopt(easy, CURLOPT_TIMEOUT_MS, timeout_ms);
 
     curl_easy_setopt(easy, CURLOPT_HEADERFUNCTION, &RedC::header_callback);
@@ -82,7 +87,7 @@ py_object RedC::request(const string &method, const string &url, const char *raw
       curl_easy_setopt(easy, CURLOPT_CONNECTTIMEOUT_MS, connect_timeout_ms);
     }
 
-    if (method == "HEAD" || method == "OPTIONS") {
+    if (is_nobody) {
       curl_easy_setopt(easy, CURLOPT_NOBODY, 1L);
     } else {
       curl_easy_setopt(easy, CURLOPT_WRITEFUNCTION, &RedC::write_callback);
@@ -93,17 +98,19 @@ py_object RedC::request(const string &method, const string &url, const char *raw
       curl_easy_setopt(easy, CURLOPT_MAXREDIRS, 30L);
     }
 
-    if (!proxy_url.empty()) {
-      curl_easy_setopt(easy, CURLOPT_PROXY, proxy_url.c_str());
+    if (!isNullOrEmpty(proxy_url)) {
+      curl_easy_setopt(easy, CURLOPT_PROXY, proxy_url);
     }
 
     if (!verify) {
       curl_easy_setopt(easy, CURLOPT_SSL_VERIFYPEER, 0);
       curl_easy_setopt(easy, CURLOPT_SSL_VERIFYHOST, 0);
+    } else if (!isNullOrEmpty(ca_cert_path)) {
+      curl_easy_setopt(easy, CURLOPT_CAINFO, ca_cert_path);
     }
 
     CurlMime curl_mime_;
-    if (raw_data && *raw_data) {
+    if (!isNullOrEmpty(raw_data)) {
       curl_easy_setopt(easy, CURLOPT_POSTFIELDS, raw_data);
       curl_easy_setopt(easy, CURLOPT_POSTFIELDSIZE_LARGE, (curl_off_t)strlen(raw_data));
     } else if (!data.is_none() || !files.is_none()) {
@@ -165,13 +172,25 @@ py_object RedC::request(const string &method, const string &url, const char *raw
       d.request_headers = std::move(slist_headers);
       d.curl_mime_ = std::move(curl_mime_);
 
-      if (!stream_callback.is_none()) {
-        d.stream_callback = stream_callback;
-      }
-
       curl_easy_setopt(easy, CURLOPT_HEADERDATA, &d);
-      if (method != "HEAD" || method != "OPTIONS") {
+      if (!is_nobody) {
         curl_easy_setopt(easy, CURLOPT_WRITEDATA, &d);
+
+        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);
+        }
       }
     }
 
@@ -187,9 +206,6 @@ py_object RedC::request(const string &method, const string &url, const char *raw
 
 void RedC::worker_loop() {
   while (running_) {
-    if (!running_)
-      break;
-
     CURL *e;
     if (queue_.try_dequeue(e)) {
       CURLMcode res = curl_multi_add_handle(multi_handle_, e);
@@ -202,7 +218,7 @@ void RedC::worker_loop() {
           lock.unlock();
           {
             acq_gil gil;
-            loop_.attr("call_soon_threadsafe")(nb::cpp_function([data = std::move(data), res]() {
+            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)));
             }));
           }
@@ -214,6 +230,10 @@ void RedC::worker_loop() {
       curl_multi_poll(multi_handle_, nullptr, 0, 30000, &numfds);
     }
 
+    if (!running_) {
+      return;
+    }
+
     curl_multi_perform(multi_handle_, &still_running_);
 
     CURLMsg *msg;
@@ -257,7 +277,7 @@ void RedC::worker_loop() {
               result = nb::make_tuple(-1, NULL, NULL, (int)res, curl_easy_strerror(res));
             }
 
-            loop_.attr("call_soon_threadsafe")(nb::cpp_function([data = std::move(data), result = std::move(result)]() {
+            call_soon_threadsafe_(nb::cpp_function([data = std::move(data), result = std::move(result)]() {
               data.future.attr("set_result")(std::move(result));
             }));
           }
@@ -272,9 +292,12 @@ void RedC::worker_loop() {
 
 void RedC::cleanup() {
   std::unique_lock<std::mutex> lock(mutex_);
-  acq_gil gil;
   for (auto &[easy, data] : transfers_) {
-    loop_.attr("call_soon_threadsafe")(nb::cpp_function([data = std::move(data)]() { data.future.attr("cancel")(); }));
+    {
+      acq_gil gil;
+      call_soon_threadsafe_(data.future.attr("cancel"));
+    }
+
     curl_multi_remove_handle(multi_handle_, easy);
     curl_easy_cleanup(easy);
   }
@@ -294,10 +317,25 @@ size_t RedC::header_callback(char *buffer, size_t size, size_t nitems, Data *cli
   return total_size;
 }
 
+size_t RedC::progress_callback(Data *clientp, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal,
+                               curl_off_t ulnow) {
+  if (clientp->has_progress_callback) {
+    try {
+      acq_gil
+          gil;  //TODO: this sometimes hangs on exit, which lead to other functions to block such as curl_multi_perform and worker_loop never exit
+      clientp->progress_callback(dltotal, dlnow, ultotal, ulnow);
+    } catch (const std::exception &e) {
+      std::cerr << "Error in progress_callback: " << e.what() << std::endl;
+    }
+  }
+
+  return 0;
+}
+
 size_t RedC::write_callback(char *data, size_t size, size_t nmemb, Data *clientp) {
   size_t total_size = size * nmemb;
 
-  if (!clientp->stream_callback.is_none()) {
+  if (clientp->has_stream_callback) {
     try {
       acq_gil gil;
       clientp->stream_callback(py_bytes(data, total_size), total_size);
@@ -314,9 +352,11 @@ size_t RedC::write_callback(char *data, size_t size, size_t nmemb, Data *clientp
 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("stream_callback") = nb::none(), arg("verbose") = false)
+           arg("ca_cert_path") = "", arg("stream_callback") = nb::none(), arg("progress_callback") = nb::none(),
+           arg("verbose") = false)
       .def("close", &RedC::close);
-}
+}

{redc-0.1.0.dev5 → redc-0.1.1.dev1}/redc/ext/redc.h

@@ -5,7 +5,6 @@
 #include <cstring>
 #include <map>
 #include <mutex>
-#include <string>
 #include <thread>
 #include <vector>
 
@@ -21,17 +20,26 @@
 namespace nb = nanobind;
 using namespace nb::literals;
 
-using string = std::string;
-using py_object = nb::object;
 using acq_gil = nb::gil_scoped_acquire;
-using arg = nb::arg;
+using rel_gil = nb::gil_scoped_release;
+
+using py_object = nb::object;
 using py_bytes = nb::bytes;
+using arg = nb::arg;
 using dict = nb::dict;
 
+bool isNullOrEmpty(const char *str) {
+  return !str || !*str;
+}
+
 struct Data {
   py_object future;
   py_object loop;
-  py_object stream_callback = nb::none();
+  py_object stream_callback{nb::none()};
+  py_object progress_callback{nb::none()};
+
+  bool has_stream_callback{false};
+  bool has_progress_callback{false};
 
   std::vector<char> headers;
   CurlSlist request_headers;
@@ -48,25 +56,25 @@ class RedC {
   bool is_running();
   void close();
 
-  py_object request(const string &method, const string &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 string &proxy_url = "",
-                    const bool &verify = true, const py_object &stream_callback = nb::none(),
-                    const bool &verbose = false);
+  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);
 
  private:
-  int still_running_ = 0;
+  int still_running_{0};
   long buffer_size_;
   py_object loop_;
-  py_object builtins_;
+  py_object call_soon_threadsafe_;
 
   CURLM *multi_handle_;
 
   std::map<CURL *, Data> transfers_;
   std::mutex mutex_;
   std::thread worker_thread_;
-  std::atomic<bool> running_ = false;
+  std::atomic<bool> running_{false};
 
   moodycamel::ConcurrentQueue<CURL *> queue_;
 
@@ -75,7 +83,9 @@ class RedC {
   void CHECK_RUNNING();
 
   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);
   static size_t write_callback(char *data, size_t size, size_t nmemb, Data *clientp);
 };
 
-#endif  // REDC_H
+#endif  // REDC_H

{redc-0.1.0.dev5 → redc-0.1.1.dev1}/redc/response.py

@@ -1,6 +1,5 @@
 from .exceptions import HTTPError
 from .utils import Headers, json_loads
-from .codes import HTTPStatus
 
 
 class Response:
@@ -11,6 +10,7 @@ class Response:
         response: bytes,
         curl_code: int,
         curl_error_message: str,
+        raise_for_status: bool = False,
     ):
         """Represents an HTTP response of RedC"""
 
@@ -27,6 +27,9 @@ class Response:
         self.curl_error_message = curl_error_message
         """CURL error message"""
 
+        if raise_for_status:
+            self.raise_for_status()
+
     @property
     def content(self) -> bytes:
         """Returns the raw response content"""
@@ -58,16 +61,8 @@ class Response:
 
     def raise_for_status(self):
         """Raises an HTTPError if the response status indicates an error"""
-        if self.status_code == -1:  # Curl error
-            raise HTTPError(f"CURL {self.curl_code}: {self.curl_error_message}")
-
-        if 400 <= self.status_code <= 599:
-            short_description = HTTPStatus.get_description(self.status_code)
-            raise HTTPError(
-                self.status_code
-                if not short_description
-                else f"{self.status_code} - {short_description}"
-            )
+        if self.status_code == -1 or (400 <= self.status_code <= 599):
+            raise HTTPError(self.status_code, self.curl_code, self.curl_error_message)
 
     def __bool__(self):
         return self.status_code != -1 and 200 <= self.status_code <= 299

redc-0.1.0.dev5/redc/callbacks.py

@@ -1,40 +0,0 @@
-import inspect
-from typing import Callable
-
-
-class StreamCallback:
-    """A class for creating a stream callback"""
-
-    def __init__(self, callback: Callable[[bytes, int], None]):
-        """A callback handler for streaming data
-
-        Example:
-            .. code-block:: python
-
-                >>> def callback(data: bytes, data_size: int):
-                ...     print(f"Received {len(data)}")
-                >>> stream_callback = StreamCallback(callback)
-                >>> client.get("https://example.com/", stream_callback=stream_callback)
-
-        Parameters:
-            callback (``Callable[[bytes, int], None]``):
-                A function that accepts two arguments: data (``bytes``) and data_size (``int``)
-                The function cannot be asynchronous
-        """
-
-        self.callback = callback
-        self._validate_callback()
-
-    def _validate_callback(self):
-        if inspect.iscoroutinefunction(self.callback):
-            raise TypeError("Callback function cannot be asynchronous")
-
-        signature = inspect.signature(self.callback)
-
-        parameters = signature.parameters
-        num_parameters = len(parameters)
-
-        if num_parameters != 2:
-            raise TypeError(
-                f"Callback function must accept two arguments only callback(data: bytes, data_size: int) but it accepts {num_parameters}."
-            )

redc-0.1.0.dev5/redc/exceptions/__init__.py

@@ -1,2 +0,0 @@
-class HTTPError(Exception):
-    pass