style: apply ruff formatting to entire codebase

Author: ServerSideHannes

s3proxy/app.py

@@ -50,9 +50,7 @@ def load_credentials() -> dict[str, str]:
     return credentials_store
 
 
-def create_lifespan(
-    settings: Settings, credentials_store: dict[str, str]
-) -> AsyncIterator[None]:
+def create_lifespan(settings: Settings, credentials_store: dict[str, str]) -> AsyncIterator[None]:
     """Create lifespan context manager for FastAPI app.
 
     Args:

s3proxy/client/s3.py

@@ -36,8 +36,6 @@ def _add_optional_kwargs(kwargs: dict[str, Any], **optional: Any) -> None:
             kwargs[key] = value
 
 
-
-
 class S3Client:
     """Async S3 client wrapper with async context manager lifecycle.
 

s3proxy/client/verifier.py

@@ -51,7 +51,7 @@ def _parse_v4_credential(
         try:
             parts = credential.split("/")
             access_key, date_stamp, region, service = parts[0], parts[1], parts[2], parts[3]
-        except (IndexError, ValueError):
+        except IndexError, ValueError:
             return None, "", "", "", "Invalid credential format"
 
         secret_key = self.credentials_store.get(access_key)
@@ -188,8 +188,10 @@ def _verify_presigned_v4(
             host_header = request.headers.get("host", "")
             if "host" in signed_headers_list:
                 alternate_host = (
-                    host_header[:-3] if host_header.endswith(":80")
-                    else host_header + ":80" if ":" not in host_header
+                    host_header[:-3]
+                    if host_header.endswith(":80")
+                    else host_header + ":80"
+                    if ":" not in host_header
                     else None
                 )
                 if alternate_host:
@@ -208,7 +210,11 @@ def _verify_presigned_v4(
                         modified_request, path, signed_headers_list, query_for_signing
                     )
                     calculated_sig_alt = self._compute_v4_signature(
-                        canonical_request_alt, amz_date, date_stamp, region, service,
+                        canonical_request_alt,
+                        amz_date,
+                        date_stamp,
+                        region,
+                        service,
                         credentials.secret_key,
                     )
                     if hmac.compare_digest(calculated_sig_alt, signature):

s3proxy/concurrency.py

@@ -35,7 +35,7 @@ def _create_malloc_release() -> Callable[[], int] | None:
         libc.malloc_trim.argtypes = [ctypes.c_size_t]
         libc.malloc_trim.restype = ctypes.c_int
         return lambda: libc.malloc_trim(0)
-    except (OSError, AttributeError):
+    except OSError, AttributeError:
         return None
 
 
@@ -87,8 +87,12 @@ async def try_acquire(self, bytes_needed: int) -> int:
                 active_mb = self._active_bytes / 1024 / 1024
                 request_mb = to_reserve / 1024 / 1024
                 limit_mb = self._limit_bytes / 1024 / 1024
-                logger.warning("MEMORY_REJECTED", active_mb=round(active_mb, 2),
-                             requested_mb=round(request_mb, 2), limit_mb=round(limit_mb, 2))
+                logger.warning(
+                    "MEMORY_REJECTED",
+                    active_mb=round(active_mb, 2),
+                    requested_mb=round(request_mb, 2),
+                    limit_mb=round(limit_mb, 2),
+                )
                 MEMORY_REJECTIONS.inc()
                 raise S3Error.slow_down(
                     f"Memory limit: {active_mb:.0f}MB + {request_mb:.0f}MB > {limit_mb:.0f}MB"
@@ -120,9 +124,7 @@ async def release(self, bytes_reserved: int) -> None:
 
 
 # Default instance used by module-level functions
-_default = ConcurrencyLimiter(
-    limit_mb=int(os.environ.get("S3PROXY_MEMORY_LIMIT_MB", "128"))
-)
+_default = ConcurrencyLimiter(limit_mb=int(os.environ.get("S3PROXY_MEMORY_LIMIT_MB", "128")))
 
 
 def estimate_memory_footprint(method: str, content_length: int) -> int:

s3proxy/errors.py

@@ -161,6 +161,7 @@ def not_implemented(cls, message: str = "Not Implemented") -> S3Error:
     def slow_down(cls, message: str = "Please reduce your request rate.") -> S3Error:
         return cls(503, "SlowDown", message)
 
+
 def get_s3_error_code(status_code: int, detail: str | None = None) -> str:
     """Get S3 error code from HTTP status code and message.
 

s3proxy/handlers/base.py

@@ -159,9 +159,7 @@ def _extract_conditional_headers(
             request.headers.get("if-unmodified-since"),
         )
 
-    async def _safe_abort(
-        self, client: S3Client, bucket: str, key: str, upload_id: str
-    ) -> None:
+    async def _safe_abort(self, client: S3Client, bucket: str, key: str, upload_id: str) -> None:
         try:
             await client.abort_multipart_upload(bucket, key, upload_id)
             logger.info(
@@ -170,7 +168,9 @@ async def _safe_abort(
         except Exception as e:
             logger.warning(
                 "MULTIPART_ABORT_FAILED",
-                bucket=bucket, key=key, upload_id=upload_id[:20] + "...",
+                bucket=bucket,
+                key=key,
+                upload_id=upload_id[:20] + "...",
                 error=str(e),
             )
 

s3proxy/handlers/buckets.py

@@ -39,7 +39,6 @@ def _strip_minio_cache_suffix(value: str | None) -> str | None:
 
 
 class BucketHandlerMixin(BaseHandler):
-
     async def handle_list_buckets(self, request: Request, creds: S3Credentials) -> Response:
         async with self._client(creds) as client:
             try:
@@ -358,6 +357,7 @@ async def handle_delete_objects(self, request: Request, creds: S3Credentials) ->
 
                 # Clean up multipart metadata for all deleted objects in parallel
                 if deleted_items:
+
                     async def safe_delete_metadata(key: str) -> None:
                         with contextlib.suppress(Exception):
                             await delete_multipart_metadata(client, bucket, key)

s3proxy/handlers/multipart/copy.py

@@ -22,7 +22,6 @@
 
 
 class CopyPartMixin(BaseHandler):
-
     async def handle_upload_part_copy(self, request: Request, creds: S3Credentials) -> Response:
         bucket, key = self._parse_path(request.url.path)
         async with self._client(creds) as client:
@@ -52,10 +51,11 @@ async def handle_upload_part_copy(self, request: Request, creds: S3Credentials)
 
             body_md5 = hashlib.md5(plaintext, usedforsecurity=False).hexdigest()
             await self.multipart_manager.add_part(
-                bucket, key, upload_id,
+                bucket,
+                key,
+                upload_id,
                 PartMetadata(
-                    part_num, len(plaintext), len(ciphertext),
-                    resp["ETag"].strip('"'), body_md5
+                    part_num, len(plaintext), len(ciphertext), resp["ETag"].strip('"'), body_md5
                 ),
             )
 

s3proxy/handlers/multipart/lifecycle.py

@@ -34,15 +34,17 @@
 
 
 class LifecycleMixin(BaseHandler):
-
     async def _recover_upload_state(
         self, client: S3Client, bucket: str, key: str, upload_id: str, context: str = ""
     ) -> MultipartUploadState:
         from s3proxy.state import reconstruct_upload_state_from_s3
 
         logger.warning(
             "RECOVER_STATE_FROM_S3",
-            bucket=bucket, key=key, upload_id=upload_id[:20] + "...", context=context,
+            bucket=bucket,
+            key=key,
+            upload_id=upload_id[:20] + "...",
+            context=context,
         )
 
         state = await reconstruct_upload_state_from_s3(
@@ -54,7 +56,9 @@ async def _recover_upload_state(
         await self.multipart_manager.store_reconstructed_state(bucket, key, upload_id, state)
         logger.info(
             "RECOVER_STATE_SUCCESS",
-            bucket=bucket, key=key, upload_id=upload_id[:20] + "...",
+            bucket=bucket,
+            key=key,
+            upload_id=upload_id[:20] + "...",
             parts_recovered=len(state.parts),
         )
         return state
@@ -83,7 +87,8 @@ async def handle_create_multipart_upload(
                     upload_metadata[hdr[11:]] = val
 
             resp = await client.create_multipart_upload(
-                bucket, key,
+                bucket,
+                key,
                 content_type=content_type,
                 metadata=upload_metadata,
                 tagging=tagging,
@@ -104,19 +109,25 @@ async def handle_create_multipart_upload(
                     if attempt == 0:
                         logger.warning(
                             "PERSIST_STATE_RETRY",
-                            bucket=bucket, key=key, upload_id=upload_id[:20] + "...",
+                            bucket=bucket,
+                            key=key,
+                            upload_id=upload_id[:20] + "...",
                             error=str(e),
                         )
                     else:
                         logger.error(
                             "PERSIST_STATE_FAILED",
-                            bucket=bucket, key=key, upload_id=upload_id[:20] + "...",
+                            bucket=bucket,
+                            key=key,
+                            upload_id=upload_id[:20] + "...",
                             error=str(e),
                         )
 
             logger.info(
                 "CREATE_MULTIPART_COMPLETE",
-                bucket=bucket, key=key, upload_id=upload_id[:20] + "...",
+                bucket=bucket,
+                key=key,
+                upload_id=upload_id[:20] + "...",
             )
 
             return Response(
@@ -146,7 +157,9 @@ async def handle_complete_multipart_upload(
 
             logger.info(
                 "COMPLETE_MULTIPART",
-                bucket=bucket, key=key, upload_id=upload_id[:20] + "...",
+                bucket=bucket,
+                key=key,
+                upload_id=upload_id[:20] + "...",
                 client_parts=len(completed_parts),
                 s3_parts=len(s3_parts),
                 total_mb=f"{total_plaintext / 1024 / 1024:.2f}MB",
@@ -166,7 +179,9 @@ async def handle_complete_multipart_upload(
             # lose the DEK, making the object permanently undecryptable.
             wrapped_dek = crypto.wrap_key(state.dek, self.settings.kek)
             await save_multipart_metadata(
-                client, bucket, key,
+                client,
+                bucket,
+                key,
                 MultipartMetadata(
                     version=1,
                     part_count=len(completed_parts),
@@ -179,7 +194,9 @@ async def handle_complete_multipart_upload(
 
             logger.info(
                 "COMPLETE_MULTIPART_SUCCESS",
-                bucket=bucket, key=key, upload_id=upload_id[:20] + "...",
+                bucket=bucket,
+                key=key,
+                upload_id=upload_id[:20] + "...",
                 total_parts=len(completed_parts),
                 total_mb=f"{total_plaintext / 1024 / 1024:.2f}MB",
             )
@@ -214,7 +231,9 @@ def internal_to_client_part(internal_part_number: int) -> int:
                 # Upload exists but DEK is missing - internal state corruption
                 logger.error(
                     "RECOVER_DEK_MISSING",
-                    bucket=bucket, key=key, upload_id=upload_id[:20] + "...",
+                    bucket=bucket,
+                    key=key,
+                    upload_id=upload_id[:20] + "...",
                     message="Upload exists in S3 but DEK state is missing",
                 )
             except Exception:
@@ -236,7 +255,9 @@ def internal_to_client_part(internal_part_number: int) -> int:
 
             logger.debug(
                 "RECOVER_STATE_GROUPING",
-                bucket=bucket, key=key, upload_id=upload_id[:20] + "...",
+                bucket=bucket,
+                key=key,
+                upload_id=upload_id[:20] + "...",
                 s3_parts=len(parts_resp.get("Parts", [])),
                 client_parts=sorted(client_parts.keys()),
             )
@@ -255,22 +276,29 @@ def internal_to_client_part(internal_part_number: int) -> int:
                     plaintext_size = crypto.plaintext_size(ciphertext_size)
                     etag = s3_part.get("ETag", "").strip('"')
 
-                    internal_parts_meta.append(InternalPartMetadata(
-                        internal_part_number=internal_num,
-                        plaintext_size=plaintext_size,
-                        ciphertext_size=ciphertext_size,
-                        etag=etag,
-                    ))
+                    internal_parts_meta.append(
+                        InternalPartMetadata(
+                            internal_part_number=internal_num,
+                            plaintext_size=plaintext_size,
+                            ciphertext_size=ciphertext_size,
+                            etag=etag,
+                        )
+                    )
                     part_plaintext_size += plaintext_size
                     part_ciphertext_size += ciphertext_size
 
                 first_etag = internal_s3_parts[0].get("ETag", "").strip('"')
 
                 await self.multipart_manager.add_part(
-                    bucket, key, upload_id,
+                    bucket,
+                    key,
+                    upload_id,
                     PartMetadata(
-                        client_part_num, part_plaintext_size, part_ciphertext_size,
-                        first_etag, "",
+                        client_part_num,
+                        part_plaintext_size,
+                        part_ciphertext_size,
+                        first_etag,
+                        "",
                         internal_parts=internal_parts_meta,
                     ),
                 )
@@ -279,7 +307,9 @@ def internal_to_client_part(internal_part_number: int) -> int:
         except Exception as e:
             logger.error(
                 "RECOVER_STATE_FOR_COMPLETE_FAILED",
-                bucket=bucket, key=key, upload_id=upload_id[:20] + "...",
+                bucket=bucket,
+                key=key,
+                upload_id=upload_id[:20] + "...",
                 error=str(e),
             )
         return state
@@ -320,22 +350,24 @@ def _build_s3_parts(
                     )
                     for ip in sorted_internal:
                         etag = f'"{ip.etag}"' if not ip.etag.startswith('"') else ip.etag
-                        s3_parts.append({
-                            "PartNumber": ip.internal_part_number,
-                            "ETag": etag,
-                        })
+                        s3_parts.append(
+                            {
+                                "PartNumber": ip.internal_part_number,
+                                "ETag": etag,
+                            }
+                        )
                 else:
-                    s3_parts.append({
-                        "PartNumber": client_part_num,
-                        "ETag": cp["ETag"],
-                    })
+                    s3_parts.append(
+                        {
+                            "PartNumber": client_part_num,
+                            "ETag": cp["ETag"],
+                        }
+                    )
             else:
                 missing_parts.append(client_part_num)
 
         if missing_parts:
-            raise S3Error.invalid_part(
-                f"Parts {missing_parts} were never uploaded"
-            )
+            raise S3Error.invalid_part(f"Parts {missing_parts} were never uploaded")
         if not s3_parts:
             raise S3Error.invalid_part("No valid parts found")
 
@@ -357,8 +389,11 @@ async def _handle_complete_error(
         if error_code == "EntityTooSmall":
             logger.warning(
                 "ENTITY_TOO_SMALL",
-                bucket=bucket, key=key, upload_id=upload_id[:20] + "...",
-                parts=len(s3_parts), total_plaintext=total_plaintext,
+                bucket=bucket,
+                key=key,
+                upload_id=upload_id[:20] + "...",
+                parts=len(s3_parts),
+                total_plaintext=total_plaintext,
             )
             with contextlib.suppress(Exception):
                 await client.abort_multipart_upload(bucket, key, upload_id)
@@ -380,7 +415,9 @@ async def handle_abort_multipart_upload(
 
             logger.info(
                 "ABORT_MULTIPART",
-                bucket=bucket, key=key, upload_id=upload_id[:20] + "...",
+                bucket=bucket,
+                key=key,
+                upload_id=upload_id[:20] + "...",
             )
 
             await asyncio.gather(