zerobucket 0.1.0__py3-none-any.whl

zerobucket/__init__.py

@@ -0,0 +1,34 @@
+"""ZeroBucket: database-native image storage.
+
+    from zerobucket import ZeroBucket
+    images = ZeroBucket(database_url="postgresql://...")
+    image_id = images.put("avatar.jpg")
+    image = images.get(image_id)
+"""
+
+from .client import ZeroBucket
+from .exceptions import (
+    CorruptedImageError,
+    ImageNotFoundError,
+    ImageTooLargeError,
+    ImageValidationError,
+    StorageError,
+    UnsupportedFormatError,
+    ZeroBucketError,
+)
+from .types import Image, ImageMetadata
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "ZeroBucket",
+    "Image",
+    "ImageMetadata",
+    "ZeroBucketError",
+    "ImageValidationError",
+    "ImageTooLargeError",
+    "UnsupportedFormatError",
+    "CorruptedImageError",
+    "ImageNotFoundError",
+    "StorageError",
+]

zerobucket/adapters/__init__.py

@@ -0,0 +1,9 @@
+from .base import StorageBackend, StoredRecord, StoredRecordMetadata
+from .postgres import PostgresBackend
+
+__all__ = [
+    "StorageBackend",
+    "StoredRecord",
+    "StoredRecordMetadata",
+    "PostgresBackend",
+]

zerobucket/adapters/base.py

@@ -0,0 +1,80 @@
+"""Storage backend interface.
+
+CRITICAL DESIGN RULE: implementations of this interface know nothing about
+images. They store and retrieve rows of bytes + metadata columns. All
+image-specific logic (validation, format detection, resizing) lives in
+zerobucket.client, above this layer.
+
+This separation is what makes a future object-storage backend a real
+drop-in replacement rather than a rewrite.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class StoredRecord:
+    """Raw record shape as persisted by a storage backend."""
+
+    id: str
+    data: bytes
+    mime_type: str
+    original_filename: str | None
+    size_bytes: int
+    width: int | None
+    height: int | None
+    checksum_sha256: str
+
+
+@dataclass(frozen=True, slots=True)
+class StoredRecordMetadata:
+    """Same as StoredRecord but without `data`, for cheap existence/info checks."""
+
+    id: str
+    mime_type: str
+    original_filename: str | None
+    size_bytes: int
+    width: int | None
+    height: int | None
+    checksum_sha256: str
+
+
+class StorageBackend(ABC):
+    """Abstract interface every ZeroBucket storage adapter must implement."""
+
+    @abstractmethod
+    def put(
+        self,
+        *,
+        data: bytes,
+        mime_type: str,
+        original_filename: str | None,
+        size_bytes: int,
+        width: int | None,
+        height: int | None,
+        checksum_sha256: str,
+    ) -> str:
+        """Persist a record and return its generated id."""
+
+    @abstractmethod
+    def get(self, image_id: str) -> StoredRecord | None:
+        """Fetch a full record including bytes, or None if it doesn't exist."""
+
+    @abstractmethod
+    def get_metadata(self, image_id: str) -> StoredRecordMetadata | None:
+        """Fetch metadata only (no bytes), or None if it doesn't exist."""
+
+    @abstractmethod
+    def delete(self, image_id: str) -> bool:
+        """Delete a record. Returns True if a record was deleted, False if it didn't exist."""
+
+    @abstractmethod
+    def exists(self, image_id: str) -> bool:
+        """Return whether a record with this id exists."""
+
+    @abstractmethod
+    def close(self) -> None:
+        """Release underlying connections/resources."""

zerobucket/adapters/postgres.py

