Functions
	one_cmd_list ()

	add_default_arg (parser)

	add_default_arg_no_CS (parser)

	is_accumulated_arg (arg, driver)

	is_valid_attr (args, attr)

configparser.ConfigParser	get_config_parser ()

	parse_cfg (Union[str, None] config_path, str section_to_parse, args, bool quiet=False)

	print_version_and_exit (file_path)

	safemain (main, mainpath)

	run_ret (cmd, *str one_cmd=None, err_prefix=None, logfile=None)

	run (cmd, *str one_cmd=None, err_prefix=None, logfile=None)

	remove_prefix (str, prefix)

	remove_suffix (str, suffix)

	get_optimization_list (get_name=False)

	get_target_list (get_name=False)

Optional[ArgumentParser]	get_arg_parser (Optional[str] backend, str cmd, Optional[str] target)

	detect_one_import_drivers (search_path)

Variables
dict	ONE_CMD

Function Documentation

◆ add_default_arg()

utils.add_default_arg ( parser )

Definition at line 60 of file utils.py.

def add_default_arg(parser):
    # version
    parser.add_argument('-v',
                        '--version',
                        action='store_true',
                        help='show program\'s version number and exit')
 
    # verbose
    parser.add_argument('-V',
                        '--verbose',
                        action='store_true',
                        help='output additional information to stdout or stderr')
 
    # configuration file
    parser.add_argument('-C', '--config', type=str, help='run with configuation file')
    # section name that you want to run in configuration file
    parser.add_argument('-S', '--section', type=str, help=argparse.SUPPRESS)
 
 

◆ add_default_arg_no_CS()

utils.add_default_arg_no_CS ( parser )

This adds -v -V args only (no -C nor -S)

Definition at line 79 of file utils.py.

def add_default_arg_no_CS(parser):
    """
    This adds -v -V args only (no -C nor -S)
    """
    # version
    parser.add_argument('-v',
                        '--version',
                        action='store_true',
                        help='show program\'s version number and exit')
 
    # verbose
    parser.add_argument('-V',
                        '--verbose',
                        action='store_true',
                        help='output additional information to stdout or stderr')
 
 

◆ detect_one_import_drivers()

utils.detect_one_import_drivers ( search_path )

Looks for import drivers in given directory

Args:
    search_path: path to the directory where to search import drivers

Returns:
dict: each entry is related to single detected driver,
      key is a config section name, value is a driver name

Definition at line 383 of file utils.py.

def detect_one_import_drivers(search_path):
    """Looks for import drivers in given directory
 
    Args:
        search_path: path to the directory where to search import drivers
 
    Returns:
    dict: each entry is related to single detected driver,
          key is a config section name, value is a driver name
 
    """
    import_drivers_dict = {}
    for module_name in os.listdir(search_path):
        full_path = os.path.join(search_path, module_name)
        if not os.path.isfile(full_path):
            continue
        if module_name.find("one-import-") != 0:
            continue
        module_loader = importlib.machinery.SourceFileLoader(module_name, full_path)
        module_spec = importlib.util.spec_from_loader(module_name, module_loader)
        module = importlib.util.module_from_spec(module_spec)
        try:
            module_loader.exec_module(module)
            if hasattr(module, "get_driver_cfg_section"):
                section = module.get_driver_cfg_section()
                import_drivers_dict[section] = module_name
        except:
            pass
    return import_drivers_dict

◆ get_arg_parser()

Optional[ArgumentParser] utils.get_arg_parser	(	Optional[str]	backend,
		str	cmd,
		Optional[str]	target
	)

Definition at line 358 of file utils.py.

                   target: Optional[str]) -> Optional[ArgumentParser]:
    if not backend:
        return None
 
    dir_path = os.path.dirname(os.path.realpath(__file__))
    # for python module naming convention
    command_schema_path = dir_path + f'/../../backends/command/{backend}/{cmd}.py'
    if not os.path.isfile(command_schema_path):
        return None
 
    # https://docs.python.org/3/library/importlib.html#importing-a-source-file-directly
    spec = importlib.util.spec_from_file_location(cmd, command_schema_path)
    module = importlib.util.module_from_spec(spec)
    sys.modules[cmd] = module
    spec.loader.exec_module(module)
 
    if not hasattr(module, "command_schema"):
        raise RuntimeError('You must implement "command_schema" function')
 
    parser: ArgumentParser = module.command_schema()
    parser.target = target
    return parser
 
 

