graxpert 3.2.0a0.dev7__tar.gz → 3.2.0a1__tar.gz

{graxpert-3.2.0a0.dev7 → graxpert-3.2.0a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graxpert
-Version: 3.2.0a0.dev7
+Version: 3.2.0a1
 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
@@ -15,6 +15,7 @@ Classifier: Topic :: Scientific/Engineering :: Image Processing
 Classifier: Topic :: Multimedia :: Graphics :: Editors
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: MacOS
 Classifier: Operating System :: POSIX :: Linux
@@ -28,17 +29,17 @@ Description-Content-Type: text/markdown
 Requires-Dist: ml-dtypes>=0.5.3
 Requires-Dist: pillow>=11.3.0
 Requires-Dist: appdirs
-Requires-Dist: astropy>=6.1.7
+Requires-Dist: astropy>=6.0.1
 Requires-Dist: astropy-iers-data>=0.2025.9.1.0.42.11
 Requires-Dist: customtkinter>=5.2.2
 Requires-Dist: imageio>=2.37.0
 Requires-Dist: minio>=7.2.16
-Requires-Dist: numpy==2.2.6
+Requires-Dist: numpy<=2.2.6,>=2.0.2
 Requires-Dist: opencv-python-headless==4.11.0.86
 Requires-Dist: PyKrige>=1.7.2
 Requires-Dist: requests>=2.32.5
-Requires-Dist: scikit-image>=0.25.2
-Requires-Dist: scipy>=1.15.3
+Requires-Dist: scikit-image>=0.24.0
+Requires-Dist: scipy>=1.13.1
 Requires-Dist: xisf>=0.9.5
 Provides-Extra: cuda
 Requires-Dist: onnxruntime-gpu[cuda,cudnn]==1.22.0; extra == "cuda"

graxpert-3.2.0a1/graxpert/__init__.py

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

{graxpert-3.2.0a0.dev7 → graxpert-3.2.0a1}/graxpert/ai_model_handling.py

@@ -4,6 +4,7 @@ import sys
 import re
 import shutil
 import zipfile
+from multiprocessing import Process, Queue
 
 from appdirs import user_data_dir
 from minio import Minio
@@ -214,6 +215,33 @@ def get_execution_providers_ordered(gpu_acceleration=True):
         "{}".format(e))
         sys.exit(1)
 
+
+def run_in_process(fn: callable):
+    """Run a function in a separate process and return the result or raise an exception."""
+
+    q = Queue()
+
+    # Create a closure to call fn and put the result in the queue    
+    def wrapped():
+        try:
+            r = fn()
+        except Exception as e:
+            r = e # return the exception to the main process
+        q.put(r)
+
+    p = Process(target=wrapped, name="ai-worker")
+    p.start()
+    p.join()
+
+    if p.exitcode != 0:
+        raise RuntimeError(f"worker process crashed with exit code {p.exitcode}.")
+
+    result = q.get()
+    if isinstance(result, Exception):
+        raise result
+    return result
+
+
 # Provides a mutable session context that can swap out different sessions if needed
 class SessionContext:
     model_name: str
@@ -232,13 +260,24 @@ class SessionContext:
         logging.info(f"Used inference providers for {model_name}: {self.session.get_providers()}")
 
 
+    def __run_low(self, model_args: dict, gpu_acceleration: bool = True) -> any:
+        """Run the ONNX model using the specified execution provider."""
+
+        # if we are using a GPU the ONNX runtimes might crash due to native bugs (ROCm)
+        # so run in a separate process just in case
+        fn = lambda: self.session.run(None, model_args)
+        if gpu_acceleration:
+            return run_in_process(fn)
+        else:
+            return fn()
+
     def run(self, model_args: dict) -> any:
         """Run the ONNX model using the specified execution provider."""
 
         providers = self.session.get_providers()
         gpu_acceleration = len(providers) > 1 or providers[0] != "CPUExecutionProvider"
         try:
