lfss 0.11.3__tar.gz → 0.11.5__tar.gz

{lfss-0.11.3 → lfss-0.11.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lfss
-Version: 0.11.3
+Version: 0.11.5
 Summary: Lightweight file storage service
 Home-page: https://github.com/MenxLi/lfss
 Author: Li, Mengxun

lfss-0.11.5/docs/Client.md

@@ -0,0 +1,37 @@
+
+# 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
+# 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.3 → lfss-0.11.5}/docs/changelog.md

@@ -1,5 +1,21 @@
 ## 0.11
 
+### 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.3 → lfss-0.11.5}/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.3 → lfss-0.11.5}/lfss/api/connector.py

@@ -11,7 +11,7 @@ from lfss.eng.datatype import (
     FileReadPermission, FileRecord, DirectoryRecord, UserRecord, PathContents, 
     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)

{lfss-0.11.3 → lfss-0.11.5}/lfss/cli/cli.py

@@ -2,7 +2,7 @@ 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.utils import decode_uri_components
 from . import catch_request_error, line_sep
 
 def parse_permission(s: str) -> FileReadPermission:
@@ -143,7 +143,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 +160,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.3 → lfss-0.11.5}/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):
@@ -197,6 +197,11 @@ class FileConn(DBObjectBase):
     def parse_record(record) -> FileRecord:
         return FileRecord(*record)
     
+    @staticmethod
+    def escape_sqlike(url: str) -> str:
+        """ Escape a url for use in SQL LIKE clause (The % and _ characters) """
+        return url.replace('%', r'\%').replace('_', r'\_')
+    
     @overload
     async def get_file_record(self, url: str, throw: Literal[True]) -> FileRecord: ...
     @overload
@@ -246,9 +251,9 @@ class FileConn(DBObjectBase):
                 url, LENGTH(?) + 1, 
                 INSTR(SUBSTR(url, LENGTH(?) + 1), '/')
                 ) AS dirname
-            FROM fmeta WHERE url LIKE ? AND dirname != ''
+            FROM fmeta WHERE url LIKE ? ESCAPE '\\' AND dirname != ''
         )
-        """, (url, url, url + '%'))
+        """, (url, url, self.escape_sqlike(url) + '%'))
         res = await cursor.fetchone()
         assert res is not None, "Error: count_path_dirs"
         return res[0]
@@ -271,11 +276,11 @@ class FileConn(DBObjectBase):
                 1 + LENGTH(?),
                 INSTR(SUBSTR(url, 1 + LENGTH(?)), '/')
             ) AS dirname 
