lfss 0.11.5__py3-none-any.whl → 0.12.0__py3-none-any.whl

docs/Client.md

@@ -10,28 +10,28 @@ pip install lfss --no-deps
 Then set the `LFSS_ENDPOINT`, `LFSS_TOKEN` environment variables, 
 then you can use the following commands:
 ```sh
-# Query a path
-lfss query remote/file[/or_dir/]
+# Check current user information
+lfss whoami
 
-# List directories of a specified path
-lfss list-dirs remote/dir/
+# Query a path
+lfss i remote/file[/or_dir/]
 
-# List files of a specified path, 
+# List a specified path, 
 # with pagination and sorting
-lfss list-files --offset 0 --limit 100 --order access_time remote/dir/
+lfss ls remote/dir/ --offset 0 --limit 100 --order access_time 
 
 # Upload a file
-lfss upload local/file.txt remote/file.txt
+lfss up local/file.txt remote/file.txt
 
 # Upload a directory, note the ending slashes
-lfss upload local/dir/ remote/dir/
+lfss up local/dir/ remote/dir/
 
 # Download a file
-lfss download remote/file.txt local/file.txt
+lfss down remote/file.txt local/file.txt
 
-# Download a directory, with verbose output and 8 concurrent jobs
+# Download a directory, with 8 concurrent jobs
 # Overwrite existing files
-lfss download -v -j 8 --conflict overwrite remote/dir/ local/dir/   
+lfss down remote/dir/ local/dir/ -j 8 --conflict overwrite  
 ```
 
-More commands can be found using `lfss-cli --help`.
+More commands can be found using `lfss --help`.

docs/changelog.md

@@ -1,5 +1,18 @@
+## 0.12
+
+### 0.12.0
+- Change default script to client CLI
+- Client CLI default to verbose output
+- Client CLI subcommand rename and alias
+- Add delete path and more error handling for client CLI
+
 ## 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.

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);

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/api/__init__.py

