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

meerschaum/utils/daemon/FileDescriptorInterceptor.py

@@ -112,7 +112,7 @@ class FileDescriptorInterceptor:
         except OSError as e:
             if e.errno != FD_CLOSED:
                 warn(
-                    f"Error while trying to close the duplicated file descriptor:\n"
+                    "Error while trying to close the duplicated file descriptor:\n"
                     + f"{traceback.format_exc()}"
                 )
 
@@ -121,7 +121,7 @@ class FileDescriptorInterceptor:
         except OSError as e:
             if e.errno != FD_CLOSED:
                 warn(
-                    f"Error while trying to close the write-pipe "
+                    "Error while trying to close the write-pipe "
                     + "to the intercepted file descriptor:\n"
                     + f"{traceback.format_exc()}"
                 )
@@ -130,7 +130,7 @@ class FileDescriptorInterceptor:
         except OSError as e:
             if e.errno != FD_CLOSED:
                 warn(
-                    f"Error while trying to close the read-pipe "
+                    "Error while trying to close the read-pipe "
                     + "to the intercepted file descriptor:\n"
                     + f"{traceback.format_exc()}"
                 )
@@ -140,7 +140,7 @@ class FileDescriptorInterceptor:
         except OSError as e:
             if e.errno != FD_CLOSED:
                 warn(
-                    f"Error while trying to close the signal-read-pipe "
+                    "Error while trying to close the signal-read-pipe "
                     + "to the intercepted file descriptor:\n"
                     + f"{traceback.format_exc()}"
                 )
@@ -150,7 +150,7 @@ class FileDescriptorInterceptor:
         except OSError as e:
             if e.errno != FD_CLOSED:
                 warn(
-                    f"Error while trying to close the signal-write-pipe "
+                    "Error while trying to close the signal-write-pipe "
                     + "to the intercepted file descriptor:\n"
                     + f"{traceback.format_exc()}"
                 )

meerschaum/utils/daemon/RotatingFile.py

@@ -38,7 +38,7 @@ class RotatingFile(io.IOBase):
         max_file_size: Optional[int] = None,
         redirect_streams: bool = False,
         write_timestamps: bool = False,
-        timestamp_format: str = '%Y-%m-%d %H:%M',
+        timestamp_format: Optional[str] = None,
     ):
         """
         Create a file-like object which manages other files.
@@ -63,12 +63,18 @@ 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 None
+            If `write_timestamps` is `True`, use this format for the timestamps.
+            Defaults to `'%Y-%m-%d %H:%M'`.
         """
         self.file_path = pathlib.Path(file_path)
         if num_files_to_keep is None:
             num_files_to_keep = get_config('jobs', 'logs', 'num_files_to_keep')
         if max_file_size is None:
             max_file_size = get_config('jobs', 'logs', 'max_file_size')
+        if timestamp_format is None:
+            timestamp_format = get_config('jobs', 'logs', 'timestamps', 'format')
         if num_files_to_keep < 2:
             raise ValueError("At least 2 files must be kept.")
         if max_file_size < 1:
@@ -232,10 +238,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 +345,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 +574,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,121 @@
+#! /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, Union
+from meerschaum.utils.warnings import warn
+
+
+class StdinFile(io.TextIOBase):
+    """
+    Redirect user input into a Daemon's context.
+    """
+    def __init__(
+        self,
+        file_path: Union[pathlib.Path, str],
+        lock_file_path: Optional[pathlib.Path] = None,
+    ):
+        if isinstance(file_path, str):
+            file_path = pathlib.Path(file_path)
+
+        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()
+
+        self.file_path.parent.mkdir(parents=True, exist_ok=True)
+        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
+
+
+    def __str__(self) -> str:
+        return f"StdinFile('{self.file_path}')"
+
+    def __repr__(self) -> str:
+        return str(self)

meerschaum/utils/daemon/__init__.py

@@ -10,9 +10,11 @@ from __future__ import annotations
 import os, pathlib, shutil, json, datetime, threading, shlex
 from meerschaum.utils.typing import SuccessTuple, List, Optional, Callable, Any, Dict
 from meerschaum.config._paths import DAEMON_RESOURCES_PATH
