reemote 0.0.1__tar.gz

reemote-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kim Jarvis
+
+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.

reemote-0.0.1/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: reemote
+Version: 0.0.1
+Summary: A Python package for reemote functionality
+Home-page: https://github.com/kimjarvis/reemote
+Author: Kim Jarvis
+Author-email: kim.jarvis@tpfsystems.com
+License: MIT
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cryptography
+Requires-Dist: bcrypt
+Requires-Dist: asyncssh
+Requires-Dist: tabulate
+Provides-Extra: dev
+Requires-Dist: setuptools; extra == "dev"
+Requires-Dist: asyncssh; extra == "dev"
+Provides-Extra: doc
+Requires-Dist: sphinx; extra == "doc"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+
+    Reemote is a Python API for task automation, configuration management and application deployment.
+    

reemote-0.0.1/README.md

@@ -0,0 +1,17 @@
+# Reemote 
+
+Reemote is a Python API for task automation, configuration management and application deployment.
+
+# Example
+
+The [GUI example](examples/gui) demonstrates a switch that creates or removes the directory `/tmp/mydir` on all the servers in an inventory.
+
+![GUI Demo](examples/gui/gui_demo.png)
+
+# Installation
+
+Install from PyPI 
+
+```bash
+pip install reemote
+```

reemote-0.0.1/reemote/operation.py

@@ -0,0 +1,7 @@
+class Operation:
+
+    def __init__(self, command: str, changed: bool = False):
+        self.command = command
+        self.host_info = None
+        self.sudo_info = None
+

reemote-0.0.1/reemote/operations/apk/packages.py

@@ -0,0 +1,66 @@
+from reemote.printers import print_ssh_completed_process
+from typing import List
+
+class Packages:
+    """
+    A class to manage package operations on a remote system using `apk` (Alpine Linux package manager).
+
+    Attributes:
+        packages (List[str]): A list of package names to be added or removed.
+        present (bool): Indicates whether the packages should be present (`True`) or absent (`False`) on the system.
+        sudo (bool): If `True`, the commands will be executed with `sudo` privileges.
+        su (bool): If `True`, the commands will be executed with `su` privileges.
+
+    Usage:
+        This class is designed to be used in a generator-based workflow where commands are yielded for execution.
+        It supports adding or removing packages based on the `present` flag and allows privilege escalation via `sudo` or `su`.
+
+    Notes:
+        - Commands are constructed based on the `present`, `sudo`, and `su` flags.
+        - The `changed` flag is set if the package state changes after execution.
+    """
+
+    def __init__(self,
+                 packages: List[str],
+                 present: bool,
+                 repository: str = None ,
+                 sudo: bool = False,
+                 su: bool = False):
+        self.packages: List[str] = packages
+        self.present: bool = present
+        self.repository: str = repository
+        self.sudo: bool = sudo
+        self.su: bool = su
+
+        # Construct the operation string from the list of packages
+        op: List[str] = []
+        op.extend(self.packages)
+        if repository:
+            op.append(f"--repository {repository}")
+        self.op: str = " ".join(op)
+
+    def __repr__(self) -> str:
+        return (f"Packages(packages={self.packages!r}, present={self.present!r},"
+                f"repository={self.repository!r},"
+                f"sudo={self.sudo!r}, su={self.su!r})")
+
+    def execute(self):
+        r0 = yield f"echo {self}"
+        _sudo: str = "sudo -S " if self.sudo else ""
+        _su: str = "su -c " if self.su else ""
+
+        # Retrieve the current list of installed packages
+        r1 = yield f"{_sudo}apk info -v"
+
+        # Add or remove packages based on the `present` flag
+        if self.present:
+            r2 = yield f"{_sudo}{_su}'apk add {self.op}'"
+        else:
+            r2 = yield f"{_sudo}{_su}'apk del {self.op}'"
+
+        # Retrieve the updated list of installed packages
+        r3 = yield f"{_sudo}apk info -v"
+
+        # Set the `changed` flag if the package state has changed
+        if r1.cp.stdout != r3.cp.stdout:
+            r2.changed = True

reemote-0.0.1/reemote/operations/apk/update.py

