Fetches all those a given account is
        following and sees if they have muted that
        account.
969705
def muted_me(self, account=None, limit=100):
        ''' 
        '''
        self.has_muted = []
        if account is None:
            account = self.mainaccount
        following = self.following(account, limit)
        if following is False:
            self.msg.error_message("COULD NOT GET FOLLOWING FOR MUTED")
            return False
        for f in following:
            h = self.get_my_history(f)
            for a in h:
                if a[1]['op'][0] == "custom_json":
                    j = a[1]['op'][1]['json']
                    d = json.loads(j)
                    try:
                        d[1]
                    except:
                        pass
                    else:
                        for i in d[1]:
                            if i == "what":
                                if len(d[1]['what']) > 0:
                                    if d[1]['what'][0] == "ignore":
                                        if d[1]['follower'] == account:
                                            self.msg.message("MUTED BY " + f)
                                            self.has_muted.append(f)
        return self.has_muted
1201786
def get_account_history(self, address, offset=None, count=None):
        
        cur = self.db.cursor()
        return namedb_get_account_history(cur, address, offset=offset, count=count)
1047358
def getVerificators(self):
        
        verifiers = list()
        actions = ["verify", "multi_verify"]
        for event in wf.getReviewHistory(self):
            if event['action'] in actions:
                verifiers.append(event['actor'])
        sorted(verifiers, reverse=True)
        return verifiers
1054632
def get_all(cls, account_id=None, location=None):
        
        qry = db.Enforcements.filter()

        if account_id:
            qry = qry.filter(account_id == Enforcements.account_id)

        if location:
            qry = qry.join(Resource, Resource.location == location)

        return qry
455846
def abort_all_pending_sis_imports(self, account_id):
        
        path = {}
        data = {}
        params = {}

        # REQUIRED - PATH - account_id
        """ID"""
        path["account_id"] = account_id

        self.logger.debug("PUT /api/v1/accounts/{account_id}/sis_imports/abort_all_pending with query params: {params} and form data: {data}".format(params=params, data=data, **path))
        return self.generic_request("PUT", "/api/v1/accounts/{account_id}/sis_imports/abort_all_pending".format(**path), data=data, params=params)
135891
def get_removes(self, profile=None):
        
        out = []
        for rem in self.removes:
            # Filter Remove by profile
            if ((rem.profile and not profile) or
               (rem.profile and profile and rem.profile != profile)):
                continue
            out.append(rem)
        return out
279007
def get_account_details(self):
        
        headers = self._manager.get_account_headers()
        acct_prefix = "x-account-"
        meta_prefix = ACCOUNT_META_PREFIX.lower()
        ret = {}
        for hkey, hval in list(headers.items()):
            lowkey = hkey.lower()
            if lowkey.startswith(acct_prefix):
                if not lowkey.startswith(meta_prefix):
                    cleaned = hkey.replace(acct_prefix, "").replace("-", "_")
                    try:
                        # Most values are ints
                        ret[cleaned] = int(hval)
                    except ValueError:
                        ret[cleaned] = hval
        return ret
802391
def GetAccounts(alias=None):
		""""""
		if alias is not None:  payload = {'AccountAlias': alias}
		else:  payload = {}
		r = clc.v1.API.Call('post','Account/GetAccounts',payload)
		if int(r['StatusCode']) == 0:  
			# Assume first response is always the original account.  Not sure if this is reliable
			if not clc.ALIAS:  clc.ALIAS = r['Accounts'][0]['AccountAlias']
			if not clc.LOCATION:  clc.LOCATION = r['Accounts'][0]['Location']

			return(r['Accounts'])
1224345
def get_sepa_accounts(self):
        

        with self._get_dialog() as dialog:
            response = dialog.send(HKSPA1())
            
        self.accounts = []
        for seg in response.find_segments(HISPA1, throw=True):
            self.accounts.extend(seg.accounts)

        return [a for a in [acc.as_sepa_account() for acc in self.accounts] if a]
174850
def count_unread_messages_for(self, user):
        
        unread_total = self.filter(user=user,
                                   read_at__isnull=True,
                                   deleted_at__isnull=True).count()

        return unread_total
833185
def find_behind_subscriptions(self, request):
        

        task_id = find_behind_subscriptions.delay()
        return Response(
            {"accepted": True, "task_id": str(task_id)}, status=status.HTTP_202_ACCEPTED
        )
1342091
def GET_account_history(self, path_info, account_addr):
        
        if not check_account_address(account_addr):
            return self._reply_json({'error': 'Invalid address'}, status_code=400)

        qs_values = path_info['qs_values']
        page = qs_values.get('page', None)

        if page is None:
            page = "0" # compatibility

        try:
            assert len(page) < 10
            page = int(page)

            assert page >= 0
        except:
            return self._reply_json({'error': 'Invalid start block or end block or invalid page'}, status_code=400)

        blockstackd_url = get_blockstackd_url()
        res = blockstackd_client.get_account_history_page(account_addr, page, hostport=blockstackd_url)
        if json_is_error(res):
            log.error("Failed to list account history for {} at page {}: {}".format(account_addr, page, res['error']))
            return self._reply_json({'error': 'Failed to list account history for {} at page {}'.format(account_addr, page)}, status_code=res.get('http_status', 500))

        self._reply_json(res)
        return
1159367
function (account) {
	
	// get all local accounts & perform login
	var onDone = function (err, data) {
		if (err) {
			LOG.warn(err.toString());
		}
		else {
			for (var server in data.accounts) {
				LOG.warn('local server: ' + server);

				var user_list = data.accounts[server];
				for (var uid in user_list) {
					var token = user_list[uid];
					LOG.warn('local uid: ' + uid + ' token: ' + token);
					l_send_remote_login(server, uid, token);	
				}
			}
		}
	};
	SR.User.getUser(account, onDone);
}
1230320
@Override
    public void getAccountSettings() {
        getDispatcher().invokeLater(new AsyncTask(ACCOUNT_SETTINGS, listeners) {
            @Override
            public void invoke(List<TwitterListener> listeners) throws TwitterException {
                AccountSettings accountSettings = twitter.getAccountSettings();
                for (TwitterListener listener : listeners) {
                    try {
                        listener.gotAccountSettings(accountSettings);
                    } catch (Exception e) {
                        logger.warn("Exception at getAccountSettings", e);
                    }
                }
            }
        });
    }
261036
public Set<DuracloudUser> getAccountUsers(AccountInfo account) {

        DuracloudRightsRepo rightsRepo = repoMgr.getRightsRepo();
        List<AccountRights> acctRights =
            rightsRepo.findByAccountId(account.getId());

        Set<DuracloudUser> users = new HashSet<>();
        for (AccountRights rights : acctRights) {
            DuracloudUser user = rights.getUser();

            // make sure only the rights for this account are set
            user.getAccountRights().clear();
            user.getAccountRights().add(rights);

            users.add(user);
        }
        return users;
    }
152992
def get_accounts(self, **params):
        """"""
        response = self._get('v2', 'accounts', params=params)
        return self._make_api_object(response, Account)
683009
def find_behind_subscriptions():
    
    subscriptions = Subscription.objects.filter(
        active=True, completed=False, process_status=0
    ).values_list("id", flat=True)
    for subscription_id in subscriptions.iterator():
        calculate_subscription_lifecycle.delay(str(subscription_id))