procman 2.0.0__tar.gz

procman-2.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Andrei Sukhanov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

procman-2.0.0/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: procman
+Version: 2.0.0
+Summary: Tabbed GUI to start/stop/monitor programs
+Project-URL: Homepage, https://github.com/ASukhanov/procman
+Author-email: Andrei Sukhanov <cyxandr@gmail.com>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
+Requires-Dist: qtpy
+Description-Content-Type: text/markdown
+
+# manman
+Compact GUI for deployment and monitoring of servers and applications
+associated with specific tasks or apparatuses.<br>
+![condensed](docs/manman_condensed.jpg)<br>
+The GUI can control multiple independent apparatuses in different tabs.
+
+The 'status' column dynamically shows the color-coded status of the server.
+
+The commands are executed by right clicking on the cells in the 'Applications' (leftmost) column.<br>
+The top left cell executes table-wide commands:```Check All, Start All, Stop All```.<br>
+It also holds commands to
+- delete current tab (**Delete**),
+- edit the table of the current tab (**Edit**),
+- condense and expand table arrangement (**Condense and Uncondense**).
+
+The following actions are defined for regular rows:
+  - **Check**
+  - **Start**
+  - **Stop**
+  - **Command**: will display the command for starting the server/application
+
+Definition of actions, associated with an apparatus, are defined in the 
+startup dictionary of the python scripts, code-named as apparatus_NAME.py. See examples in the config directory.
+
+Supported keys are:
+  - **'cmd'**: command which will be used to start and stop the server,
+  - **'cd'**:   directory (if needed), from where to run the cmd,
+  - **'process'**: used for checking/stopping the server to identify 
+     its process. If cmd properly identifies the 
+     server, then this key is not necessary,
+  - **'shell'**: some serverss require shell=True option for subprocess.Popen(),
+  - **'help'**: it will be used as a tooltip,
+
+## Demo
+  - ```python -m manman config/apparatus*.py```<br>
+Control of all apparatuses, defined in the ./config directory.
+Each apparatus will be controlled in a separate tab.
+  - ```python -m manman -c config apparatus1_test.py apparatus3_TST.py```<br>
+Control two apparatuses from the ./config directory.
+  - ```python -m manman -i -c config```<br>
+Interacively select apparatuses from the ./config directory.<br>
+![manman](docs/manman.png)
+

procman-2.0.0/README.md

@@ -0,0 +1,43 @@
+# manman
+Compact GUI for deployment and monitoring of servers and applications
+associated with specific tasks or apparatuses.<br>
+![condensed](docs/manman_condensed.jpg)<br>
+The GUI can control multiple independent apparatuses in different tabs.
+
+The 'status' column dynamically shows the color-coded status of the server.
+
+The commands are executed by right clicking on the cells in the 'Applications' (leftmost) column.<br>
+The top left cell executes table-wide commands:```Check All, Start All, Stop All```.<br>
+It also holds commands to
+- delete current tab (**Delete**),
+- edit the table of the current tab (**Edit**),
+- condense and expand table arrangement (**Condense and Uncondense**).
+
+The following actions are defined for regular rows:
+  - **Check**
+  - **Start**
+  - **Stop**
+  - **Command**: will display the command for starting the server/application
+
+Definition of actions, associated with an apparatus, are defined in the 
+startup dictionary of the python scripts, code-named as apparatus_NAME.py. See examples in the config directory.
+
+Supported keys are:
+  - **'cmd'**: command which will be used to start and stop the server,
+  - **'cd'**:   directory (if needed), from where to run the cmd,
+  - **'process'**: used for checking/stopping the server to identify 
+     its process. If cmd properly identifies the 
+     server, then this key is not necessary,
+  - **'shell'**: some serverss require shell=True option for subprocess.Popen(),
+  - **'help'**: it will be used as a tooltip,
+
+## Demo
+  - ```python -m manman config/apparatus*.py```<br>
+Control of all apparatuses, defined in the ./config directory.
+Each apparatus will be controlled in a separate tab.
+  - ```python -m manman -c config apparatus1_test.py apparatus3_TST.py```<br>
+Control two apparatuses from the ./config directory.
+  - ```python -m manman -i -c config```<br>
+Interacively select apparatuses from the ./config directory.<br>
+![manman](docs/manman.png)
+

procman-2.0.0/config/peakSimPlot_pp.py

@@ -0,0 +1,40 @@
+"""Pypet for liteServer peak simulator with embedded plot
+"""
+__version__='v0.0.2 2025-04-15'# host="localhost;9701:"
+
+_Namespace = "LITE"
+host = "localhost;9701:"
+dev = f"{host}dev1:"
+server = f"{host}server:"
+#``````````````````Definitions````````````````````````````````````````````````
+# Python expressions and functions, used in the spreadsheet.
+_=' '
+def span(x,y): return {'span':[x,y]}
+def color(*v): return {'color':v[0]} if len(v)==1 else {'color':list(v)}
+pvplot = f"python3 -m pvplot -a L:{dev} x,y"
+
+#``````````````````Page attributes, optional``````````````````````````````````
+#_Page = {'editable':False, **color(252,252,237)}
+_Page = {**color(240,240,240)}
+
+_Columns = {
+  1: {"justify": "center"},
+  2: {"width": 100},
+  3: {"justify": "right"},
+  5: {"width": 400},
+}
+
+_Rows = [
+['Performance:', {server+'perf':span(3,1)},_,_,{_:{'embed':pvplot,**span(1,10)}}],
+["run", dev+"run", 'debug:', server+'debug'],
+["status", {dev+"status":span(3,1)}],
+["frequency", dev+"frequency", "nPoints:", dev+"nPoints"],
+["background", {dev+"background":span(3,1)}],
+["noise", dev+"noise", "swing:", dev+"swing"],
+["peakPars", {dev+"peakPars":span(3,1)}],
+#["x", {dev+"x":span(3,1)}],
+#["y", {dev+"y":span(3,1)}],
+['yMin:', dev+'yMin', 'yMax:', dev+'yMax'],
+["rps", dev+"rps", "cycle:", dev+"cycle"],
+[],
+]