@@ -0,0 +1,45 @@
+from reemote.printers import print_ssh_completed_process
+from typing import List
+
+class Update:
+    """
+    A class to manage package operations on a remote system using `apk` (Alpine Linux package manager).
+
+    Attributes:
+        sudo (bool): If `True`, the commands will be executed with `sudo` privileges.
+        su (bool): If `True`, the commands will be executed with `su` privileges.
+
+    Usage:
+        Update installed packages.
+
+    Notes:
+        - Commands are constructed based on the `present`, `sudo`, and `su` flags.
+        - The `changed` flag is set if the package state changes after execution.
+    """
+
+    def __init__(self,
+                 sudo: bool = False,
+                 su: bool = False):
+        self.sudo: bool = sudo
+        self.su: bool = su
+
+    def __repr__(self) -> str:
+        return (f"Update("
+                f"sudo={self.sudo!r}, su={self.su!r})")
+
+    def execute(self):
+        r0 = yield f"echo {self}"
+        _sudo: str = "sudo -S " if self.sudo else ""
+        _su: str = "su -c " if self.su else ""
+
+        # Retrieve the current list of installed packages
+        r1 = yield f"{_sudo}apk info -v"
+
+        r2 = yield f"{_sudo}{_su}'apk update'"
+
+        # Retrieve the updated list of installed packages
+        r3 = yield f"{_sudo}apk info -v"
+
+        # Set the `changed` flag if the package state has changed
+        if r1.cp.stdout != r3.cp.stdout:
+            r2.changed = True

reemote-0.0.1/reemote/operations/apk/upgrade.py

@@ -0,0 +1,45 @@
+from reemote.printers import print_ssh_completed_process
+from typing import List
+
+class Upgrade:
+    """
+    A class to manage package operations on a remote system using `apk` (Alpine Linux package manager).
+
+    Attributes:
+        sudo (bool): If `True`, the commands will be executed with `sudo` privileges.
+        su (bool): If `True`, the commands will be executed with `su` privileges.
+
+    Usage:
+        Upgrade installed packages.
+
+    Notes:
+        - Commands are constructed based on the `present`, `sudo`, and `su` flags.
+        - The `changed` flag is set if the package state changes after execution.
+    """
+
+    def __init__(self,
+                 sudo: bool = False,
+                 su: bool = False):
+        self.sudo: bool = sudo
+        self.su: bool = su
+
+    def __repr__(self) -> str:
+        return (f"Upgrade("
+                f"sudo={self.sudo!r}, su={self.su!r})")
+
+    def execute(self):
+        r0 = yield f"echo {self}"
+        _sudo: str = "sudo -S " if self.sudo else ""
+        _su: str = "su -c " if self.su else ""
+
+        # Retrieve the current list of installed packages
+        r1 = yield f"{_sudo}apk info -v"
+
+        r2 = yield f"{_sudo}{_su}'apk upgrade'"
+
+        # Retrieve the upgraded list of installed packages
+        r3 = yield f"{_sudo}apk info -v"
+
+        # Set the `changed` flag if the package state has changed
+        if r1.cp.stdout != r3.cp.stdout:
+            r2.changed = True

reemote-0.0.1/reemote/operations/filesystem/chown.py

@@ -0,0 +1,70 @@
+class Chown:
+    """
+    A class to encapsulate the functionality of the `chown` or `chgrp` command in Unix-like operating systems.
+    It allows users to specify a target file or directory, along with optional user and group ownership changes,
+    additional command-line options, and the ability to execute the command with elevated privileges (`sudo`).
+
+    Attributes:
+        target (str): The file or directory whose ownership is to be changed.
+        user (Optional[str]): The new user owner. Defaults to `None`.
+        group (Optional[str]): The new group owner. Defaults to `None`.
+        options (List[str]): Additional command-line options for the `chown` or `chgrp` command.
+        sudo (bool): If `True`, the commands will be executed with `sudo` privileges.
+        su (bool): If `True`, the commands will be executed with `su` privileges.
+    """
+    def __init__(self, target: str,
+                 user: str | None = None,
+                 group: str | None = None,
+                 options=None,
+                 sudo: bool = False):
+
+        self.target = target
+        self.user = user
+        self.group = group
+        self.options = options
+        self.sudo = sudo
+
+        if options is None:
+            options = []
+
+        command = "chown"
+        user_group = None
+
+        if user and group:
+            user_group = f"{user}:{group}"
+        elif user:
+            user_group = user
+        elif group:
+            command = "chgrp"
+            user_group = group
+        else:
+            raise ValueError("Either user or group must be specified")
+
+        op = []
+        op.append(command)
+        op.extend(options)
+        op.append(user_group)
+        op.append(target)
+
+        self.chown = " ".join(op)
+
+    def __repr__(self):
+        return (f"Chown(target={self.target!r}, user={self.user!r}, "
+                f"group={self.group!r}, options={self.options!r}, sudo={self.sudo!r})")
+
+    def execute(self):
+        yield f"echo {self}"
+        _sudo = "sudo -S " if self.sudo else ""
+
+        # Get initial file info
+        r0 = yield f"{_sudo}ls -ld {self.target}"
+
+        # Execute chown command
+        r1 = yield f"{_sudo}{self.chown}"
+
+        # Get final file info to check if changed
+        r2 = yield f"{_sudo}ls -ld {self.target}"
+
+        # Set changed flag if the output differs
+        if r0.cp.stdout != r2.cp.stdout:
+            r1.changed = True

