Update third_party/psutil and fix the licence issue with it.

third_party/psutil/psutil/__init__.py

Index: third_party/psutil/psutil/__init__.py
diff --git a/third_party/psutil/psutil/__init__.py b/third_party/psutil/psutil/__init__.py
index 09b7955f2434f32c32392723231e42ec95d188b4..93724fca1a97788acf6dcba48a57d255d329f8cd 100644
--- a/third_party/psutil/psutil/__init__.py
+++ b/third_party/psutil/psutil/__init__.py
@@ -1,26 +1,35 @@
 #!/usr/bin/env python
 #
-# $Id: __init__.py 806 2010-11-12 23:09:35Z g.rodola $
+# $Id: __init__.py 1142 2011-10-05 18:45:49Z g.rodola $
 #
+# Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
 
 """psutil is a module providing convenience functions for managing
-processes in a portable way by using Python.
+processes and gather system information in a portable way by using
+Python.
 """
 
-__version__ = "0.2.0"
+__version__ = "0.3.1"
 version_info = tuple([int(num) for num in __version__.split('.')])
 
 __all__ = [
     # exceptions
-    "Error", "NoSuchProcess", "AccessDenied",
+    "Error", "NoSuchProcess", "AccessDenied", "TimeoutExpired",
     # constants
-    "NUM_CPUS", "TOTAL_PHYMEM", "version_info", "__version__",
+    "NUM_CPUS", "TOTAL_PHYMEM", "BOOT_TIME",
+    "version_info", "__version__",
+    "STATUS_RUNNING", "STATUS_IDLE", "STATUS_SLEEPING", "STATUS_DISK_SLEEP",
+    "STATUS_STOPPED", "STATUS_TRACING_STOP", "STATUS_ZOMBIE", "STATUS_DEAD",
+    "STATUS_WAKING", "STATUS_LOCKED",
     # classes
-    "Process",
+    "Process", "Popen",
     # functions
     "test", "pid_exists", "get_pid_list", "process_iter", "get_process_list",
-    "avail_phymem", "used_phymem", "total_virtmem", "avail_virtmem",
-    "used_virtmem", "cpu_times", "cpu_percent",
+    "phymem_usage", "virtmem_usage"
+    "cpu_times", "per_cpu_times", "cpu_percent", "per_cpu_percent",
+    "network_io_counters", "disk_io_counters",
     ]
 
 import sys
@@ -29,67 +38,58 @@ import time
 import signal
 import warnings
 import errno
+import subprocess
 try:
     import pwd
 except ImportError:
     pwd = None
 
-from psutil.error import Error, NoSuchProcess, AccessDenied
+from psutil.error import Error, NoSuchProcess, AccessDenied, TimeoutExpired
+from psutil._compat import property
+from psutil._common import (STATUS_RUNNING, STATUS_IDLE, STATUS_SLEEPING,
+                            STATUS_DISK_SLEEP, STATUS_STOPPED,
+                            STATUS_TRACING_STOP, STATUS_ZOMBIE, STATUS_DEAD,
+                            STATUS_WAKING, STATUS_LOCKED
+                            )
 
 # import the appropriate module for our platform only
 if sys.platform.lower().startswith("linux"):
-    from psutil._pslinux import *
-    __all__.extend(["cached_phymem", "phymem_buffers"])
+    import psutil._pslinux as _psplatform
+    from psutil._pslinux import (phymem_buffers,
+                                 cached_phymem,
+                                 IOPRIO_CLASS_NONE,
+                                 IOPRIO_CLASS_RT,
+                                 IOPRIO_CLASS_BE,
+                                 IOPRIO_CLASS_IDLE)
+    phymem_buffers = _psplatform.phymem_buffers
+    cached_phymem = _psplatform.cached_phymem
 
 elif sys.platform.lower().startswith("win32"):
-    from psutil._psmswindows import *
+    import psutil._psmswindows as _psplatform
+    from psutil._psmswindows import (ABOVE_NORMAL_PRIORITY_CLASS,
+                                     BELOW_NORMAL_PRIORITY_CLASS,
+                                     HIGH_PRIORITY_CLASS,
+                                     IDLE_PRIORITY_CLASS,
+                                     NORMAL_PRIORITY_CLASS,
+                                     REALTIME_PRIORITY_CLASS)
 
 elif sys.platform.lower().startswith("darwin"):
