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

meerschaum/utils/daemon/Daemon.py

@@ -8,6 +8,7 @@ Manage running daemons via the Daemon class.
 
 from __future__ import annotations
 import os
+import importlib
 import pathlib
 import json
 import shutil
@@ -17,22 +18,59 @@ import time
 import traceback
 from functools import partial
 from datetime import datetime, timezone
-from meerschaum.utils.typing import Optional, Dict, Any, SuccessTuple, Callable, List, Union
+
+import meerschaum as mrsm
+from meerschaum.utils.typing import (
+    Optional, Dict, Any, SuccessTuple, Callable, List, Union,
+    is_success_tuple, Tuple,
+)
 from meerschaum.config import get_config
 from meerschaum.config.static import STATIC_CONFIG
-from meerschaum.config._paths import DAEMON_RESOURCES_PATH, LOGS_RESOURCES_PATH
+from meerschaum.config._paths import (
+    DAEMON_RESOURCES_PATH, LOGS_RESOURCES_PATH, DAEMON_ERROR_LOG_PATH,
+)
 from meerschaum.config._patch import apply_patch_to_config
 from meerschaum.utils.warnings import warn, error
 from meerschaum.utils.packages import attempt_import
 from meerschaum.utils.venv import venv_exec
 from meerschaum.utils.daemon._names import get_new_daemon_name
 from meerschaum.utils.daemon.RotatingFile import RotatingFile
+from meerschaum.utils.daemon.StdinFile import StdinFile
 from meerschaum.utils.threading import RepeatTimer
 from meerschaum.__main__ import _close_pools
 
