Returns the alternate name of a parameter.
        Only pipeline prompt-when-run parameters
        can have alternate names and alternate descriptions
502510
def get_alt_name(self):
        
        if ('altName' in self.attributes and
                bool(self.attributes['altName'].strip())):
            return self.attributes['altName']
        else:
            return None
316590
public GetPipelineResponse getPipeline(String pipelineName) {
        GetPipelineRequest request = new GetPipelineRequest();
        request.setPipelineName(pipelineName);
        return getPipeline(request);
    }
884177
def get_parameter_defaults(self, include_flags=True):
        
        return {
            name: parameter.default
            for (name, parameter)
            in self.parameters.items()
            if parameter.default is not None and (include_flags or parameter.type != 'flag')
        }
1203202
def _getPFilename(self,native,prompt):
        
        return self.get(native=native,prompt=prompt)
466792
def name(self):
        
        if not self._name:
            self._name = self._alternatives[self._choice][0]
        return self._name
690470
def get_name(self):
        
        self.name = self.name or graceful_get(self.inspect(refresh=False), "Name")
        return self.name
994190
def repr_parameter(param: inspect.Parameter) -> str:
    
    return (
        "Parameter(name={name}, annotation={annotation}, kind={kind}, "
        "default={default}".format(
            name=param.name, annotation=param.annotation, kind=param.kind,
            default=param.default)
    )
521684
def get(self, counter):
        
        return self._pipeline.get(name=self.data.name, counter=counter)
603353
def get_available_parameters(self):
        

        # At the moment, we rely on regex to extract the list of available
        # parameters. This solution will break if the format of the output
        # changes, but this is the best option that is currently available.

        result = subprocess.check_output([self.script_executable,
                                          '--PrintHelp'], env=self.environment,
                                         cwd=self.path).decode('utf-8')

        # Isolate the list of parameters
        options = re.findall('.*Program\s(?:Options|Arguments):'
                             '(.*)General\sArguments.*',
                             result, re.DOTALL)

        global_options = subprocess.check_output([self.script_executable,
                                                  '--PrintGlobals'],
                                                 env=self.environment,
                                                 cwd=self.path).decode('utf-8')

        # Get the single parameter names
        args = []
        if len(options):
            args += re.findall('.*--(.*?)[?::|=].*', options[0], re.MULTILINE)
        if len(global_options):
            args += [k for k in re.findall('.*--(.*?)[?::|=].*',
                                           global_options, re.MULTILINE) if k
                     not in ['RngRun', 'RngSeed', 'SchedulerType',
                             'SimulatorImplementationType', 'ChecksumEnabled']]
        return sorted(args)
1327155
def get_one_parameter(self, regex_exp, parameters):
        
        Rx, other = self.get_parameters(regex_exp, parameters)
        if other is not None and other.strip():
            raise iarm.exceptions.ParsingError("Extra arguments found: {}".format(other))
        return Rx.upper()
1346113
def _get_wrapper_args(routine):
        
        ret = ''

        for parameter_info in routine['parameters']:
            if ret:
                ret += ', '

            ret += parameter_info['name']

        return ret
202545
def get_default_name(self):
        '''
        
        '''
        long_names = [name for name in self.name if name.startswith("--")]
        short_names = [name for name in self.name if not name.startswith("--")]

        if long_names:
            return to_snake_case(long_names[0].lstrip("-"))

        return to_snake_case(short_names[0].lstrip("-"))
1282431
def _get_input_names(spec):
    
    retval = [feature.name for feature in spec.description.input]
    return retval
649456
public String getParameterName(Parameter parameter) {
    Name annotation = parameter.getAnnotation(Name.class);

    if (null == annotation) {
      return parameter.getName();
    }

    return annotation.value();
  }
1029161
def get_parameter_diff(awsclient, config):
    
    client_cf = awsclient.get_client('cloudformation')
    try:
        stack_name = config['stack']['StackName']
        if stack_name:
            response = client_cf.describe_stacks(StackName=stack_name)
            if response['Stacks']:
                stack_id = response['Stacks'][0]['StackId']
                stack = response['Stacks'][0]
            else:
                return None
        else:
            print(
                'StackName is not configured, could not create parameter diff')
            return None
    except GracefulExit:
        raise
    except Exception:
        # probably the stack is not existent
        return None

    changed = 0
    table = []
    table.append(['Parameter', 'Current Value', 'New Value'])

    # Check if there are parameters for the stack
    if 'Parameters' in stack:
        for param in stack['Parameters']:
            try:
                old = str(param['ParameterValue'])
                # can not compare list with str!!
                # if ',' in old:
                #    old = old.split(',')
                new = config['parameters'][param['ParameterKey']]
                if old != new:
                    if old.startswith('***'):
                        # parameter is configured with `NoEcho=True`
                        # this means we can not really say if the value changed!!
                        # for security reasons we block viewing the new value
                        new = old
                    table.append([param['ParameterKey'], old, new])
                    changed += 1
            except GracefulExit:
                raise
            except Exception:
                print('Did not find %s in local config file' % param[
                    'ParameterKey'])

    if changed > 0:
        print(tabulate(table, tablefmt='fancy_grid'))

    return changed > 0
718139
public function alternateName(): ?string
    {
        if ($this->canShowName() && $this->getPrimaryName() !== $this->getSecondaryName()) {
            $all_names = $this->getAllNames();

            return $all_names[$this->getSecondaryName()]['full'];
        }

        return null;
    }
1204937
def stripped_name(self):
        """"""

        name = self.name

        # Strip function parameters from name by recursively removing paired parenthesis
        while True:
            name, n = self._parenthesis_re.subn('', name)
            if not n:
                break

        # Strip const qualifier
        name = self._const_re.sub('', name)

        # Strip template parameters from name by recursively removing paired angles
        while True:
            name, n = self._angles_re.subn('', name)
            if not n:
                break

        return name