lfss 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

frontend/index.html

@@ -48,9 +48,11 @@
         <div class="input-group">
             <input type="file" id="file-selector" accept="*">
             <label for="file-name" id="upload-file-prefix"></label>
-            <input type="text" id="file-name" placeholder="Destination file path" autocomplete="off">
-            <span id='randomize-fname-btn'>🎲</span>
-            <button id="upload-btn">Upload</button>
+            <div class="input-group">
+                <input type="text" id="file-name" placeholder="Destination file path" autocomplete="off">
+                <span id='randomize-fname-btn'>🎲</span>
+                <button id="upload-btn">Upload</button>
+            </div>
         </div>
     </div>
 

frontend/scripts.js

@@ -264,7 +264,9 @@ function refreshFileList(){
 
                     const downloadButton = document.createElement('a');
                     downloadButton.textContent = 'Download';
-                    downloadButton.href = conn.config.endpoint + '/_api/bundle?path=' + dir.url + (dir.url.endsWith('/') ? '' : '/');
+                    downloadButton.href = conn.config.endpoint + '/_api/bundle?' + 
+                        'token=' + conn.config.token + '&' +
+                        'path=' + dir.url + (dir.url.endsWith('/') ? '' : '/');
                     actContainer.appendChild(downloadButton);
 
                     const deleteButton = document.createElement('a');

lfss/client/api.py

@@ -3,7 +3,7 @@ import os
 import requests
 import urllib.parse
 from lfss.src.database import (
-    FileReadPermission, FileDBRecord, DBUserRecord, PathContents
+    FileReadPermission, FileRecord, UserRecord, PathContents
     )
 
 _default_endpoint = os.environ.get('LFSS_ENDPOINT', 'http://localhost:8000')
@@ -58,11 +58,11 @@ class Connector:
             path = path[1:]
         self._fetch('DELETE', path)()
     
-    def get_metadata(self, path: str) -> Optional[FileDBRecord]:
+    def get_metadata(self, path: str) -> Optional[FileRecord]:
         """Gets the metadata for the file at the specified path."""
         try:
             response = self._fetch('GET', '_api/fmeta', {'path': path})()
-            return FileDBRecord(**response.json())
+            return FileRecord(**response.json())
         except requests.exceptions.HTTPError as e:
             if e.response.status_code == 404:
                 return None
@@ -85,7 +85,7 @@ class Connector:
             headers = {'Content-Type': 'application/www-form-urlencoded'}
         )
         
-    def whoami(self) -> DBUserRecord:
+    def whoami(self) -> UserRecord:
         """Gets information about the current user."""
         response = self._fetch('GET', '_api/whoami')()
-        return DBUserRecord(**response.json())
+        return UserRecord(**response.json())

lfss/src/database.py

@@ -1,5 +1,5 @@
 
-from typing import Optional, overload, Literal
+from typing import Optional, overload, Literal, AsyncIterable
 from abc import ABC, abstractmethod
 
 import urllib.parse
@@ -58,7 +58,7 @@ class FileReadPermission(IntEnum):
     PRIVATE = 3         # accessible by owner only (including admin)
 
 @dataclasses.dataclass
-class DBUserRecord:
+class UserRecord:
     id: int
     username: str
     credential: str
@@ -71,12 +71,12 @@ class DBUserRecord:
     def __str__(self):
         return f"User {self.username} (id={self.id}, admin={self.is_admin}, created at {self.create_time}, last active at {self.last_active}), storage={self.max_storage}, permission={self.permission}"
 
-DECOY_USER = DBUserRecord(0, 'decoy', 'decoy', False, '2021-01-01 00:00:00', '2021-01-01 00:00:00', 0, FileReadPermission.PRIVATE)
+DECOY_USER = UserRecord(0, 'decoy', 'decoy', False, '2021-01-01 00:00:00', '2021-01-01 00:00:00', 0, FileReadPermission.PRIVATE)
 class UserConn(DBConnBase):
 
     @staticmethod
-    def parse_record(record) -> DBUserRecord:
-        return DBUserRecord(*record)
+    def parse_record(record) -> UserRecord:
+        return UserRecord(*record)
 
     async def init(self):
         await super().init()
@@ -102,21 +102,21 @@ class UserConn(DBConnBase):
 
         return self
     
