supernote 0.13.6__py3-none-any.whl

supernote/cli/notebook.py

@@ -0,0 +1,313 @@
+"""Notebook CLI commands."""
+
+# Copyright (c) 2020 jya
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+
+import io
+import os
+import sys
+
+from colour import Color
+
+from supernote.notebook import (
+    load,
+    load_notebook,
+    merge,
+    parse_metadata,
+    reconstruct,
+)
+from supernote.notebook.color import MODE_RGB, ColorPalette
+from supernote.notebook.converter import (
+    ImageConverter,
+    PdfConverter,
+    SvgConverter,
+    TextConverter,
+    VisibilityOverlay,
+    build_visibility_overlay,
+)
+
+
+def convert_all(converter, total, file_name, save_func, visibility_overlay):
+    basename, extension = os.path.splitext(file_name)
+    max_digits = len(str(total))
+    for i in range(total):
+        # append page number between filename and extension
+        numbered_filename = basename + "_" + str(i).zfill(max_digits) + extension
+        img = converter.convert(i, visibility_overlay)
+        save_func(img, numbered_filename)
+
+
+def convert_and_concat_all(converter, total, file_name, save_func, separator):
+    data = []
+    for i in range(total):
+        data.append(converter.convert(i))
+    data = list(map(lambda x: "" if x is None else (x + "\n"), data))
+    if len(data) > 0:
+        alldata = ((separator + "\n") if separator else "").join(data)
+        save_func(alldata, file_name)
+    else:
+        print("no data")
+
+
+def convert_to_png(args, notebook, palette):
+    converter = ImageConverter(notebook, palette=palette)
+    bg_visibility = (
+        VisibilityOverlay.INVISIBLE
+        if args.exclude_background
+        else VisibilityOverlay.DEFAULT
+    )
+    vo = build_visibility_overlay(background=bg_visibility)
+
+    def save(img, file_name):
+        img.save(file_name, format="PNG")
+
+    if args.all:
+        total = notebook.get_total_pages()
+        convert_all(converter, total, args.output, save, vo)
+    else:
+        img = converter.convert(args.number, visibility_overlay=vo)
+        save(img, args.output)
+
+
+def convert_to_svg(args, notebook, palette):
+    converter = SvgConverter(notebook, palette=palette)
+    bg_visibility = (
+        VisibilityOverlay.INVISIBLE
+        if args.exclude_background
+        else VisibilityOverlay.DEFAULT
+    )
+    vo = build_visibility_overlay(background=bg_visibility)
+
+    def save(svg, file_name):
+        if svg is not None:
+            with open(file_name, "w") as f:
+                f.write(svg)
+        else:
+            print("no path data")
+
+    if args.all:
+        total = notebook.get_total_pages()
+        convert_all(converter, total, args.output, save, vo)
+    else:
+        svg = converter.convert(args.number, visibility_overlay=vo)
+        save(svg, args.output)
+
+
+def convert_to_pdf(args, notebook, palette):
+    use_link = not args.no_link
+    use_keyword = args.add_keyword
+    converter = PdfConverter(notebook, palette=palette)
+
+    def save(data, file_name):
+        if data is not None:
+            with open(file_name, "wb") as f:
+                f.write(data)
+        else:
+            print("no data")
+
+    if args.all:
+        data = converter.convert(
+            -1, enable_link=use_link, enable_keyword=use_keyword
+        )  # minus value means converting all pages
+        save(data, args.output)
+    else:
+        data = converter.convert(
+            args.number, enable_link=use_link, enable_keyword=use_keyword
+        )
+        save(data, args.output)
+
+
+def convert_to_txt(args, notebook, palette):
+    converter = TextConverter(notebook, palette=palette)
+
+    def save(data, file_name):
+        if data is not None:
+            with open(file_name, "w") as f:
+                f.write(data)
+        else:
+            print("no data")
+
+    if args.all:
+        total = notebook.get_total_pages()
+        convert_and_concat_all(
+            converter, total, args.output, save, args.text_page_separator
+        )
+    else:
+        data = converter.convert(args.number)
+        save(data, args.output)
+
+
+def subcommand_convert(args):
+    notebook = load_notebook(args.input, policy=args.policy)
+    palette = None
+    if args.color:
+        try:
+            colors = parse_color(args.color)
+        except ValueError as e:
+            print(e, file=sys.stderr)
+            sys.exit(1)
+        palette = ColorPalette(MODE_RGB, colors)
+    if args.type == "png":
+        convert_to_png(args, notebook, palette)
+    elif args.type == "svg":
+        convert_to_svg(args, notebook, palette)
+    elif args.type == "pdf":
+        convert_to_pdf(args, notebook, palette)
+    elif args.type == "txt":
+        convert_to_txt(args, notebook, palette)
+
+
+def subcommand_analyze(args):
+    # show all metadata as JSON
+    with open(args.input, "rb") as f:
+        metadata = parse_metadata(f, policy=args.policy)
+    print(metadata.to_json(indent=2))
+
+
+def subcommand_merge(args):
+    num_input = len(args.input)
+    if num_input == 1:  # reconstruct a note file
+        notebook = load_notebook(args.input[0])
+        reconstructed_binary = reconstruct(notebook)
+        with open(args.output, "wb") as f:
+            f.write(reconstructed_binary)
+    else:  # merge multiple note files
+        with open(args.input[0], "rb") as f:
+            merged_binary = f.read()
+        for i in range(1, num_input):
+            stream = io.BytesIO(merged_binary)
+            merged_notebook = load(stream)
+            next_notebook = load_notebook(args.input[i])
+            merged_binary = merge(merged_notebook, next_notebook)
+        with open(args.output, "wb") as f:
+            f.write(merged_binary)
+
+
+def subcommand_reconstruct(args):
+    notebook = load_notebook(args.input)
+    reconstructed_binary = reconstruct(notebook)
+    with open(args.output, "wb") as f:
+        f.write(reconstructed_binary)
+
+
+def parse_color(color_string):
+    colorcodes = color_string.split(",")
+    if len(colorcodes) != 4:
+        raise ValueError(f"few color codes, 4 colors are required: {color_string}")
+    black = int(Color(colorcodes[0]).hex_l[1:7], 16)
+    darkgray = int(Color(colorcodes[1]).hex_l[1:7], 16)
+    gray = int(Color(colorcodes[2]).hex_l[1:7], 16)
+    white = int(Color(colorcodes[3]).hex_l[1:7], 16)
+    return (black, darkgray, gray, white)
+
+
+def add_parser(subparsers):
+    # 'analyze' subcommand
+    parser_analyze = subparsers.add_parser("analyze", help="analyze note file")
+    parser_analyze.add_argument("input", type=str, help="input note file")
+    parser_analyze.add_argument(
+        "--policy",
+        choices=["strict", "loose"],
+        default="strict",
+        help="select parser policy",
+    )
+    parser_analyze.set_defaults(func=subcommand_analyze)
+
+    # 'convert' subcommand
+    parser_convert = subparsers.add_parser("convert", help="image conversion")
+    parser_convert.add_argument("input", type=str, help="input note file")
+    parser_convert.add_argument("output", type=str, help="output image file")
+    parser_convert.add_argument(
+        "-n", "--number", type=int, default=0, help="page number to be converted"
+    )
+    parser_convert.add_argument(
+        "-a", "--all", action="store_true", default=False, help="convert all pages"
+    )
+    parser_convert.add_argument(
+        "-c",
+        "--color",
+        type=str,
+        help="colorize note with comma separated color codes in order of black, darkgray, gray and white.",
+    )
+    parser_convert.add_argument(
+        "-t",
+        "--type",
+        choices=["png", "svg", "pdf", "txt"],
+        default="png",
+        help="select conversion file type",
+    )
+    parser_convert.add_argument(
+        "--exclude-background",
+        action="store_true",
+        default=False,
+        help="exclude background and make it transparent (PNG and SVG are supported)",
+    )
+    parser_convert.add_argument(
+        "--pdf-type",
+        choices=["original"],
+        default="original",
+        help="select PDF conversion type",
+    )
+    parser_convert.add_argument(
+        "--no-link", action="store_true", default=False, help="disable links in PDF"
+    )
+    parser_convert.add_argument(
+        "--add-keyword",
+        action="store_true",
+        default=False,
+        help="enable keywords in PDF",
+    )
+    parser_convert.add_argument(
+        "--text-page-separator",
+        type=str,
+        default="",
+        help="page separator string for text conversion",
+    )
+    parser_convert.add_argument(
+        "--policy",
+        choices=["strict", "loose"],
+        default="strict",
+        help="select parser policy",
+    )
+    parser_convert.set_defaults(func=subcommand_convert)
+
+    # 'merge' subcommand
+    description = """
+        (EXPERIMENTAL FEATURE)
+        This command merge multiple note files to one.
+        Backup your input files to save your data because you might get a corrupted output file.
+        """
+    parser_merge = subparsers.add_parser(
+        "merge",
+        description=description,
+        help="merge multiple note files (EXPERIMENTAL FEATURE)",
+    )
+    parser_merge.add_argument("input", type=str, nargs="+", help="input note files")
+    parser_merge.add_argument("output", type=str, help="output note file")
+    parser_merge.set_defaults(func=subcommand_merge)
+
+    # 'reconstruct' subcommand
+    description = """
+        (EXPERIMENTAL FEATURE)
+        This command disassemble and reconstruct a note file for debugging and testing.
+        Backup your input file to save your data because you might get a corrupted output file.
+        """
+    parser_reconstruct = subparsers.add_parser(
+        "reconstruct",
+        description=description,
+        help="reconstruct a note file (EXPERIMENTAL FEATURE)",
+    )
+    parser_reconstruct.add_argument("input", type=str, help="input note file")
+    parser_reconstruct.add_argument("output", type=str, help="output note file")
+    parser_reconstruct.set_defaults(func=subcommand_reconstruct)

