lfss 0.7.10__py3-none-any.whl → 0.7.12__py3-none-any.whl

frontend/scripts.js

@@ -1,7 +1,7 @@
 import Connector from './api.js';
 import { permMap } from './api.js';
 import { showFloatingWindowLineInput, showPopup } from './popup.js';
-import { formatSize, decodePathURI, ensurePathURI, getRandomString, cvtGMT2Local, debounce, encodePathURI } from './utils.js';
+import { formatSize, decodePathURI, ensurePathURI, getRandomString, cvtGMT2Local, debounce, encodePathURI, asHtmlText } from './utils.js';
 import { showInfoPanel, showDirInfoPanel } from './info.js';
 
 const conn = new Connector();
@@ -251,7 +251,14 @@ function refreshFileList(){
                         onPathChange();
                     });
                     dirLink.href = '#';
-                    nameTd.appendChild(dirLink);
+                    const nameDiv = document.createElement('div');
+                    nameDiv.classList.add('filename-container');
+                    const thumbImg = document.createElement('img');
+                    thumbImg.classList.add('thumb');
+                    thumbImg.src = conn.config.endpoint + '/' + ensureSlashEnd(dir.url) + '?token=' + conn.config.token + '&thumb=true';
+                    nameDiv.appendChild(thumbImg);
+                    nameDiv.appendChild(dirLink);
+                    nameTd.appendChild(nameDiv);
 
                     tr.appendChild(nameTd);
                     tbody.appendChild(tr);
@@ -343,7 +350,13 @@ function refreshFileList(){
                     const nameTd = document.createElement('td');
                     const plainUrl = decodePathURI(file.url);
                     const fileName = plainUrl.split('/').pop();
-                    nameTd.textContent = fileName;
+
+                    nameTd.innerHTML = `
+                    <div class="filename-container">
+                        <img class="thumb" src="${conn.config.endpoint}/${file.url}?token=${conn.config.token}&thumb=true" />
+                        <span>${asHtmlText(fileName)}</span>
+                    </div>
+                    `
                     tr.appendChild(nameTd);
                     tbody.appendChild(tr);
                 }

frontend/styles.css

@@ -181,6 +181,19 @@ table#files tr td:nth-child(3), table#files tr td:nth-child(5){
     width: 12%;
 }
 
+div.filename-container{
+    display: flex;
+    flex-direction: row;
+    align-items: center;
+    gap: 0.5rem;
+    height: 32px; /* same as thumbnail */
+}
+img.thumb{
+    max-height: 32px;   /* smaller than backend */
+    max-width: 32px;
+    border-radius: 0.25rem;
+}
+
 label#upload-file-prefix{
     width: 800px;
     text-align: right;

frontend/utils.js

@@ -86,4 +86,11 @@ export function debounce(fn,wait){
         if (timeout) clearTimeout(timeout);
         timeout = setTimeout(() => fn.apply(context, args), wait);
     }
+}
+
+export function asHtmlText(text){
+    const anonElem = document.createElement('div');
+    anonElem.textContent = text;
+    const htmlText = anonElem.innerHTML;
+    return htmlText;
 }

lfss/cli/serve.py

@@ -24,7 +24,7 @@ def main():
         log_config=default_logging_config
     )
     server = Server(config=config)
-    logger.info(f"Starting server at {args.host}:{args.port}, with {args.workers} workers")
+    logger.info(f"Starting server at http://{args.host}:{args.port}, with {args.workers} workers.")
     server.run()
 
 if __name__ == "__main__":

lfss/cli/vacuum.py