+_daemons = []
+_results = {}
+
 class Daemon:
     """
     Daemonize Python functions into background processes.
+
+    Examples
+    --------
+    >>> import meerschaum as mrsm
+    >>> from meerschaum.utils.daemons import Daemon
+    >>> daemon = Daemon(print, ('hi',))
+    >>> success, msg = daemon.run()
+    >>> print(daemon.log_text)
+
+    2024-07-29 18:03 | hi
+    2024-07-29 18:03 |
+    >>> daemon.run(allow_dirty_run=True)
+    >>> print(daemon.log_text)
+
+    2024-07-29 18:03 | hi
+    2024-07-29 18:03 |
+    2024-07-29 18:05 | hi
+    2024-07-29 18:05 |
+    >>> mrsm.pprint(daemon.properties)
+    {
+        'label': 'print',
+        'target': {'name': 'print', 'module': 'builtins', 'args': ['hi'], 'kw': {}},
+        'result': None,
+        'process': {'ended': '2024-07-29T18:03:33.752806'}
+    }
+
     """
 
     def __new__(
@@ -51,10 +89,57 @@ class Daemon:
                 instance = instance.read_pickle()
         return instance
 
+    @classmethod
+    def from_properties_file(cls, daemon_id: str) -> Daemon:
+        """
+        Return a Daemon from a properties dictionary.
+        """
+        properties_path = cls._get_properties_path_from_daemon_id(daemon_id)
+        if not properties_path.exists():
+            raise OSError(f"Properties file '{properties_path}' does not exist.")
+
+        try:
+            with open(properties_path, 'r', encoding='utf-8') as f:
+                properties = json.load(f)
+        except Exception:
+            properties = {}
+
+        if not properties:
+            raise ValueError(f"No properties could be read for daemon '{daemon_id}'.")
+
+        daemon_id = properties_path.parent.name
+        target_cf = properties.get('target', {})
+        target_module_name = target_cf.get('module', None)
+        target_function_name = target_cf.get('name', None)
+        target_args = target_cf.get('args', None)
+        target_kw = target_cf.get('kw', None)
+        label = properties.get('label', None)
+
+        if None in [
+            target_module_name,
+            target_function_name,
+            target_args,
+            target_kw,
+        ]:
+            raise ValueError("Missing target function information.")
+
+        target_module = importlib.import_module(target_module_name)
+        target_function = getattr(target_module, target_function_name)
+
+        return Daemon(
+            daemon_id=daemon_id,
+            target=target_function,
+            target_args=target_args,
+            target_kw=target_kw,
+            properties=properties,
+            label=label,
+        )
+
+
     def __init__(
         self,
         target: Optional[Callable[[Any], Any]] = None,
-        target_args: Optional[List[str]] = None,
+        target_args: Union[List[Any], Tuple[Any], None] = None,
         target_kw: Optional[Dict[str, Any]] = None,
         daemon_id: Optional[str] = None,
         label: Optional[str] = None,
@@ -66,7 +151,7 @@ class Daemon:
         target: Optional[Callable[[Any], Any]], default None,
             The function to execute in a child process.
 
-        target_args: Optional[List[str]], default None
+        target_args: Union[List[Any], Tuple[Any], None], default None
             Positional arguments to pass to the target function.
 
         target_kw: Optional[Dict[str, Any]], default None
@@ -81,25 +166,54 @@ class Daemon:
             Label string to help identifiy a daemon.
             If `None`, use the function name instead.
 
-        propterties: Optional[Dict[str, Any]], default None
+        properties: Optional[Dict[str, Any]], default None
             Override reading from the properties JSON by providing an existing dictionary.
         """
         _pickle = self.__dict__.get('_pickle', False)
         if daemon_id is not None:
             self.daemon_id = daemon_id
             if not self.pickle_path.exists() and not target and ('target' not in self.__dict__):
-                raise Exception(
-                    f"Daemon '{self.daemon_id}' does not exist. "
-                    + "Pass a target to create a new Daemon."
-                )
+
+                if not self.properties_path.exists():
+                    raise Exception(
+                        f"Daemon '{self.daemon_id}' does not exist. "
+                        + "Pass a target to create a new Daemon."
+                    )
+
+                try:
+                    new_daemon = self.from_properties_file(daemon_id)
+                except Exception:
+                    new_daemon = None
+
+                if new_daemon is not None:
+                    new_daemon.write_pickle()
+                    target = new_daemon.target
+                    target_args = new_daemon.target_args
+                    target_kw = new_daemon.target_kw
+                    label = new_daemon.label
+                    self._properties = new_daemon.properties
+                else:
+                    try:
+                        self.properties_path.unlink()
+                    except Exception:
+                        pass
+
+                    raise Exception(
+                        f"Could not recover daemon '{self.daemon_id}' "
+                        + "from its properties file."
+                    )
+
         if 'target' not in self.__dict__:
             if target is None:
-                error(f"Cannot create a Daemon without a target.")
+                error("Cannot create a Daemon without a target.")
             self.target = target
-        if 'target_args' not in self.__dict__:
-            self.target_args = target_args if target_args is not None else []
-        if 'target_kw' not in self.__dict__:
-            self.target_kw = target_kw if target_kw is not None else {}
+
+        ### NOTE: We have to check self.__dict__ in case we un-pickling.
+        if '_target_args' not in self.__dict__:
+            self._target_args = target_args
+        if '_target_kw' not in self.__dict__:
+            self._target_kw = target_kw
+
         if 'label' not in self.__dict__:
             if label is None:
                 label = (
@@ -113,16 +227,16 @@ class Daemon:
             self._properties = properties
         if self._properties is None:
             self._properties = {}
-        self._properties.update({'label' : self.label})
+        self._properties.update({'label': self.label})
         ### Instantiate the process and if it doesn't exist, make sure the PID is removed.
         _ = self.process
 
 
     def _run_exit(
-            self,
-            keep_daemon_output: bool = True,
-            allow_dirty_run: bool = False,
-        ) -> Any:
+        self,
+        keep_daemon_output: bool = True,
+        allow_dirty_run: bool = False,
+    ) -> Any:
         """Run the daemon's target function.
         NOTE: This WILL EXIT the parent process!
 
@@ -130,7 +244,7 @@ class Daemon:
         ----------
         keep_daemon_output: bool, default True
             If `False`, delete the daemon's output directory upon exiting.
-            
+
         allow_dirty_run, bool, default False:
             If `True`, run the daemon, even if the `daemon_id` directory exists.
             This option is dangerous because if the same `daemon_id` runs twice,
@@ -141,31 +255,34 @@ class Daemon:
         Nothing — this will exit the parent process.
         """
         import platform, sys, os, traceback
-        from meerschaum.config._paths import DAEMON_ERROR_LOG_PATH
         from meerschaum.utils.warnings import warn
         from meerschaum.config import get_config
         daemon = attempt_import('daemon')
         lines = get_config('jobs', 'terminal', 'lines')
-        columns = get_config('jobs','terminal', 'columns')
+        columns = get_config('jobs', 'terminal', 'columns')
 
         if platform.system() == 'Windows':
             return False, "Windows is no longer supported."
 
         self._setup(allow_dirty_run)
 
+        ### NOTE: The SIGINT handler has been removed so that child processes may handle
+        ###       KeyboardInterrupts themselves.
+        ###       The previous aggressive approach was redundant because of the SIGTERM handler.
         self._daemon_context = daemon.DaemonContext(
-            pidfile = self.pid_lock,
-            stdout = self.rotating_log,
-            stderr = self.rotating_log,
-            working_directory = os.getcwd(),
-            detach_process = True,
-            files_preserve = list(self.rotating_log.subfile_objects.values()),
-            signal_map = {
-                signal.SIGINT: self._handle_interrupt,
+            pidfile=self.pid_lock,
+            stdout=self.rotating_log,
+            stderr=self.rotating_log,
+            working_directory=os.getcwd(),
+            detach_process=True,
+            files_preserve=list(self.rotating_log.subfile_objects.values()),
+            signal_map={
                 signal.SIGTERM: self._handle_sigterm,
             },
         )
 
+        _daemons.append(self)
+
         log_refresh_seconds = get_config('jobs', 'logs', 'refresh_files_seconds')
         self._log_refresh_timer = RepeatTimer(
             log_refresh_seconds,
@@ -175,55 +292,56 @@ class Daemon:
         try:
             os.environ['LINES'], os.environ['COLUMNS'] = str(int(lines)), str(int(columns))
             with self._daemon_context:
+                sys.stdin = self.stdin_file
                 os.environ[STATIC_CONFIG['environment']['daemon_id']] = self.daemon_id
+                os.environ['PYTHONUNBUFFERED'] = '1'
                 self.rotating_log.refresh_files(start_interception=True)
+                result = None
                 try:
                     with open(self.pid_path, 'w+', encoding='utf-8') as f:
                         f.write(str(os.getpid()))
 
                     self._log_refresh_timer.start()
+                    self.properties['result'] = None
+                    self._capture_process_timestamp('began')
                     result = self.target(*self.target_args, **self.target_kw)
                     self.properties['result'] = result
+                except (BrokenPipeError, KeyboardInterrupt, SystemExit):
+                    pass
                 except Exception as e:
-                    warn(f"Exception in daemon target function: {e}", stacklevel=3)
+                    warn(
+                        f"Exception in daemon target function: {traceback.format_exc()}",
+                    )
                     result = e
                 finally:
+                    _results[self.daemon_id] = result
+
+                    if keep_daemon_output:
+                        self._capture_process_timestamp('ended')
+                    else:
+                        self.cleanup()
+
                     self._log_refresh_timer.cancel()
-                    self.rotating_log.close()
                     if self.pid is None and self.pid_path.exists():
                         self.pid_path.unlink()
 
-                if keep_daemon_output:
-                    self._capture_process_timestamp('ended')
-                else:
-                    self.cleanup()
+                    if is_success_tuple(result):
+                        try:
+                            mrsm.pprint(result)
+                        except BrokenPipeError:
+                            pass
 
-                return result
         except Exception as e:
             daemon_error = traceback.format_exc()
             with open(DAEMON_ERROR_LOG_PATH, 'a+', encoding='utf-8') as f:
                 f.write(daemon_error)
             warn(f"Encountered an error while running the daemon '{self}':\n{daemon_error}")
-        finally:
-            self._cleanup_on_exit()
-
-    def _cleanup_on_exit(self):
-        """Perform cleanup operations when the daemon exits."""
-        try:
-            self._log_refresh_timer.cancel()
-            self.rotating_log.close()
-            if self.pid is None and self.pid_path.exists():
-                self.pid_path.unlink()
-            self._capture_process_timestamp('ended')
-        except Exception as e:
-            warn(f"Error during daemon cleanup: {e}")
-
 
     def _capture_process_timestamp(
-            self,
-            process_key: str,
-            write_properties: bool = True,
-        ) -> None:
+        self,
+        process_key: str,
+        write_properties: bool = True,
+    ) -> None:
         """
         Record the current timestamp to the parameters `process:<process_key>`.
 
@@ -238,7 +356,7 @@ class Daemon:
         if 'process' not in self.properties:
             self.properties['process'] = {}
 
-        if process_key not in ('began', 'ended', 'paused'):
+        if process_key not in ('began', 'ended', 'paused', 'stopped'):
             raise ValueError(f"Invalid key '{process_key}'.")
 
         self.properties['process'][process_key] = (
@@ -247,13 +365,12 @@ class Daemon:
         if write_properties:
             self.write_properties()
 
-
     def run(
-            self,
-            keep_daemon_output: bool = True,
-            allow_dirty_run: bool = False,
-            debug: bool = False,
-        ) -> SuccessTuple:
+        self,
+        keep_daemon_output: bool = True,
+        allow_dirty_run: bool = False,
+        debug: bool = False,
+    ) -> SuccessTuple:
         """Run the daemon as a child process and continue executing the parent.
 
         Parameters
@@ -279,6 +396,10 @@ class Daemon:
         if self.status == 'paused':
             return self.resume()
 
+        self._remove_stop_file()
+        if self.status == 'running':
+            return True, f"Daemon '{self}' is already running."
+
         self.mkdir_if_not_exists(allow_dirty_run)
         _write_pickle_success_tuple = self.write_pickle()
         if not _write_pickle_success_tuple[0]:
@@ -288,7 +409,7 @@ class Daemon:
             "from meerschaum.utils.daemon import Daemon; "
             + f"daemon = Daemon(daemon_id='{self.daemon_id}'); "
             + f"daemon._run_exit(keep_daemon_output={keep_daemon_output}, "
-            + f"allow_dirty_run=True)"
+            + "allow_dirty_run=True)"
         )
         env = dict(os.environ)
         env['MRSM_NOASK'] = 'true'
@@ -298,12 +419,11 @@ class Daemon:
             if _launch_success_bool
             else f"Failed to start daemon '{self.daemon_id}'."
         )
-        self._capture_process_timestamp('began')
         return _launch_success_bool, msg
 
-
-    def kill(self, timeout: Optional[int] = 8) -> SuccessTuple:
-        """Forcibly terminate a running daemon.
+    def kill(self, timeout: Union[int, float, None] = 8) -> SuccessTuple:
+        """
+        Forcibly terminate a running daemon.
         Sends a SIGTERM signal to the process.
 
         Parameters
@@ -318,10 +438,11 @@ class Daemon:
         if self.status != 'paused':
             success, msg = self._send_signal(signal.SIGTERM, timeout=timeout)
             if success:
-                self._capture_process_timestamp('ended')
+                self._write_stop_file('kill')
                 return success, msg
 
         if self.status == 'stopped':
+            self._write_stop_file('kill')
             return True, "Process has already stopped."
 
         process = self.process
@@ -332,30 +453,30 @@ class Daemon:
         except Exception as e:
             return False, f"Failed to kill job {self} with exception: {e}"
 
-        self._capture_process_timestamp('ended')
         if self.pid_path.exists():
             try:
                 self.pid_path.unlink()
             except Exception as e:
                 pass
-        return True, "Success"
 
+        self._write_stop_file('kill')
+        return True, "Success"
 
     def quit(self, timeout: Union[int, float, None] = None) -> SuccessTuple:
         """Gracefully quit a running daemon."""
         if self.status == 'paused':
             return self.kill(timeout)
+
         signal_success, signal_msg = self._send_signal(signal.SIGINT, timeout=timeout)
         if signal_success:
-            self._capture_process_timestamp('ended')
+            self._write_stop_file('quit')
         return signal_success, signal_msg
 
-
     def pause(
-            self,
-            timeout: Union[int, float, None] = None,
-            check_timeout_interval: Union[float, int, None] = None,
-        ) -> SuccessTuple:
+        self,
+        timeout: Union[int, float, None] = None,
+        check_timeout_interval: Union[float, int, None] = None,
+    ) -> SuccessTuple:
         """
         Pause the daemon if it is running.
 
@@ -377,6 +498,7 @@ class Daemon:
         if self.status == 'paused':
             return True, f"Daemon '{self.daemon_id}' is already paused."
 
+        self._write_stop_file('pause')
         try:
             self.process.suspend()
         except Exception as e:
@@ -414,12 +536,11 @@ class Daemon:
             + ('s' if timeout != 1 else '') + '.'
         )
 
-
     def resume(
-            self,
-            timeout: Union[int, float, None] = None,
-            check_timeout_interval: Union[float, int, None] = None,
-        ) -> SuccessTuple:
+        self,
+        timeout: Union[int, float, None] = None,
+        check_timeout_interval: Union[float, int, None] = None,
+    ) -> SuccessTuple:
         """
         Resume the daemon if it is paused.
 
@@ -441,6 +562,7 @@ class Daemon:
         if self.status == 'stopped':
             return False, f"Daemon '{self.daemon_id}' is stopped and cannot be resumed."
 
+        self._remove_stop_file()
         try:
             self.process.resume()
         except Exception as e:
@@ -470,38 +592,50 @@ class Daemon:
             + ('s' if timeout != 1 else '') + '.'
         )
 
+    def _write_stop_file(self, action: str) -> SuccessTuple:
+        """Write the stop file timestamp and action."""
+        if action not in ('quit', 'kill', 'pause'):
+            return False, f"Unsupported action '{action}'."
+
+        if not self.stop_path.parent.exists():
+            self.stop_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(self.stop_path, 'w+', encoding='utf-8') as f:
+            json.dump(
+                {
+                    'stop_time': datetime.now(timezone.utc).isoformat(),
+                    'action': action,
+                },
+                f
+            )
 
-    def _handle_interrupt(self, signal_number: int, stack_frame: 'frame') -> None:
-        """
-        Handle `SIGINT` within the Daemon context.
-        This method is injected into the `DaemonContext`.
-        """
-        from meerschaum.utils.process import signal_handler
-        signal_handler(signal_number, stack_frame)
+        return True, "Success"
 
-        self.rotating_log.stop_log_fd_interception(unused_only=False)
-        timer = self.__dict__.get('_log_refresh_timer', None)
-        if timer is not None:
-            timer.cancel()
+    def _remove_stop_file(self) -> SuccessTuple:
+        """Remove the stop file"""
+        if not self.stop_path.exists():
+            return True, "Stop file does not exist."
 
-        daemon_context = self.__dict__.get('_daemon_context', None)
-        if daemon_context is not None:
-            daemon_context.close()
+        try:
+            self.stop_path.unlink()
+        except Exception as e:
+            return False, f"Failed to remove stop file:\n{e}"
 
-        _close_pools()
+        return True, "Success"
 
-        import threading
-        for thread in threading.enumerate():
-            if thread.name == 'MainThread':
-                continue
-            try:
-                if thread.is_alive():
-                    stack = traceback.format_stack(sys._current_frames()[thread.ident])
-                    thread.join()
-            except Exception as e:
-                warn(traceback.format_exc())
-        raise KeyboardInterrupt()
+    def _read_stop_file(self) -> Dict[str, Any]:
+        """
+        Read the stop file if it exists.
+        """
+        if not self.stop_path.exists():
+            return {}
 
+        try:
+            with open(self.stop_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            return data
+        except Exception:
+            return {}
 
     def _handle_sigterm(self, signal_number: int, stack_frame: 'frame') -> None:
         """
