asanypath-native 2.1.1__tar.gz → 2.3.0__tar.gz

{asanypath_native-2.1.1 → asanypath_native-2.3.0}/Cargo.lock

@@ -96,7 +96,7 @@ dependencies = [
 
 [[package]]
 name = "asanypath-native"
-version = "2.1.1"
+version = "2.3.0"
 dependencies = [
  "anyhow",
  "aws-config",
@@ -114,6 +114,7 @@ dependencies = [
  "quick-xml",
  "reqwest",
  "ring",
+ "rusqlite",
  "russh",
  "russh-sftp",
  "scraper",
@@ -122,6 +123,7 @@ dependencies = [
  "sonic-rs",
  "ssh2-config",
  "tokio",
+ "tokio-util",
  "url",
  "urlencoding",
 ]
@@ -1196,6 +1198,18 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "fallible-iterator"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
+
+[[package]]
+name = "fallible-streaming-iterator"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
+
 [[package]]
 name = "fastrand"
 version = "2.5.0"
@@ -1253,6 +1267,12 @@ version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
+[[package]]
+name = "foldhash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+
 [[package]]
 name = "form_urlencoded"
 version = "1.2.2"
@@ -1492,11 +1512,32 @@ version = "0.14.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
 
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+dependencies = [
+ "foldhash",
+]
+
 [[package]]
 name = "hashbrown"
 version = "0.17.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
+dependencies = [
+ "foldhash",
+]
+
+[[package]]
+name = "hashlink"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a596f1b20ed2cc5ecac41a164aaebc7258057060f06c0cf7a2ba3991ee7990fb"
+dependencies = [
+ "hashbrown 0.17.1",
+]
 
 [[package]]
 name = "heck"
@@ -1894,6 +1935,17 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "libsqlite3-sys"
+version = "0.38.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1d20bef17f513b9b3004532233187769cd072d790971f4e4da0e346eb6401e8"
+dependencies = [
+ "cc",
+ "pkg-config",
+ "vcpkg",
+]
+
 [[package]]
 name = "litemap"
 version = "0.8.3"
@@ -2694,6 +2746,7 @@ dependencies = [
  "base64 0.22.1",
  "bytes",
  "futures-core",
+ "futures-util",
  "h2",
  "http 1.5.0",
  "http-body 1.1.0",
@@ -2714,12 +2767,14 @@ dependencies = [
  "sync_wrapper",
  "tokio",
  "tokio-rustls",
+ "tokio-util",
  "tower",
  "tower-http",
  "tower-service",
  "url",
  "wasm-bindgen",
  "wasm-bindgen-futures",
+ "wasm-streams",
  "web-sys",
  "webpki-roots",
 ]
@@ -2796,6 +2851,31 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "rsqlite-vfs"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c51c9ae4df8a7fba42103df5c621fa3c37eccf3a3c650879e90fc48b11cc192c"
+dependencies = [
+ "hashbrown 0.16.1",
+ "thiserror",
+]
+
+[[package]]
+name = "rusqlite"
+version = "0.40.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23f2a97da3e3873c73cb2a2e71b35c40ff95e0b1eefa8d72d8499a6928c3b5b3"
+dependencies = [
+ "bitflags",
+ "fallible-iterator",
+ "fallible-streaming-iterator",
+ "hashlink",
+ "libsqlite3-sys",
+ "smallvec",
+ "sqlite-wasm-rs",
+]
+
 [[package]]
 name = "russh"
 version = "0.63.3"
@@ -3359,6 +3439,18 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3a0219bd7d979d58245a4f41f695e1ac9f8befdffadd7f61f1bae9e39abc6620"
 
+[[package]]
+name = "sqlite-wasm-rs"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc3efc0da82635d7e1ced0053bbbfa8c7ab9645d0bf36ceb4f7127bb85315d75"
+dependencies = [
+ "cc",
+ "js-sys",
+ "rsqlite-vfs",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "ssh-cipher"
 version = "0.3.0"
@@ -3793,6 +3885,12 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
 [[package]]
 name = "version_check"
 version = "0.9.5"
@@ -3884,6 +3982,19 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "wasm-streams"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15053d8d85c7eccdbefef60f06769760a563c7f0a9d6902a13d35c7800b0ad65"
+dependencies = [
+ "futures-util",
+ "js-sys",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
 [[package]]
 name = "web-sys"
 version = "0.3.105"

{asanypath_native-2.1.1 → asanypath_native-2.3.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "asanypath-native"
-version = "2.1.1"
+version = "2.3.0"
 edition = "2024"
 license = "MIT"
 publish = false
@@ -12,9 +12,9 @@ crate-type = ["cdylib"]
 [dependencies]
 pyo3 = { version = "0.29", features = ["extension-module"] }
 pyo3-async-runtimes = { version = "0.29", features = ["tokio-runtime"] }
-tokio = { version = "1", features = ["rt-multi-thread", "macros"] }
+tokio = { version = "1", features = ["rt-multi-thread", "macros", "fs"] }
 aws-config = { version = "1", features = ["behavior-version-latest"] }
-reqwest = { version = "0.12", default-features = false, features = ["rustls-tls", "http2"] }
+reqwest = { version = "0.12", default-features = false, features = ["rustls-tls", "http2", "stream"] }
 futures = "0.3"
 aws-sigv4 = "1"
 aws-credential-types = { version = "1", features = ["hardcoded-credentials"] }
@@ -34,8 +34,10 @@ scraper = { version = "0.27", default-features = false }
 url = "2"
 russh = "0.63"
 russh-sftp = "3"
+tokio-util = { version = "0.7", features = ["io"] }
 anyhow = "1"
 ssh2-config = { version = "0.8", default-features = false, features = ["nolog"] }
+rusqlite = { version = "0.40", features = ["bundled"] }
 
 [profile.release]
 strip = "symbols"

{asanypath_native-2.1.1 → asanypath_native-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: asanypath-native
-Version: 2.1.1
+Version: 2.3.0
 Summary: Native cloud acceleration for asanypath (Rust/tokio/reqwest)
 License-Expression: MIT
 Requires-Python: >=3.10

{asanypath_native-2.1.1 → asanypath_native-2.3.0}/asanypath_native.pyi

@@ -8,9 +8,23 @@
 
 from typing import Any
 
+class DownloadCache:
+    def __init__(self, directory: str, size_limit: int) -> None: ...
+    @property
+    def size_limit(self) -> int: ...
+    def get(self, key: str) -> bytes | None: ...
+    def set(self, key: str, value: bytes, expire: float | None = None) -> None: ...
+    def delete(self, key: str) -> None: ...
+    def clear(self) -> None: ...
+    def close(self) -> None: ...
+
 # -- S3 --
 async def s3_get_batch(*args: Any, **kwargs: Any) -> Any: ...
 async def s3_put_batch(*args: Any, **kwargs: Any) -> Any: ...
+async def s3_create_multipart(*args: Any, **kwargs: Any) -> Any: ...
+async def s3_upload_part(*args: Any, **kwargs: Any) -> Any: ...
+async def s3_complete_multipart(*args: Any, **kwargs: Any) -> Any: ...
+async def s3_abort_multipart(*args: Any, **kwargs: Any) -> Any: ...
 async def s3_copy_batch(*args: Any, **kwargs: Any) -> Any: ...
 async def s3_delete_batch(*args: Any, **kwargs: Any) -> Any: ...
 async def s3_exists_batch(*args: Any, **kwargs: Any) -> Any: ...
@@ -26,6 +40,7 @@ async def s3_get_credentials(
     access_key: str | None,
     secret_key: str | None,
     session_token: str | None,
+    profile: str | None = None,
 ) -> tuple[str, str, str | None, str, str | None]: ...
 def s3_presign(
     endpoint: str,
@@ -42,6 +57,8 @@ def s3_presign(
 # -- GCS --
 async def gcs_get_batch(*args: Any, **kwargs: Any) -> Any: ...
 async def gcs_put_batch(*args: Any, **kwargs: Any) -> Any: ...
+async def gcs_start_resumable(*args: Any, **kwargs: Any) -> Any: ...
+async def gcs_upload_chunk(*args: Any, **kwargs: Any) -> Any: ...
 async def gcs_copy_batch(*args: Any, **kwargs: Any) -> Any: ...
 async def gcs_delete_batch(*args: Any, **kwargs: Any) -> Any: ...
 async def gcs_exists_batch(*args: Any, **kwargs: Any) -> Any: ...
@@ -62,6 +79,8 @@ def gcs_presign(
 # -- Azure --
 async def az_get_batch(*args: Any, **kwargs: Any) -> Any: ...
 async def az_put_batch(*args: Any, **kwargs: Any) -> Any: ...
+async def az_put_block(*args: Any, **kwargs: Any) -> Any: ...
+async def az_put_block_list(*args: Any, **kwargs: Any) -> Any: ...
 async def az_copy_batch(*args: Any, **kwargs: Any) -> Any: ...
 async def az_delete_batch(*args: Any, **kwargs: Any) -> Any: ...
 async def az_exists_batch(*args: Any, **kwargs: Any) -> Any: ...
@@ -84,6 +103,7 @@ def az_presign(
 # -- Artifactory --
 async def art_get_batch(*args: Any, **kwargs: Any) -> Any: ...
 async def art_put_batch(*args: Any, **kwargs: Any) -> Any: ...
+async def art_put_stream(*args: Any, **kwargs: Any) -> Any: ...
 async def art_copy_batch(*args: Any, **kwargs: Any) -> Any: ...
 async def art_delete_batch(*args: Any, **kwargs: Any) -> Any: ...
 async def art_exists_batch(*args: Any, **kwargs: Any) -> Any: ...
@@ -110,6 +130,7 @@ async def range_read(path: str, start: int, end: int, **kwargs: Any) -> bytes: .
 async def ssh_read(*args: Any, **kwargs: Any) -> bytes: ...
 async def ssh_read_range(*args: Any, **kwargs: Any) -> bytes: ...
 async def ssh_write(*args: Any, **kwargs: Any) -> int: ...
+async def ssh_write_chunk(*args: Any, **kwargs: Any) -> int: ...
 async def ssh_exists(*args: Any, **kwargs: Any) -> bool: ...
 async def ssh_stat(*args: Any, **kwargs: Any) -> Any: ...
 async def ssh_lstat(*args: Any, **kwargs: Any) -> Any: ...

{asanypath_native-2.1.1 → asanypath_native-2.3.0}/src/artifactory.rs

@@ -19,7 +19,7 @@ use pyo3::prelude::*;
 use serde::Deserialize;
 use std::collections::HashMap;
 
-use crate::http::{bearer_headers, do_request_light, status_to_pyerr};
+use crate::http::{bearer_headers, do_request_light, do_request_stream_file, status_to_pyerr};
 
 // ---------------------------------------------------------------------------
 // JSON response types for Artifactory Storage API
@@ -465,6 +465,44 @@ pub fn art_put_batch<'py>(
     })
 }
 
+/// Stream-upload a single file by PUT (body framed from disk; bounded memory).
+/// Artifactory has no multipart API, so a large object is sent as one streamed PUT.
+#[pyfunction]
+#[pyo3(signature = (base_url, key, file_path, size, token, options_json=None, use_h2=None))]
+pub fn art_put_stream<'py>(
+    py: Python<'py>,
+    base_url: String,
+    key: String,
+    file_path: String,
+    size: u64,
+    token: String,
+    options_json: Option<String>,
+    use_h2: Option<bool>,
+) -> PyResult<Bound<'py, PyAny>> {
+    let h2 = use_h2.unwrap_or(false);
+    pyo3_async_runtimes::tokio::future_into_py(py, async move {
+        let options: crate::backend::UploadOptions =
+            sonic_rs::from_str(&options_json.unwrap_or_else(|| "{}".to_string()))
+                .map_err(|e| PyValueError::new_err(format!("invalid backend_options: {e}")))?;
+        crate::backend::require_empty_provider(&options)?;
+        let creds = art_creds!(base_url, token);
+        let url = crate::backend::append_query(&creds.content_url(&key), &options.query);
+        let mut headers = creds.auth_headers();
+        headers.push((
+            "content-type".to_string(),
+            "application/octet-stream".to_string(),
+        ));
+        crate::backend::merge_user_headers(&mut headers, &options)?;
+        let (status, body) = do_request_stream_file("PUT", &url, &headers, &file_path, size, h2)
+            .await
+            .map_err(PyRuntimeError::new_err)?;
+        if !status.is_success() {
+            return Err(status_to_pyerr(status, &creds.error_path(&key), &body));
+        }
+        Ok(())
+    })
+}
+
 /// Copy multiple files concurrently (server-side). Pairs are `(src, dst)`.
 #[pyfunction]
 pub fn art_copy_batch<'py>(

{asanypath_native-2.1.1 → asanypath_native-2.3.0}/src/azure.rs

@@ -943,6 +943,97 @@ pub fn az_put_batch<'py>(
     })
 }
 
+// ---------------------------------------------------------------------------
+// Block blob upload (orchestrated from Python): stage blocks, then commit list
+// ---------------------------------------------------------------------------
+
+/// Stage one block for a block blob. `block_id` is the raw (pre-URL-encode) id.
+#[pyfunction]
+#[pyo3(signature = (endpoint, container, blob, block_id, data, account_name, account_key=None, sas_token=None, use_h2=None))]
+pub fn az_put_block<'py>(
+    py: Python<'py>,
+    endpoint: String,
+    container: String,
+    blob: String,
+    block_id: String,
+    data: Vec<u8>,
+    account_name: String,
+    account_key: Option<String>,
+    sas_token: Option<String>,
+    use_h2: Option<bool>,
+) -> PyResult<Bound<'py, PyAny>> {
+    let h2 = use_h2.unwrap_or(false);
+    pyo3_async_runtimes::tokio::future_into_py(py, async move {
+        let creds = az_creds!(endpoint, container, account_name, account_key, sas_token);
+        let base = creds.blob_url(&blob);
+        let sep = if base.contains('?') { "&" } else { "?" };
+        let url = format!(
+            "{}{}comp=block&blockid={}",
+            base,
+            sep,
+            urlencoding::encode(&block_id)
+        );
+        let mut headers = vec![("content-length".to_string(), data.len().to_string())];
+        let params = [("blockid", block_id.as_str()), ("comp", "block")];
+        creds.sign("PUT", &url, &mut headers, Some(&params));
+        let (status, body) = do_request_light("PUT", &url, &headers, Some(Bytes::from(data)), h2)
+            .await
+            .map_err(PyRuntimeError::new_err)?;
+        if !status.is_success() {
+            return Err(status_to_pyerr(status, &creds.error_path(&blob), &body));
+        }
+        Ok(())
+    })
+}
+
+/// Commit a block blob from the staged block ids (in order).
+#[pyfunction]
+#[pyo3(signature = (endpoint, container, blob, block_ids, account_name, account_key=None, sas_token=None, options_json=None, use_h2=None))]
+pub fn az_put_block_list<'py>(
+    py: Python<'py>,
+    endpoint: String,
+    container: String,
+    blob: String,
+    block_ids: Vec<String>,
+    account_name: String,
+    account_key: Option<String>,
+    sas_token: Option<String>,
+    options_json: Option<String>,
+    use_h2: Option<bool>,
+) -> PyResult<Bound<'py, PyAny>> {
+    let h2 = use_h2.unwrap_or(false);
+    pyo3_async_runtimes::tokio::future_into_py(py, async move {
+        let options: crate::backend::UploadOptions =
+            sonic_rs::from_str(&options_json.unwrap_or_else(|| "{}".to_string()))
+                .map_err(|e| PyValueError::new_err(format!("invalid backend_options: {e}")))?;
+        crate::backend::require_empty_provider(&options)?;
+        let creds = az_creds!(endpoint, container, account_name, account_key, sas_token);
+        let base = creds.blob_url(&blob);
+        let sep = if base.contains('?') { "&" } else { "?" };
+        let url = format!("{}{}comp=blocklist", base, sep);
+        let mut xml = String::from("<?xml version=\"1.0\" encoding=\"utf-8\"?><BlockList>");
+        for id in &block_ids {
+            xml.push_str(&format!("<Latest>{}</Latest>", id));
+        }
+        xml.push_str("</BlockList>");
+        let body = Bytes::from(xml.into_bytes());
+        let mut headers = vec![
+            ("content-length".to_string(), body.len().to_string()),
+            ("content-type".to_string(), "application/xml".to_string()),
+        ];
+        crate::backend::merge_user_headers(&mut headers, &options)?;
+        let params = [("comp", "blocklist")];
+        creds.sign("PUT", &url, &mut headers, Some(&params));
+        let (status, resp) = do_request_light("PUT", &url, &headers, Some(body), h2)
+            .await
+            .map_err(PyRuntimeError::new_err)?;
+        if !status.is_success() {
+            return Err(status_to_pyerr(status, &creds.error_path(&blob), &resp));
+        }
+        Ok(())
+    })
+}
+
 #[pyfunction]
 pub fn az_copy_batch<'py>(
     py: Python<'py>,

