Merge branch 'master' into python3

Conflicts:
	pdm/perf.py

diff --cc pdm/cli.py
Simple merge

diff --cc pdm/perf.py
index 7d8b48b,786ab98..feb8b4a
--- 1/pdm/perf.py
--- 2/pdm/perf.py
+++ b/pdm/perf.py
@@@ -12,8 -60,12 +60,12 @@@ class perfobj(object)
          return []
  
  class simpleattr(perfobj):
+     """An implementation of the `attr' interface, which is initialized
+     with a function, and returns whatever that function returns when
+     read.
+     """
      def __init__(self, func, info = None, *args, **kwargs):
 -        super(simpleattr, self).__init__(*args, **kwargs)
 +        super().__init__(*args, **kwargs)
          self.func = func
          if info is None:
              info = attrinfo()
@@@ -26,11 -78,15 +78,15 @@@
          return self.info
  
      def pdm_protocols(self):
 -        return super(simpleattr, self).pdm_protocols() + ["attr"]
 +        return super().pdm_protocols() + ["attr"]
  
  class valueattr(perfobj):
+     """An implementation of the `attr' interface, which is initialized
+     with a single value, and returns that value when read. Subsequent
+     updates to the value are reflected in subsequent reads.
+     """
      def __init__(self, init, info = None, *args, **kwargs):
 -        super(valueattr, self).__init__(*args, **kwargs)
 +        super().__init__(*args, **kwargs)
          self.value = init
          if info is None:
              info = attrinfo()
@@@ -43,12 -99,15 +99,15 @@@
          return self.info
  
      def pdm_protocols(self):
 -        return super(valueattr, self).pdm_protocols() + ["attr"]
 +        return super().pdm_protocols() + ["attr"]
  
- 
  class eventobj(perfobj):
+     """An implementation of the `event' interface. It keeps track of
+     subscribers, and will multiplex any event to all current
+     subscribers when submitted with the `notify' method.
+     """
      def __init__(self, *args, **kwargs):
 -        super(eventobj, self).__init__(*args, **kwargs)
 +        super().__init__(*args, **kwargs)
          self.subscribers = set()
  
      def subscribe(self, cb):
@@@ -66,11 -126,15 +126,15 @@@
              except: pass
  
      def pdm_protocols(self):
 -        return super(eventobj, self).pdm_protocols() + ["event"]
 +        return super().pdm_protocols() + ["event"]
  
  class staticdir(perfobj):
+     """An implementation of the `dir' interface. Put other PERF
+     objects in it using the normal dict assignment syntax, and it will
+     return them to requesting clients.
+     """
      def __init__(self, *args, **kwargs):
 -        super(staticdir, self).__init__(*args, **kwargs)
 +        super().__init__(*args, **kwargs)
          self.map = {}
  
      def __setitem__(self, name, ob):
@@@ -92,9 -156,17 +156,17 @@@
          return self.map[name]
  
      def pdm_protocols(self):
 -        return super(staticdir, self).pdm_protocols() + ["dir"]
 +        return super().pdm_protocols() + ["dir"]
  
  class event(object):
+     """This class should be subclassed by all event objects sent via
+     the `event' interface. Its main utility is that it keeps track of
+     the time it was created, so that listening clients can precisely
+     measure the time between event notifications.
+ 
+     Subclasses should make sure to call the __init__ method if they
+     override it.
+     """
      def __init__(self):
          self.time = time.time()
  
@@@ -112,20 -184,41 +184,41 @@@ def getprocid()
          idlock.release()
  
  class procevent(event):
+     """A subclass of the `event' class meant to group several events
+     related to the same process. Create a new process by creating (a
+     subclass of) the `startevent' class, and subsequent events in the
+     same process by passing that startevent as the `id' parameter.
+ 
+     It works by having `startevent' allocate a unique ID for each
+     process, and every other procevent initializing from that
+     startevent copying the ID. The data field `id' contains the ID so
+     that it can be compared by clients.
+ 
+     An example of such a process might be a client connection, where a
+     `startevent' is emitted when a client connects, another subclass
+     of `procevent' emitted when the client runs a command, and a
+     `finishevent' emitted when the connection is closed.
+     """
      def __init__(self, id):
 -        super(procevent, self).__init__()
 +        super().__init__()
          if isinstance(id, procevent):
              self.id = id.id
          else:
              self.id = id
  
  class startevent(procevent):
+     """A subclass of `procevent'. See its documentation for details."""
      def __init__(self):
 -        super(startevent, self).__init__(getprocid())
 +        super().__init__(getprocid())
  
  class finishevent(procevent):
-     def __init__(self, start, aborted):
+     """A subclass of `procevent'. Intended to be emitted when a
+     process finishes and terminates. The `aborted' field can be used
+     to indicate whether the process completed successfully, if such a
+     distinction is meaningful. The `start' parameter should be the
+     `startevent' instance used when the process was initiated."""
+     def __init__(self, start, aborted = False):
 -        super(finishevent, self).__init__(start)
 +        super().__init__(start)
          self.aborted = aborted
  
  sysres = staticdir()