Returns data about a specific parameter.

        :param core_param: The ``Parameter`` to introspect
        :type core_param: A ``<botocore.parameters.Parameter>`` subclass

        :returns: A dict of the relevant information
504529
def parse_param(self, core_param):
        
        return {
            'var_name': core_param.py_name,
            'api_name': core_param.name,
            'required': core_param.required,
            'docs': self.strip_html(core_param.documentation),
            'type': core_param.type,
        }
999072
def parameter(self, name=None, value=None, **kwargs):
        
        return self.nest(Parameter(name=name, value=value, **kwargs))
982178
def query_params(*es_query_params):
    

    def _wrapper(func):
        @wraps(func)
        def _wrapped(*args, **kwargs):
            params = {}
            if "params" in kwargs:
                params = kwargs.pop("params").copy()
            for p in es_query_params + GLOBAL_PARAMS:
                if p in kwargs:
                    v = kwargs.pop(p)
                    if v is not None:
                        params[p] = _escape(v)

            # don't treat ignore and request_timeout as other params to avoid escaping
            for p in ("ignore", "request_timeout"):
                if p in kwargs:
                    params[p] = kwargs.pop(p)
            return func(*args, params=params, **kwargs)

        return _wrapped

    return _wrapper
897002
def getParam(self, paramName):
        
        param = getattr(self, paramName)
        if isinstance(param, Param):
            return param
        else:
            raise ValueError("Cannot find param with name %s." % paramName)
124561
def parameters(self):
        
        parameters = []
        for hl in self.hidden_layers:
            parameters.extend(hl.parameters)
        parameters.extend(self.top_layer.parameters)
        return parameters
709432
def parameters(self):
        
        pyname = self.pyname
        if isinstance(pyname, pynames.ImportedName):
            pyname = pyname._get_imported_pyname()
        if isinstance(pyname, pynames.DefinedName):
            pyobject = pyname.get_object()
            if isinstance(pyobject, pyobjects.AbstractFunction):
                return pyobject.get_param_names()
225824
def _get_param_values(self, name):
        
        for param in self.data.get('paParameters', []):
            for _pa_parameter, values in param.items():
                if values.get('name') == name:
                    return values
479526
def select_param(param_name, default=None):
    

    def select_param(_value, _context, **params):
        return params.pop(param_name, default)

    return select_param
189627
def get_params(self, deep=False):
        
        attrs = self.__dict__
        for attr in self._include:
            attrs[attr] = getattr(self, attr)

        if deep is True:
            return attrs
        return dict([(k,v) for k,v in list(attrs.items()) \
                     if (k[0] != '_') \
                        and (k[-1] != '_') \
                        and (k not in self._exclude)])
865027
def _param(self):
        
        class Parameters(object):
            def __getitem__(_self, name):
                return self.getParameter(name)

            def __setitem__(_self, name, value):
                if isinstance(value, (float, int, basestring)):
                    self.getParameter(name).set(value)
                else:
                    self.getParameter(name).setValues(value)

            def __iter__(_self):
                return self.getParameters()

        return Parameters()
841134
def get_params(self):
        
        return self.enabled, self.size, self.chunk_delay, self.start_delay
520333
def params(self):
        
        params = {}
        params["access_token"] = self.access_token
        params["account_id"] = self.account_id
        params["alert_id"] = self.alert_id
        params["mention_id"] = self.mention_id
        params["before_date"] = self.before_date if self.before_date else ""

        if self.limit:
            if int(self.limit) > 1000:
                params["limit"] = "1000"
            elif int(self.limit) < 1:
                params["limit"] = ""
            else:
                params["limit"] = self.limit

        return params
899715
def _get_model_param_names(cls):
        """
        # fetch model parameters
        if hasattr(cls, 'set_model_params'):
            # introspect the constructor arguments to find the model parameters
            # to represent
            args, varargs, kw, default = getargspec_no_self(cls.set_model_params)
            if varargs is not None:
                raise RuntimeError("PyEMMA models should always specify their parameters in the signature"
                                   " of their set_model_params (no varargs). %s doesn't follow this convention."
                                   % (cls,))
            return args
        else:
            # No parameters known
            return []
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')
        }
405026
def get_param(self):
        
        return dict(userName=self.username, sessionId=self.session_id, database=self.database)
787759
def get_parameter_dict(self, include_frozen=False):
        
        return OrderedDict(zip(
            self.get_parameter_names(include_frozen=include_frozen),
            self.get_parameter_vector(include_frozen=include_frozen),
        ))
459880
def getparam(self, name, default=None, parents=False):
        '''
        '''
        value = getattr(self, name, None)
        if value is None:
            if parents and self._parent:
                return self._parent.getparam(name, default, parents)
            else:
                return default
        else:
            return value