{asanypath_native-2.1.1 → asanypath_native-2.3.0}/src/backend.rs

@@ -170,11 +170,14 @@ pub trait CloudBackend {
         start: u64,
         end: u64,
         use_h2: bool,
+        conditions: &[(String, String)],
     ) -> impl std::future::Future<Output = Result<PyBytesBuf, PyErr>> {
         async move {
-            let range_header = ("range".to_string(), format!("bytes={}-{}", start, end));
+            let mut headers = conditions.to_vec();
+            headers.push(("range".to_string(), format!("bytes={}-{}", start, end)));
+            headers.push(("accept-encoding".to_string(), "identity".to_string()));
             let (status, body) = self
-                .do_request("GET", path, None, use_h2, &[range_header])
+                .do_request("GET", path, None, use_h2, &headers)
                 .await
                 .map_err(|e| PyRuntimeError::new_err(e))?;
             // A range entirely past end-of-object yields 416; treat as empty (EOF)
@@ -185,6 +188,11 @@ pub trait CloudBackend {
             if !status.is_success() {
                 return Err(status_to_pyerr(status, &self.error_path(path), &body));
             }
+            if status.as_u16() != 206 {
+                return Err(pyo3::exceptions::PyOSError::new_err(
+                    "Server ignored range request",
+                ));
+            }
             Ok(PyBytesBuf(body))
         }
     }
@@ -363,9 +371,11 @@ macro_rules! batch_copy {
 /// Usage: `range_read_impl!(py, creds, path, start, end)`
 #[macro_export]
 macro_rules! range_read_impl {
-    ($py:expr, $creds:expr, $path:expr, $start:expr, $end:expr) => {
+    ($py:expr, $creds:expr, $path:expr, $start:expr, $end:expr, $conditions:expr) => {
         pyo3_async_runtimes::tokio::future_into_py($py, async move {
-            $creds.range_get(&$path, $start, $end, false).await
+            $creds
+                .range_get(&$path, $start, $end, false, &$conditions)
+                .await
         })
     };
 }
@@ -387,7 +397,8 @@ use pyo3::prelude::*;
 #[pyo3(signature = (path, start, end, endpoint=None, bucket=None, region=None,
     access_key=None, secret_key=None, session_token=None,
     container=None, account_name=None, account_key=None, sas_token=None,
-    access_token=None, base_url=None, token=None))]
+    access_token=None, base_url=None, token=None,
+    if_match=None, if_unmodified_since=None, if_generation_match=None))]
 pub fn range_read<'py>(
     py: Python<'py>,
     path: String,
