def record_live(self):
"""
record -- but get this -- live!
"""
section_head("Record mode")
device_ind, device_name = sd_select_device()
p("Enter recording duration (in seconds)")
record_time = inpt('beatsec')
p('Choose sample rate to record at, in samples per second. Hit enter to use default 44100')
rate = inpt('int', required=False)
if rate == '':
rate = 44100
self.rate = Units.rate(rate)
print(" Press Enter to begin recording, or 'q' to quit: ", end="")
inpt("none", required=False)
time.sleep(0.05)
section_head("Recording at input {0} ({1}) for {2}".format(device_ind, \
device_name, record_time))
sd.default.channels = 2
recording = sd.rec(
ind(record_time * self.rate),
self.rate.magnitude,
device=device_name)
sd.wait()
info_block("Finished recording")
self.arr = recording
if len(self.arr.shape) < 2:
transpose = self.arr.reshape(-1, 1)
self.arr = np.hstack((transpose, transpose))
self.source_block = {
'live recording': "input '{0}'".format(device_name)
}
def playback(self, duration=5, start=0, first_time=True):
"""
cat: info
desc: playback this recording's audio
args:
[duration: beats/seconds. default 5]
[start: beat/seconds to start at. defualts to beginning]
"""
duration = inpt_validate(duration, 'beatsec')
start = inpt_validate(start, 'beatsec')
section_head("Playback of '{0}'".format(self.name))
print(" preparing...")
start_ind = ind(start)
if duration <= 0:
end_ind = self.size_samps()
else:
end_ind = start_ind + ind(duration * self.rate)
arr = self.arr[start_ind : end_ind]
arr = self.get_panned_rec(arr)
print(" playing...")
rate = self.rate.to_rate().round().magnitude
try:
sd.play(arr, rate)
sd.wait()
except TypeError as e:
if first_time:
retry = True
err_mess("Error playing back. Trying again")
self.arr = [[float(i), float(j)] for i,j in self.arr]
self.playback(duration, start, False)
else:
raise e
print(" finished playback")
def process(obj):
"""
process an object.
'self.name', 'self.reltype' required.
"""
section_head("Processing {0} '{1}'".format(obj.reltype, obj.name))
while True:
try:
obj.process_message()
except AttributeError:
pass
with style("cyan, bold"):
print("\n{0} ".format(RelGlobals.get_process_num()), end="")
p("What process to run on {0} '{1}'?".format(obj.reltype, obj.name),
h=True,
o="'o' to view process options",
indent=0,
hang=4,
leading_newline=False)
try:
command = inpt(mode='split',
split_modes='arg',
help_callback=processes_help)
if process_validate(command, obj):
do_command(command, obj)
except Cancel:
return
def info(self):
"""
cat: info
"""
section_head("{0} '{1}'".format(self.reltype, self.name))
info_line("{0} samples".format(len(self.smps)))
info_line("{0} rhythms".format(len(self.rhythms)))
info_line("{0} active pairs".format(len(self.active)))
info_line("(use list_samples/rhythms/active to view them)")
def __init__(self, filename, path, rel_instance):
section_head("Loading '{0}'".format(filename))
self.proj_file_dir = path
self.current_path = path
self.filename = filename
self.rel_instance = rel_instance
# because leaf children loaded before the root, need to add parents retroactively
self.need_parent = []
self.project = None
def undo(self):
"""
cat: save
desc: reverts to previous state (maximum of 5 times)
"""
section_head("Undoing...")
if len(self.recents) != 0:
self.arr = self.recents.pop(0)
else:
err_mess("No history to revert to!")
def __init__(self, reldata_dir, proj_filename):
section_head("Initializing Program")
RelGlobals.set_rel_instance(self)
self.relfile_path = join_path(reldata_dir, proj_filename)
# set default output
self.output = "Built-in Output"
self.reltype = "Program"
# maps name : path to that proj's datafile
self.projects = self.read_proj_file()
self.current_open_proj = None
def open_proj(self):
"""
desc: open a project
"""
section_head("Opening Project")
self.list_projects()
p("Enter name of project you want to open, or 'see <name>' to see info about that project"
)
name_input = inpt("split", "obj")
see = False
if name_input[0] == "see":
try:
proj_name = name_input[1]
except IndexError:
err_mess("No name provided to 'see'")
self.open_proj()
return
see = True
else:
proj_name = name_input[0]
try:
proj_path = self.projects[proj_name]
except KeyError:
try:
proj_name = autofill(proj_name, self.projects.keys(), "name")
except AutofillError as e:
err_mess("No project matches name '{0}'".format(e.word))
return
proj_path = self.projects[proj_name]
if proj_path == "None":
err_mess("Project {0} is missing".format(proj_name))
self.handle_missing_proj(proj_name)
return
if see:
self.see_proj(proj_name, proj_path)
self.open_proj()
return
try:
loader = ProjectLoader("{0}.Project".format(proj_name), proj_path,
self)
self.current_open_proj = loader.get_proj()
except FileNotFoundError as e:
err_mess("File Not Found: '{0}'".format(e.filename))
self.handle_missing_proj(proj_name)
return
def main_menu(self):
while True:
section_head("Relativism Main Menu")
p("Would you like to edit Projects (P), Settings (S), or get Help (H)?"
)
choice = inpt("letter", allowed="psh")
try:
if choice == "p":
self.projects_menu()
elif choice == "s":
self.settings_menu()
else:
self.help_menu()
except Cancel:
pass
def create_proj(self):
"""
desc: create a new project
"""
section_head("Creating New Project")
while True:
try:
self.current_open_proj = Project(parent=self, mode="create")
break
except FileExistsError:
err_mess(
"The directory already exists and cannot be overwritten. Choose another name or location"
)
self.projects[self.current_open_proj.
name] = self.current_open_proj.get_data_dir()
self.write_proj_file()
def __init__(self, name, reltype, mode, **kwargs):
super().__init__(name=name, reltype=reltype, **kwargs)
if mode == "create":
section_head("Initializing {0}".format(reltype))
elif mode == "load":
info_line("Loading {0} '{1}'".format(reltype, name))
elif mode == "prop":
# property
pass
else:
raise UnexpectedIssue("Unknown mode '{0}'".format(mode))
self.name = name
self.reltype = reltype
self._do_aliases()
def export_to_wav(self, outfile=None):
"""
cat: save
desc: save recording to wav file
args:
outfile: filename to save to. do not include '.wav' or any other extention
"""
section_head("Writing to file")
if outfile is None:
print(" Enter output file name: ", end="")
outfile = inpt("file")
try:
info_line("writing...")
t1 = time.time()
self.write_audio(outfile)
t2 = time.time()
info_line("written successfully in {0:.4f} seconds".format(t2 - t1))
except TypeError as e:
print(" > Failed to write to file '{0}': {1}".format(outfile, e))
def process():
section_head("Editing User Settings")
method_strs = [func for func in dir(Settings) if "__" not in func and
is_public_process(getattr(Settings, func))]
while True:
info_title("Available processes:")
info_list(method_strs)
p("What process to run?")
proc = inpt("alphanum")
try:
proc = autofill(proc, method_strs)
method = getattr(Settings, proc)
if is_public_process(method):
method()
else:
raise AttributeError
except AutofillError as e:
err_mess("No process matches '{0}'!".format(e.word))
except AttributeError:
err_mess("No process matches '{0}'!".format(proc))
def __init__(self,
rec,
size,
dampening=50,
wet=50,
dry=80,
roughness=50,
spread=50):
"""
args:
size: radius in meters of room
"""
section_head("Reverb1")
self.rec = rec
self.size = inpt_validate(size, 'float', allowed=[1, None])
self.dampening = inpt_validate(dampening, 'pcnt', allowed=[0, None
]) * 1 / 100
self.wet = inpt_validate(wet, 'pcnt', allowed=[0, None])
self.dry = inpt_validate(dry, 'pcnt', allowed=[0, None])
self.rate = rec.rate
self.spread = inpt_validate(spread, 'pcnt', allowed=[0, 200]) * 1 / 100
self.nodes = []
# self.add_node(0,size)
self.add_node(size, 0)
self.add_node(-size, 0)
# self.add_node(0, -size)
# source must init before set_other_nodes
self.listener = Reverb1.Reverb1_Listener(self, 0, 0)
self.source = Reverb1.Reverb1_Source(self, rec.arr, 0, size / 2)
self.set_other_nodes()
# do the reverb
self.source.start()
# clean up
self.collect()
def projects_menu(self):
"""
top menu for opening or creating projects
"""
while True:
section_head("Projects Menu")
# choose open type: open or create
while self.current_open_proj is None:
if bool(self.projects):
p("Open existing project (O) or Create new (C)?")
open_or_create = inpt("letter", allowed="oc")
if open_or_create == 'c':
self.create_proj()
else:
self.open_proj()
else:
info_block(
"No existing projects. Defaulting to create new")
self.create_proj()
self.process_project()