-    async def get_user(self, username: str) -> Optional[DBUserRecord]:
+    async def get_user(self, username: str) -> Optional[UserRecord]:
         async with self.conn.execute("SELECT * FROM user WHERE username = ?", (username, )) as cursor:
             res = await cursor.fetchone()
         
         if res is None: return None
         return self.parse_record(res)
     
-    async def get_user_by_id(self, user_id: int) -> Optional[DBUserRecord]:
+    async def get_user_by_id(self, user_id: int) -> Optional[UserRecord]:
         async with self.conn.execute("SELECT * FROM user WHERE id = ?", (user_id, )) as cursor:
             res = await cursor.fetchone()
         
         if res is None: return None
         return self.parse_record(res)
     
-    async def get_user_by_credential(self, credential: str) -> Optional[DBUserRecord]:
+    async def get_user_by_credential(self, credential: str) -> Optional[UserRecord]:
         async with self.conn.execute("SELECT * FROM user WHERE credential = ?", (credential, )) as cursor:
             res = await cursor.fetchone()
         
@@ -182,7 +182,7 @@ class UserConn(DBConnBase):
         self.logger.info(f"Delete user {username}")
 
 @dataclasses.dataclass
-class FileDBRecord:
+class FileRecord:
     url: str
     owner_id: int
     file_id: str      # defines mapping from fmata to fdata
@@ -206,13 +206,13 @@ class DirectoryRecord:
 @dataclasses.dataclass
 class PathContents:
     dirs: list[DirectoryRecord]
-    files: list[FileDBRecord]
+    files: list[FileRecord]
     
 class FileConn(DBConnBase):
 
     @staticmethod
-    def parse_record(record) -> FileDBRecord:
-        return FileDBRecord(*record)
+    def parse_record(record) -> FileRecord:
+        return FileRecord(*record)
     
     async def init(self):
         await super().init()
@@ -259,26 +259,26 @@ class FileConn(DBConnBase):
 
         return self
     
-    async def get_file_record(self, url: str) -> Optional[FileDBRecord]:
+    async def get_file_record(self, url: str) -> Optional[FileRecord]:
         async with self.conn.execute("SELECT * FROM fmeta WHERE url = ?", (url, )) as cursor:
             res = await cursor.fetchone()
         if res is None:
             return None
         return self.parse_record(res)
     
-    async def get_file_records(self, urls: list[str]) -> list[FileDBRecord]:
+    async def get_file_records(self, urls: list[str]) -> list[FileRecord]:
         async with self.conn.execute("SELECT * FROM fmeta WHERE url IN ({})".format(','.join(['?'] * len(urls))), urls) as cursor:
             res = await cursor.fetchall()
         if res is None:
             return []
         return [self.parse_record(r) for r in res]
     
-    async def get_user_file_records(self, owner_id: int) -> list[FileDBRecord]:
+    async def get_user_file_records(self, owner_id: int) -> list[FileRecord]:
         async with self.conn.execute("SELECT * FROM fmeta WHERE owner_id = ?", (owner_id, )) as cursor:
             res = await cursor.fetchall()
         return [self.parse_record(r) for r in res]
     
-    async def get_path_records(self, url: str) -> list[FileDBRecord]:
+    async def get_path_records(self, url: str) -> list[FileRecord]:
         async with self.conn.execute("SELECT * FROM fmeta WHERE url LIKE ?", (url + '%', )) as cursor:
             res = await cursor.fetchall()
         return [self.parse_record(r) for r in res]
@@ -301,11 +301,11 @@ class FileConn(DBConnBase):
             return dirs
     
     @overload
-    async def list_path(self, url: str, flat: Literal[True]) -> list[FileDBRecord]:...
+    async def list_path(self, url: str, flat: Literal[True]) -> list[FileRecord]:...
     @overload
     async def list_path(self, url: str, flat: Literal[False]) -> PathContents:...
     
