Python URL.fromString方法代码示例

# 需要导入模块: from nevow.url import URL [as 别名]
# 或者: from nevow.url.URL import fromString [as 别名]
    def test_url(self):
        """
        An L{URL} object is flattened to the appropriate representation of
        itself, whether it is the child of a tag or the value of a tag
        attribute.
        """
        link = URL.fromString("http://foo/fu?bar=baz&bar=baz#quux%2f")
        self.assertStringEqual(
            self.flatten(link),
            "http://foo/fu?bar=baz&bar=baz#quux%2F")
        self.assertStringEqual(
            self.flatten(div[link]),
            '<div>http://foo/fu?bar=baz&amp;bar=baz#quux%2F</div>')
        self.assertStringEqual(
            self.flatten(div(foo=link)),
            '<div foo="http://foo/fu?bar=baz&amp;bar=baz#quux%2F"></div>')
        self.assertStringEqual(
            self.flatten(div[div(foo=link)]),
            '<div><div foo="http://foo/fu?bar=baz&amp;bar=baz#quux%2F"></div>'
            '</div>')

        link = URL.fromString("http://foo/fu?%2f=%7f")
        self.assertStringEqual(
            self.flatten(link),
            "http://foo/fu?%2F=%7F")
        self.assertStringEqual(
            self.flatten(div[link]),
            '<div>http://foo/fu?%2F=%7F</div>')
        self.assertStringEqual(
            self.flatten(div(foo=link)),
            '<div foo="http://foo/fu?%2F=%7F"></div>')

# 需要导入模块: from nevow.url import URL [as 别名]
# 或者: from nevow.url.URL import fromString [as 别名]
    def test_getSelectedTabExactMatch(self):
        """
        Check that L{webnav.getSelectedTab} returns the tab whose C{linkURL}
        attribute exactly matches the path of the L{nevow.url.URL} it is passed
        """

        tabs = list(webnav.Tab(str(i), None, 0, linkURL="/" + str(i)) for i in xrange(5))

        for (i, tab) in enumerate(tabs):
            selected = webnav.getSelectedTab(tabs, URL.fromString(tab.linkURL))
            self.assertIdentical(selected, tab)

        selected = webnav.getSelectedTab(tabs, URL.fromString("/XYZ"))
        self.failIf(selected)

# 需要导入模块: from nevow.url import URL [as 别名]
# 或者: from nevow.url.URL import fromString [as 别名]
    def __init__(self, url, tries=10, timeout=defaultTimeout, *a, **kw):
        """
        Prepare the download information.

        Any additional positional or keyword arguments are passed on to
        C{twisted.web.client.HTTPPageGetter}.

        @type url: C{nevow.url.URL} or C{unicode} or C{str}
        @param url: The HTTP URL to attempt to download

        @type tries: C{int}
        @param tries: The maximum number of retry attempts before giving up

        @type timeout: C{float}
        @param timeout: Timeout value, in seconds, for the page fetch;
            defaults to L{defaultTimeout}
        """
        if isinstance(url, unicode):
            url = url.encode('utf-8')
        if isinstance(url, str):
            url = URL.fromString(url)

        self.url = url.anchor(None)
        self.args = a
        self.kwargs = kw
        self.delay = self.initialDelay
        self.tries = tries
        self.timeout = timeout

# 需要导入模块: from nevow.url import URL [as 别名]
# 或者: from nevow.url.URL import fromString [as 别名]
def checkid_setup(registry, requestData, user=None):
	"""
	This method will validate and redirect a successful request to its
	return_to param. If the user isn't logged in, or doesn't have an account,
	we'll redirect to an internal page.
	
	@param registry: the current OpenID registry
	@type registry: L{OpenIDRegistry}
	
	@param requestData: the current request data
	@type requestData: L{OpenIDRequest}
	
	@param user: the current user
	@type user: L{txopenid.user.User}
	
	@return: association response
	@rtype: L{nevow.url.URL}
	"""
	if(user is not None):
		def _identity_state():
			return user.hasIdentity(requestData['openid.identity'])
		
		def _trust_state():
			 return user.trustsRoot(requestData['openid.trust_root'])
		
		if not(yield maybeDeferred(_identity_state)):
			return_to = util.appendQuery(OPENID_IDENTITY_URL, requestData)
		elif not(yield maybeDeferred(_trust_state)):
			return_to = util.appendQuery(OPENID_TRUST_URL, requestData)
		else:
			return_to = get_login_response(registry, requestData)
	else:
		return_to = util.appendQuery(OPENID_LOGIN_URL, requestData)
	
	returnValue(URL.fromString(return_to))

# 需要导入模块: from nevow.url import URL [as 别名]
# 或者: from nevow.url.URL import fromString [as 别名]
    def test_finish(self):
        """
        L{StylesheetRewritingRequestWrapper.finish} causes all written bytes to
        be translated with C{_replace} written to the wrapped request.
        """
        stylesheetFormat = """
            .foo {
                background-image: url(%s)
            }
        """
        originalStylesheet = stylesheetFormat % ("/Foo/bar",)
        expectedStylesheet = stylesheetFormat % ("/bar/Foo/bar",)

        request = FakeRequest()
        roots = {request: URL.fromString('/bar/')}
        wrapper = website.StylesheetRewritingRequestWrapper(
            request, [], roots.get)
        wrapper.write(originalStylesheet)
        wrapper.finish()
        # Parse and serialize both versions to normalize whitespace so we can
        # make a comparison.
        parser = CSSParser()
        self.assertEqual(
            parser.parseString(request.accumulator).cssText,
            parser.parseString(expectedStylesheet).cssText)

