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

third_party/psutil/psutil/__init__.py

 #!/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
 import os
 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):
     """Represents an OS process."""
 
     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
 
     def __str__(self):
         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."""
         return self._pid
 
     @property
     def ppid(self):
         """The process parent pid."""
         return self._platform_impl.get_process_ppid()
 
     @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):
         """The process name."""
         name = self._platform_impl.get_process_name()
         if os.name == 'posix':
             # On UNIX the name gets truncated to the first 15 characters.
             # If it matches the first part of the cmdline we return that
             # one instead because it's usually more explicative.
             # Examples are "gnome-keyring-d" vs. "gnome-keyring-daemon".
@@ skipping 10 matching lines @@
     def exe(self):
         """The process executable as an absolute path name."""
         exe = self._platform_impl.get_process_exe()
         # if we have the cmdline but not the exe, figure it out from argv[0]
         if not exe:
             cmdline = self.cmdline
             if cmdline and hasattr(os, 'access') and hasattr(os, 'X_OK'):
                 _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()
 
     @property
     def create_time(self):
         """The process creation time as a floating point number
         expressed in seconds since the epoch, in UTC.
         """
         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.
         """
         if not self.is_running():
             name = self._platform_impl._process_name
             raise NoSuchProcess(self.pid, name)
         retlist = []
         for proc in process_iter():
             try:
@@ skipping 46 matching lines @@
             return 0.0
         # the utilization of a single CPU
         single_cpu_percent = overall_percent * NUM_CPUS
         # ugly hack to avoid troubles with float precision issues
         if single_cpu_percent > 100.0:
             return 100.0
         return round(single_cpu_percent, 1)
 
     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()
 
     def get_memory_info(self):
         """Return a tuple representing RSS (Resident Set Size) and VMS
         (Virtual Memory Size) in bytes.
 
         On UNIX RSS and VMS are the same values shown by ps.
 
         On Windows RSS and VMS refer to "Mem Usage" and "VM Size" columns
         of taskmgr.exe.
         """
         return self._platform_impl.get_memory_info()
 
     def get_memory_percent(self):
         """Compare physical system memory to process resident memory and
         calculate process memory utilization as a percentage.
         """
         rss = self._platform_impl.get_memory_info()[0]
         try:
             return (rss / float(TOTAL_PHYMEM)) * 100
         except ZeroDivisionError:
             return 0.0
 
     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).
         On Windows only SIGTERM is valid and is treated as an alias
         for kill().
         """
         # safety measure in case the current process has been killed in
         # meantime and the kernel reused its PID
         if not self.is_running():
             name = self._platform_impl._process_name
@@ skipping 53 matching lines @@
         # safety measure in case the current process has been killed in
         # meantime and the kernel reused its PID
         if not self.is_running():
             name = self._platform_impl._process_name
             raise NoSuchProcess(self.pid, name)
         if os.name == 'posix':
             self.send_signal(signal.SIGKILL)
         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)
         except (NoSuchProcess, AccessDenied):
             continue
 
 def get_process_list():
     """Return a list of Process class instances for all running
     processes on the local machine.
     """
     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.
 
     When interval is > 0.0 compares system CPU times elapsed before
     and after the interval (blocking).
 
     When interval is 0.0 or None compares system CPU times elapsed
     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
 
-    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
 
-    t1_all = sum(t1)
-    t1_busy = t1_all - t1.idle
+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()
 
-    t2 = cpu_times()
-    t2_all = sum(t2)
-    t2_busy = t2_all - t2.idle
+def virtmem_usage():
+    """Return the amount of total, used and free virtual memory
+    on the system in bytes plus the percentage usage.
 
-    _last_cpu_times = t1
-    # this usually indicates a float precision issue
-    if t2_busy <= t1_busy:
-        return 0.0
+    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()
 
-    busy_delta = t2_busy - t1_busy
-    all_delta = t2_all - t1_all
-    busy_perc = (busy_delta / all_delta) * 100
-    return round(busy_perc, 1)
+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)
 
+def disk_partitions(all=False):
+    """Return mounted partitions as a list of namedtuples including
+    device, mount point and filesystem type.
+
+    If "all" parameter is False return physical devices only and ignore
+    all others.
+    """
+    return _psplatform.disk_partitions(all)
+
+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
     ps -aux output.
     """
     import datetime
     today_day = datetime.date.today()
 
     def get_process_info(pid):
         proc = Process(pid)
@@ skipping 29 matching lines @@
         try:
             line = get_process_info(pid)
         except (AccessDenied, NoSuchProcess):
             pass
         else:
             print line
 
 if __name__ == "__main__":
     test()