Started replacing relative imports with absolute imports

Author: kyleellefsen

flika/__init__.py

@@ -1,6 +1,13 @@
-from .logger import logger
+"""
+Flika: An interactive image processing program for biologists written in Python.
+"""
+
+from flika.logger import logger
 logger.debug("Started 'reading __init__.py'")
-from .version import __version__
-from .flika import start_flika
-from . import global_vars as g
-logger.debug("Completed 'reading __init__.py'")
+from flika.version import __version__
+from flika.flika import start_flika
+import flika.global_vars as g
+logger.debug("Completed 'reading __init__.py'")
+
+# Define public API
+__all__ = ["start_flika", "__version__", "g"]

flika/flika.py

@@ -1,24 +1,38 @@
 # -*- coding: utf-8 -*-
-from .logger import logger
-logger.debug("Started 'reading flika.py'")
-import sys, os
+"""
+Main module for the flika application.
+"""
+
+# Standard library imports
+import os
+import sys
 import platform
 import optparse
 import warnings
+import pathlib
+from typing import Any
 
 # Set Jupyter to use platformdirs (fixes deprecation warning)
 os.environ['JUPYTER_PLATFORM_DIRS'] = '1'
 
+# Third-party imports
+import numpy as np
+import beartype
+
+# Local application imports
+from flika.logger import logger
+from flika.version import __version__
+from flika.app.application import FlikaApplication
+
+logger.debug("Started 'reading flika.py'")
 logger.debug("Started 'reading flika.py, importing numpy'")
-import numpy as np  # type: ignore
 logger.debug("Completed 'reading flika.py, importing numpy'")
-from .version import __version__
-from .app.application import FlikaApplication
 
 # Filter out known warnings
 warnings.filterwarnings("ignore", category=np.exceptions.VisibleDeprecationWarning)
 
-def parse_arguments(argv):
+@beartype.beartype
+def parse_arguments(argv: list[str]) -> tuple[Any, list[str]]:
     ''' Parses command line arguments for valid flika args
 
     Arguments:
@@ -59,19 +73,19 @@ def parse_arguments(argv):
 
     err_msg = verify(parser, argv)
     if err_msg:
-        sys.stderr.write('\n%s\n' % err_msg)
+        sys.stderr.write(f'\n{err_msg}\n')
         parser.print_help()
         sys.exit(1)
 
     return parser.parse_args(argv)
 
-def verify(parser, argv):
-    """verify(parser, argv)
-    Check for input errors
+@beartype.beartype
+def verify(parser: optparse.OptionParser, argv: list[str]) -> str|None:
+    """Check for input errors
 
     Arguments:
         parser: OptionParser instance
-        argv (list): Argument list
+        argv: Argument list
 
     Returns:
         An error message in the event of an input error, or None
@@ -83,32 +97,37 @@ def verify(parser, argv):
 
     return err_msg
 
-def ipython_qt_event_loop_setup():
+@beartype.beartype
+def ipython_qt_event_loop_setup() -> None:
+    """Set up the IPython Qt event loop if running inside IPython."""
     try:
         __IPYTHON__
     except NameError:
         return #  If __IPYTHON__ is not defined, we are not in ipython
     else:
         print("Starting flika inside IPython")
-        from IPython import get_ipython  # type: ignore
+        from IPython import get_ipython
         ipython = get_ipython()
         ipython.run_line_magic("gui", "qt")
 
-def load_files(files):
-    from .process.file_ import open_file
+@beartype.beartype
+def load_files(files: list[str]) -> None:
+    from flika.process.file_ import open_file
     for f in files:
         open_file(f)
 
-def start_flika(files=[]):
+@beartype.beartype
+def start_flika(files: list[str]|None = None) -> FlikaApplication:
     """Run a flika session and exit, beginning the event loop
 
     Parameters:
-        files (list): An optional list of data files to load.
+        files: An optional list of data files to load.
 
     Returns:
         A flika application object with optional files loaded
- 
     """
+    if files is None:
+        files = []
     logger.debug("Started 'flika.start_flika()'")
     print('Starting flika')
     fa = FlikaApplication()
@@ -118,26 +137,37 @@ def start_flika(files=[]):
     logger.debug("Completed 'flika.start_flika()'")
     return fa
 
-def exec_():
+@beartype.beartype
+def exec_() -> int:
+    """Execute the flika application."""
     fa = start_flika(sys.argv[1:])
     return fa.app.exec_()
 
-def post_install():
+@beartype.beartype
+def post_install() -> None:
     if platform.system() == 'Windows':
         print("Creating start menu shortcut...")
-        import winshell  # type: ignore
-        icon_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'images', 'favicon.ico')
-        flika_exe = os.path.join(sys.exec_prefix, 'Scripts', 'flika.exe')
-        link_path = os.path.join(winshell.programs(), "flika.lnk")
-        with winshell.shortcut(link_path) as link:
-            link.path = flika_exe
-            link.description = "flika"
-            link.icon_location = (icon_path, 0)
-        link_path = os.path.join(winshell.desktop(), "flika.lnk")
-        with winshell.shortcut(link_path) as link:
-            link.path = flika_exe
-            link.description = "flika"
-            link.icon_location = (icon_path, 0)
+        try:
+            import winshell
+            import importlib.resources as pkg_resources
+            from flika import images
+            
+            # Use importlib.resources instead of os.path
+            with pkg_resources.path(images, 'favicon.ico') as icon_path:
+                # Use Path for path manipulation
+                flika_exe = pathlib.Path(sys.exec_prefix) / 'Scripts' / 'flika.exe'
+                link_path = pathlib.Path(winshell.programs()) / "flika.lnk"
+                with winshell.shortcut(str(link_path)) as link:
+                    link.path = str(flika_exe)
+                    link.description = "flika"
+                    link.icon_location = (str(icon_path), 0)
+                link_path = pathlib.Path(winshell.desktop()) / "flika.lnk"
+                with winshell.shortcut(str(link_path)) as link:
+                    link.path = str(flika_exe)
+                    link.description = "flika"
+                    link.icon_location = (str(icon_path), 0)
+        except ImportError:
+            print("winshell package not found. Shortcuts not created.")
 
 if __name__ == '__main__':
     start_flika(sys.argv[1:])

flika/global_vars.py

@@ -9,19 +9,22 @@
 
     I = g.win.image
 
+"""
 
+import json
+import uuid
+import multiprocessing
+from collections.abc import MutableMapping
+import pathlib
 
-"""
-from .logger import logger
-logger.debug("Started 'reading global_vars.py'")
-import os
-from multiprocessing import cpu_count
-from os.path import expanduser
+# Third-party imports
 from qtpy import QtWidgets, QtGui, QtCore
-from collections.abc import MutableMapping
-import json
-from uuid import getnode
-from .utils.system_info import get_location
+
+# Local application imports
+from flika.logger import logger
+import flika.utils.system_info
+
+logger.debug("Started 'reading global_vars.py'")
 
 __all__ = ['m', 'Settings', 'menus', 'alert', 'windows', 'traceWindows', 'currentWindow', 'win', 'currentTrace', 'clipboard']
 
@@ -42,7 +45,7 @@ class Settings(MutableMapping): #http://stackoverflow.com/questions/3387691/pyth
                         'show_windows': True, 
                         'recent_scripts': [],
                         'recent_files': [],
-                        'nCores':cpu_count(),
+                        'nCores':multiprocessing.cpu_count(),
                         'debug_mode': False,
                         'point_color': '#ff0000',
                         'point_size': 5,
@@ -53,8 +56,8 @@ class Settings(MutableMapping): #http://stackoverflow.com/questions/3387691/pyth
                         'default_roi_on_click': False}
 
     def __init__(self):
-        self.settings_file = os.path.join(expanduser("~"), '.FLIKA', 'settings.json' )
-        self.d = Settings.initial_settings
+        self.settings_file = pathlib.Path(pathlib.Path("~").expanduser() / '.FLIKA' / 'settings.json')
+        self.d = Settings.initial_settings.copy()
         self.load()
 
     def __getitem__(self, item):
@@ -83,15 +86,14 @@ def __contains__(self, item):
     def save(self):
         """save(self)
                  Save settings file. The file is stored in ``~/.FLIKA/settings.json`` """
-        if not os.path.exists(os.path.dirname(self.settings_file)):
-            os.makedirs(os.path.dirname(self.settings_file))
+        self.settings_file.parent.mkdir(parents=True, exist_ok=True)
         with open(self.settings_file, 'w') as fp:
             json.dump(self.d, fp, indent=4)
 
     def load(self):
         """load(self)
         Load settings file. The file is stored in ``~/.FLIKA/settings.json`` """
-        if not os.path.exists(self.settings_file):
+        if not self.settings_file.exists():
             print('No settings file found. Creating settings file.')
             self.save()
         try:
@@ -114,9 +116,9 @@ def _load_user_information(self):
         if 'user_information' not in self.d:
             self.d['user_information'] = {}
         if 'UUID' not in self.d['user_information'] or self.d['user_information']['UUID'] is None:
-            self.d['user_information']['UUID'] = getnode()
+            self.d['user_information']['UUID'] = uuid.getnode()
         if 'location' not in self.d['user_information'] or self.d['user_information']['location'] is None:
-            self.d['user_information']['location'] = get_location()
+            self.d['user_information']['location'] = flika.utils.system_info.get_location()
 
 
     def setmousemode(self, mode):

flika/process/__init__.py

@@ -1,20 +1,26 @@
 # -*- coding: utf-8 -*-
-from ..logger import logger
+"""
+Process module for flika - provides image processing operations.
+"""
+
+# Local application imports
+from flika.logger import logger
 logger.debug("Started 'reading process/__init__.py'")
 
-from .stacks import *
-from .math_ import *
-from .filters import *
-from .binary import *
-from .roi import *
-from .measure import *
-from .color import *
-from .overlay import *
-from .file_ import *
+from flika.process.stacks import *
+from flika.process.math_ import *
+from flika.process.filters import *
+from flika.process.binary import *
+from flika.process.roi import *
+from flika.process.measure import *
+from flika.process.color import *
+from flika.process.overlay import *
+from flika.process.file_ import *
 
 def setup_menus():
+    """Set up the flika menu structure for process operations."""
     logger.debug("Started 'process.__init__.setup_menus()'")
-    from .. import global_vars as g
+    import flika.global_vars as g
     if len(g.menus) > 0:
         print("flika menubar already initialized.")
         return

flika/process/file_.py

@@ -1,24 +1,33 @@
 # -*- coding: utf-8 -*-
-from ..logger import logger
-logger.debug("Started 'reading process/file_.py'")
-import pyqtgraph as pg
-import pyqtgraph.exporters
+"""
+File-related operations for flika - opening, saving, and closing files.
+"""
+
+# Standard library imports
 import time
 import os.path
 import sys
-import numpy as np
-from qtpy import uic, QtGui, QtCore, QtWidgets
-import shutil, subprocess
+import shutil
+import subprocess
 import datetime
 import json
 import re
 import pathlib
 
-from .. import global_vars as g
-from ..utils.BaseProcess import BaseDialog
-from ..window import Window
-from ..utils.misc import open_file_gui, save_file_gui
-from ..utils.io import tifffile
+# Third-party imports
+import numpy as np
+import pyqtgraph as pg
+from qtpy import QtGui, QtWidgets
+
+# Local application imports
+from flika.logger import logger
+import flika.global_vars as g
+from flika.utils.BaseProcess import BaseDialog
+from flika.window import Window
+from flika.utils.misc import open_file_gui, save_file_gui
+from flika.utils.io import tifffile
+
+logger.debug("Started 'reading process/file_.py'")
 
 __all__ = ['save_file', 'save_points', 'save_rois', 'save_movie_gui', 'open_file', 'open_file_from_gui', 'open_image_sequence_from_gui', 'open_points', 'close']
 
@@ -247,7 +256,7 @@ def open_image_sequence(filename=None, from_gui=False):
     return new_window
 
 
-def open_file(filename=None, from_gui=False):
+def open_file(filename: str|None =None, from_gui: bool =False):
     """ open_file(filename=None)
     Opens an image or movie file (.tif, .stk, .nd2) into a new_window.
 
@@ -272,7 +281,7 @@ def open_file(filename=None, from_gui=False):
     print(f"Filename: {filename}")
     g.m.statusBar().showMessage(f'Loading {os.path.basename(str(filename))}')
     t = time.time()
-    metadata = dict()
+    metadata: dict = {}
     ext = os.path.splitext(str(filename))[1]
     if ext in ['.tif', '.stk', '.tiff', '.ome']:
         results = open_tiff(str(filename), metadata)