lfss 0.11.4__tar.gz → 0.11.6__tar.gz

{lfss-0.11.4 → lfss-0.11.6}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: lfss
-Version: 0.11.4
-Summary: Lightweight file storage service
+Version: 0.11.6
+Summary: Lite file storage service
 Home-page: https://github.com/MenxLi/lfss
 Author: Li, Mengxun
 Author-email: mengxunli@whu.edu.cn

lfss-0.11.6/docs/Client.md

@@ -0,0 +1,40 @@
+
+# Client-side CLI tools
+
+To install python CLI tools without dependencies (to avoid conflicts with your existing packages):
+```sh
+pip install requests
+pip install lfss --no-deps
+```
+
+Then set the `LFSS_ENDPOINT`, `LFSS_TOKEN` environment variables, 
+then you can use the following commands:
+```sh
+# Check current user information
+lfss whoami
+
+# Query a path
+lfss query remote/file[/or_dir/]
+
+# List directories of a specified path
+lfss list-dirs remote/dir/
+
+# List files of a specified path, 
+# with pagination and sorting
+lfss list-files --offset 0 --limit 100 --order access_time remote/dir/
+
+# Upload a file
+lfss upload local/file.txt remote/file.txt
+
+# Upload a directory, note the ending slashes
+lfss upload local/dir/ remote/dir/
+
+# Download a file
+lfss download remote/file.txt local/file.txt
+
+# Download a directory, with verbose output and 8 concurrent jobs
+# Overwrite existing files
+lfss download -v -j 8 --conflict overwrite remote/dir/ local/dir/   
+```
+
+More commands can be found using `lfss-cli --help`.

{lfss-0.11.4 → lfss-0.11.6}/docs/changelog.md

@@ -1,5 +1,26 @@
 ## 0.11
 
+### 0.11.6
+- Hint copy and move success for frontend.
+- Add query user info and list peers api.
+- Add user with random password if not specified.
+
+### 0.11.5
+- Script entry default to client CLI. 
+- Fix single file download name deduce with decoding.
+- Fix code misspell (minor).
+
+### 0.11.4
+- Fix SQL query for LIKE clause to escape special characters in path.
+
+### 0.11.3
+- Add method to get multiple files, maybe with content, at once.
+- Allow copy directory files that the user is not the owner of.
+- Environment variables to set origin and disable file logging.
+- Fix error handling for some endpoints.
+- Redirect CLI error output to stderr.
+- Increase thumb image size to 64x64.
+
 ### 0.11.2
 - Improve frontend directory upload feedback. 
 - Set default large file threashold to 1M. 

{lfss-0.11.4 → lfss-0.11.6}/frontend/api.js

