meerschaum 2.2.7__py3-none-any.whl → 2.3.0.dev3__py3-none-any.whl

meerschaum/utils/daemon/RotatingFile.py

@@ -63,6 +63,9 @@ class RotatingFile(io.IOBase):
 
         write_timestamps: bool, default False
             If `True`, prepend the current UTC timestamp to each line of the file.
+
+        timestamp_format: str, default '%Y-%m-%d %H:%M'
+            If `write_timestamps` is `True`, use this format for the timestamps.
         """
         self.file_path = pathlib.Path(file_path)
         if num_files_to_keep is None:
@@ -232,10 +235,10 @@ class RotatingFile(io.IOBase):
 
 
     def refresh_files(
-            self,
-            potential_new_len: int = 0,
-            start_interception: bool = False,
-        ) -> '_io.TextUIWrapper':
+        self,
+        potential_new_len: int = 0,
+        start_interception: bool = False,
+    ) -> '_io.TextUIWrapper':
         """
         Check the state of the subfiles.
         If the latest subfile is too large, create a new file and delete old ones.
@@ -339,7 +342,7 @@ class RotatingFile(io.IOBase):
 
     def get_timestamp_prefix_str(self) -> str:
         """
-        Return the current minute prefixm string.
+        Return the current minute prefix string.
         """
         return datetime.now(timezone.utc).strftime(self.timestamp_format) + ' | '
 
@@ -568,7 +571,8 @@ class RotatingFile(io.IOBase):
             return
 
         self._cursor = (max_ix, position)
-        self._current_file_obj.seek(position)
+        if self._current_file_obj is not None:
+            self._current_file_obj.seek(position)
 
     
     def flush(self) -> None:

meerschaum/utils/daemon/StdinFile.py

@@ -0,0 +1,110 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+# vim:fenc=utf-8
+
+"""
+Create a file manager to pass STDIN to the Daemon.
+"""
+
+import io
+import pathlib
+import time
+import os
+import selectors
+import traceback
+
+from meerschaum.utils.typing import Optional
+from meerschaum.utils.warnings import warn
+
+
+class StdinFile(io.TextIOBase):
+    """
+    Redirect user input into a Daemon's context.
+    """
+    def __init__(
+        self,
+        file_path: pathlib.Path,
+        lock_file_path: Optional[pathlib.Path] = None,
+    ):
+        self.file_path = file_path
+        self.blocking_file_path = (
+            lock_file_path
+            if lock_file_path is not None
+            else (file_path.parent / (file_path.name + '.block'))
+        )
+        self._file_handler = None
+        self._fd = None
+        self.sel = selectors.DefaultSelector()
+
+    @property
+    def file_handler(self):
+        """
+        Return the read file handler to the provided file path.
+        """
+        if self._file_handler is not None:
+            return self._file_handler
+
+        if self.file_path.exists():
+            self.file_path.unlink()
+
+        os.mkfifo(self.file_path.as_posix(), mode=0o600)
+
+        self._fd = os.open(self.file_path, os.O_RDONLY | os.O_NONBLOCK)
+        self._file_handler = os.fdopen(self._fd, 'rb', buffering=0)
+        self.sel.register(self._file_handler, selectors.EVENT_READ)
+        return self._file_handler
+
+    def write(self, data):
+        if isinstance(data, str):
+            data = data.encode('utf-8')
+
+        with open(self.file_path, 'wb') as f:
+            f.write(data)
+
+    def fileno(self):
+        fileno = self.file_handler.fileno()
+        return fileno
+
+    def read(self, size=-1):
+        """
+        Read from the FIFO pipe, blocking on EOFError.
+        """
+        _ = self.file_handler
+        while True:
+            try:
+                data = self._file_handler.read(size)
+                if data:
+                    try:
+                        if self.blocking_file_path.exists():
+                            self.blocking_file_path.unlink()
+                    except Exception:
+                        warn(traceback.format_exc())
+                    return data.decode('utf-8')
+            except (OSError, EOFError):
+                pass
+
+            self.blocking_file_path.touch()
+            time.sleep(0.1)
+
+    def readline(self, size=-1):
+        line = ''
+        while True:
+            data = self.read(1)
+            if not data or data == '\n':
+                break
+            line += data
+
+        return line
+
+    def close(self):
+        if self._file_handler is not None:
+            self.sel.unregister(self._file_handler)
+            self._file_handler.close()
+            os.close(self._fd)
+            self._file_handler = None
+            self._fd = None
+
+        super().close()
+
+    def is_open(self):
+        return self._file_handler is not None

meerschaum/utils/daemon/__init__.py

@@ -76,7 +76,7 @@ def daemon_entry(sysargs: Optional[List[str]] = None) -> SuccessTuple:
         filtered_sysargs,
         daemon_id=_args.get('name', None) if _args else None,
         label=label,
