meerschaum 2.0.0rc7__py3-none-any.whl → 2.0.0rc8__py3-none-any.whl

meerschaum/utils/daemon/Daemon.py

@@ -168,7 +168,7 @@ class Daemon:
             finally:
                 self._log_refresh_timer.cancel()
                 self.rotating_log.close()
-                if self.pid_path.exists():
+                if self.pid is None and self.pid_path.exists():
                     self.pid_path.unlink()
 
             if keep_daemon_output:
@@ -254,7 +254,7 @@ class Daemon:
         return _launch_success_bool, msg
 
 
-    def kill(self, timeout: Optional[int] = 3) -> SuccessTuple:
+    def kill(self, timeout: Optional[int] = 8) -> SuccessTuple:
         """Forcibly terminate a running daemon.
         Sends a SIGTERM signal to the process.
 
@@ -293,7 +293,7 @@ class Daemon:
         return True, "Success"
 
 
-    def quit(self, timeout: Optional[int] = 3) -> SuccessTuple:
+    def quit(self, timeout: Union[int, float, None] = None) -> SuccessTuple:
         """Gracefully quit a running daemon."""
         if self.status == 'paused':
             return self.kill(timeout)
@@ -305,10 +305,24 @@ class Daemon:
 
     def pause(
             self,
-            timeout: Optional[int] = 3,
-            check_timeout_interval: float = 0.1,
+            timeout: Union[int, float, None] = None,
+            check_timeout_interval: Union[float, int, None] = None,
         ) -> SuccessTuple:
-        """Pause the daemon if it is running."""
+        """
+        Pause the daemon if it is running.
+
+        Parameters
+        ----------
+        timeout: Union[float, int, None], default None
+            The maximum number of seconds to wait for a process to suspend.
+
+        check_timeout_interval: Union[float, int, None], default None
+            The number of seconds to wait between checking if the process is still running.
+
+        Returns
+        -------
+        A `SuccessTuple` indicating whether the `Daemon` process was successfully suspended.
+        """
         if self.process is None:
             return False, f"Daemon '{self.daemon_id}' is not running and cannot be paused."
 
@@ -320,8 +334,18 @@ class Daemon:
         except Exception as e:
             return False, f"Failed to pause daemon '{self.daemon_id}':\n{e}"
 
-        if timeout is None:
-            success = self.process.status() == 'stopped'
+        timeout = self.get_timeout_seconds(timeout)
+        check_timeout_interval = self.get_check_timeout_interval_seconds(
+            check_timeout_interval
+        )
+
+        psutil = attempt_import('psutil')
+
+        if not timeout:
+            try:
+                success = self.process.status() == 'stopped'
+            except psutil.NoSuchProcess as e:
+                success = True
             msg = "Success" if success else f"Failed to suspend daemon '{self.daemon_id}'."
             if success:
                 self._capture_process_timestamp('paused')
@@ -329,9 +353,12 @@ class Daemon:
 
         begin = time.perf_counter()
         while (time.perf_counter() - begin) < timeout:
-            if self.process.status() == 'stopped':
-                self._capture_process_timestamp('paused')
-                return True, "Success"
+            try:
+                if self.process.status() == 'stopped':
+                    self._capture_process_timestamp('paused')
+                    return True, "Success"
+            except psutil.NoSuchProcess as e:
+                return False, f"Process exited unexpectedly. Was it killed?\n{e}"
             time.sleep(check_timeout_interval)
 
         return False, (
@@ -342,10 +369,24 @@ class Daemon:
 
     def resume(
             self,
-            timeout: Optional[int] = 3,
-            check_timeout_interval: float = 0.1,
+            timeout: Union[int, float, None] = None,
+            check_timeout_interval: Union[float, int, None] = None,
         ) -> SuccessTuple:
-        """Resume the daemon if it is paused."""
+        """
+        Resume the daemon if it is paused.
+
+        Parameters
+        ----------
+        timeout: Union[float, int, None], default None
+            The maximum number of seconds to wait for a process to resume.
+
+        check_timeout_interval: Union[float, int, None], default None
+            The number of seconds to wait between checking if the process is still stopped.
+
+        Returns
+        -------
+        A `SuccessTuple` indicating whether the `Daemon` process was successfully resumed.
+        """
         if self.status == 'running':
             return True, f"Daemon '{self.daemon_id}' is already running."
 
@@ -357,7 +398,12 @@ class Daemon:
         except Exception as e:
             return False, f"Failed to resume daemon '{self.daemon_id}':\n{e}"
 
-        if timeout is None:
+        timeout = self.get_timeout_seconds(timeout)
+        check_timeout_interval = self.get_check_timeout_interval_seconds(
+            check_timeout_interval
+        )
+
+        if not timeout:
             success = self.status == 'running'
             msg = "Success" if success else f"Failed to resume daemon '{self.daemon_id}'."
             if success:
@@ -417,8 +463,8 @@ class Daemon:
     def _send_signal(
             self,
             signal_to_send,
-            timeout: Optional[Union[float, int]] = 3,
-            check_timeout_interval: float = 0.1,
+            timeout: Union[float, int, None] = None,
+            check_timeout_interval: Union[float, int, None] = None,
         ) -> SuccessTuple:
         """Send a signal to the daemon process.
 
