fix: finish chunks (#7)

Author: NTFSvolume

bunkrr_uploader/api/api.py

@@ -19,20 +19,28 @@
 
 logger = logging.getLogger("bunkr-uploader")
 
+DEFAULT_HEADERS = {
+    "Accept": "application/json, text/plain, */*",
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:136.0) Gecko/20100101 Firefox/136.0",
+    "Referer": "https://dash.bunkr.cr/",
+    "striptags": "null",
+    "Origin": "https://dash.bunkr.cr",
+    "Sec-Fetch-Dest": "empty",
+    "Sec-Fetch-Mode": "cors",
+    "Sec-Fetch-Site": "cross-site",
+    "Pragma": "no-cache",
+}
+
 
 class BunkrrAPI:
     RATE_LIMIT = 50
 
     def __init__(self, token: str, chunk_size: int | None = None):
         self._token = token
         self._api_entrypoint = URL("https://dash.bunkr.cr/api/")
-        self._session_headers = {
-            "Accept": "application/json",
-            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:133.0) Gecko/20100101 Firefox/133.0",
-            "token": self._token,
-        }
+        self._session_headers = DEFAULT_HEADERS | {"token": self._token}
         self._session = ClientSession(self._api_entrypoint, headers=self._session_headers)
-        self._chunk_size: int = chunk_size  # type: ignore
+        self._chunk_size: int = chunk_size or 0
         self._info = None
         self._semaphore = asyncio.Semaphore(self.RATE_LIMIT)
         self._server_sessions: dict[URL, ClientSession] = {}
@@ -50,15 +58,22 @@ async def _get_json(self, path: str) -> dict:
             resp.raise_for_status()
             response: dict = await resp.json()
             record = {"url": str(resp.url), "headers": dict(resp.headers), "response": response}
-            logger.debug(f"response: \n {json.dumps(record, indent=4)}")
+            logger.debug(f"response: \n {json.dumps(record, indent=4, ensure_ascii=False)}")
             return response
 
     async def _post(self, path: str, *, data: FormData | dict | None = None, server: URL | None = None) -> dict:
         data = data or {}
         if isinstance(data, dict) and "finishchunks" not in path:
             data["token"] = data.get("token") or self._token
-        session = self.server_sessions.get(server) or self._session  # type: ignore
-        async with self._semaphore, session.post(path, data=data) as resp:
+
+        session = self.server_sessions.get(server) if server else None
+        session = session or self._session
+        headers = session.headers
+        if "finishchunks" in path:
+            headers = dict(session.headers) | {"Content-Type": "application/json;charset=utf-8"}
+            data = json.dumps(data)  # type: ignore
+
+        async with self._semaphore, session.post(path, data=data, headers=headers) as resp:
             resp.raise_for_status()
             response = await resp.json()
             record = {"url": str(resp.url), "headers": dict(resp.headers), "response": response}
