lfss 0.8.4__py3-none-any.whl → 0.9.1__py3-none-any.whl

lfss/svc/app_native.py

@@ -0,0 +1,247 @@
+from typing import Optional, Literal
+
+from fastapi import Depends, Request, Response, UploadFile
+from fastapi.exceptions import HTTPException 
+
+from ..eng.config import MAX_BUNDLE_BYTES
+from ..eng.utils import ensure_uri_compnents
+from ..eng.connection_pool import unique_cursor
+from ..eng.database import check_file_read_permission, check_path_permission, UserConn, FileConn
+from ..eng.datatype import (
+    FileReadPermission, FileRecord, UserRecord, AccessLevel, 
+    FileSortKey, DirSortKey
+)
+
+from .app_base import *
+from .common_impl import get_file_impl, put_file_impl, post_file_impl, delete_file_impl
+
+@router_fs.get("/{path:path}")
+@handle_exception
+async def get_file(
+    request: Request,
+    path: str, 
+    download: bool = False, thumb: bool = False,
+    user: UserRecord = Depends(get_current_user)
+    ):
+    return await get_file_impl(
+        request = request,
+        user = user, path = path, download = download, thumb = thumb
+        )
+
+@router_fs.head("/{path:path}")
+@handle_exception
+async def head_file(
+    request: Request,
+    path: str, 
+    download: bool = False, thumb: bool = False,
+    user: UserRecord = Depends(get_current_user)
+    ):
+    if path.startswith("_api/"):
+        raise HTTPException(status_code=405, detail="HEAD not supported for API")
+    if path.endswith("/"):
+        raise HTTPException(status_code=405, detail="HEAD not supported for directory")
+    return await get_file_impl(
+        request = request,
+        user = user, path = path, download = download, thumb = thumb, is_head = True
+        )
+
+@router_fs.put("/{path:path}")
+@handle_exception
+async def put_file(
+    request: Request, 
+    path: str, 
+    conflict: Literal["overwrite", "skip", "abort"] = "abort",
+    permission: int = 0,
+    user: UserRecord = Depends(registered_user)
+    ):
+    return await put_file_impl(
+        request = request, user = user, path = path, conflict = conflict, permission = permission
+    )
+
+# using form-data instead of raw body
+@router_fs.post("/{path:path}")
+@handle_exception
+async def post_file(
+    path: str, 
+    file: UploadFile,
+    conflict: Literal["overwrite", "skip", "abort"] = "abort",
+    permission: int = 0,
+    user: UserRecord = Depends(registered_user)
+    ):
+    return await post_file_impl(
+        file = file, user = user, path = path, conflict = conflict, permission = permission
+    )
+
+@router_fs.delete("/{path:path}")
+@handle_exception
+async def delete_file(path: str, user: UserRecord = Depends(registered_user)):
+    return await delete_file_impl(path, user)
+
+
+@router_api.get("/bundle")
+@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)
+    assert path.endswith("/") or path == ""
+
+    if not path == "" and path[0] == "/":   # adapt to both /path and path
+        path = path[1:]
+    
+    # TODO: may check peer users here
+    owner_records_cache: dict[int, UserRecord] = {}     # cache owner records, ID -> UserRecord
+    async def is_access_granted(file_record: FileRecord):
+        owner_id = file_record.owner_id
+        owner = owner_records_cache.get(owner_id, None)
+        if owner is None:
+            async with unique_cursor() as conn:
+                uconn = UserConn(conn)
+                owner = await uconn.get_user_by_id(owner_id, throw=True)
+            owner_records_cache[owner_id] = owner
+            
+        allow_access, _ = check_file_read_permission(user, owner, file_record)
+        return allow_access
+    
+    async with unique_cursor() as conn:
+        fconn = FileConn(conn)
+        files = await fconn.list_path_files(
+            url = path, flat = True, 
+            limit=(await fconn.count_path_files(url = path, flat = True))
+            )
+    files = [f for f in files if await is_access_granted(f)]
+    if len(files) == 0:
+        raise HTTPException(status_code=404, detail="No files found")
+
+    # return bundle of files
+    total_size = sum([f.file_size for f in files])
+    if total_size > MAX_BUNDLE_BYTES:
+        raise HTTPException(status_code=400, detail="Too large to zip")
+
+    file_paths = [f.url for f in files]
+    zip_buffer = await db.zip_path(path, file_paths)
+    return Response(
+        content=zip_buffer.getvalue(), media_type="application/zip", headers={
+            "Content-Disposition": f"attachment; filename=bundle.zip", 
+            "Content-Length": str(zip_buffer.getbuffer().nbytes)
+        }
+    )
+
+@router_api.get("/meta")
+@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)
+    is_file = not path.endswith("/")
+    async with unique_cursor() as cur:
+        fconn = FileConn(cur)
+        if is_file:
+            record = await fconn.get_file_record(path, throw=True)
+            if await check_path_permission(path, user, cursor=cur) < AccessLevel.READ:
+                uconn = UserConn(cur)
+                owner = await uconn.get_user_by_id(record.owner_id, throw=True)
+                is_allowed, reason = check_file_read_permission(user, owner, record)
+                if not is_allowed:
+                    raise HTTPException(status_code=403, detail=reason)
+        else:
+            if await check_path_permission(path, user, cursor=cur) < AccessLevel.READ:
+                raise HTTPException(status_code=403, detail="Permission denied")
+            record = await fconn.get_path_record(path)
+    return record
+
+@router_api.post("/meta")
+@handle_exception
+async def update_file_meta(
+    path: str, 
+    perm: Optional[int] = None, 
+    new_path: Optional[str] = None,
+    user: UserRecord = Depends(registered_user)
+    ):
+    path = ensure_uri_compnents(path)
+    if path.startswith("/"):
+        path = path[1:]
+
+    # file
+    if not path.endswith("/"):
+        if perm is not None:
+            logger.info(f"Update permission of {path} to {perm}")
+            await db.update_file_record(
+                url = path, 
+                permission = FileReadPermission(perm), 
+                op_user = user,
+            )
+    
+        if new_path is not None:
+            new_path = ensure_uri_compnents(new_path)
+            logger.info(f"Update path of {path} to {new_path}")
+            await db.move_file(path, new_path, user)
+    
+    # directory
+    else:
+        assert perm is None, "Permission is not supported for directory"
+        if new_path is not None:
+            new_path = ensure_uri_compnents(new_path)
+            logger.info(f"Update path of {path} to {new_path}")
+            # currently only move own file, with overwrite
+            await db.move_path(path, new_path, user)
+
+    return Response(status_code=200, content="OK")
+
+async def validate_path_read_permission(path: str, user: UserRecord):
+    if not path.endswith("/"):
+        raise HTTPException(status_code=400, detail="Path must end with /")
+    if not await check_path_permission(path, user) >= AccessLevel.READ:
+        raise HTTPException(status_code=403, detail="Permission denied")
+@router_api.get("/count-files")
+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)
+    async with unique_cursor() as conn:
+        fconn = FileConn(conn)
+        return { "count": await fconn.count_path_files(url = path, flat = flat) }
+@router_api.get("/list-files")
+async def list_files(
+    path: str, offset: int = 0, limit: int = 1000,
+    order_by: FileSortKey = "", order_desc: bool = False,
+    flat: bool = False, user: UserRecord = Depends(registered_user)
+    ):
+    await validate_path_read_permission(path, user)
+    path = ensure_uri_compnents(path)
+    async with unique_cursor() as conn:
+        fconn = FileConn(conn)
+        return await fconn.list_path_files(
+            url = path, offset = offset, limit = limit,
+            order_by=order_by, order_desc=order_desc, 
+            flat=flat
+        )
+
+@router_api.get("/count-dirs")
+async def count_dirs(path: str, user: UserRecord = Depends(registered_user)):
+    await validate_path_read_permission(path, user)
+    path = ensure_uri_compnents(path)
+    async with unique_cursor() as conn:
+        fconn = FileConn(conn)
+        return { "count": await fconn.count_path_dirs(url = path) }
+@router_api.get("/list-dirs")
+async def list_dirs(
+    path: str, offset: int = 0, limit: int = 1000,
+    order_by: DirSortKey = "", order_desc: bool = False,
+    skim: bool = True, user: UserRecord = Depends(registered_user)
+    ):
+    await validate_path_read_permission(path, user)
+    path = ensure_uri_compnents(path)
+    async with unique_cursor() as conn:
+        fconn = FileConn(conn)
+        return await fconn.list_path_dirs(
+            url = path, offset = offset, limit = limit,
+            order_by=order_by, order_desc=order_desc, skim=skim
+        )
+    
+@router_api.get("/whoami")
+@handle_exception
+async def whoami(user: UserRecord = Depends(registered_user)):
+    user.credential = "__HIDDEN__"
+    return user
+
+__all__ = [
+    "app", "router_api", "router_fs"
+]