-    from psutil._psosx import *
+    import psutil._psosx as _psplatform
 
 elif sys.platform.lower().startswith("freebsd"):
-    from psutil._psbsd import *
+    import psutil._psbsd as _psplatform
 
 else:
     raise NotImplementedError('platform %s is not supported' % sys.platform)
 
+__all__.extend(_psplatform.__extra__all__)
 
-class CPUTimes:
-    """This class contains information about CPU times.
-    It is not used directly but it's returned as an instance by
-    psutil.cpu_times() function.
+NUM_CPUS = _psplatform.NUM_CPUS
+BOOT_TIME = _psplatform.BOOT_TIME
+TOTAL_PHYMEM = _psplatform.phymem_usage()[0]
 
-    Every CPU time is accessible in form of an attribute and represents
-    the time CPU has spent in the given mode.
-
-    The attributes availability varies depending on the platform.
-    Here follows a list of all available attributes:
-
-     - user
-     - system
-     - idle
-     - nice (UNIX)
-     - iowait (Linux)
-     - irq (Linux, FreeBSD)
-     - softirq (Linux)
-    """
-
-    def __init__(self, **kwargs):
-        self.__attrs = []
-        for name in kwargs:
-            setattr(self, name, kwargs[name])
-            self.__attrs.append(name)
-
-    def __str__(self):
-        string = []
-        for attr in self.__attrs:
-            value = getattr(self, attr)
-            string.append("%s=%s" %(attr, value))
-        return '; '.join(string)
-
-    def __iter__(self):
-        for attr in self.__attrs:
-            yield getattr(self, attr)
+get_pid_list = _psplatform.get_pid_list
+pid_exists = _psplatform.pid_exists
 
 
 class Process(object):
