refactor: follow pep8 function naming

Author: MenxLi

lires/api/server.py

@@ -3,7 +3,7 @@
 from typing import TYPE_CHECKING, Optional, Any, Literal, TypedDict
 import aiohttp, json, os
 import deprecated
-from lires.utils import randomAlphaNumeric
+from lires.utils import random_alphanumeric
 from lires.types.dataT import DataPointSummary
 if TYPE_CHECKING:
     from lires.core.dataClass import DataPointSummary
@@ -27,7 +27,7 @@ def __init__(
         self._verify_ssl = verify_ssl
         if session_id is None:
             self._session_id = "default"
-        self._session_id = 'py-api-'+randomAlphaNumeric(8)
+        self._session_id = 'py-api-'+random_alphanumeric(8)
 
     @property
     def token(self): return self._token

lires/cmd/_update_db.py

@@ -4,7 +4,7 @@
 import os, shutil, tqdm, asyncio
 from lires.utils import TimeUtils
 from lires.core.dbConn import DBConnection, DocInfo
-from lires.core.bibReader import parseBibtex
+from lires.core.bibReader import parse_bibtex
 from lires.core.dbConn_ import DBConnection as DBConnection_old
 from lires.core.dbConn_ import DocInfo as DocInfo_old
 from lires.config import TMP_DIR, DATABASE_DIR
@@ -17,7 +17,7 @@ async def sync(conn: DBConnection, conn_old: DBConnection_old):
     all_entries = await conn_old.getMany(all_uids)
 
     for old_entry in tqdm.tqdm(all_entries):
-        bib = await parseBibtex(old_entry["bibtex"])
+        bib = await parse_bibtex(old_entry["bibtex"])
         old_info = DocInfo_old.fromString(old_entry["info_str"])
         new_info = DocInfo(
             uuid = old_info.uuid,
@@ -27,7 +27,7 @@ async def sync(conn: DBConnection, conn_old: DBConnection_old):
             device_modify=old_info.device_modify,
         )
 
-        uid = await conn.addEntry(
+        uid = await conn.add_entry(
             bibtex = old_entry["bibtex"],
             title = bib["title"],
             year = bib["year"],
@@ -47,7 +47,7 @@ async def sync(conn: DBConnection, conn_old: DBConnection_old):
         time_import = old_info.time_import
         if isinstance(time_import, str):
             # backward compatibility, < 0.6.0
-            time_import = TimeUtils.strLocalTimeToDatetime(time_import).timestamp()
+            time_import = TimeUtils.localstr2datetime(time_import).timestamp()
 
         await conn.conn.execute(
             """
@@ -64,7 +64,7 @@ async def sync(conn: DBConnection, conn_old: DBConnection_old):
     print("Done")
 
 if __name__ == "__main__":
-    temp_backup = os.path.join(TMP_DIR, "DB_BACKUP_1.4.x_to_1.5.x-{}".format(TimeUtils.nowStamp()))
+    temp_backup = os.path.join(TMP_DIR, "DB_BACKUP_1.4.x_to_1.5.x-{}".format(TimeUtils.now_stamp()))
     # make a backup of the old database
     if os.path.exists(temp_backup):
         exit("Backup already exists, please remove it first: {}".format(temp_backup))

lires/cmd/cluster.py

@@ -5,7 +5,7 @@
 
 from lires.version import VERSION
 from lires.config import LRS_HOME
-from lires.utils import BCOLORS, randomAlphaNumeric
+from lires.utils import BCOLORS, random_alphanumeric
 from typing import TypedDict
 import os, argparse, subprocess, signal, time
 import re
@@ -32,7 +32,7 @@ def __getDefaultConfig()->ClusterConfigT:
         "VERSION": "0.1.0",
         "GLOBAL_ENV": {
             "LRS_HOME": LRS_HOME,
-            "LRS_KEY": randomAlphaNumeric(32),
+            "LRS_KEY": random_alphanumeric(32),
             # disable logging to terminal, as it will be messy if the log server are also running
             "LRS_TERM_LOG_LEVEL": "CRITICAL",   
         },

lires/cmd/config.py

@@ -21,12 +21,12 @@ def run():
             print(json.dumps(json.load(fp), indent=1))
 
     elif args.subparser == "edit":
-        from lires.utils import openFile
+        from lires.utils import open_file
         import subprocess
         if args.use_editor:
             subprocess.call([args.use_editor, CONF_FILE_PATH])
         else:
-            openFile(CONF_FILE_PATH)
+            open_file(CONF_FILE_PATH)
 
     else:
         parser.print_help()

lires/cmd/index.py

@@ -5,7 +5,7 @@
 
 from lires.core.vecutils import build_feature_storage, query_feature_index
 from lires.api import IServerConn
-from lires.loader import initResources
+from lires.loader import init_resources
 
 def parseArgs() -> argparse.Namespace:
     parser = argparse.ArgumentParser(description="Build search index for the database")
@@ -31,9 +31,9 @@ def parseArgs() -> argparse.Namespace:
 
 async def entry(args):
 
-    user_pool, db_pool = await initResources()
+    user_pool, db_pool = await init_resources()
     # check if user exists
-    user = await user_pool.getUserByUsername(args.user)
+    user = await user_pool.get_user_by_username(args.user)
     if user is None:
         print(f"Error: User {args.user} does not exist")
         await user_pool.close(); await db_pool.close()

lires/cmd/invite.py

@@ -1,6 +1,6 @@
 
 import argparse
-from lires.loader import initResources
+from lires.loader import init_resources
 
 async def _run():
     parser = argparse.ArgumentParser()
@@ -18,21 +18,21 @@ async def _run():
 
     args = parser.parse_args()
 
-    user_pool, db_pool = await initResources()
+    user_pool, db_pool = await init_resources()
     user_db_conn = user_pool.conn
     try:
         if args.subparser == "create":
-            await user_db_conn.createInvitation(
+            await user_db_conn.create_invitation(
                 code = args.code,
                 created_by=0,
                 max_uses=args.max_uses,
             )
 
         elif args.subparser == "delete":
-            await user_db_conn.deleteInvitation(args.code)
+            await user_db_conn.delete_invitation(args.code)
 
         elif args.subparser == "list":
-            for inv in await user_db_conn.listInvitations():
+            for inv in await user_db_conn.list_invitations():
                 if not inv["max_uses"] > inv["uses"] and args.valid:
                     continue
 

lires/cmd/miscUtils.py

@@ -21,12 +21,12 @@ def main():
         asyncio.run(download_default_pdfjs_viewer(download_url=args.url, dst_dir=PDF_VIEWER_DIR, force=True))
     if args.subparser == "edit-config":
         from lires.config import CONF_FILE_PATH
-        from lires.utils import openFile
+        from lires.utils import open_file
         import subprocess
         if args.use_editor:
             subprocess.call([args.use_editor, CONF_FILE_PATH])
         else:
-            openFile(CONF_FILE_PATH)
+            open_file(CONF_FILE_PATH)
 
 
 if __name__ == "__main__":

lires/cmd/userManage.py

@@ -1,8 +1,8 @@
 import argparse
-from lires.loader import initResources
-from lires.user.encrypt import generateHexHash
+from lires.loader import init_resources
+from lires.user.encrypt import generate_hex_hash
 from lires.core.dataTags import DataTags
-from lires.utils import tablePrint, TimeUtils
+from lires.utils import table_print, TimeUtils
 
 def str2bool(v):
     if isinstance(v, bool):
@@ -58,51 +58,51 @@ def parseStorage(s: str) -> int:
 
     args = parser.parse_args()
 
-    user_pool, db_pool = await initResources()
+    user_pool, db_pool = await init_resources()
     user_db_conn = user_pool.conn
     try:
         if args.subparser == "add":
             assert args.password is not None, "Password is required"
-            await user_db_conn.insertUser(
-                username=args.username, password=generateHexHash(args.password), name=args.name,
-                is_admin=args.admin, mandatory_tags=DataTags(args.tags).toOrderedList(), 
+            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
             )
 
         elif args.subparser == "update":
             assert args.username is not None, "Username is required"
-            user_id = (await user_db_conn.getUser(args.username))["id"]
+            user_id = (await user_db_conn.get_user(args.username))["id"]
             if args.password is not None:
-                await user_db_conn.updateUser(user_id, password=generateHexHash(args.password))
+                await user_db_conn.update_user(user_id, password=generate_hex_hash(args.password))
             if args.name is not None:
-                await user_db_conn.updateUser(user_id, name=args.name)
+                await user_db_conn.update_user(user_id, name=args.name)
             if args.tags is not None:
-                await user_db_conn.updateUser(user_id, mandatory_tags=DataTags(args.tags).toOrderedList())
+                await user_db_conn.update_user(user_id, mandatory_tags=DataTags(args.tags).to_ordered_list())
             if args.admin is not None:
-                await user_db_conn.updateUser(user_id, is_admin=args.admin)
+                await user_db_conn.update_user(user_id, is_admin=args.admin)
             if args.max_storage is not None:
-                await user_db_conn.updateUser(user_id, max_storage=parseStorage(args.max_storage))
+                await user_db_conn.update_user(user_id, max_storage=parseStorage(args.max_storage))
 
         elif args.subparser == "delete":
             assert args.username is not None or args.id is not None, "Username or id is required"
             assert not (args.username is not None and args.id is not None), "Cannot specify both username and id"
             if args.username is not None:
                 assert args.id is None
-                user = await user_pool.getUserByUsername(args.username)
+                user = await user_pool.get_user_by_username(args.username)
             else:
                 assert args.id is not None
                 assert args.username is None
-                user = await user_pool.getUserById(args.id)
+                user = await user_pool.get_user_by_id(args.id)
             if user is None:
                 print(f"Error: User does not exist")
                 return
             if not args.yes:
-                if input(f"Are you sure you want to delete user **{await user.toString()}**, "
+                if input(f"Are you sure you want to delete user **{await user.to_string()}**, "
                          "together with all data associated? (y/[n])").lower() != "y":
                     print("Cancelled.")
                     return
-            await db_pool.deleteDatabasePermanently(user.id)
-            await user_pool.deleteUserPermanently(user.id)
+            await db_pool.delete_database_permanently(user.id)
+            await user_pool.delete_user_permanently(user.id)
             print("User deleted.")
 
         elif args.subparser == "list":
@@ -116,7 +116,7 @@ def parseStorage(s: str) -> int:
             def formatascii(s):
                 return s.encode('ascii', 'replace').decode()
             if args.table:
-                tablePrint(
+                table_print(
                     ["ID", "Username", "Name", "Admin", "Mandatory Tags", "Max Storage", "Last Active"],
                     [[
                         (user_info:=(await user.info()))["id"],
@@ -125,12 +125,12 @@ def formatascii(s):
                         'X' if user_info["is_admin"] else ' ',
                         '; '.join(user_info["mandatory_tags"]),
                         f"{(user_info['max_storage'])/1024/1024:.1f} MB",
-                        TimeUtils.stamp2Local(user_info["last_active"]).strftime("%Y-%m-%d %H:%M:%S")
+                        TimeUtils.stamp2local(user_info["last_active"]).strftime("%Y-%m-%d %H:%M:%S")
                     ] for user in all_users]
                 )
             else:
                 for user in all_users:
-                    print(await user.toString())
+                    print(await user.to_string())
 
         else:
             parser.print_usage()

lires/core/bibReader.py

@@ -9,9 +9,9 @@
 import pybtex.scanner
 from pylatexenc import latex2text
 import multiprocessing as mp
-from ..utils import randomAlphaNumeric
+from ..utils import random_alphanumeric
 
-async def checkBibtexValidity(
+async def check_bibtex_validity(
     bib_str: str, 
     onerror: Optional[Callable[[str], Awaitable[None]]] = None
     ) -> bool:
@@ -45,7 +45,7 @@ def __init__(self, mode = "single"):
         self.mode = mode
 
     @classmethod
-    def removeAbstract(cls, bib_str: str) -> str:
+    def remove_abstract(cls, bib_str: str) -> str:
         """
         Remove abstract from bib string
         """
@@ -56,7 +56,7 @@ def removeAbstract(cls, bib_str: str) -> str:
         return bib_data.to_string("bibtex")
 
     @classmethod
-    def formatBib(cls, bib_str: str) -> str:
+    def format(cls, bib_str: str) -> str:
         """ Format bib string """
         bib_data = pybtex.database.parse_string(bib_str, bib_format="bibtex")
         return bib_data.to_string("bibtex")
@@ -114,7 +114,7 @@ class ParsedRef(TypedDict):
     year: str
     authors: list[str]
     publication: str
-async def parseBibtex(bib_single: str) -> ParsedRef:
+async def parse_bibtex(bib_single: str) -> ParsedRef:
     """
     parse bibtex and extract useful entries
     """
@@ -147,7 +147,7 @@ async def parseBibtex(bib_single: str) -> ParsedRef:
 
 class BibConverter(LiresBase):
     logger = LiresBase.loggers().core
-    async def fromNBib(self, nb: str) -> str:
+    async def from_nbib(self, nb: str) -> str:
         parsed = nbib.read(nb.strip("\n") + "\n")
         if not parsed:
             await self.logger.error("Error while parsing nbib")
@@ -187,11 +187,11 @@ async def fromNBib(self, nb: str) -> str:
             data.append((k, v))
 
         bib_data = BibliographyData({
-            f"{data_dict['year']}_{randomAlphaNumeric(5)}":
+            f"{data_dict['year']}_{random_alphanumeric(5)}":
             Entry(doc_type, data)
         })
         return bib_data.to_string("bibtex")
 
-    def fromEndNote(self, en: str):
+    def from_endnote(self, en: str):
         parser = refparser.EndnoteParser()
         return parser.toBibtex(en)

lires/core/dataClass.py

@@ -284,29 +284,29 @@ async def get(self, uuid: str) -> DataPoint:
     async def gets(self, uuids: list[str], sort_by='time_import', reverse = True) -> list[DataPoint]:
         """ Get DataPoints by uuids """
         conn = self.conn
-        all_info = await conn.getMany(uuids, sort_by=sort_by, reverse=reverse)
+        all_info = await conn.get_many(uuids, sort_by=sort_by, reverse=reverse)
         tasks = [assembleDatapoint(info, self) for info in all_info]
         return await asyncio.gather(*tasks)
 
     async def getAll(self, sort_by = 'time_import', reverse=True) -> list[DataPoint]:
         """ Get all DataPoints, may remove in the future """
-        all_info = await self.conn.getAll(sort_by=sort_by, reverse=reverse)
+        all_info = await self.conn.get_all(sort_by=sort_by, reverse=reverse)
         return await asyncio.gather(*[assembleDatapoint(info, self) for info in all_info])
 
     async def getIDByTags(self, tags: Union[list, set, DataTags], from_uids: Optional[List[str]] = None) -> list[str]:
         """
         Get DataPoints by tags, including all child tags
         """
         async def _getByStrictIntersect(tags: DataTags, from_uids: Optional[List[str]] = None) -> list[str]:
-            return await self.conn.filter(from_uids=from_uids, tags=tags.toOrderedList(), strict=True, ignore_case=False)
+            return await self.conn.filter(from_uids=from_uids, tags=tags.to_ordered_list(), strict=True, ignore_case=False)
         async def _getBySingle(tag: str, from_uids: Optional[List[str]] = None) -> list[str]:
             return await self.conn.filter(from_uids=from_uids, tags=[tag], strict=True, ignore_case=False)
 
         all_tags = DataTags(await self.conn.tags())
         strict_query_tags = DataTags()                      # the exact tags to be queried
         relaxed_query_tag_groups: list[DataTags] = []       # the tags groups that will be relaxed by union of each group
         for t in tags:
-            if len(_w_child_t:= DataTags([t]).withChildsFrom(all_tags))==1:
+            if len(_w_child_t:= DataTags([t]).with_childs_from(all_tags))==1:
                 strict_query_tags.add(_w_child_t.pop())
             else:
                 relaxed_query_tag_groups.append(_w_child_t)
@@ -338,7 +338,7 @@ async def renameTag(self, tag_old: str, tag_new: str) -> bool:
         for d in data:
             d: DataPoint
             t = d.tags
-            t = TagRule.renameTag(t, tag_old, tag_new)
+            t = TagRule.rename_tag(t, tag_old, tag_new)
             if t is not None:
                 tasks.append(d.fm.writeTags(t))
         await asyncio.gather(*tasks)
@@ -355,7 +355,7 @@ async def deleteTag(self, tag: str) -> bool:
         for d in data:
             d: DataPoint
             ori_tags = d.tags
-            after_deleted = TagRule.deleteTag(ori_tags, tag)
+            after_deleted = TagRule.delete_tag(ori_tags, tag)
             if after_deleted is not None:
                 tasks.append(d.fm.writeTags(after_deleted))
         await asyncio.gather(*tasks)