Python parse.parse_qs方法代码示例

# 需要导入模块: from urllib import parse [as 别名]
# 或者: from urllib.parse import parse_qs [as 别名]
def headless_authorize(self):
        """
        Authorize without a display using only TTY.
        """
        url, _ = self.oauth.authorize_token_url(redirect_uri=self.redirect_uri)
        # Ask the user to open this url on a system with browser
        print('\n-------------------------------------------------------------------------')
        print('\t\tOpen the below URL in your browser\n')
        print(url)
        print('\n-------------------------------------------------------------------------\n')
        print('NOTE: After authenticating on Fitbit website, you will redirected to a URL which ')
        print('throws an ERROR. This is expected! Just copy the full redirected here.\n')
        redirected_url = input('Full redirected URL: ')
        params = urlparse.parse_qs(urlparse.urlparse(redirected_url).query)
        print(params['code'][0])
        self.authenticate_code(code=params['code'][0]) 

# 需要导入模块: from urllib import parse [as 别名]
# 或者: from urllib.parse import parse_qs [as 别名]
def totalCount(self):
        if not self.__totalCount:
            params = {} if self.__nextParams is None else self.__nextParams.copy()
            # set per_page = 1 so the totalCount is just the number of pages
            params.update({"per_page": 1})
            headers, data = self.__requester.requestJsonAndCheck(
                "GET",
                self.__firstUrl,
                parameters=params,
                headers=self.__headers
            )
            if 'link' not in headers:
                if data and "total_count" in data:
                    self.__totalCount = data["total_count"]
                elif data:
                    self.__totalCount = len(data)
                else:
                    self.__totalCount = 0
            else:
                links = self.__parseLinkHeader(headers)
                lastUrl = links.get("last")
                self.__totalCount = int(parse_qs(lastUrl)['page'][0])
        return self.__totalCount 

# 需要导入模块: from urllib import parse [as 别名]
# 或者: from urllib.parse import parse_qs [as 别名]
def parse_code_from_url(url: str) -> str:
    """
    Parse an URL for parameter 'code'.

    Returns
    -------
    str
        value of 'code'

    Raises
    ------
    KeyError
        if 'code' is not available or has multiple values
    """
    query = urlparse(url).query
    code = parse_qs(query).get('code', None)

    if code is None:
        raise KeyError('Parameter `code` not available!')
    elif len(code) > 1:
        raise KeyError('Multiple values for `code`!')

    return code[0] 

# 需要导入模块: from urllib import parse [as 别名]
# 或者: from urllib.parse import parse_qs [as 别名]
def urlparams(url, fragment=None, **kwargs):
    """
    Add a fragment and/or query parameters to a URL.

    Existing query string parameters are preserved, unless they conflict
    with the new parameters, in which case they're overridden.
    """
    parsed = urlparse(url)
    query = dict(parse_qs(parsed.query), **kwargs)
    return urlunparse(
        (
            parsed.scheme,
            parsed.netloc,
            parsed.path,
            parsed.params,
            urlencode(query, doseq=True),
            fragment if fragment is not None else parsed.fragment,
        )
    ) 

# 需要导入模块: from urllib import parse [as 别名]
# 或者: from urllib.parse import parse_qs [as 别名]
def test_it_cachebusts_x5u(self, settings):
        signature = SignatureFactory()

        # If none, do not cache bust
        settings.AUTOGRAPH_X5U_CACHE_BUST = None
        serializer = SignatureSerializer(instance=signature)
        url_parts = list(urlparse.urlparse(serializer.data["x5u"]))
        query = urlparse.parse_qs(url_parts[4])
        assert "cachebust" not in query

        # If set, cachebust using the value
        settings.AUTOGRAPH_X5U_CACHE_BUST = "new"
        serializer = SignatureSerializer(instance=signature)
        url_parts = list(urlparse.urlparse(serializer.data["x5u"]))
        query = urlparse.parse_qs(url_parts[4])
        assert "cachebust" in query
        assert len(query["cachebust"]) == 1
        assert query["cachebust"][0] == "new" 