@@ -98,15 +98,16 @@ class Process(object):
     def __init__(self, pid):
         """Create a new Process object, raises NoSuchProcess if the PID
         does not exist, and ValueError if the parameter is not an
-        integer PID."""
+        integer PID.
+        """
         if not isinstance(pid, int):
-            raise ValueError("An integer is required")
+            raise ValueError("an integer is required")
         if not pid_exists(pid):
-            raise NoSuchProcess(pid, None, "no process found with PID %s" % pid)
+            raise NoSuchProcess(pid, None, "no process found with pid %s" % pid)
         self._pid = pid
-        # platform-specific modules define an PlatformProcess
+        # platform-specific modules define an _psplatform.Process
         # implementation class
-        self._platform_impl = PlatformProcess(pid)
+        self._platform_impl = _psplatform.Process(pid)
         self._last_sys_cpu_times = None
         self._last_proc_cpu_times = None
 
@@ -114,30 +115,18 @@ class Process(object):
         try:
             pid = self.pid
             name = repr(self.name)
-            cmdline = self.cmdline and repr(' '.join(self.cmdline))
         except NoSuchProcess:
             details = "(pid=%s (terminated))" % self.pid
         except AccessDenied:
             details = "(pid=%s)" % (self.pid)
         else:
-            if cmdline:
-                details = "(pid=%s, name=%s, cmdline=%s)" % (pid, name, cmdline)
-            else:
-                details = "(pid=%s, name=%s)" % (pid, name)
-        return "%s.%s %s" % (self.__class__.__module__,
-                             self.__class__.__name__, details)
+            details = "(pid=%s, name=%s)" % (pid, name)
+        return "%s.%s%s" % (self.__class__.__module__,
+                            self.__class__.__name__, details)
 
     def __repr__(self):
         return "<%s at %s>" % (self.__str__(), id(self))
 
-    def __eq__(self, other):
-        """Test for equality with another Process object based on pid
-        and creation time.
-        """
-        h1 = (self.pid, self.create_time)
-        h2 = (other.pid, other.create_time)
-        return h1 == h2
-
     @property
     def pid(self):
         """The process pid."""
@@ -150,11 +139,15 @@ class Process(object):
 
     @property
     def parent(self):
-        """Return the parent process as a Process object. If no ppid is
-        known then return None."""
-        if self.ppid is not None:
-            return Process(self.ppid)
-        return None
+        """Return the parent process as a Process object. If no parent
+        pid is known return None.
+        """
+        ppid = self.ppid
+        if ppid is not None:
+            try:
+                return Process(ppid)
+            except NoSuchProcess:
+                pass
 
     @property
     def name(self):
@@ -185,37 +178,63 @@ class Process(object):
                 _exe = os.path.realpath(cmdline[0])
                 if os.path.isfile(_exe) and os.access(_exe, os.X_OK):
                     return _exe
+        if not exe:
+            raise AccessDenied(self.pid, self._platform_impl._process_name)
         return exe
 
     @property
-    def path(self):
-        msg = "'path' property is deprecated; use 'os.path.dirname(exe)' instead"
-        warnings.warn(msg, DeprecationWarning)
-        return os.path.dirname(self.exe)
-
-    @property
     def cmdline(self):
         """The command line process has been called with."""
         return self._platform_impl.get_process_cmdline()
 
     @property
-    def uid(self):
-        """The real user id of the current process."""
-        return self._platform_impl.get_process_uid()
+    def status(self):
+        """The process current status as a STATUS_* constant."""
+        return self._platform_impl.get_process_status()
 
     @property
-    def gid(self):
-        """The real group id of the current process."""
-        return self._platform_impl.get_process_gid()
+    def nice(self):
+        """Get or set process niceness (priority)."""
+        return self._platform_impl.get_process_nice()
+
+    @nice.setter
+    def nice(self, value):
+        # invoked on "p.nice = num"; change process niceness
+        return self._platform_impl.set_process_nice(value)
+
+    if os.name == 'posix':
+
+        @property
+        def uids(self):
+            """Return a named tuple denoting the process real,
+            effective, and saved user ids.
+            """
+            return self._platform_impl.get_process_uids()
+
+        @property
+        def gids(self):
+            """Return a named tuple denoting the process real,
+            effective, and saved group ids.
+            """
+            return self._platform_impl.get_process_gids()
+
+        @property
+        def terminal(self):
+            """The terminal associated with this process, if any,
+            else None.
+            """
+            return self._platform_impl.get_process_terminal()
 
     @property
     def username(self):
-        """The name of the user that owns the process."""
+        """The name of the user that owns the process.
+        On UNIX this is calculated by using *real* process uid.
+        """
         if os.name == 'posix':
             if pwd is None:
-                # might happen on compiled-from-sources python
+                # might happen if python was installed from sources
                 raise ImportError("requires pwd module shipped with standard python")
-            return pwd.getpwuid(self.uid).pw_name
+            return pwd.getpwuid(self.uids.real).pw_name
         else:
             return self._platform_impl.get_process_username()
 
@@ -227,17 +246,49 @@ class Process(object):
         return self._platform_impl.get_process_create_time()
 
     # available for Windows and Linux only
-    if hasattr(PlatformProcess, "get_process_cwd"):
+    if hasattr(_psplatform.Process, "get_process_cwd"):
+
         def getcwd(self):
             """Return a string representing the process current working
             directory.
             """
             return self._platform_impl.get_process_cwd()
 
+    # Linux, BSD and Windows only
+    if hasattr(_psplatform.Process, "get_process_io_counters"):
+
+        def get_io_counters(self):
+            """Return process I/O statistics as a namedtuple including
+            the number of read/write calls performed and the amount of
+            bytes read and written by the process.
+            """
+            return self._platform_impl.get_process_io_counters()
+
+    # available only on Linux
+    if hasattr(_psplatform.Process, "get_process_ionice"):
+
+        def get_ionice(self):
+            """Return process I/O niceness (priority) as a namedtuple."""
+            return self._platform_impl.get_process_ionice()
+
+        def set_ionice(self, ioclass, value=None):
+            """Set process I/O niceness (priority).
+            ioclass is one of the IOPRIO_CLASS_* constants.
+            iodata is a number which goes from 0 to 7. The higher the
+            value, the lower the I/O priority of the process.
+            """
+            return self._platform_impl.set_process_ionice(ioclass, value)
+
     def get_num_threads(self):
         """Return the number of threads used by this process."""
         return self._platform_impl.get_process_num_threads()
 
+    def get_threads(self):
+        """Return threads opened by process as a list of namedtuples
+        including thread id and thread CPU times (user/system).
+        """
+        return self._platform_impl.get_process_threads()
+
     def get_children(self):
         """Return the children of this process as a list of Process
         objects.