-    async def list_path(self, url: str, flat: bool = False) -> list[FileDBRecord] | PathContents:
+    async def list_path(self, url: str, flat: bool = False) -> list[FileRecord] | PathContents:
         """
         List all files and directories under the given path, 
         if flat is True, return a list of FileDBRecord, recursively including all subdirectories. 
@@ -495,7 +495,7 @@ def validate_url(url: str, is_file = True):
     if not ret:
         raise InvalidPathError(f"Invalid URL: {url}")
 
-async def get_user(db: "Database", user: int | str) -> Optional[DBUserRecord]:
+async def get_user(db: "Database", user: int | str) -> Optional[UserRecord]:
     if isinstance(user, str):
         return await db.user.get_user(user)
     elif isinstance(user, int):
@@ -591,7 +591,7 @@ class Database:
 
         return blob
 
-    async def delete_file(self, url: str) -> Optional[FileDBRecord]:
+    async def delete_file(self, url: str) -> Optional[FileRecord]:
         validate_url(url)
 
         async with transaction(self):
@@ -631,32 +631,37 @@ class Database:
             await self.file.delete_file_blobs([r.file_id for r in records])
             await self.file.delete_user_file_records(user.id)
             await self.user.delete_user(user.username)
-
-    async def zip_path(self, top_url: str, urls: Optional[list[str]]) -> io.BytesIO:
+    
+    async def iter_path(self, top_url: str, urls: Optional[list[str]]) -> AsyncIterable[tuple[FileRecord, bytes]]:
         if urls is None:
             urls = [r.url for r in await self.file.list_path(top_url, flat=True)]
 
+        for url in urls:
+            if not url.startswith(top_url):
+                continue
+            r = await self.file.get_file_record(url)
+            if r is None:
+                continue
+            f_id = r.file_id
+            blob = await self.file.get_file_blob(f_id)
+            if blob is None:
+                self.logger.warning(f"Blob not found for {url}")
+                continue
+            yield r, blob
+
+    async def zip_path(self, top_url: str, urls: Optional[list[str]]) -> io.BytesIO:
+        if top_url.startswith('/'):
+            top_url = top_url[1:]
         buffer = io.BytesIO()
         with zipfile.ZipFile(buffer, 'w') as zf:
-            for url in urls:
-                if not url.startswith(top_url):
-                    continue
-                r = await self.file.get_file_record(url)
-                if r is None:
-                    continue
-                f_id = r.file_id
-                blob = await self.file.get_file_blob(f_id)
-                if blob is None:
-                    continue
-
-                rel_path = url[len(top_url):]
+            async for (r, blob) in self.iter_path(top_url, urls):
+                rel_path = r.url[len(top_url):]
                 rel_path = decode_uri_compnents(rel_path)
                 zf.writestr(rel_path, blob)
-
         buffer.seek(0)
         return buffer
 
-def check_user_permission(user: DBUserRecord, owner: DBUserRecord, file: FileDBRecord) -> tuple[bool, str]:
+def check_user_permission(user: UserRecord, owner: UserRecord, file: FileRecord) -> tuple[bool, str]:
     if user.is_admin:
         return True, ""
     

lfss/src/log.py

@@ -64,6 +64,7 @@ def get_logger(
     name = 'default', 
     log_home = pathlib.Path(DATA_HOME) / 'logs', 
     level = 'DEBUG',
+    term_level = 'INFO',
     file_handler_type: _fh_T = 'rotate', 
     global_instance = True
     )->BaseLogger:
@@ -77,6 +78,7 @@ def get_logger(
         formatter = logging.Formatter(format_str)
         console_handler = logging.StreamHandler()
         console_handler.setFormatter(formatter)
+        console_handler.setLevel(term_level)
         logger.addHandler(console_handler)
 
         # format_str_plain = format_str.replace(BCOLORS.LIGHTMAGENTA, '').replace(BCOLORS.OKCYAN, '').replace(BCOLORS.ENDC, '')

lfss/src/server.py

@@ -7,26 +7,29 @@ from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
 from fastapi.middleware.cors import CORSMiddleware
 import mimesniff
 
-import json
+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
 from .utils import ensure_uri_compnents
-from .database import Database, DBUserRecord, DECOY_USER, FileDBRecord, check_user_permission, FileReadPermission
+from .database import Database, UserRecord, DECOY_USER, FileRecord, check_user_permission, FileReadPermission
 
-logger = get_logger("server")
+logger = get_logger("server", term_level="DEBUG")
+logger_failed_request = get_logger("failed_requests", term_level="INFO")
 conn = Database()
+req_conn = RequestDB()
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     global conn
-    await conn.init()
+    await asyncio.gather(conn.init(), req_conn.init())
     yield
-    await conn.commit()
-    await conn.close()
+    await asyncio.gather(conn.commit(), req_conn.commit())
+    await asyncio.gather(conn.close(), req_conn.close())
 
 def handle_exception(fn):
     @wraps(fn)
@@ -34,14 +37,14 @@ def handle_exception(fn):
         try:
             return await fn(*args, **kwargs)
         except Exception as e:
-            logger.error(f"Error in {fn.__name__}: {e}")
             if isinstance(e, HTTPException): raise e
-            elif isinstance(e, StorageExceededError): raise HTTPException(status_code=413, detail=str(e))
-            elif isinstance(e, PermissionError): raise HTTPException(status_code=403, detail=str(e))
-            elif isinstance(e, InvalidPathError): raise HTTPException(status_code=400, detail=str(e))
-            elif isinstance(e, FileNotFoundError): raise HTTPException(status_code=404, detail=str(e))
-            elif isinstance(e, FileExistsError): raise HTTPException(status_code=409, detail=str(e))
-            else: raise HTTPException(status_code=500, detail=str(e))
+            if isinstance(e, StorageExceededError): raise HTTPException(status_code=413, detail=str(e))
+            if isinstance(e, PermissionError): raise HTTPException(status_code=403, detail=str(e))
+            if isinstance(e, InvalidPathError): raise HTTPException(status_code=400, detail=str(e))
+            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))
     return wrapper
 
 async def get_credential_from_params(request: Request):
@@ -66,7 +69,7 @@ async def get_current_user(
         raise HTTPException(status_code=401, detail="Invalid token")
     return user
 
-app = FastAPI(docs_url="/_docs", redoc_url=None, lifespan=lifespan)
+app = FastAPI(docs_url=None, redoc_url=None, lifespan=lifespan)
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -75,10 +78,35 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+@app.middleware("http")
+async def log_requests(request: Request, call_next):
+
+    start_time = time.perf_counter()
+    response: Response = await call_next(request)
+    end_time = time.perf_counter()
+    response_time = end_time - start_time
+    response.headers["X-Response-Time"] = str(response_time)
+
+    if response.status_code >= 400:
+        logger_failed_request.error(f"{request.method} {request.url.path} {response.status_code}")
+        
+    await req_conn.log_request(
+        request.method, request.url.path, response.status_code, response_time,
+        headers = dict(request.headers), 
+        query = dict(request.query_params), 
+        client = request.client, 
+        request_size = int(request.headers.get("Content-Length", 0)),
+        response_size = int(response.headers.get("Content-Length", 0))
+    )
+    await req_conn.ensure_commit_once()
+
+    return response
+
 router_fs = APIRouter(prefix="")
 
 @router_fs.get("/{path:path}")
-async def get_file(path: str, download = False, user: DBUserRecord = Depends(get_current_user)):
+@handle_exception
+async def get_file(path: str, download = False, user: UserRecord = Depends(get_current_user)):
     path = ensure_uri_compnents(path)
 
     # handle directory query
@@ -130,7 +158,8 @@ async def get_file(path: str, download = False, user: DBUserRecord = Depends(get
         return await send(None, "inline")
 
 @router_fs.put("/{path:path}")
-async def put_file(request: Request, path: str, user: DBUserRecord = Depends(get_current_user)):
+@handle_exception
+async def put_file(request: Request, path: str, user: UserRecord = Depends(get_current_user)):
     path = ensure_uri_compnents(path)
     if user.id == 0:
         logger.debug("Reject put request from DECOY_USER")
@@ -159,20 +188,20 @@ async def put_file(request: Request, path: str, user: DBUserRecord = Depends(get
     logger.debug(f"Content-Type: {content_type}")
     if content_type == "application/json":
         body = await request.json()
-        await handle_exception(conn.save_file)(user.id, path, json.dumps(body).encode('utf-8'))
+        await conn.save_file(user.id, path, 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")
-        await handle_exception(conn.save_file)(user.id, path, await file.read())
+        await conn.save_file(user.id, path, await file.read())
     elif content_type == "application/octet-stream":
         body = await request.body()
-        await handle_exception(conn.save_file)(user.id, path, body)
+        await conn.save_file(user.id, path, body)
     else:
         body = await request.body()
-        await handle_exception(conn.save_file)(user.id, path, body)
+        await conn.save_file(user.id, path, body)
 
     # https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Methods/PUT
     if exists_flag:
@@ -185,7 +214,8 @@ async def put_file(request: Request, path: str, user: DBUserRecord = Depends(get
         }, content=json.dumps({"url": path}))
 
 @router_fs.delete("/{path:path}")
-async def delete_file(path: str, user: DBUserRecord = Depends(get_current_user)):
+@handle_exception
+async def delete_file(path: str, user: UserRecord = Depends(get_current_user)):
     path = ensure_uri_compnents(path)
     if user.id == 0:
         raise HTTPException(status_code=401, detail="Permission denied")
@@ -207,7 +237,8 @@ async def delete_file(path: str, user: DBUserRecord = Depends(get_current_user))
 router_api = APIRouter(prefix="/_api")
 
 @router_api.get("/bundle")
-async def bundle_files(path: str, user: DBUserRecord = Depends(get_current_user)):
+@handle_exception
+async def bundle_files(path: str, user: UserRecord = Depends(get_current_user)):
     logger.info(f"GET bundle({path}), user: {user.username}")
     if user.id == 0:
         raise HTTPException(status_code=401, detail="Permission denied")
@@ -218,7 +249,7 @@ async def bundle_files(path: str, user: DBUserRecord = Depends(get_current_user)
         path = path[1:]
     
     owner_records_cache = {}     # cache owner records, ID -> UserRecord
-    async def is_access_granted(file_record: FileDBRecord):
+    async def is_access_granted(file_record: FileRecord):
         owner_id = file_record.owner_id
         owner = owner_records_cache.get(owner_id, None)
         if owner is None:
@@ -249,7 +280,8 @@ async def bundle_files(path: str, user: DBUserRecord = Depends(get_current_user)
     )
 
 @router_api.get("/fmeta")
-async def get_file_meta(path: str, user: DBUserRecord = Depends(get_current_user)):
+@handle_exception
+async def get_file_meta(path: str, user: UserRecord = Depends(get_current_user)):
     logger.info(f"GET meta({path}), user: {user.username}")
     if path.endswith("/"):
         raise HTTPException(status_code=400, detail="Invalid path")
@@ -260,11 +292,12 @@ async def get_file_meta(path: str, user: DBUserRecord = Depends(get_current_user
     return file_record
 
 @router_api.post("/fmeta")
+@handle_exception
 async def update_file_meta(
     path: str, 
     perm: Optional[int] = None, 
     new_path: Optional[str] = None,
-    user: DBUserRecord = Depends(get_current_user)
+    user: UserRecord = Depends(get_current_user)
     ):
     if user.id == 0:
         raise HTTPException(status_code=401, detail="Permission denied")
@@ -280,7 +313,7 @@ async def update_file_meta(
     
     if perm is not None:
         logger.info(f"Update permission of {path} to {perm}")
-        await handle_exception(conn.file.set_file_record)(
+        await conn.file.set_file_record(
             url = file_record.url, 
             permission = FileReadPermission(perm)
         )
@@ -288,18 +321,18 @@ async def update_file_meta(
     if new_path is not None:
         new_path = ensure_uri_compnents(new_path)
         logger.info(f"Update path of {path} to {new_path}")
-        await handle_exception(conn.move_file)(path, new_path)
+        await conn.move_file(path, new_path)
 
     return Response(status_code=200, content="OK")
     
 @router_api.get("/whoami")
-async def whoami(user: DBUserRecord = Depends(get_current_user)):
+@handle_exception
+async def whoami(user: UserRecord = Depends(get_current_user)):
     if user.id == 0:
         raise HTTPException(status_code=401, detail="Login required")
     user.credential = "__HIDDEN__"
     return user
 
-
 # order matters
 app.include_router(router_api)
 app.include_router(router_fs)

lfss/src/stat.py

@@ -0,0 +1,65 @@
+from typing import Optional, Any
+import aiosqlite
+from .config import DATA_HOME
+from .utils import debounce_async
+
+class RequestDB:
+    conn: aiosqlite.Connection
+    def __init__(self):
+        self.db = DATA_HOME / 'requests.db'
+
+    async def init(self):
+        self.conn = await aiosqlite.connect(self.db)
+        await self.conn.execute('''
+            CREATE TABLE IF NOT EXISTS requests (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                time TIMESTAMP DEFAULT CURRENT_TIMESTAMP, 
+                method TEXT,
+                path TEXT,
+                headers TEXT,
+                query TEXT,
+                client TEXT,
+                duration REAL, 
+                request_size INTEGER, 
+                response_size INTEGER, 
+                status INTEGER
+            )
+        ''')
+
+    async def close(self):
+        await self.conn.close()
+    
+    async def commit(self):
+        await self.conn.commit()
+    
+    @debounce_async(0.1)
+    async def ensure_commit_once(self):
+        await self.commit()
+    
+    async def __aenter__(self):
+        return self
+    
+    async def __aexit__(self, exc_type, exc, tb):
+        await self.commit()
+    
+    async def log_request(
+        self, method: str, path: str, 
+        status: int, duration: float,
+        headers: Optional[Any] = None, 
+        query: Optional[Any] = None, 
+        client: Optional[Any] = None,
+        request_size: int = 0,
+        response_size: int = 0
+        ) -> int:
+        method = str(method).upper()
+        headers = str(headers)
+        query = str(query)
+        client = str(client)
+        async with self.conn.execute('''
+            INSERT INTO requests (
+                method, path, headers, query, client, duration, request_size, response_size, status
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ''', (method, path, headers, query, client, duration, request_size, response_size, status)) as cursor:
+            assert cursor.lastrowid is not None
+            return cursor.lastrowid
+        

lfss/src/utils.py

@@ -1,4 +1,7 @@
+from typing import Callable
 import urllib.parse
+import asyncio
+import functools
 
 def encode_uri_compnents(path: str):
     """
