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

setta/routers/artifact.py

@@ -0,0 +1,105 @@
+import os
+from typing import List
+
+from fastapi import APIRouter, Depends
+from pydantic import BaseModel
+
+from setta.cli.logger import load_from_csv_base64
+from setta.database.db.artifacts.load import (
+    load_artifact_from_disk,
+    load_artifact_metadata_and_maybe_value_from_disk,
+    load_available_artifacts,
+)
+from setta.database.db.artifacts.save_or_create import (
+    get_artifact_ids,
+    save_or_create_artifacts,
+)
+from setta.utils.constants import C
+
+from .dependencies import get_dbq, get_websocket_manager
+
+router = APIRouter()
+
+
+class SendArtifactRequest(BaseModel):
+    data: List[dict]
+    saveTo: str
+    messageType: str
+
+
+class LoadArtifactsRequest(BaseModel):
+    artifactIds: List[str]
+
+
+class LoadAvailableArtifactsRequest(BaseModel):
+    sectionType: str
+
+
+class CheckIfFileExistsRequests(BaseModel):
+    filepath: str
+
+
+class LoadArtifactFromDiskRequest(BaseModel):
+    filepath: str
+    type: str
+
+
+class ReadCSVBase64Request(BaseModel):
+    base64Str: str
+
+
+class GetArtifactIdsFromNamePathType(BaseModel):
+    namesPathsTypes: list
+
+
+@router.post(C.ROUTE_SEND_ARTIFACT)
+async def route_send_artifact(
+    x: SendArtifactRequest,
+    dbq=Depends(get_dbq),
+    websocket_manager=Depends(get_websocket_manager),
+):
+    with dbq as db:
+        artifact_ids = save_or_create_artifacts(db, x.data, x.saveTo)
+
+    for idx, d in enumerate(x.data):
+        d["id"] = artifact_ids[idx]
+
+    await websocket_manager.broadcast({"content": x.data, "messageType": x.messageType})
+    return artifact_ids
+
+
+@router.post(C.ROUTE_LOAD_ARTIFACTS)
+def route_load_artifacts(x: LoadArtifactsRequest, dbq=Depends(get_dbq)):
+    with dbq as db:
+        return load_artifact_metadata_and_maybe_value_from_disk(db, x.artifactIds)
+
+
+@router.post(C.ROUTE_LOAD_AVAILABLE_ARTIFACTS)
+def route_load_available_artifacts(
+    x: LoadAvailableArtifactsRequest, dbq=Depends(get_dbq)
+):
+    with dbq as db:
+        return load_available_artifacts(db, x.sectionType)
+
+
+@router.post(C.ROUTE_CHECK_IF_FILE_EXISTS)
+def route_check_if_file_exists(x: CheckIfFileExistsRequests):
+    return os.path.exists(x.filepath)
+
+
+@router.post(C.ROUTE_LOAD_ARTIFACT_FROM_DISK)
+def route_load_artifact_from_disk(x: LoadArtifactFromDiskRequest):
+    return load_artifact_from_disk(x.filepath, x.type)
+
+
+@router.post(C.ROUTE_READ_CSV_BASE64)
+def route_read_csv_base64(x: ReadCSVBase64Request):
+    return load_from_csv_base64(x.base64Str)
+
+
+@router.post(C.ROUTE_GET_ARTIFACT_IDS_FROM_NAME_PATH_TYPE)
+def route_get_artifact_ids_from_name_path_type(
+    x: GetArtifactIdsFromNamePathType, dbq=Depends(get_dbq)
+):
+    with dbq as db:
+        return get_artifact_ids(db, x.namesPathsTypes)

setta/routers/code_info.py

@@ -0,0 +1,32 @@
+import docstring_to_markdown
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+
+from setta.database.db.codeInfo.save import save_code_info
+from setta.utils.constants import C
+
+from .dependencies import get_dbq
+
+router = APIRouter()
+
+
+class SaveCodeInfoRequest(BaseModel):
+    codeInfo: dict
+
+
+class DocstringToMarkdownRequest(BaseModel):
+    docstring: str
+
+
+@router.post(C.ROUTE_SAVE_CODE_INFO)
+def route_save_code_info(x: SaveCodeInfoRequest, dbq=Depends(get_dbq)):
+    with dbq as db:
+        save_code_info(db, x.codeInfo)
+
+
+@router.post(C.ROUTE_DOCSTRING_TO_MARKDOWN)
+def route_docstring_to_markdown(x: DocstringToMarkdownRequest):
+    try:
+        return docstring_to_markdown.convert(x.docstring)
+    except docstring_to_markdown.UnknownFormatError as e:
+        raise HTTPException(status_code=400, detail=str(e))

setta/routers/dependencies.py

@@ -0,0 +1,49 @@
+from fastapi import Request, WebSocket
+
+
+def get_dbq(request: Request):
+    return request.app.state.dbq
+
+
+def get_tasks(request: Request):
+    return request.app.state.tasks
+
+
+def get_tasks_from_websocket(websocket: WebSocket):
+    return websocket.app.state.tasks
+
+
+def get_settings_file(request: Request):
+    return request.app.state.settings_file
+
+
+def get_terminal_websockets(request: Request):
+    return request.app.state.terminal_websockets
+
+
+def get_terminal_websockets_from_websocket(websocket: WebSocket):
+    return websocket.app.state.terminal_websockets
+
+
+def get_websocket_manager(request: Request):
+    return request.app.state.websocket_manager
+
+
+def get_websocket_manager_from_websocket(websocket: WebSocket):
+    return websocket.app.state.websocket_manager
+
+
+def get_lsps(request: Request):
+    return [
+        request.app.state.lsps,
+        request.app.state.lsp_readers,
+        request.app.state.lsp_writers,
+    ]
+
+
+def get_lsp_writers(request: Request):
+    return request.app.state.lsp_writers
+
+
+def get_lsp_writers_from_websocket(websocket: WebSocket):
+    return websocket.app.state.lsp_writers

setta/routers/in_memory_fn_stdout_websocket.py

@@ -0,0 +1,21 @@
+from fastapi import APIRouter, Depends, WebSocket, WebSocketDisconnect
+
+from setta.utils.constants import C
+
+from .dependencies import get_tasks_from_websocket
+
+router = APIRouter()
+
+
+@router.websocket(C.ROUTE_IN_MEMORY_FN_STDOUT_WEBSOCKET)
+async def in_memory_fn_stdout(
+    websocket: WebSocket,
+    tasks=Depends(get_tasks_from_websocket),
+):
+    await tasks.connect(websocket)
+    try:
+        while True:
+            # Keep the connection alive by waiting for the client disconnect
+            await websocket.receive_text()
+    except WebSocketDisconnect:
+        await tasks.disconnect(websocket)

setta/routers/interactive.py

@@ -0,0 +1,119 @@
+import black
+from fastapi import APIRouter, Depends
+from pydantic import BaseModel
+
+from setta.code_gen.create_runnable_scripts import (
+    generate_final_code_for_sections,
+    prune_and_topological_sort,
+    sanitize_section_path_full_name,
+)
+from setta.code_gen.export_selected import (
+    export_for_in_memory_fn,
+    export_selected,
+    get_section_code,
+    get_section_type,
+)
+from setta.tasks.fns.utils import replace_template_vars_with_random_names
+from setta.utils.constants import C
+from setta.utils.utils import multireplace
+
+from .dependencies import get_lsp_writers, get_tasks
+
+router = APIRouter()
+
+
+class UpdateInteractiveCodeRequest(BaseModel):
+    project: dict
+
+
+class FormatCodeRequest(BaseModel):
+    project: dict
+    candidateTemplateVars: dict
+
+
+@router.post(C.ROUTE_UPDATE_INTERACTIVE_CODE)
+async def route_update_interactive_code(
+    x: UpdateInteractiveCodeRequest,
+    tasks=Depends(get_tasks),
+    lsp_writers=Depends(get_lsp_writers),
+):
+    p = x.project
+    exporter_obj = export_selected(
+        p, always_export_args_objs=False, force_include_template_var=True
+    )
+    exporter_obj_in_memory = export_for_in_memory_fn(p)
+
+    template_var_replacement_values = {}
+    for variant in p["sectionVariants"].values():
+        for t in variant["templateVars"]:
+            if not t["sectionId"]:
+                continue
+            template_var_replacement_values[
+                t["keyword"]
+            ] = create_in_memory_module_name(p, t["sectionId"])
+
+    code_dict = await generate_final_code_for_sections(
+        p,
+        exporter_obj,
+        lsp_writers=lsp_writers,
+        folder_path="",
+        do_prepend_with_setup_code=True,
+        do_convert_var_names_to_readable_form=True,
+        template_var_replacement_values=template_var_replacement_values,
+    )
+
+    to_import, _ = prune_and_topological_sort(code_dict, p["importCodeBlocks"])
+    to_import = to_import[::-1]  # we want to import the dependencies first
+    code_list = []
+    for section_id in to_import:
+        v = code_dict[section_id]
+        task_name = create_in_memory_module_name(p, section_id)
+        code_list.append(
+            {
+                "code": v["code"],
+                "module_name": task_name,
+            }
+        )
+
+    metadata, error_msgs, content = await tasks.add_custom_fns(
+        code_list,
+        to_cache=exporter_obj_in_memory,
+    )
+    return {"metadata": metadata, "errorMsgs": error_msgs, "content": content}
+
+
+@router.post(C.ROUTE_FORMAT_CODE)
+async def route_format_code(x: FormatCodeRequest):
+    p = x.project
+    formattedCode = {}
+    for id, s in p["sections"].items():
+        if get_section_type(p, id) == C.CODE:
+            if s["codeLanguage"] == "python":
+                code = get_section_code(p, id)
+                (
+                    code,
+                    _,
+                    reverse_var_name_mapping,
+                ) = replace_template_vars_with_random_names(
+                    x.candidateTemplateVars[id], code
+                )
+                formattedCode[id] = multireplace(
+                    format_python_code(code), reverse_var_name_mapping
+                )
+
+    return formattedCode
+
+
+def format_python_code(code: str) -> str:
+    try:
+        return black.format_str(code, mode=black.Mode())
+    except black.InvalidInput:
+        pass
+
+
+def create_in_memory_module_name(p, sectionId):
+    projectConfigName = p["projectConfig"]["name"]
+    sanitized_full_name = sanitize_section_path_full_name(
+        p["sectionPathFullNames"][sectionId]
+    )
+    return f"setta_in_memory_{projectConfigName}_{sanitized_full_name}"

setta/routers/lsp.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter, Depends
+
+from setta.lsp.utils import restart_lsps
+from setta.utils.constants import C
+
+from .dependencies import get_lsps
+
+router = APIRouter()
+
+
+@router.post(C.ROUTE_RESTART_LANGUAGE_SERVER)
+async def route_restart_language_server(lsps=Depends(get_lsps)):
+    lsps, lsp_readers, lsp_writers = lsps
+    await restart_lsps(lsps, lsp_readers, lsp_writers)

setta/routers/projects.py

@@ -0,0 +1,188 @@
+import sqlite3
+from typing import List, Optional
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+
+from setta.database.backup import maybe_create_backup
+from setta.database.db.projects.delete import delete_project_configs
+from setta.database.db.projects.load import (
+    ProjectNotFound,
+    load_all_project_config_metadata,
+    load_default_config_name,
+    load_full_project,
+    load_project_config,
+    load_project_config_names,
+)
+from setta.database.db.projects.save import (
+    create_project_config,
+    save_project_config_name,
+    save_project_details,
+    set_as_default_project,
+)
+from setta.database.db.projects.saveAs import (
+    save_as_existing_project_config,
+    save_as_new_project_config,
+)
+from setta.database.db.projects.utils import (
+    add_defaults_to_project_and_load_json_sources,
+    filter_data_for_json_export,
+)
+from setta.database.export_db.export_db import maybe_export_database
+from setta.utils.constants import C
+
+from .dependencies import get_dbq
+
+router = APIRouter()
+
+
+class ProjectLoadRequest(BaseModel):
+    projectConfigName: str
+
+
+class ProjectLoadFullRequest(BaseModel):
+    excludeProjectConfigName: Optional[str] = None
+
+
+class ProjectSaveRequest(BaseModel):
+    project: dict
+
+
+class SaveAsNewProjectConfigRequest(BaseModel):
+    project: dict
+    newConfigName: str
+    withRefs: bool
+
+
+class SaveAsExistingProjectConfigRequest(BaseModel):
+    project: dict
+    configName: str
+
+
+class CreateProjectConfigRequest(BaseModel):
+    name: Optional[str] = None
+    previewImgColor: str
+
+
+class DeleteProjectConfigsRequest(BaseModel):
+    ids: List[str]
+
+
+class SetProjectConfigNameRequest(BaseModel):
+    currProjectConfigName: str
+    newProjectConfigName: str
+
+
+class SetAsDefaultProjectRequest(BaseModel):
+    projectId: str
+
+
+class FilterDataForJSONExportRequest(BaseModel):
+    project: dict
+
+
+class AddDefaultDataForJSONImportRequest(BaseModel):
+    project: dict
+
+
+@router.post(C.ROUTE_ALL_PROJECT_CONFIG_METADATA)
+def route_all_project_config_metadata(dbq=Depends(get_dbq)):
+    with dbq as db:
+        return load_all_project_config_metadata(db)
+
+
+@router.post(C.ROUTE_LOAD_PROJECT_CONFIG_NAMES)
+def route_load_project_config_names(dbq=Depends(get_dbq)):
+    with dbq as db:
+        return load_project_config_names(db)
+
+
+@router.post(C.ROUTE_LOAD_PROJECT_CONFIG)
+def route_load_project_config(
+    x: ProjectLoadRequest,
+    dbq=Depends(get_dbq),
+):
+    try:
+        with dbq as db:
+            return load_project_config(db, x.projectConfigName)
+    except ProjectNotFound as e:
+        raise HTTPException(status_code=404, detail=repr(e))
+
+
+@router.post(C.ROUTE_LOAD_FULL_PROJECT)
+def route_load_full_project(x: ProjectLoadFullRequest, dbq=Depends(get_dbq)):
+    with dbq as db:
+        return load_full_project(
+            db, excludeProjectConfigName=x.excludeProjectConfigName
+        )
+
+
+@router.post(C.ROUTE_SAVE_PROJECT)
+def route_save_project(x: ProjectSaveRequest, dbq=Depends(get_dbq)):
+    with dbq as db:
+        maybe_create_backup(db.path)
+        save_project_details(db, x.project)
+        maybe_export_database(db, db.path)
+
+
+@router.post(C.ROUTE_CREATE_PROJECT_CONFIG)
+def route_create_project_config(x: CreateProjectConfigRequest, dbq=Depends(get_dbq)):
+    with dbq as db:
+        return create_project_config(db, x.name, x.previewImgColor)
+
+
+@router.post(C.ROUTE_SAVE_AS_NEW_PROJECT_CONFIG)
+def route_save_as_new_project_config(
+    x: SaveAsNewProjectConfigRequest, dbq=Depends(get_dbq)
+):
+    with dbq as db:
+        return save_as_new_project_config(db, x.project, x.newConfigName, x.withRefs)
+
+
+@router.post(C.ROUTE_SAVE_AS_EXISTING_PROJECT_CONFIG)
+def route_save_as_existing_project_config(
+    x: SaveAsExistingProjectConfigRequest, dbq=Depends(get_dbq)
+):
+    with dbq as db:
+        return save_as_existing_project_config(db, x.project, x.configName)
+
+
+@router.post(C.ROUTE_DELETE_PROJECT_CONFIGS)
+def route_delete_project_configs(x: DeleteProjectConfigsRequest, dbq=Depends(get_dbq)):
+    with dbq as db:
+        return delete_project_configs(db, x.ids)
+
+
+@router.post(C.ROUTE_SET_PROJECT_CONFIG_NAME)
+def route_set_project_config_name(x: SetProjectConfigNameRequest, dbq=Depends(get_dbq)):
+    try:
+        with dbq as db:
+            save_project_config_name(
+                db, x.currProjectConfigName, x.newProjectConfigName
+            )
+    except sqlite3.IntegrityError as e:
+        raise HTTPException(status_code=422, detail=repr(e))
+
+
+@router.post(C.ROUTE_GET_DEFAULT_CONFIG_NAME)
+def router_get_default_config_name(dbq=Depends(get_dbq)):
+    with dbq as db:
+        return load_default_config_name(db)
+
+
+@router.post(C.ROUTE_SET_AS_DEFAULT_PROJECT)
+def router_set_as_default_project(x: SetAsDefaultProjectRequest, dbq=Depends(get_dbq)):
+    with dbq as db:
+        set_as_default_project(db, x.projectId)
+
+
+@router.post(C.ROUTE_FILTER_DATA_FOR_JSON_EXPORT)
+def router_filter_data_for_json_export(x: FilterDataForJSONExportRequest):
+    filter_data_for_json_export(x.project)
+    return x.project
+
+
+@router.post(C.ROUTE_ADD_DEFAULT_DATA_FOR_JSON_IMPORT)
+def router_add_default_data_for_json_import(x: FilterDataForJSONExportRequest):
+    add_defaults_to_project_and_load_json_sources(x.project)
+    return x.project

setta/routers/reference_renaming.py

@@ -0,0 +1,111 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+from setta.utils.constants import C
+from setta.utils.utils import replace_at_positions
+
+router = APIRouter()
+
+
+class MakeEVRefTemplateVarReplacementsRequest(BaseModel):
+    codeAreaReplacements: dict
+    codeInfoReplacements: dict
+    paramEVReplacements: dict
+
+
+def get_original(r):
+    if "originalEVRef" in r:
+        return r["originalEVRef"]
+    elif "originalTemplateVar" in r:
+        return r["originalTemplateVar"]
+    else:
+        raise KeyError
+
+
+def create_replacements_array(replacements):
+    output = []
+    for startPos, r in replacements.items():
+        oldName = get_original(r)["keyword"]
+        newName = r["newName"]
+        output.append((startPos, oldName, newName))
+    return output
+
+
+def create_new_ev_refs_template_vars(replacements, newStartPositions):
+    evRefs = []
+    templateVars = []
+    for oldPos, startPos, newName in newStartPositions:
+        common = {"startPos": startPos, "keyword": newName}
+        r = replacements[oldPos]
+        if "originalEVRef" in r:
+            evRefs.append({**r["originalEVRef"], **common})
+        elif "originalTemplateVar" in r:
+            templateVars.append({**r["originalTemplateVar"], **common})
+        else:
+            raise KeyError
+
+    # frontend needs it sorted by startPos
+    evRefs = sorted(evRefs, key=lambda x: x["startPos"])
+    templateVars = sorted(templateVars, key=lambda x: x["startPos"])
+    return evRefs, templateVars
+
+
+def get_new_value_and_positions(details):
+    return replace_at_positions(
+        details["string"],
+        create_replacements_array(details["replacements"]),
+        return_positions=True,
+    )
+
+
+def convert_to_dict(replacements):
+    output = {}
+    for r in replacements:
+        output[get_original(r)["startPos"]] = r
+    return output
+
+
+@router.post(C.ROUTE_MAKE_EV_REF_TEMPLATE_VAR_REPLACEMENTS)
+def route_make_ev_ref_template_var_replacements(
+    x: MakeEVRefTemplateVarReplacementsRequest,
+):
+    newCodeAreaValues = {}
+    for variantId, details in x.codeAreaReplacements.items():
+        details["replacements"] = convert_to_dict(details["replacements"])
+        newValue, newStartPositions = get_new_value_and_positions(details)
+        newCodeAreaValues[variantId] = [
+            newValue,
+            *create_new_ev_refs_template_vars(
+                details["replacements"], newStartPositions
+            ),
+        ]
+
+    newCodeInfoValues = {}
+    for codeInfoId, details in x.codeInfoReplacements.items():
+        details["replacements"] = convert_to_dict(details["replacements"])
+        newValue, newStartPositions = get_new_value_and_positions(details)
+        newCodeInfoValues[codeInfoId] = [
+            newValue,
+            *create_new_ev_refs_template_vars(
+                details["replacements"], newStartPositions
+            ),
+        ]
+
+    newParamEVValues = {}
+    for variantId, v in x.paramEVReplacements.items():
+        newParamEVValues[variantId] = {}
+        for referringParamInfoId, details in v.items():
+            details["replacements"] = convert_to_dict(details["replacements"])
+            newValue, newStartPositions = get_new_value_and_positions(details)
+            newParamEVValues[variantId][referringParamInfoId] = [
+                newValue,
+                *create_new_ev_refs_template_vars(
+                    details["replacements"], newStartPositions
+                ),
+            ]
+
+    return {
+        "newCodeAreaValues": newCodeAreaValues,
+        "newCodeInfoValues": newCodeInfoValues,
+        "newParamEVValues": newParamEVValues,
+    }