Get live- or testURL.
168912
public function getSecureUrl()
    {
        $defaultUrl = $this->getTestMode() === false
            ? $this->prodSecureHost
            : $this->testSecureHost;
        return $this->parameters->get('secureUrl', $defaultUrl);
    }
1327517
def get_clean_url(self):
        """"""
        if self.needs_auth:
            self.prompt_auth()
        url = RepositoryURL(self.url.full_url)
        url.username = self.username
        url.password = self.password
        return url
781294
def _get_url(method,
             api_url,
             api_version):
    '''
    
    '''
    return '{url}/{version}/{method}.json'.format(url=api_url,
                                                  version=float(api_version),
                                                  method=method)
1209626
function checkUrl(link, baseUrl, cache, options, retry)
{
	var cached;
	
	if (retry === undefined)
	{
		if (isString(link) === true)
		{
			link = linkObj(link);
			linkObj.resolve(link, baseUrl, options);
		}
		
		// TODO :: move out to an `linkObj.invalidate()` to share with `HtmlChecker()` ?
		if (link.url.resolved === null)
		{
			link.broken = true;
			link.brokenReason = "BLC_INVALID";
			linkObj.clean(link);
			return Promise.resolve(link);
		}
		
		cached = cache.get(link.url.parsed);
		
		if (cached !== undefined)
		{
			return Promise.resolve(cached).then( function(response)
			{
				// Cloned to avoid unexpected mutations as a result of user changes
				response = extend({}, response);
				
				copyResponseData(response, link, options);
				
				link.http.cached = true;
				
				return link;
			});
		}
	}
	
	var request = bhttp.request(link.url.resolved,  // TODO :: https://github.com/joepie91/node-bhttp/issues/3
	{
		discardResponse: true,
		headers: { "user-agent":options.userAgent },
		method: retry!==405 ? options.requestMethod : "get"
	})
	.then( function(response)
	{
		response = simpleResponse(response);
		
		if (response.statusCode===405 && options.requestMethod==="head" && options.retry405Head===true && retry!==405)
		{
			// Retry possibly broken server with "get"
			return checkUrl(link, baseUrl, cache, options, 405);
		}
		
		// TODO :: store ALL redirected urls in cache
		if (options.cacheResponses===true && response.url!==link.url.resolved)
		{
			cache.set(response.url, response);  // TODO :: store `request` instead to be consistent?
		}
		
		return response;
	})
	.catch( function(error)
	{
		// The error will be stored as a response
		return error;
	});
	
	if (retry === undefined)
	{
		// Send response to cache -- it will be available to `cache.get()` before being resolved
		if (options.cacheResponses === true)
		{
			cache.set(link.url.parsed, request);
		}
		
		// Send linkObj to caller
		return request.then( function(response)
		{
			copyResponseData(response, link, options);
			
			link.http.cached = false;
			
			return link;
		});
	}
	else
	{
		return request;
	}
}
720658
function getUrlDelay(url) {
    var delay;
    if (options.url && !options.url.test(url)) {
      delay = 0;
    }

    return delay;
  }
605133
def get(self, url, params=None, callback=None, retry=0, **kwargs):
        """"""
        kwargs.setdefault("allow_redirects", True)
        return self.request(
            "get", url=url, params=params, callback=callback, retry=retry, **kwargs
        )
124431
def _get_url(url):
    """"""
    try:
        data = HTTP_SESSION.get(url, stream=True)
        data.raise_for_status()
    except requests.exceptions.RequestException as exc:
        raise FetcherException(exc)

    return data
1205206
def base_url(self):
        """"""
        if self.location in self.known_locations:
            return self.known_locations[self.location]
        elif '.' in self.location or self.location == 'localhost':
            return 'https://' + self.location
        else:
            return 'https://' + self.location + API_HOST_SUFFIX
1035072
def url(self):
        """"""
        url = u'{home_url}{permalink}'.format(home_url=settings.HOME_URL,
                                              permalink=self._permalink)
        url = re.sub(r'/{2,}', r'/', url)
        return url
452611
def _get_url(self, url):
        """"""
        if self.base_url and not url.startswith(('http://', 'https://')):
            return urljoin(self.base_url, url)
        return url
309594
def run_local(client):
  """"""
  webbrowser.open(client.get_auth_uri())
  code = wait_for_redirect()
  return client.get_token(code)
449034
def geturl_req(url):
    """"""
    request = urllib.request.Request(url)
    request.add_header('Authorization', 'token %s' % API_TOKEN)
    try:
        response_url = urllib.request.urlopen(request).geturl()
        return response_url
    except urllib.error.HTTPError:
        exception()
        sys.exit(0)
826225
def get(self, *args, **kwargs):
        """"""
        location = args[0]
        params = self._get_keywords(location, kwargs)
        url = self._create_path(*args)
        request = requests.get(url, params=params)
        content = request.content
        self._request = request
        return self._output(content)
730296
def getPrevUrl(self, url, data):
        """"""
        mo = compile(r"index(\d+)\.html").search(url)
        num = int(mo.group(1)) - 1
        prefix = url.rsplit('/', 1)[0]
        return "%s/index%d.html" % (prefix, num)
33960
function getURL(at, api_url, opts) {
  var params = "?token=" + at;
  if (opts)
    params = params + "&" + querystring.stringify(opts);
  return Constants.API_BASEURL + api_url + params;
}
1346623
function(url) {
		if (silentMode) {
			return;
		}

		console.log(
			colors.bold('\nTesting ' + link(url)) +
				' ... please wait, this may take a minute.'
		);
		if (program.timer) {
			console.time('Total test time');
		}
	}
1279513
def _get(url, params=None):
        """"""
        try:
            response = requests.get(url, params=params)
            response.raise_for_status()
            # If JSON fails, return raw data
            # (e.g. when downloading CSV job logs).
            try:
                return response.json()
            except ValueError:
                return response.text
        except NameError:
            url = '{0}?{1}'.format(url, urllib.urlencode(params))
            return json.loads(urllib2.urlopen(url).read().decode(ENCODING))