Gets the total claimable amount of Gas in the wallet that is not available to claim
        because it has not yet been spent.

        Returns:
            Fixed8: the amount of Gas unavailable to claim.
556836
def GetUnavailableBonus(self):
        
        height = Blockchain.Default().Height + 1
        unspents = self.FindUnspentCoinsByAsset(Blockchain.SystemShare().Hash)
        refs = [coin.Reference for coin in unspents]
        try:
            unavailable_bonus = Blockchain.CalculateBonus(refs, height_end=height)
            return unavailable_bonus
        except Exception as e:
            pass
        return Fixed8(0)
392219
def fetch(self):
        
        params = values.of({})

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

        return BalanceInstance(self._version, payload, account_sid=self._solution['account_sid'], )
1035026
def total_supply(self, block_identifier='latest'):
        
        return self.proxy.contract.functions.totalSupply().call(block_identifier=block_identifier)
807129
def get_num_shares_on(self, on_date: datetime) -> Decimal:
        
        total_quantity = Decimal(0)

        accounts = self.get_holding_accounts()
        for account in accounts:
            acct_svc = AccountAggregate(self.book, account)
            quantity = acct_svc.get_balance_on(on_date)

            total_quantity += quantity

        return total_quantity
335108
def getbalance(self, account=None, minconf=6):
        """"""
        if account:
            return self.req("getbalance", [account, minconf])
        else:
            return self.req("getbalance")
589858
def load_commodities(self):
        
        if isinstance(self.available, Amount):
            self.available = Amount("{0:.8f} {1}".format(self.available.to_double(), self.currency))
        else:
            self.available = Amount("{0:.8f} {1}".format(self.available, self.currency))
        if isinstance(self.total, Amount):
            self.total = Amount("{0:.8f} {1}".format(self.total.to_double(), self.currency))
        else:
            self.total = Amount("{0:.8f} {1}".format(self.total, self.currency))
564302
def estimate_gas_for_function(
        address,
        web3,
        fn_identifier=None,
        transaction=None,
        contract_abi=None,
        fn_abi=None,
        *args,
        **kwargs):
    
    estimate_transaction = prepare_transaction(
        address,
        web3,
        fn_identifier=fn_identifier,
        contract_abi=contract_abi,
        fn_abi=fn_abi,
        transaction=transaction,
        fn_args=args,
        fn_kwargs=kwargs,
    )

    gas_estimate = web3.eth.estimateGas(estimate_transaction)
    return gas_estimate
1323300
private int checkAndGetTotalCount() throws IllegalStateException {
		int usedBuckets = 0;
		int totalCount = buckets[0].getCount();
		for (int i = 1; i <= bucketNb; i++) {
			int bucketCount = buckets[i].getCount();
			totalCount += bucketCount;
			if (bucketCount > 0) {
				usedBuckets++;
			}
		}
		totalCount += buckets[bucketNb + 1].getCount();
		if (usedBuckets < 3) {
			throw new IllegalStateException("Only " + usedBuckets + " buckets used, not enough for interpolation, consider reconfiguring min/max/nb");
		}
		return totalCount;
	}
251473
def current_custom_claims():
    
    jwt_data = get_jwt_data_from_app_context()
    return {k: v for (k, v) in jwt_data.items() if k not in RESERVED_CLAIMS}
511739
public BigDecimal getAvailable() {

    if (available == null) {
      return total
          .subtract(frozen)
          .subtract(loaned)
          .add(borrowed)
          .subtract(withdrawing)
          .subtract(depositing);
    } else {
      return available;
    }
  }
1214538
def get_balance_on(self, on_date: datetime) -> Decimal:
        
        assert isinstance(on_date, datetime)

        total = Decimal(0)

        splits = self.get_splits_up_to(on_date)

        for split in splits:
            total += split.quantity * self.account.sign
        return total
386706
def balance(self, account: Address):
        
        return self.web3.eth.getBalance(to_checksum_address(account), 'pending')
872813
def total(self):
        
        if self.system_total.available:
            return self.system_total.vsz
        elif self.asizeof_total: # pragma: no cover
            return self.asizeof_total
        else: # pragma: no cover
            return self.tracked_total
526730
def _get_total_services_problems_handled(self):
        
        return sum(1 for s in self.services if s.is_problem and s.problem_has_been_acknowledged)
636764
def get_wallet(self, wallet_name):
        
        response = make_request(
            '{}wallet/{}'.format(self.url, wallet_name),
            timeout=self.timeout,
            client=self._client)
        try:
            total = response['total']
            return {
                'credit': response['credit'],
                'limit': response['limit'],
                'total': WalletTotal(
                    limit=total['limit'],
                    budgeted=total['budgeted'],
                    available=total['available'],
                    unallocated=total['unallocated'],
                    usage=total['usage'],
                    consumed=total['consumed'])
            }
        except Exception as exc:
            log.error(
                'cannot get wallet from server: {!r}'.format(exc))
            raise ServerError(
                'unable to get list of wallets: {!r}'.format(exc))
771488
def get_balance(self, address):
        
        spendables = self.get_unspent_outputs(address)
        if not spendables:
            logging.warning('address %s has a balance of 0', address)
            return 0

        balance = sum(s.coin_value for s in spendables)
        return balance
1240469
def get_quota_remaining(self):
        """"""
        api = self._get_api(billing.DefaultApi)
        quota = api.get_service_package_quota()
        return None if quota is None else int(quota.quota)