open-plan-tool · MaaJoo13 · Dec 9, 2025 · Dec 9, 2025 · Feb 25, 2026 · Feb 25, 2026
diff --git a/captain-definition b/captain-definition
@@ -1,4 +1,4 @@
 {
   "schemaVersion": 2,
-  "dockerfilePath": "task_queue/Dockerfile_dev"
+  "dockerfilePath": "task_queue/Dockerfile"
 }
diff --git a/docker-compose.yml b/docker-compose.yml
@@ -1,16 +1,17 @@
-version: "3"
 services:
   web:
     environment:
       - MVS_DEV_VERSION=${MVS_DEV_VERSION}
       - MVS_OPEN_PLAN_VERSION=${MVS_OPEN_PLAN_VERSION}
+      - CELERY_BROKER_URL=redis://redis:6379
+      - CELERY_RESULT_BACKEND=redis://redis:6379
     build:
       args:
         # this should be in a .env file in the root of the repository
         mvs_version: ${MVS_DEV_VERSION}
       # `context` should be a path to a directory containing a Dockerfile
-      context: ./fastapi_app
-      dockerfile: Dockerfile
+      context: .
+      dockerfile: ./fastapi_app/Dockerfile
     restart: unless-stopped
     ports:
       - "5001:5001"
@@ -22,27 +23,31 @@ services:
   worker-dev:
     environment:
       - CELERY_TASK_NAME=dev
+      - CELERY_BROKER_URL=redis://redis:6379
+      - CELERY_RESULT_BACKEND=redis://redis:6379
     build:
       args:
         # this should be in a .env file in the root of the repository
         mvs_version: ${MVS_DEV_VERSION}
       # context should be the name of the folder which define the tasks
-      context: task_queue
-      dockerfile: Dockerfile_dev
+      context: .
+      dockerfile: ./task_queue/Dockerfile
     depends_on:
       - redis
     networks:
       - sim_network
   worker-open-plan:
     environment:
       - CELERY_TASK_NAME=open_plan
+      - CELERY_BROKER_URL=redis://redis:6379
+      - CELERY_RESULT_BACKEND=redis://redis:6379
     build:
       args:
         # this should be in a .env file in the root of the repository
         mvs_version: ${MVS_OPEN_PLAN_VERSION}
       # context should be the name of the folder which define the tasks
-      context: task_queue
-      dockerfile: Dockerfile
+      context: .
+      dockerfile: ./task_queue/Dockerfile
     depends_on:
       - redis
     networks:

diff --git a/fastapi_app/Dockerfile b/fastapi_app/Dockerfile
@@ -6,7 +6,8 @@ COPY fastapi_app/requirements.txt /tmp/
 RUN python -m pip install --upgrade pip
 RUN pip install -r /tmp/requirements.txt
 # install multi-vector-simulator's version pinned in docker-compose.yml file
-RUN pip install multi-vector-simulator==1.0.7rc3 gunicorn
+RUN pip install gunicorn
+RUN pip install "oemof-datapackage @ git+https://github.com/oemof/oemof-datapackage.git" --no-cache-dir
 
 
 

diff --git a/fastapi_app/templates/index.html b/fastapi_app/templates/index.html
@@ -6,7 +6,7 @@
       name="viewport"
       content="width=device-width, initial-scale=1, shrink-to-fit=no"
     />
-    <meta name="description" content="MVS simulation server" />
+    <meta name="description" content="EesyPlan simulation server" />
     <link rel="icon" href="{{ url_for('static', path='/favicon.ico') }}" />
     <link
         rel="stylesheet"
@@ -15,37 +15,39 @@
         crossorigin="anonymous"
     />
     <link href="{{ url_for('static', path='/style.css') }}" rel="stylesheet" />
-    <title>MVS SimServer</title>
+    <title>OpenPlan SimServer</title>
 
 </head>
 <body>
-<h1>Welcome to MVS simulation server! </h1>
+<h1>Welcome to OpenPlan simulation server! </h1>
 <div>
+	  <p>This simulation server uses oemof-eesyplan as a backend, it recieves request as jsonified oemof-datapackage and returns a JSON with the oemof-solph results</p>
     <h2>Test simulation with custom json</h2>
-    <h3>Actual multi-vector-simulator's version for development: {{ mvs_dev_version }}</h3>
+    <h3>Actual oemof-eesyplan's version for development: {{ dev_version }}</h3>
 
-    <p>Upload a mvs input json file and click on "Run simulation"</p>
+    <p>Upload a JSONIFIED datapackage or a zipped datapackage and click on "Run simulation"</p>
     <form action="/uploadjson/dev" enctype="multipart/form-data" method="post">
     <!-- the value of `name` property should be used in the uploadjson endpoint function -->
     <input name="json_file" type="file" multiple>
     <input value="Run simulation" type="submit">
     </form>
 
-    <h3>Actual multi-vector-simulator's version for open_plan: {{ mvs_open_plan_version }}</h3>
+	  <h3>Actual oemof-eesyplan's version for OpenPlan production: {{ prod_version }}</h3>
 
-    <p>Upload a mvs input json file and click on "Run simulation"</p>
-    <form action="/uploadjson/open_plan" enctype="multipart/form-data" method="post">
-        <!-- the value of `name` property should be used in the uploadjson endpoint function -->
-        <input name="json_file" type="file" multiple>
-        <input value="Run simulation" type="submit">
+    <p>Upload a datapackage in JSON format and click on "Run simulation"</p>
+    <form action="/uploadjson/prod" enctype="multipart/form-data" method="post">
+    <!-- the value of `name` property should be used in the uploadjson endpoint function -->
+    <input name="json_file" type="file" multiple>
+    <input value="Run simulation" type="submit">
     </form>
 </div>
 
 
 <div>
     <h2>More information</h2>
     <ul>
-        <li><a href="https://github.com/rl-institut/multi-vector-simulator" target="_blank">More about MVS simulation</a></li>
+        <li><a href="https://github.com/oemof/oemof-eesyplan" target="_blank">More about oemof-eesyplan</a></li>
+        <li><a href="" target="_blank">More about OpenPlan Simulation server</a></li>
     </ul>
 </div>
 {% block body %}{% endblock body%}

diff --git a/fastapi_app/webapp.py b/fastapi_app/webapp.py
@@ -1,28 +1,19 @@
+import math
 import os
 import json
 import io
-from fastapi import FastAPI, Request, Response, File, UploadFile
+from fastapi import FastAPI, Request, Response, File, UploadFile, HTTPException
 from fastapi.encoders import jsonable_encoder
 from fastapi.responses import JSONResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
 from fastapi.responses import StreamingResponse
+from celery.exceptions import TimeoutError
+import tempfile
+import zipfile
+from oemof.datapackage import datapackage  # noqa
 
 
-from multi_vector_simulator import version as mvs_version
-
-from multi_vector_simulator.utils.constants_json_strings import (
-    SIMULATION_SETTINGS,
-    OUTPUT_LP_FILE,
-    VALUE,
-    UNIT,
-)
-
-MVS_DEV_VERSION = os.environ.get("MVS_DEV_VERSION", mvs_version.version_num)
-MVS_OPEN_PLAN_VERSION = os.environ.get("MVS_OPEN_PLAN_VERSION", mvs_version.version_num)
-
-MVS_SERVER_VERSIONS = {"dev": MVS_DEV_VERSION, "open_plan": MVS_OPEN_PLAN_VERSION}
-
 try:
     from worker import app as celery_app
 except ModuleNotFoundError:
@@ -55,6 +46,7 @@
 
 # Test Driven Development --> https://fastapi.tiangolo.com/tutorial/testing/
 
+
 @app.get("/debug/ping")
 async def debug_ping():
     result = celery_app.send_task("dev.ping", queue="dev")
@@ -77,19 +69,30 @@ async def debug_ping():
 
 @app.get("/")
 def index(request: Request) -> Response:
-
     return templates.TemplateResponse(
-        "index.html",
-        {
-            "request": request,
-            "mvs_dev_version": MVS_DEV_VERSION,
-            "mvs_open_plan_version": MVS_OPEN_PLAN_VERSION,
+        request=request,
+        name="index.html",
+        context={
+            "dev_version": get_worker_version("dev"),
+            "prod_version": get_worker_version("prod"),
         },
     )
 
 
+def get_worker_version(queue):
+    task = celery_app.send_task(f"{queue}.get_version", queue=queue, kwargs={})
+    try:
+        version = task.get(timeout=0.5)
+    except TimeoutError:
+        version = f"{queue} worker not available"
+    return version
+
+
 async def simulate_json_variable(request: Request, queue: str = "dev"):
     """Receive mvs simulation parameter in json post request and send it to simulator"""
+
+    # TODO use jsonschema to verify metadata and data and then use the content of metadata to check data
+
     input_dict = await request.json()
 
     # send the task to celery
@@ -106,9 +109,9 @@ async def simulate_json_variable_dev(request: Request):
     return await simulate_json_variable(request, queue="dev")
 
 
-@app.post("/sendjson/openplan")
-async def simulate_json_variable_open_plan(request: Request):
-    return await simulate_json_variable(request, queue="open_plan")
+@app.post("/sendjson/prod")
+async def simulate_json_variable_prod(request: Request):
+    return await simulate_json_variable(request, queue="prod")
 
 
 @app.post("/uploadjson/dev")
@@ -119,20 +122,54 @@ def simulate_uploaded_json_files_dev(
     the value of `name` property of the input html tag should be `json_file` as the second
     argument of this function
     """
-    json_content = jsonable_encoder(json_file.file.read())
+
+    if "json" in json_file.filename:
+        json_content = jsonable_encoder(json_file.file.read())
+    elif "zip" in json_file.filename:
+        # TODO do the same with only pathlib and temp files
+        import uuid
+        import shutil
+
+        ZIP_DIR = "zipped"
+        UNZIP_DIR = "unzipped"
+        zip_id = str(uuid.uuid4())
+        from pathlib import Path
+
+        unzip_path = os.path.join(UNZIP_DIR, zip_id)
+        os.makedirs(unzip_path)
+        zip_path = os.path.join(UNZIP_DIR, f"{zip_id}.zip")
+        with open(zip_path, "wb") as f:
+            shutil.copyfileobj(json_file.file, f)
+        with zipfile.ZipFile(zip_path, "r") as zipf:
+            zipf.extractall(unzip_path)
+        os.remove(zip_path)
+        unzip_path = Path(unzip_path)
+        extracted_name = [f for f in unzip_path.glob("*")]
+        extracted_name = extracted_name[0]
+        json_content = datapackage.export_dp_to_json(extracted_name)
+
+        # with tempfile.TemporaryDirectory() as td:
+        #     # Open the zip file
+        #     with zipfile.ZipFile(json_file.file, 'r') as zip_ref:
+        #         # Extract all the contents into the specified directory
+        #         zip_ref.extractall(td)
+        #
+        #     json_content = json.dumps(datapackage.export_dp_to_json(td))
+        #     json_content = datapackage.export_dp_to_json(td)
+
     return run_simulation(request, input_json=json_content)
 
 
-@app.post("/uploadjson/open_plan")
-def simulate_uploaded_json_files_open_plan(
+@app.post("/uploadjson/prod")
+def simulate_uploaded_json_files_prod(
     request: Request, json_file: UploadFile = File(...)
 ):
     """Receive mvs simulation parameter in json post request and send it to simulator
     the value of `name` property of the input html tag should be `json_file` as the second
     argument of this function
     """
     json_content = jsonable_encoder(json_file.file.read())
-    return run_simulation_open_plan(request, input_json=json_content)
+    return run_simulation_prod(request, input_json=json_content)
 
 
 def run_simulation(request: Request, input_json=None, queue="dev") -> Response:
@@ -152,7 +189,9 @@ def run_simulation(request: Request, input_json=None, queue="dev") -> Response:
     )
 
     return templates.TemplateResponse(
-        "submitted_task.html", {"request": request, "task_id": task.id}
+        request=request,
+        name="submitted_task.html",
+        context={"task_id": task.id},
     )
 
 
@@ -161,17 +200,17 @@ def run_simulation_dev(request: Request, input_json=None) -> Response:
     return run_simulation(request, input_json, queue="dev")
 
 
-@app.post("/run_simulation_open_plan")
-def run_simulation_open_plan(request: Request, input_json=None) -> Response:
-    return run_simulation(request, input_json, queue="open_plan")
+@app.post("/run_simulation_prod")
+def run_simulation_prod(request: Request, input_json=None) -> Response:
+    return run_simulation(request, input_json, queue="prod")
 
 
 @app.get("/check/{task_id}")
 async def check_task(task_id: str) -> JSONResponse:
     res = celery_app.AsyncResult(task_id)
     task = {
         "server_info": None,
-        "mvs_version": None,
+        "simulation_version": None,
         "id": task_id,
         "status": res.state,
         "results": None,
@@ -181,14 +220,30 @@ async def check_task(task_id: str) -> JSONResponse:
     else:
         task["status"] = "DONE"
         results_as_dict = json.loads(res.result)
-        server_info = results_as_dict.pop("SERVER")
-        task["server_info"] = server_info
-        task["mvs_version"] = MVS_SERVER_VERSIONS.get(server_info, "unknown")
-        task["results"] = json.dumps(results_as_dict)
+        try:
+            task["server_info"] = results_as_dict.pop("SERVER")
+            task["simulation_version"] = results_as_dict.pop("VERSION")
+        except KeyError:
+            for k in ["server_info", "simulation_version"]:
+                task[k] = "Error: Could not retrieve simulation metadata"
+        task["results"] = results_as_dict
         if "ERROR" in task["results"]:
             task["status"] = "ERROR"
             task["results"] = results_as_dict
 
+    def clean_floats(obj):
+        if isinstance(obj, float):
+            if math.isnan(obj) or math.isinf(obj):
+                return None
+        if isinstance(obj, dict):
+            return {k: clean_floats(v) for k, v in obj.items()}
+        if isinstance(obj, list):
+            return [clean_floats(i) for i in obj]
+        return obj
+
+    cleaned = clean_floats(task)
+
+    return JSONResponse(content=jsonable_encoder(cleaned))
     return JSONResponse(content=jsonable_encoder(task))
 
 
@@ -197,7 +252,7 @@ async def get_lp_file(task_id: str) -> Response:
     res = celery_app.AsyncResult(task_id)
     task = {
         "server_info": None,
-        "mvs_version": mvs_version,
+        "simulation_version": None,
         "id": task_id,
         "status": res.state,
         "results": None,
@@ -208,9 +263,8 @@ async def get_lp_file(task_id: str) -> Response:
     else:
         task["status"] = "DONE"
         results_as_dict = json.loads(res.result)
-        server_info = results_as_dict.pop("SERVER")
-        task["server_info"] = server_info
-        task["mvs_version"] = MVS_SERVER_VERSIONS.get(server_info, "unknown")
+        task["server_info"] = results_as_dict.pop("SERVER")
+        task["simulation_version"] = results_as_dict.pop("VERSION")
         task["results"] = json.dumps(results_as_dict)
         if "ERROR" in task["results"]:
             task["status"] = "ERROR"

diff --git a/fastapi_app/worker.py b/fastapi_app/worker.py
@@ -11,5 +11,5 @@
 app = Celery("tasks", broker=CELERY_BROKER_URL, backend=CELERY_RESULT_BACKEND)
 app.conf.task_queues = (
     Queue("dev", routing_key="dev.#"),
-    Queue("open_plan", routing_key="open_plan.#"),
+    Queue("prod", routing_key="prod.#"),
 )