sticker-convert 2.13.3.0__py3-none-any.whl → 2.17.0.0__py3-none-any.whl

sticker_convert/definitions.py

@@ -3,6 +3,7 @@ import os
 import platform
 import sys
 from pathlib import Path
+from typing import Any, Dict
 
 
 def get_root_dir() -> Path:
@@ -89,3 +90,6 @@ SVG_SAMPLE_FPS = 30
 # If width and height not set in SVG tag, import at this dimension
 SVG_DEFAULT_WIDTH = 1024
 SVG_DEFAULT_HEIGHT = 1024
+
+# A shared dictionary
+RUNTIME_STATE: Dict[str, Any] = {}

sticker_convert/downloaders/download_band.py

@@ -1,110 +1,111 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-import json
-import zipfile
-from io import BytesIO
-from pathlib import Path
-from typing import Any, Dict, Optional, Tuple
-from urllib.parse import urlparse
-
-import requests
-
-from sticker_convert.downloaders.download_base import DownloadBase
-from sticker_convert.job_option import CredOption, InputOption
-from sticker_convert.utils.callback import CallbackProtocol, CallbackReturn
-from sticker_convert.utils.files.metadata_handler import MetadataHandler
-
-
-class DownloadBand(DownloadBase):
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        super().__init__(*args, **kwargs)
-
-    def decompress(self, zip_file: bytes) -> int:
-        with zipfile.ZipFile(BytesIO(zip_file)) as zf:
-            self.cb.put("Unzipping...")
-
-            zf_files = zf.namelist()
-            animated = [i for i in zf_files if "animation/" in i]
-            if len(animated) > 0:
-                pack_files = animated
-            else:
-                pack_files = [
-                    i
-                    for i in zf_files
-                    if i.endswith(".meta") is False and "_key" not in i
-                ]
-
-            self.cb.put(
-                (
-                    "bar",
-                    None,
-                    {"set_progress_mode": "determinate", "steps": len(pack_files)},
-                )
-            )
-
-            for num, sticker in enumerate(pack_files):
-                data = zf.read(sticker)
-                self.cb.put(f"Read {sticker}")
-                ext = sticker.split(".")[-1]
-
-                out_path = Path(self.out_dir, str(num).zfill(3) + f".{ext}")
-                with open(out_path, "wb") as f:
-                    f.write(data)
-
-                self.cb.put("update_bar")
-
-        return len(pack_files)
-
-    def get_metadata(self, pack_no: str) -> Optional[Dict[Any, Any]]:
-        r = requests.get(
-            f"https://sapi.band.us/v1.0.0/get_sticker_info?pack_no={pack_no}"
-        )
-        if r.text:
-            return json.loads(r.text)
-        else:
-            return None
-
-    def download_stickers_band(self) -> Tuple[int, int]:
-        if urlparse(self.url).netloc != "www.band.us" and self.url.isnumeric() is False:
-            self.cb.put("Download failed: Unsupported URL format")
-            return 0, 0
-
-        if self.url.isnumeric():
-            pack_no = self.url
-        else:
-            pack_no = urlparse(self.url).path.split("/")[-1]
-        metadata = self.get_metadata(pack_no)
-        if metadata:
-            self.title = metadata["result_data"]["sticker"]["name"]
-        else:
-            self.cb.put("Download failed: Failed to get metadata")
-            return 0, 0
-
-        MetadataHandler.set_metadata(self.out_dir, title=self.title)
-
-        pack_url = f"http://s.cmstatic.net/band/sticker/v2/{pack_no}/shop/pack"
-        zip_file = self.download_file(pack_url)
-
-        if zip_file:
-            self.cb.put(f"Downloaded {pack_url}")
-        else:
-            self.cb.put(f"Cannot download {pack_url}")
-            return 0, 0
-
-        pack_files_no = self.decompress(zip_file)
-
-        cover_url = f"http://s.cmstatic.net/band/sticker/v2/{pack_no}/shop/main"
-        self.download_file(cover_url, self.out_dir / "cover.png")
-
-        return pack_files_no, pack_files_no
-
-    @staticmethod
-    def start(
-        opt_input: InputOption,
-        opt_cred: Optional[CredOption],
-        cb: CallbackProtocol,
-        cb_return: CallbackReturn,
-    ) -> Tuple[int, int]:
-        downloader = DownloadBand(opt_input, opt_cred, cb, cb_return)
-        return downloader.download_stickers_band()
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import zipfile
+from io import BytesIO
+from pathlib import Path
+from typing import Any, Dict, Optional, Tuple
+from urllib.parse import urlparse
+
+import requests
+
+from sticker_convert.downloaders.download_base import DownloadBase
+from sticker_convert.job_option import CredOption, InputOption
+from sticker_convert.utils.callback import CallbackProtocol, CallbackReturn
+from sticker_convert.utils.files.metadata_handler import MetadataHandler
+from sticker_convert.utils.translate import I
+
+
+class DownloadBand(DownloadBase):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+
+    def decompress(self, zip_file: bytes) -> int:
+        with zipfile.ZipFile(BytesIO(zip_file)) as zf:
+            self.cb.put(I("Unzipping..."))
+
+            zf_files = zf.namelist()
+            animated = [i for i in zf_files if "animation/" in i]
+            if len(animated) > 0:
+                pack_files = animated
+            else:
+                pack_files = [
+                    i
+                    for i in zf_files
+                    if i.endswith(".meta") is False and "_key" not in i
+                ]
+
+            self.cb.put(
+                (
+                    "bar",
+                    None,
+                    {"set_progress_mode": "determinate", "steps": len(pack_files)},
+                )
+            )
+
+            for num, sticker in enumerate(pack_files):
+                data = zf.read(sticker)
+                self.cb.put(f"Read {sticker}")
+                ext = sticker.split(".")[-1]
+
+                out_path = Path(self.out_dir, str(num).zfill(3) + f".{ext}")
+                with open(out_path, "wb") as f:
+                    f.write(data)
+
+                self.cb.put("update_bar")
+
+        return len(pack_files)
+
+    def get_metadata(self, pack_no: str) -> Optional[Dict[Any, Any]]:
+        r = requests.get(
+            f"https://sapi.band.us/v1.0.0/get_sticker_info?pack_no={pack_no}"
+        )
+        if r.text:
+            return json.loads(r.text)
+        else:
+            return None
+
+    def download_stickers_band(self) -> Tuple[int, int]:
+        if urlparse(self.url).netloc != "www.band.us" and self.url.isnumeric() is False:
+            self.cb.put(I("Download failed: Unsupported URL format"))
+            return 0, 0
+
+        if self.url.isnumeric():
+            pack_no = self.url
+        else:
+            pack_no = urlparse(self.url).path.split("/")[-1]
+        metadata = self.get_metadata(pack_no)
+        if metadata:
+            self.title = metadata["result_data"]["sticker"]["name"]
+        else:
+            self.cb.put(I("Download failed: Failed to get metadata"))
+            return 0, 0
+
+        MetadataHandler.set_metadata(self.out_dir, title=self.title)
+
+        pack_url = f"http://s.cmstatic.net/band/sticker/v2/{pack_no}/shop/pack"
+        zip_file = self.download_file(pack_url)
+
+        if zip_file:
+            self.cb.put(I("Downloaded {}").format(pack_url))
+        else:
+            self.cb.put(I("Cannot download {}").format(pack_url))
+            return 0, 0
+
+        pack_files_no = self.decompress(zip_file)
+
+        cover_url = f"http://s.cmstatic.net/band/sticker/v2/{pack_no}/shop/main"
+        self.download_file(cover_url, self.out_dir / "cover.png")
+
+        return pack_files_no, pack_files_no
+
+    @staticmethod
+    def start(
+        opt_input: InputOption,
+        opt_cred: Optional[CredOption],
+        cb: CallbackProtocol,
+        cb_return: CallbackReturn,
+    ) -> Tuple[int, int]:
+        downloader = DownloadBand(opt_input, opt_cred, cb, cb_return)
+        return downloader.download_stickers_band()