@@ -0,0 +1,172 @@
+"""PostgreSQL storage adapter.
+
+Stores image bytes directly in a BYTEA column. All queries are
+parameterized; nothing is ever built via string concatenation.
+"""
+
+from __future__ import annotations
+
+from psycopg_pool import ConnectionPool
+
+from ..exceptions import StorageError
+from .base import StorageBackend, StoredRecord, StoredRecordMetadata
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS zerobucket_images (
+    id                  UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    data                BYTEA NOT NULL,
+    mime_type           TEXT NOT NULL,
+    original_filename   TEXT,
+    size_bytes          INTEGER NOT NULL,
+    width               INTEGER,
+    height              INTEGER,
+    checksum_sha256     CHAR(64) NOT NULL,
+    created_at          TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at          TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE INDEX IF NOT EXISTS idx_zerobucket_checksum ON zerobucket_images (checksum_sha256);
+CREATE INDEX IF NOT EXISTS idx_zerobucket_created_at ON zerobucket_images (created_at);
+"""
+
+_INSERT = """
+INSERT INTO zerobucket_images
+    (data, mime_type, original_filename, size_bytes, width, height, checksum_sha256)
+VALUES (%s, %s, %s, %s, %s, %s, %s)
+RETURNING id;
+"""
+
+_SELECT_FULL = """
+SELECT id, data, mime_type, original_filename, size_bytes, width, height, checksum_sha256
+FROM zerobucket_images
+WHERE id = %s;
+"""
+
+_SELECT_METADATA = """
+SELECT id, mime_type, original_filename, size_bytes, width, height, checksum_sha256
+FROM zerobucket_images
+WHERE id = %s;
+"""
+
+_DELETE = "DELETE FROM zerobucket_images WHERE id = %s;"
+
+_EXISTS = "SELECT 1 FROM zerobucket_images WHERE id = %s;"
+
+
+class PostgresBackend(StorageBackend):
+    """Storage backend for PostgreSQL using BYTEA columns.
+
+    Requires the pgcrypto extension (for gen_random_uuid()) on Postgres < 13.
+    Postgres 13+ has gen_random_uuid() built in.
+    """
+
+    def __init__(self, database_url: str, *, auto_migrate: bool = True) -> None:
+        try:
+            self._pool = ConnectionPool(
+                database_url, min_size=1, max_size=5, open=True, timeout=10
+            )
+        except Exception as exc:  # noqa: BLE001
+            raise StorageError(f"Could not connect to PostgreSQL: {exc}") from exc
+
+        if auto_migrate:
+            try:
+                self.migrate()
+            except Exception:
+                # Don't leak the pool's background worker threads if setup
+                # fails partway through -- close it before propagating so
+                # callers (and test runners) don't hang on shutdown.
+                self._pool.close()
+                raise
+
+    def migrate(self) -> None:
+        """Create the zerobucket_images table and indexes if they don't exist."""
+        try:
+            with self._pool.connection() as conn, conn.cursor() as cur:
+                cur.execute(_SCHEMA)
+        except Exception as exc:  # noqa: BLE001
+            raise StorageError(f"Migration failed: {exc}") from exc
+
+    def put(
+        self,
+        *,
+        data: bytes,
+        mime_type: str,
+        original_filename: str | None,
+        size_bytes: int,
+        width: int | None,
+        height: int | None,
+        checksum_sha256: str,
+    ) -> str:
+        try:
+            with self._pool.connection() as conn, conn.cursor() as cur:
+                params = (
+                    data,
+                    mime_type,
+                    original_filename,
+                    size_bytes,
+                    width,
+                    height,
+                    checksum_sha256,
+                )
+                cur.execute(_INSERT, params)
+                row = cur.fetchone()
+                return str(row[0])
+        except Exception as exc:  # noqa: BLE001
+            raise StorageError(f"Failed to store image: {exc}") from exc
+
+    def get(self, image_id: str) -> StoredRecord | None:
+        try:
+            with self._pool.connection() as conn, conn.cursor() as cur:
+                cur.execute(_SELECT_FULL, (image_id,))
+                row = cur.fetchone()
+        except Exception as exc:  # noqa: BLE001
+            raise StorageError(f"Failed to retrieve image: {exc}") from exc
+        if row is None:
+            return None
+        return StoredRecord(
+            id=str(row[0]),
+            data=bytes(row[1]),
+            mime_type=row[2],
+            original_filename=row[3],
+            size_bytes=row[4],
+            width=row[5],
+            height=row[6],
+            checksum_sha256=row[7],
+        )
+
+    def get_metadata(self, image_id: str) -> StoredRecordMetadata | None:
+        try:
+            with self._pool.connection() as conn, conn.cursor() as cur:
+                cur.execute(_SELECT_METADATA, (image_id,))
+                row = cur.fetchone()
+        except Exception as exc:  # noqa: BLE001
+            raise StorageError(f"Failed to retrieve image metadata: {exc}") from exc
+        if row is None:
+            return None
+        return StoredRecordMetadata(
+            id=str(row[0]),
+            mime_type=row[1],
+            original_filename=row[2],
+            size_bytes=row[3],
+            width=row[4],
+            height=row[5],
+            checksum_sha256=row[6],
+        )
+
+    def delete(self, image_id: str) -> bool:
+        try:
+            with self._pool.connection() as conn, conn.cursor() as cur:
+                cur.execute(_DELETE, (image_id,))
+                return cur.rowcount > 0
+        except Exception as exc:  # noqa: BLE001
+            raise StorageError(f"Failed to delete image: {exc}") from exc
+
+    def exists(self, image_id: str) -> bool:
+        try:
+            with self._pool.connection() as conn, conn.cursor() as cur:
+                cur.execute(_EXISTS, (image_id,))
+                return cur.fetchone() is not None
+        except Exception as exc:  # noqa: BLE001
+            raise StorageError(f"Failed to check image existence: {exc}") from exc
+
+    def close(self) -> None:
+        self._pool.close()

zerobucket/client.py

@@ -0,0 +1,165 @@
+"""The public ZeroBucket SDK entry point.
+
+    from zerobucket import ZeroBucket
+    images = ZeroBucket(database_url="postgresql://...")
+    image_id = images.put("avatar.jpg")
+    image = images.get(image_id)
+
+The developer never needs to think about BYTEA, checksums, or connection
+pooling -- that's all handled below.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+from pathlib import Path
+from typing import BinaryIO, Union
+
+from .adapters.base import StorageBackend
+from .adapters.postgres import PostgresBackend
+from .exceptions import ImageNotFoundError
+from .types import Image, ImageMetadata
+from .validation import DEFAULT_MAX_PIXELS, SUPPORTED_FORMATS, validate_image
+
+# What put() accepts. Framework upload objects (e.g. Flask's FileStorage,
+# FastAPI's UploadFile) are duck-typed against BinaryIO via .read().
+ImageInput = Union[str, "os.PathLike[str]", bytes, BinaryIO]
+
+# 8 MiB. Chosen as a practical ceiling for "small app" images (see README
+# for rationale); pass max_bytes= to override per-instance.
+DEFAULT_MAX_BYTES = 8 * 1024 * 1024
+
+
+class ZeroBucket:
+    """Database-native image storage.
+
+    Args:
+        database_url: PostgreSQL connection string.
+        max_bytes: Maximum accepted image size in bytes. Defaults to 8 MiB.
+            ZeroBucket stores full images in a database column; it is not
+            designed for arbitrarily large files. See the README for why.
+        max_pixels: Decoded-pixel ceiling used to reject decompression
+            bombs, independent of compressed file size.
+        allowed_formats: Which image formats to accept. Defaults to
+            JPEG/PNG/WebP.
+        backend: Advanced -- inject a custom StorageBackend instead of
+            constructing a PostgresBackend from database_url.
+    """
+
+    def __init__(
+        self,
+        database_url: str | None = None,
+        *,
+        max_bytes: int = DEFAULT_MAX_BYTES,
+        max_pixels: int = DEFAULT_MAX_PIXELS,
+        allowed_formats: frozenset[str] = SUPPORTED_FORMATS,
+        backend: StorageBackend | None = None,
+    ) -> None:
+        if backend is not None:
+            self._backend = backend
+        elif database_url is not None:
+            self._backend = PostgresBackend(database_url)
+        else:
+            raise ValueError("Either database_url or backend must be provided")
+
+        self._max_bytes = max_bytes
+        self._max_pixels = max_pixels
+        self._allowed_formats = allowed_formats
+
+    def put(self, image: ImageInput, *, filename: str | None = None) -> str:
+        """Validate, process, and store an image. Returns its id.
+
+        Accepts a file path (str or PathLike), raw bytes, or any
+        file-like object with a .read() method.
+        """
+        data, resolved_filename = _read_image_input(image, filename)
+
+        validated = validate_image(
+            data,
+            max_bytes=self._max_bytes,
+            max_pixels=self._max_pixels,
+            allowed_formats=self._allowed_formats,
+        )
+        checksum = hashlib.sha256(data).hexdigest()
+
+        return self._backend.put(
+            data=data,
+            mime_type=validated.mime_type,
+            original_filename=resolved_filename,
+            size_bytes=validated.size_bytes,
+            width=validated.width,
+            height=validated.height,
+            checksum_sha256=checksum,
+        )
+
+    def get(self, image_id: str) -> Image:
+        """Retrieve a full image, including bytes. Raises ImageNotFoundError if missing."""
+        record = self._backend.get(image_id)
+        if record is None:
+            raise ImageNotFoundError(image_id)
+        return Image(
+            data=record.data,
+            mime_type=record.mime_type,
+            filename=record.original_filename,
+            size_bytes=record.size_bytes,
+            width=record.width,
+            height=record.height,
+            checksum_sha256=record.checksum_sha256,
+        )
+
+    def metadata(self, image_id: str) -> ImageMetadata:
+        """Retrieve image metadata without pulling the (potentially large) bytes."""
+        record = self._backend.get_metadata(image_id)
+        if record is None:
+            raise ImageNotFoundError(image_id)
+        return ImageMetadata(
+            image_id=record.id,
+            mime_type=record.mime_type,
+            filename=record.original_filename,
+            size_bytes=record.size_bytes,
+            width=record.width,
+            height=record.height,
+            checksum_sha256=record.checksum_sha256,
+        )
+
+    def exists(self, image_id: str) -> bool:
+        """Return whether an image with this id exists."""
+        return self._backend.exists(image_id)
+
+    def delete(self, image_id: str) -> bool:
+        """Delete an image. Returns True if it existed and was deleted, False otherwise."""
+        return self._backend.delete(image_id)
+
+    def close(self) -> None:
+        """Release underlying database connections."""
+        self._backend.close()
+
+    def __enter__(self) -> ZeroBucket:
+        return self
+
+    def __exit__(self, *exc_info: object) -> None:
+        self.close()
+
+
+def _read_image_input(
+    image: ImageInput, filename: str | None
+) -> tuple[bytes, str | None]:
+    """Normalize any accepted input type into (bytes, filename)."""
+    if isinstance(image, bytes):
+        return image, filename
+    if isinstance(image, (str, os.PathLike)):
+        path = Path(image)
+        data = path.read_bytes()
+        return data, filename or path.name
+    if hasattr(image, "read"):
+        data = image.read()
+        if isinstance(data, str):
+            raise TypeError("File-like object must be opened in binary mode")
+        raw_name = getattr(image, "filename", None) or getattr(image, "name", None)
+        resolved_filename = filename or (os.path.basename(raw_name) if raw_name else None)
+        return data, resolved_filename
+    raise TypeError(
+        f"Unsupported image input type: {type(image)!r}. "
+        "Expected a file path, bytes, or a file-like object with .read()."
+    )

zerobucket/exceptions.py

@@ -0,0 +1,54 @@
+"""Exception hierarchy for ZeroBucket.
+
+All exceptions inherit from ZeroBucketError so callers can catch broadly
+(`except ZeroBucketError`) or narrowly (`except ImageNotFoundError`).
+"""
+
+from __future__ import annotations
+
+
+class ZeroBucketError(Exception):
+    """Base class for all ZeroBucket exceptions."""
+
+
+class ImageValidationError(ZeroBucketError):
+    """Raised when an image fails validation (bad format, too large, corrupted, etc.)."""
+
+
+class ImageTooLargeError(ImageValidationError):
+    """Raised when an image exceeds the configured maximum size."""
+
+    def __init__(self, size_bytes: int, max_bytes: int) -> None:
+        self.size_bytes = size_bytes
+        self.max_bytes = max_bytes
+        super().__init__(
+            f"Image is {size_bytes} bytes, which exceeds the maximum of {max_bytes} bytes"
+        )
+
+
+class UnsupportedFormatError(ImageValidationError):
+    """Raised when an image's detected format is not in the allowed set."""
+
+    def __init__(self, detected_format: str | None, allowed: frozenset[str]) -> None:
+        self.detected_format = detected_format
+        self.allowed = allowed
+        super().__init__(
+            f"Detected format {detected_format!r} is not supported. "
+            f"Allowed formats: {sorted(allowed)}"
+        )
+
+
+class CorruptedImageError(ImageValidationError):
+    """Raised when image bytes cannot be decoded despite having a recognizable header."""
+
+
+class ImageNotFoundError(ZeroBucketError):
+    """Raised when get() or metadata() is called with an image_id that doesn't exist."""
+
+    def __init__(self, image_id: str) -> None:
+        self.image_id = image_id
+        super().__init__(f"No image found with id {image_id!r}")
+
+
+class StorageError(ZeroBucketError):
+    """Raised for underlying storage/database failures not covered above."""

zerobucket/types.py

@@ -0,0 +1,43 @@
+"""Public data types returned by the ZeroBucket SDK.
+
+These are the only shapes callers should depend on. Internal storage
+representation (BYTEA, column layout, etc.) is never exposed here.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class Image:
+    """A retrieved image, ready to be served or written to disk.
+
+    `data` is raw bytes -- never Base64. Serving it from a web framework
+    is just: Response(image.data, mimetype=image.mime_type)
+    """
+
+    data: bytes
+    mime_type: str
+    filename: str | None
+    size_bytes: int
+    width: int | None
+    height: int | None
+    checksum_sha256: str
+
+
+@dataclass(frozen=True, slots=True)
+class ImageMetadata:
+    """Metadata about a stored image, without the pixel data itself.
+
+    Useful for existence/info checks that shouldn't pull potentially
+    multi-megabyte blobs over the wire.
+    """
+
+    image_id: str
+    mime_type: str
+    filename: str | None
+    size_bytes: int
+    width: int | None
+    height: int | None
+    checksum_sha256: str

zerobucket/validation.py

@@ -0,0 +1,103 @@
+"""Image validation.
+
+Deliberately does NOT trust file extensions or client-supplied MIME types.
+The actual bytes are decoded with Pillow and the *detected* format is what
+gets validated and stored. This is the only source of truth.
+"""
+
+from __future__ import annotations
+
+import io
+from dataclasses import dataclass
+
+from PIL import Image as PILImage
+
+from .exceptions import (
+    CorruptedImageError,
+    ImageTooLargeError,
+    UnsupportedFormatError,
+)
+
+# Pillow format name -> canonical MIME type. Deliberately small allowlist;
+# extend this (and SUPPORTED_FORMATS) to add formats, never bypass it.
+_FORMAT_TO_MIME = {
+    "JPEG": "image/jpeg",
+    "PNG": "image/png",
+    "WEBP": "image/webp",
+}
+
+SUPPORTED_FORMATS = frozenset(_FORMAT_TO_MIME)
+
+# Guard against decompression bombs: reject images that would decode to
+# more than this many pixels, regardless of how small the compressed
+# bytes are. ~89 megapixels ~= a 12000x7400 image.
+DEFAULT_MAX_PIXELS = 89_000_000
+
+
+@dataclass(frozen=True, slots=True)
+class ValidatedImage:
+    """Result of successful validation: everything derived from the bytes."""
+
+    mime_type: str
+    width: int
+    height: int
+    size_bytes: int
+
+
+def validate_image(
+    data: bytes,
+    *,
+    max_bytes: int,
+    max_pixels: int = DEFAULT_MAX_PIXELS,
+    allowed_formats: frozenset[str] = SUPPORTED_FORMATS,
+) -> ValidatedImage:
+    """Validate raw image bytes and return derived metadata.
+
+    Raises ImageTooLargeError, UnsupportedFormatError, or CorruptedImageError.
+    Never raises for reasons unrelated to the image itself.
+    """
+    size_bytes = len(data)
+    if size_bytes > max_bytes:
+        raise ImageTooLargeError(size_bytes, max_bytes)
+    if size_bytes == 0:
+        raise CorruptedImageError("Image data is empty")
+
+    # Pillow's own decompression-bomb guard, in pixels (not compressed bytes).
+    # We set it per-call rather than mutating the module-global so concurrent
+    # validate_image() calls with different limits don't race each other.
+    original_max_pixels = PILImage.MAX_IMAGE_PIXELS
+    try:
+        PILImage.MAX_IMAGE_PIXELS = max_pixels
+        try:
+            with PILImage.open(io.BytesIO(data)) as img:
+                detected_format = img.format
+                if detected_format not in allowed_formats:
+                    raise UnsupportedFormatError(detected_format, allowed_formats)
+                width, height = img.size
+                # .verify() only checks structural integrity; it does not
+                # decode pixel data (and Pillow requires reopening after
+                # calling it). Force a full pixel decode below to catch
+                # truncated/corrupted image bodies, not just bad headers.
+        except UnsupportedFormatError:
+            raise
+        except PILImage.DecompressionBombError as exc:
+            raise ImageTooLargeError(size_bytes, max_bytes) from exc
+        except Exception as exc:  # noqa: BLE001 - Pillow raises many exception types
+            raise CorruptedImageError(f"Could not decode image: {exc}") from exc
+
+        # Force full pixel decode to catch truncated image bodies that pass
+        # header parsing but fail partway through the data.
+        try:
+            with PILImage.open(io.BytesIO(data)) as img:
+                img.load()
+        except Exception as exc:  # noqa: BLE001
+            raise CorruptedImageError(f"Image data is truncated or corrupted: {exc}") from exc
+    finally:
+        PILImage.MAX_IMAGE_PIXELS = original_max_pixels
+
+    return ValidatedImage(
+        mime_type=_FORMAT_TO_MIME[detected_format],
+        width=width,
+        height=height,
+        size_bytes=size_bytes,
+    )

zerobucket-0.1.0.dist-info/METADATA

@@ -0,0 +1,31 @@
+Metadata-Version: 2.5
+Name: zerobucket
+Version: 0.1.0
+Summary: Database-native image storage. Your database. Your images. Zero buckets.
+Project-URL: Homepage, https://github.com/KedarGhadyalji/ZeroBucket
+Project-URL: Repository, https://github.com/KedarGhadyalji/ZeroBucket
+Author-email: Kedar Ghadyalji <kedarghadyalji@gmail.com>
+License-Expression: MIT
+Keywords: bytea,image,postgresql,s3-alternative,storage
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database
+Classifier: Topic :: Multimedia :: Graphics
+Requires-Python: >=3.10
+Requires-Dist: pillow>=10.0
+Requires-Dist: psycopg-pool>=3.2
+Requires-Dist: psycopg[binary]>=3.1
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# zerobucket
+
+Database-native image storage. See the repository root README for full docs.

zerobucket-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+zerobucket/__init__.py,sha256=opwT-a0m8sayhLZYKLngwpjvywJYKhqXxmzR85RvUmc,755
+zerobucket/client.py,sha256=c6x_tOHfTH7MNIOnKq4HDuyj8e5lIa5oZkTn3K0Kxps,6028
+zerobucket/exceptions.py,sha256=OEreRbHRQMHnh1n0jWYmoOyBXOwJfGa6Cb__6VB93cY,1819
+zerobucket/types.py,sha256=1EMrqTIuWQ5b8XMYtmseYxbLrMqJrgtMfYZuLMtBsyo,1073
+zerobucket/validation.py,sha256=0viA57YMZp4r-UrouawDHaslieP_pU9aFdaUGc8JQxw,3663
+zerobucket/adapters/__init__.py,sha256=pjl6-FkFNqtCN2A9O7H8jIC1ZkerZSaGsfNj2hC2ezA,215
+zerobucket/adapters/base.py,sha256=hVwHmjHtRoFAtJfDesq0P8ARLMxNZePugq_CUB1PA7o,2260
+zerobucket/adapters/postgres.py,sha256=GbmnAWEZC8OT0twKg0XK9z9zQBDF8EzgrYD2glBptbM,5968
+zerobucket-0.1.0.dist-info/METADATA,sha256=1Xg0wE-AqsQHrPIH4-Fei3mmLXFslbGU24JlUsd_B4o,1223
+zerobucket-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+zerobucket-0.1.0.dist-info/RECORD,,

zerobucket-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any