m doc

Signed-off-by: Mattias Andrée <maandree@operamail.com>

9 files changed, 171 insertions, 187 deletions

diff --git a/examples/backlight b/examples/backlight
index 525948b..9c8ff52 100644
--- a/examples/backlight
+++ b/examples/backlight
@@ -60,8 +60,6 @@ wait_period = 0.1
 cycle, adj, last = 0, 1, controller.brightness
 def periodically(year, month, day, hour, minute, second, weekday, fade):
     '''
-    :(int, int, int, int, int, int, int, float?)?→void  Place holder for periodically invoked function
-    
     Invoked periodically
     
     If you want to control at what to invoke this function next time
@@ -69,25 +67,25 @@ def periodically(year, month, day, hour, minute, second, weekday, fade):
     number of seconds to wait before invoking this function again.
     The value does not need to be an integer.
     
-    @param   year:int     The year
-    @param   month:int    The month, 1 = January, 12 = December
-    @param   day:int      The day, minimum value is 1, probable maximum value is 31 (*)
-    @param   hour:int     The hour, minimum value is 0, maximum value is 23
-    @param   minute:int   The minute, minimum value is 0, maximum value is 59
-    @param   second:int   The second, minimum value is 0, probable maximum value is 60 (**)
-    @param   weekday:int  The weekday, 1 = Monday, 7 = Sunday
-    @param   fade:float?  Blueshift can use this function to fade into a state when it start
-                          or exits. `fade` can either be negative, zero or positive or `None`,
-                          but the magnitude of value cannot exceed 1. When Blueshift starts,
-                          this function will be invoked multiple with the time parameters
-                          of the time it is invoked and each time `fade` will increase towards
-                          1, starting at 0, when the value is 1, the settings should be applied
-                          to 100 %. After this this function will be invoked once again with
-                          `fade` being `None`. When Blueshift exits the same behaviour is used
-                          except, `fade` decrease towards -1 but start slightly below 0, when
-                          -1 is reached all settings should be normal. Then Blueshift will NOT
-                          invoke this function with `fade` being `None`, instead it will by
-                          itself revert all settings and quit.
+    @param  year:int     The year
+    @param  month:int    The month, 1 = January, 12 = December
+    @param  day:int      The day, minimum value is 1, probable maximum value is 31 (*)
+    @param  hour:int     The hour, minimum value is 0, maximum value is 23
+    @param  minute:int   The minute, minimum value is 0, maximum value is 59
+    @param  second:int   The second, minimum value is 0, probable maximum value is 60 (**)
+    @param  weekday:int  The weekday, 1 = Monday, 7 = Sunday
+    @param  fade:float?  Blueshift can use this function to fade into a state when it start
+                         or exits. `fade` can either be negative, zero or positive or `None`,
+                         but the magnitude of value cannot exceed 1. When Blueshift starts,
+                         this function will be invoked multiple with the time parameters
+                         of the time it is invoked and each time `fade` will increase towards
+                         1, starting at 0, when the value is 1, the settings should be applied
+                         to 100 %. After this this function will be invoked once again with
+                         `fade` being `None`. When Blueshift exits the same behaviour is used
+                         except, `fade` decrease towards -1 but start slightly below 0, when
+                         -1 is reached all settings should be normal. Then Blueshift will NOT
+                         invoke this function with `fade` being `None`, instead it will by
+                         itself revert all settings and quit.
     
     (*)  Can be exceeded if the calendar system is changed, like in 1712-(02)Feb-30
     (**) See https://en.wikipedia.org/wiki/Leap_second
diff --git a/examples/battery b/examples/battery
index 4f333f4..118f64c 100644
--- a/examples/battery
+++ b/examples/battery
@@ -65,8 +65,6 @@ fadein_time = None
 
 def periodically(year, month, day, hour, minute, second, weekday, fade):
     '''
-    :(int, int, int, int, int, int, int, float?)?→void  Place holder for periodically invoked function
-    
     Invoked periodically
     
     If you want to control at what to invoke this function next time
@@ -74,25 +72,25 @@ def periodically(year, month, day, hour, minute, second, weekday, fade):
     number of seconds to wait before invoking this function again.
     The value does not need to be an integer.
     
