async-mega-py 2.5.1__tar.gz → 2.5.2__tar.gz

{async_mega_py-2.5.1 → async_mega_py-2.5.2}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "async-mega.py"
-version = "2.5.1"
+version = "2.5.2"
 classifiers = [
     "Development Status :: 5 - Production/Stable",
     "Environment :: Console",

{async_mega_py-2.5.1 → async_mega_py-2.5.2}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "async-mega.py"
-version = "2.5.1"
+version = "2.5.2"
 authors = [{name = "NTFSvolume", email = "NTFSvolume@proton.me"}]
 classifiers = [
     "Development Status :: 5 - Production/Stable",

{async_mega_py-2.5.1 → async_mega_py-2.5.2}/src/mega/core.py

@@ -23,7 +23,6 @@ from mega.crypto import (
     encrypt_key,
 )
 from mega.data_structures import (
-    _EMPTY_ATTRS,
     AccountStatsSerialized,
     Attributes,
     Crypto,
@@ -235,9 +234,19 @@ class MegaCore:
     def decrypt(self, node: Node) -> Node:
         crypto = attributes = None
         if node.type in (NodeType.FILE, NodeType.FOLDER):
-            full_key, share_key = self.vault[node]
-            crypto = Crypto.decompose(full_key, node.type, share_key)
-            attributes = self.decrypt_attrs(node._a, crypto.key, node.id)
+            possible_keys = self.vault.get_keys(node)
+            if len(possible_keys) > 1:
+                logger.warning(
+                    "Found multiple keys for node %s (%s keys), trying all of them", node.id, len(possible_keys)
+                )
+
+            for key in possible_keys:
+                crypto = Crypto.decompose(key.full_key, node.type, key.share_key)
+                attributes = self._decrypt_attrs(node._a, crypto.key)
+                if not attributes.is_error():
+                    break
+            else:
+                logger.warning("Unable to decrypt attributes of node %s", node.id)
 
         else:
             name = {
@@ -419,7 +428,7 @@ class MegaCore:
     @classmethod
     def decrypt_attrs(cls, attrs: str, key: tuple[int, ...], node_id: NodeID) -> Attributes:
         attributes = cls._decrypt_attrs(attrs, key)
-        if attributes is _EMPTY_ATTRS:
+        if attributes.is_error():
             logger.warning("Unable to decrypt attributes of node %s", node_id)
         return attributes
 

{async_mega_py-2.5.1 → async_mega_py-2.5.2}/src/mega/data_structures.py

@@ -13,7 +13,7 @@ import dataclasses
 import time
 from enum import IntEnum
 from types import MappingProxyType
-from typing import TYPE_CHECKING, Any, ClassVar, Final, Literal, Self, TypeAlias, TypedDict
+from typing import TYPE_CHECKING, Any, ClassVar, Final, Literal, Self, TypeAlias, TypedDict, final
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
@@ -236,9 +236,6 @@ class Crypto(_DictDumper):
             )
             assert iv
             assert meta_mac
-        else:
-            if len(composed_key) != 4:
-                raise RuntimeError(f"Invalid key, expected key len for folders is 4, got {len(composed_key) = }")
 
         return Crypto(key, iv, meta_mac, composed_key, share_key)  # pyright: ignore[reportArgumentType]
 
@@ -329,17 +326,22 @@ class Node(_DictDumper):
 _LABELS: Final = "", "red", "orange", "yellow", "green", "blue", "purple", "grey"
 
 
+@final
 @dataclasses.dataclass(slots=True, frozen=True)
 class Attributes(_DictDumper):
     name: str
     label: str = ""
     favorited: bool = False
 
-    @classmethod
-    def parse(cls, attrs: AttributesSerialized) -> Self:
+    def is_error(self) -> bool:
+        return self is _EMPTY_ATTRS
+
+    @staticmethod
+    def parse(attrs: AttributesSerialized) -> Attributes:
         if not attrs:
             return _EMPTY_ATTRS
-        return cls(
+
+        return Attributes(
             name=attrs.get("n", ""),
             label=_LABELS[attrs.get("lbl", 0)],
             favorited=bool(attrs.get("fav")),

{async_mega_py-2.5.1 → async_mega_py-2.5.2}/src/mega/errors.py

@@ -3,12 +3,18 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Final
 
 if TYPE_CHECKING:
-    from mega.data_structures import NodeID
+    from mega.data_structures import Node, NodeID
 
 
 class MegaNzError(Exception): ...
 
 
+class FileSystemError(MegaNzError, RuntimeError):
+    def __init__(self, nodes: tuple[Node, ...]) -> None:
+        super().__init__("Unable to decript attribute of some nodes in the file system")
+        self.nodes = nodes
+
+
 class ValidationError(MegaNzError, ValueError):
     """Error in validation stage"""
 

{async_mega_py-2.5.1 → async_mega_py-2.5.2}/src/mega/filesystem.py

@@ -12,7 +12,7 @@ from types import MappingProxyType
 from typing import TYPE_CHECKING, Any, Final, NamedTuple, Self
 
 from mega.data_structures import Node, NodeID, NodeType, _DictDumper
-from mega.errors import MultipleNodesFoundError, ValidationError
+from mega.errors import FileSystemError, MultipleNodesFoundError, ValidationError
 
 if TYPE_CHECKING:
     from collections.abc import Generator, Iterable, Iterator
@@ -115,7 +115,7 @@ class SimpleFileSystem(_NodeWalker, _DictDumper):
             yield from self.iterdir(self.trash_bin.id)
 
     @classmethod
-    def build(cls, nodes: Iterable[Node]) -> Self:
+    def build(cls, nodes: Iterable[Node], *, strict: bool = False) -> Self:
         root = inbox = trash_bin = None
         file_count = folder_count = 0
 
@@ -127,7 +127,12 @@ class SimpleFileSystem(_NodeWalker, _DictDumper):
                 ids = current.id, found.id
                 raise ValidationError(f"Multiple nodes of type {found.type.name} found: {ids}")
 
+        decrypt_errors: list[Node] = []
         for node in nodes:
+            if node.attributes.is_error() and strict:
+                decrypt_errors.append(node)
+                continue
+
             nodes_map[node.id] = node
             if node.parent_id:
                 children.setdefault(node.parent_id, []).append(node.id)
@@ -148,6 +153,9 @@ class SimpleFileSystem(_NodeWalker, _DictDumper):
                 case _:
                     raise RuntimeError  # pyright: ignore[reportUnreachable]
 
+        if decrypt_errors:
+            raise FileSystemError(nodes=tuple(decrypt_errors))
+
         return cls(
             root=root,
             inbox=inbox,
@@ -170,8 +178,8 @@ class SimpleFileSystem(_NodeWalker, _DictDumper):
         )
 
     @classmethod
-    def from_dump(cls, dump: dict[str, Any], /) -> Self:
-        return cls.build(Node.from_dump(node) for node in dump["nodes"].values())
+    def from_dump(cls, dump: dict[str, Any], /, *, strict: bool = False) -> Self:
+        return cls.build((Node.from_dump(node) for node in dump["nodes"].values()), strict=strict)
 
 
 @dataclasses.dataclass(slots=True, frozen=True, kw_only=True, weakref_slot=True, repr=False)
@@ -193,7 +201,7 @@ class FileSystem(SimpleFileSystem):
     _deleted: frozenset[NodeID]
 
     @classmethod
-    def build(cls, nodes: Iterable[Node]) -> Self:
+    def build(cls, nodes: Iterable[Node], *, strict: bool = False) -> Self:
         # This is really expensive
         # We do 5 loops over all nodes:
         # SimpleFileSystem:
@@ -205,14 +213,14 @@ class FileSystem(SimpleFileSystem):
         # - 4. Sort their paths
         # - 5. Freeze inv paths (list -> tuple)
 
-        self = SimpleFileSystem.build(nodes)
+        self = SimpleFileSystem.build(nodes, strict=strict)
 
         roots = list(filter(None, (self.root, self.inbox, self.trash_bin))) or [next(iter(self.nodes.values()))]
         paths: dict[NodeID, PurePosixPath] = {}
         inv_paths: dict[PurePosixPath, list[NodeID]] = {}
         deleted_ids: set[NodeID] = set()
 
-        for node_id, path, was_deleted in sorted(_resolve_paths(self, *roots), key=lambda x: str(x[1]).casefold()):
+        for node_id, path, was_deleted in sorted(_resolve_paths(self, *roots), key=lambda x: str(x.path).casefold()):
             paths[node_id] = path
             inv_paths.setdefault(path, []).append(node_id)
             if was_deleted:

async_mega_py-2.5.2/src/mega/vault.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import dataclasses
+import logging
+from typing import TYPE_CHECKING, Final, NamedTuple
+
+from mega.crypto import b64_to_a32, decrypt_key
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
+    from mega.data_structures import ComposedFileKey, GetNodesResponse, Node, NodeID, NodeKey, SharedKeys, UserID
+
+logger = logging.getLogger(__name__)
+_EXPORTED: Final = "EXP"
+# An special owner used for exported (AKA public) file/folders
+
+
+class KeyLookup(NamedTuple):
+    full_key: ComposedFileKey | NodeKey
+    share_key: NodeKey | None
+
+
+@dataclasses.dataclass(slots=True, frozen=True)
+class MegaVault:
+    master_key: tuple[int, ...] = ()
+
+    _shared_keys: dict[UserID, SharedKeys] = dataclasses.field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        _ = self._shared_keys.setdefault(_EXPORTED, {})
+
+    def update(self, api_resp: GetNodesResponse) -> None:
+        """Parse and update keys not associated with an user"""
+
+        new_keys: SharedKeys = {}
+        for share_key in api_resp["ok"]:
+            node_id, key = share_key["h"], share_key["k"]
+            new_keys[node_id] = decrypt_key(b64_to_a32(key), self.master_key)
+
+        for share_target in api_resp["s"]:
+            node_id, owner = share_target["h"], share_target["u"]
+            if key := new_keys.get(node_id):
+                self._shared_keys.setdefault(owner, {})[node_id] = key
+
+    def __getitem__(self, node: Node) -> KeyLookup:
+        keys = self.get_keys(node)
+        if len(keys) > 1:
+            logger.warning("Found multiple keys for node %s, using latest one", node.id)
+        return keys[-1]
+
+    def _get_keys(self, node: Node) -> Generator[KeyLookup]:
+        def cast_key(full_key: tuple[int, ...], share_key: tuple[int, ...] | None):
+            if len(full_key) not in (4, 8):
+                raise RuntimeError(f"Invalid key len found for node {node.id} ({len(full_key)})")
+
+            return KeyLookup(full_key, share_key)  # pyright: ignore[reportArgumentType]
+
+        # my files/folders
+        if node.owner in node.keys:
+            full_key = decrypt_key(b64_to_a32(node.keys[node.owner]), self.master_key)
+            yield cast_key(full_key, None)
+            return
+
+        # folders shared with me
+        if node.share_owner and node.share_key and node.id in node.keys:
+            share_key = decrypt_key(b64_to_a32(node.share_key), self.master_key)
+            full_key = decrypt_key(b64_to_a32(node.keys[node.id]), share_key)
+            self._shared_keys.setdefault(node.share_owner, {})[node.id] = share_key
+            yield cast_key(full_key, share_key)
+            return
+
+        # files shared with me
+        if node.owner in self._shared_keys:
+            shared_keys = self._shared_keys[node.owner]
+            for node_id, encrypted_key in node.keys.items():
+                try:
+                    share_key = shared_keys[node_id]
+                except KeyError:
+                    continue
+
+                full_key = decrypt_key(b64_to_a32(encrypted_key), share_key)
+                yield cast_key(full_key, share_key)
+            return
+
+        # public files/folders
+        if share_key := self._shared_keys[_EXPORTED].get(node.id):
+            exported_nodes = self._shared_keys[_EXPORTED].keys()
+            for node_id, encrypted_key in node.keys.items():
+                if node_id not in exported_nodes:
+                    continue
+
+                full_key = decrypt_key(b64_to_a32(encrypted_key), share_key)
+                yield cast_key(full_key, share_key)
+
+    def get_keys(self, node: Node) -> list[KeyLookup]:
+        keys = list(self._get_keys(node))
+        if len(keys) == 0:
+            raise RuntimeError(f"We do not have keys for {node = }")
+        return keys
+
+    def save_public_key(self, node_id: NodeID, share_key: tuple[int, ...]) -> None:
+        self._shared_keys[_EXPORTED][node_id] = share_key

async_mega_py-2.5.1/src/mega/vault.py

@@ -1,85 +0,0 @@
-from __future__ import annotations
-
-import dataclasses
-from typing import TYPE_CHECKING, Final, NamedTuple, cast
-
-from mega.crypto import b64_to_a32, decrypt_key
-
-if TYPE_CHECKING:
-    from mega.data_structures import (
-        ComposedFileKey,
-        GetNodesResponse,
-        Node,
-        NodeID,
-        NodeKey,
-        SharedKeys,
-        UserID,
-    )
-
-
-_EXPORTED: Final = "EXP"
-# An special owner used for exported (AKA public) file/folders
-
-
-class KeyLookup(NamedTuple):
-    full_key: ComposedFileKey | NodeKey
-    share_key: NodeKey | None
-
-
-@dataclasses.dataclass(slots=True, frozen=True)
-class MegaVault:
-    master_key: tuple[int, ...] = ()
-
-    _shared_keys: dict[UserID, SharedKeys] = dataclasses.field(default_factory=dict)
-
-    def __post_init__(self) -> None:
-        _ = self._shared_keys.setdefault(_EXPORTED, {})
-
-    def update(self, api_resp: GetNodesResponse) -> None:
-        """Parse and update keys not associated with an user"""
-
-        new_keys: SharedKeys = {}
-        for share_key in api_resp["ok"]:
-            node_id, key = share_key["h"], share_key["k"]
-            new_keys[node_id] = decrypt_key(b64_to_a32(key), self.master_key)
-
-        for share_target in api_resp["s"]:
-            node_id, owner = share_target["h"], share_target["u"]
-            if key := new_keys.get(node_id):
-                self._shared_keys.setdefault(owner, {})[node_id] = key
-
-    def __getitem__(self, node: Node) -> KeyLookup:
-        share_key: tuple[int, ...] | None = None
-
-        # my files/folders
-        if node.owner in node.keys:
-            full_key = decrypt_key(b64_to_a32(node.keys[node.owner]), self.master_key)
-
-        # folders shared with me
-        elif node.share_owner and node.share_key and node.id in node.keys:
-            share_key = decrypt_key(b64_to_a32(node.share_key), self.master_key)
-            full_key = decrypt_key(b64_to_a32(node.keys[node.id]), share_key)
-            self._shared_keys.setdefault(node.share_owner, {})[node.id] = share_key
-
-        # files shared with me
-        elif node.owner in self._shared_keys:
-            real_node_id = next(node_id for node_id in node.keys if node_id in self._shared_keys[node.owner])
-            share_key = self._shared_keys[node.owner][real_node_id]
-            full_key = decrypt_key(b64_to_a32(node.keys[real_node_id]), share_key)
-
-        # public files/folders
-        elif share_key := self._shared_keys[_EXPORTED].get(node.id):
-            real_node_id = next(node_id for node_id in node.keys if node_id in self._shared_keys[_EXPORTED])
-            encrypted_key = b64_to_a32(node.keys[real_node_id])
-            full_key = decrypt_key(encrypted_key, share_key)
-
-        else:
-            raise RuntimeError(f"We do not have keys for {node = }")
-
-        if len(full_key) not in (4, 8):
-            raise RuntimeError(f"Invalid key len found for node {node.id} ({len(full_key)})")
-
-        return KeyLookup(cast("ComposedFileKey | NodeKey", full_key), share_key)
-
-    def save_public_key(self, node_id: NodeID, share_key: tuple[int, ...]) -> None:
-        self._shared_keys[_EXPORTED][node_id] = share_key