Enhance formatting of README

Author: spaceone

README.md

@@ -53,23 +53,23 @@ API
 
 An application using pyNotifier has to initialise the notifier,
 i.e. it has to choose which notifier implementation should be
-used. This is done by calling the 'init' function:
+used. This is done by calling the `init` function:
 
-	def init( type = GENERIC ):
+	def init(type=GENERIC):
 
-If no argument is given to the 'init' function the internal
+If no argument is given to the `init` function the internal
 implementation of pyNotifier is used. Other possible choices for the
-'type' argument are GTK, QT and WX (current support for wxWindows is
+`type` argument are GTK, QT and WX (current support for wxWindows is
 not up-to-date).
 
 Some notifier implementations provide a set of options that control the
 behaviour of the notifier. The options are passed to the implementation
-as a keyword list through the 'init' function as shown in the following
+as a keyword list through the `init` function as shown in the following
 example:
 
-	def init( type = GTK, x11 = False )
+	def init(type=GTK, x11=False)
 
-This example uses the 'x11' option for the GTK notifier. If set
+This example uses the `x11` option for the GTK notifier. If set
 to False the notifier does not require gtk anymore and uses gobject
 instead.
 
@@ -78,25 +78,25 @@ Sockets
 
 To get notified when a specific event occurs the application has to
 register its interest for this event. For sockets and files this is
-done with the 'socket\_add' function':
+done with the `socket_add` function:
 
-	def socket_add( id, method, condition = IO_IN )
+	def socket_add(id, method, condition=IO_IN)
 
-The 'id' argument may be a socket or file object or a file descriptor
-that can be retrieved by calling the 'fileno()' member function of
-these objects. The second argument 'method' has to be a callable
+The `id` argument may be a socket or file object or a file descriptor
+that can be retrieved by calling the `fileno()` member function of
+these objects. The second argument `method` has to be a callable
 python object that is invoked by the notifier if the registered event
-has occured. The function is invoked with the 'id' as an
+has occured. The function is invoked with the `id` as an
 argument. Instead of a normal function the [Callback](#callbacks)
 object provided by pyNotifier may be useful at this point.
 
 To remove a registered socket or file from the notifier the
-'socket\_remove' function has to be invoked. The 'id' is the socket or
-file object or the file descriptor given to 'socket\_add' and the
-optional argument 'condition' may be set to IO\_IN or IO\_OUT depending
+`socket_remove` function has to be invoked. The `id` is the socket or
+file object or the file descriptor given to `socket_add` and the
+optional argument `condition` may be set to `IO_IN` or `IO_OUT` depending
 on the previously registered event:
 
-	def socket_remove( id, condition = IO_IN )
+	def socket_remove(id, condition=IO_IN)
 
 Another way to achieve the removal of a socket or file object from the
 notifier is to return False in the callback function. If a callback
@@ -108,22 +108,22 @@ Timer
 
 pyNotifier supports just one type of timer. If a timer is registered
 for a given interval of time the application is recurrently triggered
-when the timer expires. To register a timer the 'timer\_add' function
-has to be invoked. The first argument 'interval' must be specified in
-milliseconds. 'method' is the callback function that is invoked by the
+when the timer expires. To register a timer the `timer_add` function
+has to be invoked. The first argument `interval` must be specified in
+milliseconds. `method` is the callback function that is invoked by the
 notifier without any argument when the timer expires.
 
-	def timer_add( interval, method ) -> unique timer identifier
+	def timer_add(interval, method) -> unique timer identifier
 
 To implement a one-shot timer that is just triggered once and never
 again the application can use the return value of its callback
 function for this timer and return False or None. In this case the
 notifier automatically removes the timer. Another way to remove a
-timer is to call the method 'timer\_remove'.
+timer is to call the method `timer_remove`.
 
-	def timer_remove( id )
+	def timer_remove(id)
 
-The 'id' argument is the unique timer identifier returned by 'timer\_add'.
+The `id` argument is the unique timer identifier returned by `timer_add`.
 
 Signals
 -------
@@ -149,32 +149,32 @@ context.
 	import notifier.signals as signals
 
 	# global context
-	signals.new( 'signal1' )
+	signals.new('signal1')
 
-	class Test( signals.Provider ):
-		def __init__( self ):
-			signals.Provider.__init__( self )
-			self.signal_new( 'signal1' )
+	class Test(signals.Provider):
+		def __init__(self):
+			signals.Provider.__init__(self)
+			self.signal_new('signal1')
 
 To get informed when a signal is emitted a connection must be created as
 shown in the following code snippet.
 
 	# global context
-	def _cb_signal( signal ):
+	def _cb_signal(signal):
 		pass
 
-	signals.connect( 'signal1', _cb_signal )
+	signals.connect('signal1', _cb_signal)
 
 	# within the object
-	class Test2( object ):
-		def __init__( self, test ):
-			test.signal_connect( 'signal1', self._cb_signal )
+	class Test2(object):
+		def __init__(self, test):
+			test.signal_connect('signal1', self._cb_signal)
 
-		def _cb_signal( self, signal ):
+		def _cb_signal(self, signal):
 			pass
 
 	test = Test()
-	test2 = Test2( test )
+	test2 = Test2(test)
 
 There is no restriction in how many connection to a signal may exist,
 but it should be noted, that to many connected instances may result an a
@@ -186,10 +186,10 @@ emit a signal its name and possibly optional arguments are passed to a
 function as shown in the following snippet.
 
 	# global context
-	signals.emit( 'signal1', a, b )
+	signals.emit('signal1', a, b)
 
 	# within an object
-	test.signal_emit( 'signal1', a, b, c )
+	test.signal_emit('signal1', a, b, c)
 
 The signature of the callback function for a signal depends on the
 specific signal provider, e.g. each signal may provide as many arguments
@@ -210,49 +210,49 @@ pyNotifier provides the feature to add so called external
 dispatchers. These dispatchers are functions that will be invoked in
 each notifier step after all timers and sockets were checked. To add a
 dispatcher function to the notifier main loop the function
-'dispatcher\_add' is provided. The only argument to this function is the
+`dispatcher_add` is provided. The only argument to this function is the
 callback method that will be called.
 
-	def dispatcher_add( method )
+	def dispatcher_add(method)
 
 To remove such a dispatcher function from the notifier main loop
-'dispatcher\_remove' is used with the call back method as the only argument.
+`dispatcher_remove` is used with the call back method as the only argument.
 
-	def dispatcher_remove( method )
+	def dispatcher_remove(method)
 
 Callbacks
 ---------
 
-pyNotifier provides a class 'Callback' that can be used as a callback
-function that is passed to the 'socket\_add' and 'timer\_add'
+pyNotifier provides a class `Callback` that can be used as a callback
+function that is passed to the `socket_add` and `timer_add`
 function. This class provides the possibility to pass more than the
 specified arguments to the callback functions. For example the socket
 callback function is called with one single argument. To pass some
-state information to the callback function the 'Callback' object may
+state information to the callback function the `Callback` object may
 be used. A default callback function for a socket event would look
-like 'socket1'.
+like `socket1`.
 
 	import notifier
 	...
-	notifier.socket_add( fd, socket1 )
+	notifier.socket_add(fd, socket1)
 	...
 
-	def socket1( fd ):
-		print 'data received on socket', fd
+	def socket1(fd):
+		print('data received on socket', fd)
 		return True
 
-'fd' is the 'id' given to 'socket\_add'. To pass some state information
+`fd` is the `id` given to `socket_add`. To pass some state information
 to the callback function it can be done as shown in the following
 example.
 
 	import notifier
 	...
-	notifier.socket_add( fd, notifier.Callback( socket1, arg1, arg2 ) )
+	notifier.socket_add(fd, notifier.Callback(socket1, arg1, arg2))
 	...
 
-	def socket1( fd, arg1, arg2 ):
-		print 'data received on socket', fd
-		print 'additional state information', arg1, arg2
+	def socket1(fd, arg1, arg2):
+		print('data received on socket', fd)
+		print('additional state information', arg1, arg2)
 
 The arguments given to the Callback object are appended to the
 original list of arguments for the callback function. The argument
@@ -270,26 +270,26 @@ pyNotifier in the examples sub-directory.
 	import notifier
 
 	def another_minute():
-		print "another minute is elapsed"
+		print("another minute is elapsed")
 		# callback should be invoked again
 		return True
 
-	def first_10_secs( secs ):
-		print "the first %d secs are elapsed" % secs
+	def first_10_secs(secs):
+		print("the first %d secs are elapsed" % secs)
 		# this should be a one-shot timer
 		return False
 
-	def standard_in( in ):
-		print "someone entered some data on stdin"
-		print in.read( 80 )
+	def standard_in(in):
+		print("someone entered some data on stdin")
+		print(in.read(80))
 		# still want to watch it
 		return True
 
 	if __name__ == "__main__":
-		notifier.init( notifier.GENERIC )
+		notifier.init(notifier.GENERIC)
 
-		notifier.timer_add( 60000, another_minute )
-		notifier.timer_add( 10000, notifier.Callback( first_10_secs, 10 ) )
-		notifier.socket_add( sys.stdin, standard_in )
+		notifier.timer_add(60000, another_minute)
+		notifier.timer_add(10000, notifier.Callback(first_10_secs, 10))
+		notifier.socket_add(sys.stdin, standard_in)
 
 		notifier.loop()