@@ -304,8 +355,7 @@ class Process(object):
 
     def get_cpu_times(self):
         """Return a tuple whose values are process CPU user and system
-        time.  These are the same first two values that os.times()
-        returns for the current process.
+        times. The same as os.times() but per-process.
         """
         return self._platform_impl.get_cpu_times()
 
@@ -332,27 +382,34 @@ class Process(object):
 
     def get_open_files(self):
         """Return files opened by process as a list of namedtuples
-        including absolute file name and file descriptor.
+        including absolute file name and file descriptor number.
         """
         return self._platform_impl.get_open_files()
 
     def get_connections(self):
         """Return TCP and UPD connections opened by process as a list
-        of namedtuple/s.
-        For third party processes (!= os.getpid()) results can differ
-        depending on user privileges.
+        of namedtuples.
+        On BSD and OSX results for third party processes (!= os.getpid())
+        can differ depending on user privileges.
         """
         return self._platform_impl.get_connections()
 
     def is_running(self):
-        """Return whether the current process is running in the current
-        process list.
-        """
+        """Return whether this process is running."""
         try:
-            newproc = Process(self.pid)
-            return self == newproc
+            # Test for equality with another Process object based
+            # on pid and creation time.
+            # This pair is supposed to indentify a Process instance
+            # univocally over the time (the PID alone is not enough as
+            # it might refer to a process which is gone in meantime
+            # and its PID reused by another process).
+            new_self = Process(self.pid)
+            p1 = (self.pid, self.create_time)
+            p2 = (new_self.pid, new_self.create_time)
         except NoSuchProcess:
             return False
+        else:
+            return p1 == p2
 
     def send_signal(self, sig):
         """Send a signal to process (see signal module constants).
@@ -426,14 +483,66 @@ class Process(object):
         else:
             self._platform_impl.kill_process()
 
+    def wait(self, timeout=None):
+        """Wait for process to terminate and, if process is a children
+        of the current one also return its exit code, else None.
+        """
+        if timeout is not None and not timeout >= 0:
+            raise ValueError("timeout must be a positive integer")
+        return self._platform_impl.process_wait(timeout)
+
+
+class Popen(Process):
+    """A more convenient interface to stdlib subprocess module.
+    It starts a sub process and deals with it exactly as when using
+    subprocess.Popen class but in addition also provides all the
+    property and methods of psutil.Process class in a unique interface:
+
+      >>> import psutil
+      >>> from subprocess import PIPE
+      >>> p = psutil.Popen(["/usr/bin/python", "-c", "print 'hi'"], stdout=PIPE)
+      >>> p.name
+      'python'
+      >>> p.uids
+      user(real=1000, effective=1000, saved=1000)
+      >>> p.username
+      'giampaolo'
+      >>> p.communicate()
+      ('hi\n', None)
+      >>> p.terminate()
+      >>> p.wait(timeout=2)
+      0
+      >>>
+
+    For method names common to both classes such as kill(), terminate()
+    and wait(), psutil.Process implementation takes precedence.
+
+    For a complete documentation refers to:
+    http://docs.python.org/library/subprocess.html
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.__subproc = subprocess.Popen(*args, **kwargs)
+        Process.__init__(self, self.__subproc.pid)
+
+    def __dir__(self):
+        return list(set(dir(Popen) + dir(subprocess.Popen)))
+
+    def __getattribute__(self, name):
+        try:
+            return object.__getattribute__(self, name)
+        except AttributeError:
+            try:
+                return object.__getattribute__(self.__subproc, name)
+            except AttributeError:
+                raise AttributeError("%s instance has no attribute '%s'"
+                                      %(self.__class__.__name__, name))
 
 def process_iter():
     """Return an iterator yielding a Process class instances for all
     running processes on the local machine.
     """
     pids = get_pid_list()
