setta 0.0.1.dev0__py3-none-any.whl → 0.0.2.dev0__py3-none-any.whl

setta/routers/sections.py

@@ -0,0 +1,174 @@
+import os
+from pathlib import Path
+from typing import Dict, List
+
+from fastapi import APIRouter, HTTPException, status
+from pydantic import BaseModel
+
+from setta.code_gen.export_selected import (
+    export_param_sweep_section_to_dict,
+    export_section_to_dict,
+    export_single_run_group_to_dict,
+)
+from setta.code_gen.yaml.section_dict import (
+    param_sweep_dict_to_yaml,
+    run_group_dict_to_yaml,
+    section_dict_to_yaml,
+)
+from setta.database.db.sections.copy import (
+    copy_relative_positions,
+    copy_sections_and_other_info,
+)
+from setta.database.db.sections.jsonSource import save_json_source_data
+from setta.database.db.sections.load import load_json_sources_into_data_structures
+from setta.utils.constants import C
+from setta.utils.generate_new_filename import generate_new_filename
+
+router = APIRouter()
+
+
+class SectionsMakeCopyRequest(BaseModel):
+    sectionsAndOtherInfo: dict
+
+
+class SectionToYamlRequest(BaseModel):
+    codeInfo: dict
+    codeInfoChildren: dict
+    sectionVariant: dict
+    pinnedIds: Dict[str, List[str]]
+    unpinnedIds: Dict[str, List[str]]
+
+
+class ParamSweepSectionToYamlRequest(BaseModel):
+    sweep: list
+    codeInfo: dict
+    codeInfoChildren: dict
+
+
+class GlobalParamSweepSectionToYamlRequest(BaseModel):
+    runGroup: dict | None
+    sections: dict
+    sectionVariants: dict
+
+
+class LoadSectionJSONSourceRequest(BaseModel):
+    project: dict
+    sectionId: str
+    jsonSource: str
+
+
+class SaveSectionJSONSourceRequest(BaseModel):
+    project: dict
+    sectionId: str
+    forking_from: str
+
+
+class NewJSONVersionNameRequest(BaseModel):
+    filenameGlob: str
+
+
+class GetJSONSourcePathToBeDeleted(BaseModel):
+    variantName: str
+
+
+class DeleteFileRequest(BaseModel):
+    filepath: str
+
+
+@router.post(C.ROUTE_COPY_SECTIONS)
+def route_sections_make_copy(x: SectionsMakeCopyRequest):
+    output = copy_sections_and_other_info(x.sectionsAndOtherInfo)
+    relativePositions = copy_relative_positions(
+        x.sectionsAndOtherInfo["relativePositions"], output["section_id_map"]
+    )
+    output.pop("section_id_map")
+    return {**output, "relativePositions": relativePositions}
+
+
+@router.post(C.ROUTE_SECTION_TO_YAML)
+def route_section_to_yaml(x: SectionToYamlRequest):
+    output = export_section_to_dict(
+        x.codeInfo,
+        x.codeInfoChildren,
+        x.sectionVariant,
+        {"pinned": x.pinnedIds, "unpinned": x.unpinnedIds},
+    )
+
+    yamlValue = section_dict_to_yaml(output, x.codeInfo, x.sectionVariant)
+
+    return {
+        "yamlValue": yamlValue,
+        "originalObj": {
+            "pinned": output["pinned"].output,
+            "unpinned": output["unpinned"].output,
+        },
+    }
+
+
+@router.post(C.ROUTE_PARAM_SWEEP_SECTION_TO_YAML)
+def route_param_sweep_section_to_yaml(x: ParamSweepSectionToYamlRequest):
+    output = export_param_sweep_section_to_dict(x.sweep, x.codeInfo, x.codeInfoChildren)
+    yamlValue = param_sweep_dict_to_yaml(output)
+    return {"yamlValue": yamlValue, "originalObj": {}}
+
+
+@router.post(C.ROUTE_GLOBAL_PARAM_SWEEP_SECTION_TO_YAML)
+def route_global_param_sweep_section_to_yaml(x: GlobalParamSweepSectionToYamlRequest):
+    output = export_single_run_group_to_dict(
+        x.runGroup,
+        x.sections,
+        x.sectionVariants,
+    )
+    yamlValue = run_group_dict_to_yaml(output)
+    return {"yamlValue": yamlValue, "originalObj": {}}
+
+
+@router.post(C.ROUTE_LOAD_SECTION_JSON_SOURCE)
+def route_load_section_json_source(x: LoadSectionJSONSourceRequest):
+    p = x.project
+    p["sections"][x.sectionId]["jsonSource"] = x.jsonSource
+    load_json_sources_into_data_structures(
+        p["sections"],
+        p["codeInfo"],
+        p["codeInfoCols"],
+        p["sectionVariants"],
+        section_ids=[x.sectionId],
+    )
+    return {"project": p}
+
+
+@router.post(C.ROUTE_NEW_JSON_VERSION_NAME)
+def route_new_json_version_name(x: NewJSONVersionNameRequest):
+    new_filename = generate_new_filename(x.filenameGlob)
+    Path(new_filename).parent.mkdir(parents=True, exist_ok=True)
+    Path(new_filename).touch()
+    return new_filename
+
+
+@router.post(C.ROUTE_SAVE_SECTION_JSON_SOURCE)
+def route_save_section_json_source(x: SaveSectionJSONSourceRequest):
+    save_json_source_data(x.project, [x.sectionId], x.forking_from)
+
+
+@router.post(C.ROUTE_GET_JSON_SOURCE_PATH_TO_BE_DELETED)
+def route_get_json_source_path_to_be_deleted(x: GetJSONSourcePathToBeDeleted):
+    return os.path.abspath(x.variantName)
+
+
+@router.post(C.ROUTE_DELETE_FILE)
+def route_delete_file(x: DeleteFileRequest):
+    file = Path(x.filepath)
+    if not file.exists():
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"File '{x.filepath}' not found",
+        )
+
+    try:
+        file.unlink()
+        return {"message": f"File '{x.filepath}' deleted successfully"}
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Failed to delete file: {str(e)}",
+        )

