def delete_transaction(self, transaction):
    """Delete a transaction

    Args:
        transaction (transaction): Transaction to delete.
    """
    response = self._session.delete('transaction', data={'id': transaction.id})
    response.raise_for_status()
    if not response.json()['status']:
        raise RuntimeError(response.json()['error_msg'])

def edit_split(self, transaction, split_list):
    """Edit a transaction and its splited transactions

    Args:
        transaction (transaction): Transaction to edit.
        split_list (list): Transaction list containing the splitted transactions

    Returns:
        List of `Transaction`
    """

    return self._manage_split('edit', transaction, split_list)

def edit_transaction(self, transaction, from_account=None, to_account=None,
                     is_split=False, split_amounts=[], split_categories=[],
                     split_descriptions=[]):
    """Edit a transaction

    Args:
        transaction (transaction): Transaction to edit.
        from_account (Account): If this transaction is converted into a transfer,
            this is the account you're transferring from.
        to_account (Account): If this transaction is converted into a transfer,
            this is the account you're transferring to.
        is_split (bool): If the transaction is being split, set this to `True`.
        split_amount (list): List of float values for each split child.
        split_categories (list): List of categories for each split child.
        split_descriptions (list): List of descriptions for each split child.

    Returns:
        List of `Transaction`

    Raises:
        ValueError: if transaction doesn't have a valid `id`
    """

    if not transaction.id:
        raise ValueError(f'transaction has no id')
    data = {'id': transaction.id}
    return self._manage_transaction('put', transaction, data, from_account,
                                    to_account, is_split, split_amounts,
                                    split_categories, split_descriptions)

def get_account(self, name=None, account_id=None):
    """Get an account.

    Args:
        name (str): name of the account
        account_id (int): id of the account

    Returns:
        `Account`

    Warning:
        ClearCheckBook lets you add two accounts with the same name. In this case
        API behavior is unpredictable.
    """

    if account_id == 0:
        return NO_ACCOUNT
    elif name:
        for account in self.get_accounts():
            if account.name == name:
                return account
        else:
            raise ValueError(f'no account found with name {name}')
    else:
        response = self._session.get('account', params={'id': account_id})
        response.raise_for_status()
        if not response.json()['status']:
            raise RuntimeError(response.json()['error_msg'])
        account_data = response.json()['data']
        return Account.from_api(account_data,
                                self.get_currency(account_data['currency_code']))

def get_accounts(self, is_overview=False, all=True):
    """Get all accounts.

    Args:
        is_overview (bool): `True` to return only the accounts with a balance. `False`
            to return every account. Defaults to `False`
        all (bool): `True` to return all accounts and `NO_ACCOUNT` if it exists.

    Returns:
        A list of `Account`

    """
    response = self._session.get('accounts', params={'is_overview': is_overview,
                                                     'all': all})
    response.raise_for_status()
    if not response.json()['status']:
        raise RuntimeError(response.json()['error_msg'])
    return [Account.from_api(account_data,
                             self.get_currency(account_data['currency_code']))
            for account_data in response.json()['data']]

def get_categories(self):
    """Get all categories

    Returns:
        List of `Castegory`
    """

    response = self._session.get('categories')
    response.raise_for_status()
    if not response.json()['status']:
        raise RuntimeError(response.json()['error_msg'])
    categories = []
    for category_data in response.json()['data']:
        category = Category(**category_data)
        if category.parent:
            for category_parent in categories:
                if category_parent.id == category.parent:
                    category.parent = category_parent
                    break
        categories.append(category)
    return categories

def get_category(self, name=None, category_id=None):
    """Get a category

    Args:
        name (str): name of the category
        category_id (int): id of the category

    Returns:
        `Category`

    Warning:
        ClearCheckBook lets you add two categories with the same name. In this case
        API behavior is unpredictable.
     """

    if category_id == 0:
        return NO_CATEGORY
    for category in self.get_categories():
        if category.name == name or category.id == category_id:
            return category
    else:
        raise ValueError(f'no account found with name {name} or id {category_id}')

@lru_cache(maxsize=16)
def get_currencies(self):
    """Get all currencies

    Returns:
        List of `Currency`
     """

    response = self._session.get('currencies')
    response.raise_for_status()
    if not response.json()['status']:
        raise RuntimeError(response.json()['error_msg'])
    return [Currency(**currency) for currency in response.json()['data']]

@lru_cache(maxsize=16)
def get_currency(self, code=None, id=None):
    """Get a currency

    Args:
        code (str): The three digit currency code (eg: USD)
        category_id (int): id of the currency

    Returns:
        `Currency`
     """

    if not id and not code:
        raise TypeError('get_currency() takes either the id or code arguments')
    response = self._session.get('currency', params={'code': code, 'id': id})
    response.raise_for_status()
    if not response.json()['status']:
        raise RuntimeError(response.json()['error_msg'])
    return Currency(**response.json()['data'])

