Skip to content
Back to top

# Source code for xonsh.xoreutils.uname

    #!/usr/bin/env python

    """
    Provides a cross-platform way to figure out the system uname.

    This version of uname was written in Python for the xonsh project: http://xon.sh

    Based on cat from GNU coreutils: http://www.gnu.org/software/coreutils/
    """

    import platform
    import sys

    from xonsh.cli_utils import ArgParserAlias

    def uname_fn(
        all=False,
        kernel_name=False,
        node_name=False,
        kernel_release=False,
        kernel_version=False,
        machine=False,
        processor=False,
        hardware_platform=False,
        operating_system=False,
    ):
        """This version of uname was written in Python for the xonsh project: https://xon.sh

        Based on uname from GNU coreutils: http://www.gnu.org/software/coreutils/

        Parameters
        ----------
        all : -a, --all
            print all information, in the following order, except omit -p and -i if unknown
        kernel_name : -s, --kernel-name
            print the kernel name
        node_name : -n, --nodename
            print the network node hostname
        kernel_release : -r, --kernel-release
            print the kernel release
        kernel_version : -v, --kernel-version
            print the kernel version
        machine : -m, --machine
            print the machine hardware name
        processor : -p, --processor
            print the processor type (non-portable)
        hardware_platform : -i, --hardware-platform
            print the hardware platform (non-portable)
        operating_system : -o, --operating-system
            print the operating system
        """

        info = platform.uname()

        def gen_lines():
            if all or node_name:
                yield info.node

            if all or kernel_release:
                yield info.release

            if all or kernel_version:
                yield info.version

            if all or machine:
                yield info.machine

            if all or processor:
                yield info.processor or "unknown"

            if all or hardware_platform:
                yield "unknown"

            if all or operating_system:
                yield sys.platform

        lines = list(gen_lines())
        if all or kernel_name or (not lines):
            lines.insert(0, info.system)
        line = " ".join(lines)

        return line

    uname = ArgParserAlias(func=uname_fn, has_args=True, prog="uname")

    def main(args=None):
        from xonsh.xoreutils.util import run_alias

        run_alias("uname", args)

    if __name__ == "__main__":
        main()