@@ -522,7 +656,6 @@ class Daemon:
         _close_pools()
         raise SystemExit(0)
 
- 
     def _send_signal(
             self,
             signal_to_send,
@@ -578,7 +711,6 @@ class Daemon:
             + ('s' if timeout != 1 else '') + '.'
         )
 
-
     def mkdir_if_not_exists(self, allow_dirty_run: bool = False):
         """Create the Daemon's directory.
         If `allow_dirty_run` is `False` and the directory already exists,
@@ -618,7 +750,6 @@ class Daemon:
                 return None
         return self._process
 
-
     @property
     def status(self) -> str:
         """
@@ -633,7 +764,7 @@ class Daemon:
                 return 'paused'
             if self.process.status() == 'zombie':
                 raise psutil.NoSuchProcess(self.process.pid)
-        except psutil.NoSuchProcess:
+        except (psutil.NoSuchProcess, AttributeError):
             if self.pid_path.exists():
                 try:
                     self.pid_path.unlink()
@@ -643,7 +774,6 @@ class Daemon:
 
         return 'running'
 
-
     @classmethod
     def _get_path_from_daemon_id(cls, daemon_id: str) -> pathlib.Path:
         """
@@ -651,7 +781,6 @@ class Daemon:
         """
         return DAEMON_RESOURCES_PATH / daemon_id
 
