supernote 0.2.0__tar.gz → 0.3.0__tar.gz

{supernote-0.2.0/supernote.egg-info → supernote-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: supernote
-Version: 0.2.0
+Version: 0.3.0
 Summary: Unofficial python library for parsing Supernote notebooks
 Author-email: jya <jya@wizmy.net>, Allen Porter <allen.porter@gmail.com>
 License-Expression: Apache-2.0
@@ -15,6 +15,8 @@ Requires-Dist: potracer>=0.0.1
 Requires-Dist: pypng>=0.0.20
 Requires-Dist: reportlab>=3.6.1
 Requires-Dist: svgwrite>=1.4
+Requires-Dist: aiohttp>=3.13.2
+Requires-Dist: mashumaro>=3.17
 Dynamic: license-file
 
 # supernote
@@ -28,7 +30,7 @@ having a similar dependency limitation.
 ## Development
 
 ```
-uv venv
+uv venv --python=3.14
 source .venv/bin/activate
 uv pip install -r requirements_dev.txt
 ```

{supernote-0.2.0 → supernote-0.3.0}/README.md

@@ -9,7 +9,7 @@ having a similar dependency limitation.
 ## Development
 
 ```
-uv venv
+uv venv --python=3.14
 source .venv/bin/activate
 uv pip install -r requirements_dev.txt
 ```

{supernote-0.2.0 → supernote-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ requires = ["setuptools>=77.0"]
 
 [project]
 name = "supernote"
-version = "0.2.0"
+version = "0.3.0"
 license = "Apache-2.0"
 license-files = ["LICENSE"]
 description = "Unofficial python library for parsing Supernote notebooks"
@@ -16,6 +16,7 @@ authors = [
 requires-python = ">=3.13"
 classifiers = []
 dependencies = [
+  # Notebook dependencies
   "colour>=0.1.5",
   "numpy>=1.19.0",
   "Pillow>=7.2.0",
@@ -23,6 +24,10 @@ dependencies = [
   "pypng>=0.0.20",
   "reportlab>=3.6.1",
   "svgwrite>=1.4",
+
+  # Cloud dependencies
+  "aiohttp>=3.13.2",
+  "mashumaro>=3.17",
 ]
 
 [project.urls]
@@ -61,3 +66,6 @@ disallow_untyped_decorators = true
 disallow_untyped_defs = true
 warn_return_any = true
 warn_unreachable = true
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

{supernote-0.2.0 → supernote-0.3.0}/supernote/__init__.py

@@ -11,3 +11,5 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
+__version__ = "0.2.0"

supernote-0.3.0/supernote/cloud/api_model.py

@@ -0,0 +1,231 @@
+"""Model classes for the Supernote Cloud API."""
+
+from dataclasses import dataclass, field
+
+from mashumaro import field_options
+from mashumaro.mixins.json import DataClassJSONMixin
+from mashumaro.config import BaseConfig
+
+COUNTRY_CODE = 1
+BROWSER = "Chrome142"
+EQUIPMENT = 1
+LANGUAGE = "en"
+
+
+@dataclass
+class BaseResponse(DataClassJSONMixin):
+    """Base response class."""
+
+    success: bool = True
+    error_code: str = field(metadata=field_options(alias="errorCode"), default="")
+    error_msg: str = field(metadata=field_options(alias="errorMsg"), default="")
+
+
+@dataclass
+class QueryUserRequest(DataClassJSONMixin):
+    """Request to query user."""
+
+    account: str
+    country_code: int = field(
+        metadata=field_options(alias="countryCode"), default=COUNTRY_CODE
+    )
+
+    class Config(BaseConfig):
+        serialize_by_alias = True
+
+
+@dataclass(kw_only=True)
+class QueryUserResponse(BaseResponse):
+    """Response from query user call."""
+
+    user_id: str = field(metadata=field_options(alias="userId"))
+    user_name: str = field(metadata=field_options(alias="userName"))
+    birthday: str = field(metadata=field_options(alias="birthday"))
+    country_code: str = field(
+        metadata=field_options(alias="countryCode"), default=COUNTRY_CODE
+    )
+    telephone: str = field(metadata=field_options(alias="telephone"), default="")
+    sex: str = ""
+    file_server: str = field(metadata=field_options(alias="fileServer"), default="")
+
+
+@dataclass
+class TokenRequest(DataClassJSONMixin):
+    """Request to token endpoint."""
+
+    class Config(BaseConfig):
+        serialize_by_alias = True
+
+
+@dataclass
+class TokenResponse(BaseResponse):
+    """Response from token endpoint."""
+
+
+@dataclass
+class UserRandomCodeRequest(DataClassJSONMixin):
+    """Request to get a random code."""
+
+    account: str
+    country_code: int = field(
+        metadata=field_options(alias="countryCode"), default=COUNTRY_CODE
+    )
+
+    class Config(BaseConfig):
+        serialize_by_alias = True
+
+
+@dataclass
+class UserRandomCodeResponse(BaseResponse):
+    """Response from login."""
+
+    random_code: str = field(metadata=field_options(alias="randomCode"), default="")
+    timestamp: str = ""
+
+
+@dataclass
+class UserLoginRequest(DataClassJSONMixin):
+    """Request to login."""
+
+    account: str
+    password: str
+    login_method: int = field(metadata=field_options(alias="loginMethod"))
+    timestamp: str
+    language: str = LANGUAGE
+    country_code: int = field(
+        metadata=field_options(alias="countryCode"), default=COUNTRY_CODE
+    )
+    browser: str = BROWSER
+    equipment: int = EQUIPMENT
+
+    class Config(BaseConfig):
+        serialize_by_alias = True
+
+
+@dataclass(kw_only=True)
+class UserLoginResponse(BaseResponse):
+    """Response from access token call."""
+
+    token: str
+
+
+@dataclass
+class UserSmsLoginRequest(DataClassJSONMixin):
+    """Request to login via sms."""
+
+    telephone: str
+    timestamp: str
+    valid_code: str = field(metadata=field_options(alias="validCode"))
+    # String like "1-{telephone}_validCode"
+    valid_code_key: str = field(metadata=field_options(alias="validCodeKey"))
+
+    country_code: int = field(
+        metadata=field_options(alias="countryCode"), default=COUNTRY_CODE
+    )
+    browser: str = BROWSER
+    equipment: int = EQUIPMENT
+
+    class Config(BaseConfig):
+        serialize_by_alias = True
+
+
+@dataclass
+class UserPreAuthRequest(DataClassJSONMixin):
+    """Request for pre-auth."""
+
+    account: str
+
+
+@dataclass
+class UserPreAuthResponse(BaseResponse):
+    """Response from pre-auth."""
+
+    token: str = ""
+
+
+@dataclass
+class UserSendSmsRequest(DataClassJSONMixin):
+    """Request to send SMS code."""
+
+    telephone: str
+    timestamp: str
+    token: str
+    sign: str
+    nationcode: int = field(
+        metadata=field_options(alias="nationcode"), default=COUNTRY_CODE
+    )
+
+    class Config(BaseConfig):
+        serialize_by_alias = True
+
+
+@dataclass
+class UserSendSmsResponse(BaseResponse):
+    """Response from send SMS."""
+
+    valid_code_key: str = field(
+        metadata=field_options(alias="validCodeKey"), default=""
+    )
+
+
+@dataclass(kw_only=True)
+class UserSmsLoginResponse(BaseResponse):
+    """Response from access token call."""
+
+    token: str
+
+
+@dataclass(kw_only=True)
+class File(DataClassJSONMixin):
+    """Representation of a file."""
+
+    id: int
+    directory_id: int = field(metadata=field_options(alias="directoryId"))
+    file_name: str = field(metadata=field_options(alias="fileName"))
+    size: int = 0
+    md5: str = ""
+    is_folder: str = field(metadata=field_options(alias="isFolder"))  # "Y" or "N"
+    create_time: int = field(metadata=field_options(alias="createTime"))
+    update_time: int = field(metadata=field_options(alias="updateTime"))
+
+
+@dataclass
+class FileListRequest(DataClassJSONMixin):
+    """Request for file list."""
+
+    directory_id: int = field(metadata=field_options(alias="directoryId"))
+    page_no: int = field(metadata=field_options(alias="pageNo"))
+    page_size: int = field(metadata=field_options(alias="pageSize"), default=20)
+    order: str = "time"
+    sequence: str = "desc"
+
+    class Config(BaseConfig):
+        serialize_by_alias = True
+
+
+@dataclass(kw_only=True)
+class FileListResponse(BaseResponse):
+    """Response from file list call."""
+
+    total: int
+    size: int
+    pages: int
+    file_list: list[File] = field(metadata=field_options(alias="userFileVOList"))
+
+
+@dataclass
+class GetFileDownloadUrlRequest(DataClassJSONMixin):
+    """Request for file download."""
+
+    file_id: int = field(metadata=field_options(alias="id"))
+    file_type: int = field(metadata=field_options(alias="type"), default=0)
+
+    class Config(BaseConfig):
+        serialize_by_alias = True
+
+
+@dataclass(kw_only=True)
+class GetFileDownloadUrlResponse(BaseResponse):
+    """Response from file download call."""
+
+    url: str

supernote-0.3.0/supernote/cloud/auth.py

@@ -0,0 +1,67 @@
+"""Library for authentication."""
+
+from abc import ABC, abstractmethod
+import logging
+import pickle
+import os
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class AbstractAuth(ABC):
+    """Authentication library."""
+
+    @abstractmethod
+    async def async_get_access_token(self) -> str:
+        """Return a valid access token."""
+
+
+class ConstantAuth(AbstractAuth):
+    """Authentication library."""
+
+    def __init__(self, access_token: str):
+        """Initialize the auth."""
+        self._access_token = access_token
+
+    async def async_get_access_token(self) -> str:
+        """Return a valid access token."""
+        return self._access_token
+
+
+class FileCacheAuth(AbstractAuth):
+    """Authentication library that caches token in a file."""
+
+    def __init__(self, cache_path: str):
+        """Initialize the auth."""
+        self._cache_path = cache_path
+        self._access_token = None
+
+    async def async_get_access_token(self) -> str:
+        """Return a valid access token."""
+        if self._access_token:
+            return self._access_token
+
+        if os.path.exists(self._cache_path):
+            try:
+                with open(self._cache_path, "rb") as f:
+                    data = pickle.load(f)
+                    if isinstance(data, dict) and "access_token" in data:
+                        self._access_token = data["access_token"]
+                        return self._access_token
+            except Exception as err:
+                _LOGGER.warning("Failed to load token from cache: %s", err)
+
+        raise ValueError("No access token found in cache")
+
+    def save_access_token(self, token: str) -> None:
+        """Save access token to cache."""
+        self._access_token = token
+
+        # Ensure directory exists
+        os.makedirs(os.path.dirname(self._cache_path), exist_ok=True)
+
+        try:
+            with open(self._cache_path, "wb") as f:
+                pickle.dump({"access_token": token}, f)
+        except Exception as err:
+            _LOGGER.warning("Failed to save token to cache: %s", err)

supernote-0.3.0/supernote/cloud/client.py

@@ -0,0 +1,184 @@
+"""Library for accessing backups in Supenote Cloud."""
+
+import logging
+from typing import Any, Type, TypeVar
+
+import aiohttp
+from aiohttp.client_exceptions import ClientError
+
+from .api_model import BaseResponse
+from .exceptions import ApiException, UnauthorizedException, ForbiddenException
+from .auth import AbstractAuth
+
+_LOGGER = logging.getLogger(__name__)
+
+API_URL = "https://cloud.supernote.com/api"
+HEADERS = {
+    "Content-Type": "application/json",
+    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36",
+    "Referer": "https://cloud.supernote.com/",
+    "Origin": "https://cloud.supernote.com",
+}
+ACCESS_TOKEN = "x-access-token"
+XSRF_COOKIE = "XSRF-TOKEN"
+XSRF_HEADER = "X-XSRF-TOKEN"
+
+
+_T = TypeVar("_T", bound=BaseResponse)
+
+
+class Client:
+    """Library that makes authenticated HTTP requests."""
+
+    def __init__(
+        self,
+        websession: aiohttp.ClientSession,
+        host: str | None = None,
+        auth: AbstractAuth | None = None,
+    ):
+        """Initialize the auth."""
+        self._websession = websession
+        self._host = host or API_URL
+        self._auth = auth
+        self._xsrf_token: str | None = None
+
+    async def request(
+        self,
+        method: str,
+        url: str,
+        headers: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> aiohttp.ClientResponse:
+        """Make a request."""
+        if headers is None:
+            headers = {
+                **HEADERS,
+            }
+        # Always get a fresh CSRF token
+        self._xsrf_token = await self._get_csrf_token()
+        headers[XSRF_HEADER] = self._xsrf_token
+
+        if self._auth and ACCESS_TOKEN not in headers:
+            access_token = await self._auth.async_get_access_token()
+            headers[ACCESS_TOKEN] = access_token
+        if not (url.startswith("http://") or url.startswith("https://")):
+            url = f"{self._host}/{url}"
+        _LOGGER.debug(
+            "request[%s]=%s %s %s",
+            method,
+            url,
+            kwargs.get("params"),
+            headers,
+        )
+        if method != "get" and "json" in kwargs:
+            _LOGGER.debug("request[post json]=%s", kwargs["json"])
+        response = await self._websession.request(
+            method, url, **kwargs, headers=headers
+        )
+        return response
+
+    async def get(self, url: str, **kwargs: Any) -> aiohttp.ClientResponse:
+        """Make a get request."""
+        try:
+            resp = await self.request("get", url, **kwargs)
+        except ClientError as err:
+            raise ApiException(f"Error connecting to API: {err}") from err
+        return await self._raise_for_status(resp)
+
+    async def get_json(
+        self,
+        url: str,
+        data_cls: Type[_T],
+        **kwargs: Any,
+    ) -> _T:
+        """Make a get request and return json response."""
+        resp = await self.get(url, **kwargs)
+        try:
+            result = await resp.text()
+        except ClientError as err:
+            raise ApiException("Server returned malformed response") from err
+        _LOGGER.debug("response=%s", result)
+        try:
+            data_response = data_cls.from_json(result)
+        except (LookupError, ValueError) as err:
+            raise ApiException(f"Server return malformed response: {result}") from err
+        if not data_response.success:
+            raise ApiException(data_response.error_msg)
+        return data_response
+
+    async def post(self, url: str, **kwargs: Any) -> aiohttp.ClientResponse:
+        """Make a post request."""
+        try:
+            resp = await self.request("post", url, **kwargs)
+        except ClientError as err:
+            raise ApiException(f"Error connecting to API: {err}") from err
+        return await self._raise_for_status(resp)
+
+    async def post_json(self, url: str, data_cls: Type[_T], **kwargs: Any) -> _T:
+        """Make a post request and return a json response."""
+        resp = await self.post(url, **kwargs)
+        try:
+            result = await resp.text()
+        except ClientError as err:
+            raise ApiException("Server returned malformed response") from err
+        try:
+            data_response = data_cls.from_json(result)
+        except (LookupError, ValueError) as err:
+            raise ApiException(f"Server return malformed response: {result}") from err
+        if not data_response.success:
+            raise ApiException(data_response.error_msg)
+        return data_response
+
+    async def _get_csrf_token(self) -> str:
+        """Get the CSRF token."""
+        url = f"{self._host}/csrf"
+        _LOGGER.debug("CSRF request[get]=%s %s", url, HEADERS)
+        resp = await self._websession.request("get", url, headers=HEADERS)
+        try:
+            result = await resp.text()
+        except ClientError as err:
+            raise ApiException("Server returned malformed response") from err
+        _LOGGER.debug("CSRF response=%s", result)
+        _LOGGER.debug("CSRF response headers=%s", resp.headers)
+        token = resp.headers.get(XSRF_HEADER)
+        if token is None:
+            raise ApiException("Failed to get CSRF token from header")
+        _LOGGER.debug("CSRF token=%s", token)
+        _LOGGER.debug("CSRF response cookies=%s", resp.cookies)
+        return token
+
+    @classmethod
+    async def _raise_for_status(
+        cls, resp: aiohttp.ClientResponse
+    ) -> aiohttp.ClientResponse:
+        """Raise exceptions on failure methods."""
+        error_detail = await cls._error_detail(resp)
+        try:
+            resp.raise_for_status()
+        except aiohttp.ClientResponseError as err:
+            if err.status == 401:
+                error_message = (
+                    f"Unauthorized response from API ({err.status}): {error_detail}"
+                )
+                raise UnauthorizedException(error_message) from err
+            if err.status == 403:
+                error_message = (
+                    f"Forbidden response from API ({err.status}): {error_detail}"
+                )
+                raise ForbiddenException(error_message) from err
+            error_message = f"Error response from API ({err.status}): {error_detail}"
+            raise ApiException(error_message) from err
+        except aiohttp.ClientError as err:
+            raise ApiException(f"Error from API: {err}") from err
+        return resp
+
+    @classmethod
+    async def _error_detail(cls, resp: aiohttp.ClientResponse) -> str | None:
+        """Returns an error message string from the APi response."""
+        if resp.status < 400:
+            return None
+        try:
+            result = await resp.text()
+        except ClientError:
+            return None
+        return result

supernote-0.3.0/supernote/cloud/cloud_client.py

@@ -0,0 +1,48 @@
+"""Library for accessing backups in Supenote Cloud."""
+
+from .api_model import (
+    FileListResponse,
+    GetFileDownloadUrlRequest,
+    GetFileDownloadUrlResponse,
+    FileListRequest,
+    QueryUserResponse,
+    QueryUserRequest,
+)
+from .client import Client
+
+
+class SupernoteCloudClient:
+    """A client library for Supernote Cloud."""
+
+    def __init__(self, client: Client):
+        """Initialize the client."""
+        self._client = client
+
+    async def query_user(self, account: str) -> QueryUserResponse:
+        """Query the user."""
+        payload = QueryUserRequest(country_code=1, account=account).to_dict()
+        return await self._client.post_json(
+            "user/query", QueryUserResponse, json=payload
+        )
+
+    async def file_list(self, directory_id: int = 0) -> FileListResponse:
+        """Return a list of files."""
+        payload = FileListRequest(
+            directory_id=directory_id,
+            page_no=1,
+            page_size=100,
+            order="time",
+            sequence="desc",
+        ).to_dict()
+        return await self._client.post_json(
+            "file/list/query", FileListResponse, json=payload
+        )
+
+    async def file_download(self, file_id: int) -> bytes:
+        """Download a file."""
+        payload = GetFileDownloadUrlRequest(file_id=file_id, file_type=0).to_dict()
+        download_url_response = await self._client.post_json(
+            "file/download/url", GetFileDownloadUrlResponse, json=payload
+        )
+        response = await self._client.get(download_url_response.url)
+        return await response.read()

supernote-0.3.0/supernote/cloud/exceptions.py

@@ -0,0 +1,25 @@
+"""Exceptions for supernote cloud."""
+
+
+class SupernoteException(Exception):
+    """Base exception for supernote cloud."""
+
+
+class SmsVerificationRequired(SupernoteException):
+    """Exception raised when SMS verification is required."""
+
+    def __init__(self, message: str, timestamp: str):
+        super().__init__(message)
+        self.timestamp = timestamp
+
+
+class ApiException(SupernoteException):
+    """API exception."""
+
+
+class ForbiddenException(ApiException):
+    """API exception."""
+
+
+class UnauthorizedException(ApiException):
+    """Authentication exception."""

supernote-0.3.0/supernote/cloud/login_client.py

@@ -0,0 +1,174 @@
+"""Library for accessing backups in Supenote Cloud."""
+
+import hashlib
+import logging
+from typing import TypeVar
+
+from mashumaro.mixins.json import DataClassJSONMixin
+
+from .api_model import (
+    UserLoginRequest,
+    UserLoginResponse,
+    UserRandomCodeRequest,
+    UserRandomCodeResponse,
+    UserSmsLoginRequest,
+    UserSmsLoginResponse,
+    UserPreAuthRequest,
+    UserPreAuthResponse,
+    UserSendSmsRequest,
+    UserSendSmsResponse,
+    TokenRequest,
+    TokenResponse,
+)
+from .client import Client
+from .exceptions import ApiException, SmsVerificationRequired
+
+_LOGGER = logging.getLogger(__name__)
+
+
+_T = TypeVar("_T", bound=DataClassJSONMixin)
+
+
+def _sha256_s(s: str) -> str:
+    return hashlib.sha256(s.encode("utf-8")).hexdigest()
+
+
+def _md5_s(s: str) -> str:
+    return hashlib.md5(s.encode("utf-8")).hexdigest()
+
+
+def _encode_password(password: str, rc: str) -> str:
+    return _sha256_s(_md5_s(password) + rc)
+
+
+def _extract_real_key(token: str) -> str:
+    """Extract real key from token as per JS logic."""
+    # var t = e.charAt(e.length - 1)
+    # var n = parseInt(t)
+    # var a = e.split("-")
+    # var o = a[n];
+    if not token:
+        return ""
+    last_char = token[-1]
+    try:
+        index = int(last_char)
+        parts = token.split("-")
+        if 0 <= index < len(parts):
+            return parts[index]
+    except ValueError:
+        pass
+    return ""
+
+
+class LoginClient:
+    """A client library for logging in."""
+
+    def __init__(self, client: Client):
+        """Initialize the client."""
+        self._client = client
+
+    async def login(self, email: str, password: str) -> str:
+        """Log in and return an access token."""
+        await self._token()
+        random_code_response = await self._get_random_code(email)
+        encoded_password = _encode_password(password, random_code_response.random_code)
+        access_token_response = await self._get_access_token(
+            email, encoded_password, random_code_response.timestamp
+        )
+        return access_token_response.token
+
+    async def sms_login(self, telephone: str, code: str, timestamp: str) -> str:
+        """Log in via SMS code."""
+        # Always get a fresh CSRF token for the SMS login request
+        await self._client._get_csrf_token()
+
+        payload = UserSmsLoginRequest(
+            telephone=telephone,
+            timestamp=timestamp,
+            valid_code=code,
+            valid_code_key=f"1-{telephone}_validCode",
+        ).to_dict()
+
+        response = await self._client.post_json(
+            "official/user/sms/login", UserSmsLoginResponse, json=payload
+        )
+        return response.token
+
+    async def request_sms_code(self, telephone: str, country_code: int = 1) -> None:
+        """Request an SMS verification code."""
+        # 1. Pre-auth to get token
+        # Note: The JS code prefixes the account with the country code for pre-auth
+        # account: this.tempAccountInfo.countryCode + this.tempAccountInfo.account
+        account_with_code = f"{country_code}{telephone}"
+        pre_auth_payload = UserPreAuthRequest(account=account_with_code).to_dict()
+
+        # Always get a fresh CSRF token
+        await self._client._get_csrf_token()
+
+        pre_auth_response = await self._client.post_json(
+            "user/validcode/pre-auth", UserPreAuthResponse, json=pre_auth_payload
+        )
+
+        token = pre_auth_response.token
+
+        # 2. Extract real key and calculate sign
+        # e.sign = e.hash256(n + a) where n is account_with_code and a is real_key
+        real_key = _extract_real_key(token)
+        sign = _sha256_s(account_with_code + real_key)
+
+        # 3. Send SMS
+        # timestamp is needed here. In the JS it uses e.tempAccountInfo.timestamp
+        # We might need to fetch a timestamp first if we don't have one, but let's see.
+        # The JS gets timestamp from the initial login failure or a separate query.
+        # For now, let's try to get a fresh timestamp/random code first?
+        # Actually, the JS flow for "sendVerificationCode" seems to use existing timestamp.
+        # But if we are starting fresh, we might need one.
+        # Let's assume we can get a fresh random code to get a timestamp.
+        random_code_resp = await self._get_random_code(telephone)
+        timestamp = random_code_resp.timestamp
+
+        sms_payload = UserSendSmsRequest(
+            telephone=telephone,
+            timestamp=timestamp,
+            token=token,
+            sign=sign,
+            nationcode=country_code,
+        ).to_dict()
+
+        await self._client.post_json(
+            "user/sms/validcode/send", UserSendSmsResponse, json=sms_payload
+        )
+
+    async def _token(self) -> None:
+        """Get a random code."""
+        await self._client.post_json(
+            "user/query/token",
+            TokenResponse,
+            json=TokenRequest().to_dict(),
+        )
+
+    async def _get_random_code(self, email: str) -> UserRandomCodeResponse:
+        """Get a random code."""
+        payload = UserRandomCodeRequest(account=email).to_dict()
+        return await self._client.post_json(
+            "official/user/query/random/code", UserRandomCodeResponse, json=payload
+        )
+
+    async def _get_access_token(
+        self, email: str, encoded_password: str, random_code_timestamp: str
+    ) -> UserLoginResponse:
+        """Get an access token."""
+        payload = UserLoginRequest(
+            account=email,
+            password=encoded_password,
+            login_method=1,
+            timestamp=random_code_timestamp,
+        ).to_dict()
+        try:
+            return await self._client.post_json(
+                "official/user/account/login/new", UserLoginResponse, json=payload
+            )
+        except ApiException as err:
+            if "verification code" in str(err):
+                raise SmsVerificationRequired(str(err), random_code_timestamp) from err
+            raise

supernote-0.3.0/supernote/cmds/__init__.py

@@ -0,0 +1 @@
+"""Supernote command line tool."""

supernote-0.3.0/supernote/cmds/cloud_login_tool.py

@@ -0,0 +1,247 @@
+#!/usr/bin/env python3
+"""Cloud login debugging tool for Supernote Cloud."""
+
+import asyncio
+import logging
+import sys
+import os
+
+import aiohttp
+
+from supernote.cloud.client import Client
+from supernote.cloud.login_client import LoginClient
+from supernote.cloud.auth import FileCacheAuth
+from supernote.cloud.cloud_client import SupernoteCloudClient
+from supernote.cloud.exceptions import SupernoteException
+
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def setup_logging(verbose: bool = False) -> None:
+    """Setup logging configuration."""
+    level = logging.DEBUG if verbose else logging.INFO
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        stream=sys.stdout,
+    )
+    # Enable debug logging for cloud modules and aiohttp
+    if verbose:
+        logging.getLogger("supernote.cloud").setLevel(logging.DEBUG)
+        logging.getLogger("supernote.cloud.client").setLevel(logging.DEBUG)
+        logging.getLogger("aiohttp").setLevel(logging.DEBUG)
+
+
+async def async_cloud_login(email: str, password: str, verbose: bool = False) -> None:
+    """Perform cloud login with detailed debugging output.
+
+    Args:
+        email: User email/account
+        password: User password
+        verbose: Enable verbose HTTP logging
+    """
+    setup_logging(verbose)
+
+    print("=" * 80)
+    print("Supernote Cloud Login Debugging Tool")
+    print("=" * 80)
+    print(f"Email: {email}")
+    print(
+        f"Verbose Mode: {'ENABLED' if verbose else 'DISABLED (use -v or --verbose for detailed logs)'}"
+    )
+    print("=" * 80)
+    print()
+
+    async with aiohttp.ClientSession() as session:
+        try:
+            # Step 1: Create client and login
+            print("Step 1: Initializing client...")
+            client = Client(session)
+            login_client = LoginClient(client)
+
+            print("Step 2: Starting login flow...")
+            print("  - This will get CSRF token")
+            print("  - Call token endpoint")
+            print("  - Get random code")
+            print("  - Encode password")
+            print("  - Submit login request")
+            print()
+
+            try:
+                access_token = await login_client.login(email, password)
+            except SupernoteException as err:
+                # Check if it's an SMS verification requirement
+                # We do this by checking the exception type, but since we just added it
+                # we need to make sure we import it.
+                # For now, let's assume if the message contains "verification code" it is one.
+                # But better to use the type.
+                from supernote.cloud.exceptions import SmsVerificationRequired
+
+                if isinstance(err, SmsVerificationRequired):
+                    print()
+                    print("!" * 80)
+                    print("SMS Verification Required")
+                    print("!" * 80)
+                    print(f"Message: {err}")
+                    print("The server has sent an SMS verification code to your phone.")
+                    print()
+
+                    print("Requesting SMS verification code...")
+                    await login_client.request_sms_code(email)
+                    print("SMS code requested successfully.")
+                    print()
+
+                    code = input("Enter verification code: ").strip()
+                    print()
+                    print("Submitting verification code...")
+
+                    access_token = await login_client.sms_login(
+                        email, code, err.timestamp
+                    )
+                else:
+                    raise
+
+            print("✓ Login successful!")
+            print(
+                f"Access Token: {access_token[:20]}..."
+                if len(access_token) > 20
+                else access_token
+            )
+            print()
+
+            # Save token to cache
+            cache_path = os.path.expanduser("~/.cache/supernote.pkl")
+            print(f"Saving token to {cache_path}...")
+            auth = FileCacheAuth(cache_path)
+            auth.save_access_token(access_token)
+            print("✓ Token saved!")
+            print()
+
+            # Step 2: Test basic functionality
+            print("Step 3: Testing basic functionality...")
+            # auth = ConstantAuth(access_token) # No longer needed as we use FileCacheAuth
+            authenticated_client = Client(session, auth=auth)
+            cloud_client = SupernoteCloudClient(authenticated_client)
+
+            # Test 1: Query user
+            print("  Test 1: Querying user information...")
+            try:
+                user_response = await cloud_client.query_user(email)
+                print("  ✓ User query successful!")
+                print(f"    - User ID: {user_response.user_id}")
+                print(f"    - User Name: {user_response.user_name}")
+                print(f"    - Country Code: {user_response.country_code}")
+                if user_response.file_server:
+                    print(f"    - File Server: {user_response.file_server}")
+            except SupernoteException as err:
+                print(f"  ✗ User query failed: {err}")
+            print()
+
+            # Test 2: List files
+            print("  Test 2: Listing files in root directory...")
+            try:
+                file_list_response = await cloud_client.file_list(directory_id=0)
+                print("  ✓ File list successful!")
+                print(f"    - Total files: {file_list_response.total}")
+                print(f"    - Pages: {file_list_response.pages}")
+                print(f"    - Files in this page: {file_list_response.size}")
+
+                if file_list_response.file_list:
+                    print("    - First few files:")
+                    for i, file in enumerate(file_list_response.file_list[:5]):
+                        folder_marker = "📁" if file.is_folder == "Y" else "📄"
+                        print(f"      {folder_marker} {file.file_name} (ID: {file.id})")
+                else:
+                    print("    - No files found")
+            except SupernoteException as err:
+                print(f"  ✗ File list failed: {err}")
+            print()
+
+            print("=" * 80)
+            print("All tests completed successfully!")
+            print("=" * 80)
+
+        except SupernoteException as err:
+            print()
+            print("=" * 80)
+            print(f"✗ Error during login flow: {err}")
+            print("=" * 80)
+            if verbose:
+                import traceback
+
+                traceback.print_exc()
+            sys.exit(1)
+        except Exception as err:
+            print()
+            print("=" * 80)
+            print(f"✗ Unexpected error: {err}")
+            print("=" * 80)
+            if verbose:
+                import traceback
+
+                traceback.print_exc()
+            sys.exit(1)
+
+
+def subcommand_cloud_login(args) -> None:
+    """Handler for cloud-login subcommand.
+
+    Args:
+        args: Parsed command line arguments
+    """
+    asyncio.run(async_cloud_login(args.email, args.password, args.verbose))
+
+
+async def async_cloud_ls(verbose: bool = False) -> None:
+    """List files in Supernote Cloud using cached credentials.
+
+    Args:
+        verbose: Enable verbose logging
+    """
+    setup_logging(verbose)
+
+    cache_path = os.path.expanduser("~/.cache/supernote.pkl")
+    if not os.path.exists(cache_path):
+        print(f"Error: No cached credentials found at {cache_path}")
+        print("Please run 'supernote-tool cloud-login' first.")
+        sys.exit(1)
+
+    async with aiohttp.ClientSession() as session:
+        try:
+            auth = FileCacheAuth(cache_path)
+            client = Client(session, auth=auth)
+            cloud_client = SupernoteCloudClient(client)
+
+            print("Listing files in root directory...")
+            file_list_response = await cloud_client.file_list()
+
+            print(f"Total files: {file_list_response.total}")
+            if file_list_response.file_list:
+                for file in file_list_response.file_list:
+                    folder_marker = "📁" if file.is_folder == "Y" else "📄"
+                    print(f"{folder_marker} {file.file_name} (ID: {file.id})")
+
+        except SupernoteException as err:
+            print(f"Error: {err}")
+            if verbose:
+                import traceback
+
+                traceback.print_exc()
+            sys.exit(1)
+        except Exception as err:
+            print(f"Unexpected error: {err}")
+            if verbose:
+                import traceback
+
+                traceback.print_exc()
+            sys.exit(1)
+
+
+def subcommand_cloud_ls(args) -> None:
+    """Handler for cloud-ls subcommand.
+
+    Args:
+        args: Parsed command line arguments
+    """
+    asyncio.run(async_cloud_ls(args.verbose))

{supernote-0.2.0 → supernote-0.3.0}/supernote/cmds/supernote_tool.py

@@ -29,6 +29,7 @@ from supernote.converter import (
     TextConverter,
 )
 from supernote.converter import VisibilityOverlay
+from supernote.cmds.cloud_login_tool import subcommand_cloud_login, subcommand_cloud_ls
 
 
 def convert_all(converter, total, file_name, save_func, visibility_overlay):
@@ -316,6 +317,26 @@ def main():
     parser_reconstruct.add_argument("output", type=str, help="output note file")
     parser_reconstruct.set_defaults(handler=subcommand_reconstruct)
 
+    # 'cloud-login' subcommand
+    parser_cloud_login = subparsers.add_parser(
+        "cloud-login", help="debug Supernote Cloud login flow"
+    )
+    parser_cloud_login.add_argument("email", type=str, help="user email/account")
+    parser_cloud_login.add_argument("password", type=str, help="user password")
+    parser_cloud_login.add_argument(
+        "-v", "--verbose", action="store_true", help="Enable verbose logging"
+    )
+    parser_cloud_login.set_defaults(handler=subcommand_cloud_login)
+
+    # Cloud ls command
+    cloud_ls_parser = subparsers.add_parser(
+        "cloud-ls", help="List files in Supernote Cloud"
+    )
+    cloud_ls_parser.add_argument(
+        "-v", "--verbose", action="store_true", help="Enable verbose logging"
+    )
+    cloud_ls_parser.set_defaults(handler=subcommand_cloud_ls)
+
     args = parser.parse_args()
     if hasattr(args, "handler"):
         args.handler(args)

{supernote-0.2.0 → supernote-0.3.0/supernote.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: supernote
-Version: 0.2.0
+Version: 0.3.0
 Summary: Unofficial python library for parsing Supernote notebooks
 Author-email: jya <jya@wizmy.net>, Allen Porter <allen.porter@gmail.com>
 License-Expression: Apache-2.0
@@ -15,6 +15,8 @@ Requires-Dist: potracer>=0.0.1
 Requires-Dist: pypng>=0.0.20
 Requires-Dist: reportlab>=3.6.1
 Requires-Dist: svgwrite>=1.4
+Requires-Dist: aiohttp>=3.13.2
+Requires-Dist: mashumaro>=3.17
 Dynamic: license-file
 
 # supernote
@@ -28,7 +30,7 @@ having a similar dependency limitation.
 ## Development
 
 ```
-uv venv
+uv venv --python=3.14
 source .venv/bin/activate
 uv pip install -r requirements_dev.txt
 ```

{supernote-0.2.0 → supernote-0.3.0}/supernote.egg-info/SOURCES.txt

@@ -16,6 +16,13 @@ supernote.egg-info/dependency_links.txt
 supernote.egg-info/entry_points.txt
 supernote.egg-info/requires.txt
 supernote.egg-info/top_level.txt
+supernote/cloud/api_model.py
+supernote/cloud/auth.py
+supernote/cloud/client.py
+supernote/cloud/cloud_client.py
+supernote/cloud/exceptions.py
+supernote/cloud/login_client.py
 supernote/cmds/__init__.py
+supernote/cmds/cloud_login_tool.py
 supernote/cmds/supernote_tool.py
 tests/test_init.py

{supernote-0.2.0 → supernote-0.3.0}/supernote.egg-info/requires.txt

@@ -5,3 +5,5 @@ potracer>=0.0.1
 pypng>=0.0.20
 reportlab>=3.6.1
 svgwrite>=1.4
+aiohttp>=3.13.2
+mashumaro>=3.17