def create_generator(self, argv): parser = argparse.ArgumentParser( description='Create a new Halide generator', usage='hlgen create generator <name>') parser.add_argument('name', type=str, help='The name of the generator. This will also be the name of the source file created.') args = parser.parse_args(argv) project = Project() project.create_generator(args.name) project.save()
def delete_configuration(self, argv): parser = argparse.ArgumentParser( description='Delete an existing Halide generator configuration', usage='''hlgen delete configuration <gen> [<name>] Recommended to run `make clean` before running this command. To remove the default configuration, either omit <name> or write '(default)'. ''') parser.add_argument('gen', help='The name of the generator.') parser.add_argument('name', help='The name of the configuration.', default=None, nargs='?') args = parser.parse_args(argv) project = Project() project.delete_configuration(args.gen, self._normalize_config_name(args.name)) project.save()
def create_configuration(self, argv): parser = argparse.ArgumentParser( description='Create a new Halide generator configuration', usage='''hlgen create configuration <gen> <name> [<params>] The new configuration will be compiled as <gen>__<name>.{a,h,so,etc.}. To restore a default configuration after deleting it either omit <name> by putting '' in its place or write '(default)' ''') parser.add_argument('gen', type=str, help='The name of the generator.') parser.add_argument('name', type=str, help='The name of the configuration.', default='', nargs='?') parser.add_argument('params', type=str, help='The build parameters passed to the generator.', nargs=argparse.REMAINDER) args = parser.parse_args(argv) project = Project() project.create_configuration(args.gen, self._normalize_config_name(args.name), args.params) project.save()
def delete_generator(self, argv): parser = argparse.ArgumentParser( description='Delete an existing Halide generator', usage='hlgen delete generator [-f/--force] <name>') parser.add_argument('-f', '--force', action='store_true', help='do not prompt for confirmation before deleting files') parser.add_argument('name', type=str, help='The name of the generator.') args = parser.parse_args(argv) can_delete = True if not args.force: response = None while response not in ['', 'y', 'yes', 'n', 'no']: print('Alert! this action will delete any associated .gen.cpp files.') response = input('Are you sure you wish to continue? [y/n] ').lower() can_delete = response in ['', 'y', 'yes'] if can_delete: project = Project() project.delete_generator(args.name) project.save()
class Relativism(): 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 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 settings_menu(self): try: Settings.process() except Cancel: pass 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() def help_menu(self): #TODO raise NotImplementedError def validate_child_name(self, child, new_name): if new_name in self.projects: err_mess("Project named '{0}' already exists!".format(new_name)) return False if new_name == "see": err_mess("'see' is a protected keyword. Choose another name") return False # if no path, we have to wait until after path is selected to check. # this is verified in create_proj() if child.path is not None: newpath = join_path(child.path, child.get_data_filename(new_name), is_dir=True) if os.path.exists(newpath): err_mess( "Something already exists at path '{0}'".format(newpath)) return False # update projects file try: del self.projects[child.name] except KeyError: pass self.projects[new_name] = child.get_data_dir() self.write_proj_file() return True 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 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 see_proj(self, proj_name, proj_path): info_block("Previewing Project '{0}'".format(proj_name)) fullpath = join_path( proj_path, proj_name + ".Project." + RelSavedObj.datafile_extension) with open(fullpath, "r") as f: data = json.load(f) info_title("Path: " + data["path"]) info_line("Audio file: " + str(data["file"])) info_line("Children:") children = [ re.sub(r"<.*>", "", i).split(".") for i in data["children"] ] children = ["{0} '{1}'".format(i[1], i[0]) for i in children] info_list(children) def list_projects(self): info_title("Existing projects:") for k, v in self.projects.items(): if v == "None": info_list(k + " (Not found)") else: info_list(k) def process_project(self): if self.current_open_proj is None: err_mess("No project is currently open! Open or create one") else: process(self.current_open_proj) self.current_open_proj.save() self.current_open_proj = None def read_proj_file(self): """ read projects.data file """ # read project names try: data_file = open(self.relfile_path, "r") paths = data_file.readlines() data_file.close() paths = [re.sub(r" ", "\t", i) for i in paths] paths = [i.strip().split("\t") for i in paths] paths = {i[0]: i[1] for i in paths if len(i) > 1} except FileNotFoundError: dirc, _, _ = split_path(self.relfile_path) os.makedirs(dirc, exist_ok=True) path_f = open(self.relfile_path, "w") path_f.close() paths = {} return paths def write_proj_file(self): """ write projects.data file """ paths = [ str(k) + "\t" + str(v) + "\n" for k, v in self.projects.items() ] with open(self.relfile_path, "w") as f: f.writelines(paths) def handle_missing_proj(self, proj_name): """ locate or remove proj, rewrite file """ self.projects[proj_name] = "None" p("Locate '{0}'?".format(proj_name), o="y/n") located = False if inpt("yn"): p("Select the project's folder/directory (should be named '{0}.Project'" .format(proj_name), start="\n") try: directory = input_dir() self.projects[proj_name] = directory located = True except Cancel: pass if not located: p("Failed to locate. Remove this Project from known projects?", o="y/n") if inpt("yn"): del self.projects[proj_name] self.write_proj_file() def save(self): """ cleanup actions for Relativism object """ if self.current_open_proj is not None: self.current_open_proj.save() self.write_proj_file()