# 需要导入模块: from urllib import parse [as 别名]
# 或者: from urllib.parse import parse_qs [as 别名]
def get_video_id(url):
    parsed_url = urlparse(url)
    if parsed_url.netloc == "youtu.be":
        video_id = parsed_url.path[1:]
        if len(video_id) != 11:
            video_id = None
    else:
        parsed_query = parse_qs(parsed_url.query)
        try:
            video_id = parsed_query["v"]
            if type(video_id) == type(list()):  # TODO: Use isinstance()
                video_id = video_id[0]
        except KeyError:
            video_id = None

    return video_id 

# 需要导入模块: from urllib import parse [as 别名]
# 或者: from urllib.parse import parse_qs [as 别名]
def GET(self, rse):
        """
        Get RSE usage information.

        :param rse: the RSE name.
        """
        header('Content-Type', 'application/x-json-stream')
        source = None
        if ctx.query:
            params = parse_qs(ctx.query[1:])
            if 'source' in params:
                source = params['source'][0]

        try:
            for usage in list_rse_usage_history(rse=rse, issuer=ctx.env.get('issuer'), source=source):
                yield render_json(**usage) + '\n'
        except RSENotFound as error:
            raise generate_http_error(404, 'RSENotFound', error.args[0])
        except RucioException as error:
            raise generate_http_error(500, error.__class__.__name__, error.args[0])
        except Exception as error:
            print(format_exc())
            raise InternalError(error) 

# 需要导入模块: from urllib import parse [as 别名]
# 或者: from urllib.parse import parse_qs [as 别名]
def testRequestToken(self):

    class MockResponse(object):

      def __init__(self, code):
        self.code = code.decode()

      def read(self):
        return ('{"refresh_token": "' + self.code + '456"}').encode()

    def mock_urlopen(unused_url, param):
      return MockResponse(urlparse.parse_qs(param)[b'code'][0])

    # Choose urlopen function to mock based on Python version
    if sys.version_info[0] < 3:
      urlopen_lib = 'urllib2.urlopen'
    else:
      urlopen_lib = 'urllib.request.urlopen'

    with mock.patch(urlopen_lib, new=mock_urlopen):
      auth_code = '123'
      refresh_token = ee.oauth.request_token(auth_code)
      self.assertEqual('123456', refresh_token) 

# 需要导入模块: from urllib import parse [as 别名]
# 或者: from urllib.parse import parse_qs [as 别名]
def get_method(self):
		bsObj=BeautifulSoup(self.body,"html.parser")
		links=bsObj.find_all("a",href=True)
		for a in links:
			url=a["href"]
			if url.startswith("http://") is False or url.startswith("https://") is False or url.startswith("mailto:") is False:
				base=urljoin(self.url,a["href"])
				query=urlparse(base).query
				if query != "":
					Log.warning("Found link with query: "+G+query+N+" Maybe a vuln XSS point")
					
					query_payload=query.replace(query[query.find("=")+1:len(query)],self.payload,1)
					test=base.replace(query,query_payload,1)
					
					query_all=base.replace(query,urlencode({x: self.payload for x in parse_qs(query)}))
					
					Log.info("Query (GET) : "+test)
					Log.info("Query (GET) : "+query_all)
					
					_respon=self.session.get(test)
					if self.payload in _respon.text or self.payload in self.session.get(query_all).text:
						Log.high("Detected XSS (GET) at "+_respon.url)
					else:
						Log.info("This page is safe from XSS (GET) attack but not 100% yet...") 

# 需要导入模块: from urllib import parse [as 别名]
# 或者: from urllib.parse import parse_qs [as 别名]
def get_agents(self, count=1000, name="", listening=""):
        agents = []
        url = f"{self.url}/agents"
        params = {'count': count, 'name': name, 'listening': listening}

        while True:
            response = self._call_api("GET", url, params=params)

            agents = agents + response.get('value', [])

            try:
                # Only retrieve start parameter from next url href since API does NOT include name and listening
                # parameters even if included in original request so the next href can't be used blindly
                query_params = parse_qs(urlparse(response['links']['next']['href']).query)
                # Add or overwrite start parameter for next request
                params['start'] = query_params['start']
            except KeyError:
                # Return current list of agents when there are no more links to follow
                return agents 

