refactor: follow pep8 function naming

Author: MenxLi

docs/src/dev/index.md

@@ -24,14 +24,8 @@ The principle is to **Keep this project simple and maintainable**:
 ## Naming convention
 **Python**
 
-Alough [PEP-8](https://peps.python.org/pep-0008/#function-and-variable-names) suggests use `lower_case_with_underscores` for methods and functions...  
-
-By my personal preference, I use the following naming rules: 
-- `snake_case` (Lowercase / Lower case with underscore) for variables, properties
-- `lowerCamelCase` (Mixed case) for functions, methods
-- `UpperCamelCase` (Pascal case) for classes
-
-**Please follow this style if you are working on this repository**, these naming makes it very clear to distinguish between different types of code.
+Follow [PEP-8](https://peps.python.org/pep-0008/#function-and-variable-names) for python code style.  
+Use `snake_case` for command line arguments.
 
 **Javascript**   
 

lires/cmd/cluster.py

@@ -25,7 +25,7 @@ class ClusterConfigT(TypedDict):
 allowed_entries = ['log', 'ai', 'feed', 'server']
 exec_order = allowed_entries
 
-def __getDefaultConfig()->ClusterConfigT:
+def __default_config()->ClusterConfigT:
     ssl_certfile = os.environ.get("LRS_SSL_CERTFILE", "")
     ssl_keyfile = os.environ.get("LRS_SSL_KEYFILE", "")
     return {
@@ -60,8 +60,8 @@ def __getDefaultConfig()->ClusterConfigT:
         ]
     }
 
-def generateConfigFile(path:str):
-    config = __getDefaultConfig()
+def generate_config_file(path:str):
+    config = __default_config()
 
     # use yaml
     with open(path, "w") as f:
@@ -97,7 +97,7 @@ def generateConfigFile(path:str):
     with open(path, "w") as f:
         f.write("# " + "\n# ".join(comments) + "\n" + content)
 
-def loadConfigFile(path:str)->ClusterConfigT:
+def load_config_file(path:str)->ClusterConfigT:
     with open(path, "r") as f:
         config: ClusterConfigT = yaml.safe_load(f)
 
@@ -137,7 +137,7 @@ def cprint(*args):
     print(BCOLORS.LIGHTMAGENTA + "[cluster] " + " ".join(map(str, args)) + BCOLORS.ENDC)
 
 ## Multi-processes
-def initProcesses(config: ClusterConfigT):
+def init_processes(config: ClusterConfigT):
     """ Execute the config file """
     ps: list[subprocess.Popen] = []
     g_env = os.environ.copy()
@@ -190,15 +190,15 @@ def main():
         if os.path.exists(args.path) and not args.overwrite:
             cprint("Config file already exists, use --overwrite to overwrite")
             exit(1)
-        generateConfigFile(args.path)
+        generate_config_file(args.path)
         exit(0)
 
     if args.overwrite and not args.generate:
         cprint("--overwrite can only be used with --generate")
         exit(1)
 
     if not os.path.exists(args.path) and args.init_if_not_exist:
-        generateConfigFile(args.path)
+        generate_config_file(args.path)
 
     if not os.path.exists(args.path):
         cprint("Config file does not exist, use --generate to generate one")
@@ -220,11 +220,11 @@ def main():
             time.sleep(0.1)
 
     ## Start servers -------------------------------
-    config = loadConfigFile(args.path)
-    procs = initProcesses(config)
+    config = load_config_file(args.path)
+    procs = init_processes(config)
 
     # handle SIGINT
-    def sigintHandler(sig, frame):
+    def sigint_handler(sig, frame):
         print("")   # print a newline
         cprint("{} received, terminating...".format(signal.Signals(sig).name))
 
@@ -242,8 +242,8 @@ def sigintHandler(sig, frame):
         cprint("All processes terminated, exit.")
         exit(0)
 
-    signal.signal(signal.SIGINT, sigintHandler)
-    signal.signal(signal.SIGTERM, sigintHandler)
+    signal.signal(signal.SIGINT, sigint_handler)
+    signal.signal(signal.SIGTERM, sigint_handler)
 
     while True:
         time.sleep(1)

lires/cmd/config.py

@@ -1,4 +1,4 @@
-from ..config import generateDefaultConf, CONF_FILE_PATH
+from ..config import generate_default_conf, CONF_FILE_PATH
 import argparse, json
 
 def run():
@@ -13,7 +13,7 @@ def run():
 
     args = parser.parse_args()
     if args.subparser == "reset":
-        generateDefaultConf(args.group)
+        generate_default_conf(args.group)
 
     elif args.subparser == "show":
         print("Configuration file: ", CONF_FILE_PATH)

lires/cmd/index.py

@@ -7,7 +7,7 @@
 from lires.api import IServerConn
 from lires.loader import init_resources
 
-def parseArgs() -> argparse.Namespace:
+def parse_arguments() -> argparse.Namespace:
     parser = argparse.ArgumentParser(description="Build search index for the database")
     parser.add_argument("user", action="store", type=str, help="user name")
     subparsers = parser.add_subparsers(dest="subparser", help="sub-command help")
@@ -82,7 +82,7 @@ async def entry(args):
 
 def main():
     import asyncio
-    args = parseArgs()
+    args = parse_arguments()
     asyncio.run(entry(args))
 
 if __name__ == "__main__":

lires/cmd/log.py

@@ -22,15 +22,15 @@ def __init__(self, db_file: str) -> None:
         self.conn = sqlite3.connect(db_file)
         self.cur = self.conn.cursor()
 
-    def getTableNames(self) -> list[str]:
+    def get_table_names(self) -> list[str]:
         self.cur.execute("SELECT name FROM sqlite_master WHERE type='table';")
         return [x[0] for x in self.cur.fetchall()]
 
-    def hasTable(self, table_name: str) -> bool:
+    def has_table(self, table_name: str) -> bool:
         self.cur.execute(f"SELECT name FROM sqlite_master WHERE type='table' AND name='{table_name}';")
         return len(self.cur.fetchall()) > 0
 
-    def getMessagesFromTable(
+    def get_messages_from(
         self, 
         table_name: str, 
         level_name: Optional[str] = None,
@@ -41,7 +41,7 @@ def getMessagesFromTable(
             self.cur.execute(f"SELECT * FROM {table_name} WHERE level_name='{level_name}' ORDER BY time DESC LIMIT {limit}")
         return self.cur.fetchall()
 
-    def getCountFromTable(
+    def get_count_from(
         self, 
         table_name: str, 
         level_name: Optional[str] = None) -> int:
@@ -58,16 +58,16 @@ def getCountFromTable(
     "ERROR": BCOLORS.FAIL,
     "CRITICAL": BCOLORS.FAIL,
 }
-def formatLine(line: tuple) -> str:
+def format_line(line: tuple) -> str:
     time = line[1]
     level_name = line[3]
     message = line[4]
     return f"{BCOLORS.OKCYAN}{time}{BCOLORS.ENDC} {__color_level[level_name]}{level_name}{BCOLORS.ENDC}: {message}"
-def formatLines(lines: list[tuple]) -> Generator[str, None, None]:
+def format_lines(lines: list[tuple]) -> Generator[str, None, None]:
     for i in range(0, len(lines)):
-        yield formatLine(lines[i])
+        yield format_line(lines[i])
 
-def sortLines(lines: list[tuple]) -> list[tuple]:
+def sort_lines(lines: list[tuple]) -> list[tuple]:
     # in the order of time
     return sorted(lines, key=lambda x: x[0], reverse=False)
 
@@ -102,17 +102,17 @@ def main():
         parser.print_help()
         return
 
-    def getAllTableNames(files) -> list[str]:
+    def get_all_table_names(files) -> list[str]:
         __all_table_names = []
         for file in files:
             reader = LogDBReader(file)
-            __all_table_names.extend(reader.getTableNames())
+            __all_table_names.extend(reader.get_table_names())
         return sorted(list(set(__all_table_names)))
 
     if args.subparser_name == 'view':
         __all_lines = []
         table_name = args.table
-        __all_table_names = getAllTableNames(args.files)
+        __all_table_names = get_all_table_names(args.files)
         if table_name is None or table_name == "":
             for idx, table_name in enumerate(__all_table_names):
                 print(f"[{idx}] {table_name}")
@@ -143,13 +143,13 @@ def getAllTableNames(files) -> list[str]:
 
         for file in args.files:
             reader = LogDBReader(file)
-            if not reader.hasTable(table_name):
+            if not reader.has_table(table_name):
                 continue
-            lines = reader.getMessagesFromTable(table_name, args.level, limit=args.limit)
+            lines = reader.get_messages_from(table_name, args.level, limit=args.limit)
             __all_lines.extend(lines)
-        __all_lines = sortLines(__all_lines)
+        __all_lines = sort_lines(__all_lines)
         try:
-            for line in formatLines(__all_lines):
+            for line in format_lines(__all_lines):
                 print(line)
             print('\n'+'-' * 80)
             print(f"Total {len(__all_lines)} lines, from table {table_name}")
@@ -164,14 +164,14 @@ def getAllTableNames(files) -> list[str]:
 
     elif args.subparser_name == 'check':
         # get size of each table
-        all_tables = getAllTableNames(args.files)
+        all_tables = get_all_table_names(args.files)
         count = {}
         for file in args.files:
             reader = LogDBReader(file)
             for table_name in all_tables:
-                if not reader.hasTable(table_name):
+                if not reader.has_table(table_name):
                     continue
-                lines = reader.getCountFromTable(table_name, level_name=args.level)
+                lines = reader.get_count_from(table_name, level_name=args.level)
                 count[table_name] = count.setdefault(table_name, 0) + lines
         # print
         max_len = max([len(x) for x in all_tables])
@@ -191,8 +191,8 @@ async def ensureNotLogging():
             from lires.core.error import LiresError
             from lires.utils import BCOLORS
             from lires.api import RegistryConn
-            from lires.config import getConf
-            group_id = getConf()['group']
+            from lires.config import get_conf
+            group_id = get_conf()['group']
             rconn = RegistryConn()
             try:
                 log_service = await rconn.get('log', group_id)
@@ -211,7 +211,7 @@ def unifyPath(path: str) -> str:
             if unifyPath(all_files[i]) == unifyPath(args.output):
                 all_files.pop(i)
                 break
-        all_tables = getAllTableNames(all_files)
+        all_tables = get_all_table_names(all_files)
         conn = sqlite3.connect(args.output)
         cur = conn.cursor()
 
@@ -232,9 +232,9 @@ def unifyPath(path: str) -> str:
                 sql_create = sql_create[:-2] + ")"
                 cur.execute(sql_create)
 
-                if not reader.hasTable(table_name):
+                if not reader.has_table(table_name):
                     continue
-                lines = reader.getMessagesFromTable(table_name)
+                lines = reader.get_messages_from(table_name)
                 for line in lines:
                     cur.execute(f"INSERT INTO {table_name} VALUES (?,?,?,?,?)", line)
         conn.commit()

lires/cmd/userManage.py

@@ -45,7 +45,7 @@ async def _run():
     parser_list.add_argument('-r', "--reverse", help = "Reverse order", action="store_true")
     parser_list.add_argument('--ascii', help = "Only print ascii characters, work only with table", action="store_true")
 
-    def parseStorage(s: str) -> int:
+    def parse_storage(s: str) -> int:
         assert s[:-1].isdigit(), "Invalid storage size"
         assert s[-1].lower() in ["m", "g", "t"], "Invalid storage unit"
         if s[-1].lower() == "m":
@@ -66,7 +66,7 @@ def parseStorage(s: str) -> int:
             await user_db_conn.insert_user(
                 username=args.username, password=generate_hex_hash(args.password), name=args.name,
                 is_admin=args.admin, mandatory_tags=DataTags(args.tags).to_ordered_list(), 
-                max_storage=parseStorage(args.max_storage) if args.max_storage is not None else None
+                max_storage=parse_storage(args.max_storage) if args.max_storage is not None else None
             )
 
         elif args.subparser == "update":
@@ -81,7 +81,7 @@ def parseStorage(s: str) -> int:
             if args.admin is not None:
                 await user_db_conn.update_user(user_id, is_admin=args.admin)
             if args.max_storage is not None:
-                await user_db_conn.update_user(user_id, max_storage=parseStorage(args.max_storage))
+                await user_db_conn.update_user(user_id, max_storage=parse_storage(args.max_storage))
 
         elif args.subparser == "delete":
             assert args.username is not None or args.id is not None, "Username or id is required"

lires/config.py

@@ -56,28 +56,28 @@
 # the new fields will be added on top of the old config file on getConf()
 import uuid
 import platform
-def __staticConfigToken(prefix = uuid.NAMESPACE_DNS):
+def __static_config_token(prefix = uuid.NAMESPACE_DNS):
     # Create a static token for the configuration file, 
     # based on the $LRS_HOME directory and node id
     return uuid.uuid5(prefix, platform.node() + LRS_HOME).hex
 __default_config: LiresConfT = {
-    'group': __staticConfigToken(uuid.NAMESPACE_DNS)[:8],
+    'group': __static_config_token(uuid.NAMESPACE_DNS)[:8],
     'max_users': 1000,
     'default_user_max_storage': '512m',
     'service_port_range': [21000, 22000],
     'allow_public_query': True,
 }
 __essential_config_keys = []  # keys that must be in the configuration file
 __g_config: Optional[LiresConfT] = None     # buffer
-def getConf() -> LiresConfT:
+def get_conf() -> LiresConfT:
     global __g_config, CONF_FILE_PATH
     if __g_config is None:
         with open(CONF_FILE_PATH, "r", encoding="utf-8") as conf_file:
             read_conf = json.load(conf_file)
 
         # compare the keys and value types recursively
         # TODO: may be replaced by a more elegant solution
-        def compareObject(d1, d2):
+        def compare_object(d1, d2):
             if not type(d1) == type(d2):
                 __logger.debug(f"Type mismatch: {type(d1)} != {type(d2)}")
                 return False
@@ -91,14 +91,14 @@ def compareObject(d1, d2):
                         __logger.debug(f"Key mismatch: {d1.keys()} != {d2.keys()}")
                         return False
                 for k in d1:
-                    if not compareObject(d1[k], d2[k]):
+                    if not compare_object(d1[k], d2[k]):
                         return False
             return True
         # check if the essential keys are in the configuration file
         if not all([k in read_conf for k in __essential_config_keys]):
             raise KeyError(f"Essential keys ({__essential_config_keys}) are missing in the configuration file")
         # warn if the configuration file is outdated
-        if not compareObject(read_conf, __default_config):
+        if not compare_object(read_conf, __default_config):
             __logger.warn("Configuration file outdated, "
             "default configuration will be used as fallback, if errors occur, "
             "please run `lrs-config reset` to update the configuration file")
@@ -121,7 +121,7 @@ def compareObject(d1, d2):
     # To not repeatedly reading/parsing configuration file
     return __g_config
 
-def saveToConf(**kwargs):
+def save_conf(**kwargs):
     global __g_config
     try:
         with open(CONF_FILE_PATH, "r", encoding="utf-8") as conf_file:
@@ -137,7 +137,7 @@ def saveToConf(**kwargs):
     # So that next time the configuration will be read from file by getConf
     __g_config = None
 
-def generateDefaultConf(group: Optional[str] = None):
+def generate_default_conf(group: Optional[str] = None):
     """
     Generate default configuration file at CONF_FILE_PATH
     """