supernote/cli/server.py

@@ -0,0 +1,89 @@
+import argparse
+import logging
+import os
+import tempfile
+from pathlib import Path
+
+from supernote.server import app as server_app
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format="%(message)s")
+logger = logging.getLogger("supernote-cli")
+
+# For ephemeral mode
+DEBUG_EMAIL = "debug@example.com"
+DEBUG_PASSWORD = "password"
+LOGIN_COMMAND = "supernote cloud login --url http://{SUPERNOTE_HOST}:{SUPERNOTE_PORT} {DEBUG_EMAIL} --password {DEBUG_PASSWORD}"
+EXAMPLE_COMMAND = "supernote cloud ls"
+
+
+def serve_run(args: argparse.Namespace) -> None:
+    """Wrapper for serve command to handle ephemeral mode."""
+    if getattr(args, "ephemeral", False):
+        with tempfile.TemporaryDirectory(prefix="supernote-ephemeral-") as tmp_dir:
+            tmp_path = Path(tmp_dir)
+            # Create system directory for database
+            (tmp_path / "system").mkdir(parents=True, exist_ok=True)
+
+            # Set environment variables for the server process
+            os.environ["SUPERNOTE_EPHEMERAL"] = "true"
+            if not os.getenv("SUPERNOTE_PORT"):
+                os.environ["SUPERNOTE_PORT"] = "8080"
+            if not os.getenv("SUPERNOTE_HOST"):
+                os.environ["SUPERNOTE_HOST"] = "127.0.0.1"
+            os.environ["SUPERNOTE_STORAGE_DIR"] = str(tmp_path)
+
+            print(f"Using ephemeral mode with storage directory: {tmp_path}")
+            print(f"Created default user: {DEBUG_EMAIL} / {DEBUG_PASSWORD}")
+            print("Run command to login:")
+            print(
+                "  "
+                + LOGIN_COMMAND.format(
+                    SUPERNOTE_HOST=os.getenv("SUPERNOTE_HOST"),
+                    SUPERNOTE_PORT=os.getenv("SUPERNOTE_PORT"),
+                    DEBUG_EMAIL=DEBUG_EMAIL,
+                    DEBUG_PASSWORD=DEBUG_PASSWORD,
+                )
+            )
+            print("Run command to test:")
+            print("  " + EXAMPLE_COMMAND)
+            server_app.run(args)
+    else:
+        server_app.run(args)
+
+
+def add_parser(subparsers):
+    # Common parent parser
+    base_parser = argparse.ArgumentParser(add_help=False)
+    base_parser.add_argument(
+        "--config-dir",
+        type=str,
+        default=None,
+        help="Path to configuration directory (default: config/)",
+    )
+    parser_serve = subparsers.add_parser(
+        "serve",
+        parents=[base_parser],
+        help="Start the Supernote Private Cloud server",
+    )
+    parser_serve.add_argument(
+        "--ephemeral",
+        action="store_true",
+        help="Run in isolated temporary environment with random port and debug user",
+    )
+    parser_serve.set_defaults(func=serve_run)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Supernote Server CLI")
+    subparsers = parser.add_subparsers(dest="command")
+    add_parser(subparsers)
+    args = parser.parse_args()
+    if hasattr(args, "func"):
+        args.func(args)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

