daxa 0.0.2__py3-none-any.whl

daxa/__init__.py

@@ -0,0 +1,5 @@
+#  This code is a part of the Democratising Archival X-ray Astronomy (DAXA) module.
+#  Last modified by David J Turner (turne540@msu.edu) 15/04/2024, 14:49. Copyright (c) The Contributors
+
+from .config import daxa_conf, OUTPUT, NUM_CORES, sb_rate
+from .mission.xmm import *

daxa/config.py

@@ -0,0 +1,88 @@
+#  This code is a part of the Democratising Archival X-ray Astronomy (DAXA) module.
+#  Last modified by David J Turner (turne540@msu.edu) 15/04/2024, 14:49. Copyright (c) The Contributors
+
+import os
+from configparser import ConfigParser
+from warnings import warn
+
+import pandas as pd
+import pkg_resources
+from astropy.units import def_unit, ct, deg, s
+from numpy import floor
+
+from .exceptions import DAXAConfigError
+
+# If XDG_CONFIG_HOME is set, then use that, otherwise use this default config path
+CONFIG_PATH = os.environ.get('XDG_CONFIG_HOME', os.path.join(os.path.expanduser('~'), '.config', 'daxa'))
+# DAXA config file path
+CONFIG_FILE = os.path.join(CONFIG_PATH, 'daxa.cfg')
+# Section of the config file for setting up the DAXA module
+DAXA_CONFIG = {"daxa_save_path": "daxa_output/",
+               "num_cores": -1}
+
+if not os.path.exists(CONFIG_PATH):
+    os.makedirs(CONFIG_PATH)
+
+# If first DAXA run, creates default config file
+if not os.path.exists(CONFIG_FILE):
+    daxa_default = ConfigParser()
+    daxa_default.add_section("DAXA_SETUP")
+    daxa_default["DAXA_SETUP"] = DAXA_CONFIG
+    with open(CONFIG_FILE, 'w') as new_cfg:
+        daxa_default.write(new_cfg)
+
+    # First time run triggers this message
+    warn("A configuration file has been created ({}); you can use it to control where DAXA "
+         "stores data by default.".format(CONFIG_FILE), stacklevel=2)
+
+daxa_conf = ConfigParser()
+# It would be nice to do configparser interpolation, but it wouldn't handle the lists of energy values
+daxa_conf.read(CONFIG_FILE)
+
+try:
+    cfg_cores = daxa_conf['DAXA_SETUP'].getint('num_cores')
+except ValueError:
+    raise DAXAConfigError("The 'num_cores' configuration parameter must be an integer, with -1 corresponding "
+                          "to a null value and meaning that DAXA will determine the number of cores to use itself.")
+
+# As it turns out, the ConfigParser class is a pain to work with, so we're converting to a dict here
+# Addressing works just the same
+daxa_conf = {str(sect): dict(daxa_conf[str(sect)]) for sect in daxa_conf}
+
+if cfg_cores != -1 and cfg_cores <= os.cpu_count():
+    # If the user has set a number of cores in the config file then we'll use that.
+    NUM_CORES = int(daxa_conf["DAXA_SETUP"]["num_cores"])
+elif cfg_cores != -1:
+    raise DAXAConfigError("You have set a num_cores values that is greater than the number of cores available in"
+                          " the current system ({}).".format(os.cpu_count()))
+else:
+    # Going to allow multi-core processing to use 90% of available cores by default, but
+    # this can be over-ridden in individual SAS calls.
+    NUM_CORES = max(int(floor(os.cpu_count() * 0.9)), 1)  # Makes sure that at least one core is used
+
+
+# This is the default output directory for archives setup by DAXA, though it can be overridden on
+#  a mission level
+OUTPUT = os.path.abspath(daxa_conf["DAXA_SETUP"]["daxa_save_path"]) + "/"
+
+# Here we read in files that list the errors and warnings in SAS
+errors = pd.read_csv(pkg_resources.resource_filename(__name__, "files/sas_errors.csv"), header="infer")
+warnings = pd.read_csv(pkg_resources.resource_filename(__name__, "files/sas_warnings.csv"), header="infer")
+# Just the names of the errors in two handy constants
+SASERROR_LIST = errors["ErrName"].values
+SASWARNING_LIST = warnings["WarnName"].values
+
+# Reading in the file with information on the eROSITA observations that were made available in the
+#  eROSITA CalPV release
+EROSITA_CALPV_INFO = pd.read_csv(pkg_resources.resource_filename(__name__, "files/erosita_calpv_info.csv"),
+                                 header="infer", dtype={'ObsID': str})
+# TODO This may end up changing when we get access to the DR1 release - it could be in a format that makes this
+#  a bad way of doing it
+# Then doing the same thing, but for the German eRASS:1 release
+ERASS_DE_DR1_INFO = pd.read_csv(pkg_resources.resource_filename(__name__, "files/erass_de_dr1_info.csv"),
+                                header="infer", dtype={'ObsID': str, 'FIELD1': str, 'FIELD2': str, 'FIELD3': str,
+                                                       'FIELD4': str, 'FIELD5': str, 'FIELD6': str, 'FIELD7': str,
+                                                       'FIELD8': str, 'FIELD9': str})
+
+# We define a surface brightness rate astropy unit for use in flaregti to measure thresholds in
+sb_rate = def_unit('sb_rate', ct / (deg**2 * s))

daxa/exceptions.py

@@ -0,0 +1,469 @@
+#  This code is a part of the Democratising Archival X-ray Astronomy (DAXA) module.
+#  Last modified by David J Turner (turne540@msu.edu) 16/04/2024, 19:47. Copyright (c) The Contributors
+
+
+class DAXAConfigError(Exception):
+    def __init__(self, *args):
+        """
+        Exception raised for flawed DAXA config files.
+
+        :param expression:
+        :param message:
+        """
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return '{0} '.format(self.message)
+        else:
+            return 'DAXAConfig has been raised'
+
+
+class DAXADownloadError(Exception):
+    def __init__(self, *args):
+        """
+        Exception raised for problems with data downloads orchestrated by DAXA.
+
+        :param expression:
+        :param message:
+        """
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return '{0} '.format(self.message)
+        else:
+            return 'DAXADownloadError has been raised'
+
+
+class DAXANotDownloadedError(Exception):
+    def __init__(self, *args):
+        """
+        Exception raised for when something attempts to perform an action that requires data to be downlaoded, and
+        it hasn't been.
+
+        :param expression:
+        :param message:
+        """
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return '{0} '.format(self.message)
+        else:
+            return 'DAXANotDownloadedError has been raised'
+
+
+class DuplicateMissionError(Exception):
+    def __init__(self, *args):
+        """
+        Exception raised when multiple instances of the same mission are passed to an Archive definition.
+
+        :param expression:
+        :param message:
+        """
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return '{0} '.format(self.message)
+        else:
+            return 'DuplicateMissionError has been raised'
+
+
+class ArchiveExistsError(Exception):
+    def __init__(self, *args):
+        """
+        Exception raised when an archive name that has already been used in a particular
+        DAXA output directory is used again.
+
+        :param expression:
+        :param message:
+        """
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return '{0} '.format(self.message)
+        else:
+            return 'ArchiveExistsError has been raised'
+
+
+class MissionLockedError(Exception):
+    def __init__(self, *args):
+        """
+        Exception raised when a mission instance has been locked (no further changes to selected observations
+        can be made) and a change of some kind is attempted.
+
+        :param expression:
+        :param message:
+        """
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return '{0} '.format(self.message)
+        else:
+            return 'MissionLockedError has been raised'
+
+
+class SASNotFoundError(Exception):
+    def __init__(self, *args):
+        """
+        Exception raised if the XMM Scientific Analysis System can not be found on the system.
+
+        :param expression:
+        :param message:
+        """
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return '{0} '.format(self.message)
+        else:
+            return 'SASNotFoundError has been raised'
+
+
+class SASVersionError(Exception):
+    def __init__(self, *args):
+        """
+        Exception raised if the XMM Scientific Analysis System located on the system is a version
+        that is not compatible with DAXA.
+
+        :param expression:
+        :param message:
+        """
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return '{0} '.format(self.message)
+        else:
+            return 'SASVersionError has been raised'
+
+class eSASSNotFoundError(Exception):
+    def __init__(self, *args):
+        """
+        Exception raised if the eROSITA Science Analysis Software System can not be found on the system.
+
+        :param expression:
+        :param message:
+        """
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return '{0} '.format(self.message)
+        else:
+            return 'eSASSNotFoundError has been raised'
+
+
+class BackendSoftwareError(Exception):
+    def __init__(self, *args):
+        """
+        Exception raised if a required piece of backend software has not been located.
+
+        :param expression:
+        :param message:
+        """
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return '{0} '.format(self.message)
+        else:
+            return 'BackendSoftwareError has been raised'
+
+
+class NoXMMMissionsError(Exception):
+    def __init__(self, *args):
+        """
+        Exception raised if an archive containing no XMM missions is passed to an XMM specific processing function.
+
+        :param expression:
+        :param message:
+        """
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return '{0} '.format(self.message)
+        else:
+            return 'NoXMMMissionsError has been raised'
+
+class NoEROSITAMissionsError(Exception):
+    def __init__(self, *args):
+        """
+        Exception raised if an archive containing no eROSITA missions is passed to an eROSITA specific processing function.
+
+        :param expression:
+        :param message:
+        """
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return '{0} '.format(self.message)
+        else:
+            return 'NoEROSITAMissionsError has been raised'
+
+
+class NoProcessingError(Exception):
+    def __init__(self, *args):
+        """
+        Exception raised if a method tries to access processed data when no processing has been applied.
+
+        :param expression:
+        :param message:
+        """
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return '{0} '.format(self.message)
+        else:
+            return 'NoProcessingError has been raised'
+
+
+class NoDependencyProcessError(Exception):
+    def __init__(self, *args):
+        """
+        Exception raised if a processing method that the current process depends on has not been run.
+
+        :param expression:
+        :param message:
+        """
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return '{0} '.format(self.message)
+        else:
+            return 'NoDependencyProcessError has been raised'
+
+
+class NoObsAfterFilterError(Exception):
+    def __init__(self, *args):
+        """
+        Exception raised if a there are no valid observations left in a mission after filtering processes have been
+        applied.
+
+        :param expression:
+        :param message:
+        """
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return '{0} '.format(self.message)
+        else:
+            return 'NoObsAfterFilterError has been raised'
+
+
+class IllegalSourceType(Exception):
+    def __init__(self, *args):
+        """
+        Exception raised if a source type that isn't in the DAXA source type taxonomy has been used.
+
+        :param expression:
+        :param message:
+        """
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return '{0} '.format(self.message)
+        else:
+            return 'IllegalSourceType has been raised'
+
+
+class NoTargetSourceTypeInfo(Exception):
+    def __init__(self, *args):
+        """
+        Exception raised if a mission doesn't have any information on each observation's target source type.
+
+        :param expression:
+        :param message:
+        """
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return '{0} '.format(self.message)
+        else:
+            return 'NoSourceTypeInfo has been raised'
+
+
+class ObsNotAssociatedError(Exception):
+    def __init__(self, *args):
+        """
+        Exception raised if an observation is not associated with a particular mission's filtered dataset.
+
+        :param expression:
+        :param message:
+        """
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return '{0} '.format(self.message)
+        else:
+            return 'ObsNotAssociatedError has been raised'
+
+
+class MissionNotAssociatedError(Exception):
+    def __init__(self, *args):
+        """
+        Exception raised if a mission is not associated with a particular archive dataset.
+
+        :param expression:
+        :param message:
+        """
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return '{0} '.format(self.message)
+        else:
+            return 'MissionNotAssociatedError has been raised'
+
+
+class NoRegionsAssociatedError(Exception):
+    def __init__(self, *args):
+        """
+        Exception raised if there are no source regions available for the user to retrieve.
+
+        :param expression:
+        :param message:
+        """
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return '{0} '.format(self.message)
+        else:
+            return 'NoRegionsAssociatedError has been raised'
+
+
+class IncompatibleSaveError(Exception):
+    def __init__(self, *args):
+        """
+        Exception raised if a save file being read in to reinstate a DAXA mission or archive is being used incorrectly
+        and is not compatible with the process.
+
+        :param expression:
+        :param message:
+        """
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return '{0} '.format(self.message)
+        else:
+            return 'IncompatibleSaveError has been raised'
+
+
+class PreProcessedNotSupportedError(Exception):
+    def __init__(self, *args):
+        """
+        Exception raised if the user attempts to access pre-processed data for a mission class that does not support
+        it (usually because the data are not available in the archive).
+
+        :param expression:
+        :param message:
+        """
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return '{0} '.format(self.message)
+        else:
+            return 'PreProcessedNotSupportedError has been raised'
+
+
+class PreProcessedNotAvailableError(Exception):
+    def __init__(self, *args):
+        """
+        Exception raised if the user attempts to access a pre-processed product that is not available for the
+        mission - e.g. if they try to access an image for an energy band not present in the archive.
+
+        :param expression:
+        :param message:
+        """
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return '{0} '.format(self.message)
+        else:
+            return 'PreProcessedNotAvailableError has been raised'
+