◆ get_config_parser()

configparser.ConfigParser utils.get_config_parser ( )

Initialize configparser and set default option

This funciton has been introduced for all the one-cmds tools having same parsing option.

Definition at line 111 of file utils.py.

def get_config_parser() -> configparser.ConfigParser:
    """
    Initialize configparser and set default option
 
    This funciton has been introduced for all the one-cmds tools having same parsing option.
    """
    parser = configparser.ConfigParser(inline_comment_prefixes=('#', ';'))
    parser.optionxform = str
 
    return parser
 
 

Referenced by parse_cfg().

◆ get_optimization_list()

utils.get_optimization_list ( get_name = False )

returns a list of optimization. If `get_name` is True,
only basename without extension is returned rather than full file path.

[one hierarchy]
one
├── backends
├── bin
├── doc
├── include
├── lib
├── optimization
└── test

Optimization options must be placed in `optimization` folder

Definition at line 280 of file utils.py.

def get_optimization_list(get_name=False):
    """
    returns a list of optimization. If `get_name` is True,
    only basename without extension is returned rather than full file path.
 
    [one hierarchy]
    one
    ├── backends
    ├── bin
    ├── doc
    ├── include
    ├── lib
    ├── optimization
    └── test
 
    Optimization options must be placed in `optimization` folder
    """
    dir_path = os.path.dirname(os.path.realpath(__file__))
 
    # optimization folder
    files = [
        f for f in glob.glob(dir_path + '/../../optimization/O*.cfg', recursive=True)
    ]
    # exclude if the name has space
    files = [s for s in files if not ' ' in s]
 
    opt_list = []
    for cand in files:
        base = ntpath.basename(cand)
        if os.path.isfile(cand) and os.access(cand, os.R_OK):
            opt_list.append(cand)
 
    if get_name == True:
        # NOTE the name includes prefix 'O'
        # e.g. O1, O2, ONCHW not just 1, 2, NCHW
        opt_list = [ntpath.basename(f) for f in opt_list]
        opt_list = [remove_suffix(s, '.cfg') for s in opt_list]
 
    return opt_list
 
 

References remove_suffix().

◆ get_target_list()

utils.get_target_list ( get_name = False )

returns a list of targets. If `get_name` is True,
only basename without extension is returned rather than full file path.

[one hierarchy]
one
├── backends
├── bin
├── doc
├── include
├── lib
├── optimization
├── target
└── test

Target configuration files must be placed in `target` folder

Definition at line 321 of file utils.py.

def get_target_list(get_name=False):
    """
    returns a list of targets. If `get_name` is True,
    only basename without extension is returned rather than full file path.
 
    [one hierarchy]
    one
    ├── backends
    ├── bin
    ├── doc
    ├── include
    ├── lib
    ├── optimization
    ├── target
    └── test
 
    Target configuration files must be placed in `target` folder
    """
    dir_path = os.path.dirname(os.path.realpath(__file__))
 
    # target folder
    files = [f for f in glob.glob(dir_path + '/../../target/*.ini', recursive=True)]
    # exclude if the name has space
    files = [s for s in files if not ' ' in s]
 
    target_list = []
    for cand in files:
        if os.path.isfile(cand) and os.access(cand, os.R_OK):
            target_list.append(cand)
 
    if get_name == True:
        target_list = [ntpath.basename(f) for f in target_list]
        target_list = [remove_suffix(s, '.ini') for s in target_list]
 
    return target_list
 
 

References remove_suffix().

◆ is_accumulated_arg()

utils.is_accumulated_arg	(	arg,
		driver
	)

Definition at line 96 of file utils.py.

def is_accumulated_arg(arg, driver):
    if driver == "one-quantize":
        accumulables = [
            "tensor_name", "scale", "zero_point", "src_tensor_name", "dst_tensor_name"
        ]
        if arg in accumulables:
            return True
 
    return False
 
 

Referenced by parse_cfg().

◆ is_valid_attr()

utils.is_valid_attr	(	args,
		attr
	)

Definition at line 107 of file utils.py.

