meerschaum 2.7.10__py3-none-any.whl → 2.8.1__py3-none-any.whl

meerschaum/core/Pipe/_sync.py

@@ -319,16 +319,42 @@ def sync(
             if debug:
                 dprint("Successfully synced the first chunk, attemping the rest...")
 
-            failed_chunks = []
             def _process_chunk(_chunk):
-                try:
-                    _chunk_success, _chunk_msg = _sync(p, _chunk)
-                except Exception as e:
-                    _chunk_success, _chunk_msg = False, str(e)
-                if not _chunk_success:
-                    failed_chunks.append(_chunk)
+                _chunk_attempts = 0
+                _max_chunk_attempts = 3
+                while _chunk_attempts < _max_chunk_attempts:
+                    try:
+                        _chunk_success, _chunk_msg = _sync(p, _chunk)
+                    except Exception as e:
+                        _chunk_success, _chunk_msg = False, str(e)
+                    if _chunk_success:
+                        break
+                    _chunk_attempts += 1
+                    _sleep_seconds = _chunk_attempts ** 2
+                    warn(
+                        (
+                            f"Failed to sync chunk to {self} "
+                            + f"(attempt {_chunk_attempts} / {_max_chunk_attempts}).\n"
+                            + f"Sleeping for {_sleep_seconds} second"
+                            + ('s' if _sleep_seconds != 1 else '')
+                            + ":\n{_chunk_msg}"
+                        ),
+                        stack=False,
+                    )
+                    time.sleep(_sleep_seconds)
+
+                num_rows_str = (
+                    f"{num_rows:,} rows"
+                    if (num_rows := len(_chunk)) != 1
+                    else f"{num_rows} row"
+                )
                 _chunk_msg = (
-                    self._get_chunk_label(_chunk, dt_col)
+                    (
+                        "Synced"
+                        if _chunk_success
+                        else "Failed to sync"
+                    ) + f" a chunk ({num_rows_str}) to {p}:\n"
+                    + self._get_chunk_label(_chunk, dt_col)
                     + '\n'
                     + _chunk_msg
                 )
@@ -351,27 +377,16 @@ def sync(
             )
             chunk_messages = [chunk_msg for _, chunk_msg in results]
             success_bools = [chunk_success for chunk_success, _ in results]
+            num_successes = len([chunk_success for chunk_success, _ in results if chunk_success])
+            num_failures = len([chunk_success for chunk_success, _ in results if not chunk_success])
             success = all(success_bools)
             msg = (
-                f'Synced {len(chunk_messages)} chunk'
+                'Synced '
+                + f'{len(chunk_messages):,} chunk'
                 + ('s' if len(chunk_messages) != 1 else '')
-                + f' to {p}:\n\n'
+                + f' to {p}\n({num_successes} succeeded, {num_failures} failed):\n\n'
                 + '\n\n'.join(chunk_messages).lstrip().rstrip()
             ).lstrip().rstrip()
-
-            ### If some chunks succeeded, retry the failures.
-            retry_success = True
-            if not success and any(success_bools):
-                if debug:
-                    dprint("Retrying failed chunks...")
-                chunks_to_retry = [c for c in failed_chunks]
-                failed_chunks = []
-                for chunk in chunks_to_retry:
-                    chunk_success, chunk_msg = _process_chunk(chunk)
-                    msg += f"\n\nRetried chunk:\n{chunk_msg}\n"
-                    retry_success = retry_success and chunk_success
-
-            success = success and retry_success
             return success, msg
 
         ### Cast to a dataframe and ensure datatypes are what we expect.
@@ -474,6 +489,7 @@ def get_sync_time(
     params: Optional[Dict[str, Any]] = None,
     newest: bool = True,
     apply_backtrack_interval: bool = False,
+    remote: bool = False,
     round_down: bool = False,
     debug: bool = False
 ) -> Union['datetime', int, None]:
@@ -493,6 +509,10 @@ def get_sync_time(
     apply_backtrack_interval: bool, default False
         If `True`, subtract the backtrack interval from the sync time.
 
+    remote: bool, default False
+        If `True` and the instance connector supports it, return the sync time
+        for the remote table definition.
+
     round_down: bool, default False
         If `True`, round down the datetime value to the nearest minute.
 
@@ -506,17 +526,30 @@ def get_sync_time(
     """
     from meerschaum.utils.venv import Venv
     from meerschaum.connectors import get_connector_plugin
-    from meerschaum.utils.misc import round_time
+    from meerschaum.utils.misc import round_time, filter_keywords
+    from meerschaum.utils.warnings import warn
 
     if not self.columns.get('datetime', None):
         return None
 
-    with Venv(get_connector_plugin(self.instance_connector)):
-        sync_time = self.instance_connector.get_sync_time(
+    connector = self.instance_connector if not remote else self.connector
+    with Venv(get_connector_plugin(connector)):
+        if not hasattr(connector, 'get_sync_time'):
+            warn(
+                f"Connectors of type '{connector.type}' "
+                "do not implement `get_sync_time().",
+                stack=False,
+            )
+            return None
+        sync_time = connector.get_sync_time(
             self,
-            params=params,
-            newest=newest,
-            debug=debug,
+            **filter_keywords(
+                connector.get_sync_time,
+                params=params,
+                newest=newest,
+                remote=remote,
+                debug=debug,
+            )
         )
 
     if round_down and isinstance(sync_time, datetime):

meerschaum/core/Pipe/_verify.py

@@ -11,6 +11,7 @@ from datetime import datetime, timedelta
 import meerschaum as mrsm
 from meerschaum.utils.typing import SuccessTuple, Any, Optional, Union, Tuple, Dict
 from meerschaum.utils.warnings import warn, info
+from meerschaum.config.static import STATIC_CONFIG
 
 
 def verify(
@@ -22,6 +23,9 @@ def verify(
     bounded: Optional[bool] = None,
     deduplicate: bool = False,
     workers: Optional[int] = None,
+    batchsize: Optional[int] = None,
+    skip_chunks_with_greater_rowcounts: bool = False,
+    check_rowcounts_only: bool = False,
     debug: bool = False,
     **kwargs: Any
 ) -> SuccessTuple:
@@ -53,6 +57,17 @@ def verify(
         If provided, limit the verification to this many threads.
         Use a value of `1` to sync chunks in series.
 
+    batchsize: Optional[int], default None
+        If provided, sync this many chunks in parallel.
+        Defaults to `Pipe.get_num_workers()`.
+
+    skip_chunks_with_greater_rowcounts: bool, default False
+        If `True`, compare the rowcounts for a chunk and skip syncing if the pipe's
+        chunk rowcount equals or exceeds the remote's rowcount.
+
+    check_rowcounts_only: bool, default False
+        If `True`, only compare rowcounts and print chunks which are out-of-sync.
+
     debug: bool, default False
         Verbosity toggle.
 
@@ -64,8 +79,10 @@ def verify(
     A SuccessTuple indicating whether the pipe was successfully resynced.
     """
     from meerschaum.utils.pool import get_pool
+    from meerschaum.utils.formatting import make_header
     from meerschaum.utils.misc import interval_str
     workers = self.get_num_workers(workers)
+    check_rowcounts = skip_chunks_with_greater_rowcounts or check_rowcounts_only
 
     ### Skip configured bounding in parameters
     ### if `bounded` is explicitly `False`.
@@ -83,21 +100,26 @@ def verify(
             if bound_time is not None
             else self.get_sync_time(newest=False, debug=debug)
         )
+        if begin is None:
+            remote_oldest_sync_time = self.get_sync_time(newest=False, remote=True, debug=debug)
+            begin = remote_oldest_sync_time
     if bounded and end is None:
         end = self.get_sync_time(newest=True, debug=debug)
+        if end is None:
+            remote_newest_sync_time = self.get_sync_time(newest=True, remote=True, debug=debug)
+            end = remote_newest_sync_time
+        if end is not None:
+            end += (
+                timedelta(minutes=1)
+                if hasattr(end, 'tzinfo')
+                else 1
+            )
 
     begin, end = self.parse_date_bounds(begin, end)
-
-    if bounded and end is not None:
-        end += (
-            timedelta(minutes=1)
-            if isinstance(end, datetime)
-            else 1
-        )
-
-    cannot_determine_bounds = not self.exists(debug=debug)
+    cannot_determine_bounds = bounded and begin is None and end is None
 
     if cannot_determine_bounds:
+        warn(f"Cannot determine sync bounds for {self}. Syncing instead...", stack=False)
         sync_success, sync_msg = self.sync(
             begin=begin,
             end=end,
@@ -160,17 +182,16 @@ def verify(
             else chunk_bounds[-1][0]
         )
     )
+    message_header = f"{begin_to_print} - {end_to_print}"
 
     info(
         f"Verifying {self}:\n    Syncing {len(chunk_bounds)} chunk"
         + ('s' if len(chunk_bounds) != 1 else '')
         + f" ({'un' if not bounded else ''}bounded)"
         + f" of size '{interval_str(chunk_interval)}'"
-        + f" between '{begin_to_print}' and '{end_to_print}'."
+        + f" between '{begin_to_print}' and '{end_to_print}'.\n"
     )
 
-    pool = get_pool(workers=workers)
-
     ### Dictionary of the form bounds -> success_tuple, e.g.:
     ### {
     ###    (2023-01-01, 2023-01-02): (True, "Success")
@@ -180,87 +201,169 @@ def verify(
         chunk_begin_and_end: Tuple[
             Union[int, datetime],
             Union[int, datetime]
-        ]
+        ],
+        _workers: Optional[int] = 1,
     ):
         if chunk_begin_and_end in bounds_success_tuples:
             return chunk_begin_and_end, bounds_success_tuples[chunk_begin_and_end]
 
         chunk_begin, chunk_end = chunk_begin_and_end
+        do_sync = True
+        chunk_success, chunk_msg = False, "Did not sync chunk."
+        if check_rowcounts:
+            existing_rowcount = self.get_rowcount(begin=chunk_begin, end=chunk_end, debug=debug)
+            remote_rowcount = self.get_rowcount(
+                begin=chunk_begin,
+                end=chunk_end,
+                remote=True,
+                debug=debug,
+            )
+            checked_rows_str = (
+                f"checked {existing_rowcount} row"
+                + ("s" if existing_rowcount != 1 else '')
+                + f" vs {remote_rowcount} remote"
+            )
+            if (
+                existing_rowcount is not None
+                and remote_rowcount is not None
+                and existing_rowcount >= remote_rowcount
+            ):
+                do_sync = False
+                chunk_success, chunk_msg = True, (
+                    "Row-count is up-to-date "
+                    f"({checked_rows_str})."
+                )
+            elif check_rowcounts_only:
+                do_sync = False
+                chunk_success, chunk_msg = True, (
+                    f"Row-counts are out-of-sync ({checked_rows_str})."
+                )
+
         chunk_success, chunk_msg = self.sync(
             begin=chunk_begin,
             end=chunk_end,
             params=params,
-            workers=1,
+            workers=_workers,
             debug=debug,
             **kwargs
-        )
+        ) if do_sync else (chunk_success, chunk_msg)
         chunk_msg = chunk_msg.strip()
         if ' - ' not in chunk_msg:
             chunk_label = f"{chunk_begin} - {chunk_end}"
-            chunk_msg = f'{chunk_label}\n{chunk_msg}'
+            chunk_msg = f'Verified chunk for {self}:\n{chunk_label}\n{chunk_msg}'
         mrsm.pprint((chunk_success, chunk_msg))
         return chunk_begin_and_end, (chunk_success, chunk_msg)
 
     ### If we have more than one chunk, attempt to sync the first one and return if its fails.
     if len(chunk_bounds) > 1:
         first_chunk_bounds = chunk_bounds[0]
+        first_label = f"{first_chunk_bounds[0]} - {first_chunk_bounds[1]}"
+        info(f"Verifying first chunk for {self}:\n    {first_label}")
         (
             (first_begin, first_end),
             (first_success, first_msg)
-        ) = process_chunk_bounds(first_chunk_bounds)
+        ) = process_chunk_bounds(first_chunk_bounds, _workers=workers)
         if not first_success:
             return (
                 first_success,
-                f"\n{first_begin} - {first_end}\n"
+                f"\n{first_label}\n"
                 + f"Failed to sync first chunk:\n{first_msg}"
             )
         bounds_success_tuples[first_chunk_bounds] = (first_success, first_msg)