@@ -2,8 +2,8 @@
 Vacuum the database and external storage to ensure that the storage is consistent and minimal.
 """
 
-from lfss.src.config import LARGE_BLOB_DIR, DATA_HOME
-import argparse, time, os
+from lfss.src.config import LARGE_BLOB_DIR
+import argparse, time
 from functools import wraps
 from asyncio import Semaphore
 import aiofiles, asyncio
@@ -11,6 +11,7 @@ import aiofiles.os
 from contextlib import contextmanager
 from lfss.src.database import transaction, unique_cursor
 from lfss.src.stat import RequestDB
+from lfss.src.utils import now_stamp
 from lfss.src.connection_pool import global_entrance
 
 sem: Semaphore
@@ -68,12 +69,9 @@ async def vacuum_main(index: bool = False, blobs: bool = False):
 
 async def vacuum_requests():
     with indicator("VACUUM-requests"):
-        req_db = await RequestDB().init()
-        try:
-            await req_db.shrink()
+        async with RequestDB().connect() as req_db:
+            await req_db.shrink(max_rows=1_000_000, time_before=now_stamp() - 7*24*60*60)
             await req_db.conn.execute("VACUUM")
-        finally:
-            await req_db.close()
             
 def main():
     global sem
@@ -81,7 +79,7 @@ def main():
     parser.add_argument("-j", "--jobs", type=int, default=2, help="Number of concurrent jobs")
     parser.add_argument("-m", "--metadata", action="store_true", help="Vacuum metadata")
     parser.add_argument("-d", "--data", action="store_true", help="Vacuum blobs")
-    parser.add_argument("-r", "--requests", action="store_true", help="Vacuum request logs")
+    parser.add_argument("-r", "--requests", action="store_true", help="Vacuum request logs to only keep at most recent 1M rows in 7 days")
     args = parser.parse_args()
     sem = Semaphore(args.jobs)
     asyncio.run(vacuum_main(index=args.metadata, blobs=args.data))

lfss/client/__init__.py

@@ -1,7 +1,7 @@
 import os, time, pathlib
 from threading import Lock
-from concurrent.futures import ThreadPoolExecutor
 from .api import Connector
+from ..src.bounded_pool import BoundedThreadPoolExecutor
 
 def upload_file(
     connector: Connector, 
@@ -68,7 +68,7 @@ def upload_directory(
             ):
             faild_files.append(file_path)
 
-    with ThreadPoolExecutor(n_concurrent) as executor:
+    with BoundedThreadPoolExecutor(n_concurrent) as executor:
         for root, dirs, files in os.walk(directory):
             for file in files:
                 executor.submit(put_file, os.path.join(root, file))
@@ -149,7 +149,7 @@ def download_directory(
             ):
             failed_files.append(src_url)
         
-    with ThreadPoolExecutor(n_concurrent) as executor:
+    with BoundedThreadPoolExecutor(n_concurrent) as executor:
         for file in connector.list_path(src_path, flat=True).files:
             executor.submit(get_file, file.url)
     return failed_files

lfss/client/api.py

@@ -31,8 +31,9 @@ class Connector:
             headers.update({
                 'Authorization': f"Bearer {self.config['token']}",
             })
-            response = requests.request(method, url, headers=headers, **kwargs)
-            response.raise_for_status()
+            with requests.Session() as s:
+                response = s.request(method, url, headers=headers, **kwargs)
+                response.raise_for_status()
             return response
         return f
 

lfss/src/bounded_pool.py

@@ -0,0 +1,44 @@
+"""
+Code modified from: https://github.com/mowshon/bounded_pool_executor
+"""
+
+import multiprocessing
+import concurrent.futures
+import multiprocessing.synchronize
+import threading
+from typing import Optional
+
+class _BoundedPoolExecutor:
+
+    semaphore: Optional[multiprocessing.synchronize.BoundedSemaphore | threading.BoundedSemaphore] = None
+    _max_workers: int
+
+    def acquire(self):
+        assert self.semaphore is not None
+        self.semaphore.acquire()
+
+    def release(self, fn):
+        assert self.semaphore is not None
+        self.semaphore.release()
+
+    def submit(self, fn, *args, **kwargs):
+        self.acquire()
+        future = super().submit(fn, *args, **kwargs)    # type: ignore
+        future.add_done_callback(self.release)
+
+        return future
+
+
+class BoundedProcessPoolExecutor(_BoundedPoolExecutor, concurrent.futures.ProcessPoolExecutor):
+
+    def __init__(self, max_workers=None):
+        super().__init__(max_workers)
+        self.semaphore = multiprocessing.BoundedSemaphore(self._max_workers * 2)
+
+
+class BoundedThreadPoolExecutor(_BoundedPoolExecutor, concurrent.futures.ThreadPoolExecutor):
+
+    def __init__(self, max_workers=None):
+        super().__init__(max_workers)
+        self.semaphore = threading.BoundedSemaphore(self._max_workers * 2)
+

lfss/src/server.py

@@ -19,6 +19,7 @@ from .config import MAX_BUNDLE_BYTES, MAX_FILE_BYTES, LARGE_FILE_BYTES, CHUNK_SI
 from .utils import ensure_uri_compnents, format_last_modified, now_stamp
 from .connection_pool import global_connection_init, global_connection_close, unique_cursor
 from .database import Database, UserRecord, DECOY_USER, FileRecord, check_user_permission, FileReadPermission, UserConn, FileConn, PathContents
+from .thumb import get_thumb
 
 logger = get_logger("server", term_level="DEBUG")
 logger_failed_request = get_logger("failed_requests", term_level="INFO")
@@ -31,7 +32,6 @@ async def lifespan(app: FastAPI):
     try:
         await global_connection_init(n_read = 2)
         await asyncio.gather(db.init(), req_conn.init())
-        await req_conn.shrink()
         yield
         await req_conn.commit()
     finally:
@@ -50,7 +50,7 @@ def handle_exception(fn):
             if isinstance(e, FileNotFoundError): raise HTTPException(status_code=404, detail=str(e))
             if isinstance(e, FileExistsError): raise HTTPException(status_code=409, detail=str(e))
             logger.error(f"Uncaptured error in {fn.__name__}: {e}")
-            raise HTTPException(status_code=500, detail=str(e))
+            raise 
     return wrapper
 
 async def get_credential_from_params(request: Request):
@@ -119,9 +119,59 @@ async def log_requests(request: Request, call_next):
 
 router_fs = APIRouter(prefix="")
 
+async def emit_thumbnail(
+    path: str, download: bool,
+    create_time: Optional[str] = None
+    ):
+    if path.endswith("/"):
+        fname = path.split("/")[-2]
+    else:
+        fname = path.split("/")[-1]
+    thumb_blob, mime_type = await get_thumb(path)
+    disp = "inline" if not download else "attachment"
+    headers = {
+        "Content-Disposition": f"{disp}; filename={fname}.thumb.jpg",
+        "Content-Length": str(len(thumb_blob)),
+    }
+    if create_time is not None:
+        headers["Last-Modified"] = format_last_modified(create_time)
+    return Response(
+        content=thumb_blob, media_type=mime_type, headers=headers
+    )
+async def emit_file(
+    file_record: FileRecord, 
+    media_type: Optional[str] = None, 
+    disposition = "attachment"
+    ):
+    if media_type is None:
+        media_type = file_record.mime_type
+    path = file_record.url
+    fname = path.split("/")[-1]
+    if not file_record.external:
+        fblob = await db.read_file(path)
+        return Response(
+            content=fblob, media_type=media_type, headers={
+                "Content-Disposition": f"{disposition}; filename={fname}", 
+                "Content-Length": str(len(fblob)), 
+                "Last-Modified": format_last_modified(file_record.create_time)
+            }
+        )
+    else:
+        return StreamingResponse(
+            await db.read_file_stream(path), media_type=media_type, headers={
+                "Content-Disposition": f"{disposition}; filename={fname}", 
+                "Content-Length": str(file_record.file_size),
+                "Last-Modified": format_last_modified(file_record.create_time)
+            }
+        )
+
 @router_fs.get("/{path:path}")
 @handle_exception
-async def get_file(path: str, download: bool = False, flat: bool = False, user: UserRecord = Depends(get_current_user)):
+async def get_file(
+    path: str, 
+    download: bool = False, flat: bool = False, thumb: bool = False,
+    user: UserRecord = Depends(get_current_user)
+    ):
     path = ensure_uri_compnents(path)
 
     # handle directory query
@@ -132,6 +182,9 @@ async def get_file(path: str, download: bool = False, flat: bool = False, user:
             fconn = FileConn(conn)
             if user.id == 0:
                 raise HTTPException(status_code=401, detail="Permission denied, credential required")
+            if thumb:
+                return await emit_thumbnail(path, download, create_time=None)
+            
             if path == "/":
                 if flat:
                     raise HTTPException(status_code=400, detail="Flat query not supported for root path")
@@ -146,6 +199,7 @@ async def get_file(path: str, download: bool = False, flat: bool = False, user:
 
             return await fconn.list_path(path, flat = flat)
     
+    # handle file query
     async with unique_cursor() as conn:
         fconn = FileConn(conn)
         file_record = await fconn.get_file_record(path)
@@ -160,32 +214,13 @@ async def get_file(path: str, download: bool = False, flat: bool = False, user:
     if not allow_access:
         raise HTTPException(status_code=403, detail=reason)
     
-    fname = path.split("/")[-1]
-    async def send(media_type: Optional[str] = None, disposition = "attachment"):
-        if media_type is None:
-            media_type = file_record.mime_type
-        if not file_record.external:
-            fblob = await db.read_file(path)
-            return Response(
-                content=fblob, media_type=media_type, headers={
-                    "Content-Disposition": f"{disposition}; filename={fname}", 
-                    "Content-Length": str(len(fblob)), 
-                    "Last-Modified": format_last_modified(file_record.create_time)
-                }
-            )
-        else:
-            return StreamingResponse(
-                await db.read_file_stream(path), media_type=media_type, headers={
-                    "Content-Disposition": f"{disposition}; filename={fname}", 
-                    "Content-Length": str(file_record.file_size),
-                    "Last-Modified": format_last_modified(file_record.create_time)
-                }
-            )
-    
-    if download:
-        return await send('application/octet-stream', "attachment")
+    if thumb:
+        return await emit_thumbnail(path, download, create_time=file_record.create_time)
     else:
-        return await send(None, "inline")
+        if download:
+            return await emit_file(file_record, 'application/octet-stream', "attachment")
+        else:
+            return await emit_file(file_record, None, "inline")
 
 @router_fs.put("/{path:path}")
 @handle_exception

lfss/src/stat.py

@@ -1,7 +1,8 @@
 from typing import Optional, Any
 import aiosqlite
+from contextlib import asynccontextmanager
 from .config import DATA_HOME
-from .utils import debounce_async, concurrent_wrap
+from .utils import debounce_async
 
 class RequestDB:
     conn: aiosqlite.Connection
@@ -26,6 +27,14 @@ class RequestDB:
             )
         ''')
         return self
+    
+    def connect(self):
+        @asynccontextmanager
+        async def _mgr():
+            await self.init()
+            yield self
+            await self.close()
+        return _mgr()
 
     async def close(self):
         await self.conn.close()
@@ -65,7 +74,6 @@ class RequestDB:
             assert cursor.lastrowid is not None
             return cursor.lastrowid
     
-    @concurrent_wrap()
     async def shrink(self, max_rows: int = 1_000_000, time_before: float = 0):
         async with aiosqlite.connect(self.db) as conn:
 

lfss/src/thumb.py

@@ -0,0 +1,121 @@
+from lfss.src.config import DATA_HOME
+from lfss.src.database import FileConn
+from lfss.src.connection_pool import unique_cursor
+from typing import Optional
+from PIL import Image
+from io import BytesIO
+import aiosqlite
+
+def prepare_svg(svg_str: str):
+    """
+    Injects grey color to the svg string, and encodes it to bytes
+    """
+    color = "#666"
+    x = svg_str.replace('<path', '<path fill="{}"'.format(color))
+    x = x.replace('<svg', '<svg fill="{}"'.format(color))
+    return x.encode()
+
+# from: https://pictogrammers.com/library/mdi/
+ICON_FOLER = prepare_svg('<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><title>folder-outline</title><path d="M20,18H4V8H20M20,6H12L10,4H4C2.89,4 2,4.89 2,6V18A2,2 0 0,0 4,20H20A2,2 0 0,0 22,18V8C22,6.89 21.1,6 20,6Z" /></svg>')
+ICON_FILE = prepare_svg('<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><title>file-document-outline</title><path d="M6,2A2,2 0 0,0 4,4V20A2,2 0 0,0 6,22H18A2,2 0 0,0 20,20V8L14,2H6M6,4H13V9H18V20H6V4M8,12V14H16V12H8M8,16V18H13V16H8Z" /></svg>')
+ICON_PDF = prepare_svg('<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><title>file-pdf-box</title><path d="M19 3H5C3.9 3 3 3.9 3 5V19C3 20.1 3.9 21 5 21H19C20.1 21 21 20.1 21 19V5C21 3.9 20.1 3 19 3M9.5 11.5C9.5 12.3 8.8 13 8 13H7V15H5.5V9H8C8.8 9 9.5 9.7 9.5 10.5V11.5M14.5 13.5C14.5 14.3 13.8 15 13 15H10.5V9H13C13.8 9 14.5 9.7 14.5 10.5V13.5M18.5 10.5H17V11.5H18.5V13H17V15H15.5V9H18.5V10.5M12 10.5H13V13.5H12V10.5M7 10.5H8V11.5H7V10.5Z" /></svg>')
+ICON_EXE = prepare_svg('<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><title>application-brackets-outline</title><path d="M9.5,8.5L11,10L8,13L11,16L9.5,17.5L5,13L9.5,8.5M14.5,17.5L13,16L16,13L13,10L14.5,8.5L19,13L14.5,17.5M21,2H3A2,2 0 0,0 1,4V20A2,2 0 0,0 3,22H21A2,2 0 0,0 23,20V4A2,2 0 0,0 21,2M21,20H3V6H21V20Z" /></svg>')
+ICON_ZIP = prepare_svg('<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><title>zip-box-outline</title><path d="M12 17V15H14V17H12M14 13V11H12V13H14M14 9V7H12V9H14M10 11H12V9H10V11M10 15H12V13H10V15M21 5V19C21 20.1 20.1 21 19 21H5C3.9 21 3 20.1 3 19V5C3 3.9 3.9 3 5 3H19C20.1 3 21 3.9 21 5M19 5H12V7H10V5H5V19H19V5Z" /></svg>')
+ICON_CODE = prepare_svg('<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><title>file-code-outline</title><path d="M14 2H6C4.89 2 4 2.9 4 4V20C4 21.11 4.89 22 6 22H18C19.11 22 20 21.11 20 20V8L14 2M18 20H6V4H13V9H18V20M9.54 15.65L11.63 17.74L10.35 19L7 15.65L10.35 12.3L11.63 13.56L9.54 15.65M17 15.65L13.65 19L12.38 17.74L14.47 15.65L12.38 13.56L13.65 12.3L17 15.65Z" /></svg>')
+
+THUMB_DB = DATA_HOME / 'thumbs.db'
+THUMB_SIZE = (48, 48)
+
+async def _maybe_init_thumb(c: aiosqlite.Cursor):
+    await c.execute('''
+        CREATE TABLE IF NOT EXISTS thumbs (
+            path TEXT PRIMARY KEY,
+            ctime TEXT,
+            thumb BLOB
+        )
+    ''')
+
+async def _get_cache_thumb(c: aiosqlite.Cursor, path: str, ctime: str) -> Optional[bytes]:
+    res = await c.execute('''
+        SELECT ctime, thumb FROM thumbs WHERE path = ? 
+    ''', (path, ))
+    row = await res.fetchone()
+    if row is None:
+        return None
+    # check if ctime matches, if not delete and return None
+    if row[0] != ctime:
+        await _delete_cache_thumb(c, path)
+        return None
+    blob: bytes = row[1]
+    return blob
+    
+async def _save_cache_thumb(c: aiosqlite.Cursor, path: str, ctime: str, raw_bytes: bytes) -> bytes:
+    raw_img = Image.open(BytesIO(raw_bytes))
+    raw_img.thumbnail(THUMB_SIZE)
+    img = raw_img.convert('RGB')
+    bio = BytesIO()
+    img.save(bio, 'JPEG')
+    blob = bio.getvalue()
+    await c.execute('''
+        INSERT OR REPLACE INTO thumbs (path, ctime, thumb) VALUES (?, ?, ?)
+    ''', (path, ctime, blob))
+    await c.execute('COMMIT')  # commit immediately
+    return blob
+
+async def _delete_cache_thumb(c: aiosqlite.Cursor, path: str):
+    await c.execute('''
+        DELETE FROM thumbs WHERE path = ?
+    ''', (path, ))
+    await c.execute('COMMIT')
+
+async def get_thumb(path: str) -> tuple[bytes, str]:
+    """
+    returns [image bytes of thumbnail, mime type] if supported, 
+    or None if not supported. 
+    Raises FileNotFoundError if file does not exist
+    """
+    if path.endswith('/'):
+        return ICON_FOLER, 'image/svg+xml'
+
+    async with aiosqlite.connect(THUMB_DB) as conn:
+        cur = await conn.cursor()
+        await _maybe_init_thumb(cur)
+
+        async with unique_cursor() as main_c:
+            fconn = FileConn(main_c)
+            r = await fconn.get_file_record(path)
+            if r is None:
+                await _delete_cache_thumb(cur, path)
+                raise FileNotFoundError(f'File not found: {path}')
+        
+            if not r.mime_type.startswith('image/'):
+                match r.mime_type:
+                    case 'application/pdf' | 'application/x-pdf':
+                        return ICON_PDF, 'image/svg+xml'
+                    case 'application/x-msdownload' | 'application/x-msdos-program' | 'application/x-msi' | 'application/octet-stream':
+                        return ICON_EXE, 'image/svg+xml'
+                    case 'application/zip' | 'application/x-zip-compressed' | 'application/x-zip' | 'application/x-compressed' | 'application/x-compress':
+                        return ICON_ZIP, 'image/svg+xml'
+                    case 'text/plain' | 'text/x-python' | 'text/x-c' | 'text/x-c++' | 'text/x-java' | 'text/x-php' | 'text/x-shellscript' | 'text/x-perl' | 'text/x-ruby' | 'text/x-go' | 'text/x-rust' | 'text/x-haskell' | 'text/x-lisp' | 'text/x-lua' | 'text/x-tcl' | 'text/x-sql' | 'text/x-yaml' | 'text/x-xml' | 'text/x-markdown' | 'text/x-tex' | 'text/x-asm' | 'text/x-fortran' | 'text/x-pascal' | 'text/x-erlang' | 'text/x-ocaml' | 'text/x-matlab' | 'text/x-csharp' | 'text/x-swift' | 'text/x-kotlin' | 'text/x-dart' | 'text/x-julia' | 'text/x-scala' | 'text/x-clojure' | 'text/x-elm' | 'text/x-crystal' | 'text/x-nim' | 'text/x-zig':
+                        return ICON_CODE, 'image/svg+xml'
+                    case _:
+                        return ICON_FILE, 'image/svg+xml'
+
+        c_time = r.create_time
+        thumb_blob = await _get_cache_thumb(cur, path, c_time)
+        if thumb_blob is not None:
+            return thumb_blob, "image/jpeg"
+        
+        # generate thumb
+        async with unique_cursor() as main_c:
+            fconn = FileConn(main_c)
+            if r.external:
+                data = b""
+                async for chunk in fconn.get_file_blob_external(r.file_id):
+                    data += chunk
+            else:
+                data = await fconn.get_file_blob(r.file_id)
+            assert data is not None
+        
+        thumb_blob = await _save_cache_thumb(cur, path, c_time, data)
+        return thumb_blob, "image/jpeg"

{lfss-0.7.10.dist-info → lfss-0.7.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lfss
-Version: 0.7.10
+Version: 0.7.12
 Summary: Lightweight file storage service
 Home-page: https://github.com/MenxLi/lfss
 Author: li, mengxun
@@ -15,6 +15,8 @@ Requires-Dist: aiofiles (==23.*)
 Requires-Dist: aiosqlite (==0.*)
 Requires-Dist: fastapi (==0.*)
 Requires-Dist: mimesniff (==1.*)
+Requires-Dist: pillow
+Requires-Dist: uvicorn (==0.*)
 Project-URL: Repository, https://github.com/MenxLi/lfss
 Description-Content-Type: text/markdown
 

{lfss-0.7.10.dist-info → lfss-0.7.12.dist-info}/RECORD

@@ -7,30 +7,32 @@ frontend/info.css,sha256=Ny0N3GywQ3a9q1_Qph_QFEKB4fEnTe_2DJ1Y5OsLLmQ,595
 frontend/info.js,sha256=WhOGaeqMoezEAfg4nIpK26hvejC7AZ-ZDLiJmRj0kDk,5758
 frontend/popup.css,sha256=TJZYFW1ZcdD1IVTlNPYNtMWKPbN6XDbQ4hKBOFK8uLg,1284
 frontend/popup.js,sha256=3PgaGZmxSdV1E-D_MWgcR7aHWkcsHA1BNKSOkmP66tA,5191
-frontend/scripts.js,sha256=OP99BSbnyTE1LJebGVUvV3WUnDBiZdqaC3a9SE1FF6U,20286
-frontend/styles.css,sha256=37aU9Iep_hTz3LnAAAcEhC_I7AC0A4lX6apnMuGPTlA,4214
-frontend/utils.js,sha256=Ts4nlef8pkrEgpwX-uQwAhWvwxlIzex8ijDLNCa22ps,2372
+frontend/scripts.js,sha256=4LHc1M2QwxtCJsbShxXu0uKYBY8auv84JuYcd1zwpQM,21069
+frontend/styles.css,sha256=ghtQLSi7-zS8Yuac49TNiGVxNgggh-R3SM7HDYQM97c,4482
+frontend/utils.js,sha256=IYUZl77ugiXKcLxSNOWC4NSS0CdD5yRgUsDb665j0xM,2556
 lfss/cli/balance.py,sha256=R2rbO2tg9TVnnQIVeU0GJVeMS-5LDhEdk4mbOE9qGq0,4121
 lfss/cli/cli.py,sha256=LH1nx5wI1K2DZ3hvHz7oq5HcXVDoW2V6sr7q9gJ8gqo,4621
 lfss/cli/panel.py,sha256=iGdVmdWYjA_7a78ZzWEB_3ggIOBeUKTzg6F5zLaB25c,1401
-lfss/cli/serve.py,sha256=bO3GT0kuylMGN-7bZWP4e71MlugGZ_lEMkYaYld_Ntg,985
+lfss/cli/serve.py,sha256=T-jz_PJcaY9FJRRfyWV9MbjDI73YdOOCn4Nr2PO-s0c,993
 lfss/cli/user.py,sha256=ETLtj0N-kmxv0mhmeAsO6cY7kPq7nOOP4DetxIRoQpQ,3405
-lfss/cli/vacuum.py,sha256=i7YufreIsl8J9qfHm876vCmo0wv9OnK-FwyRK0o6HNQ,3624
-lfss/client/__init__.py,sha256=8uvcKs3PYQamDd_cjfN-fX9QUohEzJqeJlOYkBlzC3M,4556
-lfss/client/api.py,sha256=kSkB4wADTu012-1wl6v90OiZrw6aTQ42GU4jtV4KO0k,5764
+lfss/cli/vacuum.py,sha256=4TMMYC_5yEt7jeaFTVC3iX0X6aUzYXBiCsrcIYgw_uA,3695
+lfss/client/__init__.py,sha256=kcClDdHaQowAhHFYdrFyFqHIOe5MEjfENYq1icuj3Mg,4577
+lfss/client/api.py,sha256=aHorSuxl79xvRRfwuitXANYoTogWKVO11XX7mdrhHTE,5807
 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=2qN2nu3onP1M7U6ENC0ZbVVRE90aDomTcQ1GsBLLHF8,800
 lfss/src/connection_pool.py,sha256=r4Ho5d_Gd4S_KbT7515UJoiyfIgS6xyttqMsKqOfaIg,5190
 lfss/src/database.py,sha256=w2QPE3h1Lx0D0fUmdtu9s1XHpNp9p27zqm8AVeP2UVg,32476
 lfss/src/datatype.py,sha256=WfrLALU_7wei5-i_b0TxY8xWI5mwxLUHFepHSps49zA,1767
 lfss/src/error.py,sha256=imbhwnbhnI3HLhkbfICROe3F0gleKrOk4XnqHJDOtuI,285
 lfss/src/log.py,sha256=u6WRZZsE7iOx6_CV2NHh1ugea26p408FI4WstZh896A,5139
-lfss/src/server.py,sha256=WnUc116XnGooH78IQNkI7VO4bel-Xvp_ZzCoHTcu8sM,16288
-lfss/src/stat.py,sha256=sCSsrdkA0aX9fyNfZlNrZ8PVpovKYQKwWj2xKcCIXx4,3009
+lfss/src/server.py,sha256=hFUeg14-G2nIfY2sD9fL_3YvRv7TuuGQk932HCT_NPs,17224
+lfss/src/stat.py,sha256=Wr-ug_JqtbSIf3XwQnv1xheGhsDTEOlLWuYoKO_26Jo,3201
+lfss/src/thumb.py,sha256=KnKvjP3RwhjqFZxZabdUTuk5l9fv3AXO2YUgu0Xzvps,6770
 lfss/src/utils.py,sha256=TBGYvgt6xMP8UC5wTGHAr9fmdhu0_gjOtxcSeyvGyVM,3918
-lfss-0.7.10.dist-info/METADATA,sha256=iKvhqHzMfLEqap1_iNt-UIYykPUAZKuCPJhR302AWpM,1968
-lfss-0.7.10.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-lfss-0.7.10.dist-info/entry_points.txt,sha256=VJ8svMz7RLtMCgNk99CElx7zo7M-N-z7BWDVw2HA92E,205
-lfss-0.7.10.dist-info/RECORD,,
+lfss-0.7.12.dist-info/METADATA,sha256=bFSR41dbc7Y_Ui4ALbYEqbCjvmpvh4WNBmonJ3Pn868,2021
+lfss-0.7.12.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+lfss-0.7.12.dist-info/entry_points.txt,sha256=VJ8svMz7RLtMCgNk99CElx7zo7M-N-z7BWDVw2HA92E,205
+lfss-0.7.12.dist-info/RECORD,,