Log out information about the arguments given.

    The arguments provided to this function correspond to the arguments that
    one can pass to ``requests.request``.

    :return: Nothing is returned.
495552
def _log_request(method, url, kwargs, data=None, params=None):
    
    logger.debug(
        'Making HTTP %s request to %s with %s, %s and %s.',
        method,
        url,
        'options {0}'.format(kwargs) if len(kwargs) > 0 else 'no options',
        'params {0}'.format(params) if params else 'no params',
        'data {0}'.format(data) if data is not None else 'no data',
    )
1161653
def logout(request, next_page=None):
    

    auth.logout(request)

    if not next_page:
        next_page = _redirect_url(request)

    if settings.CAS_LOGOUT_COMPLETELY:
        return HttpResponseRedirect(_logout_url(request, next_page))
    else:
        return HttpResponseRedirect(next_page)
810255
def _get(self, *args, **kwargs):
        

        if 'timeout' not in kwargs:
            kwargs['timeout'] = self.timeout

        req = self.session.get(*args, **kwargs)
        return req
528945
def _do_logoff(self):
        
        session_uri = '/api/sessions/this-session'
        self.delete(session_uri, logon_required=False)
        self._session_id = None
        self._session = None
        self._headers.pop('X-API-Session', None)
1282278
def _get(self, *args, **kwargs):
        
        return self._request(requests.get, *args, **kwargs)
90668
def request_info(self, request):

		

		# We have to re-resolve the request path here, because the information
		# is not stored on the request.
		view, args, kwargs = resolve(request.path)
		for i, arg in enumerate(args):
			kwargs[i] = arg

		parameters = {}
		parameters.update(kwargs)
		parameters.update(request.POST.items())

		environ = request.META

		return {
				"session": dict(request.session),
				'cookies': dict(request.COOKIES),
				'headers': dict(get_headers(environ)),
                'env': dict(get_environ(environ)),
				"remote_ip": request.META["REMOTE_ADDR"],
				"parameters": parameters,
				"action": view.__name__,
				"application": view.__module__,
				"method": request.method,
				"url": request.build_absolute_uri()
		}
820786
def get_logout_url(self, redirect_url=None):
        """"""
        url = urllib_parse.urljoin(self.server_url, 'logout')
        if redirect_url:
            params = {self.logout_redirect_param_name: redirect_url}
            url += '?' + urllib_parse.urlencode(params)
        return url
1275642
def _logout_request(self):
        """"""
        _LOGGER.debug('logout')
        url = 'http://' + self._host + '/login_sid.lua'
        params = {
            'security:command/logout': '1',
            'sid': self._sid
        }

        self._request(url, params)
776112
def logout(self):
        
        if current_user.is_authenticated:
            self.security_service.logout_user()

        if request.is_json:
            return '', HTTPStatus.NO_CONTENT

        self.flash(_('flask_unchained.bundles.security:flash.logout'),
                   category='success')
        return self.redirect('SECURITY_POST_LOGOUT_REDIRECT_ENDPOINT')
713992
def from_request(request=None) -> dict:
    

    request = request if request else flask_request

    try:
        json_args = request.get_json(silent=True)
    except Exception:
        json_args = None

    try:
        get_args = request.values
    except Exception:
        get_args = None

    arg_sources = list(filter(
        lambda arg: arg is not None,
        [json_args, get_args, {}]
    ))

    return arg_sources[0]
230549
def request(self, *args, **kwargs):
        
        return self.session.request(*args, **self.get_kwargs(**kwargs))
246918
def request_args(self):
        '''
        
        '''
        kwargs = {}
        kwargs.update(self.request.match_info.items())
        kwargs.update(self.request.query.items())
        return kwargs
113146
def removeRequest(self, service, *args):
        
        if isinstance(service, RequestWrapper):
            if self.logger:
                self.logger.debug('Removing request: %s',
                    self.requests[self.requests.index(service)])
            del self.requests[self.requests.index(service)]

            return

        for request in self.requests:
            if request.service == service and request.args == args:
                if self.logger:
                    self.logger.debug('Removing request: %s',
                        self.requests[self.requests.index(request)])
                del self.requests[self.requests.index(request)]

                return

        raise LookupError("Request not found")
681951
def do_timeout(self, args):
        

        if not self.current:
            print('There are no resources in use. Use the command "open".')
            return

        args = args.strip()

        if not args:
            try:
                print('Timeout: {}ms'.format(self.current.timeout))
            except Exception as e:
                print(e)
        else:        
            args = args.split(' ')
            try:
                self.current.timeout = float(args[0])
                print('Done')
            except Exception as e:
                print(e)
805527
def get_dict_of_all_args(self):
        
        dictionary = {}
        for arg in [arg for arg in self.request.arguments if arg not in self.settings.get("reserved_query_string_params", [])]:
            val =  self.get_argument(arg, default=None)
            if val:
                dictionary[arg] = val
        return dictionary
1164702
def get_query_arguments(self, name: str, strip: bool = True) -> List[str]:
        
        return self._get_arguments(name, self.request.query_arguments, strip)
970494
def logout(request):
    """"""
    request.response.headers.extend(forget(request))
    return {'redirect': request.POST.get('came_from', '/')}