mt-metadata 0.3.6__py2.py3-none-any.whl → 0.3.8__py2.py3-none-any.whl

mt_metadata/__init__.py

@@ -39,7 +39,7 @@ you should only have to changes these dictionaries.
 
 __author__ = """Jared Peacock"""
 __email__ = "jpeacock@usgs.gov"
-__version__ = "0.3.6"
+__version__ = "0.3.8"
 
 # =============================================================================
 # Imports

mt_metadata/base/helpers.py

@@ -2,7 +2,7 @@
 """
 Created on Wed Dec 23 20:37:52 2020
 
-:copyright: 
+:copyright:
     Jared Peacock (jpeacock@usgs.gov)
 
 :license: MIT
@@ -637,11 +637,18 @@ def element_to_string(element):
 # Helper function to be sure everything is encoded properly
 # =============================================================================
 class NumpyEncoder(json.JSONEncoder):
+
     """
     Need to encode numpy ints and floats for json to work
     """
 
     def default(self, obj):
+        """
+
+        :param obj:
+        :type obj:
+        :return:
+        """
         if isinstance(
             obj,
             (
@@ -659,7 +666,7 @@ class NumpyEncoder(json.JSONEncoder):
             ),
         ):
             return int(obj)
-        elif isinstance(obj, (np.float_, np.float16, np.float32, np.float64)):
+        elif isinstance(obj, (np.float16, np.float32, np.float64)):
             return float(obj)
         elif isinstance(obj, (np.ndarray)):
             if obj.dtype == complex:

mt_metadata/timeseries/filters/filtered.py

@@ -17,6 +17,7 @@ from mt_metadata.base.helpers import write_lines
 from mt_metadata.base import get_schema, Base
 from mt_metadata.timeseries.standards import SCHEMA_FN_PATHS
 from mt_metadata.utils.exceptions import MTSchemaError
+from typing import Optional, Union
 
 # =============================================================================
 attr_dict = get_schema("filtered", SCHEMA_FN_PATHS)
@@ -31,6 +32,14 @@ class Filtered(Base):
     __doc__ = write_lines(attr_dict)
 
     def __init__(self, **kwargs):
+        """
+        Constructor
+
+        :param kwargs:
+
+        TODO: Consider not setting self.applied = None, as this has the effect of self._applied = [True,]
+        """
+        self._applied_values_map = _applied_values_map()
         self._name = []
         self._applied = []
         self.name = None
@@ -53,7 +62,7 @@ class Filtered(Base):
         elif isinstance(names, list):
             self._name = [ss.strip().lower() for ss in names]
         elif isinstance(names, np.ndarray):
-            names = names.astype(np.unicode_)
+            names = names.astype(np.str_)
             self._name = [ss.strip().lower() for ss in names]
         else:
             msg = "names must be a string or list of strings not {0}, type {1}"
@@ -68,25 +77,52 @@ class Filtered(Base):
             self.logger.warning(msg)
 
     @property
-    def applied(self):
+    def applied(self) -> list:
         return self._applied
 
     @applied.setter
-    def applied(self, applied):
+    def applied(
+        self,
+        applied: Union[list, str, None, int, tuple, np.ndarray, bool],
+    ) -> None:
+        """
+        Sets the value of the booleans for whether each filter has been applied or not
+
+        :type applied: Union[list, str, None, int, tuple]
+        :param applied: The value to set self._applied.
+
+        Notes:
+        self._applied is a list, but we allow this to be assigned by single values as well,
+        such as None, True, 0. Supporting these other values makes the logic a little bit involved.
+        If a null value is received, the filters are assumed to be applied.
+        If a simple value, such as True, None, 0, etc. is not received, the input argument
+        applied (which is iterable) is first converted to `applied_list`.
+        The values in `applied_list` are then mapped to booleans.
+
+
+        """
+        # Handle cases where we did not pass an iterable
         if not hasattr(applied, "__iter__"):
-            if applied in [None, "none", "None", "NONE", "null"]:
-                self._applied = [True]
-                return
-            elif applied in [0, "0"]:
-                self._applied = [False]
-                return
+            self._applied = [self._applied_values_map[applied], ]
+            return
+
+        # the returned type from a hdf5 dataset is a numpy array.
+        if isinstance(applied, np.ndarray):
+            applied = applied.tolist()
 
         #sets an empty list to one default value
         if isinstance(applied, list) and len(applied) == 0:
-            self.applied = [True]
+            self._applied = [True]
             return
 
+        # Handle string case
         if isinstance(applied, str):
+            # Handle simple strings
+            if applied in self._applied_values_map.keys():
+                self._applied = [self._applied_values_map[applied], ]
+                return
+
+            # Handle string-lists (e.g. from json)
             if applied.find("[") >= 0:
                 applied = applied.replace("[", "").replace("]", "")
             if applied.count(",") > 0:
@@ -97,44 +133,20 @@ class Filtered(Base):
                 applied_list = [ss.lower() for ss in applied.split()]
         elif isinstance(applied, list):
             applied_list = applied
-            # set integer strings to integers ["0","1"]--> [0, 1]
-            for i, elt in enumerate(applied_list):
-                if elt in ["0", "1",]:
-                    applied_list[i] = int(applied_list[i])
-            # set integers to bools [0,1]--> [False, True]
-            for i, elt in enumerate(applied_list):
-                if elt in [0, 1,]:
-                    applied_list[i] = bool(applied_list[i])
-        elif isinstance(applied, bool):
-            applied_list = [applied]
-        # the returned type from a hdf5 dataset is a numpy array.
-        elif isinstance(applied, np.ndarray):
+        elif isinstance(applied, tuple):
             applied_list = list(applied)
-            if applied_list == []:
-                applied_list = [True]
         else:
-            msg = "applied must be a string or list of strings not {0}"
-            self.logger.error(msg.format(applied))
-            raise MTSchemaError(msg.format(applied))
-
-        bool_list = []
-        for app_bool in applied_list:
-            if app_bool is None:
-                bool_list.append(True)
-            elif isinstance(app_bool, str):
-                if app_bool.lower() in ["false", "0"]:
-                    bool_list.append(False)
-                elif app_bool.lower() in ["true", "1"]:
-                    bool_list.append(True)
-                else:
-                    msg = "Filter.applied must be [ True | False ], not {0}"
-                    self.logger.error(msg.format(app_bool))
-                    raise MTSchemaError(msg.format(app_bool))
-            elif isinstance(app_bool, (bool, np.bool_)):
-                bool_list.append(bool(app_bool))
-            else:
-                msg = "Filter.applied must be [True | False], not {0}"
-                self.logger.error(msg.format(app_bool))
+            msg = f"Input applied cannot be of type {type(applied)}"
+            self.logger.error(msg)
+            raise MTSchemaError(msg)
+
+        # Now we have a simple list -- map to bools
+        try:
+            bool_list = [self._applied_values_map[x] for x in applied_list]
+        except KeyError:
+            msg = f"A key in {applied_list} is not mapped to a boolean"
+            msg += "\n fix this by adding to _applied_values_map"
+            self.logger.error(msg)
         self._applied = bool_list
 
         # check for consistency
@@ -146,36 +158,82 @@ class Filtered(Base):
             self.logger.warning(msg)
 
 
-    def _check_consistency(self):
-        # check for consistency
-        if self._name != []:
-            if self._applied is None:
-                self.logger.warning("Need to input filter.applied")
-                return False
-            if len(self._name) == 1:
-                if len(self._applied) == 1:
-                    return True
-            elif len(self._name) > 1:
-                if len(self._applied) == 1:
-                    self.logger.debug(
-                        "Assuming all filters have been "
-                        + "applied as {0}".format(self._applied[0])
-                    )
-                    return True
-                elif len(self._applied) > 1:
-                    if len(self._applied) != len(self._name):
-                        self.logger.warning(
-                            "Applied and filter names "
-                            + "should be the same length. "
-                            + "Appied={0}, names={1}".format(
-                                len(self._applied), len(self._name)
-                            )
-                        )
-                        return False
-                    else:
-                        return True
-        elif self._name == [] and len(self._applied) > 0:
+    def _check_consistency(self) -> bool:
+        """
+        Logic to look for inconstencies in the configuration of the filter names and applied values.
+
+        In general, list of filter names should be same length as list of applied booleans.
+
+        Cases:
+        The filter has no name -- this could happen on intialization.
+
+        :return: bool
+	    True if OK, False if not.
+
+        """
+        # This inconsistency is ok -- the filter may not have been assigned a name yet
+        if self._name == [] and len(self._applied) > 0:
             self.logger.debug("Name probably not yet initialized -- skipping consitency check")
             return True
+
+        # Otherwise self._name != []
+
+        # Applied not assigned - this is not OK
+        if self._applied is None:
+            self.logger.warning("Need to input filter.applied")
+            return False
+
+        # Name and applied have same length, 1. This is OK
+        if len(self._name) == 1:
+            if len(self._applied) == 1:
+                return True
+
+        # Multiple filter names (name not of length 0 or 1)
+        if len(self._name) > 1:
+            # If only one applied boolean, we allow it.
+            # TODO: consider being less tolerant here
+            if len(self._applied) == 1:
+                msg = f"Assuming all filters have been applied as {self._applied[0]}"
+                self.logger.debug(msg)
+                self._applied = len(self.name) * [self._applied[0],]
+                msg = f"Explicitly set filter applied state to {self._applied[0]}"
+                self.logger.debug(msg)
+                return True
+            elif len(self._applied) > 1:
+                # need to check the lists are really the same length
+                if len(self._applied) != len(self._name):
+                    msg = "Applied and filter names should be the same length. "
+                    msg += f"Appied={len(self._applied)}, names={len(self._name)}"
+                    self.logger.warning(msg)
+                    return False
+                else:
+                    return True
         else:
+            # Some unknown configuration we have not yet encountered
+            msg = "Filter consistency check failed for an unknown reason"
+            self.logger.warning(msg)
             return False
+
+
+def _applied_values_map(
+    treat_null_values_as: Optional[bool] = True
+) -> dict:
+    """
+    helper function to simplify logic in applied setter.
+
+    Notes:
+    The logic in the setter was getting quite complicated handling many types.
+    A reasonable solution seemed to be to map each of the allowed values to a bool
+    via dict and then use this dict when setting applied values.
+
+    :return: dict
+    Mapping of all tolerated single-values for setting applied booleans
+    """
+    null_values = [None, "none", "None", "NONE", "null"]
+    null_values_map = {x: treat_null_values_as for x in null_values}
+    true_values = [True, 1, "1", "True", "true"]
+    true_values_map =  {x:True for x in true_values}
+    false_values = [False, 0, "0", "False", "false"]
+    false_values_map =  {x:False for x in false_values}
+    values_map = {**null_values_map, **true_values_map, **false_values_map}
+    return values_map

mt_metadata/timeseries/station.py

@@ -59,6 +59,8 @@ attr_dict.add_dict(get_schema("copyright", SCHEMA_FN_PATHS), None)
 attr_dict["release_license"]["required"] = False
 attr_dict.add_dict(get_schema("citation", SCHEMA_FN_PATHS), None, keys=["doi"])
 attr_dict["doi"]["required"] = False
+
+
 # =============================================================================
 class Station(Base):
     __doc__ = write_lines(attr_dict)
@@ -316,3 +318,32 @@ class Station(Base):
                 else:
                     if self.time_period.end < max(end):
                         self.time_period.end = max(end)
+
+    def sort_runs_by_time(self, inplace=True, ascending=True):
+        """
+        return a list of runs sorted by start time in the order of ascending or
+        descending.
+
+        :param ascending: DESCRIPTION, defaults to True
+        :type ascending: TYPE, optional
+        :return: DESCRIPTION
+        :rtype: TYPE
+
+        """
+
+        run_ids = []
+        run_starts = []
+        for run_key, run_obj in self.runs.items():
+            run_ids.append(run_key)
+            run_starts.append(run_obj.time_period.start.split("+")[0])
+
+        index = np.argsort(np.array(run_starts, dtype=np.datetime64))
+
+        new_runs = ListDict()
+        for ii in index:
+            new_runs[run_ids[ii]] = self.runs[run_ids[ii]]
+
+        if inplace:
+            self.runs = new_runs
+        else:
+            return new_runs

mt_metadata/timeseries/stationxml/xml_inventory_mt_experiment.py

@@ -174,6 +174,7 @@ class XMLInventoryMTExperiment:
                     xml_station.site.country = ",".join(
                         [str(country) for country in mt_survey.country]
                     )
+                # need to sort the runs by time
                 for mt_run in mt_station.runs:
                     xml_station = self.add_run(
                         xml_station, mt_run, mt_survey.filters

mt_metadata/transfer_functions/__init__.py

@@ -1,3 +1,41 @@
+# Define allowed sets of channel labellings
+STANDARD_INPUT_CHANNELS = [
+    "hx",
+    "hy",
+]
+STANDARD_OUTPUT_CHANNELS = [
+    "ex",
+    "ey",
+    "hz",
+]
+
+CHANNEL_MAPS = {
+    "default": {"hx": "hx", "hy": "hy", "hz": "hz", "ex": "ex", "ey": "ey"},
+    "lemi12": {"hx": "bx", "hy": "by", "hz": "bz", "ex": "e1", "ey": "e2"},
+    "lemi34": {"hx": "bx", "hy": "by", "hz": "bz", "ex": "e3", "ey": "e4"},
+    "phoenix123": {"hx": "h1", "hy": "h2", "hz": "h3", "ex": "e1", "ey": "e2"},
+    "musgraves": {"hx": "bx", "hy": "by", "hz": "bz", "ex": "ex", "ey": "ey"},
+}
+
+
+def get_allowed_channel_names(standard_names):
+    """
+    :param standard_names: one of STANDARD_INPUT_NAMES, or STANDARD_OUTPUT_NAMES
+    :type standard_names: list
+    :return: allowed_names: list of channel names that are supported
+    :rtype: list
+    """
+    allowed_names = []
+    for ch in standard_names:
+        for _, channel_map in CHANNEL_MAPS.items():
+            allowed_names.append(channel_map[ch])
+    allowed_names = list(set(allowed_names))
+    return allowed_names
+
+
+ALLOWED_INPUT_CHANNELS = get_allowed_channel_names(STANDARD_INPUT_CHANNELS)
+ALLOWED_OUTPUT_CHANNELS = get_allowed_channel_names(STANDARD_OUTPUT_CHANNELS)
+
 from .core import TF
 
 __all__ = ["TF"]

mt_metadata/transfer_functions/core.py

@@ -274,7 +274,7 @@ class TF:
                 )
                 self.logger.error(msg)
                 raise TypeError(msg)
-        return run_metadata.copy()
+        return run_metadata
 
     def _validate_station_metadata(self, station_metadata):
         """
