supernote 0.13.6__py3-none-any.whl

supernote/server/static/js/main.js

@@ -0,0 +1,241 @@
+import { createApp, ref, onMounted, computed } from 'https://unpkg.com/vue@3/dist/vue.esm-browser.js';
+import { useFileSystem } from './composables/useFileSystem.js';
+import { setToken, getToken, login, logout, fetchProcessingStatus } from './api/client.js';
+import FileCard from './components/FileCard.js';
+import LoginCard from './components/LoginCard.js';
+import FileViewer from './components/FileViewer.js';
+import SystemPanel from './components/SystemPanel.js';
+import MoveModal from './components/MoveModal.js';
+import RenameModal from './components/RenameModal.js';
+
+createApp({
+    components: {
+        FileCard,
+        LoginCard,
+        FileViewer,
+        SystemPanel,
+        MoveModal,
+        RenameModal
+    },
+    setup() {
+        // Auth State
+        const isLoggedIn = ref(false);
+        const loginError = ref(null);
+        const showSystemPanel = ref(false);
+
+        // UI State
+        const showNewFolderModal = ref(false);
+        const newFolderName = ref('');
+        const showMoveModal = ref(false);
+        const showRenameModal = ref(false);
+        const itemToRename = ref(null);
+        const selectedIds = ref([]);
+        const processingStatuses = ref({}); // fileId -> status string
+
+        // File System
+        const {
+            files,
+            currentDirectoryId,
+            isLoading,
+            error,
+            loadDirectory,
+            createNewFolder,
+            deleteSelectedItems,
+            moveSelectedItems,
+            uploadFiles,
+            renameSelectedItem
+        } = useFileSystem();
+
+        const view = ref('grid');
+        const selectedFile = ref(null);
+        const breadcrumbs = ref([{ id: "0", name: "Cloud" }]);
+
+        const folders = computed(() => files.value.filter(f => f.isDirectory));
+        const regularFiles = computed(() => files.value.filter(f => !f.isDirectory));
+
+        // Methods
+        async function openItem(item) {
+            if (item.isDirectory) {
+                currentDirectoryId.value = item.id;
+                breadcrumbs.value.push({ id: item.id, name: item.name });
+                selectedIds.value = [];
+                await loadDirectory(item.id);
+            } else {
+                selectedFile.value = item;
+                view.value = 'viewer';
+            }
+        }
+
+        async function navigateTo(index) {
+            const crumbs = breadcrumbs.value.slice(0, index + 1);
+            breadcrumbs.value = crumbs;
+            const target = crumbs[crumbs.length - 1];
+            view.value = 'grid';
+            selectedIds.value = [];
+            await loadDirectory(target.id);
+        }
+
+        // Selection
+        function toggleSelection(id) {
+            const index = selectedIds.value.indexOf(id);
+            if (index > -1) {
+                selectedIds.value.splice(index, 1);
+            } else {
+                selectedIds.value.push(id);
+            }
+        }
+
+        // Actions
+        async function handleCreateFolder() {
+            if (!newFolderName.value) return;
+            try {
+                await createNewFolder(newFolderName.value);
+                showNewFolderModal.value = false;
+                newFolderName.value = '';
+            } catch (e) {
+                alert("Failed to create folder: " + e.message);
+            }
+        }
+
+        const fileInput = ref(null);
+        function triggerUpload() {
+            fileInput.value.click();
+        }
+
+        async function handleFileUpload(event) {
+            const selectedFiles = event.target.files;
+            if (selectedFiles.length === 0) return;
+            try {
+                await uploadFiles(selectedFiles);
+            } catch (e) {
+                alert("Upload failed: " + e.message);
+            } finally {
+                event.target.value = ''; // Reset input
+            }
+        }
+
+        async function handleDeleteSelected() {
+            if (!confirm(`Are you sure you want to delete ${selectedIds.value.length} items?`)) return;
+            try {
+                await deleteSelectedItems(selectedIds.value);
+                selectedIds.value = [];
+            } catch (e) {
+                alert("Delete failed: " + e.message);
+            }
+        }
+
+        function handleMoveSelected() {
+            showMoveModal.value = true;
+        }
+
+        async function onConfirmMove(targetDirId) {
+            try {
+                await moveSelectedItems(selectedIds.value, targetDirId);
+                selectedIds.value = [];
+                showMoveModal.value = false;
+            } catch (e) {
+                alert("Move failed: " + e.message);
+            }
+        }
+
+        function triggerRename(item) {
+            itemToRename.value = item;
+            showRenameModal.value = true;
+        }
+
+        async function onConfirmRename(newName) {
+            try {
+                await renameSelectedItem(itemToRename.value.id, newName);
+                showRenameModal.value = false;
+                itemToRename.value = null;
+            } catch (e) {
+                alert("Rename failed: " + e.message);
+            }
+        }
+
+        async function handleLogin({ email, password }) {
+            loginError.value = null;
+            try {
+                await login(email, password);
+                isLoggedIn.value = true;
+                await loadDirectory();
+            } catch (e) {
+                loginError.value = e.message;
+                alert(e.message);
+            }
+        }
+
+        function handleLogout() {
+            logout();
+        }
+
+        onMounted(() => {
+            if (getToken()) {
+                isLoggedIn.value = true;
+                loadDirectory();
+            }
+
+            // Polling for processing status
+            setInterval(async () => {
+                if (!isLoggedIn.value || isLoading.value || files.value.length === 0) return;
+
+                const noteFileIds = files.value
+                    .filter(f => f.extension === 'note')
+                    .map(f => parseInt(f.id));
+
+                if (noteFileIds.length === 0) return;
+
+                try {
+                    const result = await fetchProcessingStatus(noteFileIds);
+                    if (result.success) {
+                        processingStatuses.value = {
+                            ...processingStatuses.value,
+                            ...result.statusMap
+                        };
+                    }
+                } catch (e) {
+                    console.error("Failed to poll status:", e);
+                }
+            }, 3000); // Every 3 seconds
+        });
+
+        return {
+            isLoggedIn,
+            handleLogin,
+            handleLogout,
+            view,
+            files,
+            folders,
+            regularFiles,
+            currentDirectoryId,
+            isLoading,
+            error,
+            breadcrumbs,
+            openItem,
+            navigateTo,
+            selectedFile,
+            showSystemPanel,
+
+            // New States
+            showNewFolderModal,
+            newFolderName,
+            showMoveModal,
+            showRenameModal,
+            itemToRename,
+            selectedIds,
+            fileInput,
+
+            // New Methods
+            toggleSelection,
+            handleCreateFolder,
+            triggerUpload,
+            handleFileUpload,
+            handleDeleteSelected,
+            handleMoveSelected,
+            onConfirmMove,
+            triggerRename,
+            onConfirmRename,
+            processingStatuses
+        };
+    }
+}).mount('#app');