@@ -21,4 +24,29 @@ def ensure_uri_compnents(path: str):
     """
     Ensure the path components are safe to use
     """
-    return encode_uri_compnents(decode_uri_compnents(path))
+    return encode_uri_compnents(decode_uri_compnents(path))
+
+def debounce_async(delay: float = 0):
+    """
+    Decorator to debounce the async function (procedure)
+    The function must return None
+    """
+    def debounce_wrap(func):
+        # https://docs.python.org/3/library/asyncio-task.html#asyncio.Task.cancel
+        async def delayed_func(*args, **kwargs):
+            await asyncio.sleep(delay)
+            await func(*args, **kwargs)
+
+        task_record: asyncio.Task | None = None
+        @functools.wraps(func)
+        async def wrapper(*args, **kwargs):
+            nonlocal task_record
+            if task_record is not None:
+                task_record.cancel()
+            task_record = asyncio.create_task(delayed_func(*args, **kwargs))
+            try:
+                await task_record
+            except asyncio.CancelledError:
+                pass
+        return wrapper
+    return debounce_wrap

{lfss-0.3.0.dist-info → lfss-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lfss
-Version: 0.3.0
+Version: 0.3.2
 Summary: Lightweight file storage service
 Home-page: https://github.com/MenxLi/lfss
 Author: li, mengxun

{lfss-0.3.0.dist-info → lfss-0.3.2.dist-info}/RECORD

@@ -2,25 +2,26 @@ Readme.md,sha256=8ZAADV1K20gEDhwiL-Qq_rBAePlwWQn8c5uJ_X7OCIg,1128
 docs/Known_issues.md,sha256=rfdG3j1OJF-59S9E06VPyn0nZKbW-ybPxkoZ7MEZWp8,81
 docs/Permission.md,sha256=EY1Y4tT5PDdHDb2pXsVgMAJXxkUihTZfPT0_z7Q53FA,1485
 frontend/api.js,sha256=D_MaQlmBGzzSR30a23Kh3DxPeF8MpKYe5uXSb9srRTU,7281
-frontend/index.html,sha256=JP6Sd-1JdlEfWQ4fjmSs-CrNw-2iq1RlS55SuXJq5lg,2019
+frontend/index.html,sha256=VPJDs2LG8ep9kjlsKzjWzpN9vc1VGgdvOUlNTZWyQoQ,2088
 frontend/popup.css,sha256=VzkjG1ZTLxhHMtTyobnlvqYmVsTmdbJJed2Pu1cc06c,1007
 frontend/popup.js,sha256=dH5n7C2Vo9gCsMfQ4ajL4D1ETl0Wk9rIldxUb7x0f_c,4634
-frontend/scripts.js,sha256=lp5EalD0Ikpy4Tw5dhEORsOB_44Z88I4gJI4e8C1SDE,18175
+frontend/scripts.js,sha256=1Cd5cb84SWolozA0Q1MpWaXiAqeQ5R6qZyk7gdoRPgU,18266
 frontend/styles.css,sha256=Ql_-W5dbh6LlJL2Kez8qsqPSF2fckFgmOYP4SMfKJVs,4065
 frontend/utils.js,sha256=biE2te5ezswZyuwlDTYbHEt7VWKfCcUrusNt1lHjkLw,2263
 lfss/cli/panel.py,sha256=iGdVmdWYjA_7a78ZzWEB_3ggIOBeUKTzg6F5zLaB25c,1401
 lfss/cli/serve.py,sha256=bO3GT0kuylMGN-7bZWP4e71MlugGZ_lEMkYaYld_Ntg,985
 lfss/cli/user.py,sha256=906MIQO1mr4XXzPpT8Kfri1G61bWlgjDzIglxypQ7z0,3251
 lfss/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lfss/client/api.py,sha256=SSrs1rafALmK_Pc7MfqeQm0El1rcGc-dXP8H6XMpmrY,3455
+lfss/client/api.py,sha256=VBiU-JxGaN6S-fXYD_KvzG7FsGBIUzZ5IisJJSMooDk,3443
 lfss/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lfss/src/config.py,sha256=mc8QoiWoPgiZ5JnSvKBH8jWbp5uLSyG3l5boDiQPXS0,325
-lfss/src/database.py,sha256=6LDXaYO_dFuR8KrOPcvXS1_-sszFwvpyhbXaS2MTpq4,27576
+lfss/src/database.py,sha256=jsDcDrc5r4mnuFiY10YEMwIRMvx6c4PY4LN9C9BinDA,27854
 lfss/src/error.py,sha256=S5ui3tJ0uKX4EZnt2Db-KbDmJXlECI_OY95cNMkuegc,218
-lfss/src/log.py,sha256=7mRHFwhx7GKtm_cRryoEIlRQhHTLQC3Qd-N81YsoKao,5174
-lfss/src/server.py,sha256=BeJ15QxN66k7UETCkUe03NDIIKWYdGYRtOMjox_CxIQ,11872
-lfss/src/utils.py,sha256=MrjKc8W2Y7AbgVGadSNAA50tRMbGYWRrA4KUhOCwuUU,694
-lfss-0.3.0.dist-info/METADATA,sha256=xTlFyG26uh5X1Vk0PDGj6tPW_6ExBgMEQ3AK3SCyYLQ,1787
-lfss-0.3.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-lfss-0.3.0.dist-info/entry_points.txt,sha256=nUIJhenyZbcymvPVhrzV7SAtRhd7O52DflbRrpQUC04,110
-lfss-0.3.0.dist-info/RECORD,,
+lfss/src/log.py,sha256=qNE04sHoZ2rMbQ5dR2zT7Xaz1KVAfYp5hKpWJX42S9g,5244
+lfss/src/server.py,sha256=6sXOXGPF3s1h38zNS6mP4N9qEXZ8biEAx-wSdpCNlwg,13010
+lfss/src/stat.py,sha256=Y28h-TNhQJzsAlCP4E7mnJmgISXGIECvCCRPq_73ZN0,2043
+lfss/src/utils.py,sha256=qCXFTIcfnVsdg6zvoEDhZniLTU-WiG23SILXzUG1XBw,1613
+lfss-0.3.2.dist-info/METADATA,sha256=qHYqmRzikIGgohOabShmfj1T9lQHa6iIPAF2BV2wSVo,1787
+lfss-0.3.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+lfss-0.3.2.dist-info/entry_points.txt,sha256=nUIJhenyZbcymvPVhrzV7SAtRhd7O52DflbRrpQUC04,110
+lfss-0.3.2.dist-info/RECORD,,