lorax-arg 0.1__py3-none-any.whl

lorax/utils.py

@@ -0,0 +1,124 @@
+"""
+Lorax Utility Functions.
+
+JSON handling, file utilities, and other helpers.
+Note: LRU caches have been moved to lorax.cache.lru
+"""
+
+import json
+import re
+import os
+import numpy as np
+
+
+# Re-export LRU classes for backward compatibility during transition
+from lorax.cache.lru import LRUCache, LRUCacheWithMeta
+
+
+def make_json_safe(obj):
+    if isinstance(obj, dict):
+        return {k: make_json_safe(v) for k, v in obj.items()}
+    if isinstance(obj, set):
+        return sorted(obj)   # or list(obj)
+    if isinstance(obj, list):
+        return [make_json_safe(v) for v in obj]
+    return obj
+
+
+def ensure_json_dict(data):
+    # If already a dict, return as-is
+    if isinstance(data, dict):
+        return data
+
+    # If bytes, decode to string
+    if isinstance(data, (bytes, bytearray)):
+        data = data.decode("utf-8")
+    # If string, parse JSON
+    if isinstance(data, str):
+        return json.loads(data)
+
+    raise TypeError(f"Unsupported data type: {type(data)}")
+
+
+def make_json_serializable(obj):
+    """Convert to JSON-safe Python structures and decode nested JSON strings."""
+    if isinstance(obj, bytes):
+        try:
+            text = obj.decode('utf-8')
+            return make_json_serializable(json.loads(text))
+        except Exception:
+            return text
+    elif isinstance(obj, str):
+        # Try to parse JSON strings like '{"family_id": "ST082"}'
+        try:
+            parsed = json.loads(obj)
+            return make_json_serializable(parsed)
+        except Exception:
+            return obj
+    elif isinstance(obj, dict):
+        return {k: make_json_serializable(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        return [make_json_serializable(i) for i in obj]
+    elif hasattr(obj, '__dict__'):
+        return make_json_serializable(obj.__dict__)
+    elif isinstance(obj, np.ndarray):
+        return obj.tolist()
+    else:
+        return obj
+
+
+def extract_sample_names(newick_str):
+    tokens = re.findall(r'([^(),:]+):', newick_str)
+
+    samples = []
+    for t in tokens:
+        # Skip pure numbers (branch lengths)
+        if re.fullmatch(r'[0-9.+Ee-]+', t):
+            continue
+        samples.append(t)
+
+    # Remove duplicates while preserving order
+    return list(dict.fromkeys(samples))
+
+
+def max_branch_length_from_newick(nwk):
+    values = re.findall(r":([0-9.eE+-]+)", nwk)
+    if not values:
+        return 0.0
+    return max(map(float, values))
+
+
+def list_project_files(directory, projects, root, exclude_dirs=None):
+        """
+        Recursively list files and folders for the given directory.
+        If subdirectories are found, they are added as keys and populated similarly.
+        """
+        exclude = set(exclude_dirs or [])
+        for item in os.listdir(directory):
+            item_path = os.path.join(directory, item)
+            if os.path.isdir(item_path):
+                directory_name = os.path.relpath(item_path, root)
+                directory_basename = os.path.basename(item_path)
+                if directory_basename in exclude:
+                    continue
+                if directory_basename not in projects:
+                    projects[str(directory_basename)] = {
+                        "folder": str(directory_name),
+                        "files": [],
+                        "description": "",
+                    }
+                    list_project_files(
+                        item_path,
+                        projects,
+                        root=root,
+                        exclude_dirs=exclude,
+                    )
+            else:
+                directory_name = os.path.relpath(directory, root)
+                directory_basename = os.path.basename(directory)
+                if os.path.isfile(item_path) and (
+                    item.endswith(".trees") or item.endswith(".trees.tsz") or item.endswith(".csv")
+                ):
+                    if item not in projects[str(directory_basename)]["files"]:
+                        projects[str(directory_basename)]["files"].append(item)
+        return projects

lorax_app/__init__.py

@@ -0,0 +1,4 @@
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"
+

lorax_app/app.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Optional
+
+import socketio
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from starlette.middleware.gzip import GZipMiddleware
+
+from lorax.constants import (
+    MAX_HTTP_BUFFER_SIZE,
+    SOCKET_PING_INTERVAL,
+    SOCKET_PING_TIMEOUT,
+)
+from lorax.context import REDIS_CLUSTER_URL, REDIS_CLUSTER
+from lorax.routes import router as backend_router
+from lorax.sockets import register_socket_events
+
+
+def _get_static_dir() -> Path:
+    """
+    Resolve the directory containing the built website assets.
+
+    Precedence:
+    1) `LORAX_APP_STATIC_DIR` env var (useful for local/dev without copying assets)
+    2) Packaged `static/` directory (included in the wheel for pip installs)
+    """
+    override = os.getenv("LORAX_APP_STATIC_DIR")
+    if override:
+        return Path(override).expanduser().resolve()
+
+    # In a built wheel, `static/` is shipped as package data.
+    return Path(__file__).resolve().parent / "static"
+
+
+def _serve_file(path: Path) -> FileResponse:
+    if not path.exists() or not path.is_file():
+        raise HTTPException(status_code=404, detail="Not found")
+    return FileResponse(path)
+
+
+def create_fastapi_app(static_dir: Optional[Path] = None) -> FastAPI:
+    static_dir = static_dir or _get_static_dir()
+    index_html = static_dir / "index.html"
+    if not index_html.exists():
+        raise RuntimeError(
+            "Lorax UI assets not found.\n\n"
+            "If you are running from source, build the website and point the app to it:\n"
+            "  npm ci && VITE_API_BASE=/api npm --workspace packages/website run build\n"
+            "  export LORAX_APP_STATIC_DIR=packages/website/dist\n\n"
+            "If you are installing from PyPI, use an official wheel that includes UI assets."
+        )
+
+    app = FastAPI(title="Lorax App", version="0.1.0")
+    app.add_middleware(GZipMiddleware, minimum_size=1000)
+
+    allowed_origins = [
+        o.strip()
+        for o in os.getenv(
+            "ALLOWED_ORIGINS",
+            "http://localhost:3000,http://127.0.0.1:3000,http://localhost:3001,http://127.0.0.1:3001",
+        ).split(",")
+        if o.strip()
+    ]
+
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=allowed_origins,
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # Backend API under /api
+    app.include_router(backend_router, prefix="/api")
+
+    # Static files + SPA fallback
+    @app.get("/")
+    async def spa_root():
+        return _serve_file(index_html)
+
+    @app.get("/{path:path}")
+    async def spa_fallback(path: str, request: Request):
+        # Let /api/* be handled by the mounted backend router; if we got here,
+        # it wasn't a backend match, so treat it as 404.
+        if path.startswith("api/") or path == "api":
+            raise HTTPException(status_code=404, detail="Not found")
+
+        # Serve built asset directly if it exists (e.g. /assets/*.js, /logo.png).
+        candidate = (static_dir / path).resolve()
+        try:
+            candidate.relative_to(static_dir.resolve())
+        except ValueError:
+            # Prevent path traversal.
+            raise HTTPException(status_code=400, detail="Invalid path")
+
+        if candidate.exists() and candidate.is_file():
+            return _serve_file(candidate)
+
+        # SPA route (e.g. /<file>?project=Uploads)
+        return _serve_file(index_html)
+
+    return app
+
+
+def create_asgi_app() -> socketio.ASGIApp:
+    """
+    Create the combined ASGI app.
+
+    - UI served by FastAPI routes.
+    - Backend router mounted at /api.
+    - Socket.IO served at /api/socket.io/.
+    """
+    fastapi_app = create_fastapi_app()
+
+    client_manager = None
+    if REDIS_CLUSTER_URL and not REDIS_CLUSTER:
+        client_manager = socketio.AsyncRedisManager(REDIS_CLUSTER_URL)
+    elif REDIS_CLUSTER_URL and REDIS_CLUSTER:
+        print("Warning: Socket.IO Redis manager does not support Redis Cluster; running without shared manager.")
+
+    if client_manager:
+        sio = socketio.AsyncServer(
+            async_mode="asgi",
+            cors_allowed_origins="*",
+            client_manager=client_manager,
+            logger=False,
+            engineio_logger=False,
+            ping_timeout=SOCKET_PING_TIMEOUT,
+            ping_interval=SOCKET_PING_INTERVAL,
+            max_http_buffer_size=MAX_HTTP_BUFFER_SIZE,
+        )
+    else:
+        sio = socketio.AsyncServer(
+            async_mode="asgi",
+            cors_allowed_origins="*",
+            logger=False,
+            engineio_logger=False,
+            ping_timeout=SOCKET_PING_TIMEOUT,
+            ping_interval=SOCKET_PING_INTERVAL,
+            max_http_buffer_size=MAX_HTTP_BUFFER_SIZE,
+        )
+
+    register_socket_events(sio)
+
+    # Expose socket endpoint under /api/socket.io
+    return socketio.ASGIApp(
+        sio,
+        other_asgi_app=fastapi_app,
+        socketio_path="api/socket.io",
+    )
+
+
+# Default importable app for uvicorn: `uvicorn lorax_app.app:asgi_app`
+asgi_app = create_asgi_app()
+

lorax_app/cli.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import shutil
+import threading
+import time
+import webbrowser
+from pathlib import Path
+from urllib.parse import quote
+from urllib.request import urlopen
+
+import click
+
+from lorax.constants import UPLOADS_DIR
+
+
+def _copy_into_uploads(src: Path) -> str:
+    """
+    Copy a user-provided file into the backend's local uploads location.
+
+    Local-mode uploads layout is:
+      <UPLOADS_DIR>/Uploads/<filename>
+    """
+    src = src.expanduser().resolve()
+    if not src.exists() or not src.is_file():
+        raise click.ClickException(f"File not found: {src}")
+
+    uploads_root = Path(UPLOADS_DIR) / "Uploads"
+    uploads_root.mkdir(parents=True, exist_ok=True)
+
+    dest = uploads_root / src.name
+    print(f"Copying {src} to {dest}")
+    shutil.copy2(src, dest)
+    return dest.name
+
+
+def _wait_for_health(base_url: str, timeout_s: float = 20.0, interval_s: float = 0.5) -> bool:
+    """Poll /api/health until the server is ready (or timeout)."""
+    deadline = time.monotonic() + timeout_s
+    health_url = f"{base_url}/api/health"
+    while time.monotonic() < deadline:
+        try:
+            with urlopen(health_url, timeout=1) as resp:
+                if resp.status == 200:
+                    return True
+        except Exception:
+            pass
+        time.sleep(interval_s)
+    return False
+
+
+@click.group(
+    context_settings={"help_option_names": ["-h", "--help"], "allow_extra_args": True},
+    invoke_without_command=True,
+)
+@click.option("--file", "file_path", type=click.Path(dir_okay=False, path_type=Path))
+@click.option("--host", default="127.0.0.1", show_default=True)
+@click.option("--port", default=3000, type=int, show_default=True)
+@click.pass_context
+def main(
+    ctx: click.Context,
+    file_path: Path | None,
+    host: str,
+    port: int,
+):
+    """
+    Run Lorax as a single-port app (UI + backend).
+
+    If FILE is provided, it is copied into Lorax uploads and the browser opens
+    directly to the viewer route for that file.
+    """
+    if ctx.invoked_subcommand is None:
+        file = file_path
+        if file is None and ctx.args:
+            candidate = Path(ctx.args[0]).expanduser()
+            if candidate.exists() and candidate.is_file():
+                file = candidate
+            else:
+                raise click.ClickException(f"File not found: {candidate}")
+        _serve(file=file, host=host, port=port)
+
+
+def _serve(file: Path | None, host: str, port: int) -> None:
+    import uvicorn
+
+    filename = None
+    if file is not None:
+        filename = _copy_into_uploads(file)
+
+    def open_browser_delayed():
+        base = f"http://{host}:{port}" if host != "0.0.0.0" else f"http://127.0.0.1:{port}"
+        ready = _wait_for_health(base)
+        if not ready:
+            click.echo("Warning: /api/health did not respond yet; opening browser anyway.")
+        if filename:
+            url = f"{base}/{quote(filename)}?project=Uploads"
+        else:
+            url = f"{base}/"
+        click.echo(f"Opening browser: {url}")
+        webbrowser.open(url)
+
+    threading.Thread(target=open_browser_delayed, daemon=True).start()
+
+    click.echo(f"Starting Lorax app on {host}:{port}")
+    uvicorn.run(
+        "lorax_app.app:asgi_app",
+        host=host,
+        port=port,
+        reload=False,
+        log_level="info",
+    )
+
+
+if __name__ == "__main__":
+    main()