async-mega-py 2.1.1__tar.gz → 2.2.1__tar.gz

{async_mega_py-2.1.1 → async_mega_py-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: async-mega.py
-Version: 2.1.1
+Version: 2.2.1
 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.1 → async_mega_py-2.2.1}/pyproject.toml

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

async_mega_py-2.2.1/src/mega/__init__.py

@@ -0,0 +1,8 @@
+import importlib.metadata
+from contextvars import ContextVar
+
+_package_name_ = "async-mega-py"
+__version__ = importlib.metadata.version(_package_name_)
+
+LOG_FILE_PROGRESS: ContextVar[bool] = ContextVar("LOG_FILE_PROGRESS", default=True)
+LOG_HTTP_TRAFFIC: ContextVar[bool] = ContextVar("LOG_HTTP_TRAFFIC", default=False)

{async_mega_py-2.1.1 → async_mega_py-2.2.1}/src/mega/__main__.py

@@ -1,3 +1,4 @@
+# ruff: noqa: E402
 from __future__ import annotations
 
 import contextlib
@@ -6,11 +7,14 @@ 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
 
-from mega import __version__, env
-from mega.api import LOG_HTTP_TRAFFIC
+from mega import LOG_HTTP_TRAFFIC, __version__, env
 from mega.client import MegaNzClient
 from mega.transfer_it import TransferItClient
 from mega.utils import Site, setup_logger

{async_mega_py-2.1.1 → async_mega_py-2.2.1}/src/mega/api.py

@@ -3,17 +3,18 @@ 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
+from typing import TYPE_CHECKING, Any, ClassVar, Generic, Literal, ParamSpec, Self, TypeVar
 
 import aiohttp
 import yarl
 from aiolimiter import AsyncLimiter
 
+from mega import LOG_HTTP_TRAFFIC, __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 +26,6 @@ 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__)
 
 
@@ -67,25 +63,23 @@ def retry(
     return wrapper
 
 
-@dataclasses.dataclass(slots=True, weakref_slot=True, init=False)
+@dataclasses.dataclass(slots=True, weakref_slot=True)
 class MegaAPI:
-    session_id: str | None
-    _request_id: int
-    _client_id: str
+    _session: aiohttp.ClientSession | None = None
+
+    user_agent: str = f"{_package_name_}/{__version__}"
 
-    __session: aiohttp.ClientSession | None
-    _auto_close_session: bool
-    _rate_limiter: AsyncLimiter
+    session_id: str | None = dataclasses.field(init=False, default=None)
+    _request_id: int = dataclasses.field(init=False, default_factory=random_u32int)
+    _client_id: str = dataclasses.field(init=False, default_factory=lambda: random_id(10))
 
-    _entrypoint: ClassVar[yarl.URL] = yarl.URL("https://g.api.mega.co.nz/cs")
+    _auto_close_session: bool = dataclasses.field(init=False)
+    _rate_limiter: AsyncLimiter = dataclasses.field(init=False, default_factory=lambda: AsyncLimiter(100, 60))
 
-    def __init__(self, session: aiohttp.ClientSession | 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)
+    _entrypoint: ClassVar[yarl.URL] = dataclasses.field(init=False, default=yarl.URL("https://g.api.mega.co.nz/cs"))
+
+    def __post_init__(self) -> None:
+        self._auto_close_session = self._session is None
 
     @property
     def entrypoint(self) -> yarl.URL:
@@ -95,22 +89,12 @@ class MegaAPI:
     def client_id(self) -> str:
         return self._client_id
 
-    @property
-    def request_id(self) -> int:
-        return self._request_id
-
-    @property
-    def _session(self) -> aiohttp.ClientSession:
-        if self.__session is None:
-            self.__session = aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(sock_connect=160, sock_read=60))
-        return self.__session
-
     def __repr__(self) -> str:
         return f"<{type(self).__name__}>(session_id={self.session_id!r}, client_id={self.client_id!r}, auto_close_session={self._auto_close_session!r})"
 
     async def aclose(self) -> None:
-        if self._auto_close_session and self.__session:
-            await self.__session.close()
+        if self._auto_close_session and self._session:
+            await self._session.close()
 
     async def __enter__(self) -> Self:
         return self