lfss/svc/common_impl.py

@@ -0,0 +1,270 @@
+import json
+from fastapi import Request, Response, HTTPException, UploadFile
+from fastapi.responses import StreamingResponse
+from typing import Optional, Literal
+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.config import CHUNK_SIZE
+
+from .app_base import skip_request_log, db, logger
+
+@skip_request_log
+async def emit_thumbnail(
+    path: str, download: bool,
+    create_time: Optional[str] = None, 
+    is_head = False
+    ):
+    if path.endswith("/"):
+        fname = path.split("/")[-2]
+    else:
+        fname = path.split("/")[-1]
+    if (thumb_res := await get_thumb(path)) is None:
+        return Response(status_code=415, content="Thumbnail not supported")
+    thumb_blob, mime_type = thumb_res
+    disp = "inline" if not download else "attachment"
+    headers = {
+        "Content-Disposition": f"{disp}; filename={fname}.thumb.jpg",
+        "Content-Length": str(len(thumb_blob)),
+    }
+    if create_time is not None:
+        headers["Last-Modified"] = format_last_modified(create_time)
+    if is_head: return Response(status_code=200, headers=headers)
+    return Response(
+        content=thumb_blob, media_type=mime_type, headers=headers
+    )
+async def emit_file(
+    file_record: FileRecord, 
+    media_type: Optional[str] = None, 
+    disposition = "attachment", 
+    is_head = False, 
+    range_start = -1,
+    range_end = -1
+    ):
+    if range_start < 0: assert range_start == -1
+    if range_end < 0: assert range_end == -1
+
+    if media_type is None:
+        media_type = file_record.mime_type
+    path = file_record.url
+    fname = path.split("/")[-1]
+
+    if range_start == -1:
+        arng_s = 0          # actual range start
+    else:
+        arng_s = range_start
+    if range_end == -1:
+        arng_e = file_record.file_size - 1
+    else:
+        arng_e = range_end
+    
+    if arng_s >= file_record.file_size or arng_e >= file_record.file_size:
+        raise HTTPException(status_code=416, detail="Range not satisfiable")
+    if arng_s > arng_e:
+        raise HTTPException(status_code=416, detail="Invalid range")
+
+    headers = {
+        "Content-Disposition": f"{disposition}; filename={fname}", 
+        "Content-Length": str(arng_e - arng_s + 1),
+        "Content-Range": f"bytes {arng_s}-{arng_e}/{file_record.file_size}",
+        "Last-Modified": format_last_modified(file_record.create_time), 
+        "Accept-Ranges": "bytes", 
+    }
+
+    if is_head: return Response(status_code=200 if (range_start == -1 and range_end == -1) else 206, headers=headers)
+
+    await delayed_log_access(path)
+    return StreamingResponse(
+        await db.read_file(
+            path, 
+            start_byte=arng_s if range_start != -1 else -1,
+            end_byte=arng_e + 1 if range_end != -1 else -1
+        ),
+        media_type=media_type, 
+        headers=headers, 
+        status_code=206 if range_start != -1 or range_end != -1 else 200
+    )
+
+async def get_file_impl(
+    request: Request,
+    user: UserRecord, 
+    path: str, 
+    download: bool = False, 
+    thumb: bool = False,
+    is_head = False,
+    ):
+    path = ensure_uri_compnents(path)
+
+    # handle directory query
+    if path == "": path = "/"
+    if path.endswith("/"):
+        # return file under the path as json
+        async with unique_cursor() as cur:
+            fconn = FileConn(cur)
+            if user.id == 0:
+                raise HTTPException(status_code=401, detail="Permission denied, credential required")
+            if thumb:
+                return await emit_thumbnail(path, download, create_time=None)
+            
+            if path == "/":
+                peer_users = await UserConn(cur).list_peer_users(user.id, AccessLevel.READ)
+                return PathContents(
+                    dirs = await fconn.list_root_dirs(user.username, *[x.username for x in peer_users], skim=True) \
+                        if not user.is_admin else await fconn.list_root_dirs(skim=True),
+                    files = []
+                )
+
+            if not await check_path_permission(path, user, cursor=cur) >= AccessLevel.READ:
+                raise HTTPException(status_code=403, detail="Permission denied")
+
+            return await fconn.list_path(path)
+    
+    # handle file query
+    async with unique_cursor() as cur:
+        fconn = FileConn(cur)
+        file_record = await fconn.get_file_record(path, throw=True)
+        uconn = UserConn(cur)
+        owner = await uconn.get_user_by_id(file_record.owner_id, throw=True)
+
+        if not await check_path_permission(path, user, cursor=cur) >= AccessLevel.READ:
+            allow_access, reason = check_file_read_permission(user, owner, file_record)
+            if not allow_access:
+                raise HTTPException(status_code=403 if user.id != 0 else 401, detail=reason)
+    
+    req_range = request.headers.get("Range", None)
+    if not req_range is None:
+        # handle range request
+        if not req_range.startswith("bytes="):
+            raise HTTPException(status_code=400, detail="Invalid range request")
+        range_str = req_range[6:].strip()
+        if "," in range_str:
+            raise HTTPException(status_code=400, detail="Multiple ranges not supported")
+        if "-" not in range_str:
+            raise HTTPException(status_code=400, detail="Invalid range request")
+        range_start, range_end = map(lambda x: int(x) if x != "" else -1 , range_str.split("-"))
+    else:
+        range_start, range_end = -1, -1
+    
+    if thumb:
+        if (range_start != -1 or range_end != -1): logger.warning("Range request for thumbnail")
+        return await emit_thumbnail(path, download, create_time=file_record.create_time, is_head=is_head)
+    else:
+        if download:
+            return await emit_file(file_record, 'application/octet-stream', "attachment", is_head = is_head, range_start=range_start, range_end=range_end)
+        else:
+            return await emit_file(file_record, None, "inline", is_head = is_head, range_start=range_start, range_end=range_end)
+
+async def put_file_impl(
+    request: Request, 
+    user: UserRecord, 
+    path: str, 
+    conflict: Literal["overwrite", "skip", "abort"] = "abort",
+    permission: int = 0,
+    ):
+    path = ensure_uri_compnents(path)
+    assert not path.endswith("/"), "Path must not end with /"
+
+    access_level = await check_path_permission(path, user)
+    if access_level < AccessLevel.WRITE:
+        logger.debug(f"Reject put request from {user.username} to {path}")
+        raise HTTPException(status_code=403, detail="Permission denied")
+    
+    logger.info(f"PUT {path}, user: {user.username}")
+    exists_flag = False
+    async with unique_cursor() as conn:
+        fconn = FileConn(conn)
+        file_record = await fconn.get_file_record(path)
+
+    if file_record:
+        if conflict == "abort":
+            raise HTTPException(status_code=409, detail="File exists")
+        if conflict == "skip":
+            return Response(status_code=200, headers={
+                "Content-Type": "application/json",
+            }, content=json.dumps({"url": path}))
+        exists_flag = True
+        if await check_path_permission(path, user) < AccessLevel.WRITE:
+            raise HTTPException(status_code=403, detail="Permission denied, cannot overwrite other's file")
+        await db.delete_file(path)
+    
+    # check content-type
+    content_type = request.headers.get("Content-Type", "application/octet-stream")
+    logger.debug(f"Content-Type: {content_type}")
+    if not (content_type == "application/octet-stream" or content_type == "application/json"):
+        # raise HTTPException(status_code=415, detail="Unsupported content type, put request must be application/json or application/octet-stream, got " + content_type)
+        logger.warning(f"Unsupported content type, put request must be application/json or application/octet-stream, got {content_type}")
+    
+    async def blob_reader():
+        nonlocal request
+        async for chunk in request.stream():
+            yield chunk
+
+    await db.save_file(user.id, path, blob_reader(), permission = FileReadPermission(permission))
+
+    # https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Methods/PUT
+    return Response(status_code=200 if exists_flag else 201, headers={
+        "Content-Type": "application/json",
+    }, content=json.dumps({"url": path}))
+
+
+async def post_file_impl(
+    path: str, 
+    user: UserRecord, 
+    file: UploadFile,
+    conflict: Literal["overwrite", "skip", "abort"] = "abort",
+    permission: int = 0,
+):
+    path = ensure_uri_compnents(path)
+    assert not path.endswith("/"), "Path must not end with /"
+
+    access_level = await check_path_permission(path, user)
+    if access_level < AccessLevel.WRITE:
+        logger.debug(f"Reject post request from {user.username} to {path}")
+        raise HTTPException(status_code=403, detail="Permission denied")
+
+    logger.info(f"POST {path}, user: {user.username}")
+    exists_flag = False
+    async with unique_cursor() as conn:
+        fconn = FileConn(conn)
+        file_record = await fconn.get_file_record(path)
+
+    if file_record:
+        if conflict == "abort":
+            raise HTTPException(status_code=409, detail="File exists")
+        if conflict == "skip":
+            return Response(status_code=200, headers={
+                "Content-Type": "application/json",
+            }, content=json.dumps({"url": path}))
+        exists_flag = True
+        if await check_path_permission(path, user) < AccessLevel.WRITE: 
+            raise HTTPException(status_code=403, detail="Permission denied, cannot overwrite other's file")
+        await db.delete_file(path)
+    
+    async def blob_reader():
+        nonlocal file
+        while (chunk := await file.read(CHUNK_SIZE)):
+            yield chunk
+
+    await db.save_file(user.id, path, blob_reader(), permission = FileReadPermission(permission))
+    return Response(status_code=200 if exists_flag else 201, headers={
+        "Content-Type": "application/json",
+    }, content=json.dumps({"url": path}))
+
+async def delete_file_impl(path: str, user: UserRecord):
+    path = ensure_uri_compnents(path)
+    if await check_path_permission(path, user) < AccessLevel.WRITE:
+        raise HTTPException(status_code=403, detail="Permission denied")
+    
+    logger.info(f"DELETE {path}, user: {user.username}")
+
+    if path.endswith("/"):
+        res = await db.delete_path(path, user)
+    else:
+        res = await db.delete_file(path, user)
+
+    if res:
+        return Response(status_code=200, content="Deleted")
+    else:
+        return Response(status_code=404, content="Not found")