procman-2.0.0/config/proc1_test.py

@@ -0,0 +1,24 @@
+'''Definition of the second test apparatus.
+'''
+import os
+homeDir = os.environ['HOME']
+
+__version__ = 'v0.0.1 2025-05-21'#
+
+# abbreviations:
+help,cmd,process,cd = ['help','cmd','process','cd']
+
+#``````````````````Properties, used by manman`````````````````````````````````
+title = 'Test applications'
+
+startup = {
+'xclock':{help:'Digital xclock', 
+  cmd:'xclock -digital'
+  },
+'htop':{help:'Process viewer in separate xterm',
+  cmd:'xterm htop',
+  },
+'sleep30':{help:'Sleep for 30 seconds', 
+  cmd:'sleep 30', process:'sleep 30'
+  },
+}

procman-2.0.0/config/proc2_test.py

@@ -0,0 +1,24 @@
+'''Definition of the second test apparatus.
+'''
+import os
+homeDir = os.environ['HOME']
+
+__version__ = 'v0.0.1 2025-05-21'#
+
+# abbreviations:
+help,cmd,process,cd = ['help','cmd','process','cd']
+
+#``````````````````Properties, used by manman`````````````````````````````````
+title = 'Test1 applications'
+
+startup = {
+'xclock':{help:'Analog xclock', 
+  cmd:'xclock -analog'
+  },
+'top':{help:'Process viewer in separate xterm',
+  cmd:'xterm top',
+  },
+'sleep10':{help:'Sleep for 10 seconds', 
+  cmd:'sleep 10', process:'sleep 10'
+  },
+}

procman-2.0.0/config/proc3_TST.py

@@ -0,0 +1,72 @@
+'''Definition of a test apparatus, running a liteServer with peak simulator.
+The managers for this example could be installed with pip:
+  pip install liteserver pvplot pypeto
+
+The script should define dictionary startup.
+Supported keys are:
+  'cmd': command which will be used to start and stop the manager,
+  'cd:   directory (if needed), from where to run the cmd,
+  'process': used for stopping the manager using 'pkill -f', if cmd properly identifies the 
+     manager, then this key is not necessary,
+  'help': it will be used as a tooltip,
+'''
+import os
+homeDir = os.environ['HOME']
+epics_home = os.environ.get('EPICS_HOME')
+
+__version__ = 'v0.1.5 2025-04-26'# added 'process' to better track of processes
+
+# abbreviations:
+help,cmd,process,cd = ['help','cmd','process','cd']
+
+#``````````````````Properties, used by manman`````````````````````````````````
+title = 'Peak Simulator'
+startup = {
+#       Operational managers
+# liteServer-based
+'peakSimulator':{help:
+  'Lite server, simulating peaks and noise',
+  cmd:		'python3 -m liteserver.device.litePeakSimulator -ilo -p9701',
+  process:	'liteserver.device.litePeakSimulator -ilo -p9701',
+  },
+'plot it':{help:
+  'Plotting tool for peakSimulator',
+  cmd:		'python3 -m pvplot -aL:localhost;9701:dev1: x,y',
+  process:	'pvplot -aL:localhost;9701:dev1: x,y',
+  },
+'control it':{help:
+  'Automatic parameter editing tool of the peakSimulator',
+  cmd:		'python3 -m pypeto -aLITE localhost;9701:dev1',
+  process:	'pypeto -aLITE localhost;9701:dev1',
+  },
+'control&plot':{help:
+  'Parameter editing with integrated plot',
+  cmd:		'python3 -m pypeto -c config -f peakSimPlot',
+  process:	'pypeto -c config -f peakSimPlot',
+  #Note: It will look for config file: config/peakSimPlot_pp.py
+  },
+}
+if epics_home is not None:
+    startup.update({
+# EPICS IOCs
+'simScope':{help:
+  'EPICS testAsynPortDriver, hosting a simulate oscilloscope',
+  cd:f'{epics_home}/asyn/iocBoot/ioctestAsynPortDriver/',
+  cmd:'screen -d -m -S simScope ../../bin/linux-x86_64/testAsynPortDriver st.cmd',
+  process:'testAsynPortDriver st.cmd', 
+},
+#'tst_caproto_ioc':  {cmd:'python3 -m caproto.ioc_examples.simple --list-pvs',help:
+#  'Simple IOC for testing EPICS Channel Access functionality'},
+'pet_simScope':{help:
+  'Parameter editing tool for simScope',
+  cmd:  'python3 -m pypeto -f Controls/EPICS/simScope',
+  },
+})
+
+#       Managers for testing and debugging
+startup.update({
+'tst_sleep30':{help:
+  'sleep for 30 seconds', 
+  cmd:'sleep 30', process:'sleep 30'
+  },
+})

procman-2.0.0/procman/__init__.py

@@ -0,0 +1,3 @@
+#__all__ = ['manman']
+from .procman import __version__, Window
+

procman-2.0.0/procman/__main__.py

