def allocate(self, desired_block_size=1):
desired_block_size = int(desired_block_size)
assert 0 < desired_block_size
block_id = None
with self._lock:
free_block = None
for block in self._free_heap:
if desired_block_size <= block.duration:
free_block = block
break
if free_block is not None:
split_offset = free_block.start_offset + desired_block_size
self._free_heap.remove(free_block)
if desired_block_size < free_block.duration:
new_free_block = utils.new(
free_block,
start_offset=split_offset,
used=False,
)
self._free_heap.insert(new_free_block)
used_block = utils.new(
free_block,
stop_offset=split_offset,
used=True,
)
else:
used_block = utils.new(
free_block,
used=True,
)
self._used_heap.insert(used_block)
block_id = used_block.start_offset
return block_id
def _render_datagram(self, session, input_file_path, output_file_path,
session_osc_file_path, **kwargs):
relative_session_osc_file_path = session_osc_file_path
if relative_session_osc_file_path.is_absolute():
relative_session_osc_file_path = session_osc_file_path.relative_to(
pathlib.Path.cwd())
self._report('Rendering {}.'.format(relative_session_osc_file_path))
if output_file_path.exists():
self._report(' Skipped {}. Output already exists.'.format(
relative_session_osc_file_path))
return 0
server_options = session._options
server_options = utils.new(server_options, **kwargs)
memory_size = server_options.memory_size
for factor in range(1, 4):
command = self._build_render_command(
input_file_path,
output_file_path,
session_osc_file_path,
server_options=server_options,
)
self._report(' Command: {}'.format(command))
exit_code = self._stream_subprocess(command, session.duration)
server_options = utils.new(
server_options,
memory_size=memory_size * (2**factor),
)
if exit_code == -6:
self._report(' Out of memory. Increasing to {}.'.format(
server_options.memory_size))
else:
self._report(' Rendered {} with exit code {}.'.format(
relative_session_osc_file_path, exit_code))
break
return exit_code
def _apply_iterator_recursively(self, expr, iterator):
import supriya.patterns
if isinstance(expr, supriya.patterns.CompositeEvent):
coerced_events = [
self._apply_iterator_recursively(child_event, iterator)
for child_event in expr.get('events') or ()
]
expr = utils.new(expr, events=coerced_events)
else:
expr = utils.new(expr, _iterator=iterator)
return expr
def __init__(
self,
source,
target,
source_range=None,
target_range=None,
clip_minimum=None,
clip_maximum=None,
exponent=None,
symmetric=None,
):
import supriya.synthdefs
# import supriya.system
# assert isinstance(source, supriya.system.Bindable), source
# assert isinstance(target, supriya.system.Bindable), target
# self.source = source
# self.target = target
self.source = self.patch(source)
self.target = self.patch(target)
if source_range is None:
if hasattr(self.source.func.__self__, "range_"):
source_range = self.source.func.__self__.range_
else:
source_range = (0.0, 1.0)
source_range = supriya.synthdefs.Range(source_range)
if source_range.minimum == float("-inf"):
source_range = utils.new(source_range, minimum=0.0)
if source_range.maximum == float("inf"):
source_range = utils.new(source_range, maximum=1.0)
self.source_range = supriya.synthdefs.Range(source_range)
if target_range is None:
if hasattr(self.target.func, "__self__") and hasattr(
self.target.func.__self__, "range_"):
target_range = self.target.func.__self__.range_
else:
target_range = (0.0, 1.0)
target_range = supriya.synthdefs.Range(target_range)
if target_range.minimum == float("-inf"):
target_range = utils.new(target_range, minimum=0.0)
if target_range.maximum == float("inf"):
target_range = utils.new(target_range, maximum=1.0)
self.target_range = supriya.synthdefs.Range(target_range)
self.clip_maximum = bool(clip_maximum)
self.clip_minimum = bool(clip_minimum)
if exponent is None:
exponent = 1.0
self.exponent = float(exponent)
self.symmetric = bool(symmetric)
self.source.outgoing_bindings.add(self)
self.target.incoming_bindings.add(self)
def _build_render_command(
self,
input_file_path,
output_file_path,
session_osc_file_path,
server_options=None,
):
cwd = pathlib.Path.cwd()
server_options = server_options or supriya.realtime.ServerOptions()
if os.environ.get("TRAVIS", None):
server_options = utils.new(server_options, load_synthdefs=True)
scsynth_path = "scsynth"
if not uqbar.io.find_executable(scsynth_path):
raise RuntimeError("Cannot find scsynth")
if session_osc_file_path.is_absolute():
session_osc_file_path = session_osc_file_path.relative_to(cwd)
parts = [scsynth_path, "-N", session_osc_file_path]
if input_file_path:
parts.append(input_file_path)
else:
parts.append("_")
if output_file_path.is_absolute() and cwd in output_file_path.parents:
output_file_path = output_file_path.relative_to(cwd)
parts.append(output_file_path)
parts.append(self.sample_rate)
parts.append(self.header_format.name.lower()) # Must be lowercase.
parts.append(self.sample_format.name.lower()) # Must be lowercase.
server_options = server_options.as_options_string(realtime=False)
if server_options:
parts.append(server_options)
command = " ".join(str(_) for _ in parts)
return command
def _coerce_iterator_output(self, expr, state=None):
import supriya.patterns
if not isinstance(expr, supriya.patterns.Event):
expr = supriya.patterns.NoteEvent(**expr)
if expr.get('uuid') is None:
expr = utils.new(expr, uuid=uuid.uuid4())
return expr
def _coerce_iterator_output(self, expr, state):
import supriya.patterns
expr = super(Pgroup, self)._coerce_iterator_output(expr)
if (isinstance(expr, supriya.patterns.NoteEvent)
or not expr.get('is_stop')):
kwargs = {}
if expr.get('target_node') is None:
kwargs['target_node'] = state['group_uuid']
expr = utils.new(expr, **kwargs)
return expr
def _iterate(self, state=None):
if self.key:
for _ in self._loop(self._repetitions):
for i, x in enumerate(self._pattern):
if i == 0:
x = utils.new(x, **{self.key: True})
yield x
else:
for _ in self._loop(self._repetitions):
yield from self._pattern
def _iterate(self, state=None):
synth_uuid = uuid.uuid4()
iterator = super(Pmono, self)._iterate(state=state)
events = []
try:
events.append(next(iterator))
except StopIteration:
return
for event in iterator:
events.append(event)
event = utils.new(events.pop(0), uuid=synth_uuid, is_stop=False)
should_stop = yield event
if should_stop:
return
assert len(events) == 1
if events:
event = events.pop()
event = utils.new(event, uuid=synth_uuid, is_stop=True)
yield event
def _coerce_iterator_output(self, expr, state):
import supriya.patterns
expr = super(Pgroup, self)._coerce_iterator_output(expr)
if isinstance(expr,
supriya.patterns.NoteEvent) or not expr.get("is_stop"):
kwargs = {}
if expr.get("target_node") is None:
kwargs["target_node"] = state["group_uuid"]
expr = utils.new(expr, **kwargs)
return expr
def _coerce_iterator_output_recursively(self, expr, state=None):
import supriya.patterns
if isinstance(expr, supriya.patterns.CompositeEvent):
coerced_events = [
self._coerce_iterator_output(child_event, state=state)
for child_event in expr.get('events') or ()
]
expr = utils.new(expr, events=coerced_events)
else:
expr = self._coerce_iterator_output(expr, state=state)
return expr
def _coerce_iterator_output(self, expr, state):
import supriya.patterns
iterator = expr.get("_iterator")
iterators_to_group_uuids = state["iterators_to_group_uuids"]
kwargs = {"_iterator": None}
if isinstance(expr,
supriya.patterns.NoteEvent) or not expr.get("is_stop"):
if expr.get("target_node") is None:
kwargs["target_node"] = iterators_to_group_uuids[iterator]
expr = utils.new(expr, **kwargs)
return expr
def _coerce_iterator_output(self, expr, state):
import supriya.patterns
iterator = expr.get('_iterator')
iterators_to_group_uuids = state['iterators_to_group_uuids']
kwargs = {'_iterator': None}
if (
isinstance(expr, supriya.patterns.NoteEvent) or
not expr.get('is_stop')
):
if expr.get('target_node') is None:
kwargs['target_node'] = iterators_to_group_uuids[iterator]
expr = utils.new(expr, **kwargs)
return expr
def boot(self, scsynth_path=None, server_options=None, **kwargs):
import supriya.realtime
if self.is_running:
return self
scsynth_path = scsynth_path or os.environ.get("SCSYNTH_PATH")
if not scsynth_path:
scsynth_path_candidates = uqbar.io.find_executable("scsynth")
if not scsynth_path_candidates:
raise RuntimeError("Cannot find scsynth")
scsynth_path = scsynth_path_candidates[0]
scsynth_path = pathlib.Path(scsynth_path).absolute()
if not scsynth_path.exists():
raise RuntimeError("{} does not exist".format(scsynth_path))
self._osc_io.boot(ip_address=self.ip_address, port=self.port)
self._setup_osc_callbacks()
server_options = server_options or supriya.realtime.ServerOptions()
assert isinstance(server_options, supriya.realtime.ServerOptions)
if kwargs:
server_options = utils.new(server_options, **kwargs)
options_string = server_options.as_options_string(self.port)
command = "{} {}".format(scsynth_path, options_string)
if self.debug_subprocess:
print("Boot:", command)
process = self._server_process = subprocess.Popen(
command,
shell=True,
stderr=subprocess.STDOUT,
stdout=subprocess.PIPE,
start_new_session=True,
)
try:
self._read_scsynth_boot_output()
except supriya.exceptions.ServerCannotBoot:
self._osc_io.quit()
try:
process_group = os.getpgid(process.pid)
os.killpg(process_group, signal.SIGINT)
process.terminate()
process.wait()
except ProcessLookupError:
pass
raise
self._is_running = True
self._server_options = server_options
self._setup()
PubSub.notify("server-booted")
return self
def __call__(self, execution_time, scheduled_time, communicate=True):
if self._iterator is None:
self._iterator = self._iterate_outer(
pattern=self._pattern,
server=self._server,
timestamp=scheduled_time,
uuids=self._uuids,
)
event_products, delta = next(self._iterator)
node_free_ids, requests = set(), []
for event_product in event_products:
if not event_product.event:
continue
for request in event_product.requests:
if isinstance(request, supriya.commands.NodeFreeRequest):
node_free_ids.update(request.node_ids)
else:
requests.append(request)
if event_product.is_stop:
proxies = self._uuids[event_product.uuid]
for proxy_id, proxy in proxies.items():
if isinstance(proxy, (
supriya.realtime.Bus,
supriya.realtime.BusGroup,
)):
allocator = supriya.realtime.Bus._get_allocator(
calculation_rate=proxy.calculation_rate,
server=self._server,
)
allocator.free(proxy_id)
self._uuids.pop(event_product.uuid)
if node_free_ids:
node_free_ids = sorted(node_free_ids)
request = supriya.commands.NodeFreeRequest(node_ids=node_free_ids)
requests.append(request)
consolidated_bundle = supriya.commands.RequestBundle(
timestamp=scheduled_time,
contents=requests,
)
if communicate:
osc_bundle = consolidated_bundle.to_osc_bundle()
osc_bundle = utils.new(
osc_bundle,
timestamp=osc_bundle.timestamp + self._server.latency,
)
self._server.send_message(osc_bundle)
return delta
return consolidated_bundle, delta
def _iterate(self, state=None):
patterns = [iter(_) for _ in self._patterns]
while True:
try:
event = next(patterns[0])
except StopIteration:
return
for pattern in patterns[1:]:
try:
template_event = next(pattern)
except StopIteration:
return
template_dict = template_event.as_dict()
for key, value in tuple(template_dict.items()):
if value is None:
template_dict.pop(key)
event = utils.new(event, **template_dict)
yield event
def _add_parameter(self, *args):
import supriya.synthdefs
if 3 < len(args):
raise ValueError(args)
if len(args) == 1:
assert isinstance(args[0], supriya.synthdefs.Parameter)
name, value, parameter_rate = \
args[0].name, args[0], args[0].parameter_rate
elif len(args) == 2:
name, value = args
if not isinstance(value, supriya.synthdefs.Parameter):
parameter_rate = supriya.synthdefs.ParameterRate.SCALAR
if name.startswith('a_'):
parameter_rate = supriya.synthdefs.ParameterRate.AUDIO
elif name.startswith('i_'):
parameter_rate = supriya.synthdefs.ParameterRate.SCALAR
elif name.startswith('t_'):
parameter_rate = supriya.synthdefs.ParameterRate.TRIGGER
else:
parameter_rate = supriya.synthdefs.ParameterRate.CONTROL
else:
parameter_rate = value.parameter_rate
elif len(args) == 3:
name, value, parameter_rate = args
parameter_rate = supriya.synthdefs.ParameterRate.from_expr(
parameter_rate, )
else:
raise ValueError(args)
if not isinstance(value, supriya.synthdefs.Parameter):
parameter = supriya.synthdefs.Parameter(
name=name,
parameter_rate=parameter_rate,
value=value,
)
else:
parameter = utils.new(
value,
parameter_rate=parameter_rate,
name=name,
)
assert parameter._uuid is None
parameter._uuid = self._uuid
self._parameters[name] = parameter
return parameter
def _coerce_iterator_output(self, expr, state):
import supriya.assets.synthdefs
import supriya.patterns
expr = super(Pbus, self)._coerce_iterator_output(expr)
if (isinstance(expr, supriya.patterns.NoteEvent)
or not expr.get('is_stop')):
kwargs = {}
if expr.get('target_node') is None:
kwargs['target_node'] = state['group_uuid']
prototype = (supriya.patterns.NoteEvent,
supriya.patterns.SynthEvent)
if isinstance(expr, prototype):
synthdef = expr.get(
'synthdef') or supriya.assets.synthdefs.default
parameter_names = synthdef.parameter_names
if expr.get('out') is None and 'out' in parameter_names:
kwargs['out'] = state['bus_uuid']
if expr.get('in_') is None and 'in_' in parameter_names:
kwargs['in_'] = state['bus_uuid']
expr = utils.new(expr, **kwargs)
return expr
def _iterate(self, state=None):
should_stop = self.PatternState.CONTINUE
event_iterator = iter(self._event_pattern)
key_iterators = self._coerce_pattern_pairs(self._patterns)
template_dict = {}
while True:
try:
if not should_stop:
expr = next(event_iterator)
else:
expr = event_iterator.send(True)
except StopIteration:
return
expr = self._coerce_iterator_output(expr)
for name, key_iterator in sorted(key_iterators.items()):
try:
template_dict[name] = next(key_iterator)
except StopIteration:
continue
expr = utils.new(expr, **template_dict)
should_stop = yield expr
def boot(
self,
server_options=None,
**kwargs
):
import supriya.realtime
if self.is_running:
return self
scsynth_path = 'scsynth'
if not uqbar.io.find_executable(scsynth_path):
raise RuntimeError('Cannot find scsynth')
self._osc_controller.boot()
server_options = server_options or supriya.realtime.ServerOptions()
assert isinstance(server_options, supriya.realtime.ServerOptions)
if kwargs:
server_options = utils.new(server_options, **kwargs)
options_string = server_options.as_options_string(self.port)
command = '{} {}'.format(scsynth_path, options_string)
if self.debug_subprocess:
print(command)
self._server_process = subprocess.Popen(
command,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
)
start_time = time.time()
while True:
line = self._server_process.stdout.readline().decode()
if line.startswith('SuperCollider 3 server ready'):
break
elif line.startswith('Exception in World_OpenUDP: bind: Address already in use'):
raise Exception
elif (time.time() - start_time) > 1:
raise Exception
self._is_running = True
self._server_options = server_options
self._setup()
PubSub.notify('server-booted')
return self
def _coerce_iterator_output(self, expr, state):
import supriya.assets.synthdefs
import supriya.patterns
expr = super(Pbus, self)._coerce_iterator_output(expr)
if isinstance(expr,
supriya.patterns.NoteEvent) or not expr.get("is_stop"):
kwargs = {}
if expr.get("target_node") is None:
kwargs["target_node"] = state["group_uuid"]
prototype = (supriya.patterns.NoteEvent,
supriya.patterns.SynthEvent)
if isinstance(expr, prototype):
synthdef = expr.get(
"synthdef") or supriya.assets.synthdefs.default
parameter_names = synthdef.parameter_names
if expr.get("out") is None and "out" in parameter_names:
kwargs["out"] = state["bus_uuid"]
if expr.get("in_") is None and "in_" in parameter_names:
kwargs["in_"] = state["bus_uuid"]
expr = utils.new(expr, **kwargs)
return expr
def _split(
self,
split_offset: float,
new_nodes=None,
split_occupiers: bool = True,
split_traversers: bool = True,
) -> List["Node"]:
import supriya.nonrealtime
new_nodes = new_nodes or []
state = self.session.states[split_offset]
entering, exiting, occupying, starting, _ = self.inspect_children()
children = state.nodes_to_children.get(self) or ()
start_offset, stop_offset = self.start_offset, self.stop_offset
if start_offset < split_offset < stop_offset:
old_actions = state.transitions
new_duration = stop_offset - split_offset
with supriya.nonrealtime.DoNotPropagate():
if isinstance(self, supriya.nonrealtime.Synth):
new_node = self.add_synth(
add_action="ADD_BEFORE",
duration=new_duration,
synthdef=self.synthdef,
**self._synth_kwargs,
)
else:
new_node = self.add_group(add_action="ADD_BEFORE",
duration=new_duration)
new_nodes.append(new_node)
new_actions: Dict["Node",
NodeTransition] = collections.OrderedDict()
for node in new_nodes:
if node is new_node and self in old_actions:
old_actions.pop(node)
action = old_actions.pop(self)
new_actions[node] = utils.new(action, source=new_node)
else:
new_actions[node] = old_actions.pop(node)
for child in reversed(children):
if child in old_actions:
old_actions.pop(child)
action = supriya.nonrealtime.NodeTransition(
source=child, target=new_node, action="ADD_TO_TAIL")
new_actions[child] = action
new_actions.update(old_actions)
state._transitions = new_actions
self._fixup_events(new_node, split_offset)
self._fixup_duration(split_offset - start_offset)
self._fixup_node_actions(new_node, split_offset, stop_offset)
self.session._apply_transitions(
[new_node.start_offset, new_node.stop_offset])
result = [self, new_node]
else:
return [self]
for child in children + exiting:
if ((split_occupiers and child in occupying)
or (split_traversers and child in entering)
or (split_traversers and child in exiting)):
child._split(
split_offset,
new_nodes=new_nodes,
split_occupiers=split_occupiers,
split_traversers=split_traversers,
)
return result
def _get_format_specification(self):
super_class = super(SupriyaValueObject, self)
format_specification = super_class._get_format_specification()
return utils.new(format_specification, repr_is_indented=False)
def _pre_process_event(self, event_tuple_a, event_tuple_b):
delta = float(event_tuple_b.offset - event_tuple_a.offset)
return utils.new(event_tuple_a.event, delta=delta)
def _coerce_iterator_output(self, expr, state):
expr = super(Ppar, self)._coerce_iterator_output(expr, state)
return utils.new(expr, _iterator=None)
def __copy__(self, *args):
return utils.new(self)
