gmprocess 2.6.0__tar.gz → 2.7.0__tar.gz

{gmprocess-2.6.0 → gmprocess-2.7.0}/.gitignore

@@ -22,3 +22,4 @@ dask-worker-space/
 # Vim tags
 tags
 public
+.vscode/

{gmprocess-2.6.0 → gmprocess-2.7.0}/.vscode/settings.json

@@ -1,4 +1,4 @@
 {
     "python.formatting.provider": "black",
     "editor.formatOnSave": true
-}
+}

{gmprocess-2.6.0 → gmprocess-2.7.0}/CHANGELOG.md

@@ -1,5 +1,24 @@
 ## main
 
+
+## 2.7.0 / 2026-06-04
+
+- Enhancements
+  - Support PSA metric for gmpacket files
+  - Add export_ff_sac script for selecting SAC files for finite fault inversion
+  - Add unit test for export_ff_sac script
+  - Treat an empty location code as the same as "--" when checking for duplicate records
+  - Updated KNET fetcher to use NIED http directory interface
+  - Added unit tests to test V3 cosmos writer (and updated workspace.h5)
+  - Add "count_mean", "count_min", and "count_max" as trace parameters.
+  - Add logging to show query for CESMD fetcher if a timeout occurs
+- Bugfix
+  - Fixed cosmos v3 writer where damping_values was assigned in wrong scope
+  - Fixed cosmos v3 bug with concatenate_channels=False (only one trace got periods)
+  - Set trace warnings and failures for instrument response mismatches between total sensitivity and stages.
+  - Fix station metric bug in imc_sort by forcing waveform metric to match station metric before writing
+  - Fix compute_station_metrics.py to write to station metrics if any stream passed
+
 ## 2.6.0 / 2026-04-20
 
 - Enhancements

{gmprocess-2.6.0 → gmprocess-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gmprocess
-Version: 2.6.0
+Version: 2.7.0
 Summary: USGS Automated Ground Motion Processing Software
 Author-email: Eric Thompson <emthompsone@usgs.gov>, Mike Hearne <mhearne@usgs.gov>, Brad Aagaard <baagaard@usgs.gov>, Bruce Worden <cbworden@contractor.usgs.gov>, John Rekoske <jrekoske@ucsd.edu>, Heather Hunsinger <hhunsinger@usgs.gov>, Gabe Ferragut <gferragut@usgs.gov>
 License: License

{gmprocess-2.6.0 → gmprocess-2.7.0}/code.json

@@ -1,4 +1,45 @@
 [
+    {
+        "name": "groundmotion-processing",
+        "description": "Read and process ground motion waveform data",
+        "version": "v2.7.0",
+        "status": "Production",
+        "organization": "U.S. Geological Survey",
+        "vcs": "git",
+        "repositoryURL": "https://code.usgs.gov/ghsc/esi/groundmotion-processing.git",
+        "homepageURL": "https://code.usgs.gov/ghsc/esi/groundmotion-processing",
+        "downloadURL": "https://code.usgs.gov/ghsc/esi/groundmotion-processing/-/archive/v2.7.0/groundmotion-processing-v2.7.0.zip",
+        "disclaimerURL": "https://code.usgs.gov/ghsc/esi/groundmotion-processing/-/raw/v2.7.0/DISCLAIMER.md",
+        "permissions": {
+            "licenses": [
+                {
+                    "name": "Public Domain, CC0-1.0",
+                    "URL": "https://code.usgs.gov/ghsc/esi/groundmotion-processing/-/raw/v2.7.0/LICENSE.md"
+                }
+            ],
+            "usageType": "openSource",
+            "exemptionText": null
+        },
+        "laborHours": 1,
+        "languages": [
+            "python"
+        ],
+        "tags": [
+            "earthquake",
+            "impact",
+            "strong motion",
+            "amplitudes",
+            "ground motion",
+            "usg-artificial-intelligence"
+        ],
+        "contact": {
+            "name": "Eric Thompson",
+            "email": "emthompson@usgs.gov"
+        },
+        "date": {
+            "metadataLastUpdated": "2026-06-04"
+        }
+    },
     {
         "name": "groundmotion-processing",
         "description": "Read and process ground motion waveform data",

{gmprocess-2.6.0 → gmprocess-2.7.0}/pyproject.toml

@@ -98,6 +98,8 @@ cwa_gather = "gmprocess.bin.cwa_gather:cli"
 fix_inventory = "gmprocess.bin.fix_inventory:main"
 fetch_orfeus = "gmprocess.bin.fetch_orfeus:cli"
 get_cali_cloud = "gmprocess.bin.get_cali_cloud:main"
+export_ff_sac = "gmprocess.bin.export_ff_sac:main"
+
 
 [build-system]
 requires = [

gmprocess-2.7.0/src/gmprocess/bin/export_ff_sac.py

@@ -0,0 +1,315 @@
+"""Export SAC files for finite fault inversion from a gmprocess workspace.h5"""
+
+import argparse
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import numpy as np
+from gmprocess.io.asdf.stream_workspace import StreamWorkspace
+from obspy.geodetics import gps2dist_azimuth
+
+
+def get_parser():
+    parser = argparse.ArgumentParser(
+        description=(
+            "Select a set of stations from a gmprocess workspace"
+            " and export SAC files for finite fault inversion."
+        )
+    )
+    parser.add_argument(
+        "workspace",
+        type=Path,
+        help="Path to the gmprocess workspace HDF5 file (e.g. workspace.h5).",
+    )
+    parser.add_argument(
+        "event_id",
+        help="Event ID as stored in the workspace (e.g. us6000sri7).",
+    )
+    parser.add_argument(
+        "--max-dist",
+        type=float,
+        default=300.0,
+        help="Maximum epicentral distance in km for station inclusion (default: 300).",
+    )
+    parser.add_argument(
+        "--n-max",
+        type=int,
+        default=20,
+        help="Maximum number of stations to select (default: 20).",
+    )
+    parser.add_argument(
+        "--n-lat",
+        type=int,
+        default=5,
+        help="Number of latitude grid rows for spatial sampling (default: 5).",
+    )
+    parser.add_argument(
+        "--n-lon",
+        type=int,
+        default=4,
+        help="Number of longitude grid columns for spatial sampling (default: 4).",
+    )
+    parser.add_argument(
+        "--out-dir",
+        type=Path,
+        default=None,
+        help="Output directory for SAC files (default: <event_id>/).",
+    )
+    parser.add_argument(
+        "--supp-stations",
+        nargs="+",
+        default=[],
+        metavar="STA",
+        help="Additional station IDs to include.",
+    )
+    return parser
+
+
+def collect_stream_data(sc, event):
+    """Extract per-stream arrays of lat, lon, dist, pgv for passing streams.
+
+    Args:
+        sc (StreamCollection): Streams from the workspace.
+        event (ScalarEvent): Event object with latitude and longitude attributes.
+
+    Returns:
+        tuple: lat, lon, dist, pgv (np.ndarray) and passing_indices (list of int).
+    """
+    lat, lon, dist, pgv, passing_indices = [], [], [], [], []
+
+    for i, stream in enumerate(sc):
+        if not stream.passed:
+            continue
+        passing_indices.append(i)
+        trace = stream[0]
+        slat = trace.stats.coordinates.latitude
+        slon = trace.stats.coordinates.longitude
+        lat.append(slat)
+        lon.append(slon)
+        dist.append(
+            gps2dist_azimuth(slat, slon, event.latitude, event.longitude)[0]
+            / 1000.0
+        )
+        pgvs = [
+            np.max(np.abs(tr.copy().integrate().data))
+            for tr in stream
+            if tr.stats.channel[2] != "Z"
+        ]
+        pgv.append(np.max(pgvs) if pgvs else 0.0)
+
+    return (
+        np.array(lat),
+        np.array(lon),
+        np.array(dist),
+        np.array(pgv),
+        passing_indices,
+    )
+
+
+def select_stations(lat, lon, dist, pgv, max_dist, n_max, n_lat, n_lon):
+    """Select a spatially distributed subset of stations ranked by PGV.
+
+    Divides the region into an n_lat x n_lon grid and picks the highest-PGV
+    station from each occupied cell, then fills remaining slots by global PGV
+    rank up to n_max.
+
+    Args:
+        lat (np.ndarray): Station latitudes.
+        lon (np.ndarray): Station longitudes.
+        dist (np.ndarray): Epicentral distances in km.
+        pgv (np.ndarray): Peak ground velocity (horizontal) in m/s.
+        max_dist (float): Distance cutoff in km.
+        n_max (int): Maximum total stations to select.
+        n_lat (int): Number of latitude grid rows.
+        n_lon (int): Number of longitude grid columns.
+
+    Returns:
+        tuple: id_selected (list of int), idx (np.ndarray), lat_bks
+            (np.ndarray), lon_bks (np.ndarray).
+    """
+    idx = np.where(dist < max_dist)[0]
+
+    eps = 1e-6
+    lat_bks = np.linspace(
+        lat[idx].min() - eps, lat[idx].max() + eps, n_lat + 1
+    )
+    lon_bks = np.linspace(
+        lon[idx].min() - eps, lon[idx].max() + eps, n_lon + 1
+    )
+
+    quad_id = np.full(len(dist), -1, dtype=int)
+    for i, (qx, qy) in enumerate(
+        [(x, y) for x in range(n_lon) for y in range(n_lat)]
+    ):
+        q_idx = np.where(
+            (lat[idx] > lat_bks[qy])
+            & (lat[idx] < lat_bks[qy + 1])
+            & (lon[idx] > lon_bks[qx])
+            & (lon[idx] < lon_bks[qx + 1])
+        )[0]
+        if len(q_idx):
+            quad_id[idx[q_idx]] = i
+
+    # Pick highest PGV from each occupied grid cell
+    id_selected = []
+    for qid in range(n_lat * n_lon):
+        idx_quad = np.where(qid == quad_id)[0]
+        if len(idx_quad):
+            id_selected.append(idx_quad[np.argmax(pgv[idx_quad])])
+
+    # Fill remaining slots by global PGV rank
+    if n_max > len(id_selected):
+        n_add = n_max - len(id_selected)
+        idx_rem = np.setdiff1d(idx, id_selected)
+        id_selected.extend(idx_rem[np.flip(np.argsort(pgv[idx_rem]))][:n_add])
+
+    return id_selected, idx, lat_bks, lon_bks
+
+
+def make_sac_headers(channel_code, slat, slon):
+    """Return SAC header dict with cmpaz/cmpinc set for the given channel.
+
+    Args:
+        channel_code (str): Channel code (e.g. HNN, HNE, HNZ).
+        slat (float): Station latitude.
+        slon (float): Station longitude.
+
+    Returns:
+        dict: SAC header dict suitable for assignment to ``trace.stats.sac``.
+    """
+    component = channel_code[2]
+    if component == "Z":
+        cmpinc, cmpaz = 90.0, 0.0
+    else:
+        cmpinc = 0.0
+        cmpaz = 0.0 if component in ("N", "1") else 90.0
+    return {"stla": slat, "stlo": slon, "cmpaz": cmpaz, "cmpinc": cmpinc}
+
+
+def write_sac_files(streams, passing_indices, id_selected, out_dir):
+    """Write SAC files for selected streams to out_dir.
+
+    Args:
+        streams (StreamCollection): Streams from the workspace.
+        passing_indices (list of int): Indices of passing stations.
+        id_selected (list of int): Indices of selected stations.
+        out_dir (Path): Output directory (created if absent).
+    """
+    out_dir.mkdir(parents=True, exist_ok=True)
+    for id_sel in id_selected:
+        stream = streams[passing_indices[id_sel]]
+        for trace in stream:
+            trace.stats.sac = make_sac_headers(
+                trace.stats.channel,
+                trace.stats.coordinates.latitude,
+                trace.stats.coordinates.longitude,
+            )
+            trace.write(
+                filename=str(out_dir / (trace.id + ".SAC")), format="SAC"
+            )
+
+
+def write_supp_sac_files(sc, sta_ids, supp_dir):
+    """Write SAC files for supplemental stations to supp_dir.
+
+    Args:
+        sc (StreamCollection): Streams from the workspace.
+        sta_ids (list of str): Station IDs to include.
+        supp_dir (Path): Output directory for supplemental files (created if absent).
+    """
+    if not sta_ids:
+        return
+    supp_dir.mkdir(parents=True, exist_ok=True)
+    for stream in sc:
+        if stream.passed and stream[0].stats.station in sta_ids:
+            for trace in stream:
+                trace.stats.sac = make_sac_headers(
+                    trace.stats.channel,
+                    trace.stats.coordinates.latitude,
+                    trace.stats.coordinates.longitude,
+                )
+                trace.write(
+                    filename=str(supp_dir / (trace.id + ".SAC")), format="SAC"
+                )
+    print(f"Wrote supplemental stations to {supp_dir}/")
+
+
+def save_summary_plot(
+    lat, lon, idx, id_selected, lat_bks, lon_bks, event, eqid, outdir
+):
+    """Save a map of candidate and selected stations.
+
+    Args:
+        lat (np.ndarray): Station latitudes for all passing streams.
+        lon (np.ndarray): Station longitudes for all passing streams.
+        idx (np.ndarray): Indices of candidate stations within the distance cutoff.
+        id_selected (list of int): Indices of the selected stations.
+        lat_bks (np.ndarray): Latitude grid breakpoints.
+        lon_bks (np.ndarray): Longitude grid breakpoints.
+        event (ScalarEvent): Event object providing epicenter coordinates.
+        eqid (str): Event ID used to construct the output filename.
+    """
+    fig, ax = plt.subplots()
+    ax.plot(lon[idx], lat[idx], "vk", label="Candidate")
+    for lb in lon_bks:
+        ax.axvline(x=lb, color="gray", linewidth=0.5)
+    for lb in lat_bks:
+        ax.axhline(y=lb, color="gray", linewidth=0.5)
+    ax.plot(lon[id_selected], lat[id_selected], "vg", label="Selected")
+    ax.plot(
+        event.longitude, event.latitude, "*r", markersize=12, label="Epicenter"
+    )
+    ax.set_xlabel("Longitude")
+    ax.set_ylabel("Latitude")
+    ax.legend()
+    fname = Path(outdir) / f"{eqid}_select_summary.png"
+    fig.savefig(fname, dpi=300)
+    plt.close(fig)
+    print(f"Wrote summary plot: {fname}")
+
+
+def main():
+    parser = get_parser()
+    args = parser.parse_args()
+
+    sw = StreamWorkspace.open(args.workspace)
+    sc = sw.get_streams(args.event_id, labels=["default"])
+    event = sw.get_event(args.event_id)
+
+    lat, lon, dist, pgv, passing_indices = collect_stream_data(sc, event)
+
+    if len(lat) == 0:
+        print("No passing streams found in workspace. Exiting.")
+        return
+
+    id_selected, idx, lat_bks, lon_bks = select_stations(
+        lat,
+        lon,
+        dist,
+        pgv,
+        max_dist=args.max_dist,
+        n_max=args.n_max,
+        n_lat=args.n_lat,
+        n_lon=args.n_lon,
+    )
+    out_dir = args.out_dir if args.out_dir is not None else Path(event.id)
+    save_summary_plot(
+        lat,
+        lon,
+        idx,
+        id_selected,
+        lat_bks,
+        lon_bks,
+        event,
+        args.event_id,
+        out_dir,
+    )
+
+    write_sac_files(sc, passing_indices, id_selected, out_dir)
+    print(f"Wrote {len(id_selected)} stations to {out_dir}/")
+
+    write_supp_sac_files(sc, args.supp_stations, out_dir / "supp")
+
+
+if __name__ == "__main__":
+    main()

{gmprocess-2.6.0 → gmprocess-2.7.0}/src/gmprocess/core/stationstream.py

@@ -1,4 +1,4 @@
-"""Module for the StationStream classs."""
+"""Module for the StationStream class."""
 
 # stdlib imports
 import logging
@@ -225,7 +225,9 @@ class StationStream(Stream):
             all_codes = []
             for tr in self:
                 stats = tr.stats
-                all_codes.append(f"{stats.network}.{stats.station}.{stats.location}.{stats.channel}")
+                all_codes.append(
+                    f"{stats.network}.{stats.station}.{stats.location}.{stats.channel}"
+                )
             if len(set(all_codes)) != len(all_codes):
                 for tr in self:
                     tr.fail("Nonunique channel code in StationStream.")
@@ -236,40 +238,50 @@ class StationStream(Stream):
             use_array = hasattr(self, "use_array") and self.use_array
             stats = self[0].stats
             if use_array:
-                id_str = ".".join([
-                    stats.network,
-                    stats.station,
-                    stats.location,
-                    stats.channel,
-                ])
-            else:
-                id_str = ".".join([
-                    stats.network,
-                    stats.station,
-                    stats.location,
-                    stats.channel[0:2],
-                ])
-
-            # Check that the id would be the same for all traces
-            for tr in self: # Use self to avoid creating temporary object
-                stats = tr.stats
-                if use_array:
-                    test_str = ".".join([
+                id_str = ".".join(
+                    [
                         stats.network,
                         stats.station,
                         stats.location,
                         stats.channel,
-                    ])
-                else:
-                    test_str = ".".join([
+                    ]
+                )
+            else:
+                id_str = ".".join(
+                    [
                         stats.network,
                         stats.station,
                         stats.location,
                         stats.channel[0:2],
-                    ])
+                    ]
+                )
+
+            # Check that the id would be the same for all traces
+            for tr in self:  # Use self to avoid creating temporary object
+                stats = tr.stats
+                if use_array:
+                    test_str = ".".join(
+                        [
+                            stats.network,
+                            stats.station,
+                            stats.location,
+                            stats.channel,
+                        ]
+                    )
+                else:
+                    test_str = ".".join(
+                        [
+                            stats.network,
+                            stats.station,
+                            stats.location,
+                            stats.channel[0:2],
+                        ]
+                    )
 
                 if id_str != test_str:
-                    raise ValueError(f"Inconsistent stream IDs {id_str} and {test_str} for different traces.")
+                    raise ValueError(
+                        f"Inconsistent stream IDs {id_str} and {test_str} for different traces."
+                    )
             self.id = id_str
 
     def get_id(self):

{gmprocess-2.6.0 → gmprocess-2.7.0}/src/gmprocess/core/streamcollection.py

@@ -636,6 +636,7 @@ def are_duplicates(tr1, tr2, max_dist_tolerance):
     Returns:
         bool. True if traces are duplicates, False otherwise.
     """
+    # Need to simplify the use of 1/2 vs N/E
     orientation_codes = set()
     for tr in [tr1, tr2]:
         if tr.stats.channel[2] in ["1", "N"]:
@@ -645,9 +646,14 @@ def are_duplicates(tr1, tr2, max_dist_tolerance):
         else:
             orientation_codes.add("Z")
 
+    # Replace "--" with "" due to inconsistent use despite meaning the same thing
+    loc_codes = [tr1.stats.location, tr2.stats.location]
+    loc_codes = set([c.replace("--", "") for c in loc_codes])
+
     # First, check if the ids match (net.sta.loc.cha)
     if tr1.id[:-1] == tr2.id[:-1] and len(orientation_codes) == 1:
         return True
+
     # If not matching IDs, check the station, instrument code, and distance
     else:
         distance = gps2dist_azimuth(
@@ -659,7 +665,7 @@ def are_duplicates(tr1, tr2, max_dist_tolerance):
         if (
             tr1.stats.station == tr2.stats.station
             and tr1.stats.channel[:2] == tr2.stats.channel[:2]
-            and tr1.stats.location == tr2.stats.location
+            and len(loc_codes) == 1
             and len(orientation_codes) == 1
             and distance < max_dist_tolerance
         ):

{gmprocess-2.6.0 → gmprocess-2.7.0}/src/gmprocess/io/asdf/flatfile.py

@@ -81,12 +81,24 @@ class Flatfile(object):
 
         wmc = WaveformMetricCollection.from_workspace(self.workspace, self.label)
         smc = StationMetricCollection.from_workspace(self.workspace)
-        for wml, stream_meta, station_metrics in zip(
-            wmc.waveform_metrics, wmc.stream_metadata, smc.station_metrics
-        ):
+
+        # Use dictionary to ensure each waveform metric has associated station metric
+        sm_dict = {}
+        for sm_path, sm in zip(smc.stream_paths, smc.station_metrics):
+            net_sta = ".".join(sm_path.split(".")[:3])
+            sm_dict[net_sta] = sm
+
+        for wml, stream_meta in zip(wmc.waveform_metrics, wmc.stream_metadata):
             if not wml.metric_list:
                 continue
 
+            tr_met = stream_meta[0]
+            sta_id = f"{tr_met['network']}.{tr_met['station']}.{tr_met['location']}"
+            station_metrics = sm_dict.get(sta_id)
+            if station_metrics is None:
+                logging.warning("No station metrics found for %s; skipping.", sta_id)
+                continue
+
             self._station_metrics = station_metrics
             passed_traces = [tr_met for tr_met in stream_meta if tr_met["passed"]]
             n_total = len(stream_meta)
@@ -177,6 +189,9 @@ class Flatfile(object):
             "StationElevation": trace_meta["elevation"],
             "SamplingRate": trace_meta["sampling_rate"],
             "SourceFile": source_file,
+            "CountMean": trace_meta.get("count_mean", None),
+            "CountMin": trace_meta.get("count_min", None),
+            "CountMax": trace_meta.get("count_max", None),
         }
 
     def get_sta_dict(self):

{gmprocess-2.6.0 → gmprocess-2.7.0}/src/gmprocess/io/asdf/flatfile_constants.py

@@ -66,6 +66,9 @@ FLATFILE_COLUMNS = {
     "ZLowpass": "Vertical channel lowpass frequency (Hz)",
     "ZHighpass": "Vertical channel highpass frequency (Hz)",
     "SourceFile": "Source file",
+    "CountMean": "Mean of raw counts (if available)",
+    "CountMin": "Minimum of raw counts (if available)",
+    "CountMax": "Maximum of raw counts (if available)",
 }
 
 FLATFILE_IMT_COLUMNS = {

{gmprocess-2.6.0 → gmprocess-2.7.0}/src/gmprocess/io/cosmos/cesmd_fetcher.py

@@ -148,6 +148,10 @@ class CESMDFetcher(DataFetcher):
                 raise Exception(fmt)
 
         if email == "EMAIL":
+            logging.warning(
+                "CESMDFetcher: email is still the placeholder 'EMAIL'; "
+                "CESMD will be skipped."
+            )
             fmt = (
                 "Email address is required to retrieve CESMD\n"
                 "data. This tool can download data from the CESMD\n"
@@ -197,6 +201,13 @@ class CESMDFetcher(DataFetcher):
                   - depth Event depth
                   - mag Event magnitude
         """
+        logging.info(
+            "CESMDFetcher: querying metadata (lat=%s, lon=%s, time=%s, "
+            "eq_radius=%s km, eq_dt=%s s, station_radius=%s km, "
+            "station_type=%s)",
+            self.lat, self.lon, self.time, self.radius, self.dt,
+            self.station_radius, self.station_type,
+        )
         try:
             metadata = get_metadata(
                 eqlat=self.lat,
@@ -208,7 +219,9 @@ class CESMDFetcher(DataFetcher):
                 eqradius=self.radius,  # km
                 station_radius=self.station_radius,
             )
-        except BaseException:
+        except BaseException as ex:
+            logging.warning("CESMDFetcher: metadata query failed: %r", ex)
+            logging.debug("CESMDFetcher metadata traceback:", exc_info=True)
             return []
 
         tmp_events = metadata["results"]["events"]

{gmprocess-2.6.0 → gmprocess-2.7.0}/src/gmprocess/io/cosmos/cosmos_writer.py

@@ -886,7 +886,7 @@ class CosmosWriter(object):
             elif self.volume == Volume.SPECTRA:
                 extension = "v3"
                 self.wmc = WaveformMetricCollection.from_workspace(
-                    self._workspace, "default"
+                    self._workspace, self._label
                 )
             for station_id in station_list:
                 streams = self._workspace.get_streams(
@@ -1042,11 +1042,11 @@ class CosmosWriter(object):
         return (files, nevents, nstreams, ntraces)
 
     def _write_spectra(self):
-        if self.trace_idx == 0:
+        mconf = self._workspace.config["metrics"]
+        damping_values = mconf["type_parameters"]["sa"]["damping"]
+        self.periods = mconf["type_parameters"]["sa"]["periods"]
+        if self.trace_idx == 0 or not self._concatenate_channels:
             self._write_data(self.cosmos_file, self.trace)
-            mconf = self._workspace.config["metrics"]
-            damping_values = mconf["type_parameters"]["sa"]["damping"]
-            self.periods = mconf["type_parameters"]["sa"]["periods"]
             self.cosmos_file.write(
                 f"{len(damping_values)} damping values for which spectra are "
                 f"computed:{damping_values}\n"

{gmprocess-2.6.0 → gmprocess-2.7.0}/src/gmprocess/io/global_fetcher.py

@@ -5,14 +5,14 @@ import logging
 import pathlib
 
 import numpy as np
+from gmprocess.io.dynamic_search_parameters import SearchParameters
+from gmprocess.io.utils import _walk
+from gmprocess.utils.config import get_config
 
 from obspy.geodetics import kilometers2degrees
 
 # local imports
 from .fetcher import DataFetcher
-from gmprocess.utils.config import get_config
-from gmprocess.io.utils import _walk
-from gmprocess.io.dynamic_search_parameters import SearchParameters
 
 FETCHER_DIRS = [
     "cosmos",
@@ -172,7 +172,9 @@ def find_fetchers(lat, lon):
                 fetcher_mod = cfile
                 break
         idx = max(
-            loc for loc, val in enumerate(fetcher_mod.parts) if val == "gmprocess"
+            loc
+            for loc, val in enumerate(fetcher_mod.parts)
+            if val == "gmprocess"
         )
         mod_tuple = fetcher_mod.parts[idx:]
         mod_name = ".".join(mod_tuple)