def get_transaction(self, id):
    """Get a transaction.

    Args:
        id (int): ID of the transaction

    Returns:
        `Transaction`
    """

    response = self._session.get('transaction', params={'id': id})
    response.raise_for_status()
    if not response.json()['status']:
        raise RuntimeError(response.json()['error_msg'])
    tr_data = response.json()['data']
    return Transaction.from_api(tr_data,
                                self.get_account(account_id=tr_data['account_id']),
                                self.get_category(category_id=tr_data['category_id']),
                                self.get_transaction(tr_data['parent']) if
                                tr_data['parent'] else None)

def get_transactions(self, account=None, created_at=None, from_trans=None,
                     order=None, order_direction=None, separate_splitsid=None):
    """Get all transactions. This method returns an `Transaction` interator.

    Args:
        account (Account): Account to get transactions from. Defaults to all accounts.
        created_at (pendulum.Datetime): Start timestamp to retrieve transactions from.
            Defaults to all transactions.
        from_trans (Transaction): Retrieve all transactions added after this
            transaction.
        order (str): Which column to sort the transactions on: date, created_at,
            amount, account, category, description, memo, payee, check_num.
        order_direction: Whether to return the results in ascending or descending
            order. Valid parameters are DESC or ASC.
        separate_splitsid (bool): Whether to have splits appear in order under their
            parents. If you're trying to retrieve newly added transactions, set this to
            `True` or else split children will inherit the parent's `created_at` value
    Returns:
        Iterator
    """

    limit = 250
    page = 1
    accounts = {account.id: account for account in self.get_accounts()}
    categories = {category.id: category for category in self.get_categories()}
    while True:
        params = {'account_id': account.id if account else None,
                  'created_at': created_at.to_date_string() if created_at else None,
                  'from_id': from_trans.id if from_trans else None,
                  'created_at_time': created_at.to_time_string()
                  if created_at else None,
                  'created_at_timezone':  created_at.timezone if created_at else None,
                  'order': order,
                  'order_direction': order_direction,
                  'separate_splitsid': separate_splitsid,
                  'limit': limit,
                  'page': page}
        response = self._session.get('transactions', params=params)
        response.raise_for_status()
        if not response.json()['status']:
            raise RuntimeError(response.json()['error_msg'])
        if not response.json()['data']:
            break
        for tr_data in response.json()['data']:
            yield Transaction.from_api(tr_data,
                                       accounts.get(tr_data['account_id'],
                                                    NO_ACCOUNT),
                                       categories.get(tr_data['category_id'],
                                                      NO_CATEGORY),
                                       self.get_transaction(tr_data['parent']) if
                                       tr_data['parent'] else None)
        page += 1

def insert_split(self, transaction, split_list):
    """Insert a transaction with its splited transactions

    Args:
        transaction (transaction): Transaction to insert.
        split_list (list): Transaction list containing the splitted transactions

    Returns:
        List of `Transaction`
    """

    return self._manage_split('insert', transaction, split_list)

def insert_transaction(self, transaction, from_account=None, to_account=None,
                       is_split=False, split_amounts=[], split_categories=[],
                       split_descriptions=[]):
    """Insert a transaction

    Args:
        transaction (transaction): Transaction to insert.
        from_account (Account): If this transaction is converted into a transfer,
            this is the account you're transferring from.
        to_account (Account): If this transaction is converted into a transfer,
            this is the account you're transferring to.
        is_split (bool): If the transaction is being split, set this to `True`.
        split_amount (list): List of float values for each split child.
        split_categories (list): List of categories for each split child.
        split_descriptions (list): List of descriptions for each split child.

    Returns:
        List of `Transaction`
    """

    data = {}
    return self._manage_transaction('post', transaction, data, from_account,
                                    to_account, is_split, split_amounts,
                                    split_categories, split_descriptions)

def transform_transfer(self, transaction, from_account_name, to_account_name):
    """Transform a withdrawal or deposit transactions into a transfer

    Args:
        transaction (transaction): Transaction to transform.
        from_account_name (str): The account you're transferring from.
        to_account_name (str): The account you're transferring to.

    Returns:
        List of `Transaction`

    Warning:
        ClearCheckBook lets you add two accounts with the same name. In this case
        API behavior is unpredictable.
    """

    accounts = self.get_accounts()
    try:
        from_account = accounts[from_account_name]
    except KeyError:
        raise ValueError(f'no account found with name {from_account_name}')
    try:
        to_account = accounts[to_account_name]
    except KeyError:
        raise ValueError(f'no account found with name {to_account_name}')
    transaction.transaction_type = TRANSFER
    return self.edit_transaction(transaction,
                                 from_account=from_account, to_account=to_account)