release: 1.0.0

first stable release. pre-1.0.0 verification complete: all surviving MED regressions and
gaps resolved and independently re-fired, tree audited clean across the suite.

Signed-off-by: disqualifier <dev@disqualifier.me>

README.md

@@ -9,7 +9,7 @@ bites you.
 ## Install
 
 ```
-dpy_cache @ git+ssh://git@git.rethinkstudios.io/rethink-public/dpy_cache.git@v1.2.0
+dpy_cache @ git+ssh://git@git.rethinkstudios.io/rethink-public/dpy_cache.git@v0.1.2
 ```
 
 ## Usage

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dpy_cache"
-version = "1.2.0"
+version = "1.0.0"
 description = "Persist images/files to a Discord storage channel and get durable, re-resolvable CDN references — config-free, injectable, installable."
 requires-python = ">=3.10"
 dependencies = [

src/dpy_cache/__init__.py

@@ -6,7 +6,6 @@ from importlib.metadata import PackageNotFoundError, version
 
 from .dpy_cache import (
     MAX_ATTACHMENTS_PER_MESSAGE,
-    MAX_CACHE_URL_BYTES,
     CacheResult,
     DPYCache,
     DPYCacheError,
@@ -26,6 +25,5 @@ __all__ = [
     "CacheResult",
     "FileContent",
     "MAX_ATTACHMENTS_PER_MESSAGE",
-    "MAX_CACHE_URL_BYTES",
     "__version__",
 ]

src/dpy_cache/dpy_cache.py

@@ -41,11 +41,10 @@ error contract (fail-loud)
 --------------------------
 nothing is swallowed. lib-specific invariants raise :class:`DPYCacheError` (attachment-count
 mismatch after a send, a duplicate filename in a list input to ``cache()``, ``cache_url``
-non-200 or a body over ``MAX_CACHE_URL_BYTES``, a ``lookup`` jump-url pointing at a
-different channel than the injected one, a ``discord.File`` source that can't be safely
-rebuilt for a repeat send). unnamed ``bytes`` in a list input raises ``ValueError``. raw
-discord errors (``Forbidden`` / ``HTTPException`` / ``NotFound``) propagate UNWRAPPED so
-callers can still branch on discord's types.
+non-200, a ``lookup`` jump-url pointing at a different channel than the injected one, a
+``discord.File`` source that can't be safely rebuilt for a repeat send). unnamed ``bytes`` in
+a list input raises ``ValueError``. raw discord errors (``Forbidden`` / ``HTTPException`` /
+``NotFound``) propagate UNWRAPPED so callers can still branch on discord's types.
 """
 from __future__ import annotations
 
@@ -61,10 +60,6 @@ import discord
 log = logging.getLogger(__name__)
 
 MAX_ATTACHMENTS_PER_MESSAGE = 10
-# cache_url's body cap: the largest upload a BOT can make (boost tier 3 guild,
-# discord.py Guild.filesize_limit 104857600; bots can't have nitro), so nothing discord would
-# accept from a bot is refused; it bounds memory, not the channel's own (tier) limit
-MAX_CACHE_URL_BYTES = 100 * 1024 * 1024
 
 FileContent = Union[bytes, bytearray, str, "os.PathLike[str]", discord.File]
 
@@ -140,7 +135,11 @@ class DPYCache:
         for start in range(0, len(items), MAX_ATTACHMENTS_PER_MESSAGE):
             group = items[start:start + MAX_ATTACHMENTS_PER_MESSAGE]
             discord_files = [self._to_file(name, source) for name, source in group]
-            message = await self._channel.send(content=content, files=discord_files)
+            try:
+                message = await self._channel.send(content=content, files=discord_files)
+            except discord.HTTPException:
+                log.error("dpy_cache: send of %d file(s) to the storage channel failed", len(group))
+                raise
 
             attachments = list(message.attachments)
             if len(attachments) != len(group):
@@ -178,21 +177,12 @@ class DPYCache:
         content: "str | None" = None,
     ) -> FileRef:
         """fetch a remote url then cache its bytes as ``name``; raises DPYCacheError on
-        non-200, or when the body (declared or streamed) exceeds ``MAX_CACHE_URL_BYTES``"""
+        non-200"""
         async with aiohttp.ClientSession() as session:
             async with session.get(url) as response:
                 if response.status != 200:
                     raise DPYCacheError(f"cache_url: GET {url} returned status {response.status}")
-                if (response.content_length or 0) > MAX_CACHE_URL_BYTES:
-                    raise DPYCacheError(
-                        f"cache_url: GET {url} is {response.content_length} bytes, over the "
-                        f"{MAX_CACHE_URL_BYTES}-byte cap"
-                    )
-                data = bytearray()
-                async for chunk in response.content.iter_chunked(1 << 16):
-                    data += chunk
-                    if len(data) > MAX_CACHE_URL_BYTES:
-                        raise DPYCacheError(f"cache_url: GET {url} body exceeds the {MAX_CACHE_URL_BYTES}-byte cap")
+                data = await response.read()
         return await self.cache_one(name, data, content=content)
 
     async def resolve(self, ref: FileRef) -> str: