api.py

from fastapi import FastAPI, Request, HTTPException, BackgroundTasks
from app.backend.models import NotificationsTable, BugReportsTable, MasTable, IntermediateMasTable, AdvancedCoreMaterialsTable, TelemetryTable
from app.backend.models import BugReport
from app.backend.mas_models import MagneticCore, CoreShape, Magnetic, Inputs
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import FileResponse, Response
from fastapi.encoders import jsonable_encoder
import pandas
from datetime import datetime
import json
import bson
from bson import ObjectId, json_util
import copy
import os
import pathlib
import base64
import kombu
import celery
# from pylatex import Document, Command, Package
# from pylatex.utils import NoEscape
import PyOpenMagnetics
from OpenMagneticsVirtualBuilder.builder import Builder as ShapeBuilder  # noqa: E402
import sys
# sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../MVB/src/OpenMagneticsVirtualBuilder')))
# from builder import Builder as ShapeBuilder  # noqa: E402
import hashlib
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), 'app/backend')))
from plotter import purge_queue
from plotter import task_generate_core_3d_model
from plotter import task_generate_core_technical_drawing, task_generate_gapping_technical_drawing
import ast
import httpx

temp_folder = "/opt/openmagnetics/temp"
high_performance_backend_url = "http://86.127.248.99:8001"
use_celery = ast.literal_eval(os.getenv('USE_CELERY', "True"))
use_db = "OM_DB_ADDRESS" in os.environ


def clean_dimensions(core):
    # Make sure no unwanted dimension gets in
    families = ShapeBuilder("FreeCAD").get_families()
    if "familySubtype" in core['functionalDescription']['shape'] and core['functionalDescription']['shape']['familySubtype'] is not None:
        dimensions = families[core['functionalDescription']['shape']['family']][int(core['functionalDescription']['shape']['familySubtype'])]
    else:
        dimensions = families[core['functionalDescription']['shape']['family']][1]
    aux = copy.deepcopy(core['functionalDescription']['shape']['dimensions'])
    for key, value in core['functionalDescription']['shape']['dimensions'].items():
        if key not in dimensions:
            aux.pop(key)
    core['functionalDescription']['shape']['dimensions'] = aux
    return core


def delete_none(_dict):
    """Delete None values recursively from all of the dictionaries, tuples, lists, sets"""
    if isinstance(_dict, dict):
        for key, value in list(_dict.items()):
            if isinstance(value, (list, dict, tuple, set)):
                _dict[key] = delete_none(value)
            elif value is None or key is None:
                del _dict[key]

    elif isinstance(_dict, (list, set, tuple)):
        _dict = type(_dict)(delete_none(item) for item in _dict if item is not None)

    return _dict


def flatten_dimensions(data):
    dimensions = data["dimensions"]
    for k, v in dimensions.items():
        if "nominal" not in v:
            if "maximum" not in v:
                v["nominal"] = v["minimum"]
            elif "minimum" not in v:
                v["nominal"] = v["maximum"]
            else:
                v["nominal"] = round((v["maximum"] + v["minimum"]) / 2, 6)
    dim = {k: v["nominal"] for k, v in dimensions.items()}
    data["dimensions"] = dim
    return data


app = FastAPI()

origins = [
    "https://openmagnetics.com",
    "https://beta.openmagnetics.com",
    "http://localhost:5173",
    "http://localhost:5174",
    "http://localhost:4173",
]

app.add_middleware(
    CORSMiddleware,
    allow_origins=origins,
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)


@app.get("/", include_in_schema=False)
def read_root():
    return {"Hello": "World"}


@app.post("/get_notifications", include_in_schema=False)
def get_notifications():
    notifications_table = NotificationsTable()
    new_notifications = notifications_table.read_active_notifications(datetime.now())
    return {"notifications": new_notifications.to_dict('records')}


@app.post("/report_bug", include_in_schema=False)
def report_bug(data: BugReport):
    data = data.dict()

    bug_reports_table = BugReportsTable()
    bug_report_id = bug_reports_table.report_bug(data['username'], data['userDataDump'], data['userInformation'])
    return {"status": "reported", "bug_report_id": bug_report_id}


@app.post("/core_compute_shape_stl", include_in_schema=False)
@app.post("/core_compute_shape", include_in_schema=False)
def core_compute_shape(coreShape: CoreShape):
    coreShape = coreShape.dict()
    core_builder = ShapeBuilder("FreeCAD").factory(coreShape)
    core_builder.set_output_path(temp_folder)    
    step_path, stl_path = core_builder.get_piece(coreShape)
    if step_path is None:
        purge_queue()
        raise HTTPException(status_code=418, detail="Wrong dimensions")
    else:
        return FileResponse(stl_path)


@app.post("/core_compute_shape_stp", include_in_schema=False)
def core_compute_shape_stp(coreShape: CoreShape):
    coreShape = coreShape.dict()
    core_builder = ShapeBuilder("FreeCAD").factory(coreShape)
    core_builder.set_output_path(temp_folder)    
    step_path, stl_path = core_builder.get_piece(coreShape)
    if step_path is None:
        purge_queue()
        raise HTTPException(status_code=418, detail="Wrong dimensions")
    else:
        return FileResponse(step_path)


@app.post("/core_compute_core_3d_model_stl", include_in_schema=False)
@app.post("/core_compute_core_3d_model", include_in_schema=False)
async def core_compute_core_3d_model(request: Request):
    core = await request.json()
    number_retries = 5
    stl_data = None

    if not use_celery:
        print("not use_celery")
        stl_data = task_generate_core_3d_model(core, temp_folder)
    else:
        try:
            for retry in range(number_retries):
                result = task_generate_core_3d_model.delay(core, temp_folder)
                try:
                    stl_data = result.get(timeout=10)
                except celery.exceptions.TimeoutError:
                    continue
                except ConnectionResetError:
                    continue
                if stl_data is not None:
                    break
                print("Retrying task_generate_core_3d_model")
            if stl_data is None:
                purge_queue()
        except kombu.exceptions.OperationalError:
            stl_data = task_generate_core_3d_model(core, temp_folder)

    if stl_data is None:
        raise HTTPException(status_code=418, detail="Wrong dimensions")
    else:
        # json_compatible_item_data = jsonable_encoder(stl_data, custom_encoder={bytes: lambda v: base64.b64encode(v).decode('utf-8')})
        # return json_compatible_item_data
        return stl_data


@app.post("/core_compute_core_3d_model_stp", include_in_schema=False)
async def core_compute_core_3d_model_stp(request: Request):
    core = await request.json()
    number_retries = 5
    stp_data = None

    if not use_celery:
        stp_data = task_generate_core_3d_model(core, temp_folder, False)
    else:
        try:
            for retry in range(number_retries):
                result = task_generate_core_3d_model.delay(core, temp_folder, False)
                try:
                    stp_data = result.get(timeout=10)
                except celery.exceptions.TimeoutError:
                    continue
                except ConnectionResetError:
                    continue
                if stp_data is not None:
                    break
                print("Retrying task_generate_core_3d_model")
            if stp_data is None:
                purge_queue()
        except kombu.exceptions.OperationalError:
            stp_data = task_generate_core_3d_model(core, temp_folder, False)

    if stp_data is None:
        raise HTTPException(status_code=418, detail="Wrong dimensions")
    else:
        # json_compatible_item_data = jsonable_encoder(stp_data, custom_encoder={bytes: lambda v: base64.b64encode(v).decode('utf-8')})
        # return json_compatible_item_data
        return stp_data


@app.post("/core_compute_technical_drawing", include_in_schema=False)
async def core_compute_technical_drawing(request: Request):
    data = await request.json()
    number_retries = 5
    views = None

    if not use_celery:
        views = task_generate_core_technical_drawing(data, temp_folder)
    else:
        try:
            for retry in range(number_retries):
                result = task_generate_core_technical_drawing.delay(data, temp_folder)
                try:
                    views = result.get(timeout=10)
                except celery.exceptions.TimeoutError:
                    continue
                except ConnectionResetError:
                    continue
                if views is not None:
                    break
                print("Retrying task_generate_core_technical_drawing")
            if views is None:
                purge_queue()
        except kombu.exceptions.OperationalError:
            views = task_generate_core_technical_drawing(data, temp_folder)

    if views is None:
        raise HTTPException(status_code=418, detail="Wrong dimensions")
    else:
        return views


@app.post("/core_compute_gapping_technical_drawing", include_in_schema=False)
async def core_compute_gapping_technical_drawing(request: Request):
    data = await request.json()
    number_retries = 5
    views = None

    if not use_celery:
        views = task_generate_core_technical_drawing(data, temp_folder)
    else:
        try:
            for retry in range(number_retries):
                result = task_generate_gapping_technical_drawing.delay(data, temp_folder)
                try:
                    views = result.get(timeout=10)
                except celery.exceptions.TimeoutError:
                    continue
                except ConnectionResetError:
                    continue
                if views is not None:
                    break
                print("Retrying task_generate_gapping_technical_drawing")
            if views is None:
                purge_queue()
        except kombu.exceptions.OperationalError:
            views = task_generate_core_technical_drawing(data, temp_folder)

    if views is None:
        raise HTTPException(status_code=418, detail="Wrong dimensions")
    else:
        return views