-    @param   year:int     The year
-    @param   month:int    The month, 1 = January, 12 = December
-    @param   day:int      The day, minimum value is 1, probable maximum value is 31 (*)
-    @param   hour:int     The hour, minimum value is 0, maximum value is 23
-    @param   minute:int   The minute, minimum value is 0, maximum value is 59
-    @param   second:int   The second, minimum value is 0, probable maximum value is 60 (**)
-    @param   weekday:int  The weekday, 1 = Monday, 7 = Sunday
-    @param   fade:float?  Blueshift can use this function to fade into a state when it start
-                          or exits. `fade` can either be negative, zero or positive or `None`,
-                          but the magnitude of value cannot exceed 1. When Blueshift starts,
-                          this function will be invoked multiple with the time parameters
-                          of the time it is invoked and each time `fade` will increase towards
-                          1, starting at 0, when the value is 1, the settings should be applied
-                          to 100 %. After this this function will be invoked once again with
-                          `fade` being `None`. When Blueshift exits the same behaviour is used
-                          except, `fade` decrease towards -1 but start slightly below 0, when
-                          -1 is reached all settings should be normal. Then Blueshift will NOT
-                          invoke this function with `fade` being `None`, instead it will by
-                          itself revert all settings and quit.
+    @param  year:int     The year
+    @param  month:int    The month, 1 = January, 12 = December
+    @param  day:int      The day, minimum value is 1, probable maximum value is 31 (*)
+    @param  hour:int     The hour, minimum value is 0, maximum value is 23
+    @param  minute:int   The minute, minimum value is 0, maximum value is 59
+    @param  second:int   The second, minimum value is 0, probable maximum value is 60 (**)
+    @param  weekday:int  The weekday, 1 = Monday, 7 = Sunday
+    @param  fade:float?  Blueshift can use this function to fade into a state when it start
+                         or exits. `fade` can either be negative, zero or positive or `None`,
+                         but the magnitude of value cannot exceed 1. When Blueshift starts,
+                         this function will be invoked multiple with the time parameters
+                         of the time it is invoked and each time `fade` will increase towards
+                         1, starting at 0, when the value is 1, the settings should be applied
+                         to 100 %. After this this function will be invoked once again with
+                         `fade` being `None`. When Blueshift exits the same behaviour is used
+                         except, `fade` decrease towards -1 but start slightly below 0, when
+                         -1 is reached all settings should be normal. Then Blueshift will NOT
+                         invoke this function with `fade` being `None`, instead it will by
+                         itself revert all settings and quit.
     
     (*)  Can be exceeded if the calendar system is changed, like in 1712-(02)Feb-30
     (**) See https://en.wikipedia.org/wiki/Leap_second