setta/routers/settings.py

@@ -0,0 +1,40 @@
+from fastapi import APIRouter, Depends
+from pydantic import BaseModel
+
+from setta.utils.constants import C
+
+from .dependencies import get_settings_file
+
+router = APIRouter()
+
+
+class SaveSettingsRequest(BaseModel):
+    settings: dict
+
+
+class SaveSettingsProjectRequest(BaseModel):
+    settingsProject: dict
+
+
+@router.post(C.ROUTE_SAVE_SETTINGS)
+def route_save_settings(
+    x: SaveSettingsRequest, settings_file=Depends(get_settings_file)
+):
+    return settings_file.save_settings(x.settings)
+
+
+@router.post(C.ROUTE_LOAD_SETTINGS)
+def route_load_settings(settings_file=Depends(get_settings_file)):
+    return settings_file.load_settings()
+
+
+@router.post(C.ROUTE_SAVE_SETTINGS_PROJECT)
+def route_save_settings_project(
+    x: SaveSettingsProjectRequest, settings_file=Depends(get_settings_file)
+):
+    return settings_file.save_settings_project(x.settingsProject)
+
+
+@router.post(C.ROUTE_LOAD_SETTINGS_PROJECT)
+def route_load_settings_project(settings_file=Depends(get_settings_file)):
+    return settings_file.load_settings_project()

setta/routers/terminals.py

@@ -0,0 +1,83 @@
+import asyncio
+import logging
+from typing import List
+
+from fastapi import APIRouter, Depends, WebSocket
+from pydantic import BaseModel
+
+from setta.utils.constants import C
+
+from .dependencies import (
+    get_lsp_writers_from_websocket,
+    get_terminal_websockets,
+    get_terminal_websockets_from_websocket,
+)
+
+logger = logging.getLogger(__name__)
+
+
+router = APIRouter()
+
+
+class DeleteTerminalsRequest(BaseModel):
+    sectionIds: List[str]
+
+
+@router.websocket(C.ROUTE_TERMINAL)
+async def terminal_websocket_endpoint(
+    websocket: WebSocket,
+    projectConfigId: str,
+    sectionId: str,
+    id: str,
+    isTemporary: bool,
+    terminal_websockets=Depends(get_terminal_websockets_from_websocket),
+    lsp_writers=Depends(get_lsp_writers_from_websocket),
+):
+    # First check if terminal exists
+    isNew = terminal_websockets.new_terminal(projectConfigId, sectionId, isTemporary)
+
+    # Start the background task for terminal handling
+    async def handle_terminal():
+        read_task = asyncio.get_running_loop().create_task(
+            terminal_websockets.read_from_terminal(sectionId)
+        )
+        await read_task
+        await terminal_websockets.delete_terminal(sectionId)
+
+    # Create the background task
+    if isNew:
+        asyncio.get_running_loop().create_task(handle_terminal())
+
+    try:
+        await terminal_websockets.connect(websocket, sectionId, id)
+        write_task = asyncio.get_running_loop().create_task(
+            terminal_websockets.write_to_terminal(websocket, lsp_writers, sectionId)
+        )
+        await write_task
+    except:
+        pass
+    finally:
+        # Cleanup
+        logger.debug(f"terminal_websocket_endpoint disconnect: {id}")
+        terminal_websockets.disconnect(sectionId, id)
+
+
+@router.post(C.ROUTE_GET_FREE_TERMINAL)
+def route_terminal_get_free_terminal(
+    projectConfigId, terminal_websockets=Depends(get_terminal_websockets)
+):
+    return terminal_websockets.get_free_terminal(projectConfigId)
+
+
+@router.post(C.ROUTE_DELETE_TERMINALS)
+async def route_terminal_delete_terminals(
+    x: DeleteTerminalsRequest, terminal_websockets=Depends(get_terminal_websockets)
+):
+    await terminal_websockets.delete_terminals(x.sectionIds)
+
+
+@router.post(C.ROUTE_GET_EXISTING_TERMINALS)
+def route_terminal_get_existing_terminals(
+    projectConfigId, terminal_websockets=Depends(get_terminal_websockets)
+):
+    return terminal_websockets.get_existing_terminals(projectConfigId)

setta/routers/websocket.py

@@ -0,0 +1,36 @@
+import json
+import logging
+import traceback
+
+from fastapi import APIRouter, Depends, WebSocket, WebSocketDisconnect
+
+from setta.utils.constants import C
+
+from .dependencies import get_tasks_from_websocket, get_websocket_manager_from_websocket
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+@router.websocket(C.ROUTE_WEBSOCKET_MANAGER)
+async def websocket_endpoint(
+    websocket: WebSocket,
+    websocket_manager=Depends(get_websocket_manager_from_websocket),
+    tasks=Depends(get_tasks_from_websocket),
+):
+    id = await websocket_manager.connect(websocket)
+    while True:
+        try:
+            data = await websocket.receive_text()
+            await websocket_manager.send_message(
+                json.loads(data), fromWebsocketId=id, tasks=tasks
+            )
+        except WebSocketDisconnect:
+            logger.debug("WebSocketDisconnect!")
+            await websocket_manager.disconnect(id)
+            break
+        except Exception as e:
+            logger.debug(f"Exception details:\n{traceback.format_exc()}")
+            logger.debug(e)
+            logger.debug("caught the exception!")

setta/server.py

@@ -0,0 +1,141 @@
+import logging
+import os
+from contextlib import asynccontextmanager
+from pathlib import Path
+
+from fastapi import FastAPI, Request, status
+from fastapi.exceptions import RequestValidationError
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+
+from setta.database.db_init import maybe_create_tables_and_seed
+from setta.database.db_objs import DBQueue
+from setta.database.settings_file import SettingsFile
+from setta.lsp.utils import (
+    create_file_watcher,
+    create_lsp_readers,
+    create_lsp_writers,
+    create_lsps,
+    kill_lsps,
+    start_lsps,
+)
+from setta.routers import (
+    artifact_router,
+    code_info_router,
+    in_memory_fn_stdout_router,
+    interactive_code_router,
+    lsp_router,
+    projects_router,
+    reference_renaming_router,
+    sections_router,
+    settings_router,
+    terminals_router,
+    websocket_router,
+)
+from setta.tasks.tasks import Tasks
+from setta.terminals.terminals import TerminalWebsockets
+from setta.utils.constants import CODE_FOLDER, USER_SETTINGS, C
+from setta.utils.utils import get_absolute_path, is_dev_mode
+from setta.utils.websocket_manager import WebsocketManager
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # startup
+    app.state.settings_file = SettingsFile()
+    app.state.lsps = create_lsps(
+        workspace_folder=Path(os.getcwd()),
+        code_folder=Path(os.getcwd()) / CODE_FOLDER / "temp_folder",
+        settings=USER_SETTINGS["languageServer"],
+    )
+    app.state.lsp_writers = create_lsp_writers(app.state.lsps)
+    app.state.file_watcher = create_file_watcher(app.state.lsps, app.state.lsp_writers)
+    app.state.terminal_websockets = TerminalWebsockets()
+    app.state.websocket_manager = WebsocketManager()
+    app.state.tasks = Tasks(app.state.lsp_writers)
+    app.state.lsp_readers = create_lsp_readers(
+        app.state.lsps, app.state.websocket_manager
+    )
+    app.state.dbq = DBQueue(
+        C.DB_PATH,
+    )
+
+    maybe_create_tables_and_seed(
+        app.state.dbq,
+        with_examples=C.WITH_EXAMPLES,
+        with_base_ui_types=True,
+    )
+
+    app.state.dbq.connect()
+    await start_lsps(
+        app.state.lsps,
+        app.state.lsp_readers,
+        app.state.lsp_writers,
+    )
+    app.state.file_watcher.start()
+
+    if not is_dev_mode():
+        # Mount the 'frontend/dist' directory at '/static'
+        frontend_folder = Path("static/frontend")
+        dist_path = get_absolute_path(__file__, frontend_folder)
+        app.mount(
+            "/static",
+            StaticFiles(directory=dist_path, html=True),
+            name="static",
+        )
+
+        # {full_path:path} is to catch all paths not explicitly covered here
+        @app.get("/{full_path:path}", response_class=HTMLResponse)
+        async def read_root(full_path: str):
+            # Adjust the path to match the location of your 'index.html'
+            with open(dist_path / "index.html") as f:
+                content = f.read()
+            return content
+
+    print(f"Ready: {C.BACKEND}", flush=True)
+    try:
+        yield
+    finally:
+        app.state.tasks.close()
+        app.state.file_watcher.stop()
+        await kill_lsps(app.state.lsps, app.state.lsp_readers)
+
+
+app = FastAPI(
+    lifespan=lifespan,
+    openapi_url=f"{C.ROUTE_PREFIX}{C.ROUTE_OPENAPI_DOCS}",
+    docs_url=f"{C.ROUTE_PREFIX}{C.ROUTE_SWAGGER_DOCS}",
+    redoc_url=f"{C.ROUTE_PREFIX}{C.ROUTE_REDOC_DOCS}",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=C.FRONTEND_ORIGINS,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+kwargs = {"prefix": C.ROUTE_PREFIX}
+app.include_router(projects_router, **kwargs)
+app.include_router(sections_router, **kwargs)
+app.include_router(terminals_router, **kwargs)
+app.include_router(websocket_router, **kwargs)
+app.include_router(code_info_router, **kwargs)
+app.include_router(settings_router, **kwargs)
+app.include_router(interactive_code_router, **kwargs)
+app.include_router(artifact_router, **kwargs)
+app.include_router(reference_renaming_router, **kwargs)
+app.include_router(in_memory_fn_stdout_router, **kwargs)
+app.include_router(lsp_router, **kwargs)
+
+
+# https://github.com/tiangolo/fastapi/issues/3361#issuecomment-1002120988
+@app.exception_handler(RequestValidationError)
+async def validation_exception_handler(request: Request, exc: RequestValidationError):
+    exc_str = f"{exc}".replace("\n", " ").replace("   ", " ")
+    logging.error(f"{request}: {exc_str}")
+    content = {"status_code": 10422, "message": exc_str, "data": None}
+    return JSONResponse(
+        content=content, status_code=status.HTTP_422_UNPROCESSABLE_ENTITY
+    )

setta/start.py

@@ -0,0 +1,112 @@
+import asyncio
+import logging
+import sys
+from pathlib import Path
+
+import click
+import uvicorn
+
+from . import __version__
+from .cli.connect import connect as _connect
+from .database.db_init import maybe_create_tables_and_seed
+from .database.db_objs import DBQueue
+from .database.db_path import get_default_db_path
+from .database.export_db.export_db import export_database
+from .database.import_db import import_database
+from .utils.constants import C, set_constants
+
+
+@click.command()
+@click.argument("websocket_id", required=False)
+@click.option("--host", default=C.DEFAULT_HOST, help="backend host")
+@click.option("--port", default=C.DEFAULT_PORT, help="backend port")
+def connect(websocket_id, host, port):
+    set_constants(host=host, port=port)
+    asyncio.run(_connect(websocket_id))
+
+
+@click.command()
+def version():
+    print(f"setta version {__version__}")
+
+
+@click.command()
+@click.argument(
+    "path",
+    type=click.Path(file_okay=True, dir_okay=False, writable=True),
+    required=True,
+)
+@click.option("--with_examples", is_flag=True)
+def init_db(path, with_examples):
+    dbq = DBQueue(path)
+    maybe_create_tables_and_seed(dbq, with_examples)
+
+
+@click.command()
+@click.argument("path", default=get_default_db_path(), required=False)
+def export_db(path):
+    export_database(path)
+
+
+@click.command()
+@click.argument("yaml_path", required=True)
+@click.argument("output_path", required=True)
+def import_db(yaml_path, output_path):
+    import_database(yaml_path, output_path)
+
+
+@click.group(
+    invoke_without_command=True,
+    context_settings=dict(
+        ignore_unknown_options=True,
+    ),
+)
+@click.option("--reload", is_flag=True)
+@click.option("--with-examples", is_flag=True)
+@click.option("--db", "-d", type=str, default=get_default_db_path())
+@click.option("--host", default=C.DEFAULT_HOST, help="backend host")
+@click.option("--port", default=C.DEFAULT_PORT, help="backend port")
+@click.option(
+    "--log-level",
+    type=click.Choice(
+        ["critical", "error", "warning", "info", "debug"], case_sensitive=False
+    ),
+    default="critical",
+    help="Set the logging level",
+)
+@click.pass_context
+def cli(ctx, reload, with_examples, db, host, port, log_level):
+    if ctx.invoked_subcommand is None:
+        print("Starting Setta", flush=True)
+
+        set_constants(
+            with_examples=with_examples,
+            db_path=db,
+            host=host,
+            port=port,
+        )
+
+        sys.path.append(str(Path(__file__).resolve().parent))
+
+        logging.basicConfig(
+            level=getattr(logging, log_level.upper()),
+            format="%(levelname)s - %(asctime)s - %(name)s - %(message)s",
+        )
+
+        config = uvicorn.Config(
+            "server:app",
+            host=host,
+            port=port,
+            log_level=log_level,
+            reload=reload,
+        )
+        server = uvicorn.Server(config)
+
+        server.run()
+
+
+cli.add_command(connect)
+cli.add_command(version)
+cli.add_command(init_db)
+cli.add_command(export_db)
+cli.add_command(import_db)