def can_handle(fname): """Return a score between 0 and 100. 100 is for the best match (specific extension), 0 is for no match at all. """ if helper.is_video_file(fname): return 80 return 0
def can_handle(fname): ext = os.path.splitext(fname)[1].lower() if ext in ('.txt', '.log'): return 100 elif ext == '.gz': return 50 elif helper.is_video_file(fname): return 0 else: # It may handle any type of file ? return 1
def main(): logging.basicConfig(level=logging.INFO) if os.environ.get('ADVENE_DEBUG'): LOGGING = { 'version': 1, 'disable_existing_loggers': False, 'loggers': { } } # Handle ADVENE_DEBUG variable. for m in os.environ.get('ADVENE_DEBUG', '').split(':'): LOGGING['loggers'][m] = { 'level': 'DEBUG' } LOGGING['loggers'][m.replace('.', '_')] = { 'level': 'DEBUG' } # Plugin package name can be mangled if '.plugins' in m: LOGGING['loggers'][m.replace('.', '_').replace('_plugins_', '_app_plugins_')] = { 'level': 'DEBUG' } logging.config.dictConfig(LOGGING) USAGE = f"{sys.argv[0]} [-o filter_options] filter_name input_file [output_file]" import advene.core.controller as controller # The controller will import (as a module) advene.util.importer, # which will be different from __main__. So local IMPORTERS # variable will be different from advene.util.importer.IMPORTERS # Fix this situation by restoring appropriate IMPORTERS reference: IMPORTERS = controller.advene.util.importer.IMPORTERS # Basic controller initialization - load plugins c = controller.AdveneController() c.init_plugins() if len(config.data.args) < 2: logger.info("""\n\nSyntax: %s filter_name can be "auto" for autodetection (first valid importer), "list" for a list of valid importers for the file Use "-o help" as filter option for getting parameter help. Filter parameters displayed as --long-option-name in the help message should be entered as "-o long-option-name=value" (strip leading -- from option and use one "-o" option per parameter). A base template package can be specified using the "-o template_package=path.azp" option. The given package will be loaded before the import takes place. If no output file is specified, then data will be dumped to stdout in a JSON format. Available filters: * %s """ % (USAGE, "\n * ".join(sorted(i.name.replace(' ', '_') for i in controller.advene.util.importer.IMPORTERS)))) sys.exit(0) # Handle input parameters/options filtername = config.data.args[0].replace('_', ' ') inputfile = config.data.args[1] if config.data.args[2:]: outputfile = config.data.args[2] else: outputfile = '' # Filter options are passed using the -o option, but there is a # specific template_package option to specify initial template # packages template_package = config.data.options.options.get('template_package') # Rebuild filter option string from config.data.options.options dict option_list = [ (f"--{k}={v}" if v else f"--{k}") for (k, v) in config.data.options.options.items() if k != 'template_package' ] # If template_package is None, then the controller will use the # standard template package c.load_package(template_package) # If we are importing a video file, then set it as default media # for the package. This will also initialize the imagecache. if helper.is_video_file(inputfile): c.set_default_media(inputfile) def progress(value, label=""): sys.stderr.write('\rProgress %02d%% - %s' % (int(100 * value), label)) return True if filtername == 'auto': i = get_importer(inputfile, package=c.package, controller=c, callback=progress) elif filtername == 'list': # List valid importer names for the given file valid, invalid = get_valid_importers(inputfile) validlist = '\n * '.join(sorted(i.name for i in valid)) logger.info(f"Valid importers for {inputfile}:\n * {validlist}") sys.exit(1) else: i = None cl = [ f for f in controller.advene.util.importer.IMPORTERS if f.name.startswith(filtername) ] if len(cl) == 1: i = cl[0](package=c.package, controller=c, callback=progress) elif len(cl) > 1: logger.error("Too many possibilities:\n%s", "\n".join(f.name for f in cl)) sys.exit(1) if i is None: logger.error("No matching importer starting with %s", filtername) sys.exit(1) i.optionparser.set_usage(USAGE) if option_list: args = i.process_options(option_list) # (for .sub conversion for instance, --fps, --offset) logger.info("Converting %s to %s using %s", inputfile, outputfile, i.name) # Serialize data as JSON to stdout def json_serialize(p, filename="-"): from advene.util.exporter import FlatJsonExporter e = FlatJsonExporter(controller=c) e.set_source(p) e.export(filename or '-') reqs = i.check_requirements() if reqs: # Not all requirements are met. Display some information. logger.error("The filter is not ready.\n%s" % "\n".join(reqs)) sys.exit(1) if hasattr(i, 'async_process_file'): # async mode from gi.repository import GLib mainloop = GLib.MainLoop() def end_callback(): if outputfile == '' or outputfile.endswith('.json'): json_serialize(i.package, outputfile) else: i.package.save(outputfile) mainloop.quit() return True i.async_process_file(inputfile, end_callback) mainloop.run() else: i.process_file(inputfile) if outputfile == '' or outputfile.endswith('.json'): json_serialize(i.package, outputfile) else: i.package.save(outputfile) logger.info(i.statistics_formatted()) sys.exit(0)