supernote/server/static/style.css

@@ -0,0 +1,14 @@
+[v-cloak] { display: none; }
+
+body {
+    font-family: 'Inter', sans-serif;
+}
+
+.animate-pulse-slow {
+    animation: pulse 4s cubic-bezier(0.4, 0, 0.6, 1) infinite;
+}
+
+@keyframes pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: .7; }
+}

supernote/server/utils/hashing.py

@@ -0,0 +1,18 @@
+"""Module for hashing utilities."""
+
+import hashlib
+
+
+def sha256_string(s: str) -> str:
+    """Return SHA256 hex digest of a string."""
+    return hashlib.sha256(s.encode("utf-8")).hexdigest()
+
+
+def hash_with_salt(content: str, salt: str) -> str:
+    """Hash content with salt using SHA256."""
+    return sha256_string(f"{content}{salt}")
+
+
+def get_md5_hash(s: str) -> str:
+    """Return MD5 hex digest of a string."""
+    return hashlib.md5(s.encode("utf-8")).hexdigest()

supernote/server/utils/note_content.py

@@ -0,0 +1,76 @@
+import re
+from datetime import datetime
+from typing import Optional
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from supernote.server.db.models.note_processing import NotePageContentDO
+
+
+async def get_page_content_by_id(
+    session: AsyncSession, file_id: int, page_id: str
+) -> Optional[NotePageContentDO]:
+    """Retrieve NotePageContentDO by file_id and page_id using an existing session."""
+    return (
+        (
+            await session.execute(
+                select(NotePageContentDO)
+                .where(NotePageContentDO.file_id == file_id)
+                .where(NotePageContentDO.page_id == page_id)
+            )
+        )
+        .scalars()
+        .first()
+    )
+
+
+def infer_page_date(page_id: str) -> datetime | None:
+    """Infers a date from a Supernote PAGEID string.
+
+    PAGEID usually looks like: P20231027123456... (P followed by YYYYMMDDHHMMSS)
+    """
+    if not page_id or not page_id.startswith("P"):
+        return None
+
+    # Try to extract YYYYYMMDD
+    match = re.match(r"P(\d{8})", page_id)
+    if not match:
+        return None
+
+    date_str = match.group(1)
+    try:
+        return datetime.strptime(date_str, "%Y%m%d")
+    except ValueError:
+        return None
+
+
+def format_page_metadata(
+    page_index: int,
+    page_id: str,
+    file_name: Optional[str] = None,
+    notebook_create_time: Optional[int] = None,
+    include_section_divider: bool = False,
+) -> str:
+    """Formats a consistent metadata block for a notebook page.
+
+    Used in OCR prompts, transcripts, and summaries.
+    """
+    lines = [f"--- Page {page_index + 1} ---"]
+    if file_name:
+        lines.append(f"Notebook Filename: {file_name}")
+
+    if notebook_create_time:
+        nb_dt = datetime.fromtimestamp(notebook_create_time / 1000)
+        lines.append(f"Notebook Created: {nb_dt.strftime('%Y-%m-%d %H:%M:%S')}")
+
+    lines.append(f"Page ID: {page_id}")
+
+    inferred_date = infer_page_date(page_id)
+    if inferred_date:
+        lines.append(f"Page Date (Inferred): {inferred_date.strftime('%Y-%m-%d')}")
+
+    if include_section_divider:
+        lines.append("---")
+
+    return "\n".join(lines)

