lfss 0.8.0__py3-none-any.whl → 0.8.1__py3-none-any.whl

frontend/api.js

@@ -73,7 +73,8 @@ export default class Connector {
             method: 'PUT',
             headers: {
                 'Authorization': 'Bearer ' + this.config.token, 
-                'Content-Type': 'application/octet-stream'
+                'Content-Type': 'application/octet-stream', 
+                'Content-Length': fileBytes.byteLength
             },
             body: fileBytes
         });
@@ -83,6 +84,38 @@ export default class Connector {
         return (await res.json()).url;
     }
 
+    /**
+    * @param {string} path - the path to the file (url)
+    * @param {File} file - the file to upload
+    * @returns {Promise<string>} - the promise of the request, the url of the file
+    */
+    async post(path, file, {
+        conflict = 'abort',
+        permission = 0
+    } = {}){
+        if (path.startsWith('/')){ path = path.slice(1); }
+        const dst = new URL(this.config.endpoint + '/' + path);
+        dst.searchParams.append('conflict', conflict);
+        dst.searchParams.append('permission', permission);
+        // post as multipart form data
+        const formData = new FormData();
+        formData.append('file', file);
+        const res = await fetch(dst.toString(), {
+            method: 'POST',
+            // don't include the content type, let the browser handle it
+            // https://muffinman.io/blog/uploading-files-using-fetch-multipart-form-data/
+            headers: {
+                'Authorization': 'Bearer ' + this.config.token, 
+            },
+            body: formData
+        });
+                
+        if (res.status != 200 && res.status != 201){
+            throw new Error(`Failed to upload file, status code: ${res.status}, message: ${await res.json()}`);
+        }
+        return (await res.json()).url;
+    }
+
     /**
     * @param {string} path - the path to the file (url), should end with .json
     * @param {Objec} data - the data to upload
@@ -422,4 +455,28 @@ export async function listPath(conn, path, {
         dirs: dirCount,
         files: fileCount
     }];
-};
+};
+
+/**
+ * a function to wrap the upload function into one
+ * it will return the url of the file
+ * 
+ * @typedef {Object} UploadOptions
+ * @property {string} conflict - the conflict resolution strategy, can be 'abort', 'replace', 'rename'
+ * @property {number} permission - the permission of the file, can be 0, 1, 2, 3
+ * 
+ * @param {Connector} conn - the connector to the API
+ * @param {string} path - the path to the file (url)
+ * @param {File} file - the file to upload
+ * @param {UploadOptions} options - the options for the request
+ * @returns {Promise<string>} - the promise of the request, the url of the file
+ */
+export async function uploadFile(conn, path, file, {
+    conflict = 'abort',
+    permission = 0
+} = {}){
+    if (file.size < 1024 * 1024 * 10){
+        return await conn.put(path, file, {conflict, permission});
+    }
+    return await conn.post(path, file, {conflict, permission});
+}

frontend/scripts.js

@@ -1,4 +1,4 @@
-import { permMap, listPath } from './api.js';
+import { permMap, listPath, uploadFile } from './api.js';
 import { showFloatingWindowLineInput, showPopup } from './popup.js';
 import { formatSize, decodePathURI, ensurePathURI, getRandomString, cvtGMT2Local, debounce, encodePathURI, asHtmlText } from './utils.js';
 import { showInfoPanel, showDirInfoPanel } from './info.js';
