quasimoto.sampler package

quasimoto.sampler package#

Submodules#

quasimoto.sampler.channel module#

A module implementing a signal channel.

class quasimoto.sampler.channel.SignalChannel(time_keeper: TimeKeeper, params: SourceParameters = (None, None, 261.62556800000067, 1.0, WaveShape.SINE, True))[source]#

Bases: SourceInterface

A signal channel that allows an arbitrary number of sources to contribute to it.

register_dynamic(name: str, factory: type[SourceInterface] | str, data: dict[str, Any] = None) → SignalOperationResult[source]#: Register a dynamic source.

register_factory(source: type[SourceInterface]) → SignalOperationResult[source]#: Attempt to register a source type.

register_source(name: str, source: SourceInterface) → SignalOperationResult[source]#: Attempt to register a signal source.

remove_source(name: str) → SignalOperationResult[source]#: Attempt to register a signal source.

value(now: float) → int[source]#: Get the next value.

class quasimoto.sampler.channel.SignalOperationResult(status: bool, message: str = '')[source]#

Bases: NamedTuple

A container for information about results of signal operations.

message: str#: Alias for field number 1

status: bool#: Alias for field number 0

quasimoto.sampler.frequency module#

A module implementing a simple frequency interface class.

class quasimoto.sampler.frequency.HasFrequencyMixin(frequency: float = 261.62556800000067, shape: WaveShape | int | str = WaveShape.SINE)[source]#

Bases: object

A simple mixin class for classes that have some frequency component.

harmonic(index: int) → float[source]#: Get a harmonic frequency based on this instance’s frequency.

next_shape() → None[source]#: Increment to the next shape.

period() → float[source]#: Obtain the period for this frequency.

quantize_to_period(time: float) → float[source]#: Return time extended to the next start-of-period.

sawtooth(now: float) → float[source]#: Get a raw sawtooth-wave value sample.

sin(now: float) → float[source]#: Get a raw sin-wave value sample.

square(now: float) → float[source]#: Get a raw square-wave value sample.

triangle(now: float) → float[source]#: Get a raw triangle-wave value sample.

quasimoto.sampler.frequency.proportion_pool(step: float, *instances: HasFrequencyMixin) → None[source]#: Handle updating instance proportions.

quasimoto.sampler.notes module#

A module implementing an interface to musical notes.

class quasimoto.sampler.notes.Note(*values)[source]#

Bases: RuntimeIntEnum

An enumeration interface for notes.

A = 9#

AB = 8#

AS = 10#

B = 11#

BB = 10#

C = 0#

CS = 1#

D = 2#

DB = 1#

DS = 3#

E = 4#

EB = 3#

F = 5#

FS = 6#

G = 7#

GB = 6#

GS = 8#

frequency(octave_offset: int = 0) → float[source]#: Get the frequency of a note.

static from_index(index: int) → tuple[Note, int][source]#: Get a note from a specified index.

quasimoto.sampler.notes.note_by_index(index: int) → float[source]#: Get the frequency of a note based on its index from the root (lowest) frequency.

quasimoto.sampler.parameters module#

A module implementing a sampler-creation-parameter interface.

class quasimoto.sampler.parameters.SourceParameters(stop_time: float | None = None, duration: float | None = None, frequency: float = 261.62556800000067, amplitude: float = 1.0, shape: WaveShape = WaveShape.SINE, enabled: bool = True)[source]#

Bases: NamedTuple

A container for parameters used to instantiate sources.

amplitude: float#: Alias for field number 3

duration: float | None#: Alias for field number 1

enabled: bool#: Alias for field number 5

frequency: float#: Alias for field number 2

static from_dict(data: dict[str, Any]) → SourceParameters[source]#: Get source parameters from dictionary data.

static from_index(index: int, **kwargs) → SourceParameters[source]#: Create source parameters from a note index.

static from_note(note: Note, octave_offset: int = 0, **kwargs) → SourceParameters[source]#: Create parameters from a given note.

shape: WaveShape#: Alias for field number 4

stop_time: float | None#: Alias for field number 0

quasimoto.sampler.signature module#

A module implementing a simple time-signature interface.

quasimoto.sampler.signature.beat_period(tempo: int = 120) → float[source]#: Get the period in seconds of a single beat, based on beats-per-second tempo.

quasimoto.sampler.source module#

A module implementing a sound-source interface base class.

class quasimoto.sampler.source.SourceInterface(time_keeper: TimeKeeper, params: SourceParameters = (None, None, 261.62556800000067, 1.0, WaveShape.SINE, True))[source]#

Bases: HasFrequencyMixin, Iterable[int], ABC

A class implementing a sound-source interface.

clone(harmonic: int = None, stop_time: float = None) → T[source]#: Get a copy of this instance.

copy() → T[source]#: Create a copy of this instance.

classmethod create(time_keeper: TimeKeeper, data: dict[str, Any] = None) → T[source]#: Create a source instance from dictionary data.

get_samples(duration_s: float) → list[int][source]#: Collect samples.

plot(path: Path | str, duration_s: float) → None[source]#: Create a plot.

sample_for(duration_s: float, handler: Callable[[int], None]) → None[source]#: Sample this source for the specified duration.

set_duration(duration: float = None) → None[source]#: Set a duration for this source.

to_wave(path: Path, duration_s: float) → None[source]#: Write this source to a wave file.

abstractmethod value(now: float) → int[source]#: Get the next value.

quasimoto.sampler.time module#

A module implementing a simple time-keeper interface.

class quasimoto.sampler.time.PeriodMixin(sample_rate: int = 48000)[source]#

Bases: object

A simple class mixin for other classes that have a time-period component.

num_samples(duration_s: float) → int[source]#: Get the number of samples for a specified amount of time.

sample_number(time: float) → int[source]#: Determine the sample number that the given time starts.

class quasimoto.sampler.time.TimeKeeper(time: float = 0.0, sample_rate: int = 48000)[source]#

Bases: PeriodMixin

A class for keeping time.

advance() → None[source]#: Advance time forward.

call_at(time: float, callback: Callable[[float], None]) → None[source]#: Register a callback that runs at the specified time.

call_in(time: float, callback: Callable[[float], None]) → float[source]#: Register a callback for some relative amount of time in the future.

call_sequence(*callbacks: tuple[float, Callable[[float], None]]) → None[source]#: Register a call sequence.

copy() → T[source]#: Get a copy of this instance.

Module contents#

A module implementing sampler interfaces.

class quasimoto.sampler.Sampler(time_keeper: TimeKeeper, params: SourceParameters = (None, None, 261.62556800000067, 1.0, WaveShape.SINE, True), num_bits: int = 16)[source]#