scraper-rust 0.5.0__tar.gz → 0.5.1__tar.gz

{scraper_rust-0.5.0 → scraper_rust-0.5.1}/Cargo.lock

@@ -244,6 +244,31 @@ dependencies = [
  "libm",
 ]
 
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
 [[package]]
 name = "cssparser"
 version = "0.37.0"
@@ -1680,6 +1705,26 @@ dependencies = [
  "rand_core",
 ]
 
+[[package]]
+name = "rayon"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
 [[package]]
 name = "redox_syscall"
 version = "0.5.18"
@@ -1832,11 +1877,12 @@ dependencies = [
 
 [[package]]
 name = "scraper-rs"
-version = "0.5.0"
+version = "0.5.1"
 dependencies = [
  "html5ever",
  "pyo3",
  "pyo3-async-runtimes",
+ "rayon",
  "scraper",
  "tokio",
  "xee-xpath",

{scraper_rust-0.5.0 → scraper_rust-0.5.1}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "scraper-rs"
-version = "0.5.0"
+version = "0.5.1"
 edition = "2024"
 readme = "README.md"
 
@@ -15,7 +15,8 @@ extension-module = ["pyo3/extension-module"]
 [dependencies]
 pyo3 = { version = "0.28.3", features = ["abi3-py310"] }
 pyo3-async-runtimes = { version = "0.28", features = ["tokio-runtime"] }
-tokio = { version = "1", features = ["rt", "macros"] }
+rayon = "1"
+tokio = { version = "1", features = ["rt", "macros", "sync"] }
 
 scraper = { version = "0.27.0", git = "https://github.com/rust-scraper/scraper", features = ["atomic"], rev = "9c1eff304e45a8bccb463968268ce6758703e821" }
 

{scraper_rust-0.5.0 → scraper_rust-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scraper-rust
-Version: 0.5.0
+Version: 0.5.1
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
@@ -103,6 +103,7 @@ asyncio.run(main())
 ```
 
 All async functions accept the same keyword arguments as their sync counterparts (`max_size_bytes`, `truncate_on_limit`, etc.).
+CPU-bound async parsing and selection work is offloaded through the Rust async core onto Rayon worker threads so concurrent coroutines do not run that work on the event-loop thread.
 `AsyncDocument` supports `async with` for automatic cleanup in coroutine code, and `AsyncElement` / `AsyncDocument` both expose async `.prettify()` helpers.
 
 ### Large documents and memory safety

{scraper_rust-0.5.0 → scraper_rust-0.5.1}/README.md

@@ -76,6 +76,7 @@ asyncio.run(main())
 ```
 
 All async functions accept the same keyword arguments as their sync counterparts (`max_size_bytes`, `truncate_on_limit`, etc.).
+CPU-bound async parsing and selection work is offloaded through the Rust async core onto Rayon worker threads so concurrent coroutines do not run that work on the event-loop thread.
 `AsyncDocument` supports `async with` for automatic cleanup in coroutine code, and `AsyncElement` / `AsyncDocument` both expose async `.prettify()` helpers.
 
 ### Large documents and memory safety

{scraper_rust-0.5.0 → scraper_rust-0.5.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "scraper-rust"
-version = "0.5.0"
+version = "0.5.1"
 description = "Python bindings around rust-scraper/scraper with PyO3"
 authors = [{ name = "Yehor Smoliakov", email = "egorsmkv@gmail.com" }]
 requires-python = ">=3.10"

{scraper_rust-0.5.0 → scraper_rust-0.5.1}/scraper_rs/asyncio.py

@@ -2,44 +2,35 @@
 
 from __future__ import annotations
 
-import asyncio
-
 from .scraper_rs import (
-    Document as _Document,
-    Element as _Element,
-    first as _first_sync,
-    prettify as _prettify_sync,
-    select as _select_sync,
-    select_first as _select_first_sync,
-    xpath as _xpath_sync,
-    xpath_first as _xpath_first_sync,
+    _AsyncDocumentCore,
+    _AsyncElementCore,
+    first_async as _first_async,
+    parse_async as _parse_async,
+    prettify_async as _prettify_async,
+    select_async as _select_async,
+    select_first_async as _select_first_async,
+    xpath_async as _xpath_async,
+    xpath_first_async as _xpath_first_async,
 )
 
 
-def _wrap_element(element: _Element | None) -> "AsyncElement | None":
+def _wrap_element(element: _AsyncElementCore | None) -> "AsyncElement | None":
     if element is None:
         return None
     return AsyncElement(element)
 
 
-def _wrap_elements(elements: list[_Element]) -> list["AsyncElement"]:
+def _wrap_elements(elements: list[_AsyncElementCore]) -> list["AsyncElement"]:
     return [AsyncElement(element) for element in elements]
 
 
-def _parse_state(html: str, kwargs: dict[str, int | bool | None]) -> tuple[str, str]:
-    document = _Document(html, **kwargs)
-    try:
-        return document.html, document.text
-    finally:
-        document.close()
-
-
 class AsyncElement:
     """Async wrapper for immutable element snapshots."""
 
     __slots__ = ("_element",)
 
-    def __init__(self, element: _Element) -> None:
+    def __init__(self, element: _AsyncElementCore) -> None:
         self._element = element
 
     @property
@@ -65,32 +56,25 @@ class AsyncElement:
         return self._element.get(name, default)
 
     async def select(self, css: str) -> list["AsyncElement"]:
-        await asyncio.sleep(0)
-        return _wrap_elements(self._element.select(css))
+        return _wrap_elements(await self._element.select(css))
 
     async def select_first(self, css: str) -> "AsyncElement | None":
-        await asyncio.sleep(0)
-        return _wrap_element(self._element.select_first(css))
+        return _wrap_element(await self._element.select_first(css))
 
     async def find(self, css: str) -> "AsyncElement | None":
-        await asyncio.sleep(0)
-        return _wrap_element(self._element.find(css))
+        return _wrap_element(await self._element.find(css))
 
     async def css(self, css: str) -> list["AsyncElement"]:
-        await asyncio.sleep(0)
-        return _wrap_elements(self._element.css(css))
+        return _wrap_elements(await self._element.css(css))
 
     async def xpath(self, expr: str) -> list["AsyncElement"]:
-        await asyncio.sleep(0)
-        return _wrap_elements(self._element.xpath(expr))
+        return _wrap_elements(await self._element.xpath(expr))
 
     async def xpath_first(self, expr: str) -> "AsyncElement | None":
-        await asyncio.sleep(0)
-        return _wrap_element(self._element.xpath_first(expr))
+        return _wrap_element(await self._element.xpath_first(expr))
 
     async def prettify(self) -> str:
-        await asyncio.sleep(0)
-        return self._element.prettify()
+        return await self._element.prettify()
 
     def to_dict(self) -> dict[str, str | dict[str, str]]:
         return self._element.to_dict()
@@ -100,59 +84,44 @@ class AsyncElement:
 
 
 class AsyncDocument:
-    """Async wrapper that stores only shareable document state."""
+    """Async wrapper around Rust-owned document state."""
 
-    __slots__ = ("_html", "_text", "_closed")
+    __slots__ = ("_document",)
 
-    def __init__(self, html: str, text: str) -> None:
-        self._html = html
-        self._text = text
-        self._closed = False
+    def __init__(self, document: _AsyncDocumentCore) -> None:
+        self._document = document
 
     @property
     def html(self) -> str:
-        return "" if self._closed else self._html
+        return self._document.html
 
     @property
     def text(self) -> str:
-        return "" if self._closed else self._text
+        return self._document.text
 
     async def select(self, css: str) -> list[AsyncElement]:
-        if self._closed:
-            return []
-        return await select(self._html, css)
+        return _wrap_elements(await self._document.select(css))
 
     async def select_first(self, css: str) -> AsyncElement | None:
-        if self._closed:
-            return None
-        return await select_first(self._html, css)
+        return _wrap_element(await self._document.select_first(css))
 
     async def find(self, css: str) -> AsyncElement | None:
-        return await self.select_first(css)
+        return _wrap_element(await self._document.find(css))
 
     async def css(self, css: str) -> list[AsyncElement]:
-        return await self.select(css)
+        return _wrap_elements(await self._document.css(css))
 
     async def xpath(self, expr: str) -> list[AsyncElement]:
-        if self._closed:
-            return []
-        return await xpath(self._html, expr)
+        return _wrap_elements(await self._document.xpath(expr))
 
     async def xpath_first(self, expr: str) -> AsyncElement | None:
-        if self._closed:
-            return None
-        return await xpath_first(self._html, expr)
+        return _wrap_element(await self._document.xpath_first(expr))
 
     async def prettify(self) -> str:
-        if self._closed:
-            return ""
-        await asyncio.sleep(0)
-        return _prettify_sync(self._html)
+        return await self._document.prettify()
 
     def close(self) -> None:
-        self._closed = True
-        self._html = ""
-        self._text = ""
+        self._document.close()
 
     def __enter__(self) -> "AsyncDocument":
         return self
@@ -167,43 +136,35 @@ class AsyncDocument:
         self.close()
 
     def __repr__(self) -> str:
-        return f"<AsyncDocument len_html={len(self.html)}>"
+        return repr(self._document)
 
 
 async def parse(html: str, **kwargs) -> "AsyncDocument":
-    await asyncio.sleep(0)
-    parsed_html, text = _parse_state(html, kwargs)
-    return AsyncDocument(parsed_html, text)
+    return AsyncDocument(await _parse_async(html, **kwargs))
 
 
 async def select(html: str, css: str, **kwargs) -> list["AsyncElement"]:
-    await asyncio.sleep(0)
-    return _wrap_elements(_select_sync(html, css, **kwargs))
+    return _wrap_elements(await _select_async(html, css, **kwargs))
 
 
 async def select_first(html: str, css: str, **kwargs) -> "AsyncElement | None":
-    await asyncio.sleep(0)
-    return _wrap_element(_select_first_sync(html, css, **kwargs))
+    return _wrap_element(await _select_first_async(html, css, **kwargs))
 
 
 async def first(html: str, css: str, **kwargs) -> "AsyncElement | None":
-    await asyncio.sleep(0)
-    return _wrap_element(_first_sync(html, css, **kwargs))
+    return _wrap_element(await _first_async(html, css, **kwargs))
 
 
 async def xpath(html: str, expr: str, **kwargs) -> list["AsyncElement"]:
-    await asyncio.sleep(0)
-    return _wrap_elements(_xpath_sync(html, expr, **kwargs))
+    return _wrap_elements(await _xpath_async(html, expr, **kwargs))
 
 
 async def xpath_first(html: str, expr: str, **kwargs) -> "AsyncElement | None":
-    await asyncio.sleep(0)
-    return _wrap_element(_xpath_first_sync(html, expr, **kwargs))
+    return _wrap_element(await _xpath_first_async(html, expr, **kwargs))
 
 
 async def prettify(html: str, **kwargs) -> str:
-    await asyncio.sleep(0)
-    return _prettify_sync(html, **kwargs)
+    return await _prettify_async(html, **kwargs)
 
 
 __all__ = [

{scraper_rust-0.5.0 → scraper_rust-0.5.1}/src/runtime.rs

@@ -21,7 +21,12 @@ where
     F: FnOnce() -> PyResult<T> + Send + 'static,
     T: Send + 'static,
 {
-    tokio::task::spawn_blocking(work)
+    let (sender, receiver) = tokio::sync::oneshot::channel();
+    rayon::spawn(move || {
+        let _ = sender.send(work());
+    });
+
+    receiver
         .await
         .map_err(|e| PyValueError::new_err(format!("Task join error: {e}")))?
 }

{scraper_rust-0.5.0 → scraper_rust-0.5.1}/uv.lock

@@ -151,7 +151,7 @@ wheels = [
 
 [[package]]
 name = "scraper-rust"
-version = "0.5.0"
+version = "0.5.1"
 source = { editable = "." }
 
 [package.optional-dependencies]