ArcGIS_Shell.pyt

import arcpy
import locale
import os
import subprocess

class Toolbox(object):
    def __init__(self):
        self.label = "ArcGIS_Shell"
        self.alias = "ArcGIS_Shell"
        self.tools = [Shell]


class Shell(object):
    def __init__(self):
        self.label = "Shell"
        self.description = (
            "Runs a shell command and returns its output."
        )
        self.canRunInBackground = False

    def getParameterInfo(self):
        command = arcpy.Parameter(
            displayName="Command",
            name="command",
            datatype="GPString",
            parameterType="Required",
            direction="Input"
        )

        command_output = arcpy.Parameter(
            displayName="Output",
            name="command_output",
            datatype="GPString",
            parameterType="Derived",
            direction="Output"
        )

        return [command, command_output]

    def isLicensed(self):
        return True

    def updateParameters(self, parameters):
        return

    def updateMessages(self, parameters):
        return

    def execute(self, parameters, messages):
        command_text = parameters[0].valueAsText

        command_result = run_command(command_text)
        command_output = format_command_output(command_result)

        if command_output:
            arcpy.AddMessage(command_output)
        arcpy.SetParameterAsText(1, command_output)

def run_command(command_text):
    display = (command_text or "").strip()

    try:
        if not display:
            raise ValueError("Command parameter is empty")

        completed = subprocess.run(
            display,
            shell=True,
            stdin=subprocess.DEVNULL,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            timeout=10
        )

        return {
            "command": display,
            "shell": True,
            "returnCode": completed.returncode,
            "stdout": decode_command_output(completed.stdout),
            "stderr": decode_command_output(completed.stderr)[:1000]
        }

    except Exception as exc:
        return {
            "command": display,
            "shell": True,
            "returnCode": None,
            "stdout": "",
            "stderr": "{}: {}".format(type(exc).__name__, str(exc))[:1000]
        }


def decode_command_output(output_bytes):
    encoding = locale.getpreferredencoding(False)
    return normalize_line_endings(output_bytes.decode(encoding, errors="replace").rstrip())


def normalize_line_endings(text):
    return text.replace("\r\n", "\n").replace("\r", "\n").replace("\n", os.linesep)


def format_command_output(command_result):
    stdout = command_result.get("stdout", "")
    stderr = command_result.get("stderr", "")
    return_code = command_result.get("returnCode")

    if return_code == 0:
        return stdout

    output = []
    if stdout:
        output.append(stdout)
    if stderr:
        output.append(stderr)
    if return_code not in (0, None):
        if output:
            output.append("")
        output.append("Exit code: {}".format(return_code))

    return os.linesep.join(output)