diff --git a/examples/bedtime b/examples/bedtime
index eff08d2..23ebec9 100644
--- a/examples/bedtime
+++ b/examples/bedtime
@@ -202,8 +202,6 @@ def get_bedness(time):
 last_dayness, last_bedness = -1, -1
 def periodically(year, month, day, hour, minute, second, weekday, fade):
     '''
-    :(int, int, int, int, int, int, int, float?)?→void  Place holder for periodically invoked function
-    
     Invoked periodically
     
     If you want to control at what to invoke this function next time
@@ -211,25 +209,25 @@ def periodically(year, month, day, hour, minute, second, weekday, fade):
     number of seconds to wait before invoking this function again.
     The value does not need to be an integer.
     
-    @param   year:int     The year
-    @param   month:int    The month, 1 = January, 12 = December
-    @param   day:int      The day, minimum value is 1, probable maximum value is 31 (*)
-    @param   hour:int     The hour, minimum value is 0, maximum value is 23
-    @param   minute:int   The minute, minimum value is 0, maximum value is 59
-    @param   second:int   The second, minimum value is 0, probable maximum value is 60 (**)
-    @param   weekday:int  The weekday, 1 = Monday, 7 = Sunday
-    @param   fade:float?  Blueshift can use this function to fade into a state when it start
-                          or exits. `fade` can either be negative, zero or positive or `None`,
-                          but the magnitude of value cannot exceed 1. When Blueshift starts,
-                          this function will be invoked multiple with the time parameters
-                          of the time it is invoked and each time `fade` will increase towards
-                          1, starting at 0, when the value is 1, the settings should be applied
-                          to 100 %. After this this function will be invoked once again with
-                          `fade` being `None`. When Blueshift exits the same behaviour is used
-                          except, `fade` decrease towards -1 but start slightly below 0, when
-                          -1 is reached all settings should be normal. Then Blueshift will NOT
-                          invoke this function with `fade` being `None`, instead it will by
-                          itself revert all settings and quit.
+    @param  year:int     The year
+    @param  month:int    The month, 1 = January, 12 = December
+    @param  day:int      The day, minimum value is 1, probable maximum value is 31 (*)
+    @param  hour:int     The hour, minimum value is 0, maximum value is 23
+    @param  minute:int   The minute, minimum value is 0, maximum value is 59
+    @param  second:int   The second, minimum value is 0, probable maximum value is 60 (**)
+    @param  weekday:int  The weekday, 1 = Monday, 7 = Sunday
+    @param  fade:float?  Blueshift can use this function to fade into a state when it start
+                         or exits. `fade` can either be negative, zero or positive or `None`,
+                         but the magnitude of value cannot exceed 1. When Blueshift starts,
+                         this function will be invoked multiple with the time parameters
+                         of the time it is invoked and each time `fade` will increase towards
+                         1, starting at 0, when the value is 1, the settings should be applied
+                         to 100 %. After this this function will be invoked once again with
+                         `fade` being `None`. When Blueshift exits the same behaviour is used
+                         except, `fade` decrease towards -1 but start slightly below 0, when
+                         -1 is reached all settings should be normal. Then Blueshift will NOT
+                         invoke this function with `fade` being `None`, instead it will by
+                         itself revert all settings and quit.
     
     (*)  Can be exceeded if the calendar system is changed, like in 1712-(02)Feb-30
     (**) See https://en.wikipedia.org/wiki/Leap_second
diff --git a/examples/comprehensive b/examples/comprehensive
index daaa626..b164212 100644
--- a/examples/comprehensive
+++ b/examples/comprehensive
@@ -279,8 +279,6 @@ sigmoid_ = list(zip(sigmoid_red, sigmoid_green, sigmoid_blue))
 icc_video_filter_profile = [None] * len(icc_video_filter_profile_day)
 def periodically(year, month, day, hour, minute, second, weekday, fade):
     '''
-    :(int, int, int, int, int, int, int, float?)?→void  Place holder for periodically invoked function
-    
     Invoked periodically
     
     If you want to control at what to invoke this function next time
@@ -288,25 +286,25 @@ def periodically(year, month, day, hour, minute, second, weekday, fade):
     number of seconds to wait before invoking this function again.
     The value does not need to be an integer.
     
-    @param   year:int     The year
-    @param   month:int    The month, 1 = January, 12 = December
-    @param   day:int      The day, minimum value is 1, probable maximum value is 31 (*)
-    @param   hour:int     The hour, minimum value is 0, maximum value is 23
-    @param   minute:int   The minute, minimum value is 0, maximum value is 59
-    @param   second:int   The second, minimum value is 0, probable maximum value is 60 (**)
-    @param   weekday:int  The weekday, 1 = Monday, 7 = Sunday
-    @param   fade:float?  Blueshift can use this function to fade into a state when it start
-                          or exits. `fade` can either be negative, zero or positive or `None`,
-                          but the magnitude of value cannot exceed 1. When Blueshift starts,
-                          this function will be invoked multiple with the time parameters
-                          of the time it is invoked and each time `fade` will increase towards
-                          1, starting at 0, when the value is 1, the settings should be applied
-                          to 100 %. After this this function will be invoked once again with
-                          `fade` being `None`. When Blueshift exits the same behaviour is used
-                          except, `fade` decrease towards -1 but start slightly below 0, when
-                          -1 is reached all settings should be normal. Then Blueshift will NOT
-                          invoke this function with `fade` being `None`, instead it will by
-                          itself revert all settings and quit.
+    @param  year:int     The year
+    @param  month:int    The month, 1 = January, 12 = December
+    @param  day:int      The day, minimum value is 1, probable maximum value is 31 (*)
+    @param  hour:int     The hour, minimum value is 0, maximum value is 23
+    @param  minute:int   The minute, minimum value is 0, maximum value is 59
+    @param  second:int   The second, minimum value is 0, probable maximum value is 60 (**)
+    @param  weekday:int  The weekday, 1 = Monday, 7 = Sunday
+    @param  fade:float?  Blueshift can use this function to fade into a state when it start
+                         or exits. `fade` can either be negative, zero or positive or `None`,
+                         but the magnitude of value cannot exceed 1. When Blueshift starts,
+                         this function will be invoked multiple with the time parameters
+                         of the time it is invoked and each time `fade` will increase towards
+                         1, starting at 0, when the value is 1, the settings should be applied
+                         to 100 %. After this this function will be invoked once again with
+                         `fade` being `None`. When Blueshift exits the same behaviour is used
+                         except, `fade` decrease towards -1 but start slightly below 0, when
+                         -1 is reached all settings should be normal. Then Blueshift will NOT
+                         invoke this function with `fade` being `None`, instead it will by
+                         itself revert all settings and quit.
     
     (*)  Can be exceeded if the calendar system is changed, like in 1712-(02)Feb-30
     (**) See https://en.wikipedia.org/wiki/Leap_second