+        info(f"Completed first chunk for {self}:\n    {first_label}\n")
 
-    bounds_success_tuples.update(dict(pool.map(process_chunk_bounds, chunk_bounds)))
-    bounds_success_bools = {bounds: tup[0] for bounds, tup in bounds_success_tuples.items()}
+    pool = get_pool(workers=workers)
+    batches = self.get_chunk_bounds_batches(chunk_bounds, batchsize=batchsize, workers=workers)
 
-    message_header = f"{begin_to_print} - {end_to_print}"
-    if all(bounds_success_bools.values()):
-        msg = get_chunks_success_message(bounds_success_tuples, header=message_header)
-        if deduplicate:
-            deduplicate_success, deduplicate_msg = self.deduplicate(
-                begin=begin,
-                end=end,
-                params=params,
-                workers=workers,
-                debug=debug,
-                **kwargs
+    def process_batch(
+        batch_chunk_bounds: Tuple[
+            Tuple[Union[datetime, int, None], Union[datetime, int, None]],
+            ...
+        ]
+    ):
+        _batch_begin = batch_chunk_bounds[0][0]
+        _batch_end = batch_chunk_bounds[-1][-1]
+        batch_message_header = f"{_batch_begin} - {_batch_end}"
+        batch_bounds_success_tuples = dict(pool.map(process_chunk_bounds, batch_chunk_bounds))
+        bounds_success_tuples.update(batch_bounds_success_tuples)
+        batch_bounds_success_bools = {
+            bounds: tup[0]
+            for bounds, tup in batch_bounds_success_tuples.items()
+        }
+
+        if all(batch_bounds_success_bools.values()):
+            msg = get_chunks_success_message(
+                batch_bounds_success_tuples,
+                header=batch_message_header,
+                check_rowcounts_only=check_rowcounts_only,
+            )
+            if deduplicate:
+                deduplicate_success, deduplicate_msg = self.deduplicate(
+                    begin=_batch_begin,
+                    end=_batch_end,
+                    params=params,
+                    workers=workers,
+                    debug=debug,
+                    **kwargs
+                )
+                return deduplicate_success, msg + '\n\n' + deduplicate_msg
+            return True, msg
+
+        batch_chunk_bounds_to_resync = [
+            bounds
+            for bounds, success in zip(batch_chunk_bounds, batch_bounds_success_bools)
+            if not success
+        ]
+        batch_bounds_to_print = [
+            f"{bounds[0]} - {bounds[1]}"
+            for bounds in batch_chunk_bounds_to_resync
+        ]
+        if batch_bounds_to_print:
+            warn(
+                "Will resync the following failed chunks:\n    "
+                + '\n    '.join(batch_bounds_to_print),
+                stack=False,
             )
-            return deduplicate_success, msg + '\n\n' + deduplicate_msg
-        return True, msg
-
-    chunk_bounds_to_resync = [
-        bounds
-        for bounds, success in zip(chunk_bounds, bounds_success_bools)
-        if not success
-    ]
-    bounds_to_print = [
-        f"{bounds[0]} - {bounds[1]}"
-        for bounds in chunk_bounds_to_resync
-    ]
-    if bounds_to_print:
-        warn(
-            f"Will resync the following failed chunks:\n    "
-            + '\n    '.join(bounds_to_print),
-            stack=False,
-        )
-
-    retry_bounds_success_tuples = dict(pool.map(process_chunk_bounds, chunk_bounds_to_resync))
-    bounds_success_tuples.update(retry_bounds_success_tuples)
-    retry_bounds_success_bools = {
-        bounds: tup[0]
-        for bounds, tup in retry_bounds_success_tuples.items()
-    }
 
-    if all(retry_bounds_success_bools.values()):
-        message = (
-            get_chunks_success_message(bounds_success_tuples, header=message_header)
-            + f"\nRetried {len(chunk_bounds_to_resync)} chunks."
+        retry_bounds_success_tuples = dict(pool.map(
+            process_chunk_bounds,
+            batch_chunk_bounds_to_resync
+        ))
+        batch_bounds_success_tuples.update(retry_bounds_success_tuples)
+        bounds_success_tuples.update(retry_bounds_success_tuples)
+        retry_bounds_success_bools = {
+            bounds: tup[0]
+            for bounds, tup in retry_bounds_success_tuples.items()
+        }
+
+        if all(retry_bounds_success_bools.values()):
+            chunks_message = (
+                get_chunks_success_message(
+                    batch_bounds_success_tuples,
+                    header=batch_message_header,
+                    check_rowcounts_only=check_rowcounts_only,
+                ) + f"\nRetried {len(batch_chunk_bounds_to_resync)} chunk" + (
+                    's'
+                    if len(batch_chunk_bounds_to_resync) != 1
+                    else ''
+                ) + "."
+            )
+            if deduplicate:
+                deduplicate_success, deduplicate_msg = self.deduplicate(
+                    begin=_batch_begin,
+                    end=_batch_end,
+                    params=params,
+                    workers=workers,
+                    debug=debug,
+                    **kwargs
+                )
+                return deduplicate_success, chunks_message + '\n\n' + deduplicate_msg
+            return True, chunks_message
+
+        batch_chunks_message = get_chunks_success_message(
+            batch_bounds_success_tuples,
+            header=batch_message_header,
+            check_rowcounts_only=check_rowcounts_only,
         )
         if deduplicate:
             deduplicate_success, deduplicate_msg = self.deduplicate(
@@ -271,26 +374,58 @@ def verify(
                 debug=debug,
                 **kwargs
             )
-            return deduplicate_success, message + '\n\n' + deduplicate_msg
-        return True, message
-
-    message = get_chunks_success_message(bounds_success_tuples, header=message_header)
-    if deduplicate:
-        deduplicate_success, deduplicate_msg = self.deduplicate(
-            begin=begin,
-            end=end,
-            params=params,
-            workers=workers,
-            debug=debug,
-            **kwargs
+            return deduplicate_success, batch_chunks_message + '\n\n' + deduplicate_msg
+        return False, batch_chunks_message
+
+    num_batches = len(batches)
+    for batch_i, batch in enumerate(batches):
+        batch_begin = batch[0][0]
+        batch_end = batch[-1][-1]
+        batch_counter_str = f"({(batch_i + 1):,}/{num_batches:,})"
+        batch_label = f"batch {batch_counter_str}:\n{batch_begin} - {batch_end}"
+        retry_failed_batch = True
+        try:
+            for_self = 'for ' + str(self)
+            batch_label_str = batch_label.replace(':\n', ' ' + for_self + '...\n    ')
+            info(f"Verifying {batch_label_str}\n")
+            batch_success, batch_msg = process_batch(batch)
+        except (KeyboardInterrupt, Exception) as e:
+            batch_success = False
+            batch_msg = str(e)
+            retry_failed_batch = False
+
+        batch_msg_to_print = (
+            f"{make_header('Completed batch ' + batch_counter_str + ' ' + for_self + ':')}\n{batch_msg}"
         )
-        return deduplicate_success, message + '\n\n' + deduplicate_msg
-    return False, message
+        mrsm.pprint((batch_success, batch_msg_to_print))
+
+        if not batch_success and retry_failed_batch:
+            info(f"Retrying batch {batch_counter_str}...")
+            retry_batch_success, retry_batch_msg = process_batch(batch)
+            retry_batch_msg_to_print = (
+                f"Retried {make_header('batch ' + batch_label)}\n{retry_batch_msg}"
+            )
+            mrsm.pprint((retry_batch_success, retry_batch_msg_to_print))
+
+            batch_success = retry_batch_success
+            batch_msg = retry_batch_msg
+
+        if not batch_success:
+            return False, f"Failed to verify {batch_label}:\n\n{batch_msg}"
+
+    chunks_message = get_chunks_success_message(
+        bounds_success_tuples,
+        header=message_header,
+        check_rowcounts_only=check_rowcounts_only,
+    )
+    return True, chunks_message
+
 
 
 def get_chunks_success_message(
     chunk_success_tuples: Dict[Tuple[Any, Any], SuccessTuple],
     header: str = '',
+    check_rowcounts_only: bool = False,
 ) -> str:
     """
     Sum together all of the inserts and updates from the chunks.
@@ -319,10 +454,19 @@ def get_chunks_success_message(
     inserts = [stat['inserted'] for stat in chunk_stats]
     updates = [stat['updated'] for stat in chunk_stats]
     upserts = [stat['upserted'] for stat in chunk_stats]
+    checks = [stat['checked'] for stat in chunk_stats]
+    out_of_sync_bounds_messages = {
+        bounds: message
+        for bounds, (success, message) in chunk_success_tuples.items()
+        if 'out-of-sync' in message
+    } if check_rowcounts_only else {}
+
     num_inserted = sum(inserts)
     num_updated = sum(updates)
     num_upserted = sum(upserts)
+    num_checked = sum(checks)
     num_fails = len(fail_chunk_bounds_tuples)
+    num_out_of_sync = len(out_of_sync_bounds_messages)
 
     header = (header + "\n") if header else ""
     stats_msg = items_str(
@@ -330,22 +474,38 @@ def get_chunks_success_message(
             ([f'inserted {num_inserted:,}'] if num_inserted else [])
             + ([f'updated {num_updated:,}'] if num_updated else [])
             + ([f'upserted {num_upserted:,}'] if num_upserted else [])
+            + ([f'checked {num_checked:,}'] if num_checked else [])
         ) or ['synced 0'],
         quotes=False,
         and_=False,
     )
 
     success_msg = (
-        f"Successfully synced {len(chunk_success_tuples):,} chunk"
+        "Successfully "
+        + ('synced' if not check_rowcounts_only else 'checked')
+        + f" {len(chunk_success_tuples):,} chunk"
         + ('s' if len(chunk_success_tuples) != 1 else '')
         + '\n(' + stats_msg
         + ' rows in total).'
     )
+    if check_rowcounts_only:
+        success_msg += (
+            f"\n\nFound {num_out_of_sync} chunk"
+            + ('s' if num_out_of_sync != 1 else '')
+            + ' to be out-of-sync'
+            + ('.' if num_out_of_sync == 0 else ':\n\n  ')
+            + '\n  '.join(
+                [
+                    f'{lbound} - {rbound}'
+                    for lbound, rbound in out_of_sync_bounds_messages
+                ]
+            )
+        )
     fail_msg = (
         ''
         if num_fails == 0
         else (
-            f"\n\nFailed to sync {num_fails} chunk"
+            f"\n\nFailed to sync {num_fails:,} chunk"
             + ('s' if num_fails != 1 else '') + ":\n"
             + '\n'.join([
                 f"{fail_begin} - {fail_end}\n{msg}\n"
@@ -436,9 +596,15 @@ def get_bound_time(self, debug: bool = False) -> Union[datetime, int, None]:
 
     bound_time = sync_time - bound_interval
     oldest_sync_time = self.get_sync_time(newest=False, debug=debug)
+    max_bound_time_days = STATIC_CONFIG['pipes']['max_bound_time_days']
+
+    extreme_sync_times_delta = (
+        hasattr(oldest_sync_time, 'tzinfo')
+        and (sync_time - oldest_sync_time) >= timedelta(days=max_bound_time_days)
+    )
 
     return (
         bound_time
-        if bound_time > oldest_sync_time
+        if bound_time > oldest_sync_time or extreme_sync_times_delta
         else None
     )

meerschaum/core/User/__init__.py

@@ -9,7 +9,7 @@ Manager users' metadata via the User class
 from typing import Optional
 
 import meerschaum as mrsm
-from meerschaum.core.User._User import User, hash_password, verify_password
+from meerschaum.core.User._User import User
 
 
 def is_user_allowed_to_execute(
@@ -19,8 +19,6 @@ def is_user_allowed_to_execute(
     """
     Return a `SuccessTuple` indicating whether a given user is allowed to execute actions.
     """
-    print(f"{debug=}")
-    print(f"{user=}")
     if user is None:
         return True, "Success"
 
@@ -29,9 +27,7 @@ def is_user_allowed_to_execute(
     if user_type == 'admin':
         return True, "Success"
 
-    from meerschaum.config import get_config
-
-    allow_non_admin = get_config('system', 'api', 'permissions', 'actions', 'non_admin')
+    allow_non_admin = mrsm.get_config('system', 'api', 'permissions', 'actions', 'non_admin')
     if not allow_non_admin:
         return False, "The administrator for this server has not allowed users to perform actions."
 

meerschaum/jobs/_Job.py

@@ -30,7 +30,7 @@ if TYPE_CHECKING:
     from meerschaum.jobs._Executor import Executor
 
 BANNED_CHARS: List[str] = [
-    ',', ';', "'", '"',
+    ',', ';', "'", '"', '.', '$', '#', '=', '*', '&', '!', '`', '~',
 ]
 RESTART_FLAGS: List[str] = [
     '-s',

meerschaum/jobs/__init__.py

@@ -150,6 +150,13 @@ def get_filtered_jobs(
         }
 
     jobs_to_return = {}
+    filter_list_without_underscores = [name for name in filter_list if not name.startswith('_')]
+    filter_list_with_underscores = [name for name in filter_list if name.startswith('_')]
+    if (
+        filter_list_without_underscores and not filter_list_with_underscores
+        or filter_list_with_underscores and not filter_list_without_underscores
+    ):
+        pass
     for name in filter_list:
         job = jobs.get(name, None)
         if job is None:
@@ -161,6 +168,14 @@ def get_filtered_jobs(
             continue
         jobs_to_return[name] = job
 
+    if not jobs_to_return and filter_list_with_underscores:
+        names_to_exclude = [name.lstrip('_') for name in filter_list_with_underscores]
+        return {
+            name: job
+            for name, job in jobs.items()
+            if name not in names_to_exclude
+        }
+
     return jobs_to_return
 
 

meerschaum/utils/dataframe.py

@@ -7,6 +7,8 @@ Utility functions for working with DataFrames.
 """
 
 from __future__ import annotations
+
+import pathlib
 from datetime import datetime, timezone
 from collections import defaultdict