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

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

@@ -96,7 +96,7 @@ dependencies = [
 
 [[package]]
 name = "asanypath-native"
-version = "2.2.0"
+version = "2.3.1"
 dependencies = [
  "anyhow",
  "aws-config",
@@ -114,6 +114,7 @@ dependencies = [
  "quick-xml",
  "reqwest",
  "ring",
+ "rusqlite",
  "russh",
  "russh-sftp",
  "scraper",
@@ -1197,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"
@@ -1254,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"
@@ -1493,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"
@@ -1895,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"
@@ -2800,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"
@@ -3363,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"
@@ -3797,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"

{asanypath_native-2.2.0 → asanypath_native-2.3.1}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "asanypath-native"
-version = "2.2.0"
+version = "2.3.1"
 edition = "2024"
 license = "MIT"
 publish = false
@@ -37,6 +37,7 @@ 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.2.0 → asanypath_native-2.3.1}/PKG-INFO

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

{asanypath_native-2.2.0 → asanypath_native-2.3.1}/asanypath_native.pyi

@@ -8,6 +8,16 @@
 
 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: ...
@@ -30,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,

{asanypath_native-2.2.0 → asanypath_native-2.3.1}/src/azure.rs

@@ -16,6 +16,7 @@ use futures::future::join_all;
 use hmac::{Hmac, KeyInit, Mac};
 use pyo3::exceptions::{PyRuntimeError, PyValueError};
 use pyo3::prelude::*;
+use pyo3::pybacked::PyBackedBytes;
 use quick_xml::Reader;
 use quick_xml::events::Event;
 use serde::{Deserialize, Serialize};
@@ -956,7 +957,7 @@ pub fn az_put_block<'py>(
     container: String,
     blob: String,
     block_id: String,
-    data: Vec<u8>,
+    data: PyBackedBytes,
     account_name: String,
     account_key: Option<String>,
     sas_token: Option<String>,
@@ -976,9 +977,10 @@ pub fn az_put_block<'py>(
         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)?;
+        let (status, body) =
+            do_request_light("PUT", &url, &headers, Some(Bytes::from_owner(data)), h2)
+                .await
+                .map_err(PyRuntimeError::new_err)?;
         if !status.is_success() {
             return Err(status_to_pyerr(status, &creds.error_path(&blob), &body));
         }

{asanypath_native-2.2.0 → asanypath_native-2.3.1}/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.1/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.2.0 → asanypath_native-2.3.1}/src/gcs.rs

@@ -18,6 +18,7 @@ use futures::future::join_all;
 use pyo3::exceptions::PyRuntimeError;
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
+use pyo3::pybacked::PyBackedBytes;
 use serde::{Deserialize, Serialize};
 use sonic_rs::JsonValueTrait;
 use std::collections::{HashMap, HashSet};
@@ -155,6 +156,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 +352,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
         }
     }
@@ -979,7 +996,7 @@ pub fn gcs_start_resumable<'py>(
 pub fn gcs_upload_chunk<'py>(
     py: Python<'py>,
     session_uri: String,
-    data: Vec<u8>,
+    data: PyBackedBytes,
     offset: u64,
     total: u64,
     use_h2: Option<bool>,
@@ -995,10 +1012,15 @@ pub fn gcs_upload_chunk<'py>(
                 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)?;
+        let (status, body, _h) = do_request(
+            "PUT",
+            &session_uri,
+            &headers,
+            Some(Bytes::from_owner(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(())
@@ -1239,7 +1261,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.2.0 → asanypath_native-2.3.1}/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)?)?;

{asanypath_native-2.2.0 → asanypath_native-2.3.1}/src/s3.rs

@@ -25,6 +25,7 @@ use bytes::Bytes;
 use pyo3::exceptions::PyRuntimeError;
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
+use pyo3::pybacked::PyBackedBytes;
 use quick_xml::Reader;
 use quick_xml::{XmlVersion, events::Event};
 use serde::{Deserialize, Serialize};
@@ -56,8 +57,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 +137,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) {
@@ -1150,7 +1155,7 @@ pub fn s3_upload_part<'py>(
     key: String,
     upload_id: String,
     part_number: u32,
-    data: Vec<u8>,
+    data: PyBackedBytes,
     region: String,
     access_key: String,
     secret_key: String,
@@ -1177,7 +1182,7 @@ pub fn s3_upload_part<'py>(
             "PUT",
             &s3_path,
             &query,
-            Some(Bytes::from(data)),
+            Some(Bytes::from_owner(data)),
             h2,
             &[],
         )