@@ -75,7 +75,7 @@ def upload_directory(
             this_count = _counter
             dst_path = f"{path}{os.path.relpath(file_path, directory)}"
             if verbose:
-                print(f"[{this_count}] Uploading {file_path} to {dst_path}")
+                print(f"[{this_count}] {file_path} -> {dst_path}")
 
         if not (res:=upload_file(
             c, file_path, dst_path, 
@@ -178,7 +178,7 @@ def download_directory(
             this_count = _counter
             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}")
+                print(f"[{this_count}/{file_count}] {src_url} -> {dst_path}")
 
         if not (res:=download_file(
             c, src_url, dst_path, 

lfss/api/connector.py

@@ -1,14 +1,15 @@
 from __future__ import annotations
 from typing import Optional, Literal
 from collections.abc import Iterator
-import os, json
+import os
 import requests
 import requests.adapters
 import urllib.parse
 from tempfile import SpooledTemporaryFile
+from concurrent.futures import ThreadPoolExecutor, as_completed
 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_components
@@ -17,6 +18,13 @@ _default_endpoint = os.environ.get('LFSS_ENDPOINT', 'http://localhost:8000')
 _default_token = os.environ.get('LFSS_TOKEN', '')
 num_t = float | int
 
+def _p(x: str) -> str:
+    if x == '/':
+        return x
+    if x.startswith('/'):
+        x = x[1:]
+    return x
+
 class Connector:
     class Session:
         def __init__(
@@ -99,6 +107,7 @@ class Connector:
     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"
+        path = _p(path)
 
         # Skip ahead by checking if the file already exists
         if conflict == 'skip-ahead':
@@ -123,6 +132,7 @@ class Connector:
         using the POST method, with form-data/multipart.
         file can be a path to a file on disk, or bytes.
         """
+        path = _p(path)
 
         # Skip ahead by checking if the file already exists
         if conflict == 'skip-ahead':
@@ -155,6 +165,7 @@ class Connector:
         """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"
+        path = _p(path)
 
         # Skip ahead by checking if the file already exists
         if conflict == 'skip-ahead':
@@ -184,6 +195,7 @@ class Connector:
 
     def get(self, path: str) -> Optional[bytes]:
         """Downloads a file from the specified path."""
+        path = _p(path)
         response = self._get(path)
         if response is None: return None
         return response.content
@@ -193,6 +205,7 @@ class Connector:
         Downloads a partial file from the specified path.
         start and end are the byte offsets, both inclusive.
         """
+        path = _p(path)
         response = self._fetch_factory('GET', path, extra_headers={
             'Range': f"bytes={range_start if range_start >= 0 else ''}-{range_end if range_end >= 0 else ''}"
         })()
@@ -201,11 +214,13 @@ class Connector:
     
     def get_stream(self, path: str) -> Iterator[bytes]:
         """Downloads a file from the specified path, will raise PathNotFoundError if path not found."""
+        path = _p(path)
         response = self._get(path, stream=True)
         if response is None: raise PathNotFoundError("Path not found: " + path)
         return response.iter_content(chunk_size=1024)
 
     def get_json(self, path: str) -> Optional[dict]:
+        path = _p(path)
         response = self._get(path)
         if response is None: return None
         assert response.headers['Content-Type'] == 'application/json'
@@ -218,16 +233,18 @@ class Connector:
         """
         response = self._fetch_factory(
             'GET', '_api/get-multiple', 
-            {'path': paths, "skip_content": skip_content}
+            {'path': [_p(p) for p in paths], "skip_content": skip_content}
             )()
         return response.json()
     
     def delete(self, path: str):
         """Deletes the file at the specified path."""
+        path = _p(path)
         self._fetch_factory('DELETE', path)()
     
     def get_meta(self, path: str) -> Optional[FileRecord | DirectoryRecord]:
         """Gets the metadata for the file at the specified path."""
+        path = _p(path)
         try:
             response = self._fetch_factory('GET', '_api/meta', {'path': path})()
             if path.endswith('/'):
@@ -242,19 +259,9 @@ class Connector:
     def get_fmeta(self, path: str) -> Optional[FileRecord]: assert (f:=self.get_meta(path)) is None or isinstance(f, FileRecord); return f 
     def get_dmeta(self, path: str) -> Optional[DirectoryRecord]: assert (d:=self.get_meta(path)) is None or isinstance(d, DirectoryRecord); return d
     
-    def list_path(self, path: str) -> PathContents:
-        """ 
-        shorthand list with limited options, 
-        for large directories / more options, use list_files and list_dirs instead.
-        """
-        assert path.endswith('/')
-        response = self._fetch_factory('GET', path)()
-        dirs = [DirectoryRecord(**d) for d in response.json()['dirs']]
-        files = [FileRecord(**f) for f in response.json()['files']]
-        return PathContents(dirs=dirs, files=files)
-    
     def count_files(self, path: str, flat: bool = False) -> int:
         assert path.endswith('/')
+        path = _p(path)
         response = self._fetch_factory('GET', '_api/count-files', {'path': path, 'flat': flat})()
         return response.json()['count']
 
@@ -264,6 +271,7 @@ class Connector:
         flat: bool = False
     ) -> list[FileRecord]:
         assert path.endswith('/')
+        path = _p(path)
         response = self._fetch_factory('GET', "_api/list-files", {
             'path': path,
             'offset': offset, 'limit': limit, 'order_by': order_by, 'order_desc': order_desc, 'flat': flat
@@ -272,6 +280,7 @@ class Connector:
     
     def count_dirs(self, path: str) -> int:
         assert path.endswith('/')
+        path = _p(path)
         response = self._fetch_factory('GET', '_api/count-dirs', {'path': path})()
         return response.json()['count']
         
@@ -281,32 +290,97 @@ class Connector:
         skim: bool = True
     ) -> list[DirectoryRecord]:
         assert path.endswith('/')
+        path = _p(path)
         response = self._fetch_factory('GET', "_api/list-dirs", {
             'path': path,
             'offset': offset, 'limit': limit, 'order_by': order_by, 'order_desc': order_desc, 'skim': skim
         })()
         return [DirectoryRecord(**d) for d in response.json()]
+    
+    def list_path(
+        self, path: str, offset: int = 0, limit: int = 1000,
+        order_by: FileSortKey = '', order_desc: bool = False, 
+        _workers: int = 2
+    ) -> PathContents:
+        """ Aggregately lists both files and directories under the given path.  """
+        assert path.endswith('/')
+        path = _p(path)
+        if path == '/':
+            # handle root path separately
+            # TODO: change later
+            response = self._fetch_factory('GET', path)()
+            dirs = [DirectoryRecord(**d) for d in response.json()['dirs']]
+            files = [FileRecord(**f) for f in response.json()['files']]
+            return PathContents(dirs=dirs, files=files)
+
+        dirs: list[DirectoryRecord] = []
+        files: list[FileRecord] = []
+        with ThreadPoolExecutor(max_workers=_workers) as executor:
+            count_futures = {
+                executor.submit(self.count_dirs, path): 'dirs',
+                executor.submit(self.count_files, path, flat=False): 'files'
+            }
+            dir_count = 0
+            file_count = 0
+            for future in as_completed(count_futures):
+                if count_futures[future] == 'dirs':
+                    dir_count = future.result()
+                else:
+                    file_count = future.result()
+            dir_offset = offset
+            dir_limit = min(limit, max(0, dir_count - dir_offset))
+            file_offset = max(0, offset - dir_count)
+            file_limit = min(limit - dir_limit, max(0, file_count - file_offset))
+
+            dir_order_by = 'dirname' if order_by == 'url' else ''
+            file_order_by = order_by
+
+            def fetch_dirs():
+                nonlocal dirs
+                if dir_limit > 0:
+                    dirs = self.list_dirs(
+                        path, offset=dir_offset, limit=dir_limit, 
+                        order_by=dir_order_by, order_desc=order_desc
+                    )
+            def fetch_files():
+                nonlocal files
+                if file_limit > 0:
+                    files = self.list_files(
+                        path, offset=file_offset, limit=file_limit, 
+                        order_by=file_order_by, order_desc=order_desc, flat=False
+                    )
+            futures = [
+                executor.submit(fetch_dirs),
+                executor.submit(fetch_files)
+            ]
+            for future in as_completed(futures):
+                future.result()
+        return PathContents(dirs=dirs, files=files)
 
     def set_file_permission(self, path: str, permission: int | FileReadPermission):
         """Sets the file permission for the specified path."""
+        path = _p(path)
         self._fetch_factory('POST', '_api/meta', {'path': path, 'perm': int(permission)})(
             headers={'Content-Type': 'application/www-form-urlencoded'}
         )
         
     def move(self, path: str, new_path: str):
         """Move file or directory to a new path."""
+        path = _p(path); new_path = _p(new_path)
         self._fetch_factory('POST', '_api/meta', {'path': path, 'new_path': new_path})(
             headers = {'Content-Type': 'application/www-form-urlencoded'}
         )
     
     def copy(self, src: str, dst: str):
         """Copy file from src to dst."""
+        src = _p(src); dst = _p(dst)
         self._fetch_factory('POST', '_api/copy', {'src': src, 'dst': dst})(
             headers = {'Content-Type': 'application/www-form-urlencoded'}
         )
     
     def bundle(self, path: str) -> Iterator[bytes]:
         """Bundle a path into a zip file."""
+        path = _p(path)
         response = self._fetch_factory('GET', '_api/bundle', {'path': path})(
             headers = {'Content-Type': 'application/www-form-urlencoded'}, 
             stream = True
@@ -316,4 +390,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/cli/__init__.py

@@ -1,12 +1,16 @@
 from contextlib import contextmanager
-from typing import Iterable, TypeVar, Generator
+from typing import Iterable, TypeVar, Generator, Callable, Optional
 import requests, os
 
 @contextmanager
-def catch_request_error():
+def catch_request_error(error_code_handler: Optional[ dict[int, Callable[[requests.Response], None]] ] = None):
     try:
         yield
     except requests.RequestException as e:
+        if error_code_handler is not None:
+            if e.response is not None and e.response.status_code in error_code_handler:
+                error_code_handler[e.response.status_code](e.response)
+                return
         print(f"\033[31m[Request error]: {e}\033[0m")
         if e.response is not None:
             print(f"\033[91m[Error message]: {e.response.text}\033[0m")
@@ -15,13 +19,13 @@ T = TypeVar('T')
 def line_sep(iter: Iterable[T], enable=True, start=True, end=True, color="\033[90m") -> Generator[T, None, None]:
     screen_width = os.get_terminal_size().columns
     def print_ln():
-        print(color + "-" * screen_width + "\033[0m")
+        if enable: print(color + "-" * screen_width + "\033[0m")
 
-    if start and enable:
+    if start:
         print_ln()
     for i, line in enumerate(iter):
-        if enable and i > 0:
+        if i > 0:
             print_ln()
         yield line
-    if end and enable:
+    if end:
         print_ln()

lfss/cli/cli.py

@@ -1,26 +1,49 @@
 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_components
-from . import catch_request_error, line_sep
+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 as _line_sep
+
+# monkey patch to avoid printing line separators...may remove line_sep in the future
+line_sep = lambda *args, **kwargs: _line_sep(*args, enable=False, **kwargs)
 
 def parse_permission(s: str) -> FileReadPermission:
     for p in 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 default_error_handler_dict(path: str):
+    return {
+        401: lambda _: print(f"\033[31mUnauthorized\033[0m ({path})", file=sys.stderr),
+        403: lambda _: print(f"\033[31mForbidden\033[0m ({path})", file=sys.stderr),
+        404: lambda _: print(f"\033[31mNot found\033[0m ({path})", file=sys.stderr), 
+        409: lambda _: print(f"\033[31mConflict\033[0m ({path})", file=sys.stderr),
+    }
 
 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 a file or directory", aliases=["up"])
     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")
+    sp_upload.add_argument("-q", "--quiet", action="store_true", help="Quiet output, no progress info")
     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", "skip-ahead"], default="abort", help="Conflict resolution")
@@ -28,21 +51,35 @@ 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 a file or directory", aliases=["down"])
     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")
+    sp_download.add_argument("-q", "--quiet", action="store_true", help="Quiet output, no progress info")
     sp_download.add_argument("-j", "--jobs", type=int, default=1, help="Number of concurrent downloads")
     sp_download.add_argument("--interval", type=float, default=0, help="Interval between files, only works with directory download")
-    sp_download.add_argument("--overwrite", action="store_true", help="Overwrite existing files")
+    sp_download.add_argument("--conflict", choices=["overwrite", "skip"], default="abort", help="Conflict resolution, only works with file download")
     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.add_argument("path", help="Path to query", nargs="*", type=str)
+    sp_query = sp.add_parser("info", help="Query file or directories metadata from the server", aliases=["i"])
+    sp_query.add_argument("path", help="Path to query", nargs="+", type=str)
+
+    # delete
+    sp_delete = sp.add_parser("delete", help="Delete files or directories", aliases=["del"])
+    sp_delete.add_argument("path", help="Path to delete", nargs="+", type=str)
+    sp_delete.add_argument("-y", "--yes", action="store_true", help="Confirm deletion without prompt")
+
+    # aggregate list
+    sp_list = sp.add_parser("list", help="Aggregately list files and directories of a given path", aliases=["ls"])
+    sp_list.add_argument("path", help="Path to list", type=str)
+    sp_list.add_argument("--offset", type=int, default=0, help="Offset of the list")
+    sp_list.add_argument("--limit", type=int, default=100, help="Limit of the list")
+    sp_list.add_argument("-l", "--long", action="store_true", help="Detailed list, including all metadata")
+    sp_list.add_argument("--order", "--order-by", type=str, help="Order of the list", default="", choices=typing.get_args(FileSortKey))
+    sp_list.add_argument("--reverse", "--order-desc", action="store_true", help="Reverse the list order")
 
     # list directories
-    sp_list_d = sp.add_parser("list-dirs", help="List directories of a given path")
+    sp_list_d = sp.add_parser("list-d", help="List directories of a given path", aliases=["lsd"])
     sp_list_d.add_argument("path", help="Path to list", type=str)
     sp_list_d.add_argument("--offset", type=int, default=0, help="Offset of the list")
     sp_list_d.add_argument("--limit", type=int, default=100, help="Limit of the list")
@@ -51,7 +88,7 @@ def parse_arguments():
     sp_list_d.add_argument("--reverse", "--order-desc", action="store_true", help="Reverse the list order")
 
     # list files
-    sp_list_f = sp.add_parser("list-files", help="List files of a given path")
+    sp_list_f = sp.add_parser("list-f", help="List files of a given path", aliases=["lsf"])
     sp_list_f.add_argument("path", help="Path to list", type=str)
     sp_list_f.add_argument("--offset", type=int, default=0, help="Offset of the list")
     sp_list_f.add_argument("--limit", type=int, default=100, help="Limit of the list")
@@ -65,12 +102,33 @@ 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 in ["upload", "up"]:
         src_path = Path(args.src)
         if src_path.is_dir():
             failed_upload = upload_directory(
                 connector, args.src, args.dst, 
-                verbose=args.verbose,
+                verbose=not args.quiet,
                 n_concurrent=args.jobs, 
                 n_retries=args.retries, 
                 interval=args.interval,
@@ -86,7 +144,7 @@ def main():
                 connector, 
                 file_path = args.src, 
                 dst_url = args.dst, 
-                verbose=args.verbose,
+                verbose=not args.quiet,
                 n_retries=args.retries, 
                 interval=args.interval,
                 conflict=args.conflict,
@@ -95,16 +153,16 @@ def main():
             if not success:
                 print("\033[91mFailed to upload: \033[0m", msg, file=sys.stderr)
     
-    elif args.command == "download":
+    elif args.command in ["download", "down"]:
         is_dir = args.src.endswith("/")
         if is_dir:
             failed_download = download_directory(
                 connector, args.src, args.dst, 
-                verbose=args.verbose,
+                verbose=not args.quiet,
                 n_concurrent=args.jobs, 
                 n_retries=args.retries, 
                 interval=args.interval,
-                overwrite=args.overwrite
+                overwrite=args.conflict == "overwrite"
             )
             if failed_download:
                 print("\033[91mFailed to download:\033[0m", file=sys.stderr)
@@ -115,7 +173,7 @@ def main():
                 connector, 
                 src_url = args.src, 
                 file_path = args.dst, 
-                verbose=args.verbose,
+                verbose=not args.quiet,
                 n_retries=args.retries, 
                 interval=args.interval,
                 overwrite=args.overwrite
@@ -123,17 +181,50 @@ def main():
             if not success:
                 print("\033[91mFailed to download: \033[0m", msg, file=sys.stderr)
     
-    elif args.command == "query":
+    elif args.command in ["delete", "del"]:
+        if not args.yes:
+            print("You are about to delete the following paths:")
+            for path in args.path:
+                print("[D]" if path.endswith("/") else "[F]", path)
+            confirm = input("Are you sure? ([yes]/no): ")
+            if confirm.lower() not in ["", "y", "yes"]:
+                print("Aborted.")
+                exit(0)
+        for path in args.path:
+            with catch_request_error(default_error_handler_dict(path)):
+                connector.delete(path)
+                print(f"\033[32mDeleted\033[0m ({path})")
+    
+    elif args.command in ["info", "i"]:
         for path in args.path:
-            with catch_request_error():
+            with catch_request_error(default_error_handler_dict(path)):
                 res = connector.get_meta(path)
                 if res is None:
                     print(f"\033[31mNot found\033[0m ({path})")
                 else:
                     print(res)
     
-    elif args.command == "list-files":
-        with catch_request_error():
+    elif args.command in ["ls", "list"]:
+        with catch_request_error(default_error_handler_dict(args.path)):
+            res = connector.list_path(
+                args.path, 
+                offset=args.offset, 
+                limit=args.limit, 
+                order_by=args.order,
+                order_desc=args.reverse,
+            )
+            for i, d in enumerate(line_sep(res.dirs, end=False)):
+                d.url = decode_uri_components(d.url)
+                print(f"[d{i+1}] {d if args.long else d.url}")
+            for i, f in enumerate(line_sep(res.files)):
+                f.url = decode_uri_components(f.url)
+                print(f"[f{i+1}] {f if args.long else f.url}")
+
+            if len(res.dirs) + len(res.files) == args.limit:
+                print(f"\033[33m[Warning] List limit reached, use --offset and --limit to list more items.\033[0m")
+    
+    elif args.command in ["lsf", "list-f"]:
+        with catch_request_error(default_error_handler_dict(args.path)):
             res = connector.list_files(
                 args.path, 
                 offset=args.offset, 
@@ -147,10 +238,10 @@ def main():
                 print(f"[{i+1}] {f if args.long else f.url}")
 
             if len(res) == args.limit:
-                print(f"\033[33m[Warning] List limit reached, use --offset and --limit to list more files.")
+                print(f"\033[33m[Warning] List limit reached, use --offset and --limit to list more files.\033[0m")
         
-    elif args.command == "list-dirs":
-        with catch_request_error():
+    elif args.command in ["lsd", "list-d"]:
+        with catch_request_error(default_error_handler_dict(args.path)):
             res = connector.list_dirs(
                 args.path, 
                 offset=args.offset, 
@@ -164,7 +255,7 @@ def main():
                 print(f"[{i+1}] {d if args.long else d.url}")
 
             if len(res) == args.limit:
-                print(f"\033[33m[Warning] List limit reached, use --offset and --limit to list more directories.")
+                print(f"\033[33m[Warning] List limit reached, use --offset and --limit to list more directories.\033[0m")
     
     else:
         raise NotImplementedError(f"Command {args.command} not implemented.")

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/eng/database.py

@@ -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()

lfss/svc/app_native.py

@@ -8,7 +8,7 @@ from fastapi.exceptions import HTTPException
 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
@@ -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 /")

{lfss-0.11.5.dist-info → lfss-0.12.0.dist-info}/METADATA

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

{lfss-0.11.5.dist-info → lfss-0.12.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
 Readme.md,sha256=B-foESzFWoSI5MEd89AWUzKcVRrTwipM28TK8GN0o8c,1920
-docs/Client.md,sha256=2GSKrcKkjYHxxA6Afa2vhHj7UFEQ-_EdmNRkZ06jPHU,975
+docs/Client.md,sha256=hoF_LrMiGJelEwNIO06aidhEVc0AphaeK-iA-6lxvrU,891
 docs/Enviroment_variables.md,sha256=CZ5DrrXSLU5RLBEVQ-gLMaOIuFthd7dEiTzO7ODrPRQ,788
 docs/Known_issues.md,sha256=ZqETcWP8lzTOel9b2mxEgCnADFF8IxOrEtiVO1NoMAk,251
 docs/Permission.md,sha256=thUJx7YRoU63Pb-eqo5l5450DrZN3QYZ36GCn8r66no,3152
 docs/Webdav.md,sha256=-Ja-BTWSY1BEMAyZycvEMNnkNTPZ49gSPzmf3Lbib70,1547
-docs/changelog.md,sha256=7Pa-yRqF2E0uU69e32bquAGmumgV3I-6irBiW-Jt5Nw,2120
-frontend/api.js,sha256=F35jQjWF2LITkuO-wZJuEKyafLWFx_M4C2tEYJV8zak,22631
+docs/changelog.md,sha256=oet-7w4bxUTr3NjlkkfVYfGzOWiljuNvJHTtQ4JYGMk,2463
+frontend/api.js,sha256=RqvwRWhYZx7_cDlyYgWzgJAr83RxH47WzY-5KL6aRX0,22670
 frontend/index.html,sha256=-k0bJ5FRqdl_H-O441D_H9E-iejgRCaL_z5UeYaS2qc,3384
 frontend/info.css,sha256=Ny0N3GywQ3a9q1_Qph_QFEKB4fEnTe_2DJ1Y5OsLLmQ,595
 frontend/info.js,sha256=xGUJPCSrtDhuSu0ELLQZ77PmVWldg-prU1mwQGbdEoA,5797
@@ -13,27 +13,27 @@ frontend/login.css,sha256=VMM0QfbDFYerxKWKSGhMI1yg5IRBXg0TTdLJEEhQZNk,355
 frontend/login.js,sha256=xJkulk8dlvV4BhevADLeUrnZwShiFTWv3Wg2iJFUZlY,2423
 frontend/popup.css,sha256=TJZYFW1ZcdD1IVTlNPYNtMWKPbN6XDbQ4hKBOFK8uLg,1284
 frontend/popup.js,sha256=cyUjtO0wbtqbEodHfwyUsak9iWbcDXeWMGDhpCPbcoE,5453
-frontend/scripts.js,sha256=T3kMjTxrjOkp93OV4ZMGgCLRRaQgRmNzzxriOMGVeZM,24412
+frontend/scripts.js,sha256=awnhw4CHxE4cPvg3g9pramtyxMEo7i_ygGSCer1BsFI,24633
 frontend/state.js,sha256=vbNL5DProRKmSEY7xu9mZH6IY0PBenF8WGxPtGgDnLI,1680
 frontend/styles.css,sha256=xcNLqI3KBsY5TLnku8UIP0Jfr7QLajr1_KNlZj9eheM,4935
 frontend/thumb.css,sha256=rNsx766amYS2DajSQNabhpQ92gdTpNoQKmV69OKvtpI,295
 frontend/thumb.js,sha256=46ViD2TlTTWy0fx6wjoAs_5CQ4ajYB90vVzM7UO2IHw,6182
 frontend/utils.js,sha256=XP5hM_mROYaxK5dqn9qZVwv7GdQuiDzByilFskbrnxA,6068
-lfss/api/__init__.py,sha256=MdRsQSldbV4tZpAdzgr0sws8ru9GPvqUWVcsT6iVRFY,6844
-lfss/api/connector.py,sha256=sz2mvGsHOREhev0FCd9p9RdyrJxRwtt-X63Kt4_E_dQ,13933
-lfss/cli/__init__.py,sha256=lPwPmqpa7EXQ4zlU7E7LOe6X2kw_xATGdwoHphUEirA,827
+lfss/api/__init__.py,sha256=qHlQAnvw2y0FNZKhes6ikzItEEQvyJWFhVMs1GAqZiM,6822
+lfss/api/connector.py,sha256=kFgBFfd_eyQzt_lDDifS-sF7haldP0SZkVZPb5dYP9I,17004
+lfss/cli/__init__.py,sha256=0tnAldjEhySM9VKfTXXS5SjYKpjcZtbgI8VQyjL9T1Y,1135
 lfss/cli/balance.py,sha256=fUbKKAUyaDn74f7mmxMfBL4Q4voyBLHu6Lg_g8GfMOQ,4121
-lfss/cli/cli.py,sha256=l4_hU7DLJ_QqTG69oKZSVXSA46PjfpxiUc_8ruTY6n0,8196
+lfss/cli/cli.py,sha256=bdV6n3f4eKMqO2uFDoEhZyh-mc9PeobVNkQS6ubCUx8,13305
 lfss/cli/log.py,sha256=TBlt8mhHMouv8ZBUMHYfGZiV6-0yPdajJQ5mkGHEojI,3016
 lfss/cli/panel.py,sha256=Xq3I_n-ctveym-Gh9LaUpzHiLlvt3a_nuDiwUS-MGrg,1597
 lfss/cli/serve.py,sha256=vTo6_BiD7Dn3VLvHsC5RKRBC3lMu45JVr_0SqpgHdj0,1086
-lfss/cli/user.py,sha256=1mTroQbaKxHjFCPHT67xwd08v-zxH0RZ_OnVc-4MzL0,5364
+lfss/cli/user.py,sha256=8LVoMEoqDbHZgyQROHuuzTOIx0t09OYNeDnI4C4JB1g,5543
 lfss/cli/vacuum.py,sha256=arEY89kYJKEpzuzjKtf21V7s0QzM1t3QWa1hNghhT0Q,6611
 lfss/eng/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lfss/eng/bounded_pool.py,sha256=BI1dU-MBf82TMwJBYbjhEty7w1jIUKc5Bn9SnZ_-hoY,1288
 lfss/eng/config.py,sha256=0dncHYn3tYw4pKBwXuP_huz0u7ud23fJ6SUmUPfLmeM,967
 lfss/eng/connection_pool.py,sha256=1aq7nSgd7hB9YNV4PjD1RDRyl_moDw3ubBtSLyfgGBs,6320
-lfss/eng/database.py,sha256=obJU3rD_AvwVzIUiSB1gqsC2k7_E6p7dw8PW7eYvi84,57241
+lfss/eng/database.py,sha256=9ezwrZEPC-Jnh5dxEKahb9AsFWbSQlNcYVZqVbZrYwI,57502
 lfss/eng/datatype.py,sha256=27UB7-l9SICy5lAvKjdzpTL_GohZjzstQcr9PtAq7nM,2709
 lfss/eng/error.py,sha256=JGf5NV-f4rL6tNIDSAx5-l9MG8dEj7F2w_MuOjj1d1o,732
 lfss/eng/log.py,sha256=yciFQ7Utz1AItNekS4YtdP6bM7i1krA6qSAU2wVQv24,7698
@@ -44,10 +44,10 @@ lfss/sql/pragma.sql,sha256=uENx7xXjARmro-A3XAK8OM8v5AxDMdCCRj47f86UuXg,206
 lfss/svc/app.py,sha256=r1KUO3sPaaJWbkJF0bcVTD7arPKLs2jFlq52Ixicomo,220
 lfss/svc/app_base.py,sha256=s5ieQVI4BT0CBYavRx0dyBqwts7PYnjyCovHNYPHul8,7014
 lfss/svc/app_dav.py,sha256=DRMgByUAQ3gD6wL9xmikV5kvVmATN7QkxGSttFTYxFU,18245
-lfss/svc/app_native.py,sha256=K2vlNs6b4DE2bPgRuHxic9oDp8V3D5M5wNjIibGjQyg,10612
+lfss/svc/app_native.py,sha256=imqnuAoseTS2CmztUI0yQ0Jjq_jqbjxYG-_FFnYp6u0,11040
 lfss/svc/common_impl.py,sha256=wlTQm8zEGAfyw9FJvK9zqgLQw47MzNq6IT3OgwdUaCw,13736
 lfss/svc/request_log.py,sha256=v8yXEIzPjaksu76Oh5vgdbUEUrw8Kt4etLAXBWSGie8,3207
-lfss-0.11.5.dist-info/METADATA,sha256=h1KBhb0MjCtgrlaUqfDSqLH_6Jxy1q4KaETLEMauIyY,2732
-lfss-0.11.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-lfss-0.11.5.dist-info/entry_points.txt,sha256=M4ubn9oLYcTc9wxlLKWwljnluStPWpCDlCGuTVU8twg,255
-lfss-0.11.5.dist-info/RECORD,,
+lfss-0.12.0.dist-info/METADATA,sha256=pu3Plg5cQ7FesSpLqN5bjhsZQvalsgDAPUD7en_cwAE,2725
+lfss-0.12.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+lfss-0.12.0.dist-info/entry_points.txt,sha256=M4ubn9oLYcTc9wxlLKWwljnluStPWpCDlCGuTVU8twg,255
+lfss-0.12.0.dist-info/RECORD,,