@@ -427,13 +473,11 @@ class Daemon:
         signal_to_send:
             The signal the send to the daemon, e.g. `signals.SIGINT`.
 
-        timeout:
+        timeout: Union[float, int, None], default None
             The maximum number of seconds to wait for a process to terminate.
-            Defaults to 3.
 
-        check_timeout_interval: float, default 0.1
+        check_timeout_interval: Union[float, int, None], default None
             The number of seconds to wait between checking if the process is still running.
-            Defaults to 0.1.
 
         Returns
         -------
@@ -444,11 +488,17 @@ class Daemon:
         except Exception as e:
             return False, f"Failed to send signal {signal_to_send}:\n{traceback.format_exc()}"
 
-        if timeout is None:
+        timeout = self.get_timeout_seconds(timeout)
+        check_timeout_interval = self.get_check_timeout_interval_seconds(
+            check_timeout_interval
+        )
+
+        if not timeout:
             return True, f"Successfully sent '{signal}' to daemon '{self.daemon_id}'."
+
         begin = time.perf_counter()
         while (time.perf_counter() - begin) < timeout:
-            if not self.pid_path.exists():
+            if not self.status == 'running':
                 return True, "Success"
             time.sleep(check_timeout_interval)
 
@@ -464,8 +514,8 @@ class Daemon:
         raise a `FileExistsError`.
         """
         try:
-            self.path.mkdir(parents=True, exist_ok=False)
-            _already_exists = False
+            self.path.mkdir(parents=True, exist_ok=True)
+            _already_exists = any(os.scandir(self.path))
         except FileExistsError:
             _already_exists = True
 
@@ -506,8 +556,17 @@ class Daemon:
         if self.process is None:
             return 'stopped'
 
-        if self.process.status() == 'stopped':
-            return 'paused'
+        psutil = attempt_import('psutil')
+        try:
+            if self.process.status() == 'stopped':
+                return 'paused'
+        except psutil.NoSuchProcess:
+            if self.pid_path.exists():
+                try:
+                    self.pid_path.unlink()
+                except Exception as e:
+                    pass
+            return 'stopped'
 
         return 'running'
 
@@ -804,6 +863,28 @@ class Daemon:
             self.rotating_log.delete()
 
 
+    def get_timeout_seconds(self, timeout: Union[int, float, None] = None) -> Union[int, float]:
+        """
+        Return the timeout value to use. Use `--timeout-seconds` if provided,
+        else the configured default (8).
+        """
+        if isinstance(timeout, (int, float)):
+            return timeout
+        return get_config('jobs', 'timeout_seconds')
+
+
+    def get_check_timeout_interval_seconds(
+            self,
+            check_timeout_interval: Union[int, float, None] = None,
+        ) -> Union[int, float]:
+        """
+        Return the interval value to check the status of timeouts.
+        """
+        if isinstance(check_timeout_interval, (int, float)):
+            return check_timeout_interval
+        return get_config('jobs', 'check_timeout_interval_seconds')
+
+
     def __getstate__(self):
         """
         Pickle this Daemon.

meerschaum/utils/daemon/__init__.py

@@ -14,6 +14,7 @@ from meerschaum.utils.daemon.Daemon import Daemon
 from meerschaum.utils.daemon.Log import Log
 from meerschaum.utils.daemon.RotatingFile import RotatingFile
 
+
 def daemon_entry(sysargs: Optional[List[str]] = None) -> SuccessTuple:
     """Parse sysargs and execute a Meerschaum action as a daemon.
 
@@ -27,7 +28,7 @@ def daemon_entry(sysargs: Optional[List[str]] = None) -> SuccessTuple:
     A SuccessTuple.
     """
     from meerschaum._internal.entry import entry
-    _args = None
+    _args = {}
     if '--name' in sysargs or '--job-name' in sysargs:
         from meerschaum._internal.arguments._parse_arguments import parse_arguments
         _args = parse_arguments(sysargs)