+from meerschaum.utils.daemon.StdinFile import StdinFile
 from meerschaum.utils.daemon.Daemon import Daemon
 from meerschaum.utils.daemon.RotatingFile import RotatingFile
 from meerschaum.utils.daemon.FileDescriptorInterceptor import FileDescriptorInterceptor
+from meerschaum.utils.daemon._names import get_new_daemon_name
 
 
 def daemon_entry(sysargs: Optional[List[str]] = None) -> SuccessTuple:
@@ -76,7 +78,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 +183,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 +231,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 +257,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/daemon/_names.py

@@ -18,7 +18,8 @@ _bank: Dict[str, Dict[str, List[str]]] = {
             'bright', 'dark', 'neon',
         ],
         'sizes': [
-            'big', 'small', 'large', 'huge', 'tiny', 'long', 'short', 'grand', 'mini', 'micro'
+            'big', 'small', 'large', 'huge', 'tiny', 'long', 'short', 'average', 'mini', 'micro',
+            'maximum', 'minimum', 'median',
         ],
         'personalities': [
             'groovy', 'cool', 'awesome', 'nice', 'fantastic', 'sweet', 'great', 'amazing',
@@ -26,29 +27,36 @@ _bank: Dict[str, Dict[str, List[str]]] = {
         ],
         'emotions': [
             'angry', 'happy', 'excited', 'suspicious', 'sad', 'thankful', 'grateful', 'satisfied',
+            'peaceful', 'ferocious', 'content',
         ],
         'sensations': [
             'sleepy', 'awake', 'alert', 'thirsty', 'comfy', 'warm', 'cold', 'chilly', 'soft',
-            'smooth', 'chunky',
+            'smooth', 'chunky', 'hungry',
         ],
         'materials': [
             'golden', 'silver', 'metal', 'plastic', 'wool', 'wooden', 'nylon', 'fuzzy', 'silky',
+            'suede', 'vinyl',
         ],
         'qualities': [
             'expensive', 'cheap', 'premier', 'best', 'favorite', 'better', 'good', 'affordable',
+            'organic', 'electric',
         ],
     },
     'nouns' : {
         'animals': [
-            'mouse', 'fox', 'horse', 'dragon', 'pig', 'hippo', 'elephant' , 'tiger', 'deer',
+            'mouse', 'fox', 'horse', 'pig', 'hippo', 'elephant' , 'tiger', 'deer', 'salmon',
             'gerbil', 'snake', 'turtle', 'rhino', 'dog', 'cat', 'giraffe', 'rabbit', 'squirrel',
             'unicorn', 'lizard', 'lion', 'bear', 'gazelle', 'whale', 'dolphin', 'fish', 'butterfly',
             'ladybug', 'fly', 'shrimp', 'flamingo', 'parrot', 'tuna', 'panda', 'lemur', 'duck',
             'seal', 'walrus', 'seagull', 'iguana', 'salamander', 'kitten', 'puppy', 'octopus',
         ],
+        'weather': [
+            'rain', 'sun', 'snow', 'wind', 'tornado', 'hurricane', 'blizzard', 'monsoon', 'storm',
+            'shower', 'hail',
+        ],
         'plants': [
             'tree', 'flower', 'vine', 'fern', 'palm', 'palmetto', 'oak', 'pine', 'rose', 'lily',
-            'ivy',
+            'ivy', 'leaf', 'shrubbery', 'acorn', 'fruit',
         ],
         'foods': [
             'pizza', 'sushi', 'apple', 'banana', 'sandwich', 'burger', 'taco', 'bratwurst',
@@ -74,8 +82,6 @@ _bank: Dict[str, Dict[str, List[str]]] = {
     },
 }
 
-_disallow_combinations: List[Tuple[str, str]] = []
-
 _adjectives: List[str]= []
 for category, items in _bank['adjectives'].items():
     _adjectives += items
@@ -84,7 +90,7 @@ _nouns: List[str] = []
 for category, items in _bank['nouns'].items():
     _nouns += items
 
-def generate_random_name(separator: str = '_'):
+def generate_random_name(separator: str = '-'):
     """
     Return a random adjective and noun combination.
 
@@ -96,12 +102,8 @@ def generate_random_name(separator: str = '_'):
     -------
     A string containing an random adjective and random noun. 
     """
-    while True:
-        adjective_category = random.choice(list(_bank['adjectives'].keys()))
-        noun_category = random.choice(list(_bank['nouns'].keys()))
-        if (adjective_category, noun_category) in _disallow_combinations:
-            continue
-        break
+    adjective_category = random.choice(list(_bank['adjectives'].keys()))
+    noun_category = random.choice(list(_bank['nouns'].keys()))
     return (
         random.choice(_bank['adjectives'][adjective_category])
         + separator

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,59 @@ 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.jobs import (
+    Job,
+    get_jobs,
+    get_running_jobs,
+    get_stopped_jobs,
+    get_paused_jobs,
+    get_executor_keys_from_context,
 )
+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
+    from meerschaum.utils.misc import items_str
     
-    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 = list(set(
+        [
+            job.executor_keys.replace('systemd:main', 'systemd')
+            for job in jobs.values()
+        ]
+    )) if jobs else [get_executor_keys_from_context()]
 
     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 +69,25 @@ 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"
+                + ('s' if len(executor_keys_list) != 1 else '')
+                + f" {items_str(executor_keys_list)}"
+            ),
+            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(
+            "Executor",
+            style=(get_config('shell', 'ansi', 'executor', 'rich', 'style') 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,39 +111,56 @@ def pprint_jobs(
             return rich_text.Text('\n') + success_tuple_text
 
 
-        for d in running_daemons:
-            if d.hidden:
-                continue
-            table.add_row(
-                d.daemon_id,
-                d.label,
-                rich_console.Group(
-                    rich_text.Text(d.status, style=('green' if ANSI else '')),
+        for name, job in running_jobs.items():
+            status_group = [
+                (
+                    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 ''))
                 ),
+            ] + ([rich_text.Text(f"PID: {pid}")] if (pid := job.pid) else [])
+
+            if job.restart:
+                status_group.append(rich_text.Text('(restarts)'))
+
+            table.add_row(
+                job.name,
+                job.executor_keys.replace('systemd:main', 'systemd'),
+                job.label,
+                rich_console.Group(*status_group),
             )
 
-        for d in paused_daemons:
-            if d.hidden:
-                continue
+        for name, job in paused_jobs.items():
+            status_group = [
+                rich_text.Text(job.status, style=('yellow' if ANSI else '')),
+            ]
+            if job.restart:
+                status_group.append(rich_text.Text('(restarts)'))
+
             table.add_row(
-                d.daemon_id,
-                d.label,
-                rich_console.Group(
-                    rich_text.Text(d.status, style=('yellow' if ANSI else '')),
-                ),
+                job.name,
+                job.executor_keys.replace('systemd:main', 'systemd'),
+                job.label,
+                rich_console.Group(*status_group),
             )
 
-        for d in stopped_daemons:
-            if d.hidden:
-                continue
+        for name, job in stopped_jobs.items():
+            status_group = [
+                rich_text.Text(job.status, style=('red' if ANSI else '')),
+            ]
+            if job.restart:
+                if job.stop_time is None:
+                    status_group.append(rich_text.Text('(restarts)'))
+                else:
+                    status_group.append(rich_text.Text('(start to resume restarts)'))
+
+            status_group.append(get_success_text(job))
 
             table.add_row(
-                d.daemon_id,
-                d.label,
-                rich_console.Group(
-                    rich_text.Text(d.status, style=('red' if ANSI else '')),
-                    get_success_text(d)
-                ),
+                job.name,
+                job.executor_keys.replace('systemd:main', 'systemd'),
+                job.label,
+                rich_console.Group(*status_group),
             )
         get_console().print(table)
 
@@ -133,15 +169,32 @@ def pprint_jobs(
 
 
 def pprint_job(
-        daemon: Daemon,
-        nopretty: bool = False,
-    ):
-    """Pretty-print a single Daemon."""
-    if daemon.hidden:
-        return
+    job: Job,
+    nopretty: bool = False,
+):
+    """Pretty-print a single `Job`."""
     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.")