diff --git a/examples/sleepmode b/examples/sleepmode
index 8713b63..d633f27 100644
--- a/examples/sleepmode
+++ b/examples/sleepmode
@@ -68,8 +68,6 @@ wait_period = 60 * 60
 
 def periodically(year, month, day, hour, minute, second, weekday, fade):
     '''
-    :(int, int, int, int, int, int, int, float?)?→void  Place holder for periodically invoked function
-    
     Invoked periodically
     
     If you want to control at what to invoke this function next time
@@ -77,25 +75,25 @@ def periodically(year, month, day, hour, minute, second, weekday, fade):
     number of seconds to wait before invoking this function again.
     The value does not need to be an integer.
     
-    @param   year:int     The year
-    @param   month:int    The month, 1 = January, 12 = December
-    @param   day:int      The day, minimum value is 1, probable maximum value is 31 (*)
-    @param   hour:int     The hour, minimum value is 0, maximum value is 23
-    @param   minute:int   The minute, minimum value is 0, maximum value is 59
-    @param   second:int   The second, minimum value is 0, probable maximum value is 60 (**)
-    @param   weekday:int  The weekday, 1 = Monday, 7 = Sunday
-    @param   fade:float?  Blueshift can use this function to fade into a state when it start
-                          or exits. `fade` can either be negative, zero or positive or `None`,
-                          but the magnitude of value cannot exceed 1. When Blueshift starts,
-                          this function will be invoked multiple with the time parameters
-                          of the time it is invoked and each time `fade` will increase towards
-                          1, starting at 0, when the value is 1, the settings should be applied
-                          to 100 %. After this this function will be invoked once again with
-                          `fade` being `None`. When Blueshift exits the same behaviour is used
-                          except, `fade` decrease towards -1 but start slightly below 0, when
-                          -1 is reached all settings should be normal. Then Blueshift will NOT
-                          invoke this function with `fade` being `None`, instead it will by
-                          itself revert all settings and quit.
+    @param  year:int     The year
+    @param  month:int    The month, 1 = January, 12 = December
+    @param  day:int      The day, minimum value is 1, probable maximum value is 31 (*)
+    @param  hour:int     The hour, minimum value is 0, maximum value is 23
+    @param  minute:int   The minute, minimum value is 0, maximum value is 59
+    @param  second:int   The second, minimum value is 0, probable maximum value is 60 (**)
+    @param  weekday:int  The weekday, 1 = Monday, 7 = Sunday
+    @param  fade:float?  Blueshift can use this function to fade into a state when it start
+                         or exits. `fade` can either be negative, zero or positive or `None`,
+                         but the magnitude of value cannot exceed 1. When Blueshift starts,
+                         this function will be invoked multiple with the time parameters
+                         of the time it is invoked and each time `fade` will increase towards
+                         1, starting at 0, when the value is 1, the settings should be applied
+                         to 100 %. After this this function will be invoked once again with
+                         `fade` being `None`. When Blueshift exits the same behaviour is used
+                         except, `fade` decrease towards -1 but start slightly below 0, when
+                         -1 is reached all settings should be normal. Then Blueshift will NOT
+                         invoke this function with `fade` being `None`, instead it will by
+                         itself revert all settings and quit.
     
     (*)  Can be exceeded if the calendar system is changed, like in 1712-(02)Feb-30
     (**) See https://en.wikipedia.org/wiki/Leap_second
diff --git a/examples/textconf b/examples/textconf
index 9f9d778..38c56a2 100644
--- a/examples/textconf
+++ b/examples/textconf
@@ -477,8 +477,6 @@ for sb in saved_backlight_:
 
 def periodically(year, month, day, hour, minute, second, weekday, fade):
     '''
