Callback for "alias-get" command
548411
public function cmdGetAlias()
    {
        $result = $this->getListAlias();
        $this->outputFormat($result);
        $this->outputFormatTableAlias($result);
        $this->output();
    }
309550
function getAlias( $alias ) {

        return isset( $this->aliases[ $alias ] ) ? $this->aliases[ $alias ] : $alias;

    }
168574
public static function alias( $alias, $params = array(), $retain = false )
	{
		$route_params = array();
		
		// to handle the suffix after a slash in an alias define
		$suffix = '';
		
		if ( strpos( $alias, '/' ) !== false && $alias !== '/' )
		{
			// slashes in aliases get appended as suffix
			list( $alias, $suffix ) = explode( '/', $alias );
			
			$suffix = '/'.$suffix;
		}
	

		// get the parameters with the numeric keys so we can 
		// pass them as route parameters like [any]-[num]-[num]/[any]/
		foreach( $params as $key => $value )
		{
			if ( is_int( $key ) )
			{
				$route_params[] = $value; unset( $params[$key] );
			}
		}

		return CCUrl::to( CCRouter::alias( $alias, $route_params ).$suffix, $params, $retain );
	}
325266
def _get_script(self):
        
        if settings.repeat:
            repeat_fuck = '{} --repeat {}--force-command {}'.format(
                get_alias(),
                '--debug ' if settings.debug else '',
                shell.quote(self.script))
            return shell.or_(self.script, repeat_fuck)
        else:
            return self.script
1295417
def get(name, *args, **kwargs):
    
    cmd = COMMAND_MAPPER.get(name)
    return cmd(*args, **kwargs)
1321042
def _filter_commands(ctx, commands=None):
    """"""
    lookup = getattr(ctx.command, 'commands', {})
    if not lookup and isinstance(ctx.command, click.MultiCommand):
        lookup = _get_lazyload_commands(ctx.command)

    if commands is None:
        return sorted(lookup.values(), key=lambda item: item.name)

    names = [name.strip() for name in commands.split(',')]
    return [lookup[name] for name in names if name in lookup]
211642
static function get($alias = null)
    {
        if ($alias === null) {
            return static::$config[static::$default];
        }
        if (isset(static::$config[$alias])) {
            return static::$config[$alias];
        } else {
            return false;
        }
    }
993486
def get_command(self, ctx, name):
        """"""
        plugin = os.path.basename(self.folder)
        try:
            command = importlib.import_module("honeycomb.commands.{}.{}".format(plugin, name))
        except ImportError:
            raise click.UsageError("No such command {} {}\n\n{}".format(plugin, name, self.get_help(ctx)))
        return getattr(command, name)
59433
def retrieve_import_alias_mapping(names_list):
    """"""
    import_alias_names = dict()

    for alias in names_list:
        if alias.asname:
            import_alias_names[alias.asname] = alias.name
    return import_alias_names
1014055
function runAlias(aliasName, directories, options, argv) {
	return new Promise((resolve, reject) => {
		const tasks = getAllAliases(options)[aliasName];
		if (!tasks) {
			reject(new MrmUnknownAlias(`Alias “${aliasName}” not found.`));
			return;
		}

		console.log(kleur.yellow(`Running alias ${aliasName}...`));

		promiseSeries(tasks, name => {
			return runTask(name, directories, options, argv);
		})
			.then(() => resolve())
			.catch(reject);
	});
}
703050
def _find_alias(FunctionName, Name, FunctionVersion=None,
                region=None, key=None, keyid=None, profile=None):
    '''
    
    '''
    conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)

    args = {
        'FunctionName': FunctionName
    }
    if FunctionVersion:
        args['FunctionVersion'] = FunctionVersion

    for aliases in __utils__['boto3.paged_call'](conn.list_aliases, **args):
        for alias in aliases.get('Aliases'):
            if alias['Name'] == Name:
                return alias
    return None
372636
def get_command(self, ctx, cmd_name):
        """"""
        rv = click.Group.get_command(self, ctx, cmd_name)
        if rv is not None:
            return rv
        cmd_name = self.command_aliases.get(cmd_name, "")
        return click.Group.get_command(self, ctx, cmd_name)
730152
def alias_create(self, args: argparse.Namespace) -> None:
        """"""

        # Validate the alias name
        valid, errmsg = self.statement_parser.is_valid_command(args.name)
        if not valid:
            self.perror("Invalid alias name: {}".format(errmsg), traceback_war=False)
            return

        if args.name in self.macros:
            self.perror("Alias cannot have the same name as a macro", traceback_war=False)
            return

        utils.unquote_redirection_tokens(args.command_args)

        # Build the alias value string
        value = args.command
        if args.command_args:
            value += ' ' + ' '.join(args.command_args)

        # Set the alias
        result = "overwritten" if args.name in self.aliases else "created"
        self.aliases[args.name] = value
        self.poutput("Alias '{}' {}".format(args.name, result))
392818
def get_command(self, name):
        """"""

        def command(options):
            client = ZookeeperClient(
                "%s:%d" % (options.pop('host'), options.pop('port')),
                session_timeout=1000
                )

            path = options.pop('path_prefix')
            force = options.pop('force')
            extra = options.pop('extra')

            # Apply settings to options dictionary. While this does
            # conflate arguments for the utility with command options,
            # that's something we're willing to accept.
            options.update(extra)

            controller = Command(client, path, self.services, force)
            method = getattr(controller, "cmd_%s" % name)
            return method(**options)

        return command
776939
def not_as_alias_handler(names_list):
    """"""
    list_ = list()
    for alias in names_list:
        list_.append(alias.name)
    return list_
783743
function alias( $aliasName )
    {
        $aliasList = $this->aliasList();
        if ( !array_key_exists( $aliasName, $aliasList ) )
            return false;
        return $aliasList[$aliasName];
    }
1109230
def cli(ctx):
    """"""
    cmd = click.prompt('Command')
    desc = click.prompt('Description ')
    alias = click.prompt('Alias (optional)', default='')
    utils.save_command(cmd, desc, alias)

    utils.log(ctx, 'Saved the new command - {} - with the description - {}.'.format(cmd, desc))