# 需要导入模块: from urllib import parse [as 别名]
# 或者: from urllib.parse import parse_qs [as 别名]
def do_GET(self):
        params = urlparse.parse_qs(urlparse.urlparse(self.path).query)
        key = params.get('apikey')
        if not key:
            self.send_response(400)
            return

        self.server.key_queue.put(key[0])

        self.send_response(200)
        self.send_header('Access-Control-Allow-Origin', '*')
        self.send_header('Access-Control-Allow-Methods', 'GET, OPTIONS')
        self.send_header('Content-type', 'text/html')
        self.end_headers()

        page_content = ("""
            <html>
            <header>
             <script>
               window.location.replace("%s/cli_login?keystate=sent");
             </script>
            </header>
            </html>
        """ % (floyd.floyd_web_host)).encode('utf-8')
        self.wfile.write(page_content) 

# 需要导入模块: from urllib import parse [as 别名]
# 或者: from urllib.parse import parse_qs [as 别名]
def filter_result(link):
    try:

        # Valid results are absolute URLs not pointing to a Google domain
        # like images.google.com or googleusercontent.com
        o = urlparse(link, 'http')
        if o.netloc and 'google' not in o.netloc:
            return link

        # Decode hidden URLs.
        if link.startswith('/url?'):
            link = parse_qs(o.query)['q'][0]

            # Valid results are absolute URLs not pointing to a Google domain
            # like images.google.com or googleusercontent.com
            o = urlparse(link, 'http')
            if o.netloc and 'google' not in o.netloc:
                return link

    # Otherwise, or on error, return None.
    except Exception:
        pass
    return None


# Shortcut to search images
# Beware, this does not return the image link. 

# 需要导入模块: from urllib import parse [as 别名]
# 或者: from urllib.parse import parse_qs [as 别名]
def compare_query(url_org, url_compare):
    param_org = parse.parse_qs(parse.urlparse(url_org).query, True)
    param_compare = parse.parse_qs(parse.urlparse(url_compare).query, True)
    for key, value in param_org.items():
        if not (key in param_compare):
            return False
        if value[0].strip():
            if not param_compare[key] == value:
                return False
    return True 

# 需要导入模块: from urllib import parse [as 别名]
# 或者: from urllib.parse import parse_qs [as 别名]
def prepare_query_filters(query):
    filters = {'labels': {}, 'fields': {}}
    if query:
        # set based regex - does not support only field
        labelRegex = re.compile('^(?P<label>.*) (?P<matcher>notin|in)\s?\((?P<values>.*)\)$')

        queries = parse_qs(query)
        if 'labelSelector' in queries:
            for items in queries['labelSelector']:
                # split on , but not inside ()
                r = re.compile(r'(?:[^,(]|\([^)]*\))+')
                for item in r.findall(items):
                    if '=' in item:
                        # equal based requirement
                        key, value = item.split('=')
                        filters['labels'][key] = value
                    else:
                        # set based requirement
                        matches = labelRegex.match(item)
                        if matches is None:
                            continue

                        # split and strip spaces
                        values = [x.strip() for x in matches.group('values').split(',')]
                        key = matches.group('label') + '__' + matches.group('matcher')
                        filters['labels'][key] = values

        if 'fieldSelector' in queries:
            for items in queries['fieldSelector']:
                for item in items.split(','):
                    key, value = item.split('=')
                    filters['fields'][key] = value

    return filters 

# 需要导入模块: from urllib import parse [as 别名]
# 或者: from urllib.parse import parse_qs [as 别名]
def read_request_data(self):  # type: () -> Dict[str, str]
        assert self.headers['Content-Type'] == 'application/x-www-form-urlencoded'

        content = self.read_request_body()
        data_lists = parse_qs(
            content,
            # Strict options:
            keep_blank_values=True,
            strict_parsing=True,
            errors='strict',
        )
        # Flatten the listed values.
        data_flat = {k: v for (k, [v]) in data_lists.items()}
        return data_flat