def is_valid_attr(args, attr):
    return hasattr(args, attr) and getattr(args, attr)

Referenced by parse_cfg().

◆ one_cmd_list()

utils.one_cmd_list ( )

Definition at line 56 of file utils.py.

def one_cmd_list():
    return [cmd for group, cmds in ONE_CMD.items() for cmd in cmds.keys()]

Referenced by run(), and run_ret().

◆ parse_cfg()

utils.parse_cfg	(	Union[str, None]	config_path,
		str	section_to_parse,
			args,
		bool	quiet = `False`
	)

parse configuration file and store the information to args

:param config_path: path to configuration file
:param section_to_parse: section name to parse
:param args: object to store the parsed information
:param quiet: raise no error when given section doesn't exist

Definition at line 123 of file utils.py.

              quiet: bool = False):
    """
    parse configuration file and store the information to args
    
    :param config_path: path to configuration file
    :param section_to_parse: section name to parse
    :param args: object to store the parsed information
    :param quiet: raise no error when given section doesn't exist
    """
    if config_path is None:
        return
 
    parser = get_config_parser()
    parser.read(config_path)
 
    if not parser.has_section(section_to_parse) and quiet:
        return
 
    if not parser.has_section(section_to_parse):
        raise AssertionError('configuration file must have \'' + section_to_parse +
                             '\' section')
 
    # set environment
    CFG_ENV_SECTION = 'Environment'
    if parser.has_section(CFG_ENV_SECTION):
        for key in parser[CFG_ENV_SECTION]:
            os.environ[key] = parser[CFG_ENV_SECTION][key]
 
    for key in parser[section_to_parse]:
        if is_accumulated_arg(key, section_to_parse):
            if not is_valid_attr(args, key):
                setattr(args, key, [parser[section_to_parse][key]])
            else:
                getattr(args, key).append(parser[section_to_parse][key])
            continue
        if hasattr(args, key) and getattr(args, key):
            continue
        setattr(args, key, parser[section_to_parse][key])
 
 

References get_config_parser(), is_accumulated_arg(), and is_valid_attr().

◆ print_version_and_exit()

utils.print_version_and_exit ( file_path )

print version of the file located in the file_path

Definition at line 166 of file utils.py.

def print_version_and_exit(file_path):
    """print version of the file located in the file_path"""
    script_path = os.path.realpath(file_path)
    dir_path = os.path.dirname(script_path)
    script_name = os.path.splitext(os.path.basename(script_path))[0]
    # run one-version
    subprocess.call([os.path.join(dir_path, 'one-version'), script_name])
    sys.exit()
 
 

◆ remove_prefix()

utils.remove_prefix	(	str,
		prefix
	)

Definition at line 268 of file utils.py.

def remove_prefix(str, prefix):
    if str.startswith(prefix):
        return str[len(prefix):]
    return str
 
 

◆ remove_suffix()

utils.remove_suffix	(	str,
		suffix
	)

Definition at line 274 of file utils.py.

def remove_suffix(str, suffix):
    if str.endswith(suffix):
        return str[:-len(suffix)]
    return str
 
 

Referenced by get_optimization_list(), and get_target_list().

◆ run()

utils.run	(		cmd,
		*str	one_cmd = `None`,
			err_prefix = `None`,
			logfile = `None`
	)

Execute command in subprocess

Args:
    one_cmd: subtool name to execute with given `cmd`
    cmd: command to be executed in subprocess
    err_prefix: prefix to be put before every stderr lines
    logfile: file stream to which both of stdout and stderr lines will be written

Definition at line 228 of file utils.py.

def run(cmd, *, one_cmd: str = None, err_prefix=None, logfile=None):
    """Execute command in subprocess
 
    Args:
        one_cmd: subtool name to execute with given `cmd`
        cmd: command to be executed in subprocess
        err_prefix: prefix to be put before every stderr lines
        logfile: file stream to which both of stdout and stderr lines will be written
    """
    if one_cmd:
        assert one_cmd in one_cmd_list(), f'Invalid ONE COMMAND: {one_cmd}'
        dir_path = os.path.dirname(os.path.dirname(
            os.path.realpath(__file__)))  # bin = onelib/../
        driver_path = os.path.join(dir_path, f'one-{one_cmd}')
        cmd = [driver_path] + cmd
 
    with subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) as p:
        import select
        inputs = set([p.stdout, p.stderr])
        while inputs:
            readable, _, _ = select.select(inputs, [], [])
            for x in readable:
                line = x.readline()
                if len(line) == 0:
                    inputs.discard(x)
                    continue
                if x == p.stdout:
                    out = sys.stdout
                if x == p.stderr:
                    out = sys.stderr
                    if err_prefix:
                        line = f"{err_prefix}: ".encode() + line
                out.buffer.write(line)
                out.buffer.flush()
                if logfile != None:
                    logfile.write(line)
    if p.returncode != 0:
        sys.exit(p.returncode)
 
 

