runps 4.0.0__py3-none-any.whl

runps-4.0.0.dist-info/METADATA

@@ -0,0 +1,502 @@
+Metadata-Version: 2.4
+Name: runps
+Version: 4.0.0
+Summary: A small python utility for launching external processes easily..
+Author: Andrew Moffat, Lucas Sinclair
+License: Copyright (C) 2011-2012 by Andrew Moffat
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/xapple/runps/
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+License-File: AUTHORS.md
+Dynamic: license-file
+
+`runps` version 4.0.0
+=====================
+
+#### This is a fork of the `sh` package (formely `pbs` package) that works on Linux, macOS and Windows.
+
+| Package     | *nix / Python 2 | *nix / Python 3 | Windows / Python 2 | Windows / Python 3 | Compatible forking* |
+|-------------|-----------------|-----------------| ---------------    | ---------------    | ------------------- |
+| [`sh`](https://github.com/amoffat/sh) | ✅ Works         | ✅  Works        | 🔴 Not supported   | 🔴 Not supported   | 🔴 Fails            |
+| `runps`     | ✅ Works         | ✅  Works        | ✅ Works           | ✅ Works           | ✅ Works            |
+
+\* By compatible forking we mean a method of creating subprocesses that can work successfully inside a debugging environment such as the one provided by PyCharm.
+
+### Why do we need a different version of `sh`?
+
+* First, in early 2012, the original `pbs` package was conceived by [@amoffat](https://github.com/amoffat/sh). It could launch subprocesses on both Unix and Windows environments with Python 2.
+
+* In late 2012, the `pbs` project was renamed to `sh`, lots of functionality was added, but support for Windows [was completely dropped](http://amoffat.github.io/sh/sections/faq.html#will-windows-be-supported).
+
+* For some time, the legacy `pbs` package was still used whenever one needs to launch external processes on Windows machines and was [still available](https://pypi.org/project/pbs/) at `pip install pbs`.
+
+* The old `pbs` package was also used for its more compatible way of starting subprocesses. The current `sh` module is [not compatible](https://github.com/amoffat/sh/issues/475) with developing in PyCharm for instance.
+
+* However, the last ever published version of `pbs` (v0.110 from Oct 20, 2012) does not work on Python 3. This package fixes that.
+
+* `runps` works on all platforms and Python versions.
+
+
+### How do I install and use this package?
+
+* You can install this version with this command:
+
+    `pip install runps`
+
+* You can use this package with this import statement (if you are porting from `sh` code):
+
+    `import runps as sh`
+
+
+### What exactly did not work in Python 3?
+
+This would be the traceback that the old `pbs v0.110` would produce:
+
+    c:\python37\lib\site-packages\pbs.py in __call__(self, *args, **kwargs)
+        454             cwd=call_args["cwd"], stdin=stdin, stdout=stdout, stderr=stderr)
+        455
+    --> 456         return RunningCommand(command_ran, process, call_args, actual_stdin)
+        457
+        458
+
+    c:\python37\lib\site-packages\pbs.py in __init__(self, command_ran, process, call_args,
+     stdin)
+        166         if stdin: stdin = stdin.encode("utf8")
+        167         self._stdout, self._stderr = self.process.communicate(stdin)
+    --> 168         self._handle_exit_code(self.process.wait())
+        169
+        170     def __enter__(self):
+
+    c:\python37\lib\site-packages\pbs.py in _handle_exit_code(self, rc)
+        233     def _handle_exit_code(self, rc):
+        234         if rc not in self.call_args["ok_code"]:
+    --> 235             raise get_rc_exc(rc)(self.command_ran, self._stdout, self._stderr)
+        236
+        237     def __len__(self):
+
+    c:\python37\lib\site-packages\pbs.py in __init__(self, full_cmd, stdout, stderr)
+         93
+         94         msg = "\n\nRan: %r\n\nSTDOUT:\n\n  %s\n\nSTDERR:\n\n  %s" %\
+    ---> 95             (full_cmd, tstdout.decode(), tstderr.decode())
+         96         super(ErrorReturnCode, self).__init__(msg)
+         97
+
+    AttributeError: 'str' object has no attribute 'decode'
+
+This would occur when the program called exited with a non-zero return code.
+
+* * *
+
+
+Original documentation
+======================
+
+runps is a unique subprocess wrapper that maps your system programs to
+Python functions dynamically.  runps helps you write shell scripts in
+Python by giving you the good features of Bash (easy command calling, easy
+piping) with all the power and flexibility of Python.
+
+```python
+from runps import ifconfig
+print ifconfig("eth0")
+```
+
+runps is not a collection of system commands implemented in Python.
+
+# Getting
+
+    $> pip install runps
+
+# Usage
+
+The easiest way to get up and running is to import runps
+directly or import your program from runps:
+
+```python
+import runps
+print runps.ifconfig("eth0")
+
+from runps import ifconfig
+print ifconfig("eth0")
+```
+
+A less common usage pattern is through runps Command wrapper, which takes a
+full path to a command and returns a callable object.  This is useful for
+programs that have weird characters in their names or programs that aren't in
+your $PATH:
+
+```python
+import runps
+ffmpeg = runps.Command("/usr/bin/ffmpeg")
+ffmpeg(movie_file)
+```
+
+The last usage pattern is for trying runps through an interactive REPL.  By
+default, this acts like a star import (so all of your system programs will be
+immediately available as functions):
+
+    $> python runps.py
+
+
+# Examples
+
+## Executing Commands
+
+Commands work like you'd expect.  **Just call your program's name like
+a function:**
+
+```python
+# print the contents of this directory
+print ls("-l")
+
+# get the longest line of this file
+longest_line = wc(__file__, "-L")
+
+# get interface information
+print ifconfig("eth0")
+```
+
+Note that these aren't Python functions, these are running the binary
+commands on your system dynamically by resolving your PATH, much like Bash does.
+In this way, all the programs on your system are easily available
+in Python.
+
+You can also call attributes on commands.  This translates to the command
+name followed by the attribute name:
+
+```python
+from runps import git
+
+# resolves to "git branch -v"
+print git.branch("-v")
+```
+
+It turns out this is extremely useful for commands whose first argument is often
+another sub-command (like git, svn, time, sudo, etc).
+See "Baking" for an advanced usage of this.
+
+## Keyword Arguments
+
+Keyword arguments also work like you'd expect: they get replaced with the
+long-form and short-form commandline option:
+
+```python
+# resolves to "curl http://duckduckgo.com/ -o page.html --silent"
+curl("http://duckduckgo.com/", o="page.html", silent=True)
+
+# or if you prefer not to use keyword arguments, this does the same thing:
+curl("http://duckduckgo.com/", "-o", "page.html", "--silent")
+
+# resolves to "adduser amoffat --system --shell=/bin/bash --no-create-home"
+adduser("amoffat", system=True, shell="/bin/bash", no_create_home=True)
+
+# or
+adduser("amoffat", "--system", "--shell", "/bin/bash", "--no-create-home")
+```
+
+## Piping
+
+Piping has become function composition:
+
+```python
+# sort this directory by biggest file
+print sort(du(glob("*"), "-sb"), "-rn")
+
+# print the number of folders and files in /etc
+print wc(ls("/etc", "-1"), "-l")
+```
+
+## Redirection
+
+runps can redirect the standard and error output streams of a process to a file.
+This is done with the special _out and _err keyword arguments. You can pass a
+filename or a file object as the argument value. When the name of an already
+existing file is passed, the contents of the file will be overwritten.
+
+```python
+ls(_out="files.list")
+ls("nonexistent", _err="error.txt")
+```
+
+runps can also redirect the error output stream to the standard output stream,
+using the special _err_to_out=True keyword argument.
+
+
+## Sudo and With Contexts
+
+Commands can be run within a "with" context.  Popular commands using this
+might be "sudo" or "fakeroot":
+
+```python
+with sudo:
+    print ls("/root")
+```
+
+If you need
+to run a command in a with context AND call it, for example, specifying
+a -p prompt with sudo, you need to use the "_with" keyword argument.
+This let's the command know that it's being run from a with context so
+it can behave correctly.
+
+```python
+with sudo(p=">", _with=True):
+    print ls("/root")
+```
+
+## Background Processes
+
+Commands can be run in the background with the special _bg=True keyword
+argument:
+
+```python
+# blocks
+sleep(3)
+print "...3 seconds later"
+
+# doesn't block
+p = sleep(3, _bg=True)
+print "prints immediately!"
+p.wait()
+print "...and 3 seconds later"
+```
+
+You can also pipe together background processes!
+
+```python
+p = wc(curl("http://github.com/", silent=True, _bg=True), "--bytes")
+print "prints immediately!"
+print "byte count of github: %d" % int(p) # lazily completes
+```
+
+This lets you start long-running commands at the beginning of your script
+(like a file download) and continue performing other commands in the
+foreground.
+
+
+## Foreground Processes
+
+Foreground processes are processes that you want to interact directly with
+the default stdout and stdin of your terminal.  In other words, these are
+processes that you do not want to return their output as a return value
+of their call.  An example would be opening a text editor:
+
+```python
+vim(file_to_edit)
+```
+
+This will block because runps will be trying to aggregate the output
+of the command to python, without displaying anything to the screen. The
+solution is the "_fg" special keyword arg:
+
+```python
+vim(file_to_edit, _fg=True)
+```
+
+This will open vim as expected and let you use it as expected, with all
+the input coming from the keyboard and the output going to the screen.
+The return value of a foreground process is an empty string.
+
+
+## Finding Commands
+
+"Which" finds the full path of a program, or returns None if it doesn't exist.
+This command is one of the few commands implemented as a Python function,
+and therefore doesn't rely on the "which" program actually existing.
+
+```python
+print which("python") # "/usr/bin/python"
+print which("ls") # "/bin/ls"
+print which("some_command") # None
+
+if not which("supervisorctl"): apt_get("install", "supervisor", "-y")
+```
+
+## Baking
+
+runps is capable of "baking" arguments into commands.  This is similar
+to the stdlib functools.partial wrapper.  An example can speak volumes:
+
+```python
+from runps import ls
+
+ls = ls.bake("-la")
+print ls # "/usr/bin/ls -la"
+
+# resolves to "ls / -la"
+print ls("/")
+```
+
+The idea is that calling "bake" on a command creates a callable object
+that automatically passes along all of the arguments passed into "bake".
+This gets **really interesting** when you combine this with the attribute
+access on a command:
+
+```python
+from runps import ssh
+
+# calling whoami on the server.  this is tedious to do if you're running
+# any more than a few commands.
+iam1 = ssh("myserver.com", "-p 1393", "whoami")
+
+# wouldn't it be nice to bake the common parameters into the ssh command?
+myserver = ssh.bake("myserver.com", p=1393)
+
+print myserver # "/usr/bin/ssh myserver.com -p 1393"
+
+# resolves to "/usr/bin/ssh myserver.com -p 1393 whoami"
+iam2 = myserver.whoami()
+
+assert(iam1 == iam2) # True!
+```
+
+Now that the "myserver" callable represents a baked ssh command, you
+can call anything on the server easily:
+
+```python
+# resolves to "/usr/bin/ssh myserver.com -p 1393 tail /var/log/dumb_daemon.log -n 100"
+print myserver.tail("/var/log/dumb_daemon.log", n=100)
+```
+
+## Environment Variables
+
+Environment variables are available much like they are in Bash:
+
+```python
+print HOME
+print SHELL
+print PS1
+```
+
+You can set enviroment variables the usual way, through the os.environ
+mapping:
+
+```python
+import os
+os.environ["TEST"] = "123"
+```
+
+Now any new subprocess commands called from the script will be able to
+access that environment variable.
+
+## Exceptions
+
+Exceptions are dynamically generated based on the return code of the command.
+This lets you catch a specific return code, or catch all error return codes
+through the base class ErrorReturnCode:
+
+```python
+try: print ls("/some/non-existant/folder")
+except ErrorReturnCode_2:
+    print "folder doesn't exist!"
+    create_the_folder()
+except ErrorReturnCode:
+    print "unknown error"
+    exit(1)
+```
+
+## Globbing
+
+Glob-expansion is not done on your arguments.  For example, this will not work:
+
+```python
+from runps import du
+print du("*")
+```
+
+You'll get an error to the effect of "cannot access '\*': No such file or directory".
+This is because the "\*" needs to be glob expanded:
+
+```python
+from runps import du, glob
+print du(glob("*"))
+```
+
+
+## Commandline Arguments
+
+You can access commandline arguments similar to Bash's $1, $2, etc by using
+ARG1, ARG2, etc:
+
+```python
+print ARG1, ARG2
+
+# if an argument isn't defined, it's set to None
+if ARG10 is None: do_something()
+```
+
+You can access the entire argparse/optparse-friendly list of commandline
+arguments through "ARGV".  This is recommended for flexibility:
+
+```python
+import argparse
+parser = argparse.ArgumentParser(prog="PROG")
+parser.add_argument("-x", default=3, type=int)
+ns = parser.parse_args(ARGV)
+print ns.x
+```
+
+
+## Weirdly-named Commands
+
+runps automatically handles underscore-dash conversions.  For example, if you want
+to call apt-get:
+
+```python
+apt_get("install", "mplayer", y=True)
+```
+
+runps looks for "apt_get", but if it doesn't find it, replaces all underscores
+with dashes and searches again.  If the command still isn't found, a
+CommandNotFound exception is raised.
+
+Commands with other, less-commonly symbols in their names must be accessed
+directly through the "Command" class wrapper.  The Command class takes the full
+path to the program as a string:
+
+```python
+p27 = Command(which("python2.7"))
+print p27("-h")
+```
+
+The Command wrapper is also useful for commands that are not in your standard PATH:
+
+```python
+script = Command("/tmp/temporary-script.sh")
+print script()
+```
+
+## Non-standard Exit Codes
+
+Normally, if a command returns an exit code that is not 0, runps raises an exception
+based on that exit code.  However, if you have determined that an error code
+is normal and want to retrieve the output of the command without runps raising an
+exception, you can use the "_ok_code" special argument to suppress the exception:
+
+```python
+output = runps.ls("dir_that_exists", "dir_that_doesnt", _ok_code=2)
+```
+
+In the above example, even though you're trying to list a directory that doesn't
+exist, you can still get the output from the directory that does exist by telling
+the command that 2 is an "ok" exit code, so don't raise an exception.
+
+_ok_code can also take a list or tuple of numbers for multiple ok exit codes.

runps-4.0.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+runps.py,sha256=ZXJUcBu-4o3eHiv13vTHy3F37KUucq_YP9z4cERlLb0,17526
+runps-4.0.0.dist-info/licenses/AUTHORS.md,sha256=UEit9bmRGS35YiCe-h24oVGFJpf_4d_i7QtpzT89ERo,281
+runps-4.0.0.dist-info/licenses/LICENSE.txt,sha256=2EkcbiNlaNBPfIwH8vG49dFCcG2rariPbg0t1Ha2xwY,1065
+runps-4.0.0.dist-info/METADATA,sha256=_hdaJ0-WKovcdjLL1rbV3PjTF8PVxHkfiHtQp3VFeFs,15665
+runps-4.0.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+runps-4.0.0.dist-info/top_level.txt,sha256=xxRNhiYCmiH39JBo7m911yXLpHavc0cfB9HKnu9Idd0,6
+runps-4.0.0.dist-info/RECORD,,

runps-4.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

runps-4.0.0.dist-info/licenses/AUTHORS.md

@@ -0,0 +1,22 @@
+# Author
+
+* Andrew Moffat <andrew.robert.moffat@gmail.com>
+
+
+# Contributors
+
+* Dmitry Medvinsky <dmedvinsky@gmail.com>
+* Jure Žiberna
+* Bahadır Kandemir
+* Jannis Leidel <jezdez@enn.io>
+* tingletech
+* tdudziak
+* Arjen Stolk
+* nemec
+* fruch
+* Ralph Bean
+
+
+# `runps` fork
+
+* xapple

runps-4.0.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (C) 2011-2012 by Andrew Moffat
+
+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.

runps-4.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+runps

runps.py

@@ -0,0 +1,492 @@
+# Constants #
+__version__     = "4.0.0"
+__project_url__ = "https://github.com/xapple/runps"
+
+# Modules #
+import sys, os, re, warnings, functools, types, subprocess
+from glob import glob as original_glob
+
+# Python 3 hack #
+IS_PY3 = sys.version_info[0] == 3
+if IS_PY3: unicode = str
+
+###############################################################################
+class CommandNotFound(Exception): pass
+
+class ErrorReturnCode(Exception):
+    truncate_cap = 200
+
+    def __init__(self, full_cmd, stdout, stderr, call_args):
+        # Attributes #
+        self.full_cmd  = full_cmd
+        self.stdout    = stdout
+        self.stderr    = stderr
+        self.call_args = call_args
+        # Check stdout #
+        if self.stdout is None:
+            out = "<redirected to '%s'>" % self.call_args['out']
+            out = out.encode()
+        else:
+            out   = self.stdout[:self.truncate_cap]
+            out_delta = len(self.stdout) - len(out)
+            if out_delta:
+                out += ("... (%d more, please see e.stdout)" % out_delta).encode()
+        # Check stderr #
+        if self.stderr is None:
+            err = "<redirected to '%s'>" % self.call_args['err']
+            err = err.encode()
+        else:
+            err   = self.stderr[:self.truncate_cap]
+            err_delta = len(self.stderr) - len(err)
+            if err_delta:
+                err += ("... (%d more, please see e.stderr)" % err_delta).encode()
+        # Build message #
+        msg = "\n\nRan: %s\n\nSTDOUT:\n\n  %s\n\nSTDERR:\n\n  %s"
+        msg = msg % (full_cmd, out.decode(), err.decode())
+        # Call parent #
+        super(ErrorReturnCode, self).__init__(msg)
+
+rc_exc_regex = re.compile(r"ErrorReturnCode_(\d+)")
+rc_exc_cache = {}
+
+def get_rc_exc(rc):
+    rc = int(rc)
+    try:
+        return rc_exc_cache[rc]
+    except KeyError:
+        pass
+    name = "ErrorReturnCode_%d" % rc
+    exc = type(name, (ErrorReturnCode,), {})
+    rc_exc_cache[rc] = exc
+    return exc
+
+def which(program):
+    def is_exe(file_path):
+        return os.path.exists(file_path) and os.access(file_path, os.X_OK)
+    file_path, file_name = os.path.split(program)
+    if file_path:
+        if is_exe(program): return program
+    else:
+        for path in os.environ["PATH"].split(os.pathsep):
+            exe_file = os.path.join(path, program)
+            if is_exe(exe_file):
+                return exe_file
+    return None
+
+def resolve_program(program):
+    """Our actual command might have a dash in it, but we can't call
+    that from python (we have to use underscores), so we'll check
+    if a dash version of our underscore command exists and use that
+    if it does."""
+    path = which(program)
+    if not path:
+        if "_" in program: path = which(program.replace("_", "-"))
+        if not path: return None
+    return path
+
+def glob(arg):
+    return original_glob(arg) or arg
+
+###############################################################################
+class RunningCommand(object):
+    def __init__(self, command_ran, process, call_args, stdin=None):
+        # Base attributes #
+        self.command_ran = command_ran
+        self.process = process
+        self._stdout = None
+        self._stderr = None
+        self.call_args = call_args
+
+        # We're running in the background, return self and let us lazily
+        # evaluate.
+        if self.call_args["bg"]: return
+
+        # We're running this command as a with context, don't do anything
+        # because nothing was started to run from Command.__call__
+        if self.call_args["with"]: return
+
+        # Run and block #
+        if stdin: stdin = stdin.encode("utf8")
+        self._stdout, self._stderr = self.process.communicate(stdin)
+        self._handle_exit_code(self.process.wait())
+
+    def __enter__(self):
+        # We don't actually do anything here because anything that should
+        # have been done or would have been done in the Command.__call__ call.
+        # essentially all that has to happen is the command be pushed on
+        # the prepend stack.
+        pass
+
+    def __exit__(self, typ, value, traceback):
+        if self.call_args["with"] and Command._prepend_stack:
+            Command._prepend_stack.pop()
+
+    def __repr__(self):
+        return "<RunningCommand %r, pid:%d, special_args:%r" % (
+            self.command_ran, self.process.pid, self.call_args)
+
+    def __str__(self):
+        if IS_PY3: return self.__unicode__()
+        else: return unicode(self).encode("utf8")
+
+    def __unicode__(self):
+        if self.process:
+            if self.call_args["bg"]: self.wait()
+            if self._stdout: return self.stdout
+            else: return ""
+
+    def __eq__(self, other):
+        return unicode(self) == unicode(other)
+
+    def __contains__(self, item):
+        return item in str(self)
+
+    def __getattr__(self, p):
+        # Let these three attributes pass through to the Popen object
+        if p in ("send_signal", "terminate", "kill"):
+            if self.process: return getattr(self.process, p)
+            else: raise AttributeError
+        return getattr(unicode(self), p)
+
+    def __long__(self):
+        return long(str(self).strip())
+
+    def __float__(self):
+        return float(str(self).strip())
+
+    def __int__(self):
+        return int(str(self).strip())
+
+    @property
+    def stdout(self):
+        if self.call_args["bg"]: self.wait()
+        return self._stdout.decode("utf8", "replace")
+
+    @property
+    def stderr(self):
+        if self.call_args["bg"]: self.wait()
+        return self._stderr.decode("utf8", "replace")
+
+    def wait(self):
+        if self.process.returncode is not None: return
+        self._stdout, self._stderr = self.process.communicate()
+        self._handle_exit_code(self.process.wait())
+        return str(self)
+
+    def _handle_exit_code(self, rc):
+        if rc not in self.call_args["ok_code"]:
+            raise get_rc_exc(rc)(self.command_ran, self._stdout, self._stderr, self.call_args)
+
+    def __len__(self):
+        return len(str(self))
+
+###############################################################################
+class Command(object):
+    _prepend_stack = []
+
+    call_args = {
+        "fg":         False,   # run command in foreground
+        "bg":         False,   # run command in background
+        "with":       False,   # prepend the command to every command after it
+        "out":        None,    # redirect STDOUT
+        "err":        None,    # redirect STDERR
+        "err_to_out": None,    # redirect STDERR to STDOUT
+        "in":         None,
+        "env":        os.environ,
+        "cwd":        None,
+        # This is for commands that may have a different exit status than the
+        # normal 0. This can either be an integer or a list/tuple of integers
+        "ok_code": 0,
+    }
+
+    @classmethod
+    def create(cls, program):
+        path = resolve_program(program)
+        if not path: raise CommandNotFound(program)
+        return cls(path)
+
+    def __init__(self, path):
+        # Path to executable #
+        self._path = path
+        # Partial #
+        self._partial            = False
+        self._partial_baked_args = []
+        self._partial_call_args  = {}
+
+    def __getattribute__(self, name):
+        # Convenience #
+        getattribute = functools.partial(object.__getattribute__, self)
+        if name.startswith("_"): return getattribute(name)
+        if name == "bake":       return getattribute("bake")
+        else:                    return getattribute("bake")(name)
+
+    @staticmethod
+    def _extract_call_args(kwargs):
+        kwargs = kwargs.copy()
+        call_args = Command.call_args.copy()
+        for arg, default in call_args.items():
+            key = "_" + arg
+            if key in kwargs:
+                call_args[arg] = kwargs[key]
+                del kwargs[key]
+        return call_args, kwargs
+
+    def _format_arg(self, arg):
+        if IS_PY3: arg = str(arg)
+        else: arg = unicode(arg).encode("utf8")
+        return arg
+
+    def _compile_args(self, args, kwargs):
+        processed_args = []
+
+        # Aggregate positional args
+        for arg in args:
+            if isinstance(arg, (list, tuple)):
+                if not arg:
+                    message  = "Empty list passed as an argument to '%r'."
+                    message += " If you're using glob.glob(), please use runps.glob() instead."
+                    warnings.warn(message % self.path, stacklevel=3)
+                for sub_arg in arg: processed_args.append(self._format_arg(sub_arg))
+            else: processed_args.append(self._format_arg(arg))
+
+        # Aggregate the keyword arguments
+        for k,v in kwargs.items():
+            # We're passing a short arg as a kwarg, example:
+            # cut(d="\t")
+            if len(k) == 1:
+                processed_args.append("-" + k)
+                if v is not True: processed_args.append(self._format_arg(v))
+            # we're doing a long arg
+            else:
+                k = k.replace("_", "-")
+                if v is True: processed_args.append("--" + k)
+                else: processed_args.append("--%s=%s" % (k, self._format_arg(v)))
+        return processed_args
+
+    def bake(self, *args, **kwargs):
+        fn = Command(self._path)
+        fn._partial = True
+        call_args, kwargs = self._extract_call_args(kwargs)
+        pruned_call_args = call_args
+        for k,v in Command.call_args.items():
+            try:
+                if pruned_call_args[k] == v:
+                    del pruned_call_args[k]
+            except KeyError: continue
+        fn._partial_call_args.update(self._partial_call_args)
+        fn._partial_call_args.update(pruned_call_args)
+        fn._partial_baked_args.extend(self._partial_baked_args)
+        fn._partial_baked_args.extend(self._compile_args(args, kwargs))
+        return fn
+
+    def __str__(self):
+        if IS_PY3: return self.__unicode__()
+        else: return unicode(self).encode("utf-8")
+
+    def __repr__(self):
+        return str(self)
+
+    def __unicode__(self):
+        baked_args = " ".join(self._partial_baked_args)
+        if baked_args: baked_args = " " + baked_args
+        return self._path + baked_args
+
+    def __eq__(self, other):
+        try: return str(self) == str(other)
+        except: return False
+
+    def __enter__(self):
+        Command._prepend_stack.append([self._path])
+
+    def __exit__(self, typ, value, traceback):
+        Command._prepend_stack.pop()
+
+    def __call__(self, *args, **kwargs):
+        kwargs = kwargs.copy()
+        args = list(args)
+        cmd = []
+
+        # Aggregate any with contexts
+        for prepend in self._prepend_stack: cmd.extend(prepend)
+
+        cmd.append(self._path)
+
+        call_args, kwargs = self._extract_call_args(kwargs)
+        call_args.update(self._partial_call_args)
+
+        # Here we normalize the ok_code to be something we can do
+        # "if return_code in call_args["ok_code"]" on
+        if not isinstance(call_args["ok_code"], (tuple, list)):
+            call_args["ok_code"] = [call_args["ok_code"]]
+
+        # Set pipe to None if we're outputting straight to CLI
+        pipe = None if call_args["fg"] else subprocess.PIPE
+
+        # Check if we're piping via composition
+        stdin = pipe
+        actual_stdin = None
+        if args:
+            first_arg = args.pop(0)
+            if isinstance(first_arg, RunningCommand):
+                # It makes sense that if the input pipe of a command is running
+                # in the background, then this command should run in the
+                # background as well
+                if first_arg.call_args["bg"]:
+                    call_args["bg"] = True
+                    stdin = first_arg.process.stdout
+                else:
+                    actual_stdin = first_arg.stdout
+            else: args.insert(0, first_arg)
+
+        processed_args = self._compile_args(args, kwargs)
+
+        # Makes sure our arguments are broken up correctly
+        split_args = self._partial_baked_args + processed_args
+        final_args = split_args
+
+        cmd.extend(final_args)
+        command_ran = " ".join(cmd)
+
+        # With contexts shouldn't run at all yet, they prepend
+        # to every command in the context
+        if call_args["with"]:
+            Command._prepend_stack.append(cmd)
+            return RunningCommand(command_ran, None, call_args)
+
+        # Stdin from string
+        input = call_args["in"]
+        if input:
+            actual_stdin = input
+
+        # Stdout redirection
+        stdout = pipe
+        out = call_args["out"]
+        if out:
+            if hasattr(out, "write"): stdout = out
+            else: stdout = open(str(out), "w")
+
+        # Stderr redirection
+        stderr = pipe
+        err = call_args["err"]
+
+        if err:
+            if hasattr(err, "write"): stderr = err
+            else: stderr = open(str(err), "w")
+
+        if call_args["err_to_out"]: stderr = subprocess.STDOUT
+
+        # Leave shell=False
+        process = subprocess.Popen(cmd, shell=False, env=call_args["env"],
+            cwd=call_args["cwd"], stdin=stdin, stdout=stdout, stderr=stderr)
+
+        return RunningCommand(command_ran, process, call_args, actual_stdin)
+
+###############################################################################
+class Environment(dict):
+    """
+    This class is used directly when we do a "from runps import *". It allows
+    lookups to names that aren't found in the global scope to be searched
+    for as a program. For example, if "ls" isn't found in the program's
+    scope, we consider it a system program and try to find it.
+    """
+
+    def __init__(self, *args, **kwargs):
+        dict.__init__(self, *args, **kwargs)
+        self["Command"]         = Command
+        self["CommandNotFound"] = CommandNotFound
+        self["ErrorReturnCode"] = ErrorReturnCode
+        self["ARGV"]            = sys.argv[1:]
+        for i, arg in enumerate(sys.argv):
+            self["ARG%d" % i] = arg
+        # This needs to be last
+        self["env"] = os.environ
+
+    def __setitem__(self, k, v):
+        # Are we altering an environment variable?
+        if "env" in self and k in self["env"]: self["env"][k] = v
+        # No? Just setting a regular name
+        else: dict.__setitem__(self, k, v)
+
+    def __missing__(self, key):
+        # This seems to happen in Python 3
+        if key == "__path__":
+            message  = "You cannot use the form 'from runps import x' in Python 3."
+            message += "Please use x = runps.Command('x') instead."
+            raise ImportError(message)
+
+        # The only way we'd get to here is if we've tried to
+        # import * from a repl. So, raise an exception, since
+        # that's really the only sensible thing to do
+        if key == "__all__":
+            message  = "Cannot import * from runps."
+            message += "Please import runps or import programs individually."
+            raise ImportError(message)
+
+        # If we end with "_" just go ahead and skip searching
+        # our namespace for python stuff. This was mainly for the
+        # command "id", which is a popular program for finding
+        # if a user exists, but also a python function for getting
+        # the address of an object. So can call the python
+        # version by "id" and the program version with "id_"
+        if not key.endswith("_"):
+            # check if we're naming a dynamically generated ReturnCode exception
+            try: return rc_exc_cache[key]
+            except KeyError:
+                m = rc_exc_regex.match(key)
+                if m: return get_rc_exc(int(m.group(1)))
+
+            # are we naming a command-line argument?
+            if key.startswith("ARG"):
+                return None
+
+            # is it a built-in?
+            try: return getattr(self["__builtins__"], key)
+            except AttributeError: pass
+        elif not key.startswith("_"): key = key.rstrip("_")
+
+        # how about an environment variable?
+        try: return os.environ[key]
+        except KeyError: pass
+
+        # is it a custom built-in?
+        builtin = getattr(self, "b_" + key, None)
+        if builtin: return builtin
+
+        # it must be a command then
+        return Command.create(key)
+
+    def b_cd(self, path):
+        os.chdir(path)
+
+    def b_which(self, program):
+        return which(program)
+
+###############################################################################
+class SelfWrapper(types.ModuleType):
+    """
+    This is a thin wrapper around THIS module (we patch sys.modules[__name__]).
+    this is in the case that the user does a "from runps import whatever"
+    in other words, they only want to import certain programs, not the whole
+    system PATH worth of commands. In this case, we just proxy the
+    import lookup to our Environment class.
+    """
+
+    def __init__(self, self_module):
+        """
+        This is super ugly to have to copy attributes like this,
+        but it seems to be the only way to make reload() behave
+        nicely. If one makes these attributes dynamic lookups in
+        __getattr__, reload sometimes chokes in weird ways.
+        """
+        for attr in ["__builtins__", "__doc__", "__name__", "__package__"]:
+            setattr(self, attr, getattr(self_module, attr))
+
+        self.self_module = self_module
+        self.env = Environment(globals())
+
+    def __getattr__(self, name):
+        return self.env[name]
+
+###############################################################################
+self = sys.modules[__name__]
+sys.modules[__name__] = SelfWrapper(self)