PyThea 0.9.0__tar.gz → 0.10.0__tar.gz

{PyThea-0.9.0 → pythea-0.10.0}/CHANGELOG.md

@@ -1,3 +1,38 @@
+# v0.10.0 (17-April-2024)
+
+## Features
+ - Option added to choose the step for Running Difference or the background image for the Base Difference image processing.
+ - Fetures added in the app to plot limb or meridians from different observers and grid.
+ - Feture added in the app for manual change of the images colorbar limits.
+ - Feture added in the app to use median filter images processing.
+ - Tests added: A test to verify the existence of Pythea's database directory
+
+## Major Changes
+- Updates sunpy dependencies to sunpy 5.1.2
+
+## Minor Changes
+- Improvements on the pipeline of image download and processing in the app.
+- Improvements and simplifications on the figures production in the app.
+- Values of the colormap limits in the app are stored and are reused when changing the imager.
+
+## Bug Fixes
+- Fixes a bug with test_database_dir_exists.
+- Fixes a bug when corrupted fits files loaded and imager load skipped.
+- Fixes a bug with AIA visuallization from missing date_average.
+- Fixes a bug with supplementary imaging selection.
+
+# v0.9.1 (5-March-2024)
+
+## Features
+ - A utility added to load the json fitting files
+
+## Minor Changes
+- Simplifies the code structure for loading the fitting files in the app
+
+## Bug Fixes
+- Fixes a bug when passing no maps in maputils
+- Fixes a bug when corrupted fits files loaded and imager load skipped
+
 # v0.9.0 (8-Feb-2024)
 
 ## Features

{PyThea-0.9.0/PyThea.egg-info → pythea-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyThea
-Version: 0.9.0
+Version: 0.10.0
 Summary: PyThea: A software package to reconstruct the 3D structure of CMEs and shock waves
 Home-page: https://github.com/AthKouloumvakos/PyThea
 Author: Athanasios Kouloumvakos
@@ -27,8 +27,8 @@ Requires-Dist: aiapy
 Requires-Dist: astropy
 Requires-Dist: astroquery
 Requires-Dist: numexpr
-Requires-Dist: sunpy==4.1.0
-Requires-Dist: parfive==1.5.1
+Requires-Dist: sunpy==5.1.2
+Requires-Dist: parfive==2.1.0
 Requires-Dist: pooch
 Requires-Dist: matplotlib
 Requires-Dist: seaborn

{PyThea-0.9.0 → pythea-0.10.0}/PyThea/PyThea_app.py

@@ -18,6 +18,8 @@
 """
 
 
+from copy import copy
+
 import astropy.units as u
 import numpy as np
 import stqdm  # See also https://github.com/tqdm/tqdm
@@ -29,12 +31,12 @@ from PyThea.callbacks import load_or_delete_fittings
 from PyThea.config import (app_styles, config_sliders, selected_bodies,
                            selected_imagers)
 from PyThea.geometrical_models import ellipsoid, gcs, spheroid
-from PyThea.modules import (date_and_event_selection, final_parameters_gmodel,
+from PyThea.modules import (date_and_event_selection, figure_streamlit,
+                            final_parameters_gmodel,
                             fitting_and_slider_options_container,
-                            fitting_sliders, maps_clims)
-from PyThea.sunpy_dev.map.maputils import get_closest
-from PyThea.utils import (download_fits, make_figure, model_fittings,
-                          plot_bodies, plot_fitting_model,
+                            fitting_sliders)
+from PyThea.sunpy_dev.map.maputils import get_closest, maps_clims
+from PyThea.utils import (download_fits, model_fittings, plot_fitting_model,
                           single_imager_maps_process)
 from PyThea.version import version
 
@@ -185,24 +187,58 @@ def run():
         if 'imagers_list_' not in st.session_state:
             # imagers_list_ is used later when we download or filter the images
             st.session_state['imagers_list_'] = []
-        image_mode = procoption_container.selectbox('Map sequence processing',
+        image_mode = procoption_container.selectbox('Map Sequence Processing',
                                                     options=['Running Diff.', 'Base Diff.', 'Plain'], key='image_mode',
-                                                    on_change=delete_from_state, kwargs={'vars': ['map', 'imagers_list_']})
+                                                    on_change=delete_from_state,
+                                                    kwargs={'vars': ['map', 'imagers_list_', 'clim', 'clim_manual_low', 'clim_manual_high']})
+        if image_mode in ['Running Diff.', 'Base Diff.']:
+            diff_value = procoption_container.number_input('Select Step/Image for Running/Base Diff.', 1, 5, key='diff_value',
+                                                           on_change=delete_from_state,
+                                                           kwargs={'vars': ['map', 'imagers_list_', 'clim', 'clim_manual_low', 'clim_manual_high']})
+        else:
+            diff_value = None
+
+        procoption_container.number_input('Median Filter', 1, 6, 1, 1, key='images_median_filter')
 
     with st.sidebar.expander('Plot/View Options'):
         plotviewopt_container = st.container()
-        clip_model = plotviewopt_container.checkbox('Clip plot on image limits', value=True)
+        plotviewopt_container.checkbox('Clip plot on image limits', value=True, key='clip_model')
         plt_supp_imagers = plotviewopt_container.checkbox('Supplementary Imaging', value=False)
-        star_field = plotviewopt_container.checkbox('View Bodies or s/c')
-        if star_field:
-            bodies_list = plotviewopt_container.multiselect('Select Bodies', options=selected_bodies.bodies_dict.keys(),
-                                                            default=['Mercury', 'Venus', 'Jupiter'])
+        plotviewopt_container.checkbox('View Bodies or s/c', key='star_field')
+        if st.session_state.star_field:
+            plotviewopt_container.multiselect('Select Bodies', options=selected_bodies.bodies_dict.keys(),
+                                              default=['Mercury', 'Venus', 'Jupiter'],
+                                              key='bodies_list')
+        plotviewopt_container.checkbox('View Limb and Meridians', key='plot_solar_reference_lines_')
+        if st.session_state.plot_solar_reference_lines_:
+            markdown = '''
+                **Limb**: plots the solar limb as observed  # noqa
+                for the selected observers.  # noqa
+                **Central Meridian**: plots the central meridian  # noqa
+                observed for the selected observers.  # noqa
+                **CR Meridan+Equator**: plots the primary meridian  # noqa
+                and equator of Carrington coordinate system.  # noqa
+                '''.strip()
+            plotviewopt_container.selectbox('Select plot option',
+                                            options=['Limb from Obs.', 'Central Meridian from Obs.', 'Carr. Prime Meridian+Solar Equator',
+                                                     'Stonyhurst Grid', 'Carrington Grid'],
+                                            help=markdown,
+                                            key='plot_solar_reference_lines_mode')
+            disabled = False if st.session_state.plot_solar_reference_lines_mode in ['Limb from Obs.', 'Central Meridian from Obs.'] else True
+            plotviewopt_container.multiselect('Select Bodies',
+                                              label_visibility='collapsed',
+                                              options=selected_bodies.bodies_dict.keys(),
+                                              default=['Earth'], disabled=disabled,
+                                              key='plot_solar_reference_lines_bodies_list')
 
     #############################################################
     # Download and Process the Images
     # This part runs only if the map_ doesn't exits or the session_state.map_ does not contain all the imagers requested
     imager_added = list(set(imagers_list) - set(st.session_state['imagers_list_']))
     imager_removed = list(set(st.session_state['imagers_list_']) - set(imagers_list))
+    if 'map_colormap_limits' not in st.session_state:
+        st.session_state['map_colormap_limits'] = {}
+
     if 'map_' not in st.session_state or imager_added != []:
         st.session_state.map_ = {} if 'map_' not in st.session_state else st.session_state.map_
         st.session_state.map = {} if 'map' not in st.session_state else st.session_state.map
@@ -213,20 +249,25 @@ def run():
             if imager not in st.session_state.map_:
                 st.session_state.map_[imager] = download_fits(st.session_state.date_process,
                                                               imager, time_range=imaging_time_range)
+                st.session_state.map_[imager] = single_imager_maps_process(st.session_state.map_[imager],
+                                                                           **selected_imagers.imager_dict[imager][1],
+                                                                           skip='sequence_processing')
             processed_images = single_imager_maps_process(st.session_state.map_[imager],
+                                                          skip=['filter', 'prepare'],
                                                           image_mode=image_mode,
-                                                          **selected_imagers.imager_dict[imager][1])
+                                                          diff_num=diff_value)
             if processed_images != []:
                 st.session_state.map[imager] = processed_images
+                st.session_state.map_colormap_limits[imager] = maps_clims(st.session_state.map[imager])
             else:
                 st.session_state.imagers_list_.remove(imager)
+                st.session_state.map_colormap_limits.pop(imager, None)
+
     if imager_removed != []:
         st.session_state['imagers_list_'] = imagers_list
         for imager in imager_removed:
             st.session_state.map_.pop(imager, None)
 
-    maps_clims(st, st.session_state.imagers_list_)
-
     if not st.session_state.imagers_list_:
         st.error('No images have been downloaded or processed.')  # TODO: Explain better
         st.stop()
@@ -236,7 +277,8 @@ def run():
     st.markdown('### Multi-viewpoint imaging')
     col1, col2 = st.columns((1, 3))
     imager_select = col1.selectbox('Select an imager',
-                                   options=st.session_state.imagers_list_)
+                                   options=st.session_state.imagers_list_,
+                                   on_change=delete_from_state, kwargs={'vars': ['clim', 'clim_manual_low', 'clim_manual_high']})
 
     maps_date = [getattr(maps, 'date_average', None) or getattr(maps, 'date', None) for maps in st.session_state.map[imager_select]]
     if len(maps_date) > 1:
@@ -248,14 +290,26 @@ def run():
 
     running_map = st.session_state.map[imager_select][maps_date.index(running_map_date)]
 
-    qmin = st.session_state.map_clim[imager_select][0]  # np.nanquantile(running_map.data, 0.20)
-    qmax = st.session_state.map_clim[imager_select][1]  # np.nanquantile(running_map.data, 0.80)
-    col1, col2 = st.columns((1, 3))
-    cmmin, cpmax = config_sliders.slider_image_pmclims[image_mode]
-    clim = plotviewopt_container.slider('Images climits:',
-                                        min_value=float(cmmin), max_value=float(cpmax),
-                                        value=(float(qmin-10), float(qmax+10)),
-                                        key='clim')
+    manual_clim = plotviewopt_container.checkbox('Provide clims values', on_change=delete_from_state, kwargs={'vars': ['clim']})
+    if manual_clim:
+        col1, col2 = plotviewopt_container.columns(2)
+        if 'clim_manual_low' not in st.session_state:
+            st.session_state.clim_manual_low = st.session_state.map_colormap_limits[imager_select][0]
+        qmin = col1.number_input('Low clim value', label_visibility='collapsed', key='clim_manual_low')
+        if 'clim_manual_high' not in st.session_state:
+            st.session_state.clim_manual_high = st.session_state.map_colormap_limits[imager_select][1]
+        qmax = col2.number_input('High clim value', label_visibility='collapsed', key='clim_manual_high')
+        st.session_state.map_colormap_limits[imager_select] = [qmin, qmax]
+    else:
+        qmin = st.session_state.map_colormap_limits[imager_select][0]
+        qmax = st.session_state.map_colormap_limits[imager_select][1]
+        cmmin, cpmax = config_sliders.slider_image_pmclims[image_mode]
+        if 'clim' not in st.session_state:
+            st.session_state.clim = [float(qmin), float(qmax)]
+        st.session_state.map_colormap_limits[imager_select] = \
+            plotviewopt_container.slider('Images colorbar limits:',
+                                         min_value=float(cmmin), max_value=float(cpmax),
+                                         key='clim')
 
     #############################################################
     # Finalize the geometrical model
@@ -290,35 +344,28 @@ def run():
 
     #############################################################
     # Plot main and supplement figure images
-    fig, axis = make_figure(running_map, image_mode, clim=clim, clip_model=clip_model)
-    if st.session_state.plot_mesh_mode == 'Skeleton':
-        model.plot(axis, mode='Skeleton')
-    elif st.session_state.plot_mesh_mode == 'Full':
-        model.plot(axis, mode='Skeleton')
-        model.plot(axis, mode='Full')
-    elif st.session_state.plot_mesh_mode == 'Surface':
-        model.plot(axis, only_surface=True)
-
-    if star_field:
-        plot_bodies(axis, bodies_list, running_map)
-        axis.legend()
+    fig, axis = figure_streamlit(st, running_map, image_mode, imager_select, model)
     st.pyplot(fig)
 
-    if plt_supp_imagers and len(st.session_state.imagers_list_) > 2:
-        supl_imagers = st.select_slider('Select supplement imagers',
-                                        options=st.session_state.imagers_list_,
-                                        value=(st.session_state.imagers_list_[1],
-                                               st.session_state.imagers_list_[-1]),
-                                        key='supl_imagers')
-        col1, col2 = st.columns(2)
-        fig, axis = make_figure(get_closest(st.session_state.map[supl_imagers[0]],
-                                running_map_date), image_mode)
-        model.plot(axis, mode='Skeleton')
-        col1.pyplot(fig)
-        fig, axis = make_figure(get_closest(st.session_state.map[supl_imagers[1]],
-                                            running_map_date), image_mode)
-        model.plot(axis, mode='Skeleton')
-        col2.pyplot(fig)
+    if plt_supp_imagers:
+        if len(st.session_state.imagers_list_) < 3:
+            other_element = [element for element in st.session_state.imagers_list_ if element != imager_select][0]
+            fig, axis = figure_streamlit(st, get_closest(st.session_state.map[other_element], running_map_date), image_mode, other_element, model)
+            st.pyplot(fig)
+        else:
+            supl_imagers_list = copy(st.session_state.imagers_list_)
+            supl_imagers_list.remove(imager_select)
+            supl_imagers = st.select_slider('Select supplement imagers',
+                                            options=supl_imagers_list,
+                                            value=(supl_imagers_list[0],
+                                                   supl_imagers_list[-1]),
+                                            key='supl_imagers')
+            col1, col2 = st.columns(2)
+            fig, axis = figure_streamlit(st, get_closest(st.session_state.map[supl_imagers[0]], running_map_date), image_mode, supl_imagers[0], model)
+            col1.pyplot(fig)
+            fig, axis = figure_streamlit(st, get_closest(st.session_state.map[supl_imagers[1]], running_map_date), image_mode, supl_imagers[1], model)
+            model.plot(axis, mode='Skeleton')
+            col2.pyplot(fig)
 
     #############################################################
     # Store the fitting

{PyThea-0.9.0 → pythea-0.10.0}/PyThea/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.9.0'
-__version_tuple__ = version_tuple = (0, 9, 0)
+__version__ = version = '0.10.0'
+__version_tuple__ = version_tuple = (0, 10, 0)

{PyThea-0.9.0 → pythea-0.10.0}/PyThea/callbacks.py

@@ -39,7 +39,8 @@ def change_long_lat_sliders(st):
     if st.session_state.coord_system == 'HGS':
         center_ = st.session_state.center.transform_to(frames.HeliographicStonyhurst)
     elif st.session_state.coord_system == 'HGC':
-        center_ = st.session_state.center.transform_to(frames.HeliographicCarrington)
+        center_ = st.session_state.center.transform_to(frames.HeliographicCarrington(observer='Earth',
+                                                                                     obstime=st.session_state.center.obstime))
     st.session_state.longit = float(center_.lon.to_value(u.degree))
     st.session_state.latitu = float(center_.lat.to_value(u.degree))
 

{PyThea-0.9.0 → pythea-0.10.0}/PyThea/geometrical_models.py

@@ -283,7 +283,8 @@ class spheroid:
         """
         Returns the spheroid parameters as `~pandas.DataFrame`.
         """
-        center_ = self.center.transform_to(frames.HeliographicCarrington)
+        center_ = self.center.transform_to(frames.HeliographicCarrington(observer='Earth',
+                                                                         obstime=self.center.obstime))
         data_dict = {
             'hgln': self.center.lon.to_value(u.degree),
             'hglt': self.center.lat.to_value(u.degree),
@@ -303,7 +304,8 @@ class spheroid:
         '''
         Returns the Spheroid object and parameters in a printable sting array.
         '''
-        center_ = self.center.transform_to(frames.HeliographicCarrington)
+        center_ = self.center.transform_to(frames.HeliographicCarrington(observer='Earth',
+                                                                         obstime=self.center.obstime))
         output = '<Spheroid object \n'
         output += 'HGLN = %3.2f degrees \n'%self.center.lon.to_value(u.degree)
         output += 'HGLT = %3.2f degrees \n'%self.center.lat.to_value(u.degree)
@@ -402,7 +404,8 @@ class ellipsoid(spheroid):
         """
         Returns the ellipsoid parameters as `~pandas.DataFrame`.
         """
-        center_ = self.center.transform_to(frames.HeliographicCarrington)
+        center_ = self.center.transform_to(frames.HeliographicCarrington(observer='Earth',
+                                                                         obstime=self.center.obstime))
         data_dict = {
             'hgln': self.center.lon.to_value(u.degree),
             'hglt': self.center.lat.to_value(u.degree),
@@ -469,7 +472,8 @@ class ellipsoid(spheroid):
         '''
         Returns the Ellipsoid object and parameters in a printable sting array.
         '''
-        center_ = self.center.transform_to(frames.HeliographicCarrington)
+        center_ = self.center.transform_to(frames.HeliographicCarrington(observer='Earth',
+                                                                         obstime=self.center.obstime))
         output = '<Ellipsoid object \n'
         output += 'HGLN = %3.2f degrees \n'%self.center.lon.to_value(u.degree)
         output += 'HGLT = %3.2f degrees \n'%self.center.lat.to_value(u.degree)
@@ -669,7 +673,8 @@ class gcs():
         """
         Returns the GCS parameters as `~pandas.DataFrame`.
         """
-        center_ = self.center.transform_to(frames.HeliographicCarrington)
+        center_ = self.center.transform_to(frames.HeliographicCarrington(observer='Earth',
+                                                                         obstime=self.center.obstime))
         data_dict = {
             'hgln': self.center.lon.to_value(u.degree),
             'hglt': self.center.lat.to_value(u.degree),
@@ -689,7 +694,8 @@ class gcs():
         '''
         Returns the GCS object and parameters in a printable sting array.
         '''
-        center_ = self.center.transform_to(frames.HeliographicCarrington)
+        center_ = self.center.transform_to(frames.HeliographicCarrington(observer='Earth',
+                                                                         obstime=self.center.obstime))
         output = '<GCS object \n'
         output += 'HGLN = %3.2f degrees \n'%self.center.lon.to_value(u.degree)
         output += 'HGLT = %3.2f degrees \n'%self.center.lat.to_value(u.degree)

{PyThea-0.9.0 → pythea-0.10.0}/PyThea/modules.py

@@ -19,16 +19,14 @@
 
 
 import datetime
-import json
 
 import astropy.units as u
-import numpy as np
-import pandas as pd
 
 from PyThea.callbacks import change_fitting_sliders, change_long_lat_sliders
 from PyThea.config.config_sliders import sliders_dict as sd
 from PyThea.geometrical_models import ellipsoid, gcs, spheroid
-from PyThea.utils import get_hek_flare, model_fittings
+from PyThea.utils import (get_hek_flare, make_figure, model_fittings,
+                          plot_bodies, plot_solar_reference_lines)
 
 
 def date_and_event_selection(st):
@@ -68,29 +66,14 @@ def date_and_event_selection(st):
             if uploaded_file.type != 'application/json':
                 st.sidebar.error('Unsupported file type')
                 st.stop()
-            fitting = json.loads(uploaded_file.read())
-            st.session_state.event_selected = fitting['event_selected']
-            st.session_state.date_process  = datetime.datetime.strptime(fitting['date_process'], '%Y-%m-%dT%H:%M:%S.%f')
-            st.session_state.geometrical_model = fitting['geometrical_model']['type']
-            table_indx = [datetime.datetime.strptime(t, '%Y-%m-%dT%H:%M:%S.%f') for t in fitting['geometrical_model']['parameters']['time']]
-            parameters = pd.DataFrame(fitting['geometrical_model']['parameters'], index=table_indx)
-            parameters = parameters.drop(['time'], axis=1)
-
-            if 'kinematics' in fitting:
-                kinematics = fitting['kinematics']
-            else:
-                # TODO: Remove this in version 1.0.0
-                st.warning('**Warning:** The .json fitting file does not contain the "kinematics" information. \
-                            This means that the file was prodused using Pythea with <V0.6.0. \
-                            **To resolve this:** Just do a save of the loaded fitting now and replace \
-                            the old file with the new one. This will not alter your fittings.')
-                kinematics = {'fit_method': {'type': 'polynomial', 'order': 1}}
-
-            st.session_state.model_fittings = model_fittings(fitting['event_selected'],
-                                                             fitting['date_process'],
-                                                             fitting['geometrical_model']['type'],
-                                                             parameters,
-                                                             kinematics=kinematics)
+
+            st.session_state.model_fittings = model_fittings.load_from_json(uploaded_file)
+
+            st.session_state.event_selected = st.session_state.model_fittings.event_selected
+            st.session_state.date_process  = \
+                datetime.datetime.strptime(st.session_state.model_fittings.date_process, '%Y-%m-%dT%H:%M:%S.%f')
+            st.session_state.geometrical_model = st.session_state.model_fittings.geometrical_model
+
             st.rerun()
 
 
@@ -201,13 +184,27 @@ def final_parameters_gmodel(st):
         return rcenter, height, alpha, kappa, tilt
 
 
-def maps_clims(st, imagers_list):
-    if 'map_clim' not in st.session_state:
-        st.session_state['map_clim'] = {}
+def figure_streamlit(st, running_map, image_mode, imager, model):
 
-    for imager in imagers_list:
-        if imager not in st.session_state.map or st.session_state.map[imager] == []:
-            pass
-        else:
-            map_ = st.session_state.map[imager][0]
-            st.session_state.map_clim[imager] = [np.nanquantile(map_.data, 0.20), np.nanquantile(map_.data, 0.80)]
+    fig, axis = make_figure(running_map, image_mode,
+                            clim=st.session_state.map_colormap_limits[imager],
+                            clip_model=st.session_state.clip_model,
+                            median_filter=st.session_state.images_median_filter)
+
+    if st.session_state.plot_mesh_mode == 'Skeleton':
+        model.plot(axis, mode='Skeleton')
+    elif st.session_state.plot_mesh_mode == 'Full':
+        model.plot(axis, mode='Skeleton')
+        model.plot(axis, mode='Full')
+    elif st.session_state.plot_mesh_mode == 'Surface':
+        model.plot(axis, only_surface=True)
+
+    if st.session_state.star_field:
+        plot_bodies(axis, st.session_state.bodies_list, running_map)
+        axis.legend()
+
+    if st.session_state.plot_solar_reference_lines_:
+        plot_solar_reference_lines(axis, st.session_state.plot_solar_reference_lines_bodies_list,
+                                   running_map, mode=st.session_state.plot_solar_reference_lines_mode)
+
+    return fig, axis

pythea-0.10.0/PyThea/sunpy_dev/extern/sunkit_instruments/aia/utils.py

@@ -0,0 +1,14 @@
+from astropy.time import TimeDelta
+from aiapy.calibrate import fix_observer_location, update_pointing
+
+__all__ = ['prep_aia']
+
+
+def prep_aia(map_sequence):
+    map_sequence = [update_pointing(tmap) for tmap in map_sequence]
+    map_sequence = [fix_observer_location(tmap) for tmap in map_sequence]
+
+    for map_ in map_sequence:
+        map_.meta['DATE-AVG'] = (map_.date + TimeDelta(map_.meta['exptime']/2, format='sec')).value
+
+    return map_sequence

{PyThea-0.9.0 → pythea-0.10.0}/PyThea/sunpy_dev/map/maputils.py

@@ -8,8 +8,8 @@ import warnings
 import astropy.units as u
 import numpy as np
 import sunpy.map
-from aiapy.calibrate import fix_observer_location, update_pointing
 
+import PyThea.sunpy_dev.extern.sunkit_instruments.aia.utils  # noqa
 import PyThea.sunpy_dev.extern.sunkit_instruments.lasco.utils  # noqa
 import PyThea.sunpy_dev.extern.sunkit_instruments.stereo.utils  # noqa
 
@@ -17,17 +17,17 @@ __all__ = ['maps_sequence_processing', 'get_closest', 'normalize_exposure',
            'prepare_maps', 'difference_maps', 'mask_occulter']
 
 
-def maps_sequence_processing(map_sequence, seq_type='Plain'):
+def maps_sequence_processing(map_sequence, **kwargs):
     """
-    Returns a sequence of maps which is processed as running difference or base difference or plain images.
+    Returns a sequence of maps which is processed as plain images, running or base difference images.
 
     Parameters
     ----------
     map_sequence : `~sunpy.map.GenericMap`
         A list SunPy maps.
 
-    seq_type : '~str'
-        The type of sequence processing
+    image_mode : '~str'
+        The type of sequence processing: 'Running Diff.', 'Base Diff.', 'Plain'
 
     Returns
     -------
@@ -35,18 +35,24 @@ def maps_sequence_processing(map_sequence, seq_type='Plain'):
         A SunPy map.
     """
 
+    if len(map_sequence) == 0:
+        return []
+
+    seq_type = kwargs.get('image_mode', 'Plain')
+    diff_num = kwargs.get('diff_num', 1 if seq_type == 'Running Diff.' else 0 if seq_type == 'Base Diff.' else None)
+
     normalized = True if True in [tmap.exposure_time == 1.0*u.second for tmap in map_sequence] else False
     if not normalized:
         warnings.warn('Warning [maps_sequence_processing]: The exposure time of the maps is not normalized.')
 
     smap = []
     if seq_type == 'Running Diff.':
-        for i in range(1, len(map_sequence)):
-            smap_diff = difference_maps(map_sequence[i], map_sequence[i-1])
+        for i in range(1+diff_num, len(map_sequence)):
+            smap_diff = difference_maps(map_sequence[i], map_sequence[i-diff_num])
             smap.append(smap_diff)
     if seq_type == 'Base Diff.':
         for i in range(1, len(map_sequence)):
-            smap_diff = difference_maps(map_sequence[i], map_sequence[0])
+            smap_diff = difference_maps(map_sequence[i], map_sequence[diff_num])
             smap.append(smap_diff)
     if seq_type == 'Plain':
         for i in range(0, len(map_sequence)):
@@ -132,6 +138,9 @@ def filter_maps(map_sequence, **kwargs):
 
     '''
 
+    if len(map_sequence) == 0:
+        return []
+
     if 'exposure' in kwargs.keys():
         map_sequence = [tmap for tmap in map_sequence if tmap.exposure_time > kwargs['exposure']*u.second]
 
@@ -145,6 +154,7 @@ def filter_maps(map_sequence, **kwargs):
         sequence_final = sunpy.map.Map(map_sequence, sequence=True)
     else:
         sequence_final = []
+
     return sequence_final
 
 
@@ -169,16 +179,16 @@ def prepare_maps(map_sequence, **kwargs):
         A SunPy map.
 
     '''
-    detector = map_sequence[0].detector
-    print(f'Preparing image sequence for {detector}.')
 
     if len(map_sequence) == 0:
         return []
 
+    detector = map_sequence[0].detector
+    print(f'Preparing image sequence for {detector}. This could take a while...')
+
     # Prepare the maps before anything else
     if detector == 'AIA':
-        map_sequence = [update_pointing(tmap) for tmap in map_sequence]
-        map_sequence = [fix_observer_location(tmap) for tmap in map_sequence]
+        map_sequence = PyThea.sunpy_dev.extern.sunkit_instruments.aia.utils.prep_aia(map_sequence)
     elif detector == 'COR1':
         if 'polar' not in kwargs.keys():
             map_sequence = PyThea.sunpy_dev.extern.sunkit_instruments.stereo.utils.cor_polariz(map_sequence)
@@ -279,3 +289,7 @@ def mask_occulter(smap, apply_mask=True, mask_value=0):
         smap.data[mask_inner+mask_outer] = mask_value
         return sunpy.map.Map(smap.data, smap.meta)
     return mask_inner+mask_outer
+
+
+def maps_clims(images):
+    return [np.nanquantile(images[1].data, 0.20)-10, np.nanquantile(images[1].data, 0.80)+10]

pythea-0.10.0/PyThea/test/Pythea_test.py

@@ -0,0 +1,24 @@
+"""
+A place for the more generic tests that do not fit in the other categories
+
+Note
+----
+Before you start the test the PyThea pkg should be in the python path
+export PYTHONPATH="${PYTHONPATH}:{top_level_dir_that_pythea_lives}/PyThea"
+"""
+
+import os
+from pathlib import Path
+
+
+def test_database_dir_exists():
+    """
+    Tests that Pythea's database directory exists.
+    """
+    # Skip the test if running in GitHub Actions
+    if os.environ.get('CI') == 'true':
+        print("Skipping test as it's running in GitHub Actions.")
+        return
+
+    database_dir = os.path.join(Path.home(), 'PyThea')
+    assert os.path.exists(database_dir), f"PyThea's database directory '{database_dir}' does not exist."

{PyThea-0.9.0 → pythea-0.10.0}/PyThea/utils.py

@@ -23,6 +23,7 @@ import io
 import json
 import os
 import re
+import warnings
 from copy import copy
 from pathlib import Path
 
@@ -35,13 +36,17 @@ import numpy as np
 import pandas as pd
 import seaborn as sns
 import sunpy.map
+from astropy.coordinates import SkyCoord
+from astropy.visualization.wcsaxes.wcsapi import wcsapi_to_celestial_frame
 from scipy.interpolate import UnivariateSpline
+from scipy.ndimage import median_filter
 from scipy.optimize import curve_fit
-from sunpy.coordinates import get_horizons_coord
+from sunpy.coordinates import frames, get_horizons_coord
 from sunpy.map.maputils import contains_coordinate
 from sunpy.net import Fido
 from sunpy.net import attrs as a
 from sunpy.time import parse_time
+from sunpy.visualization import drawing
 
 from PyThea.config.selected_bodies import bodies_dict
 from PyThea.config.selected_imagers import imager_dict
@@ -86,13 +91,15 @@ def make_figure(map, image_mode, clim=[-20, 20], clip_model=True, **kwargs):
 
     if image_mode == 'Plain':
         # TODO: For plain images or when EUVIA-B are used, this does not work very well.
-        map.plot()
+        map.plot(norm=colors.Normalize(vmin=clim[0], vmax=clim[1]))
     else:
+        median_filter_value = kwargs.get('median_filter', 1)
+        if median_filter_value != 1:
+            map = sunpy.map.Map(median_filter(map.data, size=int(median_filter_value)), map.meta)
         map.plot(cmap='Greys_r',
                  norm=colors.Normalize(vmin=clim[0], vmax=clim[1]))
 
     map.draw_limb(resolution=90)
-    # map.draw_grid(linewidth=2, color='red') # TODO: This takes too much computation time. Maybe for AIA or EUVI?
 
     yax = axis.coords[1]
     yax.set_ticklabel(rotation=90)
@@ -127,6 +134,42 @@ def plot_bodies(axis, bodies_list, smap):
                             fillstyle='none', markersize=6, label=body)
 
 
+def plot_solar_reference_lines(axis, bodies_list, smap, mode='Limb from Obs.'):
+    '''
+    Plots solar reference lines (e.g. solar limb, central meridians, equator) in wcs axis.
+    '''
+    def draw_central_meridian(axis, body_coo, date, color):
+        body_coo = body_coo.transform_to(frames.HeliographicStonyhurst)
+        constant_lon = SkyCoord(body_coo.lon, np.linspace(-90, 90, 90) * u.deg,
+                                frame=frames.HeliographicStonyhurst(obstime=date))
+        v, _ = drawing._plot_vertices(constant_lon, axis, wcsapi_to_celestial_frame(axis.wcs), None,
+                                      color=color, close_path=False, linewidth=1)
+
+    for body in bodies_list:
+        try:
+            body_coo = get_horizons_coord(bodies_dict[body][0], smap.date_average)
+        except ValueError as ve:
+            print(f'Error processing {body}: {ve}')
+            continue
+
+        if mode in ['Limb from Obs.', 'limb']:
+            drawing.limb(axis, body_coo, color=bodies_dict[body][1],
+                         linewidth=1, resolution=90, label=f'Limb seen from {body}')
+        if mode in ['Central Meridian from Obs.', 'meridian']:
+            draw_central_meridian(axis, body_coo, smap.date_average, bodies_dict[body][1])
+
+    if mode in ['Carr. Prime Meridian+Solar Equator', ['carr-me']]:
+        drawing.equator(axis, linewidth=1, resolution=90)
+        drawing.prime_meridian(axis, linewidth=1, resolution=90)
+    elif mode in ['Stonyhurst Grid', ['stony-grid']]:
+        earth = get_horizons_coord(3, smap.date_average)
+        draw_central_meridian(axis, earth, smap.date_average, 'white')
+        smap.draw_grid(linewidth=1, color='red', system='stonyhurst', alpha=0.8)
+    elif mode in ['Carrington Grid', ['carr-grid']]:
+        drawing.prime_meridian(axis, linewidth=1, resolution=90)
+        smap.draw_grid(linewidth=1, color='red', system='carrington', alpha=0.8)
+
+
 def download_fits(date_process, imager, time_range=[-1, 1]):
     '''
     Downloads the imaging data (fits files) from VSO
@@ -134,24 +177,26 @@ def download_fits(date_process, imager, time_range=[-1, 1]):
     timerange = a.Time(date_process + datetime.timedelta(hours=time_range[0]),
                        date_process + datetime.timedelta(hours=time_range[1]))
 
-    map_ = {}
+    maps_ = []
     args = imager_dict[imager][0]
     result = Fido.search(timerange, *args)
     print(result)
     if result:
         downloaded_files = Fido.fetch(result, path=f'{database_dir}'+'/data/{source}/{instrument}/'+'/{file}')
-        try:
-            map_ = sunpy.map.Map(downloaded_files)
-        except RuntimeError as err:
-            print('Handling RuntimeError error:', err)
-            map_ = []
-        except OSError as err:
-            print('Handling OSError error:', err)
-            map_ = []
-    else:
-        map_ = []
-
-    return map_
+        for file_path in downloaded_files:
+            try:
+                map_ = sunpy.map.Map(file_path)
+                maps_.append(map_)
+            except RuntimeError as err:
+                print('Handling RuntimeError error:', err)
+            except OSError as err:
+                print('Handling OSError error:', err)
+                os.remove(file_path)
+                print(f"File '{file_path}' has been removed.")
+        if maps_:
+            maps_ = sunpy.map.Map(maps_, sequence=True)
+
+    return maps_
 
 
 def maps_process(maps_dict_in, imagers_list_in, image_mode, **kwargs):
@@ -183,15 +228,21 @@ def maps_process(maps_dict_in, imagers_list_in, image_mode, **kwargs):
     return maps_dict_out, imagers_list_out
 
 
-def single_imager_maps_process(map_list_in, image_mode='Plain', **kwargs):
+def single_imager_maps_process(map_list, skip=None, **kwargs):
     '''
     Process the images for a single imager and return the final maps.
     '''
-    map_list_out = filter_maps(map_list_in, **kwargs)
-    map_list_out = prepare_maps(map_list_out, **kwargs)
-    map_list_out = maps_sequence_processing(map_list_out, seq_type=image_mode)
 
-    return map_list_out
+    if 'filter' not in str(skip or ''):
+        map_list = filter_maps(map_list, **kwargs)
+
+    if 'prepare' not in str(skip or ''):
+        map_list = prepare_maps(map_list, **kwargs)
+
+    if 'sequence_processing' not in str(skip or ''):
+        map_list = maps_sequence_processing(map_list, **kwargs)
+
+    return map_list
 
 
 # TODO: Implement units here
@@ -207,6 +258,36 @@ class model_fittings:
         self.parameters = model_parameters
         self.kinematics = kinematics
 
+    @staticmethod
+    def load_from_json(json_file):
+        if isinstance(json_file, str):
+            with open(json_file, 'r') as file:
+                json_content = file.read()
+                fitting = json.loads(json_content)
+        else:
+            fitting = json.loads(json_file.read())
+
+        table_indx = [datetime.datetime.strptime(t, '%Y-%m-%dT%H:%M:%S.%f') for t in fitting['geometrical_model']['parameters']['time']]
+        parameters = pd.DataFrame(fitting['geometrical_model']['parameters'], index=table_indx)
+        parameters = parameters.drop(['time'], axis=1)
+        if 'kinematics' in fitting:
+            kinematics = fitting['kinematics']
+        else:
+            # TODO: Remove this in version 1.0.0
+            warnings.warn('The .json fitting file does not contain the "kinematics" information. \n \
+                            This means that the file was prodused using Pythea with <V0.6.0. \n \
+                            To resolve this: Just do a save of the loaded fitting now and replace \n \
+                            the old file with the new one. This will not alter your fittings.')
+            kinematics = {'fit_method': {'type': 'polynomial', 'order': 1}}
+
+        model_fittings_class = model_fittings(fitting['event_selected'],
+                                              fitting['date_process'],
+                                              fitting['geometrical_model']['type'],
+                                              parameters,
+                                              kinematics=kinematics)
+
+        return model_fittings_class
+
     def model_id(self):
         str_id = self.event_selected.replace('-', '').replace(':', '').replace('|', 'D').replace('.', 'p') + 'M' + self.geometrical_model
         return str_id

{PyThea-0.9.0 → pythea-0.10.0/PyThea.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyThea
-Version: 0.9.0
+Version: 0.10.0
 Summary: PyThea: A software package to reconstruct the 3D structure of CMEs and shock waves
 Home-page: https://github.com/AthKouloumvakos/PyThea
 Author: Athanasios Kouloumvakos
@@ -27,8 +27,8 @@ Requires-Dist: aiapy
 Requires-Dist: astropy
 Requires-Dist: astroquery
 Requires-Dist: numexpr
-Requires-Dist: sunpy==4.1.0
-Requires-Dist: parfive==1.5.1
+Requires-Dist: sunpy==5.1.2
+Requires-Dist: parfive==2.1.0
 Requires-Dist: pooch
 Requires-Dist: matplotlib
 Requires-Dist: seaborn

{PyThea-0.9.0 → pythea-0.10.0}/PyThea.egg-info/SOURCES.txt

@@ -38,6 +38,8 @@ PyThea/extensions/buttons.py
 PyThea/sunpy_dev/__init__.py
 PyThea/sunpy_dev/extern/__init__.py
 PyThea/sunpy_dev/extern/sunkit_instruments/__init__.py
+PyThea/sunpy_dev/extern/sunkit_instruments/aia/__init__.py
+PyThea/sunpy_dev/extern/sunkit_instruments/aia/utils.py
 PyThea/sunpy_dev/extern/sunkit_instruments/lasco/__init__.py
 PyThea/sunpy_dev/extern/sunkit_instruments/lasco/utils.py
 PyThea/sunpy_dev/extern/sunkit_instruments/stereo/__init__.py

{PyThea-0.9.0 → pythea-0.10.0}/PyThea.egg-info/requires.txt

@@ -5,8 +5,8 @@ aiapy
 astropy
 astroquery
 numexpr
-sunpy==4.1.0
-parfive==1.5.1
+sunpy==5.1.2
+parfive==2.1.0
 pooch
 matplotlib
 seaborn

{PyThea-0.9.0 → pythea-0.10.0}/environment.yml

@@ -14,8 +14,8 @@ dependencies:
   - astropy
   - astroquery
   - numexpr
-  - sunpy=4.1.0
-  - parfive==1.5.1 # With parfive>=2.0.0 there is an issue with streamlit and asyncio (see #13)
+  - sunpy=5.1.2
+  - parfive==2.1.0  # The issue with streamlit and asyncio is resolved (see #13). Keep this for a while to make sure everything works smoothly.
   - streamlit
   - seaborn
   - pyvista

{PyThea-0.9.0 → pythea-0.10.0}/requirements.txt

@@ -5,8 +5,8 @@ aiapy
 astropy
 astroquery
 numexpr
-sunpy==4.1.0
-parfive==1.5.1
+sunpy==5.1.2
+parfive==2.1.0
 pooch
 matplotlib
 seaborn

PyThea-0.9.0/PyThea/test/Pythea_test.py

@@ -1,8 +0,0 @@
-"""
-A place for the more generic tests that do not fit in the other categories
-
-Note
-----
-Before you start the test the PyThea pkg should be in the python path
-export PYTHONPATH="${PYTHONPATH}:{top_level_dir_that_pythea_lives}/PyThea"
-"""