async-mega-py 2.1.0__tar.gz → 2.2.0__tar.gz

{async_mega_py-2.1.0 → async_mega_py-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: async-mega.py
-Version: 2.1.0
+Version: 2.2.0
 Summary: Python library for the Mega.nz and Transfer.it API
 Keywords: api,downloader,mega,mega.nz,transfer.it
 Author: NTFSvolume

{async_mega_py-2.1.0 → async_mega_py-2.2.0}/pyproject.toml

@@ -34,7 +34,7 @@ license = "Apache-2.0"
 license-files = ["LICENSE"]
 readme = "README.md"
 requires-python = ">=3.11"
-version = "2.1.0"
+version = "2.2.0"
 
 [project.optional-dependencies]
 cli = [

{async_mega_py-2.1.0 → async_mega_py-2.2.0}/src/mega/__main__.py

@@ -1,3 +1,4 @@
+# ruff: noqa: E402
 from __future__ import annotations
 
 import contextlib
@@ -6,6 +7,10 @@ import logging
 from pathlib import Path
 from typing import TYPE_CHECKING, Annotated
 
+from rich.traceback import install as install_rich_traceback
+
+_ = install_rich_traceback(width=None, max_frames=2)
+
 import yarl
 from cyclopts import App, Parameter
 

{async_mega_py-2.1.0 → async_mega_py-2.2.0}/src/mega/api.py

@@ -3,17 +3,19 @@ from __future__ import annotations
 import asyncio
 import contextlib
 import dataclasses
+import json
 import logging
+import uuid
 from collections.abc import Mapping, Sequence
 from contextvars import ContextVar
 from functools import wraps
-from types import MappingProxyType
 from typing import TYPE_CHECKING, Any, ClassVar, Literal, ParamSpec, Self, TypeVar
 
 import aiohttp
 import yarl
 from aiolimiter import AsyncLimiter
 
+from mega import __version__, _package_name_
 from mega.crypto import generate_hashcash
 from mega.errors import RequestError, RetryRequestError
 from mega.utils import random_id, random_u32int
@@ -25,11 +27,8 @@ if TYPE_CHECKING:
     _R = TypeVar("_R")
 
 
-_UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:137.0) Gecko/20100101 Firefox/137.0"
-_DEFAULT_HEADERS: MappingProxyType[str, str] = MappingProxyType({"User-Agent": _UA})
-
-
 LOG_HTTP_TRAFFIC: ContextVar[bool] = ContextVar("LOG_HTTP_TRAFFIC", default=False)
+
 logger = logging.getLogger(__name__)
 
 
@@ -78,14 +77,16 @@ class MegaAPI:
     _rate_limiter: AsyncLimiter
 
     _entrypoint: ClassVar[yarl.URL] = yarl.URL("https://g.api.mega.co.nz/cs")
+    user_agent: str
 
-    def __init__(self, session: aiohttp.ClientSession | None = None) -> None:
+    def __init__(self, session: aiohttp.ClientSession | None = None, user_agent: str | None = None) -> None:
         self.session_id = None
         self._request_id = random_u32int()
         self._client_id = random_id(10)
         self.__session = session
         self._auto_close_session = session is None
         self._rate_limiter = AsyncLimiter(100, 60)
+        self.user_agent = user_agent or f"{_package_name_}/{__version__}"
 
     @property
     def entrypoint(self) -> yarl.URL:
@@ -174,19 +175,37 @@ class MegaAPI:
         headers: Mapping[str, str] | None = None,
         **kwargs: Any,
     ) -> AsyncGenerator[aiohttp.ClientResponse]:
-        kwargs["headers"] = _DEFAULT_HEADERS | (headers or {})
+        kwargs["headers"] = {"User-Agent": self.user_agent} | (headers or {})
+        request_id = str(uuid.uuid4())
         if LOG_HTTP_TRAFFIC.get():
-            params = ", ".join(f"{name} = {value!r}" for name, value in kwargs.items())
-            logger.debug(f"Making {method} request to {url!s} with {params}")
-        async with self._rate_limiter, self._session.request(method, url, **kwargs) as resp:
-            yield resp
+            logger.debug(
+                "Starting %s request [id=%s] to %s \n%s",
+                method,
+                request_id,
+                url,
+                kwargs,
+            )
+
+        resp = None
+        try:
+            async with self._rate_limiter, self._session.request(method, url, **kwargs) as resp:
+                yield resp
+        except RetryRequestError:
+            logger.warning("Request [id=%s] failed, retrying", request_id)
+            raise
+        finally:
+            if resp and LOG_HTTP_TRAFFIC.get():
+                logger.debug(
+                    "Finished %s request [id=%s]\n%s",
+                    method,
+                    request_id,
+                    _LazyResponseLog(resp),
+                )
 
     @staticmethod
     async def _parse_response(response: aiohttp.ClientResponse) -> Any:
         json_resp = await response.json()
         resp = json_resp
