lfss 0.5.2__tar.gz → 0.7.0__tar.gz

{lfss-0.5.2 → lfss-0.7.0}/PKG-INFO

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

{lfss-0.5.2 → lfss-0.7.0}/lfss/cli/balance.py

@@ -24,10 +24,10 @@ def barriered(func):
 @barriered
 async def move_to_external(f_id: str, flag: str = ''):
     async with aiosqlite.connect(db_file, timeout = 60) as c:
-        async with c.execute( "SELECT data FROM fdata WHERE file_id = ?", (f_id,)) as cursor:
+        async with c.execute( "SELECT data FROM blobs.fdata WHERE file_id = ?", (f_id,)) as cursor:
             blob_row = await cursor.fetchone()
             if blob_row is None:
-                print(f"{flag}File {f_id} not found in fdata")
+                print(f"{flag}File {f_id} not found in blobs.fdata")
                 return
         await c.execute("BEGIN")
         blob: bytes = blob_row[0]
@@ -35,7 +35,7 @@ async def move_to_external(f_id: str, flag: str = ''):
             async with aiofiles.open(LARGE_BLOB_DIR / f_id, 'wb') as f:
                 await f.write(blob)
             await c.execute( "UPDATE fmeta SET external = 1 WHERE file_id = ?", (f_id,))
-            await c.execute( "DELETE FROM fdata WHERE file_id = ?", (f_id,))
+            await c.execute( "DELETE FROM blobs.fdata WHERE file_id = ?", (f_id,))
             await c.commit()
             print(f"{flag}Moved {f_id} to external storage")
         except Exception as e:
@@ -56,7 +56,7 @@ async def move_to_internal(f_id: str, flag: str = ''):
 
         await c.execute("BEGIN")
         try:
-            await c.execute("INSERT INTO fdata (file_id, data) VALUES (?, ?)", (f_id, blob))
+            await c.execute("INSERT INTO blobs.fdata (file_id, data) VALUES (?, ?)", (f_id, blob))
             await c.execute("UPDATE fmeta SET external = 0 WHERE file_id = ?", (f_id,))
             await c.commit()
             (LARGE_BLOB_DIR / f_id).unlink(missing_ok=True)

{lfss-0.5.2 → lfss-0.7.0}/lfss/cli/cli.py

@@ -14,7 +14,7 @@ def parse_arguments():
     sp_upload.add_argument("dst", help="Destination path", type=str)
     sp_upload.add_argument("-j", "--jobs", type=int, default=1, help="Number of concurrent uploads")
     sp_upload.add_argument("--interval", type=float, default=0, help="Interval between files, only works with directory upload")
-    sp_upload.add_argument("--conflict", choices=["overwrite", "abort", "skip"], default="abort", help="Conflict resolution")
+    sp_upload.add_argument("--conflict", choices=["overwrite", "abort", "skip", "skip-ahead"], default="abort", help="Conflict resolution")
     sp_upload.add_argument("--permission", type=FileReadPermission, default=FileReadPermission.UNSET, help="File permission")
     sp_upload.add_argument("--retries", type=int, default=0, help="Number of retries, only works with directory upload")
 

{lfss-0.5.2 → lfss-0.7.0}/lfss/client/api.py

@@ -2,7 +2,7 @@ from typing import Optional, Literal
 import os
 import requests
 import urllib.parse
-from lfss.src.database import (
+from lfss.src.datatype import (
     FileReadPermission, FileRecord, DirectoryRecord, UserRecord, PathContents
     )
 
@@ -34,8 +34,18 @@ class Connector:
             return response
         return f
 
-    def put(self, path: str, file_data: bytes, permission: int | FileReadPermission = 0, conflict: Literal['overwrite', 'abort', 'skip'] = 'abort'):
+    def put(self, path: str, file_data: bytes, permission: int | FileReadPermission = 0, conflict: Literal['overwrite', 'abort', 'skip', 'skip-ahead'] = 'abort'):
         """Uploads a file to the specified path."""
+        assert isinstance(file_data, bytes), "file_data must be 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}
+
         response = self._fetch('PUT', path, search_params={
             'permission': int(permission),
             'conflict': conflict
@@ -45,9 +55,19 @@ class Connector:
         )
         return response.json()
     
-    def put_json(self, path: str, data: dict, permission: int | FileReadPermission = 0, conflict: Literal['overwrite', 'abort', 'skip'] = 'abort'):
+    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"
+        assert isinstance(data, dict), "data must be a dict"
+
+        # 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}
+
         response = self._fetch('PUT', path, search_params={
             'permission': int(permission),
             'conflict': conflict

{lfss-0.5.2 → lfss-0.7.0}/lfss/sql/init.sql

@@ -1,7 +1,13 @@
+PRAGMA journal_mode=MEMROY;
+PRAGMA temp_store=MEMORY;
+PRAGMA page_size=4096;
+PRAGMA synchronous=NORMAL;
+PRAGMA case_sensitive_like=ON;
+
 CREATE TABLE IF NOT EXISTS user (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
-    username VARCHAR(255) UNIQUE NOT NULL,
-    credential VARCHAR(255) NOT NULL,
+    username VARCHAR(256) UNIQUE NOT NULL,
+    credential VARCHAR(256) NOT NULL,
     is_admin BOOLEAN DEFAULT FALSE,
     create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP, 
     last_active TIMESTAMP DEFAULT CURRENT_TIMESTAMP, 
@@ -10,22 +16,18 @@ CREATE TABLE IF NOT EXISTS user (
 );
 
 CREATE TABLE IF NOT EXISTS fmeta (
-    url VARCHAR(512) PRIMARY KEY,
+    url VARCHAR(1024) PRIMARY KEY,
     owner_id INTEGER NOT NULL,
-    file_id VARCHAR(256) NOT NULL,
+    file_id CHAR(32) NOT NULL,
     file_size INTEGER,
     create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP, 
     access_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
     permission INTEGER DEFAULT 0, 
-    external BOOLEAN DEFAULT FALSE,
+    external BOOLEAN DEFAULT FALSE, 
+    mime_type VARCHAR(256) DEFAULT 'application/octet-stream',
     FOREIGN KEY(owner_id) REFERENCES user(id)
 );
 
-CREATE TABLE IF NOT EXISTS fdata (
-    file_id VARCHAR(256) PRIMARY KEY,
-    data BLOB
-);
-
 CREATE TABLE IF NOT EXISTS usize (
     user_id INTEGER PRIMARY KEY,
     size INTEGER DEFAULT 0
@@ -36,3 +38,8 @@ CREATE INDEX IF NOT EXISTS idx_fmeta_url ON fmeta(url);
 CREATE INDEX IF NOT EXISTS idx_user_username ON user(username);
 
 CREATE INDEX IF NOT EXISTS idx_user_credential ON user(credential);
+
+CREATE TABLE IF NOT EXISTS blobs.fdata (
+    file_id CHAR(32) PRIMARY KEY,
+    data BLOB
+);

lfss-0.7.0/lfss/sql/pragma.sql

@@ -0,0 +1,8 @@
+PRAGMA journal_mode=DELETE;
+PRAGMA synchronous=NORMAL;
+PRAGMA case_sensitive_like=ON;
+PRAGMA page_size=4096;
+
+PRAGMA blobs.journal_mode=DELETE;
+PRAGMA blobs.synchronous=NORMAL;
+PRAGMA blobs.page_size=16384;

{lfss-0.5.2 → lfss-0.7.0}/lfss/src/config.py

@@ -7,6 +7,7 @@ DATA_HOME = Path(os.environ.get('LFSS_DATA', __default_dir))
 if not DATA_HOME.exists():
     DATA_HOME.mkdir()
     print(f"[init] Created data home at {DATA_HOME}")
+DATA_HOME = DATA_HOME.resolve().absolute()
 LARGE_BLOB_DIR = DATA_HOME / 'large_blobs'
 LARGE_BLOB_DIR.mkdir(exist_ok=True)
 

{lfss-0.5.2 → lfss-0.7.0}/lfss/src/database.py

@@ -1,19 +1,20 @@
 
 from typing import Optional, overload, Literal, AsyncIterable
 from abc import ABC, abstractmethod
+import os
 
 import urllib.parse
 from pathlib import Path
-import dataclasses, hashlib, uuid
+import hashlib, uuid
 from contextlib import asynccontextmanager
 from functools import wraps
-from enum import IntEnum
 import zipfile, io, asyncio
 
 import aiosqlite, aiofiles
 import aiofiles.os
 from asyncio import Lock
 
+from .datatype import UserRecord, FileReadPermission, FileRecord, DirectoryRecord, PathContents
 from .config import DATA_HOME, LARGE_BLOB_DIR
 from .log import get_logger
 from .utils import decode_uri_compnents
@@ -57,33 +58,18 @@ class DBConnBase(ABC):
         """Should return self"""
         global _g_conn
         if _g_conn is None:
-            _g_conn = await aiosqlite.connect(DATA_HOME / 'lfss.db')
+            if not os.environ.get('SQLITE_TEMPDIR'):
+                os.environ['SQLITE_TEMPDIR'] = str(DATA_HOME)
+            # large blobs are stored in a separate database, should be more efficient
+            _g_conn = await aiosqlite.connect(DATA_HOME / 'index.db')
+            async with _g_conn.cursor() as c:
+                await c.execute(f"ATTACH DATABASE ? AS blobs", (str(DATA_HOME/'blobs.db'), ))
             await execute_sql(_g_conn, 'pragma.sql')
             await execute_sql(_g_conn, 'init.sql')
 
     async def commit(self):
         await self.conn.commit()
 
-class FileReadPermission(IntEnum):
-    UNSET = 0           # not set
-    PUBLIC = 1          # accessible by anyone
-    PROTECTED = 2       # accessible by any user
-    PRIVATE = 3         # accessible by owner only (including admin)
-
-@dataclasses.dataclass
-class UserRecord:
-    id: int
-    username: str
-    credential: str
-    is_admin: bool
-    create_time: str
-    last_active: str
-    max_storage: int
-    permission: 'FileReadPermission'
-
-    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 = UserRecord(0, 'decoy', 'decoy', False, '2021-01-01 00:00:00', '2021-01-01 00:00:00', 0, FileReadPermission.PRIVATE)
 class UserConn(DBConnBase):
 
@@ -174,37 +160,6 @@ class UserConn(DBConnBase):
         await self.conn.execute("DELETE FROM user WHERE username = ?", (username, ))
         self.logger.info(f"Delete user {username}")
 
-@dataclasses.dataclass
-class FileRecord:
-    url: str
-    owner_id: int
-    file_id: str      # defines mapping from fmata to fdata
-    file_size: int
-    create_time: str
-    access_time: str
-    permission: FileReadPermission
-    external: bool
-
-    def __str__(self):
-        return  f"File {self.url} (owner={self.owner_id}, created at {self.create_time}, accessed at {self.access_time}, " + \
-                f"file_id={self.file_id}, permission={self.permission}, size={self.file_size}, external={self.external})"
-
-@dataclasses.dataclass
-class DirectoryRecord:
-    url: str
-    size: int
-    create_time: str = ""
-    update_time: str = ""
-    access_time: str = ""
-
-    def __str__(self):
-        return f"Directory {self.url} (size={self.size})"
-
-@dataclasses.dataclass
-class PathContents:
-    dirs: list[DirectoryRecord]
-    files: list[FileRecord]
-    
 class FileConn(DBConnBase):
 
     @staticmethod
@@ -213,28 +168,6 @@ class FileConn(DBConnBase):
     
     async def init(self):
         await super().init()
-        # backward compatibility, since 0.2.1
-        async with self.conn.execute("SELECT * FROM user") as cursor:
-            res = await cursor.fetchall()
-        for r in res:
-            async with self.conn.execute("SELECT user_id FROM usize WHERE user_id = ?", (r[0], )) as cursor:
-                size = await cursor.fetchone()
-            if size is None:
-                async with self.conn.execute("SELECT SUM(file_size) FROM fmeta WHERE owner_id = ?", (r[0], )) as cursor:
-                    size = await cursor.fetchone()
-                if size is not None and size[0] is not None:
-                    await self._user_size_inc(r[0], size[0])
-        
-        # backward compatibility, since 0.5.0
-        # 'external' means the file is not stored in the database, but in the external storage
-        async with self.conn.execute("SELECT * FROM fmeta") as cursor:
-            res = await cursor.fetchone()
-        if res and len(res) < 8:
-            self.logger.info("Updating fmeta table")
-            await self.conn.execute('''
-            ALTER TABLE fmeta ADD COLUMN external BOOLEAN DEFAULT FALSE
-            ''')
-
         return self
     
     async def get_file_record(self, url: str) -> Optional[FileRecord]:
@@ -372,43 +305,42 @@ class FileConn(DBConnBase):
         assert res is not None
         return res[0] or 0
     
+    @atomic
+    async def update_file_record(
+        self, url, owner_id: Optional[int] = None, permission: Optional[FileReadPermission] = None
+        ):
+        old = await self.get_file_record(url)
+        assert old is not None, f"File {url} not found"
+        if owner_id is None:
+            owner_id = old.owner_id
+        if permission is None:
+            permission = old.permission
+        await self.conn.execute(
+            "UPDATE fmeta SET owner_id = ?, permission = ? WHERE url = ?", 
+            (owner_id, int(permission), url)
+            )
+        self.logger.info(f"Updated file {url}")
+    
     @atomic
     async def set_file_record(
         self, url: str, 
-        owner_id: Optional[int] = None, 
-        file_id: Optional[str] = None, 
-        file_size: Optional[int] = None, 
-        permission: Optional[ FileReadPermission ] = None, 
-        external: Optional[bool] = None
+        owner_id: int, 
+        file_id:str, 
+        file_size: int, 
+        permission: FileReadPermission, 
+        external: bool, 
+        mime_type: str
         ):
-
-        old = await self.get_file_record(url)
-        if old is not None:
-            self.logger.debug(f"Updating fmeta {url}: permission={permission}, owner_id={owner_id}")
-            # should delete the old blob if file_id is changed
-            assert file_id is None, "Cannot update file id"
-            assert file_size is None, "Cannot update file size"
-            assert external is None, "Cannot update external"
-
-            if owner_id is None: owner_id = old.owner_id
-            if permission is None: permission = old.permission
-            await self.conn.execute(
-                """
-                UPDATE fmeta SET owner_id = ?, permission = ?, 
-                access_time = CURRENT_TIMESTAMP WHERE url = ?
-                """, (owner_id, int(permission), url))
-            self.logger.info(f"File {url} updated")
-        else:
-            self.logger.debug(f"Creating fmeta {url}: permission={permission}, owner_id={owner_id}, file_id={file_id}, file_size={file_size}, external={external}")
-            if permission is None:
-                permission = FileReadPermission.UNSET
-            assert owner_id is not None and file_id is not None and file_size is not None and external is not None
-            await self.conn.execute(
-                "INSERT INTO fmeta (url, owner_id, file_id, file_size, permission, external) VALUES (?, ?, ?, ?, ?, ?)", 
-                (url, owner_id, file_id, file_size, int(permission), external)
-                )
-            await self._user_size_inc(owner_id, file_size)
-            self.logger.info(f"File {url} created")
+        self.logger.debug(f"Creating fmeta {url}: permission={permission}, owner_id={owner_id}, file_id={file_id}, file_size={file_size}, external={external}, mime_type={mime_type}")
+        if permission is None:
+            permission = FileReadPermission.UNSET
+        assert owner_id is not None and file_id is not None and file_size is not None and external is not None
+        await self.conn.execute(
+            "INSERT INTO fmeta (url, owner_id, file_id, file_size, permission, external, mime_type) VALUES (?, ?, ?, ?, ?, ?, ?)", 
+            (url, owner_id, file_id, file_size, int(permission), external, mime_type)
+            )
+        await self._user_size_inc(owner_id, file_size)
+        self.logger.info(f"File {url} created")
     
     @atomic
     async def move_file(self, old_url: str, new_url: str):
@@ -479,7 +411,7 @@ class FileConn(DBConnBase):
     
     @atomic
     async def set_file_blob(self, file_id: str, blob: bytes):
-        await self.conn.execute("INSERT OR REPLACE INTO fdata (file_id, data) VALUES (?, ?)", (file_id, blob))
+        await self.conn.execute("INSERT OR REPLACE INTO blobs.fdata (file_id, data) VALUES (?, ?)", (file_id, blob))
     
     @atomic
     async def set_file_blob_external(self, file_id: str, stream: AsyncIterable[bytes])->int:
@@ -496,7 +428,7 @@ class FileConn(DBConnBase):
         return size_sum
     
     async def get_file_blob(self, file_id: str) -> Optional[bytes]:
-        async with self.conn.execute("SELECT data FROM fdata WHERE file_id = ?", (file_id, )) as cursor:
+        async with self.conn.execute("SELECT data FROM blobs.fdata WHERE file_id = ?", (file_id, )) as cursor:
             res = await cursor.fetchone()
         if res is None:
             return None
@@ -515,11 +447,11 @@ class FileConn(DBConnBase):
     
     @atomic
     async def delete_file_blob(self, file_id: str):
-        await self.conn.execute("DELETE FROM fdata WHERE file_id = ?", (file_id, ))
+        await self.conn.execute("DELETE FROM blobs.fdata WHERE file_id = ?", (file_id, ))
     
     @atomic
     async def delete_file_blobs(self, file_ids: list[str]):
-        await self.conn.execute("DELETE FROM fdata WHERE file_id IN ({})".format(','.join(['?'] * len(file_ids))), file_ids)
+        await self.conn.execute("DELETE FROM blobs.fdata WHERE file_id IN ({})".format(','.join(['?'] * len(file_ids))), file_ids)
 
 def validate_url(url: str, is_file = True):
     prohibited_chars = ['..', ';', "'", '"', '\\', '\0', '\n', '\r', '\t', '\x0b', '\x0c']
@@ -587,7 +519,8 @@ class Database:
     async def save_file(
         self, u: int | str, url: str, 
         blob: bytes | AsyncIterable[bytes], 
-        permission: FileReadPermission = FileReadPermission.UNSET
+        permission: FileReadPermission = FileReadPermission.UNSET, 
+        mime_type: str = 'application/octet-stream'
         ):
         """
         if file_size is not provided, the blob must be bytes
@@ -619,7 +552,7 @@ class Database:
                 await self.file.set_file_blob(f_id, blob)
                 await self.file.set_file_record(
                     url, owner_id=user.id, file_id=f_id, file_size=file_size, 
-                    permission=permission, external=False)
+                    permission=permission, external=False, mime_type=mime_type)
                 await self.user.set_active(user.username)
         else:
             assert isinstance(blob, AsyncIterable)
@@ -631,7 +564,7 @@ class Database:
                     raise StorageExceededError(f"Unable to save file, user {user.username} has storage limit of {user.max_storage}, used {user_size_used}, requested {file_size}")
                 await self.file.set_file_record(
                     url, owner_id=user.id, file_id=f_id, file_size=file_size, 
-                    permission=permission, external=True)
+                    permission=permission, external=True, mime_type=mime_type)
                 await self.user.set_active(user.username)
 
     async def read_file_stream(self, url: str) -> AsyncIterable[bytes]:

lfss-0.7.0/lfss/src/datatype.py

@@ -0,0 +1,55 @@
+from enum import IntEnum
+import dataclasses
+
+class FileReadPermission(IntEnum):
+    UNSET = 0           # not set
+    PUBLIC = 1          # accessible by anyone
+    PROTECTED = 2       # accessible by any user
+    PRIVATE = 3         # accessible by owner only (including admin)
+
+@dataclasses.dataclass
+class UserRecord:
+    id: int
+    username: str
+    credential: str
+    is_admin: bool
+    create_time: str
+    last_active: str
+    max_storage: int
+    permission: 'FileReadPermission'
+
+    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})"
+
+@dataclasses.dataclass
+class FileRecord:
+    url: str
+    owner_id: int
+    file_id: str      # defines mapping from fmata to blobs.fdata
+    file_size: int
+    create_time: str
+    access_time: str
+    permission: FileReadPermission
+    external: bool
+    mime_type: str
+
+    def __str__(self):
+        return  f"File {self.url} [{self.mime_type}] (owner={self.owner_id}, created at {self.create_time}, accessed at {self.access_time}, " + \
+                f"file_id={self.file_id}, permission={self.permission}, size={self.file_size}, external={self.external})"
+
+@dataclasses.dataclass
+class DirectoryRecord:
+    url: str
+    size: int
+    create_time: str = ""
+    update_time: str = ""
+    access_time: str = ""
+
+    def __str__(self):
+        return f"Directory {self.url} (size={self.size})"
+
+@dataclasses.dataclass
+class PathContents:
+    dirs: list[DirectoryRecord]
+    files: list[FileRecord]
+    

{lfss-0.5.2 → lfss-0.7.0}/lfss/src/server.py

@@ -15,7 +15,7 @@ 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_BLOB_DIR, LARGE_FILE_BYTES
+from .config import MAX_BUNDLE_BYTES, MAX_FILE_BYTES, LARGE_FILE_BYTES
 from .utils import ensure_uri_compnents, format_last_modified, now_stamp
 from .database import Database, UserRecord, DECOY_USER, FileRecord, check_user_permission, FileReadPermission
 
@@ -142,12 +142,10 @@ async def get_file(path: str, download = False, user: UserRecord = Depends(get_c
     
     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 conn.read_file(path)
-            if media_type is None:
-                media_type, _ = mimetypes.guess_type(fname)
-            if media_type is None:
-                media_type = mimesniff.what(fblob)
             return Response(
                 content=fblob, media_type=media_type, headers={
                     "Content-Disposition": f"{disposition}; filename={fname}", 
@@ -155,12 +153,7 @@ async def get_file(path: str, download = False, user: UserRecord = Depends(get_c
                     "Last-Modified": format_last_modified(file_record.create_time)
                 }
             )
-        
         else:
-            if media_type is None:
-                media_type, _ = mimetypes.guess_type(fname)
-            if media_type is None:
-                media_type = mimesniff.what(str((LARGE_BLOB_DIR / file_record.file_id).absolute()))
             return StreamingResponse(
                 await conn.read_file_stream(path), media_type=media_type, headers={
                     "Content-Disposition": f"{disposition}; filename={fname}", 
@@ -228,14 +221,24 @@ async def put_file(
         blobs = await request.body()
     else:
         blobs = await request.body()
+    
+    # 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():
             chunk_size = 16 * 1024 * 1024    # 16MB
             for b in range(0, len(blobs), chunk_size):
                 yield blobs[b:b+chunk_size]
-        await conn.save_file(user.id, path, blob_reader(), permission = FileReadPermission(permission))
+        await conn.save_file(user.id, path, blob_reader(), permission = FileReadPermission(permission), mime_type = mime_t)
     else:
-        await conn.save_file(user.id, path, blobs, permission = FileReadPermission(permission))
+        await conn.save_file(user.id, path, blobs, permission = FileReadPermission(permission), mime_type=mime_t)
 
     # https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Methods/PUT
     if exists_flag:
@@ -353,7 +356,7 @@ async def update_file_meta(
         
         if perm is not None:
             logger.info(f"Update permission of {path} to {perm}")
-            await conn.file.set_file_record(
+            await conn.file.update_file_record(
                 url = file_record.url, 
                 permission = FileReadPermission(perm)
             )

{lfss-0.5.2 → lfss-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "lfss"
-version = "0.5.2"
+version = "0.7.0"
 description = "Lightweight file storage service"
 authors = ["li, mengxun <limengxun45@outlook.com>"]
 readme = "Readme.md"

lfss-0.5.2/lfss/sql/pragma.sql

@@ -1,5 +0,0 @@
-PRAGMA journal_mode=MEMROY;
-PRAGMA temp_store=MEMORY;
-PRAGMA page_size=8192;
-PRAGMA synchronous=NORMAL;
-PRAGMA case_sensitive_like=ON;