PyPI - zrb - Versions diffs - 1.0.0a21__py3-none-any.whl → 1.0.0b3__py3-none-any.whl - Mend

zrb 1.0.0a21py3-none-any.whl → 1.0.0b3py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (195) hide show

zrb/runner/{web_controller → web_route}/error_page/view.html RENAMED Viewed

@@ -1,5 +1,6 @@
 <!doctype html>
 <html lang="en">
     <head>
         <meta charset="utf-8">
         <meta name="viewport" content="width=device-width, initial-scale=1">
@@ -9,6 +10,7 @@
         <title>Zrb</title>
         <link rel="stylesheet" href="/static/common.css">
     </head>
     <body>
         <header class="container">
             <hgroup>
@@ -26,9 +28,12 @@
             </hgroup>
         </header>
         <main class="container">
+            <article>
                 <h2>{error_status_code}</h2>
                 <p>{error_message}</p>
+            </article>
         </main>
     </body>
     <script src="/refresh-token.js"></script>
 </html>

zrb/runner/web_route/home_page/home_page_route.py ADDED Viewed

@@ -0,0 +1,51 @@
+import os
+from typing import TYPE_CHECKING
+from zrb.group.any_group import AnyGroup
+from zrb.runner.web_config.config import WebConfig
+from zrb.runner.web_util.html import (
+    get_html_auth_link,
+    get_html_subgroup_info,
+    get_html_subtask_info,
+)
+from zrb.runner.web_util.user import get_user_from_request
+from zrb.util.file import read_file
+from zrb.util.string.format import fstring_format
+if TYPE_CHECKING:
+    # We want fastapi to only be loaded when necessary to decrease footprint
+    from fastapi import FastAPI
+def serve_home_page(
+    app: "FastAPI",
+    root_group: AnyGroup,
+    web_config: WebConfig,
+) -> None:
+    from fastapi import Request
+    from fastapi.responses import HTMLResponse
+    # Serve homepage
+    @app.get("/", response_class=HTMLResponse, include_in_schema=False)
+    @app.get("/ui", response_class=HTMLResponse, include_in_schema=False)
+    @app.get("/ui/", response_class=HTMLResponse, include_in_schema=False)
+    async def home_page_ui(request: Request) -> HTMLResponse:
+        _DIR = os.path.dirname(__file__)
+        _VIEW_TEMPLATE = read_file(os.path.join(_DIR, "view.html"))
+        user = await get_user_from_request(web_config, request)
+        group_info = get_html_subgroup_info(user, "/ui/", root_group)
+        task_info = get_html_subtask_info(user, "/ui/", root_group)
+        auth_link = get_html_auth_link(user)
+        return HTMLResponse(
+            fstring_format(
+                _VIEW_TEMPLATE,
+                {
+                    "group_info": group_info,
+                    "task_info": task_info,
+                    "name": root_group.name,
+                    "description": root_group.description,
+                    "auth_link": auth_link,
+                },
+            )
+        )

zrb/runner/web_route/login_api_route.py ADDED Viewed

@@ -0,0 +1,31 @@
+from typing import TYPE_CHECKING, Annotated
+from zrb.runner.web_config.config import WebConfig
+from zrb.runner.web_util.cookie import set_auth_cookie
+from zrb.runner.web_util.token import generate_tokens_by_credentials
+if TYPE_CHECKING:
+    # We want fastapi to only be loaded when necessary to decrease footprint
+    from fastapi import FastAPI
+def serve_login_api(app: "FastAPI", web_config: WebConfig) -> None:
+    from fastapi import Depends, Response
+    from fastapi.responses import JSONResponse
+    from fastapi.security import OAuth2PasswordRequestForm
+    @app.post("/api/v1/login")
+    async def login_api(
+        response: Response, form_data: Annotated[OAuth2PasswordRequestForm, Depends()]
+    ):
+        token = generate_tokens_by_credentials(
+            web_config=web_config,
+            username=form_data.username,
+            password=form_data.password,
+        )
+        if token is None:
+            return JSONResponse(
+                content={"detail": "Incorrect username or password"}, status_code=400
+            )
+        set_auth_cookie(web_config, response, token)
+        return token

zrb/runner/web_route/login_page/login_page_route.py ADDED Viewed