# 需要导入模块: from nevow.url import URL [as 别名]
# 或者: from nevow.url.URL import fromString [as 别名]
    def rendered(request):
        if request.redirected_to is None:
            result.callback(request)
        else:
            visited.append(request.redirected_to)

            if visited.index(request.redirected_to) != len(visited) - 1:
                visited.append(request.redirected_to)
                result.errback(Exception("Redirect loop: %r" % (visited,)))
            elif len(visited) > redirectLimit:
                result.errback(Exception("Too many redirects: %r" % (visited,)))
            else:
                newHeaders = headers.copy()

                # Respect redirects
                location = URL.fromString(request.redirected_to)
                newHeaders['host'] = location.netloc

                # Respect cookies
                cookies.update(request.cookies)

                # str(URL) shouldn't really do what it does.
                page = getResource(
                    site, str(location), newHeaders, cookies)
                page.addCallbacks(rendered, result.errback)

# 需要导入模块: from nevow.url import URL [as 别名]
# 或者: from nevow.url.URL import fromString [as 别名]
 def test_parseURLs(self):
     """
     L{eridanus.iriparse.parseURL} extracts and parses (as a
     L{nevow.url.URL}) all URIs in a string.
     """
     self.assertEquals(
         list(iriparse.parseURLs(u'http://google.com/')),
         [URL.fromString(u'http://google.com/')])

# 需要导入模块: from nevow.url import URL [as 别名]
# 或者: from nevow.url.URL import fromString [as 别名]
 def test_parseURL(self):
     """
     L{eridanus.iriparse.parseURL} extracts and parses (as a
     L{nevow.url.URL}) the first URI in a string.
     """
     self.assertEquals(
         iriparse.parseURL(
             u'http://google.com/ http://foo.bar/ world'),
         URL.fromString(u'http://google.com/'))

# 需要导入模块: from nevow.url import URL [as 别名]
# 或者: from nevow.url.URL import fromString [as 别名]
 def evaluate(self, expn):
     """
     Evaluate an expression.
     """
     url = URL.fromString('http://www.google.com/search?')
     url = url.add('q', expn + '=')
     url = url.add('num', '1')
     d = self._fetch(url)
     d.addCallback(self._extractResult, expn)
     return d

# 需要导入模块: from nevow.url import URL [as 别名]
# 或者: from nevow.url.URL import fromString [as 别名]
 def test_replaceMantissa(self):
     """
     L{StylesheetRewritingRequestWrapper._replace} changes URLs of the form
     I{/Mantissa/foo} to I{<rootURL>/static/mantissa-base/foo}.
     """
     request = object()
     roots = {request: URL.fromString('/bar/')}
     wrapper = website.StylesheetRewritingRequestWrapper(request, [], roots.get)
     self.assertEqual(
         wrapper._replace('/Mantissa/foo.png'),
         '/bar/static/mantissa-base/foo.png')

# 需要导入模块: from nevow.url import URL [as 别名]
# 或者: from nevow.url.URL import fromString [as 别名]
    def rootChild_resetPassword(self, req, webViewer):
        """
        Redirect authenticated users to their settings page (hopefully they
        have one) when they try to reset their password.

        This is the wrong way for this functionality to be implemented.  See
        #2524.
        """
        from xmantissa.ixmantissa import IWebTranslator, IPreferenceAggregator
        return URL.fromString(
            IWebTranslator(self.store).linkTo(
                IPreferenceAggregator(self.store).storeID))

# 需要导入模块: from nevow.url import URL [as 别名]
# 或者: from nevow.url.URL import fromString [as 别名]
 def test_replaceOtherOffering(self):
     """
     L{StylesheetRewritingRequestWrapper._replace} changes URLs of the form
     I{/Something/foo} to I{<rootURL>/static/Something/foo} if C{Something}
     gives the name of an installed offering with a static content path.
     """
     request = object()
     roots = {request: URL.fromString('/bar/')}
     wrapper = website.StylesheetRewritingRequestWrapper(request, ['OfferingName'], roots.get)
     self.assertEqual(
         wrapper._replace('/OfferingName/foo.png'),
         '/bar/static/OfferingName/foo.png')

# 需要导入模块: from nevow.url import URL [as 别名]
# 或者: from nevow.url.URL import fromString [as 别名]
    def renderHTTP(self, ctx):
        req = inevow.IRequest(ctx)
        password = req.args.get('password', [None])[0]

        if password is None:
            return Page.renderHTTP(self, ctx)

        self.original.store.transact(self.original.setPassword,
                                     unicode(password)) # XXX TODO: select
                                                        # proper decoding
                                                        # strategy.
        return URL.fromString('/')

# 需要导入模块: from nevow.url import URL [as 别名]
# 或者: from nevow.url.URL import fromString [as 别名]
 def test_shortURL(self):
     """
     L{StylesheetRewritingRequestWrapper._replace} changes URLs with only
     one segment so they are beneath the root URL.
     """
     request = object()
     roots = {request: URL.fromString('/bar/')}
     wrapper = website.StylesheetRewritingRequestWrapper(
         request, [], roots.get)
     self.assertEqual(
         wrapper._replace('/'),
         '/bar/')

# 需要导入模块: from nevow.url import URL [as 别名]
# 或者: from nevow.url.URL import fromString [as 别名]
 def test_nonOfferingOnlyGivenPrefix(self):
     """
     L{StylesheetRewritingRequestWrapper._replace} only changes URLs of the
     form I{/Something/foo} so they are beneath the root URL if C{Something}
     does not give the name of an installed offering.
     """
     request = object()
     roots = {request: URL.fromString('/bar/')}
     wrapper = website.StylesheetRewritingRequestWrapper(
         request, ['Foo'], roots.get)
     self.assertEqual(
         wrapper._replace('/OfferingName/foo.png'),
         '/bar/OfferingName/foo.png')