lfss/{src/stat.py → svc/request_log.py}

@@ -1,8 +1,8 @@
 from typing import Optional, Any
 import aiosqlite
 from contextlib import asynccontextmanager
-from .config import DATA_HOME
-from .utils import debounce_async
+from ..eng.config import DATA_HOME
+from ..eng.utils import debounce_async
 
 class RequestDB:
     conn: aiosqlite.Connection

{lfss-0.8.4.dist-info → lfss-0.9.1.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: lfss
-Version: 0.8.4
+Version: 0.9.1
 Summary: Lightweight file storage service
 Home-page: https://github.com/MenxLi/lfss
-Author: li, mengxun
-Author-email: limengxun45@outlook.com
+Author: li_mengxun
+Author-email: limengxun45@outlookc.com
 Requires-Python: >=3.10
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
@@ -32,6 +32,7 @@ My experiment on a lightweight and high-performance file/object storage service.
 - Pagination and sorted file listing for vast number of files.  
 - High performance: high concurrency, near-native speed on stress tests.
 - Support range requests, so you can stream large files / resume download.
+- WebDAV compatible ([NOTE](./docs/Webdav.md)).
 
 It stores small files and metadata in sqlite, large files in the filesystem.  
 Tested on 2 million files, and it is still fast.
@@ -53,7 +54,11 @@ lfss-panel --open
 Or, you can start a web server at `/frontend` and open `index.html` in your browser. 
 
 The API usage is simple, just `GET`, `PUT`, `DELETE` to the `/<username>/file/url` path.  
-Authentication via `Authorization` header with the value `Bearer <token>`, or through the `token` query parameter.  
+The authentication can be acheived through one of the following methods:
+1. `Authorization` header with the value `Bearer sha256(<username><password>)`.
+2. `token` query parameter with the value `sha256(<username><password>)`.
+3. HTTP Basic Authentication with the username and password. 
+
 You can refer to `frontend` as an application example, `lfss/api/connector.py` for more APIs. 
 
 By default, the service exposes all files to the public for `GET` requests, 

lfss-0.9.1.dist-info/RECORD

@@ -0,0 +1,49 @@
+Readme.md,sha256=6gOvhb93ma83VKC4-pfi4TccZxCq4kj3GEB9qa9ols4,1759
+docs/Known_issues.md,sha256=rfdG3j1OJF-59S9E06VPyn0nZKbW-ybPxkoZ7MEZWp8,81
+docs/Permission.md,sha256=mvK8gVBBgoIFJqikcaReU_bUo-mTq_ECqJaDDJoQF7Q,3126
+docs/Webdav.md,sha256=9Q41ROEJodVVAnlo1Tf0jqsyrbuHhv_ElSsXbIPXYIg,1547
+frontend/api.js,sha256=hMV6Fc1JxkFQgv7BV1Y_Su7pqsWeF_92hPMmDBcXC04,18485
+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
+frontend/login.css,sha256=VMM0QfbDFYerxKWKSGhMI1yg5IRBXg0TTdLJEEhQZNk,355
+frontend/login.js,sha256=QoO8yKmBHDVP-ZomCMOaV7xVUVIhpl7esJrb6T5aHQE,2466
+frontend/popup.css,sha256=TJZYFW1ZcdD1IVTlNPYNtMWKPbN6XDbQ4hKBOFK8uLg,1284
+frontend/popup.js,sha256=3PgaGZmxSdV1E-D_MWgcR7aHWkcsHA1BNKSOkmP66tA,5191
+frontend/scripts.js,sha256=nWH6NgavZTVmjK44i2DeRi6mJzGSe4qeQPUbDaEVt58,21735
+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=IYUZl77ugiXKcLxSNOWC4NSS0CdD5yRgUsDb665j0xM,2556
+lfss/api/__init__.py,sha256=8IJqrpWK1doIyVVbntvVic82A57ncwl5b0BRHX4Ri6A,6660
+lfss/api/connector.py,sha256=gLn-eW1m6trjqj54YXzPqByQFT56WlSy08kUm1UX4LE,11573
+lfss/cli/__init__.py,sha256=lPwPmqpa7EXQ4zlU7E7LOe6X2kw_xATGdwoHphUEirA,827
+lfss/cli/balance.py,sha256=fUbKKAUyaDn74f7mmxMfBL4Q4voyBLHu6Lg_g8GfMOQ,4121
+lfss/cli/cli.py,sha256=aYjB8d4k6JUd9efxZK-XOj-mlG4JeOr_0lnj2qqCiK0,8066
+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/vacuum.py,sha256=GOG72d3NYe9bYCNc3y8JecEmM-DrKlGq3JQcisv_xBg,3702
+lfss/eng/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lfss/eng/bounded_pool.py,sha256=BI1dU-MBf82TMwJBYbjhEty7w1jIUKc5Bn9SnZ_-hoY,1288
+lfss/eng/config.py,sha256=DmnUYMeLOL-45OstysyMpSBPmLofgzvcSrsWjHvssYs,915
+lfss/eng/connection_pool.py,sha256=-tePasJxiZZ73ymgWf_kFnaKouc4Rrr4K6EXwjb7Mm4,6141
+lfss/eng/database.py,sha256=81wp6LczdByk05RYcJfLjd0tx4ZT3Ue2k994UYMiDZI,47172
+lfss/eng/datatype.py,sha256=27UB7-l9SICy5lAvKjdzpTL_GohZjzstQcr9PtAq7nM,2709
+lfss/eng/error.py,sha256=61hcjeQ-y5htKhImDtDuWDf0GPrwbj5LySibeHiKFxc,529
+lfss/eng/log.py,sha256=u6WRZZsE7iOx6_CV2NHh1ugea26p408FI4WstZh896A,5139
+lfss/eng/thumb.py,sha256=YO1yTI8WzW7pBpQN9x5PtPayxhftb32IJl1zPSS9mks,3243
+lfss/eng/utils.py,sha256=zZ7r9BsNV8XJJVNOxfIqRCO1bxNzh7bc9vEJiCkgbKI,6208
+lfss/sql/init.sql,sha256=8LjHx0TBCkBD62xFfssSeHDqKYVQQJkZAg4rSm046f4,1496
+lfss/sql/pragma.sql,sha256=uENx7xXjARmro-A3XAK8OM8v5AxDMdCCRj47f86UuXg,206
+lfss/svc/app.py,sha256=XK0hx5yKMk8JViJ2BXgsFr3hgSdWn_equJ0JoJwMiuc,221
+lfss/svc/app_base.py,sha256=LjH9tJzaFcP7PB8OBUizG9kvNhts2eq0JxNMBUCoHw0,6312
+lfss/svc/app_dav.py,sha256=8Etdoh_NmvZpEG8J9m97xRF4i-GNGJNvNfgjfLIDjzk,17224
+lfss/svc/app_native.py,sha256=ML-PR-zdoi5j3-KrGhIaYPMbSoW9Lesh7NROPNPUINU,9221
+lfss/svc/common_impl.py,sha256=m3lMA97a4yd_VFG3IrVYIsDzyUEseX7sU633qj7iyDI,10858
+lfss/svc/request_log.py,sha256=v8yXEIzPjaksu76Oh5vgdbUEUrw8Kt4etLAXBWSGie8,3207
+lfss-0.9.1.dist-info/METADATA,sha256=CZuVoVTKJG002grUK_hXtgy0b_j3m-eNHDK0SRyVLL4,2519
+lfss-0.9.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+lfss-0.9.1.dist-info/entry_points.txt,sha256=VJ8svMz7RLtMCgNk99CElx7zo7M-N-z7BWDVw2HA92E,205
+lfss-0.9.1.dist-info/RECORD,,