@@ -298,7 +298,7 @@ class TF:
                 )
                 self.logger.error(msg)
                 raise TypeError(msg)
-        return station_metadata.copy()
+        return station_metadata
 
     def _validate_survey_metadata(self, survey_metadata):
         """
@@ -328,7 +328,7 @@ class TF:
                 )
                 self.logger.error(msg)
                 raise TypeError(msg)
-        return survey_metadata.copy()
+        return survey_metadata
 
     ### Properties ------------------------------------------------------------
     @property
@@ -1475,9 +1475,8 @@ class TF:
         """
         self.station_metadata.id = validate_name(station_name)
         if self.station_metadata.runs[0].id is None:
-            r = self.station_metadata.runs[0].copy()
+            r = self.station_metadata.runs.pop(None)
             r.id = f"{self.station_metadata.id}a"
-            self.station_metadata.runs.remove(None)
             self.station_metadata.runs.append(r)
 
     @property
@@ -2164,9 +2163,9 @@ class TF:
         """
         zmm_kwargs = {}
         zmm_kwargs["channel_nomenclature"] = self.channel_nomenclature
-        zmm_kwargs[
-            "inverse_channel_nomenclature"
-        ] = self.inverse_channel_nomenclature
+        zmm_kwargs["inverse_channel_nomenclature"] = (
+            self.inverse_channel_nomenclature
+        )
         if hasattr(self, "decimation_dict"):
             zmm_kwargs["decimation_dict"] = self.decimation_dict
         zmm_obj = ZMM(**zmm_kwargs)

mt_metadata/transfer_functions/io/edi/edi.py

@@ -252,6 +252,22 @@ class EDI(object):
             return 1.0 / self.frequency
         return None
 
+    def _assert_descending_frequency(self):
+        """
+        Assert that the transfer function is ordered from high frequency to low
+        frequency.
+
+        """
+        if self.frequency[0] < self.frequency[1]:
+            self.logger.debug(
+                "Ordered arrays to be arranged from high to low frequency"
+            )
+            self.frequency = self.frequency[::-1]
+            self.z = self.z[::-1]
+            self.z_err = self.z_err[::-1]
+            self.t = self.t[::-1]
+            self.t_err = self.t_err[::-1]
+
     def read(self, fn=None, get_elevation=False):
         """
         Read in an edi file and fill attributes of each section's classes.
@@ -419,8 +435,7 @@ class EDI(object):
                         )
                 elif key.startswith("t"):
                     obj[:, ii, jj] = (
-                        data_dict[f"{key}r.exp"]
-                        + data_dict[f"{key}i.exp"] * 1j
+                        data_dict[f"{key}r.exp"] + data_dict[f"{key}i.exp"] * 1j
                     )
                     try:
                         error_key = [
@@ -457,13 +472,8 @@ class EDI(object):
             except KeyError as error:
                 self.logger.debug(error)
         # check for order of frequency, we want high togit  low
-        if self.frequency[0] < self.frequency[1]:
-            self.logger.debug(
-                "Ordered arrays to be arranged from high to low frequency"
-            )
-            self.frequency = self.frequency[::-1]
-            self.z = self.z[::-1]
-            self.z_err = self.z_err[::-1]
+        self._assert_descending_frequency()
+
         try:
             self.rotation_angle = np.array(data_dict["zrot"])
         except KeyError:
@@ -756,10 +766,8 @@ class EDI(object):
             extra_lines.append(
                 f"\toriginal_program.date={self.Header.progdate}\n"
             )
-        if self.Header.fileby != "1980-01-01":
-            extra_lines.append(
-                f"\toriginal_file.date={self.Header.filedate}\n"
-            )
+        if self.Header.filedate != "1980-01-01":
+            extra_lines.append(f"\toriginal_file.date={self.Header.filedate}\n")
         header_lines = self.Header.write_header(
             longitude_format=longitude_format, latlon_format=latlon_format
         )
@@ -907,15 +915,11 @@ class EDI(object):
             ]
         elif data_key.lower() == "freq":
             block_lines = [
-                ">{0} // {1:.0f}\n".format(
-                    data_key.upper(), data_comp_arr.size
-                )
+                ">{0} // {1:.0f}\n".format(data_key.upper(), data_comp_arr.size)
             ]
         elif data_key.lower() in ["zrot", "trot"]:
             block_lines = [
-                ">{0} // {1:.0f}\n".format(
-                    data_key.upper(), data_comp_arr.size
-                )
+                ">{0} // {1:.0f}\n".format(data_key.upper(), data_comp_arr.size)
             ]
         else:
             raise ValueError("Cannot write block for {0}".format(data_key))
@@ -1039,6 +1043,13 @@ class EDI(object):
         if survey.summary != None:
             self.Info.info_list.append(f"survey.summary = {survey.summary}")
 
+        for key in survey.to_dict(single=True).keys():
+            if "northwest" in key or "southeast" in key or "time_period" in key:
+                continue
+            value = survey.get_attr_from_name(key)
+            if value != None:
+                self.Info.info_list.append(f"survey.{key} = {value}")
+
     @property
     def station_metadata(self):
         sm = metadata.Station()
@@ -1192,6 +1203,8 @@ class EDI(object):
         self.Header.datum = sm.location.datum
         self.Header.units = sm.transfer_function.units
         self.Header.enddate = sm.time_period.end
+        if sm.geographic_name is not None:
+            self.Header.loc = sm.geographic_name
 
         ### write notes
         # write comments, which would be anything in the info section from an edi
@@ -1379,3 +1392,11 @@ class EDI(object):
     @property
     def rrhy_metadata(self):
         return self._get_magnetic_metadata("rrhy")
+
+    @property
+    def rrhx_metadata(self):
+        return self._get_magnetic_metadata("rrhx")
+
+    @property
+    def rrhy_metadata(self):
+        return self._get_magnetic_metadata("rrhy")

mt_metadata/transfer_functions/io/edi/metadata/define_measurement.py

@@ -441,6 +441,7 @@ class DefineMeasurement(Base):
                     "chtype": channel.component,
                     "id": channel.channel_id,
                     "acqchan": channel.channel_number,
+                    "dip": channel.measurement_tilt,
                 }
             )
             setattr(self, f"meas_{channel.component.lower()}", meas)

mt_metadata/transfer_functions/io/edi/metadata/emeasurement.py

@@ -17,6 +17,7 @@ from .standards import SCHEMA_FN_PATHS
 # =============================================================================
 attr_dict = get_schema("emeasurement", SCHEMA_FN_PATHS)
 
+
 # ==============================================================================
 # magnetic measurements
 # ==============================================================================
@@ -40,8 +41,9 @@ class EMeasurement(Base):
 
         super().__init__(attr_dict=attr_dict, **kwargs)
 
-        if self.x != 0 or self.y != 0 or self.x2 != 0 or self.y2 != 0:
-            self.azm = self.azimuth
+        if self.azm == 0:
+            if self.x != 0 or self.x2 != 0 or self.y != 0 or self.y2 != 0:
+                self.azm = self.azimuth
 
     def __str__(self):
         return "\n".join(

mt_metadata/transfer_functions/io/edi/metadata/header.py

@@ -213,7 +213,7 @@ class Header(Location):
         self,
         longitude_format="LON",
         latlon_format="dms",
-        required=True,
+        required=False,
     ):
         """
         Write header information to a list of lines.
@@ -243,6 +243,8 @@ class Header(Location):
         for key, value in self.to_dict(single=True, required=required).items():
             if key in ["x", "x2", "y", "y2", "z", "z2"]:
                 continue
+            if value in [None, "None"]:
+                continue
             if key in ["latitude"]:
                 key = "lat"
             elif key in ["longitude"]:

mt_metadata/transfer_functions/io/edi/metadata/information.py

@@ -10,6 +10,7 @@ Created on Sat Dec  4 14:13:37 2021
 from mt_metadata.base import Base
 from mt_metadata.base.helpers import validate_name
 
+
 # ==============================================================================
 # Info object
 # ==============================================================================
@@ -444,11 +445,17 @@ class Information(Base):
                             new_dict[new_key] = value.split()[0]
                         elif key.lower().endswith("sen"):
                             comp = key.lower().split()[0]
-                            new_dict[
-                                f"{comp}.sensor.manufacturer"
-                            ] = "Phoenix Geophysics"
+                            new_dict[f"{comp}.sensor.manufacturer"] = (
+                                "Phoenix Geophysics"
+                            )
                             new_dict[f"{comp}.sensor.type"] = "Induction Coil"
                             new_dict[new_key] = value
+                        elif new_key in [
+                            "survey.time_period.start_date",
+                            "survey.time_period.end_date",
+                        ]:
+                            if value.count("-") == 1:
+                                new_dict[new_key] = value.split("-")[0]
                         else:
                             new_dict[new_key] = value
 
@@ -461,8 +468,8 @@ class Information(Base):
                 new_dict[key] = value
 
         if processing_parameters != []:
-            new_dict[
-                "transfer_function.processing_parameters"
-            ] = processing_parameters
+            new_dict["transfer_function.processing_parameters"] = (
+                processing_parameters
+            )
 
         self.info_dict = new_dict