Return the url of the LinkedIn authentication page
502225
public function getAuthenticationUrl($type = 'private')
    {
        if (!$this->getRedirect()) {
            throw new \Exception('please set a redirect url for your permissions request');
        }

        $config = $this->getConfig();
        if (!isset($config['dataset'][$type])) {
            // @todo Is this configurable?
            throw new \Exception('unknown action. please check your apiconfig.yml file for the available types');
        }

        $params = array();
        $params['response_type'] = 'code';
        $params['client_id'] = $config['api_key'];
        $params['redirect_uri'] = $this->getRedirect();
        $params['scope'] = $config['dataset'][$type]['scope'];
        $params['state'] = $this->resetState()->getState();

        $url = $config['urls']['auth'] . '?' . http_build_query($params);

        return $url;
    }
1261332
async def _get_auth_page(self) -> str:
        
        # Prepare request
        params = {
            'client_id': self.app_id,
            'redirect_uri': 'https://oauth.vk.com/blank.html',
            'display': 'mobile',
            'response_type': 'token',
            'v': self.API_VERSION
        }
        if self.scope:
            params['scope'] = self.scope

        # Send request
        status, response = await self.driver.get_text(self.AUTH_URL, params)

        # Process response
        if status != 200:
            error_dict = json.loads(response)
            raise VkAuthError(error_dict['error'], error_dict['error_description'], self.AUTH_URL, params)
        return response
118658
def url(self):
        
        with switch_window(self._browser, self.name):
            return self._browser.url
1241590
def get_pre_auth_url_m(self, redirect_uri):
        
        url = "https://mp.weixin.qq.com/safe/bindcomponent?action=bindcomponent&auth_type=3&no_scan=1&"
        redirect_uri = quote(redirect_uri, safe='')
        return "{0}component_appid={1}&pre_auth_code={2}&redirect_uri={3}".format(
            url, self.component_appid, self.create_preauthcode()['pre_auth_code'], redirect_uri
        )
1364654
def get_url(self, secure=False, longurl=False):
        
        driver_name = self.driver.name.lower()
        try:
            # Currently only Cloudfiles and Local supports it
            url = self._obj.get_cdn_url()
            if "local" in driver_name:
                url = url_for(SERVER_ENDPOINT,
                              object_name=self.name,
                              _external=longurl)
        except NotImplementedError as e:
            object_path = '%s/%s' % (self.container.name, self.name)
            if 's3' in driver_name:
                base_url = 'http://%s' % self.driver.connection.host
                url = urljoin(base_url, object_path)
            elif 'google' in driver_name:
                url = urljoin('http://storage.googleapis.com', object_path)
            elif 'azure' in driver_name:
                base_url = ('http://%s.blob.core.windows.net' % self.driver.key)
                url = urljoin(base_url, object_path)
            else:
                raise e

        if secure:
            if 'cloudfiles' in driver_name:
                parsed_url = urlparse(url)
                if parsed_url.scheme != 'http':
                    return url
                split_netloc = parsed_url.netloc.split('.')
                split_netloc[1] = 'ssl'
                url = urlunparse(
                    'https',
                    '.'.join(split_netloc),
                    parsed_url.path,
                    parsed_url.params, parsed_url.query,
                    parsed_url.fragment
                )
            if ('s3' in driver_name or
                    'google' in driver_name or
                    'azure' in driver_name):
                url = url.replace('http://', 'https://')
        return url
870335
def authorize_url(self, scope='', **kwargs):
        
        self._check_configuration("site", "authorization_url", "redirect_uri",
                                  "client_id")
        if isinstance(scope, (list, tuple, set, frozenset)):
            self._check_configuration("scope_sep")
            scope = self.scope_sep.join(scope)
        oauth_params = {
            'redirect_uri': self.redirect_uri,
            'client_id': self.client_id,
            'scope': scope,
        }
        oauth_params.update(kwargs)
        return "%s%s?%s" % (self.site, quote(self.authorization_url),
                            urlencode(oauth_params))
425313
def get_auth_url(self, app_id, canvas_url, perms=None, **kwargs):
        """"""
        url = "{0}{1}/{2}".format(
            FACEBOOK_WWW_URL, self.version, FACEBOOK_OAUTH_DIALOG_PATH
        )

        args = {"client_id": app_id, "redirect_uri": canvas_url}
        if perms:
            args["scope"] = ",".join(perms)
        args.update(kwargs)
        return url + urlencode(args)
1005897
def get_url(access_token, endpoint=ams_rest_endpoint, flag=True):
    '''
    '''
    return do_ams_get_url(endpoint, access_token, flag)
943084
public function get_url() {
        if ($this->other['badgetype'] == BADGE_TYPE_COURSE) {
            // Course badge.
            $return = new \moodle_url('/badges/index.php',
                    array('type' => BADGE_TYPE_COURSE, 'id' => $this->other['courseid']));
        } else {
            // Site badge.
            $return = new \moodle_url('/badges/index.php', array('type' => BADGE_TYPE_SITE));
        }
        return $return;
    }
1293928
def __get_oauth_url(self, url, method, **kwargs):
        
        oauth = OAuth(
            url=url,
            consumer_key=self.consumer_key,
            consumer_secret=self.consumer_secret,
            version=self.version,
            method=method,
            oauth_timestamp=kwargs.get("oauth_timestamp", int(time()))
        )

        return oauth.get_oauth_url()
299304
def get_auth(self):
        """"""
        auth_resp = get_with_retry(self.cerberus_url + '/v2/auth/user',
                                 auth=(self.username, self.password),
                                 headers=self.HEADERS)

        if auth_resp.status_code != 200:
            throw_if_bad_response(auth_resp)

        return auth_resp.json()
551304
def get_url endpoint, method
      api = @wp_api ? 'wp-json' : 'wc-api'
      url = @url
      url = "#{url}/" unless url.end_with? "/"
      url = "#{url}#{api}/#{@version}/#{endpoint}"

      @is_ssl ? url : oauth_url(url, method)
    end
73128
def get_authorize_url(self, redirect_uri, **kw):
        '''
        
        '''
        redirect = redirect_uri if redirect_uri else self._redirect_uri
        if not redirect:
            raise APIError('21305', 'Parameter absent: redirect_uri', 'OAuth2 request')
        response_type = kw.pop('response_type', 'code')
        return 'https://api.weibo.com/oauth2/authorize?%s' % \
               _encode_params(client_id=self._client_id,
                              response_type=response_type,
                              redirect_uri=redirect, **kw)
465293
def get_oauth_url(self):
        
        params = OrderedDict()

        if "?" in self.url:
            url = self.url[:self.url.find("?")]
            for key, value in parse_qsl(urlparse(self.url).query):
                params[key] = value
        else:
            url = self.url

        params["oauth_consumer_key"] = self.consumer_key
        params["oauth_timestamp"] = self.timestamp
        params["oauth_nonce"] = self.generate_nonce()
        params["oauth_signature_method"] = "HMAC-SHA256"
        params["oauth_signature"] = self.generate_oauth_signature(params, url)

        query_string = urlencode(params)

        return "%s?%s" % (url, query_string)
786095
def url(self):
        """"""
        return self.get_url(self.world, self.category, self.vocation, self.page)
1263455
def provider_login_url(parser, token):
    
    bits = token.split_contents()
    provider_id = bits[1]
    params = token_kwargs(bits[2:], parser, support_legacy=False)
    return ProviderLoginURLNode(provider_id, params)
908535
def page_url(self) -> str:
        """"""
        url = self.attributes['canonicalurl']
        assert isinstance(url, str)
        return url