``param_get <instance_number> <param_symbol>``

        get the value of the request control

        e.g.::

            param_get 0 gain

        :param Lv2Param param: Parameter that will be get your current value
343022
def param_get(param):
        
        instance = param.effect.instance

        return 'param_get {} {}'.format(instance, param.symbol)
1309878
def fetch(self):
        
        params = values.of({})

        payload = self._version.fetch(
            'GET',
            self._uri,
            params=params,
        )

        return NumberInstance(self._version, payload, number=self._solution['number'], )
976092
def get(request_uri, params={})
      sp = signed_params("GET", request_uri, params)
      http_client.get(request_uri, sp)
    end
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
513539
def _get_params_value(params):
    
    # sort params for consistency
    ord_params = sorted(params)

    def fn(obj):
        l = []
        for p in ord_params:
            try:
                l.append((p, obj.parameters[p]))
            except:
                raise ValueError('{} is not a valid parameter'.format(p))
        return tuple(l)
    return fn
624628
def param(sym)
    param_value = @params[sym]
    default_value = self.class.param_named(sym).options[:default]
    return param_value || default_value
  end
259296
def GET(self, func, data):
        
        if func not in ['getRegisterUserInfo']:
            s, message = self.checkAccount()

            if s is False:
                return False, message

        url = nurls[func]
        r = self.session.get(url, params = data)
        r.encoding = 'utf-8'

        if self.debug:
            print r.text

        try:
            try:
                metadata = json.loads(r.text)
            except:
                metadata = json.loads(r.text[r.text.find('{'):-1])

            message = metadata['message']
            if message == 'success':
                return True, metadata['resultvalue']
            else:
                return False, message
        except:
            for e in sys.exc_info():
                print e
            sys.exit(1)
            return False, "Error %s: Failed to send GET request" %func
893110
def get_params(self):
        
        return self.timeout, self.xonxoff, self.rtscts, self.baudrate
264723
def params(self_, parameter_name=None):
        
        if self_.self is not None and self_.self._instance__params:
            self_.warning('The Parameterized instance has instance '
                          'parameters created using new-style param '
                          'APIs, which are incompatible with .params. '
                          'Use the new more explicit APIs on the '
                          '.param accessor to query parameter instances.'
                          'To query all parameter instances use '
                          '.param.objects with the option to return '
                          'either class or instance parameter objects. '
                          'Alternatively use .param[name] indexing to '
                          'access a specific parameter object by name.')

        pdict = self_.objects(instance='existing')
        if parameter_name is None:
            return pdict
        else:
            return pdict[parameter_name]
149226
def get(self, url, data=None, params=None):
        
        return self.request("get", url, data, params)
144481
def url_param2value(param):
    
    if param == None:
        return Null
    if param == None:
        return Null

    def _decode(v):
        output = []
        i = 0
        while i < len(v):
            c = v[i]
            if c == "%":
                d = hex2chr(v[i + 1:i + 3])
                output.append(d)
                i += 3
            else:
                output.append(c)
                i += 1

        output = text_type("".join(output))
        try:
            return json2value(output)
        except Exception:
            pass
        return output

    query = Data()
    for p in param.split('&'):
        if not p:
            continue
        if p.find("=") == -1:
            k = p
            v = True
        else:
            k, v = p.split("=")
            v = _decode(v)

        u = query.get(k)
        if u is None:
            query[k] = v
        elif is_list(u):
            u += [v]
        else:
            query[k] = [u, v]

    return query
1177877
def get(self, param=None, must=[APIKEY]):
        '''
        '''
        param = {} if param is None else param
        r = self.verify_param(param, must)
        if not r.is_succ():
            return r
        handle = CommonResultHandler(lambda rsp: {VERSION_V1:rsp.get(USER), VERSION_V2:rsp}[self.version()])
        return self.path('get.json').post(param, handle, r)
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
403893
def _extract_parameters(
    params: Sequence[ExtensionParameter], *, is_server: bool
) -> Tuple[bool, bool, Optional[int], Optional[Union[int, bool]]]:
    
    server_no_context_takeover: bool = False
    client_no_context_takeover: bool = False
    server_max_window_bits: Optional[int] = None
    client_max_window_bits: Optional[Union[int, bool]] = None

    for name, value in params:

        if name == "server_no_context_takeover":
            if server_no_context_takeover:
                raise DuplicateParameter(name)
            if value is None:
                server_no_context_takeover = True
            else:
                raise InvalidParameterValue(name, value)

        elif name == "client_no_context_takeover":
            if client_no_context_takeover:
                raise DuplicateParameter(name)
            if value is None:
                client_no_context_takeover = True
            else:
                raise InvalidParameterValue(name, value)

        elif name == "server_max_window_bits":
            if server_max_window_bits is not None:
                raise DuplicateParameter(name)
            if value in _MAX_WINDOW_BITS_VALUES:
                server_max_window_bits = int(value)
            else:
                raise InvalidParameterValue(name, value)

        elif name == "client_max_window_bits":
            if client_max_window_bits is not None:
                raise DuplicateParameter(name)
            if is_server and value is None:  # only in handshake requests
                client_max_window_bits = True
            elif value in _MAX_WINDOW_BITS_VALUES:
                client_max_window_bits = int(value)
            else:
                raise InvalidParameterValue(name, value)

        else:
            raise InvalidParameterName(name)

    return (
        server_no_context_takeover,
        client_no_context_takeover,
        server_max_window_bits,
        client_max_window_bits,
    )
1270600
def instance_params
			model = get_model
			# get all params except for id, and the standard dates
			respond_to do |format|
				format.html {  }
				format.json do
					body = JSON.parse(request.body.read)
					if body.is_a? Hash
						pascal = model.model_name.singular_route_key.camelize
						camel = model.model_name.singular_route_key.camelize(:lower)
						snake = model.model_name.singular_route_key
						# instance_name 
						if body.has_key? snake
							params.merge!(body)
						# instanceName
						elsif body.has_key? camel
							params.merge!({snake => body[camel]})
						# InstanceName
						elsif body.has_key? pascal
							params.merge!({snake => body[pascal]})
						else
							params[model.model_name.singular_route_key] = body
						end
					end
				end
			end
			return params.require(model.model_name.singular_route_key.to_sym).permit(model.attribute_names.collect{|x| x.to_sym} - [:id,:created_at,:updated_at])
		end
588728
def param_fetch_one(self, name):
        ''''''
        try:
            idx = int(name)
            self.mav.param_request_read_send(self.target_system, self.target_component, "", idx)
        except Exception:
            self.mav.param_request_read_send(self.target_system, self.target_component, name, -1)
349169
def get_param(self):
        
        cycle_progress = self.event_index / self.cycle_size
        return self.start_value + ((self.end_value - self.start_value) / 2) * (1 - math.cos(math.pi * cycle_progress))