opendal 0.1.9 → 0.1.11

data/core/services/tos/src/core.rs

@@ -16,6 +16,7 @@
 // under the License.
 
 use std::fmt::Debug;
+use std::time::Duration;
 
 use http::Request;
 use http::Response;
@@ -99,6 +100,27 @@ impl TosCore {
         )
     }
 
+    pub async fn sign_query<T>(
+        &self,
+        ctx: &OperationContext,
+        req: Request<T>,
+        duration: Duration,
+    ) -> Result<Request<T>> {
+        if self.skip_signature {
+            return Ok(req);
+        }
+
+        let (mut parts, body) = req.into_parts();
+        self.signer(ctx)
+            .sign(&mut parts, Some(duration))
+            .await
+            .map_err(|e| new_request_sign_error(e.into()))?;
+
+        parts.headers.remove(HOST);
+
+        Ok(Request::from_parts(parts, body))
+    }
+
     pub async fn send(
         &self,
         ctx: &OperationContext,
@@ -413,12 +435,11 @@ impl TosCore {
         self.send(ctx, req).await
     }
 
-    pub async fn tos_delete_object(
+    pub fn tos_delete_object_request(
         &self,
-        ctx: &OperationContext,
         path: &str,
         args: &OpDelete,
-    ) -> Result<Response<Buffer>> {
+    ) -> Result<Request<Buffer>> {
         let p = build_abs_path(&self.root, path);
 
         let mut url = format!(
@@ -444,11 +465,19 @@ impl TosCore {
 
         let req = Request::delete(&url);
 
-        let req = req
-            .extension(Operation::Delete)
+        req.extension(Operation::Delete)
             .extension(ServiceOperation("DeleteObject"))
             .body(Buffer::new())
-            .map_err(new_request_build_error)?;
+            .map_err(new_request_build_error)
+    }
+
+    pub async fn tos_delete_object(
+        &self,
+        ctx: &OperationContext,
+        path: &str,
+        args: &OpDelete,
+    ) -> Result<Response<Buffer>> {
+        let req = self.tos_delete_object_request(path, args)?;
 
         self.send(ctx, req).await
     }
@@ -1052,99 +1081,103 @@ pub struct CopyObjectOutput {
     pub etag: String,
 }
 
-mod error {
-    use bytes::Buf;
-    use http::{Response, StatusCode};
-    use quick_xml::de;
-    use serde::Deserialize;
-
-    use opendal_core::raw::*;
-    use opendal_core::*;
-
-    /// TosError is the error returned by TOS service.
-    #[derive(Default, Debug, Deserialize, PartialEq, Eq)]
-    #[serde(default, rename_all = "PascalCase")]
-    pub(crate) struct TosError {
-        pub code: String,
-        pub message: String,
-        pub resource: String,
-        pub request_id: String,
-    }
+use bytes::Buf;
+use http::StatusCode;
+use quick_xml::de;
 
-    /// Parse error response into Error.
-    pub(crate) fn parse_error(resp: Response<Buffer>) -> Error {
-        let (parts, body) = resp.into_parts();
-        let bs = body.to_bytes();
+/// TosError is the error returned by TOS service.
+#[derive(Default, Debug, Deserialize, PartialEq, Eq)]
+#[serde(default, rename_all = "PascalCase")]
+pub(crate) struct TosError {
+    pub code: String,
+    pub message: String,
+    pub resource: String,
+    pub request_id: String,
+}
 
-        let (mut kind, mut retryable) = match parts.status {
-            StatusCode::FORBIDDEN => (ErrorKind::PermissionDenied, false),
-            StatusCode::NOT_FOUND => (ErrorKind::NotFound, false),
-            StatusCode::NOT_MODIFIED | StatusCode::PRECONDITION_FAILED => {
-                (ErrorKind::ConditionNotMatch, false)
-            }
-            StatusCode::CONFLICT => (ErrorKind::ConditionNotMatch, true),
-            StatusCode::TOO_MANY_REQUESTS => (ErrorKind::RateLimited, true),
-            code if code.is_server_error() => (ErrorKind::Unexpected, true),
-            _ => (ErrorKind::Unexpected, false),
-        };
-
-        let (message, tos_err) = parse_tos_error(&bs)
-            .map(|tos_err| (format!("{tos_err:?}"), Some(tos_err)))
-            .unwrap_or_else(|| (String::from_utf8_lossy(&bs).into_owned(), None));
-
-        if let Some(tos_err) = tos_err {
-            (kind, retryable) =
-                parse_tos_error_code(tos_err.code.as_str()).unwrap_or((kind, retryable));
-        }
+/// Context needed to classify an error from this service.
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct ErrorContext {
+    service_operation: ServiceOperation,
+}
 
-        let mut err = Error::new(kind, message);
+impl ErrorContext {
+    pub(crate) const fn new(service_operation: ServiceOperation) -> Self {
+        Self { service_operation }
+    }
+}
 
-        err = with_error_response_context(err, parts);
+/// Parse an error response using its service request context.
+pub(crate) fn parse_error(ctx: ErrorContext, resp: Response<Buffer>) -> Error {
+    let (parts, body) = resp.into_parts();
+    let bs = body.to_bytes();
 
-        if retryable {
-            err = err.set_temporary();
+    let (mut kind, mut retryable) = match parts.status {
+        StatusCode::FORBIDDEN => (ErrorKind::PermissionDenied, false),
+        StatusCode::NOT_FOUND => (ErrorKind::NotFound, false),
+        StatusCode::NOT_MODIFIED | StatusCode::PRECONDITION_FAILED => {
+            (ErrorKind::ConditionNotMatch, false)
         }
-
-        err
+        StatusCode::CONFLICT => (ErrorKind::ConditionNotMatch, true),
+        StatusCode::TOO_MANY_REQUESTS => (ErrorKind::RateLimited, true),
+        code if code.is_server_error() => (ErrorKind::Unexpected, true),
+        _ => (ErrorKind::Unexpected, false),
+    };
+
+    let (message, tos_err) = parse_tos_error(&bs)
+        .map(|tos_err| (format!("{tos_err:?}"), Some(tos_err)))
+        .unwrap_or_else(|| (String::from_utf8_lossy(&bs).into_owned(), None));
+
+    if let Some(tos_err) = tos_err {
+        (kind, retryable) =
+            parse_tos_error_code(tos_err.code.as_str()).unwrap_or((kind, retryable));
     }
 
-    fn parse_tos_error(bs: &bytes::Bytes) -> Option<TosError> {
-        de::from_reader::<_, TosError>(bs.chunk().reader())
-            .or_else(|_| serde_json::from_slice::<TosError>(bs))
-            .ok()
+    let mut err = Error::new(kind, message);
+
+    err = err.with_context("service_operation", ctx.service_operation.0);
+    err = with_error_response_context(err, parts);
+
+    if retryable {
+        err = err.set_temporary();
     }
 
-    /// Returns the `Error kind` of this code and whether the error is retryable.
-    /// TOS error codes: https://www.volcengine.com/docs/6349/74874
-    pub fn parse_tos_error_code(code: &str) -> Option<(ErrorKind, bool)> {
-        match code {
-            "NoSuchBucket" => Some((ErrorKind::ConfigInvalid, false)),
-            "NoSuchKey" => Some((ErrorKind::NotFound, false)),
-            "DuplicateObject" => Some((ErrorKind::ConditionNotMatch, false)),
-            "RequestTimeout" => Some((ErrorKind::Unexpected, true)),
-            "InternalError" => Some((ErrorKind::Unexpected, true)),
-            "OperationAborted" => Some((ErrorKind::Unexpected, true)),
-            "SlowDown" => Some((ErrorKind::RateLimited, true)),
-            "ServiceUnavailable" => Some((ErrorKind::Unexpected, true)),
-            "TooManyRequests" => Some((ErrorKind::RateLimited, true)),
-            "ExceedAccountQPSLimit" | "ExceedAccountRateLimit" => {
-                Some((ErrorKind::RateLimited, true))
-            }
-            "ExceedBucketQPSLimit" | "ExceedBucketRateLimit" => {
-                Some((ErrorKind::RateLimited, true))
-            }
-            _ => None,
-        }
+    err
+}
+
+fn parse_tos_error(bs: &bytes::Bytes) -> Option<TosError> {
+    de::from_reader::<_, TosError>(bs.chunk().reader())
+        .or_else(|_| serde_json::from_slice::<TosError>(bs))
+        .ok()
+}
+
+/// Returns the `Error kind` of this code and whether the error is retryable.
+/// TOS error codes: https://www.volcengine.com/docs/6349/74874
+pub fn parse_tos_error_code(code: &str) -> Option<(ErrorKind, bool)> {
+    match code {
+        "NoSuchBucket" => Some((ErrorKind::ConfigInvalid, false)),
+        "NoSuchKey" => Some((ErrorKind::NotFound, false)),
+        "DuplicateObject" => Some((ErrorKind::ConditionNotMatch, false)),
+        "RequestTimeout" => Some((ErrorKind::Unexpected, true)),
+        "InternalError" => Some((ErrorKind::Unexpected, true)),
+        "OperationAborted" => Some((ErrorKind::Unexpected, true)),
+        "SlowDown" => Some((ErrorKind::RateLimited, true)),
+        "ServiceUnavailable" => Some((ErrorKind::Unexpected, true)),
+        "TooManyRequests" => Some((ErrorKind::RateLimited, true)),
+        "ExceedAccountQPSLimit" | "ExceedAccountRateLimit" => Some((ErrorKind::RateLimited, true)),
+        "ExceedBucketQPSLimit" | "ExceedBucketRateLimit" => Some((ErrorKind::RateLimited, true)),
+        _ => None,
     }
+}
 
-    #[cfg(test)]
-    mod tests {
-        use super::*;
+#[cfg(test)]
+mod tests {
+    use super::*;
 
-        #[test]
-        fn test_parse_error() {
-            let bs = bytes::Bytes::from(
-                r#"
+    #[test]
+    fn test_parse_error() {
+        let bs = bytes::Bytes::from(
+            r#"
 <?xml version="1.0" encoding="UTF-8"?>
 <Error>
   <Code>NoSuchKey</Code>
@@ -1153,34 +1186,34 @@ mod error {
   <RequestId>4442587FB7D0A2F9</RequestId>
 </Error>
 "#,
-            );
+        );
 
-            let out: TosError = de::from_reader(bs.reader()).expect("must success");
-            println!("{out:?}");
+        let out: TosError = de::from_reader(bs.reader()).expect("must success");
+        println!("{out:?}");
 
-            assert_eq!(out.code, "NoSuchKey");
-            assert_eq!(out.message, "The resource you requested does not exist");
-            assert_eq!(out.resource, "/mybucket/myfoto.jpg");
-            assert_eq!(out.request_id, "4442587FB7D0A2F9");
-        }
+        assert_eq!(out.code, "NoSuchKey");
+        assert_eq!(out.message, "The resource you requested does not exist");
+        assert_eq!(out.resource, "/mybucket/myfoto.jpg");
+        assert_eq!(out.request_id, "4442587FB7D0A2F9");
+    }
 
-        #[test]
-        fn test_parse_json_error() {
-            let bs = bytes::Bytes::from(
-                r#"{"Code":"DuplicateObject","RequestId":"request-id","Message":"The object already exists."}"#,
-            );
+    #[test]
+    fn test_parse_json_error() {
+        let bs = bytes::Bytes::from(
+            r#"{"Code":"DuplicateObject","RequestId":"request-id","Message":"The object already exists."}"#,
+        );
 
-            let out = parse_tos_error(&bs).expect("must success");
+        let out = parse_tos_error(&bs).expect("must success");
 
-            assert_eq!(out.code, "DuplicateObject");
-            assert_eq!(out.message, "The object already exists.");
-            assert_eq!(out.request_id, "request-id");
-        }
+        assert_eq!(out.code, "DuplicateObject");
+        assert_eq!(out.message, "The object already exists.");
+        assert_eq!(out.request_id, "request-id");
+    }
 
-        #[test]
-        fn test_parse_error_from_unrelated_input() {
-            let bs = bytes::Bytes::from(
-                r#"
+    #[test]
+    fn test_parse_error_from_unrelated_input() {
+        let bs = bytes::Bytes::from(
+            r#"
 <?xml version="1.0" encoding="UTF-8"?>
 <CompleteMultipartUploadResult xmlns="http://tos.apache.org/doc/2024-01-01/">
   <Bucket>example-bucket</Bucket>
@@ -1188,16 +1221,13 @@ mod error {
   <UploadId>VXBsb2FkIElEIGZvciA2aWWpbmcncyBteS1tb3ZpZS5tMnRzIHVwbG9hZA</UploadId>
 </CompleteMultipartUploadResult>
 "#,
-            );
+        );
 
-            let out: TosError = de::from_reader(bs.reader()).expect("must success");
-            assert_eq!(out, TosError::default());
-        }
+        let out: TosError = de::from_reader(bs.reader()).expect("must success");
+        assert_eq!(out, TosError::default());
     }
 }
 
-pub(super) use error::*;
-
 mod utils {
     use http::HeaderMap;
     use http::header::ETAG;
@@ -1216,13 +1246,13 @@ mod utils {
         path: &str,
         headers: &HeaderMap,
     ) -> opendal_core::Result<Metadata> {
-        let mut metadata = parse_into_metadata(path, headers)?;
+        let mut metadata = parse_into_metadata(path, headers)?.into_builder();
 
         if let Some(etag) = tos_parse_etag(headers)? {
-            metadata.set_etag(etag);
+            metadata.etag(etag);
         }
 
-        Ok(metadata)
+        Ok(metadata.build())
     }
 }
 

data/core/services/tos/src/deleter.rs

@@ -50,7 +50,10 @@ impl oio::BatchDelete for TosDeleter {
         match status {
             StatusCode::NO_CONTENT => Ok(()),
             StatusCode::NOT_FOUND => Ok(()),
-            _ => Err(crate::core::parse_error(resp)),
+            _ => Err(crate::core::parse_error(
+                crate::core::ErrorContext::new(ServiceOperation("DeleteObject")),
+                resp,
+            )),
         }
     }
 
@@ -59,7 +62,10 @@ impl oio::BatchDelete for TosDeleter {
 
         let status = resp.status();
         if status != StatusCode::OK {
-            return Err(crate::core::parse_error(resp));
+            return Err(crate::core::parse_error(
+                crate::core::ErrorContext::new(ServiceOperation("DeleteMultipleObjects")),
+                resp,
+            ));
         }
 
         let bs = resp.into_body();
@@ -90,7 +96,7 @@ impl oio::BatchDelete for TosDeleter {
                 let deleted = deleted.swap_remove(idx);
                 let op = if op.version().is_some() {
                     if let Some(version) = &deleted.version_id {
-                        op.with_version(version)
+                        op.into_version(version)
                     } else {
                         op
                     }

data/core/services/tos/src/docs.md

@@ -10,7 +10,7 @@ Depending on its configuration and the backing system, this service can expose:
 - [x] list
 - [x] copy
 - [ ] rename
-- [ ] presign
+- [x] presign
 
 Inspect the effective capability set with [`opendal_core::Operator::info`] and
 [`opendal_core::OperatorInfo::capability`] after building an operator.

data/core/services/tos/src/lister.rs

@@ -21,8 +21,7 @@ use bytes::Buf;
 
 use crate::core::parse_error;
 use crate::core::*;
-use opendal_core::EntryMode;
-use opendal_core::Metadata;
+use opendal_core::MetadataBuilder;
 use opendal_core::OperationContext;
 use opendal_core::Result;
 use opendal_core::raw::*;
@@ -77,7 +76,10 @@ impl oio::PageList for TosLister {
             .await?;
 
         if resp.status() != http::StatusCode::OK {
-            return Err(parse_error(resp));
+            return Err(parse_error(
+                ErrorContext::new(ServiceOperation("ListObjectsV2")),
+                resp,
+            ));
         }
 
         let bs = resp.into_body();
@@ -90,7 +92,7 @@ impl oio::PageList for TosLister {
         for prefix in output.common_prefixes {
             let de = oio::Entry::new(
                 &build_rel_path(&self.core.root, &prefix.prefix),
-                Metadata::new(EntryMode::DIR),
+                MetadataBuilder::dir().build(),
             );
 
             ctx.entries.push_back(de);
@@ -102,16 +104,19 @@ impl oio::PageList for TosLister {
                 path = "/".to_string();
             }
 
-            let mut meta = Metadata::new(EntryMode::from_path(&path));
-            meta.set_is_current(true);
+            let mut meta = if path.ends_with('/') {
+                MetadataBuilder::dir()
+            } else {
+                MetadataBuilder::file(object.size)
+            };
+            meta.is_current(Some(true));
             if let Some(etag) = &object.etag {
-                meta.set_etag(etag);
-                meta.set_content_md5(etag.trim_matches('"'));
+                meta.etag(etag);
+                meta.content_md5(etag.trim_matches('"'));
             }
-            meta.set_content_length(object.size);
-            meta.set_last_modified(object.last_modified.parse::<Timestamp>()?);
+            meta.last_modified(object.last_modified.parse::<Timestamp>()?);
 
-            let de = oio::Entry::with(path, meta);
+            let de = oio::Entry::with(path, meta.build());
             ctx.entries.push_back(de);
         }
 
@@ -172,7 +177,10 @@ impl oio::PageList for TosObjectVersionsLister {
             .await?;
 
         if resp.status() != http::StatusCode::OK {
-            return Err(parse_error(resp));
+            return Err(parse_error(
+                ErrorContext::new(ServiceOperation("ListObjectVersions")),
+                resp,
+            ));
         }
 
         let bs = resp.into_body();
@@ -193,7 +201,7 @@ impl oio::PageList for TosObjectVersionsLister {
         for prefix in output.common_prefixes {
             let de = oio::Entry::new(
                 &build_rel_path(&self.core.root, &prefix.prefix),
-                Metadata::new(EntryMode::DIR),
+                MetadataBuilder::dir().build(),
             );
 
             ctx.entries.push_back(de);
@@ -209,18 +217,21 @@ impl oio::PageList for TosObjectVersionsLister {
                 path = "/".to_string();
             }
 
-            let mut meta = Metadata::new(EntryMode::from_path(&path));
-            meta.set_version(&version_object.version_id);
-            meta.set_is_current(version_object.is_latest);
-            meta.set_content_length(version_object.size);
-            meta.set_last_modified(version_object.last_modified.parse::<Timestamp>()?);
+            let mut meta = if path.ends_with('/') {
+                MetadataBuilder::dir()
+            } else {
+                MetadataBuilder::file(version_object.size)
+            };
+            meta.version(&version_object.version_id);
+            meta.is_current(Some(version_object.is_latest));
+            meta.last_modified(version_object.last_modified.parse::<Timestamp>()?);
 
             if let Some(etag) = version_object.etag {
-                meta.set_etag(&etag);
-                meta.set_content_md5(etag.trim_matches('"'));
+                meta.etag(&etag);
+                meta.content_md5(etag.trim_matches('"'));
             }
 
-            let de = oio::Entry::with(path, meta);
+            let de = oio::Entry::with(path, meta.build());
             ctx.entries.push_back(de);
         }
 
@@ -231,13 +242,17 @@ impl oio::PageList for TosObjectVersionsLister {
                     path = "/".to_string();
                 }
 
-                let mut meta = Metadata::new(EntryMode::FILE);
-                meta.set_version(&delete_marker.version_id);
-                meta.set_is_deleted(true);
-                meta.set_is_current(delete_marker.is_latest);
-                meta.set_last_modified(delete_marker.last_modified.parse::<Timestamp>()?);
-
-                let de = oio::Entry::with(path, meta);
+                let mut meta = if path.ends_with('/') {
+                    MetadataBuilder::dir()
+                } else {
+                    MetadataBuilder::file(0)
+                };
+                meta.version(&delete_marker.version_id);
+                meta.is_deleted(true);
+                meta.is_current(Some(delete_marker.is_latest));
+                meta.last_modified(delete_marker.last_modified.parse::<Timestamp>()?);
+
+                let de = oio::Entry::with(path, meta.build());
                 ctx.entries.push_back(de);
             }
         }

data/core/services/tos/src/reader.rs

@@ -16,7 +16,7 @@
 // under the License.
 
 use super::backend::*;
-use crate::core::parse_error;
+use crate::core::{ErrorContext, parse_error};
 use http::Response;
 use http::StatusCode;
 use opendal_core::BytesRange;
@@ -67,7 +67,10 @@ impl oio::StreamRead for TosReader {
             _ => {
                 let (part, mut body) = resp.into_parts();
                 let buf = body.to_buffer().await?;
-                return Err(parse_error(Response::from_parts(part, buf)));
+                return Err(parse_error(
+                    ErrorContext::new(ServiceOperation("GetObject")),
+                    Response::from_parts(part, buf),
+                ));
             }
         };
 

data/core/services/tos/src/writer.rs

@@ -47,19 +47,24 @@ impl TosWriter {
     }
 
     fn parse_header_into_meta(path: &str, headers: &http::HeaderMap) -> Result<Metadata> {
-        let mut meta = Metadata::new(EntryMode::from_path(path));
+        let mut meta = if path.ends_with('/') {
+            MetadataBuilder::dir()
+        } else {
+            MetadataBuilder::unknown()
+        };
         if let Some(etag) = tos_parse_etag(headers)? {
-            meta.set_etag(etag);
+            meta.etag(etag);
         }
         if let Some(version) = parse_header_to_str(headers, X_TOS_VERSION_ID)? {
-            meta.set_version(version);
+            meta.version(version);
         }
-        if let Some(value) =
-            parse_header_to_str(headers, X_TOS_OBJECT_SIZE)?.and_then(|size| size.parse().ok())
+        if !path.ends_with('/')
+            && let Some(value) =
+                parse_header_to_str(headers, X_TOS_OBJECT_SIZE)?.and_then(|size| size.parse().ok())
         {
-            meta.set_content_length(value);
+            meta.set_file(value);
         }
-        Ok(meta)
+        Ok(meta.build())
     }
 }
 
@@ -77,7 +82,10 @@ impl oio::MultipartWrite for TosWriter {
 
         match status {
             StatusCode::CREATED | StatusCode::OK => Ok(meta),
-            _ => Err(parse_error(resp)),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("PutObject")),
+                resp,
+            )),
         }
     }
 
@@ -97,7 +105,10 @@ impl oio::MultipartWrite for TosWriter {
 
                 Ok(result.upload_id)
             }
-            _ => Err(parse_error(resp)),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("CreateMultipartUpload")),
+                resp,
+            )),
         }
     }
 
@@ -135,7 +146,10 @@ impl oio::MultipartWrite for TosWriter {
                     size: None,
                 })
             }
-            _ => Err(parse_error(resp)),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("UploadPart")),
+                resp,
+            )),
         }
     }
 
@@ -158,7 +172,8 @@ impl oio::MultipartWrite for TosWriter {
             .await?;
 
         let status = resp.status();
-        let mut meta = TosWriter::parse_header_into_meta(&self.path, resp.headers())?;
+        let mut meta =
+            TosWriter::parse_header_into_meta(&self.path, resp.headers())?.into_builder();
 
         match status {
             StatusCode::OK => {
@@ -171,15 +186,18 @@ impl oio::MultipartWrite for TosWriter {
                 if !ret.etag.is_empty() {
                     // CompleteMultipartUpload response wraps ETag in quotes:
                     // https://www.volcengine.com/docs/6349/74868
-                    meta.set_etag(ret.etag.trim_matches('"'));
+                    meta.etag(ret.etag.trim_matches('"'));
                 }
                 if !ret.version_id.is_empty() {
-                    meta.set_version(&ret.version_id);
+                    meta.version(&ret.version_id);
                 }
 
-                Ok(meta)
+                Ok(meta.build())
             }
-            _ => Err(parse_error(resp)),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("CompleteMultipartUpload")),
+                resp,
+            )),
         }
     }
 
@@ -191,7 +209,10 @@ impl oio::MultipartWrite for TosWriter {
 
         match resp.status() {
             StatusCode::NO_CONTENT => Ok(()),
-            _ => Err(parse_error(resp)),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("AbortMultipartUpload")),
+                resp,
+            )),
         }
     }
 }

data/core/services/upyun/Cargo.toml

@@ -38,7 +38,7 @@ hmac = "0.13.0"
 http = { workspace = true }
 log = { workspace = true }
 md-5 = "0.11.0"
-opendal-core = { path = "../../core", version = "0.58.1", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.0", default-features = false }
 quick-xml = { workspace = true, features = ["serialize", "overlapped-lists"] }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }