Retrives a parameter from SSM Parameter Store

    .. versionadded:: Neon

    .. code-block:: text

        salt-call boto_ssm.get_parameter test-param withdescription=True
325839
def get_parameter(name, withdecryption=False, resp_json=False, region=None, key=None, keyid=None, profile=None):
    '''
    
    '''
    conn = __utils__['boto3.get_connection']('ssm', region=region, key=key, keyid=keyid, profile=profile)
    try:
        resp = conn.get_parameter(Name=name, WithDecryption=withdecryption)
    except conn.exceptions.ParameterNotFound:
        log.warning("get_parameter: Unable to locate name: %s", name)
        return False

    if resp_json:
        return json.loads(resp['Parameter']['Value'])
    else:
        return resp['Parameter']['Value']
764405
function getMessage(sKey, aParameters) {
		return sap.ui.getCore().getLibraryResourceBundle().getText(sKey, aParameters);
	}
654090
public boolean recordParameterDescription(
      String parameterName, String description) {
    if (currentInfo.documentParam(parameterName, description)) {
      populated = true;
      return true;
    } else {
      return false;
    }
  }
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)
    )
1040314
def delete_parameter(Name, region=None, key=None, keyid=None, profile=None):
    '''
    
    '''
    conn = __utils__['boto3.get_connection']('ssm', region=region, key=key, keyid=keyid, profile=profile)
    try:
        resp = conn.delete_parameter(Name=Name)
    except conn.exceptions.ParameterNotFound:
        log.warning("delete_parameter: Unable to locate name: %s", Name)
        return False
    if resp['ResponseMetadata']['HTTPStatusCode'] == 200:
        return True
    else:
        return False
509056
def get_parameter(self, name):
        
        i = self.get_parameter_names(include_frozen=True).index(name)
        return self.get_parameter_vector(include_frozen=True)[i]
337312
def __get_param(self, param):
        
        try:
            return self.request_json[param]
        except KeyError:
            raise FnexchangeError(400, 'Bad request: {0} is required'.format(param))
196027
def parameter_action(self, text, loc, par):
        """"""
        exshared.setpos(loc, text)
        if DEBUG > 0:
            print("PARAM:",par)
            if DEBUG == 2: self.symtab.display()
            if DEBUG > 2: return
        index = self.symtab.insert_parameter(par.name, par.type)
        self.shared.function_params += 1
        return index
581378
def _getParameters(self):
        """"""
        param = self.query._getParameters()
        key = self.__PATTERN_KEY % (str(self._getIndex()))
        val = self.__PATTERN_VALUE % (self.__column, self.__value)
        #self.__column.getColumnAlias()
        param.update({key:val})
        return param
861821
def get_param(self, param):
        

        # Imports
        import os
        from ..const import EnumAnharmRepoParam
        from ..error import RepoError as RErr

        # Must be a valid parameter name
        if not param in EnumAnharmRepoParam:
            raise ValueError("'{0}' is not a valid " +
                    "parameter enum value".format(param))
        ## end if

        # Get the params group, complaining if repo not bound
        try:
            grp = self._repo.require_group(self.G_param)
        except AttributeError:
            raise RErr(RErr.STATUS,
                        "Cannot load; no repository open", "")
        ## end try

        # Group should be guaranteed present with 'require_group', try
        #  loading the parameter; complain if not found.
        try:
            out_param = grp.get(param).value
        except AttributeError:
            raise RErr(RErr.DATA,
                    "Parameter '" + param + "' not found",
                    self.fname)
        ## end try

        # Return
        self._repo.flush()
        return out_param
1371552
def get_data(self, request, key='params'):
        
        return request.session.get('%s:%s' % (constants.SESSION_KEY, key))
1345557
def __non_body_parameter_descriptor(self, param):
    
    descriptor = {}

    descriptor['name'] = param.name

    param_type, param_format = self.__field_to_parameter_type_and_format(param)

    # Required
    if param.required:
      descriptor['required'] = True

    # Type
    descriptor['type'] = param_type

    # Format (optional)
    if param_format:
      descriptor['format'] = param_format

    # Default
    default = self.__parameter_default(param)
    if default is not None:
      descriptor['default'] = default

    # Repeated
    if param.repeated:
      descriptor['repeated'] = True

    # Enum
    enum_descriptor = self.__parameter_enum(param)
    if enum_descriptor is not None:
      descriptor['enum'] = enum_descriptor

    return descriptor
780572
def get_params(self, name, param_list):
        '''

        '''
        self.add_cmd_output("lctl get_param %s" % " ".join(param_list),
                            suggest_filename="params-%s" % name,
                            stderr=False)
1219211
def get_parameter(self, index):
        """"""
        result = None
        if index < len(self.paramorder):
            key = self.paramorder[index]
            if key in self._parameters:
                result = self._parameters[key]

        return result
1339121
int findParameterIndex(String parameterName) throws SQLException {

        checkClosed();

        int index = parameterNameMap.get(parameterName, -1);

        if (index >= 0) {
            return index + 1;
        }

        throw Util.sqlException(ErrorCode.JDBC_COLUMN_NOT_FOUND,
                                parameterName);
    }
728931
def query(method='GET', profile_dict=None, url=None, path='api/v1',
          action=None, api_key=None, service=None, params=None,
          data=None, subdomain=None, client_url=None, description=None,
          opts=None, verify_ssl=True):
    '''
    
    '''
    user_agent = 'SaltStack {0}'.format(__version__)

    if opts is None:
        opts = {}

    if isinstance(profile_dict, dict):
        creds = profile_dict
    else:
        creds = {}

    if api_key is not None:
        creds['pagerduty.api_key'] = api_key

    if service is not None:
        creds['pagerduty.service'] = service

    if subdomain is not None:
        creds['pagerduty.subdomain'] = subdomain

    if client_url is None:
        client_url = 'https://{0}.pagerduty.com'.format(
            creds['pagerduty.subdomain']
        )

    if url is None:
        url = 'https://{0}.pagerduty.com/{1}/{2}'.format(
            creds['pagerduty.subdomain'],
            path,
            action
        )

    if params is None:
        params = {}

    if data is None:
        data = {}

    data['client'] = user_agent

    # pagerduty.service is not documented.  While it makes sense to have in
    # some cases, don't force it when it is not defined.
    if 'pagerduty.service' in creds and creds['pagerduty.service'] is not None:
        data['service_key'] = creds['pagerduty.service']
    data['client_url'] = client_url
    if 'event_type' not in data:
        data['event_type'] = 'trigger'
    if 'description' not in data:
        if not description:
            data['description'] = 'SaltStack Event Triggered'
        else:
            data['description'] = description

    headers = {
        'User-Agent': user_agent,
        'Authorization': 'Token token={0}'.format(creds['pagerduty.api_key'])
    }
    if method == 'GET':
        data = {}
    else:
        headers['Content-type'] = 'application/json'

    result = salt.utils.http.query(
        url,
        method,
        params=params,
        header_dict=headers,
        data=salt.utils.json.dumps(data),
        decode=False,
        text=True,
        opts=opts,
    )

    return result['text']
629831
def get_params(self, params, name_request):
        '''
        
        '''
        self.write('')
        for elem in params:
            request_type = elem['type'] if elem.get('type', None) else 'schema'
            name = elem['name']
            if elem.get('required', None):
                name += '(required)'
            schema = elem.get('schema', None)
            name = ':{} {} {}:'.format(name_request, request_type, name)
            if schema:
                definition = schema['$ref'].split('/')[-1]
                self.write(name + ' :ref:`{}`'.format(definition), 1)
                self.write('')
            else:
                desc = elem.get('description', '')
                self.write(name)
                self.write('{}'.format(desc), self.indent_depth + 1)
        self.write('')