supernote/client/__init__.py

@@ -0,0 +1,28 @@
+"""Client library for accessing Supernote Cloud services.
+
+Example:
+    async with await Supernote.login("email@example.com", "password", host="http://localhost:8080") as sn:
+        # Access Web and Device APIs directly through the session object
+        # Example: List root folder using path-based Device API
+        result = await sn.device.list_folder("/")
+
+        # sn.token contains the access token for use with `Supernote.from_token`
+        print(sn.token)
+
+    # Use an existing token:
+    sn = Supernote.from_token("your-token", host="http://localhost:8080")
+"""
+
+from .api import Supernote
+from .auth import AbstractAuth, ConstantAuth, FileCacheAuth
+from .client import Client
+from .login_client import LoginClient
+
+__all__ = [
+    "Supernote",
+    "Client",
+    "AbstractAuth",
+    "ConstantAuth",
+    "FileCacheAuth",
+    "LoginClient",
+]

supernote/client/admin.py

@@ -0,0 +1,76 @@
+import logging
+
+from supernote.client.client import Client
+from supernote.models.base import BaseResponse
+from supernote.models.user import (
+    RetrievePasswordDTO,
+    UpdateEmailDTO,
+    UpdatePasswordDTO,
+    UserRegisterDTO,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class AdminClient:
+    """Client for administrative tasks (User Management)."""
+
+    def __init__(self, client: Client) -> None:
+        """Initialize with an existing client instance."""
+        self.client = client
+
+    async def register(
+        self, email: str, password: str, username: str | None = None
+    ) -> None:
+        """Register a new user."""
+        dto = UserRegisterDTO(email=email, password=password, user_name=username)
+        await self.client.post_json(
+            "/api/user/register", BaseResponse, json=dto.to_dict()
+        )
+        logger.info(f"Registered user {email}")
+
+    async def unregister(self) -> None:
+        """Delete currently logged in user."""
+        await self.client.post_json("/api/user/unregister", BaseResponse)
+        logger.info("Unregistered user")
+
+    async def update_password(self, new_password: str) -> None:
+        """Update password for currently logged in user."""
+        dto = UpdatePasswordDTO(password=new_password)
+        await self.client.put_json(
+            "/api/user/password", BaseResponse, json=dto.to_dict()
+        )
+        logger.info("Password updated")
+
+    async def update_email(self, new_email: str) -> None:
+        """Update email for currently logged in user."""
+        dto = UpdateEmailDTO(email=new_email)
+        await self.client.put_json("/api/user/email", BaseResponse, json=dto.to_dict())
+        logger.info("Email updated")
+
+    async def retrieve_password(self, email: str, new_password: str) -> None:
+        """Reset password (public endpoint)."""
+        dto = RetrievePasswordDTO(email=email, password=new_password)
+        await self.client.post_json(
+            "/api/official/user/retrieve/password", BaseResponse, json=dto.to_dict()
+        )
+        logger.info(f"Password reset for {email}")
+
+    async def admin_create_user(
+        self, email: str, password: str, username: str | None = None
+    ) -> None:
+        """Register a new user through the admin API."""
+        dto = UserRegisterDTO(email=email, password=password, user_name=username)
+        await self.client.post_json(
+            "/api/admin/users", BaseResponse, json=dto.to_dict()
+        )
+        logger.info(f"Registered user {email}")
+
+    async def admin_reset_password(self, email: str, password_md5: str) -> None:
+        """Force reset user password through admin API."""
+        await self.client.post_json(
+            "/api/admin/users/password",
+            BaseResponse,
+            json={"email": email, "password": password_md5},
+        )
+        logger.info(f"Password reset for {email}")

supernote/client/api.py

@@ -0,0 +1,135 @@
+"""Supernote session wrapper."""
+
+from typing import Self
+
+import aiohttp
+
+from .auth import AbstractAuth, ConstantAuth
+from .client import Client
+from .device import DeviceClient
+from .login_client import LoginClient
+from .web import WebClient
+
+
+class Supernote:
+    """A session-managed entry point for Supernote clients.
+
+    Example:
+        async with await Supernote.login("email@example.com", "password", host="http://localhost:8080") as sn:
+            # Access Web and Device APIs directly through the session object
+            # Example: List root folder using path-based Device API
+            result = await sn.device.list_folder("/")
+
+            # sn.token contains the access token for use with `Supernote.from_token`
+            print(sn.token)
+
+    Example using an existing token:
+        sn = Supernote.from_token("your-token", host="http://localhost:8080")
+        # Note: When created this way, you are responsible for closing the session
+        # or passing an existing one.
+    """
+
+    def __init__(
+        self,
+        host: str | None = None,
+        session: aiohttp.ClientSession | None = None,
+        auth: AbstractAuth | None = None,
+        close_session: bool | None = None,
+    ):
+        """Initialize the Supernote session wrapper."""
+        if close_session is not None:
+            self._close_session = close_session
+        else:
+            self._close_session = session is None
+        self._session = session or aiohttp.ClientSession()
+        self._client = Client(self._session, host=host, auth=auth)
+        self._web = WebClient(self._client)
+        self._device = DeviceClient(self._client)
+        self._login_client = LoginClient(self._client)
+
+    @classmethod
+    async def login(
+        cls,
+        email: str,
+        password: str,
+        host: str | None = None,
+        session: aiohttp.ClientSession | None = None,
+    ) -> "Supernote":
+        """Log in and return an authenticated Supernote instance."""
+        # Create a temporary unauthenticated instance to perform login
+        sn = cls(session=session, host=host)
+        login_client = LoginClient(sn.client)
+        token = await login_client.login(email, password)
+        # Return a new authenticated instance sharing the same session
+        return sn.with_auth(ConstantAuth(token))
+
+    @classmethod
+    def from_token(
+        cls,
+        token: str,
+        host: str | None = None,
+        session: aiohttp.ClientSession | None = None,
+    ) -> "Supernote":
+        """Return an authenticated Supernote instance using an existing token."""
+        return cls.from_auth(ConstantAuth(token), host=host, session=session)
+
+    @classmethod
+    def from_auth(
+        cls,
+        auth: AbstractAuth,
+        host: str | None = None,
+        session: aiohttp.ClientSession | None = None,
+    ) -> "Supernote":
+        """Return an authenticated Supernote instance using existing credentials."""
+        return cls(host=host, session=session, auth=auth)
+
+    async def __aenter__(self) -> Self:
+        """Enter the async context manager."""
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: object | None,
+    ) -> None:
+        """Exit the async context manager."""
+        if self._close_session:
+            await self._session.close()
+
+    @property
+    def web(self) -> WebClient:
+        """Return the web client."""
+        return self._web
+
+    @property
+    def device(self) -> DeviceClient:
+        """Return the device client."""
+        return self._device
+
+    @property
+    def login_client(self) -> LoginClient:
+        """Return the login client."""
+        return self._login_client
+
+    @property
+    def client(self) -> Client:
+        """Return the lower level base client."""
+        return self._client
+
+    @property
+    def token(self) -> str | None:
+        """Return the current access token if authenticated with ConstantAuth."""
+        auth = self._client.get_auth()
+        if isinstance(auth, ConstantAuth):
+            return auth.token
+        return None
+
+    def with_auth(self, auth: AbstractAuth) -> Self:
+        """Return a new Supernote instance with the given authentication credentials."""
+        return self.__class__(
+            session=self._session,
+            host=self._client.host,
+            auth=auth,
+            close_session=self._close_session,
+        )