asanypath-native 2.1.0__tar.gz → 2.2.0__tar.gz

{asanypath_native-2.1.0 → asanypath_native-2.2.0}/Cargo.lock

@@ -96,7 +96,7 @@ dependencies = [
 
 [[package]]
 name = "asanypath-native"
-version = "2.1.0"
+version = "2.2.0"
 dependencies = [
  "anyhow",
  "aws-config",
@@ -122,6 +122,7 @@ dependencies = [
  "sonic-rs",
  "ssh2-config",
  "tokio",
+ "tokio-util",
  "url",
  "urlencoding",
 ]
@@ -311,9 +312,9 @@ dependencies = [
 
 [[package]]
 name = "aws-sigv4"
-version = "1.5.3"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31d955e76ff96acd555bf06fa0fa6d5bf9335fa84ae7c64481b20ae61d231f70"
+checksum = "2312577f088c9fbf4206dfdb884cf1de9407b43e1a923cbed5237775116fc24b"
 dependencies = [
  "aws-credential-types",
  "aws-smithy-http",
@@ -448,15 +449,14 @@ dependencies = [
 
 [[package]]
 name = "aws-smithy-runtime-api"
-version = "1.16.2"
+version = "1.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d881a7b7ad179fd6611680c9de89f716fb00ab40299a9a7b8c6913e8f7511a8"
+checksum = "c0730c16f91124c6a2abb4932c77e299288b3dd9f967ea2e9ec48cc6731e87a4"
 dependencies = [
  "aws-smithy-async",
  "aws-smithy-runtime-api-macros",
  "aws-smithy-types",
  "bytes",
- "http 0.2.12",
  "http 1.5.0",
  "pin-project-lite",
  "tokio",
@@ -488,9 +488,9 @@ dependencies = [
 
 [[package]]
 name = "aws-smithy-types"
-version = "1.6.4"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b791f3ac597193fe1d08b82366986eb1f5bc31f2ac6c194c0855276116c76cd"
+checksum = "69bb407740a197147da48238ecc94498493c9e85445732360cec180296ca45f1"
 dependencies = [
  "base64-simd",
  "bytes",
@@ -2695,6 +2695,7 @@ dependencies = [
  "base64 0.22.1",
  "bytes",
  "futures-core",
+ "futures-util",
  "h2",
  "http 1.5.0",
  "http-body 1.1.0",
@@ -2715,12 +2716,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",
 ]
@@ -3885,6 +3888,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.0 → asanypath_native-2.2.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "asanypath-native"
-version = "2.1.0"
+version = "2.2.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,6 +34,7 @@ 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"] }
 

{asanypath_native-2.1.0 → asanypath_native-2.2.0}/PKG-INFO

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

asanypath_native-2.2.0/asanypath_native.pyi

@@ -0,0 +1,135 @@
+# 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.
+
+"""Type stub for the Rust-native asanypath_native extension module."""
+
+from typing import Any
+
+# -- 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: ...
+async def s3_list_batch(*args: Any, **kwargs: Any) -> Any: ...
+async def s3_head_batch(*args: Any, **kwargs: Any) -> Any: ...
+async def s3_is_dir(*args: Any, **kwargs: Any) -> Any: ...
+async def s3_is_dir_batch(*args: Any, **kwargs: Any) -> Any: ...
+async def s3_list_buckets(*args: Any, **kwargs: Any) -> Any: ...
+async def s3_get_acl(*args: Any, **kwargs: Any) -> Any: ...
+async def s3_put_acl(*args: Any, **kwargs: Any) -> Any: ...
+async def s3_get_credentials(
+    region_override: str | None,
+    access_key: str | None,
+    secret_key: str | None,
+    session_token: str | None,
+) -> tuple[str, str, str | None, str, str | None]: ...
+def s3_presign(
+    endpoint: str,
+    bucket: str,
+    key: str,
+    region: str,
+    access_key: str,
+    secret_key: str,
+    session_token: str | None = None,
+    method: str | None = None,
+    expires: int | None = None,
+) -> str: ...
+
+# -- 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: ...
+async def gcs_list_batch(*args: Any, **kwargs: Any) -> Any: ...
+async def gcs_head(*args: Any, **kwargs: Any) -> Any: ...
+async def gcs_head_batch(*args: Any, **kwargs: Any) -> Any: ...
+async def gcs_is_dir(*args: Any, **kwargs: Any) -> Any: ...
+async def gcs_is_dir_batch(*args: Any, **kwargs: Any) -> Any: ...
+async def gcs_list_buckets(*args: Any, **kwargs: Any) -> Any: ...
+def gcs_presign(
+    bucket: str,
+    object_path: str,
+    service_account_json: str,
+    method: str | None = None,
+    expires: int | None = None,
+) -> str: ...
+
+# -- 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: ...
+async def az_list_batch(*args: Any, **kwargs: Any) -> Any: ...
+async def az_head_batch(*args: Any, **kwargs: Any) -> Any: ...
+async def az_is_dir(*args: Any, **kwargs: Any) -> Any: ...
+async def az_is_dir_batch(*args: Any, **kwargs: Any) -> Any: ...
+async def az_list_containers(*args: Any, **kwargs: Any) -> Any: ...
+def az_presign(
+    endpoint: str,
+    container: str,
+    blob_path: str,
+    account_name: str,
+    account_key: str | None = None,
+    sas_token: str | None = None,
+    method: str | None = None,
+    expires: int | None = None,
+) -> str: ...
+
+# -- 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: ...
+async def art_list_batch(*args: Any, **kwargs: Any) -> Any: ...
+async def art_list_repos(*args: Any, **kwargs: Any) -> Any: ...
+async def art_storage_info(*args: Any, **kwargs: Any) -> Any: ...
+
+# -- HTTP --
+async def http_get(*args: Any, **kwargs: Any) -> Any: ...
+async def http_put(*args: Any, **kwargs: Any) -> Any: ...
+async def http_post(*args: Any, **kwargs: Any) -> Any: ...
+async def http_delete(*args: Any, **kwargs: Any) -> Any: ...
+async def http_head(*args: Any, **kwargs: Any) -> Any: ...
+async def http_patch(*args: Any, **kwargs: Any) -> Any: ...
+async def http_options(*args: Any, **kwargs: Any) -> Any: ...
+async def http_exists(*args: Any, **kwargs: Any) -> Any: ...
+async def http_scrape_links(*args: Any, **kwargs: Any) -> Any: ...
+async def http_request(*args: Any, **kwargs: Any) -> Any: ...
+
+# -- Unified --
+async def range_read(path: str, start: int, end: int, **kwargs: Any) -> bytes: ...
+
+# -- SSH / SFTP --
+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: ...
+async def ssh_setstat(*args: Any, **kwargs: Any) -> None: ...
+async def ssh_list(*args: Any, **kwargs: Any) -> Any: ...
+async def ssh_mkdir(*args: Any, **kwargs: Any) -> None: ...
+async def ssh_rmdir(*args: Any, **kwargs: Any) -> None: ...
+async def ssh_unlink(*args: Any, **kwargs: Any) -> None: ...
+async def ssh_rename(*args: Any, **kwargs: Any) -> None: ...
+def ssh_resolve_config(
+    host: str, config_paths: list[str]
+) -> tuple[str | None, int | None, str | None, str | None]: ...
+def ssh_disconnect_all() -> None: ...

{asanypath_native-2.1.0 → asanypath_native-2.2.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.0 → asanypath_native-2.2.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.0 → asanypath_native-2.2.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)
@@ -930,6 +930,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>(

{asanypath_native-2.1.0 → asanypath_native-2.2.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.0 → asanypath_native-2.2.0}/src/lib.rs

@@ -40,6 +40,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 +60,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 +77,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 +91,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 +112,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.0 → asanypath_native-2.2.0}/src/s3.rs

@@ -11,6 +11,9 @@ use std::collections::HashMap;
 use std::sync::OnceLock;
 use std::time::SystemTime;
 
+use aws_config::environment::region::EnvironmentVariableRegionProvider;
+use aws_config::meta::region::RegionProviderChain;
+use aws_config::profile::region::ProfileFileRegionProvider;
 use aws_config::{BehaviorVersion, Region};
 use aws_credential_types::Credentials;
 use aws_credential_types::provider::{ProvideCredentials, SharedCredentialsProvider};
@@ -66,20 +69,54 @@ async fn s3_aws_config(region_override: Option<String>) -> Result<S3AwsConfig, S
         return Ok(config.clone());
     }
 
-    let mut loader = aws_config::defaults(BehaviorVersion::latest());
-    if let Some(profile) = profile {
+    // Resolve region WITHOUT IMDS: explicit override > AWS_REGION env > profile.
+    // The loader must then receive a *concrete* region: an unset region makes the
+    // credentials chain probe EC2 IMDS during load() (a ~3s timeout off-EC2), which
+    // is pointless when a custom endpoint_url is configured (S3-compatible stores).
+    let region_no_imds: Option<Region> = match &region_override {
+        Some(region) => Some(Region::new(region.clone())),
+        None => {
+            RegionProviderChain::first_try(EnvironmentVariableRegionProvider::new())
+                .or_else(ProfileFileRegionProvider::default())
+                .region()
+                .await
+        }
+    };
+
+    // First load with a concrete placeholder region (no IMDS) to read endpoint_url.
+    let probe_region = region_no_imds
+        .clone()
+        .unwrap_or_else(|| Region::new("us-east-1"));
+    let mut loader = aws_config::defaults(BehaviorVersion::latest()).region(probe_region);
+    if let Some(profile) = &profile {
         loader = loader.profile_name(profile);
     }
-    if let Some(region) = region_override {
-        loader = loader.region(Region::new(region));
-    }
     let sdk_config = loader.load().await;
+    let endpoint_url = sdk_config.endpoint_url().map(str::to_string);
+
+    // Preserve IMDS: only a genuine real-AWS target (no endpoint, no configured
+    // region) consults the IMDS region provider; then reload so the credentials
+    // chain is built against the IMDS-resolved region.
+    let (region, sdk_config) = if let Some(region) = region_no_imds {
+        (region.as_ref().to_string(), sdk_config)
+    } else if endpoint_url.is_some() {
+        ("us-east-1".to_string(), sdk_config)
+    } else {
+        match RegionProviderChain::default_provider().region().await {
+            Some(imds_region) => {
+                let mut loader =
+                    aws_config::defaults(BehaviorVersion::latest()).region(imds_region.clone());
+                if let Some(profile) = &profile {
+                    loader = loader.profile_name(profile);
+                }
+                (imds_region.as_ref().to_string(), loader.load().await)
+            }
+            None => ("us-east-1".to_string(), sdk_config),
+        }
+    };
     let config = S3AwsConfig {
-        region: sdk_config
-            .region()
-            .map(|region| region.as_ref().to_string())
-            .unwrap_or_else(|| "us-east-1".to_string()),
-        endpoint_url: sdk_config.endpoint_url().map(str::to_string),
+        region,
+        endpoint_url,
         credentials_provider: sdk_config
             .credentials_provider()
             .ok_or_else(|| "AWS credential provider chain is unavailable".to_string())?,
@@ -1028,6 +1065,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.0 → asanypath_native-2.2.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)]