-        keep_daemon_output=('--rm' not in sysargs),
+        keep_daemon_output=('--rm' not in (sysargs or [])),
     )
     return success_tuple
 
@@ -181,7 +181,11 @@ def get_daemon_ids() -> List[str]:
     """
     Return the IDs of all daemons on disk.
     """
-    return sorted(os.listdir(DAEMON_RESOURCES_PATH))
+    return [
+        daemon_dir
+        for daemon_dir in sorted(os.listdir(DAEMON_RESOURCES_PATH))
+        if (DAEMON_RESOURCES_PATH / daemon_dir / 'properties.json').exists()
+    ]
 
 
 def get_running_daemons(daemons: Optional[List[Daemon]] = None) -> List[Daemon]:
@@ -225,10 +229,11 @@ def get_stopped_daemons(daemons: Optional[List[Daemon]] = None) -> List[Daemon]:
 
 
 def get_filtered_daemons(
-        filter_list: Optional[List[str]] = None,
-        warn: bool = False,
-    ) -> List[Daemon]:
-    """Return a list of `Daemons` filtered by a list of `daemon_ids`.
+    filter_list: Optional[List[str]] = None,
+    warn: bool = False,
+) -> List[Daemon]:
+    """
+    Return a list of `Daemons` filtered by a list of `daemon_ids`.
     Only `Daemons` that exist are returned.
     
     If `filter_list` is `None` or empty, return all `Daemons` (from `get_daemons()`).
