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 = new(free_block,
start_offset=split_offset,
used=False)
self._free_heap.add(new_free_block)
used_block = new(free_block,
stop_offset=split_offset,
used=True)
else:
used_block = new(free_block, used=True)
self._used_heap.add(used_block)
block_id = used_block.start_offset
if block_id is None:
return block_id
return int(block_id)
def split(self, *offsets):
"""
Split at ``offsets``:
::
>>> from supriya.intervals import Interval
>>> interval = Interval(0, 10)
>>> for split_interval in interval.split(1, 3, 7):
... split_interval
...
Interval(start_offset=0.0, stop_offset=1.0)
Interval(start_offset=1.0, stop_offset=3.0)
Interval(start_offset=3.0, stop_offset=7.0)
Interval(start_offset=7.0, stop_offset=10.0)
"""
from .IntervalTree import IntervalTree
split_offsets = sorted(
float(offset) for offset in offsets
if self._start_offset < offset < self._stop_offset)
result = IntervalTree()
right_interval = self
for offset in split_offsets:
left_interval = new(right_interval, stop_offset=offset)
right_interval = new(right_interval, start_offset=offset)
result.add(left_interval)
result.add(right_interval)
return result
def _render_datagram(
self,
session,
input_file_path,
output_file_path,
session_osc_file_path,
scsynth_path=None,
**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 = new(server_options, **kwargs)
memory_size = server_options.memory_size
for factor in range(1, 6):
command = self._build_render_command(
input_file_path,
output_file_path,
session_osc_file_path,
scsynth_path=scsynth_path,
server_options=server_options,
)
self._report(" Command: {}".format(command))
try:
exit_code = self._stream_subprocess(command, session.duration)
except KeyboardInterrupt:
if output_file_path.exists():
output_file_path.unlink()
raise
server_options = 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 _render_datagram(
self,
session,
input_file_path,
output_file_path,
session_osc_file_path,
scsynth_path=None,
**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 = new(server_options, **kwargs)
memory_size = server_options.memory_size
for factor in range(1, 6):
command = self._build_render_command(
input_file_path,
output_file_path,
session_osc_file_path,
scsynth_path=scsynth_path,
server_options=server_options,
)
self._report(" Command: {}".format(command))
try:
exit_code = self._stream_subprocess(command, session.duration)
except KeyboardInterrupt:
if output_file_path.exists():
output_file_path.unlink()
raise
server_options = 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 = new(expr, events=coerced_events)
else:
expr = 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 = new(source_range, minimum=0.0)
if source_range.maximum == float("inf"):
source_range = 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 = new(target_range, minimum=0.0)
if target_range.maximum == float("inf"):
target_range = 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 __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 = new(source_range, minimum=0.0)
if source_range.maximum == float("inf"):
source_range = 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 = new(target_range, minimum=0.0)
if target_range.maximum == float("inf"):
target_range = 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,
*,
scsynth_path=None,
server_options=None,
):
cwd = pathlib.Path.cwd()
scsynth_path = supriya.realtime.BootOptions.find_scsynth(scsynth_path)
server_options = server_options or supriya.realtime.BootOptions()
if os.environ.get("TRAVIS", None):
server_options = new(server_options, load_synthdefs=True)
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 _build_render_command(
self,
input_file_path,
output_file_path,
session_osc_file_path,
*,
scsynth_path=None,
server_options=None,
):
cwd = pathlib.Path.cwd()
scsynth_path = supriya.realtime.BootOptions.find_scsynth(scsynth_path)
server_options = server_options or supriya.realtime.BootOptions()
if os.environ.get("TRAVIS", None):
server_options = new(server_options, load_synthdefs=True)
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
async def boot(self,
port=DEFAULT_PORT,
*,
scsynth_path=None,
options=None,
**kwargs):
if self._is_running:
raise supriya.exceptions.ServerOnline
port = port or DEFAULT_PORT
loop = asyncio.get_running_loop()
self._boot_future = loop.create_future()
self._quit_future = loop.create_future()
self._options = new(options or Options(), **kwargs)
scsynth_path = scsynth.find(scsynth_path)
self._process_protocol = AsyncProcessProtocol()
await self._process_protocol.boot(self._options, scsynth_path, port)
if not await self._process_protocol.boot_future:
self._boot_future.set_result(False)
self._quit_future.set_result(True)
raise supriya.exceptions.ServerCannotBoot
self._ip_address = "127.0.0.1"
self._is_owner = True
self._port = port
await self._connect()
return self
def new(self, start_offset=None, stop_offset=None, **kwargs):
"""
Template a new interval:
::
>>> from supriya.intervals import Interval
>>> interval_one = Interval(0, 10)
>>> interval_two = interval_one.new()
>>> interval_two
Interval(start_offset=0.0, stop_offset=10.0)
>>> interval_two is not interval_one
True
::
>>> interval_two.new(start_offset=5.0)
Interval(start_offset=5.0, stop_offset=10.0)
"""
if start_offset is not None:
kwargs["start_offset"] = start_offset
if stop_offset is not None:
kwargs["stop_offset"] = stop_offset
return new(self, **kwargs)
async def __aexit__(self, *args):
results = self._exit()
if not results:
return
timestamp, request_bundle, synthdefs = results
server = self.provider.server
# The underlying asyncio UDP transport will silently drop oversize packets
if len(request_bundle.to_datagram()) <= 8192:
if self.wait:
# If waiting, the original ProviderMoment timestamp can be ignored
await request_bundle.communicate_async(server=server,
sync=True)
else:
server.send(request_bundle.to_osc())
else:
# If over the UDP packet limit, partition the message
requests = request_bundle.contents
# Always wait for SynthDefs to load.
if synthdefs:
synthdef_request = requests[0]
requests = synthdef_request.callback.contents or []
synthdef_request = new(synthdef_request, callback=None)
await synthdef_request.communicate_async(sync=True,
server=server)
if self.wait:
# If waiting, the original ProviderMoment timestamp can be ignored
for bundle in commands.RequestBundle.partition(requests):
await bundle.communicate_async(server=server, sync=True)
else:
for bundle in commands.RequestBundle.partition(
requests, timestamp=timestamp):
server.send(bundle.to_osc())
async def boot(
self,
*,
ip_address: str = DEFAULT_IP_ADDRESS,
port: int = DEFAULT_PORT,
scsynth_path: Optional[str] = None,
options: Optional[Options] = None,
**kwargs,
) -> "AsyncServer":
if self._is_running:
raise supriya.exceptions.ServerOnline
port = port or DEFAULT_PORT
loop = asyncio.get_running_loop()
self._boot_future = loop.create_future()
self._quit_future = loop.create_future()
self._options = new(options or Options(), **kwargs)
scsynth_path = find(scsynth_path)
self._process_protocol = AsyncProcessProtocol()
await self._process_protocol.boot(self._options, scsynth_path, port)
if not await self._process_protocol.boot_future:
self._boot_future.set_result(False)
self._quit_future.set_result(True)
raise supriya.exceptions.ServerCannotBoot
self._ip_address = ip_address
self._is_owner = True
self._port = port
await self._connect()
return self
def _allocate(self, paused_nodes, requests, server, synthdefs):
import supriya.commands
if paused_nodes:
requests.append(
supriya.commands.NodeRunRequest(
node_id_run_flag_pairs=[(node, False)
for node in paused_nodes]))
if not requests:
return self
elif 1 < len(requests):
request = supriya.commands.RequestBundle(contents=requests)
else:
request = requests[0]
requests[:] = [request]
if synthdefs:
synthdef_request = supriya.commands.SynthDefReceiveRequest(
synthdefs=synthdefs, callback=requests[0])
if len(synthdef_request.to_datagram(
with_placeholders=True)) > 8192:
directory_path = pathlib.Path(tempfile.mkdtemp())
synthdef_request = supriya.commands.SynthDefLoadDirectoryRequest(
directory_path=directory_path, callback=requests[0])
for synthdef in synthdefs:
file_name = "{}.scsyndef".format(synthdef.anonymous_name)
synthdef_path = directory_path / file_name
synthdef_path.write_bytes(synthdef.compile())
requests[:] = [synthdef_request]
if len(requests[0].to_datagram(with_placeholders=True)) > 8192:
node_allocate_request = requests[0].callback
synthdef_request = new(requests[0], callback=None)
requests[:] = [node_allocate_request, synthdef_request]
for request in requests:
request.communicate(server=server, sync=True)
return self
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 = new(expr, uuid=uuid.uuid4())
return expr
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 = new(expr, uuid=uuid.uuid4())
return expr
def boot(self, scsynth_path=None, options=None, **kwargs):
if self.is_running:
return self
self._options = new(options or BootOptions(), **kwargs)
scsynth_path = BootOptions.find_scsynth(scsynth_path)
self._server_process = self._options.boot(scsynth_path, self.port)
self._is_owner = True
self._connect()
PubSub.notify("server-booted")
return self
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 = 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 = new(x, **{self.key: True})
yield x
else:
for _ in self._loop(self._repetitions):
yield from self._pattern
def boot(self, scsynth_path=None, options=None, **kwargs):
if self.is_running:
return self
self._options = new(options or BootOptions(), **kwargs)
scsynth_path = BootOptions.find_scsynth(scsynth_path)
self._server_process = self._options.boot(scsynth_path, self.port)
self._is_owner = True
self._connect()
PubSub.notify("server-booted")
return self
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 = 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 = 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 = 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 = 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 = new(expr, **kwargs)
return expr
def sanitize_event(event, cache):
if isinstance(event, CompositeEvent):
return new(event,
events=[sanitize_event(x, cache) for x in event.events])
sanitize_data = {}
args, _, kwargs = get_vars(event)
for key, value in args.items():
if isinstance(value, UUID):
value = sanitize_id(value, cache)
sanitize_data[key] = value
for key, value in sorted(kwargs.items()):
if isinstance(value, UUID):
value = sanitize_id(value, cache)
sanitize_data[key] = value
return type(event)(**sanitize_data)
def __call__(self,
current_moment,
desired_moment,
*args,
communicate=True):
if self._iterator is None:
self._iterator = self._iterate_outer(
pattern=self._pattern,
server=self._server,
timestamp=desired_moment.seconds,
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=desired_moment.seconds, contents=requests)
if communicate:
osc_bundle = consolidated_bundle.to_osc()
osc_bundle = new(osc_bundle,
timestamp=osc_bundle.timestamp +
self._server.latency)
self._server.send(osc_bundle)
return delta
return consolidated_bundle, delta
def _iterate(self, state=None):
event_iterator = iter(self._pattern)
iterator_pairs = sorted(self._prepare_patterns().items())
while True:
try:
event = next(event_iterator)
except StopIteration:
return
template_dict = {}
for key, key_iterator in iterator_pairs:
try:
template_dict[key] = next(key_iterator)
except StopIteration:
return
event = new(event, **template_dict)
if (yield event):
return
def boot(self,
port=DEFAULT_PORT,
*,
scsynth_path=None,
options=None,
**kwargs):
if self.is_running:
raise supriya.exceptions.ServerOnline
port = port or DEFAULT_PORT
self._options = new(options or Options(), **kwargs)
scsynth_path = scsynth.find(scsynth_path)
self._process_protocol = SyncProcessProtocol()
self._process_protocol.boot(self._options, scsynth_path, port)
self._ip_address = "127.0.0.1"
self._is_owner = True
self._port = port
self._connect()
return self
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 = new(event, **template_dict)
yield event
def __exit__(self, *args):
results = self._exit()
if not results:
return
timestamp, request_bundle, synthdefs = results
try:
self.provider.server.send(request_bundle.to_osc())
except OSError:
requests = request_bundle.contents
if synthdefs:
synthdef_request = requests[0]
requests = synthdef_request.callback.contents or []
synthdef_request = new(synthdef_request, callback=None)
synthdef_request.communicate(sync=True,
server=self.provider.server)
for bundle in commands.RequestBundle.partition(
requests, timestamp=timestamp):
self.provider.server.send(bundle.to_osc())
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 = new(event, **template_dict)
yield event
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()
osc_bundle = new(
osc_bundle, timestamp=osc_bundle.timestamp + self._server.latency
)
self._server.send_message(osc_bundle)
return delta
return consolidated_bundle, delta
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 = 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 = new(expr, **template_dict)
should_stop = yield expr
def boot(
self,
*,
ip_address: str = DEFAULT_IP_ADDRESS,
port: int = DEFAULT_PORT,
scsynth_path: Optional[str] = None,
options: Optional[Options] = None,
**kwargs,
) -> "Server":
if self.is_running:
raise supriya.exceptions.ServerOnline
port = port or DEFAULT_PORT
self._options = new(options or Options(), **kwargs)
scsynth_path = find(scsynth_path)
self._process_protocol = SyncProcessProtocol()
self._process_protocol.boot(self._options, scsynth_path, port)
self._ip_address = ip_address
self._is_owner = True
self._port = port
self._connect()
return self
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 = new(expr, **template_dict)
should_stop = yield expr
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 = new(expr, **kwargs)
return expr
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.ParameterRate.SCALAR
if name.startswith("a_"):
parameter_rate = supriya.ParameterRate.AUDIO
elif name.startswith("i_"):
parameter_rate = supriya.ParameterRate.SCALAR
elif name.startswith("t_"):
parameter_rate = supriya.ParameterRate.TRIGGER
else:
parameter_rate = supriya.ParameterRate.CONTROL
else:
parameter_rate = value.parameter_rate
elif len(args) == 3:
name, value, parameter_rate = args
parameter_rate = supriya.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 = new(value, parameter_rate=parameter_rate, name=name)
assert parameter._uuid is None
parameter._uuid = self._uuid
self._parameters[name] = parameter
return parameter
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.ParameterRate.SCALAR
if name.startswith("a_"):
parameter_rate = supriya.ParameterRate.AUDIO
elif name.startswith("i_"):
parameter_rate = supriya.ParameterRate.SCALAR
elif name.startswith("t_"):
parameter_rate = supriya.ParameterRate.TRIGGER
else:
parameter_rate = supriya.ParameterRate.CONTROL
else:
parameter_rate = value.parameter_rate
elif len(args) == 3:
name, value, parameter_rate = args
parameter_rate = supriya.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 = new(value, parameter_rate=parameter_rate, name=name)
assert parameter._uuid is None
parameter._uuid = self._uuid
self._parameters[name] = parameter
return parameter
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] = 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 _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] = 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 new(format_specification, repr_is_indented=False)
def _coerce_iterator_output(self, expr, state):
expr = super(Ppar, self)._coerce_iterator_output(expr, state)
return new(expr, _iterator=None)
def _pre_process_event(self, event_tuple_a, event_tuple_b):
delta = float(event_tuple_b.offset - event_tuple_a.offset)
return new(event_tuple_a.event, delta=delta)
def merge(self, event):
_, _, kwargs = get_vars(event)
return new(self, **kwargs)
def _linearize(self):
if hasattr(self, 'callback') and self.callback:
yield new(self, callback=None)
yield from self.callback._linearize()
else:
yield self
