update: cleanup

Author: VsevolodX

utils/jupyterlite.py

@@ -42,14 +42,14 @@ class SeverityLevelEnum(Enum):
     import subprocess
 
 
-def log(message: str, level: Optional[SeverityLevelEnum] = None, force_verbose=None):
+def log(message: str, level: Optional[SeverityLevelEnum] = None, force_verbose: Optional[bool] = None):
     """
     Log a message based on the VERBOSE flag in the caller's globals().
 
     Args:
         message (str): The message to log.
-        level (SeverityLevelEnum): The severity level of the message (e.g., INFO, WARNING, ERROR).
-        force_verbose (bool): If True, log the message regardless of the VERBOSE flag in globals()
+        level (SeverityLevelEnum, optional): The severity level of the message (e.g., INFO, WARNING, ERROR).
+        force_verbose (bool, optional): If True, log the message regardless of the VERBOSE flag in globals().
     """
     if force_verbose is True:
         should_log = True
@@ -71,11 +71,12 @@ def log(message: str, level: Optional[SeverityLevelEnum] = None, force_verbose=N
             print(f"{level.value}: {message}")
 
 
-async def install_package_pyodide(pkg: str, verbose=True):
+async def install_package_pyodide(pkg: str, verbose: bool = True):
     """
     Install a package in a Pyodide environment.
+
     Args:
-        pkg (string): The name of the package to install.
+        pkg (str): The name of the package to install.
         verbose (bool): Whether to print the name of the installed package.
     """
     is_url = pkg.startswith("http://") or pkg.startswith("https://") or pkg.startswith("emfs:/")
@@ -86,24 +87,26 @@ async def install_package_pyodide(pkg: str, verbose=True):
         log(f"Installed {pkg_name}", force_verbose=verbose)
 
 
-def install_package_python(pkg: str, verbose=True):
+def install_package_python(pkg: str, verbose: bool = True):
     """
     Install a package in a standard Python environment.
+
     Args:
-        pkg (string): The name of the package to install.
+        pkg (str): The name of the package to install.
         verbose (bool): Whether to print the name of the installed package.
     """
     subprocess.check_call([sys.executable, "-m", "pip", "install", pkg])
     if verbose:
         log(f"Installed {pkg}", force_verbose=verbose)
 
 
-async def install_packages(notebook_name: str, requirements_path="config.yml", verbose=True):
+async def install_packages(notebook_name: str, requirements_path: str = "config.yml", verbose: bool = True):
     """
     Install the packages listed in the requirements file for the notebook with the given name.
+
     Args:
-        notebook_name (string): The name of the notebook for which to install packages.
-        requirements_path (string): The path to the requirements file.
+        notebook_name (str): The name of the notebook for which to install packages.
+        requirements_path (str): The path to the requirements file.
         verbose (bool): Whether to print the names of the installed packages and status of installation.
     """
     if ENVIRONMENT == EnvironmentEnum.PYODIDE:
@@ -167,7 +170,7 @@ def set_data_pyodide(key: str, value: Any):
     through a JavaScript function defined in the JupyterLite extension `data_bridge`.
 
     Args:
-        key (string): The name under which data will be sent.
+        key (str): The name under which data will be sent.
         value (Any): The value to send to the host environment.
     """
     serialized_data = json.dumps({key: value})
@@ -189,8 +192,9 @@ def set_data_pyodide(key: str, value: Any):
 def set_data_python(key: str, value: Any):
     """
     Write data to the `uploads` folder in a JupyterLab environment.
+
     Args:
-        key (string): The name under which data will be written.
+        key (str): The name under which data will be written.
         value (Any): The value to write to the `uploads` folder.
     """
     if not os.path.exists(UPLOADS_FOLDER):
@@ -206,8 +210,9 @@ def set_data_python(key: str, value: Any):
 def set_data(key: str, value: Any):
     """
     Switch between the two functions `set_data_pyodide` and `set_data_python` based on the environment.
+
     Args:
-        key (string): The name under which data will be written or sent.
+        key (str): The name under which data will be written or sent.
         value (Any): The value to write or send.
     """
     if ENVIRONMENT == EnvironmentEnum.PYODIDE:
@@ -219,20 +224,22 @@ def set_data(key: str, value: Any):
 def get_data_pyodide(key: str, globals_dict: Optional[Dict] = None):
     """
     Load data from the host environment into globals()[key] variable.
+
     Args:
-        key (string): global variable name to store the received data.
-        globals_dict (dict): globals() dictionary of the current scope.
+        key (str): Global variable name to store the received data.
+        globals_dict (dict, optional): globals() dictionary of the current scope.
     """
     if globals_dict is not None:
-        globals_dict[key] = globals_dict["data_from_host"]
+        globals_dict[key] = globals_dict.get("data_from_host", None)
 
 
 def get_data_python(key: str, globals_dict: Optional[Dict] = None):
     """
     Read data from the `uploads` folder in a JupyterLab environment.
+
     Args:
-        key (string): The name under which data is expected to be received.
-        globals_dict (dict): A dictionary to store the received data. Defaults to None.
+        key (str): The name under which data is expected to be received.
+        globals_dict (dict, optional): A dictionary to store the received data. Defaults to None.
     """
     try:
         data_from_host = []
@@ -254,9 +261,10 @@ def get_data_python(key: str, globals_dict: Optional[Dict] = None):
 def get_data(key: str, globals_dict: Optional[Dict] = None):
     """
     Switch between the two functions `get_data_pyodide` and `get_data_python` based on the environment.
+
     Args:
-        key (string): The name under which data is expected to be received.
-        globals_dict (dict): A dictionary to store the received data. Defaults to None.
+        key (str): The name under which data is expected to be received.
+        globals_dict (dict, optional): A dictionary to store the received data. Defaults to None.
     """
     if ENVIRONMENT == EnvironmentEnum.PYODIDE:
         get_data_pyodide(key, globals_dict)
@@ -269,7 +277,7 @@ def get_materials(globals_dict: Optional[Dict] = None) -> List[Any]:
     Retrieve materials from the environment and assign them to globals_dict["materials_in"].
 
     Args:
-        globals_dict (dict): The globals dictionary to populate.
+        globals_dict (dict, optional): The globals dictionary to populate.
 
     Returns:
         List[Material]: A list of Material objects.
@@ -309,14 +317,14 @@ def set_materials(materials: List[Any]):
     set_data("materials", materials_data)
 
 
-def load_materials_from_folder(folder_path: Optional[str] = None):
+def load_materials_from_folder(folder_path: Optional[str] = None, verbose: bool = True) -> List[Any]:
     """
     Load materials from the specified folder or from the UPLOADS_FOLDER by default.
 
     Args:
         folder_path (Optional[str]): The path to the folder containing material files.
                                      If not provided, defaults to the UPLOADS_FOLDER.
-        verbose: set to be verbose
+        verbose (bool): Whether to log verbose messages.
 
     Returns:
         List[Material]: A list of Material objects loaded from the folder.
@@ -326,7 +334,7 @@ def load_materials_from_folder(folder_path: Optional[str] = None):
     folder_path = folder_path or UPLOADS_FOLDER
 
     if not os.path.exists(folder_path):
-        log(f"Folder '{folder_path}' does not exist.", SeverityLevelEnum.ERROR)
+        log(f"Folder '{folder_path}' does not exist.", SeverityLevelEnum.ERROR, force_verbose=verbose)
         return []
 
     data_from_host = []
@@ -337,54 +345,67 @@ def load_materials_from_folder(folder_path: Optional[str] = None):
                 with open(os.path.join(folder_path, filename), "r") as file:
                     data = json.load(file)
                 name = os.path.splitext(filename)[0]
-                log(f"{index}: {name}")
+                log(f"{index}: {name}", SeverityLevelEnum.INFO, force_verbose=verbose)
                 index += 1
                 data_from_host.append(data)
     except FileNotFoundError:
-        log(f"No data found in the '{folder_path}' folder.", SeverityLevelEnum.ERROR)
+        log(f"No data found in the '{folder_path}' folder.", SeverityLevelEnum.ERROR, force_verbose=verbose)
         return []
 
     materials = [Material(item) for item in data_from_host]
 
     if materials:
-        log(f"Successfully loaded {len(materials)} materials from folder '{folder_path}'", SeverityLevelEnum.INFO)
+        log(
+            f"Successfully loaded {len(materials)} materials from folder '{folder_path}'",
+            SeverityLevelEnum.INFO,
+            force_verbose=verbose,
+        )
     else:
-        log(f"No materials found in folder '{folder_path}'", SeverityLevelEnum.WARNING)
+        log(f"No materials found in folder '{folder_path}'", SeverityLevelEnum.WARNING, force_verbose=verbose)
 
     return materials
 
 
-def load_material_from_folder(folder_path: str, name: str) -> Optional[Any]:
+def load_material_from_folder(folder_path: str, name: str, verbose: bool = True) -> Optional[Any]:
     """
     Load a single material from the specified folder by matching a substring of the name.
 
     Args:
         folder_path (str): The path to the folder containing material files.
         name (str): The substring of the name of the material to load.
+        verbose (bool): Whether to log verbose messages.
 
     Returns:
         Optional[Material]: The first Material object that contains the name substring, or None if not found.
     """
-    materials = load_materials_from_folder(folder_path)
+    # Reuse the existing function to load all materials from the folder
+    materials = load_materials_from_folder(folder_path, verbose=verbose)
     for material in materials:
         if name.lower() in material.name.lower():
             log(
-                f"Material containing '{name}' found: '{material.name}' in folder '{folder_path}'.",
+                f"Found: '{material.name}'",
                 SeverityLevelEnum.INFO,
+                force_verbose=verbose,
             )
             return material
-    log(f"No material containing '{name}' found in folder '{folder_path}'.", SeverityLevelEnum.WARNING)
+
+    log(
+        f"No material containing '{name}' found in folder '{folder_path}'.",
+        SeverityLevelEnum.WARNING,
+        force_verbose=verbose,
+    )
     return None
 
 
-def write_materials_to_folder(materials: List[Any], folder_path: Optional[str] = None):
+def write_materials_to_folder(materials: List[Any], folder_path: Optional[str] = None, verbose: bool = True):
     """
     Write materials to the specified folder or to the UPLOADS_FOLDER by default.
 
     Args:
         materials (List[Material]): The list of Material objects to write to the folder.
         folder_path (Optional[str]): The path to the folder where the materials will be written.
                                      If not provided, defaults to the UPLOADS_FOLDER.
+        verbose (bool): Whether to log verbose messages.
     """
     from mat3ra.utils.array import convert_to_array_if_not
 
@@ -393,10 +414,12 @@ def write_materials_to_folder(materials: List[Any], folder_path: Optional[str] =
 
     if not os.path.exists(folder_path):
         os.makedirs(folder_path)
+        if verbose:
+            log(f"Created folder '{folder_path}'.", SeverityLevelEnum.INFO)
 
     for material in materials:
         safe_name = material.name.replace("%", "pct").replace("/", ":")
         file_path = os.path.join(folder_path, f"{safe_name}.json")
         with open(file_path, "w") as file:
             json.dump(material.to_json(), file)
-        log(f"Material '{material.name}' written to '{file_path}'")
+        log(f"Material '{material.name}' written to '{file_path}'", SeverityLevelEnum.INFO, force_verbose=verbose)