-        if LOG_HTTP_TRAFFIC.get():
-            logger.debug(f"Got response [{response.status}] json={json_resp!r}")
 
         if isinstance(json_resp, list) and len(json_resp) == 1:
             resp = json_resp[0]
@@ -196,19 +215,40 @@ class MegaAPI:
                 return resp
 
             if resp == -3:
-                msg = "Request failed, retrying"
-                logger.warning(msg)
                 raise RetryRequestError
             raise RequestError(resp)
 
         return resp
 
 
+class _LazyResponseLog:
+    def __init__(self, resp: aiohttp.ClientResponse) -> None:
+        self.resp = resp
+
+    def __json__(self) -> dict[str, Any]:
+        me = {
+            "url": str(self.resp.url),
+            "status_code": self.resp.status,
+            "response_headers": dict(self.resp.headers),
+            "content": None,
+        }
+        if self.resp._body:
+            stripped = self.resp._body.strip()
+            if stripped:
+                content = json.loads(stripped.decode(self.resp.get_encoding()))
+                me.update(content=content)
+
+        return me
+
+    def __str__(self) -> str:
+        return str(self.__json__())
+
+
 class APIContextManager:
     __slots__ = ("_api",)
 
-    def __init__(self, session: aiohttp.ClientSession | None = None) -> None:
-        self._api: MegaAPI = MegaAPI(session)
+    def __init__(self, session: aiohttp.ClientSession | None = None, *, user_agent: str | None = None) -> None:
+        self._api: MegaAPI = MegaAPI(session, user_agent)
 
     async def __aenter__(self) -> Self:
         return self

{async_mega_py-2.1.0 → async_mega_py-2.2.0}/src/mega/chunker.py

@@ -90,11 +90,13 @@ def _iter_chunks(
 
     aes = AES.new(key_bytes, AES.MODE_CTR, counter=Counter.new(128, initial_value=nonce))
     mac_cypher = AES.new(key_bytes, AES.MODE_CBC, EMPTY_IV)
-    chunk_cypher = AES.new(key_bytes, AES.MODE_CBC, iv_bytes)
-
     data_in: bytes | None = yield b""
 
     while data_in is not None:
+        if not data_in:
+            data_in = yield b""
+            continue
+
         if decrypt:
             decrypted_data = data_out = aes.decrypt(data_in)
         else:
@@ -104,6 +106,8 @@ def _iter_chunks(
         mem_view = memoryview(decrypted_data)
         last_block_index = (len(decrypted_data) % AES.block_size) or AES.block_size
         last_block = pad_bytes(mem_view[-last_block_index:])
+
+        chunk_cypher = AES.new(key_bytes, AES.MODE_CBC, iv_bytes)
         chunk_cypher.encrypt(mem_view[:-last_block_index])
         mac_bytes = mac_cypher.encrypt(chunk_cypher.encrypt(last_block))
         data_in = yield data_out

{async_mega_py-2.1.0 → async_mega_py-2.2.0}/src/mega/client.py

@@ -43,8 +43,8 @@ class MegaNzClient(APIContextManager):
 
     __slots__ = ("_core",)
 
-    def __init__(self, session: aiohttp.ClientSession | None = None) -> None:
-        super().__init__(session)
+    def __init__(self, session: aiohttp.ClientSession | None = None, *, user_agent: str | None = None) -> None:
+        super().__init__(session, user_agent=user_agent)
         self._core: MegaCore = MegaCore(self._api)
         if hasattr(sys, "ps1"):
             setup_logger(logging.DEBUG)

{async_mega_py-2.1.0 → async_mega_py-2.2.0}/src/mega/data_structures.py

@@ -134,6 +134,9 @@ class _DictDumper:
         """Get a JSONable dict representation of this object"""
         return dataclasses.asdict(self)
 
+    def __json__(self) -> dict[str, Any]:
+        return self.dump()
+
     def _shallow_dump(self) -> dict[str, Any]:
         return {name: getattr(self, name) for name in _fields(type(self))}
 

{async_mega_py-2.1.0 → async_mega_py-2.2.0}/src/mega/transfer_it.py

@@ -46,8 +46,8 @@ class TransferItAPI(MegaAPI):
 
 
 class TransferItClient(APIContextManager):
-    def __init__(self, session: aiohttp.ClientSession | None = None) -> None:  # pyright: ignore[reportMissingSuperCall]
-        self._api = TransferItAPI(session)
+    def __init__(self, session: aiohttp.ClientSession | None = None, *, user_agent: str | None = None) -> None:  # pyright: ignore[reportMissingSuperCall]
+        self._api = TransferItAPI(session, user_agent=user_agent)
 
     @property
     def progress_bar(self) -> _GeneratorContextManager[None, None, None]: