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
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 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 _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_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 __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 _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