# -*- python -*-
# This example uses a text based configuration file to make
# it easier for non-programmers to use Blueshift. It is however
# rather limited, the lisp-esque example is a bit more complex
# but do much more. It will # read a file with the same pathname
# just with ‘.conf’ # appended (‘textconf.conf’ in this case.)
# However, if the filename of this file ends with with ‘rc’,
# that part will be removed, for example, if you rename this
# script to ‘~/.blueshiftrc’ it will read ‘~/.blueshift.conf’
# rather than ‘~/.blueshiftrc.conf’.
# Copyright © 2014 Mattias Andrée (maandree@member.fsf.org)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import sys
import time
import subprocess
# Get the name of .conf file
conf = '%s.conf' % (config_file[:-2] if config_file.endswith('rc') else config_file)
# Read .conf file
with open(conf, 'r') as file:
conf = file.read()
# Parse .conf file
sections = {'blueshift' : []}
section = []
sections['blueshift'].append(section)
for line in conf.split('\n'):
line = line.strip()
if line.startswith('[') and line.endswith(']'):
section_name = line[1 : -1].strip().lower()
if section_name not in sections:
sections[section_name] = []
section = []
sections[section_name].append(section)
elif line.startswith(';') or line.startswith('#'):
continue
elif ('=' in line) or (':' in line):
eq = len(line) if '=' not in line else line.find('=')
cl = len(line) if ':' not in line else line.find(':')
eq = min(eq, cl)
section.append((line[:eq].strip().lower(), line[eq + 1:].strip()))
elif len(line.strip()) > 0:
sys.stderr.buffer.write(('Malformated line: %s\n' % line).encode('utf-8'))
sys.stderr.buffer.flush()
# Default values
location = None
adjustment_method_x = ['randr']
adjustment_method_tty = ['drm']
points = ['solar', '3', '-6']
# List of adjustments and temporary monitor information
adjustments = []
monitors = []
crtc = None
screen = None
def parse_value(value):
'''
Parse a setting value
@param value:str The value to parse
@return :(list<str>, bool, bool, bool) The words in the value string, with commands spawned,
and with 'linear', 'cie' and 'default' filtered out,
and their
existance is put as booleans
'''
def spawn(cmd):
'''
Spawn an external process and read its output, but only the first line
@param cmd:str The command to spawn
@return :str? The first line of the command's output, `None` on failure
'''
proc = subprocess.Popen(['sh', '-c', cmd], stdout = subprocess.PIPE, stderr = sys.stderr)
output = proc.communicate()[0].split('\n')[0]
if (proc.returncode == 0) and (len(output) > 0):
return output
return None
words, buf, cmd = [], '', None
for c in value:
if cmd is not None:
if cmd == '':
if c == '(':
cmd += '('
else:
cmd = None
buf += '$'
else:
cmd += c
if c == ')':
cmd = cmd[1 : -1]
cmd = spawn(cmd)
if cmd is not None:
buf = cmd
cmd = None
elif c == ' ':
if not buf == '':
words.append(buf)
buf = ''
elif c == '$':
cmd = ''
else:
buf += c
if not buf == '':
words.append(buf)
return ([w for w in words if w not in ['linear', 'cie', 'default']],
'linear' in words, 'cie' in words, 'default' in words)
# Evaluate .conf file
def make_f(f, value, default):
'''
Make an adjustment function
@param f:(*¿V??)→void The function that makes the adjustment
@param value:list<¿V??> The values for each time point
@param default:list<¿V??> The default value
'''
ff = None
value_ = []
for val in value:
value_ += val
if any(map(lambda v : v is None, value_ + default)):
def ff(t, a):
val0 = value[(int(t) + 0) % len(value)]
val1 = value[(int(t) + 1) % len(value)]
t %= 1
val = zip(val0, val1, default)
def interpol(v0, v1, d):
if (v0 is None) or (v1 is None) or (d is None):
if ( d is None) and a == 0: return None
if (v0 is None) and t == 0: return None
if (v1 is None) and t == 1: return None
v0 = v0 * (1 - t) if v0 is not None else 0
v1 = v1 * t if v1 is not None else 0
return v0 + v1
val = [interpol(v0, v1, d) for v0, v1, d in val]
f(*val)
else:
def ff(t, a):
val0 = value[(int(t) + 0) % len(value)]
val1 = value[(int(t) + 1) % len(value)]
t %= 1
val = zip(val0, val1, default)
val = [(v0 * (1 - t) + v1 * t) * a + (1 - a) * d for v0, v1, d in val]
f(*val)
return ff
def float3(value):
'''
Parse a string representation of a float trio
@param value:str The float trio as a string
@return :[float?, float?, float?] The float trio as a float list
'''
value = [None if v == 'none' else float(v) for v in value.split(':')]
if len(value) < 3:
value *= 3
return value[:3]
def float6(value):
'''
Parse a string representation of a float pair-trio
@param value:str The float pair-trio as a string
@return :[float?]*6 The float pair-trio as a float list
'''
(part1, part2) = [[float(v) for v in val.split(':')] for val in value.split('..')]
if len(part1) < 3: part1 *= 3
if len(part2) < 3: part2 *= 3
part1 = part1[:3]
part2 = part2[:3]
value = []
for p, q in zip(part1, part2):
value.append(p)
value.append(q)
return value
def add_adjustments(adjsections, adjustments):
'''
Add adjustions from a section to a list
@param adjsections:list<list<(str, str)>> The sections
@param adjustments:list<(float, float)→void> The list to fill with adjustments
'''
global location, points, adjustment_method_x, adjustment_method_tty, crtc, screen
for section in adjsections:
for (setting, value) in section:
(value, linear, cie, default) = parse_value(value)
new_adjustment = None
if linear:
adjustments.append(lambda _t, _a: linearise())
if setting == 'location': location = value
elif setting == 'points': points = value
elif setting == 'adjustment-method-x': adjustment_method_x = value
elif setting == 'adjustment-method-tty': adjustment_method_tty = value
elif setting == 'crtc': crtc = value
elif setting == 'screen': screen = value
elif setting == 'card': screen = value
elif setting == 'temperature':
f = lambda x : temperature(x, lambda t : divide_by_maximum(cmf_10deg(t)))
new_adjustment = make_f(f, [[float(v)] for v in value], [6500])
elif setting == 'contrast':
f = cie_contrast if cie else rgb_contrast
new_adjustment = make_f(f, [float3(v) for v in value], 3 * [1])
elif setting == 'brightness':
f = cie_brightness if cie else rgb_brightness
new_adjustment = make_f(f, [float3(v) for v in value], 3 * [1])
elif setting == 'gamma':
def f(*levels):
clip()
gamma(*levels)
new_adjustment = make_f(f, [float3(v) for v in value], 3 * [1])
elif setting == 'negative':
def f(*values):
negative(*[not v == 0 for v in values])
new_adjustment = make_f(f, [float3(v) for v in value], 3 * [0])
elif setting == 'invert':
def f(*values):
(cie_invert if cie else rgb_invert)(*[not v == 0 for v in values])
new_adjustment = make_f(f, [float3(v) for v in value], 3 * [0])
elif setting == 'sigmoid':
new_adjustment = make_f(sigmoid, [float3(v) for v in value], 3 * [None])
elif setting == 'limits':
f = cie_limits if cie else rgb_limits
new_adjustment = make_f(f, [float6(v) for v in value], 3 * [0, 1])
elif setting == 'icc':
def noop():
pass
profiles = [noop if val == 'none' else load_load(val) for val in value]
new_adjustment = make_icc_interpolation(profiles)
elif setting == 'monitor':
add_adjustments(sections[' '.join(['monitor'] + value)], adjustments)
else:
sys.stderr.buffer.write(('Setting not recognised: %s\n' % setting).encode('utf-8'))
sys.stderr.buffer.flush()
if new_adjustment is not None:
if default:
new_adjustment_ = new_adjustment
def f(t, a):
new_adjustment_(t, 1)
new_adjustment = f
adjustments.append(new_adjustment)
if linear:
adjustments.append(lambda _t, _a: standardise())
add_adjustments(sections['blueshift'], adjustments)
adjustment_method = adjustment_method_tty if ttymode else adjustment_method_x
adjustment_method = adjustment_method[0]
list_method = 'randr' if adjustment_method == 'vidmode' else adjustment_method
screen_list = None
for section in sections[adjustment_method]:
output_adjustments = []
crtc, screen = None, None
add_adjustments([section], output_adjustments)
if (screen_list is None) and ((crtc is None) or (screen is None)):
screen_list = list_screens(list_method)
if screen is None:
screen = list(range(len(screen_list)))
else:
screen = [int(s) for s in screen]
crtcs = {}
for s in screen:
if crtc is not None:
crtcs[s] = [int(c) for c in crtc]
else:
crtcs[s] = list(range(screen_list[s].crtc_count))
monitors.append((crtcs, screen, output_adjustments))
# Get gamma adjustment/reader functions
get_method = {'randr' : randr_get, 'vidmode' : vidmode_get, 'drm' : drm_get}
set_method = {'randr' : randr, 'vidmode' : vidmode, 'drm' : drm }
get_method = get_method[adjustment_method]
set_method = set_method[adjustment_method]
# Save gamma ramps
saved = {}
for crtcs, screens, _ in monitors:
for screen in screens:
if screen not in saved:
saved[screen] = {}
saved_ = saved[screen]
for crtc in crtcs[screen]:
saved_[crtc] = get_method(crtc, screen)
# Evaluate location
latitude, longitude = None, None
if 'solar' in points:
if (location is None) or (len(location) == 0):
sys.stderr.buffer.write(('Location missing\n').encode('utf-8'))
sys.stderr.buffer.flush()
sys.exit(1)
try:
if not len(location) == 2:
raise Exception()
location = [float(c) for c in location]
except:
sys.stderr.buffer.write(('Malformation location\n').encode('utf-8'))
sys.stderr.buffer.flush()
sys.exit(1)
if not ((-90 <= location[0] <= 90) and (-180 <= location[0] <= 180)):
sys.stderr.buffer.write(('Invalid location\n').encode('utf-8'))
sys.stderr.buffer.flush()
sys.exit(1)
(latitude, longitude) = location
# Evaluate point
if ('solar' not in points) and ('time' not in points):
sys.stderr.buffer.write(('Invalid points settings\n').encode('utf-8'))
sys.stderr.buffer.flush()
sys.exit(1)
reduce_points = 'reduce' in points
solar_points = 'solar' in points
def t(point):
point = [float(p) for p in point.split(':')]
while len(point) > 3:
point.append(0)
v = sum([v * 60 ** (2 - i) for i, v in enumerate(point)])
return v % 24
points = [float(p) if solar_points else t(p) for p in points if p not in ['solar', 'time', 'reduce']]
points = list(enumerate(points))
if reduce_points:
n = len(points) - 1
points = [(r / n, v) for r, v in points]
get_timepoint = None
points.sort(key = lambda x : x[0])
if not solar_points:
one_day = 24 * 60 * 60
points.append((points[0][0], points[0][1] + one_day))
points = [(points[-2][0], points[-2][1] - one_day)] + points
def get_timepoint():
v = time.time() % one_day
for i in range(len(points) - 1):
a, b = points[i][1], points[i + 1][1]
if a <= v <= b:
a_, b_ = points[i][0], points[i + 1][0]
v = (v - a) / (b - a)
if (a_ + 1 == b_) or (b_ == 0):
return v + points[i][0]
else:
return points[i][1] - v
return 1 # should never happen
if solar_points:
def get_timepoint():
v = solar_elevation(latitude, longitude)
for i in range(len(points) - 1):
a, b = points[i][1], points[i + 1][1]
if a <= v <= b:
a_, b_ = points[i][0], points[i + 1][0]
v = (v - a) / (b - a)
if (a_ + 1 == b_) or (b_ == 0):
return v + points[i][0]
else:
return points[i][1] - v
if v < points[0][1]:
return points[0][0]
return points[-1][0]
wait_period = 5
'''
:float The number of seconds to wait before invoking `periodically` again
'''
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
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.
(*) Can be exceeded if the calendar system is changed, like in 1712-(02)Feb-30
(**) See https://en.wikipedia.org/wiki/Leap_second
'''
start_over()
alpha = 1 if fade is None else abs(fade)
timepoint = get_timepoint()
for adjustment in adjustments:
adjustment(timepoint, alpha)
r, g, b = r_curve[:], g_curve[:], b_curve[:]
for crtcs, screens, output_adjustments in monitors:
r_curve[:], g_curve[:], b_curve[:] = r, g, b
for adjustment in output_adjustments:
adjustment(timepoint, alpha)
for screen in screens:
set_method(*(crtcs[screen]), screen = screen)
def reset():
'''
Invoked to reset the displays
'''
for crtcs, screens, _ in monitors:
for screen in screens:
saved_ = saved[screen]
for crtc in crtcs[screen]:
start_over()
saved_[crtc]()
set_method(crtc, screen = screen)
