Access the Authy Twilio Domain

        :returns: Authy Twilio Domain
        :rtype: twilio.rest.authy.Authy
429170
def authy(self):
        
        if self._authy is None:
            from twilio.rest.authy import Authy
            self._authy = Authy(self)
        return self._authy
71276
def API_GET(self):  # pylint: disable=arguments-differ
        
        if self.user_manager.session_logged_in():
            return 200, {"authenticated": True, "username": self.user_manager.session_username()}
        else:
            return 200, {"authenticated": False}
282273
def get_domain(self):
        
        if self.domain is None:
            return np.array([self.points.min(axis=0), 
                             self.points.max(axis=0)])
        return self.domain
348911
def fetch(self):
        
        params = values.of({})

        payload = self._version.fetch(
            'GET',
            self._uri,
            params=params,
        )

        return IpAddressInstance(
            self._version,
            payload,
            account_sid=self._solution['account_sid'],
            ip_access_control_list_sid=self._solution['ip_access_control_list_sid'],
            sid=self._solution['sid'],
        )
478009
def _authenticate(self):
        """"""
        response = self._get("/v1/domains/{0}".format(self.domain))

        self.domain_id = response["domain"]["id"]
800000
def domain(self):
        
        remove_pac = self.cleanup.replace(
            "https://", "").replace("http://", "").replace("www.", "")
        try:
            return remove_pac.split('/')[0]
        except:
            return None
1040475
def domain_list(auth=None, **kwargs):
    '''
    
    '''
    cloud = get_operator_cloud(auth)
    kwargs = _clean_kwargs(**kwargs)
    return cloud.list_domains(**kwargs)
281857
def fetch(self):
        
        return self.domain._record(self.doapi_manager.request(self.url)\
                                                             ["domain_record"])
372652
def get_authserver(self, domainid, serverid):
        """"""
        return self.api_call(
            ENDPOINTS['authservers']['get'],
            dict(domainid=domainid, serverid=serverid))
1258398
def get_authservers(self, domainid, page=None):
        """"""
        opts = {}
        if page:
            opts['page'] = page
        return self.api_call(
            ENDPOINTS['authservers']['list'],
            dict(domainid=domainid), **opts)
970136
def urlinfo(self, domain, response_group = URLINFO_RESPONSE_GROUPS):
        '''
        
        '''
        params = {
            'Action': "UrlInfo",
            'Url': domain,
            'ResponseGroup': response_group
        }

        url, headers = self.create_v4_signature(params)
        return self.return_output(url, headers)
618184
def current_access(self):
        
        return self.access_for(actor=current_auth.actor, anchors=current_auth.anchors)
533038
def get_auth_bearer(self):
        """"""
        access_token = ''
        auth_header = self.get_header('authorization')
        if auth_header:
            m = re.search(r"^Bearer\s+(\S+)$", auth_header, re.I)
            if m: access_token = m.group(1)

        return access_token
719908
def get(self):
        
        return self.rest_api.get_tokens_list(
            self.rest_api.raiden_api.raiden.default_registry.address,
        )
1050195
def get_authorization_url(self):
        
        return self._build_authorization_request_url(
            response_type=auth.TOKEN_RESPONSE_TYPE,
            redirect_url=self.redirect_url,
        )
1177210
def next_page(self):
        
        if not self.next_page_url:
            return None

        response = self._version.domain.twilio.request('GET', self.next_page_url)
        cls = type(self)
        return cls(self._version, response, self._solution)
1233899
def rest_get(self, url, params=None, headers=None, auth=None, verify=True, cert=None):
        
        res = requests.get(url, params=params, headers=headers, auth=auth, verify=verify,
                           cert=cert)
        return res.text, res.status_code