meerschaum 2.3.0rc1__py3-none-any.whl → 2.3.0rc3__py3-none-any.whl

meerschaum/_internal/arguments/__init__.py

@@ -8,7 +8,7 @@ This package includes argument parsing utilities.
 
 from meerschaum._internal.arguments._parse_arguments import (
     parse_arguments, parse_line, remove_leading_action,
-    parse_dict_to_sysargs,
+    parse_dict_to_sysargs, split_chained_sysargs,
 )
 from meerschaum._internal.arguments._parser import parser
 from meerschaum.plugins import add_plugin_argument

meerschaum/_internal/arguments/_parse_arguments.py

@@ -19,6 +19,44 @@ _locks = {
 _loaded_plugins_args: bool = False
 
 
+def split_chained_sysargs(sysargs: List[str]) -> List[List[str]]:
+    """
+    Split a `sysargs` list containing "and" keys (`&&`)
+    into a list of individual `sysargs`.
+    """
+    from meerschaum.config.static import STATIC_CONFIG
+    and_key = STATIC_CONFIG['system']['arguments']['and_key']
+
+    if not sysargs or and_key not in sysargs:
+        return [sysargs]
+
+    ### Coalesce and consecutive joiners into one.
+    coalesce_args = []
+    previous_arg = None
+    for arg in [_arg for _arg in sysargs]:
+        if arg == and_key and previous_arg == and_key:
+            continue
+        coalesce_args.append(arg)
+        previous_arg = arg
+
+    ### Remove any joiners from the ends.
+    if coalesce_args[0] == and_key:
+        coalesce_args = coalesce_args[1:]
+    if coalesce_args[-1] == and_key:
+        coalesce_args = coalesce_args[:-1]
+
+    chained_sysargs = []
+    current_sysargs = []
+    for arg in coalesce_args:
+        if arg != and_key:
+            current_sysargs.append(arg)
+        else:
+            chained_sysargs.append(current_sysargs)
+            current_sysargs = []
+    chained_sysargs.append(current_sysargs)
+    return chained_sysargs
+
+
 def parse_arguments(sysargs: List[str]) -> Dict[str, Any]:
     """
     Parse a list of arguments into standard Meerschaum arguments.
@@ -206,9 +244,24 @@ def parse_dict_to_sysargs(
     args_dict: Dict[str, Any]
 ) -> List[str]:
     """Revert an arguments dictionary back to a command line list."""
+    import shlex
     from meerschaum._internal.arguments._parser import get_arguments_triggers
-    sysargs = []
-    sysargs += args_dict.get('action', [])
+    from meerschaum.config.static import STATIC_CONFIG
+    from meerschaum.utils.warnings import warn
+
+    and_key = STATIC_CONFIG['system']['arguments']['and_key']
+    if (line := args_dict.get('line', None)):
+        return shlex.split(line)
+
+    if (_sysargs := args_dict.get('sysargs', None)):
+        return _sysargs
+
+    action = args_dict.get('action', None)
+    if action and and_key in action:
+        warn(f"Cannot determine flags from chained actions:\n{args_dict}")
+
+    sysargs: List[str] = []
+    sysargs.extend(action or [])
     allow_none_args = {'location_keys'}
 
     triggers = get_arguments_triggers()
@@ -216,6 +269,7 @@ def parse_dict_to_sysargs(
     for a, t in triggers.items():
         if a == 'action' or a not in args_dict:
             continue
+
         ### Add boolean flags
         if isinstance(args_dict[a], bool):
             if args_dict[a] is True:

meerschaum/_internal/entry.py

@@ -40,31 +40,68 @@ def entry(sysargs: Optional[List[str]] = None) -> SuccessTuple:
     -------
     A `SuccessTuple` indicating success.
     """
-    from meerschaum._internal.arguments import parse_arguments
+    import shlex
+    from meerschaum.utils.formatting import make_header
+    from meerschaum._internal.arguments import parse_arguments, split_chained_sysargs
     from meerschaum.config.static import STATIC_CONFIG
     if sysargs is None:
         sysargs = []
     if not isinstance(sysargs, list):
-        import shlex
         sysargs = shlex.split(sysargs)
-    args = parse_arguments(sysargs)
-    argparse_exception = args.get(
-        STATIC_CONFIG['system']['arguments']['failure_key'],
-        None,
+
+    has_daemon = '-d' in sysargs or '--daemon' in sysargs
+    has_start_job = sysargs[:2] == ['start', 'job']
+    chained_sysargs = (
+        [sysargs]
+        if has_daemon or has_start_job
+        else split_chained_sysargs(sysargs)
     )
-    if argparse_exception is not None:
-        args_text = args.get('text', '')
-        if not args_text.startswith('show arguments'):
-            return (
-                False,
+    results: List[SuccessTuple] = []
+
+    for _sysargs in chained_sysargs:
+        args = parse_arguments(_sysargs)
+        argparse_exception = args.get(
+            STATIC_CONFIG['system']['arguments']['failure_key'],
+            None,
+        )
+        if argparse_exception is not None:
+            args_text = args.get('text', '')
+            if not args_text.startswith('show arguments'):
+                return (
+                    False,
+                    (
+                        "Invalid arguments:"
+                        + (f"\n{args_text}" if args_text else '')
+                        + f"\n    {argparse_exception}"
+                    )
+                )
+
+        entry_success, entry_msg = entry_with_args(**args)
+        if not entry_success:
+            return entry_success, entry_msg
+
+        results.append((entry_success, entry_msg))
+
+    success = all(_success for _success, _ in results)
+    msg = (
+        results[0][1]
+        if len(results) == 1
+        else 'Successfully completed steps:\n\n' + '\n'.join(
+            [
                 (
-                    "Invalid arguments:"
-                    + (f"\n{args_text}" if args_text else '')
-                    + f"\n    {argparse_exception}"
+                    make_header(shlex.join(_sysargs))
+                    + '\n    ' + _msg + '\n'
                 )
-            )
+                for i, ((_, _msg), _sysargs) in enumerate(zip(results, chained_sysargs))
+            ]
+        )
+    )
+    if _systemd_result_path:
+        import json
+        with open(_systemd_result_path, 'w+', encoding='utf-8') as f:
+            json.dump((success, msg), f)
 
-    return entry_with_args(**args)
+    return success, msg
 
 
 def entry_with_args(
@@ -79,7 +116,16 @@ def entry_with_args(
     import inspect
     from meerschaum.actions import get_action, get_main_action_name
     from meerschaum._internal.arguments import remove_leading_action
-    from meerschaum.utils.venv import Venv, active_venvs, deactivate_venv
+    from meerschaum.utils.venv import active_venvs, deactivate_venv
+    from meerschaum.config.static import STATIC_CONFIG
+
+    and_key = STATIC_CONFIG['system']['arguments']['and_key']
+    escaped_and_key = STATIC_CONFIG['system']['arguments']['escaped_and_key']
+    if and_key in (sysargs := kw.get('sysargs', [])):
+        if '-d' in sysargs or '--daemon' in sysargs:
+            sysargs = [(arg if arg != and_key else escaped_and_key) for arg in sysargs]
+        return entry(sysargs)
+
     if kw.get('trace', None):
         from meerschaum.utils.misc import debug_trace
         debug_trace()
@@ -159,11 +205,6 @@ def entry_with_args(
     for venv in [venv for venv in active_venvs]:
         deactivate_venv(venv, debug=kw.get('debug', False), force=True)
 
-    if _systemd_result_path:
-        import json
-        with open(_systemd_result_path, 'w+', encoding='utf-8') as f:
-            json.dump(result, f)
-
     return result
 
 

meerschaum/_internal/shell/Shell.py

@@ -8,6 +8,8 @@ This module is the entry point for the interactive shell.
 from __future__ import annotations
 import os
 from copy import deepcopy
+from itertools import chain
+
 from meerschaum.utils.typing import Union, SuccessTuple, Any, Callable, Optional, List, Dict
 from meerschaum.utils.packages import attempt_import
 from meerschaum.config import __doc__, __version__ as version, get_config
@@ -30,6 +32,12 @@ from meerschaum._internal.shell.ShellCompleter import ShellCompleter
 _clear_screen = get_config('shell', 'clear_screen', patch=True)
 from meerschaum.utils.misc import string_width, remove_ansi
 from meerschaum.jobs import get_executor_keys_from_context
+from meerschaum.config.static import STATIC_CONFIG
+from meerschaum._internal.arguments._parse_arguments import (
+    split_chained_sysargs,
+    parse_arguments,
+    parse_line,
+)
 
 patch = True
 ### remove default cmd2 commands
@@ -63,6 +71,8 @@ reserved_completers = {
 ### To handle dynamic reloading, store shell attributes externally.
 ### This is because the shell object address gets lost upon reloads.
 shell_attrs = {}
+AND_KEY: str = STATIC_CONFIG['system']['arguments']['and_key']
+ESCAPED_AND_KEY: str = STATIC_CONFIG['system']['arguments']['escaped_and_key']
 
 def _insert_shell_actions(
         _shell: Optional['Shell'] = None,
@@ -111,7 +121,6 @@ def _completer_wrapper(
         if _check_keys is not None:
             return _check_keys
 
-        from meerschaum._internal.arguments._parse_arguments import parse_line
         args = parse_line(line)
         if target.__name__ != 'default_action_completer':
             if len(args['action']) > 0:
@@ -149,7 +158,6 @@ def default_action_completer(
 
 def _check_complete_keys(line: str) -> Optional[List[str]]:
     from meerschaum._internal.arguments._parser import parser, get_arguments_triggers
-    from meerschaum._internal.arguments._parse_arguments import parse_line
 
     ### TODO Add all triggers
     trigger_args = {
@@ -546,16 +554,68 @@ class Shell(cmd.Cmd):
             else:
                 main_action_name = args['action'][0]
 
+        def _add_flag_to_sysargs(
+                chained_sysargs, key, value, flag, shell_key=None,
+            ):
+            shell_key = shell_key or key
+            shell_value = remove_ansi(shell_attrs.get(shell_key) or '')
+            if key == 'mrsm_instance':
+                default_value = get_config('meerschaum', 'instance')
+            elif key == 'repository':
+                default_value = get_config('meerschaum', 'default_repository')
+            elif key == 'executor_keys':
+                default_value = get_executor_keys_from_context()
+            else:
+                default_value = None
+
+            if shell_value == default_value:
+                return
+
+            for sysargs in chained_sysargs:
+                kwargs = parse_arguments(sysargs)
+                if key in kwargs:
+                    continue
+                sysargs.extend([flag, value])
+
+            args['sysargs'] = list(
+                chain.from_iterable(
+                    sub_sysargs + [AND_KEY]
+                    for sub_sysargs in chained_sysargs
+                )
+            )[:-1]
+
+
         ### if no instance is provided, use current shell default,
         ### but not for the 'api' command (to avoid recursion)
-        if 'mrsm_instance' not in args and main_action_name != 'api':
-            args['mrsm_instance'] = str(shell_attrs['instance_keys'])
+        if main_action_name != 'api':
+            chained_sysargs = split_chained_sysargs(args['sysargs'])
+            chained_filtered_sysargs = split_chained_sysargs(args['filtered_sysargs'])
+            mrsm_instance = shell_attrs['instance_keys']
+            args['mrsm_instance'] = mrsm_instance
+            _add_flag_to_sysargs(
+                chained_sysargs, 'mrsm_instance', mrsm_instance, '-i', 'instance_keys',
+            )
+            _add_flag_to_sysargs(
+                chained_filtered_sysargs, 'mrsm_instance', mrsm_instance, '-i', 'instance_keys',
+            )
 
-        if 'repository' not in args and main_action_name != 'api':
-            args['repository'] = str(shell_attrs['repo_keys'])
+            repo_keys = str(shell_attrs['repo_keys'])
+            args['repository'] = repo_keys
+            _add_flag_to_sysargs(
+                chained_sysargs, 'repository', repo_keys, '-r', 'repo_keys',
+            )
+            _add_flag_to_sysargs(
+                chained_filtered_sysargs, 'repository', repo_keys, '-r', 'repo_keys',
+            )
 
-        if 'executor_keys' not in args:
-            args['executor_keys'] = remove_ansi(str(shell_attrs['executor_keys']))
+            executor_keys = remove_ansi(str(shell_attrs['executor_keys']))
+            args['executor_keys'] = remove_ansi(executor_keys)
+            _add_flag_to_sysargs(
+                chained_sysargs, 'executor_keys', executor_keys, '-e',
+            )
+            _add_flag_to_sysargs(
+                chained_filtered_sysargs, 'executor_keys', executor_keys, '-e',
+            )
 
         ### parse out empty strings
         if args['action'][0].strip("\"'") == '':
@@ -630,12 +690,12 @@ class Shell(cmd.Cmd):
         info(f"Debug mode is {'on' if shell_attrs['debug'] else 'off'}.")
 
     def do_instance(
-            self,
-            action: Optional[List[str]] = None,
-            executor_keys=None,
-            debug: bool = False,
-            **kw: Any
-        ) -> SuccessTuple:
+        self,
+        action: Optional[List[str]] = None,
+        executor_keys=None,
+        debug: bool = False,
+        **kw: Any
+    ) -> SuccessTuple:
         """
         Temporarily set a default Meerschaum instance for the duration of the shell.
         The default instance is loaded from the Meerschaum configuraton file
@@ -804,6 +864,7 @@ class Shell(cmd.Cmd):
         from meerschaum import get_connector
         from meerschaum.connectors.parse import parse_executor_keys
         from meerschaum.utils.warnings import warn, info
+        from meerschaum.jobs import get_executor_keys_from_context
 
         if action is None:
             action = []
@@ -814,6 +875,10 @@ class Shell(cmd.Cmd):
             executor_keys = ''
         if executor_keys == '':
             executor_keys = get_executor_keys_from_context()
+
+        if executor_keys == 'systemd' and get_executor_keys_from_context() != 'systemd':
+            warn(f"Cannot execute via `systemd`, falling back to `local`...", stack=False)
+            executor_keys = 'local'
         
         conn = parse_executor_keys(executor_keys, debug=debug)
 
@@ -987,7 +1052,7 @@ def input_with_sigint(_input, session, shell: Optional[Shell] = None):
         )
 
         try:
-            typ, label = shell_attrs['instance_keys'].split(':')
+            typ, label = shell_attrs['instance_keys'].split(':', maxsplit=1)
             connected = typ in connectors and label in connectors[typ]
         except Exception as e:
             connected = False

meerschaum/actions/delete.py

@@ -509,12 +509,22 @@ def _complete_delete_jobs(
         get_stopped_jobs,
         get_paused_jobs,
         get_running_jobs,
+        get_executor_keys_from_context,
     )
     from meerschaum.utils.misc import remove_ansi
+    from meerschaum.connectors.parse import parse_executor_keys
 
-    executor_keys = executor_keys or remove_ansi(shell_attrs.get('executor_keys', 'local'))
+    executor_keys = (
+        executor_keys
+        or remove_ansi(
+            shell_attrs.get('executor_keys', get_executor_keys_from_context())
+        )
+    )
+
+    if parse_executor_keys(executor_keys, construct=False) is None:
+        return []
 
-    jobs = get_jobs(executor_keys)
+    jobs = get_jobs(executor_keys, include_hidden=False)
     if _get_job_method:
         method_keys = [_get_job_method] if isinstance(_get_job_method, str) else _get_job_method
         method_jobs = {}
@@ -540,11 +550,11 @@ def _complete_delete_jobs(
 
 
 def _delete_venvs(
-        action: Optional[List[str]] = None,
-        yes: bool = False,
-        force: bool = False,
-        **kwargs: Any
-    ) -> SuccessTuple:
+    action: Optional[List[str]] = None,
+    yes: bool = False,
+    force: bool = False,
+    **kwargs: Any
+) -> SuccessTuple:
     """
     Remove virtual environments.
     Specify which venvs to remove, or remove everything at once.

meerschaum/actions/start.py

@@ -82,6 +82,7 @@ def _start_api(action: Optional[List[str]] = None, **kw):
     from meerschaum.actions import actions
     return actions['api'](action=['start'], **kw)
 
+
 def _start_jobs(
     action: Optional[List[str]] = None,
     name: Optional[str] = None,
@@ -119,25 +120,20 @@ def _start_jobs(
                 Start the job 'happy_seal' but via the `--name` flag.
                 This only applies when no text follows the words 'start job'.
     """
-    import textwrap
     from meerschaum.utils.warnings import warn, info
     from meerschaum.utils.daemon._names import get_new_daemon_name
     from meerschaum.jobs import (
         Job,
-        get_jobs,
         get_filtered_jobs,
         get_stopped_jobs,
         get_running_jobs,
         get_paused_jobs,
-        get_restart_jobs,
         _install_healthcheck_job,
     )
-    from meerschaum._internal.arguments._parse_arguments import parse_arguments
     from meerschaum.actions import actions
     from meerschaum.utils.prompt import yes_no
     from meerschaum.utils.formatting import print_tuple
-    from meerschaum.utils.formatting._jobs import pprint_job, pprint_jobs
-    from meerschaum.utils.formatting._shell import clear_screen
+    from meerschaum.utils.formatting._jobs import pprint_jobs
     from meerschaum.utils.misc import items_str
 
     names = []

meerschaum/api/dash/callbacks/jobs.py

@@ -24,13 +24,13 @@ from dash import Patch
 html, dcc = import_html(check_update=CHECK_UPDATE), import_dcc(check_update=CHECK_UPDATE)
 import dash_bootstrap_components as dbc
 from meerschaum.api.dash.components import alert_from_success_tuple, build_cards_grid
-from meerschaum.utils.daemon import Daemon
 from dash.exceptions import PreventUpdate
 from meerschaum.api.dash.jobs import (
     build_manage_job_buttons_div_children,
     build_status_children,
     build_process_timestamps_children,
 )
+from meerschaum.jobs import Job
 from meerschaum.api.dash.users import is_session_authenticated
 
 @dash_app.callback(
@@ -53,15 +53,11 @@ def download_job_logs(n_clicks):
         raise PreventUpdate
 
     component_dict = json.loads(ctx[0]['prop_id'].split('.' + 'n_clicks')[0])
-    daemon_id = component_dict['index']
-    daemon = Daemon(daemon_id=daemon_id)
+    job_name = component_dict['index']
     now = datetime.now(timezone.utc)
-    filename = (
-        daemon.rotating_log.file_path.name[:(-1 * len('.log'))]
-        + '_' + str(int(now.timestamp())) + '.log'
-    )
+    filename = job_name + '_' + str(int(now.timestamp())) + '.log'
     return {
-        'content': daemon.log_text,
+        'content': job.get_logs(),
         'filename': filename,
     }
 
@@ -73,12 +69,14 @@ def download_job_logs(n_clicks):
     Output({'type': 'process-timestamps-div', 'index': MATCH}, 'children'),
     Input({'type': 'manage-job-button', 'action': ALL, 'index': MATCH}, 'n_clicks'),
     State('session-store', 'data'),
+    State({'type': 'job-label-p', 'index': MATCH}, 'children'),
     prevent_initial_call = True,
 )
 def manage_job_button_click(
-        n_clicks: Optional[int] = None,
-        session_data: Optional[Dict[str, Any]] = None,
-    ):
+    n_clicks: Optional[int] = None,
+    session_data: Optional[Dict[str, Any]] = None,
+    job_label: Optional[str] = None,
+):
     """
     Start, stop, pause, or delete the given job.
     """
@@ -102,20 +100,20 @@ def manage_job_button_click(
         raise PreventUpdate
 
     component_dict = json.loads(ctx[0]['prop_id'].split('.' + 'n_clicks')[0])
-    daemon_id = component_dict['index']
+    job_name = component_dict['index']
     manage_job_action = component_dict['action']
     try:
-        daemon = Daemon(daemon_id=daemon_id)
+        job = Job(job_name, job_label.replace('\n', ' ') if job_label else None)
     except Exception as e:
-        daemon = None
-    if daemon is None:
+        job = None
+    if job is None:
         raise PreventUpdate
 
     manage_functions = {
-        'start': functools.partial(daemon.run, allow_dirty_run=True),
-        'stop': daemon.quit,
-        'pause': daemon.pause,
-        'delete': daemon.cleanup,
+        'start': job.start,
+        'stop': job.stop,
+        'pause': job.pause,
+        'delete': job.delete,
     }
     if manage_job_action not in manage_functions:
         return (
@@ -125,7 +123,7 @@ def manage_job_button_click(
             dash.no_update,
         )
 
-    old_status = daemon.status
+    old_status = job.status
     try:
         success, msg = manage_functions[manage_job_action]()
     except Exception as e:
@@ -136,15 +134,15 @@ def manage_job_button_click(
     check_interval_seconds = 0.01
     begin = time.perf_counter()
     while (time.perf_counter() - begin) < timeout_seconds:
-        if daemon.status != old_status:
+        if job.status != old_status:
             break
         time.sleep(check_interval_seconds)
 
     return (
         alert_from_success_tuple((success, msg)),
-        build_manage_job_buttons_div_children(daemon),
-        build_status_children(daemon),
-        build_process_timestamps_children(daemon),
+        build_manage_job_buttons_div_children(job),
+        build_status_children(job),
+        build_process_timestamps_children(job),
     )
 
 dash_app.clientside_callback(
@@ -165,7 +163,7 @@ dash_app.clientside_callback(
         }
 
         const triggered_id = dash_clientside.callback_context.triggered_id;
-        const job_daemon_id = triggered_id["index"];
+        const job_name = triggered_id["index"];
 
         iframe = document.getElementById('webterm-iframe');
         if (!iframe){ return dash_clientside.no_update; }
@@ -174,7 +172,7 @@ dash_app.clientside_callback(
             {
                action: "show",
                subaction: "logs",
-               subaction_text: job_daemon_id,
+               subaction_text: job_name,
             },
             url
         );
@@ -197,44 +195,38 @@ dash_app.clientside_callback(
     prevent_initial_call = True,
 )
 def refresh_jobs_on_interval(
-        n_intervals: Optional[int] = None,
-        session_data: Optional[Dict[str, Any]] = None,
-    ):
+    n_intervals: Optional[int] = None,
+    session_data: Optional[Dict[str, Any]] = None,
+):
     """
     When the jobs refresh interval fires, rebuild the jobs' onscreen components.
     """
     session_id = session_data.get('session-id', None)
     is_authenticated = is_session_authenticated(session_id)
 
-    daemon_ids = [
+    job_names = [
         component_dict['id']['index']
         for component_dict in dash.callback_context.outputs_grouping[0]
     ]
 
-    ### NOTE: The daemon may have been deleted, but the card may still exist.
-    daemons = []
-    for daemon_id in daemon_ids:
-        try:
-            daemon = Daemon(daemon_id=daemon_id)
-        except Exception as e:
-            daemon = None
-        daemons.append(daemon)
+    ### NOTE: The job may have been deleted, but the card may still exist.
+    jobs = [Job(name) for name in job_names]
 
     return (
         [
             (
-                build_manage_job_buttons_div_children(daemon)
+                build_manage_job_buttons_div_children(job)
                 if is_authenticated
                 else []
             )
-            for daemon in daemons
+            for job in jobs
         ],
         [
-            build_status_children(daemon)
-            for daemon in daemons
+            build_status_children(job)
+            for job in jobs
         ],
         [
-            build_process_timestamps_children(daemon)
-            for daemon in daemons
+            build_process_timestamps_children(job)
+            for job in jobs
         ],
     )