-    :(int, int, int, int, int, int, int, float?)?→void  Place holder for periodically invoked function
-    
     Invoked periodically
     
     If you want to control at what to invoke this function next time
@@ -486,25 +484,25 @@ def periodically(year, month, day, hour, minute, second, weekday, fade):
     number of seconds to wait before invoking this function again.
     The value does not need to be an integer.
     
-    @param   year:int     The year
-    @param   month:int    The month, 1 = January, 12 = December
-    @param   day:int      The day, minimum value is 1, probable maximum value is 31 (*)
-    @param   hour:int     The hour, minimum value is 0, maximum value is 23
-    @param   minute:int   The minute, minimum value is 0, maximum value is 59
-    @param   second:int   The second, minimum value is 0, probable maximum value is 60 (**)
-    @param   weekday:int  The weekday, 1 = Monday, 7 = Sunday
-    @param   fade:float?  Blueshift can use this function to fade into a state when it start
-                          or exits. `fade` can either be negative, zero or positive or `None`,
-                          but the magnitude of value cannot exceed 1. When Blueshift starts,
-                          this function will be invoked multiple with the time parameters
-                          of the time it is invoked and each time `fade` will increase towards
-                          1, starting at 0, when the value is 1, the settings should be applied
-                          to 100 %. After this this function will be invoked once again with
-                          `fade` being `None`. When Blueshift exits the same behaviour is used
-                          except, `fade` decrease towards -1 but start slightly below 0, when
-                          -1 is reached all settings should be normal. Then Blueshift will NOT
-                          invoke this function with `fade` being `None`, instead it will by
-                          itself revert all settings and quit.
+    @param  year:int     The year
+    @param  month:int    The month, 1 = January, 12 = December
+    @param  day:int      The day, minimum value is 1, probable maximum value is 31 (*)
+    @param  hour:int     The hour, minimum value is 0, maximum value is 23
+    @param  minute:int   The minute, minimum value is 0, maximum value is 59
+    @param  second:int   The second, minimum value is 0, probable maximum value is 60 (**)
+    @param  weekday:int  The weekday, 1 = Monday, 7 = Sunday
+    @param  fade:float?  Blueshift can use this function to fade into a state when it start
+                         or exits. `fade` can either be negative, zero or positive or `None`,
+                         but the magnitude of value cannot exceed 1. When Blueshift starts,
+                         this function will be invoked multiple with the time parameters
+                         of the time it is invoked and each time `fade` will increase towards
+                         1, starting at 0, when the value is 1, the settings should be applied
+                         to 100 %. After this this function will be invoked once again with
+                         `fade` being `None`. When Blueshift exits the same behaviour is used
+                         except, `fade` decrease towards -1 but start slightly below 0, when
+                         -1 is reached all settings should be normal. Then Blueshift will NOT
+                         invoke this function with `fade` being `None`, instead it will by
+                         itself revert all settings and quit.
     
     (*)  Can be exceeded if the calendar system is changed, like in 1712-(02)Feb-30
     (**) See https://en.wikipedia.org/wiki/Leap_second
