OrgTJWater/TJWaterServerBinary
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(db)!: finalize pooled WNDB v2 migration

Browse Source
This commit is contained in:
jiang
2026-08-27 17:26:22 +08:00
parent fa188af0b1
commit b74799a39d
105 changed files with 4988 additions and 5565 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/algorithms/simulation/runner.py
+20 -24
View File
@@ -1,9 +1,7 @@
import numpy as np
from functools import wraps
from app.services.tjnetwork import (
ChangeSet,
close_project,
copy_project,
delete_project,
get_pattern,
get_patterns,
get_pump,
@@ -11,9 +9,6 @@ from app.services.tjnetwork import (
get_status,
get_tank,
get_time,
have_project,
is_project_open,
open_project,
read_all,
run_project,
set_pattern,
@@ -29,6 +24,7 @@ import pytz
import requests
import time
import app.services.project_info as project_info
from app.native.wndb.core.projects import temporary_project_database
from app.services.time_api import parse_clock_duration_seconds
url_path = 'http://10.101.15.16:9000/loong' # 内网
@@ -572,9 +568,6 @@ def trim_time_flag(url_date_time:str)->str:
# 单时间步长模拟
def run_simulation(name:str,start_datetime:str,end_datetime:str=None, duration:int=900)->str:
if(is_project_open(name)):
close_project(name)
open_project(name)
#get_current_data(cur_datetime)
#extract the patternindex from datetime
#e.g. 0: the first time step for 00:00-00:14; 1: the second step for 00:15-00:30
@@ -654,32 +647,38 @@ def run_simulation(name:str,start_datetime:str,end_datetime:str=None, duration:i
# 在线模拟
def _clean_extended_simulation(func):
@wraps(func)
def wrapper(name: str, simulation_type: str, *args, **kwargs):
if simulation_type.upper() != "EXTENDED":
return func(name, simulation_type, *args, **kwargs)
with temporary_project_database(name, "extended_simulation") as temporary:
kwargs["_temporary_project"] = temporary
return func(name, simulation_type, *args, **kwargs)
return wrapper
@_clean_extended_simulation
def run_simulation_ex(name: str, simulation_type: str, start_datetime: str,
end_datetime: str = None, duration: int = 0,
pump_control: dict[str, list] = None, tank_initial_level_control: dict[str, float] = None,
region_demand_control: dict[str, float] = None, valve_control: dict[str, dict] = None,
downloading_prohibition: bool = False) -> str:
downloading_prohibition: bool = False,
_temporary_project: str | None = None) -> str:
time_cost_start = time.perf_counter()
print('{} -- Hydraulic simulation started.'.format(
datetime.now(pytz.timezone('Asia/Shanghai')).strftime('%Y-%m-%d %H:%M:%S')))
if is_project_open(name):
close_project(name)
if simulation_type.upper() == 'REALTIME': # 实时模拟(修改原数据库)
name_c = name
elif simulation_type.upper() == 'EXTENDED': # 扩展模拟(复制数据库)
name_c = '_'.join([name, 'c'])
if have_project(name_c):
if is_project_open(name_c):
close_project(name_c)
delete_project(name_c)
copy_project(name, name_c) # 备份项目
if _temporary_project is None:
raise RuntimeError("Extended simulation isolation was not prepared")
name_c = _temporary_project
else:
raise Exception('Incorrect simulation type, choose in (realtime, extended)')
open_project(name_c)
# 时间处理
# extract the pattern index from datetime
# e.g. 0: the first time step for 00:00-00:14; 1: the second step for 00:15-00:30
@@ -848,8 +847,6 @@ def run_simulation_ex(name: str, simulation_type: str, start_datetime: str,
datetime.now(pytz.timezone('Asia/Shanghai')).strftime('%Y-%m-%d %H:%M:%S'),
time_cost_end - time_cost_start))
close_project(name_c)
return result
@@ -858,7 +855,6 @@ if __name__ == '__main__':
# tQ=get_current_total_Q()
# print(f"the current tQ is {tQ}\n")
# data=get_hist_data(ids,conver_beingtime_to_ucttime('2024-04-10 15:05:00'),conver_beingtime_to_ucttime('2024-04-10 15:10:00'))
# open_project("beibeizone")
# read_inp("beibeizone","beibeizone-export_nochinese.inp")
# run_simulation("beibeizone","2024-04-01T08:00:00Z")
# read_inp('bb_server', 'model20_en.inp')
app/algorithms/simulation/scenarios.py
+52 -101
View File
@@ -1,5 +1,6 @@
import json
from datetime import datetime
from functools import wraps
from math import pi, sqrt
import pytz
@@ -9,6 +10,7 @@ from app.algorithms.simulation.runner import (
run_simulation_ex,
from_clock_to_seconds_2,
)
from app.native.wndb.core.projects import temporary_project_database
from app.services.tjnetwork import (
ChangeSet,
OPTION_DEMAND_MODEL_PDA,
@@ -16,9 +18,6 @@ from app.services.tjnetwork import (
SOURCE_TYPE_SETPOINT,
add_pattern,
add_source,
close_project,
copy_project,
delete_project,
get_demand,
get_emitter,
get_node_links,
@@ -27,10 +26,7 @@ from app.services.tjnetwork import (
get_pipe,
get_source,
get_time,
have_project,
is_junction,
is_project_open,
open_project,
set_demand,
set_emitter,
set_option,
@@ -39,11 +35,23 @@ from app.services.tjnetwork import (
)
def _isolated_analysis(purpose: str):
def decorator(func):
@wraps(func)
def wrapper(name: str, *args, **kwargs):
with temporary_project_database(name, purpose) as temporary:
kwargs["_temporary_project"] = temporary
return func(name, *args, **kwargs)
return wrapper
return decorator
############################################################
# burst analysis 01
############################################################
def convert_to_local_unit(proj: str, emitters: float) -> float:
open_project(proj)
proj_opt = get_option(proj)
str_unit = proj_opt.get("UNITS")
@@ -61,6 +69,7 @@ def convert_to_local_unit(proj: str, emitters: float) -> float:
return emitters
@_isolated_analysis("burst_analysis")
def burst_analysis(
name: str,
modify_pattern_start_time: str,
@@ -72,6 +81,7 @@ def burst_analysis(
modify_valve_opening: dict[str, float] = None,
scheme_name: str = None,
username: str | None = None,
_temporary_project: str | None = None,
) -> None:
"""
爆管模拟
@@ -101,21 +111,17 @@ def burst_analysis(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Start Analysis."
)
new_name = f"burst_Anal_{name}"
if have_project(new_name):
if is_project_open(new_name):
close_project(new_name)
delete_project(new_name)
if _temporary_project is None:
raise RuntimeError("Burst analysis isolation was not prepared")
new_name = _temporary_project
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Start Copying Database."
)
copy_project(name + "_template", new_name)
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Start Opening Database."
)
open_project(new_name)
simulation.run_simulation(
name=new_name,
simulation_type="manually_temporary",
@@ -207,20 +213,19 @@ def burst_analysis(
)
# step 3. restore the base model status
# execute_undo(name) #有疑惑
if is_project_open(new_name):
close_project(new_name)
delete_project(new_name)
############################################################
# valve closing analysis 02
############################################################
@_isolated_analysis("valve_close_analysis")
def valve_close_analysis(
name: str,
modify_pattern_start_time: str,
modify_total_duration: int = 900,
modify_valve_opening: dict[str, float] = None,
scheme_name: str = None,
_temporary_project: str | None = None,
) -> None:
"""
关阀模拟
@@ -235,21 +240,17 @@ def valve_close_analysis(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Start Analysis."
)
new_name = f"valve_close_Anal_{name}"
if have_project(new_name):
if is_project_open(new_name):
close_project(new_name)
delete_project(new_name)
if _temporary_project is None:
raise RuntimeError("Valve-close analysis isolation was not prepared")
new_name = _temporary_project
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Start Copying Database."
)
copy_project(name + "_template", new_name)
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Start Opening Database."
)
open_project(new_name)
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Database Loading OK."
@@ -287,9 +288,6 @@ def valve_close_analysis(
# step 3. restore the base model
# for valve in valves:
# execute_undo(name)
if is_project_open(new_name):
close_project(new_name)
delete_project(new_name)
# return result
@@ -297,6 +295,7 @@ def valve_close_analysis(
# flushing analysis 03
# Pipe_Flushing_Analysis(prj_name,date_time, Valve_id_list, Drainage_Node_Id, Flushing_flow[opt], Flushing_duration[opt])->out_file:string
############################################################
@_isolated_analysis("flushing_analysis")
def flushing_analysis(
name: str,
modify_pattern_start_time: str,
@@ -307,6 +306,7 @@ def flushing_analysis(
scheme_name: str = None,
username: str | None = None,
valve_control: dict[str, dict] = None,
_temporary_project: str | None = None,
) -> None:
"""
管道冲洗模拟
@@ -334,23 +334,17 @@ def flushing_analysis(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Start Analysis."
)
new_name = f"flushing_Anal_{name}"
if have_project(new_name):
if is_project_open(new_name):
close_project(new_name)
delete_project(new_name)
# if is_project_open(name):
# close_project(name)
if _temporary_project is None:
raise RuntimeError("Flushing analysis isolation was not prepared")
new_name = _temporary_project
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Start Copying Database."
)
copy_project(name + "_template", new_name)
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Start Opening Database."
)
open_project(new_name)
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Database Loading OK."
@@ -449,9 +443,6 @@ def flushing_analysis(
scheme_detail=scheme_detail,
)
# step 4. restore the base model
if is_project_open(new_name):
close_project(new_name)
delete_project(new_name)
# return result
@@ -459,6 +450,7 @@ def flushing_analysis(
# Contaminant simulation 04
#
############################################################
@_isolated_analysis("contaminant_simulation")
def contaminant_simulation(
name: str,
modify_pattern_start_time: str, # 模拟开始时间,格式为'2024-11-25T09:00:00+08:00'
@@ -468,6 +460,7 @@ def contaminant_simulation(
scheme_name: str = None,
source_pattern: str = None, # 污染源时间变化模式名称
username: str | None = None,
_temporary_project: str | None = None,
) -> None:
"""
污染模拟
@@ -494,23 +487,17 @@ def contaminant_simulation(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Start Analysis."
)
new_name = f"contaminant_Sim_{name}"
if have_project(new_name):
if is_project_open(new_name):
close_project(new_name)
delete_project(new_name)
# if is_project_open(name):
# close_project(name)
if _temporary_project is None:
raise RuntimeError("Contaminant simulation isolation was not prepared")
new_name = _temporary_project
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Start Copying Database."
)
copy_project(name + "_template", new_name)
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Start Opening Database."
)
open_project(new_name)
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Database Loading OK."
@@ -599,9 +586,6 @@ def contaminant_simulation(
# for i in range(1,operation_step):
# execute_undo(name)
if is_project_open(new_name):
close_project(new_name)
delete_project(new_name)
############################################################
@@ -623,45 +607,19 @@ def age_analysis(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Start Analysis."
)
new_name = f"age_Anal_{name}"
if have_project(new_name):
if is_project_open(new_name):
close_project(new_name)
delete_project(new_name)
# if is_project_open(name):
# close_project(name)
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Start Copying Database."
)
copy_project(name + "_template", new_name)
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Start Opening Database."
)
open_project(new_name)
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Database Loading OK."
)
# step 1. run simulation
with temporary_project_database(name, "age_analysis") as new_name:
result = run_simulation_ex(
new_name,
"realtime",
modify_pattern_start_time,
duration=modify_total_duration,
downloading_prohibition=True,
)
simulation_result = json.loads(result)
output_data = simulation_result.get("output")
if not isinstance(output_data, dict):
raise RuntimeError("run_simulation_ex did not return JSON output content")
result = run_simulation_ex(
new_name,
"realtime",
modify_pattern_start_time,
duration=modify_total_duration,
downloading_prohibition=True,
)
simulation_result = json.loads(result)
output_data = simulation_result.get("output")
if not isinstance(output_data, dict):
raise RuntimeError("run_simulation_ex did not return JSON output content")
# step 2. restore the base model status
# execute_undo(name) #有疑惑
if is_project_open(new_name):
close_project(new_name)
delete_project(new_name)
nodes_age = []
node_result = output_data.get("node_results") or []
for node in node_result:
@@ -680,6 +638,7 @@ def age_analysis(
############################################################
@_isolated_analysis("pressure_regulation")
def pressure_regulation(
name: str,
modify_pattern_start_time: str,
@@ -688,6 +647,7 @@ def pressure_regulation(
modify_fixed_pump_pattern: dict[str, list] = None,
modify_variable_pump_pattern: dict[str, list] = None,
scheme_name: str = None,
_temporary_project: str | None = None,
) -> None:
"""
区域调压模拟，用来模拟未来15分钟内，开关水泵对区域压力的影响
@@ -704,23 +664,17 @@ def pressure_regulation(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Start Analysis."
)
new_name = f"pressure_regulation_{name}"
if have_project(new_name):
if is_project_open(new_name):
close_project(new_name)
delete_project(new_name)
# if is_project_open(name):
# close_project(name)
if _temporary_project is None:
raise RuntimeError("Pressure-regulation isolation was not prepared")
new_name = _temporary_project
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Start Copying Database."
)
copy_project(name + "_template", new_name)
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Start Opening Database."
)
open_project(new_name)
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Database Loading OK."
@@ -751,7 +705,4 @@ def pressure_regulation(
scheme_name=scheme_name,
result_db_name=name,
)
if is_project_open(new_name):
close_project(new_name)
delete_project(new_name)
# return result
app/algorithms/water_demand/service.py
+14 -14
View File
@@ -1,8 +1,11 @@
from app.native.wndb.commands.executor import execute_batch_command
from app.native.wndb.core.database import ChangeSet
from app.native.wndb.gis.region_geometry import Topology, get_nodes_in_region
from app.native.wndb.model.demands import get_demand
from app.native.wndb.model.elements import get_nodes, is_junction
from app.native.wndb.gis.network_views import (
get_junction_demands,
sum_junction_base_demand,
)
from app.native.wndb.model.elements import get_nodes
DISTRIBUTION_TYPE_ADD = 'ADD'
@@ -28,7 +31,7 @@ def calculate_demand_to_nodes(name: str, demand: float, nodes: list[str]) -> dic
result: dict[str, float] = {}
for node, value in t_nodes.items():
if not is_junction(name, node):
if value["type"] != "junction":
continue
demand_per_node = 0.0
for link in value['links']:
@@ -68,15 +71,19 @@ def distribute_demand_to_nodes(name: str, demand: float, nodes: list[str], type:
demand_per_length = demand / length_sum
cs = ChangeSet()
demands_by_junction = get_junction_demands(
name,
[node for node, value in t_nodes.items() if value["type"] == "junction"],
)
for node, value in t_nodes.items():
if not is_junction(name, node):
if value["type"] != "junction":
continue
demand_per_node = 0.0
for link in value['links']:
demand_per_node += abs(t_links[link]['length']) * demand_per_length * 0.5
ds = get_demand(name, node)['demands']
ds = demands_by_junction.get(node, [])
if len(ds) == 0:
ds = [{'demand': demand_per_node, 'pattern': None, 'category': None}]
elif type == DISTRIBUTION_TYPE_ADD:
@@ -92,13 +99,6 @@ def distribute_demand_to_region(name: str, demand: float, region: str, type: str
nodes = get_nodes_in_region(name, region)
return distribute_demand_to_nodes(name, demand, nodes, type)
def get_total_base_demand(name:str,region:str)->float:
def get_total_base_demand(name: str, region: str) -> float:
nodes = get_nodes_in_region(name, region)
t_demands=0.0
for node in nodes:
if not is_junction(name, node):
continue
ds = get_demand(name, node)['demands']
t_demands= t_demands+ds[0]['demand']
return t_demands
return sum_junction_base_demand(name, nodes)
app/api/problem_details.py
+20
View File
@@ -8,6 +8,8 @@ from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from pydantic import BaseModel, Field
from app.native.wndb.core.database import MaterializedViewRefreshAfterCommitError
class ProblemDetails(BaseModel):
"""RFC 9457 compatible error response used by the REST contract."""
@@ -53,6 +55,24 @@ def _problem_response(
def install_problem_details_handlers(app: FastAPI) -> None:
@app.exception_handler(MaterializedViewRefreshAfterCommitError)
async def materialized_view_refresh_error_handler(
request: Request,
exc: MaterializedViewRefreshAfterCommitError,
) -> JSONResponse:
response = _problem_response(
request,
status_code=503,
title="Materialized view refresh failed",
detail=(
f"Project {exc.project!r} changes were committed, but GIS query "
"views could not be refreshed. Do not repeat the write blindly."
),
code="materialized_view_refresh_failed_after_commit",
)
response.headers["X-TJWater-Changes-Committed"] = "true"
return response
@app.exception_handler(RequestValidationError)
async def validation_error_handler(
request: Request,
app/api/v1/endpoints/components/controls.py
+13 -12
View File
@@ -1,5 +1,6 @@
from fastapi import APIRouter, Request, Query, Path, Body
from typing import Any, List, Dict, Union
from typing import Any
from fastapi import APIRouter, Body, Query
from app.services.tjnetwork import (
ChangeSet,
get_control,
@@ -13,7 +14,7 @@ from app.services.tjnetwork import (
router = APIRouter()
@router.get("/network-schemas/control", summary="获取控制架构", description="获取网络中控制对象的架构定义")
async def fastapi_get_control_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
def fastapi_get_control_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
"""获取控制架构。
返回指定网络中控制对象的属性架构定义。
@@ -21,7 +22,7 @@ async def fastapi_get_control_schema(network: str = Query(..., description="管
return get_control_schema(network)
@router.get("/controls/properties", summary="获取控制属性", description="获取指定网络中的控制属性信息")
async def fastapi_get_control_properties(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, Any]:
def fastapi_get_control_properties(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, Any]:
"""获取控制属性。
返回指定网络中的控制对象属性信息。
@@ -29,19 +30,19 @@ async def fastapi_get_control_properties(network: str = Query(..., description="
return get_control(network)
@router.patch("/controls/properties", response_model=None, summary="设置控制属性", description="更新指定网络中的控制属性")
async def fastapi_set_control_properties(
def fastapi_set_control_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""设置控制属性。
更新指定网络中的控制属性值。
"""
props = await req.json()
props = payload
return set_control(network, ChangeSet(props))
@router.get("/rule-schemas", summary="获取规则架构", description="获取网络中规则对象的架构定义")
async def fastapi_get_rule_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
def fastapi_get_rule_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
"""获取规则架构。
返回指定网络中规则对象的属性架构定义。
@@ -49,7 +50,7 @@ async def fastapi_get_rule_schema(network: str = Query(..., description="管网
return get_rule_schema(network)
@router.get("/rule-properties", summary="获取规则属性", description="获取指定网络中的规则属性信息")
async def fastapi_get_rule_properties(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, Any]:
def fastapi_get_rule_properties(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, Any]:
"""获取规则属性。
返回指定网络中的规则对象属性信息。
@@ -57,13 +58,13 @@ async def fastapi_get_rule_properties(network: str = Query(..., description="管
return get_rule(network)
@router.patch("/rule-properties", response_model=None, summary="设置规则属性", description="更新指定网络中的规则属性")
async def fastapi_set_rule_properties(
def fastapi_set_rule_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""设置规则属性。
更新指定网络中的规则属性值。
"""
props = await req.json()
props = payload
return set_rule(network, ChangeSet(props))
app/api/v1/endpoints/components/curves.py
+14 -13
View File
@@ -1,5 +1,6 @@
from fastapi import APIRouter, Request, Query, Path, Body
from typing import Any, List, Dict, Union
from typing import Any
from fastapi import APIRouter, Body, Query
from app.services.tjnetwork import (
ChangeSet,
add_curve,
@@ -14,7 +15,7 @@ from app.services.tjnetwork import (
router = APIRouter()
@router.get("/network-schemas/curve", summary="获取曲线架构", description="获取网络中曲线对象的架构定义")
async def fastapi_get_curve_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
def fastapi_get_curve_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
"""获取曲线架构。
返回指定网络中曲线对象的属性架构定义。
@@ -22,23 +23,23 @@ async def fastapi_get_curve_schema(network: str = Query(..., description="管网
return get_curve_schema(network)
@router.post("/curves", response_model=None, summary="添加曲线", description="在网络中添加一条新的曲线")
async def fastapi_add_curve(
def fastapi_add_curve(
network: str = Query(..., description="管网名称（或数据库名称）"),
curve: str = Query(..., description="曲线ID"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""添加曲线。
在指定网络中创建一条新的曲线，并设置其初始属性。
"""
props = await req.json()
props = payload
ps = {
"id": curve,
} | props
return add_curve(network, ChangeSet(ps))
@router.delete("/curves", response_model=None, summary="删除曲线", description="从网络中删除指定的曲线")
async def fastapi_delete_curve(
def fastapi_delete_curve(
network: str = Query(..., description="管网名称（或数据库名称）"),
curve: str = Query(..., description="曲线ID")
) -> ChangeSet:
@@ -50,7 +51,7 @@ async def fastapi_delete_curve(
return delete_curve(network, ChangeSet(ps))
@router.get("/curves/properties", summary="获取曲线属性", description="获取指定曲线的属性信息")
async def fastapi_get_curve_properties(
def fastapi_get_curve_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
curve: str = Query(..., description="曲线ID")
) -> dict[str, Any]:
@@ -61,21 +62,21 @@ async def fastapi_get_curve_properties(
return get_curve(network, curve)
@router.patch("/curves/properties", response_model=None, summary="设置曲线属性", description="更新指定曲线的属性")
async def fastapi_set_curve_properties(
def fastapi_set_curve_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
curve: str = Query(..., description="曲线ID"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""设置曲线属性。
更新指定曲线的属性值。
"""
props = await req.json()
props = payload
ps = {"id": curve} | props
return set_curve(network, ChangeSet(ps))
@router.get("/curves", summary="获取所有曲线", description="获取网络中的所有曲线列表")
async def fastapi_get_curves(network: str = Query(..., description="管网名称（或数据库名称）")) -> list[str]:
def fastapi_get_curves(network: str = Query(..., description="管网名称（或数据库名称）")) -> list[str]:
"""获取所有曲线。
返回指定网络中的所有曲线ID列表。
@@ -83,7 +84,7 @@ async def fastapi_get_curves(network: str = Query(..., description="管网名称
return get_curves(network)
@router.get("/curves/existence", summary="检查曲线存在性", description="检查指定的曲线是否存在")
async def fastapi_is_curve(
def fastapi_is_curve(
network: str = Query(..., description="管网名称（或数据库名称）"),
curve: str = Query(..., description="曲线ID")
) -> bool:
app/api/v1/endpoints/components/options.py
+23 -22
View File
@@ -1,5 +1,6 @@
from fastapi import APIRouter, Request, Query, Path, Body
from typing import Any, List, Dict, Union
from typing import Any
from fastapi import APIRouter, Body, Query
from app.services.tjnetwork import (
ChangeSet,
get_energy,
@@ -19,7 +20,7 @@ from app.services.tjnetwork import (
router = APIRouter()
@router.get("/network-schemas/time", summary="获取时间选项架构", description="获取网络中时间选项的架构定义")
async def fastapi_get_time_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
def fastapi_get_time_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
"""获取时间选项架构。
返回指定网络中时间相关选项的属性架构定义。
@@ -27,7 +28,7 @@ async def fastapi_get_time_schema(network: str = Query(..., description="管网
return get_time_schema(network)
@router.get("/network-options/time", summary="获取时间选项属性", description="获取指定网络中的时间选项属性信息")
async def fastapi_get_time_properties(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, Any]:
def fastapi_get_time_properties(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, Any]:
"""获取时间选项属性。
返回指定网络中的时间相关选项属性。
@@ -35,19 +36,19 @@ async def fastapi_get_time_properties(network: str = Query(..., description="管
return get_time(network)
@router.patch("/time-properties", response_model=None, summary="设置时间选项属性", description="更新指定网络中的时间选项属性")
async def fastapi_set_time_properties(
def fastapi_set_time_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""设置时间选项属性。
更新指定网络中的时间相关选项属性值。
"""
props = await req.json()
props = payload
return set_time(network, ChangeSet(props))
@router.get("/network-schemas/energy", summary="获取能耗选项架构", description="获取网络中能耗选项的架构定义")
async def fastapi_get_energy_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
def fastapi_get_energy_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
"""获取能耗选项架构。
返回指定网络中能耗相关选项的属性架构定义。
@@ -55,7 +56,7 @@ async def fastapi_get_energy_schema(network: str = Query(..., description="管
return get_energy_schema(network)
@router.get("/network-options/energy", summary="获取能耗选项属性", description="获取指定网络中的能耗选项属性信息")
async def fastapi_get_energy_properties(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, Any]:
def fastapi_get_energy_properties(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, Any]:
"""获取能耗选项属性。
返回指定网络中的能耗相关选项属性。
@@ -63,19 +64,19 @@ async def fastapi_get_energy_properties(network: str = Query(..., description="
return get_energy(network)
@router.patch("/energy-properties", response_model=None, summary="设置能耗选项属性", description="更新指定网络中的能耗选项属性")
async def fastapi_set_energy_properties(
def fastapi_set_energy_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""设置能耗选项属性。
更新指定网络中的能耗相关选项属性值。
"""
props = await req.json()
props = payload
return set_energy(network, ChangeSet(props))
@router.get("/network-schemas/pump-energy", summary="获取泵能耗选项架构", description="获取网络中泵能耗选项的架构定义")
async def fastapi_get_pump_energy_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
def fastapi_get_pump_energy_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
"""获取泵能耗选项架构。
返回指定网络中泵能耗相关选项的属性架构定义。
@@ -83,7 +84,7 @@ async def fastapi_get_pump_energy_schema(network: str = Query(..., description="
return get_pump_energy_schema(network)
@router.get("/network-options/pump-energy", summary="获取泵能耗属性", description="获取指定泵的能耗属性信息")
async def fastapi_get_pump_energy_proeprties(
def fastapi_get_pump_energy_proeprties(
network: str = Query(..., description="管网名称（或数据库名称）"),
pump: str = Query(..., description="泵ID")
) -> dict[str, Any]:
@@ -94,21 +95,21 @@ async def fastapi_get_pump_energy_proeprties(
return get_pump_energy(network, pump)
@router.patch("/network-options/pump-energy", response_model=None, summary="设置泵能耗属性", description="更新指定泵的能耗属性")
async def fastapi_set_pump_energy_properties(
def fastapi_set_pump_energy_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
pump: str = Query(..., description="泵ID"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""设置泵能耗属性。
更新指定泵的能耗相关属性值。
"""
props = await req.json()
props = payload
ps = {"id": pump} | props
return set_pump_energy(network, ChangeSet(ps))
@router.get("/network-schemas/option", summary="获取选项架构", description="获取网络中选项对象的架构定义")
async def fastapi_get_option_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
def fastapi_get_option_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
"""获取选项架构。
返回指定网络中选项对象的属性架构定义。
@@ -116,7 +117,7 @@ async def fastapi_get_option_schema(network: str = Query(..., description="管
return get_option_v3_schema(network)
@router.get("/network-options", summary="获取选项属性", description="获取指定网络中的选项属性信息")
async def fastapi_get_option_properties(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, Any]:
def fastapi_get_option_properties(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, Any]:
"""获取选项属性。
返回指定网络中的选项对象属性信息。
@@ -124,13 +125,13 @@ async def fastapi_get_option_properties(network: str = Query(..., description="
return get_option_v3(network)
@router.patch("/network-options", response_model=None, summary="设置选项属性", description="更新指定网络中的选项属性")
async def fastapi_set_option_properties(
def fastapi_set_option_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""设置选项属性。
更新指定网络中的选项属性值。
"""
props = await req.json()
props = payload
return set_option_v3(network, ChangeSet(props))
app/api/v1/endpoints/components/patterns.py
+14 -13
View File
@@ -1,5 +1,6 @@
from fastapi import APIRouter, Request, Query, Path, Body
from typing import Any, List, Dict, Union
from typing import Any
from fastapi import APIRouter, Body, Query
from app.services.tjnetwork import (
ChangeSet,
add_pattern,
@@ -14,7 +15,7 @@ from app.services.tjnetwork import (
router = APIRouter()
@router.get("/network-schemas/pattern", summary="获取模式架构", description="获取网络中模式对象的架构定义")
async def fastapi_get_pattern_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
def fastapi_get_pattern_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
"""获取模式架构。
返回指定网络中模式对象的属性架构定义。
@@ -22,23 +23,23 @@ async def fastapi_get_pattern_schema(network: str = Query(..., description="管
return get_pattern_schema(network)
@router.post("/patterns", response_model=None, summary="添加模式", description="在网络中添加一个新的模式")
async def fastapi_add_pattern(
def fastapi_add_pattern(
network: str = Query(..., description="管网名称（或数据库名称）"),
pattern: str = Query(..., description="模式ID"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""添加模式。
在指定网络中创建一个新的模式，并设置其初始属性。
"""
props = await req.json()
props = payload
ps = {
"id": pattern,
} | props
return add_pattern(network, ChangeSet(ps))
@router.delete("/patterns", response_model=None, summary="删除模式", description="从网络中删除指定的模式")
async def fastapi_delete_pattern(
def fastapi_delete_pattern(
network: str = Query(..., description="管网名称（或数据库名称）"),
pattern: str = Query(..., description="模式ID")
) -> ChangeSet:
@@ -50,7 +51,7 @@ async def fastapi_delete_pattern(
return delete_pattern(network, ChangeSet(ps))
@router.get("/patterns/properties", summary="获取模式属性", description="获取指定模式的属性信息")
async def fastapi_get_pattern_properties(
def fastapi_get_pattern_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
pattern: str = Query(..., description="模式ID")
) -> dict[str, Any]:
@@ -61,21 +62,21 @@ async def fastapi_get_pattern_properties(
return get_pattern(network, pattern)
@router.patch("/patterns/properties", response_model=None, summary="设置模式属性", description="更新指定模式的属性")
async def fastapi_set_pattern_properties(
def fastapi_set_pattern_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
pattern: str = Query(..., description="模式ID"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""设置模式属性。
更新指定模式的属性值。
"""
props = await req.json()
props = payload
ps = {"id": pattern} | props
return set_pattern(network, ChangeSet(ps))
@router.get("/patterns/existence", summary="检查模式存在性", description="检查指定的模式是否存在")
async def fastapi_is_pattern(
def fastapi_is_pattern(
network: str = Query(..., description="管网名称（或数据库名称）"),
pattern: str = Query(..., description="模式ID")
) -> bool:
@@ -86,7 +87,7 @@ async def fastapi_is_pattern(
return is_pattern(network, pattern)
@router.get("/patterns", summary="获取所有模式", description="获取网络中的所有模式列表")
async def fastapi_get_patterns(network: str = Query(..., description="管网名称（或数据库名称）")) -> list[str]:
def fastapi_get_patterns(network: str = Query(..., description="管网名称（或数据库名称）")) -> list[str]:
"""获取所有模式。
返回指定网络中的所有模式ID列表。
app/api/v1/endpoints/components/quality.py
+48 -47
View File
@@ -1,5 +1,6 @@
from fastapi import APIRouter, Request, Query, Path, Body
from typing import Any, List, Dict, Union
from typing import Any
from fastapi import APIRouter, Body, Query
from app.services.tjnetwork import (
ChangeSet,
add_mixing,
@@ -32,7 +33,7 @@ from app.services.tjnetwork import (
router = APIRouter()
@router.get("/network-schemas/quality", summary="获取水质架构", description="获取网络中水质对象的架构定义")
async def fastapi_get_quality_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
def fastapi_get_quality_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
"""获取水质架构。
返回指定网络中水质对象的属性架构定义。
@@ -40,7 +41,7 @@ async def fastapi_get_quality_schema(network: str = Query(..., description="管
return get_quality_schema(network)
@router.get("/quality-configurations/properties", summary="获取水质属性", description="获取指定节点的水质属性信息")
async def fastapi_get_quality_properties(
def fastapi_get_quality_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
node: str = Query(..., description="节点ID")
) -> dict[str, Any]:
@@ -51,19 +52,19 @@ async def fastapi_get_quality_properties(
return get_quality(network, node)
@router.patch("/quality-configurations/properties", response_model=None, summary="设置水质属性", description="更新指定节点的水质属性")
async def fastapi_set_quality_properties(
def fastapi_set_quality_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""设置水质属性。
更新指定节点的水质属性值。
"""
props = await req.json()
props = payload
return set_quality(network, ChangeSet(props))
@router.get("/network-schemas/emitter", summary="获取发射器架构", description="获取网络中发射器对象的架构定义")
async def fastapi_get_emitter_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
def fastapi_get_emitter_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
"""获取发射器架构。
返回指定网络中发射器对象的属性架构定义。
@@ -71,7 +72,7 @@ async def fastapi_get_emitter_schema(network: str = Query(..., description="管
return get_emitter_schema(network)
@router.get("/emitters/properties", summary="获取发射器属性", description="获取指定连接点的发射器属性信息")
async def fastapi_get_emitter_properties(
def fastapi_get_emitter_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
junction: str = Query(..., description="连接点ID")
) -> dict[str, Any]:
@@ -82,21 +83,21 @@ async def fastapi_get_emitter_properties(
return get_emitter(network, junction)
@router.patch("/emitters/properties", response_model=None, summary="设置发射器属性", description="更新指定连接点的发射器属性")
async def fastapi_set_emitter_properties(
def fastapi_set_emitter_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
junction: str = Query(..., description="连接点ID"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""设置发射器属性。
更新指定连接点的发射器属性值。
"""
props = await req.json()
props = payload
ps = {"junction": junction} | props
return set_emitter(network, ChangeSet(ps))
@router.get("/network-schemas/source", summary="获取水源架构", description="获取网络中水源对象的架构定义")
async def fastapi_get_source_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
def fastapi_get_source_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
"""获取水源架构。
返回指定网络中水源对象的属性架构定义。
@@ -104,7 +105,7 @@ async def fastapi_get_source_schema(network: str = Query(..., description="管
return get_source_schema(network)
@router.get("/sources/detail", summary="获取水源属性", description="获取指定节点的水源属性信息")
async def fastapi_get_source(
def fastapi_get_source(
network: str = Query(..., description="管网名称（或数据库名称）"),
node: str = Query(..., description="节点ID")
) -> dict[str, Any]:
@@ -115,31 +116,31 @@ async def fastapi_get_source(
return get_source(network, node)
@router.patch("/sources", response_model=None, summary="设置水源属性", description="更新指定节点的水源属性")
async def fastapi_set_source(
def fastapi_set_source(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""设置水源属性。
更新指定节点的水源属性值。
"""
props = await req.json()
props = payload
return set_source(network, ChangeSet(props))
@router.post("/sources", response_model=None, summary="添加水源", description="在网络中添加一个新的水源")
async def fastapi_add_source(
def fastapi_add_source(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""添加水源。
在指定网络中创建一个新的水源，并设置其初始属性。
"""
props = await req.json()
props = payload
return add_source(network, ChangeSet(props))
@router.delete("/sources", response_model=None, summary="删除水源", description="从网络中删除指定节点的水源")
async def fastapi_delete_source(
def fastapi_delete_source(
network: str = Query(..., description="管网名称（或数据库名称）"),
node: str = Query(..., description="节点ID")
) -> ChangeSet:
@@ -151,7 +152,7 @@ async def fastapi_delete_source(
return delete_source(network, ChangeSet(props))
@router.get("/network-schemas/reaction", summary="获取反应架构", description="获取网络中反应对象的架构定义")
async def fastapi_get_reaction_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
def fastapi_get_reaction_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
"""获取反应架构。
返回指定网络中反应对象的属性架构定义。
@@ -159,7 +160,7 @@ async def fastapi_get_reaction_schema(network: str = Query(..., description="管
return get_reaction_schema(network)
@router.get("/reactions/detail", summary="获取反应属性", description="获取指定网络中的反应属性信息")
async def fastapi_get_reaction(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, Any]:
def fastapi_get_reaction(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, Any]:
"""获取反应属性。
返回指定网络中的反应属性信息。
@@ -167,19 +168,19 @@ async def fastapi_get_reaction(network: str = Query(..., description="管网名
return get_reaction(network)
@router.patch("/reactions", response_model=None, summary="设置反应属性", description="更新指定网络中的反应属性")
async def fastapi_set_reaction(
def fastapi_set_reaction(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""设置反应属性。
更新指定网络中的反应属性值。
"""
props = await req.json()
props = payload
return set_reaction(network, ChangeSet(props))
@router.get("/network-schemas/pipe-reaction", summary="获取管道反应架构", description="获取网络中管道反应对象的架构定义")
async def fastapi_get_pipe_reaction_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
def fastapi_get_pipe_reaction_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
"""获取管道反应架构。
返回指定网络中管道反应对象的属性架构定义。
@@ -187,7 +188,7 @@ async def fastapi_get_pipe_reaction_schema(network: str = Query(..., description
return get_pipe_reaction_schema(network)
@router.get("/pipe-reactions/detail", summary="获取管道反应属性", description="获取指定管道的反应属性信息")
async def fastapi_get_pipe_reaction(
def fastapi_get_pipe_reaction(
network: str = Query(..., description="管网名称（或数据库名称）"),
pipe: str = Query(..., description="管道ID")
) -> dict[str, Any]:
@@ -198,19 +199,19 @@ async def fastapi_get_pipe_reaction(
return get_pipe_reaction(network, pipe)
@router.patch("/pipe-reactions", response_model=None, summary="设置管道反应属性", description="更新指定管道的反应属性")
async def fastapi_set_pipe_reaction(
def fastapi_set_pipe_reaction(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""设置管道反应属性。
更新指定管道的反应属性值。
"""
props = await req.json()
props = payload
return set_pipe_reaction(network, ChangeSet(props))
@router.get("/network-schemas/tank-reaction", summary="获取水池反应架构", description="获取网络中水池反应对象的架构定义")
async def fastapi_get_tank_reaction_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
def fastapi_get_tank_reaction_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
"""获取水池反应架构。
返回指定网络中水池反应对象的属性架构定义。
@@ -218,7 +219,7 @@ async def fastapi_get_tank_reaction_schema(network: str = Query(..., description
return get_tank_reaction_schema(network)
@router.get("/tank-reactions/detail", summary="获取水池反应属性", description="获取指定水池的反应属性信息")
async def fastapi_get_tank_reaction(
def fastapi_get_tank_reaction(
network: str = Query(..., description="管网名称（或数据库名称）"),
tank: str = Query(..., description="水池ID")
) -> dict[str, Any]:
@@ -229,19 +230,19 @@ async def fastapi_get_tank_reaction(
return get_tank_reaction(network, tank)
@router.patch("/tank-reactions", response_model=None, summary="设置水池反应属性", description="更新指定水池的反应属性")
async def fastapi_set_tank_reaction(
def fastapi_set_tank_reaction(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""设置水池反应属性。
更新指定水池的反应属性值。
"""
props = await req.json()
props = payload
return set_tank_reaction(network, ChangeSet(props))
@router.get("/network-schemas/mixing", summary="获取混合架构", description="获取网络中混合对象的架构定义")
async def fastapi_get_mixing_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
def fastapi_get_mixing_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
"""获取混合架构。
返回指定网络中混合对象的属性架构定义。
@@ -249,7 +250,7 @@ async def fastapi_get_mixing_schema(network: str = Query(..., description="管
return get_mixing_schema(network)
@router.get("/mixing-configurations/detail", summary="获取混合属性", description="获取指定水池的混合属性信息")
async def fastapi_get_mixing(
def fastapi_get_mixing(
network: str = Query(..., description="管网名称（或数据库名称）"),
tank: str = Query(..., description="水池ID")
) -> dict[str, Any]:
@@ -260,37 +261,37 @@ async def fastapi_get_mixing(
return get_mixing(network, tank)
@router.patch("/mixing-configurations", response_model=None, summary="设置混合属性", description="更新指定水池的混合属性")
async def fastapi_set_mixing(
def fastapi_set_mixing(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""设置混合属性。
更新指定水池的混合属性值。
"""
props = await req.json()
props = payload
return set_mixing(network, ChangeSet(props))
@router.post("/mixing-configurations", response_model=None, summary="添加混合", description="在网络中添加一个新的混合")
async def fastapi_add_mixing(
def fastapi_add_mixing(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""添加混合。
在指定网络中创建一个新的混合，并设置其初始属性。
"""
props = await req.json()
props = payload
return add_mixing(network, ChangeSet(props))
@router.delete("/mixing-configurations", response_model=None, summary="删除混合", description="从网络中删除指定的混合")
async def fastapi_delete_mixing(
def fastapi_delete_mixing(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""删除混合。
从指定网络中删除指定的混合及其相关数据。
"""
props = await req.json()
props = payload
return delete_mixing(network, ChangeSet(props))
app/api/v1/endpoints/components/visuals.py
+32 -31
View File
@@ -1,5 +1,6 @@
from fastapi import APIRouter, Request, Query, Path, Body, Response
from typing import Any, List, Dict, Union
from typing import Any
from fastapi import APIRouter, Body, Query
from app.services.tjnetwork import (
ChangeSet,
add_label,
@@ -24,7 +25,7 @@ import json
router = APIRouter()
@router.get("/network-schemas/vertex", summary="获取图形元素架构", description="获取网络中图形元素对象的架构定义")
async def fastapi_get_vertex_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
def fastapi_get_vertex_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
"""获取图形元素架构。
返回指定网络中图形元素对象的属性架构定义。
@@ -32,7 +33,7 @@ async def fastapi_get_vertex_schema(network: str = Query(..., description="管
return get_vertex_schema(network)
@router.get("/visual-elements/properties", summary="获取图形元素属性", description="获取指定图形元素的属性信息")
async def fastapi_get_vertex_properties(
def fastapi_get_vertex_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
link: str = Query(..., description="图形元素链接")
) -> dict[str, Any]:
@@ -43,43 +44,43 @@ async def fastapi_get_vertex_properties(
return get_vertex(network, link)
@router.patch("/visual-elements/properties", response_model=None, summary="设置图形元素属性", description="更新指定图形元素的属性")
async def fastapi_set_vertex_properties(
def fastapi_set_vertex_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""设置图形元素属性。
更新指定图形元素的属性值。
"""
props = await req.json()
props = payload
return set_vertex(network, ChangeSet(props))
@router.post("/visual-elements", response_model=None, summary="添加图形元素", description="在网络中添加一个新的图形元素")
async def fastapi_add_vertex(
def fastapi_add_vertex(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""添加图形元素。
在指定网络中创建一个新的图形元素，并设置其初始属性。
"""
props = await req.json()
props = payload
return add_vertex(network, ChangeSet(props))
@router.delete("/visual-elements", response_model=None, summary="删除图形元素", description="从网络中删除指定的图形元素")
async def fastapi_delete_vertex(
def fastapi_delete_vertex(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""删除图形元素。
从指定网络中删除指定的图形元素及其相关数据。
"""
props = await req.json()
props = payload
return delete_vertex(network, ChangeSet(props))
@router.get("/visual-elements/links", response_class=PlainTextResponse, summary="获取所有图形元素链接", description="获取网络中的所有图形元素链接列表")
async def fastapi_get_all_vertex_links(network: str = Query(..., description="管网名称（或数据库名称）")) -> list[str]:
def fastapi_get_all_vertex_links(network: str = Query(..., description="管网名称（或数据库名称）")) -> list[str]:
"""获取所有图形元素链接。
返回指定网络中的所有图形元素链接列表。
@@ -87,7 +88,7 @@ async def fastapi_get_all_vertex_links(network: str = Query(..., description="
return json.dumps(get_all_vertex_links(network))
@router.get("/all-vertices", response_class=PlainTextResponse, summary="获取所有图形元素", description="获取网络中的所有图形元素详细信息")
async def fastapi_get_all_vertices(network: str = Query(..., description="管网名称（或数据库名称）")) -> list[dict[str, Any]]:
def fastapi_get_all_vertices(network: str = Query(..., description="管网名称（或数据库名称）")) -> list[dict[str, Any]]:
"""获取所有图形元素。
返回指定网络中的所有图形元素详细信息。
@@ -95,7 +96,7 @@ async def fastapi_get_all_vertices(network: str = Query(..., description="管网
return json.dumps(get_all_vertices(network))
@router.get("/network-schemas/label", summary="获取标签架构", description="获取网络中标签对象的架构定义")
async def fastapi_get_label_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
def fastapi_get_label_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
"""获取标签架构。
返回指定网络中标签对象的属性架构定义。
@@ -103,7 +104,7 @@ async def fastapi_get_label_schema(network: str = Query(..., description="管网
return get_label_schema(network)
@router.get("/labels/properties", summary="获取标签属性", description="获取指定坐标处的标签属性信息")
async def fastapi_get_label_properties(
def fastapi_get_label_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
x: float = Query(..., description="X坐标"),
y: float = Query(..., description="Y坐标")
@@ -115,43 +116,43 @@ async def fastapi_get_label_properties(
return get_label(network, x, y)
@router.patch("/labels/properties", response_model=None, summary="设置标签属性", description="更新指定标签的属性")
async def fastapi_set_label_properties(
def fastapi_set_label_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""设置标签属性。
更新指定标签的属性值。
"""
props = await req.json()
props = payload
return set_label(network, ChangeSet(props))
@router.post("/labels", response_model=None, summary="添加标签", description="在网络中添加一个新的标签")
async def fastapi_add_label(
def fastapi_add_label(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""添加标签。
在指定网络中创建一个新的标签，并设置其初始属性。
"""
props = await req.json()
props = payload
return add_label(network, ChangeSet(props))
@router.delete("/labels", response_model=None, summary="删除标签", description="从网络中删除指定的标签")
async def fastapi_delete_label(
def fastapi_delete_label(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""删除标签。
从指定网络中删除指定的标签及其相关数据。
"""
props = await req.json()
props = payload
return delete_label(network, ChangeSet(props))
@router.get("/network-schemas/backdrop", summary="获取背景架构", description="获取网络中背景对象的架构定义")
async def fastapi_get_backdrop_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
def fastapi_get_backdrop_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
"""获取背景架构。
返回指定网络中背景对象的属性架构定义。
@@ -159,7 +160,7 @@ async def fastapi_get_backdrop_schema(network: str = Query(..., description="管
return get_backdrop_schema(network)
@router.get("/backdrops/properties", summary="获取背景属性", description="获取指定网络的背景属性信息")
async def fastapi_get_backdrop_properties(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, Any]:
def fastapi_get_backdrop_properties(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, Any]:
"""获取背景属性。
返回指定网络的背景属性信息。
@@ -167,13 +168,13 @@ async def fastapi_get_backdrop_properties(network: str = Query(..., description=
return get_backdrop(network)
@router.patch("/backdrops/properties", response_model=None, summary="设置背景属性", description="更新指定网络的背景属性")
async def fastapi_set_backdrop_properties(
def fastapi_set_backdrop_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""设置背景属性。
更新指定网络的背景属性值。
"""
props = await req.json()
props = payload
return set_backdrop(network, ChangeSet(props))
app/api/v1/endpoints/meta.py
+6 -7
View File
@@ -2,14 +2,11 @@ import logging
from fastapi import APIRouter, Depends, HTTPException, status, Query, Path
import psycopg
from psycopg import AsyncConnection
from sqlalchemy import text
from sqlalchemy.exc import SQLAlchemyError
from sqlalchemy.ext.asyncio import AsyncSession
from app.auth.project_dependencies import (
ProjectContext,
get_project_context,
get_project_pg_session,
get_project_pg_connection,
get_project_timescale_connection,
get_metadata_repository,
)
@@ -90,7 +87,7 @@ async def list_user_projects(
@router.get("/projects/current/database-health", summary="检查数据库健康状态", description="检查项目数据库连接的健康状况")
async def project_db_health(
pg_session: AsyncSession = Depends(get_project_pg_session),
pg_conn: AsyncConnection = Depends(get_project_pg_connection),
ts_conn: AsyncConnection = Depends(get_project_timescale_connection),
):
"""
@@ -99,8 +96,10 @@ async def project_db_health(
检查PostgreSQL和TimescaleDB数据库的连接状态
"""
try:
await pg_session.execute(text("SELECT 1"))
except SQLAlchemyError as exc:
async with pg_conn.cursor() as cur:
await cur.execute("SELECT 1")
await cur.fetchone()
except psycopg.Error as exc:
logger.error("Project PostgreSQL health check failed", exc_info=True)
raise HTTPException(
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
app/api/v1/endpoints/model_import.py
+16 -4
View File
@@ -12,6 +12,7 @@ from fastapi import (
UploadFile,
status,
)
from starlette.concurrency import run_in_threadpool
from app.auth.metadata_dependencies import (
get_current_metadata_admin,
@@ -24,6 +25,7 @@ from app.auth.project_dependencies import (
from app.core.audit import AuditAction, log_audit_event
from app.infra.db.metadb.repositories.metadata_repository import MetadataRepository
from app.infra.db.project_routing import activate_project_routing
from app.native.wndb.core.database import MaterializedViewRefreshAfterCommitError
from app.services.network_import import network_update
from app.services.tjnetwork import run_inp
@@ -87,8 +89,8 @@ def _validate_inp_bytes(content: bytes, filename: str) -> str:
async def _read_upload(file: UploadFile) -> tuple[bytes, str]:
filename = Path(file.filename or "").name
content = await file.read(MAX_INP_FILE_BYTES + 1)
_validate_inp_bytes(content, filename)
return content, filename
normalized = _validate_inp_bytes(content, filename).encode("utf-8")
return normalized, filename
async def _audit_model_change(
@@ -114,7 +116,7 @@ async def _audit_model_change(
)
async def _run_uploaded_inp(content: bytes) -> str:
def _run_uploaded_inp_sync(content: bytes) -> str:
target_dir = Path("inp")
target_dir.mkdir(parents=True, exist_ok=True)
model_name = f"admin_model_{uuid4().hex}"
@@ -123,7 +125,11 @@ async def _run_uploaded_inp(content: bytes) -> str:
return run_inp(model_name)
async def _update_from_inp(content: bytes, project_code: str) -> None:
async def _run_uploaded_inp(content: bytes) -> str:
return await run_in_threadpool(_run_uploaded_inp_sync, content)
def _update_from_inp_sync(content: bytes, project_code: str) -> None:
temp_path: Path | None = None
try:
with NamedTemporaryFile(suffix=".inp", delete=False) as temp_file:
@@ -135,9 +141,15 @@ async def _update_from_inp(content: bytes, project_code: str) -> None:
temp_path.unlink(missing_ok=True)
async def _update_from_inp(content: bytes, project_code: str) -> None:
await run_in_threadpool(_update_from_inp_sync, content, project_code)
async def _apply_model_update(content: bytes, project_code: str) -> None:
try:
await _update_from_inp(content, project_code)
except MaterializedViewRefreshAfterCommitError:
raise
except Exception as exc:
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
app/api/v1/endpoints/network/demands.py
+15 -14
View File
@@ -1,5 +1,6 @@
from fastapi import APIRouter, Request, Query, Path, Body
from typing import Any, List, Dict, Union
from typing import Any
from fastapi import APIRouter, Body, Query
from app.services.tjnetwork import (
ChangeSet,
calculate_demand_to_network,
@@ -21,7 +22,7 @@ router = APIRouter()
summary="获取需水量属性架构",
description="获取指定水网中需水量(Demand)的属性架构定义"
)
async def fastapi_get_demand_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
def fastapi_get_demand_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
"""
获取需水量属性架构。
@@ -35,7 +36,7 @@ async def fastapi_get_demand_schema(network: str = Query(..., description="管
summary="获取需水量属性",
description="获取指定水网中节点的需水量属性信息"
)
async def fastapi_get_demand_properties(
def fastapi_get_demand_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
junction: str = Query(..., description="节点ID")
) -> dict[str, Any]:
@@ -54,17 +55,17 @@ async def fastapi_get_demand_properties(
summary="设置需水量属性",
description="设置指定水网中节点的需水量属性信息"
)
async def fastapi_set_demand_properties(
def fastapi_set_demand_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
junction: str = Query(..., description="节点ID"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""
设置节点的需水量属性。
修改指定节点的需水量信息。请求体应包含需水量值、水压等级等属性。
"""
props = await req.json()
props = payload
ps = {"junction": junction} | props
return set_demand(network, ChangeSet(ps))
@@ -76,9 +77,9 @@ async def fastapi_set_demand_properties(
summary="计算需水量到节点分配",
description="将总需水量按指定方式分配到多个节点"
)
async def fastapi_calculate_demand_to_nodes(
def fastapi_calculate_demand_to_nodes(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> dict[str, float]:
"""
计算需水量到节点分配。
@@ -91,7 +92,7 @@ async def fastapi_calculate_demand_to_nodes(
"nodes": 节点ID列表(list[str])
}
"""
props = await req.json()
props = payload
demand = props["demand"]
nodes = props["nodes"]
return calculate_demand_to_nodes(network, demand, nodes)
@@ -101,9 +102,9 @@ async def fastapi_calculate_demand_to_nodes(
summary="计算需水量到区域分配",
description="将总需水量按区域特征分配到该区域内的节点"
)
async def fastapi_calculate_demand_to_region(
def fastapi_calculate_demand_to_region(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> dict[str, float]:
"""
计算需水量到区域分配。
@@ -116,7 +117,7 @@ async def fastapi_calculate_demand_to_region(
"region": 区域ID(str)
}
"""
props = await req.json()
props = payload
demand = props["demand"]
region = props["region"]
return calculate_demand_to_region(network, demand, region)
@@ -126,7 +127,7 @@ async def fastapi_calculate_demand_to_region(
summary="计算需水量到整网分配",
description="将需水量均匀分配到整个水网的所有需水节点"
)
async def fastapi_calculate_demand_to_network(
def fastapi_calculate_demand_to_network(
network: str = Query(..., description="管网名称（或数据库名称）"),
demand: float = Query(..., description="总需水量(m³/h)", gt=0)
) -> dict[str, float]:
app/api/v1/endpoints/network/general.py
+35 -34
View File
@@ -1,5 +1,6 @@
from fastapi import APIRouter, Request, Query, Path, Body
from typing import Any, List, Dict, Union
from typing import Any
from fastapi import APIRouter, Body, Query
from app.services.tjnetwork import (
ChangeSet,
delete_junction,
@@ -48,7 +49,7 @@ router = APIRouter()
summary="检查节点有效性",
description="检查指定ID是否为水网中的有效节点"
)
async def fastapi_is_node(
def fastapi_is_node(
network: str = Query(..., description="管网名称（或数据库名称）"),
node: str = Query(..., description="节点ID")
) -> bool:
@@ -60,7 +61,7 @@ async def fastapi_is_node(
summary="检查是否为接点",
description="检查指定ID是否为水网中的接点(需求点)"
)
async def fastapi_is_junction(
def fastapi_is_junction(
network: str = Query(..., description="管网名称（或数据库名称）"),
node: str = Query(..., description="节点ID")
) -> bool:
@@ -72,7 +73,7 @@ async def fastapi_is_junction(
summary="检查是否为水源",
description="检查指定ID是否为水网中的水源(水库/河流)"
)
async def fastapi_is_reservoir(
def fastapi_is_reservoir(
network: str = Query(..., description="管网名称（或数据库名称）"),
node: str = Query(..., description="节点ID")
) -> bool:
@@ -84,7 +85,7 @@ async def fastapi_is_reservoir(
summary="检查是否为蓄水池",
description="检查指定ID是否为水网中的蓄水池"
)
async def fastapi_is_tank(
def fastapi_is_tank(
network: str = Query(..., description="管网名称（或数据库名称）"),
node: str = Query(..., description="节点ID")
) -> bool:
@@ -96,7 +97,7 @@ async def fastapi_is_tank(
summary="检查管线有效性",
description="检查指定ID是否为水网中的有效管线"
)
async def fastapi_is_link(
def fastapi_is_link(
network: str = Query(..., description="管网名称（或数据库名称）"),
link: str = Query(..., description="管线ID")
) -> bool:
@@ -108,7 +109,7 @@ async def fastapi_is_link(
summary="检查是否为管道",
description="检查指定ID是否为水网中的管道"
)
async def fastapi_is_pipe(
def fastapi_is_pipe(
network: str = Query(..., description="管网名称（或数据库名称）"),
link: str = Query(..., description="管线ID")
) -> bool:
@@ -120,7 +121,7 @@ async def fastapi_is_pipe(
summary="检查是否为泵",
description="检查指定ID是否为水网中的泵"
)
async def fastapi_is_pump(
def fastapi_is_pump(
network: str = Query(..., description="管网名称（或数据库名称）"),
link: str = Query(..., description="管线ID")
) -> bool:
@@ -132,7 +133,7 @@ async def fastapi_is_pump(
summary="检查是否为阀门",
description="检查指定ID是否为水网中的阀门"
)
async def fastapi_is_valve(
def fastapi_is_valve(
network: str = Query(..., description="管网名称（或数据库名称）"),
link: str = Query(..., description="管线ID")
) -> bool:
@@ -144,7 +145,7 @@ async def fastapi_is_valve(
summary="获取节点类型",
description="获取指定节点的类型(接点/水源/蓄水池)"
)
async def fastapi_get_node_type(
def fastapi_get_node_type(
network: str = Query(..., description="管网名称（或数据库名称）"),
node: str = Query(..., description="节点ID")
) -> str:
@@ -156,7 +157,7 @@ async def fastapi_get_node_type(
summary="获取管线类型",
description="获取指定管线的类型(管道/泵/阀门)"
)
async def fastapi_get_link_type(
def fastapi_get_link_type(
network: str = Query(..., description="管网名称（或数据库名称）"),
link: str = Query(..., description="管线ID")
) -> str:
@@ -168,7 +169,7 @@ async def fastapi_get_link_type(
summary="获取元素类型",
description="获取指定元素的类型(节点或管线)"
)
async def fastapi_get_element_type(
def fastapi_get_element_type(
network: str = Query(..., description="管网名称（或数据库名称）"),
element: str = Query(..., description="元素ID")
) -> str:
@@ -180,7 +181,7 @@ async def fastapi_get_element_type(
summary="获取元素类型值",
description="获取指定元素的类型数值标识"
)
async def fastapi_get_element_type_value(
def fastapi_get_element_type_value(
network: str = Query(..., description="管网名称（或数据库名称）"),
element: str = Query(..., description="元素ID")
) -> int:
@@ -192,7 +193,7 @@ async def fastapi_get_element_type_value(
summary="获取所有节点",
description="获取指定水网中的所有节点ID列表"
)
async def fastapi_get_nodes(network: str = Query(..., description="管网名称（或数据库名称）")) -> list[str]:
def fastapi_get_nodes(network: str = Query(..., description="管网名称（或数据库名称）")) -> list[str]:
"""获取水网中所有节点的ID列表。"""
return get_nodes(network)
@@ -201,7 +202,7 @@ async def fastapi_get_nodes(network: str = Query(..., description="管网名称
summary="获取所有管线",
description="获取指定水网中的所有管线ID列表"
)
async def fastapi_get_links(network: str = Query(..., description="管网名称（或数据库名称）")) -> list[str]:
def fastapi_get_links(network: str = Query(..., description="管网名称（或数据库名称）")) -> list[str]:
"""获取水网中所有管线的ID列表。"""
return get_links(network)
@@ -226,7 +227,7 @@ def get_node_links_endpoint(
summary="获取节点属性",
description="获取指定节点的所有属性信息"
)
async def fast_get_node_properties(
def fast_get_node_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
node: str = Query(..., description="节点ID")
) -> dict[str, Any]:
@@ -238,7 +239,7 @@ async def fast_get_node_properties(
summary="获取管线属性",
description="获取指定管线的所有属性信息"
)
async def fast_get_link_properties(
def fast_get_link_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
link: str = Query(..., description="管线ID")
) -> dict[str, Any]:
@@ -250,7 +251,7 @@ async def fast_get_link_properties(
summary="获取SCADA点属性",
description="获取指定SCADA点的属性信息"
)
async def fast_get_scada_properties(
def fast_get_scada_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
scada: str = Query(..., description="SCADA点ID")
) -> dict[str, Any]:
@@ -262,7 +263,7 @@ async def fast_get_scada_properties(
summary="获取所有SCADA点属性",
description="获取指定水网中所有SCADA点的属性信息"
)
async def fast_get_all_scada_properties(
def fast_get_all_scada_properties(
network: str = Query(..., description="管网名称（或数据库名称）")
) -> list[dict[str, Any]]:
"""获取水网中所有SCADA点的属性列表。"""
@@ -273,7 +274,7 @@ async def fast_get_all_scada_properties(
summary="获取指定类型元素属性",
description="获取指定类型的元素属性信息"
)
async def fast_get_element_properties_with_type(
def fast_get_element_properties_with_type(
network: str = Query(..., description="管网名称（或数据库名称）"),
elementtype: str = Query(..., description="元素类型"),
element: str = Query(..., description="元素ID")
@@ -286,7 +287,7 @@ async def fast_get_element_properties_with_type(
summary="获取元素属性",
description="获取指定元素的属性信息"
)
async def fast_get_element_properties(
def fast_get_element_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
element: str = Query(..., description="元素ID")
) -> dict[str, Any]:
@@ -302,7 +303,7 @@ async def fast_get_element_properties(
summary="获取标题属性架构",
description="获取指定水网的标题(标题)属性架构定义"
)
async def fast_get_title_schema(
def fast_get_title_schema(
network: str = Query(..., description="管网名称（或数据库名称）")
) -> dict[str, dict[str, Any]]:
"""获取水网标题的属性架构。"""
@@ -313,7 +314,7 @@ async def fast_get_title_schema(
summary="获取水网标题属性",
description="获取指定水网的标题(Title)信息"
)
async def fast_get_title(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, Any]:
def fast_get_title(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, Any]:
"""获取水网的标题属性。"""
return get_title(network)
@@ -323,12 +324,12 @@ async def fast_get_title(network: str = Query(..., description="管网名称（
summary="设置水网标题属性",
description="设置指定水网的标题(Title)信息"
)
async def fastapi_set_title(
def fastapi_set_title(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""设置水网的标题属性。"""
props = await req.json()
props = payload
return set_title(network, ChangeSet(props))
############################################################
@@ -340,7 +341,7 @@ async def fastapi_set_title(
summary="获取状态属性架构",
description="获取指定水网的状态(Status)属性架构定义"
)
async def fastapi_get_status_schema(
def fastapi_get_status_schema(
network: str = Query(..., description="管网名称（或数据库名称）")
) -> dict[str, dict[str, Any]]:
"""获取水网状态的属性架构。"""
@@ -351,7 +352,7 @@ async def fastapi_get_status_schema(
summary="获取管线状态",
description="获取指定管线的状态信息"
)
async def fastapi_get_status(
def fastapi_get_status(
network: str = Query(..., description="管网名称（或数据库名称）"),
link: str = Query(..., description="管线ID")
) -> dict[str, Any]:
@@ -364,13 +365,13 @@ async def fastapi_get_status(
summary="设置管线状态",
description="设置指定管线的状态信息"
)
async def fastapi_set_status_properties(
def fastapi_set_status_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
link: str = Query(..., description="管线ID"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""设置管线的状态属性。"""
props = await req.json()
props = payload
ps = {"link": link} | props
return set_status(network, ChangeSet(ps))
@@ -384,7 +385,7 @@ async def fastapi_set_status_properties(
summary="删除节点",
description="删除指定的节点(接点/水源/蓄水池)"
)
async def fastapi_delete_node(
def fastapi_delete_node(
network: str = Query(..., description="管网名称（或数据库名称）"),
node: str = Query(..., description="节点ID")
) -> ChangeSet:
@@ -404,7 +405,7 @@ async def fastapi_delete_node(
summary="删除管线",
description="删除指定的管线(管道/泵/阀门)"
)
async def fastapi_delete_link(
def fastapi_delete_link(
network: str = Query(..., description="管网名称（或数据库名称）"),
link: str = Query(..., description="管线ID")
) -> ChangeSet:
app/api/v1/endpoints/network/geometry.py
+6 -6
View File
@@ -27,7 +27,7 @@ router = APIRouter()
# # example: set_coord(p, ChangeSet({'node': 'j1', 'x': 1.0, 'y': 2.0}))
# @router.post("/setcoord/", response_model=None)
# async def fastapi_set_coord(network: str, req: Request) -> ChangeSet:
# props = await req.json()
# props = payload
# return set_coord(network, ChangeSet(props))
@router.get(
@@ -35,7 +35,7 @@ router = APIRouter()
summary="获取节点坐标",
description="获取指定节点的地理坐标(X, Y)"
)
async def fastapi_get_node_coord(
def fastapi_get_node_coord(
network: str = Query(..., description="管网名称（或数据库名称）"),
node: str = Query(..., description="节点ID")
) -> dict[str, float] | None:
@@ -48,7 +48,7 @@ async def fastapi_get_node_coord(
summary="获取范围内的网络元素",
description="获取指定地理范围内的网络节点和管线"
)
async def fastapi_get_network_in_extent(
def fastapi_get_network_in_extent(
network: str = Query(..., description="管网名称（或数据库名称）"),
x1: float = Query(..., description="范围左下角X坐标", alias="x1"),
y1: float = Query(..., description="范围左下角Y坐标", alias="y1"),
@@ -63,7 +63,7 @@ async def fastapi_get_network_in_extent(
summary="获取主要节点坐标",
description="获取直径大于等于指定值的节点坐标"
)
async def fastapi_get_majornode_coords(
def fastapi_get_majornode_coords(
network: str = Query(..., description="管网名称（或数据库名称）"),
diameter: int = Query(..., description="最小直径(mm)", gt=0)
) -> dict[str, dict[str, float]]:
@@ -75,7 +75,7 @@ async def fastapi_get_majornode_coords(
summary="获取主要管道节点",
description="获取直径大于等于指定值的管道的节点ID"
)
async def fastapi_get_major_pipe_nodes(
def fastapi_get_major_pipe_nodes(
network: str = Query(..., description="管网名称（或数据库名称）"),
diameter: int = Query(..., description="最小直径(mm)", gt=0)
) -> list[str] | None:
@@ -87,7 +87,7 @@ async def fastapi_get_major_pipe_nodes(
summary="获取网络管线节点",
description="获取指定水网所有管线的起点和终点节点"
)
async def fastapi_get_network_link_nodes(
def fastapi_get_network_link_nodes(
network: str = Query(..., description="管网名称（或数据库名称）")
) -> list[str] | None:
"""获取网络中所有管线的连接节点。"""
app/api/v1/endpoints/network/junctions.py
+23 -22
View File
@@ -1,5 +1,6 @@
from fastapi import APIRouter, Request, Query, Path, Body
from typing import Any, List, Dict, Union
from typing import Any
from fastapi import APIRouter, Body, Query
from app.services.tjnetwork import (
ChangeSet,
add_junction,
@@ -13,7 +14,7 @@ from app.services.tjnetwork import (
router = APIRouter()
@router.get("/network-schemas/junction", summary="获取节点架构", description="获取指定项目的节点属性架构和数据类型定义。")
async def fast_get_junction_schema(
def fast_get_junction_schema(
network: str = Query(..., description="管网名称（或数据库名称）")
) -> dict[str, dict[str, Any]]:
"""
@@ -27,7 +28,7 @@ async def fast_get_junction_schema(
return get_junction_schema(network)
@router.post("/junctions", response_model=None, summary="添加节点", description="在供水网络中添加新的节点，指定节点ID和空间坐标。")
async def fastapi_add_junction(
def fastapi_add_junction(
network: str = Query(..., description="管网名称（或数据库名称）"),
junction: str = Query(..., description="节点 ID"),
x: float = Query(..., description="X 坐标"),
@@ -51,7 +52,7 @@ async def fastapi_add_junction(
return add_junction(network, ChangeSet(ps))
@router.delete("/junctions", response_model=None, summary="删除节点", description="从供水网络中删除指定的节点。")
async def fastapi_delete_junction(
def fastapi_delete_junction(
network: str = Query(..., description="管网名称（或数据库名称）"),
junction: str = Query(..., description="节点 ID")
) -> ChangeSet:
@@ -69,7 +70,7 @@ async def fastapi_delete_junction(
return delete_junction(network, ChangeSet(ps))
@router.get("/junctions/elevation", summary="获取节点标高", description="获取指定节点的标高（海拔高度）。")
async def fastapi_get_junction_elevation(
def fastapi_get_junction_elevation(
network: str = Query(..., description="管网名称（或数据库名称）"),
junction: str = Query(..., description="节点 ID")
) -> float:
@@ -87,7 +88,7 @@ async def fastapi_get_junction_elevation(
return ps["elevation"]
@router.get("/junctions/x", summary="获取节点 X 坐标", description="获取指定节点的 X 坐标值。")
async def fastapi_get_junction_x(
def fastapi_get_junction_x(
network: str = Query(..., description="管网名称（或数据库名称）"),
junction: str = Query(..., description="节点 ID")
) -> float:
@@ -105,7 +106,7 @@ async def fastapi_get_junction_x(
return ps["x"]
@router.get("/junctions/y", summary="获取节点 Y 坐标", description="获取指定节点的 Y 坐标值。")
async def fastapi_get_junction_y(
def fastapi_get_junction_y(
network: str = Query(..., description="管网名称（或数据库名称）"),
junction: str = Query(..., description="节点 ID")
) -> float:
@@ -123,7 +124,7 @@ async def fastapi_get_junction_y(
return ps["y"]
@router.get("/junctions/coord", summary="获取节点坐标", description="获取指定节点的 X 和 Y 坐标。")
async def fastapi_get_junction_coord(
def fastapi_get_junction_coord(
network: str = Query(..., description="管网名称（或数据库名称）"),
junction: str = Query(..., description="节点 ID")
) -> dict[str, float]:
@@ -142,7 +143,7 @@ async def fastapi_get_junction_coord(
return coord
@router.get("/junctions/demand", summary="获取节点需水量", description="获取指定节点的需水量。")
async def fastapi_get_junction_demand(
def fastapi_get_junction_demand(
network: str = Query(..., description="管网名称（或数据库名称）"),
junction: str = Query(..., description="节点 ID")
) -> float:
@@ -160,7 +161,7 @@ async def fastapi_get_junction_demand(
return ps["demand"]
@router.get("/junctions/pattern", summary="获取节点需水模式", description="获取指定节点的需水模式标识。")
async def fastapi_get_junction_pattern(
def fastapi_get_junction_pattern(
network: str = Query(..., description="管网名称（或数据库名称）"),
junction: str = Query(..., description="节点 ID")
) -> str:
@@ -178,7 +179,7 @@ async def fastapi_get_junction_pattern(
return ps["pattern"]
@router.patch("/junctions/elevation", response_model=None, summary="设置节点标高", description="设置指定节点的标高值。")
async def fastapi_set_junction_elevation(
def fastapi_set_junction_elevation(
network: str = Query(..., description="管网名称（或数据库名称）"),
junction: str = Query(..., description="节点 ID"),
elevation: float = Query(..., description="标高（海拔高度）")
@@ -198,7 +199,7 @@ async def fastapi_set_junction_elevation(
return set_junction(network, ChangeSet(ps))
@router.patch("/junctions/x", response_model=None, summary="设置节点 X 坐标", description="设置指定节点的 X 坐标值。")
async def fastapi_set_junction_x(
def fastapi_set_junction_x(
network: str = Query(..., description="管网名称（或数据库名称）"),
junction: str = Query(..., description="节点 ID"),
x: float = Query(..., description="X 坐标值")
@@ -218,7 +219,7 @@ async def fastapi_set_junction_x(
return set_junction(network, ChangeSet(ps))
@router.patch("/junctions/y", response_model=None, summary="设置节点 Y 坐标", description="设置指定节点的 Y 坐标值。")
async def fastapi_set_junction_y(
def fastapi_set_junction_y(
network: str = Query(..., description="管网名称（或数据库名称）"),
junction: str = Query(..., description="节点 ID"),
y: float = Query(..., description="Y 坐标值")
@@ -238,7 +239,7 @@ async def fastapi_set_junction_y(
return set_junction(network, ChangeSet(ps))
@router.patch("/junctions/coord", response_model=None, summary="设置节点坐标", description="设置指定节点的 X 和 Y 坐标。")
async def fastapi_set_junction_coord(
def fastapi_set_junction_coord(
network: str = Query(..., description="管网名称（或数据库名称）"),
junction: str = Query(..., description="节点 ID"),
x: float = Query(..., description="X 坐标值"),
@@ -260,7 +261,7 @@ async def fastapi_set_junction_coord(
return set_junction(network, ChangeSet(ps))
@router.patch("/junctions/demand", response_model=None, summary="设置节点需水量", description="设置指定节点的需水量。")
async def fastapi_set_junction_demand(
def fastapi_set_junction_demand(
network: str = Query(..., description="管网名称（或数据库名称）"),
junction: str = Query(..., description="节点 ID"),
demand: float = Query(..., description="需水量值")
@@ -280,7 +281,7 @@ async def fastapi_set_junction_demand(
return set_junction(network, ChangeSet(ps))
@router.patch("/junctions/pattern", response_model=None, summary="设置节点需水模式", description="设置指定节点的需水模式标识。")
async def fastapi_set_junction_pattern(
def fastapi_set_junction_pattern(
network: str = Query(..., description="管网名称（或数据库名称）"),
junction: str = Query(..., description="节点 ID"),
pattern: str = Query(..., description="需水模式标识")
@@ -300,7 +301,7 @@ async def fastapi_set_junction_pattern(
return set_junction(network, ChangeSet(ps))
@router.get("/junctions/properties", summary="获取节点属性", description="获取指定节点的所有属性信息。")
async def fastapi_get_junction_properties(
def fastapi_get_junction_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
junction: str = Query(..., description="节点 ID")
) -> dict[str, Any]:
@@ -317,7 +318,7 @@ async def fastapi_get_junction_properties(
return get_junction(network, junction)
@router.get("/junctions", summary="获取所有节点属性", description="获取指定项目中所有节点的属性信息。")
async def fastapi_get_all_junction_properties(
def fastapi_get_all_junction_properties(
network: str = Query(..., description="管网名称（或数据库名称）")
) -> list[dict[str, Any]]:
"""
@@ -336,10 +337,10 @@ async def fastapi_get_all_junction_properties(
return results
@router.patch("/junctions/properties", response_model=None, summary="批量设置节点属性", description="批量设置指定节点的多个属性。")
async def fastapi_set_junction_properties(
def fastapi_set_junction_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
junction: str = Query(..., description="节点 ID"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""
批量设置节点属性。
@@ -354,6 +355,6 @@ async def fastapi_set_junction_properties(
Returns:
ChangeSet: 包含变更信息的结果
"""
props = await req.json()
props = payload
ps = {"id": junction} | props
return set_junction(network, ChangeSet(ps))
app/api/v1/endpoints/network/pipes.py
+25 -24
View File
@@ -1,5 +1,6 @@
from fastapi import APIRouter, Request, Query, Path, Body
from typing import Any, List, Dict, Union
from typing import Any
from fastapi import APIRouter, Body, Query
from app.services.tjnetwork import (
ChangeSet,
PIPE_STATUS_OPEN,
@@ -14,7 +15,7 @@ from app.services.tjnetwork import (
router = APIRouter()
@router.get("/network-schemas/pipe", summary="获取管道模式", description="获取管道对象的模式定义，包含所有可用字段及其类型")
async def fastapi_get_pipe_schema(
def fastapi_get_pipe_schema(
network: str = Query(..., description="管网名称（或数据库名称）")
) -> dict[str, dict[str, Any]]:
"""
@@ -29,7 +30,7 @@ async def fastapi_get_pipe_schema(
return get_pipe_schema(network)
@router.post("/pipes", response_model=None, summary="添加管道", description="向网络中添加新的管道，需要提供管道的基本参数如长度、管径、粗糙度等")
async def fastapi_add_pipe(
def fastapi_add_pipe(
network: str = Query(..., description="管网名称（或数据库名称）"),
pipe: str = Query(..., description="管道标识符"),
node1: str = Query(..., description="管道起始节点ID"),
@@ -70,7 +71,7 @@ async def fastapi_add_pipe(
return add_pipe(network, ChangeSet(ps))
@router.delete("/pipes", response_model=None, summary="删除管道", description="从网络中删除指定的管道")
async def fastapi_delete_pipe(
def fastapi_delete_pipe(
network: str = Query(..., description="管网名称（或数据库名称）"),
pipe: str = Query(..., description="要删除的管道ID")
) -> ChangeSet:
@@ -88,7 +89,7 @@ async def fastapi_delete_pipe(
return delete_pipe(network, ChangeSet(ps))
@router.get("/pipes/node1", summary="获取管道起始节点", description="获取指定管道的起始节点ID")
async def fastapi_get_pipe_node1(
def fastapi_get_pipe_node1(
network: str = Query(..., description="管网名称（或数据库名称）"),
pipe: str = Query(..., description="管道ID")
) -> str | None:
@@ -106,7 +107,7 @@ async def fastapi_get_pipe_node1(
return ps["node1"]
@router.get("/pipes/node2", summary="获取管道终止节点", description="获取指定管道的终止节点ID")
async def fastapi_get_pipe_node2(
def fastapi_get_pipe_node2(
network: str = Query(..., description="管网名称（或数据库名称）"),
pipe: str = Query(..., description="管道ID")
) -> str | None:
@@ -124,7 +125,7 @@ async def fastapi_get_pipe_node2(
return ps["node2"]
@router.get("/pipes/length", summary="获取管道长度", description="获取指定管道的长度")
async def fastapi_get_pipe_length(
def fastapi_get_pipe_length(
network: str = Query(..., description="管网名称（或数据库名称）"),
pipe: str = Query(..., description="管道ID")
) -> float | None:
@@ -142,7 +143,7 @@ async def fastapi_get_pipe_length(
return ps["length"]
@router.get("/pipes/diameter", summary="获取管道管径", description="获取指定管道的管径")
async def fastapi_get_pipe_diameter(
def fastapi_get_pipe_diameter(
network: str = Query(..., description="管网名称（或数据库名称）"),
pipe: str = Query(..., description="管道ID")
) -> float | None:
@@ -160,7 +161,7 @@ async def fastapi_get_pipe_diameter(
return ps["diameter"]
@router.get("/pipes/roughness", summary="获取管道粗糙度", description="获取指定管道的粗糙度")
async def fastapi_get_pipe_roughness(
def fastapi_get_pipe_roughness(
network: str = Query(..., description="管网名称（或数据库名称）"),
pipe: str = Query(..., description="管道ID")
) -> float | None:
@@ -178,7 +179,7 @@ async def fastapi_get_pipe_roughness(
return ps["roughness"]
@router.get("/pipes/minor-loss", summary="获取管道局部阻力系数", description="获取指定管道的局部阻力系数")
async def fastapi_get_pipe_minor_loss(
def fastapi_get_pipe_minor_loss(
network: str = Query(..., description="管网名称（或数据库名称）"),
pipe: str = Query(..., description="管道ID")
) -> float | None:
@@ -196,7 +197,7 @@ async def fastapi_get_pipe_minor_loss(
return ps["minor_loss"]
@router.get("/pipes/status", summary="获取管道状态", description="获取指定管道的状态（开启或关闭）")
async def fastapi_get_pipe_status(
def fastapi_get_pipe_status(
network: str = Query(..., description="管网名称（或数据库名称）"),
pipe: str = Query(..., description="管道ID")
) -> str | None:
@@ -214,7 +215,7 @@ async def fastapi_get_pipe_status(
return ps["status"]
@router.patch("/pipes/node1", response_model=None, summary="设置管道起始节点", description="设置指定管道的起始节点")
async def fastapi_set_pipe_node1(
def fastapi_set_pipe_node1(
network: str = Query(..., description="管网名称（或数据库名称）"),
pipe: str = Query(..., description="管道ID"),
node1: str = Query(..., description="新的起始节点ID")
@@ -234,7 +235,7 @@ async def fastapi_set_pipe_node1(
return set_pipe(network, ChangeSet(ps))
@router.patch("/pipes/node2", response_model=None, summary="设置管道终止节点", description="设置指定管道的终止节点")
async def fastapi_set_pipe_node2(
def fastapi_set_pipe_node2(
network: str = Query(..., description="管网名称（或数据库名称）"),
pipe: str = Query(..., description="管道ID"),
node2: str = Query(..., description="新的终止节点ID")
@@ -254,7 +255,7 @@ async def fastapi_set_pipe_node2(
return set_pipe(network, ChangeSet(ps))
@router.patch("/pipes/length", response_model=None, summary="设置管道长度", description="设置指定管道的长度")
async def fastapi_set_pipe_length(
def fastapi_set_pipe_length(
network: str = Query(..., description="管网名称（或数据库名称）"),
pipe: str = Query(..., description="管道ID"),
length: float = Query(..., description="新的管道长度（单位：米）")
@@ -274,7 +275,7 @@ async def fastapi_set_pipe_length(
return set_pipe(network, ChangeSet(ps))
@router.patch("/pipes/diameter", response_model=None, summary="设置管道管径", description="设置指定管道的管径")
async def fastapi_set_pipe_diameter(
def fastapi_set_pipe_diameter(
network: str = Query(..., description="管网名称（或数据库名称）"),
pipe: str = Query(..., description="管道ID"),
diameter: float = Query(..., description="新的管道管径（单位：毫米）")
@@ -294,7 +295,7 @@ async def fastapi_set_pipe_diameter(
return set_pipe(network, ChangeSet(ps))
@router.patch("/pipes/roughness", response_model=None, summary="设置管道粗糙度", description="设置指定管道的粗糙度")
async def fastapi_set_pipe_roughness(
def fastapi_set_pipe_roughness(
network: str = Query(..., description="管网名称（或数据库名称）"),
pipe: str = Query(..., description="管道ID"),
roughness: float = Query(..., description="新的管道粗糙度值")
@@ -314,7 +315,7 @@ async def fastapi_set_pipe_roughness(
return set_pipe(network, ChangeSet(ps))
@router.patch("/pipes/minor-loss", response_model=None, summary="设置管道局部阻力系数", description="设置指定管道的局部阻力系数")
async def fastapi_set_pipe_minor_loss(
def fastapi_set_pipe_minor_loss(
network: str = Query(..., description="管网名称（或数据库名称）"),
pipe: str = Query(..., description="管道ID"),
minor_loss: float = Query(..., description="新的局部阻力系数值")
@@ -334,7 +335,7 @@ async def fastapi_set_pipe_minor_loss(
return set_pipe(network, ChangeSet(ps))
@router.patch("/pipes/status", response_model=None, summary="设置管道状态", description="设置指定管道的状态（开启或关闭）")
async def fastapi_set_pipe_status(
def fastapi_set_pipe_status(
network: str = Query(..., description="管网名称（或数据库名称）"),
pipe: str = Query(..., description="管道ID"),
status: str = Query(..., description="新的管道状态（开启/关闭）")
@@ -354,7 +355,7 @@ async def fastapi_set_pipe_status(
return set_pipe(network, ChangeSet(ps))
@router.get("/pipes/properties", summary="获取管道属性", description="获取指定管道的所有属性信息")
async def fastapi_get_pipe_properties(
def fastapi_get_pipe_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
pipe: str = Query(..., description="管道ID")
) -> dict[str, Any]:
@@ -371,7 +372,7 @@ async def fastapi_get_pipe_properties(
return get_pipe(network, pipe)
@router.get("/pipes", summary="获取所有管道属性", description="获取网络中所有管道的属性信息列表")
async def fastapi_get_all_pipe_properties(
def fastapi_get_all_pipe_properties(
network: str = Query(..., description="管网名称（或数据库名称）")
) -> list[dict[str, Any]]:
"""
@@ -388,10 +389,10 @@ async def fastapi_get_all_pipe_properties(
return results
@router.patch("/pipes/properties", response_model=None, summary="设置管道属性", description="批量设置指定管道的多个属性")
async def fastapi_set_pipe_properties(
def fastapi_set_pipe_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
pipe: str = Query(..., description="管道ID"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""
批量设置管道属性。
@@ -404,6 +405,6 @@ async def fastapi_set_pipe_properties(
Returns:
ChangeSet对象，包含本次修改的变更信息
"""
props = await req.json()
props = payload
ps = {"id": pipe} | props
return set_pipe(network, ChangeSet(ps))
app/api/v1/endpoints/network/pumps.py
+15 -14
View File
@@ -1,5 +1,6 @@
from fastapi import APIRouter, Request, Query, Path, Body
from typing import Any, List, Dict, Union
from typing import Any
from fastapi import APIRouter, Body, Query
from app.services.tjnetwork import (
ChangeSet,
add_pump,
@@ -13,7 +14,7 @@ from app.services.tjnetwork import (
router = APIRouter()
@router.get("/network-schemas/pump", summary="获取水泵模式", description="获取水泵对象的模式定义，包含所有可用字段及其类型")
async def fastapi_get_pump_schema(
def fastapi_get_pump_schema(
network: str = Query(..., description="管网名称（或数据库名称）")
) -> dict[str, dict[str, Any]]:
"""
@@ -28,7 +29,7 @@ async def fastapi_get_pump_schema(
return get_pump_schema(network)
@router.post("/pumps", response_model=None, summary="添加水泵", description="向网络中添加新的水泵，需要提供水泵的基本参数如功率等")
async def fastapi_add_pump(
def fastapi_add_pump(
network: str = Query(..., description="管网名称（或数据库名称）"),
pump: str = Query(..., description="水泵标识符"),
node1: str = Query(..., description="水泵起始节点ID"),
@@ -52,7 +53,7 @@ async def fastapi_add_pump(
return add_pump(network, ChangeSet(ps))
@router.delete("/pumps", response_model=None, summary="删除水泵", description="从网络中删除指定的水泵")
async def fastapi_delete_pump(
def fastapi_delete_pump(
network: str = Query(..., description="管网名称（或数据库名称）"),
pump: str = Query(..., description="要删除的水泵ID")
) -> ChangeSet:
@@ -70,7 +71,7 @@ async def fastapi_delete_pump(
return delete_pump(network, ChangeSet(ps))
@router.get("/pumps/node1", summary="获取水泵起始节点", description="获取指定水泵的起始节点ID")
async def fastapi_get_pump_node1(
def fastapi_get_pump_node1(
network: str = Query(..., description="管网名称（或数据库名称）"),
pump: str = Query(..., description="水泵ID")
) -> str | None:
@@ -88,7 +89,7 @@ async def fastapi_get_pump_node1(
return ps["node1"]
@router.get("/pumps/node2", summary="获取水泵终止节点", description="获取指定水泵的终止节点ID")
async def fastapi_get_pump_node2(
def fastapi_get_pump_node2(
network: str = Query(..., description="管网名称（或数据库名称）"),
pump: str = Query(..., description="水泵ID")
) -> str | None:
@@ -106,7 +107,7 @@ async def fastapi_get_pump_node2(
return ps["node2"]
@router.patch("/pumps/node1", response_model=None, summary="设置水泵起始节点", description="设置指定水泵的起始节点")
async def fastapi_set_pump_node1(
def fastapi_set_pump_node1(
network: str = Query(..., description="管网名称（或数据库名称）"),
pump: str = Query(..., description="水泵ID"),
node1: str = Query(..., description="新的起始节点ID")
@@ -126,7 +127,7 @@ async def fastapi_set_pump_node1(
return set_pump(network, ChangeSet(ps))
@router.patch("/pumps/node2", response_model=None, summary="设置水泵终止节点", description="设置指定水泵的终止节点")
async def fastapi_set_pump_node2(
def fastapi_set_pump_node2(
network: str = Query(..., description="管网名称（或数据库名称）"),
pump: str = Query(..., description="水泵ID"),
node2: str = Query(..., description="新的终止节点ID")
@@ -146,7 +147,7 @@ async def fastapi_set_pump_node2(
return set_pump(network, ChangeSet(ps))
@router.get("/pumps/properties", summary="获取水泵属性", description="获取指定水泵的所有属性信息")
async def fastapi_get_pump_properties(
def fastapi_get_pump_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
pump: str = Query(..., description="水泵ID")
) -> dict[str, Any]:
@@ -163,7 +164,7 @@ async def fastapi_get_pump_properties(
return get_pump(network, pump)
@router.get("/pumps", summary="获取所有水泵属性", description="获取网络中所有水泵的属性信息列表")
async def fastapi_get_all_pump_properties(
def fastapi_get_all_pump_properties(
network: str = Query(..., description="管网名称（或数据库名称）")
) -> list[dict[str, Any]]:
"""
@@ -180,10 +181,10 @@ async def fastapi_get_all_pump_properties(
return results
@router.patch("/pumps/properties", response_model=None, summary="设置水泵属性", description="批量设置指定水泵的多个属性")
async def fastapi_set_pump_properties(
def fastapi_set_pump_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
pump: str = Query(..., description="水泵ID"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""
批量设置水泵属性。
@@ -196,6 +197,6 @@ async def fastapi_set_pump_properties(
Returns:
ChangeSet对象，包含本次修改的变更信息
"""
props = await req.json()
props = payload
ps = {"id": pump} | props
return set_pump(network, ChangeSet(ps))
app/api/v1/endpoints/network/regions.py
+13 -14
View File
@@ -1,6 +1,6 @@
from typing import Any
from fastapi import APIRouter, Query, Request
from fastapi import APIRouter, Body, Query
from app.services.tjnetwork import (
ChangeSet,
@@ -18,21 +18,21 @@ router = APIRouter()
@router.get("/network-schemas/region", summary="获取区域属性架构")
async def get_region_schema_endpoint(
def get_region_schema_endpoint(
network: str = Query(..., description="管网名称（或数据库名称）"),
) -> dict[str, dict[str, Any]]:
return get_region_schema(network)
@router.get("/regions", summary="获取区域列表")
async def get_regions_endpoint(
def get_regions_endpoint(
network: str = Query(..., description="管网名称（或数据库名称）"),
) -> list[dict[str, Any]]:
return [get_region(network, region_id) for region_id in get_regions(network)]
@router.get("/regions/detail", summary="获取区域信息")
async def get_region_endpoint(
def get_region_endpoint(
network: str = Query(..., description="管网名称（或数据库名称）"),
id: str = Query(..., description="区域 ID"),
) -> dict[str, Any]:
@@ -40,7 +40,7 @@ async def get_region_endpoint(
@router.get("/regions/nodes", summary="获取区域节点")
async def get_region_nodes_endpoint(
def get_region_nodes_endpoint(
network: str = Query(..., description="管网名称（或数据库名称）"),
id: str = Query(..., description="区域 ID"),
) -> list[str]:
@@ -48,26 +48,25 @@ async def get_region_nodes_endpoint(
@router.patch("/regions", summary="修改区域", response_model=None)
async def set_region_endpoint(
def set_region_endpoint(
network: str = Query(..., description="管网名称（或数据库名称）"),
request: Request = None,
payload: dict[str, Any] = Body(...),
) -> ChangeSet:
return set_region(network, ChangeSet(await request.json()))
return set_region(network, ChangeSet(payload))
@router.post("/regions", summary="添加区域", response_model=None)
async def add_region_endpoint(
def add_region_endpoint(
network: str = Query(..., description="管网名称（或数据库名称）"),
request: Request = None,
payload: dict[str, Any] = Body(...),
) -> ChangeSet:
payload = await request.json()
payload["boundary"] = [tuple(point[:2]) for point in payload.get("boundary", [])]
return add_region(network, ChangeSet(payload))
@router.delete("/regions", summary="删除区域", response_model=None)
async def delete_region_endpoint(
def delete_region_endpoint(
network: str = Query(..., description="管网名称（或数据库名称）"),
request: Request = None,
payload: dict[str, Any] = Body(...),
) -> ChangeSet:
return delete_region(network, ChangeSet(await request.json()))
return delete_region(network, ChangeSet(payload))
app/api/v1/endpoints/network/reservoirs.py
+21 -20
View File
@@ -1,5 +1,6 @@
from fastapi import APIRouter, Request, Query, Path, Body
from typing import Any, List, Dict, Union
from typing import Any
from fastapi import APIRouter, Body, Query
from app.services.tjnetwork import (
ChangeSet,
add_reservoir,
@@ -17,7 +18,7 @@ router = APIRouter()
summary="获取水库模式",
description="获取指定供水网络中所有水库的模式/属性字段定义"
)
async def fast_get_reservoir_schema(
def fast_get_reservoir_schema(
network: str = Query(..., description="管网名称（或数据库名称）")
) -> dict[str, dict[str, Any]]:
"""
@@ -39,7 +40,7 @@ async def fast_get_reservoir_schema(
summary="添加水库",
description="在指定供水网络中添加新的水库/水源节点"
)
async def fastapi_add_reservoir(
def fastapi_add_reservoir(
network: str = Query(..., description="管网名称（或数据库名称）"),
reservoir: str = Query(..., description="水库的唯一标识符"),
x: float = Query(..., description="水库的X坐标"),
@@ -70,7 +71,7 @@ async def fastapi_add_reservoir(
summary="删除水库",
description="从指定供水网络中删除指定的水库/水源节点"
)
async def fastapi_delete_reservoir(
def fastapi_delete_reservoir(
network: str = Query(..., description="管网名称（或数据库名称）"),
reservoir: str = Query(..., description="要删除的水库的唯一标识符")
) -> ChangeSet:
@@ -94,7 +95,7 @@ async def fastapi_delete_reservoir(
summary="获取水库水头",
description="获取指定水库的供水水头/总水头值"
)
async def fastapi_get_reservoir_head(
def fastapi_get_reservoir_head(
network: str = Query(..., description="管网名称（或数据库名称）"),
reservoir: str = Query(..., description="水库的唯一标识符")
) -> float | None:
@@ -118,7 +119,7 @@ async def fastapi_get_reservoir_head(
summary="获取水库模式",
description="获取指定水库的运行模式/供水模式"
)
async def fastapi_get_reservoir_pattern(
def fastapi_get_reservoir_pattern(
network: str = Query(..., description="管网名称（或数据库名称）"),
reservoir: str = Query(..., description="水库的唯一标识符")
) -> str | None:
@@ -142,7 +143,7 @@ async def fastapi_get_reservoir_pattern(
summary="获取水库X坐标",
description="获取指定水库的X坐标位置"
)
async def fastapi_get_reservoir_x(
def fastapi_get_reservoir_x(
network: str = Query(..., description="管网名称（或数据库名称）"),
reservoir: str = Query(..., description="水库的唯一标识符")
) -> dict[str, float] | None:
@@ -166,7 +167,7 @@ async def fastapi_get_reservoir_x(
summary="获取水库Y坐标",
description="获取指定水库的Y坐标位置"
)
async def fastapi_get_reservoir_y(
def fastapi_get_reservoir_y(
network: str = Query(..., description="管网名称（或数据库名称）"),
reservoir: str = Query(..., description="水库的唯一标识符")
) -> dict[str, float] | None:
@@ -190,7 +191,7 @@ async def fastapi_get_reservoir_y(
summary="获取水库坐标",
description="获取指定水库的平面坐标（X和Y坐标）"
)
async def fastapi_get_reservoir_coord(
def fastapi_get_reservoir_coord(
network: str = Query(..., description="管网名称（或数据库名称）"),
reservoir: str = Query(..., description="水库的唯一标识符")
) -> dict[str, float] | None:
@@ -216,7 +217,7 @@ async def fastapi_get_reservoir_coord(
summary="设置水库水头",
description="更新指定水库的供水水头/总水头值"
)
async def fastapi_set_reservoir_head(
def fastapi_set_reservoir_head(
network: str = Query(..., description="管网名称（或数据库名称）"),
reservoir: str = Query(..., description="水库的唯一标识符"),
head: float = Query(..., description="新的水头值（米）")
@@ -243,7 +244,7 @@ async def fastapi_set_reservoir_head(
summary="设置水库模式",
description="更新指定水库的运行模式/供水模式"
)
async def fastapi_set_reservoir_pattern(
def fastapi_set_reservoir_pattern(
network: str = Query(..., description="管网名称（或数据库名称）"),
reservoir: str = Query(..., description="水库的唯一标识符"),
pattern: str = Query(..., description="新的运行模式")
@@ -270,7 +271,7 @@ async def fastapi_set_reservoir_pattern(
summary="设置水库X坐标",
description="更新指定水库的X坐标位置"
)
async def fastapi_set_reservoir_x(
def fastapi_set_reservoir_x(
network: str = Query(..., description="管网名称（或数据库名称）"),
reservoir: str = Query(..., description="水库的唯一标识符"),
x: float = Query(..., description="新的X坐标值")
@@ -297,7 +298,7 @@ async def fastapi_set_reservoir_x(
summary="设置水库Y坐标",
description="更新指定水库的Y坐标位置"
)
async def fastapi_set_reservoir_y(
def fastapi_set_reservoir_y(
network: str = Query(..., description="管网名称（或数据库名称）"),
reservoir: str = Query(..., description="水库的唯一标识符"),
y: float = Query(..., description="新的Y坐标值")
@@ -324,7 +325,7 @@ async def fastapi_set_reservoir_y(
summary="设置水库坐标",
description="更新指定水库的平面坐标（X和Y坐标）"
)
async def fastapi_set_reservoir_coord(
def fastapi_set_reservoir_coord(
network: str = Query(..., description="管网名称（或数据库名称）"),
reservoir: str = Query(..., description="水库的唯一标识符"),
x: float = Query(..., description="新的X坐标值"),
@@ -352,7 +353,7 @@ async def fastapi_set_reservoir_coord(
summary="获取水库属性",
description="获取指定水库的所有属性"
)
async def fastapi_get_reservoir_properties(
def fastapi_get_reservoir_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
reservoir: str = Query(..., description="水库的唯一标识符")
) -> dict[str, Any]:
@@ -375,7 +376,7 @@ async def fastapi_get_reservoir_properties(
summary="获取所有水库属性",
description="获取指定供水网络中所有水库的属性"
)
async def fastapi_get_all_reservoir_properties(
def fastapi_get_all_reservoir_properties(
network: str = Query(..., description="管网名称（或数据库名称）")
) -> list[dict[str, Any]]:
"""
@@ -398,10 +399,10 @@ async def fastapi_get_all_reservoir_properties(
summary="设置水库属性",
description="批量更新指定水库的多个属性"
)
async def fastapi_set_reservoir_properties(
def fastapi_set_reservoir_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
reservoir: str = Query(..., description="水库的唯一标识符"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""
设置水库的多个属性。
@@ -416,6 +417,6 @@ async def fastapi_set_reservoir_properties(
Returns:
包含操作变更集的ChangeSet对象
"""
props = await req.json()
props = payload
ps = {"id": reservoir} | props
return set_reservoir(network, ChangeSet(ps))
app/api/v1/endpoints/network/tags.py
+9 -8
View File
@@ -1,5 +1,6 @@
from fastapi import APIRouter, Request, Query, Path, Body
from typing import Any, List, Dict, Union
from typing import Any
from fastapi import APIRouter, Body, Query
from app.services.tjnetwork import (
ChangeSet,
get_tag,
@@ -19,7 +20,7 @@ router = APIRouter()
summary="获取标签属性架构",
description="获取指定水网的标签(Tag)属性架构定义"
)
async def fastapi_get_tag_schema(
def fastapi_get_tag_schema(
network: str = Query(..., description="管网名称（或数据库名称）")
) -> dict[str, dict[str, Any]]:
"""获取标签的属性架构。"""
@@ -30,7 +31,7 @@ async def fastapi_get_tag_schema(
summary="获取标签信息",
description="获取指定类型和ID的标签信息"
)
async def fastapi_get_tag(
def fastapi_get_tag(
network: str = Query(..., description="管网名称（或数据库名称）"),
t_type: str = Query(..., description="标签类型"),
id: str = Query(..., description="元素ID")
@@ -43,7 +44,7 @@ async def fastapi_get_tag(
summary="获取所有标签",
description="获取指定水网中的所有标签信息"
)
async def fastapi_get_tags(
def fastapi_get_tags(
network: str = Query(..., description="管网名称（或数据库名称）")
) -> list[dict[str, Any]]:
"""获取水网中所有标签的列表。"""
@@ -56,10 +57,10 @@ async def fastapi_get_tags(
summary="设置标签",
description="为指定元素设置或修改标签信息"
)
async def fastapi_set_tag(
def fastapi_set_tag(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""设置标签信息。"""
props = await req.json()
props = payload
return set_tag(network, ChangeSet(props))
app/api/v1/endpoints/network/tanks.py
+33 -32
View File
@@ -1,5 +1,6 @@
from fastapi import APIRouter, Request, Query, Path, Body
from typing import Any, List, Dict, Union
from typing import Any
from fastapi import APIRouter, Body, Query
from app.services.tjnetwork import (
ChangeSet,
add_tank,
@@ -13,7 +14,7 @@ from app.services.tjnetwork import (
router = APIRouter()
@router.get("/network-schemas/tank", summary="获取水箱模式", description="获取指定网络的水箱数据结构模式定义")
async def fast_get_tank_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
def fast_get_tank_schema(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, dict[str, Any]]:
"""
获取水箱的数据结构模式。
@@ -26,7 +27,7 @@ async def fast_get_tank_schema(network: str = Query(..., description="管网名
return get_tank_schema(network)
@router.post("/tanks", summary="新增水箱", description="向指定网络中新增一个水箱", response_model=None)
async def fastapi_add_tank(
def fastapi_add_tank(
network: str = Query(..., description="管网名称（或数据库名称）"),
tank: str = Query(..., description="水箱ID"),
x: float = Query(..., description="X坐标"),
@@ -70,7 +71,7 @@ async def fastapi_add_tank(
return add_tank(network, ChangeSet(ps))
@router.delete("/tanks", summary="删除水箱", description="删除指定网络中的水箱", response_model=None)
async def fastapi_delete_tank(
def fastapi_delete_tank(
network: str = Query(..., description="管网名称（或数据库名称）"),
tank: str = Query(..., description="水箱ID")
) -> ChangeSet:
@@ -88,7 +89,7 @@ async def fastapi_delete_tank(
return delete_tank(network, ChangeSet(ps))
@router.get("/tanks/elevation", summary="获取水箱标高", description="获取指定水箱的标高值")
async def fastapi_get_tank_elevation(
def fastapi_get_tank_elevation(
network: str = Query(..., description="管网名称（或数据库名称）"),
tank: str = Query(..., description="水箱ID")
) -> float | None:
@@ -106,7 +107,7 @@ async def fastapi_get_tank_elevation(
return ps["elevation"]
@router.get("/tanks/init-level", summary="获取水箱初始水位", description="获取指定水箱的初始水位值")
async def fastapi_get_tank_init_level(
def fastapi_get_tank_init_level(
network: str = Query(..., description="管网名称（或数据库名称）"),
tank: str = Query(..., description="水箱ID")
) -> float | None:
@@ -124,7 +125,7 @@ async def fastapi_get_tank_init_level(
return ps["init_level"]
@router.get("/tanks/min-level", summary="获取水箱最小水位", description="获取指定水箱的最小水位值")
async def fastapi_get_tank_min_level(
def fastapi_get_tank_min_level(
network: str = Query(..., description="管网名称（或数据库名称）"),
tank: str = Query(..., description="水箱ID")
) -> float | None:
@@ -142,7 +143,7 @@ async def fastapi_get_tank_min_level(
return ps["min_level"]
@router.get("/tanks/max-level", summary="获取水箱最大水位", description="获取指定水箱的最大水位值")
async def fastapi_get_tank_max_level(
def fastapi_get_tank_max_level(
network: str = Query(..., description="管网名称（或数据库名称）"),
tank: str = Query(..., description="水箱ID")
) -> float | None:
@@ -160,7 +161,7 @@ async def fastapi_get_tank_max_level(
return ps["max_level"]
@router.get("/tanks/diameter", summary="获取水箱直径", description="获取指定水箱的直径值")
async def fastapi_get_tank_diameter(
def fastapi_get_tank_diameter(
network: str = Query(..., description="管网名称（或数据库名称）"),
tank: str = Query(..., description="水箱ID")
) -> float | None:
@@ -178,7 +179,7 @@ async def fastapi_get_tank_diameter(
return ps["diameter"]
@router.get("/tanks/min-vol", summary="获取水箱最小体积", description="获取指定水箱的最小体积值")
async def fastapi_get_tank_min_vol(
def fastapi_get_tank_min_vol(
network: str = Query(..., description="管网名称（或数据库名称）"),
tank: str = Query(..., description="水箱ID")
) -> float | None:
@@ -196,7 +197,7 @@ async def fastapi_get_tank_min_vol(
return ps["min_vol"]
@router.get("/tanks/vol-curve", summary="获取水箱容积曲线", description="获取指定水箱的容积曲线标识")
async def fastapi_get_tank_vol_curve(
def fastapi_get_tank_vol_curve(
network: str = Query(..., description="管网名称（或数据库名称）"),
tank: str = Query(..., description="水箱ID")
) -> str | None:
@@ -214,7 +215,7 @@ async def fastapi_get_tank_vol_curve(
return ps["vol_curve"]
@router.get("/tanks/overflow", summary="获取水箱溢流口", description="获取指定水箱的溢流口配置")
async def fastapi_get_tank_overflow(
def fastapi_get_tank_overflow(
network: str = Query(..., description="管网名称（或数据库名称）"),
tank: str = Query(..., description="水箱ID")
) -> str | None:
@@ -232,7 +233,7 @@ async def fastapi_get_tank_overflow(
return ps["overflow"]
@router.get("/tanks/x", summary="获取水箱X坐标", description="获取指定水箱的X坐标值")
async def fastapi_get_tank_x(
def fastapi_get_tank_x(
network: str = Query(..., description="管网名称（或数据库名称）"),
tank: str = Query(..., description="水箱ID")
) -> float:
@@ -250,7 +251,7 @@ async def fastapi_get_tank_x(
return ps["x"]
@router.get("/tanks/y", summary="获取水箱Y坐标", description="获取指定水箱的Y坐标值")
async def fastapi_get_tank_y(
def fastapi_get_tank_y(
network: str = Query(..., description="管网名称（或数据库名称）"),
tank: str = Query(..., description="水箱ID")
) -> float:
@@ -268,7 +269,7 @@ async def fastapi_get_tank_y(
return ps["y"]
@router.get("/tanks/coord", summary="获取水箱坐标", description="获取指定水箱的X和Y坐标")
async def fastapi_get_tank_coord(
def fastapi_get_tank_coord(
network: str = Query(..., description="管网名称（或数据库名称）"),
tank: str = Query(..., description="水箱ID")
) -> dict[str, float]:
@@ -287,7 +288,7 @@ async def fastapi_get_tank_coord(
return coord
@router.patch("/tanks/elevation", summary="设置水箱标高", description="设置指定水箱的标高值", response_model=None)
async def fastapi_set_tank_elevation(
def fastapi_set_tank_elevation(
network: str = Query(..., description="管网名称（或数据库名称）"),
tank: str = Query(..., description="水箱ID"),
elevation: float = Query(..., description="新的标高值")
@@ -307,7 +308,7 @@ async def fastapi_set_tank_elevation(
return set_tank(network, ChangeSet(ps))
@router.patch("/tanks/init-level", summary="设置水箱初始水位", description="设置指定水箱的初始水位值", response_model=None)
async def fastapi_set_tank_init_level(
def fastapi_set_tank_init_level(
network: str = Query(..., description="管网名称（或数据库名称）"),
tank: str = Query(..., description="水箱ID"),
init_level: float = Query(..., description="新的初始水位值")
@@ -327,7 +328,7 @@ async def fastapi_set_tank_init_level(
return set_tank(network, ChangeSet(ps))
@router.patch("/tanks/min-level", summary="设置水箱最小水位", description="设置指定水箱的最小水位值", response_model=None)
async def fastapi_set_tank_min_level(
def fastapi_set_tank_min_level(
network: str = Query(..., description="管网名称（或数据库名称）"),
tank: str = Query(..., description="水箱ID"),
min_level: float = Query(..., description="新的最小水位值")
@@ -347,7 +348,7 @@ async def fastapi_set_tank_min_level(
return set_tank(network, ChangeSet(ps))
@router.patch("/tanks/max-level", summary="设置水箱最大水位", description="设置指定水箱的最大水位值", response_model=None)
async def fastapi_set_tank_max_level(
def fastapi_set_tank_max_level(
network: str = Query(..., description="管网名称（或数据库名称）"),
tank: str = Query(..., description="水箱ID"),
max_level: float = Query(..., description="新的最大水位值")
@@ -367,7 +368,7 @@ async def fastapi_set_tank_max_level(
return set_tank(network, ChangeSet(ps))
@router.patch("/tanks/diameter", summary="设置水箱直径", description="设置指定水箱的直径值", response_model=None)
async def fastapi_set_tank_diameter(
def fastapi_set_tank_diameter(
network: str = Query(..., description="管网名称（或数据库名称）"),
tank: str = Query(..., description="水箱ID"),
diameter: float = Query(..., description="新的直径值")
@@ -387,7 +388,7 @@ async def fastapi_set_tank_diameter(
return set_tank(network, ChangeSet(ps))
@router.patch("/tanks/min-vol", summary="设置水箱最小体积", description="设置指定水箱的最小体积值", response_model=None)
async def fastapi_set_tank_min_vol(
def fastapi_set_tank_min_vol(
network: str = Query(..., description="管网名称（或数据库名称）"),
tank: str = Query(..., description="水箱ID"),
min_vol: float = Query(..., description="新的最小体积值")
@@ -407,7 +408,7 @@ async def fastapi_set_tank_min_vol(
return set_tank(network, ChangeSet(ps))
@router.patch("/tanks/vol-curve", summary="设置水箱容积曲线", description="设置指定水箱的容积曲线标识", response_model=None)
async def fastapi_set_tank_vol_curve(
def fastapi_set_tank_vol_curve(
network: str = Query(..., description="管网名称（或数据库名称）"),
tank: str = Query(..., description="水箱ID"),
vol_curve: str = Query(..., description="新的容积曲线标识")
@@ -427,7 +428,7 @@ async def fastapi_set_tank_vol_curve(
return set_tank(network, ChangeSet(ps))
@router.patch("/tanks/overflow", summary="设置水箱溢流口", description="设置指定水箱的溢流口配置", response_model=None)
async def fastapi_set_tank_overflow(
def fastapi_set_tank_overflow(
network: str = Query(..., description="管网名称（或数据库名称）"),
tank: str = Query(..., description="水箱ID"),
overflow: str = Query(..., description="新的溢流口配置")
@@ -447,7 +448,7 @@ async def fastapi_set_tank_overflow(
return set_tank(network, ChangeSet(ps))
@router.patch("/tanks/x", summary="设置水箱X坐标", description="设置指定水箱的X坐标值", response_model=None)
async def fastapi_set_tank_x(
def fastapi_set_tank_x(
network: str = Query(..., description="管网名称（或数据库名称）"),
tank: str = Query(..., description="水箱ID"),
x: float = Query(..., description="新的X坐标值")
@@ -467,7 +468,7 @@ async def fastapi_set_tank_x(
return set_tank(network, ChangeSet(ps))
@router.patch("/tanks/y", summary="设置水箱Y坐标", description="设置指定水箱的Y坐标值", response_model=None)
async def fastapi_set_tank_y(
def fastapi_set_tank_y(
network: str = Query(..., description="管网名称（或数据库名称）"),
tank: str = Query(..., description="水箱ID"),
y: float = Query(..., description="新的Y坐标值")
@@ -487,7 +488,7 @@ async def fastapi_set_tank_y(
return set_tank(network, ChangeSet(ps))
@router.patch("/tanks/coord", summary="设置水箱坐标", description="设置指定水箱的X和Y坐标", response_model=None)
async def fastapi_set_tank_coord(
def fastapi_set_tank_coord(
network: str = Query(..., description="管网名称（或数据库名称）"),
tank: str = Query(..., description="水箱ID"),
x: float = Query(..., description="新的X坐标值"),
@@ -509,7 +510,7 @@ async def fastapi_set_tank_coord(
return set_tank(network, ChangeSet(ps))
@router.get("/tanks/properties", summary="获取水箱属性", description="获取指定水箱的所有属性")
async def fastapi_get_tank_properties(
def fastapi_get_tank_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
tank: str = Query(..., description="水箱ID")
) -> dict[str, Any]:
@@ -526,7 +527,7 @@ async def fastapi_get_tank_properties(
return get_tank(network, tank)
@router.get("/tanks", summary="获取所有水箱属性", description="获取指定网络中所有水箱的属性")
async def fastapi_get_all_tank_properties(
def fastapi_get_all_tank_properties(
network: str = Query(..., description="管网名称（或数据库名称）")
) -> list[dict[str, Any]]:
"""
@@ -543,10 +544,10 @@ async def fastapi_get_all_tank_properties(
return results
@router.patch("/tanks/properties", summary="设置水箱属性", description="批量设置指定水箱的多个属性", response_model=None)
async def fastapi_set_tank_properties(
def fastapi_set_tank_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
tank: str = Query(..., description="水箱ID"),
req: Request = None
payload: dict[str, Any] = Body(...)
) -> ChangeSet:
"""
批量设置水箱的属性。
@@ -559,6 +560,6 @@ async def fastapi_set_tank_properties(
Returns:
包含变更信息的ChangeSet对象
"""
props = await req.json()
props = payload
ps = {"id": tank} | props
return set_tank(network, ChangeSet(ps))
app/api/v1/endpoints/network/valves.py
+22 -21
View File
@@ -1,5 +1,6 @@
from fastapi import APIRouter, Request, Query, Path, Body
from typing import Any, List, Dict, Union
from typing import Any
from fastapi import APIRouter, Body, Query
from app.services.tjnetwork import (
ChangeSet,
VALVES_TYPE_PRV,
@@ -18,7 +19,7 @@ router = APIRouter()
summary="获取阀门架构",
description="获取指定水网中所有阀门的架构和字段定义",
)
async def fastapi_get_valve_schema(
def fastapi_get_valve_schema(
network: str = Query(..., description="管网名称（或数据库名称）")
) -> dict[str, dict[str, Any]]:
"""
@@ -34,7 +35,7 @@ async def fastapi_get_valve_schema(
summary="添加阀门",
description="在指定的水网中添加新的阀门",
)
async def fastapi_add_valve(
def fastapi_add_valve(
network: str = Query(..., description="管网名称（或数据库名称）"),
valve: str = Query(..., description="阀门ID"),
node1: str = Query(..., description="起点节点ID"),
@@ -67,7 +68,7 @@ async def fastapi_add_valve(
summary="删除阀门",
description="从指定的水网中删除指定的阀门",
)
async def fastapi_delete_valve(
def fastapi_delete_valve(
network: str = Query(..., description="管网名称（或数据库名称）"),
valve: str = Query(..., description="阀门ID"),
) -> ChangeSet:
@@ -84,7 +85,7 @@ async def fastapi_delete_valve(
summary="获取阀门起点节点",
description="获取指定阀门连接的起点节点ID",
)
async def fastapi_get_valve_node1(
def fastapi_get_valve_node1(
network: str = Query(..., description="管网名称（或数据库名称）"),
valve: str = Query(..., description="阀门ID"),
) -> str | None:
@@ -101,7 +102,7 @@ async def fastapi_get_valve_node1(
summary="获取阀门终点节点",
description="获取指定阀门连接的终点节点ID",
)
async def fastapi_get_valve_node2(
def fastapi_get_valve_node2(
network: str = Query(..., description="管网名称（或数据库名称）"),
valve: str = Query(..., description="阀门ID"),
) -> str | None:
@@ -118,7 +119,7 @@ async def fastapi_get_valve_node2(
summary="获取阀门直径",
description="获取指定阀门的直径",
)
async def fastapi_get_valve_diameter(
def fastapi_get_valve_diameter(
network: str = Query(..., description="管网名称（或数据库名称）"),
valve: str = Query(..., description="阀门ID"),
) -> float | None:
@@ -135,7 +136,7 @@ async def fastapi_get_valve_diameter(
summary="获取阀门类型",
description="获取指定阀门的类型",
)
async def fastapi_get_valve_type(
def fastapi_get_valve_type(
network: str = Query(..., description="管网名称（或数据库名称）"),
valve: str = Query(..., description="阀门ID"),
) -> str | None:
@@ -152,7 +153,7 @@ async def fastapi_get_valve_type(
summary="获取阀门开度",
description="获取指定阀门的开度/设置值",
)
async def fastapi_get_valve_setting(
def fastapi_get_valve_setting(
network: str = Query(..., description="管网名称（或数据库名称）"),
valve: str = Query(..., description="阀门ID"),
) -> float | None:
@@ -169,7 +170,7 @@ async def fastapi_get_valve_setting(
summary="获取阀门损失系数",
description="获取指定阀门的损失系数",
)
async def fastapi_get_valve_minor_loss(
def fastapi_get_valve_minor_loss(
network: str = Query(..., description="管网名称（或数据库名称）"),
valve: str = Query(..., description="阀门ID"),
) -> float | None:
@@ -187,7 +188,7 @@ async def fastapi_get_valve_minor_loss(
summary="设置阀门起点节点",
description="设置指定阀门的起点节点",
)
async def fastapi_set_valve_node1(
def fastapi_set_valve_node1(
network: str = Query(..., description="管网名称（或数据库名称）"),
valve: str = Query(..., description="阀门ID"),
node1: str = Query(..., description="新的起点节点ID"),
@@ -206,7 +207,7 @@ async def fastapi_set_valve_node1(
summary="设置阀门终点节点",
description="设置指定阀门的终点节点",
)
async def fastapi_set_valve_node2(
def fastapi_set_valve_node2(
network: str = Query(..., description="管网名称（或数据库名称）"),
valve: str = Query(..., description="阀门ID"),
node2: str = Query(..., description="新的终点节点ID"),
@@ -225,7 +226,7 @@ async def fastapi_set_valve_node2(
summary="设置阀门直径",
description="设置指定阀门的直径",
)
async def fastapi_set_valve_diameter(
def fastapi_set_valve_diameter(
network: str = Query(..., description="管网名称（或数据库名称）"),
valve: str = Query(..., description="阀门ID"),
diameter: float = Query(..., description="新的直径值（mm）"),
@@ -244,7 +245,7 @@ async def fastapi_set_valve_diameter(
summary="设置阀门类型",
description="设置指定阀门的类型",
)
async def fastapi_set_valve_type(
def fastapi_set_valve_type(
network: str = Query(..., description="管网名称（或数据库名称）"),
valve: str = Query(..., description="阀门ID"),
type: str = Query(..., description="新的阀门类型"),
@@ -263,7 +264,7 @@ async def fastapi_set_valve_type(
summary="设置阀门开度",
description="设置指定阀门的开度/设置值",
)
async def fastapi_set_valve_setting(
def fastapi_set_valve_setting(
network: str = Query(..., description="管网名称（或数据库名称）"),
valve: str = Query(..., description="阀门ID"),
setting: float = Query(..., description="新的开度值"),
@@ -281,7 +282,7 @@ async def fastapi_set_valve_setting(
summary="获取阀门所有属性",
description="获取指定阀门的所有属性",
)
async def fastapi_get_valve_properties(
def fastapi_get_valve_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
valve: str = Query(..., description="阀门ID"),
) -> dict[str, Any]:
@@ -297,7 +298,7 @@ async def fastapi_get_valve_properties(
summary="获取所有阀门属性",
description="获取指定水网中所有阀门的属性",
)
async def fastapi_get_all_valve_properties(
def fastapi_get_all_valve_properties(
network: str = Query(..., description="管网名称（或数据库名称）")
) -> list[dict[str, Any]]:
"""
@@ -315,16 +316,16 @@ async def fastapi_get_all_valve_properties(
summary="批量设置阀门属性",
description="批量设置指定阀门的多个属性",
)
async def fastapi_set_valve_properties(
def fastapi_set_valve_properties(
network: str = Query(..., description="管网名称（或数据库名称）"),
valve: str = Query(..., description="阀门ID"),
req: Request = None,
payload: dict[str, Any] = Body(...),
) -> ChangeSet:
"""
批量设置阀门的属性。
更新指定阀门的一个或多个属性，通过JSON请求体传递要更新的属性。
"""
props = await req.json()
props = payload
ps = {"id": valve} | props
return set_valve(network, ChangeSet(ps))
app/api/v1/endpoints/project.py
+4 -398
View File
@@ -1,43 +1,18 @@
import json
from fastapi import APIRouter, Request, HTTPException, Query, Path, Depends
from fastapi.responses import PlainTextResponse
from typing import Any, Dict, List
from fastapi import APIRouter, HTTPException, Query, Depends
from app.infra.db.metadb.repositories.metadata_repository import MetadataRepository
from app.auth.project_dependencies import get_metadata_repository
from app.auth.permissions import (
ENVIRONMENT_MANAGE,
require_permission,
from app.auth.project_dependencies import (
get_metadata_repository,
)
from app.domain.schemas.metadata import ProjectMetaResponse
import app.services.project_info as project_info
from app.services.tjnetwork import (
ChangeSet,
list_project,
have_project,
create_project,
delete_project,
is_project_open,
open_project,
close_project,
copy_project,
export_inp,
read_inp,
dump_inp,
get_all_vertices,
get_all_scada_info,
convert_inp_v3_to_v2,
)
# For inp file upload/download
import os
from fastapi import Response, status
from fastapi.responses import FileResponse
inpDir = "data/" # Assuming data directory exists or is defined somewhere.
# In main.py it was likely global. For safety, let's use a relative path or get from config.
# But let's stick to what main.py probably used or a default.
router = APIRouter()
lockedPrjs: Dict[str, str] = {}
@router.get("/projects/current", summary="获取项目信息", description="从数据库获取项目的详细信息，包括地图范围等。", response_model=ProjectMetaResponse)
async def get_project_info_endpoint(
@@ -63,105 +38,8 @@ async def get_project_info_endpoint(
project_role="viewer", # Default role for public access
)
@router.get("/project-codes", summary="获取项目列表", description="获取服务器上所有可用的供水管网项目名称列表。")
async def list_projects_endpoint() -> list[str]:
"""
获取项目列表
返回所有已创建项目的名称列表。
"""
return list_project()
@router.get("/projects/existence", summary="检查项目是否存在", description="检查指定名称的项目是否存在。")
async def have_project_endpoint(
network: str = Query(..., description="管网名称（或数据库名称）")
):
"""
检查项目是否存在
- **network**: 管网名称（或数据库名称）
"""
return have_project(network)
@router.post("/projects", summary="创建新项目", description="创建一个新的供水管网项目。如果项目已存在，可能会覆盖或报错（取决于底层实现）。")
async def create_project_endpoint(
network: str = Query(..., description="管网名称（或数据库名称）"),
_=Depends(require_permission(ENVIRONMENT_MANAGE)),
):
"""
创建新项目
- **network**: 管网名称（或数据库名称）
"""
create_project(network)
return network
@router.delete("/projects", summary="删除项目", description="永久删除指定的供水管网项目。此操作不可恢复。")
async def delete_project_endpoint(
network: str = Query(..., description="管网名称（或数据库名称）"),
_=Depends(require_permission(ENVIRONMENT_MANAGE)),
):
"""
删除项目
- **network**: 管网名称（或数据库名称）
"""
delete_project(network)
return True
@router.get("/projects/current/status", summary="检查项目是否已打开", description="检查指定项目是否已被加载到内存中。")
async def is_project_open_endpoint(
network: str = Query(..., description="管网名称（或数据库名称）")
):
"""
检查项目是否已打开
- **network**: 管网名称（或数据库名称）
"""
return is_project_open(network)
@router.post("/projects/current", summary="打开项目", description="将指定项目加载到内存中，并初始化数据库连接池。")
async def open_project_endpoint(
network: str = Query(..., description="管网名称（或数据库名称）")
):
"""
打开项目
- **network**: 管网名称（或数据库名称）
"""
open_project(network)
return network
@router.delete("/projects/current", summary="关闭项目", description="将指定项目从内存中卸载，释放资源。")
async def close_project_endpoint(
network: str = Query(..., description="管网名称（或数据库名称）")
):
"""
关闭项目
- **network**: 管网名称（或数据库名称）
"""
close_project(network)
return True
@router.post("/project-copies", summary="复制项目", description="将现有项目复制为新项目。")
async def copy_project_endpoint(
source: str = Query(..., description="管网名称（或数据库名称）"),
target: str = Query(..., description="管网名称（或数据库名称）"),
_=Depends(require_permission(ENVIRONMENT_MANAGE)),
):
"""
复制项目
- **source**: 管网名称（或数据库名称）
- **target**: 管网名称（或数据库名称）
"""
copy_project(source, target)
return True
@router.get("/projects/current/exports/change-set", response_model=None, summary="导出项目为 ChangeSet", description="导出项目的变更集 (ChangeSet)，包含顶点、SCADA 元素、DMA、SA、VD 等信息。")
async def export_inp_endpoint(
def export_inp_endpoint(
network: str = Query(..., description="管网名称（或数据库名称）"),
version: str = Query(..., description="版本号 (通常用于增量更新)")
) -> ChangeSet:
@@ -173,279 +51,7 @@ async def export_inp_endpoint(
"""
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_info(network))
close_project(network)
return cs
@router.post("/projects/current/imports", summary="读取 INP 文件到项目", description="从服务器文件系统中读取指定的 INP 文件并加载到项目中。")
async def read_inp_endpoint(
network: str = Query(..., description="管网名称（或数据库名称）"),
inp: str = Query(..., description="INP 文件名 (不包含路径)")
) -> bool:
"""
读取 INP 文件到项目
- **network**: 管网名称（或数据库名称）
- **inp**: INP 文件名
"""
read_inp(network, inp)
return True
@router.post("/projects/current/exports/inp", summary="导出项目到 INP 文件", description="将项目当前状态保存为 INP 文件到服务器文件系统。")
async def dump_inp_endpoint(
network: str = Query(..., description="管网名称（或数据库名称）"),
inp: str = Query(..., description="目标文件名")
) -> bool:
"""
导出项目到 INP 文件
- **network**: 管网名称（或数据库名称）
- **inp**: 目标文件名
"""
dump_inp(network, inp)
return True
@router.get("/projects/current/lock", summary="检查项目是否被锁定", description="检查指定项目是否处于锁定状态。")
async def is_project_locked_endpoint(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
):
"""
检查项目是否被锁定
- **network**: 管网名称（或数据库名称）
"""
return network in lockedPrjs.keys()
@router.get("/projects/current/lock/ownership", summary="检查项目是否被当前用户锁定", description="检查指定项目是否被当前访问地址 (IP) 锁定。")
async def is_project_locked_by_me_endpoint(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
):
"""
检查项目是否被当前用户锁定
- **network**: 管网名称（或数据库名称）
"""
client_host = req.client.host
return lockedPrjs.get(network) == client_host
# 0 successfully locked
# 1 already locked by you
# 2 locked by others
@router.post("/projects/current/lock", summary="锁定项目", description="锁定指定项目以防止并发修改。")
async def lock_project_endpoint(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
):
"""
锁定项目
返回值:
- **0**: 锁定成功
- **1**: 已被当前用户锁定
- **2**: 已被其他用户锁定
"""
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
@router.delete("/projects/current/lock", summary="解锁项目", description="释放对项目的锁定。")
def unlock_project_endpoint(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
):
"""
解锁项目
只有锁定者才能解锁。
"""
client_host = req.client.host
if lockedPrjs.get(network) == client_host:
print("delete key")
del lockedPrjs[network]
return True
return False
@router.get("/projects/current/files/inp", status_code=status.HTTP_200_OK, summary="下载 INP 文件", description="从服务器数据目录下载指定的 INP 文件。")
async def fastapi_download_inp(
name: str = Query(..., description="文件名"),
response: Response = None
):
"""
下载 INP 文件
- **name**: 文件名
"""
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
# DingZQ, 2024-12-28, convert v3 to v2
@router.post("/project-conversions", response_model=None, summary="转换 INP V3 为 V2", description="将 EPANET 3.0 格式的 INP 内容转换为 2.x 格式。")
async def fastapi_convert_v3_to_v2(
req: Request
) -> ChangeSet:
"""
转换 INP V3 为 V2
- **req**: 请求体，需包含 `{"inp": "..."}` 结构
"""
network = "v3Tov2"
jo_root = await req.json()
inp = jo_root["inp"]
cs = convert_inp_v3_to_v2(inp)
op = cs.operations[0]
open_project(network)
op["vertex"] = json.dumps(get_all_vertices(network))
op["scada"] = json.dumps(get_all_scada_info(network))
close_project(network)
return cs
async def read_inp_endpoint(
network: str = Query(..., description="管网名称（或数据库名称）"),
inp: str = Query(..., description="INP 文件名 (不包含路径)")
) -> bool:
"""
读取 INP 文件到项目
- **network**: 管网名称（或数据库名称）
- **inp**: INP 文件名
"""
read_inp(network, inp)
return True
async def dump_inp_endpoint(
network: str = Query(..., description="管网名称（或数据库名称）"),
inp: str = Query(..., description="目标文件名")
) -> bool:
"""
导出项目到 INP 文件
- **network**: 管网名称（或数据库名称）
- **inp**: 目标文件名
"""
dump_inp(network, inp)
return True
async def is_project_locked_endpoint(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
):
"""
检查项目是否被锁定
- **network**: 管网名称（或数据库名称）
"""
return network in lockedPrjs.keys()
async def is_project_locked_by_me_endpoint(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
):
"""
检查项目是否被当前用户锁定
- **network**: 管网名称（或数据库名称）
"""
client_host = req.client.host
return lockedPrjs.get(network) == client_host
# 0 successfully locked
# 1 already locked by you
# 2 locked by others
async def lock_project_endpoint(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
):
"""
锁定项目
返回值:
- **0**: 锁定成功
- **1**: 已被当前用户锁定
- **2**: 已被其他用户锁定
"""
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
def unlock_project_endpoint(
network: str = Query(..., description="管网名称（或数据库名称）"),
req: Request = None
):
"""
解锁项目
只有锁定者才能解锁。
"""
client_host = req.client.host
if lockedPrjs.get(network) == client_host:
print("delete key")
del lockedPrjs[network]
return True
return False
async def fastapi_download_inp(
name: str = Query(..., description="文件名"),
response: Response = None
):
"""
下载 INP 文件
- **name**: 文件名
"""
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
# DingZQ, 2024-12-28, convert v3 to v2
async def fastapi_convert_v3_to_v2(
req: Request
) -> ChangeSet:
"""
转换 INP V3 为 V2
- **req**: 请求体，需包含 `{"inp": "..."}` 结构
"""
network = "v3Tov2"
jo_root = await req.json()
inp = jo_root["inp"]
cs = convert_inp_v3_to_v2(inp)
op = cs.operations[0]
open_project(network)
op["vertex"] = json.dumps(get_all_vertices(network))
op["scada"] = json.dumps(get_all_scada_info(network))
close_project(network)
return cs
app/api/v1/endpoints/sensor_placement.py
+8 -1
View File
@@ -12,7 +12,12 @@ from app.algorithms.sensor import (
pressure_sensor_placement_sensitivity,
)
from app.auth.metadata_dependencies import get_current_metadata_user
from app.auth.project_dependencies import ProjectContext, get_project_context
from app.auth.project_dependencies import (
ProjectContext,
get_project_context,
use_project_business_routing,
)
from app.infra.db.project_routing import ActiveProjectRouting
from app.domain.schemas.sensor_placement import (
SensorPointResponse,
SensorPlacementExportRequest,
@@ -106,6 +111,7 @@ def _get_run_response(
async def get_sensor_placement_candidate_detail(
node_id: str = Path(..., min_length=1, max_length=32),
project_context: ProjectContext = Depends(get_project_context),
_routing: ActiveProjectRouting = Depends(use_project_business_routing),
) -> dict[str, Any]:
try:
return await run_in_threadpool(
@@ -166,6 +172,7 @@ async def optimize_sensor_placement_scheme(
)
async def get_sensor_placement_runs(
project_context: ProjectContext = Depends(get_project_context),
_routing: ActiveProjectRouting = Depends(use_project_business_routing),
) -> list[dict[str, Any]]:
return await run_in_threadpool(
list_sensor_placement_runs,
app/api/v1/endpoints/simulation.py
+22 -22
View File
@@ -127,7 +127,7 @@ def run_simulation_manually_by_date(
# 必须用这个PlainTextResponse，不然每个key都有引号
@router.post("/project-runs", response_class=PlainTextResponse, summary="运行项目模拟", description="基于指定的管网项目运行标准水力模拟，返回纯文本格式的模拟报告。")
async def run_project_endpoint(network: str = Query(..., description="管网名称（或数据库名称）")) -> str:
def run_project_endpoint(network: str = Query(..., description="管网名称（或数据库名称）")) -> str:
"""
运行项目模拟
@@ -143,7 +143,7 @@ async def run_project_endpoint(network: str = Query(..., description="管网名
# output 是 json
# report 是 text
@router.post("/project-return-dict-runs", summary="运行项目模拟（返回字典）", description="基于指定的管网项目运行标准水力模拟，返回JSON格式的字典，包含输出数据和报告文本。")
async def run_project_return_dict_endpoint(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, Any]:
def run_project_return_dict_endpoint(network: str = Query(..., description="管网名称（或数据库名称）")) -> dict[str, Any]:
"""
运行项目模拟（返回字典）
@@ -160,7 +160,7 @@ async def run_project_return_dict_endpoint(network: str = Query(..., description
# put in inp folder, name without extension
@router.post("/inp-runs", summary="运行INP文件", description="运行指定INP文件格式的管网模型进行水力模拟。INP文件应该放在inp文件夹中，参数为文件名不含扩展名。")
async def run_inp_endpoint(network: str = Query(..., description="inp文件名（不含扩展名）")) -> str:
def run_inp_endpoint(network: str = Query(..., description="inp文件名（不含扩展名）")) -> str:
"""
运行INP文件
@@ -173,7 +173,7 @@ async def run_inp_endpoint(network: str = Query(..., description="inp文件名
# path is absolute path
@router.get("/outputs", summary="导出模拟输出", description="导出指定路径的模拟输出文件内容。参数应为绝对路径。")
async def dump_output_endpoint(output: str = Query(..., description="模拟输出文件的绝对路径")) -> str:
def dump_output_endpoint(output: str = Query(..., description="模拟输出文件的绝对路径")) -> str:
"""
导出模拟输出
@@ -186,7 +186,7 @@ async def dump_output_endpoint(output: str = Query(..., description="模拟输
# Analysis Endpoints
@router.post("/burst-analyses", summary="爆管分析（高级）", description="高级版本的爆管分析，支持在指定时间点修改泵控制模式和阀门开度，以分析这些改变对爆管影响的作用。支持固定泵和变速泵的独立控制。")
async def fastapi_burst_analysis(
def fastapi_burst_analysis(
network: str = Query(..., description="管网名称（或数据库名称）"),
modify_pattern_start_time: str = Query(..., description="模式修改开始时间（ISO 8601格式）"),
burst_ID: list[str] = Query(..., description="爆管节点/管段ID列表"),
@@ -220,7 +220,7 @@ async def fastapi_burst_analysis(
@router.post("/valve-closure-analyses", response_class=PlainTextResponse, summary="阀门关闭分析（高级）", description="高级版本的阀门关闭分析，支持同时关闭多个阀门，并在指定持续时间内进行模拟。返回纯文本格式的分析结果。")
async def fastapi_valve_close_analysis(
def fastapi_valve_close_analysis(
network: str = Query(..., description="管网名称（或数据库名称）"),
start_time: str = Query(..., description="阀门关闭开始时间（ISO 8601格式）"),
valves: List[str] = Query(..., description="要关闭的阀门ID列表"),
@@ -249,7 +249,7 @@ async def fastapi_valve_close_analysis(
@router.post("/valve-isolation-analyses", summary="阀门隔离分析", description="分析当发生突发事件时，通过关闭指定阀门进行隔离，确定哪些阀门必须关闭、哪些可选关闭，以及隔离的可行性。")
async def valve_isolation_endpoint(
def valve_isolation_endpoint(
network: str = Query(..., description="管网名称（或数据库名称）"),
accident_element: List[str] = Query(..., description="发生事故的管段/节点ID列表"),
disabled_valves: List[str] = Query(None, description="已故障的阀门ID列表（可选）"),
@@ -290,7 +290,7 @@ async def valve_isolation_endpoint(
@router.post("/flushing-analyses", response_class=PlainTextResponse, summary="冲洗分析（高级）", description="高级版本的冲洗分析，支持按状态和设置值控制多个可选阀门，指定排污节点，并设置固定的冲洗流量。返回纯文本格式的分析结果。")
async def fastapi_flushing_analysis(
def fastapi_flushing_analysis(
network: str = Query(..., description="管网名称（或数据库名称）"),
start_time: str = Query(..., description="冲洗开始时间（ISO 8601格式）"),
valves: List[str] | None = Query(None, description="参与控制的阀门ID列表（可选）"),
@@ -403,7 +403,7 @@ async def fastapi_flushing_analysis(
@router.post("/contaminant-simulations", response_class=PlainTextResponse, summary="污染物模拟", description="对管网中的污染物扩散进行模拟，评估污染源对管网的影响范围和浓度分布。支持指定污染源位置、污染浓度和扩散模式。")
async def fastapi_contaminant_simulation(
def fastapi_contaminant_simulation(
network: str = Query(..., description="管网名称（或数据库名称）"),
start_time: str = Query(..., description="污染开始时间（ISO 8601格式）"),
source: str = Query(..., description="污染源节点ID"),
@@ -440,7 +440,7 @@ async def fastapi_contaminant_simulation(
@router.post("/water-age-analyses", response_class=PlainTextResponse, summary="水龄分析（高级）", description="高级版本的水龄分析，在指定时间点进行分析，支持自定义模拟持续时间。返回纯文本格式的分析结果。")
async def fastapi_age_analysis(
def fastapi_age_analysis(
network: str = Query(..., description="管网名称（或数据库名称）"),
start_time: str = Query(..., description="分析开始时间（ISO 8601格式）"),
duration: int = Query(..., description="模拟持续时间（秒）"),
@@ -464,7 +464,7 @@ async def fastapi_age_analysis(
@router.post("/pressure-regulation-calculations", summary="压力调节（基础）", description="对管网的压力进行调节分析，通过控制泵的运行来维持目标节点的目标压力。此为基础版本。")
async def pressure_regulation_endpoint(
def pressure_regulation_endpoint(
network: str = Query(..., description="管网名称（或数据库名称）"),
target_node: str = Query(..., description="目标节点ID"),
target_pressure: float = Query(..., description="目标压力值（kPa）"),
@@ -482,7 +482,7 @@ async def pressure_regulation_endpoint(
@router.post("/pressure-regulation-analyses", summary="压力调节（高级）", description="高级版本的压力调节分析，通过JSON请求体提供详细的控制参数，包括固定泵和变速泵的独立控制、水箱初始水位等。")
async def fastapi_pressure_regulation(data: PressureRegulation = Body(..., description="压力调节控制参数")) -> str:
def fastapi_pressure_regulation(data: PressureRegulation = Body(..., description="压力调节控制参数")) -> str:
"""
压力调节（高级版本）
@@ -496,7 +496,7 @@ async def fastapi_pressure_regulation(data: PressureRegulation = Body(..., descr
支持固定泵和变速泵的独立控制。
"""
item = data.dict()
item = data.model_dump()
simulation.query_corresponding_element_id_and_query_id(item["network"])
fixed_pumps = set(globals.fixed_pumps_id.keys())
variable_pumps = set(globals.variable_pumps_id.keys())
@@ -520,7 +520,7 @@ async def fastapi_pressure_regulation(data: PressureRegulation = Body(..., descr
@router.post("/project-managements", summary="项目管理（高级）", description="高级版本的项目管理，通过JSON请求体提供详细的控制参数，包括泵控制策略、水箱初始水位和区域需水量控制。")
async def fastapi_project_management(data: ProjectManagement = Body(..., description="项目管理控制参数")) -> str:
def fastapi_project_management(data: ProjectManagement = Body(..., description="项目管理控制参数")) -> str:
"""
项目管理（高级版本）
@@ -533,7 +533,7 @@ async def fastapi_project_management(data: ProjectManagement = Body(..., descrip
支持多维度的项目管理。
"""
item = data.dict()
item = data.model_dump()
return project_management(
prj_name=item["network"],
start_datetime=item["start_time"],
@@ -549,7 +549,7 @@ async def fastapi_project_management(data: ProjectManagement = Body(..., descrip
@router.post("/scheduling-analyses", summary="排程分析", description="对管网的供水排程进行分析，优化泵的运行时间和出水流量，平衡水厂出水、水箱进出水，满足用户需求。")
async def fastapi_scheduling_analysis(data: SchedulingAnalysis = Body(..., description="排程分析参数")) -> str:
def fastapi_scheduling_analysis(data: SchedulingAnalysis = Body(..., description="排程分析参数")) -> str:
"""
排程分析
@@ -563,7 +563,7 @@ async def fastapi_scheduling_analysis(data: SchedulingAnalysis = Body(..., descr
用于优化供水排程。
"""
item = data.dict()
item = data.model_dump()
return scheduling_simulation(
item["network"],
item["start_time"],
@@ -575,7 +575,7 @@ async def fastapi_scheduling_analysis(data: SchedulingAnalysis = Body(..., descr
@router.post("/daily-scheduling-analyses", summary="日排程分析", description="对管网的每日供水排程进行分析，优化水库、水厂、水箱和用户需求的协调，制定合理的每日排程方案。")
async def fastapi_daily_scheduling_analysis(data: DailySchedulingAnalysis = Body(..., description="日排程分析参数")) -> str:
def fastapi_daily_scheduling_analysis(data: DailySchedulingAnalysis = Body(..., description="日排程分析参数")) -> str:
"""
日排程分析
@@ -590,7 +590,7 @@ async def fastapi_daily_scheduling_analysis(data: DailySchedulingAnalysis = Body
用于制定每日供水排程方案。
"""
item = data.dict()
item = data.model_dump()
return daily_scheduling_simulation(
item["network"],
item["start_time"],
@@ -607,7 +607,7 @@ async def fastapi_daily_scheduling_analysis(data: DailySchedulingAnalysis = Body
@router.post("/pump-failure-events", summary="泵故障管理", description="记录和管理泵的故障状态，包括故障发生时间和受影响的泵列表。系统将记录故障日志并更新泵状态。")
async def fastapi_pump_failure(data: PumpFailureState = Body(..., description="泵故障状态信息")) -> str:
def fastapi_pump_failure(data: PumpFailureState = Body(..., description="泵故障状态信息")) -> str:
"""
泵故障管理
@@ -617,7 +617,7 @@ async def fastapi_pump_failure(data: PumpFailureState = Body(..., description="
系统将验证泵信息的有效性并更新故障状态文件。
"""
item = data.dict()
item = data.model_dump()
with open("./pump_failure_message.txt", "a", encoding="utf-8-sig") as f1:
f1.write("[{}] {}\n".format(datetime.now().strftime("%Y-%m-%d %H:%M:%S"), item))
with open("./pump_failure_status.txt", "r", encoding="utf-8-sig") as f2:
@@ -651,7 +651,7 @@ async def fastapi_pump_failure(data: PumpFailureState = Body(..., description="
@router.post("/simulation-runs", summary="手动运行日期指定模拟", description="根据指定的开始时间和持续时间，手动运行水力模拟。开始时间必须是显式带时区的 ISO 8601 / RFC3339 时间。")
async def fastapi_run_simulation_manually_by_date(
def fastapi_run_simulation_manually_by_date(
data: RunSimulationManuallyByDate = Body(..., description="模拟运行参数"),
) -> dict[str, str]:
"""
app/api/v1/endpoints/timeseries/realtime.py
+31 -4
View File
@@ -2,6 +2,7 @@ from fastapi import APIRouter, Depends, HTTPException, Query, Path, Body
from typing import List
from datetime import datetime
from psycopg import AsyncConnection
from pydantic import BaseModel
from app.infra.db.timescaledb.repositories.realtime import RealtimeRepository
from .dependencies import get_timescale_connection
@@ -13,9 +14,31 @@ TIME_RANGE_START_DESC = f"时间范围开始时间。{TIME_WITH_TZ_DESC}"
TIME_RANGE_END_DESC = f"时间范围结束时间。{TIME_WITH_TZ_DESC}"
class RealtimeLinkBatchItem(BaseModel):
time: datetime
id: str
flow: float | None = None
friction: float | None = None
headloss: float | None = None
quality: float | None = None
reaction: float | None = None
setting: float | None = None
status: float | None = None
velocity: float | None = None
class RealtimeNodeBatchItem(BaseModel):
time: datetime
id: str
actual_demand: float | None = None
total_head: float | None = None
pressure: float | None = None
quality: float | None = None
@router.post("/timeseries/realtime/links/batches", status_code=201, summary="批量插入实时管道数据")
async def insert_realtime_links(
data: List[dict] = Body(..., description="管道数据列表，每项包含管道ID、时间戳等信息"),
data: List[RealtimeLinkBatchItem] = Body(..., description="同一时间点的管道快照数据"),
conn: AsyncConnection = Depends(get_timescale_connection)
):
"""
@@ -29,7 +52,9 @@ async def insert_realtime_links(
Returns:
插入成功的记录数
"""
await RealtimeRepository.insert_links_batch(conn, data)
await RealtimeRepository.insert_links_batch(
conn, [item.model_dump() for item in data]
)
return {"message": f"Inserted {len(data)} records"}
@@ -119,7 +144,7 @@ async def update_realtime_link_field(
@router.post("/timeseries/realtime/nodes/batches", status_code=201, summary="批量插入实时节点数据")
async def insert_realtime_nodes(
data: List[dict] = Body(..., description="节点数据列表，每项包含节点ID、时间戳等信息"),
data: List[RealtimeNodeBatchItem] = Body(..., description="同一时间点的节点快照数据"),
conn: AsyncConnection = Depends(get_timescale_connection)
):
"""
@@ -133,7 +158,9 @@ async def insert_realtime_nodes(
Returns:
插入成功的记录数
"""
await RealtimeRepository.insert_nodes_batch(conn, data)
await RealtimeRepository.insert_nodes_batch(
conn, [item.model_dump() for item in data]
)
return {"message": f"Inserted {len(data)} records"}
app/api/v1/rest_router.py
+12 -12
View File
@@ -11,6 +11,7 @@ from fastapi import APIRouter, Depends, Query
from fastapi.encoders import jsonable_encoder
from fastapi.routing import APIRoute
from pydantic import BaseModel, JsonValue, create_model
from starlette.concurrency import run_in_threadpool
from starlette.responses import Response
from app.api.problem_details import ProblemDetails
@@ -38,6 +39,14 @@ class Page(BaseModel, Generic[T]):
offset: int
async def _call_endpoint(endpoint, *args, **kwargs):
"""Call async handlers directly and offload synchronous handlers."""
if inspect.iscoroutinefunction(endpoint):
return await endpoint(*args, **kwargs)
result = await run_in_threadpool(endpoint, *args, **kwargs)
return await result if inspect.isawaitable(result) else result
_NAME_IS_NETWORK = {
"pressure_sensor_placement_sensitivity_endpoint",
"pressure_sensor_placement_kmeans_endpoint",
@@ -59,7 +68,6 @@ _TIMESCALE_ROUTED_ENDPOINT_MODULES = {
"app.api.v1.endpoints.leakage",
"app.api.v1.endpoints.simulation",
}
_TIMESCALE_ROUTED_ENDPOINT_NAMES = {"open_project_endpoint"}
def _clean_name(name: str) -> str:
@@ -183,10 +191,7 @@ def _with_header_project_context(endpoint, route_name: str):
if model_has_username:
kwargs.pop(injected_user_name, None)
with activate_project_routing(project_routing):
result = endpoint(*args, **kwargs)
if inspect.isawaitable(result):
return await result
return result
return await _call_endpoint(endpoint, *args, **kwargs)
parameters = []
for name, parameter in signature.parameters.items():
@@ -206,7 +211,6 @@ def _with_header_project_context(endpoint, route_name: str):
get_project_simulation_routing
if (
endpoint.__module__ in _TIMESCALE_ROUTED_ENDPOINT_MODULES
or endpoint.__name__ in _TIMESCALE_ROUTED_ENDPOINT_NAMES
)
else get_project_business_routing
)
@@ -262,9 +266,7 @@ def _with_pagination(endpoint):
else:
limit = kwargs.pop("_rest_limit")
offset = kwargs.pop("_rest_offset")
result = endpoint(*args, **kwargs)
if inspect.isawaitable(result):
result = await result
result = await _call_endpoint(endpoint, *args, **kwargs)
if not isinstance(result, list):
return result
if handler_handles_pagination:
@@ -313,9 +315,7 @@ def _with_jsonable_response(endpoint):
@wraps(endpoint)
async def wrapper(*args, **kwargs):
result = endpoint(*args, **kwargs)
if inspect.isawaitable(result):
result = await result
result = await _call_endpoint(endpoint, *args, **kwargs)
if isinstance(result, Response):
return result
return jsonable_encoder(result)
app/auth/project_dependencies.py
+33 -36
View File
@@ -16,7 +16,7 @@ from app.infra.db.metadb.repositories.metadata_repository import (
MetadataRepository,
ProjectDbRouting,
)
from app.infra.db.project_routing import ActiveProjectRouting
from app.infra.db.project_routing import ActiveProjectRouting, activate_project_routing
DB_ROLE_BIZ_DATA = "biz_data"
DB_ROLE_IOT_DATA = "iot_data"
@@ -107,6 +107,14 @@ async def get_project_business_routing(
return await resolve_project_business_routing(ctx, metadata_repo)
async def use_project_business_routing(
routing: ActiveProjectRouting = Depends(get_project_business_routing),
) -> AsyncGenerator[ActiveProjectRouting, None]:
"""Keep the routed BizDB active for an entire endpoint invocation."""
with activate_project_routing(routing):
yield routing
async def resolve_project_business_routing(
ctx: ProjectContext,
metadata_repo: MetadataRepository,
@@ -189,31 +197,6 @@ async def _get_project_routing(
return routing
async def get_project_pg_session(
ctx: ProjectContext = Depends(get_project_context),
metadata_repo: MetadataRepository = Depends(get_metadata_repository),
) -> AsyncGenerator[AsyncSession, None]:
routing = await _get_project_routing(
metadata_repo,
ctx.project_id,
DB_ROLE_BIZ_DATA,
DB_TYPE_POSTGRES,
"PostgreSQL",
)
pool_min_size = routing.pool_min_size or settings.PROJECT_PG_POOL_SIZE
pool_max_size = routing.pool_max_size or settings.PROJECT_PG_POOL_SIZE
sessionmaker = await project_connection_manager.get_pg_sessionmaker(
ctx.project_id,
DB_ROLE_BIZ_DATA,
routing.dsn,
pool_min_size,
pool_max_size,
)
async with sessionmaker() as session:
yield session
async def get_project_pg_connection(
ctx: ProjectContext = Depends(get_project_context),
metadata_repo: MetadataRepository = Depends(get_metadata_repository),
@@ -226,16 +209,23 @@ async def get_project_pg_connection(
"PostgreSQL",
)
pool_min_size = routing.pool_min_size or settings.PROJECT_PG_POOL_SIZE
pool_max_size = routing.pool_max_size or settings.PROJECT_PG_POOL_SIZE
pool = await project_connection_manager.get_pg_pool(
pool_min_size = (
routing.pool_min_size
if routing.pool_min_size is not None
else settings.PROJECT_PG_POOL_MIN_SIZE
)
pool_max_size = (
routing.pool_max_size
if routing.pool_max_size is not None
else settings.PROJECT_PG_POOL_SIZE
)
async with project_connection_manager.pg_connection(
ctx.project_id,
DB_ROLE_BIZ_DATA,
routing.dsn,
pool_min_size,
pool_max_size,
)
async with pool.connection() as conn:
) as conn:
yield conn
@@ -251,14 +241,21 @@ async def get_project_timescale_connection(
"TimescaleDB",
)
pool_min_size = routing.pool_min_size or settings.PROJECT_TS_POOL_MIN_SIZE
pool_max_size = routing.pool_max_size or settings.PROJECT_TS_POOL_MAX_SIZE
pool = await project_connection_manager.get_timescale_pool(
pool_min_size = (
routing.pool_min_size
if routing.pool_min_size is not None
else settings.PROJECT_TS_POOL_MIN_SIZE
)
pool_max_size = (
routing.pool_max_size
if routing.pool_max_size is not None
else settings.PROJECT_TS_POOL_MAX_SIZE
)
async with project_connection_manager.timescale_connection(
ctx.project_id,
DB_ROLE_IOT_DATA,
routing.dsn,
pool_min_size,
pool_max_size,
)
async with pool.connection() as conn:
) as conn:
yield conn
app/core/config.py
+7 -5
View File
@@ -36,13 +36,15 @@ class Settings(BaseSettings):
METADATA_DB_POOL_SIZE: int = 5
METADATA_DB_MAX_OVERFLOW: int = 10
PROJECT_PG_CACHE_SIZE: int = 50
PROJECT_TS_CACHE_SIZE: int = 50
PROJECT_PG_CACHE_SIZE: int = 16
PROJECT_TS_CACHE_SIZE: int = 16
PROJECT_PG_POOL_MIN_SIZE: int = 0
PROJECT_PG_POOL_SIZE: int = 5
PROJECT_PG_MAX_OVERFLOW: int = 10
PROJECT_PG_POOL_SIZE: int = 4
PROJECT_PG_MAX_OVERFLOW: int = 2
PROJECT_TS_POOL_MIN_SIZE: int = 0
PROJECT_TS_POOL_MAX_SIZE: int = 10
PROJECT_TS_POOL_MAX_SIZE: int = 4
WNDB_TEMPLATE_DB_NAME: str = "tjwater_v2_template"
WNDB_TEMP_DB_MAX_COUNT: int = 8
# Keycloak access token verification
KEYCLOAK_PUBLIC_KEY: str = ""
app/infra/db/dynamic_manager.py
+250 -181
View File
@@ -1,40 +1,29 @@
import asyncio
import logging
from collections import OrderedDict
from collections.abc import AsyncIterator
from contextlib import asynccontextmanager
from dataclasses import dataclass
from typing import Dict
from uuid import UUID
from psycopg import AsyncConnection
from psycopg_pool import AsyncConnectionPool
from psycopg.rows import dict_row
from sqlalchemy.engine.url import make_url
from sqlalchemy.ext.asyncio import (
AsyncEngine,
AsyncSession,
async_sessionmaker,
create_async_engine,
)
from app.core.config import settings
logger = logging.getLogger(__name__)
_check_async_connection = AsyncConnectionPool.check_connection
@dataclass(frozen=True)
class PgEngineEntry:
engine: AsyncEngine
sessionmaker: async_sessionmaker[AsyncSession]
connection_url: str
pool_min_size: int
pool_max_size: int
@dataclass(frozen=True)
@dataclass
class PoolEntry:
pool: AsyncConnectionPool
connection_url: str
pool_min_size: int
pool_max_size: int
borrow_count: int = 0
@dataclass(frozen=True)
@@ -45,186 +34,203 @@ class CacheKey:
class ProjectConnectionManager:
def __init__(self) -> None:
self._pg_cache: Dict[CacheKey, PgEngineEntry] = OrderedDict()
self._ts_cache: Dict[CacheKey, PoolEntry] = OrderedDict()
self._pg_raw_cache: Dict[CacheKey, PoolEntry] = OrderedDict()
self._pg_lock = asyncio.Lock()
self._retired_ts: list[tuple[CacheKey, PoolEntry]] = []
self._retired_pg: list[tuple[CacheKey, PoolEntry]] = []
self._ts_lock = asyncio.Lock()
self._pg_raw_lock = asyncio.Lock()
def _normalize_pg_url(self, url: str) -> str:
parsed = make_url(url)
if parsed.drivername in {"postgresql", "postgres"}:
parsed = parsed.set(drivername="postgresql+psycopg")
return parsed.render_as_string(hide_password=False)
async def get_pg_sessionmaker(
async def _get_timescale_pool_locked(
self,
project_id: UUID,
db_role: str,
connection_url: str,
pool_min_size: int,
pool_max_size: int,
) -> async_sessionmaker[AsyncSession]:
async with self._pg_lock:
normalized_url = self._normalize_pg_url(connection_url)
pool_min_size = max(1, pool_min_size)
pool_max_size = max(pool_min_size, pool_max_size)
key = CacheKey(project_id=project_id, db_role=db_role)
entry = self._pg_cache.get(key)
if entry:
if (
entry.connection_url == normalized_url
and entry.pool_min_size == pool_min_size
and entry.pool_max_size == pool_max_size
):
self._pg_cache.move_to_end(key)
return entry.sessionmaker
await entry.engine.dispose()
logger.info(
"Rebuilding PostgreSQL engine for project %s (%s) due to config change",
project_id,
db_role,
)
self._pg_cache.pop(key, None)
engine = create_async_engine(
normalized_url,
pool_size=pool_min_size,
max_overflow=max(0, pool_max_size - pool_min_size),
pool_pre_ping=True,
)
sessionmaker = async_sessionmaker(engine, expire_on_commit=False)
self._pg_cache[key] = PgEngineEntry(
engine=engine,
sessionmaker=sessionmaker,
connection_url=normalized_url,
pool_min_size=pool_min_size,
pool_max_size=pool_max_size,
)
await self._evict_pg_if_needed()
) -> tuple[CacheKey, AsyncConnectionPool]:
pool_min_size = max(0, pool_min_size)
pool_max_size = max(1, pool_min_size, pool_max_size)
key = CacheKey(project_id=project_id, db_role=db_role)
entry = self._ts_cache.get(key)
if entry:
if (
entry.connection_url == connection_url
and entry.pool_min_size == pool_min_size
and entry.pool_max_size == pool_max_size
):
self._ts_cache.move_to_end(key)
return key, entry.pool
logger.info(
"Created PostgreSQL engine for project %s (%s)", project_id, db_role
"Rebuilding TimescaleDB pool for project %s (%s) due to config change",
project_id,
db_role,
)
return sessionmaker
async def get_timescale_pool(
self,
project_id: UUID,
db_role: str,
connection_url: str,
pool_min_size: int,
pool_max_size: int,
) -> AsyncConnectionPool:
async with self._ts_lock:
pool_min_size = max(1, pool_min_size)
pool_max_size = max(pool_min_size, pool_max_size)
key = CacheKey(project_id=project_id, db_role=db_role)
entry = self._ts_cache.get(key)
if entry:
if (
entry.connection_url == connection_url
and entry.pool_min_size == pool_min_size
and entry.pool_max_size == pool_max_size
):
self._ts_cache.move_to_end(key)
return entry.pool
pool = AsyncConnectionPool(
conninfo=connection_url,
min_size=pool_min_size,
max_size=pool_max_size,
open=False,
kwargs={"row_factory": dict_row},
check=_check_async_connection,
)
await pool.open()
if entry is not None:
if entry.borrow_count:
self._retired_ts.append((key, entry))
else:
await entry.pool.close()
logger.info(
"Rebuilding TimescaleDB pool for project %s (%s) due to config change",
project_id,
db_role,
)
self._ts_cache.pop(key, None)
self._ts_cache[key] = PoolEntry(
pool=pool,
connection_url=connection_url,
pool_min_size=pool_min_size,
pool_max_size=pool_max_size,
)
logger.info("Created TimescaleDB pool for project %s (%s)", project_id, db_role)
return key, pool
pool = AsyncConnectionPool(
conninfo=connection_url,
min_size=pool_min_size,
max_size=pool_max_size,
open=False,
kwargs={"row_factory": dict_row},
)
await pool.open()
self._ts_cache[key] = PoolEntry(
pool=pool,
connection_url=connection_url,
pool_min_size=pool_min_size,
pool_max_size=pool_max_size,
)
await self._evict_ts_if_needed()
logger.info(
"Created TimescaleDB pool for project %s (%s)", project_id, db_role
)
return pool
async def get_pg_pool(
async def _get_pg_pool_locked(
self,
project_id: UUID,
db_role: str,
connection_url: str,
pool_min_size: int,
pool_max_size: int,
) -> AsyncConnectionPool:
) -> tuple[CacheKey, AsyncConnectionPool]:
pool_min_size = max(0, pool_min_size)
pool_max_size = max(1, pool_min_size, pool_max_size)
key = CacheKey(project_id=project_id, db_role=db_role)
entry = self._pg_raw_cache.get(key)
if entry:
if (
entry.connection_url == connection_url
and entry.pool_min_size == pool_min_size
and entry.pool_max_size == pool_max_size
):
self._pg_raw_cache.move_to_end(key)
return key, entry.pool
logger.info(
"Rebuilding PostgreSQL pool for project %s (%s) due to config change",
project_id,
db_role,
)
pool = AsyncConnectionPool(
conninfo=connection_url,
min_size=pool_min_size,
max_size=pool_max_size,
open=False,
kwargs={"row_factory": dict_row},
check=_check_async_connection,
)
await pool.open()
if entry is not None:
if entry.borrow_count:
self._retired_pg.append((key, entry))
else:
await entry.pool.close()
self._pg_raw_cache[key] = PoolEntry(
pool=pool,
connection_url=connection_url,
pool_min_size=pool_min_size,
pool_max_size=pool_max_size,
)
logger.info("Created PostgreSQL pool for project %s (%s)", project_id, db_role)
return key, pool
@asynccontextmanager
async def pg_connection(
self,
project_id: UUID,
db_role: str,
connection_url: str,
pool_min_size: int,
pool_max_size: int,
) -> AsyncIterator[AsyncConnection]:
async with self._pg_raw_lock:
pool_min_size = max(1, pool_min_size)
pool_max_size = max(pool_min_size, pool_max_size)
key = CacheKey(project_id=project_id, db_role=db_role)
entry = self._pg_raw_cache.get(key)
if entry:
if (
entry.connection_url == connection_url
and entry.pool_min_size == pool_min_size
and entry.pool_max_size == pool_max_size
):
self._pg_raw_cache.move_to_end(key)
return entry.pool
await entry.pool.close()
logger.info(
"Rebuilding PostgreSQL pool for project %s (%s) due to config change",
project_id,
db_role,
)
self._pg_raw_cache.pop(key, None)
pool = AsyncConnectionPool(
conninfo=connection_url,
min_size=pool_min_size,
max_size=pool_max_size,
open=False,
kwargs={"row_factory": dict_row},
)
await pool.open()
self._pg_raw_cache[key] = PoolEntry(
pool=pool,
connection_url=connection_url,
pool_min_size=pool_min_size,
pool_max_size=pool_max_size,
key, pool = await self._get_pg_pool_locked(
project_id,
db_role,
connection_url,
pool_min_size,
pool_max_size,
)
borrowed_entry = self._pg_raw_cache[key]
borrowed_entry.borrow_count += 1
await self._evict_pg_raw_if_needed()
logger.info(
"Created PostgreSQL pool for project %s (%s)", project_id, db_role
)
return pool
async def _evict_pg_if_needed(self) -> None:
while len(self._pg_cache) > settings.PROJECT_PG_CACHE_SIZE:
key, entry = self._pg_cache.popitem(last=False)
await entry.engine.dispose()
logger.info(
"Evicted PostgreSQL engine for project %s (%s)",
key.project_id,
key.db_role,
)
try:
async with pool.connection() as conn:
yield conn
finally:
async with self._pg_raw_lock:
borrowed_entry.borrow_count -= 1
if borrowed_entry.borrow_count == 0 and borrowed_entry.pool is not (
self._pg_raw_cache.get(key).pool
if key in self._pg_raw_cache
else None
):
self._retired_pg = [
item for item in self._retired_pg if item[1] is not borrowed_entry
]
await borrowed_entry.pool.close()
await self._evict_pg_raw_if_needed()
async def _evict_ts_if_needed(self) -> None:
@asynccontextmanager
async def timescale_connection(
self,
project_id: UUID,
db_role: str,
connection_url: str,
pool_min_size: int,
pool_max_size: int,
) -> AsyncIterator[AsyncConnection]:
async with self._ts_lock:
key, pool = await self._get_timescale_pool_locked(
project_id,
db_role,
connection_url,
pool_min_size,
pool_max_size,
)
borrowed_entry = self._ts_cache[key]
borrowed_entry.borrow_count += 1
await self._evict_ts_if_needed()
try:
async with pool.connection() as conn:
yield conn
finally:
async with self._ts_lock:
borrowed_entry.borrow_count -= 1
if borrowed_entry.borrow_count == 0 and borrowed_entry.pool is not (
self._ts_cache.get(key).pool
if key in self._ts_cache
else None
):
self._retired_ts = [
item for item in self._retired_ts if item[1] is not borrowed_entry
]
await borrowed_entry.pool.close()
await self._evict_ts_if_needed()
async def _evict_ts_if_needed(
self, protected_key: CacheKey | None = None
) -> None:
while len(self._ts_cache) > settings.PROJECT_TS_CACHE_SIZE:
key, entry = self._ts_cache.popitem(last=False)
idle = next(
(
(key, entry)
for key, entry in self._ts_cache.items()
if entry.borrow_count == 0 and key != protected_key
),
None,
)
if idle is None:
return
key, entry = idle
self._ts_cache.pop(key)
await entry.pool.close()
logger.info(
"Evicted TimescaleDB pool for project %s (%s)",
@@ -232,9 +238,22 @@ class ProjectConnectionManager:
key.db_role,
)
async def _evict_pg_raw_if_needed(self) -> None:
async def _evict_pg_raw_if_needed(
self, protected_key: CacheKey | None = None
) -> None:
while len(self._pg_raw_cache) > settings.PROJECT_PG_CACHE_SIZE:
key, entry = self._pg_raw_cache.popitem(last=False)
idle = next(
(
(key, entry)
for key, entry in self._pg_raw_cache.items()
if entry.borrow_count == 0 and key != protected_key
),
None,
)
if idle is None:
return
key, entry = idle
self._pg_raw_cache.pop(key)
await entry.pool.close()
logger.info(
"Evicted PostgreSQL pool for project %s (%s)",
@@ -242,17 +261,61 @@ class ProjectConnectionManager:
key.db_role,
)
async def close_all(self) -> None:
async with self._pg_lock:
for key, entry in list(self._pg_cache.items()):
await entry.engine.dispose()
logger.info(
"Closed PostgreSQL engine for project %s (%s)",
key.project_id,
key.db_role,
)
self._pg_cache.clear()
async def close_project(
self, project_id: UUID, db_role: str | None = None
) -> bool:
"""Close this worker's idle pools for a project.
Returns ``False`` without interrupting requests when any matching pool is
currently borrowed. Callers may retry after those requests complete.
"""
closed = True
for cache, lock, label in (
(self._ts_cache, self._ts_lock, "TimescaleDB"),
(self._pg_raw_cache, self._pg_raw_lock, "PostgreSQL"),
):
async with lock:
keys = [
key
for key in cache
if key.project_id == project_id
and (db_role is None or key.db_role == db_role)
]
for key in keys:
entry = cache[key]
if entry.borrow_count:
closed = False
continue
cache.pop(key)
await entry.pool.close()
logger.info(
"Closed %s pool for project %s (%s)",
label,
key.project_id,
key.db_role,
)
for retired, lock in (
(self._retired_ts, self._ts_lock),
(self._retired_pg, self._pg_raw_lock),
):
async with lock:
matches = [
item
for item in retired
if item[0].project_id == project_id
and (db_role is None or item[0].db_role == db_role)
]
if any(entry.borrow_count for _key, entry in matches):
closed = False
for item in matches:
key, entry = item
if entry.borrow_count:
continue
retired.remove(item)
await entry.pool.close()
return closed
async def close_all(self) -> None:
async with self._ts_lock:
for key, entry in list(self._ts_cache.items()):
await entry.pool.close()
@@ -262,6 +325,9 @@ class ProjectConnectionManager:
key.db_role,
)
self._ts_cache.clear()
for _key, entry in self._retired_ts:
await entry.pool.close()
self._retired_ts.clear()
async with self._pg_raw_lock:
for key, entry in list(self._pg_raw_cache.items()):
@@ -272,6 +338,9 @@ class ProjectConnectionManager:
key.db_role,
)
self._pg_raw_cache.clear()
for _key, entry in self._retired_pg:
await entry.pool.close()
self._retired_pg.clear()
project_connection_manager = ProjectConnectionManager()
app/infra/db/project_routing.py
+30 -2
View File
@@ -5,9 +5,9 @@ from contextvars import ContextVar, Token
from dataclasses import dataclass
from typing import Iterator
from psycopg.conninfo import make_conninfo
from psycopg.conninfo import conninfo_to_dict, make_conninfo
from app.core.config import get_pgconn_string, get_timescaledb_pgconn_string
from app.core.config import get_pgconn_string, get_timescaledb_pgconn_string, settings
@dataclass(frozen=True)
@@ -16,6 +16,17 @@ class ActiveProjectRouting:
business_dsn: str
timescale_dsn: str | None = None
@property
def business_database_name(self) -> str:
"""Return the physical BizDB name selected by metadata routing."""
database_name = conninfo_to_dict(self.business_dsn).get("dbname")
if not database_name:
raise RuntimeError(
f"Business database routing for project {self.project_code!r} "
"does not contain a database name"
)
return database_name
_active_project_routing: ContextVar[ActiveProjectRouting | None] = ContextVar(
"active_project_routing",
@@ -42,6 +53,23 @@ def _dsn_for_database(dsn: str, database_name: str) -> str:
return make_conninfo(dsn, dbname=database_name)
def get_project_database_name(name: str) -> str:
"""Resolve a logical project code to its routed physical BizDB name."""
routing = get_active_project_routing()
if routing is not None and name == routing.project_code:
return routing.business_database_name
return name
def get_project_template_database_name(name: str | None = None) -> str:
"""Return the configured immutable template for the WNDB schema version.
The template belongs to the database schema version, not to an individual
logical project or its temporary physical database name.
"""
return settings.WNDB_TEMPLATE_DB_NAME
def get_project_pgconn_string(db_name: str | None = None) -> str:
routing = get_active_project_routing()
if routing is None:
app/infra/db/timescaledb/composite_queries.py
+111 -83
View File
@@ -56,38 +56,40 @@ class CompositeQueries:
Raises:
ValueError: 当 SCADA 设备未找到或字段无效时
"""
result = {}
scada_by_id = await CompositeQueries._get_project_scada_index(postgres_conn)
link_devices: dict[str, str] = {}
node_devices: dict[str, str] = {}
for device_id in device_ids:
target_scada = scada_by_id.get(device_id)
if not target_scada:
raise ValueError(f"SCADA device {device_id} not found")
scada_type = target_scada["device_type"]
element_id = (
target_scada["link_id"]
if scada_type in {"pipe_flow", "flow"}
else target_scada["node_id"]
)
if scada_type == "pipe_flow":
# 查询 link 模拟数据
res = await RealtimeRepository.get_link_field_by_time_range(
timescale_conn, start_time, end_time, element_id, "flow"
)
if scada_type in {"pipe_flow", "flow"}:
link_devices[device_id] = target_scada["link_id"]
elif scada_type == "pressure":
# 查询 node 模拟数据
res = await RealtimeRepository.get_node_field_by_time_range(
timescale_conn, start_time, end_time, element_id, "pressure"
)
node_devices[device_id] = target_scada["node_id"]
else:
raise ValueError(f"Unknown SCADA type: {scada_type}")
# 添加 scada_id 到每个数据项
for item in res:
item["scada_id"] = device_id
result[device_id] = res
return result
link_series = await RealtimeRepository.get_link_fields_by_ids_time_range(
timescale_conn, start_time, end_time,
list(dict.fromkeys(link_devices.values())), "flow",
)
node_series = await RealtimeRepository.get_node_fields_by_ids_time_range(
timescale_conn, start_time, end_time,
list(dict.fromkeys(node_devices.values())), "pressure",
)
return {
device_id: [
{**item, "scada_id": device_id}
for item in (
link_series.get(element_id, [])
if device_id in link_devices
else node_series.get(element_id, [])
)
]
for device_id, element_id in (link_devices | node_devices).items()
}
@staticmethod
async def get_scada_associated_analysis_simulation_data(
@@ -117,38 +119,41 @@ class CompositeQueries:
Raises:
ValueError: 当 SCADA 设备未找到或字段无效时
"""
result = {}
scada_by_id = await CompositeQueries._get_project_scada_index(postgres_conn)
link_devices: dict[str, str] = {}
node_devices: dict[str, str] = {}
for device_id in device_ids:
target_scada = scada_by_id.get(device_id)
if not target_scada:
raise ValueError(f"SCADA device {device_id} not found")
scada_type = target_scada["device_type"]
element_id = (
target_scada["link_id"]
if scada_type in {"pipe_flow", "flow"}
else target_scada["node_id"]
)
if scada_type == "pipe_flow":
# 查询 link 模拟数据
res = await AnalysisResultsRepository.get_link_series(
timescale_conn, run_id, element_id, start_time, end_time, "flow"
)
if scada_type in {"pipe_flow", "flow"}:
link_devices[device_id] = target_scada["link_id"]
elif scada_type == "pressure":
# 查询 node 模拟数据
res = await AnalysisResultsRepository.get_node_series(
timescale_conn, run_id, element_id, start_time, end_time, "pressure"
)
node_devices[device_id] = target_scada["node_id"]
else:
raise ValueError(f"Unknown SCADA type: {scada_type}")
# 添加 scada_id 到每个数据项
for item in res:
item["scada_id"] = device_id
result[device_id] = res
return result
link_series = await AnalysisResultsRepository.get_series_by_ids(
timescale_conn, run_id, "link",
list(dict.fromkeys(link_devices.values())), start_time, end_time, "flow",
)
node_series = await AnalysisResultsRepository.get_series_by_ids(
timescale_conn, run_id, "node",
list(dict.fromkeys(node_devices.values())), start_time, end_time, "pressure",
)
return {
device_id: [
{**item, "scada_id": device_id}
for item in (
link_series.get(element_id, [])
if device_id in link_devices
else node_series.get(element_id, [])
)
]
for device_id, element_id in (link_devices | node_devices).items()
}
@staticmethod
async def get_realtime_simulation_data(
@@ -175,26 +180,33 @@ class CompositeQueries:
Raises:
ValueError: 当 SCADA 设备未找到或字段无效时
"""
result = {}
pipe_ids: list[str] = []
junction_ids: list[str] = []
for feature_id, feature_type in feature_infos:
if feature_type.lower() == "pipe":
# 查询 link 模拟数据
res = await RealtimeRepository.get_link_field_by_time_range(
timescale_conn, start_time, end_time, feature_id, "flow"
)
pipe_ids.append(feature_id)
elif feature_type.lower() == "junction":
# 查询 node 模拟数据
res = await RealtimeRepository.get_node_field_by_time_range(
timescale_conn, start_time, end_time, feature_id, "pressure"
)
junction_ids.append(feature_id)
else:
raise ValueError(f"Unknown type: {feature_type}")
# 添加 scada_id 到每个数据项
for item in res:
item["feature_id"] = feature_id
result[feature_id] = res
return result
link_series = await RealtimeRepository.get_link_fields_by_ids_time_range(
timescale_conn, start_time, end_time, list(dict.fromkeys(pipe_ids)), "flow"
)
node_series = await RealtimeRepository.get_node_fields_by_ids_time_range(
timescale_conn, start_time, end_time,
list(dict.fromkeys(junction_ids)), "pressure",
)
return {
feature_id: [
{**item, "feature_id": feature_id}
for item in (
link_series.get(feature_id, [])
if feature_type.lower() == "pipe"
else node_series.get(feature_id, [])
)
]
for feature_id, feature_type in feature_infos
}
@staticmethod
async def get_analysis_simulation_data(
@@ -223,25 +235,34 @@ class CompositeQueries:
Raises:
ValueError: 当类型无效时
"""
result = {}
pipe_ids: list[str] = []
junction_ids: list[str] = []
for feature_id, feature_type in feature_infos:
if feature_type.lower() == "pipe":
# 查询 link 模拟数据
res = await AnalysisResultsRepository.get_link_series(
timescale_conn, run_id, feature_id, start_time, end_time, "flow"
)
pipe_ids.append(feature_id)
elif feature_type.lower() == "junction":
# 查询 node 模拟数据
res = await AnalysisResultsRepository.get_node_series(
timescale_conn, run_id, feature_id, start_time, end_time, "pressure"
)
junction_ids.append(feature_id)
else:
raise ValueError(f"Unknown type: {feature_type}")
# 添加 feature_id 到每个数据项
for item in res:
item["feature_id"] = feature_id
result[feature_id] = res
return result
link_series = await AnalysisResultsRepository.get_series_by_ids(
timescale_conn, run_id, "link", list(dict.fromkeys(pipe_ids)),
start_time, end_time, "flow",
)
node_series = await AnalysisResultsRepository.get_series_by_ids(
timescale_conn, run_id, "node", list(dict.fromkeys(junction_ids)),
start_time, end_time, "pressure",
)
return {
feature_id: [
{**item, "feature_id": feature_id}
for item in (
link_series.get(feature_id, [])
if feature_type.lower() == "pipe"
else node_series.get(feature_id, [])
)
]
for feature_id, feature_type in feature_infos
}
@staticmethod
async def get_element_associated_scada_data(
@@ -399,7 +420,7 @@ class CompositeQueries:
if scada_by_id[device_id]["device_type"] in {"pipe_flow", "flow"}
]
updated_rows = 0
cleaned_rows: list[tuple[datetime, str, float | None]] = []
for grouped_ids, cleaning_function in (
(pressure_ids, clean_pressure_data_df_km),
(flow_ids, clean_flow_data_df_kf),
@@ -422,18 +443,25 @@ class CompositeQueries:
if isinstance(time_value, datetime)
else datetime.fromisoformat(str(time_value))
)
await ScadaRepository.update_scada_field(
timescale_conn,
time_dt,
device_id,
"cleaned_value",
value,
cleaned_rows.append(
(
time_dt,
device_id,
None if pd.isna(value) else float(value),
)
)
updated_rows += 1
if updated_rows == 0:
if not cleaned_rows:
raise ValueError("SCADA 数据清洗未产生任何数据库更新")
updated_rows = await ScadaRepository.update_scada_field_batch(
timescale_conn,
cleaned_rows,
"cleaned_value",
)
if updated_rows == 0:
raise ValueError("SCADA 清洗结果未匹配任何已有监测数据")
return "success"
@staticmethod
app/infra/db/timescaledb/internal_queries.py
+3 -2
View File
@@ -259,7 +259,7 @@ class InternalQueries:
query = sql.SQL(
"SELECT btrim({}::text) AS id, time, {} FROM {}.{} "
"WHERE run_id = %s AND time >= %s AND time <= %s "
"AND btrim({}::text) = ANY(%s)"
"AND btrim({}::text) = ANY(%s) ORDER BY id, time"
).format(
sql.Identifier(id_column),
sql.Identifier(field),
@@ -274,7 +274,8 @@ class InternalQueries:
else:
query = sql.SQL(
"SELECT btrim({}::text) AS id, time, {} FROM {}.{} "
"WHERE time >= %s AND time <= %s AND btrim({}::text) = ANY(%s)"
"WHERE time >= %s AND time <= %s "
"AND btrim({}::text) = ANY(%s) ORDER BY id, time"
).format(
sql.Identifier(id_column),
sql.Identifier(field),
app/infra/db/timescaledb/repositories/analysis.py
+47
View File
@@ -175,6 +175,53 @@ class AnalysisResultsRepository:
await cur.execute(query, (run_id, link_id, start_time, end_time))
return await cur.fetchall()
@staticmethod
async def get_series_by_ids(
conn: AsyncConnection,
run_id: UUID,
element_type: str,
element_ids: list[str],
start_time: datetime,
end_time: datetime,
field: str,
) -> dict[str, list[dict[str, Any]]]:
if element_type == "node":
table_name, id_column, valid_fields = (
"node_results", "node_id", AnalysisResultsRepository.NODE_FIELDS
)
elif element_type == "link":
table_name, id_column, valid_fields = (
"link_results", "link_id", AnalysisResultsRepository.LINK_FIELDS
)
else:
raise ValueError(f"invalid analysis element type: {element_type}")
if field not in valid_fields:
raise ValueError(f"invalid {element_type} result field: {field}")
result: dict[str, list[dict[str, Any]]] = {
element_id: [] for element_id in element_ids
}
if not element_ids:
return result
query = sql.SQL(
"SELECT {} AS element_id, time, {} AS value FROM analysis.{} "
"WHERE run_id = %s AND {} = ANY(%s) AND time BETWEEN %s AND %s "
"ORDER BY {}, time"
).format(
sql.Identifier(id_column),
sql.Identifier(field),
sql.Identifier(table_name),
sql.Identifier(id_column),
sql.Identifier(id_column),
)
async with conn.cursor() as cur:
await cur.execute(query, (run_id, element_ids, start_time, end_time))
for row in await cur.fetchall():
result.setdefault(str(row["element_id"]), []).append(
{"time": row["time"], "value": row["value"]}
)
return result
@staticmethod
async def get_values_at_time(
conn: AsyncConnection,
app/infra/db/timescaledb/repositories/realtime.py
+120 -20
View File
@@ -7,6 +7,19 @@ from app.services.time_api import parse_utc_time
class RealtimeRepository:
@staticmethod
def _batch_time(data: List[dict]) -> datetime:
"""Return one normalized timestamp shared by every row in a snapshot."""
if not data:
raise ValueError("Realtime batch must not be empty")
times = {
parse_utc_time(item["time"], field_name="time")
for item in data
}
if len(times) != 1:
raise ValueError("Realtime batch must contain exactly one timestamp")
return times.pop()
# --- Link Simulation ---
@staticmethod
@@ -15,8 +28,7 @@ class RealtimeRepository:
if not data:
return
# 假设同一批次的数据时间是相同的
target_time = data[0]["time"]
target_time = RealtimeRepository._batch_time(data)
# 使用事务确保原子性
async with conn.transaction():
@@ -38,7 +50,7 @@ class RealtimeRepository:
for item in data:
await copy.write_row(
(
item["time"],
target_time,
item["id"],
item.get("flow"),
item.get("friction"),
@@ -57,8 +69,7 @@ class RealtimeRepository:
if not data:
return
# 假设同一批次的数据时间是相同的
target_time = data[0]["time"]
target_time = RealtimeRepository._batch_time(data)
# 使用事务确保原子性
with conn.transaction():
@@ -80,7 +91,7 @@ class RealtimeRepository:
for item in data:
copy.write_row(
(
item["time"],
target_time,
item["id"],
item.get("flow"),
item.get("friction"),
@@ -99,7 +110,8 @@ class RealtimeRepository:
) -> List[dict]:
async with conn.cursor() as cur:
await cur.execute(
"SELECT * FROM realtime.link_results WHERE time >= %s AND time <= %s AND link_id = %s",
"SELECT * FROM realtime.link_results WHERE time >= %s AND time <= %s "
"AND link_id = %s ORDER BY time",
(start_time, end_time, link_id),
)
return await cur.fetchall()
@@ -112,7 +124,8 @@ class RealtimeRepository:
normalized_end_time = parse_utc_time(end_time, field_name="end_time")
async with conn.cursor() as cur:
await cur.execute(
"SELECT * FROM realtime.link_results WHERE time >= %s AND time <= %s",
"SELECT * FROM realtime.link_results WHERE time >= %s AND time <= %s "
"ORDER BY time, link_id",
(normalized_start_time, normalized_end_time),
)
return await cur.fetchall()
@@ -140,7 +153,8 @@ class RealtimeRepository:
raise ValueError(f"Invalid field: {field}")
query = sql.SQL(
"SELECT time, {} FROM realtime.link_results WHERE time >= %s AND time <= %s AND link_id = %s"
"SELECT time, {} FROM realtime.link_results WHERE time >= %s "
"AND time <= %s AND link_id = %s ORDER BY time"
).format(sql.Identifier(field))
async with conn.cursor() as cur:
@@ -150,6 +164,36 @@ class RealtimeRepository:
{"time": row["time"].isoformat(), "value": row[field]} for row in rows
]
@staticmethod
async def get_link_fields_by_ids_time_range(
conn: AsyncConnection,
start_time: datetime,
end_time: datetime,
link_ids: list[str],
field: str,
) -> dict[str, list[dict[str, Any]]]:
valid_fields = {
"flow", "friction", "headloss", "quality", "reaction",
"setting", "status", "velocity",
}
if field not in valid_fields:
raise ValueError(f"Invalid field: {field}")
result = {link_id: [] for link_id in link_ids}
if not link_ids:
return result
query = sql.SQL(
"SELECT link_id, time, {} FROM realtime.link_results "
"WHERE time BETWEEN %s AND %s AND link_id = ANY(%s) "
"ORDER BY link_id, time"
).format(sql.Identifier(field))
async with conn.cursor() as cur:
await cur.execute(query, (start_time, end_time, link_ids))
for row in await cur.fetchall():
result.setdefault(str(row["link_id"]), []).append(
{"time": row["time"].isoformat(), "value": row[field]}
)
return result
@staticmethod
async def get_links_field_by_time_range(
conn: AsyncConnection,
@@ -172,7 +216,8 @@ class RealtimeRepository:
raise ValueError(f"Invalid field: {field}")
query = sql.SQL(
"SELECT link_id, time, {} FROM realtime.link_results WHERE time >= %s AND time <= %s"
"SELECT link_id, time, {} FROM realtime.link_results "
"WHERE time >= %s AND time <= %s ORDER BY link_id, time"
).format(sql.Identifier(field))
async with conn.cursor() as cur:
@@ -230,8 +275,7 @@ class RealtimeRepository:
if not data:
return
# 假设同一批次的数据时间是相同的
target_time = data[0]["time"]
target_time = RealtimeRepository._batch_time(data)
# 使用事务确保原子性
async with conn.transaction():
@@ -253,7 +297,7 @@ class RealtimeRepository:
for item in data:
await copy.write_row(
(
item["time"],
target_time,
item["id"],
item.get("actual_demand"),
item.get("total_head"),
@@ -267,8 +311,7 @@ class RealtimeRepository:
if not data:
return
# 假设同一批次的数据时间是相同的
target_time = data[0]["time"]
target_time = RealtimeRepository._batch_time(data)
# 使用事务确保原子性
with conn.transaction():
@@ -290,7 +333,7 @@ class RealtimeRepository:
for item in data:
copy.write_row(
(
item["time"],
target_time,
item["id"],
item.get("actual_demand"),
item.get("total_head"),
@@ -305,7 +348,8 @@ class RealtimeRepository:
) -> List[dict]:
async with conn.cursor() as cur:
await cur.execute(
"SELECT * FROM realtime.node_results WHERE time >= %s AND time <= %s AND node_id = %s",
"SELECT * FROM realtime.node_results WHERE time >= %s AND time <= %s "
"AND node_id = %s ORDER BY time",
(start_time, end_time, node_id),
)
return await cur.fetchall()
@@ -318,7 +362,8 @@ class RealtimeRepository:
normalized_end_time = parse_utc_time(end_time, field_name="end_time")
async with conn.cursor() as cur:
await cur.execute(
"SELECT * FROM realtime.node_results WHERE time >= %s AND time <= %s",
"SELECT * FROM realtime.node_results WHERE time >= %s AND time <= %s "
"ORDER BY time, node_id",
(normalized_start_time, normalized_end_time),
)
return await cur.fetchall()
@@ -336,7 +381,8 @@ class RealtimeRepository:
raise ValueError(f"Invalid field: {field}")
query = sql.SQL(
"SELECT time, {} FROM realtime.node_results WHERE time >= %s AND time <= %s AND node_id = %s"
"SELECT time, {} FROM realtime.node_results WHERE time >= %s "
"AND time <= %s AND node_id = %s ORDER BY time"
).format(sql.Identifier(field))
async with conn.cursor() as cur:
@@ -346,6 +392,33 @@ class RealtimeRepository:
{"time": row["time"].isoformat(), "value": row[field]} for row in rows
]
@staticmethod
async def get_node_fields_by_ids_time_range(
conn: AsyncConnection,
start_time: datetime,
end_time: datetime,
node_ids: list[str],
field: str,
) -> dict[str, list[dict[str, Any]]]:
valid_fields = {"actual_demand", "total_head", "pressure", "quality"}
if field not in valid_fields:
raise ValueError(f"Invalid field: {field}")
result = {node_id: [] for node_id in node_ids}
if not node_ids:
return result
query = sql.SQL(
"SELECT node_id, time, {} FROM realtime.node_results "
"WHERE time BETWEEN %s AND %s AND node_id = ANY(%s) "
"ORDER BY node_id, time"
).format(sql.Identifier(field))
async with conn.cursor() as cur:
await cur.execute(query, (start_time, end_time, node_ids))
for row in await cur.fetchall():
result.setdefault(str(row["node_id"]), []).append(
{"time": row["time"].isoformat(), "value": row[field]}
)
return result
@staticmethod
async def get_nodes_field_by_time_range(
conn: AsyncConnection, start_time: datetime, end_time: datetime, field: str
@@ -355,7 +428,8 @@ class RealtimeRepository:
raise ValueError(f"Invalid field: {field}")
query = sql.SQL(
"SELECT node_id, time, {} FROM realtime.node_results WHERE time >= %s AND time <= %s"
"SELECT node_id, time, {} FROM realtime.node_results "
"WHERE time >= %s AND time <= %s ORDER BY node_id, time"
).format(sql.Identifier(field))
async with conn.cursor() as cur:
@@ -459,6 +533,19 @@ class RealtimeRepository:
# transactions (savepoints), while this outer transaction guarantees
# that a link write failure also rolls back the node replacement.
async with conn.transaction():
async with conn.cursor() as cur:
await cur.execute(
"SELECT pg_advisory_xact_lock(hashtextextended(%s::text, 1))",
(simulation_time,),
)
await cur.execute(
"DELETE FROM realtime.node_results WHERE time = %s",
(simulation_time,),
)
await cur.execute(
"DELETE FROM realtime.link_results WHERE time = %s",
(simulation_time,),
)
if node_data:
await RealtimeRepository.insert_nodes_batch(conn, node_data)
@@ -525,6 +612,19 @@ class RealtimeRepository:
# transactions (savepoints), while this outer transaction guarantees
# that a link write failure also rolls back the node replacement.
with conn.transaction():
with conn.cursor() as cur:
cur.execute(
"SELECT pg_advisory_xact_lock(hashtextextended(%s::text, 1))",
(simulation_time,),
)
cur.execute(
"DELETE FROM realtime.node_results WHERE time = %s",
(simulation_time,),
)
cur.execute(
"DELETE FROM realtime.link_results WHERE time = %s",
(simulation_time,),
)
if node_data:
RealtimeRepository.insert_nodes_batch_sync(conn, node_data)
app/infra/db/timescaledb/repositories/scada.py
+32 -3
View File
@@ -35,7 +35,8 @@ class ScadaRepository:
) -> List[dict]:
async with conn.cursor() as cur:
await cur.execute(
"SELECT * FROM scada.measurements WHERE device_id = ANY(%s) AND time >= %s AND time <= %s",
"SELECT * FROM scada.measurements WHERE device_id = ANY(%s) "
"AND time >= %s AND time <= %s ORDER BY device_id, time",
(device_ids, start_time, end_time),
)
return await cur.fetchall()
@@ -49,7 +50,8 @@ class ScadaRepository:
) -> List[dict]:
with conn.cursor(row_factory=dict_row) as cur:
cur.execute(
"SELECT * FROM scada.measurements WHERE device_id = ANY(%s) AND time >= %s AND time <= %s",
"SELECT * FROM scada.measurements WHERE device_id = ANY(%s) "
"AND time >= %s AND time <= %s ORDER BY device_id, time",
(device_ids, start_time, end_time),
)
return cur.fetchall()
@@ -88,7 +90,9 @@ class ScadaRepository:
raise ValueError(f"Invalid field: {field}")
query = sql.SQL(
"SELECT device_id, time, {} FROM scada.measurements WHERE time >= %s AND time <= %s AND device_id = ANY(%s)"
"SELECT device_id, time, {} FROM scada.measurements "
"WHERE time >= %s AND time <= %s AND device_id = ANY(%s) "
"ORDER BY device_id, time"
).format(sql.Identifier(field))
async with conn.cursor() as cur:
@@ -122,6 +126,31 @@ class ScadaRepository:
if cur.rowcount == 0:
await cur.execute(insert_query, (time, device_id, value))
@staticmethod
async def update_scada_field_batch(
conn: AsyncConnection,
rows: list[tuple[datetime, str, float | None]],
field: str,
) -> int:
"""Update existing SCADA samples in one set-based statement."""
valid_fields = {"monitored_value", "cleaned_value"}
if field not in valid_fields:
raise ValueError(f"Invalid field: {field}")
if not rows:
return 0
query = sql.SQL(
"UPDATE scada.measurements AS measurement SET {} = batch.value "
"FROM unnest(%s::timestamptz[], %s::text[], %s::double precision[]) "
"AS batch(time, device_id, value) "
"WHERE measurement.time = batch.time "
"AND measurement.device_id = batch.device_id"
).format(sql.Identifier(field))
times, device_ids, values = zip(*rows)
async with conn.cursor() as cur:
await cur.execute(query, (list(times), list(device_ids), list(values)))
return cur.rowcount
@staticmethod
async def delete_scada_by_id_time_range(
conn: AsyncConnection, device_id: str, start_time: datetime, end_time: datetime
app/infra/db/timescaledb/sync_pool.py
+2
View File
@@ -11,6 +11,7 @@ from app.core.config import settings
from app.infra.db.project_routing import get_project_timescale_pgconn_string
_check_connection = ConnectionPool.check_connection
_pools: OrderedDict[str, ConnectionPool] = OrderedDict()
_pool_conninfo: dict[str, str] = {}
_pool_borrows: dict[str, int] = {}
@@ -49,6 +50,7 @@ def get_timescale_pool(db_name: str) -> ConnectionPool:
min_size=settings.PROJECT_TS_POOL_MIN_SIZE,
max_size=settings.PROJECT_TS_POOL_MAX_SIZE,
kwargs={"row_factory": dict_row},
check=_check_connection,
open=True,
)
_pools[db_name] = pool
app/main.py
-6
View File
@@ -5,14 +5,12 @@ from fastapi.middleware.cors import CORSMiddleware
import logging
from datetime import datetime
import app.services.project_info as project_info
from app.api.problem_details import install_problem_details_handlers
from app.api.v1.rest_router import api_router
from app.infra.db.dynamic_manager import project_connection_manager
from app.infra.db.metadb.database import close_metadata_engine
from app.infra.db.timescaledb.sync_pool import close_all_timescale_pools
from app.native.wndb.core.connection import close_all_project_pools
from app.services.tjnetwork import open_project
from app.core.config import settings
# 导入审计中间件
@@ -30,10 +28,6 @@ async def lifespan(app: FastAPI):
logger.info("TJWater CloudService is starting...")
logger.info("**********************************************************")
if project_info.name:
print(project_info.name)
open_project(project_info.name)
yield
# 清理资源
await project_connection_manager.close_all()
app/native/wndb/commands/cascade.py
+3 -4
View File
@@ -7,7 +7,7 @@ from ..model.reservoirs import unset_reservoir_by_pattern
from ..model.tanks import unset_tank_by_curve
from ..model.pumps import unset_pump_by_curve, unset_pump_by_pattern
from ..model.tags import delete_tag_by_node, delete_tag_by_link
from ..model.demands import delete_demand_by_junction, unset_demand_by_pattern
from ..model.demands import delete_demand_by_junction
from ..model.status import delete_status_by_link
from ..model.energy import delete_pump_energy_by_pump, unset_pump_energy_by_pattern, unset_pump_energy_by_curve
from ..model.emitters import delete_emitter_by_junction
@@ -167,7 +167,6 @@ def expand_pattern_delete(name: str, cs: ChangeSet) -> ChangeSet:
result.merge(unset_reservoir_by_pattern(name, id))
result.merge(unset_pump_by_pattern(name, id))
result.merge(unset_demand_by_pattern(name, id))
result.merge(unset_pump_energy_by_pattern(name, id))
result.merge(unset_source_by_pattern(name, id))
result.merge(cs)
@@ -191,7 +190,7 @@ def expand_curve_delete(name: str, cs: ChangeSet) -> ChangeSet:
return result
def expand_legacy_options_update(cs: ChangeSet) -> ChangeSet:
def expand_v2_options_update(cs: ChangeSet) -> ChangeSet:
cs.operations[0]['operation'] = API_UPDATE
cs.operations[0]['type'] = 'option'
new_cs = cs
@@ -239,6 +238,6 @@ _DELETE_REWRITERS: dict[str, DeleteRewriter] = {
}
_UPDATE_REWRITERS: dict[str, UpdateRewriter] = {
"option": expand_legacy_options_update,
"option": expand_v2_options_update,
"option_v3": expand_v3_options_update,
}
app/native/wndb/commands/executor.py
+6 -5
View File
@@ -2,13 +2,14 @@
from collections.abc import Callable
from ..core.connection import project_transaction
from ..core.database import (
API_ADD,
API_DELETE,
API_UPDATE,
ChangeSet,
refresh_materialized_views,
changes_affect_materialized_views,
model_mutation_transaction,
refresh_materialized_views_after_commit,
)
from ..gis.backdrop import set_backdrop
from ..gis.labels import add_label, delete_label, set_label
@@ -131,7 +132,7 @@ def _execute_delete_command(name: str, change_set: ChangeSet) -> ChangeSet:
def execute_batch_commands(name: str, change_set: ChangeSet) -> ChangeSet:
with project_transaction(name):
with model_mutation_transaction(name):
rewritten = ChangeSet()
for operation in change_set.operations:
rewritten.merge(expand_command(name, ChangeSet(operation)))
@@ -146,8 +147,8 @@ def execute_batch_commands(name: str, change_set: ChangeSet) -> ChangeSet:
elif operation_type == API_DELETE:
result.merge(_execute_delete_command(name, ChangeSet(operation)))
if rewritten.operations:
refresh_materialized_views(name)
if changes_affect_materialized_views(rewritten):
refresh_materialized_views_after_commit(name)
return result
app/native/wndb/core/connection.py
+20
View File
@@ -11,6 +11,7 @@ from psycopg_pool import ConnectionPool
from app.core.config import settings
from app.infra.db.project_routing import get_project_pgconn_string
_check_connection = ConnectionPool.check_connection
_pools: OrderedDict[str, ConnectionPool] = OrderedDict()
_pool_conninfo: dict[str, str] = {}
_pool_borrows: dict[str, int] = {}
@@ -21,6 +22,10 @@ _active_project_connection: ContextVar[tuple[str, Connection] | None] = ContextV
"wndb_active_project_connection",
default=None,
)
_active_model_mutation_locks: ContextVar[frozenset[str]] = ContextVar(
"wndb_active_model_mutation_locks",
default=frozenset(),
)
def _close_pool(pool: ConnectionPool) -> None:
@@ -78,6 +83,7 @@ def get_project_pool(name: str) -> ConnectionPool:
min_size=settings.PROJECT_PG_POOL_MIN_SIZE,
max_size=settings.PROJECT_PG_POOL_SIZE + settings.PROJECT_PG_MAX_OVERFLOW,
kwargs={"autocommit": True, "row_factory": dict_row},
check=_check_connection,
open=True,
)
_pools[name] = pool
@@ -140,6 +146,7 @@ def get_admin_pool() -> ConnectionPool:
min_size=settings.PROJECT_PG_POOL_MIN_SIZE,
max_size=settings.PROJECT_PG_POOL_SIZE,
kwargs={"autocommit": True, "row_factory": dict_row},
check=_check_connection,
open=True,
)
_admin_pools[conninfo] = pool
@@ -192,10 +199,12 @@ def project_transaction(name: str) -> Iterator[Connection]:
try:
with pool.connection() as conn:
token = _active_project_connection.set((name, conn))
lock_token = _active_model_mutation_locks.set(frozenset())
try:
with conn.transaction():
yield conn
finally:
_active_model_mutation_locks.reset(lock_token)
_active_project_connection.reset(token)
finally:
with _registry_lock:
@@ -208,6 +217,17 @@ def is_project_transaction_active(name: str) -> bool:
return active is not None and active[0] == name
def is_model_mutation_lock_active(name: str) -> bool:
"""Return whether the current project transaction already owns its model lock."""
return name in _active_model_mutation_locks.get()
def mark_model_mutation_lock_active(name: str) -> None:
"""Record a transaction-scoped advisory lock to avoid duplicate round trips."""
locks = _active_model_mutation_locks.get()
_active_model_mutation_locks.set(locks | {name})
@contextmanager
def admin_connection() -> Iterator[Connection]:
"""Borrow a PostgreSQL administration connection from its pool."""
app/native/wndb/core/database.py
+103 -6
View File
@@ -1,10 +1,19 @@
from collections.abc import Mapping, Sequence
from typing import Any
from collections.abc import Iterator, Mapping, Sequence
from contextlib import contextmanager
from typing import Any, Callable
from psycopg import sql
from psycopg.rows import Row, dict_row
from .connection import is_project_transaction_active, project_connection
from app.infra.db.project_routing import get_project_database_name
from .connection import (
is_model_mutation_lock_active,
is_project_transaction_active,
mark_model_mutation_lock_active,
project_connection,
project_transaction,
)
API_ADD = "add"
API_UPDATE = "update"
@@ -61,6 +70,20 @@ class DatabaseCommand:
self.sql = statement
self.changes = changes
class MaterializedViewRefreshAfterCommitError(RuntimeError):
"""Report a failed view refresh without implying that the write rolled back."""
changes_committed = True
def __init__(self, project: str) -> None:
self.project = project
super().__init__(
f"Project {project!r} changes were committed, but materialized view "
"refresh failed"
)
QueryParams = Sequence[Any] | Mapping[str, Any]
@@ -78,6 +101,27 @@ def _execute(cur, query: str, params: QueryParams | None = None):
return cur.execute(query, params) if params is not None else cur.execute(query)
def acquire_model_mutation_lock(conn, name: str) -> None:
"""Serialize model replacement and ordinary WNDB mutations per database."""
if is_model_mutation_lock_active(name):
return
physical_name = get_project_database_name(name)
with conn.cursor() as cur:
cur.execute(
"select pg_advisory_xact_lock(hashtextextended(%s, 0))",
(f"tjwater:wndb:model:{physical_name}",),
)
mark_model_mutation_lock_active(name)
@contextmanager
def model_mutation_transaction(name: str) -> Iterator[Any]:
"""Open a project transaction and acquire its model lock before reading."""
with project_transaction(name) as conn:
acquire_model_mutation_lock(conn, name)
yield conn
def read(name: str, query: str, params: QueryParams | None = None) -> Row:
with project_connection(name) as conn, conn.cursor(row_factory=dict_row) as cur:
_execute(cur, query, params)
@@ -104,8 +148,15 @@ def try_read(
def write(name: str, query: str, params: QueryParams | None = None) -> None:
with project_connection(name) as conn, conn.cursor() as cur:
_execute(cur, query, params)
connection_context = (
project_connection(name)
if is_project_transaction_active(name)
else model_mutation_transaction(name)
)
with connection_context as conn:
acquire_model_mutation_lock(conn, name)
with conn.cursor() as cur:
_execute(cur, query, params)
def refresh_materialized_views(name: str, *, concurrently: bool = True) -> None:
@@ -114,6 +165,13 @@ def refresh_materialized_views(name: str, *, concurrently: bool = True) -> None:
cur.execute("CALL gis.refresh_all_materialized_views(%s)", (concurrently,))
def refresh_materialized_views_after_commit(name: str) -> None:
try:
refresh_materialized_views(name)
except Exception as exc:
raise MaterializedViewRefreshAfterCommitError(name) from exc
_MATERIALIZED_VIEW_SOURCES = (
"network.nodes",
"network.junctions",
@@ -135,9 +193,48 @@ def _affects_materialized_views(command: DatabaseCommand) -> bool:
return any(source in statement for source in _MATERIALIZED_VIEW_SOURCES)
_MATERIALIZED_VIEW_ELEMENT_TYPES = frozenset(
{
"junction",
"reservoir",
"tank",
"pipe",
"pump",
"valve",
"demand",
"vertex",
}
)
def changes_affect_materialized_views(change_set: ChangeSet) -> bool:
"""Return whether a dispatched WNDB batch changes a published GIS source."""
return any(
operation.get("type") in _MATERIALIZED_VIEW_ELEMENT_TYPES
for operation in change_set.operations
)
def execute_command(name: str, command: DatabaseCommand) -> ChangeSet:
"""Apply a model mutation without the removed database undo/redo journal."""
write(name, command.sql)
if _affects_materialized_views(command) and not is_project_transaction_active(name):
refresh_materialized_views(name)
refresh_materialized_views_after_commit(name)
return ChangeSet.from_list(command.changes)
def execute_locked_command(
name: str,
builder: Callable[[], DatabaseCommand | None],
) -> ChangeSet:
"""Build a read-modify-write command only after acquiring the model lock."""
nested_transaction = is_project_transaction_active(name)
command: DatabaseCommand | None = None
with model_mutation_transaction(name):
command = builder()
if command is None:
return ChangeSet()
result = execute_command(name, command)
if not nested_transaction and _affects_materialized_views(command):
refresh_materialized_views_after_commit(name)
return result
app/native/wndb/core/model_replace.py
+284
View File
@@ -0,0 +1,284 @@
from psycopg import Connection, sql
from .connection import project_connection, project_transaction
from .database import acquire_model_mutation_lock
_MODEL_SCHEMAS = ("network", "gis")
_ALLOWED_EXTERNAL_REFERENCES = {
("analysis", "results", "network", "nodes"),
("analysis", "results", "network", "links"),
("asset", "scada_devices", "network", "nodes"),
("asset", "scada_devices", "network", "links"),
}
def _model_tables(conn: Connection) -> list[tuple[str, str]]:
with conn.cursor() as cur:
cur.execute(
"""
select n.nspname as schema_name, c.relname as table_name
from pg_class c
join pg_namespace n on n.oid = c.relnamespace
where n.nspname = any(%s) and c.relkind in ('r', 'p')
order by n.nspname, c.relname
""",
(list(_MODEL_SCHEMAS),),
)
return [(row["schema_name"], row["table_name"]) for row in cur.fetchall()]
def _copy_order(
conn: Connection, tables: list[tuple[str, str]]
) -> list[tuple[str, str]]:
table_set = set(tables)
dependencies: dict[tuple[str, str], set[tuple[str, str]]] = {
table: set() for table in tables
}
with conn.cursor() as cur:
cur.execute(
"""
select source_ns.nspname as source_schema,
source.relname as source_table,
target_ns.nspname as target_schema,
target.relname as target_table
from pg_constraint constraint_row
join pg_class source on source.oid = constraint_row.conrelid
join pg_namespace source_ns on source_ns.oid = source.relnamespace
join pg_class target on target.oid = constraint_row.confrelid
join pg_namespace target_ns on target_ns.oid = target.relnamespace
where constraint_row.contype = 'f'
and source_ns.nspname = any(%s)
and target_ns.nspname = any(%s)
""",
(list(_MODEL_SCHEMAS), list(_MODEL_SCHEMAS)),
)
for row in cur.fetchall():
source = (row["source_schema"], row["source_table"])
target = (row["target_schema"], row["target_table"])
if source in table_set and target in table_set and source != target:
dependencies[source].add(target)
ordered: list[tuple[str, str]] = []
remaining = set(tables)
while remaining:
ready = sorted(
table for table in remaining if not (dependencies[table] & remaining)
)
if not ready:
cycle = ", ".join(f"{schema}.{table}" for schema, table in sorted(remaining))
raise RuntimeError(f"Model table foreign-key cycle detected: {cycle}")
ordered.extend(ready)
remaining.difference_update(ready)
return ordered
def _table_columns(
conn: Connection, schema_name: str, table_name: str
) -> list[str]:
with conn.cursor() as cur:
cur.execute(
"""
select column_name
from information_schema.columns
where table_schema = %s and table_name = %s
and is_generated = 'NEVER'
order by ordinal_position
""",
(schema_name, table_name),
)
return [row["column_name"] for row in cur.fetchall()]
def _external_references(conn: Connection) -> set[tuple[str, str, str, str]]:
with conn.cursor() as cur:
cur.execute(
"""
select source_ns.nspname as source_schema,
source.relname as source_table,
target_ns.nspname as target_schema,
target.relname as target_table
from pg_constraint constraint_row
join pg_class source on source.oid = constraint_row.conrelid
join pg_namespace source_ns on source_ns.oid = source.relnamespace
join pg_class target on target.oid = constraint_row.confrelid
join pg_namespace target_ns on target_ns.oid = target.relnamespace
where constraint_row.contype = 'f'
and target_ns.nspname = any(%s)
and source_ns.nspname <> all(%s)
""",
(list(_MODEL_SCHEMAS), list(_MODEL_SCHEMAS)),
)
return {
(
row["source_schema"],
row["source_table"],
row["target_schema"],
row["target_table"],
)
for row in cur.fetchall()
}
def _copy_table(
source_conn: Connection,
target_conn: Connection,
schema_name: str,
table_name: str,
columns: list[str],
) -> None:
relation = sql.Identifier(schema_name, table_name)
column_list = sql.SQL(", ").join(map(sql.Identifier, columns))
copy_out = sql.SQL("copy {} ({}) to stdout").format(relation, column_list)
copy_in = sql.SQL("copy {} ({}) from stdin").format(relation, column_list)
with source_conn.cursor().copy(copy_out) as source_copy:
with target_conn.cursor().copy(copy_in) as target_copy:
for chunk in source_copy:
target_copy.write(chunk)
def replace_project_model(
target_project: str,
source_project: str,
*,
copy_source_scada: bool = False,
) -> None:
"""Atomically replace WNDB/GIS model tables from a validated staging DB.
Business and analysis tables remain in the target database. Historical
analysis rows keep references that still exist and become element-neutral
when an element disappeared. SCADA devices are retained only when their
bound node or link still exists in the replacement model.
``copy_source_scada`` is used only for temporary project clones. Normal INP
replacement keeps the target project's existing device mappings and drops
mappings whose model element no longer exists.
"""
with project_connection(source_project) as source_conn, source_conn.transaction():
with source_conn.cursor() as cur:
cur.execute("set transaction isolation level repeatable read, read only")
source_tables = _model_tables(source_conn)
source_columns = {
table: _table_columns(source_conn, *table) for table in source_tables
}
source_scada_columns = (
_table_columns(source_conn, "asset", "scada_devices")
if copy_source_scada
else []
)
copy_order = _copy_order(source_conn, source_tables)
with project_transaction(target_project) as target_conn:
acquire_model_mutation_lock(target_conn, target_project)
target_tables = _model_tables(target_conn)
if set(target_tables) != set(source_tables):
missing = sorted(set(source_tables) - set(target_tables))
extra = sorted(set(target_tables) - set(source_tables))
raise RuntimeError(
f"Staging/target model schema mismatch; missing={missing}, extra={extra}"
)
for table, columns in source_columns.items():
if _table_columns(target_conn, *table) != columns:
raise RuntimeError(
f"Staging/target columns differ for {table[0]}.{table[1]}"
)
if copy_source_scada and _table_columns(
target_conn, "asset", "scada_devices"
) != source_scada_columns:
raise RuntimeError(
"Source/target columns differ for asset.scada_devices"
)
unexpected = _external_references(target_conn) - _ALLOWED_EXTERNAL_REFERENCES
if unexpected:
formatted = ", ".join(
f"{source_schema}.{source_table}->{target_schema}.{target_table}"
for source_schema, source_table, target_schema, target_table in sorted(
unexpected
)
)
raise RuntimeError(
f"Model replacement has unsupported external references: {formatted}"
)
with target_conn.cursor() as cur:
if not copy_source_scada:
cur.execute(
"create temporary table model_scada_snapshot on commit drop "
"as table asset.scada_devices"
)
cur.execute("delete from asset.scada_devices")
cur.execute(
"create temporary table model_result_refs on commit drop as "
"select result_id, node_id, link_id from analysis.results"
)
cur.execute("update analysis.results set node_id = null, link_id = null")
for schema_name, table_name in reversed(copy_order):
cur.execute(
sql.SQL("delete from {}").format(
sql.Identifier(schema_name, table_name)
)
)
for schema_name, table_name in copy_order:
_copy_table(
source_conn,
target_conn,
schema_name,
table_name,
source_columns[(schema_name, table_name)],
)
if copy_source_scada:
_copy_table(
source_conn,
target_conn,
"asset",
"scada_devices",
source_scada_columns,
)
with target_conn.cursor() as cur:
if not copy_source_scada:
cur.execute(
"""
insert into asset.scada_devices
select snapshot.*
from model_scada_snapshot snapshot
where (
snapshot.node_id is not null
and exists (
select 1 from network.nodes node
where node.id = snapshot.node_id
)
) or (
snapshot.link_id is not null
and exists (
select 1 from network.links link
where link.id = snapshot.link_id
)
)
"""
)
cur.execute(
"""
update analysis.results result
set node_id = case
when exists (
select 1 from network.nodes node
where node.id = refs.node_id
) then refs.node_id
else null
end,
link_id = case
when exists (
select 1 from network.links link
where link.id = refs.link_id
) then refs.link_id
else null
end
from model_result_refs refs
where refs.result_id = result.result_id
"""
)
app/native/wndb/core/projects.py
+222 -62
View File
@@ -1,13 +1,46 @@
from collections.abc import Iterable
from contextlib import contextmanager
import re
from uuid import uuid4
from psycopg import sql
from psycopg.rows import dict_row
from app.core.config import settings
from app.infra.db.project_routing import (
get_project_database_name,
get_project_template_database_name,
)
from .connection import (
admin_connection,
close_project_pool,
get_project_pool,
is_project_pool_open,
)
_server_databases = ["template0", "template1", "postgres", "project"]
_SERVER_DATABASES = frozenset({"template0", "template1", "postgres", "project"})
_TEMPORARY_DATABASE_PREFIX = "tjw_tmp_"
def _protected_databases() -> frozenset[str]:
return _SERVER_DATABASES | {
settings.METADATA_DB_NAME,
settings.WNDB_TEMPLATE_DB_NAME,
}
def _validate_project_database(name: str, *, allow_template_source: bool = False) -> None:
if not name:
raise ValueError("Project database name must not be empty")
protected = {database.casefold() for database in _protected_databases()}
is_template = name.casefold().endswith("_template")
if (
allow_template_source
and name.casefold() == settings.WNDB_TEMPLATE_DB_NAME.casefold()
):
return
if name.casefold() in protected or is_template:
raise ValueError(f"Database {name!r} is protected and cannot be managed as a project")
def list_project() -> list[str]:
@@ -16,92 +49,219 @@ def list_project() -> list[str]:
with conn.cursor(row_factory=dict_row) as cur:
for p in cur.execute(
"select datname from pg_database where datname <> all(%s) order by datname",
(_server_databases,),
(list(_protected_databases()),),
):
ps.append(p["datname"])
if not str(p["datname"]).casefold().endswith("_template"):
ps.append(p["datname"])
return ps
@contextmanager
def _database_locks(cur, *database_names: str):
"""Serialize physical database lifecycle operations across server workers."""
lock_names = sorted(set(database_names), key=str.casefold)
for database_name in lock_names:
cur.execute(
"select pg_advisory_lock(hashtextextended(%s, 0))",
(f"tjwater:wndb:{database_name}",),
)
try:
yield
finally:
for database_name in reversed(lock_names):
cur.execute(
"select pg_advisory_unlock(hashtextextended(%s, 0))",
(f"tjwater:wndb:{database_name}",),
)
@contextmanager
def _temporary_database_capacity(cur, database_name: str):
"""Serialize temporary creation and enforce a server-wide hard limit."""
if not database_name.startswith(_TEMPORARY_DATABASE_PREFIX):
yield
return
lock_name = "tjwater:wndb:temporary-database-capacity"
cur.execute("select pg_advisory_lock(hashtextextended(%s, 0))", (lock_name,))
try:
cur.execute(
"select count(*) as count from pg_database where datname like %s",
(f"{_TEMPORARY_DATABASE_PREFIX}%",),
)
row = cur.fetchone()
count = int(row["count"] if row is not None else 0)
limit = max(1, settings.WNDB_TEMP_DB_MAX_COUNT)
if count >= limit:
raise RuntimeError(
f"Temporary database limit reached ({count}/{limit}); "
"retry after an active analysis completes"
)
yield
finally:
cur.execute("select pg_advisory_unlock(hashtextextended(%s, 0))", (lock_name,))
def _database_allows_connections(cur, database_name: str) -> bool:
cur.execute(
"select datallowconn from pg_database where datname = %s",
(database_name,),
)
row = cur.fetchone()
if row is None:
raise ValueError(f"Database {database_name!r} does not exist")
return bool(row["datallowconn"])
def _set_database_connections(cur, database_name: str, *, allowed: bool) -> None:
cur.execute(
"update pg_database set datallowconn = %s where datname = %s",
(allowed, database_name),
)
def temporary_project_name(project: str, purpose: str) -> str:
"""Return a collision-resistant physical database name for one run."""
physical_name = get_project_database_name(project)
safe_purpose = re.sub(r"[^a-z0-9_]+", "_", purpose.casefold()).strip("_")
safe_project = re.sub(r"[^a-z0-9_]+", "_", physical_name.casefold()).strip("_")
prefix = (
f"{_TEMPORARY_DATABASE_PREFIX}{safe_purpose or 'run'}_"
f"{safe_project or 'project'}"
)[:29]
return f"{prefix}_{uuid4().hex}"
@contextmanager
def temporary_project_database(project: str, purpose: str):
"""Clone one project's runnable model into an isolated temporary database."""
temporary_name = temporary_project_name(project, purpose)
try:
copy_project(get_project_template_database_name(project), temporary_name)
# Import lazily to keep physical database lifecycle independent from
# model-copy implementation details at module import time.
from .database import refresh_materialized_views_after_commit
from .model_replace import replace_project_model
replace_project_model(
temporary_name,
project,
copy_source_scada=True,
)
refresh_materialized_views_after_commit(temporary_name)
yield temporary_name
finally:
if have_project(temporary_name):
delete_project(temporary_name)
@contextmanager
def temporary_template_database(name_hint: str, purpose: str):
"""Create an empty schema-only temporary database from the fixed template."""
temporary_name = temporary_project_name(name_hint, purpose)
try:
copy_project(get_project_template_database_name(name_hint), temporary_name)
yield temporary_name
finally:
if have_project(temporary_name):
delete_project(temporary_name)
def have_project(name: str) -> bool:
database_name = get_project_database_name(name)
with admin_connection() as conn:
with conn.cursor() as cur:
cur.execute("select 1 from pg_database where datname = %s", (name,))
cur.execute("select 1 from pg_database where datname = %s", (database_name,))
return cur.fetchone() is not None
def copy_project(source: str, new: str) -> None:
physical_source = get_project_database_name(source)
physical_new = get_project_database_name(new)
_validate_project_database(physical_source, allow_template_source=True)
_validate_project_database(physical_new)
close_project_pool(source)
close_project_pool(new)
with admin_connection() as admin_conn:
with admin_conn.cursor() as cur:
cur.execute(
"update pg_database set datallowconn = false where datname = %s",
(source,),
)
try:
cur.execute(
"select pg_terminate_backend(pid) from pg_stat_activity where datname = %s and pid <> pg_backend_pid()",
(source,),
)
cur.execute(
sql.SQL("create database {} with template = {}").format(
sql.Identifier(new), sql.Identifier(source)
)
)
finally:
cur.execute(
"update pg_database set datallowconn = true where datname = %s",
(source,),
)
with _temporary_database_capacity(cur, physical_new):
with _database_locks(cur, physical_source, physical_new):
source_allowed = _database_allows_connections(cur, physical_source)
if source_allowed:
_set_database_connections(
cur,
physical_source,
allowed=False,
)
try:
cur.execute(
"select pg_terminate_backend(pid) from pg_stat_activity "
"where datname = %s and pid <> pg_backend_pid()",
(physical_source,),
)
cur.execute(
sql.SQL("create database {} with template = {}").format(
sql.Identifier(physical_new),
sql.Identifier(physical_source),
)
)
finally:
if source_allowed:
_set_database_connections(
cur,
physical_source,
allowed=True,
)
def create_project(name: str) -> None:
return copy_project("project", name)
return copy_project(get_project_template_database_name(name), name)
def delete_project(name: str) -> None:
database_name = get_project_database_name(name)
_validate_project_database(database_name)
close_project_pool(name)
with admin_connection() as conn:
with conn.cursor() as cur:
cur.execute(
"select pg_terminate_backend(pid) from pg_stat_activity "
"where datname = %s and pid <> pg_backend_pid()",
(name,),
)
cur.execute(
sql.SQL("drop database {}").format(sql.Identifier(name))
)
with _database_locks(cur, database_name):
was_allowed = _database_allows_connections(cur, database_name)
if was_allowed:
_set_database_connections(cur, database_name, allowed=False)
try:
cur.execute(
"select pg_terminate_backend(pid) from pg_stat_activity "
"where datname = %s and pid <> pg_backend_pid()",
(database_name,),
)
cur.execute(
sql.SQL("drop database {}").format(
sql.Identifier(database_name)
)
)
except Exception:
if was_allowed:
_set_database_connections(cur, database_name, allowed=True)
raise
def clean_project(excluded: list[str] = []) -> None:
projects = list_project()
def clean_project(projects: Iterable[str]) -> None:
"""Delete only the explicitly supplied project databases."""
targets = list(dict.fromkeys(projects))
physical_targets = [get_project_database_name(project) for project in targets]
for database_name in physical_targets:
_validate_project_database(database_name)
if not targets:
return
with admin_connection() as conn:
with conn.cursor(row_factory=dict_row) as cur:
row = cur.execute("select current_database()").fetchone()
if row != None:
current_db = row["current_database"]
if current_db in projects:
projects.remove(current_db)
for project in projects:
if project in _server_databases or project in excluded:
continue
cur.execute(
"select pg_terminate_backend(pid) from pg_stat_activity "
"where datname = %s and pid <> pg_backend_pid()",
(project,),
)
cur.execute(
sql.SQL("drop database {}").format(sql.Identifier(project))
)
current_db = row["current_database"] if row is not None else None
if current_db in physical_targets:
raise ValueError(f"Cannot delete the current database {current_db!r}")
def open_project(name: str) -> None:
get_project_pool(name)
def is_project_open(name: str) -> bool:
return is_project_pool_open(name)
def close_project(name: str) -> None:
close_project_pool(name)
for project in targets:
delete_project(project)
app/native/wndb/gis/coordinates.py
+16 -54
View File
@@ -1,10 +1,5 @@
from psycopg.rows import dict_row
from ..core.database import read_all, sql_literal, try_read
from ..core.connection import project_connection
from ..core.database import read_all, sql_literal, try_read, write
from ..core.connection import project_connection
from ..model.elements import get_link_nodes
from psycopg.rows import dict_row
def sql_update_coord(node: str, x: float, y: float) -> str:
geom = f"st_setsrid(st_makepoint({sql_literal(x)}, {sql_literal(y)}), 900914)"
@@ -21,8 +16,8 @@ def sql_delete_coord(node: str) -> str:
def from_postgis_point(coord: str) -> dict[str, float]:
xy = coord.lower().removeprefix('point(').removesuffix(')').split(' ')
return { 'x': float(xy[0]), 'y': float(xy[1]) }
xy = coord.lower().removeprefix("point(").removesuffix(")").split(" ")
return {"x": float(xy[0]), "y": float(xy[1])}
def get_node_coord(name: str, node: str) -> dict[str, float]:
@@ -31,51 +26,15 @@ def get_node_coord(name: str, node: str) -> dict[str, float]:
"select st_astext(geom) as coord_geom from gis.node_geometries where node_id = %s",
(node,),
)
if row == None:
write(name, sql_insert_coord(node, 0.0, 0.0))
return {'x': 0.0, 'y': 0.0}
return from_postgis_point(row['coord_geom'])
# DingZQ 2025-01-03, get nodes in extent
# return node id list
# node_id:junction:x:y
def get_nodes_in_extent(name: str, x1: float, y1: float, x2: float, y2: float) -> list[str]:
nodes = []
objs = read_all(name, 'select node_id, st_astext(geom) as coord_geom from gis.node_geometries')
for obj in objs:
node_id = obj['node_id']
coord = from_postgis_point(obj['coord_geom'])
x = coord['x']
y = coord['y']
if x1 <= x <= x2 and y1 <= y <= y2:
nodes.append(f"{node_id}:junction:{x}:{y}")
return nodes
# DingZQ 2025-01-03, get links in extent
# return link id list
# link_id:pipe:node_id1:node_id2
def get_links_in_extent(name: str, x1: float, y1: float, x2: float, y2: float) -> list[str]:
node_ids = set([s.split(':')[0] for s in get_nodes_in_extent(name, x1, y1, x2, y2)])
all_link_ids = []
with project_connection(name) as conn:
with conn.cursor(row_factory=dict_row) as cur:
cur.execute("select link_id from network.pipes")
for record in cur:
all_link_ids.append(record['link_id'])
links = []
for link_id in all_link_ids:
nodes = get_link_nodes(name, link_id)
if nodes[0] in node_ids and nodes[1] in node_ids:
links.append(f"{link_id}:pipe:{nodes[0]}:{nodes[1]}")
return links
if row is None:
return {"x": 0.0, "y": 0.0}
return from_postgis_point(row["coord_geom"])
def node_has_coord(name: str, node: str) -> bool:
return try_read(
name, "select node_id from gis.node_geometries where node_id = %s", (node,)
) != None
) is not None
#--------------------------------------------------------------
@@ -94,11 +53,14 @@ def inp_in_coord(line: str) -> str:
def inp_out_coord(name: str) -> list[str]:
lines = []
objs = read_all(name, 'select node_id, st_astext(geom) as coord_geom from gis.node_geometries')
objs = read_all(
name,
"select node_id, st_astext(geom) as coord_geom from gis.node_geometries",
)
for obj in objs:
node = obj['node_id']
coord = from_postgis_point(obj['coord_geom'])
x = coord['x']
y = coord['y']
lines.append(f'{node} {x} {y}')
node = obj["node_id"]
coord = from_postgis_point(obj["coord_geom"])
x = coord["x"]
y = coord["y"]
lines.append(f"{node} {x} {y}")
return lines
app/native/wndb/gis/network_views.py
+191
View File
@@ -0,0 +1,191 @@
"""Read-only projections backed by the GIS materialized-view query layer."""
from typing import Any
from ..core.database import read, read_all
def _node_coord_rows(
rows: list[Any],
) -> dict[str, dict[str, Any]]:
return {
str(row["id"]): {
"x": float(row["x"]),
"y": float(row["y"]),
"type": str(row["node_type"]),
}
for row in rows
}
def get_network_node_coords(name: str) -> dict[str, dict[str, Any]]:
"""Return every publishable node with one view-backed query."""
rows = read_all(
name,
"""
SELECT id, x, y, node_type
FROM gis.network_nodes
ORDER BY id
""",
)
return _node_coord_rows(rows)
def get_major_node_coords(
name: str, diameter: int
) -> dict[str, dict[str, Any]]:
"""Return endpoints of pipes above the requested diameter."""
rows = read_all(
name,
"""
SELECT n.id, n.x, n.y, n.node_type
FROM gis.pipes AS p
CROSS JOIN LATERAL (
VALUES (p.start_node_id), (p.end_node_id)
) AS endpoint(id)
JOIN gis.network_nodes AS n ON n.id = endpoint.id
WHERE p.diameter > %s
GROUP BY n.id, n.x, n.y, n.node_type
ORDER BY n.id
""",
(diameter,),
)
return _node_coord_rows(rows)
def get_network_link_nodes(name: str) -> list[str]:
"""Return every publishable link in the established API wire format."""
rows = read_all(
name,
"""
SELECT id, link_type, start_node_id, end_node_id
FROM gis.network_links
ORDER BY id
""",
)
return [
f"{row['id']}:{row['link_type']}:{row['start_node_id']}:{row['end_node_id']}"
for row in rows
]
def get_major_pipe_nodes(name: str, diameter: int) -> list[str]:
"""Return large pipes in the established API wire format."""
rows = read_all(
name,
"""
SELECT id, start_node_id, end_node_id
FROM gis.pipes
WHERE diameter > %s
ORDER BY id
""",
(diameter,),
)
return [
f"{row['id']}:pipe:{row['start_node_id']}:{row['end_node_id']}"
for row in rows
]
def get_topology_rows(
name: str, node_ids: list[str]
) -> tuple[list[Any], list[Any]]:
"""Load selected nodes and their internal links with two batch queries."""
if not node_ids:
return [], []
nodes = read_all(
name,
"""
SELECT n.id,
ST_X(g.geom) AS x,
ST_Y(g.geom) AS y,
n.node_type::text AS node_type
FROM network.nodes AS n
JOIN gis.node_geometries AS g ON g.node_id = n.id
WHERE n.id = ANY(%s)
ORDER BY n.id
""",
(node_ids,),
)
links = read_all(
name,
"""
SELECT l.id,
l.start_node_id,
l.end_node_id,
COALESCE(p.length, 0.0) AS length
FROM network.links AS l
LEFT JOIN network.pipes AS p ON p.link_id = l.id
WHERE l.start_node_id = ANY(%s)
AND l.end_node_id = ANY(%s)
ORDER BY l.id
""",
(node_ids, node_ids),
)
return nodes, links
def get_boundary_link_ids(name: str, node_ids: list[str]) -> list[str]:
"""Return links with exactly one endpoint inside the supplied node set."""
if not node_ids:
return []
rows = read_all(
name,
"""
SELECT id
FROM network.links
WHERE (start_node_id = ANY(%s)) <> (end_node_id = ANY(%s))
ORDER BY id
""",
(node_ids, node_ids),
)
return [str(row["id"]) for row in rows]
def get_junction_demands(
name: str, node_ids: list[str]
) -> dict[str, list[dict[str, Any]]]:
"""Read authoritative demands for selected junctions from model tables."""
if not node_ids:
return {}
rows = read_all(
name,
"""
SELECT junction_id,
sequence_no,
base_demand,
pattern_id,
category
FROM network.demands
WHERE junction_id = ANY(%s)
ORDER BY junction_id, sequence_no
""",
(node_ids,),
)
result: dict[str, list[dict[str, Any]]] = {}
for row in rows:
result.setdefault(str(row["junction_id"]), []).append(
{
"demand": float(row["base_demand"]),
"pattern": row["pattern_id"],
"category": row["category"],
}
)
return result
def sum_junction_base_demand(name: str, node_ids: list[str]) -> float:
"""Sum selected junction demand from the authoritative model table."""
if not node_ids:
return 0.0
row = read(
name,
"""
SELECT COALESCE(SUM(base_demand), 0.0) AS total_base_demand
FROM network.demands
WHERE junction_id = ANY(%s)
""",
(node_ids,),
)
return float(row["total_base_demand"])
app/native/wndb/gis/region_geometry.py
+33 -47
View File
@@ -2,10 +2,8 @@ import platform
import math
from typing import Any
import pyclipper
from ..model.elements import get_node_links, get_link_nodes, is_pipe
from ..model.pipes import get_pipe
from ..core.database import read, try_read, read_all
from .coordinates import node_has_coord, get_node_coord
from .network_views import get_boundary_link_ids, get_topology_rows
def from_postgis_polygon(polygon: str) -> list[tuple[float, float]]:
@@ -42,21 +40,7 @@ def get_nodes_in_boundary(name: str, boundary: list[tuple[float, float]]) -> lis
def _get_links_on_boundary(name: str, nodes: list[str]) -> list[str]:
links: list[str] = []
for node in nodes:
node_links = get_node_links(name, node)
for link in node_links:
if link in links:
continue
link_nodes = get_link_nodes(name, link)
if link_nodes[0] in nodes and link_nodes[1] not in nodes:
links.append(link)
elif link_nodes[0] not in nodes and link_nodes[1] in nodes:
links.append(link)
return links
return get_boundary_link_ids(name, nodes)
def get_nodes_in_region(name: str, region_id: str) -> list[str]:
@@ -128,37 +112,39 @@ def _angle_of_node_link(node: str, link: str, nodes, links) -> float:
class Topology:
def __init__(self, db: str, nodes: list[str]) -> None:
self._nodes: dict[str, Any] = {}
self._max_x_node = ''
self._node_list: list[str] = []
for node in nodes:
if not node_has_coord(db, node):
continue
if get_node_links(db, node) == 0:
continue
self._nodes[node] = get_node_coord(db, node) | { 'links': [] }
self._node_list.append(node)
if self._max_x_node == '' or self._nodes[node]['x'] > self._nodes[self._max_x_node]['x']:
self._max_x_node = node
node_rows, link_rows = get_topology_rows(db, nodes)
self._nodes: dict[str, Any] = {
str(row["id"]): {
"x": float(row["x"]),
"y": float(row["y"]),
"type": str(row["node_type"]),
"links": [],
}
for row in node_rows
}
self._node_list = list(self._nodes)
self._max_x_node = max(
self._nodes,
key=lambda node_id: self._nodes[node_id]["x"],
default="",
)
self._links: dict[str, Any] = {}
self._link_list: list[str] = []
for node in self._nodes:
for link in get_node_links(db, node):
candidate = True
link_nodes = get_link_nodes(db, link)
for link_node in link_nodes:
if link_node not in self._nodes:
candidate = False
break
if candidate:
length = get_pipe(db, link)['length'] if is_pipe(db, link) else 0.0
self._links[link] = { 'node1' : link_nodes[0], 'node2' : link_nodes[1], 'length' : length }
self._link_list.append(link)
if link not in self._nodes[link_nodes[0]]['links']:
self._nodes[link_nodes[0]]['links'].append(link)
if link not in self._nodes[link_nodes[1]]['links']:
self._nodes[link_nodes[1]]['links'].append(link)
for row in link_rows:
link_id = str(row["id"])
node1 = str(row["start_node_id"])
node2 = str(row["end_node_id"])
if node1 not in self._nodes or node2 not in self._nodes:
continue
self._links[link_id] = {
"node1": node1,
"node2": node2,
"length": float(row["length"]),
}
self._nodes[node1]["links"].append(link_id)
self._nodes[node2]["links"].append(link_id)
self._link_list = list(self._links)
def nodes(self):
return self._nodes
app/native/wndb/inp/exporter.py
+4 -21
View File
@@ -1,6 +1,6 @@
import os
from ..core.projects import close_project, have_project, is_project_open, open_project
from ..core.projects import have_project
from ..core.database import ChangeSet
from .sections import (
BACKDROP,
@@ -56,7 +56,7 @@ from ..model.reactions import inp_out_reaction
from ..model.mixing import inp_out_mixing
from ..model.times import inp_out_time
from ..model.reports import inp_out_report
from ..model.options_legacy import inp_out_option
from ..model.options_v2 import inp_out_option_v2
from ..model.options_v3 import inp_out_option_v3
from ..gis.coordinates import inp_out_coord
from ..gis.vertices import inp_out_vertex
@@ -72,11 +72,6 @@ def dump_inp(project: str, inp: str, version: str = '3'):
if not have_project(project):
return
project_open = is_project_open(project)
if not project_open:
open_project(project)
dir = os.getcwd()
path = os.path.join(dir, inp)
@@ -173,7 +168,7 @@ def dump_inp(project: str, inp: str, version: str = '3'):
if version == '3':
file.write('\n'.join(inp_out_option_v3(project)))
else:
file.write('\n'.join(inp_out_option(project)))
file.write('\n'.join(inp_out_option_v2(project)))
elif name == COORDINATES:
file.write('\n'.join(inp_out_coord(project)))
@@ -194,10 +189,6 @@ def dump_inp(project: str, inp: str, version: str = '3'):
file.close()
if not project_open:
close_project(project)
def export_inp(project: str, version: str = '3') -> ChangeSet:
if version != '3' and version != '2':
version = '2'
@@ -205,11 +196,6 @@ def export_inp(project: str, version: str = '3') -> ChangeSet:
if not have_project(project):
return ChangeSet()
project_open = is_project_open(project)
if not project_open:
open_project(project)
inp = ''
for name in section_name:
@@ -294,7 +280,7 @@ def export_inp(project: str, version: str = '3') -> ChangeSet:
if version == '3':
inp += '\n'.join(inp_out_option_v3(project))
else:
inp += '\n'.join(inp_out_option(project))
inp += '\n'.join(inp_out_option_v2(project))
elif name == COORDINATES:
inp += '\n'.join(inp_out_coord(project))
@@ -313,7 +299,4 @@ def export_inp(project: str, version: str = '3') -> ChangeSet:
inp += '\n'
if not project_open:
close_project(project)
return ChangeSet({'operation': 'export', 'inp': inp})
app/native/wndb/inp/importer.py
+69 -67
View File
@@ -1,18 +1,26 @@
import datetime
import logging
import os
from tempfile import NamedTemporaryFile
from psycopg import sql
from ..core.projects import (
close_project,
create_project,
copy_project,
delete_project,
have_project,
is_project_open,
open_project,
temporary_project_name,
temporary_template_database,
)
from app.infra.db.project_routing import get_project_template_database_name
from ..core.connection import project_transaction
from ..core.database import ChangeSet, refresh_materialized_views, sql_literal, write
from ..core.model_replace import replace_project_model
from ..core.database import (
ChangeSet,
refresh_materialized_views_after_commit,
sql_literal,
write,
)
from .sections import (
BACKDROP,
BOUND,
@@ -68,7 +76,7 @@ from ..model.reactions import inp_in_reaction
from ..model.mixing import inp_in_mixing
from ..model.times import inp_in_time
from ..model.reports import inp_in_report
from ..model.options_legacy import inp_in_option
from ..model.options_v2 import inp_in_option_v2
from ..model.options_v3 import inp_in_option_v3
from ..gis.coordinates import inp_in_coord
from ..gis.vertices import inp_in_vertex
@@ -82,10 +90,11 @@ from .exporter import export_inp
_S = "S"
_L = "L"
logger = logging.getLogger(__name__)
def _inp_in_option(section: list[str], version: str = "3") -> str:
return inp_in_option_v3(section) if version == "3" else inp_in_option(section)
return inp_in_option_v3(section) if version == "3" else inp_in_option_v2(section)
_handler = {
@@ -389,60 +398,49 @@ def read_inp(project: str, inp: str, version: str = "3") -> bool:
if version != "3" and version != "2":
version = "2"
if is_project_open(project):
close_project(project)
if not have_project(project):
raise ValueError(f"Project database {project!r} does not exist")
if have_project(project):
delete_project(project)
staging_project = temporary_project_name(project, "model_import")
replacement_committed = False
try:
copy_project(get_project_template_database_name(project), staging_project)
with project_transaction(staging_project):
parse_file(staging_project, inp, version)
replace_project_model(project, staging_project)
replacement_committed = True
finally:
try:
if have_project(staging_project):
delete_project(staging_project)
except Exception:
logger.exception(
"Failed to remove model-import staging database %s",
staging_project,
)
create_project(project)
open_project(project)
if replacement_committed:
refresh_materialized_views_after_commit(project)
with project_transaction(project):
parse_file(project, inp, version)
refresh_materialized_views(project)
"""try:
parse_file(project, inp, version)
except:
close_project(project)
delete_project(project)
return False"""
close_project(project)
return True
# DingZQ, 2024-12-28, convert v3 to v2
def convert_inp_v3_to_v2(inp: str) -> ChangeSet:
project = "v3Tov2"
if is_project_open(project):
close_project(project)
if have_project(project):
delete_project(project)
create_project(project)
open_project(project)
filename = f"inp/{project}_temp.inp"
if os.path.exists(filename):
os.remove(filename)
with open(filename, "w", encoding="utf-8") as f:
f.write(inp)
parse_file(project, filename, "3")
"""try:
parse_file(project, inp, version)
except:
close_project(project)
delete_project(project)
return False"""
return export_inp(project, "2")
temp_path: str | None = None
with temporary_template_database("conversion", "v3_to_v2") as project:
try:
with NamedTemporaryFile(
mode="w", suffix=".inp", encoding="utf-8", delete=False
) as temp_file:
temp_file.write(inp)
temp_path = temp_file.name
with project_transaction(project):
parse_file(project, temp_path, "3")
return export_inp(project, "2")
finally:
if temp_path is not None:
os.remove(temp_path)
def import_inp(project: str, cs: ChangeSet, version: str = "3") -> bool:
@@ -452,17 +450,21 @@ def import_inp(project: str, cs: ChangeSet, version: str = "3") -> bool:
if "inp" not in cs.operations[0]:
return False
filename = f"inp/{project}_temp.inp"
if os.path.exists(filename):
os.remove(filename)
_print_time(f'Start writing temp file "{filename}"...')
with open(filename, "w", encoding="utf-8") as f:
f.write(str(cs.operations[0]["inp"]))
_print_time(f'End writing temp file "{filename}"...')
result = read_inp(project, filename, version)
# os.remove(filename)
return result
temp_path: str | None = None
try:
with NamedTemporaryFile(
mode="w",
suffix=".inp",
prefix="tjwater_import_",
encoding="utf-8",
delete=False,
) as temp_file:
temp_file.write(str(cs.operations[0]["inp"]))
temp_path = temp_file.name
return read_inp(project, temp_path, version)
finally:
if temp_path is not None:
try:
os.remove(temp_path)
except FileNotFoundError:
pass
app/native/wndb/model/demands.py
-13
View File
@@ -94,16 +94,3 @@ def delete_demand_by_junction(name: str, junction: str) -> ChangeSet:
if row is None:
return ChangeSet()
return ChangeSet(g_update_prefix | {'type': 'demand', 'junction': junction, 'demands': []})
def unset_demand_by_pattern(name: str, pattern: str) -> ChangeSet:
cs = ChangeSet()
rows = read_all(name, "select distinct junction_id as junction from network.demands where pattern_id = %s", (pattern,))
for row in rows:
ds = get_demand(name, row['junction'])
for d in ds['demands']:
d['pattern'] = None
cs.append(g_update_prefix | {'type': 'demand', 'junction': row['junction'], 'demands': ds['demands']})
return cs
app/native/wndb/model/elements.py
+2 -36
View File
@@ -159,26 +159,6 @@ def get_nodes(name: str) -> list[str]:
return _get_all(name, _NODE)
def get_nodes_id_and_type(name: str) -> dict[str, str]:
rows = read_all_typed(name, "SELECT id, node_type FROM network.nodes", ())
return {row["id"]: row["node_type"] for row in rows}
def get_major_nodes(name: str, diameter: int) -> list[str]:
rows = read_all_typed(
name,
"""
SELECT DISTINCT endpoint
FROM network.links AS l
JOIN network.pipes AS p ON p.link_id = l.id
CROSS JOIN LATERAL (VALUES (l.start_node_id), (l.end_node_id)) AS e(endpoint)
WHERE p.diameter > %s
""",
(diameter,),
)
return [row["endpoint"] for row in rows]
def get_junctions(name: str) -> list[str]:
return _get_nodes_by_type(name, JUNCTION)
@@ -195,20 +175,6 @@ def get_links(name: str) -> list[str]:
return _get_all(name, _LINK)
def get_links_id_and_type(name: str) -> dict[str, str]:
rows = read_all_typed(name, "SELECT id, link_type FROM network.links", ())
return {row["id"]: row["link_type"] for row in rows}
def get_major_pipes(name: str, diameter: int) -> list[str]:
rows = read_all_typed(
name,
"SELECT link_id FROM network.pipes WHERE diameter > %s ORDER BY link_id",
(diameter,),
)
return [row["link_id"] for row in rows]
def get_pipes(name: str) -> list[str]:
return _get_links_by_type(name, PIPE)
@@ -247,10 +213,10 @@ def get_node_links(name: str, node_id: str) -> list[str]:
def get_all_node_links(name: str) -> dict[str, list[str]]:
"""Build the node adjacency map with one scan of the link table."""
"""Build the node adjacency map with one scan of the unified GIS view."""
rows = read_all_typed(
name,
"SELECT id, start_node_id, end_node_id FROM network.links ORDER BY id",
"SELECT id, start_node_id, end_node_id FROM gis.network_links ORDER BY id",
(),
)
result: dict[str, list[str]] = {}
app/native/wndb/model/junctions.py
+15 -6
View File
@@ -6,6 +6,7 @@ from ..core.database import (
ChangeSet,
DatabaseCommand,
execute_command,
execute_locked_command,
g_add_prefix,
g_delete_prefix,
g_update_prefix,
@@ -94,8 +95,12 @@ class Junction(object):
def as_dict(self) -> dict[str, Any]:
return { 'type': self.type, 'id': self.id, 'x': self.x, 'y': self.y, 'elevation': self.elevation }
def _set_junction(name: str, cs: ChangeSet) -> DatabaseCommand:
raw_new = get_junction(name, cs.operations[0]['id'])
def _set_junction(
name: str,
cs: ChangeSet,
current: dict[str, Any] | None = None,
) -> DatabaseCommand:
raw_new = current if current is not None else get_junction(name, cs.operations[0]['id'])
new_dict = cs.operations[0]
schema = get_junction_schema(name)
@@ -113,11 +118,15 @@ def _set_junction(name: str, cs: ChangeSet) -> DatabaseCommand:
def set_junction(name: str, cs: ChangeSet) -> ChangeSet:
if 'id' not in cs.operations[0]:
operation = cs.operations[0]
if 'id' not in operation:
return ChangeSet()
if get_junction(name, cs.operations[0]['id']) == {}:
return ChangeSet()
return execute_command(name, _set_junction(name, cs))
def build_command() -> DatabaseCommand | None:
current = get_junction(name, operation['id'])
return None if current == {} else _set_junction(name, cs, current)
return execute_locked_command(name, build_command)
def _add_junction(name: str, cs: ChangeSet) -> DatabaseCommand:
app/native/wndb/model/options_legacy.py → app/native/wndb/model/options_v2.py
+5 -7
View File
@@ -1,10 +1,8 @@
from psycopg import sql
from ..core.database import ChangeSet, g_update_prefix, read_all, sql_literal
from .options import get_option_schema, generate_v3
def _inp_in_option(section: list[str]) -> ChangeSet:
def _inp_in_option_v2(section: list[str]) -> ChangeSet:
if len(section) <= 0:
return ChangeSet()
@@ -34,9 +32,9 @@ def _inp_in_option(section: list[str]) -> ChangeSet:
return result
def inp_in_option(section: list[str]) -> str:
def inp_in_option_v2(section: list[str]) -> str:
sql = ''
result = _inp_in_option(section)
result = _inp_in_option_v2(section)
for op in result.operations:
for key in op.keys():
if key == 'operation' or key == 'type':
@@ -48,7 +46,7 @@ def inp_in_option(section: list[str]) -> str:
return sql
def inp_out_option(name: str) -> list[str]:
def inp_out_option_v2(name: str) -> list[str]:
lines = []
objs = read_all(name, "select key, value from network.simulation_settings where engine_version = 'legacy' order by key")
@@ -71,7 +69,7 @@ def inp_out_option(name: str) -> list[str]:
# why write this ?
if key == 'PRESSURE':
continue
# release version does not support new keys and has error message
# EPANET V2 does not support these newer keys.
if key == 'HTOL' or key == 'QTOL' or key == 'RQTOL':
continue
# ignore some weird settings for DDA
app/native/wndb/model/options_v3.py
-2
View File
@@ -1,5 +1,3 @@
from psycopg import sql
from ..core.database import ChangeSet, g_update_prefix, read_all, sql_literal
from .options import get_option_schema, get_option_v3_schema, generate_v2, generate_v3
app/native/wndb/model/patterns.py
+4 -1
View File
@@ -93,7 +93,10 @@ def _delete_pattern(name: str, cs: ChangeSet) -> DatabaseCommand:
id = cs.operations[0]['id']
f_id = sql_literal(id)
statement = f"delete from network.patterns where id = {f_id};"
statement = (
f"update network.demands set pattern_id = null where pattern_id = {f_id};"
f"\ndelete from network.patterns where id = {f_id};"
)
change = g_delete_prefix | { 'type': 'pattern' } | { 'id': id }
app/native/wndb/model/pipes.py
+52 -8
View File
@@ -4,6 +4,7 @@ from ..core.database import (
ChangeSet,
DatabaseCommand,
execute_command,
execute_locked_command,
g_add_prefix,
g_delete_prefix,
g_update_prefix,
@@ -144,9 +145,12 @@ class Pipe(object):
def as_dict(self) -> dict[str, Any]:
return { 'type': self.type, 'id': self.id, 'node1': self.node1, 'node2': self.node2, 'length': self.length, 'diameter': self.diameter, 'roughness': self.roughness, 'minor_loss': self.minor_loss, 'status': self.status }
def _set_pipe(name: str, cs: ChangeSet) -> DatabaseCommand:
raw_new = get_pipe(name, cs.operations[0]['id'])
def _set_pipe(
name: str,
cs: ChangeSet,
current: dict[str, Any] | None = None,
) -> DatabaseCommand:
raw_new = current if current is not None else get_pipe(name, cs.operations[0]['id'])
new_dict = cs.operations[0]
schema = get_pipe_schema(name)
for key, value in schema.items():
@@ -154,19 +158,59 @@ def _set_pipe(name: str, cs: ChangeSet) -> DatabaseCommand:
raw_new[key] = new_dict[key]
new = Pipe(raw_new)
statement = f"update network.links set start_node_id = {new.f_node1}, end_node_id = {new.f_node2} where id = {new.f_id};"
statement += f"\nupdate network.pipes set length = {new.f_length}, diameter = {new.f_diameter}, roughness = {new.f_roughness}, minor_loss = {new.f_minor_loss}, status = {new.f_status} where link_id = {new.f_id};"
link_columns = {
'node1': ('start_node_id', new.f_node1),
'node2': ('end_node_id', new.f_node2),
}
pipe_columns = {
'length': ('length', new.f_length),
'diameter': ('diameter', new.f_diameter),
'roughness': ('roughness', new.f_roughness),
'minor_loss': ('minor_loss', new.f_minor_loss),
'status': ('status', new.f_status),
}
statements = []
link_assignments = [
f"{column} = {value}"
for field, (column, value) in link_columns.items()
if field in new_dict
]
if link_assignments:
statements.append(
f"update network.links set {', '.join(link_assignments)} where id = {new.f_id};"
)
pipe_assignments = [
f"{column} = {value}"
for field, (column, value) in pipe_columns.items()
if field in new_dict
]
if pipe_assignments:
statements.append(
f"update network.pipes set {', '.join(pipe_assignments)} where link_id = {new.f_id};"
)
statement = "\n".join(statements)
change = g_update_prefix | new.as_dict()
return DatabaseCommand(statement, [change])
def set_pipe(name: str, cs: ChangeSet) -> ChangeSet:
if 'id' not in cs.operations[0]:
operation = cs.operations[0]
if 'id' not in operation:
return ChangeSet()
if get_pipe(name, cs.operations[0]['id']) == {}:
mutable_fields = {
'node1', 'node2', 'length', 'diameter', 'roughness', 'minor_loss', 'status'
}
if not mutable_fields.intersection(operation):
return ChangeSet()
return execute_command(name, _set_pipe(name, cs))
def build_command() -> DatabaseCommand | None:
current = get_pipe(name, operation['id'])
if current == {}:
return None
return _set_pipe(name, cs, current)
return execute_locked_command(name, build_command)
def _add_pipe(name: str, cs: ChangeSet) -> DatabaseCommand:
app/native/wndb/model/pumps.py
+15 -6
View File
@@ -4,6 +4,7 @@ from ..core.database import (
ChangeSet,
DatabaseCommand,
execute_command,
execute_locked_command,
g_add_prefix,
g_delete_prefix,
g_update_prefix,
@@ -87,8 +88,12 @@ class Pump(object):
def as_dict(self) -> dict[str, Any]:
return { 'type': self.type, 'id': self.id, 'node1': self.node1, 'node2': self.node2, 'power': self.power, 'head': self.head, 'speed': self.speed, 'pattern': self.pattern }
def _set_pump(name: str, cs: ChangeSet) -> DatabaseCommand:
raw_new = get_pump(name, cs.operations[0]['id'])
def _set_pump(
name: str,
cs: ChangeSet,
current: dict[str, Any] | None = None,
) -> DatabaseCommand:
raw_new = current if current is not None else get_pump(name, cs.operations[0]['id'])
new_dict = cs.operations[0]
schema = get_pump_schema(name)
@@ -105,11 +110,15 @@ def _set_pump(name: str, cs: ChangeSet) -> DatabaseCommand:
def set_pump(name: str, cs: ChangeSet) -> ChangeSet:
if 'id' not in cs.operations[0]:
operation = cs.operations[0]
if 'id' not in operation:
return ChangeSet()
if get_pump(name, cs.operations[0]['id']) == {}:
return ChangeSet()
return execute_command(name, _set_pump(name, cs))
def build_command() -> DatabaseCommand | None:
current = get_pump(name, operation['id'])
return None if current == {} else _set_pump(name, cs, current)
return execute_locked_command(name, build_command)
def _add_pump(name: str, cs: ChangeSet) -> DatabaseCommand:
app/native/wndb/model/reservoirs.py
+15 -6
View File
@@ -4,6 +4,7 @@ from ..core.database import (
ChangeSet,
DatabaseCommand,
execute_command,
execute_locked_command,
g_add_prefix,
g_delete_prefix,
g_update_prefix,
@@ -85,8 +86,12 @@ class Reservoir(object):
def as_dict(self) -> dict[str, Any]:
return { 'type': self.type, 'id': self.id, 'x': self.x, 'y': self.y, 'head': self.head, 'pattern': self.pattern }
def _set_reservoir(name: str, cs: ChangeSet) -> DatabaseCommand:
raw_new = get_reservoir(name, cs.operations[0]['id'])
def _set_reservoir(
name: str,
cs: ChangeSet,
current: dict[str, Any] | None = None,
) -> DatabaseCommand:
raw_new = current if current is not None else get_reservoir(name, cs.operations[0]['id'])
new_dict = cs.operations[0]
schema = get_reservoir_schema(name)
@@ -104,11 +109,15 @@ def _set_reservoir(name: str, cs: ChangeSet) -> DatabaseCommand:
def set_reservoir(name: str, cs: ChangeSet) -> ChangeSet:
if 'id' not in cs.operations[0]:
operation = cs.operations[0]
if 'id' not in operation:
return ChangeSet()
if get_reservoir(name, cs.operations[0]['id']) == {}:
return ChangeSet()
return execute_command(name, _set_reservoir(name, cs))
def build_command() -> DatabaseCommand | None:
current = get_reservoir(name, operation['id'])
return None if current == {} else _set_reservoir(name, cs, current)
return execute_locked_command(name, build_command)
def _add_reservoir(name: str, cs: ChangeSet) -> DatabaseCommand:
app/native/wndb/model/tanks.py
+15 -6
View File
@@ -4,6 +4,7 @@ from ..core.database import (
ChangeSet,
DatabaseCommand,
execute_command,
execute_locked_command,
g_add_prefix,
g_delete_prefix,
g_update_prefix,
@@ -121,8 +122,12 @@ class Tank(object):
def as_dict(self) -> dict[str, Any]:
return { 'type': self.type, 'id': self.id, 'x': self.x, 'y': self.y, 'elevation': self.elevation, 'init_level': self.init_level, 'min_level': self.min_level, 'max_level': self.max_level, 'diameter': self.diameter, 'min_vol': self.min_vol, 'vol_curve': self.vol_curve, 'overflow': self.overflow }
def _set_tank(name: str, cs: ChangeSet) -> DatabaseCommand:
raw_new = get_tank(name, cs.operations[0]['id'])
def _set_tank(
name: str,
cs: ChangeSet,
current: dict[str, Any] | None = None,
) -> DatabaseCommand:
raw_new = current if current is not None else get_tank(name, cs.operations[0]['id'])
new_dict = cs.operations[0]
schema = get_tank_schema(name)
@@ -140,11 +145,15 @@ def _set_tank(name: str, cs: ChangeSet) -> DatabaseCommand:
def set_tank(name: str, cs: ChangeSet) -> ChangeSet:
if 'id' not in cs.operations[0]:
operation = cs.operations[0]
if 'id' not in operation:
return ChangeSet()
if get_tank(name, cs.operations[0]['id']) == {}:
return ChangeSet()
return execute_command(name, _set_tank(name, cs))
def build_command() -> DatabaseCommand | None:
current = get_tank(name, operation['id'])
return None if current == {} else _set_tank(name, cs, current)
return execute_locked_command(name, build_command)
def _add_tank(name: str, cs: ChangeSet) -> DatabaseCommand:
app/native/wndb/model/valves.py
+15 -6
View File
@@ -4,6 +4,7 @@ from ..core.database import (
ChangeSet,
DatabaseCommand,
execute_command,
execute_locked_command,
g_add_prefix,
g_delete_prefix,
g_update_prefix,
@@ -94,8 +95,12 @@ class Valve(object):
def as_dict(self) -> dict[str, Any]:
return { 'type': self.type, 'id': self.id, 'node1': self.node1, 'node2': self.node2, 'diameter': self.diameter, 'v_type': self.v_type, 'setting': self.setting, 'minor_loss': self.minor_loss }
def _set_valve(name: str, cs: ChangeSet) -> DatabaseCommand:
raw_new = get_valve(name, cs.operations[0]['id'])
def _set_valve(
name: str,
cs: ChangeSet,
current: dict[str, Any] | None = None,
) -> DatabaseCommand:
raw_new = current if current is not None else get_valve(name, cs.operations[0]['id'])
new_dict = cs.operations[0]
schema = get_valve_schema(name)
@@ -112,11 +117,15 @@ def _set_valve(name: str, cs: ChangeSet) -> DatabaseCommand:
def set_valve(name: str, cs: ChangeSet) -> ChangeSet:
if 'id' not in cs.operations[0]:
operation = cs.operations[0]
if 'id' not in operation:
return ChangeSet()
if get_valve(name, cs.operations[0]['id']) == {}:
return ChangeSet()
return execute_command(name, _set_valve(name, cs))
def build_command() -> DatabaseCommand | None:
current = get_valve(name, operation['id'])
return None if current == {} else _set_valve(name, cs, current)
return execute_locked_command(name, build_command)
def _add_valve(name: str, cs: ChangeSet) -> DatabaseCommand:
app/services/__init__.py
+1 -1
View File
@@ -1,5 +1,5 @@
"""Service package.
Keep package initialization lightweight. Import concrete service modules directly,
for example: `from app.services.tjnetwork import open_project`.
for example: `from app.services.tjnetwork import get_junction`.
"""
app/services/simulation.py
+291 -264
View File
@@ -9,7 +9,6 @@ from app.services.tjnetwork import (
get_status,
get_tank,
get_time,
open_project,
read_all,
run_project,
set_demand,
@@ -34,7 +33,8 @@ import logging
import app.services.globals as globals
import app.services.project_info as project_info
from app.services.time_api import parse_beijing_time, parse_clock_duration_seconds
from app.native.wndb.core.connection import project_connection
from app.native.wndb.core.connection import project_connection, project_transaction
from app.native.wndb.core.database import refresh_materialized_views_after_commit
from app.infra.db.timescaledb.internal_queries import (
InternalQueries as TimescaleInternalQueries,
)
@@ -48,6 +48,31 @@ logging.basicConfig(
)
def _primary_demand(demand_set: dict) -> dict:
"""Return sequence-zero demand, creating it when a junction has none."""
demands = demand_set.setdefault("demands", [])
if not demands:
demands.append({"demand": 0.0, "pattern": None, "category": None})
return demands[0]
def _primary_demand_pattern(demand_set: dict) -> str:
"""Return the first configured pattern in deterministic sequence order."""
pattern = next(
(
demand.get("pattern")
for demand in demand_set.get("demands", [])
if demand.get("pattern")
),
None,
)
if pattern is None:
raise ValueError(
f"Junction {demand_set.get('junction')!r} has no demand pattern"
)
return str(pattern)
def query_corresponding_element_id_and_query_id(name: str) -> None:
"""Load realtime device-to-element mappings from the new asset schema."""
target_maps = {
@@ -221,281 +246,283 @@ def run_simulation(
# elif simulation_type.upper() == 'EXTENDED': # 扩展模拟(复制数据库)
# name_c = '_'.join([name, 'c'])
# if have_project(name_c):
# if is_project_open(name_c):
# close_project(name_c)
# delete_project(name_c)
# copy_project(name, name_c) # 备份项目
# else:
# raise Exception('Incorrect simulation type, choose in (realtime, extended)')
name_c = name
# 打开数据库
open_project(name_c)
dic_time = get_time(name_c)
with project_transaction(name_c):
dic_time = get_time(name_c)
print(dic_time)
print(dic_time)
# 获取水力模拟步长，如’0:15:00‘
globals.hydraulic_timestep = dic_time["HYDRAULIC TIMESTEP"]
# 转换为分钟浮点数，兼容 EPANET 的 H:MM 和 H:MM:SS 写法
globals.PATTERN_TIME_STEP = (
parse_clock_duration_seconds(
globals.hydraulic_timestep,
field_name="HYDRAULIC TIMESTEP",
# 获取水力模拟步长，如’0:15:00‘
globals.hydraulic_timestep = dic_time["HYDRAULIC TIMESTEP"]
# 转换为分钟浮点数，兼容 EPANET 的 H:MM 和 H:MM:SS 写法
globals.PATTERN_TIME_STEP = (
parse_clock_duration_seconds(
globals.hydraulic_timestep,
field_name="HYDRAULIC TIMESTEP",
)
/ 60
)
/ 60
)
# 对输入的时间参数进行处理
pattern_start_time = convert_time_format(modify_pattern_start_time)
# 获取模拟开始时间是对应pattern的第几个数
modify_index = get_pattern_index(pattern_start_time)
# 遍历水泵的pattern_id，并根据输入的pump_pattern修改pattern的值
# for pump_pattern_id in pump_pattern_ids:
# # 检查pump_pattern中pump_pattern_id对应的第一个频率值是否为有效数字（非空、非NaN）。如果该值有效，则继续执行代码块。
# if not np.isnan(modify_pump_pattern[pump_pattern_id][0]):
# # 取出数据库中的pattern
# pump_pattern = get_pattern(name_c, get_pump(name_c, pump_pattern_id)['pattern'])
# # 替换数据库中的pattern为modify_pump_pattern
# pump_pattern['factors'][modify_index: modify_index + len(modify_pump_pattern[pump_pattern_id])] \
# = modify_pump_pattern[pump_pattern_id]
# cs = ChangeSet()
# cs.append(pump_pattern)
# set_pattern(name_c, cs)
# 修改模拟开始的时间
str_pattern_start = get_pattern_index_str(
convert_time_format(modify_pattern_start_time)
)
dic_time = get_time(name_c)
dic_time["PATTERN START"] = str_pattern_start
dic_time["DURATION"] = from_seconds_to_clock(modify_total_duration)
if simulation_type.upper() == "REALTIME":
dic_time["DURATION"] = 0
cs = ChangeSet()
cs.operations.append(dic_time)
set_time(name_c, cs)
# 根据SCADA实时数据进行修改，如果没有对应的SCADA数据，如未来的时间点，则不改变pg数据库的数据
if globals.reservoirs_id:
# reservoirs_id = {'ZBBDJSCP000002': '2497', 'R00003': '2571'}
# 1.获取reservoir的SCADA数据,形式如{'2497': '3.1231', '2571': '2.7387'}
reservoir_SCADA_data_dict = TimescaleInternalQueries.query_scada_by_ids_time(
device_ids=list(globals.reservoirs_id.values()),
query_time=modify_pattern_start_time,
db_name=name,
# 对输入的时间参数进行处理
pattern_start_time = convert_time_format(modify_pattern_start_time)
# 获取模拟开始时间是对应pattern的第几个数
modify_index = get_pattern_index(pattern_start_time)
# 遍历水泵的pattern_id，并根据输入的pump_pattern修改pattern的值
# for pump_pattern_id in pump_pattern_ids:
# # 检查pump_pattern中pump_pattern_id对应的第一个频率值是否为有效数字（非空、非NaN）。如果该值有效，则继续执行代码块。
# if not np.isnan(modify_pump_pattern[pump_pattern_id][0]):
# # 取出数据库中的pattern
# pump_pattern = get_pattern(name_c, get_pump(name_c, pump_pattern_id)['pattern'])
# # 替换数据库中的pattern为modify_pump_pattern
# pump_pattern['factors'][modify_index: modify_index + len(modify_pump_pattern[pump_pattern_id])] \
# = modify_pump_pattern[pump_pattern_id]
# cs = ChangeSet()
# cs.append(pump_pattern)
# set_pattern(name_c, cs)
# 修改模拟开始的时间
str_pattern_start = get_pattern_index_str(
convert_time_format(modify_pattern_start_time)
)
# 2.构建出新字典，形式如{'ZBBDJSCP000002': '3.1231', 'R00003': '2.7387'}
reservoir_dict = {
key: reservoir_SCADA_data_dict[value]
for key, value in globals.reservoirs_id.items()
}
# 3.修改reservoir液位模式
for reservoir_name, value in reservoir_dict.items():
if value and float(value) != 0:
# 先根据reservoir获取对应的pattern，再对pattern进行修改
reservoir_pattern = get_pattern(
name_c, get_reservoir(name_c, reservoir_name)["pattern"]
)
reservoir_pattern["factors"][modify_index] = (
float(value) + globals.RESERVOIR_BASIC_HEIGHT
)
cs = ChangeSet()
cs.append(reservoir_pattern)
set_pattern(name_c, cs)
if globals.tanks_id:
# 修改tank初始液位
tank_SCADA_data_dict = TimescaleInternalQueries.query_scada_by_ids_time(
device_ids=list(globals.tanks_id.values()),
query_time=modify_pattern_start_time,
db_name=name,
)
tank_dict = {
key: tank_SCADA_data_dict[value] for key, value in globals.tanks_id.items()
}
for tank_name, value in tank_dict.items():
if value and float(value) != 0:
tank = get_tank(name_c, tank_name)
tank["init_level"] = float(value)
cs = ChangeSet()
cs.append(tank)
set_tank(name_c, cs)
if globals.fixed_pumps_id:
# 修改工频泵的pattern
fixed_pump_SCADA_data_dict = TimescaleInternalQueries.query_scada_by_ids_time(
device_ids=list(globals.fixed_pumps_id.values()),
query_time=modify_pattern_start_time,
db_name=name,
)
# print(fixed_pump_SCADA_data_dict)
fixed_pump_dict = {
key: fixed_pump_SCADA_data_dict[value]
for key, value in globals.fixed_pumps_id.items()
}
# print(fixed_pump_dict)
for fixed_pump_name, value in fixed_pump_dict.items():
if value:
pump_pattern = get_pattern(
name_c, get_pump(name_c, fixed_pump_name)["pattern"]
)
# print(pump_pattern)
pump_pattern["factors"][modify_index] = float(value)
# print(pump_pattern['factors'][modify_index])
cs = ChangeSet()
cs.append(pump_pattern)
set_pattern(name_c, cs)
if globals.variable_pumps_id:
# 修改变频泵的pattern
variable_pump_SCADA_data_dict = (
TimescaleInternalQueries.query_scada_by_ids_time(
device_ids=list(globals.variable_pumps_id.values()),
dic_time = get_time(name_c)
dic_time["PATTERN START"] = str_pattern_start
dic_time["DURATION"] = from_seconds_to_clock(modify_total_duration)
if simulation_type.upper() == "REALTIME":
dic_time["DURATION"] = 0
cs = ChangeSet()
cs.operations.append(dic_time)
set_time(name_c, cs)
# 根据SCADA实时数据进行修改，如果没有对应的SCADA数据，如未来的时间点，则不改变pg数据库的数据
if globals.reservoirs_id:
# reservoirs_id = {'ZBBDJSCP000002': '2497', 'R00003': '2571'}
# 1.获取reservoir的SCADA数据,形式如{'2497': '3.1231', '2571': '2.7387'}
reservoir_SCADA_data_dict = TimescaleInternalQueries.query_scada_by_ids_time(
device_ids=list(globals.reservoirs_id.values()),
query_time=modify_pattern_start_time,
db_name=name,
)
)
variable_pump_dict = {
key: variable_pump_SCADA_data_dict[value]
for key, value in globals.variable_pumps_id.items()
}
for variable_pump_name, value in variable_pump_dict.items():
if value:
pump_pattern = get_pattern(
name_c, get_pump(name_c, variable_pump_name)["pattern"]
)
pump_pattern["factors"][modify_index] = float(value) / 50
cs = ChangeSet()
cs.append(pump_pattern)
set_pattern(name_c, cs)
if globals.demand_id:
# 基于实时数据，修改大用户节点的pattern
demand_SCADA_data_dict = TimescaleInternalQueries.query_scada_by_ids_time(
device_ids=list(globals.demand_id.values()),
query_time=modify_pattern_start_time,
db_name=name,
)
demand_dict = {
key: demand_SCADA_data_dict[value]
for key, value in globals.demand_id.items()
}
for demand_name, value in demand_dict.items():
if value:
demand_pattern = get_pattern(
name_c, get_demand(name_c, demand_name)["pattern"]
)
if get_option(name_c)["UNITS"] == "LPS":
demand_pattern["factors"][modify_index] = (
float(value) / 3.6
) # 默认SCADA数据获取的是流量单位是m3/h， 转换为 L/s
elif get_option(name_c)["UNITS"] == "CMH":
demand_pattern["factors"][modify_index] = float(value)
cs = ChangeSet()
cs.append(demand_pattern)
set_pattern(name_c, cs)
# 水质、压力实时数据使用方法待补充
#############################
# 显式请求参数覆盖实时设备数据，用于扩展模拟。
# 修改清水池(reservoir)液位的pattern
if modify_reservoir_head_pattern:
for reservoir_name in modify_reservoir_head_pattern.keys():
# 这句代码的作用是判断modify_reservoir_head_pattern[reservoir_name][0]是否不是NaN。
# 如果modify_reservoir_head_pattern[reservoir_name][0]不是NaN，则条件成立，代码块会执行
if not np.isnan(modify_reservoir_head_pattern[reservoir_name][0]):
# 给 list 中的所有元素加上 RESERVOIR_BASIC_HEIGHT
modified_values = [
value + globals.RESERVOIR_BASIC_HEIGHT
for value in modify_reservoir_head_pattern[reservoir_name]
]
reservoir_pattern = get_pattern(
name_c, get_reservoir(name_c, reservoir_name)["pattern"]
)
reservoir_pattern["factors"][
modify_index : modify_index + len(modified_values)
] = modified_values
cs = ChangeSet()
cs.append(reservoir_pattern)
set_pattern(name_c, cs)
# 修改调节池(tank)初始液位
if modify_tank_initial_level:
for tank_name in modify_tank_initial_level.keys():
if (not np.isnan(modify_tank_initial_level[tank_name])) and (
modify_tank_initial_level[tank_name] != 0
):
tank = get_tank(name_c, tank_name)
tank["init_level"] = modify_tank_initial_level[tank_name]
cs = ChangeSet()
cs.append(tank)
set_tank(name_c, cs)
# 修改节点（junction）基础水量（demand）
if modify_junction_base_demand:
for junction_name in modify_junction_base_demand.keys():
if not np.isnan(modify_junction_base_demand[junction_name]):
junction = get_demand(name_c, junction_name)
junction["demand"] = modify_junction_base_demand[junction_name]
cs = ChangeSet()
cs.append(junction)
set_demand(name_c, cs)
# 修改节点（junction）的水量模式（pattern）
if modify_junction_damand_pattern:
for pattern_name in modify_junction_damand_pattern.keys():
if not np.isnan(modify_junction_damand_pattern[pattern_name][0]):
junction_pattern = get_pattern(name_c, pattern_name)
junction_pattern["factors"][
modify_index : modify_index
+ len(modify_junction_damand_pattern[pattern_name])
] = modify_junction_damand_pattern[pattern_name]
cs = ChangeSet()
cs.append(junction_pattern)
set_pattern(name_c, cs)
# 修改工频水泵（fixed_pump）的pattern
if modify_fixed_pump_pattern:
for pump_name in modify_fixed_pump_pattern.keys():
if not np.isnan(modify_fixed_pump_pattern[pump_name][0]):
pump_pattern = get_pattern(
name_c, get_pump(name_c, pattern_name)["pattern"]
)
pump_pattern["factors"][
modify_index : modify_index + len(modify_fixed_pump_pattern)
] = modify_fixed_pump_pattern[pump_name]
cs = ChangeSet()
cs.append(pump_pattern)
set_pattern(name_c, cs)
# 修改变频水泵（variable_pump）的pattern
if modify_variable_pump_pattern:
for pump_name in modify_variable_pump_pattern.keys():
if not np.isnan(modify_variable_pump_pattern[pump_name][0]):
# 给 list 中的所有元素除以 50Hz
modified_values = [
value / 50 for value in modify_variable_pump_pattern[pump_name]
]
pump_pattern = get_pattern(
name_c, get_pump(name_c, pattern_name)["pattern"]
)
pump_pattern["factors"][
modify_index : modify_index + len(modified_values)
] = modified_values
cs = ChangeSet()
cs.append(pump_pattern)
set_pattern(name_c, cs)
# 显式阀门控制沿用 run_simulation_ex 的处理顺序和覆盖规则。
if valve_control is not None:
_apply_valve_control(name_c, valve_control)
# 保留原开度参数逻辑，兼容现有方案调用。
elif modify_valve_opening:
for valve_name in modify_valve_opening.keys():
if not np.isnan(modify_valve_opening[valve_name]):
valve_status = get_status(name_c, valve_name)
if modify_valve_opening[valve_name] == 0:
valve_status["status"] = "CLOSED"
valve_status["setting"] = 0
elif modify_valve_opening[valve_name] < 1:
valve_status["status"] = "OPEN"
valve_status["setting"] = 0.1036 * pow(
modify_valve_opening[valve_name], -3.105
# 2.构建出新字典，形式如{'ZBBDJSCP000002': '3.1231', 'R00003': '2.7387'}
reservoir_dict = {
key: reservoir_SCADA_data_dict[value]
for key, value in globals.reservoirs_id.items()
}
# 3.修改reservoir液位模式
for reservoir_name, value in reservoir_dict.items():
if value and float(value) != 0:
# 先根据reservoir获取对应的pattern，再对pattern进行修改
reservoir_pattern = get_pattern(
name_c, get_reservoir(name_c, reservoir_name)["pattern"]
)
elif modify_valve_opening[valve_name] == 1:
valve_status["status"] = "OPEN"
valve_status["setting"] = 0
cs = ChangeSet()
cs.append(valve_status)
set_status(name_c, cs)
# 运行并返回结果
result_data = json.loads(run_project(name_c))
reservoir_pattern["factors"][modify_index] = (
float(value) + globals.RESERVOIR_BASIC_HEIGHT
)
cs = ChangeSet()
cs.append(reservoir_pattern)
set_pattern(name_c, cs)
if globals.tanks_id:
# 修改tank初始液位
tank_SCADA_data_dict = TimescaleInternalQueries.query_scada_by_ids_time(
device_ids=list(globals.tanks_id.values()),
query_time=modify_pattern_start_time,
db_name=name,
)
tank_dict = {
key: tank_SCADA_data_dict[value] for key, value in globals.tanks_id.items()
}
for tank_name, value in tank_dict.items():
if value and float(value) != 0:
tank = get_tank(name_c, tank_name)
tank["init_level"] = float(value)
cs = ChangeSet()
cs.append(tank)
set_tank(name_c, cs)
if globals.fixed_pumps_id:
# 修改工频泵的pattern
fixed_pump_SCADA_data_dict = TimescaleInternalQueries.query_scada_by_ids_time(
device_ids=list(globals.fixed_pumps_id.values()),
query_time=modify_pattern_start_time,
db_name=name,
)
# print(fixed_pump_SCADA_data_dict)
fixed_pump_dict = {
key: fixed_pump_SCADA_data_dict[value]
for key, value in globals.fixed_pumps_id.items()
}
# print(fixed_pump_dict)
for fixed_pump_name, value in fixed_pump_dict.items():
if value:
pump_pattern = get_pattern(
name_c, get_pump(name_c, fixed_pump_name)["pattern"]
)
# print(pump_pattern)
pump_pattern["factors"][modify_index] = float(value)
# print(pump_pattern['factors'][modify_index])
cs = ChangeSet()
cs.append(pump_pattern)
set_pattern(name_c, cs)
if globals.variable_pumps_id:
# 修改变频泵的pattern
variable_pump_SCADA_data_dict = (
TimescaleInternalQueries.query_scada_by_ids_time(
device_ids=list(globals.variable_pumps_id.values()),
query_time=modify_pattern_start_time,
db_name=name,
)
)
variable_pump_dict = {
key: variable_pump_SCADA_data_dict[value]
for key, value in globals.variable_pumps_id.items()
}
for variable_pump_name, value in variable_pump_dict.items():
if value:
pump_pattern = get_pattern(
name_c, get_pump(name_c, variable_pump_name)["pattern"]
)
pump_pattern["factors"][modify_index] = float(value) / 50
cs = ChangeSet()
cs.append(pump_pattern)
set_pattern(name_c, cs)
if globals.demand_id:
# 基于实时数据，修改大用户节点的pattern
demand_SCADA_data_dict = TimescaleInternalQueries.query_scada_by_ids_time(
device_ids=list(globals.demand_id.values()),
query_time=modify_pattern_start_time,
db_name=name,
)
demand_dict = {
key: demand_SCADA_data_dict[value]
for key, value in globals.demand_id.items()
}
for demand_name, value in demand_dict.items():
if value is not None and not np.isnan(float(value)):
demand_set = get_demand(name_c, demand_name)
demand_pattern = get_pattern(
name_c, _primary_demand_pattern(demand_set)
)
if get_option(name_c)["UNITS"] == "LPS":
demand_pattern["factors"][modify_index] = (
float(value) / 3.6
) # 默认SCADA数据获取的是流量单位是m3/h， 转换为 L/s
elif get_option(name_c)["UNITS"] == "CMH":
demand_pattern["factors"][modify_index] = float(value)
cs = ChangeSet()
cs.append(demand_pattern)
set_pattern(name_c, cs)
# 水质、压力实时数据使用方法待补充
#############################
# 显式请求参数覆盖实时设备数据，用于扩展模拟。
# 修改清水池(reservoir)液位的pattern
if modify_reservoir_head_pattern:
for reservoir_name in modify_reservoir_head_pattern.keys():
# 这句代码的作用是判断modify_reservoir_head_pattern[reservoir_name][0]是否不是NaN。
# 如果modify_reservoir_head_pattern[reservoir_name][0]不是NaN，则条件成立，代码块会执行
if not np.isnan(modify_reservoir_head_pattern[reservoir_name][0]):
# 给 list 中的所有元素加上 RESERVOIR_BASIC_HEIGHT
modified_values = [
value + globals.RESERVOIR_BASIC_HEIGHT
for value in modify_reservoir_head_pattern[reservoir_name]
]
reservoir_pattern = get_pattern(
name_c, get_reservoir(name_c, reservoir_name)["pattern"]
)
reservoir_pattern["factors"][
modify_index : modify_index + len(modified_values)
] = modified_values
cs = ChangeSet()
cs.append(reservoir_pattern)
set_pattern(name_c, cs)
# 修改调节池(tank)初始液位
if modify_tank_initial_level:
for tank_name in modify_tank_initial_level.keys():
if (not np.isnan(modify_tank_initial_level[tank_name])) and (
modify_tank_initial_level[tank_name] != 0
):
tank = get_tank(name_c, tank_name)
tank["init_level"] = modify_tank_initial_level[tank_name]
cs = ChangeSet()
cs.append(tank)
set_tank(name_c, cs)
# 修改节点（junction）基础水量（demand）
if modify_junction_base_demand:
for junction_name in modify_junction_base_demand.keys():
if not np.isnan(modify_junction_base_demand[junction_name]):
junction = get_demand(name_c, junction_name)
_primary_demand(junction)["demand"] = (
modify_junction_base_demand[junction_name]
)
cs = ChangeSet()
cs.append(junction)
set_demand(name_c, cs)
# 修改节点（junction）的水量模式（pattern）
if modify_junction_damand_pattern:
for pattern_name in modify_junction_damand_pattern.keys():
if not np.isnan(modify_junction_damand_pattern[pattern_name][0]):
junction_pattern = get_pattern(name_c, pattern_name)
junction_pattern["factors"][
modify_index : modify_index
+ len(modify_junction_damand_pattern[pattern_name])
] = modify_junction_damand_pattern[pattern_name]
cs = ChangeSet()
cs.append(junction_pattern)
set_pattern(name_c, cs)
# 修改工频水泵（fixed_pump）的pattern
if modify_fixed_pump_pattern:
for pump_name in modify_fixed_pump_pattern.keys():
if not np.isnan(modify_fixed_pump_pattern[pump_name][0]):
pump_pattern = get_pattern(
name_c, get_pump(name_c, pump_name)["pattern"]
)
pump_pattern["factors"][
modify_index
: modify_index + len(modify_fixed_pump_pattern[pump_name])
] = modify_fixed_pump_pattern[pump_name]
cs = ChangeSet()
cs.append(pump_pattern)
set_pattern(name_c, cs)
# 修改变频水泵（variable_pump）的pattern
if modify_variable_pump_pattern:
for pump_name in modify_variable_pump_pattern.keys():
if not np.isnan(modify_variable_pump_pattern[pump_name][0]):
# 给 list 中的所有元素除以 50Hz
modified_values = [
value / 50 for value in modify_variable_pump_pattern[pump_name]
]
pump_pattern = get_pattern(
name_c, get_pump(name_c, pump_name)["pattern"]
)
pump_pattern["factors"][
modify_index : modify_index + len(modified_values)
] = modified_values
cs = ChangeSet()
cs.append(pump_pattern)
set_pattern(name_c, cs)
# 显式阀门控制沿用 run_simulation_ex 的处理顺序和覆盖规则。
if valve_control is not None:
_apply_valve_control(name_c, valve_control)
# 保留原开度参数逻辑，兼容现有方案调用。
elif modify_valve_opening:
for valve_name in modify_valve_opening.keys():
if not np.isnan(modify_valve_opening[valve_name]):
valve_status = get_status(name_c, valve_name)
if modify_valve_opening[valve_name] == 0:
valve_status["status"] = "CLOSED"
valve_status["setting"] = 0
elif modify_valve_opening[valve_name] < 1:
valve_status["status"] = "OPEN"
valve_status["setting"] = 0.1036 * pow(
modify_valve_opening[valve_name], -3.105
)
elif modify_valve_opening[valve_name] == 1:
valve_status["status"] = "OPEN"
valve_status["setting"] = 0
cs = ChangeSet()
cs.append(valve_status)
set_status(name_c, cs)
# 运行并返回结果
result_data = json.loads(run_project(name_c))
refresh_materialized_views_after_commit(name_c)
time_cost_end = time.perf_counter()
print(
"{} -- Hydraulic simulation finished, cost time: {:.2f} s.".format(
app/services/simulation_ops.py
+42 -54
View File
@@ -1,55 +1,60 @@
import json
from datetime import datetime
from functools import wraps
from math import pi
import pytz
from app.algorithms.simulation.runner import run_simulation_ex
from app.native.wndb.core.projects import temporary_project_database
from app.services.tjnetwork import (
close_project,
copy_project,
delete_project,
get_pipe,
get_tank,
have_project,
is_project_open,
open_project,
)
def _isolated_operation(purpose: str):
def decorator(func):
@wraps(func)
def wrapper(prj_name: str, *args, **kwargs):
with temporary_project_database(prj_name, purpose) as temporary:
kwargs["_temporary_project"] = temporary
return func(prj_name, *args, **kwargs)
return wrapper
return decorator
############################################################
# project management 07 ***暂时不使用，与业务需求无关***
############################################################
@_isolated_operation("project_management")
def project_management(
prj_name,
start_datetime,
pump_control,
tank_initial_level_control=None,
region_demand_control=None,
_temporary_project=None,
) -> str:
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Start Analysis."
)
new_name = f"project_management_{prj_name}"
if have_project(new_name):
if is_project_open(new_name):
close_project(new_name)
delete_project(new_name)
# if is_project_open(prj_name):
# close_project(prj_name)
if _temporary_project is None:
raise RuntimeError("Project-management isolation was not prepared")
new_name = _temporary_project
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Start Copying Database."
)
copy_project(prj_name + "_template", new_name)
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Start Opening Database."
)
open_project(new_name)
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Database Loading OK."
@@ -64,9 +69,6 @@ def project_management(
region_demand_control=region_demand_control,
downloading_prohibition=True,
)
if is_project_open(new_name):
close_project(new_name)
delete_project(new_name)
return result
@@ -75,31 +77,31 @@ def project_management(
############################################################
@_isolated_operation("scheduling")
def scheduling_simulation(
prj_name, start_time, pump_control, tank_id, water_plant_output_id, time_delta=300
prj_name,
start_time,
pump_control,
tank_id,
water_plant_output_id,
time_delta=300,
_temporary_project=None,
) -> str:
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Start Analysis."
)
new_name = f"scheduling_{prj_name}"
if have_project(new_name):
if is_project_open(new_name):
close_project(new_name)
delete_project(new_name)
# if is_project_open(prj_name):
# close_project(prj_name)
if _temporary_project is None:
raise RuntimeError("Scheduling isolation was not prepared")
new_name = _temporary_project
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Start Copying Database."
)
copy_project(prj_name + "_template", new_name)
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Start Opening Database."
)
open_project(new_name)
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Database Loading OK."
@@ -115,9 +117,6 @@ def scheduling_simulation(
if not isinstance(output_data, dict):
raise RuntimeError("run_simulation_ex did not return JSON output content")
if not is_project_open(new_name):
open_project(new_name)
tank = get_tank(new_name, tank_id) # 水塔信息
tank_floor_space = pi * pow(tank["diameter"] / 2, 2) # 水塔底面积(m^2)
tank_init_level = tank["init_level"] # 水塔初始水位(m)
@@ -158,38 +157,34 @@ def scheduling_simulation(
"tank_level": tank_level,
}
if is_project_open(new_name):
close_project(new_name)
delete_project(new_name)
return json.dumps(simulation_results)
@_isolated_operation("daily_scheduling")
def daily_scheduling_simulation(
prj_name, start_time, pump_control, reservoir_id, tank_id, water_plant_output_id
prj_name,
start_time,
pump_control,
reservoir_id,
tank_id,
water_plant_output_id,
_temporary_project=None,
) -> str:
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Start Analysis."
)
new_name = f"daily_scheduling_{prj_name}"
if have_project(new_name):
if is_project_open(new_name):
close_project(new_name)
delete_project(new_name)
# if is_project_open(prj_name):
# close_project(prj_name)
if _temporary_project is None:
raise RuntimeError("Daily-scheduling isolation was not prepared")
new_name = _temporary_project
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Start Copying Database."
)
copy_project(prj_name + "_template", new_name)
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Start Opening Database."
)
open_project(new_name)
print(
datetime.now(pytz.timezone("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S")
+ " -- Database Loading OK."
@@ -209,9 +204,6 @@ def daily_scheduling_simulation(
if not isinstance(output_data, dict):
raise RuntimeError("run_simulation_ex did not return JSON output content")
if not is_project_open(new_name):
open_project(new_name)
node_results = output_data.get("node_results") or [] # [{'node': str, 'result': [{'pressure': float, 'head': float}]}]
water_plant_output_pressure = []
reservoir_level = []
@@ -235,8 +227,4 @@ def daily_scheduling_simulation(
"tank_level": tank_level,
}
if is_project_open(new_name):
close_project(new_name)
delete_project(new_name)
return json.dumps(simulation_results)
app/services/tjnetwork.py
+6 -41
View File
@@ -32,14 +32,11 @@ from app.native.wndb.commands.api import (
)
from app.native.wndb.core.database import ChangeSet, read_all
from app.native.wndb.core.projects import (
close_project,
copy_project,
create_project,
delete_project,
have_project,
is_project_open,
list_project,
open_project,
)
from app.native.wndb.gis.backdrop import (
get_backdrop,
@@ -54,6 +51,12 @@ from app.native.wndb.gis.labels import (
get_label_schema,
set_label,
)
from app.native.wndb.gis.network_views import (
get_major_node_coords,
get_major_pipe_nodes,
get_network_link_nodes,
get_network_node_coords,
)
from app.native.wndb.gis.region_geometry import get_nodes_in_region
from app.native.wndb.gis.regions import (
add_region,
@@ -89,16 +92,11 @@ from app.native.wndb.model.elements import (
get_curves,
get_element_type,
get_element_type_value,
get_link_nodes,
get_link_type,
get_links,
get_links_id_and_type,
get_major_nodes,
get_major_pipes,
get_node_links,
get_node_type,
get_nodes,
get_nodes_id_and_type,
get_patterns,
get_regions,
is_curve,
@@ -280,39 +278,6 @@ def get_element_properties(name: str, element_id: str) -> dict[str, Any]:
return get_scada_info(name, element_id)
def get_network_node_coords(name: str) -> dict[str, dict[str, Any]]:
nodes = get_nodes_id_and_type(name)
return {
node_id: {**get_node_coord(name, node_id), "type": node_type}
for node_id, node_type in nodes.items()
}
def get_major_node_coords(name: str, diameter: int) -> dict[str, dict[str, Any]]:
node_types = get_nodes_id_and_type(name)
return {
node_id: {**get_node_coord(name, node_id), "type": node_types[node_id]}
for node_id in get_major_nodes(name, diameter)
}
def get_network_link_nodes(name: str) -> list[str]:
links = get_links_id_and_type(name)
return [
f"{link_id}:{link_type}:{nodes[0]}:{nodes[1]}"
for link_id, link_type in links.items()
if (nodes := get_link_nodes(name, link_id))
]
def get_major_pipe_nodes(name: str, diameter: int) -> list[str]:
return [
f"{link_id}:pipe:{nodes[0]}:{nodes[1]}"
for link_id in get_major_pipes(name, diameter)
if (nodes := get_link_nodes(name, link_id))
]
def get_network_in_extent(
name: str, x1: float, y1: float, x2: float, y2: float
) -> dict[str, Any]: