requake 0.7.3__tar.gz → 0.8__tar.gz

{requake-0.7.3 → requake-0.8}/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 Copyright (c) 2021-2026 Claudio Satriano <satriano@ipgp.fr>
 
+## [0.8] - 2026-05-22
+
+This release introduces a major storage change.
+
+Requake now stores scan-related data (catalog, event pairs, and families) in a
+SQLite database instead of CSV files. This improves storage efficiency and
+data access performance, especially for large catalogs.
+
+This change is not backward compatible at the data format level. The
+high-level behavior of the command-line interface remains unchanged.
+
 ## [0.7.3] - 2026-04-14
 
 This release is intended to validate the new release workflow.
@@ -140,6 +151,7 @@ Mostly a bugfix release with a slightly improved trace plotting.
 
 - Initial release, not yet feature complete
 
+[0.8]: https://github.com/SeismicSource/requake/compare/v0.7.3...v0.8
 [0.7.3]: https://github.com/SeismicSource/requake/compare/v0.7.2...v0.7.3
 [0.7.2]: https://github.com/SeismicSource/requake/compare/v0.7.1...v0.7.2
 [0.7.1]: https://github.com/SeismicSource/requake/compare/v0.7...v0.7.1

{requake-0.7.3 → requake-0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: requake
-Version: 0.7.3
+Version: 0.8
 Summary: Repeating earthquakes search and analysis
 Author-email: Claudio Satriano <satriano@ipgp.fr>
 License-Expression: GPL-3.0-or-later
@@ -37,7 +37,7 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: license-file
 
-<img src="https://cdn.jsdelivr.net/gh/SeismicSource/requake@5d538bf0991032045ae581e62eef887b54cdfa16/imgs/Requake_logo.svg" width="400">
+<img src="https://cdn.jsdelivr.net/gh/SeismicSource/requake@e3ac4cce14f782d62a5f22f432a5391a2ccacfe7/imgs/Requake_logo.svg" width="400">
 
 # Requake
 
@@ -140,6 +140,15 @@ You can keep your local Requake repository updated by running `git pull`
 from times to times. Thanks to `pip`'s "editable mode", you don't need to
 reinstall Requake after each update.
 
+If you want the repository style rules to run locally before each commit,
+enable the included git hook once per clone:
+
+    scripts/setup_local_hooks.sh
+
+You can also run the local style checks manually with:
+
+    scripts/check_style.sh
+
 ## Running
 
 ### Command line arguments

{requake-0.7.3 → requake-0.8}/README.md

@@ -101,6 +101,15 @@ You can keep your local Requake repository updated by running `git pull`
 from times to times. Thanks to `pip`'s "editable mode", you don't need to
 reinstall Requake after each update.
 
+If you want the repository style rules to run locally before each commit,
+enable the included git hook once per clone:
+
+    scripts/setup_local_hooks.sh
+
+You can also run the local style checks manually with:
+
+    scripts/check_style.sh
+
 ## Running
 
 ### Command line arguments

{requake-0.7.3 → requake-0.8}/requake/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2026-04-14T10:01:43+0200",
+ "date": "2026-05-22T08:53:09+0200",
  "dirty": false,
  "error": null,
- "full-revisionid": "5d538bf0991032045ae581e62eef887b54cdfa16",
- "version": "0.7.3"
+ "full-revisionid": "e3ac4cce14f782d62a5f22f432a5391a2ccacfe7",
+ "version": "0.8"
 }
 '''  # END VERSION_JSON
 

{requake-0.7.3 → requake-0.8}/requake/catalog/catalog.py

@@ -28,6 +28,7 @@ class RequakeEvent():
                  depth=None, mag_type=None, mag=None, author=None,
                  catalog=None, contributor=None, contributor_id=None,
                  mag_author=None, location_name=None, trace_id=None):
+        """Initialize an event container."""
         self.evid = evid
         self.orig_time = orig_time
         self.lon = lon
@@ -45,24 +46,31 @@ class RequakeEvent():
         self.correlations = {}
 
     def __eq__(self, other):
+        """Return True when two events have the same identity."""
         return self.evid == other.evid and self.trace_id == other.trace_id
 
     def __gt__(self, other):
+        """Compare events by origin time."""
         return self.orig_time > other.orig_time
 
     def __ge__(self, other):
+        """Compare events by origin time."""
         return self.orig_time >= other.orig_time
 
     def __lt__(self, other):
+        """Compare events by origin time."""
         return self.orig_time < other.orig_time
 
     def __le__(self, other):
+        """Compare events by origin time."""
         return self.orig_time <= other.orig_time
 
     def __hash__(self):
+        """Return the event hash."""
         return self.evid.__hash__()
 
     def __str__(self):
+        """Return a compact string representation of the event."""
         return (
             f'{self.evid} {self.orig_time} '
             f'{self.lon} {self.lat} {self.depth} {self.mag_type} {self.mag}'
@@ -148,46 +156,12 @@ class RequakeCatalog(list):
         """
         self[:] = sorted(self, key=lambda ev: ev.orig_time)
 
-    def read(self, filename):
-        """
-        Read catalog from FDSN text file format.
-
-        Skips events already in the catalog.
-
-        :param filename: input filename
-        :type filename: str
-
-        :raises FileNotFoundError: if filename does not exist
-        :raises ValueError: if line is not in FDSN text file format
-        """
-        with open(filename, 'r', encoding='utf8') as fp:
-            for line in fp:
-                if not line:
-                    continue
-                if line[0] == '#':
-                    continue
-                ev = RequakeEvent()
-                ev.from_fdsn_text(line)
-                self.append(ev)
-        self.deduplicate()
-
-    def write(self, filename):
-        """
-        Write catalog in FDSN text file format.
-
-        :param filename: output filename
-        :type filename: str
-        """
-        with open(filename, 'w', encoding='utf8') as fp:
-            for ev in self:
-                fp.write(ev.fdsn_text() + '\n')
-
     def filter(
-            self, starttime=None, endtime=None,
-            minlatitude=None, maxlatitude=None,
-            minlongitude=None, maxlongitude=None,
-            mindepth=None, maxdepth=None,
-            minmagnitude=None, maxmagnitude=None
+        self, starttime=None, endtime=None,
+        minlatitude=None, maxlatitude=None,
+        minlongitude=None, maxlongitude=None,
+        mindepth=None, maxdepth=None,
+        minmagnitude=None, maxmagnitude=None
     ):
         """
         Filter the catalog, based on the specified criteria.
@@ -220,60 +194,47 @@ class RequakeCatalog(list):
         """
         outcat = RequakeCatalog()
         for ev in self:
-            if ev.orig_time is not None:
-                if starttime is not None and ev.orig_time < starttime:
-                    continue
-                if endtime is not None and ev.orig_time > endtime:
-                    continue
-            if ev.lat is not None:
-                if minlatitude is not None and ev.lat < minlatitude:
-                    continue
-                if maxlatitude is not None and ev.lat > maxlatitude:
-                    continue
-            if ev.lon is not None:
-                if minlongitude is not None and ev.lon < minlongitude:
-                    continue
-                if maxlongitude is not None and ev.lon > maxlongitude:
-                    continue
-            if ev.depth is not None:
-                if mindepth is not None and ev.depth < mindepth:
-                    continue
-                if maxdepth is not None and ev.depth > maxdepth:
-                    continue
-            if ev.mag is not None:
-                if minmagnitude is not None and ev.mag < minmagnitude:
-                    continue
-                if maxmagnitude is not None and ev.mag > maxmagnitude:
-                    continue
+            if _out_of_range(ev.orig_time, starttime, endtime):
+                continue
+            if _out_of_range(ev.lat, minlatitude, maxlatitude):
+                continue
+            if _out_of_range(ev.lon, minlongitude, maxlongitude):
+                continue
+            if _out_of_range(ev.depth, mindepth, maxdepth):
+                continue
+            if _out_of_range(ev.mag, minmagnitude, maxmagnitude):
+                continue
             outcat.append(ev)
         return outcat
 
 
+def _out_of_range(value, minimum, maximum):
+    """Return True when a value falls outside the requested bounds."""
+    if value is None:
+        return False
+    return (
+        (minimum is not None and value < minimum)
+        or (maximum is not None and value > maximum)
+    )
+
+
 def read_stored_catalog():
     """
-    Read the catalog stored in the output directory.
+    Read the catalog stored in the output database.
 
     :return: Catalog object.
     :rtype: RequakeCatalog
 
-    :raises ValueError: if error reading catalog file
-    :raises FileNotFoundError: if catalog file not found
+    :raises ValueError: if the stored catalog is empty
+    :raises FileNotFoundError: if the output database is not found
     """
-    try:
-        cat = RequakeCatalog()
-        cat.read(config.scan_catalog_file)
-        cat.sort()
-        if not cat:
-            raise ValueError('Empty catalog')
-        return cat
-    except ValueError as err:
-        raise ValueError(
-            f'Error reading catalog file {config.scan_catalog_file}: {err}'
-        ) from err
-    except (FileNotFoundError, NotADirectoryError) as err:
-        raise FileNotFoundError(
-            f'Catalog file {config.scan_catalog_file} not found'
-        ) from err
+    from ..database.catalog import read_catalog as read_catalog_from_db
+
+    cat = read_catalog_from_db(config)
+    cat.sort()
+    if not cat:
+        raise ValueError('Empty catalog')
+    return cat
 
 
 def fix_non_locatable_events(catalog):
@@ -308,9 +269,9 @@ def _base26(val):
     :rtype: str
     """
     chars = [
-      'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
-      'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
-      'u', 'v', 'w', 'x', 'y', 'z'
+        'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
+        'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
+        'u', 'v', 'w', 'x', 'y', 'z'
     ]
     base = len(chars)
     ret = ''
@@ -337,7 +298,7 @@ def generate_evid(orig_time):
     orig_year = UTCDateTime(year=year, month=1, day=1)
     val = int(orig_time - orig_year)
     # normalize val between 0 (aaaaaa) and 26**6-1 (zzzzzz)
-    maxval = 366*24*3600  # max number of seconds in leap year
-    normval = int(val/maxval * (26**6-1))
+    maxval = 366 * 24 * 3600  # max number of seconds in leap year
+    normval = int(val / maxval * (26 ** 6 - 1))
     ret = _base26(normval)
     return f'{prefix}{year}{ret}'

{requake-0.7.3 → requake-0.8}/requake/catalog/print_catalog.py

@@ -16,9 +16,7 @@ logger = logging.getLogger(__name__.rsplit('.', maxsplit=1)[-1])
 
 
 def print_catalog():
-    """
-    Print the event catalog to screen.
-    """
+    """Print the event catalog to screen."""
     try:
         catalog = read_stored_catalog()
     except (ValueError, FileNotFoundError) as msg:

{requake-0.7.3 → requake-0.8}/requake/catalog/read_catalog.py

@@ -13,7 +13,9 @@ import os
 import logging
 import contextlib
 from ..config import config, rq_exit
-from .catalog import RequakeCatalog
+from ..database.db import get_db_path
+from ..database.catalog import write_catalog as write_stored_catalog
+from .catalog import RequakeEvent, RequakeCatalog
 from .read_catalog_from_fdsnws import read_catalog_from_fdsnws
 from .read_catalog_from_quakeml import read_catalog_from_quakeml
 from .read_catalog_from_csv import read_catalog_from_csv
@@ -45,7 +47,16 @@ def _read_catalog_from_file():
     # try to read the catalog as a FDSN text file
     with contextlib.suppress(ValueError):
         cat = RequakeCatalog()
-        cat.read(catalog_file)
+        with open(catalog_file, 'r', encoding='utf8') as fp:
+            for line in fp:
+                if not line:
+                    continue
+                if line[0] == '#':
+                    continue
+                ev = RequakeEvent()
+                ev.from_fdsn_text(line)
+                cat.append(ev)
+        cat.deduplicate()
         return cat
     # try to read the catalog as a CSV file
     # raises ValueError in case of failure
@@ -54,8 +65,7 @@ def _read_catalog_from_file():
 
 def _filter_catalog(catalog):
     """
-    Filter an event catalog, based on the criteria specified
-    in the configuration.
+    Filter an event catalog using the configured selection criteria.
 
     :param catalog: Event catalog.
     :type catalog: requake.catalog.RequakeCatalog
@@ -99,14 +109,17 @@ def read_catalog():
     :rtype: requake.catalog.RequakeCatalog
     """
     catalog = RequakeCatalog()
-    output_cat_file = config.scan_catalog_file
     nevs_read = 0
     if config.args.append:
         with contextlib.suppress(FileNotFoundError):
-            catalog = RequakeCatalog()
-            catalog.read(output_cat_file)
+            from .catalog import read_stored_catalog
+
+            catalog = read_stored_catalog()
             nevs_read = len(catalog)
-            logger.info(f'{nevs_read} events read from "{output_cat_file}"')
+            logger.info(
+                f'{nevs_read} events read from db file '
+                f'{get_db_path(config)}'
+            )
     logger.info('Reading catalog...')
     input_cat_file = config.args.catalog_file
     if input_cat_file is not None:
@@ -136,7 +149,10 @@ def read_catalog():
         logger.info(f'{nevs_dedup} duplicate events removed')
     # Sort catalog in increasing time order
     catalog.sort()
-    # Write catalog to output file
-    catalog.write(output_cat_file)
+    # Write catalog to the output database
+    write_stored_catalog(catalog, config)
     nevs_written = len(catalog) - nevs_read
-    logger.info(f'{nevs_written} events written to "{output_cat_file}"')
+    logger.info(
+        f'{nevs_written} events written to db file '
+        f'{get_db_path(config)}'
+    )

{requake-0.7.3 → requake-0.8}/requake/catalog/read_catalog_from_csv.py

@@ -19,8 +19,7 @@ logger = logging.getLogger(__name__.rsplit('.', maxsplit=1)[-1])
 
 def _guess_field_names(input_fields):
     """
-    Guess the field names corresponding to origin time, latitude, longitude,
-    depth, magnitude and magnitude type.
+    Guess field names for origin time, location, depth, and magnitude.
 
     :param input_fields: list of field names
     :type input_fields: list of str
@@ -80,9 +79,8 @@ def _guess_field_names(input_fields):
     # make a list of duplicated fields, which have been matched more than once
     duplicated_fields = [
         (key, value, output_field_scores[key])
-        for key, value in output_fields.items() if
-        value is not None and
-        list(output_fields.values()).count(value) > 1
+        for key, value in output_fields.items()
+        if value is not None and list(output_fields.values()).count(value) > 1
     ]
     # if there are duplicated fields, keep the one with the highest score
     for _key, value, score in duplicated_fields:
@@ -167,7 +165,7 @@ def read_catalog_from_csv(filename):
         nrows -= 1  # first row is the header
         cat = RequakeCatalog()
         for n, row in enumerate(reader):
-            print(f'reading row {n+1}/{nrows}\r', end='')
+            print(f'reading row {n + 1}/{nrows}\r', end='')
             if fields['orig_time'] is None:
                 # try build a date-time field from year, month, day, hour,
                 # minute and seconds fields
@@ -195,7 +193,7 @@ def read_catalog_from_csv(filename):
                         )
                     except ValueError:
                         logger.error(
-                            f'Unable to parse origin time at row {n+2}: '
+                            f'Unable to parse origin time at row {n + 2}: '
                             f'"{orig_time_str}"')
                         continue
             row[None] = None

{requake-0.7.3 → requake-0.8}/requake/config/__init__.py

@@ -14,4 +14,8 @@ from .generic_printer import generic_printer  # noqa
 # The config object is created in config.py and needs to be populated
 # when using requake from command line, this is done by the configure()
 # function in rq_setup.py
-from .config import config  # noqa
+from .config import (  # noqa
+    config,
+    to_picklable_config_dict,
+    from_picklable_config_dict,
+)

requake-0.8/requake/config/config.py

@@ -0,0 +1,125 @@
+# -*- coding: utf8 -*-
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""
+Config class for Requake.
+
+:copyright:
+    2021-2026 Claudio Satriano <satriano@ipgp.fr>
+:license:
+    GNU General Public License v3.0 or later
+    (https://www.gnu.org/licenses/gpl-3.0-standalone.html)
+"""
+from argparse import Namespace
+
+
+# Runtime objects that are useful in-process but should not be sent to
+# worker processes via ProcessPoolExecutor.
+RUNTIME_ONLY_KEYS = frozenset({
+    'station_client',
+    'dataselect_client',
+    'catalog_fdsn_event_clients',
+})
+
+
+class Config(dict):
+    """A class to access config values with dot notation."""
+
+    def __setitem__(self, key, value):
+        """Make Config keys accessible as attributes."""
+        super().__setattr__(key, value)
+        super().__setitem__(key, value)
+
+    def __getattr__(self, key):
+        """Make Config keys accessible as attributes."""
+        try:
+            return self.__getitem__(key)
+        except KeyError as err:
+            raise AttributeError(err) from err
+
+    __setattr__ = __setitem__
+
+
+def to_picklable_config_dict(
+    cfg,
+    drop_inventory=False,
+    extra_excluded_keys=None,
+):
+    """
+    Build a pickle-safe config snapshot for multiprocessing.
+
+    This helper strips known runtime-only objects (for example ObsPy clients
+    containing SSL contexts) and converts ``args`` from ``argparse.Namespace``
+    to a plain ``dict``.
+
+    Typical usage with ``concurrent.futures.ProcessPoolExecutor``::
+
+        from concurrent.futures import ProcessPoolExecutor
+        from requake.config import (
+            config,
+            to_picklable_config_dict,
+            from_picklable_config_dict,
+        )
+
+        cfg_dict = to_picklable_config_dict(config)
+
+        def worker(cfg_dict, event_id):
+            cfg = from_picklable_config_dict(cfg_dict)
+            # Rebuild only what is needed in each process.
+            # Re-create network clients here, not in the parent process.
+            return cfg['cc_min'], event_id
+
+        def _worker_call(args):
+            cfg, evid = args
+            return worker(cfg, evid)
+
+        with ProcessPoolExecutor() as pool:
+            worker_args = ((cfg_dict, evid) for evid in event_ids)
+            list(pool.map(_worker_call, worker_args))
+
+    :param cfg: Requake config-like mapping.
+    :type cfg: Mapping
+    :param drop_inventory: Exclude ``inventory`` from the snapshot.
+    :type drop_inventory: bool
+    :param extra_excluded_keys: Additional keys to remove from the snapshot.
+    :type extra_excluded_keys: iterable or None
+    :return: A pickle-safe shallow copy of the configuration.
+    :rtype: dict
+    """
+    cfg_dict = dict(cfg)
+    excluded_keys = set(RUNTIME_ONLY_KEYS)
+    if drop_inventory:
+        excluded_keys.add('inventory')
+    if extra_excluded_keys is not None:
+        excluded_keys.update(extra_excluded_keys)
+    for key in excluded_keys:
+        cfg_dict.pop(key, None)
+
+    args = cfg_dict.get('args')
+    if isinstance(args, Namespace):
+        cfg_dict['args'] = vars(args).copy()
+
+    return cfg_dict
+
+
+def from_picklable_config_dict(cfg_dict):
+    """
+    Rebuild a ``Config`` instance from a pickle-safe snapshot.
+
+    This helper is the counterpart of ``to_picklable_config_dict()`` and is
+    intended for worker processes receiving a serialized config payload.
+
+    If ``args`` is a dict, it is converted back to ``argparse.Namespace``.
+
+    :param cfg_dict: Pickle-safe config snapshot.
+    :type cfg_dict: Mapping
+    :return: Reconstructed config object.
+    :rtype: Config
+    """
+    cfg = Config()
+    cfg.update(dict(cfg_dict))
+    args = cfg.get('args')
+    if isinstance(args, dict):
+        cfg['args'] = Namespace(**args)
+    return cfg
+
+config = Config()  # noqa

requake-0.8/requake/config/configobj/_version.py

@@ -0,0 +1,6 @@
+"""Project version.
+
+Copyright (C) 2005-2014 ConfigObj contributors.
+Licensed under BSD-3-Clause.
+"""
+__version__ = '5.1.0'

{requake-0.7.3 → requake-0.8}/requake/config/generic_printer.py

@@ -21,7 +21,7 @@ logger = logging.getLogger(__name__.rsplit('.', maxsplit=1)[-1])
 
 def generic_printer(rows, headers_fmt, print_headers=True):
     """
-    A generic printer function for Requake.
+    Print rows using the configured output format.
 
     :param rows: Rows to print.
     :type rows: list of rows

{requake-0.7.3 → requake-0.8}/requake/config/parse_arguments.py

@@ -18,9 +18,8 @@ from .._version import get_versions
 
 
 class NewlineHelpFormatter(argparse.HelpFormatter):
-    """
-    Custom help formatter that preserves newlines in help messages.
-    """
+    """Custom help formatter that preserves newlines in help messages."""
+
     def _split_lines(self, text, width):
         lines = []
         for line in text.splitlines():  # Split the text by newlines first
@@ -36,11 +35,11 @@ class NewlineHelpFormatter(argparse.HelpFormatter):
 
 class SubcommandHelpFormatter(argparse.RawDescriptionHelpFormatter):
     """
-    Custom help formatter that removes the list of subcommands from the help
-    message.
+    Custom help formatter that removes the subcommand list from help.
 
     See: https://stackoverflow.com/a/13429281/2021880
     """
+
     def _format_action(self, action):
         parts = super(
             argparse.RawDescriptionHelpFormatter, self
@@ -130,7 +129,7 @@ def parse_arguments(progname='requake'):
             '- CSV\n'
             '- Space-separated text files.\n\n'
             'For CSV or space-separated formats, the file must include '
-            'at least one column for the event\'s origin time '
+            "at least one column for the event's origin time "
             'and may contain additional columns for event ID, longitude, '
             'latitude, depth, and magnitude. Column names '
             'must be specified in the first row.\n\n'
@@ -472,8 +471,8 @@ def parse_arguments(progname='requake'):
         pass
     except ValueError:
         sys.stderr.write(
-            f"{progname} {args.action}: "
-            "error: argument -l/--longerthan: "
+            f'{progname} {args.action}: '
+            'error: argument -l/--longerthan: '
             f"invalid value: '{args.longerthan}'\n"
         )
         sys.exit(2)
@@ -483,8 +482,8 @@ def parse_arguments(progname='requake'):
         pass
     except ValueError:
         sys.stderr.write(
-            f"{progname} {args.action}: "
-            "error: argument -S/--shorterthan: "
+            f'{progname} {args.action}: '
+            'error: argument -S/--shorterthan: '
             f"invalid value: '{args.shorterthan}'\n"
         )
         sys.exit(2)
@@ -513,13 +512,13 @@ def _timespec_to_sec(timespec):
     elif suffix == 'm':
         time_in_seconds *= 60
     elif suffix == 'h':
-        time_in_seconds *= 24*60
+        time_in_seconds *= 24 * 60
     elif suffix == 'd':
-        time_in_seconds *= 24*60*60
+        time_in_seconds *= 24 * 60 * 60
     elif suffix == 'M':
-        time_in_seconds *= 30*24*60*60
+        time_in_seconds *= 30 * 24 * 60 * 60
     elif suffix == 'y':
-        time_in_seconds *= 365*24*60*60
+        time_in_seconds *= 365 * 24 * 60 * 60
     else:
-        raise ValueError(f"Invalid time specification: {timespec}")
+        raise ValueError(f'Invalid time specification: {timespec}')
     return time_in_seconds