-            result = self.session.run(None, model_args)
+            result = self.__run_low(model_args, gpu_acceleration)
         except Exception as e:
             if not gpu_acceleration:
                 raise  # Rethrow, the failure occurred with the regular CPU model also - show error dialog
@@ -246,7 +285,7 @@ class SessionContext:
             logging.warning(f"Error running model, falling back to CPU only: {e}")
             import onnxruntime as ort
             self.session = ort.InferenceSession(self.model_name, providers=get_execution_providers_ordered(False))
-            result = self.session.run(None, model_args)
+            result = self.__run_low(model_args, False)
 
         # all graxpert results are in the first array index
         return result[0]

{graxpert-3.2.0a0.dev7 → graxpert-3.2.0a1}/graxpert/application/app.py

@@ -32,6 +32,10 @@ from graxpert.stretch import StretchParameters, stretch_all
 from graxpert.ui.loadingframe import DynamicProgressThread
 
 
+def callback(p):
+    eventbus.emit(AppEvents.AI_DOWNLOAD_PROGRESS, {"progress": p})
+
+
 class GraXpert:
 
     def __init__(self):
@@ -674,8 +678,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 +711,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 +725,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 +740,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.dev7 → graxpert-3.2.0a1}/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.dev7 → graxpert-3.2.0a1}/graxpert/main.py

@@ -1,3 +1,4 @@
+import json
 import os
 import platform
 import sys
