Return URL that maps given tracking number on given carrier as
https://api.goshippo.com/tracks/<i>carrier</i>/<i>tracking number</i>
434711
private static String trackingNumberURL(String carrier, String trackingNumber)
			throws AuthenticationException, InvalidRequestException, APIConnectionException, APIException {
		try {
			return String.format("%s/%s/%s", classURL(Track.class), urlEncode(carrier), urlEncode(trackingNumber));
		} catch (UnsupportedEncodingException e) {
			throw new InvalidRequestException("Unable to encode parameters to " + CHARSET
					+ ". Please contact support@goshippo.com for assistance.", null, e);
		}
	}
351517
@Override
	public String getURL(String corpNum, String TOGO) throws PopbillException {
		return getURL(corpNum, null, TOGO);
	}
1267240
protected function generateTrackingUrl($url, $trackingId)
    {
        $trackingUrl = ParserUtil::addUrlParam($url, $this->trackingIdName, $trackingId);
        
        // Pass the base URL if tracking script runs in dev or dev-stay mode.
        if($this->trackingJsMode == 'dev' || $this->trackingJsMode == 'dev-stay'){
            $trackingUrl = ParserUtil::addUrlParam($trackingUrl, 'cctapi', urlencode($this->baseUrl));
        }

        return $trackingUrl;
    }
286898
public function track_link()
    {
        $oUri     = Factory::service('Uri');
        $oEmailer = Factory::service('Emailer', 'nails/module-email');

        $sRef    = $oUri->segment(4);
        $sGuid   = $oUri->segment(5);
        $sHash   = $oUri->segment(6);
        $iLinkId = (int) $oUri->segment(7) ?: null;

        // --------------------------------------------------------------------------

        if (!$sRef || !$oEmailer->validateHash($sRef, $sGuid, $sHash)) {
            show404();
        }

        // --------------------------------------------------------------------------

        $sUrl = $oEmailer->trackLink($sRef, $iLinkId);
        if ($sUrl === false) {
            show404();
        }

        redirect($sUrl);
    }
808966
def _build_url(self, host, sport, method, id, format, parameters):
        
        path = "/".join(filter(None, (sport, method, id)))
        url = "https://" + host + "/" + path + "." + format
        if parameters:
            paramstring = urllib.parse.urlencode(parameters)
            url = url + "?" + paramstring
        return url
232877
def get_hard_track_url(item_id):
    

    streams_url = "https://api.soundcloud.com/i1/tracks/%s/streams/?client_id=%s&app_version=%s" % (
    item_id, AGGRESSIVE_CLIENT_ID, APP_VERSION)
    response = requests.get(streams_url)
    json_response = response.json()

    if response.status_code == 200:
        hard_track_url = json_response['http_mp3_128_url']
        return hard_track_url
    else:
        return None
859994
def _get_url(cls, name, message_model, dispatch_model):
        
        global APP_URLS_ATTACHED

        url = ''

        if dispatch_model is None:
            return url

        if APP_URLS_ATTACHED != False:  # sic!

            hashed = cls.get_dispatch_hash(dispatch_model.id, message_model.id)

            try:
                url = reverse(name, args=[message_model.id, dispatch_model.id, hashed])
                url = '%s%s' % (get_site_url(), url)
            except NoReverseMatch:
                if APP_URLS_ATTACHED is None:
                    APP_URLS_ATTACHED = False

        return url
237144
def LatLngsToGoogleUrl(source, destination, dt):
  """"""
  params = {"saddr": FormatLatLng(source),
            "daddr": FormatLatLng(destination),
            "time": dt.strftime("%I:%M%p"),
            "date": dt.strftime("%Y-%m-%d"),
            "dirflg": "r",
            "ie": "UTF8",
            "oe": "UTF8"}
  url = urlparse.urlunsplit(("http", "maps.google.com", "/maps",
                             urllib.urlencode(params), ""))
  return url