@@ -0,0 +1,55 @@
+"""Tabbed GUI for starting/stopping/monitoring programs.
+"""
+__version__ = 'v1.1.1 2025-07-30'# added --interactive
+
+import sys, os, argparse
+from qtpy.QtWidgets import QApplication
+from . import procman, helpers
+
+#``````````````````Main```````````````````````````````````````````````````````
+def main():
+    global pargs
+    parser = argparse.ArgumentParser('python -m procman',
+      description=__doc__,
+      formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+      epilog=f'Version {procman.__version__}')
+    parser.add_argument('-c', '--configDir', help=\
+      ('Root directory of config files, one config file per program, '
+      'if None, then ./config directory will be used'))
+    parser.add_argument('-C', '--condensed', action='store_true', help=\
+      'Condensed arrangement of tables: no headers, narrow columns')
+    parser.add_argument('-i', '--interactive', default=False, action='store_true', help=
+      'Select files interactively')
+    parser.add_argument('-t', '--interval', default=10., help=\
+      'Interval in seconds of periodic checking. If 0 then no checking')
+    parser.add_argument('-v', '--verbose', action='count', default=0, help=\
+      'Show more log messages (-vv: show even more).')
+    parser.add_argument('-z', '--zoomin', help=\
+      'Zoom the application window by a factor, factor must be >= 1')
+    parser.add_argument('files', nargs='*', help=\
+      ('Path of config files, can include wildcards. '
+       'If None, then an interactive dialog will be opened to select files.')),
+    pargs = parser.parse_args()
+    helpers.Verbose = pargs.verbose
+    if pargs.configDir is None and len(pargs.filess) == 0:
+        pargs.configDir = 'config'
+    procman.Window.pargs = pargs# transfer pargs to procman module
+
+    # handle the --zoomin
+    if pargs.zoomin is not None:
+        os.environ["QT_SCALE_FACTOR"] = pargs.zoomin
+
+    # arrange keyboard interrupt to kill the program
+    import signal
+    signal.signal(signal.SIGINT, signal.SIG_DFL)
+    
+    # start GUI
+    app = QApplication(sys.argv)
+    window = procman.Window()
+    window.show()
+    app.exec_()
+    print('Application exit')
+
+if __name__ == '__main__':
+    main()
+

procman-2.0.0/procman/cli.py

@@ -0,0 +1,106 @@
+'''Command line tool to start servers and managers
+'''
+__version__ = 'v0.1.4 2024-10-27'#
+import sys, os, time, subprocess, argparse, threading
+from functools import partial
+from importlib import import_module
+
+from . import helpers as H
+
+Apparatus = H.list_of_apparatus()
+
+ManCmds = ['Check','Start','Stop','Command']
+
+def manAction(manName, cmd):
+    H.printv(f'manAction: {manName, cmd}')
+    cmdstart = Startup[manName]['cmd']    
+    if cmd == 'Check':
+        H.printv(f'checking process {cmdstart} ')
+        if H.is_process_running(cmdstart):
+            print(f'Manager "{manName}" \tstarted')#, process name: "{cmdstart}"')
+            return os.EX_OK
+        else:
+            print(f'Manager "{manName}" \tis not running')
+            return os.EX_UNAVAILABLE
+            
+    elif cmd == 'Start':
+        H.printv(f'starting {manName}')
+        if H.is_process_running(cmdstart):
+            H.printe(f'Manager "{manName}" is already running.')
+            return os.EX_CANTCREAT
+
+        cmdlist = cmdstart.split()
+        H.printv(f'popen: {cmdlist}')
+        try:
+            process = subprocess.Popen(cmdlist, #close_fds=True,# env=my_env,
+              stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+        except Exception as e:
+            H.printe(f'Exception starting {manName}: {e}') 
+            return os.EX_IOERR
+
+        time.sleep(5)# 3 is small for PLC device
+        H.printv('slept 5 seconds')
+        ex = manAction(manName, 'Check')
+        if ex != os.EX_OK:
+            return os.EX_UNAVAILABLE
+
+    elif cmd == 'Stop':
+        H.printv(f'stopping {manName}')
+        process = Startup[manName].get('process', f'{cmdstart}')
+        cmd = f'pkill -f "{process}"'
+        H.printv(f'executing: {cmd}')
+        os.system(cmd)
+        time.sleep(0.1)
+        ex = manAction(manName, 'Check')
+        if ex != os.EX_UNAVAILABLE:
+            return os.EX_SOFTWARE
+
+    elif cmd == 'Command':
+        try:
+            cd = Startup[manName]['cd']
+            cmd = f'cd {cd}; {cmdstart}'
+        except Exception as e:
+            cmd = cmdstart
+        print(f'Start command for "{manName}": "{cmd}"')
+        return os.EX_OK
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description=__doc__,
+      formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+      epilog=f'Version {__version__}')
+    parser.add_argument('-a','--apparatus', choices=Apparatus, default='TST', help='Which apparatus to control')
+    parser.add_argument('-c', '--configDir', default=H.ConfigDir, help=\
+      'Directory, containing apparatus configuration scripts')
+    parser.add_argument('-m', '--manager', default='all',
+help='Apply command to a particular manager (or all) of the apparatus')
+    parser.add_argument('-t', '--test', action='store_true',
+help='Include non-operational (test) managers') 
+    parser.add_argument('-v', '--verbose', action='count', default=0, help=\
+      'Show more log messages (-vv: show even more).')
+    parser.add_argument('command', nargs='?', choices=ManCmds, default='Check')
+    pargs = parser.parse_args()
+    H.printv(f'pargs: {pargs}')
+
+    # import the manager
+    mname = 'manman.apparatus_'+pargs.apparatus
+    module = import_module(mname)
+    print(f'imported {mname} {module.__version__}')
+    Startup = module.startup
+    mname = 'manman.apparatus_'+pargs.apparatus
+    module = import_module(mname)
+
+    if pargs.manager == 'all':
+        pargs.manager = list(Startup.keys())
+    else:
+        pargs.manager = [pargs.manager]
+    H.printv(f'Managers: {pargs.manager}')
+
+    for manName in pargs.manager:
+        if manName not in Startup:
+            H.printe(f'Wrong manager, supported are: {",".join(Startup.keys())}')
+            sys.exit(os.EX_USAGE)
+        if not pargs.test:
+            if manName.startswith('tst_'):
+                continue
+        manAction(manName, pargs.command)
+

procman-2.0.0/procman/detachable_tabs.py