-    # for each PID, create a proxyied Process object
-    # it will lazy init it's name and path later if required
     for pid in pids:
         try:
             yield Process(pid)
@@ -446,15 +555,34 @@ def get_process_list():
     """
     return list(process_iter())
 
-def cpu_times():
-    """Return system CPU times as a CPUTimes object."""
-    values = get_system_cpu_times()
-    return CPUTimes(**values)
+def cpu_times(percpu=False):
+    """Return system-wide CPU times as a namedtuple object.
+    Every CPU time represents the time CPU has spent in the given mode.
+    The attributes availability varies depending on the platform.
+    Here follows a list of all available attributes:
+     - user
+     - system
+     - idle
+     - nice (UNIX)
+     - iowait (Linux)
+     - irq (Linux, FreeBSD)
+     - softirq (Linux)
+
+    When percpu is True return a list of nameduples for each CPU.
+    First element of the list refers to first CPU, second element
+    to second CPU and so on.
+    The order of the list is consistent across calls.
+    """
+    if not percpu:
+        return _psplatform.get_system_cpu_times()
+    else:
+        return _psplatform.get_system_per_cpu_times()
 
 
 _last_cpu_times = cpu_times()
+_last_per_cpu_times = cpu_times(percpu=True)
 
-def cpu_percent(interval=0.1):
+def cpu_percent(interval=0.1, percpu=False):
     """Return a float representing the current system-wide CPU
     utilization as a percentage.
 
@@ -465,33 +593,184 @@ def cpu_percent(interval=0.1):
     since last call or module import, returning immediately.
     In this case is recommended for accuracy that this function be
     called with at least 0.1 seconds between calls.
+
+    When percpu is True returns a list of floats representing the
+    utilization as a percentage for each CPU.
+    First element of the list refers to first CPU, second element
+    to second CPU and so on.
+    The order of the list is consistent across calls.
     """
     global _last_cpu_times
-
+    global _last_per_cpu_times
     blocking = interval is not None and interval > 0.0
-    if blocking:
-        t1 = cpu_times()
-        time.sleep(interval)
+
+    def calculate(t1, t2):
+        t1_all = sum(t1)
+        t1_busy = t1_all - t1.idle
+
+        t2_all = sum(t2)
+        t2_busy = t2_all - t2.idle
+
+        # this usually indicates a float precision issue
+        if t2_busy <= t1_busy:
+            return 0.0
+
+        busy_delta = t2_busy - t1_busy
+        all_delta = t2_all - t1_all
+        busy_perc = (busy_delta / all_delta) * 100
+        return round(busy_perc, 1)
+
+    # system-wide usage
+    if not percpu:
+        if blocking:
+            t1 = cpu_times()
+            time.sleep(interval)
+        else:
+            t1 = _last_cpu_times
+        _last_cpu_times = cpu_times()
+        return calculate(t1, _last_cpu_times)
+    # per-cpu usage
     else:
-        t1 = _last_cpu_times
+        ret = []
+        if blocking:
+            tot1 = cpu_times(percpu=True)
+            time.sleep(interval)
+        else:
+            tot1 = _last_per_cpu_times
+        _last_per_cpu_times = cpu_times(percpu=True)
+        for t1, t2 in zip(tot1, _last_per_cpu_times):
+            ret.append(calculate(t1, t2))
+        return ret
+
+def phymem_usage():
+    """Return the amount of total, used and free physical memory
+    on the system in bytes plus the percentage usage.
+    """
+    return _psplatform.phymem_usage()
+
+def virtmem_usage():
+    """Return the amount of total, used and free virtual memory
+    on the system in bytes plus the percentage usage.
+
+    On Linux they match the values returned by free command line utility.
+    On OS X and FreeBSD they represent the same values as returned by
+    sysctl vm.vmtotal. On Windows they are determined by reading the
+    PageFile values of MEMORYSTATUSEX structure.
+    """
+    return _psplatform.virtmem_usage()
 
-    t1_all = sum(t1)
-    t1_busy = t1_all - t1.idle
+def disk_usage(path):
+    """Return disk usage statistics about the given path as a namedtuple
+    including total, used and free space expressed in bytes plus the
+    percentage usage.
+    """
+    return _psplatform.get_disk_usage(path)
 
-    t2 = cpu_times()
-    t2_all = sum(t2)
-    t2_busy = t2_all - t2.idle
+def disk_partitions(all=False):
+    """Return mounted partitions as a list of namedtuples including
+    device, mount point and filesystem type.
 