@@ -132,7 +132,7 @@ uploadButton.addEventListener('click', () => {
     }
     path = path + fileName;
     showPopup('Uploading...', {level: 'info', timeout: 3000});
-    conn.put(path, file, {'conflict': 'overwrite'})
+    uploadFile(conn, path, file, {'conflict': 'overwrite'})
         .then(() => {
             refreshFileList();
             uploadFileNameInput.value = '';
@@ -178,10 +178,10 @@ Are you sure you want to proceed?
                 `)){ return; }
             
             let counter = 0;
-            async function uploadFile(...args){
+            async function uploadFileFn(...args){
                 const [file, path] = args;
                 try{
-                    await conn.put(path, file, {conflict: 'overwrite'});
+                    await uploadFile(conn, path, file, {conflict: 'overwrite'});
                 }
                 catch (err){
                     showPopup('Failed to upload file [' + file.name + ']: ' + err, {level: 'error', timeout: 5000});
@@ -194,7 +194,7 @@ Are you sure you want to proceed?
             for (let i = 0; i < files.length; i++){
                 const file = files[i];
                 const path = dstPath + file.name;
-                promises.push(uploadFile(file, path));
+                promises.push(uploadFileFn(file, path));
             }
             showPopup('Uploading multiple files...', {level: 'info', timeout: 3000});
             Promise.all(promises).then(

lfss/api/__init__.py

@@ -18,9 +18,13 @@ def upload_file(
     error_msg = ""
     while this_try <= n_retries:
         try:
-            with open(file_path, 'rb') as f:
-                blob = f.read()
-            connector.put(dst_url, blob, **put_kwargs)
+            fsize = os.path.getsize(file_path)
+            if fsize < 32 * 1024 * 1024:     # 32MB
+                with open(file_path, 'rb') as f:
+                    blob = f.read()
+                connector.put(dst_url, blob, **put_kwargs)
+            else:
+                connector.post(dst_url, file_path, **put_kwargs)
             break
         except Exception as e:
             if isinstance(e, KeyboardInterrupt):
@@ -97,14 +101,24 @@ def download_file(
                 print(f"File {file_path} already exists, skipping download.")
             return True, error_msg
         try:
-            blob = connector.get(src_url)
-            if blob is None:
+            fmeta = connector.get_metadata(src_url)
+            if fmeta is None:
                 error_msg = "File not found."
                 return False, error_msg
+
             pathlib.Path(file_path).parent.mkdir(parents=True, exist_ok=True)
-            with open(file_path, 'wb') as f:
-                f.write(blob)
+            fsize = fmeta.file_size   # type: ignore
+            if fsize < 32 * 1024 * 1024:     # 32MB
+                blob = connector.get(src_url)
+                assert blob is not None
+                with open(file_path, 'wb') as f:
+                    f.write(blob)
+            else:
+                with open(file_path, 'wb') as f:
+                    for chunk in connector.get_stream(src_url):
+                        f.write(chunk)
             break
+
         except Exception as e:
             if isinstance(e, KeyboardInterrupt):
                 raise e

lfss/api/connector.py

@@ -4,6 +4,7 @@ import os
 import requests
 import requests.adapters
 import urllib.parse
+from tempfile import SpooledTemporaryFile
 from lfss.src.error import PathNotFoundError
 from lfss.src.datatype import (
     FileReadPermission, FileRecord, DirectoryRecord, UserRecord, PathContents, 
@@ -95,6 +96,42 @@ class Connector:
         )
         return response.json()
     
+    def post(self, path, file: str | bytes, permission: int | FileReadPermission = 0, conflict: Literal['overwrite', 'abort', 'skip', 'skip-ahead'] = 'abort'):
+        """
+        Uploads a file to the specified path, 
+        using the POST method, with form-data/multipart.
+        file can be a path to a file on disk, or bytes.
+        """
+
+        # Skip ahead by checking if the file already exists
+        if conflict == 'skip-ahead':
+            exists = self.get_metadata(path)
+            if exists is None:
+                conflict = 'skip'
+            else:
+                return {'status': 'skipped', 'path': path}
+        
+        if isinstance(file, str):
+            assert os.path.exists(file), "File does not exist on disk"
+            fsize = os.path.getsize(file)
+
+        with open(file, 'rb') if isinstance(file, str) else SpooledTemporaryFile(max_size=1024*1024*32) as fp:
+
+            if isinstance(file, bytes):
+                fsize = len(file)
+                fp.write(file)
+                fp.seek(0)
+
+            # https://stackoverflow.com/questions/12385179/
+            print(f"Uploading {fsize} bytes")
+            response = self._fetch_factory('POST', path, search_params={
+                'permission': int(permission),
+                'conflict': conflict
+                })(
+                files={'file': fp},
+            )
+        return response.json()
+    
     def put_json(self, path: str, data: dict, permission: int | FileReadPermission = 0, conflict: Literal['overwrite', 'abort', 'skip', 'skip-ahead'] = 'abort'):
         """Uploads a JSON file to the specified path."""
         assert path.endswith('.json'), "Path must end with .json"

lfss/src/config.py

@@ -18,7 +18,7 @@ if __env_large_file is not None:
     LARGE_FILE_BYTES = parse_storage_size(__env_large_file)
 else:
     LARGE_FILE_BYTES = 8 * 1024 * 1024  # 8MB
-MAX_FILE_BYTES = 512 * 1024 * 1024   # 512MB
+MAX_MEM_FILE_BYTES = 128 * 1024 * 1024   # 128MB
 MAX_BUNDLE_BYTES = 512 * 1024 * 1024   # 512MB
 CHUNK_SIZE = 1024 * 1024   # 1MB chunks for streaming (on large files)
 

lfss/src/database.py

@@ -8,13 +8,14 @@ import zipfile, io, asyncio
 
 import aiosqlite, aiofiles
 import aiofiles.os
+import mimetypes, mimesniff
 
 from .connection_pool import execute_sql, unique_cursor, transaction
 from .datatype import (
     UserRecord, FileReadPermission, FileRecord, DirectoryRecord, PathContents, 
     FileSortKey, DirSortKey, isValidFileSortKey, isValidDirSortKey
     )
-from .config import LARGE_BLOB_DIR, CHUNK_SIZE
+from .config import LARGE_BLOB_DIR, CHUNK_SIZE, LARGE_FILE_BYTES, MAX_MEM_FILE_BYTES
 from .log import get_logger
 from .utils import decode_uri_compnents, hash_credential, concurrent_wrap, debounce_async
 from .error import *
@@ -285,8 +286,7 @@ class FileConn(DBObjectBase):
     async def user_size(self, user_id: int) -> int:
         cursor = await self.cur.execute("SELECT size FROM usize WHERE user_id = ?", (user_id, ))
         res = await cursor.fetchone()
-        if res is None:
-            return -1
+        if res is None: return 0
         return res[0]
     async def _user_size_inc(self, user_id: int, inc: int):
         self.logger.debug(f"Increasing user {user_id} size by {inc}")
@@ -534,59 +534,66 @@ class Database:
     
     async def save_file(
         self, u: int | str, url: str, 
-        blob: bytes | AsyncIterable[bytes], 
+        blob_stream: AsyncIterable[bytes], 
         permission: FileReadPermission = FileReadPermission.UNSET, 
-        mime_type: str = 'application/octet-stream'
-        ):
+        mime_type: Optional[str] = None
+        ) -> int:
         """
-        if file_size is not provided, the blob must be bytes
+        Save a file to the database. 
+        Will check file size and user storage limit, 
+        should check permission before calling this method. 
         """
         validate_url(url)
         async with unique_cursor() as cur:
             user = await get_user(cur, u)
-            if user is None:
-                return
-            
-            # check if the user is the owner of the path, or is admin
-            if url.startswith('/'):
-                url = url[1:]
-            first_component = url.split('/')[0]
-            if first_component != user.username:
-                if not user.is_admin:
-                    raise PermissionDeniedError(f"Permission denied: {user.username} cannot write to {url}")
-                else:
-                    if await get_user(cur, first_component) is None:
-                        raise PermissionDeniedError(f"Invalid path: {first_component} is not a valid username")
+            assert user is not None, f"User {u} not found"
             
             fconn_r = FileConn(cur)
             user_size_used = await fconn_r.user_size(user.id)
 
-            if isinstance(blob, bytes):
-                file_size = len(blob)
-                if user_size_used + file_size > user.max_storage:
-                    raise StorageExceededError(f"Unable to save file, user {user.username} has storage limit of {user.max_storage}, used {user_size_used}, requested {file_size}")
-                f_id = uuid.uuid4().hex
-
-                async with transaction() as w_cur:
-                    fconn_w = FileConn(w_cur)
-                    await fconn_w.set_file_blob(f_id, blob)
-                    await fconn_w.set_file_record(
-                        url, owner_id=user.id, file_id=f_id, file_size=file_size, 
-                        permission=permission, external=False, mime_type=mime_type)
-            else:
-                assert isinstance(blob, AsyncIterable)
-                f_id = uuid.uuid4().hex
-                file_size = await FileConn.set_file_blob_external(f_id, blob)
+            f_id = uuid.uuid4().hex
+            async with aiofiles.tempfile.SpooledTemporaryFile(max_size=MAX_MEM_FILE_BYTES) as f:
+                async for chunk in blob_stream:
+                    await f.write(chunk)
+                file_size = await f.tell()
                 if user_size_used + file_size > user.max_storage:
-                    await FileConn.delete_file_blob_external(f_id)
                     raise StorageExceededError(f"Unable to save file, user {user.username} has storage limit of {user.max_storage}, used {user_size_used}, requested {file_size}")
                 
-                async with transaction() as w_cur:
-                    await FileConn(w_cur).set_file_record(
-                        url, owner_id=user.id, file_id=f_id, file_size=file_size, 
-                        permission=permission, external=True, mime_type=mime_type)
-            
+                # check mime type
+                if mime_type is None:
+                    fname = url.split('/')[-1]
+                    mime_type, _ = mimetypes.guess_type(fname)
+                if mime_type is None:
+                    await f.seek(0)
+                    mime_type = mimesniff.what(await f.read(1024))
+                if mime_type is None:
+                    mime_type = 'application/octet-stream'
+                await f.seek(0)
+                
+                if file_size < LARGE_FILE_BYTES:
+                    blob = await f.read()
+                    async with transaction() as w_cur:
+                        fconn_w = FileConn(w_cur)
+                        await fconn_w.set_file_blob(f_id, blob)
+                        await fconn_w.set_file_record(
+                            url, owner_id=user.id, file_id=f_id, file_size=file_size, 
+                            permission=permission, external=False, mime_type=mime_type)
+                
+                else:
+                    async def blob_stream_tempfile():
+                        nonlocal f
+                        while True:
+                            chunk = await f.read(CHUNK_SIZE)
+                            if not chunk: break
+                            yield chunk
+                    await FileConn.set_file_blob_external(f_id, blob_stream_tempfile())
+                    async with transaction() as w_cur:
+                        await FileConn(w_cur).set_file_record(
+                            url, owner_id=user.id, file_id=f_id, file_size=file_size, 
+                            permission=permission, external=True, mime_type=mime_type)
+
         await delayed_log_activity(user.username)
+        return file_size
 
     async def read_file_stream(self, url: str) -> AsyncIterable[bytes]:
         validate_url(url)

lfss/src/server.py

@@ -1,7 +1,7 @@
 from typing import Optional, Literal
 from functools import wraps
 
-from fastapi import FastAPI, APIRouter, Depends, Request, Response
+from fastapi import FastAPI, APIRouter, Depends, Request, Response, UploadFile
 from fastapi.responses import StreamingResponse
 from fastapi.exceptions import HTTPException 
 from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
@@ -9,16 +9,15 @@ from fastapi.middleware.cors import CORSMiddleware
 import mimesniff
 
 import asyncio, json, time
-import mimetypes
 from contextlib import asynccontextmanager
 
 from .error import *
 from .log import get_logger
 from .stat import RequestDB
-from .config import MAX_BUNDLE_BYTES, MAX_FILE_BYTES, LARGE_FILE_BYTES, CHUNK_SIZE
+from .config import MAX_BUNDLE_BYTES, MAX_MEM_FILE_BYTES, LARGE_FILE_BYTES, CHUNK_SIZE
 from .utils import ensure_uri_compnents, format_last_modified, now_stamp, wait_for_debounce_tasks
 from .connection_pool import global_connection_init, global_connection_close, unique_cursor
-from .database import Database, DECOY_USER, check_user_permission, UserConn, FileConn, delayed_log_activity
+from .database import Database, DECOY_USER, check_user_permission, UserConn, FileConn, delayed_log_activity, get_user
 from .datatype import (
     FileReadPermission, FileRecord, UserRecord, PathContents, 
     FileSortKey, DirSortKey
@@ -246,18 +245,21 @@ async def put_file(
     path: str, 
     conflict: Literal["overwrite", "skip", "abort"] = "abort",
     permission: int = 0,
-    user: UserRecord = Depends(registered_user)):
+    user: UserRecord = Depends(registered_user)
+    ):
     path = ensure_uri_compnents(path)
-    if not path.startswith(f"{user.username}/") and not user.is_admin:
-        logger.debug(f"Reject put request from {user.username} to {path}")
-        raise HTTPException(status_code=403, detail="Permission denied")
-    
-    content_length = request.headers.get("Content-Length")
-    if content_length is not None:
-        content_length = int(content_length)
-        if content_length > MAX_FILE_BYTES:
-            logger.debug(f"Reject put request from {user.username} to {path}, file too large")
-            raise HTTPException(status_code=413, detail="File too large")
+    assert not path.endswith("/"), "Path must not end with /"
+    if not path.startswith(f"{user.username}/"):
+        if not user.is_admin:
+            logger.debug(f"Reject put request from {user.username} to {path}")
+            raise HTTPException(status_code=403, detail="Permission denied")
+        else:
+            first_comp = path.split("/")[0]
+            async with unique_cursor() as c:
+                uconn = UserConn(c)
+                owner = await uconn.get_user(first_comp)
+                if not owner:
+                    raise HTTPException(status_code=404, detail="Owner not found")
     
     logger.info(f"PUT {path}, user: {user.username}")
     exists_flag = False
@@ -280,47 +282,73 @@ async def put_file(
     # check content-type
     content_type = request.headers.get("Content-Type")
     logger.debug(f"Content-Type: {content_type}")
-    if content_type == "application/json":
-        body = await request.json()
-        blobs = json.dumps(body).encode('utf-8')
-    elif content_type == "application/x-www-form-urlencoded":
-        # may not work...
-        body = await request.form()
-        file = body.get("file")
-        if isinstance(file, str) or file is None:
-            raise HTTPException(status_code=400, detail="Invalid form data, file required")
-        blobs = await file.read()
-    elif content_type == "application/octet-stream":
-        blobs = await request.body()
-    else:
-        blobs = await request.body()
+    if not (content_type == "application/octet-stream" or content_type == "application/json"):
+        raise HTTPException(status_code=415, detail="Unsupported content type, put request must be application/json or application/octet-stream")
     
-    # check file type
-    assert not path.endswith("/"), "Path must be a file"
-    fname = path.split("/")[-1]
-    mime_t, _ = mimetypes.guess_type(fname)
-    if mime_t is None:
-        mime_t = mimesniff.what(blobs)
-    if mime_t is None:
-        mime_t = "application/octet-stream"
-
-    if len(blobs) > LARGE_FILE_BYTES:
-        async def blob_reader():
-            for b in range(0, len(blobs), CHUNK_SIZE):
-                yield blobs[b:b+CHUNK_SIZE]
-        await db.save_file(user.id, path, blob_reader(), permission = FileReadPermission(permission), mime_type = mime_t)
-    else:
-        await db.save_file(user.id, path, blobs, permission = FileReadPermission(permission), mime_type=mime_t)
+    async def blob_reader():
+        nonlocal request
+        async for chunk in request.stream():
+            yield chunk
+
+    await db.save_file(user.id, path, blob_reader(), permission = FileReadPermission(permission))
 
     # https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Methods/PUT
-    if exists_flag:
-        return Response(status_code=201, headers={
-            "Content-Type": "application/json",
-        }, content=json.dumps({"url": path}))
-    else:
-        return Response(status_code=200, headers={
-            "Content-Type": "application/json",
-        }, content=json.dumps({"url": path}))
+    return Response(status_code=200 if exists_flag else 201, headers={
+        "Content-Type": "application/json",
+    }, content=json.dumps({"url": path}))
+
+# using form-data instead of raw body
+@router_fs.post("/{path:path}")
+@handle_exception
+async def post_file(
+    path: str, 
+    file: UploadFile,
+    conflict: Literal["overwrite", "skip", "abort"] = "abort",
+    permission: int = 0,
+    user: UserRecord = Depends(registered_user)
+    ):
+    path = ensure_uri_compnents(path)
+    assert not path.endswith("/"), "Path must not end with /"
+    if not path.startswith(f"{user.username}/"):
+        if not user.is_admin:
+            logger.debug(f"Reject put request from {user.username} to {path}")
+            raise HTTPException(status_code=403, detail="Permission denied")
+        else:
+            first_comp = path.split("/")[0]
+            async with unique_cursor() as conn:
+                uconn = UserConn(conn)
+                owner = await uconn.get_user(first_comp)
+                if not owner:
+                    raise HTTPException(status_code=404, detail="Owner not found")
+
+    logger.info(f"POST {path}, user: {user.username}")
+    exists_flag = False
+    async with unique_cursor() as conn:
+        fconn = FileConn(conn)
+        file_record = await fconn.get_file_record(path)
+
+    if file_record:
+        if conflict == "abort":
+            raise HTTPException(status_code=409, detail="File exists")
+        if conflict == "skip":
+            return Response(status_code=200, headers={
+                "Content-Type": "application/json",
+            }, content=json.dumps({"url": path}))
+        exists_flag = True
+        if not user.is_admin and not file_record.owner_id == user.id:
+            raise HTTPException(status_code=403, detail="Permission denied, cannot overwrite other's file")
+        await db.delete_file(path)
+    
+    async def blob_reader():
+        nonlocal file
+        while (chunk := await file.read(CHUNK_SIZE)):
+            yield chunk
+
+    await db.save_file(user.id, path, blob_reader(), permission = FileReadPermission(permission))
+    return Response(status_code=200 if exists_flag else 201, headers={
+        "Content-Type": "application/json",
+    }, content=json.dumps({"url": path}))
+    
 
 @router_fs.delete("/{path:path}")
 @handle_exception

{lfss-0.8.0.dist-info → lfss-0.8.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lfss
-Version: 0.8.0
+Version: 0.8.1
 Summary: Lightweight file storage service
 Home-page: https://github.com/MenxLi/lfss
 Author: li, mengxun
@@ -16,6 +16,7 @@ Requires-Dist: aiosqlite (==0.*)
 Requires-Dist: fastapi (==0.*)
 Requires-Dist: mimesniff (==1.*)
 Requires-Dist: pillow
+Requires-Dist: python-multipart
 Requires-Dist: requests (==2.*)
 Requires-Dist: uvicorn (==0.*)
 Project-URL: Repository, https://github.com/MenxLi/lfss

{lfss-0.8.0.dist-info → lfss-0.8.1.dist-info}/RECORD

@@ -1,7 +1,7 @@
 Readme.md,sha256=LpbTvUWjCOv4keMNDrZvEnNAmCQnvaxvlq2srWixXn0,1299
 docs/Known_issues.md,sha256=rfdG3j1OJF-59S9E06VPyn0nZKbW-ybPxkoZ7MEZWp8,81
 docs/Permission.md,sha256=9r9nEmhqfz18RTS8FI0fZ9F0a31r86OoAyx3EQxxpk0,2317
-frontend/api.js,sha256=9cR8ddaoF-ulauQ1tcISV2nmfakkplC7uS8-lWFqU58,15820
+frontend/api.js,sha256=wUJNAkL8QigAiwR_jaMPUhCQEsL-lp0wZ6XeueYgunE,18049
 frontend/index.html,sha256=-k0bJ5FRqdl_H-O441D_H9E-iejgRCaL_z5UeYaS2qc,3384
 frontend/info.css,sha256=Ny0N3GywQ3a9q1_Qph_QFEKB4fEnTe_2DJ1Y5OsLLmQ,595
 frontend/info.js,sha256=WhOGaeqMoezEAfg4nIpK26hvejC7AZ-ZDLiJmRj0kDk,5758
@@ -9,14 +9,14 @@ frontend/login.css,sha256=VMM0QfbDFYerxKWKSGhMI1yg5IRBXg0TTdLJEEhQZNk,355
 frontend/login.js,sha256=QoO8yKmBHDVP-ZomCMOaV7xVUVIhpl7esJrb6T5aHQE,2466
 frontend/popup.css,sha256=TJZYFW1ZcdD1IVTlNPYNtMWKPbN6XDbQ4hKBOFK8uLg,1284
 frontend/popup.js,sha256=3PgaGZmxSdV1E-D_MWgcR7aHWkcsHA1BNKSOkmP66tA,5191
-frontend/scripts.js,sha256=PFgAZC-frV-qs6sYCb1ZzH_CAa7in17qbfqYiaIxNmA,21697
+frontend/scripts.js,sha256=2YoMhrcAkI1bHihD_2EK6uCHZ1s0DiIR3FzZsh79x9A,21729
 frontend/state.js,sha256=vbNL5DProRKmSEY7xu9mZH6IY0PBenF8WGxPtGgDnLI,1680
 frontend/styles.css,sha256=xcNLqI3KBsY5TLnku8UIP0Jfr7QLajr1_KNlZj9eheM,4935
 frontend/thumb.css,sha256=rNsx766amYS2DajSQNabhpQ92gdTpNoQKmV69OKvtpI,295
 frontend/thumb.js,sha256=RQ_whXNwmkdG4SEbNQGeh488YYzqwoNYDc210hPeuhQ,5703
 frontend/utils.js,sha256=IYUZl77ugiXKcLxSNOWC4NSS0CdD5yRgUsDb665j0xM,2556
-lfss/api/__init__.py,sha256=YI1_9nyW0E5lyXn_PmmIzIff1ccBC-KCA0twpsKDRIY,5453
-lfss/api/connector.py,sha256=q9CJBOmN83tfpwI1IclSzq_lzI4Kq1SOKC3S5H-vuWo,9301
+lfss/api/__init__.py,sha256=MRzwISePOdq3of9IWGryVWX6coGkxeJ3OEh42Se4IYc,6029
+lfss/api/connector.py,sha256=tmcgKswE0sktBhanEDEc6mpuJA0de7C-DS2YqlpxHX4,10743
 lfss/cli/balance.py,sha256=R2rbO2tg9TVnnQIVeU0GJVeMS-5LDhEdk4mbOE9qGq0,4121
 lfss/cli/cli.py,sha256=8VKe41m_LhVSFxGlvgBxdz55sjscLNbbkNX1fOnmES4,4618
 lfss/cli/panel.py,sha256=iGdVmdWYjA_7a78ZzWEB_3ggIOBeUKTzg6F5zLaB25c,1401
@@ -27,17 +27,17 @@ lfss/sql/init.sql,sha256=C-JtQAlaOjESI8uoF1Y_9dKukEVSw5Ll-7yA3gG-XHU,1210
 lfss/sql/pragma.sql,sha256=uENx7xXjARmro-A3XAK8OM8v5AxDMdCCRj47f86UuXg,206
 lfss/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lfss/src/bounded_pool.py,sha256=BI1dU-MBf82TMwJBYbjhEty7w1jIUKc5Bn9SnZ_-hoY,1288
-lfss/src/config.py,sha256=K1b5clNRO4EzxDG-p6U5aRLDaq-Up0tDHfn_D79D0ns,857
+lfss/src/config.py,sha256=7k_6L_aG7vD-lVcmgpwMIg-ggpMMDNU8IbaB4y1effE,861
 lfss/src/connection_pool.py,sha256=4YULPcmndy33FyBSo9w1fZjAlBX2q-xPP27xJOTA06I,5228
-lfss/src/database.py,sha256=yFMoxHJ-ZRwi9qvSVdIl9m_gpycmL2eencdv7P0vzwQ,35678
+lfss/src/database.py,sha256=Cexv6r9sZl29hWzFyL_J_kWz9roUbut6A246Zc4ORs0,35885
 lfss/src/datatype.py,sha256=q2lc8BJaB2sS7gtqPMqxM625mckgI2SmvuqbadiObLY,2158
 lfss/src/error.py,sha256=Bh_GUtuNsMSMIKbFreU4CfZzL96TZdNAIcgmDxvGbQ0,333
 lfss/src/log.py,sha256=u6WRZZsE7iOx6_CV2NHh1ugea26p408FI4WstZh896A,5139
-lfss/src/server.py,sha256=OcyPuVyvBCxpgF8ESxzDYNZnUJIbkOGDv-eghUSVM9E,20063
+lfss/src/server.py,sha256=mUu0WbiGdM08Jos7a4r_e9ND5sK_tNDEv1VGRPIHvLk,21206
 lfss/src/stat.py,sha256=WlRiiAl0rHX9oPi3thi6K4GKn70WHpClSDCt7iZUow4,3197
 lfss/src/thumb.py,sha256=qjCNMpnCozMuzkhm-2uAYy1eAuYTeWG6xqs-13HX-7k,3266
 lfss/src/utils.py,sha256=nal2rpr00jq1PeFhGQXkvU0FIbtRhXTj8VmbeIyRyLI,5184
-lfss-0.8.0.dist-info/METADATA,sha256=uNZzNHCActK1ok2aPmZZqMXE3JxyWHStAVAH5mzpvkc,2076
-lfss-0.8.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-lfss-0.8.0.dist-info/entry_points.txt,sha256=VJ8svMz7RLtMCgNk99CElx7zo7M-N-z7BWDVw2HA92E,205
-lfss-0.8.0.dist-info/RECORD,,
+lfss-0.8.1.dist-info/METADATA,sha256=PMNu6iNXnpYU6Lyxvlr9-e-ypSj71dygYyqH3mTHzE0,2108
+lfss-0.8.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+lfss-0.8.1.dist-info/entry_points.txt,sha256=VJ8svMz7RLtMCgNk99CElx7zo7M-N-z7BWDVw2HA92E,205
+lfss-0.8.1.dist-info/RECORD,,