@@ -0,0 +1,39 @@
+import os
+from typing import TYPE_CHECKING
+from zrb.group.any_group import AnyGroup
+from zrb.runner.web_config.config import WebConfig
+from zrb.runner.web_util.html import get_html_auth_link
+from zrb.runner.web_util.user import get_user_from_request
+from zrb.util.file import read_file
+from zrb.util.string.format import fstring_format
+if TYPE_CHECKING:
+    # We want fastapi to only be loaded when necessary to decrease footprint
+    from fastapi import FastAPI
+def serve_login_page(
+    app: "FastAPI",
+    root_group: AnyGroup,
+    web_config: WebConfig,
+) -> None:
+    from fastapi import Request
+    from fastapi.responses import HTMLResponse
+    @app.get("/login", response_class=HTMLResponse, include_in_schema=False)
+    async def login(request: Request) -> HTMLResponse:
+        _DIR = os.path.dirname(__file__)
+        _VIEW_TEMPLATE = read_file(os.path.join(_DIR, "view.html"))
+        user = await get_user_from_request(web_config, request)
+        auth_link = get_html_auth_link(user)
+        return HTMLResponse(
+            fstring_format(
+                _VIEW_TEMPLATE,
+                {
+                    "name": root_group.name,
+                    "description": root_group.description,
+                    "auth_link": auth_link,
+                },
+            )
+        )

zrb/runner/web_route/logout_api_route.py ADDED Viewed

@@ -0,0 +1,18 @@
+from typing import TYPE_CHECKING
+from zrb.runner.web_config.config import WebConfig
+if TYPE_CHECKING:
+    # We want fastapi to only be loaded when necessary to decrease footprint
+    from fastapi import FastAPI
+def serve_logout_api(app: "FastAPI", web_config: WebConfig) -> None:
+    from fastapi import Response
+    @app.get("/api/v1/logout")
+    @app.post("/api/v1/logout")
+    async def logout_api(response: Response):
+        response.delete_cookie(web_config.access_token_cookie_name)
+        response.delete_cookie(web_config.refresh_token_cookie_name)
+        return {"message": "Logout successful"}

zrb/runner/web_route/logout_page/logout_page_route.py ADDED Viewed

@@ -0,0 +1,40 @@
+import os
+from typing import TYPE_CHECKING
+from zrb.group.any_group import AnyGroup
+from zrb.runner.web_config.config import WebConfig
+from zrb.runner.web_util.html import get_html_auth_link
+from zrb.runner.web_util.user import get_user_from_request
+from zrb.util.file import read_file
+from zrb.util.string.format import fstring_format
+if TYPE_CHECKING:
+    # We want fastapi to only be loaded when necessary to decrease footprint
+    from fastapi import FastAPI
+def serve_logout_page(
+    app: "FastAPI",
+    root_group: AnyGroup,
+    web_config: WebConfig,
+) -> None:
+    from fastapi import Request
+    from fastapi.responses import HTMLResponse
+    @app.get("/logout", response_class=HTMLResponse, include_in_schema=False)
+    async def logout(request: Request) -> HTMLResponse:
+        _DIR = os.path.dirname(__file__)
+        _VIEW_TEMPLATE = read_file(os.path.join(_DIR, "view.html"))
+        user = await get_user_from_request(web_config, request)
+        auth_link = get_html_auth_link(user)
+        return HTMLResponse(
+            fstring_format(
+                _VIEW_TEMPLATE,
+                {
+                    "name": root_group.name,
+                    "description": root_group.description,
+                    "auth_link": auth_link,
+                    "user": user,
+                },
+            )
+        )

zrb/runner/{web_controller/group_info_page/controller.py → web_route/node_page/group/show_group_page.py} RENAMED Viewed

@@ -1,8 +1,8 @@
 import os
 from zrb.group.any_group import AnyGroup