-
     @property
     def path(self) -> pathlib.Path:
         """
@@ -659,7 +788,6 @@ class Daemon:
         """
         return self._get_path_from_daemon_id(self.daemon_id)
 
-
     @classmethod
     def _get_properties_path_from_daemon_id(cls, daemon_id: str) -> pathlib.Path:
         """
@@ -667,7 +795,6 @@ class Daemon:
         """
         return cls._get_path_from_daemon_id(daemon_id) / 'properties.json'
 
-
     @property
     def properties_path(self) -> pathlib.Path:
         """
@@ -675,6 +802,12 @@ class Daemon:
         """
         return self._get_properties_path_from_daemon_id(self.daemon_id)
 
+    @property
+    def stop_path(self) -> pathlib.Path:
+        """
+        Return the path for the stop file (created when manually stopped).
+        """
+        return self.path / '.stop.json'
 
     @property
     def log_path(self) -> pathlib.Path:
@@ -683,6 +816,22 @@ class Daemon:
         """
         return LOGS_RESOURCES_PATH / (self.daemon_id + '.log')
 
+    @property
+    def stdin_file_path(self) -> pathlib.Path:
+        """
+        Return the stdin file path.
+        """
+        return self.path / 'input.stdin'
+
+    @property
+    def blocking_stdin_file_path(self) -> pathlib.Path:
+        """
+        Return the stdin file path.
+        """
+        if '_blocking_stdin_file_path' in self.__dict__:
+            return self._blocking_stdin_file_path
+
+        return self.path / 'input.stdin.block'
 
     @property
     def log_offset_path(self) -> pathlib.Path:
@@ -691,24 +840,46 @@ class Daemon:
         """
         return LOGS_RESOURCES_PATH / ('.' + self.daemon_id + '.log.offset')
 