reemote-0.0.1/reemote/operations/filesystem/directory.py

@@ -0,0 +1,51 @@
+from reemote.result import Result
+
+class Directory:
+    class Directory:
+        """
+        A class to manage directory states on a filesystem.
+
+        Attributes:
+            path (str): The absolute or relative path of the directory to manage. This is the target directory whose state will be checked or modified.
+            present (bool): Indicates whether the directory should exist (`True`) or not (`False`) on the system. If `True`, the directory will be created if it does not exist. If `False`, the directory will be removed if it exists.
+            sudo (bool): If `True`, the commands will be executed with `sudo` privileges. Defaults to `False`.
+
+        Usage:
+            This class is designed to be used in a generator-based workflow where commands are yielded for execution.
+            It supports creating or removing directories based on the `present` flag and allows privilege escalation via `sudo`.
+
+        Notes:
+            - Commands are constructed based on the `present` and `sudo` flags.
+            - The `changed` flag is set if the directory state changes after execution.
+        """
+    def __init__(self, path: str, present: bool, sudo: bool = False):
+        self.path = path
+        self.present = present
+        self.sudo = sudo
+
+    def __repr__(self):
+        return f"Directory(path={self.path!r}, present={self.present!r}, sudo={self.sudo!r})"
+
+    def execute(self):
+        yield f"echo {self}"
+        """
+        Execute the directory management logic as a generator.
+
+        This method checks if the directory exists and performs actions based on the `present` flag.
+        """
+        _sudo = "sudo -S " if self.sudo else ""
+        # Check whether the directory exists
+        r0: Result = yield f"{_sudo}[ -d {self.path} ]"
+        # print(f">>>>> Received in Directory: {r}")
+
+        if self.present and r0.cp.returncode != 0:
+            # Present directory does not exist, so create it
+            r1 =yield f"{_sudo}mkdir -p {self.path}"
+            # print(f">>>>> Received in Directory: {r1}")
+            r1.changed=True
+
+        if not self.present and r0.cp.returncode == 0:
+            # Not Present directory exists, so remove it
+            r2 = yield f"{_sudo}rmdir -p {self.path}"
+            # print(f">>>>> Received in Directory: {r2}")
+            r2.changed=True

reemote-0.0.1/reemote/pre_order_generator.py

@@ -0,0 +1,35 @@
+from reemote.operation import Operation
+
+
+def pre_order_generator(node):
+    """
+    Enhanced generator function with better error handling and string wrapping.
+    """
+    stack = [(node, iter(node.execute()))]
+    result = None
+
+    while stack:
+        current_node, iterator = stack[-1]
+        try:
+            value = iterator.send(result) if result is not None else next(iterator)
+            result = None
+
+            # Handle different types of yielded values
+            if isinstance(value, Operation):
+                result = yield value
+            elif isinstance(value, str):
+                # Auto-wrap strings in Operation objects
+                operation = Operation(value)
+                result = yield operation
+            elif hasattr(value, 'execute') and callable(value.execute):
+                # If it's a node with execute method, push to stack
+                stack.append((value, iter(value.execute())))
+            else:
+                raise TypeError(f"Unsupported yield type: {type(value)}")
+
+        except StopIteration:
+            stack.pop()
+        except Exception as e:
+            # Handle errors in node execution
+            print(f"Error in node execution: {e}")
+            stack.pop()

reemote-0.0.1/reemote/printers.py