@@ -174,19 +158,40 @@ 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
+        if self._session is None:
+            self._session = aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(sock_connect=160, sock_read=60))
+
+        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,27 +201,48 @@ class MegaAPI:
                 return resp
 
             if resp == -3:
-                msg = "Request failed, retrying"
-                logger.warning(msg)
                 raise RetryRequestError
             raise RequestError(resp)
 
         return resp
 
 
-class APIContextManager:
-    __slots__ = ("_api",)
+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__())
+
 
-    def __init__(self, session: aiohttp.ClientSession | None = None) -> None:
-        self._api: MegaAPI = MegaAPI(session)
+_API_T = TypeVar("_API_T", bound=MegaAPI, covariant=True)
+
+
+class APIContextManager(Generic[_API_T]):
+    __slots__ = ("_api",)
 
     async def __aenter__(self) -> Self:
         return self
 
     async def __aexit__(self, *_) -> None:
-        await self.close()
+        await self.aclose()
 
     async def aclose(self) -> None:
-        await self._api.close()
+        await self._api.aclose()
 
     close = aclose

{async_mega_py-2.1.1 → async_mega_py-2.2.1}/src/mega/client.py

@@ -7,7 +7,7 @@ from pathlib import Path, PurePosixPath
 from typing import TYPE_CHECKING
 
 from mega import progress
-from mega.api import APIContextManager
+from mega.api import APIContextManager, MegaAPI
 from mega.core import MegaCore
 from mega.crypto import a32_to_base64, b64_to_a32, b64_url_encode, encrypt_attr, encrypt_key
 from mega.data_structures import (
@@ -38,13 +38,16 @@ logger = logging.getLogger(__name__)
 _DOMAIN = Site.MEGA.value
 
 
-class MegaNzClient(APIContextManager):
+class MegaNzClient(APIContextManager[MegaAPI]):
     """Interface with all the public methods of the API"""
 
     __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:
+        self._api = MegaAPI(session)
+        if user_agent:
+            self._api.user_agent = user_agent
+
         self._core: MegaCore = MegaCore(self._api)
         if hasattr(sys, "ps1"):
             setup_logger(logging.DEBUG)

{async_mega_py-2.1.1 → async_mega_py-2.2.1}/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.1 → async_mega_py-2.2.1}/src/mega/transfer_it.py

@@ -45,9 +45,13 @@ class TransferItAPI(MegaAPI):
         return await super().post(json, params)
 
 
-class TransferItClient(APIContextManager):
-    def __init__(self, session: aiohttp.ClientSession | None = None) -> None:  # pyright: ignore[reportMissingSuperCall]
+class TransferItClient(APIContextManager[TransferItAPI]):
+    __slots__ = ()
+
+    def __init__(self, session: aiohttp.ClientSession | None = None, *, user_agent: str | None = None) -> None:
         self._api = TransferItAPI(session)
+        if user_agent:
+            self._api.user_agent = user_agent
 
     @property
     def progress_bar(self) -> _GeneratorContextManager[None, None, None]:

{async_mega_py-2.1.1 → async_mega_py-2.2.1}/src/mega/utils.py

@@ -14,6 +14,7 @@ from typing import TYPE_CHECKING, Literal, TypeVar, overload
 import aiohttp
 import yarl
 
+from mega import LOG_FILE_PROGRESS
 from mega.errors import ValidationError
 
 if TYPE_CHECKING:
@@ -63,7 +64,7 @@ def setup_logger(level: int = logging.INFO) -> None:
 
 
 def progress_logger(output_path: Path, file_size: int, *, download: bool) -> Callable[[float], None]:
-    if not logger.isEnabledFor(10):
+    if not (LOG_FILE_PROGRESS.get() and logger.isEnabledFor(logging.DEBUG)):
         return lambda _: None
 
     from mega.data_structures import ByteSize

async_mega_py-2.1.1/src/mega/__init__.py

@@ -1,4 +0,0 @@
-import importlib.metadata
-
-_package_name_ = "async-mega-py"
-__version__ = importlib.metadata.version(_package_name_)