@@ -250,13 +255,14 @@ def get_filtered_daemons(
     if not filter_list:
         daemons = get_daemons()
         return [d for d in daemons if not d.hidden]
+
     from meerschaum.utils.warnings import warn as _warn
     daemons = []
     for d_id in filter_list:
         try:
             d = Daemon(daemon_id=d_id)
             _exists = d.path.exists()
-        except Exception as e:
+        except Exception:
             _exists = False
         if not _exists:
             if warn:

meerschaum/utils/formatting/__init__.py

@@ -28,9 +28,10 @@ _attrs = {
     'ANSI': None,
     'UNICODE': None,
     'CHARSET': None,
+    'RESET': '\033[0m',
 }
 __all__ = sorted([
-    'ANSI', 'CHARSET', 'UNICODE',
+    'ANSI', 'CHARSET', 'UNICODE', 'RESET',
     'colored',
     'translate_rich_to_termcolor',
     'get_console',

meerschaum/utils/formatting/_jobs.py

@@ -7,46 +7,52 @@ Print jobs information.
 """
 
 from __future__ import annotations
+
+from datetime import datetime, timezone
+
 import meerschaum as mrsm
-from meerschaum.utils.typing import List, Optional, Any, is_success_tuple
-from meerschaum.utils.daemon import (
-    Daemon,
-    get_daemons,
-    get_running_daemons,
-    get_stopped_daemons,
-    get_paused_daemons,
+from meerschaum.utils.typing import List, Optional, Any, is_success_tuple, Dict
+from meerschaum.utils.jobs import (
+    Job,
+    get_jobs,
+    get_running_jobs,
+    get_stopped_jobs,
+    get_paused_jobs,
 )
+from meerschaum.config import get_config
+
 
 def pprint_jobs(
-    daemons: List[Daemon],
+    jobs: Dict[str, Job],
     nopretty: bool = False,
 ):
     """Pretty-print a list of Daemons."""
     from meerschaum.utils.formatting import make_header
     
-    running_daemons = get_running_daemons(daemons)
-    paused_daemons = get_paused_daemons(daemons)
-    stopped_daemons = get_stopped_daemons(daemons)
+    running_jobs = get_running_jobs(jobs=jobs)
+    paused_jobs = get_paused_jobs(jobs=jobs)
+    stopped_jobs = get_stopped_jobs(jobs=jobs)
+    executor_keys = (list(jobs.values())[0].executor_keys if jobs else None) or 'local'
 
     def _nopretty_print():
         from meerschaum.utils.misc import print_options
-        if running_daemons:
+        if running_jobs:
             if not nopretty:
                 print('\n' + make_header('Running jobs'))
-            for d in running_daemons:
-                pprint_job(d, nopretty=nopretty)
+            for name, job in running_jobs.items():
+                pprint_job(job, nopretty=nopretty)
 
-        if paused_daemons:
+        if paused_jobs:
             if not nopretty:
                 print('\n' + make_header('Paused jobs'))
-            for d in paused_daemons:
-                pprint_job(d, nopretty=nopretty)
+            for name, job in paused_jobs.items():
+                pprint_job(job, nopretty=nopretty)
 
-        if stopped_daemons:
+        if stopped_jobs:
             if not nopretty:
                 print('\n' + make_header('Stopped jobs'))
-            for d in stopped_daemons:
-                pprint_job(d, nopretty=nopretty)
+            for name, job in stopped_jobs.items():
+                pprint_job(job, nopretty=nopretty)
 
     def _pretty_print():
         from meerschaum.utils.formatting import get_console, UNICODE, ANSI, format_success_tuple
@@ -56,19 +62,17 @@ def pprint_jobs(
             'rich.table', 'rich.text', 'rich.box', 'rich.json', 'rich.panel', 'rich.console',
         )
         table = rich_table.Table(
-            title = rich_text.Text('Jobs'),
-            box = (rich_box.ROUNDED if UNICODE else rich_box.ASCII),
-            show_lines = True,
-            show_header = ANSI,
+            title=rich_text.Text(f"\nJobs on Executor '{executor_keys}'"),
+            box=(rich_box.ROUNDED if UNICODE else rich_box.ASCII),
+            show_lines=True,
+            show_header=ANSI,
         )
         table.add_column("Name", justify='right', style=('magenta' if ANSI else ''))
         table.add_column("Command")
         table.add_column("Status")
 
-        def get_success_text(d):
-            success_tuple = d.properties.get('result', None)
-            if isinstance(success_tuple, list):
-                success_tuple = tuple(success_tuple)
+        def get_success_text(job):
+            success_tuple = job.result
             if not is_success_tuple(success_tuple):
                 return rich_text.Text('')
 
@@ -92,38 +96,43 @@ def pprint_jobs(
             return rich_text.Text('\n') + success_tuple_text
 
 
-        for d in running_daemons:
-            if d.hidden:
+        for name, job in running_jobs.items():
+            if job.hidden:
                 continue
+
+            status_text = (
+                rich_text.Text(job.status, style=('green' if ANSI else ''))
+                if not job.is_blocking_on_stdin()
+                else rich_text.Text('waiting for input', style=('yellow' if ANSI else ''))
+            )
+
             table.add_row(
-                d.daemon_id,
-                d.label,
-                rich_console.Group(
-                    rich_text.Text(d.status, style=('green' if ANSI else '')),
-                ),
+                job.name,
+                job.label,
+                rich_console.Group(status_text),
             )
 
-        for d in paused_daemons:
-            if d.hidden:
+        for name, job in paused_jobs.items():
+            if job.hidden:
                 continue
             table.add_row(
-                d.daemon_id,
-                d.label,
+                job.name,
+                job.label,
                 rich_console.Group(
-                    rich_text.Text(d.status, style=('yellow' if ANSI else '')),
+                    rich_text.Text(job.status, style=('yellow' if ANSI else '')),
                 ),
             )
 
-        for d in stopped_daemons:
-            if d.hidden:
+        for name, job in stopped_jobs.items():
+            if job.hidden:
                 continue
 
             table.add_row(
-                d.daemon_id,
-                d.label,
+                job.name,
+                job.label,
                 rich_console.Group(
-                    rich_text.Text(d.status, style=('red' if ANSI else '')),
-                    get_success_text(d)
+                    rich_text.Text(job.status, style=('red' if ANSI else '')),
+                    get_success_text(job)
                 ),
             )
         get_console().print(table)
@@ -133,15 +142,35 @@ def pprint_jobs(
 
 
 def pprint_job(
-        daemon: Daemon,
-        nopretty: bool = False,
-    ):
-    """Pretty-print a single Daemon."""
-    if daemon.hidden:
+    job: Job,
+    nopretty: bool = False,
+):
+    """Pretty-print a single `Job`."""
+    if job.hidden:
         return
+
     from meerschaum.utils.warnings import info
     if not nopretty:
-        info(f"Command for job '{daemon.daemon_id}':")
-        print('\n' + daemon.label + '\n')
+        info(f"Command for job '{job.name}':")
+        print('\n' + job.label + '\n')
     else:
-        print(daemon.daemon_id)
+        print(job.name)
+
+
+def strip_timestamp_from_line(line: str) -> str:
+    """
+    Remove the leading timestamp from a job's line (if present).
+    """
+    now = datetime.now(timezone.utc)
+    timestamp_format = get_config('jobs', 'logs', 'timestamps', 'format')
+    now_str = now.strftime(timestamp_format)
+
+    date_prefix_str = line[:len(now_str)]
+    try:
+        line_timestamp = datetime.strptime(date_prefix_str, timestamp_format)
+    except Exception:
+        line_timestamp = None
+    if line_timestamp:
+        line = line[(len(now_str) + 3):]
+
+    return line

meerschaum/utils/formatting/_shell.py

@@ -47,9 +47,15 @@ def clear_screen(debug: bool = False) -> bool:
     from meerschaum.utils.formatting import ANSI, get_console
     from meerschaum.utils.debug import dprint
     from meerschaum.config import get_config
+    from meerschaum.utils.daemon import running_in_daemon
     global _tried_clear_command
+
+    if running_in_daemon():
+        return True
+
     if not get_config('shell', 'clear_screen'):
         return True
+
     print("", end="", flush=True)
     if debug:
         dprint("Skipping screen clear.")