@@ -411,7 +422,20 @@ pub fn range_read<'py>(
     // Artifactory
     base_url: Option<String>,
     token: Option<String>,
+    if_match: Option<String>,
+    if_unmodified_since: Option<String>,
+    if_generation_match: Option<String>,
 ) -> PyResult<Bound<'py, PyAny>> {
+    let mut conditions = Vec::new();
+    if let Some(value) = if_match {
+        conditions.push(("if-match".to_string(), value));
+    }
+    if let Some(value) = if_unmodified_since {
+        conditions.push(("if-unmodified-since".to_string(), value));
+    }
+    if let Some(value) = if_generation_match {
+        conditions.push(("x-asanypath-generation-match".to_string(), value));
+    }
     if let Some(region) = region {
         // S3
         let creds = crate::s3::S3Creds {
@@ -422,7 +446,7 @@ pub fn range_read<'py>(
             secret_key: secret_key.unwrap_or_default(),
             session_token,
         };
-        range_read_impl!(py, creds, path, start, end)
+        range_read_impl!(py, creds, path, start, end, conditions)
     } else if let Some(container) = container {
         // Azure
         use crate::azure::AzCreds;
@@ -433,12 +457,12 @@ pub fn range_read<'py>(
             account_key,
             sas_token,
         );
-        range_read_impl!(py, creds, path, start, end)
+        range_read_impl!(py, creds, path, start, end, conditions)
     } else if let Some(base_url) = base_url {
         // Artifactory
         use crate::artifactory::ArtCreds;
         let creds = ArtCreds::new(base_url, token.unwrap_or_default());
-        range_read_impl!(py, creds, path, start, end)
+        range_read_impl!(py, creds, path, start, end, conditions)
     } else {
         // GCS
         use crate::gcs::GcsCreds;
@@ -447,6 +471,6 @@ pub fn range_read<'py>(
             bucket.unwrap_or_default(),
             access_token,
         );