-from zrb.runner.web_config import User
-from zrb.runner.web_util import (
+from zrb.runner.web_schema.user import User
+from zrb.runner.web_util.html import (
     get_html_auth_link,
     get_html_subgroup_info,
     get_html_subtask_info,
@@ -11,7 +11,7 @@ from zrb.util.file import read_file
 from zrb.util.string.format import fstring_format
-def show_group_info_page(user: User, root_group: AnyGroup, group: AnyGroup, url: str):
+def show_group_page(user: User, root_group: AnyGroup, group: AnyGroup, url: str):
     from fastapi.responses import HTMLResponse
     _DIR = os.path.dirname(__file__)

zrb/runner/web_route/node_page/node_page_route.py ADDED Viewed

@@ -0,0 +1,50 @@
+import os
+from typing import TYPE_CHECKING
+from zrb.context.shared_context import SharedContext
+from zrb.group.any_group import AnyGroup
+from zrb.runner.web_config.config import WebConfig
+from zrb.runner.web_route.error_page.show_error_page import show_error_page
+from zrb.runner.web_route.node_page.group.show_group_page import show_group_page
+from zrb.runner.web_route.node_page.task.show_task_page import show_task_page
+from zrb.runner.web_util.user import get_user_from_request
+from zrb.session.session import Session
+from zrb.task.any_task import AnyTask
+from zrb.util.group import NodeNotFoundError, extract_node_from_args
+if TYPE_CHECKING:
+    # We want fastapi to only be loaded when necessary to decrease footprint
+    from fastapi import FastAPI
+def serve_node_page(
+    app: "FastAPI",
+    root_group: AnyGroup,
+    web_config: WebConfig,
+) -> None:
+    from fastapi import Request
+    from fastapi.responses import HTMLResponse
+    @app.get("/ui/{path:path}", response_class=HTMLResponse, include_in_schema=False)
+    async def ui_page(path: str, request: Request) -> HTMLResponse:
+        user = await get_user_from_request(web_config, request)
+        # Avoid capturing '/ui' itself
+        if not path:
+            return show_error_page(user, root_group, 422, "Undefined path")
+        args = path.strip("/").split("/")
+        try:
+            node, node_path, residual_args = extract_node_from_args(root_group, args)
+        except NodeNotFoundError as e:
+            return show_error_page(user, root_group, 404, str(e))
+        url = f"/ui/{'/'.join(node_path)}/"
+        if isinstance(node, AnyTask):
+            if not user.can_access_task(node):
+                return show_error_page(user, root_group, 403, "Forbidden")
+            shared_ctx = SharedContext(env=dict(os.environ))
+            session = Session(shared_ctx=shared_ctx, root_group=root_group)
+            return show_task_page(user, root_group, node, session, url, residual_args)
+        elif isinstance(node, AnyGroup):
+            if not user.can_access_group(node):
+                return show_error_page(user, root_group, 403, "Forbidden")
+            return show_group_page(user, root_group, node, url)
+        return show_error_page(user, root_group, 404, "Not found")

zrb/runner/{web_controller/session_page/controller.py → web_route/node_page/task/show_task_page.py} RENAMED Viewed

@@ -2,15 +2,15 @@ import json
 import os
 from zrb.group.any_group import AnyGroup
-from zrb.runner.web_config import User
-from zrb.runner.web_util import get_html_auth_link
+from zrb.runner.web_schema.user import User
+from zrb.runner.web_util.html import get_html_auth_link
 from zrb.session.any_session import AnySession
 from zrb.task.any_task import AnyTask
 from zrb.util.file import read_file
 from zrb.util.string.format import fstring_format
-def show_session_page(
+def show_task_page(
     user: User,
     root_group: AnyGroup,
     task: AnyTask,

zrb/runner/web_route/refresh_token_api_route.py ADDED Viewed

@@ -0,0 +1,38 @@
+from typing import TYPE_CHECKING
+from zrb.runner.web_config.config import WebConfig
+from zrb.runner.web_schema.token import RefreshTokenRequest
+from zrb.runner.web_util.cookie import set_auth_cookie
+from zrb.runner.web_util.token import regenerate_tokens
+if TYPE_CHECKING:
+    # We want fastapi to only be loaded when necessary to decrease footprint
+    from fastapi import FastAPI
+def serve_refresh_token_api(app: "FastAPI", web_config: WebConfig) -> None:
+    from fastapi import Cookie, Response
+    from fastapi.responses import JSONResponse
+    @app.post("/api/v1/refresh-token")
+    async def refresh_token_api(
+        response: Response,
+        body: RefreshTokenRequest = None,
+        refresh_token_cookie: str = Cookie(
+            None, alias=web_config.refresh_token_cookie_name
+        ),
+    ):
+        # Try to get the refresh token from the request body first
+        refresh_token = body.refresh_token if body else None
+        # If not in the body, try to get it from the cookie
+        if not refresh_token:
+            refresh_token = refresh_token_cookie
+        # If we still don't have a refresh token, raise an exception
+        if not refresh_token:
+            return JSONResponse(
+                content={"detail": "Refresh token not provided"}, status_code=400
+            )
+        # Get token
+        new_token = regenerate_tokens(web_config, refresh_token)
+        set_auth_cookie(web_config, response, new_token)
+        return new_token

zrb/runner/{web_controller/static → web_route/static/resources}/session/current-session.js RENAMED Viewed

@@ -13,14 +13,16 @@ const CURRENT_SESSION = {
                 for (const inputName in dataInputs) {
                     const inputValue = dataInputs[inputName];
                     const input = submitTaskForm.querySelector(`[name="${inputName}"]`);
-                    input.value = inputValue;
+                    if (input) {
+                        input.value = inputValue;
+                    }
                 }
                 resultLineCount = data.final_result.split("\n").length;
                 resultTextarea.rows = resultLineCount <= 5 ? resultLineCount : 5;
                 // update text areas
                 resultTextarea.value = data.final_result;
                 logTextarea.value = data.log.join("\n");
-                logTextarea.scrollTop = logTextarea.scrollHeight;
+                // logTextarea.scrollTop = logTextarea.scrollHeight;
                 // visualize history
                 this.showCurrentSession(data.task_status, data.finished);
                 if (data.finished) {
@@ -49,6 +51,7 @@ const CURRENT_SESSION = {
                     "Content-Type": "application/json"
                 },
             });
+            console.log("RESPONSE", response);
             return await response.json();
         } catch (error) {
             console.error("Error:", error);

zrb/runner/{web_controller/static → web_route/static/resources}/session/event.js RENAMED Viewed

@@ -20,9 +20,9 @@ window.addEventListener("load", async function () {
 const submitTaskForm = document.getElementById("submit-task-form");
-submitTaskForm.addEventListener("input", async function(event) {
+submitTaskForm.addEventListener("change", async function(event) {
     const currentInput = event.target;
-    const inputs = Array.from(submitTaskForm.querySelectorAll("input[name]"));
+    const inputs = Array.from(submitTaskForm.querySelectorAll("input[name], textarea[name]"));
     const inputMap = {};
     const fixedInputNames = [];
     for (const input of inputs) {
@@ -53,6 +53,9 @@ submitTaskForm.addEventListener("input", async function(event) {
                     return;
                 }
                 const input = submitTaskForm.querySelector(`[name="${key}"]`);
+                if (input === currentInput) {
+                    return;
+                }
                 input.value = value;
             });
         } else {

zrb/runner/web_route/static/static_route.py ADDED Viewed

@@ -0,0 +1,44 @@
+import os
+from typing import TYPE_CHECKING
+from zrb.runner.web_config.config import WebConfig
+from zrb.util.file import read_file
+if TYPE_CHECKING:
+    # We want fastapi to only be loaded when necessary to decrease footprint
+    from fastapi import FastAPI
+def serve_static_resources(app: "FastAPI", web_config: WebConfig) -> None:
+    from fastapi import HTTPException
+    from fastapi.responses import FileResponse, PlainTextResponse
+    from fastapi.staticfiles import StaticFiles
+    _STATIC_DIR = os.path.join(os.path.dirname(__file__), "resources")
+    app.mount("/static", StaticFiles(directory=_STATIC_DIR), name="static")
+    # Serve static files
+    @app.get("/static/{file_path:path}", include_in_schema=False)
+    async def static_files(file_path: str):
+        full_path = os.path.join(_STATIC_DIR, file_path)
+        if os.path.isfile(full_path):
+            return FileResponse(full_path)
+        raise HTTPException(status_code=404, detail="File not found")
+    @app.get("/refresh-token.js", include_in_schema=False)
+    async def refresh_token_js():
+        return PlainTextResponse(
+            content=_get_refresh_token_js(
+                60 * web_config.refresh_token_expire_minutes / 3
+            ),
+            media_type="application/javascript",
+        )
+def _get_refresh_token_js(refresh_interval_seconds: int):
+    _DIR = os.path.dirname(__file__)
+    return read_file(
+        os.path.join(_DIR, "refresh-token.template.js"),
+        {"refreshIntervalSeconds": f"{refresh_interval_seconds}"},
+    )

zrb/runner/web_route/task_input_api_route.py ADDED Viewed

@@ -0,0 +1,47 @@
+import json
+from typing import TYPE_CHECKING
+from zrb.group.any_group import AnyGroup
+from zrb.runner.common_util import get_run_kwargs
+from zrb.runner.web_config.config import WebConfig
+from zrb.runner.web_util.user import get_user_from_request
+from zrb.task.any_task import AnyTask
+from zrb.util.group import NodeNotFoundError, extract_node_from_args
+if TYPE_CHECKING:
+    # We want fastapi to only be loaded when necessary to decrease footprint
+    from fastapi import FastAPI
+def serve_task_input_api(
+    app: "FastAPI",
+    root_group: AnyGroup,
+    web_config: WebConfig,
+) -> None:
+    from fastapi import Query, Request
+    from fastapi.responses import JSONResponse
+    @app.get("/api/v1/task-inputs/{path:path}", response_model=dict[str, str])
+    async def get_default_inputs_api(
+        path: str,
+        request: Request,
+        query: str = Query("{}", description="JSON encoded inputs"),
+    ) -> dict[str, str]:
+        """
+        Getting input completion for path
+        """
+        user = await get_user_from_request(web_config, request)
+        args = path.strip("/").split("/")
+        try:
+            task, _, _ = extract_node_from_args(root_group, args)
+        except NodeNotFoundError:
+            return JSONResponse(content={"detail": "Not found"}, status_code=404)
+        if isinstance(task, AnyTask):
+            if not user.can_access_task(task):
+                return JSONResponse(content={"detail": "Forbidden"}, status_code=403)
+            query_dict = json.loads(query)
+            run_kwargs = get_run_kwargs(
+                task=task, args=[], kwargs=query_dict, prompt=False
+            )
+            return run_kwargs
+        return JSONResponse(content={"detail": "Not found"}, status_code=404)

zrb/runner/web_route/task_session_api_route.py ADDED Viewed

@@ -0,0 +1,147 @@
+import asyncio
+import os
+from datetime import datetime, timedelta
+from typing import TYPE_CHECKING, Any
+from zrb.context.shared_context import SharedContext
+from zrb.group.any_group import AnyGroup
+from zrb.runner.web_config.config import WebConfig
+from zrb.runner.web_schema.session import NewSessionResponse
+from zrb.runner.web_util.user import get_user_from_request
+from zrb.session.session import Session
+from zrb.session_state_log.session_state_log import SessionStateLog, SessionStateLogList
+from zrb.session_state_logger.any_session_state_logger import AnySessionStateLogger
+from zrb.task.any_task import AnyTask
+from zrb.util.group import NodeNotFoundError, extract_node_from_args, get_node_path
+if TYPE_CHECKING:
+    # We want fastapi to only be loaded when necessary to decrease footprint
+    from fastapi import FastAPI
+def serve_task_session_api(
+    app: "FastAPI",
+    root_group: AnyGroup,
+    web_config: WebConfig,
+    session_state_logger: AnySessionStateLogger,
+    coroutines: list,
+) -> None:
+    from fastapi import Query, Request
+    from fastapi.responses import JSONResponse
+    @app.post("/api/v1/task-sessions/{path:path}")
+    async def create_new_task_session_api(
+        path: str,
+        request: Request,
+        inputs: dict[str, Any],
+    ) -> NewSessionResponse:
+        """
+        Creating new session
+        """
+        user = await get_user_from_request(web_config, request)
+        args = path.strip("/").split("/")
+        try:
+            task, _, residual_args = extract_node_from_args(root_group, args)
+        except NodeNotFoundError:
+            return JSONResponse(content={"detail": "Not found"}, status_code=404)
+        if isinstance(task, AnyTask):
+            if not user.can_access_task(task):
+                return JSONResponse(content={"detail": "Forbidden"}, status_code=403)
+            session_name = residual_args[0] if residual_args else None
+            if not session_name:
+                shared_ctx = SharedContext(env=dict(os.environ))
+                session = Session(shared_ctx=shared_ctx, root_group=root_group)
+                coro = asyncio.create_task(task.async_run(session, str_kwargs=inputs))
+                coroutines.append(coro)
+                coro.add_done_callback(lambda coro: coroutines.remove(coro))
+                return NewSessionResponse(session_name=session.name)
+        return JSONResponse(content={"detail": "Not found"}, status_code=404)
+    @app.get(
+        "/api/v1/task-sessions/{path:path}",
+        response_model=SessionStateLog | SessionStateLogList,
+    )
+    async def get_task_session_api(
+        path: str,
+        request: Request,
+        min_start_query: str = Query(default=None, alias="from"),
+        max_start_query: str = Query(default=None, alias="to"),
+        page: int = Query(default=0, alias="page"),
+        limit: int = Query(default=10, alias="limit"),
+    ) -> SessionStateLog | SessionStateLogList:
+        """
+        Getting existing session or sessions
+        """
+        user = await get_user_from_request(web_config, request)
+        args = path.strip("/").split("/")
+        try:
+            task, _, residual_args = extract_node_from_args(root_group, args)
+        except NodeNotFoundError:
+            return JSONResponse(content={"detail": "Not found"}, status_code=404)
+        if isinstance(task, AnyTask) and residual_args:
+            if not user.can_access_task(task):
+                return JSONResponse(content={"detail": "Forbidden"}, status_code=403)
+            if residual_args[0] == "list":
+                task_path = get_node_path(root_group, task)
+                max_start_time = (
+                    datetime.now()
+                    if max_start_query is None
+                    else datetime.strptime(max_start_query, "%Y-%m-%d %H:%M:%S")
+                )
+                min_start_time = (
+                    max_start_time - timedelta(hours=1)
+                    if min_start_query is None
+                    else datetime.strptime(min_start_query, "%Y-%m-%d %H:%M:%S")
+                )
+                return sanitize_session_state_log_list(
+                    task,
+                    session_state_logger.list(
+                        task_path, min_start_time, max_start_time, page, limit
+                    ),
+                )
+            else:
+                return sanitize_session_state_log(
+                    task, session_state_logger.read(residual_args[0])
+                )
+        return JSONResponse(content={"detail": "Not found"}, status_code=404)
+def sanitize_session_state_log_list(
+    task: AnyTask, session_state_log_list: SessionStateLogList
+) -> SessionStateLogList:
+    return SessionStateLogList(
+        total=session_state_log_list.total,
+        data=[
+            sanitize_session_state_log(task, data)
+            for data in session_state_log_list.data
+        ],
+    )
+def sanitize_session_state_log(
+    task: AnyTask, session_state_log: SessionStateLog
+) -> SessionStateLog:
+    """
+    In session, we create snake_case aliases of inputs.
+    The purpose was to increase ergonomics, so that user can use `input.system_prompt`
+    instead of `input["system-prompt"]`
+    However, when we serve the session through HTTP API,
+    we only want to show the original input names.
+    """
+    enhanced_inputs = session_state_log.input
+    real_inputs = {}
+    for real_input in task.inputs:
+        real_input_name = real_input.name
+        real_inputs[real_input_name] = enhanced_inputs[real_input_name]
+    return SessionStateLog(
+        name=session_state_log.name,
+        start_time=session_state_log.start_time,
+        main_task_name=session_state_log.main_task_name,
+        path=session_state_log.path,
+        input=real_inputs,
+        final_result=session_state_log.final_result,
+        finished=session_state_log.finished,
+        log=session_state_log.log,
+        task_status=session_state_log.task_status,
+    )

zrb/runner/web_schema/session.py ADDED Viewed

@@ -0,0 +1,5 @@
+from pydantic import BaseModel
+class NewSessionResponse(BaseModel):
+    session_name: str

zrb/runner/web_schema/token.py ADDED Viewed

@@ -0,0 +1,11 @@
+from pydantic import BaseModel
+class RefreshTokenRequest(BaseModel):
+    refresh_token: str
+class Token(BaseModel):
+    access_token: str
+    refresh_token: str
+    token_type: str

zrb 1.0.0a21__py3-none-any.whl → 1.0.0b3__py3-none-any.whl

zrb 1.0.0a21py3-none-any.whl → 1.0.0b3py3-none-any.whl