@@ -0,0 +1,232 @@
+from asyncssh import SSHCompletedProcess
+from asyncssh import ProcessError
+from typing import Optional, Mapping, Tuple, Union
+import json
+import pandas as pd
+from tabulate import tabulate
+
+def print_ssh_completed_process(process_result):
+    """
+    Prints the fields of an SSHCompletedProcess object.
+
+    :param process_result: The completed process result to inspect.
+    :type process_result: SSHCompletedProcess
+    """
+    # Ensure the input is of the expected type
+    if not isinstance(process_result, SSHCompletedProcess):
+        raise ValueError("The provided argument is not an instance of SSHCompletedProcess.")
+
+    # Define the fields to extract and their descriptions
+    fields = [
+        ("env", "The environment the client requested to be set for the process", "dict or None"),
+        ("command", "The command the client requested the process to execute (if any)", "str or None"),
+        ("subsystem", "The subsystem the client requested the process to open (if any)", "str or None"),
+        ("exit_status", "The exit status returned, or -1 if an exit signal is sent", "int"),
+        ("exit_signal", "The exit signal sent (if any) in the form of a tuple containing the signal name, "
+                        "a bool for whether a core dump occurred, a message associated with the signal, "
+                        "and the language the message was in", "tuple or None"),
+        ("returncode", "The exit status returned, or negative of the signal number when an exit signal is sent", "int"),
+        ("stdout", "The output sent by the process to stdout (if not redirected)", "str or bytes"),
+        ("stderr", "The output sent by the process to stderr (if not redirected)", "str or bytes"),
+    ]
+
+    # Print each field and its value
+    print("Fields of SSHCompletedProcess:")
+    print("--------------------------------")
+    for field_name, description, field_type in fields:
+        value = getattr(process_result, field_name, None)
+        print(f"{field_name}: {value}")
+        print(f"  Description: {description}")
+        print(f"  Type: {field_type}")
+        print()
+
+
+def print_process_error_fields(process_error):
+    """
+    Prints the fields of an asyncssh.ProcessError exception.
+
+    Args:
+        process_error (asyncssh.ProcessError): The exception instance to inspect.
+    """
+    if not isinstance(process_error, ProcessError):
+        raise ValueError("The provided argument is not an instance of asyncssh.ProcessError.")
+
+    # Define the fields to extract and their descriptions
+    fields = [
+        ("env", "The environment the client requested to be set for the process"),
+        ("command", "The command the client requested the process to execute (if any)"),
+        ("subsystem", "The subsystem the client requested the process to open (if any)"),
+        ("exit_status", "The exit status returned, or -1 if an exit signal is sent"),
+        ("exit_signal", "The exit signal sent (if any) in the form of a tuple containing the signal name, "
+                        "a bool for whether a core dump occurred, a message associated with the signal, "
+                        "and the language the message was in"),
+        ("returncode", "The exit status returned, or negative of the signal number when an exit signal is sent"),
+        ("stdout", "The output sent by the process to stdout (if not redirected)"),
+        ("stderr", "The output sent by the process to stderr (if not redirected)"),
+        ("reason", "The reason for the error"),
+        ("lang", "The language of the error message")
+    ]
+
+    # Print each field and its value
+    print("Fields of asyncssh.ProcessError:")
+    print("--------------------------------")
+    for field_name, description in fields:
+        value = getattr(process_error, field_name, None)
+        print(f"{field_name}: {value}")
+        print(f"  Description: {description}")
+        print()
+
+def construct_host_ops(operations, results):
+    """
+    Construct a list of dictionaries grouping operations and results by host.
+
+    Args:
+        operations (list): List of Operation objects.
+        results (list): List of Result objects.
+
+    Returns:
+        list: A list of dictionaries in the desired format.
+    """
+    # Dictionary to group operations and results by host
+    host_dict = {}
+
+    # Iterate over operations and results simultaneously
+    for operation, result in zip(operations, results):
+        host = operation.host_info['host']  # Extract host from operation
+        stdout = result.cp.stdout.strip() if result.cp.stdout else "<no stdout>"  # Extract stdout from result
+
+        # Group by host
+        if host not in host_dict:
+            host_dict[host] = []
+        host_dict[host].append(
+            ({"command": operation.command},
+             {"stdout": stdout, "returncode": result.cp.returncode,
+              "changed": result.changed}))
+
+    # Convert the dictionary into the desired list of dictionaries format
+    host_ops_list = [{"host": host, "ops": ops} for host, ops in host_dict.items()]
+
+    return host_ops_list
+
+def print_json_ops(host_ops):
+    pretty_output = json.dumps(host_ops, indent=4)
+    # Print the formatted output
+    print(pretty_output)
+
+
+def generate_change_df(host_ops):
+    # Step 1: Extract commands, changed, and executed values for each host
+    data = {}
+    for host_data in host_ops:
+        host = host_data["host"]
+        data[host] = []
+        for op_pair in host_data["ops"]:
+            # Extract the command from the first dictionary
+            command = op_pair[0]["command"]
+            # Merge the changed values from both dictionaries
+            changed = any(d.get("changed", False) for d in op_pair)
+            # Get the executed value from the second dictionary
+            executed = op_pair[1].get("executed", False)
+            data[host].append((command, changed, executed))
+    # Step 2: Align commands across hosts
+    commands = [op[0] for op in data[next(iter(data))]]  # Use the first host's commands as reference
+    df_data = {}
+    # Add columns for each host: <host>_changed and <host>_executed
+    for host, ops in data.items():
+        df_data[(host, "changed")] = [changed for _, changed, _ in ops]
+        df_data[(host, "executed")] = [executed for _, _, executed in ops]
+    # Step 3: Create the DataFrame with MultiIndex columns
+    df = pd.DataFrame(df_data, index=commands)
+    # Rename the index to "Command"
+    df.index.name = "Command"
+    # Display the DataFrame
+    return df
+
+def convert_df_to_ag_grid(df):
+    # Reset index to make the index a column
+    df_reset = df.reset_index()
+
+    # Convert all column names to strings
+    df_reset.columns = [str(col) if not isinstance(col, tuple) else ' '.join(map(str, col)).strip()
+                        for col in df_reset.columns]
+
+    # Create column definitions
+    column_defs = []
+    for col in df_reset.columns:
+        field_name = col.lower().replace(' ', '_')
+        column_defs.append({'headerName': col, 'field': field_name})
+
+    # Create row data
+    row_data = []
+    for index, row in df_reset.iterrows():
+        row_dict = {}
+        for col in df_reset.columns:
+            field_name = col.lower().replace(' ', '_')
+            row_dict[field_name] = row[col]
+        row_data.append(row_dict)
+
+    return {
+        'columnDefs': column_defs,
+        'rowData': row_data
+    }
+
+
+def summarize_data_for_aggrid(data):
+    # Initialize the result dictionary
+    result = {"columnDefs": [], "rowData": []}
+
+    # Extract the list of hosts from the input data
+    hosts = [host_data["host"] for host_data in data]
+
+    # Add the 'Command' column to columnDefs
+    result["columnDefs"].append({"headerName": "Command", "field": "command"})
+
+    # Add a column for each host
+    for i, host in enumerate(hosts):
+        result["columnDefs"].append({"headerName": host, "field": f"host{i}"})
+
+    # Populate rowData
+    for ops_index, ops in enumerate(data[0]["ops"]):  # Assuming all hosts have the same commands
+        row = {}
+        # Add the command to the row
+        if ops[0]["command"].startswith("echo"):
+            row["command"] = ops[0]["command"].replace("echo", ">>>>")
+        else:
+            row["command"] = ops[0]["command"]
+
+        # Add boolean values for each host
+        for host_index, host_data in enumerate(data):
+            command_dict, result_dict = host_data["ops"][ops_index]
+            changed = result_dict.get("changed", False)
+            row[f"host{host_index}"] = changed
+
+        # Append the row to rowData
+        result["rowData"].append(row)
+
+    return result
+
+
+def get_printable_aggrid(data):
+    """
+    Formats and prints the given AGGrid data as a formatted grid.
+
+    Parameters:
+        data (dict): A dictionary containing 'columnDefs' and 'rowData'.
+                     - 'columnDefs': List of dictionaries with 'headerName' and 'field'.
+                     - 'rowData': List of dictionaries representing rows of data.
+
+    Returns:
+        None: Prints the formatted grid.
+    """
+    # Step 1: Extract headers and field mappings
+    headers = [col['headerName'] for col in data['columnDefs']]
+    field_mapping = {col['field']: col['headerName'] for col in data['columnDefs']}
+
+    # Step 2: Prepare the table data
+    table_data = []
+    for row in data['rowData']:
+        formatted_row = [row[field] for field in field_mapping.keys()]
+        table_data.append(formatted_row)
+
+    # Step 3: Print the formatted grid using tabulate
+    print(tabulate(table_data, headers=headers, tablefmt="grid"))

reemote-0.0.1/reemote/result.py

@@ -0,0 +1,9 @@
+from asyncssh import SSHCompletedProcess
+
+class Result:
+
+    def __init__(self, cp: SSHCompletedProcess, host: str, changed: bool = False):
+        self.cp = cp
+        self.host = host
+        self.changed = changed
+