References one_cmd_list().

◆ run_ret()

utils.run_ret	(		cmd,
		*str	one_cmd = `None`,
			err_prefix = `None`,
			logfile = `None`
	)

Execute command in subprocess

Args:
    one_cmd: subtool name to execute with given `cmd`
    cmd: command to be executed in subprocess
    err_prefix: prefix to be put before every stderr lines
    logfile: file stream to which both of stdout and stderr lines will be written
Return:
    Process execution return code; 0 if success and others for error.

Definition at line 186 of file utils.py.

def run_ret(cmd, *, one_cmd: str = None, err_prefix=None, logfile=None):
    """Execute command in subprocess
 
    Args:
        one_cmd: subtool name to execute with given `cmd`
        cmd: command to be executed in subprocess
        err_prefix: prefix to be put before every stderr lines
        logfile: file stream to which both of stdout and stderr lines will be written
    Return:
        Process execution return code; 0 if success and others for error.
    """
    if one_cmd:
        assert one_cmd in one_cmd_list(), f'Invalid ONE COMMAND: {one_cmd}'
        dir_path = os.path.dirname(os.path.dirname(
            os.path.realpath(__file__)))  # bin = onelib/../
        driver_path = os.path.join(dir_path, f'one-{one_cmd}')
        cmd = [driver_path] + cmd
 
    with subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) as p:
        import select
        inputs = set([p.stdout, p.stderr])
        while inputs:
            readable, _, _ = select.select(inputs, [], [])
            for x in readable:
                line = x.readline()
                if len(line) == 0:
                    inputs.discard(x)
                    continue
                if x == p.stdout:
                    out = sys.stdout
                if x == p.stderr:
                    out = sys.stderr
                    if err_prefix:
                        line = f"{err_prefix}: ".encode() + line
                out.buffer.write(line)
                out.buffer.flush()
                if logfile != None:
                    logfile.write(line)
    return p.returncode
 
 
# TODO make run call run_ret

References one_cmd_list().

◆ safemain()

utils.safemain	(	main,
		mainpath
	)

execute given method and print with program name for all uncaught exceptions

Definition at line 176 of file utils.py.

def safemain(main, mainpath):
    """execute given method and print with program name for all uncaught exceptions"""
    try:
        main()
    except Exception as e:
        prog_name = os.path.basename(mainpath)
        print(f"{prog_name}: {type(e).__name__}: " + str(e), file=sys.stderr)
        sys.exit(255)
 
 

References main().

Variable Documentation

◆ ONE_CMD

dict utils.ONE_CMD

Initial value:

=  {
    'compile': {
        'import': 'Convert given model to circle',
        'optimize': 'Optimize circle model',
        'quantize': 'Quantize circle model',
    },
    'package': {
        'pack': 'Package circle and metadata into nnpackage',
    },
    'backend': {
        'codegen': 'Code generation tool',
        'profile': 'Profile backend model file',
        'infer': 'Infer backend model file'
    },
}

Definition at line 39 of file utils.py.

Functions

Variables

Function Documentation

◆ add_default_arg()

◆ add_default_arg_no_CS()

◆ detect_one_import_drivers()

◆ get_arg_parser()

◆ get_config_parser()

◆ get_optimization_list()

◆ get_target_list()

◆ is_accumulated_arg()

◆ is_valid_attr()

◆ one_cmd_list()

◆ parse_cfg()

◆ print_version_and_exit()

◆ remove_prefix()

◆ remove_suffix()

◆ run()

◆ run_ret()

◆ safemain()

Variable Documentation

◆ ONE_CMD