# @app.post("/process_latex", include_in_schema=True)
# async def process_latex(request: Request):
#     print(request)
#     print(dir(request))
#     tex = await request.body()
#     tex = tex.decode('utf-8')
#     filepath = "/opt/openmagnetics/latex"
#     pathlib.Path(filepath).mkdir(parents=True, exist_ok=True)
#     doc = Document(default_filepath=f"{filepath}/tex")
#     doc.packages.append(Package('array'))
#     doc.packages.append(Package('booktabs'))
#     doc.packages.append(Package('babel'))
#     doc.packages.append(Package('amsmath'))
#     doc.packages.append(Package('relsize'))
#     doc.packages.append(Package('cellspace'))
#     doc.packages.append(Package('tikz'))
#     doc.packages.append(Package('geometry'))
#     doc.packages.append(Package('fancyhdr'))
#     doc.preamble.append(Command('setlength\\cellspacetoplimit', '4pt'))
#     doc.preamble.append(Command('setlength\\cellspacebottomlimit', '4pt'))
#     doc.preamble.append(Command('usetikzlibrary', 'datavisualization'))
#     doc.preamble.append(Command('geometry', 'tmargin=1in'))
#     doc.preamble.append(Command('pagestyle', 'fancy'))
#     tex = tex.replace('μ', '$\\mu$')
#     doc.append(NoEscape(tex))
#     doc.generate_pdf(clean_tex=False)
#
#     with open(f"{filepath}/tex.pdf", "rb") as pdf_file:
#         pdf_string = base64.b64encode(pdf_file.read())
#         return pdf_string


def insert_mas_background(data):
    mas_table = MasTable()
    mas_table.insert_mas(data)


@app.post("/insert_mas", include_in_schema=False)
async def insert_mas(request: Request, background_tasks: BackgroundTasks):
    data = await request.json()
    background_tasks.add_task(insert_mas_background, data)

    return "Inserting in the background"


def insert_intermediate_mas_background(data):
    mas_table = IntermediateMasTable()
    mas_table.insert_mas(data)


@app.post("/insert_intermediate_mas", include_in_schema=False)
async def insert_intermediate_mas(request: Request, background_tasks: BackgroundTasks):
    if use_db:
        data = await request.json()
        background_tasks.add_task(insert_intermediate_mas_background, data)

        return "Inserting in the background"
    else:
        return "DB not available"


def insert_telemetry_background(data, environment):
    table = TelemetryTable()
    table.record(
        session_id=data.get('session_id', 'unknown'),
        event_type=data.get('event_type', ''),
        source=data.get('source', ''),
        stage=data.get('stage'),
        environment=environment,
        app_version=data.get('app_version'),
        mas_data=data.get('mas_data'),
        topology=data.get('topology'),
        mas_version=data.get('mas_version'),
        result_count=data.get('result_count'),
        error_message=data.get('error_message'),
    )


@app.post("/telemetry", include_in_schema=False)
async def telemetry(request: Request, background_tasks: BackgroundTasks):
    if use_db:
        data = await request.json()
        # The frontend build declares its environment (VITE_ENV). Trust it when
        # valid; otherwise fall back to the backend's own OM_ENV. Defaults to
        # production only as a last resort so untagged rows never masquerade as
        # development (which would hide them from production stats).
        env = data.get('environment')
        if env not in ('development', 'production'):
            env = "development" if os.getenv("OM_ENV", "production") == "development" else "production"
        background_tasks.add_task(insert_telemetry_background, data, env)
        return "Inserting in the background"
    else:
        return "DB not available"


@app.post("/load_external_core_materials", include_in_schema=False)
async def load_external_core_materials(request: Request, background_tasks: BackgroundTasks):
    data = await request.json()

    external_core_materials_string = data["coreMaterialsString"]

    PyOpenMagnetics.load_core_materials(external_core_materials_string)
    PyOpenMagnetics.load_core_materials("")
    return "Data loaded"


@app.post("/store_request", include_in_schema=False)
async def store_request(request: Request, background_tasks: BackgroundTasks):
    data = await request.json()

    request = {
        "email": data["email"],
        "name": data["name"],
        "mas": data["mas"],
    }

    file = "/opt/openmagnetics/temp/requests.csv"

    requests = pandas.DataFrame()

    if os.path.exists(file):
        requests = pandas.read_csv(file)

    row = pandas.DataFrame([request])
    print(row)

    requests = pandas.concat([requests, row], ignore_index=True)
    print(requests)

    requests.to_csv(file)


@app.post("/read_advanced_core_material_by_name", include_in_schema=False)
async def read_advanced_core_material_by_name(request: Request):
    dataJson = await request.json()
    advanced_core_materials_table = AdvancedCoreMaterialsTable()
    advanced_core_material_data = advanced_core_materials_table.read_material_by_name(dataJson["name"])

    return advanced_core_material_data


@app.post("/create_simulation_from_mas", include_in_schema=False)
async def create_simulation_from_mas(request: Request):
    data = await request.json()
    url = f'{high_performance_backend_url}/create_simulation_from_mas'
    async with httpx.AsyncClient() as client:
        response = await client.post(url, json=data, timeout=600)
        # print(response.content)
        print("len(response.content)")
        print(len(response.content))
        return Response(content=response.content, media_type="binary/octet-stream")


@app.post("/is_high_performance_backend_available", include_in_schema=False)
async def is_high_performance_backend_available():
    try:
        url = f'{high_performance_backend_url}/remote_available'
        async with httpx.AsyncClient() as client:
            response = await client.post(url, timeout=5)
            print("Remote available")
            return True
    except Exception:
        return False