-    _last_cpu_times = t1
-    # this usually indicates a float precision issue
-    if t2_busy <= t1_busy:
-        return 0.0
+    If "all" parameter is False return physical devices only and ignore
+    all others.
+    """
+    return _psplatform.disk_partitions(all)
 
-    busy_delta = t2_busy - t1_busy
-    all_delta = t2_all - t1_all
-    busy_perc = (busy_delta / all_delta) * 100
-    return round(busy_perc, 1)
+if hasattr(_psplatform, "network_io_counters"):
 
+    def network_io_counters(pernic=False):
+        """Return network I/O statistics as a namedtuple including:
+         - number of bytes sent
+         - number of bytes received
+         - number of packets sent
+         - number of packets received
+
+        If pernic is True return the same information for every
+        network interface installed on the system as a dictionary
+        with network interface names as the keys and the namedtuple
+        described above as the values.
+        """
+        from psutil._common import ntuple_net_iostat
+        rawdict = _psplatform.network_io_counters()
+        if pernic:
+            for nic, fields in rawdict.iteritems():
+                rawdict[nic] = ntuple_net_iostat(*fields)
+            return rawdict
+        else:
+            bytes_sent, bytes_recv, packets_sent, packets_recv = 0, 0, 0, 0
+            for _, fields in rawdict.iteritems():
+                bytes_sent += fields[0]
+                bytes_recv += fields[1]
+                packets_sent += fields[2]
+                packets_recv += fields[3]
+            return ntuple_net_iostat(bytes_sent, bytes_recv,
+                                     packets_sent, packets_recv)
+
+if hasattr(_psplatform, "disk_io_counters"):
+
+    def disk_io_counters(perdisk=False):
+        """Return system disk I/O statistics as a namedtuple including:
+         - number of bytes read
+         - number of bytes written
+         - number of reads
+         - number of writes
+         - time spent reading from disk (in nanoseconds)
+         - time spent writing to disk (in nanoseconds)
+
+        If perdisk is True return the same information for every
+        physical disk installed on the system as a dictionary
+        with partition names as the keys and the namedutuple
+        described above as the values.
+        """
+        from psutil._common import ntuple_disk_iostat
+        rawdict = _psplatform.disk_io_counters()
+        if perdisk:
+            for disk, fields in rawdict.iteritems():
+                rawdict[disk] = ntuple_disk_iostat(*fields)
+            return rawdict
+        else:
+            reads, writes, rbytes, wbytes, rtime, wtime = 0, 0, 0, 0, 0, 0
+            for _, fields in rawdict.iteritems():
+                reads += fields[0]
+                writes += fields[1]
+                rbytes += fields[2]
+                wbytes += fields[3]
+                rtime += fields[4]
+                wtime += fields[5]
+            return ntuple_disk_iostat(reads, writes, rbytes, wbytes, rtime, wtime)
+
+
+def _deprecated(replacement):
+    # a decorator which can be used to mark functions as deprecated
+    def outer(fun):
+        def inner(*args, **kwargs):
+            msg = "psutil.%s is deprecated; use %s instead" \
+                  % (fun.__name__, replacement)
+            warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
+            return fun(*args, **kwargs)
+        return inner
+    return outer
+
+# --- deprecated functions
+
+@_deprecated("psutil.phymem_usage")
+def avail_phymem():
+    return phymem_usage().free
+
+@_deprecated("psutil.phymem_usage")
+def used_phymem():
+    return phymem_usage().used
+
+@_deprecated("psutil.virtmem_usage")
+def total_virtmem():
+    return virtmem_usage().total
+
+@_deprecated("psutil.virtmem_usage")
+def used_virtmem():
+    return virtmem_usage().used
+
+@_deprecated("psutil.virtmem_usage")
+def avail_virtmem():
+    return virtmem_usage().free
 
 def test():
     """List info of all currently running processes emulating a