supernote/server/utils/paths.py

@@ -0,0 +1,58 @@
+"""Module for generating storage paths for various file types.
+
+This contains storage keys and database paths.
+"""
+
+
+def get_page_png_path(file_id: int, page_id: str) -> str:
+    """Get the blob storage path for a page PNG."""
+    return f"{file_id}/pages/{page_id}.png"
+
+
+def get_file_chunk_path(object_name: str, part_number: int) -> str:
+    """Generate a storage path for a file chunk."""
+    return f"{object_name}.part.{part_number}"
+
+
+def get_summary_id(file_basis: str) -> str:
+    """Generate a unique identifier for an AI summary."""
+    return f"{file_basis}-summary"
+
+
+def get_transcript_id(file_basis: str) -> str:
+    """Generate a unique identifier for an OCR transcript."""
+    return f"{file_basis}-transcript"
+
+
+def get_conversion_png_path(
+    user_id: int, file_id: int, page_index: int, file_md5: str
+) -> str:
+    """Generate a storage path for a converted PNG page."""
+    return f"conversions/{user_id}/{file_id}/page_{page_index}_{file_md5}.png"
+
+
+def get_conversion_pdf_path(user_id: int, file_id: int, file_md5: str) -> str:
+    """Generate a storage path for a converted PDF note."""
+    return f"conversions/{user_id}/{file_id}/note_{file_md5}.pdf"
+
+
+def generate_inner_name(filename: str, equipment_no: str | None) -> str:
+    """Generate a system-of-record inner name.
+
+    Format: {UUID}-{Tail}.{Ext}
+    - UUID: Random UUID
+    - Tail: Last 3 chars of equipment number (or full if short, default '000')
+    - Ext: Original file extension
+    """
+    import os
+    import uuid
+
+    req_uuid = uuid.uuid4()
+    ext = os.path.splitext(filename)[1]
+
+    # Determine tail
+    tail = "000"
+    if equipment_no:
+        tail = equipment_no[-3:] if len(equipment_no) >= 3 else equipment_no
+
+    return f"{req_uuid}-{tail}{ext}"

supernote/server/utils/rate_limit.py

@@ -0,0 +1,52 @@
+import time
+
+from supernote.server.exceptions import RateLimitExceeded
+from supernote.server.services.coordination import CoordinationService
+
+# Constants for Rate Limiting
+LIMIT_LOGIN_IP_MAX = 20
+LIMIT_LOGIN_IP_WINDOW = 60  # 1 minute
+LOGIN_KEY_IP = "login:ip"
+
+LIMIT_LOGIN_ACCOUNT_MAX = 10
+LIMIT_LOGIN_ACCOUNT_WINDOW = 60  # 1 minute
+LOGIN_KEY_ACCOUNT = "login:account"
+
+LIMIT_PW_RESET_MAX = 5
+LIMIT_PW_RESET_WINDOW = 3600  # 1 hour
+RESET_KEY_ACCOUNT = "reset:account"
+RESET_KEY_IP = "reset:ip"
+
+
+class RateLimiter:
+    """Simple distributed rate limiter using Fixed Window Counter algorithm."""
+
+    def __init__(self, coordination_service: CoordinationService):
+        self._coordination_service = coordination_service
+
+    async def check(self, key: str, limit: int, window: int) -> None:
+        """Check if the action is allowed.
+
+        Args:
+            key: Unique identifier for the action (e.g. "login:ip:127.0.0.1")
+            limit: Max allowed attempts per window
+            window: Time window in seconds
+
+        Raises:
+            RateLimitExceeded: If the limit is exceeded.
+        """
+        # Fixed Window: bucket is defined by floor(time / window)
+        now = int(time.time())
+        bucket = now // window
+
+        # Key includes the bucket so it auto-resets when window changes
+        # e.g. "rate_limit:login:ip:127.0.0.1:167890"
+        rate_key = f"rate_limit:{key}:{bucket}"
+
+        # Increment
+        # We set TTL to window * 2 to ensure we don't clutter DB, but enough to cover the window width.
+        # Actually window size is enough + buffer.
+        count = await self._coordination_service.increment(rate_key, 1, ttl=window + 60)
+
+        if count > limit:
+            raise RateLimitExceeded("Rate limit exceeded. Try again later.")

