def _reconfigure():
try:
from echomesh.base import Settings
except:
_SETTINGS.settings_update(None)
else:
Settings.add_client(_SETTINGS)
def _reconfigure():
try:
from echomesh.base import Settings
except:
_SETTINGS.settings_update(None)
else:
Settings.add_client(_SETTINGS)
def __init__(self, instance, peers, settings_name):
super(PeerSocketBase, self).__init__()
self.instance = instance
self.peers = peers
self.settings_name = settings_name
self.add_slave(self.peers)
self.port = -1
self.socket = None
Settings.add_client(self)
def set_settings(_, *values):
if values:
assignment = Leafs.leafs(Settings.assign(values))
for address, value in six.iteritems(assignment):
LOGGER.info('Set %s=%s', '.'.join(address), value)
Settings.update_clients()
elif Settings.MERGE_SETTINGS.has_changes():
LOGGER.info(
Yaml.encode_one(dict(Settings.MERGE_SETTINGS.get_changes())))
else:
LOGGER.info('You have made no changes.')
def set_settings(_, *values):
if values:
assignment = Leafs.leafs(Settings.assign(values))
for address, value in six.iteritems(assignment):
LOGGER.info('Set %s=%s', '.'.join(address), value)
Settings.update_clients()
elif Settings.MERGE_SETTINGS.has_changes():
LOGGER.info(
Yaml.encode_one(dict(Settings.MERGE_SETTINGS.get_changes())))
else:
LOGGER.info('You have made no changes.')
def __init__(self, port, bind_port, hostname, socket_type):
super(Socket, self).__init__()
self.port = port
self.bind_port = bind_port
self.hostname = hostname
self.socket_type = socket_type
self.socket = None
self.buffer = ''
self.queue = queue.Queue()
self.max_size = MAX_SIZE
Settings.add_client(self)
def _on_run(self):
super(ScoreMaster, self)._on_run()
if self.startup:
self.startup = False
try:
self._load_elements(Settings.get('load'))
except:
LOGGER.error()
try:
self.start_elements(Settings.get('start'))
except:
LOGGER.error()
def _on_run(self):
super(ScoreMaster, self)._on_run()
if self.startup:
self.startup = False
try:
self._load_elements(Settings.get('load'))
except:
LOGGER.error()
try:
self.start_elements(Settings.get('start'))
except:
LOGGER.error()
def callback(self, data):
data = Yaml.decode_one(data)
event = data['event']
if event == 'start':
self.after_server_starts()
elif event == 'closeButtonPressed':
if Settings.get('execution', 'close_button_quits'):
Quit.request_quit()
elif Settings.get('execution', 'close_button_closes_window'):
Visualizer.set_visible(False)
else:
# print(data)
pass
def transfer(_, **data):
backup_directory = os.path.join(Path.data_path(), '.echomesh-xfer')
try:
shutil.rmtree(backup_directory)
except OSError:
pass
directories = data.get('directories', [])
if '' in directories:
directories = os.listdir(Path.data_path())
for directory in directories:
parent = os.path.dirname(os.path.join(backup_directory, directory))
MakeDirs.parent_makedirs(parent)
shutil.move(os.path.join(Path.data_path(), directory), parent)
for f, value in six.iteritems(data.get('files')):
fname = os.path.join(Path.data_path(), f)
MakeDirs.parent_makedirs(fname)
with open(fname, 'w') as o:
o.write(value['contents'])
os.utime(fname, (value['atime'], value['mtime']))
if Settings.get('execution', 'delete_backups_after_transfer'):
try:
shutil.rmtree(backup_directory)
except:
pass
def get(self, *path):
with self.lock:
value = self.clients.get(path)
if not value:
value = Expression.convert(Settings.get(*path))
self.clients[path] = value
return value
def get(self, *path):
with self.lock:
value = self.clients.get(path)
if not value:
value = Expression.convert(Settings.get(*path))
self.clients[path] = value
return value
def save(_, *values):
if values:
SetSettings.set_settings(_, *values)
files = Settings.save(False)
if files:
LOGGER.info('Settings saved to %s.', Join.join_file_names(files))
else:
LOGGER.error('There are no settings changes to save.')
def display(callback):
use_pi3d = Settings.get('pi3d', 'enable')
if use_pi3d:
from echomesh.graphics.Pi3dDisplay import Pi3dDisplay
return Pi3dDisplay()
else:
from echomesh.graphics.CDisplay import CDisplay
return CDisplay(callback)
def display(callback):
use_pi3d = Settings.get('pi3d', 'enable')
if use_pi3d:
from echomesh.graphics.Pi3dDisplay import Pi3dDisplay
return Pi3dDisplay()
else:
from echomesh.graphics.CDisplay import CDisplay
return CDisplay(callback)
def __init__(self, count=None, order='rgb', device=DEFAULT_SPI_DEVICE,
gamma=DEFAULT_GAMMA, period=None, **description):
self.enabled = SetupDebianSpiLights.lights_enabled()
if not self.enabled:
LOGGER.info('SPI running in emulation mode.')
self.gamma = gamma
self.order = cechomesh.get_spi_order(order)
self.period = period
self.period_set = period is not None
self.count_set = count is not None
if self.count_set:
self._set_count(count)
Settings.add_client(self)
if self.enabled:
self._device = open(device, 'wb')
super(Spi, self).__init__(
is_redirect=False, period=self.period, **description)
def __init__(self, parent, description):
super(Audio, self).__init__(parent, description)
if Settings.get('audio', 'output', 'enable'):
try:
self.add_mutual_pause_slave(CPlayer(self, **description))
except:
LOGGER.error()
else:
LOGGER.info('Audio disabled for %s', description.get('file', None))
description.clear_accessed()
def __init__(self, parent, description):
super(Audio, self).__init__(parent, description)
if Settings.get('audio', 'output', 'enable'):
try:
self.add_mutual_pause_slave(CPlayer(self, **description))
except:
LOGGER.error()
else:
LOGGER.info('Audio disabled for %s', description.get('file', None))
description.clear_accessed()
def _evaluate(self):
color_list = cechomesh.to_color_list(self.patterns()[0])
columns = (color_list.columns or
Settings.get('light', 'visualizer', 'layout')[0])
result = cechomesh.scroll_color_list(
color_list, self.get('dx'), self.get('dy'), columns=columns,
wrap=self.get('wrap'), smooth=self.get('smooth'),
transform=self.get('transform'))
return result
def __init__(self):
super(Instance, self).__init__()
def do_quit():
pause_outputs()
self.pause()
self.unload()
Quit.register_atexit(do_quit)
gpio = Settings.get('hardware', 'gpio')
if gpio['enable']:
GPIO.on_gpio(Quit.request_quit,
gpio['shutdown_pin'],
gpio['shutdown_pin_pull_up'],
gpio['shutdown_pin_bounce_time'])
CLog.initialize()
self.score_master = ScoreMaster.ScoreMaster()
self.peers = Peers.Peers(self)
self.socket = PeerSocket.PeerSocket(self, self.peers)
self.display = Display.display(self.callback)
self.keyboard_runnable = self.osc = None
if Settings.get('execution', 'control_program'):
from echomesh.util.thread import Keyboard
args = {}
keyboard, self.keyboard_runnable = Keyboard.keyboard(
self, new_thread=USE_KEYBOARD_THREAD or self.display)
osc_client = Settings.get('osc', 'client', 'enable')
osc_server = Settings.get('osc', 'server', 'enable')
if osc_client or osc_server:
from echomesh.sound.Osc import Osc
self.osc = Osc(osc_client, osc_server)
self.add_mutual_pause_slave(
self.socket, self.keyboard_runnable, self.osc)
self.add_slave(self.score_master)
self.add_slave(self.display)
self.set_broadcasting(False)
self.timeout = Settings.get('network', 'timeout')
def __init__(self, parent, description):
super(Image, self).__init__(parent, description)
if Settings.get('pi3d', 'enable'):
try:
self.sprite = ImageSprite(self, **description)
except:
LOGGER.error("Couldn't open image file")
else:
self.add_slave(self.sprite)
else:
LOGGER.info('Playing image %s', description.get('file', '(none)'))
description.clear_accessed()
def after_server_starts(self):
if cechomesh.LOADED:
run_after(self.run,
Expression.convert(Settings.get('execution',
'delay_before_run')))
else:
self.run()
if self.display:
self.display_loop()
elif not USE_KEYBOARD_THREAD and self.keyboard_runnable:
self.keyboard_runnable.loop()
else:
while self.is_running:
time.sleep(self.timeout)
def get_settings(_, *items):
failures = []
if items:
successes = []
for i in items:
parts = i.split('.')
try:
value = Settings.get(*parts)
except:
failures.append(i)
else:
successes.append([i, value])
else:
assignments = Settings.assignments().items()
successes = [('.'.join(s), v) for s, v in assignments]
if successes or failures:
for value, result in successes:
LOGGER.info('%s=%s', value, result)
if failures:
LOGGER.error('Didn\'t understand %s', Join.join_words(failures))
LOGGER.info('')
else:
LOGGER.info('No settings variables have been set.\n')
def __init__(self,
count=None,
order='rgb',
device=DEFAULT_SPI_DEVICE,
gamma=DEFAULT_GAMMA,
period=None,
**description):
self.enabled = SetupDebianSpiLights.lights_enabled()
if not self.enabled:
LOGGER.info('SPI running in emulation mode.')
self.gamma = gamma
self.order = cechomesh.get_spi_order(order)
self.period = period
self.period_set = period is not None
self.count_set = count is not None
if self.count_set:
self._set_count(count)
Settings.add_client(self)
if self.enabled:
self._device = open(device, 'wb')
super(Spi, self).__init__(is_redirect=False,
period=self.period,
**description)
def get_settings(_, *items):
failures = []
if items:
successes = []
for i in items:
parts = i.split('.')
try:
value = Settings.get(*parts)
except:
failures.append(i)
else:
successes.append([i, value])
else:
assignments = Settings.assignments().items()
successes = [('.'.join(s), v) for s, v in assignments]
if successes or failures:
for value, result in successes:
LOGGER.info('%s=%s', value, result)
if failures:
LOGGER.error('Didn\'t understand %s', Join.join_words(failures))
LOGGER.info('')
else:
LOGGER.info('No settings variables have been set.\n')
def _evaluate(self):
color_list = cechomesh.to_color_list(self.patterns()[0])
columns = (color_list.columns or
Settings.get('light', 'visualizer', 'layout')[0])
result = cechomesh.scroll_color_list(
color_list, self.get('dx'), self.get('dy'), columns=columns,
wrap=self.get('wrap'), smooth=self.get('smooth'),
transform=self.get('transform'))
global LAST_LIST
if False and result != LAST_LIST:
LAST_LIST = result
print(result, color_list)
return result
def _settings(_, *names):
settings = Settings.get_settings()
names = set(names)
keys = set(settings.keys())
if 'all' in names:
names = keys
bad = names - set(settings.keys())
if bad:
LOGGER.error("Don't understand settings %s.", join_words(bad))
names -= bad
if names:
_format(dict((k, v) for k, v in settings.items() if k in names))
else:
LOGGER.info(' Possible settings are:\n ' +
join_words(settings.keys()))
def _evaluate(self):
color_lists = self.patterns()
assert len(color_lists) == 1
color_list = color_lists[0]
columns = self.get('columns') or getattr(color_list, 'columns', 0)
rows = self.get('rows')
if rows:
columns = columns or cechomesh.compute_rows(len(color_list), rows)
elif columns:
rows = cechomesh.compute_rows(len(color_list), columns)
else:
columns, rows = Settings.get('light', 'visualizer', 'layout')
return cechomesh.mirror_color_list(color_list, int(columns), int(rows),
bool(self.get('reverse_x')),
bool(self.get('reverse_y')))
def keyboard(instance, writer=sys.stdout, reader=sys.stdin.readline,
new_thread=True):
def processor(line):
try:
return Command.execute(instance, line)
except:
LOGGER.error('Error processing command line.')
sleep = Expression.convert(Settings.get('execution',
'delay_before_keyboard_activates'))
keyboard = Keyboard(sleep=sleep, message=MESSAGE, processor=processor,
writer=writer, reader=reader)
if new_thread:
runnable = ThreadRunnable(target=keyboard.loop)
runnable.add_mutual_pause_slave(keyboard)
return keyboard, runnable
else:
return keyboard, keyboard
def _evaluate(self):
color_lists = self.patterns()
assert len(color_lists) == 1
color_list = color_lists[0]
columns = self.get('columns') or getattr(color_list, 'columns', 0)
rows = self.get('rows')
if rows:
columns = columns or cechomesh.compute_rows(len(color_list), rows)
elif columns:
rows = cechomesh.compute_rows(len(color_list), columns)
else:
columns, rows = Settings.get('light', 'visualizer', 'layout')
return cechomesh.mirror_color_list(
color_list, int(columns), int(rows),
bool(self.get('reverse_x')), bool(self.get('reverse_y')))
def __init__(self):
super(Pi3dDisplay, self).__init__()
self.timeout = Expression.convert(Settings.get('network', 'timeout'))
keywords = {}
background = Settings.get('pi3d', 'background')
if background:
keywords.update(background=background)
dimensions = Settings.get('pi3d', 'dimensions')
if dimensions:
x, y, width, height = dimensions
keywords.update(x=x, y=y, width=width, height=height)
for k in ['aspect', 'depth', 'far', 'near', 'tk', 'window_title']:
keywords[k] = Settings.get('pi3d', k)
from pi3d import Display
self.display = Display.create(**keywords)
Settings.add_client(self)
Shader.SHADER()
def __init__(self):
super(Pi3dDisplay, self).__init__()
self.timeout = Expression.convert(Settings.get('network', 'timeout'))
keywords = {}
background = Settings.get('pi3d', 'background')
if background:
keywords.update(background=background)
dimensions = Settings.get('pi3d', 'dimensions')
if dimensions:
x, y, width, height = dimensions
keywords.update(x=x, y=y, width=width, height=height)
for k in ['aspect', 'depth', 'far', 'near', 'tk', 'window_title']:
keywords[k] = Settings.get('pi3d', k)
from pi3d import Display
self.display = Display.create(**keywords)
Settings.add_client(self)
Shader.SHADER()
def _route_items(items, successes, failures):
for v in items:
try:
successes.append([v, Settings.get(*v.split('.'))])
except:
failures.append(v)
def _main():
import sys
times = []
def p(msg=''):
"""Print progress messages while echomesh loads."""
print(msg, end='\n' if msg else '')
global COUNT
dot = str(COUNT % 10) if USE_DIGITS_FOR_PROGRESS_BAR else '.'
print(dot, end='')
COUNT += 1
sys.stdout.flush()
import time
times.append(time.time())
p('Loading echomesh ')
from echomesh.base import Version
if Version.TOO_NEW:
print(Version.ERROR)
from echomesh.base import Path
if not Path.project_path():
return
p()
Path.fix_home_directory_environment_variable()
p()
Path.fix_sys_path()
p()
from echomesh.base import Settings
p()
Settings.read_settings(sys.argv[1:])
p()
if Settings.get('execution', 'autostart') and not Settings.get(
'permission', 'autostart'):
print()
from echomesh.util import Log
Log.logger(__name__).info('No permission to autostart')
return
p()
from echomesh.base import Quit
p()
Quit.register_atexit(Settings.save)
p()
from echomesh.Instance import Instance
p()
instance = Instance()
print()
p()
if Settings.get('diagnostics', 'startup_times'):
print()
for i in range(len(times) - 1):
print(i, ':', int(1000 * (times[i + 1] - times[i])))
print()
instance.main()
def input_level_maker():
return cechomesh.AudioLoudness(
name=Settings.get('audio', 'input', 'device_name'),
channels=Settings.get('audio', 'input', 'channels'),
chunk_size=Settings.get('audio', 'input', 'chunk_size'),
sample_rate=Settings.get('audio', 'input', 'sample_rate')).loudness
def f(echomesh_instance, **_):
name = function.__name__.strip('_')
if Settings.get('permission', name):
function(echomesh_instance)
else:
LOGGER.error("You don't have permission to run '%s'.", name)
def __init__(self, *sockets):
super(SelectLoop, self).__init__(name='SelectLoop')
self.sockets = dict((s.socket, s) for s in sockets)
Settings.add_client(self)
def f(echomesh_instance, **_):
name = function.__name__.strip('_')
if Settings.get('permission', name):
function(echomesh_instance)
else:
LOGGER.error("You don't have permission to run '%s'.", name)
def _main():
import sys
times = []
def p(msg=''):
"""Print progress messages while echomesh loads."""
print(msg, end='\n' if msg else '')
global COUNT
dot = str(COUNT % 10) if USE_DIGITS_FOR_PROGRESS_BAR else '.'
print(dot, end='')
COUNT += 1
sys.stdout.flush()
import time
times.append(time.time())
p('Loading echomesh ')
from echomesh.base import Version
if Version.TOO_NEW:
print(Version.ERROR)
from echomesh.base import Path
if not Path.project_path():
return
p()
Path.fix_home_directory_environment_variable()
p()
Path.fix_sys_path()
p()
from echomesh.base import Settings
p()
Settings.read_settings(sys.argv[1:])
p()
if Settings.get('execution', 'autostart') and not Settings.get(
'permission', 'autostart'):
print()
from echomesh.util import Log
Log.logger(__name__).info('No permission to autostart')
return
p()
from echomesh.base import Quit
p()
Quit.register_atexit(Settings.save)
p()
from echomesh.Instance import Instance
p()
instance = Instance()
print()
p()
if Settings.get('diagnostics', 'startup_times'):
print()
for i in range(len(times) - 1):
print(i, ':', int(1000 * (times[i + 1] - times[i])))
print()
instance.main()
def _on_run(self):
super(OscClient, self)._on_run()
self.client = None
self.port = None
self.host = None
Settings.add_client(self)
def settings_update(self, get):
with self.lock:
for path in self.clients.keys():
self.clients[path] = Expression.convert(Settings.get(*path))
def _on_pause(self):
Settings.remove_client(self)
super(OscClient, self)._on_pause()
self.client.close()
self.client = None
def __init__(self):
self.clients = {}
self.lock = Lock.Lock()
Settings.add_client(self)
def lights_enabled(prompt_to_fix=False):
global _LIGHTS_ENABLED
if _LIGHTS_ENABLED is None:
_LIGHTS_ENABLED = (Settings.get('light', 'enable')
and _test_spi(prompt_to_fix)) or False
return _LIGHTS_ENABLED
def __init__(self):
super(OscServer, self).__init__()
self.server = None
self.port = None
Settings.add_client(self)
def _allowed(operation):
return Settings.get('permission', operation)
def __init__(self):
Settings.add_client(self)
def initialize():
cechomesh.LOADED and cechomesh.init_log()
Settings.add_client(_Redirector())
def _allowed(operation):
return Settings.get('permission', operation)
def _route_items(items, successes, failures):
for v in items:
try:
successes.append([v, Settings.get(*v.split('.'))])
except:
failures.append(v)
def __init__(self):
super(OscServer, self).__init__()
self.server = None
self.port = None
Settings.add_client(self)
def __init__(self, *sockets):
super(SelectLoop, self).__init__(name='SelectLoop')
self.sockets = dict((s.socket, s) for s in sockets)
Settings.add_client(self)