diff --git a/examples/threaded b/examples/threaded
index a7ea730..1fb1c65 100644
--- a/examples/threaded
+++ b/examples/threaded
@@ -153,8 +153,6 @@ for m in range(len(gamma_red)):
 last_dayness = None
 def periodically(year, month, day, hour, minute, second, weekday, fade):
     '''
-    :(int, int, int, int, int, int, int, float?)?→void  Place holder for periodically invoked function
-    
     Invoked periodically
     
     If you want to control at what to invoke this function next time
@@ -162,25 +160,25 @@ def periodically(year, month, day, hour, minute, second, weekday, fade):
     number of seconds to wait before invoking this function again.
     The value does not need to be an integer.
     
-    @param   year:int     The year
-    @param   month:int    The month, 1 = January, 12 = December
-    @param   day:int      The day, minimum value is 1, probable maximum value is 31 (*)
-    @param   hour:int     The hour, minimum value is 0, maximum value is 23
-    @param   minute:int   The minute, minimum value is 0, maximum value is 59
-    @param   second:int   The second, minimum value is 0, probable maximum value is 60 (**)
-    @param   weekday:int  The weekday, 1 = Monday, 7 = Sunday
-    @param   fade:float?  Blueshift can use this function to fade into a state when it start
-                          or exits. `fade` can either be negative, zero or positive or `None`,
-                          but the magnitude of value cannot exceed 1. When Blueshift starts,
-                          this function will be invoked multiple with the time parameters
-                          of the time it is invoked and each time `fade` will increase towards
-                          1, starting at 0, when the value is 1, the settings should be applied
-                          to 100 %. After this this function will be invoked once again with
-                          `fade` being `None`. When Blueshift exits the same behaviour is used
-                          except, `fade` decrease towards -1 but start slightly below 0, when
-                          -1 is reached all settings should be normal. Then Blueshift will NOT
-                          invoke this function with `fade` being `None`, instead it will by
-                          itself revert all settings and quit.
+    @param  year:int     The year
+    @param  month:int    The month, 1 = January, 12 = December
+    @param  day:int      The day, minimum value is 1, probable maximum value is 31 (*)
+    @param  hour:int     The hour, minimum value is 0, maximum value is 23
+    @param  minute:int   The minute, minimum value is 0, maximum value is 59
+    @param  second:int   The second, minimum value is 0, probable maximum value is 60 (**)
+    @param  weekday:int  The weekday, 1 = Monday, 7 = Sunday
+    @param  fade:float?  Blueshift can use this function to fade into a state when it start
+                         or exits. `fade` can either be negative, zero or positive or `None`,
+                         but the magnitude of value cannot exceed 1. When Blueshift starts,
+                         this function will be invoked multiple with the time parameters
+                         of the time it is invoked and each time `fade` will increase towards
+                         1, starting at 0, when the value is 1, the settings should be applied
+                         to 100 %. After this this function will be invoked once again with
+                         `fade` being `None`. When Blueshift exits the same behaviour is used
+                         except, `fade` decrease towards -1 but start slightly below 0, when
+                         -1 is reached all settings should be normal. Then Blueshift will NOT
+                         invoke this function with `fade` being `None`, instead it will by
+                         itself revert all settings and quit.
     
     (*)  Can be exceeded if the calendar system is changed, like in 1712-(02)Feb-30
     (**) See https://en.wikipedia.org/wiki/Leap_second
diff --git a/examples/xmonad b/examples/xmonad
index 3a4cd23..8256e23 100644
--- a/examples/xmonad
+++ b/examples/xmonad
@@ -132,8 +132,6 @@ def get_workspaces():
 last = (-1, '')
 def periodically(year, month, day, hour, minute, second, weekday, fade):
     '''
-    :(int, int, int, int, int, int, int, float?)?→void  Place holder for periodically invoked function
-    
     Invoked periodically
     
     If you want to control at what to invoke this function next time
@@ -141,25 +139,25 @@ def periodically(year, month, day, hour, minute, second, weekday, fade):
     number of seconds to wait before invoking this function again.
     The value does not need to be an integer.
     