-        range_read_impl!(py, creds, path, start, end)
+        range_read_impl!(py, creds, path, start, end, conditions)
     }
 }

asanypath_native-2.3.0/src/cache.rs

@@ -0,0 +1,198 @@
+// Copyright (C) 2026 Axis Communications AB, Lund, Sweden
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+use std::path::PathBuf;
+use std::sync::Mutex;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+use pyo3::exceptions::{PyOSError, PyRuntimeError, PyValueError};
+use pyo3::prelude::*;
+use pyo3::types::PyBytes;
+use rusqlite::{Connection, OptionalExtension, TransactionBehavior, params};
+
+fn database_error(error: rusqlite::Error) -> PyErr {
+    PyOSError::new_err(format!("Download cache database: {error}"))
+}
+
+fn now() -> PyResult<f64> {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|time| time.as_secs_f64())
+        .map_err(|error| PyRuntimeError::new_err(error.to_string()))
+}
+
+/// Persistent byte-only cache shared through SQLite transactions.
+#[pyclass]
+pub struct DownloadCache {
+    connection: Mutex<Option<Connection>>,
+    #[pyo3(get)]
+    size_limit: i64,
+}
+
+impl DownloadCache {
+    fn with_connection<T>(
+        &self,
+        operation: impl FnOnce(&mut Connection) -> rusqlite::Result<T>,
+    ) -> PyResult<T> {
+        let mut guard = self
+            .connection
+            .lock()
+            .map_err(|_| PyRuntimeError::new_err("Download cache lock poisoned"))?;
+        let connection = guard
+            .as_mut()
+            .ok_or_else(|| PyValueError::new_err("Download cache is closed"))?;
+        operation(connection).map_err(database_error)
+    }
+}
+
+#[pymethods]
+impl DownloadCache {
+    #[new]
+    fn new(py: Python<'_>, directory: PathBuf, size_limit: i64) -> PyResult<Self> {
+        if size_limit <= 0 {
+            return Err(PyValueError::new_err("size_limit must be positive"));
+        }
+        py.detach(|| {
+            // Never open or migrate a legacy DiskCache database.
+            let directory = directory.join("native-v1");
+            std::fs::create_dir_all(&directory).map_err(|error| {
+                PyOSError::new_err(format!("Create download cache directory: {error}"))
+            })?;
+            let connection =
+                Connection::open(directory.join("cache.sqlite3")).map_err(database_error)?;
+            connection
+                .busy_timeout(Duration::from_secs(60))
+                .map_err(database_error)?;
+            connection
+                .execute_batch(
+                    "PRAGMA trusted_schema = OFF;
+                     PRAGMA auto_vacuum = FULL;
+                     PRAGMA journal_mode = TRUNCATE;
+                     CREATE TABLE IF NOT EXISTS entries (
+                         key TEXT PRIMARY KEY NOT NULL,
+                         value BLOB NOT NULL CHECK(typeof(value) = 'blob'),
+                         expires REAL,
+                         accessed INTEGER NOT NULL
+                     );
+                     CREATE INDEX IF NOT EXISTS entries_lru ON entries(accessed);",
+                )
+                .map_err(database_error)?;
+            Ok(Self {
+                connection: Mutex::new(Some(connection)),
+                size_limit,
+            })
+        })
+    }
+
+    fn get(&self, py: Python<'_>, key: String) -> PyResult<Option<Py<PyBytes>>> {
+        let timestamp = now()?;
+        let value: Option<Vec<u8>> = py.detach(|| {
+            self.with_connection(|connection| {
+                let transaction =
+                    connection.transaction_with_behavior(TransactionBehavior::Immediate)?;
+                transaction.execute(
+                    "DELETE FROM entries WHERE key = ?1 AND expires <= ?2",
+                    params![key, timestamp],
+                )?;
+                let value = transaction
+                    .query_row("SELECT value FROM entries WHERE key = ?1", [&key], |row| {
+                        row.get(0)
+                    })
+                    .optional()?;
+                if value.is_some() {
+                    transaction.execute(
+                        "UPDATE entries SET accessed =
+                         (SELECT COALESCE(MAX(accessed), 0) + 1 FROM entries) WHERE key = ?1",
+                        [&key],
+                    )?;
+                }
+                transaction.commit()?;
+                Ok(value)
+            })
+        })?;
+        Ok(value.map(|value| PyBytes::new(py, &value).unbind()))
+    }
+
+    #[pyo3(signature = (key, value, expire=None))]
+    fn set(
+        &self,
+        py: Python<'_>,
+        key: String,
+        value: Vec<u8>,
+        expire: Option<f64>,
+    ) -> PyResult<()> {
+        let timestamp = now()?;
+        if let Some(ttl) = expire
+            && (!ttl.is_finite() || !(timestamp + ttl).is_finite())
+        {
+            return Err(PyValueError::new_err("ttl must be finite"));
+        }
+        py.detach(|| {
+            self.with_connection(|connection| {
+                let transaction =
+                    connection.transaction_with_behavior(TransactionBehavior::Immediate)?;
+                transaction.execute(
+                    "DELETE FROM entries WHERE key = ?1 OR expires <= ?2",
+                    params![key, timestamp],
+                )?;
+                let size = key.len().saturating_add(value.len()) as u64;
+                // Oversized objects are returned to the caller but never retained.
+                if size <= self.size_limit as u64 && expire.is_none_or(|ttl| ttl > 0.0) {
+                    transaction.execute(
+                        "DELETE FROM entries WHERE key IN (
+                             SELECT key FROM (
+                                 SELECT key, SUM(length(CAST(key AS BLOB)) + length(value))
+                                     OVER (ORDER BY accessed DESC ROWS UNBOUNDED PRECEDING) AS used
+                                 FROM entries
+                             ) WHERE used > ?1
+                         )",
+                        [self.size_limit - size as i64],
+                    )?;
+                    transaction.execute(
+                        "INSERT INTO entries(key, value, expires, accessed)
+                         VALUES (?1, ?2, ?3, (SELECT COALESCE(MAX(accessed), 0) + 1 FROM entries))",
+                        params![key, value, expire.map(|ttl| timestamp + ttl)],
+                    )?;
+                }
+                transaction.commit()
+            })
+        })
+    }
+
+    fn delete(&self, py: Python<'_>, key: String) -> PyResult<()> {
+        py.detach(|| {
+            self.with_connection(|connection| {
+                connection.execute("DELETE FROM entries WHERE key = ?1", [key])?;
+                Ok(())
+            })
+        })
+    }
+
+    fn clear(&self, py: Python<'_>) -> PyResult<()> {
+        py.detach(|| {
+            self.with_connection(|connection| {
+                connection.execute("DELETE FROM entries", [])?;
+                Ok(())
+            })
+        })
+    }
+
+    fn close(&self, py: Python<'_>) -> PyResult<()> {
+        py.detach(|| {
+            let mut guard = self
+                .connection
+                .lock()
+                .map_err(|_| PyRuntimeError::new_err("Download cache lock poisoned"))?;
+            if let Some(connection) = guard.take() {
+                connection.close().map_err(|(connection, error)| {
+                    *guard = Some(connection);
+                    database_error(error)
+                })?;
+            }
+            Ok(())
+        })
+    }
+}

