::

            Usage:
                   info [--all]

            Options:
                   --all  -a   more extensive information 

            Prints some internal information about the shell
182206
def do_info(self, arg, arguments):
        
        if arguments["--all"]:
            Console.ok(70 * "-")
            Console.ok('DIR')
            Console.ok(70 * "-")
            for element in dir(self):
                Console.ok(str(element))
            Console.ok(70 * "-")
        self.print_info()
643509
def info_file(self):
        
        sources = SBoGrep(self.prgnam).source().split()
        for source in sources:
            self.sbo_sources.append(source.split("/")[-1])
235514
def _make_info(self, name, stat_result, namespaces):
        
        info = {
            'basic': {
                'name': name,
                'is_dir': stat.S_ISDIR(stat_result.st_mode)
            }
        }
        if 'details' in namespaces:
            info['details'] = self._make_details_from_stat(stat_result)
        if 'stat' in namespaces:
            info['stat'] = {
                k: getattr(stat_result, k)
                for k in dir(stat_result) if k.startswith('st_')
            }
        if 'access' in namespaces:
            info['access'] = self._make_access_from_stat(stat_result)
        return Info(info)
249383
function info() {
	if ( env.opts.verbose || env.opts.debug ) {
		console.log.apply(console, arguments);
	}
}
462277
def print_app_info(out=sys.stderr):
    """"""
    print("System info:", file=out)
    print(configuration.App, file=out)
    print("Python %(version)s on %(platform)s" %
                    {"version": sys.version, "platform": sys.platform}, file=out)
    stime = strtime(time.time())
    print("Local time:", stime, file=out)
    print("sys.argv", sys.argv, file=out)
268184
def print_info(self):
        """"""
        
        d = dir(self)
        self.plugins = []
        for key in d:
            if key.startswith("info_"):
                self.plugins.append(key)

        for key in self.plugins:
            if self.echo:
                Console.ok("> {0}".format(key.replace("_", " ", 1)))
            exec("self.%s()" % key)
810594
public void info( String oinfo ) {
		//
		String methodName = moduleCode + "." + "info";
		//
		out.format( "%s%n", oinfo );
		//
		charsCount += oinfo.length();
		//
		String FOInfo = getFullInfoString( oinfo );
		//
		if ( !isFileOpen( methodName ) ) return;
		//
		outFile( FOInfo );
		//
        flushFile();
		//
	}
327074
def print_about(self):
        """"""
        filepath = os.path.join(self.suite_path, "bin", self.tool_name)
        print "Tool:     %s" % self.tool_name
        print "Path:     %s" % filepath
        print "Suite:    %s" % self.suite_path

        msg = "%s (%r)" % (self.context.load_path, self.context_name)
        print "Context:  %s" % msg

        variants = self.context.get_tool_variants(self.tool_name)
        if variants:
            if len(variants) > 1:
                self._print_conflicting(variants)
            else:
                variant = iter(variants).next()
                print "Package:  %s" % variant.qualified_package_name
        return 0
150906
def info(self):
        
        info = []

        for prior_model_name, prior_model in self.prior_model_tuples:
            info.append(prior_model.name + '\n')
            info.extend([f"{prior_model_name}_{item}" for item in prior_model.info])

        return '\n'.join(info)
277918
def _get_arg_info(self):
        '''
        
        '''
        ret_dict = {
            'args': [],
            #'frame': None,
            'line': 'Unknown',
            'file': 'Unknown',
            'arg_names': []
        }
        arg_vals = self.arg_vals
        #modname = self.modname

        c = self.call
        ret_dict.update(c.info)

        if len(arg_vals) > 0:
            args = []

            if len(ret_dict['arg_names']) > 0:
                # match the found arg names to their respective values
                for i, arg_name in enumerate(ret_dict['arg_names']):
                    args.append({'name': arg_name, 'val': arg_vals[i]})

            else:
                # we can't autodiscover the names, in an interactive shell session?
                for i, arg_val in enumerate(arg_vals):
                    args.append({'name': 'Unknown {}'.format(i), 'val': arg_val})

            ret_dict['args'] = args

        return ret_dict
48148
def cli_info(data, title='Info'):
    '''
    
    '''

    wrapper = textwrap.TextWrapper()
    wrapper.initial_indent = ' ' * 4
    wrapper.subsequent_indent = wrapper.initial_indent

    return '{title}:\n\n{text}'.format(title=title, text=wrapper.fill(data))
906471
def _format_info(data):
    '''
    
    '''
    return {'gid': data.pw_gid,
            'groups': list_groups(data.pw_name),
            'home': data.pw_dir,
            'name': data.pw_name,
            'shell': data.pw_shell,
            'uid': data.pw_uid,
            'fullname': data.pw_gecos}
1114056
def format_info(info_list):
    """"""

    max_lengths = []
    if info_list:
        nr_columns = len(info_list[0])
    else:
        nr_columns = 0
    for i in range(nr_columns):
        max_lengths.append(max([len(info[i]) for info in info_list]))

    flattened_info_list = []
    for info_id in range(len(info_list)):
        info = info_list[info_id]
        for str_id in range(len(info) - 1):
            # Don't justify the last column (i.e. the last printed line)
            # as it can get much longer in some shells than in others
            orig_str = info[str_id]
            indent = max_lengths[str_id] - len(orig_str)
            info[str_id] = orig_str + indent * b' '
        flattened_info_list.append(b' '.join(info) + b'\n')

    return flattened_info_list
780379
def main(show_details:['-l']=False, cols:['-w', '--width']='', *files):
    '''
    
    '''
    print(files)
    print(show_details)
    print(cols)
1175402
def info(message, *args, **kwargs):
    
    if 'end' in kwargs:
        end = kwargs['end']
    else:
        end = '\n'

    if len(args) == 0:
        sys.stdout.write(message)
    else:
        sys.stdout.write(message % args)
    sys.stdout.write(end)
    sys.stdout.flush()
891097
def info (logname, msg, *args, **kwargs):
    
    log = logging.getLogger(logname)
    if log.isEnabledFor(logging.INFO):
        _log(log.info, msg, args, **kwargs)
437534
def get_info(self):
        ''''''
        if self._min_disk:
            for path in self._resource_paths:
                usage = psutil.disk_usage(path)

                yield ResourceInfo(path, usage.free, self._min_disk)

        if self._min_memory:
            usage = psutil.virtual_memory()

            yield ResourceInfo(None, usage.available, self._min_memory)