list all transactions associated with this wallet
499794
def listtransactions(self, account="", many=999, since=0):
        """"""
        return self.req("listtransactions", [account, many, since])
694079
def list(self):
        
        before, after = self.filename_template.split('%s', 1)
        filename_re = re.compile(r'%s(.{5,})%s$' % (re.escape(before),
                                                    re.escape(after)))
        result = []
        for filename in os.listdir(self.path):
            #: this is a session that is still being saved.
            if filename.endswith(_fs_transaction_suffix):
                continue
            match = filename_re.match(filename)
            if match is not None:
                result.append(match.group(1))
        return result
148152
def summary(self):
        """"""
        return "\n".join([
            "Transaction:",
            "  When:        " + self.date.strftime("%a %d %b %Y"),
            "  Description: " + self.desc.replace('\n', ' '),
            "  For amount:  {}".format(self.amount),
            "  From:        {}".format(
                ", ".join(map(lambda x: x.account, self.src)) if self.src \
                    else "UNKNOWN"
            ),
            "  To:          {}".format(
                ", ".join(map(lambda x: x.account, self.dst)) if self.dst \
                    else "UNKNOWN"
            ),
            ""
        ])
1346817
def fetch_withdrawals_since(self, since: int) -> List[Withdrawal]:
        """"""
        return self._transactions_since(self._withdrawals_since, 'withdrawals', since)
1212733
def MempoolCheck(self):
        
        txs = []
        values = self.MemPool.values()
        for tx in values:
            txs.append(tx)

        for tx in txs:
            res = self.RemoveTransaction(tx)
            if res:
                logger.debug("found tx 0x%s on the blockchain ...removed from mempool" % tx.Hash)
920664
def get_outputs_by_public_key(self, public_key):
        """"""
        txs = list(query.get_owned_ids(self.connection, public_key))
        return [TransactionLink(tx['id'], index)
                for tx in txs
                for index, output in enumerate(tx['outputs'])
                if condition_details_has_owner(output['condition']['details'],
                                               public_key)]
102399
def get_transactions_details(tx_hash_list, coin_symbol='btc', limit=None, api_key=None):
    

    for tx_hash in tx_hash_list:
        assert is_valid_hash(tx_hash)
    assert is_valid_coin_symbol(coin_symbol)

    if len(tx_hash_list) == 0:
        return []
    elif len(tx_hash_list) == 1:
        return [get_transaction_details(tx_hash=tx_hash_list[0],
                                        coin_symbol=coin_symbol,
                                        limit=limit,
                                        api_key=api_key
                                        )]

        url = make_url(coin_symbol, **dict(txs=';'.join(tx_hash_list)))

    params = {}
    if api_key:
        params['token'] = api_key
    if limit:
        params['limit'] = limit

    r = requests.get(url, params=params, verify=True, timeout=TIMEOUT_IN_SECONDS)
    response_dict_list = get_valid_json(r)

    cleaned_dict_list = []

    for response_dict in response_dict_list:
        if 'error' not in response_dict:
            if response_dict['block_height'] > 0:
                response_dict['confirmed'] = parser.parse(response_dict['confirmed'])
            else:
                # Blockcypher reports fake times if it's not in a block
                response_dict['confirmed'] = None
                response_dict['block_height'] = None

            # format this string as a datetime object
            response_dict['received'] = parser.parse(response_dict['received'])
        cleaned_dict_list.append(response_dict)

    return cleaned_dict_list
638297
@Override
    public String[] listPreparedTransactions()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "getPreparedTransactions");

        String[] col = null;

        if (_manager != null)
        {
            // Obtain array of in-doubt xids from the XidManager
            Xid[] xids = null;
            xids = _manager.listRemoteInDoubts();
            if (xids != null)
            {
                // Get the string representation of each xid
                // and add to the collection
                col = new String[xids.length];
                for (int i = 0; i < xids.length; i++)
                {
                    col[i] = ((PersistentTranId) xids[i]).toString();
                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                        SibTr.debug(this, tc, "xid " + col[i] + " in-doubt");
                }
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "getPreparedTransactions");
        return col;
    }