supernote/server/utils/tasks.py

@@ -0,0 +1,71 @@
+import time
+from typing import Optional
+
+from sqlalchemy import select, text
+
+from supernote.models.base import ProcessingStatus
+from supernote.server.db.models.note_processing import SystemTaskDO
+from supernote.server.db.session import DatabaseSessionManager
+from supernote.server.utils.unique_id import next_id
+
+
+async def get_task(
+    session_manager: DatabaseSessionManager,
+    file_id: int,
+    task_type: str,
+    key: str,
+) -> Optional[SystemTaskDO]:
+    """Retrieve a SystemTaskDO by file_id, task_type, and key."""
+    async with session_manager.session() as session:
+        return (
+            (
+                await session.execute(
+                    select(SystemTaskDO)
+                    .where(SystemTaskDO.file_id == file_id)
+                    .where(SystemTaskDO.task_type == task_type)
+                    .where(SystemTaskDO.key == key)
+                )
+            )
+            .scalars()
+            .first()
+        )
+
+
+async def update_task_status(
+    session_manager: DatabaseSessionManager,
+    file_id: int,
+    task_type: str,
+    key: str,
+    status: ProcessingStatus,
+    error: Optional[str] = None,
+) -> None:
+    """Create or update a SystemTaskDO status atomically."""
+    async with session_manager.session() as session:
+        now = int(time.time() * 1000)
+        # Using native SQL UPSERT because SQLite's ON CONFLICT
+        # is very robust for our needs and avoids SELECT-then-UPDATE races.
+        # We must provide 'id' and 'retry_count' manually for the INSERT part.
+        sql = text(
+            """
+            INSERT INTO f_system_task (id, file_id, task_type, key, status, last_error, retry_count, create_time, update_time)
+            VALUES (:id, :file_id, :task_type, :key, :status, :error, 0, :now, :now)
+            ON CONFLICT(file_id, task_type, key) DO UPDATE SET
+                status = excluded.status,
+                last_error = excluded.last_error,
+                update_time = excluded.update_time
+        """
+        )
+
+        await session.execute(
+            sql,
+            {
+                "id": next_id(),
+                "file_id": file_id,
+                "task_type": task_type,
+                "key": key,
+                "status": status,
+                "error": error,
+                "now": now,
+            },
+        )
+        await session.commit()

supernote/server/utils/unique_id.py

@@ -0,0 +1,48 @@
+"""Module for generating unique ids."""
+
+import random
+import threading
+import time
+
+# Global lock for thread safety
+_lock = threading.Lock()
+_last_timestamp = -1
+_sequence = 0
+
+
+def next_id() -> int:
+    """Generate a unique, time-ordered 64-bit integer ID.
+
+    Format: [Timestamp (41 bits)] [Random/Sequence (22 bits)]
+
+    This is a simplified version for a single-node server.
+    """
+    global _last_timestamp, _sequence
+
+    with _lock:
+        timestamp = int(time.time() * 1000)
+
+        if timestamp < _last_timestamp:
+            # Clock moved backwards, just wait a bit or raise
+            raise Exception("Clock moved backwards")
+
+        if timestamp == _last_timestamp:
+            _sequence = (_sequence + 1) & 0x3FFFFF  # 22 bits
+            if _sequence == 0:
+                # Overflow in same ms, wait for next ms
+                while timestamp <= _last_timestamp:
+                    timestamp = int(time.time() * 1000)
+        else:
+            _sequence = random.randint(
+                0, 1023
+            )  # Start with random offset to minimize collisions on restart
+            _last_timestamp = timestamp
+
+        # 2021-01-01 Epoch
+        epoch_offset = 1609459200000
+
+        # Shift to make room for 22 bits of randomness/sequence
+        # 41 bits (time) + 22 bits (seq) = 63 bits (Fits in Signed BigInt)
+        id_val = ((timestamp - epoch_offset) << 22) | _sequence
+
+        return id_val