{asanypath_native-2.1.1 → asanypath_native-2.3.0}/src/gcs.rs

@@ -24,7 +24,7 @@ use std::collections::{HashMap, HashSet};
 use std::sync::{Mutex, OnceLock};
 use std::time::{Duration, Instant};
 
-use crate::http::{bearer_headers, do_request_light, status_to_pyerr};
+use crate::http::{bearer_headers, do_request, do_request_light, status_to_pyerr};
 
 // ---------------------------------------------------------------------------
 // Typed JSON response structs (avoids Value allocations)
@@ -155,6 +155,14 @@ impl GcsCreds {
         format!("{}/storage/v1/b/{}/o/{}", base, self.bucket, encoded)
     }
 
+    fn media_url(&self, object_path: &str, generation: Option<&str>) -> String {
+        let mut params = vec![("alt", "media")];
+        if let Some(generation) = generation {
+            params.push(("ifGenerationMatch", generation));
+        }
+        append_params(&self.object_url(object_path), &params)
+    }
+
     fn upload_base(&self) -> String {
         let base = self.endpoint.trim_end_matches('/');
         format!("{}/upload/storage/v1/b/{}/o", base, self.bucket)
@@ -343,13 +351,21 @@ impl CloudBackend for GcsCreds {
     ) -> impl std::future::Future<Output = Result<(reqwest::StatusCode, Bytes), String>> {
         let extras = extra_headers.to_vec();
         async move {
+            let generation = extras
+                .iter()
+                .find(|(name, _)| name == "x-asanypath-generation-match")
+                .map(|(_, value)| value.as_str());
             let url = match method {
-                "GET" => append_params(&self.object_url(path), &[("alt", "media")]),
+                "GET" => self.media_url(path, generation),
                 "DELETE" => self.object_url(path),
                 _ => self.object_url(path),
             };
             let mut headers = self.auth_headers().await;
-            headers.extend(extras);
+            headers.extend(
+                extras
+                    .into_iter()
+                    .filter(|(name, _)| name != "x-asanypath-generation-match"),
+            );
             do_request_light(method, &url, &headers, body, use_h2).await
         }
     }
@@ -930,6 +946,84 @@ pub fn gcs_put_batch<'py>(
     })
 }
 
+// ---------------------------------------------------------------------------
+// Resumable upload (orchestrated from Python): init a session, then PUT ranges
+// ---------------------------------------------------------------------------
+
+/// Begin a resumable upload session; returns the session URI (Location header).
+#[pyfunction]
+#[pyo3(signature = (endpoint, bucket, object, total, access_token=None, use_h2=None))]
+pub fn gcs_start_resumable<'py>(
+    py: Python<'py>,
+    endpoint: String,
+    bucket: String,
+    object: String,
+    total: u64,
+    access_token: Option<String>,
+    use_h2: Option<bool>,
+) -> PyResult<Bound<'py, PyAny>> {
+    let h2 = use_h2.unwrap_or(false);
+    pyo3_async_runtimes::tokio::future_into_py(py, async move {
+        let creds = gcs_creds!(endpoint, bucket, access_token);
+        let url = append_params(
+            &creds.upload_base(),
+            &[("uploadType", "resumable"), ("name", &object)],
+        );
+        let mut headers = creds.auth_headers().await;
+        headers.push(("content-length".to_string(), "0".to_string()));
+        headers.push((
+            "x-upload-content-type".to_string(),
+            "application/octet-stream".to_string(),
+        ));
+        headers.push(("x-upload-content-length".to_string(), total.to_string()));
+        let (status, body, resp_headers) = do_request("POST", &url, &headers, None, h2)
+            .await
+            .map_err(PyRuntimeError::new_err)?;
+        if !status.is_success() {
+            return Err(status_to_pyerr(status, &creds.error_path(&object), &body));
+        }
+        resp_headers
+            .get("location")
+            .cloned()
+            .ok_or_else(|| PyRuntimeError::new_err("GCS resumable init: no Location header"))
+    })
+}
+
+/// Upload one chunk to a resumable session. GCS completes when offset+len == total.
+#[pyfunction]
+#[pyo3(signature = (session_uri, data, offset, total, use_h2=None))]
+pub fn gcs_upload_chunk<'py>(
+    py: Python<'py>,
+    session_uri: String,
+    data: Vec<u8>,
+    offset: u64,
+    total: u64,
+    use_h2: Option<bool>,
+) -> PyResult<Bound<'py, PyAny>> {
+    let h2 = use_h2.unwrap_or(false);
+    pyo3_async_runtimes::tokio::future_into_py(py, async move {
+        let len = data.len() as u64;
+        let end = offset + len - 1;
+        let headers = vec![
+            ("content-length".to_string(), len.to_string()),
+            (
+                "content-range".to_string(),
+                format!("bytes {offset}-{end}/{total}"),
+            ),
+        ];
+        let (status, body, _h) =
+            do_request("PUT", &session_uri, &headers, Some(Bytes::from(data)), h2)
+                .await
+                .map_err(PyRuntimeError::new_err)?;
+        // 308 Resume Incomplete = intermediate chunk accepted; 2xx = final chunk done.
+        if status.as_u16() == 308 || status.is_success() {
+            Ok(())
+        } else {
+            Err(status_to_pyerr(status, "gs://resumable-chunk", &body))
+        }
+    })
+}
+
 /// Copy multiple objects concurrently (server-side). Pairs are `(src, dst)`.
 #[pyfunction]
 pub fn gcs_copy_batch<'py>(