1302855
def list_wallets(self):
        
        response = make_request(
            '{}wallet'.format(self.url),
            timeout=self.timeout,
            client=self._client)
        try:
            total = response['total']
            return {
                'credit': response['credit'],
                'total': WalletTotal(
                    limit=total['limit'],
                    budgeted=total['budgeted'],
                    available=total['available'],
                    unallocated=total['unallocated'],
                    usage=total['usage'],
                    consumed=total['consumed']),
                'wallets': tuple(Wallet(
                    owner=wallet['owner'],
                    wallet=wallet['wallet'],
                    limit=wallet['limit'],
                    budgeted=wallet['budgeted'],
                    unallocated=wallet['unallocated'],
                    available=wallet['available'],
                    consumed=wallet['consumed'],
                    default='default' in wallet)
                    for wallet in response['wallets']),
            }
        except Exception as err:
            log.error(
                'cannot process wallets: invalid JSON response: {!r}'.format(
                    response))
            raise ServerError(
                'unable to get list of wallets: {!r}'.format(err))
680228
def _parse_transactions(self, response):
        
        transactions = list()

        if response:
            f = StringIO(response)
            reader = csv.DictReader(f)

            for line in reader:
                txn = {}
                txn['date'] = datetime.strptime(line['Date'], '%d/%m/%Y %H:%M:%S')
                txn['description'] = line['Description']
                txn['amount'] = float(line['Amount'].replace(',', ''))
                txn['reference'] = line['Transaction number']
                txn['sender'] = line['???transfer.fromOwner???']
                txn['recipient'] = line['???transfer.toOwner???']
                txn['currency'] = 'TSH'
                txn['comment'] = line['Transaction type']

                transactions.append(txn)

        return transactions
395995
def get_transactions(self, include_investment=False):
        """"""
        assert_pd()
        s = StringIO(self.get_transactions_csv(
            include_investment=include_investment))
        s.seek(0)
        df = pd.read_csv(s, parse_dates=['Date'])
        df.columns = [c.lower().replace(' ', '_') for c in df.columns]
        df.category = (df.category.str.lower()
                       .replace('uncategorized', pd.np.nan))
        return df
224347
def list(filter = nil)
      @backend.transaction(true){
        result = @backend[:user].keys.collect{|k| decrypt(k)}

        if filter.blank?
          result
        else
          result.select{|k,v| k =~ /#{filter}/}
        end
      }
    end
1290030
def issuers(self):
        """"""
        issuers = self._get_property('issuers') or []
        result = {
            '_embedded': {
                'issuers': issuers,
            },
            'count': len(issuers),
        }
        return List(result, Issuer)
256417
def get_transactions(self, account_id, **params):
        """"""
        response = self._get('v2', 'accounts', account_id, 'transactions', params=params)
        return self._make_api_object(response, Transaction)
295989
protected function getListTransaction()
    {
        $conditions = $this->query_filter;
        $conditions['limit'] = $this->data_limit;

        return (array) $this->transaction->getList($conditions);
    }
561209
def all(self, data={}, **kwargs):
        "
        if 'payment_id' in data:
            url = "/payments/{}/transfers".format(data['payment_id'])

            del data['payment_id']
            return self.get_url(url, data, **kwargs)

        return super(Transfer, self).all(data, **kwargs)
669170
def transactions
      raw_transactions = @agent.get("https://wwws.mint.com/transactionDownload.event?").body

      transos = []

      raw_transactions.split("\n").each_with_index do |line,index|

        if index > 1
          line_array = line.split(",")
          transaction = {
            :date => Date.strptime(remove_quotes(line_array[0]), '%m/%d/%Y'),
            :description=>remove_quotes(line_array[1]),
            :original_description=>remove_quotes(line_array[2]),
            :amount=>remove_quotes(line_array[3]).to_f,
            :type=>remove_quotes(line_array[4]),
            :category=>remove_quotes(line_array[5]),
            :account=>remove_quotes(line_array[6]),
            :labels=>remove_quotes(line_array[7]),
            :notes=>remove_quotes(line_array[8])
          }
          transos << transaction

        if block_given?
          yield transaction
        end

        end

      end
      transos
      
    end