diff --git a/build_pyd.py b/build_pyd.py
index ba50311..a754d4c 100644
--- a/build_pyd.py
+++ b/build_pyd.py
@@ -2,6 +2,7 @@ from distutils.core import setup
 from Cython.Build import cythonize
 
 setup(ext_modules=cythonize([
+    "main.py",
     "tjnetwork.py",
     "api/*.py",
     "epanet/*.py"
diff --git a/demo.py b/demo.py
new file mode 100644
index 0000000..6c152fc
--- /dev/null
+++ b/demo.py
@@ -0,0 +1,4 @@
+from tjnetwork import *
+
+print(list_project())
+
diff --git a/get_current_total_Q.py b/get_current_total_Q.py
new file mode 100644
index 0000000..e69de29
diff --git a/get_realValue.py b/get_realValue.py
new file mode 100644
index 0000000..d8d7b1d
--- /dev/null
+++ b/get_realValue.py
@@ -0,0 +1,58 @@
+import requests
+from datetime import datetime
+import pytz
+
+
+def convert_to_beijing_time(utc_time_str):
+    # 解析UTC时间字符串为datetime对象
+    utc_time = datetime.strptime(utc_time_str, '%Y-%m-%dT%H:%M:%SZ')
+
+    # 设定UTC时区
+    utc_timezone = pytz.timezone('UTC')
+
+    # 转换为北京时间
+    beijing_timezone = pytz.timezone('Asia/Shanghai')
+    beijing_time = utc_time.replace(tzinfo=utc_timezone).astimezone(beijing_timezone)
+
+    return beijing_time
+
+
+def get_realValue(ids):
+    # 数据接口的地址
+    url = 'http://183.64.62.100:9057/loong/api/mpoints/realValue'
+
+    # 设置GET请求的参数
+    params = {
+        'ids': ids
+    }
+
+    try:
+        # 发送GET请求获取数据
+        response = requests.get(url, params=params)
+
+        # 检查响应状态码，200表示请求成功
+        if response.status_code == 200:
+            # 解析响应的JSON数据
+            data = response.json()
+
+            # 只打印'id'、'datadt'和'realValue'数据
+            for realValue in data:
+                print("id:", realValue['id'])
+                print("mpointName:",realValue['mpointName'])
+                # print("datadt:", realValue['datadt'])
+                # 转换datadt字段为北京时间
+                beijing_time = convert_to_beijing_time(realValue['datadt'])
+                print("datadt (Beijing Time):", beijing_time.strftime('%Y-%m-%d %H:%M:%S'))
+                print("realValue:", realValue['realValue'])
+                print()  # 打印空行分隔不同条目
+        else:
+            # 如果请求不成功，打印错误信息
+            print("请求失败，状态码:", response.status_code)
+
+    except Exception as e:
+        # 捕获异常
+        print("发生异常:", e)
+
+
+# 使用示例
+get_realValue(ids='2498,2500')
diff --git a/main - 副本.py b/main - 副本.py
new file mode 100644
index 0000000..91bddb3
--- /dev/null
+++ b/main - 副本.py	
@@ -0,0 +1,1808 @@
+import os
+import io
+import json
+import time
+from typing import *
+from urllib.request import Request
+from xml.dom import minicompat
+from pydantic import BaseModel
+from starlette.responses import FileResponse, JSONResponse
+from fastapi import FastAPI, File, UploadFile, Response, status, Request, Body, HTTPException
+from fastapi.responses import PlainTextResponse
+from fastapi.middleware.gzip import GZipMiddleware
+from tjnetwork import *
+import asyncio
+import threading
+from multiprocessing import Value
+
+JUNCTION = 0
+RESERVOIR = 1
+TANK = 2
+PIPE = 1
+NODE_COUNT = 0
+LINK_COUNT = 2
+
+prjs = []
+inpDir = "C:/inpfiles/"
+tmpDir = "C:/tmpfiles/"
+
+lockedPrjs = {}
+
+if not os.path.exists(inpDir):
+    os.mkdir(inpDir)
+
+if not os.path.exists(tmpDir):
+    os.mkdir(tmpDir)
+
+app = FastAPI()
+
+# 定义一个共享变量
+lock_simulation = Value('i', 0)
+
+app.add_middleware(GZipMiddleware, minimum_size=1000)
+
+############################################################
+# extension_data
+############################################################
+@app.get('/getallextensiondatakeys/')
+async def fastapi_get_all_extension_data_keys(network: str) -> list[str]:
+    return get_all_extension_data_keys(network)
+
+@app.get('/getallextensiondata/')
+async def fastapi_get_all_extension_data(network: str) -> dict[str, Any]:
+    return get_all_extension_data(network)
+
+@app.get('/getextensiondata/')
+async def fastapi_get_extension_data(network: str, key: str) -> str | None:
+    return get_extension_data(network, key)
+
+@app.post('/setextensiondata',response_model=None)
+async def fastapi_set_extension_data(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    print(props)
+    cs = set_extension_data(network, ChangeSet(props))
+    print(cs.operations[0])
+    return cs
+
+############################################################
+# project
+############################################################
+
+@app.get('/listprojects/')
+async def fastapi_list_projects() -> list[str]:
+    return list_project()
+
+@app.get("/haveproject/")
+async def fastapi_have_project(network: str):
+    return have_project(network)
+
+@app.post("/createproject/")
+async def fastapi_create_project(network: str):
+    create_project(network)
+    return network
+
+@app.post("/deleteproject/")
+async def fastapi_delete_project(network: str):
+    delete_project(network)
+    return True
+
+@app.get("/isprojectopen/")
+async def fastapi_is_project_open(network: str):
+    return is_project_open(network)
+
+@app.post("/openproject/")
+async def fastapi_open_project(network: str):
+    open_project(network)
+    return network
+
+@app.post("/closeproject/")
+async def fastapi_close_project(network: str):
+    close_project(network)
+    return True
+
+@app.post("/copyproject/")
+async def fastapi_copy_project(source: str, target: str):
+    copy_project(source, target)
+    return True
+
+@app.post("/importinp/")
+async def fastapi_import_inp(network: str, req: Request):
+    jo_root = await req.json()
+    inp_text = jo_root['inp']
+    ps = {
+        "inp" : inp_text
+    }
+    ret = import_inp(network, ChangeSet(ps))
+    print(ret)
+    return ret
+
+@app.get("/exportinp/",response_model=None)
+async def fastapi_export_inp(network: str, version: str) -> ChangeSet:
+    cs = export_inp(network, version)
+    op = cs.operations[0]
+    open_project(network)
+    op['vertex'] = json.dumps(get_all_vertices(network))
+    op['scada'] = json.dumps(get_all_scada_elements(network))
+    op['dma'] = json.dumps(get_all_district_metering_areas(network))
+    op['sa'] = json.dumps(get_all_service_areas(network))
+    op['vd'] = json.dumps(get_all_virtual_districts(network))
+    op['legend'] = get_extension_data(network, 'legend')  
+
+    db = get_extension_data(network, 'scada_db')
+    print(db)
+    scada_db = ''
+    if db:
+        scada_db = db
+    print(scada_db)
+    op['scada_db'] = scada_db
+    
+    close_project(network)
+
+    return cs
+
+@app.post("/readinp/")
+async def fastapi_read_inp(network: str, inp: str) -> bool:
+    read_inp(network, inp)
+    return True
+
+@app.get("/dumpinp/")
+async def fastapi_dump_inp(network: str, inp: str) -> bool:
+    dump_inp(network, inp)
+    return True
+
+# 必须用这个PlainTextResponse，不然每个key都有引号
+@app.get("/runproject/", response_class = PlainTextResponse)
+async def fastapi_run_project(network: str) -> str:
+    filename = 'c:/lock.simulation'
+    filename2 = 'c:/lock.simulation2'
+    if os.path.exists(filename2):
+        print('file exists')
+        raise HTTPException(status_code=409, detail="is in simulation")   
+    else:
+        print('file doesnt exists')
+        os.rename(filename, filename2)
+        result = run_project(network)
+        os.rename(filename2, filename)
+        return result
+        
+# put in inp folder, name without extension
+@app.get("/runinp/")
+async def fastapi_run_inp(network: str) -> str:
+    return run_inp(network)
+
+# path is absolute path
+@app.get("/dumpoutput/")
+async def fastapi_dump_output(output: str) -> str:
+    return dump_output(output)
+
+@app.get("/isprojectlocked/")
+async def fastapi_is_locked(network: str, req: Request):
+    return str in lockedPrjs.keys()
+
+@app.get("/isprojectlockedbyme/")
+async def fastapi_is_locked_by_me(network: str, req: Request):
+    client_host = req.client.host
+    return lockedPrjs.get(network) == client_host
+
+# 0 successfully locked
+# 1 already locked by you
+# 2 locked by others
+@app.post("/lockproject/")
+async def fastapi_lock_project(network: str, req: Request):
+    client_host = req.client.host
+    if not network in lockedPrjs.keys():
+        lockedPrjs[network] = client_host
+        return 0
+    else:
+        if lockedPrjs.get(network) == client_host:
+            return 1
+        else:
+            return 2
+
+@app.post("/unlockproject/")
+def fastapi_unlock_project(network: str, req: Request):
+    client_host = req.client.host
+    if lockedPrjs[network] == client_host:
+        print("delete key")
+        del lockedPrjs[network]
+        return True
+        
+    return False
+
+### operations
+
+@app.get('/getcurrentoperationid/')
+async def fastapi_get_current_operaiton_id(network: str) -> int:
+    return get_current_operation(network)
+
+@app.post('/undo/')
+async def fastapi_undo(network: str):
+    return execute_undo(network)
+
+@app.post('/redo/')
+async def fastapi_redo(network: str):
+    return execute_redo(network)
+
+@app.get('/getsnapshots/')
+def fastapi_list_snapshot(network: str) -> list[tuple[int, str]]:
+    return list_snapshot(network)
+
+@app.get('/havesnapshot/')
+async def fastapi_have_snapshot(network: str, tag: str) -> bool:
+    return have_snapshot(network, tag)
+    
+@app.get('/havesnapshotforoperation/')
+async def fastapi_have_snapshot_for_operation(network: str, operation: int) -> bool:
+    return have_snapshot_for_operation(network, operation)
+
+@app.get('/havesnapshotforcurrentoperation/')
+async def fastapi_have_snapshot_for_current_operation(network: str) -> bool:
+    return have_snapshot_for_current_operation(network)
+
+@app.post('/takesnapshotforoperation/')
+async def fastapi_take_snapshot_for_operation(network: str, operation: int, tag: str) -> None:
+    return take_snapshot_for_operation(network, operation, tag)
+
+@app.post('takenapshotforcurrentoperation')
+async def fastapi_take_snapshot_for_current_operation(network: str, tag: str) -> None:
+    return take_snapshot_for_current_operation(network, tag)
+    
+@app.post('/takesnapshot/')
+def fastapi_take_snapshot(network: str, tag: str) -> None:
+    return take_snapshot(network, tag)
+
+@app.post('/picksnapshot/',response_model=None)
+def fastapi_pick_snapshot(network: str, tag: str, discard: bool = False) -> ChangeSet:
+    return pick_snapshot(network, tag, discard)
+
+@app.post('/pickoperation/',response_model=None)
+async def fastapi_pick_operation(network: str, operation: int, discard: bool = False) -> ChangeSet:
+    return pick_operation(network, operation, discard)
+
+@app.get("/syncwithserver/",response_model=None)
+async def fastapi_sync_with_server(network: str, operation: int) -> ChangeSet:
+    return sync_with_server(network, operation)
+
+@app.post("/batch/",response_model=None)
+async def fastapi_execute_batch_commands(network: str, req: Request)-> ChangeSet:
+    jo_root = await req.json()
+    cs: ChangeSet = ChangeSet()
+    cs.operations = jo_root['operations']
+    rcs = execute_batch_commands(network, cs)
+    return rcs
+
+@app.post("/compressedbatch/",response_model=None)
+async def fastapi_execute_compressed_batch_commands(network: str, req: Request)-> ChangeSet:
+    jo_root = await req.json()
+    cs: ChangeSet = ChangeSet()
+    cs.operations = jo_root['operations']
+    return execute_batch_command(network, cs)
+
+@app.get("/getrestoreoperation/")
+async def fastapi_get_restore_operation(network : str) -> int:
+    return get_restore_operation(network)
+
+@app.post("/setrestoreoperation/")
+async def fastapi_set_restore_operation(network: str, operation: int) -> None:
+    return set_restore_operation(network, operation)
+    
+############################################################
+# type
+############################################################
+
+@app.get('/isnode/')
+async def fastapi_is_node(network: str, node: str) -> bool:
+    return is_node(network, node)
+
+@app.get('/isjunction/')
+async def fastapi_is_junction(network: str, node: str) -> bool:
+    return is_junction(network, node)
+
+@app.get('/isreservoir/')
+async def fastapi_is_reservoir(network: str, node: str) -> bool:
+    return is_reservoir(network, node)
+
+@app.get('/istank/')
+async def fastapi_is_tank(network: str, node: str) -> bool:
+    return is_tank(network, node)
+
+@app.get('/islink/')
+async def fastapi_is_link(network: str, link: str) -> bool:
+    return is_link(network, link)
+
+@app.get('/ispipe/')
+async def fastapi_is_pipe(network: str, link: str) -> bool:
+    return is_pipe(network, link)
+
+@app.get('/ispump/')
+async def fastapi_is_pump(network: str, link: str) -> bool:
+    return is_pump(network, link)
+
+@app.get('/isvalve/')
+async def fastapi_is_valve(network: str, link: str) -> bool:
+    return is_valve(network, link)
+
+@app.get('/iscurve/')
+async def fastapi_is_curve(network: str, curve: str) -> bool:
+    return is_curve(network, curve)
+
+@app.get('/ispattern/')
+async def fastapi_is_pattern(network: str, pattern: str) -> bool:
+    return is_pattern(network, pattern)
+
+@app.get("/getnodes/")
+async def fastapi_get_nodes(network: str) -> list[str]:
+    return get_nodes(network)
+
+@app.get("/getlinks/")
+async def fastapi_get_links(network: str) -> list[str]:
+    return get_links(network)
+
+@app.get("/getcurves/")
+async def fastapi_get_curves(network: str) -> list[str]:
+    return get_curves(network)
+
+@app.get("/getpatterns/")
+async def fastapi_get_patterns(network: str) -> list[str]:
+    return get_patterns(network)
+
+@app.get("/getnodelinks/")
+def get_node_links(network: str, node: str) -> list[str]:
+    return get_node_links(network, node)
+
+############################################################
+# title 1.[TITLE]
+############################################################
+@app.get('/gettitleschema/')
+async def fast_get_title_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_title_schema(network)
+
+@app.get('/gettitle/')
+async def fast_get_title(network: str) -> dict[str, Any]:
+    return get_title(network)
+
+@app.get('/settitle/',response_model=None)
+async def fastapi_set_title(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_title(network, ChangeSet(props))
+
+############################################################
+# junction 2.[JUNCTIONS]
+############################################################
+@app.get('/getjunctionschema')
+async def fast_get_junction_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_junction_schema(network)
+
+@app.post("/addjunction/",response_model=None)
+async def fastapi_add_junction(network: str, junction: str, x: float, y: float, z: float) -> ChangeSet:
+    ps = { 'id' : junction, 
+           'x' : x, 
+           'y' : y, 
+           'elevation' : z }
+    return add_junction(network, ChangeSet(ps))
+
+@app.post("/deletejunction/",response_model=None)
+async def fastapi_delete_junction(network: str, junction: str) -> ChangeSet:
+    ps = {'id' : junction} 
+    return delete_junction(network, ChangeSet(ps))
+
+@app.get("/getjunctionelevation/")
+async def fastapi_get_junction_elevation(network: str, junction: str) -> float:
+    ps = get_junction(network, junction)
+    return ps['elevation']
+
+@app.get("/getjunctionx/")
+async def fastapi_get_junction_x(network: str, junction: str) -> float:
+    ps = get_junction(network, junction)
+    return ps['x']
+
+@app.get("/getjunctiony/")
+async def fastapi_get_junction_x(network: str, junction: str) -> float:
+    ps = get_junction(network, junction)
+    return ps['y']
+
+@app.get("/getjunctioncoord/")
+async def fastapi_get_junction_coord(network: str, junction: str) -> dict[str, float]:
+    ps = get_junction(network, junction)
+    coord = { 'x' : ps['x'], 
+              'y' : ps['y'] }
+    return coord
+
+@app.get("/getjunctiondemand/")
+async def fastapi_get_junction_demand(network: str, junction: str) -> float:
+    ps = get_junction(network, junction)
+    return ps['demand']
+
+@app.get("/getjunctionpattern/")
+async def fastapi_get_junction_pattern(network: str, junction: str) -> str:
+    ps = get_junction(network, junction)
+    return ps['pattern']
+
+@app.post("/setjunctionelevation/",response_model=None)
+async def fastapi_set_junction_elevation(network: str, junction: str, elevation: float) -> ChangeSet:
+    ps = { 'id' : junction,
+           'elevation' : elevation }
+    return set_junction(network, ChangeSet(ps))
+
+@app.post("/setjunctionx/",response_model=None)
+async def fastapi_set_junction_x(network: str, junction: str, x: float) -> ChangeSet:
+    ps = { 'id' : junction,
+           'x' : x }
+    return set_junction(network, ChangeSet(ps))
+    
+@app.post("/setjunctiony/",response_model=None)
+async def fastapi_set_junction_y(network: str, junction: str, y: float) -> ChangeSet:
+    ps = { 'id' : junction,
+           'y' : y }
+    return set_junction(network, ChangeSet(ps))
+
+@app.post("/setjunctioncoord/",response_model=None)
+async def fastapi_set_junction_coord(network: str, junction: str, x: float, y: float) -> ChangeSet:
+    ps = { 'id' : junction,
+           'x' : x,
+           'y' : y } 
+    return set_junction(network, ChangeSet(ps))
+    
+@app.post("/setjunctiondemand/",response_model=None)
+async def fastapi_set_junction_demand(network: str, junction: str, demand: float) -> ChangeSet:
+    ps = { 'id' : junction,
+           'demand' : demand }
+    return set_junction(network, ChangeSet(ps))
+
+@app.post("/setjunctionpattern/",response_model=None)
+async def fastapi_set_junction_pattern(network: str, junction: str, pattern: str) -> ChangeSet:
+    ps = { 'id' : junction,
+           'pattern' : pattern }
+    return set_junction(network, ChangeSet(ps))
+
+@app.get("/getjunctionproperties/")
+async def fastapi_get_junction_properties(network: str, junction: str) -> dict[str, Any]:
+    return get_junction(network, junction)
+
+@app.post("/setjunctionproperties/",response_model=None)
+async def fastapi_set_junction_properties(network: str, junction: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    ps = { 'id' : junction } | props
+    return set_junction(network, ChangeSet(ps))
+
+############################################################
+# reservoir 3.[RESERVOIRS]
+############################################################
+@app.get('/getreservoirschema')
+async def fast_get_reservoir_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_reservoir_schema(network)
+
+@app.post("/addreservoir/",response_model=None)
+async def fastapi_add_reservoir(network: str, reservoir: str, x: float, y: float, head: float) -> ChangeSet:
+    ps = { 'id' : reservoir, 
+           'x' : x, 
+           'y' : y, 
+           'head' : head }
+    return add_reservoir(network, ChangeSet(ps)) 
+
+@app.post("/deletereservoir/",response_model=None)
+async def fastapi_delete_reservoir(network: str, reservoir: str) -> ChangeSet:
+    ps = { 'id' : reservoir }
+    return delete_reservoir(network, ChangeSet(ps))
+
+@app.get("/getreservoirhead/")
+async def fastapi_get_reservoir_head(network: str, reservoir: str) -> float | None:
+    ps = get_reservoir(network, reservoir)
+    return ps['head']
+
+@app.get("/getreservoirpattern/")
+async def fastapi_get_reservoir_pattern(network: str, reservoir: str) -> str | None:
+    ps = get_reservoir(network, reservoir)
+    return ps['pattern']
+
+@app.get("/getreservoirx/")
+async def fastapi_get_reservoir_x(network: str, reservoir: str) -> dict[str, float] | None:
+    ps = get_reservoir(network, reservoir)
+    return ps['x']
+
+@app.get("/getreservoiry/")
+async def fastapi_get_reservoir_y(network: str, reservoir: str) -> dict[str, float] | None:
+    ps = get_reservoir(network, reservoir)
+    return ps['y']
+
+@app.get("/getreservoircoord/")
+async def fastapi_get_reservoir_y(network: str, reservoir: str) -> dict[str, float] | None:
+    ps = get_reservoir(network, reservoir)
+    coord = { 'id' : reservoir,
+              'x' : ps['x'], 
+              'y' : ps['y'] }
+    return coord
+
+@app.post("/setreservoirhead/",response_model=None)
+async def fastapi_set_reservoir_head(network: str, reservoir: str, head: float) -> ChangeSet:
+    ps = { 'id' : reservoir, 
+           'head' : head }
+    return set_reservoir(network, ChangeSet(ps))
+
+@app.post("/setreservoirpattern/",response_model=None)
+async def fastapi_set_reservoir_pattern(network: str, reservoir: str, pattern: str) -> ChangeSet:
+    ps = { 'id' : reservoir, 
+           'pattern' : pattern }
+    return set_reservoir(network, ChangeSet(ps))
+
+@app.post("/setreservoirx/",response_model=None)
+async def fastapi_set_reservoir_x(network: str, reservoir: str, x: float) -> ChangeSet:
+    ps = { 'id' : reservoir, 
+           'x' : x }
+    return set_reservoir(network, ChangeSet(ps))
+
+@app.post("/setreservoirx/",response_model=None)
+async def fastapi_set_reservoir_y(network: str, reservoir: str, y: float) -> ChangeSet:
+    ps = { 'id' : reservoir, 
+           'y' : y }
+    return set_reservoir(network, ChangeSet(ps))
+
+@app.post("/setreservoircoord/",response_model=None)
+async def fastapi_set_reservoir_y(network: str, reservoir: str, x: float, y: float) -> ChangeSet:
+    ps = { 'id' : reservoir, 
+           'x' : x,
+           'y' : y }
+    return set_reservoir(network, ChangeSet(ps))
+
+@app.get("/getreservoirproperties/")
+async def fastapi_get_reservoir_properties(network: str, reservoir: str) -> dict[str, Any]:
+    return get_reservoir(network, reservoir)
+
+@app.post("/setreservoirproperties/",response_model=None)
+async def fastapi_set_reservoir_properties(network: str, reservoir: str
+                                           , req: Request) -> ChangeSet:
+    props = await req.json()
+    ps = { 'id' : reservoir } | props
+    return set_reservoir(network, ChangeSet(ps))
+
+
+############################################################
+# tank 4.[TANKS]
+############################################################
+@app.get('/gettankschema')
+async def fast_get_tank_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_tank_schema(network)
+
+@app.post("/addtank/",response_model=None)
+async def fastapi_add_tank(network: str, tank: str, x: float, y: float, elevation: float, init_level: float = 0, min_level: float = 0, max_level: float = 0, diameter: float = 0, min_vol: float = 0) -> ChangeSet:
+    ps = { 'id' : tank, 
+           'x' : x, 
+           'y' : y, 
+           'elevation' : elevation,
+           'init_level' : init_level,
+           'min_level' : min_level,
+           'max_level' : max_level,
+           'diameter' : diameter,
+           'min_vol' : min_vol 
+         }
+    return add_tank(network, ChangeSet(ps)) 
+
+@app.post("/deletetank/",response_model=None)
+async def fastapi_delete_tank(network: str, tank: str) -> ChangeSet:
+    ps = { 'id' : tank }
+    return delete_tank(network, ChangeSet(ps))
+
+@app.get("/gettankelevation/")
+async def fastapi_get_tank_elevation(network: str, tank: str) -> float | None:
+    ps = get_tank(network, tank)
+    return ps['elevation']
+
+@app.get("/gettankinitlevel/")
+async def fastapi_get_tank_init_level(network: str, tank: str) -> float | None:
+    ps = get_tank(network, tank)
+    return ps['init_level']
+
+@app.get("/gettankminlevel/")
+async def fastapi_get_tank_min_level(network: str, tank: str) -> float | None:
+    ps = get_tank(network, tank)
+    return ps['min_level']
+
+@app.get("/gettankmaxlevel/")
+async def fastapi_get_tank_max_level(network: str, tank: str) -> float | None:
+    ps = get_tank(network, tank)
+    return ps['max_level']
+
+@app.get("/gettankdiameter/")
+async def fastapi_get_tank_diameter(network: str, tank: str) -> float | None:
+    ps = get_tank(network, tank)
+    return ps['diameter']
+
+@app.get("/gettankminvol/")
+async def fastapi_get_tank_min_vol(network: str, tank: str) -> float | None:
+    ps = get_tank(network, tank)
+    return ps['min_vol'] 
+
+@app.get("/gettankvolcurve/")
+async def fastapi_get_tank_vol_curve(network: str, tank: str) -> str | None:
+    ps = get_tank(network, tank)
+    return ps['vol_curve']
+
+@app.get("/gettankoverflow/")
+async def fastapi_get_tank_overflow(network: str, tank: str) -> str | None:
+    ps = get_tank(network, tank)
+    return ps['overflow']
+
+@app.get("/gettankx/")
+async def fastapi_get_tank_x(network: str, tank: str) -> float:
+    ps = get_tank(network, tank)
+    return ps['x']
+
+@app.get("/gettanky/")
+async def fastapi_get_tank_x(network: str, tank: str) -> float:
+    ps = get_tank(network, tank)
+    return ps['y']
+
+@app.get("/gettankcoord/")
+async def fastapi_get_tank_coord(network: str, tank: str) -> dict[str, float]:
+    ps = get_tank(network, tank)
+    coord = { 'x' : ps['x'], 
+              'y' : ps['y'] }
+    return coord
+
+@app.post("/settankelevation/",response_model=None)
+async def fastapi_set_tank_elevation(network: str, tank: str, elevation: float) -> ChangeSet:
+    ps = { 'id' : tank,
+           'elevation' : elevation }
+    return set_tank(network, ChangeSet(ps))
+
+@app.post("/settankinitlevel/",response_model=None)
+async def fastapi_set_tank_init_level(network: str, tank: str, init_level: float) -> ChangeSet:
+    ps = { 'id' : tank,
+           'init_level' : init_level }
+    return set_tank(network, ChangeSet(ps))
+
+@app.post("/settankminlevel/",response_model=None)
+async def fastapi_set_tank_min_level(network: str, tank: str, min_level: float) -> ChangeSet:
+    ps = { 'id' : tank,
+           'min_level' : min_level }
+    return set_tank(network, ChangeSet(ps))
+
+@app.post("/settankmaxlevel/",response_model=None)
+async def fastapi_set_tank_max_level(network: str, tank: str, max_level: float) -> ChangeSet:
+    ps = { 'id' : tank,
+           'max_level' : max_level }
+    return set_tank(network, ChangeSet(ps))
+
+@app.post("settankdiameter//",response_model=None)
+async def fastapi_set_tank_diameter(network: str, tank: str, diameter: float) -> ChangeSet:
+    ps = { 'id' : tank,
+           'diameter' : diameter }
+    return set_tank(network, ChangeSet(ps))
+
+@app.post("/settankminvol/",response_model=None)
+async def fastapi_set_tank_min_vol(network: str, tank: str, min_vol: float) -> ChangeSet:
+    ps = { 'id' : tank,
+           'min_vol' : min_vol }
+    return set_tank(network, ChangeSet(ps))
+
+@app.post("/settankvolcurve/",response_model=None)
+async def fastapi_set_tank_vol_curve(network: str, tank: str, vol_curve: str) -> ChangeSet:
+    ps = { 'id' : tank,
+           'vol_curve' : vol_curve}
+    return set_tank(network, ChangeSet(ps))
+
+@app.post("/settankoverflow/",response_model=None)
+async def fastapi_set_tank_overflow(network: str, tank: str, overflow: str) -> ChangeSet:
+    ps = { 'id' : tank,
+           'overflow' : overflow }
+    return set_tank(network, ChangeSet(ps))
+
+@app.post("/settankx/",response_model=None)
+async def fastapi_set_tank_x(network: str, tank: str, x: float) -> ChangeSet:
+    ps = { 'id' : tank,
+           'x' : x }
+    return set_tank(network, ChangeSet(ps))
+
+@app.post("/settanky/",response_model=None)
+async def fastapi_set_tank_y(network: str, tank: str, y: float) -> ChangeSet:
+    ps = { 'id' : tank,
+           'y' : y }
+    return set_tank(network, ChangeSet(ps))
+
+@app.post("/settankcoord/",response_model=None)
+async def fastapi_set_tank_coord(network: str, tank: str, x: float, y: float) -> ChangeSet:
+    ps = { 'id' : tank,
+           'x' : x, 
+           'y' : y }
+    return set_tank(network, ChangeSet(ps))
+
+@app.get("/gettankproperties/")
+async def fastapi_get_tank_properties(network: str, tank: str) -> dict[str, Any]:
+    return get_tank(network, tank)
+
+@app.post("/settankproperties/",response_model=None)
+async def fastapi_set_tank_properties(network: str, tank: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    ps = { 'id' : tank } | props
+    return set_tank(network, ChangeSet(ps)) 
+
+############################################################
+# pipe 4.[PIPES]
+############################################################
+@app.get('/getpipeschema')
+async def fastapi_get_pipe_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_pipe_schema(network)
+
+@app.post("/addpipe/",response_model=None)
+async def fastapi_add_pipe(network: str, pipe: str, node1: str, node2: str, length: float = 0, 
+                           diameter: float = 0, roughness: float = 0, minor_loss: float = 0, status: str = PIPE_STATUS_OPEN) -> ChangeSet:
+    ps = { 'id' : pipe,
+           'node1' : node1,
+           'node2' : node2,
+           'length' : length,
+           'diameter' : diameter,
+           'roughness' : roughness,
+           'minor_loss' : minor_loss,
+           'status' : status }   
+    return add_pipe(network, ChangeSet(ps))
+
+@app.post("/deletepipe/",response_model=None)
+async def fastapi_delete_pipe(network: str, pipe: str) -> ChangeSet:
+    ps = {'id' : pipe} 
+    return delete_pipe(network, ChangeSet(ps))
+
+@app.get("/getpipenode1/")
+async def fastapi_get_pipe_node1(network: str, pipe: str) -> str | None:
+    ps = get_pipe(network, pipe)
+    return ps['node1']
+
+@app.get("/getpipenode2/")
+async def fastapi_get_pipe_node2(network: str, pipe: str) -> str | None:
+    ps = get_pipe(network, pipe)
+    return ps['node2']
+
+@app.get("/getpipelength/")
+async def fastapi_get_pipe_length(network: str, pipe: str) -> float | None:
+    ps = get_pipe(network, pipe)
+    return ps['length']
+
+@app.get("/getpipediameter/")
+async def fastapi_get_pipe_diameter(network: str, pipe: str) -> float | None:
+    ps = get_pipe(network, pipe)
+    return ps['diameter']
+
+@app.get("/getpiperoughness/")
+async def fastapi_get_pipe_roughness(network: str, pipe: str) -> float | None:
+    ps = get_pipe(network, pipe)
+    return ps['roughness']
+
+@app.get("/getpipeminorloss/")
+async def fastapi_get_pipe_minor_loss(network: str, pipe: str) -> float | None:
+    ps = get_pipe(network, pipe)
+    return ps['minor_loss']
+
+@app.get("/getpipestatus/")
+async def fastapi_get_pipe_status(network: str, pipe: str) -> str | None:
+    ps = get_pipe(network, pipe)
+    return ps['status']
+
+@app.post("/setpipenode1/",response_model=None)
+async def fastapi_set_pipe_node1(network: str, pipe: str, node1: str) -> ChangeSet:
+    ps = { 'id' : pipe,
+           'node1' : node1 }
+    return set_pipe(network, ChangeSet(ps))
+
+@app.post("/setpipenode2/",response_model=None)
+async def fastapi_set_pipe_node2(network: str, pipe: str, node2: str) -> ChangeSet:
+    ps = { 'id' : pipe,
+           'node2' : node2 }
+    return set_pipe(network, ChangeSet(ps))
+
+@app.post("/setpipelength/",response_model=None)
+async def fastapi_set_pipe_length(network: str, pipe: str, length: float) -> ChangeSet:
+    ps = { 'id' : pipe,
+           'length' : length }
+    return set_pipe(network, ChangeSet(ps))
+
+@app.post("/setpipediameter/",response_model=None)
+async def fastapi_set_pipe_diameter(network: str, pipe: str, diameter: float) -> ChangeSet:
+    ps = { 'id' : pipe,
+           'diameter' : diameter }
+    return set_pipe(network, ChangeSet(ps))
+
+@app.post("/setpiperoughness/",response_model=None)
+async def fastapi_set_pipe_roughness(network: str, pipe: str, roughness: float) -> ChangeSet:
+    ps = { 'id' : pipe,
+           'roughness' : roughness }
+    return set_pipe(network, ChangeSet(ps))
+
+@app.post("/setpipeminorloss/",response_model=None)
+async def fastapi_set_pipe_minor_loss(network: str, pipe: str, minor_loss: float) -> ChangeSet:
+    ps = { 'id' : pipe,
+           'minor_loss' : minor_loss }
+    return set_pipe(network, ChangeSet(ps))
+
+@app.post("/setpipestatus/",response_model=None)
+async def fastapi_set_pipe_status(network: str, pipe: str, status: str) -> ChangeSet:
+    ps = { 'id' : pipe,
+           'status' : status }
+
+    print(status)
+    print(ps)
+
+    ret = set_pipe(network, ChangeSet(ps))
+    print(ret)
+    return ret
+
+@app.get("/getpipeproperties/")
+async def fastapi_get_pipe_properties(network: str, pipe: str) -> dict[str, Any]:
+    return get_pipe(network, pipe)
+
+@app.post("/setpipeproperties/",response_model=None)
+async def fastapi_set_pipe_properties(network: str, pipe: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    ps = { 'id' : pipe } | props
+    return set_pipe(network, ChangeSet(ps))
+    
+
+############################################################
+# pump 4.[PUMPS]
+############################################################
+@app.get('/getpumpschema')
+async def fastapi_get_pump_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_pump_schema(network)
+
+@app.post("/addpump/",response_model=None)
+async def fastapi_add_pump(network: str, pump: str, node1: str, node2: str, power: float = 0.0) -> ChangeSet:
+    ps = { 'id' : pump,
+           'node1' : node1,
+           'node2' : node2,
+           'power' : power 
+         }
+    return add_pump(network, ChangeSet(ps))
+
+@app.post("/deletepump/",response_model=None)
+async def fastapi_delete_pump(network: str, pump: str) -> ChangeSet:
+    ps = { 'id' : pump } 
+    return delete_pump(network, ChangeSet(ps)) 
+
+@app.get("/getpumpnode1/")
+async def fastapi_get_pump_node1(network: str, pump: str) -> str | None:
+    ps = get_pump(network, pump)
+    return ps['node1']
+
+@app.get("/getpumpnode2/")
+async def fastapi_get_pump_node2(network: str, pump: str) -> str | None:
+    ps = get_pump(network, pump)
+    return ps['node2']
+
+@app.post("/setpumpnode1/",response_model=None)
+async def fastapi_set_pump_node1(network: str, pump: str, node1: str) -> ChangeSet:
+    ps = { 'id' : pump,
+           'node1' : node1 } 
+    return set_pump(network, ChangeSet(ps))
+
+@app.post("/setpumpnode2/",response_model=None)
+async def fastapi_set_pump_node2(network: str, pump: str, node2: str) -> ChangeSet:
+    ps = { 'id' : pump,
+           'node2' : node2 } 
+    return set_pump(network, ChangeSet(ps))
+
+@app.get("/getpumpproperties/")
+async def fastapi_get_pump_properties(network: str, pump: str) -> dict[str, Any]:
+    return get_pump(network, pump)
+
+@app.post("/setpumpproperties/",response_model=None)
+async def fastapi_set_pump_properties(network: str, pump: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    ps = { 'id' : pump } | props
+    return set_pump(network, ChangeSet(ps)) 
+
+
+############################################################
+# valve 4.[VALVES]
+############################################################
+@app.get('/getvalveschema')
+async def fastapi_get_valve_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_valve_schema(network)
+
+@app.post("/addvalve/",response_model=None)
+async def fastapi_add_valve(network: str, valve: str, node1: str, node2: str, diameter: float = 0, v_type: str = VALVES_TYPE_PRV, setting: float = 0, minor_loss: float = 0) -> ChangeSet:
+    ps = { 'id' : valve,
+           'node1' : node1,
+           'node2' : node2,
+           'diameter' : diameter,
+           'v_type' : v_type,
+           'setting' : setting,
+           'minor_loss' : minor_loss }
+           
+    return add_valve(network, ChangeSet(ps)) 
+
+@app.post("/deletevalve/",response_model=None)
+async def fastapi_delete_valve(network: str, valve: str) -> ChangeSet:
+    ps = { 'id' : valve } 
+    return delete_valve(network, ChangeSet(ps)) 
+
+@app.get("/getvalvenode1/")
+async def fastapi_get_valve_node1(network: str, valve: str) -> str | None:
+    ps = get_valve(network, valve)
+    return ps['node1']
+
+@app.get("/getvalvenode2/")
+async def fastapi_get_valve_node2(network: str, valve: str) -> str | None:
+    ps = get_valve(network, valve)
+    return ps['node2']
+
+@app.get("/getvalvediameter/")
+async def fastapi_get_valve_diameter(network: str, valve: str) -> float | None:
+    ps = get_valve(network, valve)
+    return ps['diameter']
+
+@app.get("/getvalvetype/")
+async def fastapi_get_valve_type(network: str, valve: str) -> str | None:
+    ps = get_valve(network, valve)
+    return ps['type']
+
+@app.get("/getvalvesetting/")
+async def fastapi_get_valve_setting(network: str, valve: str) -> float | None:
+    ps = get_valve(network, valve)
+    return ps['setting']
+
+@app.get("/getvalveminorloss/")
+async def fastapi_get_valve_minor_loss(network: str, valve: str) -> float | None:
+    ps = get_valve(network, valve)
+    return ps['minor_loss']
+
+@app.post("/setvalvenode1/",response_model=None)
+async def fastapi_set_valve_node1(network: str, valve: str, node1: str) -> ChangeSet:
+    ps = { 'id' : valve,
+           'node1' : node1 } 
+    return set_valve(network, ChangeSet(ps))
+
+@app.post("/setvalvenode2/",response_model=None)
+async def fastapi_set_valve_node2(network: str, valve: str, node2: str) -> ChangeSet:
+    ps = { 'id' : valve,
+           'node2' : node2 } 
+    return set_valve(network, ChangeSet(ps))
+
+@app.post("/setvalvenodediameter/",response_model=None)
+async def fastapi_set_valve_diameter(network: str, valve: str, diameter: float) -> ChangeSet:
+    ps = { 'id' : valve,
+           'diameter' : diameter } 
+    return set_valve(network, ChangeSet(ps))
+
+@app.post("/setvalvetype/",response_model=None)
+async def fastapi_set_valve_type(network: str, valve: str, type: str) -> ChangeSet:
+    ps = { 'id' : valve,
+           'type' : type } 
+    return set_valve(network, ChangeSet(ps))
+
+@app.post("/setvalvesetting/",response_model=None)
+async def fastapi_set_valve_setting(network: str, valve: str, setting: float) -> ChangeSet:
+    ps = { 'id' : valve,
+           'setting' : setting } 
+    return set_valve(network, ChangeSet(ps))
+
+@app.get("/getvalveproperties/")
+async def fastapi_get_valve_properties(network: str, valve: str) -> dict[str, Any]:
+    return get_valve(network, valve)
+
+@app.post("/setvalveproperties/",response_model=None)
+async def fastapi_set_valve_properties(network: str, valve: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    ps = { 'id' : valve } | props
+    return set_valve(network, ChangeSet(ps)) 
+    
+    
+# node & link
+@app.post("/deletenode/",response_model=None)
+async def fastapi_delete_node(network: str, node: str) -> ChangeSet:
+    ps = {'id' : node} 
+    if is_junction(network, node):
+        return delete_junction(network, ChangeSet(ps))
+    elif is_reservoir(network, node):
+        return delete_reservoir(network, ChangeSet(ps))
+    elif is_tank(network, node):
+        return delete_tank(network, ChangeSet(ps))
+    
+@app.post("/deletelink/",response_model=None)
+async def fastapi_delete_link(network: str, link: str) -> ChangeSet:
+    ps = {'id' : link} 
+    if is_pipe(network, link):
+        return delete_pipe(network, ChangeSet(ps))
+    elif is_pump(network, link):
+        return delete_pump(network, ChangeSet(ps))
+    elif is_valve(network, link):
+        return delete_valve(network, ChangeSet(ps))
+
+############################################################
+# tag 8.[TAGS]
+############################################################
+#
+# TAG_TYPE_NODE = api.TAG_TYPE_NODE
+# TAG_TYPE_LINK = api.TAG_TYPE_LINK
+#
+
+@app.get('/gettagschema/')
+async def fastapi_get_tag_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_tag_schema(network)
+
+@app.get('/gettag/')
+async def fastapi_get_tag(network: str, t_type: str, id: str) -> dict[str, Any]:
+    return get_tag(network, t_type, id)
+
+@app.get('/gettags/')
+async def fastapi_get_tags(network: str) -> list[dict[str, Any]]:
+    tags = get_tags(network)
+    print(tags)
+    return tags
+
+# example:
+# set_tag(p, ChangeSet({'t_type': TAG_TYPE_NODE, 'id': 'j1', 'tag': 'j1t' }))
+# set_tag(p, ChangeSet({'t_type': TAG_TYPE_LINK, 'id': 'p0', 'tag': 'p0t' }))
+@app.post('/settag/',response_model=None)
+async def fastapi_set_tag(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_tag(network, ChangeSet(props))
+    
+############################################################
+# demand 9.[DEMANDS]
+############################################################
+@app.get('/getdemandschema')
+async def fastapi_get_demand_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_demand_schema(network)
+
+@app.get("/getdemandproperties/")
+async def fastapi_get_demand_properties(network: str, junction: str) -> dict[str, Any]:
+    return get_demand(network, junction)
+
+# example: set_demand(p, ChangeSet({'junction': 'j1', 'demands': [{'demand': 10.0, 'pattern': None, 'category': 'x'}, {'demand': 20.0, 'pattern': None, 'category': None}]}))
+@app.post("/setdemandproperties/",response_model=None)
+async def fastapi_set_demand_properties(network: str, junction: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    ps = { 'junction' : junction } | props
+    return set_demand(network, ChangeSet(ps)) 
+
+############################################################
+# status 10.[STATUS]  init_status
+############################################################
+@app.get('/getstatusschema')
+async def fastapi_get_status_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_status_schema(network)
+
+@app.get("/getstatus/")
+async def fastapi_get_status(network: str, link: str) -> dict[str, Any]:
+    return get_status(network, link)
+
+# example: set_status(p, ChangeSet({'link': 'p0', 'status': LINK_STATUS_OPEN, 'setting': 10.0}))
+@app.post("/setstatus/",response_model=None)
+async def fastapi_set_status_properties(network: str, link: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    ps = { 'link' : link } | props
+    return set_status(network, ChangeSet(ps)) 
+
+############################################################
+# pattern 11.[PATTERNS]
+############################################################
+@app.get('/getpatternschema')
+async def fastapi_get_pattern_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_pattern_schema(network)
+
+@app.post("/addpattern/",response_model=None)
+async def fastapi_add_pattern(network: str, pattern: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    ps = { 
+            'id' : pattern,
+         } | props
+    return add_pattern(network, ChangeSet(ps))
+
+@app.post("/deletepattern/",response_model=None)
+async def fastapi_delete_pattern(network: str, pattern: str) -> ChangeSet:
+    ps = { 'id' : pattern }
+    return delete_pattern(network, ChangeSet(ps))
+
+@app.get("/getpatternproperties/")
+async def fastapi_get_pattern_properties(network: str, pattern: str) -> dict[str, Any]:
+    return get_pattern(network, pattern)
+
+# example: set_pattern(p, ChangeSet({'id' : 'p0', 'factors': [1.0, 2.0, 3.0]}))
+@app.post("/setpatternproperties/",response_model=None)
+async def fastapi_set_pattern_properties(network: str, pattern: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    ps = { 'id' : pattern } | props
+    return set_pattern(network, ChangeSet(ps)) 
+
+############################################################
+# curve 12.[CURVES]
+############################################################
+@app.get('/getcurveschema')
+async def fastapi_get_curve_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_curve_schema(network)
+
+@app.post("/addcurve/",response_model=None)
+async def fastapi_add_curve(network: str, curve: str, req: Request) -> ChangeSet:
+    props = await req.json()
+
+    print(props)
+
+    ps = { 
+            'id' : curve,
+         } | props
+    
+    print(ps)
+    
+    return add_curve(network, ChangeSet(ps)) 
+
+@app.post("/deletecurve/",response_model=None)
+async def fastapi_delete_curve(network: str, curve: str) -> ChangeSet:
+    ps = { 'id' : curve }
+    return delete_curve(network, ChangeSet(ps))
+
+@app.get("/getcurveproperties/")
+async def fastapi_get_curve_properties(network: str, curve: str) -> dict[str, Any]:
+    return get_curve(network, curve)
+
+# example: set_curve(p, ChangeSet({'id' : 'c0', 'c_type' : CURVE_TYPE_PUMP, 'coords': [{'x': 1.0, 'y': 2.0}, {'x': 2.0, 'y': 1.0}]}))
+@app.post("/setcurveproperties/",response_model=None)
+async def fastapi_set_curve_properties(network: str, curve: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    # c_type放到request中
+    ps = { 'id' : curve } | props
+    return set_curve(network, ChangeSet(ps)) 
+
+
+############################################################
+# control 13.[CONTROLS]
+############################################################
+@app.get('/getcontrolschema/')
+async def fastapi_get_control_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_control_schema(network)
+
+@app.get("/getcontrolproperties/")
+async def fastapi_get_control_properties(network: str) -> dict[str, Any]:
+    return get_control(network)
+
+# example: set_control(p, ChangeSet({'control': 'x'}))
+@app.post("/setcontrolproperties/",response_model=None)
+async def fastapi_set_control_properties(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_control(network, ChangeSet(props)) 
+
+############################################################
+# rule 14.[RULES]
+############################################################
+@app.get("/getruleschema/")
+async def fastapi_get_rule_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_rule_schema(network)
+
+@app.get("/getruleproperties/")
+async def fastapi_get_rule_properties(network: str) -> dict[str, Any]:
+    return get_rule(network)
+
+# example: set_rule(p, ChangeSet({'rule': 'x'}))
+@app.post("/setruleproperties/",response_model=None)
+async def fastapi_set_rule_properties(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_rule(network, ChangeSet(props))
+
+
+############################################################
+# energy 15.[ENERGY]
+############################################################
+@app.get("/getenergyschema/")
+async def fastapi_get_energy_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_energy_schema(network)
+
+@app.get("/getenergyproperties/")
+async def fastapi_get_energy_properties(network: str) -> dict[str, Any]:
+    return get_energy(network)
+
+@app.post("/setenergyproperties/",response_model=None)
+async def fastapi_set_energy_properties(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_energy(network, ChangeSet(props))
+
+@app.get("/getpumpenergyschema/")
+async def fastapi_get_pump_energy_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_pump_energy_schema(network)
+
+@app.get("/getpumpenergyproperties//")
+async def fastapi_get_pump_energy_proeprties(network: str, pump: str) -> dict[str, Any]:
+    return get_pump_energy(network, pump)
+
+@app.get("/setpumpenergyproperties//",response_model=None)
+async def fastapi_set_pump_energy_properties(network: str, pump: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    ps = { 'id' : pump } | props
+    return set_pump_energy(network, ChangeSet(ps))
+
+############################################################
+# emitter 16.[EMITTERS]
+############################################################
+@app.get('/getemitterschema')
+async def fastapi_get_emitter_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_emitter_schema(network)
+
+@app.get("/getemitterproperties/")
+async def fastapi_get_emitter_properties(network: str, junction: str) -> dict[str, Any]:
+    return get_emitter(network, junction)
+
+# example: set_emitter(p, ChangeSet({'junction': 'j1', 'coefficient': 10.0}))
+@app.post("/setemitterproperties/",response_model=None)
+async def fastapi_set_emitter_properties(network: str, junction: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    ps = { 'junction' : junction } | props
+    return set_emitter(network, ChangeSet(ps)) 
+
+
+############################################################
+# quality 17.[QUALITY]
+############################################################
+@app.get('/getqualityschema/')
+async def fastapi_get_quality_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_quality_schema(network)
+
+@app.get('/getqualityproperties/')
+async def fastapi_get_quality_properties(network: str, node: str) -> dict[str, Any]:
+    return get_quality(network, node)
+
+# example: set_quality(p, ChangeSet({'node': 'j1', 'quality': 10.0}))
+@app.post("/setqualityproperties/",response_model=None)
+async def fastapi_set_quality_properties(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_quality(network, ChangeSet(props)) 
+    
+
+############################################################
+# source 18.[SOURCES]
+############################################################
+@app.get('/getsourcechema/')
+async def fastapi_get_source_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_source_schema(network)
+
+@app.get('/getsource/')
+async def fastapi_get_source(network: str, node: str) -> dict[str, Any]:
+    return get_source(network, node)
+
+@app.post('/setsource/',response_model=None)
+async def fastapi_set_source(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_source(network, ChangeSet(props))
+
+# example: add_source(p, ChangeSet({'node': 'j0', 's_type': SOURCE_TYPE_CONCEN, 'strength': 10.0, 'pattern': 'p0'}))
+@app.post('/addsource/',response_model=None)
+async def fastapi_add_source(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return add_source(network, ChangeSet(props))
+
+@app.post('/deletesource/',response_model=None)
+async def fastapi_delete_source(network: str, node: str) -> ChangeSet:
+    props = { 'node': node }
+    return delete_source(network, ChangeSet(props))
+
+
+############################################################
+# reaction 19.[REACTIONS]
+############################################################
+@app.get('/getreactionschema/')
+async def fastapi_get_reaction_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_reaction_schema(network)
+
+@app.get('/getreaction/')
+async def fastapi_get_reaction(network: str) -> dict[str, Any]:
+    return get_reaction(network)
+
+@app.post('/setreaction/',response_model=None)
+# set_reaction(p, ChangeSet({ 'ORDER BULK' : '10' }))
+async def fastapi_set_reaction(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_reaction(network, ChangeSet(props))
+
+@app.get('/getpipereactionschema/')
+async def fastapi_get_pipe_reaction_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_pipe_reaction_schema(network)
+
+@app.get('/getpipereaction/')
+async def fastapi_get_pipe_reaction(network: str, pipe: str) -> dict[str, Any]:
+    return get_pipe_reaction(network, pipe)
+
+@app.post('/setpipereaction/',response_model=None)
+async def fastapi_set_pipe_reaction(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_pipe_reaction(network, ChangeSet(props))
+
+@app.get('/gettankreactionschema/')
+async def fastapi_get_tank_reaction_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_tank_reaction_schema(network)
+
+@app.get('/gettankreaction/')
+async def fastapi_get_tank_reaction(network: str, tank: str) -> dict[str, Any]:
+    return get_tank_reaction(network, tank)
+
+@app.post('/settankreaction/',response_model=None)
+async def fastapi_set_tank_reaction(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_tank_reaction(network, ChangeSet(props))
+
+
+############################################################
+# mixing 20.[MIXING]
+############################################################
+@app.get('/getmixingschema/')
+async def fastapi_get_mixing_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_mixing_schema(network)
+
+@app.get('/getmixing/')
+async def fastapi_get_mixing(network: str, tank: str) -> dict[str, Any]:
+    return get_mixing(network, tank)
+
+@app.post('/setmixing/',response_model=None)
+async def fastapi_set_mixing(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return api.set_mixing(network, ChangeSet(props))
+
+# example: add_mixing(p, ChangeSet({'tank': 't0', 'model': MIXING_MODEL_MIXED, 'value': 10.0}))
+@app.post('/addmixing/',response_model=None)
+async def fastapi_add_mixing(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return add_mixing(network, ChangeSet(props))
+
+@app.post('/deletemixing/',response_model=None)
+async def fastapi_delete_mixing(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return delete_mixing(network, ChangeSet(props))
+
+
+############################################################
+# time 21.[TIME]
+############################################################
+@app.get('/gettimeschema')
+async def fastapi_get_time_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_time_schema(network)
+
+@app.get("/gettimeproperties/")
+async def fastapi_get_time_properties(network: str) -> dict[str, Any]:
+    return get_time(network)
+
+@app.post("/settimeproperties/",response_model=None)
+async def fastapi_set_time_properties(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_time(network, ChangeSet(props)) 
+
+############################################################
+# option 23.[OPTIONS]
+############################################################
+@app.get('/getoptionschema/')
+async def fastapi_get_option_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_option_v3_schema(network)
+
+@app.get("/getoptionproperties/")
+async def fastapi_get_option_properties(network: str) -> dict[str, Any]:
+    return get_option_v3(network)
+
+@app.post("/setoptionproperties/",response_model=None)
+async def fastapi_set_option_properties(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_option_v3(network, ChangeSet(props)) 
+
+############################################################
+# coord 24.[COORDINATES]
+############################################################
+@app.get("/getnodecoord/")
+async def fastapi_get_node_coord(network: str, node: str) -> dict[str, float] | None:
+    return get_node_coord(network, node)
+
+############################################################
+# vertex 25.[VERTICES]
+############################################################
+@app.get('/getvertexschema/')
+async def fastapi_get_vertex_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_vertex_schema(network)
+
+@app.get('/getvertexproperties/')
+async def fastapi_get_vertex_properties(network: str, link: str) -> dict[str, Any]:
+    return get_vertex(network, link)
+
+# set_vertex(p, ChangeSet({'link' : 'p0', 'coords': [{'x': 1.0, 'y': 2.0}, {'x': 2.0, 'y': 1.0}]}))
+@app.post('/setvertexproperties/',response_model=None)
+async def fastapi_set_vertex_properties(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_vertex(network, ChangeSet(props)) 
+
+@app.post('/addvertex/',response_model=None)
+async def fastapi_add_vertex(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return add_vertex(network, ChangeSet(props)) 
+
+@app.post('/deletevertex/',response_model=None)
+async def fastapi_delete_vertex(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return api.delete_vertex(network, ChangeSet(props))
+
+@app.get('/getallvertexlinks/', response_class = PlainTextResponse)
+async def fastapi_get_all_vertex_links(network: str) -> list[str]:
+    return json.dumps(get_all_vertex_links(network))
+
+@app.get('/getallvertices/', response_class = PlainTextResponse)
+async def fastapi_get_all_vertices(network: str) -> list[dict[str, Any]]:
+    return json.dumps(get_all_vertices(network))
+
+############################################################
+# label 26.[LABELS]
+############################################################
+@app.get('/getlabelschema/')
+async def fastapi_get_label_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_label_schema(network)
+
+@app.get('/getlabelproperties/')
+async def fastapi_get_label_properties(network: str, x: float, y: float) -> dict[str, Any]:
+    return get_label(network, x, y)
+
+@app.post('/setlabelproperties/',response_model=None)
+async def fastapi_set_label_properties(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_label(network, ChangeSet(props))
+
+@app.post('/addlabel/',response_model=None)
+async def fastapi_add_label(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return add_label(network, ChangeSet(props))
+
+@app.post('/deletelabel/',response_model=None)
+async def fastapi_delete_label(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return delete_label(network, ChangeSet(props))
+
+
+############################################################
+# backdrop 27.[BACKDROP]
+############################################################
+@app.get('/getbackdropschema/')
+async def fastapi_get_backdrop_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_backdrop_schema(network)
+
+@app.get('/getbackdropproperties/')
+async def fastapi_get_backdrop_properties(network: str) -> dict[str, Any]:
+    return get_backdrop(network)
+
+@app.post('/setbackdropproperties/',response_model=None)
+async def fastapi_set_backdrop_properties(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_backdrop(network, ChangeSet(props))
+
+############################################################
+# scada_device 29
+############################################################
+@app.get('/getscadadeviceschema/')
+async def fastapi_get_scada_device_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_scada_device_schema(network)
+
+@app.get('/getscadadevice/')
+async def fastapi_get_scada_device(network: str, id: str) -> dict[str, Any]:
+    return get_scada_device(network, id)
+
+@app.post('/setscadadevice/',response_model=None)
+async def fastapi_set_scada_device(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_scada_device(network, ChangeSet(props))
+
+@app.post('/addscadadevice/',response_model=None)
+async def fastapi_add_scada_device(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return add_scada_device(network, ChangeSet(props))
+
+@app.post('/deletescadadevice/',response_model=None)
+async def fastapi_delete_scada_device(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return delete_scada_device(network, ChangeSet(props))
+
+@app.post('/cleanscadadevice/',response_model=None)
+async def fastapi_clean_scada_device(network: str) -> ChangeSet:
+    return clean_scada_device(network)
+
+@app.get('/getallscadadeviceids/')
+async def fastapi_get_all_scada_device_ids(network: str) -> list[str]:
+    return get_all_scada_device_ids(network)
+
+@app.get('/getallscadadevices/', response_class = PlainTextResponse)
+async def fastapi_get_all_scada_devices(network: str) -> list[dict[str, Any]]:
+    return json.dumps(get_all_scada_devices(network))
+
+
+############################################################
+# scada_device_data 30
+############################################################
+@app.get('/getscadadevicedataschema/')
+async def fastapi_get_scada_device_data_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_scada_device_data_schema(network)
+
+@app.get('/getscadadevicedata/')
+async def fastapi_get_scada_device_data(network: str, id: str) -> dict[str, Any]:
+    return get_scada_device_data(network, id)
+
+# example: set_scada_device_data(p, ChangeSet({'device_id': 'sm_device', 'data': [{ 'time': '2023-02-10 00:02:22', 'value': 100.0 }, { 'time': '2023-02-10 00:03:22', 'value': 200.0 }]}))
+# time format must be 'YYYY-MM-DD HH:MM:SS'
+@app.post('/setscadadevicedata/',response_model=None)
+async def fastapi_set_scada_device_data(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_scada_device_data(network, ChangeSet(props))
+
+# example: add_scada_device_data(p, ChangeSet({'device_id': 'sm_device', 'time': '2023-02-10 00:02:22', 'value': 100.0}))
+@app.post('/addscadadevicedata/',response_model=None)
+async def fastapi_add_scada_device_data(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return add_scada_device_data(network, ChangeSet(props))
+
+# example: delete_scada_device_data(p, ChangeSet({'device_id': 'sm_device', 'time': '2023-02-12 00:02:22'}))
+@app.post('/deletescadadevicedata/',response_model=None)
+async def fastapi_delete_scada_device_data(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return delete_scada_device_data(network, ChangeSet(props))
+
+@app.post('/cleanscadadevicedata/',response_model=None)
+async def fastapi_clean_scada_device_data(network: str) -> ChangeSet:
+    return clean_scada_device_data(network)
+
+
+############################################################
+# scada_element 31
+############################################################
+@app.get('/getscadaelementschema/')
+async def fastapi_get_scada_element_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_scada_element_schema(network)
+
+@app.get('/getscadaelements/')
+async def fastapi_get_scada_elements(network: str) -> list[str]:
+    return get_scada_elements(network)
+
+@app.get('/getscadaelement/')
+async def fastapi_get_scada_element(network: str, id: str) -> dict[str, Any]:
+    return get_scada_element(network, id)
+
+@app.post('/setscadaelement/',response_model=None)
+async def fastapi_set_scada_element(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_scada_element(network, ChangeSet(props))
+
+@app.post('/addscadaelement/',response_model=None)
+async def fastapi_add_scada_element(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return add_scada_element(network, ChangeSet(props))
+
+@app.post('/deletescadaelement/',response_model=None)
+async def fastapi_delete_scada_element(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return delete_scada_element(network, ChangeSet(props))
+
+@app.post('/cleanscadaelement/',response_model=None)
+async def fastapi_clean_scada_element(network: str) -> ChangeSet:
+    return clean_scada_element(network)
+
+############################################################
+# general_region 32
+############################################################
+@app.get('/getregionschema/')
+async def fastapi_get_region_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_region_schema(network)
+
+@app.get('/getregion/')
+async def fastapi_get_region(network: str, id: str) -> dict[str, Any]:
+    return get_region(network, id)
+
+@app.post('/setregion/',response_model=None)
+async def fastapi_set_region(network : str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_region(network, ChangeSet(props))
+
+# example: add_region(p, ChangeSet({'id': 'r', 'boundary': [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]}))
+@app.post('/addregion/',response_model=None)
+async def fastapi_add_region(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return add_region(network, ChangeSet(props))
+
+@app.post('/deleteregion/',response_model=None)
+async def fastapi_delete_region(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return delete_region(network, ChangeSet(props))
+
+############################################################
+# district_metering_area 33
+############################################################
+@app.get('/calculatedistrictmeteringareafornodes/')
+async def fastapi_calculate_district_metering_area_for_nodes(network: str, req: Request) -> list[list[str]]:
+    props = await req.json()
+    nodes = props['nodes']
+    part_count = props['part_count']
+    part_type = props['part_type']
+    return calculate_district_metering_area_for_nodes(network, nodes, part_count, part_type)
+
+@app.get('/calculatedistrictmeteringareaforregion/')
+async def fastapi_calculate_district_metering_area_for_region(network: str, req: Request) -> list[list[str]]:
+    props = await req.json()
+    region = props['region']
+    part_count = props['part_count']
+    part_type = props['part_type']
+    return calculate_district_metering_area_for_region(network, region, part_count, part_type)
+
+@app.get('/calculatedistrictmeteringareafornetwork/')
+async def fastapi_calculate_district_metering_area_for_network(network: str, req: Request) -> list[list[str]]:
+    props = await req.json()
+    part_count = props['part_count']
+    part_type = props['part_type']
+    return calculate_district_metering_area_for_network(network, part_count, part_type)
+
+@app.get('/getdistrictmeteringareaschema/')
+async def fastapi_get_district_metering_area_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_district_metering_area_schema(network)
+
+@app.get('/getdistrictmeteringarea/')
+async def fastapi_get_district_metering_area(network: str, id: str) -> dict[str, Any]:
+    return get_district_metering_area(network, id)
+
+@app.post('/setdistrictmeteringarea/',response_model=None)
+async def fastapi_set_district_metering_area(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_district_metering_area(network, ChangeSet(props))
+
+@app.post('/adddistrictmeteringarea/',response_model=None)
+async def fastapi_add_district_metering_area(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+
+# boundary should be [(x,y), (x,y)]
+    boundary = props['boundary']
+    newBoundary = []
+    for pt in boundary:
+        newBoundary.append((pt[0], pt[1]))
+    
+    props['boundary'] = newBoundary
+               
+    return add_district_metering_area(network, ChangeSet(props))
+
+@app.post('/deletedistrictmeteringarea/',response_model=None)
+async def fastapi_delete_district_metering_area(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return delete_district_metering_area(network, ChangeSet(props))
+
+@app.get('/getalldistrictmeteringareaids/')
+async def fastapi_get_all_district_metering_area_ids(network: str) -> list[str]:
+    return get_all_district_metering_area_ids(network)
+
+@app.get('/getalldistrictmeteringareas/')
+async def getalldistrictmeteringareas(network: str) -> list[dict[str, Any]]:
+    return get_all_district_metering_areas(network)
+
+@app.post('/generatedistrictmeteringarea/',response_model=None)
+async def fastapi_generate_district_metering_area(network: str, part_count: int, part_type: int, inflate_delta: float) -> ChangeSet:
+    return generate_district_metering_area(network, part_count, part_type, inflate_delta)
+
+@app.post('/generatesubdistrictmeteringarea/',response_model=None)
+async def fastapi_generate_sub_district_metering_area(network: str, dma: str, part_count: int, part_type: int, inflate_delta: float) -> ChangeSet:
+    print(network)
+    print(dma)
+    print(part_count)
+    print(part_type)
+    print(inflate_delta)
+    return generate_sub_district_metering_area(network, dma, part_count, part_type, inflate_delta)
+
+############################################################
+# service_area 34
+############################################################
+@app.get('/calculateservicearea/')
+async def fastapi_calculate_service_area(network: str, time_index: int) -> dict[str, Any]:
+    return calculate_service_area(network, time_index)
+
+@app.get('/getserviceareaschema/')
+async def fastapi_get_service_area_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_service_area_schema(network)
+
+@app.get('/getservicearea/')
+async def fastapi_get_service_area(network: str, id: str) -> dict[str, Any]:
+    return get_service_area(network, id)
+
+@app.post('/setservicearea/',response_model=None)
+async def fastapi_set_service_area(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_service_area(network, ChangeSet(props))
+
+@app.post('/addservicearea/',response_model=None)
+async def fastapi_add_service_area(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return add_service_area(network, ChangeSet(props))
+
+@app.post('/deleteservicearea/',response_model=None)
+async def fastapi_delete_service_area(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return delete_service_area(network, ChangeSet(props))
+
+@app.get('/getallserviceareas/')
+async def fastapi_get_all_service_areas(network: str) -> list[dict[str, Any]]:
+    return get_all_service_areas(network)
+
+@app.post('/generateservicearea/',response_model=None)
+async def fastapi_generate_service_area(network: str, inflate_delta: float) -> ChangeSet:
+    return generate_service_area(network, inflate_delta)
+
+
+############################################################
+# virtual_district 35
+############################################################
+@app.get('/calculatevirtualdistrict/')
+async def fastapi_calculate_virtual_district(network: str, centers: list[str]) -> dict[str, list[Any]]:
+    return calculate_virtual_district(network, centers)
+
+@app.get('/getvirtualdistrictschema/')
+async def fastapi_get_virtual_district_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_virtual_district_schema(network)
+
+@app.get('/getvirtualdistrict/')
+async def fastapi_get_virtual_district(network: str, id: str) -> dict[str, Any]:
+    return get_virtual_district(network, id)
+
+@app.post('/setvirtualdistrict/',response_model=None)
+async def fastapi_set_virtual_district(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_virtual_district(network, ChangeSet(props))
+
+@app.post('/addvirtualdistrict/',response_model=None)
+async def fastapi_add_virtual_district(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return add_virtual_district(network, ChangeSet(props))
+
+@app.post('/deletevirtualdistrict/',response_model=None)
+async def fastapi_delete_virtual_district(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return delete_virtual_district(network, ChangeSet(props))
+
+@app.get('/getallvirtualdistrict/')
+async def fastapi_get_all_virtual_district(network: str) -> list[dict[str, Any]]:
+    return get_all_virtual_districts(network)
+
+@app.post('/generatevirtualdistrict/',response_model=None)
+async def fastapi_generate_virtual_district(network: str, inflate_delta: float, req: Request) -> ChangeSet:
+    props = await req.json()
+    return generate_virtual_district(network, props['centers'], inflate_delta)
+
+############################################################
+# water_distribution_area 36
+############################################################
+@app.get('/calculatedemandtonodes/')
+async def fastapi_calculate_demand_to_nodes(network: str, req: Request) -> dict[str, float]:
+    props = await req.json()
+    demand = props['demand']
+    nodes = props['nodes']
+    return calculate_demand_to_nodes(network, demand, nodes)
+
+@app.get('/calculatedemandtoregion/')
+async def fastapi_calculate_demand_to_region(network: str, req: Request) -> dict[str, float]:
+    props = await req.json()
+    demand = props['demand']
+    region = props['region']
+    return calculate_demand_to_region(network, demand, region)
+
+@app.get('/calculatedemandtonetwork/')
+async def fastapi_calculate_demand_to_network(network: str, demand: float) -> dict[str, float]:
+    return calculate_demand_to_network(network, demand)
+
+
+
+# inp file
+#@app.post("/uploadinp/", status_code=status.HTTP_200_OK)
+#async def upload_inp(afile: bytes, name: str ):
+    #filePath = inpDir + str(name)
+    #f = open(filePath, 'wb')
+    #f.write(afile)
+    #f.close()
+
+    #return True
+
+@app.get("/downloadinp/", status_code=status.HTTP_200_OK)
+async def download_inp(name: str, response: Response):
+    filePath = inpDir + name 
+    if os.path.exists(filePath):
+        return FileResponse(filePath, media_type='application/octet-stream', filename="inp.inp")
+    else:
+        response.status_code = status.HTTP_400_BAD_REQUEST
+        return True
+    
+@app.get("/getjson/")
+async def get_json():
+    return JSONResponse(
+        status_code = status.HTTP_400_BAD_REQUEST,
+        content={
+            'code': 400,
+            'message': "this is message",
+            'data': 123,
+        }
+    )
+
+
diff --git a/main.py b/main.py
index e35b1b6..072d58f 100644
--- a/main.py
+++ b/main.py
@@ -56,7 +56,7 @@ async def fastapi_get_all_extension_data(network: str) -> dict[str, Any]:
 async def fastapi_get_extension_data(network: str, key: str) -> str | None:
     return get_extension_data(network, key)
 
-@app.post('/setextensiondata')
+@app.post('/setextensiondata',response_model=None)
 async def fastapi_set_extension_data(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     print(props)
@@ -116,7 +116,7 @@ async def fastapi_import_inp(network: str, req: Request):
     print(ret)
     return ret
 
-@app.get("/exportinp/")
+@app.get("/exportinp/",response_model=None)
 async def fastapi_export_inp(network: str, version: str) -> ChangeSet:
     cs = export_inp(network, version)
     op = cs.operations[0]
@@ -160,9 +160,9 @@ async def fastapi_run_project(network: str) -> str:
         raise HTTPException(status_code=409, detail="is in simulation")   
     else:
         print('file doesnt exists')
-        os.rename(filename, filename2)
+        #os.rename(filename, filename2)
         result = run_project(network)
-        os.rename(filename2, filename)
+        #os.rename(filename2, filename)
         return result
         
 # put in inp folder, name without extension
@@ -251,19 +251,19 @@ async def fastapi_take_snapshot_for_current_operation(network: str, tag: str) ->
 def fastapi_take_snapshot(network: str, tag: str) -> None:
     return take_snapshot(network, tag)
 
-@app.post('/picksnapshot/')
+@app.post('/picksnapshot/',response_model=None)
 def fastapi_pick_snapshot(network: str, tag: str, discard: bool = False) -> ChangeSet:
     return pick_snapshot(network, tag, discard)
 
-@app.post('/pickoperation/')
+@app.post('/pickoperation/',response_model=None)
 async def fastapi_pick_operation(network: str, operation: int, discard: bool = False) -> ChangeSet:
     return pick_operation(network, operation, discard)
 
-@app.get("/syncwithserver/")
+@app.get("/syncwithserver/",response_model=None)
 async def fastapi_sync_with_server(network: str, operation: int) -> ChangeSet:
     return sync_with_server(network, operation)
 
-@app.post("/batch/")
+@app.post("/batch/",response_model=None)
 async def fastapi_execute_batch_commands(network: str, req: Request)-> ChangeSet:
     jo_root = await req.json()
     cs: ChangeSet = ChangeSet()
@@ -271,7 +271,7 @@ async def fastapi_execute_batch_commands(network: str, req: Request)-> ChangeSet
     rcs = execute_batch_commands(network, cs)
     return rcs
 
-@app.post("/compressedbatch/")
+@app.post("/compressedbatch/",response_model=None)
 async def fastapi_execute_compressed_batch_commands(network: str, req: Request)-> ChangeSet:
     jo_root = await req.json()
     cs: ChangeSet = ChangeSet()
@@ -361,7 +361,7 @@ async def fast_get_title_schema(network: str) -> dict[str, dict[str, Any]]:
 async def fast_get_title(network: str) -> dict[str, Any]:
     return get_title(network)
 
-@app.get('/settitle/')
+@app.get('/settitle/',response_model=None)
 async def fastapi_set_title(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return set_title(network, ChangeSet(props))
@@ -373,7 +373,7 @@ async def fastapi_set_title(network: str, req: Request) -> ChangeSet:
 async def fast_get_junction_schema(network: str) -> dict[str, dict[str, Any]]:
     return get_junction_schema(network)
 
-@app.post("/addjunction/")
+@app.post("/addjunction/",response_model=None)
 async def fastapi_add_junction(network: str, junction: str, x: float, y: float, z: float) -> ChangeSet:
     ps = { 'id' : junction, 
            'x' : x, 
@@ -381,7 +381,7 @@ async def fastapi_add_junction(network: str, junction: str, x: float, y: float,
            'elevation' : z }
     return add_junction(network, ChangeSet(ps))
 
-@app.post("/deletejunction/")
+@app.post("/deletejunction/",response_model=None)
 async def fastapi_delete_junction(network: str, junction: str) -> ChangeSet:
     ps = {'id' : junction} 
     return delete_junction(network, ChangeSet(ps))
@@ -418,38 +418,38 @@ async def fastapi_get_junction_pattern(network: str, junction: str) -> str:
     ps = get_junction(network, junction)
     return ps['pattern']
 
-@app.post("/setjunctionelevation/")
+@app.post("/setjunctionelevation/",response_model=None)
 async def fastapi_set_junction_elevation(network: str, junction: str, elevation: float) -> ChangeSet:
     ps = { 'id' : junction,
            'elevation' : elevation }
     return set_junction(network, ChangeSet(ps))
 
-@app.post("/setjunctionx/")
+@app.post("/setjunctionx/",response_model=None)
 async def fastapi_set_junction_x(network: str, junction: str, x: float) -> ChangeSet:
     ps = { 'id' : junction,
            'x' : x }
     return set_junction(network, ChangeSet(ps))
     
-@app.post("/setjunctiony/")
+@app.post("/setjunctiony/",response_model=None)
 async def fastapi_set_junction_y(network: str, junction: str, y: float) -> ChangeSet:
     ps = { 'id' : junction,
            'y' : y }
     return set_junction(network, ChangeSet(ps))
 
-@app.post("/setjunctioncoord/")
+@app.post("/setjunctioncoord/",response_model=None)
 async def fastapi_set_junction_coord(network: str, junction: str, x: float, y: float) -> ChangeSet:
     ps = { 'id' : junction,
            'x' : x,
            'y' : y } 
     return set_junction(network, ChangeSet(ps))
     
-@app.post("/setjunctiondemand/")
+@app.post("/setjunctiondemand/",response_model=None)
 async def fastapi_set_junction_demand(network: str, junction: str, demand: float) -> ChangeSet:
     ps = { 'id' : junction,
            'demand' : demand }
     return set_junction(network, ChangeSet(ps))
 
-@app.post("/setjunctionpattern/")
+@app.post("/setjunctionpattern/",response_model=None)
 async def fastapi_set_junction_pattern(network: str, junction: str, pattern: str) -> ChangeSet:
     ps = { 'id' : junction,
            'pattern' : pattern }
@@ -459,7 +459,7 @@ async def fastapi_set_junction_pattern(network: str, junction: str, pattern: str
 async def fastapi_get_junction_properties(network: str, junction: str) -> dict[str, Any]:
     return get_junction(network, junction)
 
-@app.post("/setjunctionproperties/")
+@app.post("/setjunctionproperties/",response_model=None)
 async def fastapi_set_junction_properties(network: str, junction: str, req: Request) -> ChangeSet:
     props = await req.json()
     ps = { 'id' : junction } | props
@@ -472,7 +472,7 @@ async def fastapi_set_junction_properties(network: str, junction: str, req: Requ
 async def fast_get_reservoir_schema(network: str) -> dict[str, dict[str, Any]]:
     return get_reservoir_schema(network)
 
-@app.post("/addreservoir/")
+@app.post("/addreservoir/",response_model=None)
 async def fastapi_add_reservoir(network: str, reservoir: str, x: float, y: float, head: float) -> ChangeSet:
     ps = { 'id' : reservoir, 
            'x' : x, 
@@ -480,7 +480,7 @@ async def fastapi_add_reservoir(network: str, reservoir: str, x: float, y: float
            'head' : head }
     return add_reservoir(network, ChangeSet(ps)) 
 
-@app.post("/deletereservoir/")
+@app.post("/deletereservoir/",response_model=None)
 async def fastapi_delete_reservoir(network: str, reservoir: str) -> ChangeSet:
     ps = { 'id' : reservoir }
     return delete_reservoir(network, ChangeSet(ps))
@@ -513,31 +513,31 @@ async def fastapi_get_reservoir_y(network: str, reservoir: str) -> dict[str, flo
               'y' : ps['y'] }
     return coord
 
-@app.post("/setreservoirhead/")
+@app.post("/setreservoirhead/",response_model=None)
 async def fastapi_set_reservoir_head(network: str, reservoir: str, head: float) -> ChangeSet:
     ps = { 'id' : reservoir, 
            'head' : head }
     return set_reservoir(network, ChangeSet(ps))
 
-@app.post("/setreservoirpattern/")
+@app.post("/setreservoirpattern/",response_model=None)
 async def fastapi_set_reservoir_pattern(network: str, reservoir: str, pattern: str) -> ChangeSet:
     ps = { 'id' : reservoir, 
            'pattern' : pattern }
     return set_reservoir(network, ChangeSet(ps))
 
-@app.post("/setreservoirx/")
+@app.post("/setreservoirx/",response_model=None)
 async def fastapi_set_reservoir_x(network: str, reservoir: str, x: float) -> ChangeSet:
     ps = { 'id' : reservoir, 
            'x' : x }
     return set_reservoir(network, ChangeSet(ps))
 
-@app.post("/setreservoirx/")
+@app.post("/setreservoirx/",response_model=None)
 async def fastapi_set_reservoir_y(network: str, reservoir: str, y: float) -> ChangeSet:
     ps = { 'id' : reservoir, 
            'y' : y }
     return set_reservoir(network, ChangeSet(ps))
 
-@app.post("/setreservoircoord/")
+@app.post("/setreservoircoord/",response_model=None)
 async def fastapi_set_reservoir_y(network: str, reservoir: str, x: float, y: float) -> ChangeSet:
     ps = { 'id' : reservoir, 
            'x' : x,
@@ -548,7 +548,7 @@ async def fastapi_set_reservoir_y(network: str, reservoir: str, x: float, y: flo
 async def fastapi_get_reservoir_properties(network: str, reservoir: str) -> dict[str, Any]:
     return get_reservoir(network, reservoir)
 
-@app.post("/setreservoirproperties/")
+@app.post("/setreservoirproperties/",response_model=None)
 async def fastapi_set_reservoir_properties(network: str, reservoir: str
                                            , req: Request) -> ChangeSet:
     props = await req.json()
@@ -563,7 +563,7 @@ async def fastapi_set_reservoir_properties(network: str, reservoir: str
 async def fast_get_tank_schema(network: str) -> dict[str, dict[str, Any]]:
     return get_tank_schema(network)
 
-@app.post("/addtank/")
+@app.post("/addtank/",response_model=None)
 async def fastapi_add_tank(network: str, tank: str, x: float, y: float, elevation: float, init_level: float = 0, min_level: float = 0, max_level: float = 0, diameter: float = 0, min_vol: float = 0) -> ChangeSet:
     ps = { 'id' : tank, 
            'x' : x, 
@@ -577,7 +577,7 @@ async def fastapi_add_tank(network: str, tank: str, x: float, y: float, elevatio
          }
     return add_tank(network, ChangeSet(ps)) 
 
-@app.post("/deletetank/")
+@app.post("/deletetank/",response_model=None)
 async def fastapi_delete_tank(network: str, tank: str) -> ChangeSet:
     ps = { 'id' : tank }
     return delete_tank(network, ChangeSet(ps))
@@ -639,67 +639,67 @@ async def fastapi_get_tank_coord(network: str, tank: str) -> dict[str, float]:
               'y' : ps['y'] }
     return coord
 
-@app.post("/settankelevation/")
+@app.post("/settankelevation/",response_model=None)
 async def fastapi_set_tank_elevation(network: str, tank: str, elevation: float) -> ChangeSet:
     ps = { 'id' : tank,
            'elevation' : elevation }
     return set_tank(network, ChangeSet(ps))
 
-@app.post("/settankinitlevel/")
+@app.post("/settankinitlevel/",response_model=None)
 async def fastapi_set_tank_init_level(network: str, tank: str, init_level: float) -> ChangeSet:
     ps = { 'id' : tank,
            'init_level' : init_level }
     return set_tank(network, ChangeSet(ps))
 
-@app.post("/settankminlevel/")
+@app.post("/settankminlevel/",response_model=None)
 async def fastapi_set_tank_min_level(network: str, tank: str, min_level: float) -> ChangeSet:
     ps = { 'id' : tank,
            'min_level' : min_level }
     return set_tank(network, ChangeSet(ps))
 
-@app.post("/settankmaxlevel/")
+@app.post("/settankmaxlevel/",response_model=None)
 async def fastapi_set_tank_max_level(network: str, tank: str, max_level: float) -> ChangeSet:
     ps = { 'id' : tank,
            'max_level' : max_level }
     return set_tank(network, ChangeSet(ps))
 
-@app.post("settankdiameter//")
+@app.post("settankdiameter//",response_model=None)
 async def fastapi_set_tank_diameter(network: str, tank: str, diameter: float) -> ChangeSet:
     ps = { 'id' : tank,
            'diameter' : diameter }
     return set_tank(network, ChangeSet(ps))
 
-@app.post("/settankminvol/")
+@app.post("/settankminvol/",response_model=None)
 async def fastapi_set_tank_min_vol(network: str, tank: str, min_vol: float) -> ChangeSet:
     ps = { 'id' : tank,
            'min_vol' : min_vol }
     return set_tank(network, ChangeSet(ps))
 
-@app.post("/settankvolcurve/")
+@app.post("/settankvolcurve/",response_model=None)
 async def fastapi_set_tank_vol_curve(network: str, tank: str, vol_curve: str) -> ChangeSet:
     ps = { 'id' : tank,
            'vol_curve' : vol_curve}
     return set_tank(network, ChangeSet(ps))
 
-@app.post("/settankoverflow/")
+@app.post("/settankoverflow/",response_model=None)
 async def fastapi_set_tank_overflow(network: str, tank: str, overflow: str) -> ChangeSet:
     ps = { 'id' : tank,
            'overflow' : overflow }
     return set_tank(network, ChangeSet(ps))
 
-@app.post("/settankx/")
+@app.post("/settankx/",response_model=None)
 async def fastapi_set_tank_x(network: str, tank: str, x: float) -> ChangeSet:
     ps = { 'id' : tank,
            'x' : x }
     return set_tank(network, ChangeSet(ps))
 
-@app.post("/settanky/")
+@app.post("/settanky/",response_model=None)
 async def fastapi_set_tank_y(network: str, tank: str, y: float) -> ChangeSet:
     ps = { 'id' : tank,
            'y' : y }
     return set_tank(network, ChangeSet(ps))
 
-@app.post("/settankcoord/")
+@app.post("/settankcoord/",response_model=None)
 async def fastapi_set_tank_coord(network: str, tank: str, x: float, y: float) -> ChangeSet:
     ps = { 'id' : tank,
            'x' : x, 
@@ -710,7 +710,7 @@ async def fastapi_set_tank_coord(network: str, tank: str, x: float, y: float) ->
 async def fastapi_get_tank_properties(network: str, tank: str) -> dict[str, Any]:
     return get_tank(network, tank)
 
-@app.post("/settankproperties/")
+@app.post("/settankproperties/",response_model=None)
 async def fastapi_set_tank_properties(network: str, tank: str, req: Request) -> ChangeSet:
     props = await req.json()
     ps = { 'id' : tank } | props
@@ -723,7 +723,7 @@ async def fastapi_set_tank_properties(network: str, tank: str, req: Request) ->
 async def fastapi_get_pipe_schema(network: str) -> dict[str, dict[str, Any]]:
     return get_pipe_schema(network)
 
-@app.post("/addpipe/")
+@app.post("/addpipe/",response_model=None)
 async def fastapi_add_pipe(network: str, pipe: str, node1: str, node2: str, length: float = 0, 
                            diameter: float = 0, roughness: float = 0, minor_loss: float = 0, status: str = PIPE_STATUS_OPEN) -> ChangeSet:
     ps = { 'id' : pipe,
@@ -736,7 +736,7 @@ async def fastapi_add_pipe(network: str, pipe: str, node1: str, node2: str, leng
            'status' : status }   
     return add_pipe(network, ChangeSet(ps))
 
-@app.post("/deletepipe/")
+@app.post("/deletepipe/",response_model=None)
 async def fastapi_delete_pipe(network: str, pipe: str) -> ChangeSet:
     ps = {'id' : pipe} 
     return delete_pipe(network, ChangeSet(ps))
@@ -776,43 +776,43 @@ async def fastapi_get_pipe_status(network: str, pipe: str) -> str | None:
     ps = get_pipe(network, pipe)
     return ps['status']
 
-@app.post("/setpipenode1/")
+@app.post("/setpipenode1/",response_model=None)
 async def fastapi_set_pipe_node1(network: str, pipe: str, node1: str) -> ChangeSet:
     ps = { 'id' : pipe,
            'node1' : node1 }
     return set_pipe(network, ChangeSet(ps))
 
-@app.post("/setpipenode2/")
+@app.post("/setpipenode2/",response_model=None)
 async def fastapi_set_pipe_node2(network: str, pipe: str, node2: str) -> ChangeSet:
     ps = { 'id' : pipe,
            'node2' : node2 }
     return set_pipe(network, ChangeSet(ps))
 
-@app.post("/setpipelength/")
+@app.post("/setpipelength/",response_model=None)
 async def fastapi_set_pipe_length(network: str, pipe: str, length: float) -> ChangeSet:
     ps = { 'id' : pipe,
            'length' : length }
     return set_pipe(network, ChangeSet(ps))
 
-@app.post("/setpipediameter/")
+@app.post("/setpipediameter/",response_model=None)
 async def fastapi_set_pipe_diameter(network: str, pipe: str, diameter: float) -> ChangeSet:
     ps = { 'id' : pipe,
            'diameter' : diameter }
     return set_pipe(network, ChangeSet(ps))
 
-@app.post("/setpiperoughness/")
+@app.post("/setpiperoughness/",response_model=None)
 async def fastapi_set_pipe_roughness(network: str, pipe: str, roughness: float) -> ChangeSet:
     ps = { 'id' : pipe,
            'roughness' : roughness }
     return set_pipe(network, ChangeSet(ps))
 
-@app.post("/setpipeminorloss/")
+@app.post("/setpipeminorloss/",response_model=None)
 async def fastapi_set_pipe_minor_loss(network: str, pipe: str, minor_loss: float) -> ChangeSet:
     ps = { 'id' : pipe,
            'minor_loss' : minor_loss }
     return set_pipe(network, ChangeSet(ps))
 
-@app.post("/setpipestatus/")
+@app.post("/setpipestatus/",response_model=None)
 async def fastapi_set_pipe_status(network: str, pipe: str, status: str) -> ChangeSet:
     ps = { 'id' : pipe,
            'status' : status }
@@ -828,7 +828,7 @@ async def fastapi_set_pipe_status(network: str, pipe: str, status: str) -> Chang
 async def fastapi_get_pipe_properties(network: str, pipe: str) -> dict[str, Any]:
     return get_pipe(network, pipe)
 
-@app.post("/setpipeproperties/")
+@app.post("/setpipeproperties/",response_model=None)
 async def fastapi_set_pipe_properties(network: str, pipe: str, req: Request) -> ChangeSet:
     props = await req.json()
     ps = { 'id' : pipe } | props
@@ -842,7 +842,7 @@ async def fastapi_set_pipe_properties(network: str, pipe: str, req: Request) ->
 async def fastapi_get_pump_schema(network: str) -> dict[str, dict[str, Any]]:
     return get_pump_schema(network)
 
-@app.post("/addpump/")
+@app.post("/addpump/",response_model=None)
 async def fastapi_add_pump(network: str, pump: str, node1: str, node2: str, power: float = 0.0) -> ChangeSet:
     ps = { 'id' : pump,
            'node1' : node1,
@@ -851,7 +851,7 @@ async def fastapi_add_pump(network: str, pump: str, node1: str, node2: str, powe
          }
     return add_pump(network, ChangeSet(ps))
 
-@app.post("/deletepump/")
+@app.post("/deletepump/",response_model=None)
 async def fastapi_delete_pump(network: str, pump: str) -> ChangeSet:
     ps = { 'id' : pump } 
     return delete_pump(network, ChangeSet(ps)) 
@@ -866,13 +866,13 @@ async def fastapi_get_pump_node2(network: str, pump: str) -> str | None:
     ps = get_pump(network, pump)
     return ps['node2']
 
-@app.post("/setpumpnode1/")
+@app.post("/setpumpnode1/",response_model=None)
 async def fastapi_set_pump_node1(network: str, pump: str, node1: str) -> ChangeSet:
     ps = { 'id' : pump,
            'node1' : node1 } 
     return set_pump(network, ChangeSet(ps))
 
-@app.post("/setpumpnode2/")
+@app.post("/setpumpnode2/",response_model=None)
 async def fastapi_set_pump_node2(network: str, pump: str, node2: str) -> ChangeSet:
     ps = { 'id' : pump,
            'node2' : node2 } 
@@ -882,7 +882,7 @@ async def fastapi_set_pump_node2(network: str, pump: str, node2: str) -> ChangeS
 async def fastapi_get_pump_properties(network: str, pump: str) -> dict[str, Any]:
     return get_pump(network, pump)
 
-@app.post("/setpumpproperties/")
+@app.post("/setpumpproperties/",response_model=None)
 async def fastapi_set_pump_properties(network: str, pump: str, req: Request) -> ChangeSet:
     props = await req.json()
     ps = { 'id' : pump } | props
@@ -896,7 +896,7 @@ async def fastapi_set_pump_properties(network: str, pump: str, req: Request) ->
 async def fastapi_get_valve_schema(network: str) -> dict[str, dict[str, Any]]:
     return get_valve_schema(network)
 
-@app.post("/addvalve/")
+@app.post("/addvalve/",response_model=None)
 async def fastapi_add_valve(network: str, valve: str, node1: str, node2: str, diameter: float = 0, v_type: str = VALVES_TYPE_PRV, setting: float = 0, minor_loss: float = 0) -> ChangeSet:
     ps = { 'id' : valve,
            'node1' : node1,
@@ -908,7 +908,7 @@ async def fastapi_add_valve(network: str, valve: str, node1: str, node2: str, di
            
     return add_valve(network, ChangeSet(ps)) 
 
-@app.post("/deletevalve/")
+@app.post("/deletevalve/",response_model=None)
 async def fastapi_delete_valve(network: str, valve: str) -> ChangeSet:
     ps = { 'id' : valve } 
     return delete_valve(network, ChangeSet(ps)) 
@@ -943,31 +943,31 @@ async def fastapi_get_valve_minor_loss(network: str, valve: str) -> float | None
     ps = get_valve(network, valve)
     return ps['minor_loss']
 
-@app.post("/setvalvenode1/")
+@app.post("/setvalvenode1/",response_model=None)
 async def fastapi_set_valve_node1(network: str, valve: str, node1: str) -> ChangeSet:
     ps = { 'id' : valve,
            'node1' : node1 } 
     return set_valve(network, ChangeSet(ps))
 
-@app.post("/setvalvenode2/")
+@app.post("/setvalvenode2/",response_model=None)
 async def fastapi_set_valve_node2(network: str, valve: str, node2: str) -> ChangeSet:
     ps = { 'id' : valve,
            'node2' : node2 } 
     return set_valve(network, ChangeSet(ps))
 
-@app.post("/setvalvenodediameter/")
+@app.post("/setvalvenodediameter/",response_model=None)
 async def fastapi_set_valve_diameter(network: str, valve: str, diameter: float) -> ChangeSet:
     ps = { 'id' : valve,
            'diameter' : diameter } 
     return set_valve(network, ChangeSet(ps))
 
-@app.post("/setvalvetype/")
+@app.post("/setvalvetype/",response_model=None)
 async def fastapi_set_valve_type(network: str, valve: str, type: str) -> ChangeSet:
     ps = { 'id' : valve,
            'type' : type } 
     return set_valve(network, ChangeSet(ps))
 
-@app.post("/setvalvesetting/")
+@app.post("/setvalvesetting/",response_model=None)
 async def fastapi_set_valve_setting(network: str, valve: str, setting: float) -> ChangeSet:
     ps = { 'id' : valve,
            'setting' : setting } 
@@ -977,7 +977,7 @@ async def fastapi_set_valve_setting(network: str, valve: str, setting: float) ->
 async def fastapi_get_valve_properties(network: str, valve: str) -> dict[str, Any]:
     return get_valve(network, valve)
 
-@app.post("/setvalveproperties/")
+@app.post("/setvalveproperties/",response_model=None)
 async def fastapi_set_valve_properties(network: str, valve: str, req: Request) -> ChangeSet:
     props = await req.json()
     ps = { 'id' : valve } | props
@@ -985,7 +985,7 @@ async def fastapi_set_valve_properties(network: str, valve: str, req: Request) -
     
     
 # node & link
-@app.post("/deletenode/")
+@app.post("/deletenode/",response_model=None)
 async def fastapi_delete_node(network: str, node: str) -> ChangeSet:
     ps = {'id' : node} 
     if is_junction(network, node):
@@ -995,7 +995,7 @@ async def fastapi_delete_node(network: str, node: str) -> ChangeSet:
     elif is_tank(network, node):
         return delete_tank(network, ChangeSet(ps))
     
-@app.post("/deletelink/")
+@app.post("/deletelink/",response_model=None)
 async def fastapi_delete_link(network: str, link: str) -> ChangeSet:
     ps = {'id' : link} 
     if is_pipe(network, link):
@@ -1030,7 +1030,7 @@ async def fastapi_get_tags(network: str) -> list[dict[str, Any]]:
 # example:
 # set_tag(p, ChangeSet({'t_type': TAG_TYPE_NODE, 'id': 'j1', 'tag': 'j1t' }))
 # set_tag(p, ChangeSet({'t_type': TAG_TYPE_LINK, 'id': 'p0', 'tag': 'p0t' }))
-@app.post('/settag/')
+@app.post('/settag/',response_model=None)
 async def fastapi_set_tag(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return set_tag(network, ChangeSet(props))
@@ -1047,7 +1047,7 @@ async def fastapi_get_demand_properties(network: str, junction: str) -> dict[str
     return get_demand(network, junction)
 
 # example: set_demand(p, ChangeSet({'junction': 'j1', 'demands': [{'demand': 10.0, 'pattern': None, 'category': 'x'}, {'demand': 20.0, 'pattern': None, 'category': None}]}))
-@app.post("/setdemandproperties/")
+@app.post("/setdemandproperties/",response_model=None)
 async def fastapi_set_demand_properties(network: str, junction: str, req: Request) -> ChangeSet:
     props = await req.json()
     ps = { 'junction' : junction } | props
@@ -1065,7 +1065,7 @@ async def fastapi_get_status(network: str, link: str) -> dict[str, Any]:
     return get_status(network, link)
 
 # example: set_status(p, ChangeSet({'link': 'p0', 'status': LINK_STATUS_OPEN, 'setting': 10.0}))
-@app.post("/setstatus/")
+@app.post("/setstatus/",response_model=None)
 async def fastapi_set_status_properties(network: str, link: str, req: Request) -> ChangeSet:
     props = await req.json()
     ps = { 'link' : link } | props
@@ -1078,7 +1078,7 @@ async def fastapi_set_status_properties(network: str, link: str, req: Request) -
 async def fastapi_get_pattern_schema(network: str) -> dict[str, dict[str, Any]]:
     return get_pattern_schema(network)
 
-@app.post("/addpattern/")
+@app.post("/addpattern/",response_model=None)
 async def fastapi_add_pattern(network: str, pattern: str, req: Request) -> ChangeSet:
     props = await req.json()
     ps = { 
@@ -1086,7 +1086,7 @@ async def fastapi_add_pattern(network: str, pattern: str, req: Request) -> Chang
          } | props
     return add_pattern(network, ChangeSet(ps))
 
-@app.post("/deletepattern/")
+@app.post("/deletepattern/",response_model=None)
 async def fastapi_delete_pattern(network: str, pattern: str) -> ChangeSet:
     ps = { 'id' : pattern }
     return delete_pattern(network, ChangeSet(ps))
@@ -1096,7 +1096,7 @@ async def fastapi_get_pattern_properties(network: str, pattern: str) -> dict[str
     return get_pattern(network, pattern)
 
 # example: set_pattern(p, ChangeSet({'id' : 'p0', 'factors': [1.0, 2.0, 3.0]}))
-@app.post("/setpatternproperties/")
+@app.post("/setpatternproperties/",response_model=None)
 async def fastapi_set_pattern_properties(network: str, pattern: str, req: Request) -> ChangeSet:
     props = await req.json()
     ps = { 'id' : pattern } | props
@@ -1109,7 +1109,7 @@ async def fastapi_set_pattern_properties(network: str, pattern: str, req: Reques
 async def fastapi_get_curve_schema(network: str) -> dict[str, dict[str, Any]]:
     return get_curve_schema(network)
 
-@app.post("/addcurve/")
+@app.post("/addcurve/",response_model=None)
 async def fastapi_add_curve(network: str, curve: str, req: Request) -> ChangeSet:
     props = await req.json()
 
@@ -1123,7 +1123,7 @@ async def fastapi_add_curve(network: str, curve: str, req: Request) -> ChangeSet
     
     return add_curve(network, ChangeSet(ps)) 
 
-@app.post("/deletecurve/")
+@app.post("/deletecurve/",response_model=None)
 async def fastapi_delete_curve(network: str, curve: str) -> ChangeSet:
     ps = { 'id' : curve }
     return delete_curve(network, ChangeSet(ps))
@@ -1133,7 +1133,7 @@ async def fastapi_get_curve_properties(network: str, curve: str) -> dict[str, An
     return get_curve(network, curve)
 
 # example: set_curve(p, ChangeSet({'id' : 'c0', 'c_type' : CURVE_TYPE_PUMP, 'coords': [{'x': 1.0, 'y': 2.0}, {'x': 2.0, 'y': 1.0}]}))
-@app.post("/setcurveproperties/")
+@app.post("/setcurveproperties/",response_model=None)
 async def fastapi_set_curve_properties(network: str, curve: str, req: Request) -> ChangeSet:
     props = await req.json()
     # c_type放到request中
@@ -1153,7 +1153,7 @@ async def fastapi_get_control_properties(network: str) -> dict[str, Any]:
     return get_control(network)
 
 # example: set_control(p, ChangeSet({'control': 'x'}))
-@app.post("/setcontrolproperties/")
+@app.post("/setcontrolproperties/",response_model=None)
 async def fastapi_set_control_properties(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return set_control(network, ChangeSet(props)) 
@@ -1170,7 +1170,7 @@ async def fastapi_get_rule_properties(network: str) -> dict[str, Any]:
     return get_rule(network)
 
 # example: set_rule(p, ChangeSet({'rule': 'x'}))
-@app.post("/setruleproperties/")
+@app.post("/setruleproperties/",response_model=None)
 async def fastapi_set_rule_properties(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return set_rule(network, ChangeSet(props))
@@ -1187,7 +1187,7 @@ async def fastapi_get_energy_schema(network: str) -> dict[str, dict[str, Any]]:
 async def fastapi_get_energy_properties(network: str) -> dict[str, Any]:
     return get_energy(network)
 
-@app.post("/setenergyproperties/")
+@app.post("/setenergyproperties/",response_model=None)
 async def fastapi_set_energy_properties(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return set_energy(network, ChangeSet(props))
@@ -1200,7 +1200,7 @@ async def fastapi_get_pump_energy_schema(network: str) -> dict[str, dict[str, An
 async def fastapi_get_pump_energy_proeprties(network: str, pump: str) -> dict[str, Any]:
     return get_pump_energy(network, pump)
 
-@app.get("/setpumpenergyproperties//")
+@app.get("/setpumpenergyproperties//",response_model=None)
 async def fastapi_set_pump_energy_properties(network: str, pump: str, req: Request) -> ChangeSet:
     props = await req.json()
     ps = { 'id' : pump } | props
@@ -1218,7 +1218,7 @@ async def fastapi_get_emitter_properties(network: str, junction: str) -> dict[st
     return get_emitter(network, junction)
 
 # example: set_emitter(p, ChangeSet({'junction': 'j1', 'coefficient': 10.0}))
-@app.post("/setemitterproperties/")
+@app.post("/setemitterproperties/",response_model=None)
 async def fastapi_set_emitter_properties(network: str, junction: str, req: Request) -> ChangeSet:
     props = await req.json()
     ps = { 'junction' : junction } | props
@@ -1237,7 +1237,7 @@ async def fastapi_get_quality_properties(network: str, node: str) -> dict[str, A
     return get_quality(network, node)
 
 # example: set_quality(p, ChangeSet({'node': 'j1', 'quality': 10.0}))
-@app.post("/setqualityproperties/")
+@app.post("/setqualityproperties/",response_model=None)
 async def fastapi_set_quality_properties(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return set_quality(network, ChangeSet(props)) 
@@ -1254,18 +1254,18 @@ async def fastapi_get_source_schema(network: str) -> dict[str, dict[str, Any]]:
 async def fastapi_get_source(network: str, node: str) -> dict[str, Any]:
     return get_source(network, node)
 
-@app.post('/setsource/')
+@app.post('/setsource/',response_model=None)
 async def fastapi_set_source(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return set_source(network, ChangeSet(props))
 
 # example: add_source(p, ChangeSet({'node': 'j0', 's_type': SOURCE_TYPE_CONCEN, 'strength': 10.0, 'pattern': 'p0'}))
-@app.post('/addsource/')
+@app.post('/addsource/',response_model=None)
 async def fastapi_add_source(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return add_source(network, ChangeSet(props))
 
-@app.post('/deletesource/')
+@app.post('/deletesource/',response_model=None)
 async def fastapi_delete_source(network: str, node: str) -> ChangeSet:
     props = { 'node': node }
     return delete_source(network, ChangeSet(props))
@@ -1282,7 +1282,7 @@ async def fastapi_get_reaction_schema(network: str) -> dict[str, dict[str, Any]]
 async def fastapi_get_reaction(network: str) -> dict[str, Any]:
     return get_reaction(network)
 
-@app.post('/setreaction/')
+@app.post('/setreaction/',response_model=None)
 # set_reaction(p, ChangeSet({ 'ORDER BULK' : '10' }))
 async def fastapi_set_reaction(network: str, req: Request) -> ChangeSet:
     props = await req.json()
@@ -1296,7 +1296,7 @@ async def fastapi_get_pipe_reaction_schema(network: str) -> dict[str, dict[str,
 async def fastapi_get_pipe_reaction(network: str, pipe: str) -> dict[str, Any]:
     return get_pipe_reaction(network, pipe)
 
-@app.post('/setpipereaction/')
+@app.post('/setpipereaction/',response_model=None)
 async def fastapi_set_pipe_reaction(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return set_pipe_reaction(network, ChangeSet(props))
@@ -1309,7 +1309,7 @@ async def fastapi_get_tank_reaction_schema(network: str) -> dict[str, dict[str,
 async def fastapi_get_tank_reaction(network: str, tank: str) -> dict[str, Any]:
     return get_tank_reaction(network, tank)
 
-@app.post('/settankreaction/')
+@app.post('/settankreaction/',response_model=None)
 async def fastapi_set_tank_reaction(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return set_tank_reaction(network, ChangeSet(props))
@@ -1326,18 +1326,18 @@ async def fastapi_get_mixing_schema(network: str) -> dict[str, dict[str, Any]]:
 async def fastapi_get_mixing(network: str, tank: str) -> dict[str, Any]:
     return get_mixing(network, tank)
 
-@app.post('/setmixing/')
+@app.post('/setmixing/',response_model=None)
 async def fastapi_set_mixing(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return api.set_mixing(network, ChangeSet(props))
 
 # example: add_mixing(p, ChangeSet({'tank': 't0', 'model': MIXING_MODEL_MIXED, 'value': 10.0}))
-@app.post('/addmixing/')
+@app.post('/addmixing/',response_model=None)
 async def fastapi_add_mixing(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return add_mixing(network, ChangeSet(props))
 
-@app.post('/deletemixing/')
+@app.post('/deletemixing/',response_model=None)
 async def fastapi_delete_mixing(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return delete_mixing(network, ChangeSet(props))
@@ -1354,7 +1354,7 @@ async def fastapi_get_time_schema(network: str) -> dict[str, dict[str, Any]]:
 async def fastapi_get_time_properties(network: str) -> dict[str, Any]:
     return get_time(network)
 
-@app.post("/settimeproperties/")
+@app.post("/settimeproperties/",response_model=None)
 async def fastapi_set_time_properties(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return set_time(network, ChangeSet(props)) 
@@ -1370,7 +1370,7 @@ async def fastapi_get_option_schema(network: str) -> dict[str, dict[str, Any]]:
 async def fastapi_get_option_properties(network: str) -> dict[str, Any]:
     return get_option_v3(network)
 
-@app.post("/setoptionproperties/")
+@app.post("/setoptionproperties/",response_model=None)
 async def fastapi_set_option_properties(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return set_option_v3(network, ChangeSet(props)) 
@@ -1394,17 +1394,17 @@ async def fastapi_get_vertex_properties(network: str, link: str) -> dict[str, An
     return get_vertex(network, link)
 
 # set_vertex(p, ChangeSet({'link' : 'p0', 'coords': [{'x': 1.0, 'y': 2.0}, {'x': 2.0, 'y': 1.0}]}))
-@app.post('/setvertexproperties/')
+@app.post('/setvertexproperties/',response_model=None)
 async def fastapi_set_vertex_properties(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return set_vertex(network, ChangeSet(props)) 
 
-@app.post('/addvertex/')
+@app.post('/addvertex/',response_model=None)
 async def fastapi_add_vertex(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return add_vertex(network, ChangeSet(props)) 
 
-@app.post('/deletevertex/')
+@app.post('/deletevertex/',response_model=None)
 async def fastapi_delete_vertex(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return api.delete_vertex(network, ChangeSet(props))
@@ -1428,17 +1428,17 @@ async def fastapi_get_label_schema(network: str) -> dict[str, dict[str, Any]]:
 async def fastapi_get_label_properties(network: str, x: float, y: float) -> dict[str, Any]:
     return get_label(network, x, y)
 
-@app.post('/setlabelproperties/')
+@app.post('/setlabelproperties/',response_model=None)
 async def fastapi_set_label_properties(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return set_label(network, ChangeSet(props))
 
-@app.post('/addlabel/')
+@app.post('/addlabel/',response_model=None)
 async def fastapi_add_label(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return add_label(network, ChangeSet(props))
 
-@app.post('/deletelabel/')
+@app.post('/deletelabel/',response_model=None)
 async def fastapi_delete_label(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return delete_label(network, ChangeSet(props))
@@ -1455,7 +1455,7 @@ async def fastapi_get_backdrop_schema(network: str) -> dict[str, dict[str, Any]]
 async def fastapi_get_backdrop_properties(network: str) -> dict[str, Any]:
     return get_backdrop(network)
 
-@app.post('/setbackdropproperties/')
+@app.post('/setbackdropproperties/',response_model=None)
 async def fastapi_set_backdrop_properties(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return set_backdrop(network, ChangeSet(props))
@@ -1471,22 +1471,22 @@ async def fastapi_get_scada_device_schema(network: str) -> dict[str, dict[str, A
 async def fastapi_get_scada_device(network: str, id: str) -> dict[str, Any]:
     return get_scada_device(network, id)
 
-@app.post('/setscadadevice/')
+@app.post('/setscadadevice/',response_model=None)
 async def fastapi_set_scada_device(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return set_scada_device(network, ChangeSet(props))
 
-@app.post('/addscadadevice/')
+@app.post('/addscadadevice/',response_model=None)
 async def fastapi_add_scada_device(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return add_scada_device(network, ChangeSet(props))
 
-@app.post('/deletescadadevice/')
+@app.post('/deletescadadevice/',response_model=None)
 async def fastapi_delete_scada_device(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return delete_scada_device(network, ChangeSet(props))
 
-@app.post('/cleanscadadevice/')
+@app.post('/cleanscadadevice/',response_model=None)
 async def fastapi_clean_scada_device(network: str) -> ChangeSet:
     return clean_scada_device(network)
 
@@ -1512,24 +1512,24 @@ async def fastapi_get_scada_device_data(network: str, id: str) -> dict[str, Any]
 
 # example: set_scada_device_data(p, ChangeSet({'device_id': 'sm_device', 'data': [{ 'time': '2023-02-10 00:02:22', 'value': 100.0 }, { 'time': '2023-02-10 00:03:22', 'value': 200.0 }]}))
 # time format must be 'YYYY-MM-DD HH:MM:SS'
-@app.post('/setscadadevicedata/')
+@app.post('/setscadadevicedata/',response_model=None)
 async def fastapi_set_scada_device_data(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return set_scada_device_data(network, ChangeSet(props))
 
 # example: add_scada_device_data(p, ChangeSet({'device_id': 'sm_device', 'time': '2023-02-10 00:02:22', 'value': 100.0}))
-@app.post('/addscadadevicedata/')
+@app.post('/addscadadevicedata/',response_model=None)
 async def fastapi_add_scada_device_data(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return add_scada_device_data(network, ChangeSet(props))
 
 # example: delete_scada_device_data(p, ChangeSet({'device_id': 'sm_device', 'time': '2023-02-12 00:02:22'}))
-@app.post('/deletescadadevicedata/')
+@app.post('/deletescadadevicedata/',response_model=None)
 async def fastapi_delete_scada_device_data(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return delete_scada_device_data(network, ChangeSet(props))
 
-@app.post('/cleanscadadevicedata/')
+@app.post('/cleanscadadevicedata/',response_model=None)
 async def fastapi_clean_scada_device_data(network: str) -> ChangeSet:
     return clean_scada_device_data(network)
 
@@ -1549,22 +1549,22 @@ async def fastapi_get_scada_elements(network: str) -> list[str]:
 async def fastapi_get_scada_element(network: str, id: str) -> dict[str, Any]:
     return get_scada_element(network, id)
 
-@app.post('/setscadaelement/')
+@app.post('/setscadaelement/',response_model=None)
 async def fastapi_set_scada_element(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return set_scada_element(network, ChangeSet(props))
 
-@app.post('/addscadaelement/')
+@app.post('/addscadaelement/',response_model=None)
 async def fastapi_add_scada_element(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return add_scada_element(network, ChangeSet(props))
 
-@app.post('/deletescadaelement/')
+@app.post('/deletescadaelement/',response_model=None)
 async def fastapi_delete_scada_element(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return delete_scada_element(network, ChangeSet(props))
 
-@app.post('/cleanscadaelement/')
+@app.post('/cleanscadaelement/',response_model=None)
 async def fastapi_clean_scada_element(network: str) -> ChangeSet:
     return clean_scada_element(network)
 
@@ -1579,18 +1579,18 @@ async def fastapi_get_region_schema(network: str) -> dict[str, dict[str, Any]]:
 async def fastapi_get_region(network: str, id: str) -> dict[str, Any]:
     return get_region(network, id)
 
-@app.post('/setregion/')
+@app.post('/setregion/',response_model=None)
 async def fastapi_set_region(network : str, req: Request) -> ChangeSet:
     props = await req.json()
     return set_region(network, ChangeSet(props))
 
 # example: add_region(p, ChangeSet({'id': 'r', 'boundary': [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]}))
-@app.post('/addregion/')
+@app.post('/addregion/',response_model=None)
 async def fastapi_add_region(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return add_region(network, ChangeSet(props))
 
-@app.post('/deleteregion/')
+@app.post('/deleteregion/',response_model=None)
 async def fastapi_delete_region(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return delete_region(network, ChangeSet(props))
@@ -1629,12 +1629,12 @@ async def fastapi_get_district_metering_area_schema(network: str) -> dict[str, d
 async def fastapi_get_district_metering_area(network: str, id: str) -> dict[str, Any]:
     return get_district_metering_area(network, id)
 
-@app.post('/setdistrictmeteringarea/')
+@app.post('/setdistrictmeteringarea/',response_model=None)
 async def fastapi_set_district_metering_area(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return set_district_metering_area(network, ChangeSet(props))
 
-@app.post('/adddistrictmeteringarea/')
+@app.post('/adddistrictmeteringarea/',response_model=None)
 async def fastapi_add_district_metering_area(network: str, req: Request) -> ChangeSet:
     props = await req.json()
 
@@ -1648,7 +1648,7 @@ async def fastapi_add_district_metering_area(network: str, req: Request) -> Chan
                
     return add_district_metering_area(network, ChangeSet(props))
 
-@app.post('/deletedistrictmeteringarea/')
+@app.post('/deletedistrictmeteringarea/',response_model=None)
 async def fastapi_delete_district_metering_area(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return delete_district_metering_area(network, ChangeSet(props))
@@ -1661,11 +1661,11 @@ async def fastapi_get_all_district_metering_area_ids(network: str) -> list[str]:
 async def getalldistrictmeteringareas(network: str) -> list[dict[str, Any]]:
     return get_all_district_metering_areas(network)
 
-@app.post('/generatedistrictmeteringarea/')
+@app.post('/generatedistrictmeteringarea/',response_model=None)
 async def fastapi_generate_district_metering_area(network: str, part_count: int, part_type: int, inflate_delta: float) -> ChangeSet:
     return generate_district_metering_area(network, part_count, part_type, inflate_delta)
 
-@app.post('/generatesubdistrictmeteringarea/')
+@app.post('/generatesubdistrictmeteringarea/',response_model=None)
 async def fastapi_generate_sub_district_metering_area(network: str, dma: str, part_count: int, part_type: int, inflate_delta: float) -> ChangeSet:
     print(network)
     print(dma)
@@ -1689,17 +1689,17 @@ async def fastapi_get_service_area_schema(network: str) -> dict[str, dict[str, A
 async def fastapi_get_service_area(network: str, id: str) -> dict[str, Any]:
     return get_service_area(network, id)
 
-@app.post('/setservicearea/')
+@app.post('/setservicearea/',response_model=None)
 async def fastapi_set_service_area(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return set_service_area(network, ChangeSet(props))
 
-@app.post('/addservicearea/')
+@app.post('/addservicearea/',response_model=None)
 async def fastapi_add_service_area(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return add_service_area(network, ChangeSet(props))
 
-@app.post('/deleteservicearea/')
+@app.post('/deleteservicearea/',response_model=None)
 async def fastapi_delete_service_area(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return delete_service_area(network, ChangeSet(props))
@@ -1708,7 +1708,7 @@ async def fastapi_delete_service_area(network: str, req: Request) -> ChangeSet:
 async def fastapi_get_all_service_areas(network: str) -> list[dict[str, Any]]:
     return get_all_service_areas(network)
 
-@app.post('/generateservicearea/')
+@app.post('/generateservicearea/',response_model=None)
 async def fastapi_generate_service_area(network: str, inflate_delta: float) -> ChangeSet:
     return generate_service_area(network, inflate_delta)
 
@@ -1728,17 +1728,17 @@ async def fastapi_get_virtual_district_schema(network: str) -> dict[str, dict[st
 async def fastapi_get_virtual_district(network: str, id: str) -> dict[str, Any]:
     return get_virtual_district(network, id)
 
-@app.post('/setvirtualdistrict/')
+@app.post('/setvirtualdistrict/',response_model=None)
 async def fastapi_set_virtual_district(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return set_virtual_district(network, ChangeSet(props))
 
-@app.post('/addvirtualdistrict/')
+@app.post('/addvirtualdistrict/',response_model=None)
 async def fastapi_add_virtual_district(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return add_virtual_district(network, ChangeSet(props))
 
-@app.post('/deletevirtualdistrict/')
+@app.post('/deletevirtualdistrict/',response_model=None)
 async def fastapi_delete_virtual_district(network: str, req: Request) -> ChangeSet:
     props = await req.json()
     return delete_virtual_district(network, ChangeSet(props))
@@ -1747,7 +1747,7 @@ async def fastapi_delete_virtual_district(network: str, req: Request) -> ChangeS
 async def fastapi_get_all_virtual_district(network: str) -> list[dict[str, Any]]:
     return get_all_virtual_districts(network)
 
-@app.post('/generatevirtualdistrict/')
+@app.post('/generatevirtualdistrict/',response_model=None)
 async def fastapi_generate_virtual_district(network: str, inflate_delta: float, req: Request) -> ChangeSet:
     props = await req.json()
     return generate_virtual_district(network, props['centers'], inflate_delta)
@@ -1774,13 +1774,12 @@ async def fastapi_calculate_demand_to_network(network: str, demand: float) -> di
     return calculate_demand_to_network(network, demand)
 
 
-
 # inp file
 @app.post("/uploadinp/", status_code=status.HTTP_200_OK)
-async def upload_inp(file: bytes = File(), name: str = None):
+async def upload_inp(afile: bytes, name: str ):
     filePath = inpDir + str(name)
     f = open(filePath, 'wb')
-    f.write(file)
+    f.write(afile)
     f.close()
 
     return True
diff --git a/startpg.bat b/startpg.bat
new file mode 100644
index 0000000..2f1b2ca
--- /dev/null
+++ b/startpg.bat
@@ -0,0 +1,3 @@
+d:
+cd "d:\postgresql14\bin"
+pg_ctl -D ../data -l logfile start
\ No newline at end of file
diff --git a/startserver.bat b/startserver.bat
index 2e882c4..76bf758 100644
--- a/startserver.bat
+++ b/startserver.bat
@@ -1 +1,3 @@
-uvicorn main:app --host 0.0.0.0 --port 80 --reload
+f:
+cd "f:\DEV\GitHub\TJWaterServer"
+uvicorn main:app --host 0.0.0.0 --port 8000 --reload