@@ -116,10 +131,12 @@ async def create_album(
     async def upload(self, file: FileInfo | Path, server: URL, album_id: str | None = None) -> UploadResponse:
         if isinstance(file, Path):
             file = FileInfo(file, album_id=album_id)
+
         file_info = file
         assert file_info.size <= self.info.maxSize
         async with aiofiles.open(file_info.path, "rb") as file_data:
             chunk_data = await file_data.read(self._chunk_size)
+
         data = FormData()
         data.add_field("files[]", chunk_data, filename=file_info.path.name, content_type=file_info.mimetype)
         if album_id:
@@ -130,5 +147,6 @@ async def upload(self, file: FileInfo | Path, server: URL, album_id: str | None
 
     async def finish_chunks(self, file_info: FileInfo, server: URL):
         data = {"files": [file_info.dump_json()]}
+        logger.info(data)
         response = await self._post("upload/finishchunks", data=data, server=server)
         return UploadResponse(**response)

bunkrr_uploader/api/files.py

@@ -51,7 +51,7 @@ def dump_json(self) -> dict:
         return {
             "uuid": self.uuid,
             "original": self.original_name,
-            "type": "",
+            "type": self.mimetype,
             "albumid": self.album_id or None,
             "filelength": None,
             "age": None,

bunkrr_uploader/api/responses.py

@@ -1,8 +1,8 @@
 # ruff: noqa: N815
 from datetime import datetime, timedelta
-from typing import Annotated
+from typing import Annotated, TypedDict
 
-from pydantic import AfterValidator, BaseModel, ByteSize, HttpUrl
+from pydantic import AfterValidator, BaseModel, ByteSize, ConfigDict, HttpUrl
 from yarl import URL
 
 HttpURL = Annotated[HttpUrl, AfterValidator(lambda x: URL(str(x)))]
@@ -14,21 +14,21 @@ class ChunkSize(BaseModel):
     timeout: timedelta
 
 
-class FileIdentifierLength(BaseModel):
+class FileIdentifierLength(TypedDict):
     min: int
     max: int
     default: int
     force: bool
 
 
-class StripTags(BaseModel):
+class StripTags(TypedDict):
     blacklistExtensions: set[str]
     default: bool
     force: bool
     video: bool
 
 
-class Permissions(BaseModel):
+class Permissions(TypedDict):
     admin: bool
     moderator: bool
     superadmin: bool
@@ -38,14 +38,19 @@ class Permissions(BaseModel):
 
 
 class BunkrrResponse(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
     description: str = ""
-    success: bool = False
+    success: bool = True
 
 
 class UploadItemResponse(BunkrrResponse):
     name: str
     url: HttpURL | None
 
+    def model_post_init(self, *_):
+        if self.url is None:
+            self.success = False
+
 
 class UploadResponse(BunkrrResponse):
     files: list[UploadItemResponse] = []

bunkrr_uploader/main.py

@@ -14,7 +14,10 @@ async def async_main() -> None:
     logger.debug(f"Using params: \n {args.model_dump_json(indent=4)}")
     bunkrr_client = BunkrrUploader(**args.model_dump())
     try:
-        await bunkrr_client.upload(args.path, album_name=args.album_name)
+        responses = await bunkrr_client.upload(args.path, album_name=args.album_name)
+        for r in responses:
+            logger.info(r.model_dump_json(indent=4))
+
     finally:
         await bunkrr_client.close()
 

bunkrr_uploader/uploader.py

@@ -2,7 +2,7 @@
 
 import asyncio
 import logging
-from dataclasses import asdict, dataclass, fields
+from dataclasses import dataclass, fields
 from typing import TYPE_CHECKING
 
 import aiofiles
@@ -26,26 +26,28 @@
 
 @dataclass(frozen=True, slots=True)
 class BunkrUploaderSettings:
+    path: Path
     concurrent_uploads: int = 1
     chunk_size: ByteSize | None = None
     upload_retries: int = 1
     use_max_chunk_size: bool = False
     chunk_retries: int = 2
     upload_delay: float = 0.5
 
-    def update(self, **kwargs) -> BunkrUploaderSettings:
-        cls_fields = fields(self)
+    @classmethod
+    def update(cls, **kwargs) -> BunkrUploaderSettings:
+        cls_fields = fields(cls)
         cls_fields_names = [f.name for f in cls_fields]
         valid_kwargs = {k: v for k, v in kwargs.items() if k in cls_fields_names}
         if not valid_kwargs:
             msg = "None of the provided attribute is in the class"
             raise ValueError(msg)
-        values = asdict(self) | valid_kwargs
-        return BunkrUploaderSettings(**values)
+        return BunkrUploaderSettings(**valid_kwargs)
 
 
 class BunkrrUploader:
-    def __init__(self, token: str, settings: BunkrUploaderSettings):
+    def __init__(self, token: str, **kwargs):
+        settings = BunkrUploaderSettings.update(**kwargs)
         self._api = BunkrrAPI(token, settings.chunk_size)
         self.settings = settings
         assert self.settings.concurrent_uploads <= self._api.RATE_LIMIT
@@ -68,7 +70,7 @@ def _prepare_files(self, files: list[Path]) -> list[FileInfo]:
         files_to_upload = []
         for file in files:
             file_info = FileInfo(file)
-            if file.suffix.casefold() in self._api.info.stripTags.blacklistExtensions:
+            if file.suffix.casefold() in self._api.info.stripTags["blacklistExtensions"]:
                 logger.error(f"File {file} has blacklisted extension {file.suffix}")
 
             elif file_info.size > self._api.info.maxSize:
@@ -198,6 +200,7 @@ async def upload(self, path: Path, recurse: bool = False, album_name: str | None
 
         if not self._ready:
             await self.startup()
+
         files_to_upload = self._prepare_files(files_to_upload)
         if not files_to_upload:
             logger.error("No files left to upload")
@@ -217,8 +220,8 @@ async def worker(file_info: FileInfo, server: URL) -> UploadResponse:
                     logger.error(str(e), exc_info=True)
                 return UploadResponse(**default_response)
 
-        responses = []
-        tasks = []
+        responses: list[UploadResponse] = []
+        tasks: list = []
         for file_info in files_to_upload:
             default_response = {"success": False, "files": [file_info.as_item]}
             server = await self._get_server(album_id)
@@ -228,7 +231,7 @@ async def worker(file_info: FileInfo, server: URL) -> UploadResponse:
             tasks.append(asyncio.create_task(worker(file_info, server)))
 
         uploads = await asyncio.gather(*tasks)
-        responses.append(uploads)
+        responses.extend(uploads)
         return responses
 
     async def close(self) -> None: