graxpert 3.2.0a0.dev8__tar.gz → 3.2.0a2__tar.gz

{graxpert-3.2.0a0.dev8 → graxpert-3.2.0a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graxpert
-Version: 3.2.0a0.dev8
+Version: 3.2.0a2
 Summary: GraXpert is an astronomical image processing program for extracting and removing gradients in the background of your astrophotos
 Home-page: https://graxpert.com
 Author: GraXpert Development Team

graxpert-3.2.0a2/graxpert/__init__.py

@@ -0,0 +1,3 @@
+from graxpert.main import api_run
+
+__all__ = ['api_run']

{graxpert-3.2.0a0.dev8 → graxpert-3.2.0a2}/graxpert/ai_model_handling.py

@@ -18,7 +18,7 @@ except Exception as e:
     logging.exception(e)
     client = None
 
-from graxpert.ui.loadingframe import DynamicProgressThread
+from graxpert.progress import DynamicProgressThread
 
 ai_models_dir = os.path.join(user_data_dir(appname="GraXpert"), "ai-models")
 bge_ai_models_dir = os.path.join(user_data_dir(appname="GraXpert"), "bge-ai-models")

{graxpert-3.2.0a0.dev8 → graxpert-3.2.0a2}/graxpert/application/app.py

@@ -29,7 +29,10 @@ from graxpert.mp_logging import logfile_name
 from graxpert.preferences import fitsheader_2_app_state, load_preferences, prefs_2_app_state
 from graxpert.s3_secrets import bge_bucket_name, deconvolution_object_bucket_name, deconvolution_stars_bucket_name, denoise_bucket_name
 from graxpert.stretch import StretchParameters, stretch_all
-from graxpert.ui.loadingframe import DynamicProgressThread
+from graxpert.progress import DynamicProgressThread
+
+def callback(p):
+    eventbus.emit(AppEvents.AI_DOWNLOAD_PROGRESS, {"progress": p})
 
 
 class GraXpert:
@@ -674,8 +677,20 @@ class GraXpert:
             else:
                 eventbus.emit(AppEvents.AI_DOWNLOAD_BEGIN)
 
-                def callback(p):
-                    eventbus.emit(AppEvents.AI_DOWNLOAD_PROGRESS, {"progress": p})
+                download_version(bge_ai_models_dir, bge_bucket_name, self.prefs.bge_ai_version, progress=callback)
+                eventbus.emit(AppEvents.AI_DOWNLOAD_END)
+        return True
+        
+    def validate_bge_ai_installation(self):
+        if self.prefs.bge_ai_version is None or self.prefs.bge_ai_version == "None":
+            messagebox.showerror("Error", _("No Background Extraction AI-Model selected. Please select one from the Advanced panel on the right."))
+            return False
+
+        if not validate_local_version(bge_ai_models_dir, self.prefs.bge_ai_version):
+            if not messagebox.askyesno(_("Install AI-Model?"), _("Selected Background Extraction AI-Model is not installed. Should I download it now?")):
+                return False
+            else:
+                eventbus.emit(AppEvents.AI_DOWNLOAD_BEGIN)
 
                 download_version(bge_ai_models_dir, bge_bucket_name, self.prefs.bge_ai_version, progress=callback)
                 eventbus.emit(AppEvents.AI_DOWNLOAD_END)
@@ -695,9 +710,6 @@ class GraXpert:
                 else:
                     eventbus.emit(AppEvents.AI_DOWNLOAD_BEGIN)
 
-                    def callback(p):
-                        eventbus.emit(AppEvents.AI_DOWNLOAD_PROGRESS, {"progress": p})
-
                     download_version(deconvolution_object_ai_models_dir, deconvolution_object_bucket_name, self.prefs.deconvolution_object_ai_version, progress=callback)
                     eventbus.emit(AppEvents.AI_DOWNLOAD_END)
             return True
@@ -712,9 +724,6 @@ class GraXpert:
                 else:
                     eventbus.emit(AppEvents.AI_DOWNLOAD_BEGIN)
 
-                    def callback(p):
-                        eventbus.emit(AppEvents.AI_DOWNLOAD_PROGRESS, {"progress": p})
-
                     download_version(deconvolution_stars_ai_models_dir, deconvolution_stars_bucket_name, self.prefs.deconvolution_stars_ai_version, progress=callback)
                     eventbus.emit(AppEvents.AI_DOWNLOAD_END)
             return True
@@ -730,9 +739,6 @@ class GraXpert:
             else:
                 eventbus.emit(AppEvents.AI_DOWNLOAD_BEGIN)
 
-                def callback(p):
-                    eventbus.emit(AppEvents.AI_DOWNLOAD_PROGRESS, {"progress": p})
-
                 download_version(denoise_ai_models_dir, denoise_bucket_name, self.prefs.denoise_ai_version, progress=callback)
                 eventbus.emit(AppEvents.AI_DOWNLOAD_END)
         return True

{graxpert-3.2.0a0.dev8 → graxpert-3.2.0a2}/graxpert/cmdline_tools.py

@@ -49,7 +49,9 @@ class CmdlineToolBase:
     def get_save_path(self):
         if self.args.output is not None:
             base_path = os.path.dirname(self.args.filename)
-            output_file_name = self.args.output + self.get_output_file_ending()
+            output_file_name = self.args.output
+            if not os.path.splitext(output_file_name)[1]: # if output file already has an extension, just use that
+                output_file_name += self.get_output_file_ending()
             return os.path.join(base_path, output_file_name)
         else:
             return os.path.splitext(self.args.filename)[0] + "_GraXpert" + self.get_output_file_ending()
@@ -59,7 +61,7 @@ class BGECmdlineTool(CmdlineToolBase):
     def __init__(self, args):
         super().__init__(args)
 
-    def execute(self):
+    def execute(self, json_prefs: dict = {}):
         astro_Image = AstroImage(do_update_display=False)
         astro_Image.set_from_file(self.args.filename, None, None)
 
@@ -71,43 +73,30 @@ class BGECmdlineTool(CmdlineToolBase):
 
         downscale_factor = 1
 
-        if self.args.preferences_file is not None:
-            preferences = Prefs()
-            preferences.interpol_type_option = "AI"
-            try:
-                preferences_file = os.path.abspath(self.args.preferences_file)
-                if os.path.isfile(preferences_file):
-                    with open(preferences_file, "r") as f:
-                        json_prefs = json.load(f)
-                        if "background_points" in json_prefs:
-                            preferences.background_points = json_prefs["background_points"]
-                        if "RBF_kernel" in json_prefs:
-                            preferences.RBF_kernel = json_prefs["RBF_kernel"]
-                        if "interpol_type_option" in json_prefs:
-                            preferences.interpol_type_option = json_prefs["interpol_type_option"]
-                        if "smoothing_option" in json_prefs:
-                            preferences.smoothing_option = json_prefs["smoothing_option"]
-                        if "sample_size" in json_prefs:
-                            preferences.sample_size = json_prefs["sample_size"]
-                        if "spline_order" in json_prefs:
-                            preferences.spline_order = json_prefs["spline_order"]
-                        if "corr_type" in json_prefs:
-                            preferences.corr_type = json_prefs["corr_type"]
-                        if "ai_version" in json_prefs:
-                            preferences.ai_version = json_prefs["ai_version"]
-                        if "ai_gpu_acceleration" in json_prefs:
-                            preferences.ai_gpu_acceleration = json_prefs["ai_gpu_acceleration"]
-
-                        if preferences.interpol_type_option == "Kriging" or preferences.interpol_type_option == "RBF":
-                            downscale_factor = 4
-
-            except Exception as e:
-                logging.exception(e)
-                logging.shutdown()
-                sys.exit(1)
-        else:
-            preferences = Prefs()
-            preferences.interpol_type_option = "AI"
+        preferences = Prefs()
+        preferences.interpol_type_option = "AI"
+
+        if "background_points" in json_prefs:
+            preferences.background_points = json_prefs["background_points"]
+        if "RBF_kernel" in json_prefs:
+            preferences.RBF_kernel = json_prefs["RBF_kernel"]
+        if "interpol_type_option" in json_prefs:
+            preferences.interpol_type_option = json_prefs["interpol_type_option"]
+        if "smoothing_option" in json_prefs:
+            preferences.smoothing_option = json_prefs["smoothing_option"]
+        if "sample_size" in json_prefs:
+            preferences.sample_size = json_prefs["sample_size"]
+        if "spline_order" in json_prefs:
+            preferences.spline_order = json_prefs["spline_order"]
+        if "corr_type" in json_prefs:
+            preferences.corr_type = json_prefs["corr_type"]
+        if "ai_version" in json_prefs:
+            preferences.bge_ai_version = json_prefs["ai_version"]
+        if "ai_gpu_acceleration" in json_prefs:
+            preferences.ai_gpu_acceleration = json_prefs["ai_gpu_acceleration"]
+
+        if preferences.interpol_type_option == "Kriging" or preferences.interpol_type_option == "RBF":
+            downscale_factor = 4
 
         if self.args.smoothing is not None:
             preferences.smoothing_option = self.args.smoothing
@@ -220,7 +209,7 @@ class DenoiseCmdlineTool(CmdlineToolBase):
         super().__init__(args)
         self.args = args
 
-    def execute(self):
+    def execute(self, json_prefs: dict = {}):
         astro_Image = AstroImage(do_update_display=False)
         astro_Image.set_from_file(self.args.filename, None, None)
 
@@ -228,28 +217,16 @@ class DenoiseCmdlineTool(CmdlineToolBase):
 
         processed_Astro_Image.fits_header = astro_Image.fits_header
 
-        if self.args.preferences_file is not None:
-            preferences = Prefs()
-            try:
-                preferences_file = os.path.abspath(self.args.preferences_file)
-                if os.path.isfile(preferences_file):
-                    with open(preferences_file, "r") as f:
-                        json_prefs = json.load(f)
-                        if "ai_version" in json_prefs:
-                            preferences.ai_version = json_prefs["ai_version"]
-                        if "denoise_strength" in json_prefs:
-                            preferences.denoise_strength = json_prefs["denoise_strength"]
-                        if "ai_batch_size" in json_prefs:
-                            preferences.ai_batch_size = json_prefs["ai_batch_size"]
-                        if "ai_gpu_acceleration" in json_prefs:
-                            preferences.ai_gpu_acceleration = json_prefs["ai_gpu_acceleration"]
+        preferences = Prefs()
 
-            except Exception as e:
-                logging.exception(e)
-                logging.shutdown()
-                sys.exit(1)
-        else:
-            preferences = Prefs()
+        if "ai_version" in json_prefs:
+            preferences.ai_version = json_prefs["ai_version"]
+        if "denoise_strength" in json_prefs:
+            preferences.denoise_strength = json_prefs["denoise_strength"]
+        if "ai_batch_size" in json_prefs:
+            preferences.ai_batch_size = json_prefs["ai_batch_size"]
+        if "ai_gpu_acceleration" in json_prefs:
+            preferences.ai_gpu_acceleration = json_prefs["ai_gpu_acceleration"]
 
         if self.args.denoise_strength is not None:
             preferences.denoise_strength = self.args.denoise_strength
@@ -320,7 +297,7 @@ class DeconvObjCmdlineTool(CmdlineToolBase):
         super().__init__(args)
         self.args = args
 
-    def execute(self):
+    def execute(self, json_prefs: dict = {}):
         astro_Image = AstroImage(do_update_display=False)
         astro_Image.set_from_file(self.args.filename, None, None)
 
@@ -328,30 +305,18 @@ class DeconvObjCmdlineTool(CmdlineToolBase):
 
         processed_Astro_Image.fits_header = astro_Image.fits_header
 
-        if self.args.preferences_file is not None:
-            preferences = Prefs()
-            try:
-                preferences_file = os.path.abspath(self.args.preferences_file)
-                if os.path.isfile(preferences_file):
-                    with open(preferences_file, "r") as f:
-                        json_prefs = json.load(f)
-                        if "ai_version" in json_prefs:
-                            preferences.ai_version = json_prefs["ai_version"]
-                        if "deconvolution_strength" in json_prefs:
-                            preferences.deconvolution_strength = json_prefs["deconvolution_strength"]
-                        if "deconvolution_psfsize" in json_prefs:
-                            preferences.deconvolution_psfsize = json_prefs["deconvolution_psfsize"]
-                        if "ai_batch_size" in json_prefs:
-                            preferences.ai_batch_size = json_prefs["ai_batch_size"]
-                        if "ai_gpu_acceleration" in json_prefs:
-                            preferences.ai_gpu_acceleration = json_prefs["ai_gpu_acceleration"]
+        preferences = Prefs()
 
-            except Exception as e:
-                logging.exception(e)
-                logging.shutdown()
-                sys.exit(1)
-        else:
-            preferences = Prefs()
+        if "ai_version" in json_prefs:
+            preferences.ai_version = json_prefs["ai_version"]
+        if "deconvolution_strength" in json_prefs:
+            preferences.deconvolution_strength = json_prefs["deconvolution_strength"]
+        if "deconvolution_psfsize" in json_prefs:
+            preferences.deconvolution_psfsize = json_prefs["deconvolution_psfsize"]
+        if "ai_batch_size" in json_prefs:
+            preferences.ai_batch_size = json_prefs["ai_batch_size"]
+        if "ai_gpu_acceleration" in json_prefs:
+            preferences.ai_gpu_acceleration = json_prefs["ai_gpu_acceleration"]
 
         if self.args.deconvolution_strength is not None:
             preferences.deconvolution_strength = self.args.deconvolution_strength
@@ -436,7 +401,7 @@ class DeconvStellarCmdlineTool(CmdlineToolBase):
         super().__init__(args)
         self.args = args
 
-    def execute(self):
+    def execute(self, json_prefs: dict = {}):
         astro_Image = AstroImage(do_update_display=False)
         astro_Image.set_from_file(self.args.filename, None, None)
 
@@ -444,30 +409,18 @@ class DeconvStellarCmdlineTool(CmdlineToolBase):
 
         processed_Astro_Image.fits_header = astro_Image.fits_header
 
-        if self.args.preferences_file is not None:
-            preferences = Prefs()
-            try:
-                preferences_file = os.path.abspath(self.args.preferences_file)
-                if os.path.isfile(preferences_file):
-                    with open(preferences_file, "r") as f:
-                        json_prefs = json.load(f)
-                        if "ai_version" in json_prefs:
-                            preferences.ai_version = json_prefs["ai_version"]
-                        if "deconvolution_strength" in json_prefs:
-                            preferences.deconvolution_strength = json_prefs["deconvolution_strength"]
-                        if "deconvolution_psfsize" in json_prefs:
-                            preferences.deconvolution_psfsize = json_prefs["deconvolution_psfsize"]
-                        if "ai_batch_size" in json_prefs:
-                            preferences.ai_batch_size = json_prefs["ai_batch_size"]
-                        if "ai_gpu_acceleration" in json_prefs:
-                            preferences.ai_gpu_acceleration = json_prefs["ai_gpu_acceleration"]
-
-            except Exception as e:
-                logging.exception(e)
-                logging.shutdown()
-                sys.exit(1)
-        else:
-            preferences = Prefs()
+        preferences = Prefs()
+
+        if "ai_version" in json_prefs:
+            preferences.ai_version = json_prefs["ai_version"]
+        if "deconvolution_strength" in json_prefs:
+            preferences.deconvolution_strength = json_prefs["deconvolution_strength"]
+        if "deconvolution_psfsize" in json_prefs:
+            preferences.deconvolution_psfsize = json_prefs["deconvolution_psfsize"]
+        if "ai_batch_size" in json_prefs:
+            preferences.ai_batch_size = json_prefs["ai_batch_size"]
+        if "ai_gpu_acceleration" in json_prefs:
+            preferences.ai_gpu_acceleration = json_prefs["ai_gpu_acceleration"]
 
         if self.args.deconvolution_strength is not None:
             preferences.deconvolution_strength = self.args.deconvolution_strength

{graxpert-3.2.0a0.dev8 → graxpert-3.2.0a2}/graxpert/main.py

@@ -1,3 +1,4 @@
+import json
 import os
 import platform
 import sys
@@ -17,20 +18,21 @@ import types
 
 from packaging import version
 
-# Must be before all other graxpert imports
-try:
-    # A load-time check for key external package dependencies. Crash and warn user.
-    import tkinter
-except ImportError:
-    # If it fails, print a helpful message and exit.
-    print("ERROR: The required 'tkinter' GUI library is not installed.", file=sys.stderr)
-    print("\nPlease install it using your system's package manager.", file=sys.stderr)
-    print("  For Debian/Ubuntu: sudo apt-get install python3-tk", file=sys.stderr)
-    print("  For Fedora:        sudo dnf install python3-tkinter", file=sys.stderr)
-    print("  For Arch Linux:    sudo pacman -S tk", file=sys.stderr)
-    print("  For OS-X:          brew install python-tk", file=sys.stderr)
-    print("  For Windows:       It should be included with your Python installation by default.", file=sys.stderr)
-    sys.exit(1) # Exit with error
+def check_tk():
+    # Must be before all other graxpert imports
+    try:
+        # A load-time check for key external package dependencies. Crash and warn user.
+        import tkinter
+    except ImportError:
+        # If it fails, print a helpful message and exit.
+        print("ERROR: The required 'tkinter' GUI library is not installed.", file=sys.stderr)
+        print("\nPlease install it using your system's package manager.", file=sys.stderr)
+        print("  For Debian/Ubuntu: sudo apt-get install python3-tk", file=sys.stderr)
+        print("  For Fedora:        sudo dnf install python3-tkinter", file=sys.stderr)
+        print("  For Arch Linux:    sudo pacman -S tk", file=sys.stderr)
+        print("  For OS-X:          brew install python-tk", file=sys.stderr)
+        print("  For Windows:       It should be included with your Python installation by default.", file=sys.stderr)
+        sys.exit(1) # Exit with error
 
 
 from graxpert.ai_model_handling import bge_ai_models_dir, denoise_ai_models_dir, deconvolution_object_ai_models_dir, deconvolution_stars_ai_models_dir, list_local_versions, list_remote_versions
@@ -101,6 +103,8 @@ def version_type(ai_models_dir, bucket_name, arg_value, pat=re.compile(r"^\d+\.\
 
 
 def ui_main(open_with_file=None):
+    check_tk() # Must be before importing tkinter
+
     import logging
     import tkinter as tk
     from concurrent.futures import ProcessPoolExecutor
@@ -194,7 +198,9 @@ def ui_main(open_with_file=None):
     app = ApplicationFrame(root)
     app.grid(column=0, row=0, sticky=tk.NSEW)
     root.update()
-    check_for_new_version()
+    # Turn off new version check because we will be switching to pypi based version checking
+    # (much faster - no 2 second pause on startup)
+    # check_for_new_version()
 
     if open_with_file and len(open_with_file) > 0:
         eventbus.emit(AppEvents.LOAD_IMAGE_REQUEST, {"filename": open_with_file})
@@ -204,7 +210,12 @@ def ui_main(open_with_file=None):
     root.mainloop()
 
 
-def parse_args():
+def parse_args(argv):
+    """Parse command line arguments.
+
+    Args:
+        argv: list of arguments to parse. If None, uses sys.argv[1:]
+    """
     available_bge_versions = collect_available_versions(bge_ai_models_dir, bge_bucket_name)
     available_denoise_versions = collect_available_versions(denoise_ai_models_dir, denoise_bucket_name)
     available_deconv_obj_versions = collect_available_versions(deconvolution_object_ai_models_dir, deconvolution_object_bucket_name)
@@ -362,81 +373,125 @@ def parse_args():
         help='Number of image tiles which Graxpert will denoise in parallel. Be careful: increasing this value might result in out-of-memory errors. Valid Range: 1..32, default: "4"',
     )
 
-    if "-h" in sys.argv or "--help" in sys.argv:
-        if "background-extraction" in sys.argv:
+    if "-h" in argv or "--help" in argv:
+        if "background-extraction" in argv:
             bge_parser.print_help()
-        elif "denoising" in sys.argv:
+        elif "denoising" in argv:
             denoise_parser.print_help()
-        elif "deconv-obj" in sys.argv:
+        elif "deconv-obj" in argv:
             deconv_obj_parser.print_help()
-        elif "deconv-stellar" in sys.argv:
+        elif "deconv-stellar" in argv:
             deconv_stellar_parser.print_help()
         else:
             parser.print_help()
         sys.exit(0)
 
-    args, extras = parser.parse_known_args()
+    args, extras = parser.parse_known_args(argv)
 
     if args.command == "background-extraction":
-        args = bge_parser.parse_args()
+        args = bge_parser.parse_args(argv)
     elif args.command == "deconv-obj":
-        args = deconv_obj_parser.parse_args()
+        args = deconv_obj_parser.parse_args(argv)
     elif args.command == "deconv-stellar":
-        args = deconv_stellar_parser.parse_args()
+        args = deconv_stellar_parser.parse_args(argv)
     elif args.command == "denoising":
-        args = denoise_parser.parse_args()
+        args = denoise_parser.parse_args(argv)
 
     return args
 
-def main():
-    """Note: this is entered directly via the entry_point definition in setup.py or called from below"""
 
-    multiprocessing.freeze_support()
-    faulthandler.enable(sys.__stderr__)
+def main_impl(args, json_prefs: dict = {}):
+    """Shared main implementation for both commandline and API usage.
 
-    try:
-        # listing available versions might be slow, so only do it if we have command line args
-        if len(sys.argv) > 1:
-            args = parse_args()
-        else:
-            # Dummy noarg defs
-            args = types.SimpleNamespace(command=None, filename=None)
+    Args:
+        args: parsed arguments namespace.
+        json_prefs: dictionary of preferences (following the documented JSON format), or None if not provided.
+    """
 
-        # Note: we wait to setup logging until after parsing args, so that --help response doesn't get log framing
-        configure_logging()
+    try:
+        # Centralize our preference file loading here, though API users will probably just pass in a dict
+        if args.preferences_file:
+            preferences_file = os.path.abspath(args.preferences_file)
+            if os.path.isfile(preferences_file):
+                with open(preferences_file, "r") as f:
+                    json_prefs = json.load(f)
 
         if args.command == "background-extraction":
             from graxpert.cmdline_tools import BGECmdlineTool
 
             logging.info(f"Starting GraXpert CLI, Background-Extraction, version: {graxpert_version} release: {graxpert_release}")
             clt = BGECmdlineTool(args)
-            clt.execute()
+            clt.execute(json_prefs)
         elif args.command == "denoising":
             from graxpert.cmdline_tools import DenoiseCmdlineTool
 
             logging.info(f"Starting GraXpert CLI, Denoising, version: {graxpert_version} release: {graxpert_release}")
             clt = DenoiseCmdlineTool(args)
-            clt.execute()
+            clt.execute(json_prefs)
         elif args.command == "deconv-obj":
             from graxpert.cmdline_tools import DeconvObjCmdlineTool
 
             logging.info(f"Starting GraXpert CLI, Deconvolution Obj, version: {graxpert_version} release: {graxpert_release}")
             clt = DeconvObjCmdlineTool(args)
-            clt.execute()
+            clt.execute(json_prefs)
         elif args.command == "deconv-stellar":
             from graxpert.cmdline_tools import DeconvStellarCmdlineTool
 
             logging.info(f"Starting GraXpert CLI, Deconvolution Stellar, version: {graxpert_version} release: {graxpert_release}")
             clt = DeconvStellarCmdlineTool(args)
-            clt.execute()
+            clt.execute(json_prefs)
         else:
             logging.info(f"Starting GraXpert UI, version: {graxpert_version} release: {graxpert_release}")
             ui_main(args.filename)
     finally:
         temp_cleanup()
-        logging.shutdown()        
 
 
+def api_run(argv, json_prefs: dict = {}):
+    """Allows running GraXpert programmatically via an API call, passing commandline args as a list of strings
+
+    Args:
+        argv: list of arguments to parse.
+        json_prefs: dictionary of preferences (following the documented JSON format), or None if not provided.
+    """
+
+    # listing available versions might be slow, so only do it if we have command line args
+    if len(argv) > 0:
+        args = parse_args(argv)
+    else:
+        # Dummy noarg defs
+        args = types.SimpleNamespace(command=None, filename=None, preferences_file=None)
+
+    main_impl(args, json_prefs)
+
+def main():
+    """Note: this is entered directly via the entry_point definition in setup.py or called from below
+
+    Args:
+        argv: Optional list of arguments to parse. If None, uses sys.argv[1:]
+    """
+
+    multiprocessing.freeze_support()
+    faulthandler.enable(sys.stderr)
+    try:
+        # listing available versions might be slow, so only do it if we have command line args
+        if len(sys.argv) > 1:
+            args = parse_args(sys.argv[1:])
+        else:
+            # Dummy noarg defs
+            args = types.SimpleNamespace(command=None, filename=None, preferences_file=None)
+
+        # Note: we wait to setup logging until after parsing args, so that --help response doesn't get log framing
+        configure_logging()
+
+        main_impl(args)
+
+        logging.shutdown()
+    except Exception as e:
+        logging.exception(e)
+        logging.shutdown()
+        sys.exit(1)
+
 if __name__ == "__main__":
     main()
 

graxpert-3.2.0a2/graxpert/progress.py

@@ -0,0 +1,51 @@
+from queue import Empty, Queue
+from threading import Thread
+
+class DynamicProgressThread(Thread):
+    def __init__(self, interval=1, total=100, callback=None):
+        Thread.__init__(self)
+        self.daemon = True
+        self.interval = interval
+        self.callback = callback
+        self.total = total
+        self.current_progress = 0
+        self.update_queue = Queue()
+        self.start()
+
+    def run(self):
+        while True:
+            try:
+                # display every interval secs
+                task = self.update_queue.get(timeout=self.interval)
+            except Empty:
+                continue
+
+            current_progress, total = task
+            self.update_queue.task_done()
+            if current_progress == total:
+                # once we have done uploading everything return
+                self.done_progress()
+                return
+
+    # minio needs this method
+    def set_meta(self, total_length, object_name=None):
+        self.total = total_length
+
+    def update(self, size):
+        if not isinstance(size, int):
+            raise ValueError(f"{type(size)} type can not be displayed. Please change it to Int.")
+
+        self.current_progress += size
+        self.update_queue.put((self.current_progress, self.total))
+
+        if self.callback is not None:
+            self.callback(self.progress())
+
+    def done_progress(self):
+        self.total = 0
+        self.current_progress = 0
+
+    def progress(self):
+        if self.total == 0:
+            return 0
+        return float(self.current_progress) / float(self.total)

{graxpert-3.2.0a0.dev8 → graxpert-3.2.0a2}/graxpert/ui/loadingframe.py

@@ -1,8 +1,6 @@
 import logging
 import tkinter as tk
 from os import path
-from queue import Empty, Queue
-from threading import Thread
 
 from customtkinter import CTkButton, CTkFont, CTkFrame, CTkImage, CTkLabel, CTkProgressBar, DoubleVar, StringVar, ThemeManager
 
@@ -91,52 +89,3 @@ class DynamicProgressFrame(CTkFrame):
         logging.info("Progress: {}%".format(int(self.variable.get() * 100)))
         self.pb.update()
 
-
-class DynamicProgressThread(Thread):
-    def __init__(self, interval=1, total=100, callback=None):
-        Thread.__init__(self)
-        self.daemon = True
-        self.interval = interval
-        self.callback = callback
-        self.total = total
-        self.current_progress = 0
-        self.update_queue = Queue()
-        self.start()
-
-    def run(self):
-        while True:
-            try:
-                # display every interval secs
-                task = self.update_queue.get(timeout=self.interval)
-            except Empty:
-                continue
-
-            current_progress, total = task
-            self.update_queue.task_done()
-            if current_progress == total:
-                # once we have done uploading everything return
-                self.done_progress()
-                return
-
-    # minio needs this method
-    def set_meta(self, total_length, object_name=None):
-        self.total = total_length
-
-    def update(self, size):
-        if not isinstance(size, int):
-            raise ValueError(f"{type(size)} type can not be displayed. Please change it to Int.")
-
-        self.current_progress += size
-        self.update_queue.put((self.current_progress, self.total))
-
-        if self.callback is not None:
-            self.callback(self.progress())
-
-    def done_progress(self):
-        self.total = 0
-        self.current_progress = 0
-
-    def progress(self):
-        if self.total == 0:
-            return 0
-        return float(self.current_progress) / float(self.total)

graxpert-3.2.0a2/graxpert/version.py

@@ -0,0 +1,2 @@
+release = "fix gui launch"
+version = "3.2.0a2"

graxpert-3.2.0a2/graxpert/version.py.bak

@@ -0,0 +1,2 @@
+release = "fix gui launch"
+version = "SNAPSHOT"

{graxpert-3.2.0a0.dev8 → graxpert-3.2.0a2}/graxpert.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graxpert
-Version: 3.2.0a0.dev8
+Version: 3.2.0a2
 Summary: GraXpert is an astronomical image processing program for extracting and removing gradients in the background of your astrophotos
 Home-page: https://graxpert.com
 Author: GraXpert Development Team

{graxpert-3.2.0a0.dev8 → graxpert-3.2.0a2}/graxpert.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ graxpert/main.py
 graxpert/mp_logging.py
 graxpert/parallel_processing.py
 graxpert/preferences.py
+graxpert/progress.py
 graxpert/radialbasisinterpolation.py
 graxpert/resource_utils.py
 graxpert/s3_secrets.py

graxpert-3.2.0a0.dev8/graxpert/ui/__init__.py

@@ -1 +0,0 @@
-

graxpert-3.2.0a0.dev8/graxpert/version.py

@@ -1,2 +0,0 @@
-release = "update changelist notes"
-version = "3.2.0.a0.dev8"

graxpert-3.2.0a0.dev8/graxpert/version.py.bak

@@ -1,2 +0,0 @@
-release = "update changelist notes"
-version = "SNAPSHOT"