@@ -194,7 +195,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 +207,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 +370,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)
+
+    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) > 0:
+            args = parse_args(sys.argv[1:])
+        else:
+            # Dummy noarg defs
+            args = types.SimpleNamespace(command=None, filename=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.0a1/graxpert/version.py

@@ -0,0 +1,2 @@
+release = "fix smoothing typo"
+version = "3.2.0a1"

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

@@ -0,0 +1,2 @@
+release = "fix smoothing typo"
+version = "SNAPSHOT"

{graxpert-3.2.0a0.dev7 → graxpert-3.2.0a1}/graxpert.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graxpert
-Version: 3.2.0a0.dev7
+Version: 3.2.0a1
 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
@@ -15,6 +15,7 @@ Classifier: Topic :: Scientific/Engineering :: Image Processing
 Classifier: Topic :: Multimedia :: Graphics :: Editors
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: MacOS
 Classifier: Operating System :: POSIX :: Linux
@@ -28,17 +29,17 @@ Description-Content-Type: text/markdown
 Requires-Dist: ml-dtypes>=0.5.3
 Requires-Dist: pillow>=11.3.0
 Requires-Dist: appdirs
-Requires-Dist: astropy>=6.1.7
+Requires-Dist: astropy>=6.0.1
 Requires-Dist: astropy-iers-data>=0.2025.9.1.0.42.11
 Requires-Dist: customtkinter>=5.2.2
 Requires-Dist: imageio>=2.37.0
 Requires-Dist: minio>=7.2.16
-Requires-Dist: numpy==2.2.6
+Requires-Dist: numpy<=2.2.6,>=2.0.2
 Requires-Dist: opencv-python-headless==4.11.0.86
 Requires-Dist: PyKrige>=1.7.2
 Requires-Dist: requests>=2.32.5
-Requires-Dist: scikit-image>=0.25.2
-Requires-Dist: scipy>=1.15.3
+Requires-Dist: scikit-image>=0.24.0
+Requires-Dist: scipy>=1.13.1
 Requires-Dist: xisf>=0.9.5
 Provides-Extra: cuda
 Requires-Dist: onnxruntime-gpu[cuda,cudnn]==1.22.0; extra == "cuda"

{graxpert-3.2.0a0.dev7 → graxpert-3.2.0a1}/graxpert.egg-info/requires.txt

@@ -1,17 +1,17 @@
 ml-dtypes>=0.5.3
 pillow>=11.3.0
 appdirs
-astropy>=6.1.7
+astropy>=6.0.1
 astropy-iers-data>=0.2025.9.1.0.42.11
 customtkinter>=5.2.2
 imageio>=2.37.0
 minio>=7.2.16
-numpy==2.2.6
+numpy<=2.2.6,>=2.0.2
 opencv-python-headless==4.11.0.86
 PyKrige>=1.7.2
 requests>=2.32.5
-scikit-image>=0.25.2
-scipy>=1.15.3
+scikit-image>=0.24.0
+scipy>=1.13.1
 xisf>=0.9.5
 
 [cpuonly]

{graxpert-3.2.0a0.dev7 → graxpert-3.2.0a1}/pyproject.toml

@@ -11,9 +11,9 @@ archs = ["auto64"]
 requires = [
     "setuptools>=80.9.0",
     "wheel>=0.45.1",
-    "astropy>=7.1.0",
+    "astropy>=6.0.1",
     "cx_Freeze>=8.4.0",
     "imageio>=2.37.0",
-    "scikit-image>=0.25.2"
+    "scikit-image>=0.24.0"
 ]
 build-backend = "setuptools.build_meta"

{graxpert-3.2.0a0.dev7 → graxpert-3.2.0a1}/requirements.txt

@@ -1,15 +1,15 @@
 ml-dtypes>=0.5.3
 pillow>=11.3.0
 appdirs
-astropy>=6.1.7
+astropy>=6.0.1
 astropy-iers-data>=0.2025.9.1.0.42.11
 customtkinter>=5.2.2
 imageio>=2.37.0
 minio>=7.2.16
-numpy==2.2.6
+numpy>=2.0.2,<=2.2.6
 opencv-python-headless==4.11.0.86
 PyKrige>=1.7.2
 requests>=2.32.5
-scikit-image>=0.25.2
-scipy>=1.15.3
+scikit-image>=0.24.0
+scipy>=1.13.1
 xisf>=0.9.5

{graxpert-3.2.0a0.dev7 → graxpert-3.2.0a1}/setup.py

@@ -109,6 +109,7 @@ setup_options = {
         # Supported Python versions: List all versions you test against.
         "Programming Language :: Python :: 3.11",
         "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
 
         # Operating System: Specify which OSs are supported.
         "Operating System :: Microsoft :: Windows",
@@ -208,15 +209,17 @@ if cx_freeze_commands.intersection(sys.argv):
 
     # for exe builds we are careful to include the correct onnxruntime
     if sys.platform == "win32":
-        build_options["excludes"] += ["onnxruntime", "onnxruntime-rocm", "onnxruntime-gpu"]
-        # FIXME temporarily disable until we see if it is needed on windows
+        pass
+        # on windows we default to whatever onnx lib was installed at build time
+        # build_options["excludes"] += ["onnxruntime", "onnxruntime-rocm", "onnxruntime-gpu"]
         # build_options["includes"] += ["onnxruntime-directml"]
     else:
         build_options["excludes"] += ["onnxruntime-gpu", "onnxruntime-rocm", "onnxruntime-directml"]
         build_options["includes"] += ["onnxruntime"]
 
     # console allows passing in command line
-    base = "Win32GUI" if sys.platform == "win32" else "console"
+    base = "gui" if sys.platform == "win32" else "console"
+    # base = "console" # if debugging on windows (or trying to use the exe in a script, then this is probably better)
 
     executables = [cx_Freeze.Executable("./graxpert/main.py", base=base,
                                         icon="./img/Icon", # leave off extension so it will be autocorrected for any OS

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

@@ -1 +0,0 @@
-

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

@@ -1,2 +0,0 @@
-release = "the github CI DMG builds are not yet reliable, don't require them before pypi publish"
-version = "3.2.0.a0.dev7"

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

@@ -1,2 +0,0 @@
-release = "the github CI DMG builds are not yet reliable, don't require them before pypi publish"
-version = "SNAPSHOT"