@@ -0,0 +1,416 @@
+"""Support for detachable tabs.
+# https://stackoverflow.com/a/50693795/3620725
+"""
+from PyQt5 import QtGui, QtCore, QtWidgets
+from PyQt5.QtCore import pyqtSignal, pyqtSlot
+
+class DetachableTabWidget(QtWidgets.QTabWidget):
+    def __init__(self, parent=None):
+        QtWidgets.QTabWidget.__init__(self, parent)
+
+        self.tabBar = self.TabBar(self)
+        self.tabBar.onDetachTabSignal.connect(self.detachTab)
+        self.tabBar.onMoveTabSignal.connect(self.moveTab)
+        self.tabBar.detachedTabDropSignal.connect(self.detachedTabDrop)
+
+        self.setTabBar(self.tabBar)
+
+        # Used to keep a reference to detached tabs since their QMainWindow
+        # does not have a parent
+        self.detachedTabs = {}
+
+        # Close all detached tabs if the application is closed explicitly
+        QtWidgets.qApp.aboutToQuit.connect(self.closeDetachedTabs)  # @UndefinedVariable
+
+    ##
+    #  The default movable functionality of QTabWidget must remain disabled
+    #  so as not to conflict with the added features
+    def setMovable(self, movable):
+        pass
+
+    ##
+    #  Move a tab from one position (index) to another
+    #
+    #  @param    fromIndex    the original index location of the tab
+    #  @param    toIndex      the new index location of the tab
+    @pyqtSlot(int, int)
+    def moveTab(self, fromIndex, toIndex):
+        widget = self.widget(fromIndex)
+        icon = self.tabIcon(fromIndex)
+        text = self.tabText(fromIndex)
+
+        self.removeTab(fromIndex)
+        self.insertTab(toIndex, widget, icon, text)
+        self.setCurrentIndex(toIndex)
+
+    ##
+    #  Detach the tab by removing it's contents and placing them in
+    #  a DetachedTab window
+    #
+    #  @param    index    the index location of the tab to be detached
+    #  @param    point    the screen position for creating the new DetachedTab window
+    @pyqtSlot(int, QtCore.QPoint)
+    def detachTab(self, index, point):
+
+        # Get the tab content
+        name = self.tabText(index)
+        icon = self.tabIcon(index)
+        if icon.isNull():
+            icon = self.window().windowIcon()
+        contentWidget = self.widget(index)
+
+        try:
+            contentWidgetRect = contentWidget.frameGeometry()
+        except AttributeError:
+            return
+
+        # Create a new detached tab window
+        detachedTab = self.DetachedTab(name, contentWidget)
+        detachedTab.setWindowModality(QtCore.Qt.NonModal)
+        detachedTab.setWindowIcon(icon)
+        detachedTab.setGeometry(contentWidgetRect)
+        detachedTab.onCloseSignal.connect(self.attachTab)
+        detachedTab.onDropSignal.connect(self.tabBar.detachedTabDrop)
+        detachedTab.move(point)
+        detachedTab.show()
+
+        # Create a reference to maintain access to the detached tab
+        self.detachedTabs[name] = detachedTab
+
+    ##
+    #  Re-attach the tab by removing the content from the DetachedTab window,
+    #  closing it, and placing the content back into the DetachableTabWidget
+    #
+    #  @param    contentWidget    the content widget from the DetachedTab window
+    #  @param    name             the name of the detached tab
+    #  @param    icon             the window icon for the detached tab
+    #  @param    insertAt         insert the re-attached tab at the given index
+    def attachTab(self, contentWidget, name, icon, insertAt=None):
+
+        # Make the content widget a child of this widget
+        contentWidget.setParent(self)
+
+        # Remove the reference
+        del self.detachedTabs[name]
+
+        # Create an image from the given icon (for comparison)
+        if not icon.isNull():
+            try:
+                tabIconPixmap = icon.pixmap(icon.availableSizes()[0])
+                tabIconImage = tabIconPixmap.toImage()
+            except IndexError:
+                tabIconImage = None
+        else:
+            tabIconImage = None
+
+        # Create an image of the main window icon (for comparison)
+        if not icon.isNull():
+            try:
+                windowIconPixmap = self.window().windowIcon().pixmap(icon.availableSizes()[0])
+                windowIconImage = windowIconPixmap.toImage()
+            except IndexError:
+                windowIconImage = None
+        else:
+            windowIconImage = None
+
+        # Determine if the given image and the main window icon are the same.
+        # If they are, then do not add the icon to the tab
+        if tabIconImage == windowIconImage:
+            if insertAt == None:
+                index = self.addTab(contentWidget, name)
+            else:
+                index = self.insertTab(insertAt, contentWidget, name)
+        else:
+            if insertAt == None:
+                index = self.addTab(contentWidget, icon, name)
+            else:
+                index = self.insertTab(insertAt, contentWidget, icon, name)
+
+        # Make this tab the current tab
+        if index > -1:
+            self.setCurrentIndex(index)
+
+    ##
+    #  Remove the tab with the given name, even if it is detached
+    #
+    #  @param    name    the name of the tab to be removed
+    def removeTabByName(self, name):
+
+        # Remove the tab if it is attached
+        attached = False
+        for index in range(self.count()):
+            if str(name) == str(self.tabText(index)):
+                self.removeTab(index)
+                attached = True
+                break
+
+        # If the tab is not attached, close it's window and
+        # remove the reference to it
+        if not attached:
+            for key in self.detachedTabs:
+                if str(name) == str(key):
+                    self.detachedTabs[key].onCloseSignal.disconnect()
+                    self.detachedTabs[key].close()
+                    del self.detachedTabs[key]
+                    break
+
+    ##
+    #  Handle dropping of a detached tab inside the DetachableTabWidget
+    #
+    #  @param    name     the name of the detached tab
+    #  @param    index    the index of an existing tab (if the tab bar
+    #                     determined that the drop occurred on an
+    #                     existing tab)
+    #  @param    dropPos  the mouse cursor position when the drop occurred
+    @QtCore.pyqtSlot(str, int, QtCore.QPoint)
+    def detachedTabDrop(self, name, index, dropPos):
+
+        # If the drop occurred on an existing tab, insert the detached
+        # tab at the existing tab's location
+        if index > -1:
+
+            # Create references to the detached tab's content and icon
+            contentWidget = self.detachedTabs[name].contentWidget
+            icon = self.detachedTabs[name].windowIcon()
+
+            # Disconnect the detached tab's onCloseSignal so that it
+            # does not try to re-attach automatically
+            self.detachedTabs[name].onCloseSignal.disconnect()
+
+            # Close the detached
+            self.detachedTabs[name].close()
+
+            # Re-attach the tab at the given index
+            self.attachTab(contentWidget, name, icon, index)
+
+
+        # If the drop did not occur on an existing tab, determine if the drop
+        # occurred in the tab bar area (the area to the side of the QTabBar)
+        else:
+
+            # Find the drop position relative to the DetachableTabWidget
+            tabDropPos = self.mapFromGlobal(dropPos)
+
+            # If the drop position is inside the DetachableTabWidget...
+            if tabDropPos in self.rect():
+
+                # If the drop position is inside the tab bar area (the
+                # area to the side of the QTabBar) or there are not tabs
+                # currently attached...
+                if tabDropPos.y() < self.tabBar.height() or self.count() == 0:
+                    # Close the detached tab and allow it to re-attach
+                    # automatically
+                    self.detachedTabs[name].close()
+
+    ##
+    #  Close all tabs that are currently detached.
+    def closeDetachedTabs(self):
+        listOfDetachedTabs = []
+
+        for key in self.detachedTabs:
+            listOfDetachedTabs.append(self.detachedTabs[key])
+
+        for detachedTab in listOfDetachedTabs:
+            detachedTab.close()
+
+    ##
+    #  When a tab is detached, the contents are placed into this QMainWindow.  The tab
+    #  can be re-attached by closing the dialog or by dragging the window into the tab bar
+    class DetachedTab(QtWidgets.QMainWindow):
+        onCloseSignal = pyqtSignal(QtWidgets.QWidget, str, QtGui.QIcon)
+        onDropSignal = pyqtSignal(str, QtCore.QPoint)
+
+        def __init__(self, name, contentWidget):
+            QtWidgets.QMainWindow.__init__(self, None)
+
+            self.setObjectName(name)
+            self.setWindowTitle('manman '+name)
+
+            self.contentWidget = contentWidget
+            self.setCentralWidget(self.contentWidget)
+            self.contentWidget.show()
+
+            self.windowDropFilter = self.WindowDropFilter()
+            self.installEventFilter(self.windowDropFilter)
+            self.windowDropFilter.onDropSignal.connect(self.windowDropSlot)
+
+        ##
+        #  Handle a window drop event
+        #
+        #  @param    dropPos    the mouse cursor position of the drop
+        @QtCore.pyqtSlot(QtCore.QPoint)
+        def windowDropSlot(self, dropPos):
+            self.onDropSignal.emit(self.objectName(), dropPos)
+
+        ##
+        #  If the window is closed, emit the onCloseSignal and give the
+        #  content widget back to the DetachableTabWidget
+        #
+        #  @param    event    a close event
+        def closeEvent(self, event):
+            self.onCloseSignal.emit(self.contentWidget, self.objectName(), self.windowIcon())
+
+        ##
+        #  An event filter class to detect a QMainWindow drop event
+        class WindowDropFilter(QtCore.QObject):
+            onDropSignal = pyqtSignal(QtCore.QPoint)
+
+            def __init__(self):
+                QtCore.QObject.__init__(self)
+                self.lastEvent = None
+
+            ##
+            #  Detect a QMainWindow drop event by looking for a NonClientAreaMouseMove (173)
+            #  event that immediately follows a Move event
+            #
+            #  @param    obj    the object that generated the event
+            #  @param    event  the current event
+            def eventFilter(self, obj, event):
+
+                # If a NonClientAreaMouseMove (173) event immediately follows a Move event...
+                if self.lastEvent == QtCore.QEvent.Move and event.type() == 173:
+
+                    # Determine the position of the mouse cursor and emit it with the
+                    # onDropSignal
+                    mouseCursor = QtGui.QCursor()
+                    dropPos = mouseCursor.pos()
+                    self.onDropSignal.emit(dropPos)
+                    self.lastEvent = event.type()
+                    return True
+
+                else:
+                    self.lastEvent = event.type()
+                    return False
+
+    ##
+    #  The TabBar class re-implements some of the functionality of the QTabBar widget
+    class TabBar(QtWidgets.QTabBar):
+        onDetachTabSignal = pyqtSignal(int, QtCore.QPoint)
+        onMoveTabSignal = pyqtSignal(int, int)
+        detachedTabDropSignal = pyqtSignal(str, int, QtCore.QPoint)
+
+        def __init__(self, parent=None):
+            QtWidgets.QTabBar.__init__(self, parent)
+
+            self.setAcceptDrops(True)
+            self.setElideMode(QtCore.Qt.ElideRight)
+            self.setSelectionBehaviorOnRemove(QtWidgets.QTabBar.SelectLeftTab)
+
+            self.dragStartPos = QtCore.QPoint()
+            self.dragDropedPos = QtCore.QPoint()
+            self.mouseCursor = QtGui.QCursor()
+            self.dragInitiated = False
+
+        ##
+        #  Send the onDetachTabSignal when a tab is double clicked
+        #
+        #  @param    event    a mouse double click event
+        def mouseDoubleClickEvent(self, event):
+            event.accept()
+            self.onDetachTabSignal.emit(self.tabAt(event.pos()), self.mouseCursor.pos())
+
+        ##
+        #  Set the starting position for a drag event when the mouse button is pressed
+        #
+        #  @param    event    a mouse press event
+        def mousePressEvent(self, event):
+            if event.button() == QtCore.Qt.LeftButton:
+                self.dragStartPos = event.pos()
+
+            self.dragDropedPos.setX(0)
+            self.dragDropedPos.setY(0)
+
+            self.dragInitiated = False
+
+            QtWidgets.QTabBar.mousePressEvent(self, event)
+
+        ##
+        #  Determine if the current movement is a drag.  If it is, convert it into a QDrag.  If the
+        #  drag ends inside the tab bar, emit an onMoveTabSignal.  If the drag ends outside the tab
+        #  bar, emit an onDetachTabSignal.
+        #
+        #  @param    event    a mouse move event
+        def mouseMoveEvent(self, event):
+
+            # Determine if the current movement is detected as a drag
+            if not self.dragStartPos.isNull() and (
+                    (event.pos() - self.dragStartPos).manhattanLength() < QtWidgets.QApplication.startDragDistance()):
+                self.dragInitiated = True
+
+            # If the current movement is a drag initiated by the left button
+            if (((event.buttons() & QtCore.Qt.LeftButton)) and self.dragInitiated):
+
+                # Stop the move event
+                finishMoveEvent = QtGui.QMouseEvent(QtCore.QEvent.MouseMove, event.pos(), QtCore.Qt.NoButton,
+                                                    QtCore.Qt.NoButton, QtCore.Qt.NoModifier)
+                QtWidgets.QTabBar.mouseMoveEvent(self, finishMoveEvent)
+
+                # Convert the move event into a drag
+                drag = QtGui.QDrag(self)
+                mimeData = QtCore.QMimeData()
+                mimeData.setData('action', b'application/tab-detach')
+                drag.setMimeData(mimeData)
+
+                # Create the appearance of dragging the tab content
+                pixmap = self.parentWidget().currentWidget().grab()
+                targetPixmap = QtGui.QPixmap(pixmap.size())
+                targetPixmap.fill(QtCore.Qt.transparent)
+                painter = QtGui.QPainter(targetPixmap)
+                painter.setOpacity(0.85)
+                painter.drawPixmap(0, 0, pixmap)
+                painter.end()
+                drag.setPixmap(targetPixmap)
+
+                # Initiate the drag
+                dropAction = drag.exec_(QtCore.Qt.MoveAction | QtCore.Qt.CopyAction)
+
+                # For Linux:  Here, drag.exec_() will not return MoveAction on Linux.  So it
+                #             must be set manually
+                if self.dragDropedPos.x() != 0 and self.dragDropedPos.y() != 0:
+                    dropAction = QtCore.Qt.MoveAction
+
+                # If the drag completed outside of the tab bar, detach the tab and move
+                # the content to the current cursor position
+                if dropAction == QtCore.Qt.IgnoreAction:
+                    event.accept()
+                    self.onDetachTabSignal.emit(self.tabAt(self.dragStartPos), self.mouseCursor.pos())
+
+                # Else if the drag completed inside the tab bar, move the selected tab to the new position
+                elif dropAction == QtCore.Qt.MoveAction:
+                    if not self.dragDropedPos.isNull():
+                        event.accept()
+                        self.onMoveTabSignal.emit(self.tabAt(self.dragStartPos), self.tabAt(self.dragDropedPos))
+            else:
+                QtWidgets.QTabBar.mouseMoveEvent(self, event)
+
+        ##
+        #  Determine if the drag has entered a tab position from another tab position
+        #
+        #  @param    event    a drag enter event
+        def dragEnterEvent(self, event):
+            mimeData = event.mimeData()
+            formats = mimeData.formats()
+
+            if 'action' in formats and mimeData.data('action') == 'application/tab-detach':
+                event.acceptProposedAction()
+
+            QtWidgets.QTabBar.dragMoveEvent(self, event)
+
+        ##
+        #  Get the position of the end of the drag
+        #
+        #  @param    event    a drop event
+        def dropEvent(self, event):
+            self.dragDropedPos = event.pos()
+            QtWidgets.QTabBar.dropEvent(self, event)
+
+        ##
+        #  Determine if the detached tab drop event occurred on an existing tab,
+        #  then send the event to the DetachableTabWidget
+        def detachedTabDrop(self, name, dropPos):
+
+            tabDropPos = self.mapFromGlobal(dropPos)
+
+            index = self.tabAt(tabDropPos)
+
+            self.detachedTabDropSignal.emit(name, index, dropPos)

procman-2.0.0/procman/helpers.py

@@ -0,0 +1,18 @@
+"""Helpers for manman"""
+import sys, os, time, glob
+import subprocess
+
+ConfigDir = '/operations/app_store/manman'
+
+Verbose = 0
+
+def printTime(): return time.strftime("%m%d:%H%M%S")
+def printi(msg): print(f'inf_@{printTime()}: {msg}')
+def printw(msg): print(f'WAR_@{printTime()}: {msg}')
+def printe(msg): print(f'ERR_{printTime()}: {msg}')
+def _printv(msg, level):
+    if Verbose >= level:
+        print(f'dbg{level}: {msg}')
+def printv(msg): _printv(msg, 1)
+def printvv(msg): _printv(msg, 2)
+

procman-2.0.0/procman/procman.py

@@ -0,0 +1,342 @@
+"""Tabbed GUI for starting/stopping/monitoring programs.
+"""
+__version__ = 'v2.0.0 2025-09-07'# Adopted from manman
+#TODO: xdg_open does not launch if other editors not running. 
+
+import sys, os, time, subprocess, argparse, threading, glob
+from functools import partial
+from importlib import import_module
+
+from qtpy import QtWidgets as QW, QtGui, QtCore
+
+from . import helpers as H
+from . import detachable_tabs
+
+#``````````````````Constants``````````````````````````````````````````````````
+ManCmds =       ['Check',    'Start',    'Stop',     'Command']
+AllManCmds = ['Check All','Start All','Stop All', 'Edit', 'Delete',
+                'Condense', 'Uncondense']#, 'Exit All']
+Col = {'Applications':0, 'status':1, 'response':2}
+BoldFont = QtGui.QFont("Helvetica", 14, QtGui.QFont.Bold)
+FilePrefix = 'proc'
+MinimalRowHeight = 20
+#``````````````````Helpers````````````````````````````````````````````````````
+def select_files_interactively(directory, title=f'Select {FilePrefix}*.py files'):
+    dialog = QW.QFileDialog()
+    dialog.setFileMode( QW.QFileDialog.FileMode() )
+    ffilter = f'procman ({FilePrefix}*.py)'
+    files = dialog.getOpenFileNames( None, title, directory, ffilter)[0]
+    return files
+
+def create_folderMap():
+    # create map of {folder1: [file1,...], folder2...} from pargs.files
+    #print(f'c,a: {Window.pargs.configDir, Window.pargs.files}')
+    folders = {}
+    if Window.pargs.configDir is None:
+        files = [os.path.abspath(i) for i in Window.pargs.filess]
+    else:
+        absfolder = os.path.abspath(Window.pargs.configDir)
+        if Window.pargs.interactive:
+            if len(Window.pargs.files) == 0:
+                files = select_files_interactively(absfolder)
+            else:
+                files = [absfolder+'/'+i for i in Window.pargs.files]
+        else:
+            s = f'{absfolder}/*)'
+            l = glob.glob('proc*.py', root_dir=absfolder)
+            files = [absfolder+'/'+i for i in l]
+    for f in files:
+        folder,tail = os.path.split(f)
+        if not (tail.startswith(FilePrefix) and tail.endswith('.py')):
+            H.printe(f'Config file should have prefix {FilePrefix} and suffix ".py"')
+            sys.exit(1)
+        if folder not in folders:
+            folders[folder] = []
+        folders[folder].append(tail)
+
+    # sort the file lists
+    for folder in folders:
+        folders[folder].sort()
+    return folders
+
+def launch_default_editor(configFile):
+    cmd = f'xdg-open {configFile}'
+    H.printi(f'Launching editor: {cmd}')
+    subprocess.call(cmd.split())
+
+def is_process_running(cmdstart):
+    try:
+        subprocess.check_output(["pgrep", '-f', cmdstart])
+        return True
+    except subprocess.CalledProcessError:
+        return False
+
+def setButtonStyleSheet(parent):
+    parent.setStyleSheet("QPushButton{"
+            #"background-color: lightBlue;"
+            "background-color: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,"
+                "stop: 0 white, stop: 1 lightBlue);"
+            #'border: 2px solid blue;'
+            "border-style: solid;"
+            "border-color: Grey;"
+            "border-width: 2px;"
+            "border-radius: 10px;}"
+            #"font-weight: bold;"# no effect
+            'QPushButton::pressed{background-color:pink;}'
+        )#{+ButtonStyleSheet)    
+
+class myPushButton(QW.QPushButton):
+    """Custom pushbutton""" 
+    def __init__(self, text, manName='?', buttons=[]):
+        super().__init__()
+        self.setText(text)
+        self.buttons = buttons
+        self.manName = manName
+        self.clicked.connect(self.buttonClicked)
+
+    def buttonClicked(self):
+        buttonText = self.text()
+        #print(f'Clicked {buttonText, self.manName, self.buttons}')
+        if len(self.buttons) != 0:
+            dlg = myDialog(self, self.manName, self.buttons)
+            r = dlg.exec()
+            return
+        if self.manName == '':
+            return
+        #print(f'Executing manAction{self.manName, buttonText}')
+        if self.manName == 'All':
+            current_mytable().tableWideAction(buttonText)
+        else:
+            current_mytable().manAction(self.manName, buttonText)
+
+class myDialog(QW.QDialog):
+    def __init__(self, parent, title, buttons):
+        super().__init__(parent)
+
+        self.setWindowTitle(title)
+        layout = QW.QVBoxLayout(self)
+        for btnTxt in buttons:
+            btn = myPushButton(btnTxt, title)
+            btn.clicked.connect(self.accept)
+            #self.buttonBox.addButton(btn)
+            layout.addWidget(btn)
+        self.setLayout(layout)
+        
+#``````````````````Table Widget```````````````````````````````````````````````
+def current_mytable():
+    return Window.tabWidget.currentWidget()
+class MyTable(QW.QTableWidget):
+    def __init__(self, folder, fname, tabName):
+        super().__init__()
+        mname = fname[:-3]
+        H.printv(f'importing {mname}')
+        try:
+            module = import_module(mname)
+        except SyntaxError as e:
+            H.printe(f'Syntax Error in {fname}: {e}')
+            sys.exit(1)
+        H.printv(f'imported {mname} {module.__version__}')
+        self.startup = module.startup
+        self.configFile = folder+'/'+fname
+        self.setColumnCount(len(Col))
+        self.setHorizontalHeaderLabels(Col.keys())
+        self.verticalHeader().setMinimumSectionSize(MinimalRowHeight)
+        self.manRow = {}
+        setButtonStyleSheet(self)
+
+        try:    title = module.title
+        except: title = 'Applications'
+
+        # Wide button for for tab-wide commands
+        #wideRow(self, 0, title, AllManCmds)
+        rowPosition=0
+        self._insertRow(rowPosition)
+        self.setSpan(rowPosition,0,1,2)
+        item = myPushButton(title, 'All', AllManCmds)
+        item.setToolTip('Commands for all programs in this page')
+        self.setCellWidget(rowPosition, Col['Applications'], item)
+
+        # Set up all rows 
+        for manName,props in self.startup.items():
+            rowPosition = self.rowCount()
+            self._insertRow(rowPosition)
+            self.manRow[manName] = rowPosition
+
+            item = myPushButton(manName, manName, buttons=ManCmds)
+            try:    item.setToolTip(props['help'])
+            except: pass
+            self.setCellWidget(rowPosition, Col['Applications'], item)
+
+            self.setItem(rowPosition, Col['status'],
+              QW.QTableWidgetItem('?'))
+            self.setItem(rowPosition, Col['response'],
+              QW.QTableWidgetItem(''))
+
+        # Set up headers
+        header = self.horizontalHeader()
+        header.setStretchLastSection(True)
+        if Window.pargs.condensed:
+            self.set_headersVisibility(False)
+
+    def _insertRow(self, rowPosition):
+        self.insertRow(rowPosition)
+        self.setRowHeight(rowPosition, 1)  
+
+    def manAction(self, manName:str, cmd:str):
+        # Execute action
+        #print(f'manAction: {manName, cmd}')
+        rowPosition = self.manRow[manName]
+        startup = self.startup
+        cmdstart = startup[manName]['cmd']
+        process = startup[manName].get('process', f'{cmdstart}')
+        #print(f"pos: {rowPosition},{Col['response']}")
+
+        if cmd == 'Check':
+            H.printvv(f'checking process {process} ')
+            status = ['not running','is started'][is_process_running(process)]
+            item = self.item(rowPosition,Col['status'])
+            color = 'lightGreen' if 'started' in status else 'pink'
+            item.setBackground(QtGui.QColor(color))
+            item.setText(status)
+
+        elif cmd == 'Start':
+            self.item(rowPosition, Col['response']).setText('')
+            if is_process_running(process):
+                txt = f'Is already running manager {manName}'
+                #print(txt)
+                self.item(rowPosition, Col['response']).setText(txt)
+                return
+            H.printv(f'starting {manName}')
+            item = self.item(rowPosition, Col['status'])
+            item.setText('starting...')
+            path = startup[manName].get('cd')
+            H.printi('Executing commands:')
+            if path:
+                path = path.strip()
+                expandedPath = os.path.expanduser(path)
+                try:
+                    os.chdir(expandedPath)
+                except Exception as e:
+                    txt = f'ERR: in chdir: {e}'
+                    self.item(rowPosition, Col['response']).setText(txt)
+                    return
+                print(f'cd {os.getcwd()}')
+            print(cmdstart)
+            expandedCmd = os.path.expanduser(cmdstart)
+            cmdlist = expandedCmd.split()
+            shell = startup[manName].get('shell',False)
+            H.printv(f'popen: {cmdlist}, shell:{shell}')
+            try:
+                proc = subprocess.Popen(cmdlist, shell=shell, #close_fds=True,# env=my_env,
+                  stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+            except Exception as e:
+                H.printv(f'Exception: {e}') 
+                self.item(rowPosition, Col['response']).setText(str(e))
+                return
+            Window.timer.singleShot(int(Window.pargs.interval*1000),
+                partial(self.deferredCheck,(manName,rowPosition)))
+
+        elif cmd == 'Stop':
+            self.item(rowPosition, Col['response']).setText('')
+            H.printv(f'stopping {manName}')
+            cmd = f'pkill -f "{process}"'
+            H.printi(f'Executing:\n{cmd}')
+            os.system(cmd)
+            time.sleep(0.1)
+            self.manAction(manName, ManCmds.index('Check'))
+
+        elif cmd == 'Command':
+            try:
+                cd = startup[manName]['cd']
+                cmd = f'cd {cd}; {cmdstart}'
+            except Exception as e:
+                cmd = cmdstart
+            #print(f'Command in row {rowPosition}:\n{cmd}')
+            self.item(rowPosition, Col['response']).setText(cmd)
+            return
+
+    def set_headersVisibility(self, visible:bool):
+        #print(f'set_headersVisibility {visible}')
+        self.horizontalHeader().setVisible(visible)
+        self.verticalHeader().setVisible(visible)
+
+    def tableWideAction(self, cmd:str):
+        # Execute table-wide action
+        #print(f'tableWideAction: {cmd}')
+        if cmd == 'Edit':
+            launch_default_editor(self.configFile)
+        elif cmd == 'Delete':
+            idx = Window.tabWidget.currentIndex()
+            tabtext = Window.tabWidget.tabText(idx)
+            H.printi(f'Deleting tab {idx,tabtext}')
+            del Window.tableWidgets[tabtext]
+            Window.tabWidget.removeTab(idx)
+            self.deleteLater()# it is important to properly delete the associated widget
+        elif cmd == 'Condense':
+            self.set_headersVisibility(False)
+        elif cmd == 'Uncondense':
+            self.set_headersVisibility(True)
+        elif cmd == 'Exit All':
+            self.exit_all()
+        else:# Delegate command to managers
+            for manName in self.startup:
+                cmd = cmd.split()[0]# use first word of the command
+                #print(f'man {manName,cmd}')
+                if manName.startswith('tst') and cmd != 'Check':
+                    continue
+                self.manAction(manName, cmd)
+
+    def deferredCheck(self, args):
+        #print(f'deferred: {args}')
+        manName,rowPosition = args
+        self.manAction(manName, ManCmds.index('Check'))
+        if 'start' not in self.item(rowPosition, Col['status']).text():
+            self.item(rowPosition, Col['response']).setText('Failed to start')
+#``````````````````Main Window````````````````````````````````````````````````
+class Window(QW.QMainWindow):# it may sense to subclass it from QW.QMainWindow
+    pargs = None
+    tableWidgets = {}
+    timer = QtCore.QTimer()
+
+    def __init__(self):
+        super().__init__()
+        H.Verbose = Window.pargs.verbose
+        folders = create_folderMap()
+        if len(folders) == 0:
+            sys.exit(1)
+        H.printi(f'Configuration files: {folders}')
+        self.setWindowTitle('procman')
+
+        # Create tabWidget
+        Window.tabWidget = detachable_tabs.DetachableTabWidget()
+        Window.tabWidget.currentChanged.connect(periodicCheck)
+        self.setCentralWidget(Window.tabWidget)
+        H.printv(f'tabWidget created')
+
+        # Add tables, configured from files, to tabs
+        for folder,files in folders.items():
+            sys.path.append(folder)
+            for fname in files:
+                tabName = fname[len(FilePrefix):-3]
+                mytable = MyTable(folder, fname, tabName)
+                Window.tableWidgets[tabName] = mytable
+                #print(f'Adding tab: {fname}')
+                Window.tabWidget.addTab(mytable, tabName)
+
+        # Update tables and set up periodic check
+        periodicCheck()
+        if Window.pargs.interval != 0.:
+            Window.timer.timeout.connect(periodicCheck)
+            Window.timer.setInterval(int(Window.pargs.interval*1000.))
+            Window.timer.start()
+
+def periodicCheck():
+    # execute tableWideAction on current tab
+    current_mytable().tableWideAction('Check')
+    # execute tableWideAction on all detached tabs
+    for tabName,mytable in Window.tableWidgets.items():
+        detached  = tabName in Window.tabWidget.detachedTabs
+        #print(f'periodic for {tabName,detached}')
+        if detached:
+            mytable.tableWideAction('Check')
+

procman-2.0.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "procman"
+version = "2.0.0"
+authors = [
+  { name="Andrei Sukhanov", email="cyxandr@gmail.com" },
+]
+
+description = "Tabbed GUI to start/stop/monitor programs"
+readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "qtpy",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/ASukhanov/procman"