-            FROM fmeta WHERE url LIKE ? AND dirname != ''
+            FROM fmeta WHERE url LIKE ? ESCAPE '\\' AND dirname != ''
         """ \
         + (f"ORDER BY {order_by} {'DESC' if order_desc else 'ASC'}" if order_by else '') \
         + " LIMIT ? OFFSET ?"
-        cursor = await self.cur.execute(sql_qury, (url, url, url + '%', limit, offset))
+        cursor = await self.cur.execute(sql_qury, (url, url, self.escape_sqlike(url) + '%', limit, offset))
         res = await cursor.fetchall()
         dirs_str = [r[0] for r in res]
         async def get_dir(dir_url):
@@ -290,9 +295,15 @@ class FileConn(DBObjectBase):
         if not url.endswith('/'): url += '/'
         if url == '/': url = ''
         if flat:
-            cursor = await self.cur.execute("SELECT COUNT(*) FROM fmeta WHERE url LIKE ?", (url + '%', ))
+            cursor = await self.cur.execute(
+                "SELECT COUNT(*) FROM fmeta WHERE url LIKE ? ESCAPE '\\'", 
+                (self.escape_sqlike(url) + '%', )
+                )
         else:
-            cursor = await self.cur.execute("SELECT COUNT(*) FROM fmeta WHERE url LIKE ? AND url NOT LIKE ?", (url + '%', url + '%/%'))
+            cursor = await self.cur.execute(
+                "SELECT COUNT(*) FROM fmeta WHERE url LIKE ? ESCAPE '\\' AND url NOT LIKE ? ESCAPE '\\'", 
+                (self.escape_sqlike(url) + '%', self.escape_sqlike(url) + '%/%')
+                )
         res = await cursor.fetchone()
         assert res is not None, "Error: count_path_files"
         return res[0]
@@ -309,14 +320,14 @@ class FileConn(DBObjectBase):
         if not url.endswith('/'): url += '/'
         if url == '/': url = ''
 
-        sql_query = "SELECT * FROM fmeta WHERE url LIKE ?"
-        if not flat: sql_query += " AND url NOT LIKE ?"
+        sql_query = "SELECT * FROM fmeta WHERE url LIKE ? ESCAPE '\\'"
+        if not flat: sql_query += " AND url NOT LIKE ? ESCAPE '\\'"
         if order_by: sql_query += f" ORDER BY {order_by} {'DESC' if order_desc else 'ASC'}"
         sql_query += " LIMIT ? OFFSET ?"
         if flat:
-            cursor = await self.cur.execute(sql_query, (url + '%', limit, offset))
+            cursor = await self.cur.execute(sql_query, (self.escape_sqlike(url) + '%', limit, offset))
         else:
-            cursor = await self.cur.execute(sql_query, (url + '%', url + '%/%', limit, offset))
+            cursor = await self.cur.execute(sql_query, (self.escape_sqlike(url) + '%', self.escape_sqlike(url) + '%/%', limit, offset))
         res = await cursor.fetchall()
         files = [self.parse_record(r) for r in res]
         return files
@@ -351,8 +362,8 @@ class FileConn(DBObjectBase):
                 MAX(access_time) as access_time, 
                 COUNT(*) as n_files
             FROM fmeta 
-            WHERE url LIKE ?
-        """, (url + '%', ))
+            WHERE url LIKE ? ESCAPE '\\'
+        """, (self.escape_sqlike(url) + '%', ))
         result = await cursor.fetchone()
         if result is None or any(val is None for val in result):
             raise PathNotFoundError(f"Path {url} not found")
@@ -376,10 +387,16 @@ class FileConn(DBObjectBase):
         if not url.endswith('/'):
             url += '/'
         if not include_subpath:
-            cursor = await self.cur.execute("SELECT SUM(file_size) FROM fmeta WHERE url LIKE ? AND url NOT LIKE ?", (url + '%', url + '%/%'))
+            cursor = await self.cur.execute(
+                "SELECT SUM(file_size) FROM fmeta WHERE url LIKE ? ESCAPE '\\' AND url NOT LIKE ? ESCAPE '\\'",
+                (self.escape_sqlike(url) + '%', self.escape_sqlike(url) + '%/%')
+                )
             res = await cursor.fetchone()
         else:
-            cursor = await self.cur.execute("SELECT SUM(file_size) FROM fmeta WHERE url LIKE ?", (url + '%', ))
+            cursor = await self.cur.execute(
+                "SELECT SUM(file_size) FROM fmeta WHERE url LIKE ? ESCAPE '\\'",
+                (self.escape_sqlike(url) + '%', )
+                )
             res = await cursor.fetchone()
         assert res is not None
         return res[0] or 0
@@ -442,7 +459,10 @@ class FileConn(DBObjectBase):
         """
         assert old_url.endswith('/'), "Old path must end with /"
         assert new_url.endswith('/'), "New path must end with /"
-        cursor = await self.cur.execute("SELECT * FROM fmeta WHERE url LIKE ?", (old_url + '%', ))
+        cursor = await self.cur.execute(
+            "SELECT * FROM fmeta WHERE url LIKE ? ESCAPE '\\'",
+            (self.escape_sqlike(old_url) + '%', )
+            )
         res = await cursor.fetchall()
         for r in res:
             old_record = FileRecord(*r)
@@ -472,10 +492,16 @@ class FileConn(DBObjectBase):
         assert old_url.endswith('/'), "Old path must end with /"
         assert new_url.endswith('/'), "New path must end with /"
         if user_id is None:
