Use __init__.py to manage api module

api/__init__.py

@@ -0,0 +1,14 @@
+from api.s0_base import delete_curve, delete_node, delete_pattern
+from project import have_project, create_project, delete_project
+from project import is_project_open, open_project, close_project
+
+from operation import execute_undo as undo
+from operation import execute_redo as redo
+
+from s0_base import add_node, add_link, add_curve, add_pattern
+from s0_base import have_node, have_link, have_curve, have_pattern
+from s0_base import is_junction, is_reservoir, is_tank
+from s0_base import is_pipe, is_pump, is_valve
+from s0_base import delete_node, delete_link, delete_curve, delete_pattern
+
+from s1_title import set_title, get_title

api/operation.py

@@ -1,5 +1,5 @@
 from psycopg.rows import dict_row
-from api.connection import g_conn_dict as conn
+from connection import g_conn_dict as conn
 
 def _get_current_operation(name: str) -> int:
     with conn[name].cursor(row_factory=dict_row) as cur:

api/project.py

@@ -1,5 +1,5 @@
 import psycopg as pg
-from api.connection import g_conn_dict as conn
+from connection import g_conn_dict as conn
 
 def have_project(name: str) -> bool:
     with pg.connect(conninfo="dbname=postgres", autocommit=True) as conn:

api/s0_base.py

@@ -1,6 +1,6 @@
 from psycopg.rows import dict_row
-from api.connection import g_conn_dict as conn
-from api.operation import *
+from connection import g_conn_dict as conn
+from operation import *
 
 _NODE = "_node"
 _LINK = "_link"

api/s1_title.py

@@ -1,5 +1,5 @@
 from psycopg.rows import dict_row
-from api.connection import g_conn_dict as conn
+from connection import g_conn_dict as conn
 
 def set_title(name: str, value: str) -> None:
     with conn[name].cursor() as cur:

api/t_operation.py

@@ -1,5 +1,5 @@
-from api.project import *
-from api.s0_base import *
+from project import *
+from s0_base import *
 
 p = "test_operation"
 

api/t_s0_base.py

@@ -1,5 +1,5 @@
-from api.project import *
-from api.s0_base import *
+from project import *
+from s0_base import *
 
 p = "test_s0_base"
 n_1 = "n_1"

api/t_s1_title.py

@@ -1,5 +1,5 @@
-from api.project import *
-from api.s1_title import *
+from project import *
+from s1_title import *
 
 p = "test_s1_title"
 

tjnetwork_new.py

@@ -1,7 +1,4 @@
-import api.project as _p
-import api.operation as _o
-import api.s0_base as _0
-import api.s1_title as _1
+import api
 
 JUNCTION = "JUNCTION"
 RESERVOIR = "RESERVOIR"
@@ -11,85 +8,85 @@ PUMP = "PUMP"
 VALVE = "VALVE"
 
 def have_project(name: str) -> bool:
-    return _p.have_project(name)
+    return api.have_project(name)
 
 def create_project(name: str) -> None:
-    return _p.create_project(name)
+    return api.create_project(name)
 
 def delete_project(name: str) -> None:
-    return _p.delete_project(name)
+    return api.delete_project(name)
 
 def is_project_open(name: str) -> bool:
-    return _p.is_project_open(name)
+    return api.is_project_open(name)
 
 def open_project(name: str) -> None:
-    return _p.open_project(name)
+    return api.open_project(name)
 
 def close_project(name: str) -> None:
-    return _p.close_project(name)
+    return api.close_project(name)
 
 def undo(name: str) -> None:
-    return _o.execute_undo(name)
+    return api.undo(name)
 
 def redo(name: str) -> None:
-    return _o.execute_redo(name)
+    return api.redo(name)
 
 def add_node(name: str, node_id: str, node_type: str) -> None:
-    return _0.add_node(name, node_id, node_type)
+    return api.add_node(name, node_id, node_type)
 
 def have_node(name: str, node_id: str) -> bool:
-    return _0.have_node(name, node_id)
+    return api.have_node(name, node_id)
 
 def is_junction(name: str, node_id: str) -> bool:
-    return _0.is_junction(name, node_id)
+    return api.is_junction(name, node_id)
 
 def is_reservoir(name: str, node_id: str) -> bool:
-    return _0.is_reservoir(name, node_id)
+    return api.is_reservoir(name, node_id)
 
 def is_tank(name: str, node_id: str) -> bool:
-    return _0.is_tank(name, node_id)
+    return api.is_tank(name, node_id)
 
 def delete_node(name: str, node_id: str) -> None:
-    return _0.delete_node(name, node_id)
+    return api.delete_node(name, node_id)
 
 def add_link(name: str, link_id: str, link_type: str) -> None:
-    return _0.add_link(name, link_id, link_type)
+    return api.add_link(name, link_id, link_type)
 
 def have_link(name: str, link_id: str) -> bool:
-    return _0.have_link(name, link_id)
+    return api.have_link(name, link_id)
 
 def is_pipe(name: str, link_id: str) -> bool:
-    return _0.is_pipe(name, link_id)
+    return api.is_pipe(name, link_id)
 
 def is_pump(name: str, link_id: str) -> bool:
-    return _0.is_pump(name, link_id)
+    return api.is_pump(name, link_id)
 
 def is_valve(name: str, link_id: str) -> bool:
-    return _0.is_valve(name, link_id)
+    return api.is_valve(name, link_id)
 
 def delete_link(name: str, link_id: str) -> None:
-    return _0.delete_link(name, link_id)
+    return api.delete_link(name, link_id)
 
 def add_curve(name: str, curve_id: str) -> None:
-    return _0.add_curve(name, curve_id)
+    return api.add_curve(name, curve_id)
 
 def have_curve(name: str, curve_id: str) -> bool:
-    return _0.have_curve(name, curve_id)
+    return api.have_curve(name, curve_id)
 
 def delete_curve(name: str, curve_id: str) -> None:
-    return _0.delete_curve(name, curve_id)
+    return api.delete_curve(name, curve_id)
 
 def add_pattern(name: str, pattern_id: str) -> None:
-    return _0.add_pattern(name, pattern_id)
+    return api.add_pattern(name, pattern_id)
 
 def have_pattern(name: str, pattern_id: str) -> bool:
-    return _0.have_pattern(name, pattern_id)
+    return api.have_pattern(name, pattern_id)
 
 def delete_pattern(name: str, pattern_id: str) -> None:
-    return _0.delete_pattern(name, pattern_id)
+    return api.delete_pattern(name, pattern_id)
 
 def set_title(name: str, title: str) -> None:
-    return _1.set_title(name, title)
+    return api.set_title(name, title)
 
 def get_title(name: str) -> str:
-    return _1.get_title(name)
+    return api.get_title(name)