-    
     @property
     def rotating_log(self) -> RotatingFile:
+        """
+        The rotating log file for the daemon's output.
+        """
         if '_rotating_log' in self.__dict__:
             return self._rotating_log
 
+        write_timestamps = (
+            self.properties.get('logs', {}).get('write_timestamps', None)
+        )
+        if write_timestamps is None:
+            write_timestamps = get_config('jobs', 'logs', 'timestamps', 'enabled')
+
         self._rotating_log = RotatingFile(
             self.log_path,
-            redirect_streams = True,
-            write_timestamps = get_config('jobs', 'logs', 'timestamps', 'enabled'),
-            timestamp_format = get_config('jobs', 'logs', 'timestamps', 'format'),
+            redirect_streams=True,
+            write_timestamps=write_timestamps,
+            timestamp_format=get_config('jobs', 'logs', 'timestamps', 'format'),
         )
         return self._rotating_log
 
+    @property
+    def stdin_file(self):
+        """
+        Return the file handler for the stdin file.
+        """
+        if '_stdin_file' in self.__dict__:
+            return self._stdin_file
+
+        self._stdin_file = StdinFile(
+            self.stdin_file_path,
+            lock_file_path=self.blocking_stdin_file_path,
+        )
+        return self._stdin_file
 
     @property
     def log_text(self) -> Optional[str]:
-        """Read the log files and return their contents.
+        """
+        Read the log files and return their contents.
         Returns `None` if the log file does not exist.
         """
         new_rotating_log = RotatingFile(
@@ -720,7 +891,6 @@ class Daemon:
         )
         return new_rotating_log.read()
 
-
     def readlines(self) -> List[str]:
         """
         Read the next log lines, persisting the cursor for later use.
@@ -731,7 +901,6 @@ class Daemon:
         self._write_log_offset()
         return lines
 
-
     def _read_log_offset(self) -> Tuple[int, int]:
         """
         Return the current log offset cursor.
@@ -749,7 +918,6 @@ class Daemon:
         subfile_index, subfile_position = int(cursor_parts[0]), int(cursor_parts[1])
         return subfile_index, subfile_position
 
-
     def _write_log_offset(self) -> None:
         """
         Write the current log offset file.
@@ -759,10 +927,10 @@ class Daemon:
             subfile_position = self.rotating_log._cursor[1]
             f.write(f"{subfile_index} {subfile_position}")
 
-
     @property
     def pid(self) -> Union[int, None]:
-        """Read the PID file and return its contents.
+        """
+        Read the PID file and return its contents.
         Returns `None` if the PID file does not exist.
         """
         if not self.pid_path.exists():
@@ -770,6 +938,8 @@ class Daemon:
         try:
             with open(self.pid_path, 'r', encoding='utf-8') as f:
                 text = f.read()
+            if len(text) == 0:
+                return None
             pid = int(text.rstrip())
         except Exception as e:
             warn(e)
@@ -777,7 +947,6 @@ class Daemon:
             pid = None
         return pid
 
-
     @property
     def pid_path(self) -> pathlib.Path:
         """
@@ -785,7 +954,6 @@ class Daemon:
         """
         return self.path / 'process.pid'
 
-
     @property
     def pid_lock(self) -> 'fasteners.InterProcessLock':
         """
@@ -798,7 +966,6 @@ class Daemon:
         self._pid_lock = fasteners.InterProcessLock(self.pid_path)
         return self._pid_lock
 
-
     @property
     def pickle_path(self) -> pathlib.Path:
         """
@@ -806,25 +973,27 @@ class Daemon:
         """
         return self.path / 'pickle.pkl'
 
-
     def read_properties(self) -> Optional[Dict[str, Any]]:
         """Read the properties JSON file and return the dictionary."""
         if not self.properties_path.exists():
             return None
         try:
             with open(self.properties_path, 'r', encoding='utf-8') as file:
-                return json.load(file)
+                properties = json.load(file)
         except Exception as e:
-            return {}
-
+            properties = {}
+        
+        return properties
 
     def read_pickle(self) -> Daemon:
         """Read a Daemon's pickle file and return the `Daemon`."""
         import pickle, traceback
         if not self.pickle_path.exists():
             error(f"Pickle file does not exist for daemon '{self.daemon_id}'.")
+
         if self.pickle_path.stat().st_size == 0:
             error(f"Pickle was empty for daemon '{self.daemon_id}'.")
+
         try:
             with open(self.pickle_path, 'rb') as pickle_file:
                 daemon = pickle.load(pickle_file)
@@ -837,21 +1006,30 @@ class Daemon:
             error(msg)
         return daemon
 
-
     @property
     def properties(self) -> Dict[str, Any]:
         """
         Return the contents of the properties JSON file.
         """
-        _file_properties = self.read_properties()
+        try:
+            _file_properties = self.read_properties()
+        except Exception:
+            traceback.print_exc()
+            _file_properties = {}
+
         if not self._properties:
             self._properties = _file_properties
+
         if self._properties is None:
             self._properties = {}
+
         if _file_properties is not None:
-            self._properties = apply_patch_to_config(_file_properties, self._properties)
-        return self._properties
+            self._properties = apply_patch_to_config(
+                _file_properties,
+                self._properties,
+            )
 
+        return self._properties
 
     @property
     def hidden(self) -> bool:
@@ -860,12 +1038,14 @@ class Daemon:
         """
         return self.daemon_id.startswith('_') or self.daemon_id.startswith('.')
 
-
     def write_properties(self) -> SuccessTuple:
         """Write the properties dictionary to the properties JSON file
         (only if self.properties exists).
         """
-        success, msg = False, f"No properties to write for daemon '{self.daemon_id}'."
+        success, msg = (
+            False,
+            f"No properties to write for daemon '{self.daemon_id}'."
+        )
         if self.properties is not None:
             try:
                 self.path.mkdir(parents=True, exist_ok=True)
@@ -876,7 +1056,6 @@ class Daemon:
                 success, msg = False, str(e)
         return success, msg
 
-
     def write_pickle(self) -> SuccessTuple:
         """Write the pickle file for the daemon."""
         import pickle, traceback
@@ -892,9 +1071,9 @@ class Daemon:
 
 
     def _setup(
-            self,
-            allow_dirty_run: bool = False,
-        ) -> None:
+        self,
+        allow_dirty_run: bool = False,
+    ) -> None:
         """
         Update properties before starting the Daemon.
         """
@@ -918,7 +1097,6 @@ class Daemon:
         if not _write_pickle_success_tuple[0]:
             error(_write_pickle_success_tuple[1])
 
-
     def cleanup(self, keep_logs: bool = False) -> SuccessTuple:
         """
         Remove a daemon's directory after execution.
@@ -962,9 +1140,9 @@ class Daemon:
 
 
     def get_check_timeout_interval_seconds(
-            self,
-            check_timeout_interval: Union[int, float, None] = None,
-        ) -> Union[int, float]:
+        self,
+        check_timeout_interval: Union[int, float, None] = None,
+    ) -> Union[int, float]:
         """
         Return the interval value to check the status of timeouts.
         """
@@ -972,6 +1150,33 @@ class Daemon:
             return check_timeout_interval
         return get_config('jobs', 'check_timeout_interval_seconds')
 
+    @property
+    def target_args(self) -> Union[Tuple[Any], None]:
+        """
+        Return the positional arguments to pass to the target function.
+        """
+        target_args = (
+            self.__dict__.get('_target_args', None)
+            or self.properties.get('target', {}).get('args', None)
+        )
+        if target_args is None:
+            return tuple([])
+
+        return tuple(target_args)
+
+    @property
+    def target_kw(self) -> Union[Dict[str, Any], None]:
+        """
+        Return the keyword arguments to pass to the target function.
+        """
+        target_kw = (
+            self.__dict__.get('_target_kw', None)
+            or self.properties.get('target', {}).get('kw', None)
+        )
+        if target_kw is None:
+            return {}
+
+        return {key: val for key, val in target_kw.items()}
 
     def __getstate__(self):
         """
@@ -1022,4 +1227,4 @@ class Daemon:
         return self.daemon_id == other.daemon_id
 
     def __hash__(self):
-        return hash(self.daemon_id)       
+        return hash(self.daemon_id)