@@ -1161,7 +1255,21 @@ fn secs_to_datetime(secs: u64) -> (i64, i64, i64, u64, u64, u64) {
 
 #[cfg(test)]
 mod adc_tests {
-    use super::mint_adc_token;
+    use super::{GcsCreds, mint_adc_token};
+
+    #[test]
+    fn range_media_url_pins_generation() {
+        let creds = GcsCreds::new(
+            "https://storage.googleapis.com".into(),
+            "bucket".into(),
+            None,
+        );
+        let url = url::Url::parse(&creds.media_url("nested/file.bin", Some("123"))).unwrap();
+        let query: std::collections::HashMap<_, _> = url.query_pairs().collect();
+        assert_eq!(query.get("alt").unwrap(), "media");
+        assert_eq!(query.get("ifGenerationMatch").unwrap(), "123");
+        assert!(url.path().ends_with("nested%2Ffile.bin"));
+    }
 
     #[test]
     fn rejects_service_account_adc() {

{asanypath_native-2.1.1 → asanypath_native-2.3.0}/src/http.rs

@@ -158,6 +158,46 @@ pub async fn do_request_light(
     .await
 }
 
+/// Stream a request body from a file (bounded memory). An explicit
+/// `content_length` frames the body with Content-Length instead of chunked
+/// encoding; retries reopen the file so a consumed stream can be replayed.
+pub async fn do_request_stream_file(
+    method: &str,
+    url: &str,
+    headers: &[(String, String)],
+    file_path: &str,
+    content_length: u64,
+    use_h2: bool,
+) -> Result<(StatusCode, Bytes), String> {
+    let method_parsed = method.parse::<Method>().map_err(|e| e.to_string())?;
+    let client = get_client(use_h2);
+    let headers = headers.to_vec();
+
+    (async || {
+        let file = tokio::fs::File::open(file_path)
+            .await
+            .map_err(|e| e.to_string())?;
+        let stream = tokio_util::io::ReaderStream::new(file);
+        let mut req = client.request(method_parsed.clone(), url);
+        for (k, v) in &headers {
+            req = req.header(k.as_str(), v.as_str());
+        }
+        req = req
+            .header("content-length", content_length.to_string())
+            .body(reqwest::Body::wrap_stream(stream));
+        let resp = req.send().await.map_err(|e| e.to_string())?;
+        let status = resp.status();
+        if is_retryable_status(status) {
+            return Err(format!("HTTP {} (retryable)", status.as_u16()));
+        }
+        let resp_body = resp.bytes().await.map_err(|e| e.to_string())?;
+        Ok((status, resp_body))
+    })
+    .retry(retry_backoff())
+    .when(|e: &String| is_retryable(e))
+    .await
+}
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------

{asanypath_native-2.1.1 → asanypath_native-2.3.0}/src/lib.rs

@@ -14,6 +14,7 @@ use pyo3::prelude::*;
 
 #[macro_use]
 pub mod backend;
+pub mod cache;
 pub mod http;
 pub mod xml;
 
@@ -29,6 +30,7 @@ pub mod ssh;
 
 #[pymodule]
 fn asanypath_native(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_class::<cache::DownloadCache>()?;
     // S3
     m.add_function(wrap_pyfunction!(s3::s3_is_dir, m)?)?;
     m.add_function(wrap_pyfunction!(s3::s3_get_acl, m)?)?;
@@ -40,6 +42,10 @@ fn asanypath_native(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(s3::s3_get_batch, m)?)?;
     m.add_function(wrap_pyfunction!(s3::s3_head_batch, m)?)?;
     m.add_function(wrap_pyfunction!(s3::s3_put_batch, m)?)?;
+    m.add_function(wrap_pyfunction!(s3::s3_create_multipart, m)?)?;
+    m.add_function(wrap_pyfunction!(s3::s3_upload_part, m)?)?;
+    m.add_function(wrap_pyfunction!(s3::s3_complete_multipart, m)?)?;
+    m.add_function(wrap_pyfunction!(s3::s3_abort_multipart, m)?)?;
     m.add_function(wrap_pyfunction!(s3::s3_delete_batch, m)?)?;
     m.add_function(wrap_pyfunction!(s3::s3_exists_batch, m)?)?;
     m.add_function(wrap_pyfunction!(s3::s3_is_dir_batch, m)?)?;
@@ -56,6 +62,8 @@ fn asanypath_native(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(gcs::gcs_get_batch, m)?)?;
     m.add_function(wrap_pyfunction!(gcs::gcs_head_batch, m)?)?;
     m.add_function(wrap_pyfunction!(gcs::gcs_put_batch, m)?)?;
+    m.add_function(wrap_pyfunction!(gcs::gcs_start_resumable, m)?)?;
+    m.add_function(wrap_pyfunction!(gcs::gcs_upload_chunk, m)?)?;
     m.add_function(wrap_pyfunction!(gcs::gcs_delete_batch, m)?)?;
     m.add_function(wrap_pyfunction!(gcs::gcs_exists_batch, m)?)?;
     m.add_function(wrap_pyfunction!(gcs::gcs_is_dir_batch, m)?)?;
@@ -71,6 +79,8 @@ fn asanypath_native(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(azure::az_get_batch, m)?)?;
     m.add_function(wrap_pyfunction!(azure::az_head_batch, m)?)?;
     m.add_function(wrap_pyfunction!(azure::az_put_batch, m)?)?;
+    m.add_function(wrap_pyfunction!(azure::az_put_block, m)?)?;
+    m.add_function(wrap_pyfunction!(azure::az_put_block_list, m)?)?;
     m.add_function(wrap_pyfunction!(azure::az_delete_batch, m)?)?;
     m.add_function(wrap_pyfunction!(azure::az_exists_batch, m)?)?;
     m.add_function(wrap_pyfunction!(azure::az_is_dir_batch, m)?)?;
@@ -83,6 +93,7 @@ fn asanypath_native(m: &Bound<'_, PyModule>) -> PyResult<()> {
     // Artifactory batch
     m.add_function(wrap_pyfunction!(artifactory::art_get_batch, m)?)?;
     m.add_function(wrap_pyfunction!(artifactory::art_put_batch, m)?)?;
+    m.add_function(wrap_pyfunction!(artifactory::art_put_stream, m)?)?;
     m.add_function(wrap_pyfunction!(artifactory::art_delete_batch, m)?)?;
     m.add_function(wrap_pyfunction!(artifactory::art_exists_batch, m)?)?;
     m.add_function(wrap_pyfunction!(artifactory::art_list_batch, m)?)?;
@@ -103,6 +114,7 @@ fn asanypath_native(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(ssh::ssh_read, m)?)?;
     m.add_function(wrap_pyfunction!(ssh::ssh_read_range, m)?)?;
     m.add_function(wrap_pyfunction!(ssh::ssh_write, m)?)?;
+    m.add_function(wrap_pyfunction!(ssh::ssh_write_chunk, m)?)?;
     m.add_function(wrap_pyfunction!(ssh::ssh_exists, m)?)?;
     m.add_function(wrap_pyfunction!(ssh::ssh_stat, m)?)?;
     m.add_function(wrap_pyfunction!(ssh::ssh_lstat, m)?)?;

{asanypath_native-2.1.1 → asanypath_native-2.3.0}/src/s3.rs

@@ -56,8 +56,11 @@ struct S3AwsConfig {
 
 static S3_AWS_CONFIGS: OnceLock<AsyncMutex<HashMap<String, S3AwsConfig>>> = OnceLock::new();
 
-async fn s3_aws_config(region_override: Option<String>) -> Result<S3AwsConfig, String> {
-    let profile = std::env::var("AWS_PROFILE").ok();
+async fn s3_aws_config(
+    profile: Option<String>,
+    region_override: Option<String>,
+) -> Result<S3AwsConfig, String> {
+    let profile = profile.or_else(|| std::env::var("AWS_PROFILE").ok());
     let cache_key = format!(
         "{}|{}",
         profile.as_deref().unwrap_or_default(),
@@ -133,9 +136,10 @@ pub fn s3_get_credentials<'py>(
     access_key: Option<String>,
     secret_key: Option<String>,
     session_token: Option<String>,
+    profile: Option<String>,
 ) -> PyResult<Bound<'py, PyAny>> {
     pyo3_async_runtimes::tokio::future_into_py(py, async move {
-        let config = s3_aws_config(region_override)
+        let config = s3_aws_config(profile, region_override)
             .await
             .map_err(PyRuntimeError::new_err)?;
         let resolved = match (access_key, secret_key) {
@@ -1065,6 +1069,229 @@ pub fn s3_put_batch<'py>(
     })
 }
 
+// ---------------------------------------------------------------------------
+// Multipart upload primitives (sequencing/concurrency orchestrated from Python)
+// ---------------------------------------------------------------------------
+
+/// Extract the `<UploadId>` text from an InitiateMultipartUpload response.
+fn parse_upload_id(body: &[u8]) -> Result<String, PyErr> {
+    let mut reader = Reader::from_reader(body);
+    reader.config_mut().trim_text(true);
+    let mut buf = Vec::new();
+    let mut in_id = false;
+    let mut text = String::new();
+    loop {
+        match reader.read_event_into(&mut buf) {
+            Ok(Event::Start(e)) => {
+                let name = e.name();
+                if local_name(name.as_ref()) == "UploadId" {
+                    in_id = true;
+                    text.clear();
+                }
+            }
+            Ok(Event::Text(e)) if in_id => text.push_str(&e.xml10_content()),
+            Ok(Event::End(_)) if in_id => return Ok(text.clone()),
+            Ok(Event::Eof) | Err(_) => break,
+            _ => {}
+        }
+        buf.clear();
+    }
+    Err(PyRuntimeError::new_err(
+        "S3 CreateMultipartUpload: no UploadId in response",
+    ))
+}
+
+/// Initiate a multipart upload; returns the UploadId.
+#[pyfunction]
+#[pyo3(signature = (endpoint, bucket, key, region, access_key, secret_key, session_token=None, options_json=None, use_h2=None))]
+pub fn s3_create_multipart<'py>(
+    py: Python<'py>,
+    endpoint: String,
+    bucket: String,
+    key: String,
+    region: String,
+    access_key: String,
+    secret_key: String,
+    session_token: Option<String>,
+    options_json: Option<String>,
+    use_h2: Option<bool>,
+) -> PyResult<Bound<'py, PyAny>> {
+    let h2 = use_h2.unwrap_or(false);
+    pyo3_async_runtimes::tokio::future_into_py(py, async move {
+        let creds = s3_creds!(
+            endpoint,
+            bucket,
+            region,
+            access_key,
+            secret_key,
+            session_token
+        );
+        let options: crate::backend::UploadOptions =
+            sonic_rs::from_str(&options_json.unwrap_or_else(|| "{}".to_string()))
+                .map_err(|e| PyValueError::new_err(format!("invalid backend_options: {e}")))?;
+        crate::backend::require_empty_provider(&options)?;
+        let mut extra = crate::backend::user_headers(&options)?;
+        extra.push(("content-length".to_string(), "0".to_string()));
+        let s3_path = format!("/{key}");
+        let query = vec![("uploads".to_string(), String::new())];
+        let (status, body, _h) = do_s3_request(&creds, "POST", &s3_path, &query, None, h2, &extra)
+            .await
+            .map_err(PyRuntimeError::new_err)?;
+        if !status.is_success() {
+            return Err(status_to_pyerr(status, &creds.error_path(&key), &body));
+        }
+        parse_upload_id(&body)
+    })
+}
+
+/// Upload one part; returns its ETag (used to complete the upload).
+#[pyfunction]
+#[pyo3(signature = (endpoint, bucket, key, upload_id, part_number, data, region, access_key, secret_key, session_token=None, use_h2=None))]
+pub fn s3_upload_part<'py>(
+    py: Python<'py>,
+    endpoint: String,
+    bucket: String,
+    key: String,
+    upload_id: String,
+    part_number: u32,
+    data: Vec<u8>,
+    region: String,
+    access_key: String,
+    secret_key: String,
+    session_token: Option<String>,
+    use_h2: Option<bool>,
+) -> PyResult<Bound<'py, PyAny>> {
+    let h2 = use_h2.unwrap_or(false);
+    pyo3_async_runtimes::tokio::future_into_py(py, async move {
+        let creds = s3_creds!(
+            endpoint,
+            bucket,
+            region,
+            access_key,
+            secret_key,
+            session_token
+        );
+        let s3_path = format!("/{key}");
+        let query = vec![
+            ("partNumber".to_string(), part_number.to_string()),
+            ("uploadId".to_string(), upload_id),
+        ];
+        let (status, body, headers) = do_s3_request(
+            &creds,
+            "PUT",
+            &s3_path,
+            &query,
+            Some(Bytes::from(data)),
+            h2,
+            &[],
+        )
+        .await
+        .map_err(PyRuntimeError::new_err)?;
+        if !status.is_success() {
+            return Err(status_to_pyerr(status, &creds.error_path(&key), &body));
+        }
+        Ok(headers.get("etag").cloned().unwrap_or_default())
+    })
+}
+
+/// Complete a multipart upload from the collected `(part_number, etag)` pairs.
+#[pyfunction]
+#[pyo3(signature = (endpoint, bucket, key, upload_id, parts, region, access_key, secret_key, session_token=None, use_h2=None))]
+pub fn s3_complete_multipart<'py>(
+    py: Python<'py>,
+    endpoint: String,
+    bucket: String,
+    key: String,
+    upload_id: String,
+    parts: Vec<(u32, String)>,
+    region: String,
+    access_key: String,
+    secret_key: String,
+    session_token: Option<String>,
+    use_h2: Option<bool>,
+) -> PyResult<Bound<'py, PyAny>> {
+    let h2 = use_h2.unwrap_or(false);
+    pyo3_async_runtimes::tokio::future_into_py(py, async move {
+        let creds = s3_creds!(
+            endpoint,
+            bucket,
+            region,
+            access_key,
+            secret_key,
+            session_token
+        );
+        let mut xml = String::from("<CompleteMultipartUpload>");
+        for (n, etag) in &parts {
+            xml.push_str(&format!(
+                "<Part><PartNumber>{n}</PartNumber><ETag>{etag}</ETag></Part>"
+            ));
+        }
+        xml.push_str("</CompleteMultipartUpload>");
+        let s3_path = format!("/{key}");
+        let query = vec![("uploadId".to_string(), upload_id)];
+        let extra = vec![("content-type".to_string(), "application/xml".to_string())];
+        let (status, body, _h) = do_s3_request(
+            &creds,
+            "POST",
+            &s3_path,
+            &query,
+            Some(Bytes::from(xml.into_bytes())),
+            h2,
+            &extra,
+        )
+        .await
+        .map_err(PyRuntimeError::new_err)?;
+        if !status.is_success() {
+            return Err(status_to_pyerr(status, &creds.error_path(&key), &body));
+        }
+        // S3 may return 200 OK with an <Error> body when completion fails.
+        if body.windows(7).any(|w| w == b"<Error>") {
+            return Err(PyRuntimeError::new_err(format!(
+                "S3 CompleteMultipartUpload failed: {}",
+                String::from_utf8_lossy(&body)
+            )));
+        }
+        Ok(())
+    })
+}
+
+/// Abort a multipart upload, discarding any uploaded parts.
+#[pyfunction]
+#[pyo3(signature = (endpoint, bucket, key, upload_id, region, access_key, secret_key, session_token=None, use_h2=None))]
+pub fn s3_abort_multipart<'py>(
+    py: Python<'py>,
+    endpoint: String,
+    bucket: String,
+    key: String,
+    upload_id: String,
+    region: String,
+    access_key: String,
+    secret_key: String,
+    session_token: Option<String>,
+    use_h2: Option<bool>,
+) -> PyResult<Bound<'py, PyAny>> {
+    let h2 = use_h2.unwrap_or(false);
+    pyo3_async_runtimes::tokio::future_into_py(py, async move {
+        let creds = s3_creds!(
+            endpoint,
+            bucket,
+            region,
+            access_key,
+            secret_key,
+            session_token
+        );
+        let s3_path = format!("/{key}");
+        let query = vec![("uploadId".to_string(), upload_id)];
+        let (status, body, _h) = do_s3_request(&creds, "DELETE", &s3_path, &query, None, h2, &[])
+            .await
+            .map_err(PyRuntimeError::new_err)?;
+        if !status.is_success() {
+            return Err(status_to_pyerr(status, &creds.error_path(&key), &body));
+        }
+        Ok(())
+    })
+}
+
 /// Copy multiple objects concurrently (server-side). Pairs are `(src_key, dst_key)`.
 #[pyfunction]
 pub fn s3_copy_batch<'py>(