@@ -249,6 +249,7 @@ export default class Connector {
     /**
      * @param {string} path - the path to the file directory, should ends with '/'
      * @returns {Promise<PathListResponse>} - the promise of the request
+     * NOTE: will deprecated in future
      */
     async listPath(path){
         path = this._sanitizeDirPath(path);

{lfss-0.11.4 → lfss-0.11.6}/frontend/scripts.js

@@ -347,6 +347,7 @@ async function refreshFileList(){
                             console.log("Moving", dirurl, "to", dstPath);
                             conn.move(dirurl, dstPath)
                                 .then(() => {
+                                    showPopup('Successfully moved path.', {level: 'success', timeout: 3000});
                                     refreshFileList();
                                 }, 
                                 (err) => {
@@ -371,6 +372,7 @@ async function refreshFileList(){
                             console.log("Copying", dirurl, "to", dstPath);
                             conn.copy(dirurl, dstPath)
                                 .then(() => {
+                                    showPopup('Successfully copied path.', {level: 'success', timeout: 3000});
                                     refreshFileList();
                                 }, 
                                 (err) => {

{lfss-0.11.4 → lfss-0.11.6}/lfss/api/__init__.py

@@ -2,7 +2,7 @@ import os, time, pathlib
 from threading import Lock
 from .connector import Connector
 from ..eng.datatype import FileRecord
-from ..eng.utils import decode_uri_compnents
+from ..eng.utils import decode_uri_components
 from ..eng.bounded_pool import BoundedThreadPoolExecutor
 
 def upload_file(
@@ -105,7 +105,7 @@ def download_file(
     assert not src_url.endswith('/'), "Source URL must not end with a slash."
     while this_try <= n_retries:
         if os.path.isdir(file_path):
-            fname = src_url.split('/')[-1]
+            fname = decode_uri_components(src_url.split('/')[-1])
             file_path = os.path.join(file_path, fname)
 
         if not overwrite and os.path.exists(file_path):
@@ -176,7 +176,7 @@ def download_directory(
         with _counter_lock:
             _counter += 1
             this_count = _counter
-            dst_path = f"{directory}{os.path.relpath(decode_uri_compnents(src_url), decode_uri_compnents(src_path))}"
+            dst_path = f"{directory}{os.path.relpath(decode_uri_components(src_url), decode_uri_components(src_path))}"
             if verbose:
                 print(f"[{this_count}/{file_count}] Downloading {src_url} to {dst_path}")
 

{lfss-0.11.4 → lfss-0.11.6}/lfss/api/connector.py

@@ -8,10 +8,10 @@ import urllib.parse
 from tempfile import SpooledTemporaryFile
 from lfss.eng.error import PathNotFoundError
 from lfss.eng.datatype import (
-    FileReadPermission, FileRecord, DirectoryRecord, UserRecord, PathContents, 
+    FileReadPermission, FileRecord, DirectoryRecord, UserRecord, PathContents, AccessLevel, 
     FileSortKey, DirSortKey
     )
-from lfss.eng.utils import ensure_uri_compnents
+from lfss.eng.utils import ensure_uri_components
 
 _default_endpoint = os.environ.get('LFSS_ENDPOINT', 'http://localhost:8000')
 _default_token = os.environ.get('LFSS_TOKEN', '')
@@ -74,7 +74,7 @@ class Connector:
     ):
         if path.startswith('/'):
             path = path[1:]
-        path = ensure_uri_compnents(path)
+        path = ensure_uri_components(path)
         def f(**kwargs):
             search_params_t = [
                 (k, str(v).lower() if isinstance(v, bool) else v)
@@ -316,4 +316,10 @@ class Connector:
     def whoami(self) -> UserRecord:
         """Gets information about the current user."""
         response = self._fetch_factory('GET', '_api/whoami')()
-        return UserRecord(**response.json())
+        return UserRecord(**response.json())
+
+    def list_peers(self, level: AccessLevel = AccessLevel.READ, incoming: bool = False) -> list[UserRecord]:
+        """List all users that have at least the given access level to the current user."""
+        response = self._fetch_factory('GET', '_api/list-peers', {'level': int(level), 'incoming': incoming})()
+        users = [UserRecord(**u) for u in response.json()]
+        return users

{lfss-0.11.4 → lfss-0.11.6}/lfss/cli/cli.py

@@ -1,8 +1,8 @@
 from pathlib import Path
 import argparse, typing, sys
 from lfss.api import Connector, upload_directory, upload_file, download_file, download_directory
-from lfss.eng.datatype import FileReadPermission, FileSortKey, DirSortKey
-from lfss.eng.utils import decode_uri_compnents
+from lfss.eng.datatype import FileReadPermission, FileSortKey, DirSortKey, AccessLevel
+from lfss.eng.utils import decode_uri_components, fmt_storage_size
 from . import catch_request_error, line_sep
 
 def parse_permission(s: str) -> FileReadPermission:
@@ -10,14 +10,27 @@ def parse_permission(s: str) -> FileReadPermission:
         if p.name.lower() == s.lower():
             return p
     raise ValueError(f"Invalid permission {s}")
+def parse_access_level(s: str) -> AccessLevel:
+    for p in AccessLevel:
+        if p.name.lower() == s.lower():
+            return p
+    raise ValueError(f"Invalid access level {s}")
 
 def parse_arguments():
     parser = argparse.ArgumentParser(description="Client-side command line interface, set LFSS_ENDPOINT and LFSS_TOKEN environment variables for authentication.")
 
     sp = parser.add_subparsers(dest="command", required=True)
 
+    # whoami
+    sp_whoami = sp.add_parser("whoami", help="Show current user information")
+
+    # list peers
+    sp_peers = sp.add_parser("peers", help="Query users that you have access to or users that have access to you")
+    sp_peers.add_argument('-l', "--level", type=parse_access_level, default=AccessLevel.READ, help="Access level filter")
+    sp_peers.add_argument('-i', '--incoming', action='store_true', help="List users that have access to you (rather than you have access to them")
+
     # upload
-    sp_upload = sp.add_parser("upload", help="Upload files")
+    sp_upload = sp.add_parser("upload", help="Upload file(s)")
     sp_upload.add_argument("src", help="Source file or directory", type=str)
     sp_upload.add_argument("dst", help="Destination url path", type=str)
     sp_upload.add_argument("-v", "--verbose", action="store_true", help="Verbose output")
@@ -28,7 +41,7 @@ def parse_arguments():
     sp_upload.add_argument("--retries", type=int, default=0, help="Number of retries")
 
     # download
-    sp_download = sp.add_parser("download", help="Download files")
+    sp_download = sp.add_parser("download", help="Download file(s)")
     sp_download.add_argument("src", help="Source url path", type=str)
     sp_download.add_argument("dst", help="Destination file or directory", type=str)
     sp_download.add_argument("-v", "--verbose", action="store_true", help="Verbose output")
@@ -38,7 +51,7 @@ def parse_arguments():
     sp_download.add_argument("--retries", type=int, default=0, help="Number of retries")
 
     # query
-    sp_query = sp.add_parser("query", help="Query files or directories metadata from the server")
+    sp_query = sp.add_parser("query", help="Query file or directories metadata from the server")
     sp_query.add_argument("path", help="Path to query", nargs="*", type=str)
 
     # list directories
@@ -65,7 +78,28 @@ def parse_arguments():
 def main():
     args = parse_arguments()
     connector = Connector()
-    if args.command == "upload":
+    if args.command == "whoami":
+        with catch_request_error():
+            user = connector.whoami()
+            print("Username:", user.username)
+            print("User ID:", user.id)
+            print("Is Admin:", bool(user.is_admin))
+            print("Max Storage:", fmt_storage_size(user.max_storage))
+            print("Default Permission:", user.permission.name)
+            print("Created At:", user.create_time)
+            print("Last Active:", user.last_active)
+    
+    elif args.command == "peers":
+        with catch_request_error():
+            users = connector.list_peers(level=args.level, incoming=args.incoming)
+            if not args.incoming:
+                print(f"Peers that you have {args.level.name} access to:")
+            else:
+                print(f"Peers that have {args.level.name} access to you:")
+            for i, u in enumerate(line_sep(users)):
+                print(f"[{i+1}] {u.username} (id={u.id})")
+
+    elif args.command == "upload":
         src_path = Path(args.src)
         if src_path.is_dir():
             failed_upload = upload_directory(
@@ -143,7 +177,7 @@ def main():
                 order_desc=args.reverse,
             )
             for i, f in enumerate(line_sep(res)):
-                f.url = decode_uri_compnents(f.url)
+                f.url = decode_uri_components(f.url)
                 print(f"[{i+1}] {f if args.long else f.url}")
 
             if len(res) == args.limit:
@@ -160,7 +194,7 @@ def main():
                 order_desc=args.reverse,
             )
             for i, d in enumerate(line_sep(res)):
-                d.url = decode_uri_compnents(d.url)
+                d.url = decode_uri_components(d.url)
                 print(f"[{i+1}] {d if args.long else d.url}")
 
             if len(res) == args.limit:

{lfss-0.11.4 → lfss-0.11.6}/lfss/cli/user.py

@@ -1,4 +1,4 @@
-import argparse, asyncio, os
+import argparse, asyncio, os, secrets
 from contextlib import asynccontextmanager
 from .cli import parse_permission, FileReadPermission
 from ..eng.utils import parse_storage_size, fmt_storage_size
@@ -18,10 +18,10 @@ async def _main():
     sp = parser.add_subparsers(dest='subparser_name', required=True)
     sp_add = sp.add_parser('add')
     sp_add.add_argument('username', type=str)
-    sp_add.add_argument('password', type=str)
+    sp_add.add_argument('password', nargs='?', type=str, default=None)
     sp_add.add_argument('--admin', action='store_true', help='Set user as admin')
     sp_add.add_argument("--permission", type=parse_permission, default=FileReadPermission.UNSET, help="File permission, can be public, protected, private, or unset")
-    sp_add.add_argument('--max-storage', type=parse_storage_size, default="1G", help="Maximum storage size, e.g. 1G, 100M, 10K")
+    sp_add.add_argument('--max-storage', type=parse_storage_size, default="10G", help="Maximum storage size, e.g. 1G, 100M, 10K, default is 10G")
     
     sp_delete = sp.add_parser('delete')
     sp_delete.add_argument('username', type=str)
@@ -58,6 +58,9 @@ async def _main():
     
     if args.subparser_name == 'add':
         async with get_uconn() as uconn:
+            if args.password is None:
+                passwd = secrets.token_urlsafe(16)
+                args.password = passwd
             await uconn.create_user(args.username, args.password, args.admin, max_storage=args.max_storage, permission=args.permission)
             user = await uconn.get_user(args.username)
             assert user is not None

{lfss-0.11.4 → lfss-0.11.6}/lfss/eng/database.py

@@ -21,7 +21,7 @@ from .datatype import (
     )
 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, static_vars
+from .utils import decode_uri_components, hash_credential, concurrent_wrap, debounce_async, static_vars
 from .error import *
 
 class DBObjectBase(ABC):
@@ -163,25 +163,31 @@ class UserConn(DBObjectBase):
             return AccessLevel.NONE
         return AccessLevel(res[0])
     
-    async def list_peer_users(self, src_user: int | str, level: AccessLevel) -> list[UserRecord]:
+    async def list_peer_users(self, user: int | str, level: AccessLevel, incoming = False) -> list[UserRecord]:
         """
-        List all users that src_user can do [AliasLevel] to, with level >= level, 
-        Note: the returned list does not include src_user and is not apporiate for admin (who has all permissions for all users)
+        if not incoming:
+            List all users that user can do [AliasLevel] to, with level >= level, 
+        else:
+            List all users that can do [AliasLevel] to user, with level >= level
+        Note: the returned list does not include user and is not apporiate for admin (who has all permissions for all users)
         """
         assert int(level) > AccessLevel.NONE, f"Invalid level, {level}"
-        match src_user:
+        aim_field = 'src_user_id' if incoming else 'dst_user_id'
+        query_field = 'dst_user_id' if incoming else 'src_user_id'
+    
+        match user:
             case int():
-                await self.cur.execute("""
+                await self.cur.execute(f"""
                     SELECT * FROM user WHERE id IN (
-                        SELECT dst_user_id FROM upeer WHERE src_user_id = ? AND access_level >= ?
+                        SELECT {aim_field} FROM upeer WHERE {query_field} = ? AND access_level >= ?
                     )
-                """, (src_user, int(level)))
+                """, (user, int(level)))
             case str():
-                await self.cur.execute("""
+                await self.cur.execute(f"""
                     SELECT * FROM user WHERE id IN (
-                        SELECT dst_user_id FROM upeer WHERE src_user_id = (SELECT id FROM user WHERE username = ?) AND access_level >= ?
+                        SELECT {aim_field} FROM upeer WHERE {query_field} = (SELECT id FROM user WHERE username = ?) AND access_level >= ?
                     )
-                """, (src_user, int(level)))
+                """, (user, int(level)))
             case _:
                 raise ValueError("Invalid arguments")
         res = await self.cur.fetchall()
@@ -1108,7 +1114,7 @@ class Database:
         async def data_iter():
             async for (r, blob) in self.iter_dir(top_url, None):
                 rel_path = r.url[len(top_url):]
-                rel_path = decode_uri_compnents(rel_path)
+                rel_path = decode_uri_components(rel_path)
                 b_iter: AsyncIterable[bytes]
                 if isinstance(blob, bytes):
                     async def blob_iter(): yield blob
@@ -1138,7 +1144,7 @@ class Database:
         with zipfile.ZipFile(buffer, 'w') as zf:
             async for (r, blob) in self.iter_dir(top_url, None):
                 rel_path = r.url[len(top_url):]
-                rel_path = decode_uri_compnents(rel_path)
+                rel_path = decode_uri_components(rel_path)
                 if r.external:
                     assert isinstance(blob, AsyncIterable)
                     zf.writestr(rel_path, b''.join([chunk async for chunk in blob]))

{lfss-0.11.4 → lfss-0.11.6}/lfss/eng/utils.py

@@ -21,19 +21,19 @@ async def copy_file(source: str|pathlib.Path, destination: str|pathlib.Path):
 def hash_credential(username: str, password: str):
     return hashlib.sha256(f"{username}:{password}".encode()).hexdigest()
 
-def encode_uri_compnents(path: str):
+def encode_uri_components(path: str):
     path_sp = path.split("/")
     mapped = map(lambda x: urllib.parse.quote(x), path_sp)
     return "/".join(mapped)
 
-def decode_uri_compnents(path: str):
+def decode_uri_components(path: str):
     path_sp = path.split("/")
     mapped = map(lambda x: urllib.parse.unquote(x), path_sp)
     return "/".join(mapped)
 
-def ensure_uri_compnents(path: str):
+def ensure_uri_components(path: str):
     """ Ensure the path components are safe to use """
-    return encode_uri_compnents(decode_uri_compnents(path))
+    return encode_uri_components(decode_uri_components(path))
 
 class TaskManager:
     def __init__(self):

{lfss-0.11.4 → lfss-0.11.6}/lfss/svc/app_dav.py

@@ -11,7 +11,7 @@ from ..eng.error import *
 from ..eng.config import DATA_HOME, DEBUG_MODE
 from ..eng.datatype import UserRecord, FileRecord, DirectoryRecord, AccessLevel
 from ..eng.database import FileConn, UserConn, check_path_permission
-from ..eng.utils import ensure_uri_compnents, decode_uri_compnents, format_last_modified, static_vars
+from ..eng.utils import ensure_uri_components, decode_uri_components, format_last_modified, static_vars
 from .app_base import *
 from .common_impl import copy_impl
 
@@ -36,7 +36,7 @@ async def eval_path(path: str) -> tuple[ptype, str, Optional[FileRecord | Direct
         and should end with / if it is a directory, otherwise it is a file
     record is the FileRecord or DirectoryRecord object, it is None if the path does not exist
     """
-    path = decode_uri_compnents(path)
+    path = decode_uri_components(path)
     if "://" in path:
         if not path.startswith("http://") and not path.startswith("https://"):
             raise HTTPException(status_code=400, detail="Bad Request, unsupported protocol")
@@ -47,7 +47,7 @@ async def eval_path(path: str) -> tuple[ptype, str, Optional[FileRecord | Direct
         assert path.startswith(route_prefix), "Path should start with the route prefix, got: " + path
         path = path[len(route_prefix):]
 
-    path = ensure_uri_compnents(path)
+    path = ensure_uri_components(path)
     if path.startswith("/"): path = path[1:]
 
     # path now is url-safe and without leading slash
@@ -160,7 +160,7 @@ async def create_file_xml_element(frecord: FileRecord) -> ET.Element:
     href.text = f"/{frecord.url}"
     propstat = ET.SubElement(file_el, f"{{{DAV_NS}}}propstat")
     prop = ET.SubElement(propstat, f"{{{DAV_NS}}}prop")
-    ET.SubElement(prop, f"{{{DAV_NS}}}displayname").text = decode_uri_compnents(frecord.url.split("/")[-1])
+    ET.SubElement(prop, f"{{{DAV_NS}}}displayname").text = decode_uri_components(frecord.url.split("/")[-1])
     ET.SubElement(prop, f"{{{DAV_NS}}}resourcetype")
     ET.SubElement(prop, f"{{{DAV_NS}}}getcontentlength").text = str(frecord.file_size)
     ET.SubElement(prop, f"{{{DAV_NS}}}getlastmodified").text = format_last_modified(frecord.create_time)
@@ -178,7 +178,7 @@ async def create_dir_xml_element(drecord: DirectoryRecord) -> ET.Element:
     href.text = f"/{drecord.url}"
     propstat = ET.SubElement(dir_el, f"{{{DAV_NS}}}propstat")
     prop = ET.SubElement(propstat, f"{{{DAV_NS}}}prop")
-    ET.SubElement(prop, f"{{{DAV_NS}}}displayname").text = decode_uri_compnents(drecord.url.split("/")[-2])
+    ET.SubElement(prop, f"{{{DAV_NS}}}displayname").text = decode_uri_components(drecord.url.split("/")[-2])
     ET.SubElement(prop, f"{{{DAV_NS}}}resourcetype").append(ET.Element(f"{{{DAV_NS}}}collection"))
     if drecord.size >= 0:
         ET.SubElement(prop, f"{{{DAV_NS}}}getlastmodified").text = format_last_modified(drecord.create_time)
@@ -211,7 +211,7 @@ async def dav_options(request: Request, path: str):
 @handle_exception
 async def dav_propfind(request: Request, path: str, user: UserRecord = Depends(registered_user), body: Optional[ET.Element] = Depends(xml_request_body)):
     if path.startswith("/"): path = path[1:]
-    path = ensure_uri_compnents(path)
+    path = ensure_uri_components(path)
 
     if body and DEBUG_MODE:
         print("Propfind-body:", ET.tostring(body, encoding="utf-8", method="xml"))

{lfss-0.11.4 → lfss-0.11.6}/lfss/svc/app_native.py

@@ -5,10 +5,10 @@ from fastapi import Depends, Request, Response, UploadFile, Query
 from fastapi.responses import StreamingResponse, JSONResponse
 from fastapi.exceptions import HTTPException 
 
-from ..eng.utils import ensure_uri_compnents
+from ..eng.utils import ensure_uri_components
 from ..eng.config import MAX_MEM_FILE_BYTES
 from ..eng.connection_pool import unique_cursor
-from ..eng.database import check_file_read_permission, check_path_permission, FileConn, delayed_log_access
+from ..eng.database import check_file_read_permission, check_path_permission, FileConn, delayed_log_access, UserConn
 from ..eng.datatype import (
     FileReadPermission, UserRecord, AccessLevel, 
     FileSortKey, DirSortKey
@@ -83,7 +83,7 @@ async def delete_file(path: str, user: UserRecord = Depends(registered_user)):
 @handle_exception
 async def bundle_files(path: str, user: UserRecord = Depends(registered_user)):
     logger.info(f"GET bundle({path}), user: {user.username}")
-    path = ensure_uri_compnents(path)
+    path = ensure_uri_components(path)
     if not path.endswith("/"):
         raise HTTPException(status_code=400, detail="Path must end with /")
     if path[0] == "/":      # adapt to both /path and path
@@ -123,7 +123,7 @@ async def bundle_files(path: str, user: UserRecord = Depends(registered_user)):
 @handle_exception
 async def get_file_meta(path: str, user: UserRecord = Depends(registered_user)):
     logger.info(f"GET meta({path}), user: {user.username}")
-    path = ensure_uri_compnents(path)
+    path = ensure_uri_components(path)
     is_file = not path.endswith("/")
     async with unique_cursor() as cur:
         fconn = FileConn(cur)
@@ -147,7 +147,7 @@ async def update_file_meta(
     new_path: Optional[str] = None,
     user: UserRecord = Depends(registered_user)
     ):
-    path = ensure_uri_compnents(path)
+    path = ensure_uri_components(path)
     if path.startswith("/"):
         path = path[1:]
 
@@ -162,7 +162,7 @@ async def update_file_meta(
             )
     
         if new_path is not None:
-            new_path = ensure_uri_compnents(new_path)
+            new_path = ensure_uri_components(new_path)
             logger.info(f"Update path of {path} to {new_path}")
             await db.move_file(path, new_path, user)
     
@@ -170,7 +170,7 @@ async def update_file_meta(
     else:
         assert perm is None, "Permission is not supported for directory"
         if new_path is not None:
-            new_path = ensure_uri_compnents(new_path)
+            new_path = ensure_uri_components(new_path)
             logger.info(f"Update path of {path} to {new_path}")
             # will raise duplicate path error if same name path exists in the new path
             await db.move_dir(path, new_path, user)
@@ -185,6 +185,16 @@ async def copy_file(
     ):
     return await copy_impl(src_path = src, dst_path = dst, op_user = user)
 
+@router_api.get("/list-peers")
+@handle_exception
+async def list_peers(user: UserRecord = Depends(registered_user), level: AccessLevel = AccessLevel.READ, incoming: bool = False):
+    async with unique_cursor() as conn:
+        uconn = UserConn(conn)
+        peer_users = await uconn.list_peer_users(user.id, level, incoming=incoming)
+    for u in peer_users:
+        u.credential = "__HIDDEN__"
+    return peer_users
+
 async def validate_path_read_permission(path: str, user: UserRecord):
     if not path.endswith("/"):
         raise HTTPException(status_code=400, detail="Path must end with /")
@@ -194,7 +204,7 @@ async def validate_path_read_permission(path: str, user: UserRecord):
 @handle_exception
 async def count_files(path: str, flat: bool = False, user: UserRecord = Depends(registered_user)):
     await validate_path_read_permission(path, user)
-    path = ensure_uri_compnents(path)
+    path = ensure_uri_components(path)
     async with unique_cursor() as conn:
         fconn = FileConn(conn)
         return { "count": await fconn.count_dir_files(url = path, flat = flat) }
@@ -206,7 +216,7 @@ async def list_files(
     flat: bool = False, user: UserRecord = Depends(registered_user)
     ):
     await validate_path_read_permission(path, user)
-    path = ensure_uri_compnents(path)
+    path = ensure_uri_components(path)
     async with unique_cursor() as conn:
         fconn = FileConn(conn)
         return await fconn.list_dir_files(
@@ -219,7 +229,7 @@ async def list_files(
 @handle_exception
 async def count_dirs(path: str, user: UserRecord = Depends(registered_user)):
     await validate_path_read_permission(path, user)
-    path = ensure_uri_compnents(path)
+    path = ensure_uri_components(path)
     async with unique_cursor() as conn:
         fconn = FileConn(conn)
         return { "count": await fconn.count_path_dirs(url = path) }
@@ -231,7 +241,7 @@ async def list_dirs(
     skim: bool = True, user: UserRecord = Depends(registered_user)
     ):
     await validate_path_read_permission(path, user)
-    path = ensure_uri_compnents(path)
+    path = ensure_uri_components(path)
     async with unique_cursor() as conn:
         fconn = FileConn(conn)
         return await fconn.list_path_dirs(
@@ -263,7 +273,7 @@ async def get_multiple_files(
     upath2path = OrderedDict[str, str]()
     for p in path:
         p_ = p if not p.startswith("/") else p[1:]
-        upath2path[ensure_uri_compnents(p_)] = p
+        upath2path[ensure_uri_components(p_)] = p
     upaths = list(upath2path.keys())
 
     # get files

{lfss-0.11.4 → lfss-0.11.6}/lfss/svc/common_impl.py

@@ -6,7 +6,7 @@ from ..eng.connection_pool import unique_cursor
 from ..eng.datatype import UserRecord, FileRecord, PathContents, AccessLevel, FileReadPermission
 from ..eng.database import FileConn, UserConn, delayed_log_access, check_file_read_permission, check_path_permission
 from ..eng.thumb import get_thumb
-from ..eng.utils import format_last_modified, ensure_uri_compnents
+from ..eng.utils import format_last_modified, ensure_uri_components
 from ..eng.config import CHUNK_SIZE, DEBUG_MODE
 
 from .app_base import skip_request_log, db, logger
@@ -100,7 +100,7 @@ async def get_impl(
     thumb: bool = False,
     is_head = False,
     ):
-    path = ensure_uri_compnents(path)
+    path = ensure_uri_components(path)
     if path.startswith("/"): path = path[1:]
 
     # handle directory query
@@ -194,7 +194,7 @@ async def put_file_impl(
     conflict: Literal["overwrite", "skip", "abort"] = "overwrite",
     permission: int = 0,
     ):
-    path = ensure_uri_compnents(path)
+    path = ensure_uri_components(path)
     assert not path.endswith("/"), "Path must not end with /"
 
     access_level = await check_path_permission(path, user)
@@ -249,7 +249,7 @@ async def post_file_impl(
     conflict: Literal["overwrite", "skip", "abort"] = "overwrite",
     permission: int = 0,
 ):
-    path = ensure_uri_compnents(path)
+    path = ensure_uri_components(path)
     assert not path.endswith("/"), "Path must not end with /"
 
     access_level = await check_path_permission(path, user)
@@ -288,7 +288,7 @@ async def post_file_impl(
     }, content=json.dumps({"url": path}))
 
 async def delete_impl(path: str, user: UserRecord):
-    path = ensure_uri_compnents(path)
+    path = ensure_uri_components(path)
     if await check_path_permission(path, user) < AccessLevel.WRITE:
         raise HTTPException(status_code=403, detail="Permission denied")
     
@@ -307,8 +307,8 @@ async def delete_impl(path: str, user: UserRecord):
 async def copy_impl(
     op_user: UserRecord, src_path: str, dst_path: str,
 ):
-    src_path = ensure_uri_compnents(src_path)
-    dst_path = ensure_uri_compnents(dst_path)
+    src_path = ensure_uri_components(src_path)
+    dst_path = ensure_uri_components(dst_path)
     copy_type = "file" if not src_path[-1] == "/" else "directory"
     if (src_path[-1] == "/") != (dst_path[-1] == "/"):
         raise HTTPException(status_code=400, detail="Source and destination must be same type")

{lfss-0.11.4 → lfss-0.11.6}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "lfss"
-version = "0.11.4"
-description = "Lightweight file storage service"
+version = "0.11.6"
+description = "Lite file storage service"
 authors = ["Li, Mengxun <mengxunli@whu.edu.cn>"]
 readme = "Readme.md"
 homepage = "https://github.com/MenxLi/lfss"
@@ -30,10 +30,11 @@ webdavclient3 = "*"
 lfss-serve = "lfss.cli.serve:main"
 lfss-user = "lfss.cli.user:main"
 lfss-panel = "lfss.cli.panel:main"
-lfss-cli = "lfss.cli.cli:main"
 lfss-vacuum = "lfss.cli.vacuum:main"
 lfss-balance = "lfss.cli.balance:main"
 lfss-log = "lfss.cli.log:main"
+lfss-cli = "lfss.cli.cli:main"
+lfss = "lfss.cli.cli:main"
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]