-    @param   year:int     The year
-    @param   month:int    The month, 1 = January, 12 = December
-    @param   day:int      The day, minimum value is 1, probable maximum value is 31 (*)
-    @param   hour:int     The hour, minimum value is 0, maximum value is 23
-    @param   minute:int   The minute, minimum value is 0, maximum value is 59
-    @param   second:int   The second, minimum value is 0, probable maximum value is 60 (**)
-    @param   weekday:int  The weekday, 1 = Monday, 7 = Sunday
-    @param   fade:float?  Blueshift can use this function to fade into a state when it start
-                          or exits. `fade` can either be negative, zero or positive or `None`,
-                          but the magnitude of value cannot exceed 1. When Blueshift starts,
-                          the this function will be invoked multiple with the time parameters
-                          of the time it is invoked and each time `fade` will increase towards
-                          1, starting at 0, when the value is 1, the settings should be applied
-                          to 100 %. After this this function will be invoked once again with
-                          `fade` being `None`. When Blueshift exits the same behaviour is used
-                          except, `fade` decrease towards -1 but start slightly below 0, when
-                          -1 is reached all settings should be normal. Then Blueshift will NOT
-                          invoke this function with `fade` being `None`, instead it will by
-                          itself revert all settings and quit.
+    @param  year:int     The year
+    @param  month:int    The month, 1 = January, 12 = December
+    @param  day:int      The day, minimum value is 1, probable maximum value is 31 (*)
+    @param  hour:int     The hour, minimum value is 0, maximum value is 23
+    @param  minute:int   The minute, minimum value is 0, maximum value is 59
+    @param  second:int   The second, minimum value is 0, probable maximum value is 60 (**)
+    @param  weekday:int  The weekday, 1 = Monday, 7 = Sunday
+    @param  fade:float?  Blueshift can use this function to fade into a state when it start
+                         or exits. `fade` can either be negative, zero or positive or `None`,
+                         but the magnitude of value cannot exceed 1. When Blueshift starts,
+                         the this function will be invoked multiple with the time parameters
+                         of the time it is invoked and each time `fade` will increase towards
+                         1, starting at 0, when the value is 1, the settings should be applied
+                         to 100 %. After this this function will be invoked once again with
+                         `fade` being `None`. When Blueshift exits the same behaviour is used
+                         except, `fade` decrease towards -1 but start slightly below 0, when
+                         -1 is reached all settings should be normal. Then Blueshift will NOT
+                         invoke this function with `fade` being `None`, instead it will by
+                         itself revert all settings and quit.
     
     (*)  Can be exceeded if the calendar system is changed, like in 1712-(02)Feb-30
     (**) See https://en.wikipedia.org/wiki/Leap_second
diff --git a/src/__main__.py b/src/__main__.py
index dec8d2f..6490652 100755
--- a/src/__main__.py
+++ b/src/__main__.py
@@ -64,25 +64,25 @@ you can set the value of the global variable `wait_period` to the
 number of seconds to wait before invoking this function again.
 The value does not need to be an integer.
 
-@param   year:int     The year
-@param   month:int    The month, 1 = January, 12 = December
-@param   day:int      The day, minimum value is 1, probable maximum value is 31 (*)
-@param   hour:int     The hour, minimum value is 0, maximum value is 23
-@param   minute:int   The minute, minimum value is 0, maximum value is 59
-@param   second:int   The second, minimum value is 0, probable maximum value is 60 (**)
-@param   weekday:int  The weekday, 1 = Monday, 7 = Sunday
-@param   fade:float?  Blueshift can use this function to fade into a state when it start
-                      or exits. `fade` can either be negative, zero or positive or `None`,
-                      but the magnitude of value cannot exceed 1. When Blueshift starts,
-                      this function will be invoked multiple with the time parameters
-                      of the time it is invoked and each time `fade` will increase towards
-                      1, starting at 0, when the value is 1, the settings should be applied
-                      to 100 %. After this this function will be invoked once again with
-                      `fade` being `None`. When Blueshift exits the same behaviour is used
-                      except, `fade` decrease towards -1 but start slightly below 0, when
-                      -1 is reached all settings should be normal. Then Blueshift will NOT
-                      invoke this function with `fade` being `None`, instead it will by
-                      itself revert all settings and quit.
+@param  year:int     The year
+@param  month:int    The month, 1 = January, 12 = December
+@param  day:int      The day, minimum value is 1, probable maximum value is 31 (*)
+@param  hour:int     The hour, minimum value is 0, maximum value is 23
+@param  minute:int   The minute, minimum value is 0, maximum value is 59
+@param  second:int   The second, minimum value is 0, probable maximum value is 60 (**)
+@param  weekday:int  The weekday, 1 = Monday, 7 = Sunday
+@param  fade:float?  Blueshift can use this function to fade into a state when it start
+                     or exits. `fade` can either be negative, zero or positive or `None`,
+                     but the magnitude of value cannot exceed 1. When Blueshift starts,
+                     this function will be invoked multiple with the time parameters
+                     of the time it is invoked and each time `fade` will increase towards
+                     1, starting at 0, when the value is 1, the settings should be applied
+                     to 100 %. After this this function will be invoked once again with
+                     `fade` being `None`. When Blueshift exits the same behaviour is used
+                     except, `fade` decrease towards -1 but start slightly below 0, when
+                     -1 is reached all settings should be normal. Then Blueshift will NOT
+                     invoke this function with `fade` being `None`, instead it will by
+                     itself revert all settings and quit.
 
 (*)  Can be exceeded if the calendar system is changed, like in 1712-(02)Feb-30
 (**) See https://en.wikipedia.org/wiki/Leap_second