{asanypath_native-2.1.1 → asanypath_native-2.3.0}/src/ssh.rs

@@ -426,6 +426,54 @@ pub fn ssh_write<'py>(
     })
 }
 
+/// Write one chunk of a streamed upload. The first chunk (`truncate=true`)
+/// resets the file; later chunks open with APPEND so no offset tracking is
+/// needed. Returns the byte count written.
+#[pyfunction]
+#[allow(clippy::too_many_arguments)]
+pub fn ssh_write_chunk<'py>(
+    py: Python<'py>,
+    path: String,
+    data: Vec<u8>,
+    truncate: bool,
+    host: String,
+    port: u16,
+    user: String,
+    password: Option<String>,
+    key_path: Option<String>,
+    key_passphrase: Option<String>,
+    use_agent: bool,
+    strict_host_key: bool,
+) -> PyResult<Bound<'py, PyAny>> {
+    let conn = conn!(
+        host,
+        port,
+        user,
+        password,
+        key_path,
+        key_passphrase,
+        use_agent,
+        strict_host_key
+    );
+    pyo3_async_runtimes::tokio::future_into_py(py, async move {
+        let session = session_for(&conn).await.map_err(PyRuntimeError::new_err)?;
+        let n = data.len();
+        let flags = if truncate {
+            OpenFlags::CREATE | OpenFlags::WRITE | OpenFlags::TRUNCATE
+        } else {
+            OpenFlags::CREATE | OpenFlags::WRITE | OpenFlags::APPEND
+        };
+        let mut file = session
+            .sftp
+            .open_with_flags(&path, flags)
+            .await
+            .map_err(err)?;
+        file.write_all(&data).await.map_err(err)?;
+        file.shutdown().await.map_err(err)?;
+        Ok(n)
+    })
+}
+
 /// Check whether a remote path exists.
 #[pyfunction]
 #[allow(clippy::too_many_arguments)]