def _get_model_path_and_name(self): model_path = self.config.get('model_path', '') if not model_path: raise ValueError('Model path should not be empty') model_name, extension = os_splitext(os_split(model_path)[1]) if extension!= '.h5': raise ValueError("This macro requires a .h5 file, {} given".format(extension)) return model_path, model_name
def get_inputs(self): self.input_folder = Folder( get_input_names_for_role("input_folder_id")[0]) output_folder_id = get_output_names_for_role("output_folder_id")[0] self.output_folder = Folder(output_folder_id) self.output_file_path = get_recipe_config()['output_model_path'] self.batch_size = int(get_recipe_config()['batch_size']) if not get_recipe_config()['show_batch_size']: self.batch_size = -1 self.overwrite_output_model = get_recipe_config( )['overwrite_output_model'] self.model_path = get_recipe_config()['model_path'] self.model_name = os_splitext(os_split(self.model_path)[1])[0] self.float_32 = get_recipe_config()["float_32"]
def get_io(fileobj: AudioIO, mod_path: list = [], cached: bool = True, blacklist: list = []) -> DevIO: """ get_io(fileobj, mod_path=[], cached=True, blacklist=[]) -> Finds a audio device that can take the data read from fileobj and returns it. """ # IO device cache dictionary global __io_cache from .import_util import load_lazy_import, unload_lazy_import # Get the file input data type. annotations = getattr(getattr(fileobj, "read"), "__annotations__", {}) file_input = annotations.get("return", str) # Get the file output data type. annotations = getattr(getattr(fileobj, "write"), "__annotations__", {}) file_output = annotations.get("data", str) if cached: # Load and already cached audio device. if file_input in __io_cache: return __io_cache[file_input] elif file_output in __io_cache: return __io_cache[file_output] # Get a list of modules ending in '_io.py' mod_list = _build_mod_list(mod_path, "_io.py", blacklist) device = None dummy = None # Make importing lazy. # load_lazy_import(mod_path=mod_path) # This packages name. this_pkgname = __name__.split(".", 1)[0] # Load the codec module that can handle file. for path, name in mod_list: # Get the package name from path. pkgname = os_basename(path.rstrip("/")) # Import the package if it is different from this one. if pkgname != this_pkgname and pkgname: try: __import__(pkgname) except ImportError as err: continue # Load the module. module = import_module(".%s" % os_splitext(name)[0], pkgname) # Get the filetypes and handler from module. supported_dict = getattr(module, "__supported_dict", {}) handler = getattr(module, supported_dict.get("handler", "dummy"), None) if not handler: continue # Try not to use the dummy. if "dummy" in name: dummy = handler continue # Check the module dependencies. dependencies = supported_dict.get("dependencies", {}) if not _check_dependencies(dependencies): continue input_t = supported_dict.get("input", []) output_t = supported_dict.get("output", []) default = supported_dict.get("default", False) # Add device input to io cache __io_cache.update(((key, handler) for key in input_t)) # Add device output to io cache. __io_cache.update(((key, handler) for key in output_t)) # Check if filename is supported. if "r" in fileobj.mode and file_input in output_t: device = handler if default: break elif "w" in fileobj.mode and file_output in input_t: device = handler if default: break # Turn off lazy imports. # unload_lazy_import() # No device was found so use the dummy_io. if not device: device = dummy return device
def get_codec(filename: str, mod_path: list = [], cached: bool = True, blacklist: list = []) -> AudioIO: """ get_codec(filename, mod_path=[], cached=True, blacklist=[]) -> Load the codecs in the path and return the first one that can play the file, or the one with the default attribute set. filename The file the codec needs to handle mod_path Additional search paths for modules cached Use cached codecs if available blacklist Modules not to load """ # Codec cache dictionary global __codec_cache from urllib.parse import urlparse from .import_util import load_lazy_import, unload_lazy_import # Get the file extension. file_ext = os_splitext(filename)[1].lower() # Get protocol. file_prot = urlparse(filename).scheme if cached: # Load and already cached codec. if file_ext in __codec_cache: return __codec_cache[file_ext] elif file_prot in __codec_cache: return __codec_cache[file_prot] # Get a list of modules ending in '_file.py' mod_list = _build_mod_list(mod_path, "_file.py", blacklist) codec = None dummy = None # Make importing lazy. # load_lazy_import(mod_path=mod_path) # This packages name. this_pkgname = __name__.split(".", 1)[0] # Load the codec module that can handle file. for path, name in mod_list: # Get the package name from path. pkgname = os_basename(path.rstrip("/")) # Import the package if it is different from this one. if pkgname != this_pkgname and pkgname: try: __import__(pkgname) except ImportError as err: continue # Load the module. try: module = import_module(".%s" % os_splitext(name)[0], pkgname) except ImportError as err: print("Skipping module: (%s) because of error: %s" % (name, err)) continue # Get the filetypes and handler from module. supported_dict = getattr(module, "__supported_dict", {}) # Get the handler. handler = getattr(module, supported_dict.get("handler", "dummy"), None) # Don't even check this module if it does not have a handler. if not handler: continue # Try not to use the dummy handler. if "dummy" in name: dummy = handler continue # Check the module dependencies. dependencies = supported_dict.get("dependencies", {}) if not _check_dependencies(dependencies): continue issupported = supported_dict.get("issupported", lambda *a: False) ext = supported_dict.get("ext", []) protocol = supported_dict.get("protocol", []) default = supported_dict.get("default", False) # Add filetype handlers to the codec cache. __codec_cache.update(((key, handler) for key in ext)) # Add protocol handlers to the codec cache. __codec_cache.update(((key, handler) for key in protocol)) # Check if filename is supported. if issupported(filename) or file_ext in ext or file_prot in protocol: codec = handler if default: break elif not codec and ".*" in ext: codec = handler # Turn off lazy imports. # unload_lazy_import() # No codec was found so default to the dummy codec. if not codec: codec = dummy return codec
def get_io(fileobj, mod_path=[], cached=True, blacklist=[]): """ get_io(fileobj, mod_path=[], cached=True, blacklist=[]) -> Finds a audio device that can take the data read from fileobj and returns it. """ # IO device cache dictionary global __io_cache from .import_util import load_lazy_import, unload_lazy_import # Get the file input data type. annotations = getattr(getattr(fileobj, 'read'), '__annotations__', {}) file_input = annotations.get('return', unicode) # Get the file output data type. annotations = getattr(getattr(fileobj, 'write'), '__annotations__', {}) file_output = annotations.get('data', unicode) if cached: # Load and already cached audio device. if file_input in __io_cache: return __io_cache[file_input] elif file_output in __io_cache: return __io_cache[file_output] # Get a list of modules ending in '_io.py' mod_list = _build_mod_list(mod_path, '_io.py', blacklist) device = None dummy = None # Make importing lazy. # load_lazy_import(mod_path=mod_path) # This packages name. this_pkgname = __name__.split('.', 1)[0] # Load the codec module that can handle file. for path, name in mod_list: # Get the package name from path. pkgname = os_basename(path.rstrip('/')) # Import the package if it is different from this one. if pkgname != this_pkgname and pkgname: try: __import__(pkgname) except ImportError as err: continue # Load the module. module = import_module('.%s' % os_splitext(name)[0], pkgname) # Get the filetypes and handler from module. supported_dict = getattr(module, '__supported_dict', {}) handler = getattr(module, supported_dict.get('handler', 'dummy'), None) if not handler: continue # Try not to use the dummy. if 'dummy' in name: dummy = handler continue # Check the module dependencies. dependencies = supported_dict.get('dependencies', {}) if not _check_dependencies(dependencies): continue input_t = supported_dict.get('input', []) output_t = supported_dict.get('output', []) default = supported_dict.get('default', False) # Add device input to io cache __io_cache.update(((key, handler) for key in input_t)) # Add device output to io cache. __io_cache.update(((key, handler) for key in output_t)) # Check if filename is supported. if 'r' in fileobj.mode and file_input in output_t: device = handler if default: break elif 'w' in fileobj.mode and file_output in input_t: device = handler if default: break # Turn off lazy imports. # unload_lazy_import() # No device was found so use the dummy_io. if not device: device = dummy return device
def get_codec(filename, mod_path=[], cached=True, blacklist=[]): """ get_codec(filename, mod_path=[], cached=True, blacklist=[]) -> Load the codecs in the path and return the first one that can play the file, or the one with the default attribute set. filename The file the codec needs to handle mod_path Additional search paths for modules cached Use cached codecs if available blacklist Modules not to load """ # Codec cache dictionary global __codec_cache from urlparse import urlparse from .import_util import load_lazy_import, unload_lazy_import # Get the file extension. file_ext = os_splitext(filename)[1].lower() # Get protocol. file_prot = urlparse(filename).scheme if cached: # Load and already cached codec. if file_ext in __codec_cache: return __codec_cache[file_ext] elif file_prot in __codec_cache: return __codec_cache[file_prot] # Get a list of modules ending in '_file.py' mod_list = _build_mod_list(mod_path, '_file.py', blacklist) codec = None dummy = None # Make importing lazy. # load_lazy_import(mod_path=mod_path) # This packages name. this_pkgname = __name__.split('.', 1)[0] # Load the codec module that can handle file. for path, name in mod_list: # Get the package name from path. pkgname = os_basename(path.rstrip('/')) # Import the package if it is different from this one. if pkgname != this_pkgname and pkgname: try: __import__(pkgname) except ImportError as err: continue # Load the module. try: module = import_module('.%s' % os_splitext(name)[0], pkgname) except ImportError as err: print("Skipping module: (%s) because of error: %s" % (name, err)) continue # Get the filetypes and handler from module. supported_dict = getattr(module, '__supported_dict', {}) # Get the handler. handler = getattr(module, supported_dict.get('handler', 'dummy'), None) # Don't even check this module if it does not have a handler. if not handler: continue # Try not to use the dummy handler. if 'dummy' in name: dummy = handler continue # Check the module dependencies. dependencies = supported_dict.get('dependencies', {}) if not _check_dependencies(dependencies): continue issupported = supported_dict.get('issupported', lambda *a: False) ext = supported_dict.get('ext', []) protocol = supported_dict.get('protocol', []) default = supported_dict.get('default', False) # Add filetype handlers to the codec cache. __codec_cache.update(((key, handler) for key in ext)) # Add protocol handlers to the codec cache. __codec_cache.update(((key, handler) for key in protocol)) # Check if filename is supported. if issupported(filename) or file_ext in ext or file_prot in protocol: codec = handler if default: break elif not codec and '.*' in ext: codec = handler # Turn off lazy imports. # unload_lazy_import() # No codec was found so default to the dummy codec. if not codec: codec = dummy return codec
def main(args: dict) -> None: """ Encode args['filename'] times. """ from os.path import basename as os_basename from os.path import isfile as os_isfile from os.path import splitext as os_splitext from sys import stdin as sys_stdin from select import select from time import sleep as time_sleep from termios import tcgetattr, tcsetattr, ECHO, ICANON, TCSANOW from termios import VMIN, VTIME from musio import open_file, open_device if args['debug']: from musio import io_util io_util.DEBUG = True filename = args['filename'] output = os_splitext(os_basename(filename))[0] + '.' + args['filetype'] output_bytes = output.encode('utf-8', 'surrogateescape') output_printable = output_bytes.decode('utf-8', 'ignore') if os_isfile(output): if input("Overwrite %s (y/n): " % output_printable).lower().startswith('n'): return # Save the current terminal state. normal = tcgetattr(sys_stdin) quiet = tcgetattr(sys_stdin) # Do not wait for key press and don't echo. quiet[3] &= ~(ECHO | ICANON) quiet[6][VMIN] = 0 quiet[6][VTIME] = 0 # Set the new terminal state. tcsetattr(sys_stdin, TCSANOW, quiet) # Value returned to tell the calling function whether to quit or # not. quit_val = True if args['filetype'].lower() == 'ogg': quality = args['quality'] / 10 if args['quality'] in range(-1, 11) else 0.5 elif args['filetype'].lower() == 'mp3': quality = args['quality'] if args['quality'] in range(0, 10) else 2 try: with open_file(**args) as in_file: in_file_title = in_file._info_dict.get('title', in_file._info_dict['name']) comment_dict = {'title': in_file_title} comment_dict.update(in_file._info_dict) for i in ['title', 'artist', 'album', 'year', 'comment', 'track', 'genre']: if args.get(i, ''): comment_dict[i] = args[i] with open_file(output, 'w', depth=in_file.depth, rate=in_file.rate, channels=in_file.channels, quality=quality, comment_dict=comment_dict) as out_file: in_file.loops = 0 if args['show_position']: filename_bytes = filename.encode('utf-8', 'surrogateescape') filename_printable = filename_bytes.decode('utf-8', 'ignore') print("Encoding: %s to %s" % (filename_printable, output_printable)) print(in_file) for data in in_file: if args['show_position']: if in_file.length > 0: # Calculate the percentage played. pos = (in_file.position * 100) / in_file.length # Make the string. pos_str = 'Position: %.2f%%' % pos # Find the length of the string. format_len = len(pos_str) + 2 # Print the string and after erasing the old # one using ansi escapes. print('\033[%dD\033[K%s' % (format_len, pos_str), end='', flush=True) out_file.write(data) # Check for input. r, _, _ = select([sys_stdin], [], [], 0) # Get input if there was any otherwise continue. if r: command = r[0].readline().lower() # Handle input commands. if command.startswith('q'): quit_val = False break elif command == '\n': break except Exception as err: print("Error: %s" % err, flush=True) raise(err) finally: # Re-set the terminal state. tcsetattr(sys_stdin, TCSANOW, normal) if args['show_position']: print("\nDone.") return quit_val
def main(args): """ Encode args['filename'] times. """ from os.path import basename as os_basename from os.path import isfile as os_isfile from os.path import splitext as os_splitext from sys import stdin as sys_stdin from sys import stdout as sys_stdout from select import select from time import sleep as time_sleep from termios import tcgetattr, tcsetattr, ECHO, ICANON, TCSANOW from termios import VMIN, VTIME from musio import open_file, open_device if args['debug']: from musio import io_util io_util.DEBUG = True filename = args['filename'] output = os_splitext(os_basename(filename))[0] + '.' + args['filetype'] output_bytes = output.encode('utf-8', 'surrogateescape') output_printable = output_bytes.decode('utf-8', 'ignore') if os_isfile(output): if raw_input("Overwrite %s (y/n): " % output_printable).lower().startswith('n'): return # Save the current terminal state. normal = tcgetattr(sys_stdin) quiet = tcgetattr(sys_stdin) # Do not wait for key press and don't echo. quiet[3] &= ~(ECHO | ICANON) quiet[6][VMIN] = 0 quiet[6][VTIME] = 0 # Set the new terminal state. tcsetattr(sys_stdin, TCSANOW, quiet) # Value returned to tell the calling function whether to quit or # not. quit_val = True if args['filetype'].lower() == 'ogg': quality = args['quality'] / 10 if args['quality'] in range(-1, 11) else 0.5 elif args['filetype'].lower() == 'mp3': quality = args['quality'] if args['quality'] in range(0, 10) else 2 try: with open_file(**args) as in_file: in_file_title = in_file._info_dict.get('title', in_file._info_dict['name']) comment_dict = {'title': in_file_title} comment_dict.update(in_file._info_dict) for i in ['title', 'artist', 'album', 'year', 'comment', 'track', 'genre']: if args.get(i, ''): comment_dict[i] = args[i] with open_file(output, 'w', depth=in_file.depth, rate=in_file.rate, channels=in_file.channels, quality=quality, comment_dict=comment_dict) as out_file: in_file.loops = 0 if args['show_position']: filename_bytes = filename.encode('utf-8', 'surrogateescape') filename_printable = filename_bytes.decode('utf-8', 'ignore') print("Encoding: %s to %s" % (filename, output)) print(in_file) for data in in_file: if args['show_position']: if in_file.length > 0: # Calculate the percentage played. pos = (in_file.position * 100) / float(in_file.length) # Make the string. pos_str = 'Position: %.2f%%' % pos # Find the length of the string. format_len = len(pos_str) + 2 # Print the string and after erasing the old # one using ansi escapes. print('\033[%dD\033[K%s' % (format_len, pos_str), end='') sys_stdout.flush() out_file.write(data) # Check for input. r, _, _ = select([sys_stdin], [], [], 0) # Get input if there was any otherwise continue. if r: command = r[0].readline().lower() # Handle input commands. if command.startswith('q'): quit_val = False break elif command == '\n': break except Exception as err: print("Error: %s" % err) raise(err) finally: # Re-set the terminal state. tcsetattr(sys_stdin, TCSANOW, normal) if args['show_position']: print("\nDone.") return quit_val