DefaultDict,

    to organize postings based on some key. See the group_by_meta classmethod

    for an example.

    @classmethod

    def group_by_meta(cls,

                      postings: Iterable[data.Posting],

                      key: MetaKey,

                      default: Optional[MetaValue]=None,

    ) -> Mapping[MetaKey, 'RelatedPostings']:

        """Relate postings by metadata value

        This method takes an iterable of postings and returns a mapping.

        The keys of the mapping are the values of post.meta.get(key, default).

        The values are RelatedPostings instances that contain all the postings

        that had that same metadata value.

        """

        retval: DefaultDict[MetaKey, 'RelatedPostings'] = collections.defaultdict(cls)

        for post in postings:

            retval[post.meta.get(key, default)].add(post)

        retval.default_factory = None

        return retval

        post_meta = {'metanumber': amt, 'metacurrency': currency}

            (acct, amt, currency, post_meta),

            (dst_acct if amt < 0 else src_acct, -amt, currency, post_meta),

def test_group_by_meta_zero():

    assert len(core.RelatedPostings.group_by_meta([], 'metacurrency')) == 0

def test_group_by_meta_key_error():

    # Make sure the return value doesn't act like a defaultdict.

    with pytest.raises(KeyError):

        core.RelatedPostings.group_by_meta([], 'metakey')['metavalue']

def test_group_by_meta_one(credit_card_cycle):

    posting = next(post for post in data.Posting.from_entries(credit_card_cycle)

                   if post.account.is_credit_card())

    actual = core.RelatedPostings.group_by_meta([posting], 'metacurrency')

    assert set(actual) == {'USD'}

def test_group_by_meta_many(two_accruals_three_payments):

    postings = [post for post in data.Posting.from_entries(two_accruals_three_payments)

                if post.account == 'Assets:Receivable:Accounts']

    actual = core.RelatedPostings.group_by_meta(postings, 'metacurrency')

    assert set(actual) == {'USD', 'EUR'}

    for key, group in actual.items():

        assert 2 <= len(group) <= 3

        assert group.balance().is_zero()

def test_group_by_meta_many_single_posts(two_accruals_three_payments):

    postings = [post for post in data.Posting.from_entries(two_accruals_three_payments)

                if post.account == 'Assets:Receivable:Accounts']

    actual = core.RelatedPostings.group_by_meta(postings, 'metanumber')

    assert set(actual) == {post.units.number for post in postings}

    assert len(actual) == len(postings)