sticker_convert/downloaders/download_base.py

@@ -1,166 +1,171 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-from functools import partial
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
-
-import anyio
-import httpx
-import requests
-
-from sticker_convert.job_option import CredOption, InputOption
-from sticker_convert.utils.callback import CallbackProtocol, CallbackReturn
-
-
-class DownloadBase:
-    def __init__(
-        self,
-        opt_input: InputOption,
-        opt_cred: Optional[CredOption],
-        cb: CallbackProtocol,
-        cb_return: CallbackReturn,
-    ) -> None:
-        self.url = opt_input.url
-        self.out_dir = opt_input.dir
-        self.input_option = opt_input.option
-        self.opt_cred = opt_cred
-        self.cb = cb
-        self.cb_return = cb_return
-
-    def download_multiple_files(
-        self,
-        targets: List[Tuple[str, Path]],
-        retries: int = 3,
-        headers: Optional[dict[Any, Any]] = None,
-        **kwargs: Any,
-    ) -> Dict[str, bool]:
-        results: Dict[str, bool] = {}
-        anyio.run(
-            partial(
-                self.download_multiple_files_async,
-                targets,
-                retries,
-                headers,
-                results,
-                **kwargs,
-            )
-        )
-        return results
-
-    async def download_multiple_files_async(
-        self,
-        targets: List[Tuple[str, Path]],
-        retries: int = 3,
-        headers: Optional[dict[Any, Any]] = None,
-        results: Optional[dict[str, bool]] = None,
-        **kwargs: Any,
-    ) -> None:
-        # targets format: [(url1, dest2), (url2, dest2), ...]
-        self.cb.put(
-            ("bar", None, {"set_progress_mode": "determinate", "steps": len(targets)})
-        )
-
-        semaphore = anyio.Semaphore(4)
-
-        async with httpx.AsyncClient() as client:
-            async with anyio.create_task_group() as tg:
-                for url, dest in targets:
-                    tg.start_soon(
-                        self.download_file_async,
-                        semaphore,
-                        client,
-                        url,
-                        dest,
-                        retries,
-                        headers,
-                        results,
-                        **kwargs,
-                    )
-
-    async def download_file_async(
-        self,
-        semaphore: anyio.Semaphore,
-        client: httpx.AsyncClient,
-        url: str,
-        dest: Path,
-        retries: int = 3,
-        headers: Optional[dict[Any, Any]] = None,
-        results: Optional[dict[str, bool]] = None,
-        **kwargs: Any,
-    ) -> None:
-        async with semaphore:
-            self.cb.put(f"Downloading {url}")
-            success = False
-            for retry in range(retries):
-                response = await client.get(
-                    url, follow_redirects=True, headers=headers, **kwargs
-                )
-                success = response.is_success
-
-                if success:
-                    async with await anyio.open_file(dest, "wb+") as f:
-                        await f.write(response.content)
-                    self.cb.put(f"Downloaded {url}")
-                else:
-                    self.cb.put(
-                        f"Error {response.status_code}: {url} (tried {retry + 1}/{retries} times)"
-                    )
-
-            if results is not None:
-                results[url] = success
-
-            self.cb.put("update_bar")
-
-    def download_file(
-        self,
-        url: str,
-        dest: Optional[Path] = None,
-        retries: int = 3,
-        show_progress: bool = True,
-        **kwargs: Any,
-    ) -> bytes:
-        result = b""
-        chunk_size = 102400
-
-        for retry in range(retries):
-            try:
-                response = requests.get(
-                    url, stream=True, allow_redirects=True, **kwargs
-                )
-                if not response.ok:
-                    return b""
-                total_length = int(response.headers.get("content-length"))  # type: ignore
-
-                self.cb.put(f"Downloading {url}")
-
-                if show_progress:
-                    steps = (total_length / chunk_size) + 1
-                    self.cb.put(
-                        (
-                            "bar",
-                            None,
-                            {"set_progress_mode": "determinate", "steps": int(steps)},
-                        )
-                    )
-
-                for chunk in response.iter_content(chunk_size=chunk_size):
-                    if chunk:
-                        result += chunk
-                        if show_progress:
-                            self.cb.put("update_bar")
-
-                break
-            except requests.exceptions.RequestException as e:
-                self.cb.put(
-                    f"Cannot download {url} (tried {retry + 1}/{retries} times): {e}"
-                )
-
-        if not result:
-            return b""
-        if dest:
-            with open(dest, "wb+") as f:
-                f.write(result)
-            self.cb.put(f"Downloaded {url}")
-            return b""
-        return result
+#!/usr/bin/env python3
+from __future__ import annotations
+
+from functools import partial
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+import anyio
+import httpx
+import requests
+
+from sticker_convert.job_option import CredOption, InputOption
+from sticker_convert.utils.callback import CallbackProtocol, CallbackReturn
+from sticker_convert.utils.translate import I
+
+
+class DownloadBase:
+    def __init__(
+        self,
+        opt_input: InputOption,
+        opt_cred: Optional[CredOption],
+        cb: CallbackProtocol,
+        cb_return: CallbackReturn,
+    ) -> None:
+        self.url = opt_input.url
+        self.out_dir = opt_input.dir
+        self.input_option = opt_input.option
+        self.opt_cred = opt_cred
+        self.cb = cb
+        self.cb_return = cb_return
+
+    def download_multiple_files(
+        self,
+        targets: List[Tuple[str, Path]],
+        retries: int = 3,
+        headers: Optional[dict[Any, Any]] = None,
+        **kwargs: Any,
+    ) -> Dict[str, bool]:
+        results: Dict[str, bool] = {}
+        anyio.run(
+            partial(
+                self.download_multiple_files_async,
+                targets,
+                retries,
+                headers,
+                results,
+                **kwargs,
+            )
+        )
+        return results
+
+    async def download_multiple_files_async(
+        self,
+        targets: List[Tuple[str, Path]],
+        retries: int = 3,
+        headers: Optional[dict[Any, Any]] = None,
+        results: Optional[dict[str, bool]] = None,
+        **kwargs: Any,
+    ) -> None:
+        # targets format: [(url1, dest2), (url2, dest2), ...]
+        self.cb.put(
+            ("bar", None, {"set_progress_mode": "determinate", "steps": len(targets)})
+        )
+
+        semaphore = anyio.Semaphore(4)
+
+        async with httpx.AsyncClient() as client:
+            async with anyio.create_task_group() as tg:
+                for url, dest in targets:
+                    tg.start_soon(
+                        self.download_file_async,
+                        semaphore,
+                        client,
+                        url,
+                        dest,
+                        retries,
+                        headers,
+                        results,
+                        **kwargs,
+                    )
+
+    async def download_file_async(
+        self,
+        semaphore: anyio.Semaphore,
+        client: httpx.AsyncClient,
+        url: str,
+        dest: Path,
+        retries: int = 3,
+        headers: Optional[dict[Any, Any]] = None,
+        results: Optional[dict[str, bool]] = None,
+        **kwargs: Any,
+    ) -> None:
+        async with semaphore:
+            self.cb.put(I("Downloading {}").format(url))
+            success = False
+            for retry in range(retries):
+                response = await client.get(
+                    url, follow_redirects=True, headers=headers, **kwargs
+                )
+                success = response.is_success
+
+                if success:
+                    async with await anyio.open_file(dest, "wb+") as f:
+                        await f.write(response.content)
+                    self.cb.put(I("Downloaded {}").format(url))
+                else:
+                    self.cb.put(
+                        I("Error {}: {} (tried {}/{} times)").format(
+                            response.status_code, url, retry + 1, retries
+                        )
+                    )
+
+            if results is not None:
+                results[url] = success
+
+            self.cb.put("update_bar")
+
+    def download_file(
+        self,
+        url: str,
+        dest: Optional[Path] = None,
+        retries: int = 3,
+        show_progress: bool = True,
+        **kwargs: Any,
+    ) -> bytes:
+        result = b""
+        chunk_size = 102400
+
+        for retry in range(retries):
+            try:
+                response = requests.get(
+                    url, stream=True, allow_redirects=True, **kwargs
+                )
+                if not response.ok:
+                    return b""
+                total_length = int(response.headers.get("content-length"))  # type: ignore
+
+                self.cb.put(I("Downloading {}").format(url))
+
+                if show_progress:
+                    steps = (total_length / chunk_size) + 1
+                    self.cb.put(
+                        (
+                            "bar",
+                            None,
+                            {"set_progress_mode": "determinate", "steps": int(steps)},
+                        )
+                    )
+
+                for chunk in response.iter_content(chunk_size=chunk_size):
+                    if chunk:
+                        result += chunk
+                        if show_progress:
+                            self.cb.put("update_bar")
+
+                break
+            except requests.exceptions.RequestException as e:
+                self.cb.put(
+                    I("Cannot download {} (tried {}/{} times): {}").format(
+                        url, retry + 1, retries, e
+                    )
+                )
+
+        if not result:
+            return b""
+        if dest:
+            with open(dest, "wb+") as f:
+                f.write(result)
+            self.cb.put(I("Downloaded {}").format(url))
+            return b""
+        return result