-            cursor = await self.cur.execute("SELECT * FROM fmeta WHERE url LIKE ?", (old_url + '%', ))
+            cursor = await self.cur.execute(
+                "SELECT * FROM fmeta WHERE url LIKE ? ESCAPE '\\'",
+                (self.escape_sqlike(old_url) + '%', )
+                )
             res = await cursor.fetchall()
         else:
-            cursor = await self.cur.execute("SELECT * FROM fmeta WHERE url LIKE ? AND owner_id = ?", (old_url + '%', user_id))
+            cursor = await self.cur.execute(
+                "SELECT * FROM fmeta WHERE url LIKE ? ESCAPE '\\' AND owner_id = ?", 
+                (self.escape_sqlike(old_url) + '%', user_id)
+                )
             res = await cursor.fetchall()
         for r in res:
             new_r = new_url + r[0][len(old_url):]
@@ -510,10 +536,16 @@ class FileConn(DBObjectBase):
     async def delete_records_by_prefix(self, path: str, under_owner_id: Optional[int] = None) -> list[FileRecord]:
         """Delete all records with url starting with path"""
         # update user size
-        cursor = await self.cur.execute("SELECT DISTINCT owner_id FROM fmeta WHERE url LIKE ?", (path + '%', ))
+        cursor = await self.cur.execute(
+            "SELECT DISTINCT owner_id FROM fmeta WHERE url LIKE ? ESCAPE '\\'",
+            (self.escape_sqlike(path) + '%', )
+            )
         res = await cursor.fetchall()
         for r in res:
-            cursor = await self.cur.execute("SELECT SUM(file_size) FROM fmeta WHERE owner_id = ? AND url LIKE ?", (r[0], path + '%'))
+            cursor = await self.cur.execute(
+                "SELECT SUM(file_size) FROM fmeta WHERE owner_id = ? AND url LIKE ? ESCAPE '\\'", 
+                (r[0], self.escape_sqlike(path) + '%')
+                )
             size = await cursor.fetchone()
             if size is not None:
                 await self._user_size_dec(r[0], size[0])
@@ -522,9 +554,9 @@ class FileConn(DBObjectBase):
         # but it's not a big deal... we should have only one writer
         
         if under_owner_id is None:
-            res = await self.cur.execute("DELETE FROM fmeta WHERE url LIKE ? RETURNING *", (path + '%', ))
+            res = await self.cur.execute("DELETE FROM fmeta WHERE url LIKE ? ESCAPE '\\' RETURNING *", (self.escape_sqlike(path) + '%', ))
         else:
-            res = await self.cur.execute("DELETE FROM fmeta WHERE url LIKE ? AND owner_id = ? RETURNING *", (path + '%', under_owner_id))
+            res = await self.cur.execute("DELETE FROM fmeta WHERE url LIKE ? ESCAPE '\\' AND owner_id = ? RETURNING *", (self.escape_sqlike(path) + '%', under_owner_id))
         all_f_rec = await res.fetchall()
         self.logger.info(f"Deleted {len(all_f_rec)} file(s) for path {path}") # type: ignore
         return [self.parse_record(r) for r in all_f_rec]
@@ -692,7 +724,7 @@ async def delayed_log_access(url: str):
     prohibited_part_regex = re.compile(
         "|".join([
             r"^\s*\.+\s*$",       # dot path
-            "[{}]".format("".join(re.escape(c) for c in ('/', "\\", "'", '"', "*", "%"))), # prohibited characters
+            "[{}]".format("".join(re.escape(c) for c in ('/', "\\", "'", '"', "*"))), # prohibited characters
         ])
     ),
 )
@@ -1076,7 +1108,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
@@ -1106,7 +1138,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.3 → lfss-0.11.5}/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.3 → lfss-0.11.5}/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.3 → lfss-0.11.5}/lfss/svc/app_native.py

@@ -5,7 +5,7 @@ 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
@@ -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)
@@ -194,7 +194,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 +206,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 +219,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 +231,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 +263,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.3 → lfss-0.11.5}/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.3 → lfss-0.11.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "lfss"
-version = "0.11.3"
+version = "0.11.5"
 description = "Lightweight file storage service"
 authors = ["Li, Mengxun <mengxunli@whu.edu.cn>"]
 readme = "Readme.md"
@@ -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"]