555505
def get_api_url(
        self,
        api_resource,
        auth_token_ticket,
        authenticator,
        private_key,
        service_url=None,
        **kwargs
    ):
        '''
        
        '''
        auth_token, auth_token_signature = self._build_auth_token_data(
            auth_token_ticket,
            authenticator,
            private_key,
            **kwargs
            )
        params = {
            'at': auth_token,
            'ats': auth_token_signature,
            }
        if service_url is not None:
            params['service'] = service_url
        url = '{}?{}'.format(
            self._get_api_url(api_resource),
            urlencode(params),
            )
        return url
135751
public function getTrackingUrl()
    {
        if (!isset($this->parcelnumber)) {
            throw new RuntimeException("Shipment has no parcel number.");
        }

        return sprintf(Api::TRACKING_URL, $this->parcelnumber);
    }
378635
def getATSTemplateMgtURL(self, CorpNum, UserID):
        
        result = self._httpget('/KakaoTalk/?TG=TEMPLATE', CorpNum, UserID)
        return result.url
848338
def url(proto, server, port=None, uri=None):
        """"""
        url_parts = [proto, '://', server]
        if port:
            port = int(port)
            if port < 1 or port > 65535:
                raise ValueError('invalid port value')
            if not ((proto == 'http' and port == 80) or
                    (proto == 'https' and port == 443)):
                url_parts.append(':')
                url_parts.append(str(port))

        if uri:
            url_parts.append('/')
            url_parts.append(requests.utils.quote(uri.strip('/')))

        url_parts.append('/')
        return ''.join(url_parts)
201000
def details(tracking_reference)
      details_url = File.join(PARCELTRACK_URL, tracking_reference.to_s)
      response = @connection.get details_url
      events = response.parsed['results'].tap do |d|
        d['tracking_events'].map {|e| e['event_datetime'] = Time.parse(e['event_datetime'])}
        d['tracking_events'].sort_by! {|k| k['event_datetime'].to_i}
      end
      RecursiveOpenStruct.new(events, recurse_over_arrays: true)
    end
204736
function httpGet(parentSpan, urlString, callback) {
    var span = opentracing.globalTracer().startSpan('http.get', { childOf : parentSpan });
    var callbackWrapper = function (err, data) {
        span.finish();
        callback(err, data);
    };

    try {
        var carrier = {};
        opentracing.globalTracer().inject(span, opentracing.FORMAT_TEXT_MAP, carrier);

        var dest = url.parse(urlString);
        var options = {
            host : PROXY_HOST,
            path : dest.path,
            port : PROXY_PORT,
            headers: {
                // User-Agent is required by the GitHub APIs
                'User-Agent': 'LightStep Example',
            }
        };
        for (var key in carrier) {
            options.headers[key] = carrier[key];
        }

        // Create a span representing the https request
        span.setTag('url', urlString);
        span.log({
            event : 'options',
            'options': options,
        });
        return http.get(options, function(response) {
            var bodyBuffer = '';
            response.on('data', function(chunk) {
                bodyBuffer += chunk;
            });
            response.on('end', function() {
                span.log({
                    body   : bodyBuffer,
                    length : bodyBuffer.length,
                });

                var parsedJSON, err;
                try {
                    parsedJSON = JSON.parse(bodyBuffer);
                } catch (exception) {
                    err = {
                        buffer    : bodyBuffer,
                        exception : exception,
                    };
                    span.setTag('error', true);
                    span.log({
                        event : 'error',
                        'error.object': err,
                    });
                }

                callbackWrapper(err, parsedJSON);
            });
        });
    } catch (exception) {
        span.setTag('error', true);
        span.log({
            event : 'error',
            'error.object': exception,
        });
        callbackWrapper(exception, null);
    }
}
38495
def get_csr(self, bay_number=None):
        
        uri = "{}/https/certificaterequest".format(self.data['uri'])

        if bay_number:
            uri += "?bayNumber=%d" % (bay_number)

        return self._helper.do_get(uri)
1230720
def _url(self, uri):
        """"""
        prefix = "{}://{}{}".format(
            self._protocol,
            self.real_connection.host,
            self._port_postfix(),
        )
        return uri.replace(prefix, '', 1)
781294
def _get_url(method,
             api_url,
             api_version):
    '''
    
    '''
    return '{url}/{version}/{method}.json'.format(url=api_url,
                                                  version=float(api_version),
                                                  method=method)