@@ -36,6 +37,38 @@ def daemon_entry(sysargs: Optional[List[str]] = None) -> SuccessTuple:
         label = shlex.join(filtered_sysargs) if sysargs else None
     except Exception as e:
         label = ' '.join(filtered_sysargs) if sysargs else None
+
+    name = _args.get('name', None)
+    daemon = None
+    if name:
+        try:
+            daemon = Daemon(daemon_id=name)
+        except Exception as e:
+            daemon = None
+
+    if daemon is not None:
+        existing_sysargs = daemon.properties['target']['args'][0]
+        existing_kwargs = parse_arguments(existing_sysargs)
+
+        ### Remove sysargs because flags are aliased.
+        _ = _args.pop('daemon', None)
+        _ = _args.pop('sysargs', None)
+        _ = _args.pop('filtered_sysargs', None)
+        debug = _args.pop('debug', None)
+        _args['sub_args'] = sorted(_args.get('sub_args', []))
+        _ = existing_kwargs.pop('daemon', None)
+        _ = existing_kwargs.pop('sysargs', None)
+        _ = existing_kwargs.pop('filtered_sysargs', None)
+        _ = existing_kwargs.pop('debug', None)
+        existing_kwargs['sub_args'] = sorted(existing_kwargs.get('sub_args', []))
+
+        ### Only run if the kwargs equal or no actions are provided.
+        if existing_kwargs == _args or not _args.get('action', []):
+            return daemon.run(
+                debug = debug,
+                allow_dirty_run = True,
+            )
+
     success_tuple = run_daemon(
         entry,
         filtered_sysargs,
@@ -47,6 +80,7 @@ def daemon_entry(sysargs: Optional[List[str]] = None) -> SuccessTuple:
         success_tuple = False, str(success_tuple)
     return success_tuple
 
+
 def daemon_action(**kw) -> SuccessTuple:
     """Execute a Meerschaum action as a daemon."""
     from meerschaum.utils.packages import run_python_package

meerschaum/utils/formatting/__init__.py

@@ -33,6 +33,7 @@ __all__ = sorted([
     'translate_rich_to_termcolor',
     'get_console',
     'print_tuple',
+    'print_options',
     'fill_ansi',
     'pprint',
     'highlight_pipes',
@@ -222,9 +223,29 @@ def print_tuple(
         common_only: bool = False,
         upper_padding: int = 0,
         lower_padding: int = 0,
+        calm: bool = False,
         _progress: Optional['rich.progress.Progress'] = None,
     ) -> None:
-    """Print `meerschaum.utils.typing.SuccessTuple`."""
+    """
+    Print `meerschaum.utils.typing.SuccessTuple`.
+
+    Parameters
+    ----------
+    skip_common: bool, default True
+        If `True`, do not print common success tuples (i.e. `(True, "Success")`).
+
+    common_only: bool, default False
+        If `True`, only print if the success tuple is common.
+
+    upper_padding: int, default 0
+        How many newlines to prepend to the message.
+
+    lower_padding: int, default 0
+        How many newlines to append to the message.
+
+    calm: bool, default False
+        If `True`, use the default emoji and color scheme.
+    """
     from meerschaum.config.static import STATIC_CONFIG
     _init()
     try:
@@ -233,6 +254,9 @@ def print_tuple(
         status = 'failure'
         tup = None, None
 
+    if calm:
+        status += '_calm'
+
     omit_messages = STATIC_CONFIG['system']['success']['ignore']
 
     do_print = True
@@ -262,6 +286,125 @@ def print_tuple(
         print(msg)
 
 
+def print_options(
+        options: Optional[Dict[str, Any]] = None,
+        nopretty: bool = False,
+        no_rich: bool = False,
+        name: str = 'options',
+        header: Optional[str] = None,
+        num_cols: Optional[int] = None,
+        adjust_cols: bool = True,
+        **kw
+    ) -> None:
+    """
+    Print items in an iterable as a fancy table.
+
+    Parameters
+    ----------
+    options: Optional[Dict[str, Any]], default None
+        The iterable to be printed.
+
+    nopretty: bool, default False
+        If `True`, don't use fancy formatting.
+
+    no_rich: bool, default False
+        If `True`, don't use `rich` to format the output.
+
+    name: str, default 'options'
+        The text in the default header after `'Available'`.
+
+    header: Optional[str], default None
+        If provided, override `name` and use this as the header text.
+
+    num_cols: Optional[int], default None
+        How many columns in the table. Depends on the terminal size. If `None`, use 8.
+
+    adjust_cols: bool, default True
+        If `True`, adjust the number of columns depending on the terminal size.
+
+    """
+    import os
+    from meerschaum.utils.packages import import_rich
+    from meerschaum.utils.formatting import make_header, highlight_pipes
+    from meerschaum.actions import actions as _actions
+    from meerschaum.utils.misc import get_cols_lines, string_width, iterate_chunks
+
+
+    if options is None:
+        options = {}
+    _options = []
+    for o in options:
+        _options.append(str(o))
+    _header = f"Available {name}" if header is None else header
+
+    if num_cols is None:
+        num_cols = 8
+
+    def _print_options_no_rich():
+        if not nopretty:
+            print()
+            print(make_header(_header))
+        ### print actions
+        for option in sorted(_options):
+            if not nopretty:
+                print("  - ", end="")
+            print(option)
+        if not nopretty:
+            print()
+
+    rich = import_rich()
+    if rich is None or nopretty or no_rich:
+        _print_options_no_rich()
+        return None
+
+    ### Prevent too many options from being truncated on small terminals.
+    if adjust_cols and _options:
+        _cols, _lines = get_cols_lines()
+        while num_cols > 1:
+            cell_len = int(((_cols - 4) - (3 * (num_cols - 1))) / num_cols)
+            num_too_big = sum([(1 if string_width(o) > cell_len else 0) for o in _options])
+            if num_too_big > int(len(_options) / 3):
+                num_cols -= 1
+                continue
+            break
+
+    from meerschaum.utils.formatting import pprint, get_console
+    from meerschaum.utils.packages import attempt_import
+    rich_columns = attempt_import('rich.columns')
+    rich_panel = attempt_import('rich.panel')
+    rich_table = attempt_import('rich.table')
+    Text = attempt_import('rich.text').Text
+    box = attempt_import('rich.box')
+    Panel = rich_panel.Panel
+    Columns = rich_columns.Columns
+    Table = rich_table.Table
+
+    if _header is not None:
+        table = Table(
+            title = '\n' + _header,
+            box = box.SIMPLE,
+            show_header = False,
+            show_footer = False,
+            title_style = '',
+            expand = True,
+        )
+    else:
+        table = Table.grid(padding=(0, 2))
+    for i in range(num_cols):
+        table.add_column()
+
+    chunks = iterate_chunks(
+        [Text.from_ansi(highlight_pipes(o)) for o in sorted(_options)],
+        num_cols,
+        fillvalue=''
+    )
+    for c in chunks:
+        table.add_row(*c)
+
+    get_console().print(table)
+    return None
+
+
 def fill_ansi(string: str, style: str = '') -> str:
     """
     Fill in non-formatted segments of ANSI text.

meerschaum/utils/formatting/_pipes.py

@@ -309,19 +309,42 @@ def highlight_pipes(message: str) -> str:
     """
     Add syntax highlighting to an info message containing stringified `meerschaum.Pipe` objects.
     """
-    if 'Pipe(' not in message or ')' not in message:
+    if 'Pipe(' not in message and ')' not in message:
         return message
+
     from meerschaum import Pipe
     segments = message.split('Pipe(')
     msg = ''
     _d = {}
     for i, segment in enumerate(segments):
-        if ',' in segment and ')' in segment:
-            paren_index = segment.find(')') + 1
-            code = "_d['pipe'] = Pipe(" + segment[:paren_index]
+        comma_index = segment.find(',')
+        paren_index = segment.find(')')
+        single_quote_index = segment.find("'")
+        double_quote_index = segment.find('"')
+
+        has_comma = comma_index != -1
+        has_paren = paren_index != -1
+        has_single_quote = single_quote_index != -1
+        has_double_quote = double_quote_index != -1
+        quote_index = double_quote_index if has_double_quote else single_quote_index
+
+        has_pipe = (
+            has_comma
+            and
+            has_paren
+            and
+            (has_single_quote or has_double_quote)
+            and not
+            (has_double_quote and has_double_quote)
+            and not
+            (comma_index > paren_index or quote_index > paren_index)
+        )
+
+        if has_pipe:
+            code = "_d['pipe'] = Pipe(" + segment[:paren_index + 1]
             try:
                 exec(code)
-                _to_add = pipe_repr(_d['pipe']) + segment[paren_index:]
+                _to_add = pipe_repr(_d['pipe']) + segment[paren_index + 1:]
             except Exception as e:
                 _to_add = 'Pipe(' + segment
             msg += _to_add