Merge branch 'master' into region

api/__init__.py

@@ -1,5 +1,5 @@
 from .project import list_project, have_project, create_project, delete_project, clean_project
-from .project import is_project_open, get_project_open_count, open_project, close_project
+from .project import is_project_open, open_project, close_project
 from .project import copy_project
 
 from .inp_in import read_inp, import_inp

api/project.py

@@ -4,10 +4,9 @@ from .connection import g_conn_dict as conn
 
 # no undo/redo
 
-_project_open_count: dict[str, int] = {}
-
 _server_databases = ['template0', 'template1', 'postgres', 'project']
 
+
 def list_project() -> list[str]:
     ps = []
     with pg.connect(conninfo="dbname=postgres host=127.0.0.1", autocommit=True) as conn:
@@ -16,24 +15,30 @@ def list_project() -> list[str]:
                 ps.append(p['datname'])
     return ps
 
+
 def have_project(name: str) -> bool:
     with pg.connect(conninfo="dbname=postgres host=127.0.0.1", autocommit=True) as conn:
         with conn.cursor() as cur:
             cur.execute(f"select * from pg_database where datname = '{name}'")
             return cur.rowcount > 0
 
+
 def copy_project(source: str, new: str) -> None:
     with pg.connect(conninfo="dbname=postgres host=127.0.0.1", autocommit=True) as conn:
         with conn.cursor() as cur:
-            cur.execute(f"create database {new} with template = {source}")
+            cur.execute(f'create database "{new}" with template = {source}')
+
 
 def create_project(name: str) -> None:
     return copy_project('project', name)
 
+
 def delete_project(name: str) -> None:
     with pg.connect(conninfo="dbname=postgres host=127.0.0.1", autocommit=True) as conn:
         with conn.cursor() as cur:
-            cur.execute(f"drop database {name}")
+            cur.execute(f"select pg_terminate_backend(pid) from pg_stat_activity where datname = '{name}'")
+            cur.execute(f'drop database "{name}"')
+
 
 def clean_project(excluded: list[str] = []) -> None:
     projects = list_project()
@@ -48,27 +53,19 @@ def clean_project(excluded: list[str] = []) -> None:
                 if project in _server_databases or project in excluded:
                     continue
                 cur.execute(f"select pg_terminate_backend(pid) from pg_stat_activity where datname = '{project}'")
-                cur.execute(f"drop database {project}")
+                cur.execute(f'drop database "{project}"')
+
 
 def open_project(name: str) -> None:
-    if name not in _project_open_count:
+    if name not in conn:
         conn[name] = pg.connect(conninfo=f"dbname={name} host=127.0.0.1", autocommit=True)
-        _project_open_count[name] = 0
 
-    _project_open_count[name] += 1
 
 def is_project_open(name: str) -> bool:
     return name in conn
 
-def get_project_open_count(name: str) -> int:
-    if is_project_open(name):
-        return _project_open_count[name]
-    return 0
 
 def close_project(name: str) -> None:
-    if name in _project_open_count:
+    if name in conn:
-        _project_open_count[name] -= 1
-        if _project_open_count[name] == 0:
         conn[name].close()
         del conn[name]
-            del _project_open_count[name]

api/s7_valves.py

@@ -157,7 +157,7 @@ def inp_in_valve(line: str) -> str:
     diameter = float(tokens[3])
     v_type = str(tokens[4].upper())
     setting = str(tokens[5])
-    minor_loss = float(tokens[6])
+    minor_loss = float(tokens[6]) if len(tokens) >= 7 else 0.0
     desc = str(tokens[-1]) if has_desc else None
 
     return f"insert into _link (id, type) values ('{id}', 'valve');insert into valves (id, node1, node2, diameter, type, setting, minor_loss) values ('{id}', '{node1}', '{node2}', {diameter}, '{v_type}', '{setting}', {minor_loss});"

dump_inp.py

@@ -0,0 +1,12 @@
+import sys
+from tjnetwork import *
+
+def main():
+    if  len(sys.argv) != 2:
+        print("dump_inp name")
+        return
+
+    dump_inp(sys.argv[1], f'{sys.argv[1]}.inp', '2')
+
+if __name__ == '__main__':
+    main()

main.py

@@ -58,10 +58,6 @@ async def fastapi_delete_project(network: str):
 async def fastapi_is_project_open(network: str):
     return is_project_open(network)
 
-@app.get('/getprojectopencount/')
-async def fastapi_get_project_open_count(network: str) -> int:
-    return get_project_open_count(network)
-
 @app.post("/openproject/")
 async def fastapi_open_project(network: str):
     open_project(network)
@@ -84,7 +80,9 @@ async def fastapi_import_inp(network: str, req: Request):
     ps = {
         "inp" : inp_text
     }
-    return import_inp(network, ChangeSet(ps))
+    ret = import_inp(network, ChangeSet(ps))
+    print(ret)
+    return ret
 
 @app.get("/exportinp/")
 async def fastapi_export_inp(network: str) -> ChangeSet:
@@ -1043,12 +1041,17 @@ async def fastapi_get_curve_schema(network: str) -> dict[str, dict[str, Any]]:
     return get_curve_schema(network)
 
 @app.post("/addcurve/")
-async def fastapi_add_curve(network: str, curve: str, c_type: str, req: Request) -> ChangeSet:
+async def fastapi_add_curve(network: str, curve: str, req: Request) -> ChangeSet:
     props = await req.json()
+
+    print(props)
+
     ps = { 
             'id' : curve,
-            'c_type': c_type
          } | props
+    
+    print(ps)
+    
     return add_curve(network, ChangeSet(ps)) 
 
 @app.post("/deletecurve/")

test_tjnetwork.py

@@ -27,43 +27,53 @@ class TestApi:
 
         assert not have_project(p)
         assert not is_project_open(p)
-        assert get_project_open_count(p) == 0
 
         create_project(p)
 
         assert have_project(p)
         assert not is_project_open(p)
-        assert get_project_open_count(p) == 0
 
         open_project(p)
 
         assert have_project(p)
         assert is_project_open(p)
-        assert get_project_open_count(p) == 1
-
-        open_project(p)
-
-        assert have_project(p)
-        assert is_project_open(p)
-        assert get_project_open_count(p) == 2
-
-        close_project(p)
-
-        assert have_project(p)
-        assert is_project_open(p)
-        assert get_project_open_count(p) == 1
 
         close_project(p)
 
         assert have_project(p)
         assert not is_project_open(p)
-        assert get_project_open_count(p) == 0
 
         delete_project(p)
 
         assert not have_project(p)
         assert not is_project_open(p)
-        assert get_project_open_count(p) == 0
+
+
+    def test_project_name(self):
+        p = 'test_PROJECT_name'
+
+        assert not have_project(p)
+        assert not is_project_open(p)
+
+        create_project(p)
+
+        assert have_project(p)
+        assert not is_project_open(p)
+
+        open_project(p)
+
+        assert have_project(p)
+        assert is_project_open(p)
+
+        close_project(p)
+
+        assert have_project(p)
+        assert not is_project_open(p)
+
+        delete_project(p)
+
+        assert not have_project(p)
+        assert not is_project_open(p)
 
 
     # operation

tjnetwork.py

@@ -185,9 +185,6 @@ def clean_project(excluded: list[str] = []) -> None:
 def is_project_open(name: str) -> bool:
     return api.is_project_open(name)
 
-def get_project_open_count(name: str) -> int:
-    return api.get_project_open_count(name)
-
 def open_project(name: str) -> None:
     return api.open_project(name)