pmflow 1.2.0__tar.gz → 1.2.3__tar.gz

{pmflow-1.2.0 → pmflow-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pmflow
-Version: 1.2.0
+Version: 1.2.3
 Summary: Manages processes
 Author-email: "Md. Mahmudul Hasan Riyad" <mhriyad98@gmail.com>
 License: MIT License
@@ -46,6 +46,7 @@ Provides-Extra: dev
 pip install pmflow
 ```
 ## Commands
+### <^> Main commands
 create: Creates a new process
 
 Required arguments:
@@ -56,26 +57,46 @@ Optional arguments:
 - --group or -g : str (default: process_id)
 - --relation or -r : "parent" | "child" (default: "parent")
 - --verbose or -v: (default: false)
+
+Note: A child process must have a group name and the group must have a parent process.
+
+Example:
 ```
-pm create "<your command>"
+pm create "<command>"
 or
-pm create "<your command>" --name "<your process name>"
+pm create "<command>" -n "<process name>" -g "<group name>" -r "child"
 ```
 ls: List all managed processes
 
 Optional arguments:
-- --json or -j (default: false)
+- --json or -j: bool (default: false)
+- --group or -g: str (default: None)
+- --running or -r: bool (default: false)
+Example:
 ```
 pm ls
 pm ls -j
+pm ls -g <group_name>
+pm ls -j -g <group_name>
+pm ls -r 
 ```
-Kill process, kills the process and also removes it from the json file.
+kill: Kill process, kills the process and also removes it from the json file.
+
+Optional arguments:
+- pid (no flag needed): int (default: 0) kills one process if it's a child process. Otherwise, kills the terminates 
+- --group or -g: str (default: None) kills one group if exist
+- --child or -c: bool (default: False) kills all child process in a group
+- --all or -a : bool (default: false) kills all the process
+
+Note: Other than -c only one options can be used at a time. -c flag must be used with -g
 
+Example:
 ```
 pm kill <PID>
-pm kill-all
+pm -g <group_name>
+pm -a
 ```
-
+### <^> Additional commands
 Recreate all process managed by the tool:
 ```
 pm recreate
@@ -86,5 +107,5 @@ pm pause <PID>
 ```
 respawn all paused process
 ```
-pm respawn-all
+pm respawn
 ```

pmflow-1.2.3/README.md

@@ -0,0 +1,73 @@
+# PMFlow
+<p style="font-size:15px;">This is a simple process managing tool</p>
+
+<p style="font-size:15px;">This tools keeps the information of the processes it manages in a json file created at it's installation location</p>
+
+## Installation
+```
+pip install pmflow
+```
+## Commands
+### <^> Main commands
+create: Creates a new process
+
+Required arguments:
+- command: str (default: None)
+
+Optional arguments:
+- --name or -n : str (default: None)
+- --group or -g : str (default: process_id)
+- --relation or -r : "parent" | "child" (default: "parent")
+- --verbose or -v: (default: false)
+
+Note: A child process must have a group name and the group must have a parent process.
+
+Example:
+```
+pm create "<command>"
+or
+pm create "<command>" -n "<process name>" -g "<group name>" -r "child"
+```
+ls: List all managed processes
+
+Optional arguments:
+- --json or -j: bool (default: false)
+- --group or -g: str (default: None)
+- --running or -r: bool (default: false)
+Example:
+```
+pm ls
+pm ls -j
+pm ls -g <group_name>
+pm ls -j -g <group_name>
+pm ls -r 
+```
+kill: Kill process, kills the process and also removes it from the json file.
+
+Optional arguments:
+- pid (no flag needed): int (default: 0) kills one process if it's a child process. Otherwise, kills the terminates 
+- --group or -g: str (default: None) kills one group if exist
+- --child or -c: bool (default: False) kills all child process in a group
+- --all or -a : bool (default: false) kills all the process
+
+Note: Other than -c only one options can be used at a time. -c flag must be used with -g
+
+Example:
+```
+pm kill <PID>
+pm -g <group_name>
+pm -a
+```
+### <^> Additional commands
+Recreate all process managed by the tool:
+```
+pm recreate
+```
+Pause a process
+```
+pm pause <PID>
+```
+respawn all paused process
+```
+pm respawn
+```

{pmflow-1.2.0 → pmflow-1.2.3}/pm/commands/create.py

@@ -13,12 +13,7 @@ from pm.settings import state
 from typing import Optional
 from enum import Enum
 from typing_extensions import Annotated
-
-
-class Relation(str, Enum):
-    PARENT = 'parent'
-    CHILD = 'child'
-
+from pm.schema import Relation
 
 def create(command: Annotated[str, typer.Argument()],
            name: Annotated[Optional[str], typer.Option("--name","-n")] = None,
@@ -27,15 +22,29 @@ def create(command: Annotated[str, typer.Argument()],
            verbose: Annotated [bool, typer.Option("--verbose", "-v")] = False) -> int:
 
     """Create a new subprocess and optionally assign a name."""
+
+    if relation == Relation.CHILD:
+        if not group:
+            typer.echo(f"Error 800: Please specify an existing group of a parent process")
+            raise typer.Exit(code=1)
+        elif group not in state.get_parents_groupname():
+            typer.echo(f"Error 801: No parent group with this name exist. "
+                       f"Please specify an existing group of a parent process")
+            raise typer.Exit(code=1)
+
     proc = subprocess.Popen(command, shell=True)
     pid = proc.pid
 
-    if not group:
-        group = str(pid)
+    if relation == Relation.PARENT:
+        if not group:
+            group = str(pid)
+        elif state.is_group_exist(group):
+            typer.echo(f"Error 802: A group can have only one parent process.")
 
     data = {
         "command": command,
         "name": name,
+        "status": "running",
         "group": group,
         "relation": relation,
     }

pmflow-1.2.3/pm/commands/kill.py

@@ -0,0 +1,127 @@
+"""
+This module is related to stopping a process's from running or deleting it altogether
+The commands it manages are
+    - pause
+    - kill
+"""
+
+import typer
+import psutil
+import signal
+from typing import Optional
+from typing_extensions import Annotated
+from pm.settings import state
+
+
+def pause(pid: int):
+    """Pause a subprocess and all its children by PID."""
+    pid_str = str(pid)
+    if pid_str in state.processes:
+        try:
+            process = psutil.Process(int(pid))
+            all_processes = [process] + process.children(recursive=True)
+            for proc in all_processes:
+                proc.send_signal(signal.SIGSTOP)
+            typer.echo(f"Process {pid} and its child processes have been paused.")
+        except psutil.NoSuchProcess:
+            typer.echo("Process not found.")
+    else:
+        typer.echo("Process not managed by this tool.")
+
+
+def kill(pid: Annotated[Optional[int], typer.Argument()] = 0,
+         group: Annotated[Optional[str], typer.Option("--group", "-g")] = None,
+        child: Annotated[Optional[bool], typer.Option("--child", "-c")] = False,
+         all: Annotated[Optional[bool], typer.Option("--all", "-a")] = False,):
+    """
+    Kill a subprocess by PID, group name.
+
+    params:
+    pid: int -> kill a process by it's pid.
+    group: str -> kill a process by it's group name.'
+    child: bool -> kill all child process of a group. This can only be used with --group or -g.
+    all: bool -> kill all existing process.
+
+    """
+
+    # validating arguments so that only one argument is given otherwise throw error
+    args_given = sum([pid != 0, group is not None, all is not False])
+
+    if args_given == 0:
+        typer.echo("Error 1100: You must specify exactly one of: PID, group, or --all.", err=True)
+        raise typer.Exit(code=1)
+
+    if args_given > 1:
+        typer.echo("Error 1200: You can only specify one of: PID, group, or --all.", err=True)
+        raise typer.Exit(code=1)
+
+    # Delete process with the flag given
+    # For pid
+    if pid:
+        pid_str = str(pid)
+
+        if pid_str in state.get_processes().keys():
+            if state.get_processes()[pid_str]["relation"] == "parent":
+                typer.echo(f"Process {pid} is a parent process. Killing it with all it's children...")
+                process_group = state.get_a_group(state.get_processes()[pid_str]["group"])
+                if process_group:
+                    kill_group_process(process_group)
+                    for pid in process_group.keys():
+                        state.remove_process(pid)
+            else:
+                try:
+                    process = psutil.Process(int(pid))
+                    for child in process.children(recursive=True):
+                        child.terminate()
+                    process.terminate()
+                    state.remove_process(pid_str)
+                    typer.echo(f"Process {pid} killed.")
+                except psutil.NoSuchProcess:
+                    state.remove_process(pid_str)
+                    typer.echo("Process not found. Removed from the state file.")
+        else:
+            typer.echo("Process not managed by this tool.")
+
+    # For group flag --group or -g
+    if group:
+        process_group = state.get_a_group(group)
+
+        if child:
+            process_group = {pid: data for pid, data in process_group.items() if data["relation"] == "child"}
+
+        if process_group:
+            kill_group_process(process_group)
+            for pid in process_group.keys():
+                state.remove_process(pid)
+
+    # For all flag --all or -a
+    if all:
+        for pid in state.processes.keys():
+            try:
+                process = psutil.Process(int(pid))
+                for child in process.children(recursive=True):
+                    child.terminate()
+                process.terminate()
+                typer.echo(f"Process {pid} terminated.")
+            except psutil.NoSuchProcess:
+                typer.echo(f"Process {pid} not found.")
+            except Exception as e:
+                typer.echo(f"Error terminating process {pid}: {str(e)}")
+
+        state.remove_all_processes()
+        typer.echo("All processes have been terminated and removed from the state.")
+
+
+def kill_group_process(processes: dict):
+
+    for pid in processes.keys():
+        try:
+            process = psutil.Process(int(pid))
+            for child in process.children(recursive=True):
+                child.terminate()
+            process.terminate()
+            typer.echo(f"Process {pid} terminated.")
+        except psutil.NoSuchProcess:
+            typer.echo(f"Process {pid} not found. Removed from state.")
+        except Exception as e:
+            typer.echo(f"Error terminating process {pid}: {str(e)}")

pmflow-1.2.3/pm/commands/ls.py

@@ -0,0 +1,67 @@
+"""
+This module manages handles output presentation of the process's.
+The command it manages are
+    - ls
+"""
+
+import typer
+import psutil
+import json
+from rich.console import Console
+from rich.table import Table
+from pm.settings import state
+from typing_extensions import Annotated
+
+
+def ls(json_output: Annotated[bool, typer.Option("--json", "-j")] = False,
+       group_name: Annotated[str, typer.Option("--group", "-g")] = None,
+       running: Annotated[bool, typer.Option("--running", "-r")] = False) -> None:
+    """List all managed subprocesses."""
+
+    # Update status of each process
+    for pid, properties in state.get_processes().items():
+        try:
+            process = psutil.Process(int(pid))
+            if process.status() == psutil.STATUS_STOPPED:
+                status = 'paused'
+            else:
+                status = 'running'
+        except psutil.NoSuchProcess:
+            status = "doesn't exist"
+
+        state.update_process(pid, "status", status)
+
+    # Console output block
+    if group_name:
+        process_dict = state.get_a_group(group_name)
+        if not process_dict:
+            typer.echo(f"Error 1000: No process group with group name {group_name} exist")
+            raise typer.Exit(code=1)
+    else:
+        process_dict = state.get_processes()
+
+    if running:
+        process_dict ={pid: data for pid, data in process_dict.items() if data["status"] == "running"}
+
+
+    if json_output:
+        json_output = json.dumps(process_dict)
+        typer.echo(json_output)
+
+    else:
+        table = Table()
+        table.add_column("PID", justify="center", style="#00ffee")
+        table.add_column("Name", justify="center", style="#f7d59e")
+        table.add_column("Status", justify="center", style="#e2fa2a")
+        table.add_column("Group", justify="center", style="#00ffee")
+        table.add_column("Relation", justify="center", style="#f700ff")
+        table.add_column("Command", justify="center", style="#00ff26")
+
+
+        for pid, properties in process_dict.items():
+
+            table.add_row(pid, properties["name"], properties["status"], properties["group"],
+                          properties["relation"],properties["command"])
+
+        console = Console()
+        console.print(table)

{pmflow-1.2.0 → pmflow-1.2.3}/pm/main.py

@@ -2,7 +2,7 @@
 import typer
 
 from pm.commands.create import create, recreate, respawn
-from pm.commands.kill import pause, kill, kill_all
+from pm.commands.kill import pause, kill
 from pm.commands.ls import ls
 
 app = typer.Typer()
@@ -20,7 +20,6 @@ app.command()(respawn)
 # Commands related to deletion of a process
 app.command()(pause)
 app.command()(kill)
-app.command()(kill_all)
 
 
 # Commands related to process presentation

pmflow-1.2.3/pm/schema.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+class Relation(str, Enum):
+    PARENT = 'parent'
+    CHILD = 'child'

{pmflow-1.2.0 → pmflow-1.2.3}/pm/utils.py

@@ -1,9 +1,11 @@
 import json
 import os
 import sys
+from typing import List, Dict
 
 import typer
 
+from pm.schema import Relation
 
 class StateManager:
     def __init__(self, STATE_FILE):
@@ -25,9 +27,6 @@ class StateManager:
         with open(self.STATE_FILE, "w") as file:
             json.dump(self.processes, file)
 
-    def get_processes(self):
-        return self.processes
-
     def add_process(self, pid, data):
         self.processes[str(pid)] = data
         self.save()
@@ -48,6 +47,21 @@ class StateManager:
         self.processes = bulk_data
         self.save()
 
+    def get_processes(self):
+        return self.processes
+
+    def get_parents_groupname(self) -> List[Relation]:
+        parent_groups = [process_meta_data["group"] for process_meta_data in self.processes.values()
+                         if process_meta_data["relation"] == Relation.PARENT]
+        return parent_groups
+
+    def get_a_group(self, group_name: str) -> Dict:
+        group_process = {pid: data for pid, data in self.processes.items() if data["group"] == group_name}
+        return group_process
+
+    def is_group_exist(self, group_name: str) -> bool:
+        return group_name in self.get_parents_groupname()
+
 
 
 def load_state(path):

{pmflow-1.2.0 → pmflow-1.2.3}/pmflow.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pmflow
-Version: 1.2.0
+Version: 1.2.3
 Summary: Manages processes
 Author-email: "Md. Mahmudul Hasan Riyad" <mhriyad98@gmail.com>
 License: MIT License
@@ -46,6 +46,7 @@ Provides-Extra: dev
 pip install pmflow
 ```
 ## Commands
+### <^> Main commands
 create: Creates a new process
 
 Required arguments:
@@ -56,26 +57,46 @@ Optional arguments:
 - --group or -g : str (default: process_id)
 - --relation or -r : "parent" | "child" (default: "parent")
 - --verbose or -v: (default: false)
+
+Note: A child process must have a group name and the group must have a parent process.
+
+Example:
 ```
-pm create "<your command>"
+pm create "<command>"
 or
-pm create "<your command>" --name "<your process name>"
+pm create "<command>" -n "<process name>" -g "<group name>" -r "child"
 ```
 ls: List all managed processes
 
 Optional arguments:
-- --json or -j (default: false)
+- --json or -j: bool (default: false)
+- --group or -g: str (default: None)
+- --running or -r: bool (default: false)
+Example:
 ```
 pm ls
 pm ls -j
+pm ls -g <group_name>
+pm ls -j -g <group_name>
+pm ls -r 
 ```
-Kill process, kills the process and also removes it from the json file.
+kill: Kill process, kills the process and also removes it from the json file.
+
+Optional arguments:
+- pid (no flag needed): int (default: 0) kills one process if it's a child process. Otherwise, kills the terminates 
+- --group or -g: str (default: None) kills one group if exist
+- --child or -c: bool (default: False) kills all child process in a group
+- --all or -a : bool (default: false) kills all the process
+
+Note: Other than -c only one options can be used at a time. -c flag must be used with -g
 
+Example:
 ```
 pm kill <PID>
-pm kill-all
+pm -g <group_name>
+pm -a
 ```
-
+### <^> Additional commands
 Recreate all process managed by the tool:
 ```
 pm recreate
@@ -86,5 +107,5 @@ pm pause <PID>
 ```
 respawn all paused process
 ```
-pm respawn-all
+pm respawn
 ```

{pmflow-1.2.0 → pmflow-1.2.3}/pmflow.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ README.md
 pyproject.toml
 pm/__init__.py
 pm/main.py
+pm/schema.py
 pm/settings.py
 pm/utils.py
 pm/commands/__init__.py

{pmflow-1.2.0 → pmflow-1.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pmflow"
-version = "1.2.0"
+version = "1.2.3"
 description = "Manages processes"
 readme = "README.md"
 authors =[{name = "Md. Mahmudul Hasan Riyad", email = "mhriyad98@gmail.com"}]

pmflow-1.2.0/README.md

@@ -1,52 +0,0 @@
-# PMFlow
-<p style="font-size:15px;">This is a simple process managing tool</p>
-
-<p style="font-size:15px;">This tools keeps the information of the processes it manages in a json file created at it's installation location</p>
-
-## Installation
-```
-pip install pmflow
-```
-## Commands
-create: Creates a new process
-
-Required arguments:
-- command: str (default: None)
-
-Optional arguments:
-- --name or -n : str (default: None)
-- --group or -g : str (default: process_id)
-- --relation or -r : "parent" | "child" (default: "parent")
-- --verbose or -v: (default: false)
-```
-pm create "<your command>"
-or
-pm create "<your command>" --name "<your process name>"
-```
-ls: List all managed processes
-
-Optional arguments:
-- --json or -j (default: false)
-```
-pm ls
-pm ls -j
-```
-Kill process, kills the process and also removes it from the json file.
-
-```
-pm kill <PID>
-pm kill-all
-```
-
-Recreate all process managed by the tool:
-```
-pm recreate
-```
-Pause a process
-```
-pm pause <PID>
-```
-respawn all paused process
-```
-pm respawn-all
-```

pmflow-1.2.0/pm/commands/kill.py

@@ -1,65 +0,0 @@
-"""
-This module is related to stopping a process's from running or deleting it altogether
-The commands it manages are
-    - pause
-    - kill
-    - kill-all
-"""
-
-import typer
-import psutil
-import signal
-from pm.settings import state
-
-
-def pause(pid: int):
-    """Pause a subprocess and all its children by PID."""
-    pid_str = str(pid)
-    if pid_str in state.processes:
-        try:
-            process = psutil.Process(int(pid))
-            all_processes = [process] + process.children(recursive=True)
-            for proc in all_processes:
-                proc.send_signal(signal.SIGSTOP)
-            typer.echo(f"Process {pid} and its child processes have been paused.")
-        except psutil.NoSuchProcess:
-            typer.echo("Process not found.")
-    else:
-        typer.echo("Process not managed by this tool.")
-
-
-def kill(pid: int):
-    """Kill a subprocess by PID."""
-    pid_str = str(pid)
-    if pid_str in state.processes:
-        try:
-            process = psutil.Process(int(pid))
-            for child in process.children(recursive=True):
-                child.terminate()
-            process.terminate()
-            state.remove_process(pid_str)
-            typer.echo(f"Process {pid} killed.")
-        except psutil.NoSuchProcess:
-            state.remove_process(pid_str)
-            typer.echo("Process not found. Removed from the state file.")
-    else:
-        typer.echo("Process not managed by this tool.")
-
-
-def kill_all():
-    """Kill all managed processes and clear the state."""
-
-    for pid in state.processes.keys():
-        try:
-            process = psutil.Process(int(pid))
-            for child in process.children(recursive=True):
-                child.terminate()
-            process.terminate()
-            typer.echo(f"Process {pid} terminated.")
-        except psutil.NoSuchProcess:
-            typer.echo(f"Process {pid} not found.")
-        except Exception as e:
-            typer.echo(f"Error terminating process {pid}: {str(e)}")
-
-    state.remove_all_processes()
-    typer.echo("All processes have been terminated and removed from the state.")

pmflow-1.2.0/pm/commands/ls.py

@@ -1,47 +0,0 @@
-"""
-This module manages handles output presentation of the process's.
-The command it manages are
-    - ls
-"""
-
-import typer
-import psutil
-import json
-from rich.console import Console
-from rich.table import Table
-from pm.settings import state
-from typing_extensions import Annotated
-
-
-def ls(json_output: Annotated[bool, typer.Option("--json", "-j")] = False) -> None:
-    """List all managed subprocesses."""
-
-    if json_output:
-        json_output = json.dumps(state.get_processes())
-        typer.echo(json_output)
-
-    else:
-        table = Table()
-        table.add_column("PID", justify="center", style="#00ffee")
-        table.add_column("Name", justify="center", style="#f7d59e")
-        table.add_column("Status", justify="center", style="#e2fa2a")
-        table.add_column("Group", justify="center", style="#00ffee")
-        table.add_column("Relation", justify="center", style="#f700ff")
-        table.add_column("Command", justify="center", style="#00ff26")
-
-
-        for pid, properties in state.get_processes().items():
-            try:
-                process = psutil.Process(int(pid))
-                if process.status() == psutil.STATUS_STOPPED:
-                    status = 'paused'
-                else:
-                    status = 'running'
-            except psutil.NoSuchProcess:
-                status = "doesn't exist"
-
-            table.add_row(pid, properties["name"], status, properties["group"],
-                          properties["relation"],properties["command"])
-
-        console = Console()
-        console.print(table)