Changeset - 3d704e2865fe
Parent rev.
Child rev.
[Not reviewed]
0 4 0
Brett Smith - 4 years ago 2020-06-03 22:54:12
brettcsmith@brettcsmith.org
reports: Balance is initialized with just amounts.

This works fine with how we're currently using it, makes transformation
methods easier to implement, and avoids potential bugs where a balance is
initialized with a bad mapping.
4 files changed with 89 insertions and 117 deletions:
conservancy_beancount/reports/core.py
17
26
tests/test_reports_balance.py
69
77
tests/test_reports_related_postings.py
3
2
tests/testutil.py
12
0 comments (0 inline, 0 general)
conservancy_beancount/reports/core.py
➞
Show inline comments
...
 
@@ -62,23 +62,18 @@ class Balance(Mapping[str, data.Amount]):
 

			




	
	
	
		
 
    def __init__(self,


			




	
	
	
		
 
                 source: Union[Iterable[Tuple[str, data.Amount]],


			




	
	
	
		
 
                               Mapping[str, data.Amount]]=(),


			




	
	
	
		
 
    ) -> None:


			




	
	
	
		
 
        if isinstance(source, Mapping):


			




	
	
	
		
 
            source = source.items()


			




	
	
	
		
 
        self._currency_map = {


			




	
	
	
		
 
            currency: amount.number for currency, amount in source


			




	
	
	
		
 
        }


			




	
	
	
		
 
    def __init__(self, source: Iterable[data.Amount]=()) -> None:


			




	
	
	
		
 
        self._currency_map = {amount.currency: amount for amount in source}


			




	
	
	
		
 

			




	
	
	
		
 
    def _add_amount(self,


			




	
	
	
		
 
                    currency_map: MutableMapping[str, Decimal],


			




	
	
	
		
 
                    currency_map: MutableMapping[str, data.Amount],


			




	
	
	
		
 
                    amount: data.Amount,


			




	
	
	
		
 
    ) -> None:


			




	
	
	
		
 
        code = amount.currency


			




	
	
	
		
 
        try:


			




	
	
	
		
 
            currency_map[amount.currency] += amount.number


			




	
	
	
		
 
            current_number = currency_map[code].number


			




	
	
	
		
 
        except KeyError:


			




	
	
	
		
 
            currency_map[amount.currency] = amount.number


			




	
	
	
		
 
            current_number = Decimal(0)


			




	
	
	
		
 
        currency_map[code] = data.Amount(current_number + amount.number, code)


			




	
	
	
		
 

			




	
	
	
		
 
    def _add_other(self,


			




	
	
	
		
 
                   currency_map: MutableMapping[str, Decimal],


			




	
	
	
		
 
                   currency_map: MutableMapping[str, data.Amount],


			




	
	
	
		
 
                   other: Union[data.Amount, 'Balance'],


			




	...
	
		
 
@@ -92,3 +87,4 @@ class Balance(Mapping[str, data.Amount]):


			




	
	
	
		
 
    def __repr__(self) -> str:


			




	
	
	
		
 
        return f"{type(self).__name__}({self._currency_map!r})"


			




	
	
	
		
 
        values = [repr(amt) for amt in self.values()]


			




	
	
	
		
 
        return f"{type(self).__name__}({values!r})"


			




	
	
	
		
 

			




	...
	
		
 
@@ -97,6 +93,4 @@ class Balance(Mapping[str, data.Amount]):


			




	
	
	
		
 

			




	
	
	
		
 
    def __abs__(self) -> 'Balance':


			




	
	
	
		
 
        return type(self)(


			




	
	
	
		
 
            (key, bc_amount.abs(amt)) for key, amt in self.items()


			




	
	
	
		
 
        )


			




	
	
	
		
 
    def __abs__(self: BalanceType) -> BalanceType:


			




	
	
	
		
 
        return type(self)(bc_amount.abs(amt) for amt in self.values())


			




	
	
	
		
 

			




	...
	
		
 
@@ -105,4 +99,3 @@ class Balance(Mapping[str, data.Amount]):


			




	
	
	
		
 
        self._add_other(retval_map, other)


			




	
	
	
		
 
        return type(self)((code, data.Amount(number, code))


			




	
	
	
		
 
                          for code, number in retval_map.items())


			




	
	
	
		
 
        return type(self)(retval_map.values())


			




	
	
	
		
 

			




	...
	
		
 
@@ -116,9 +109,7 @@ class Balance(Mapping[str, data.Amount]):


			




	
	
	
		
 

			




	
	
	
		
 
    def __neg__(self) -> 'Balance':


			




	
	
	
		
 
        return type(self)(


			




	
	
	
		
 
            (key, -amt) for key, amt in self.items()


			




	
	
	
		
 
        )


			




	
	
	
		
 
    def __neg__(self: BalanceType) -> BalanceType:


			




	
	
	
		
 
        return type(self)(-amt for amt in self.values())


			




	
	
	
		
 

			




	
	
	
		
 
    def __getitem__(self, key: str) -> data.Amount:


			




	
	
	
		
 
        return data.Amount(self._currency_map[key], key)


			




	
	
	
		
 
        return self._currency_map[key]


			




	
	
	
		
 

			




	...
	
		
 
@@ -134,3 +125,3 @@ class Balance(Mapping[str, data.Amount]):


			




	
	
	
		
 
    ) -> bool:


			




	
	
	
		
 
        return all(op_func(number, operand) for number in self._currency_map.values())


			




	
	
	
		
 
        return all(op_func(amt.number, operand) for amt in self.values())


			




	
	
	
		
 

			




        

    


    
    

    

        

                

                    tests/test_reports_balance.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	...
	
		
 
@@ -36,2 +36,6 @@ DEFAULT_STRINGS = [


			




	
	
	
		
 

			




	
	
	
		
 
def amounts_from_map(currency_map):


			




	
	
	
		
 
    for code, number in currency_map.items():


			




	
	
	
		
 
        yield testutil.Amount(number, code)


			




	
	
	
		
 

			




	
	
	
		
 
def test_empty_balance():


			




	...
	
		
 
@@ -51,3 +55,3 @@ def test_zero_balance(currencies):


			




	
	
	
		
 
    keys = currencies.split()


			




	
	
	
		
 
    balance = core.Balance(testutil.balance_map((key, 0) for key in keys))


			




	
	
	
		
 
    balance = core.Balance(testutil.Amount(0, key) for key in keys)


			




	
	
	
		
 
    assert balance


			




	...
	
		
 
@@ -64,4 +68,4 @@ def test_zero_balance(currencies):


			




	
	
	
		
 
def test_nonzero_balance(currencies):


			




	
	
	
		
 
    amounts = testutil.balance_map(zip(currencies.split(), itertools.count(110, 100)))


			




	
	
	
		
 
    balance = core.Balance(amounts.items())


			




	
	
	
		
 
    amounts = dict(zip(currencies.split(), itertools.count(110, 100)))


			




	
	
	
		
 
    balance = core.Balance(amounts_from_map(amounts))


			




	
	
	
		
 
    assert balance


			




	...
	
		
 
@@ -69,7 +73,7 @@ def test_nonzero_balance(currencies):


			




	
	
	
		
 
    assert not balance.is_zero()


			




	
	
	
		
 
    assert all(balance[key] == amt for key, amt in amounts.items())


			




	
	
	
		
 
    assert all(balance[key] == testutil.Amount(amt, key) for key, amt in amounts.items())


			




	
	
	
		
 

			




	
	
	
		
 
def test_mixed_balance():


			




	
	
	
		
 
    amounts = testutil.balance_map(USD=0, EUR=120)


			




	
	
	
		
 
    balance = core.Balance(amounts.items())


			




	
	
	
		
 
    amounts = {'USD': 0, 'EUR': 120}


			




	
	
	
		
 
    balance = core.Balance(amounts_from_map(amounts))


			




	
	
	
		
 
    assert balance


			




	...
	
		
 
@@ -77,5 +81,5 @@ def test_mixed_balance():


			




	
	
	
		
 
    assert not balance.is_zero()


			




	
	
	
		
 
    assert all(balance[key] == amt for key, amt in amounts.items())


			




	
	
	
		
 
    assert all(balance[key] == testutil.Amount(amt, key) for key, amt in amounts.items())


			




	
	
	
		
 

			




	
	
	
		
 
@pytest.mark.parametrize('balance_map_kwargs,expected', [


			




	
	
	
		
 
@pytest.mark.parametrize('mapping,expected', [


			




	
	
	
		
 
    ({}, True),


			




	...
	
		
 
@@ -91,5 +95,4 @@ def test_mixed_balance():


			




	
	
	
		
 
])


			




	
	
	
		
 
def test_eq_zero(balance_map_kwargs, expected):


			




	
	
	
		
 
    amounts = testutil.balance_map(**balance_map_kwargs)


			




	
	
	
		
 
    balance = core.Balance(amounts.items())


			




	
	
	
		
 
def test_eq_zero(mapping, expected):


			




	
	
	
		
 
    balance = core.Balance(amounts_from_map(mapping))


			




	
	
	
		
 
    assert balance.eq_zero() == expected


			




	...
	
		
 
@@ -97,3 +100,3 @@ def test_eq_zero(balance_map_kwargs, expected):


			




	
	
	
		
 

			




	
	
	
		
 
@pytest.mark.parametrize('balance_map_kwargs,expected', [


			




	
	
	
		
 
@pytest.mark.parametrize('mapping,expected', [


			




	
	
	
		
 
    ({}, True),


			




	...
	
		
 
@@ -108,8 +111,7 @@ def test_eq_zero(balance_map_kwargs, expected):


			




	
	
	
		
 
])


			




	
	
	
		
 
def test_ge_zero(balance_map_kwargs, expected):


			




	
	
	
		
 
    amounts = testutil.balance_map(**balance_map_kwargs)


			




	
	
	
		
 
    balance = core.Balance(amounts.items())


			




	
	
	
		
 
def test_ge_zero(mapping, expected):


			




	
	
	
		
 
    balance = core.Balance(amounts_from_map(mapping))


			




	
	
	
		
 
    assert balance.ge_zero() == expected


			




	
	
	
		
 

			




	
	
	
		
 
@pytest.mark.parametrize('balance_map_kwargs,expected', [


			




	
	
	
		
 
@pytest.mark.parametrize('mapping,expected', [


			




	
	
	
		
 
    ({}, True),


			




	...
	
		
 
@@ -124,8 +126,7 @@ def test_ge_zero(balance_map_kwargs, expected):


			




	
	
	
		
 
])


			




	
	
	
		
 
def test_le_zero(balance_map_kwargs, expected):


			




	
	
	
		
 
    amounts = testutil.balance_map(**balance_map_kwargs)


			




	
	
	
		
 
    balance = core.Balance(amounts.items())


			




	
	
	
		
 
def test_le_zero(mapping, expected):


			




	
	
	
		
 
    balance = core.Balance(amounts_from_map(mapping))


			




	
	
	
		
 
    assert balance.le_zero() == expected


			




	
	
	
		
 

			




	
	
	
		
 
@pytest.mark.parametrize('balance_map_kwargs', [


			




	
	
	
		
 
@pytest.mark.parametrize('mapping', [


			




	
	
	
		
 
    {},


			




	...
	
		
 
@@ -138,13 +139,9 @@ def test_le_zero(balance_map_kwargs, expected):


			




	
	
	
		
 
])


			




	
	
	
		
 
def test_abs(balance_map_kwargs):


			




	
	
	
		
 
    amounts = testutil.balance_map(**balance_map_kwargs)


			




	
	
	
		
 
    actual = abs(core.Balance(amounts.items()))


			




	
	
	
		
 
    assert set(actual) == set(balance_map_kwargs)


			




	
	
	
		
 
    abs_amounts = testutil.balance_map(**{


			




	
	
	
		
 
        key: abs(number) for key, number in balance_map_kwargs.items()


			




	
	
	
		
 
    })


			




	
	
	
		
 
    for key in balance_map_kwargs:


			




	
	
	
		
 
        assert actual[key] == abs_amounts[key]


			




	
	
	
		
 
def test_abs(mapping):


			




	
	
	
		
 
    actual = abs(core.Balance(amounts_from_map(mapping)))


			




	
	
	
		
 
    assert set(actual) == set(mapping)


			




	
	
	
		
 
    for key, number in mapping.items():


			




	
	
	
		
 
        assert actual[key] == testutil.Amount(abs(number), key)


			




	
	
	
		
 

			




	
	
	
		
 
@pytest.mark.parametrize('balance_map_kwargs', [


			




	
	
	
		
 
@pytest.mark.parametrize('mapping', [


			




	
	
	
		
 
    {},


			




	...
	
		
 
@@ -157,10 +154,9 @@ def test_abs(balance_map_kwargs):


			




	
	
	
		
 
])


			




	
	
	
		
 
def test_neg(balance_map_kwargs):


			




	
	
	
		
 
    amounts = testutil.balance_map(**balance_map_kwargs)


			




	
	
	
		
 
    actual = -core.Balance(amounts.items())


			




	
	
	
		
 
    assert set(actual) == set(balance_map_kwargs)


			




	
	
	
		
 
    for key in balance_map_kwargs:


			




	
	
	
		
 
        assert actual[key] == -amounts[key]


			




	
	
	
		
 
def test_neg(mapping):


			




	
	
	
		
 
    actual = -core.Balance(amounts_from_map(mapping))


			




	
	
	
		
 
    assert set(actual) == set(mapping)


			




	
	
	
		
 
    for key, number in mapping.items():


			




	
	
	
		
 
        assert actual[key] == testutil.Amount(-number, key)


			




	
	
	
		
 

			




	
	
	
		
 
@pytest.mark.parametrize('kwargs1,kwargs2,expected', [


			




	
	
	
		
 
@pytest.mark.parametrize('map1,map2,expected', [


			




	
	
	
		
 
    ({}, {}, True),


			




	...
	
		
 
@@ -175,5 +171,5 @@ def test_neg(balance_map_kwargs):


			




	
	
	
		
 
])


			




	
	
	
		
 
def test_eq(kwargs1, kwargs2, expected):


			




	
	
	
		
 
    bal1 = core.Balance(testutil.balance_map(**kwargs1))


			




	
	
	
		
 
    bal2 = core.Balance(testutil.balance_map(**kwargs2))


			




	
	
	
		
 
def test_eq(map1, map2, expected):


			




	
	
	
		
 
    bal1 = core.Balance(amounts_from_map(map1))


			




	
	
	
		
 
    bal2 = core.Balance(amounts_from_map(map2))


			




	
	
	
		
 
    actual = bal1 == bal2


			




	...
	
		
 
@@ -188,4 +184,4 @@ def test_eq(kwargs1, kwargs2, expected):


			




	
	
	
		
 
def test_add_amount(number, currency):


			




	
	
	
		
 
    start_amounts = testutil.balance_map(USD=500)


			




	
	
	
		
 
    start_bal = core.Balance(start_amounts)


			




	
	
	
		
 
    start_amount = testutil.Amount(500, 'USD')


			




	
	
	
		
 
    start_bal = core.Balance([start_amount])


			




	
	
	
		
 
    add_amount = testutil.Amount(number, currency)


			




	...
	
		
 
@@ -197,5 +193,5 @@ def test_add_amount(number, currency):


			




	
	
	
		
 
        assert len(actual) == 2


			




	
	
	
		
 
        assert actual['USD'] == testutil.Amount(500)


			




	
	
	
		
 
        assert actual['USD'] == start_amount


			




	
	
	
		
 
        assert actual[currency] == add_amount


			




	
	
	
		
 
    assert start_bal == start_amounts


			




	
	
	
		
 
    assert start_bal == {'USD': start_amount}


			




	
	
	
		
 

			




	...
	
		
 
@@ -208,4 +204,3 @@ def test_add_amount(number, currency):


			




	
	
	
		
 
def test_iadd_amount(number, currency):


			




	
	
	
		
 
    start_amounts = testutil.balance_map(USD=500)


			




	
	
	
		
 
    balance = core.MutableBalance(start_amounts)


			




	
	
	
		
 
    balance = core.MutableBalance([testutil.Amount(500, 'USD')])


			




	
	
	
		
 
    add_amount = testutil.Amount(number, currency)


			




	...
	
		
 
@@ -220,3 +215,3 @@ def test_iadd_amount(number, currency):


			




	
	
	
		
 

			




	
	
	
		
 
@pytest.mark.parametrize('balance_map_kwargs', [


			




	
	
	
		
 
@pytest.mark.parametrize('mapping', [


			




	
	
	
		
 
    {},


			




	...
	
		
 
@@ -229,14 +224,13 @@ def test_iadd_amount(number, currency):


			




	
	
	
		
 
])


			




	
	
	
		
 
def test_add_balance(balance_map_kwargs):


			




	
	
	
		
 
    start_numbers = {'USD': 500, 'BRL': 40000}


			




	
	
	
		
 
    start_bal = core.Balance(testutil.balance_map(**start_numbers))


			




	
	
	
		
 
    expect_numbers = start_numbers.copy()


			




	
	
	
		
 
    for code, number in balance_map_kwargs.items():


			




	
	
	
		
 
def test_add_balance(mapping):


			




	
	
	
		
 
    expect_numbers = {'USD': 500, 'BRL': 40000}


			




	
	
	
		
 
    start_bal = core.Balance(amounts_from_map(expect_numbers))


			




	
	
	
		
 
    for code, number in mapping.items():


			




	
	
	
		
 
        expect_numbers[code] = expect_numbers.get(code, 0) + number


			




	
	
	
		
 
    add_bal = core.Balance(testutil.balance_map(**balance_map_kwargs))


			




	
	
	
		
 
    add_bal = core.Balance(amounts_from_map(mapping))


			




	
	
	
		
 
    actual = start_bal + add_bal


			




	
	
	
		
 
    expected = core.Balance(testutil.balance_map(**expect_numbers))


			




	
	
	
		
 
    expected = core.Balance(amounts_from_map(expect_numbers))


			




	
	
	
		
 
    assert actual == expected


			




	
	
	
		
 

			




	
	
	
		
 
@pytest.mark.parametrize('balance_map_kwargs', [


			




	
	
	
		
 
@pytest.mark.parametrize('mapping', [


			




	
	
	
		
 
    {},


			




	...
	
		
 
@@ -249,21 +243,20 @@ def test_add_balance(balance_map_kwargs):


			




	
	
	
		
 
])


			




	
	
	
		
 
def test_iadd_balance(balance_map_kwargs):


			




	
	
	
		
 
    start_numbers = {'USD': 500, 'BRL': 40000}


			




	
	
	
		
 
    balance = core.MutableBalance(testutil.balance_map(**start_numbers))


			




	
	
	
		
 
    expect_numbers = start_numbers.copy()


			




	
	
	
		
 
    for code, number in balance_map_kwargs.items():


			




	
	
	
		
 
def test_iadd_balance(mapping):


			




	
	
	
		
 
    expect_numbers = {'USD': 500, 'BRL': 40000}


			




	
	
	
		
 
    balance = core.MutableBalance(amounts_from_map(expect_numbers))


			




	
	
	
		
 
    for code, number in mapping.items():


			




	
	
	
		
 
        expect_numbers[code] = expect_numbers.get(code, 0) + number


			




	
	
	
		
 
    balance += core.Balance(testutil.balance_map(**balance_map_kwargs))


			




	
	
	
		
 
    expected = core.Balance(testutil.balance_map(**expect_numbers))


			




	
	
	
		
 
    balance += core.Balance(amounts_from_map(mapping))


			




	
	
	
		
 
    expected = core.Balance(amounts_from_map(expect_numbers))


			




	
	
	
		
 
    assert balance == expected


			




	
	
	
		
 

			




	
	
	
		
 
@pytest.mark.parametrize('balance_map_kwargs,expected', DEFAULT_STRINGS)


			




	
	
	
		
 
def test_str(balance_map_kwargs, expected):


			




	
	
	
		
 
    amounts = testutil.balance_map(**balance_map_kwargs)


			




	
	
	
		
 
    assert str(core.Balance(amounts.items())) == expected


			




	
	
	
		
 
@pytest.mark.parametrize('mapping,expected', DEFAULT_STRINGS)


			




	
	
	
		
 
def test_str(mapping, expected):


			




	
	
	
		
 
    balance = core.Balance(amounts_from_map(mapping))


			




	
	
	
		
 
    assert str(balance) == expected


			




	
	
	
		
 

			




	
	
	
		
 
@pytest.mark.parametrize('bal_kwargs,expected', DEFAULT_STRINGS)


			




	
	
	
		
 
def test_format_defaults(bal_kwargs, expected):


			




	
	
	
		
 
    amounts = testutil.balance_map(**bal_kwargs)


			




	
	
	
		
 
    assert core.Balance(amounts).format() == expected


			




	
	
	
		
 
@pytest.mark.parametrize('mapping,expected', DEFAULT_STRINGS)


			




	
	
	
		
 
def test_format_defaults(mapping, expected):


			




	
	
	
		
 
    balance = core.Balance(amounts_from_map(mapping))


			




	
	
	
		
 
    assert balance.format() == expected


			




	
	
	
		
 

			




	...
	
		
 
@@ -276,3 +269,3 @@ def test_format_defaults(bal_kwargs, expected):


			




	
	
	
		
 
def test_format_fmt(fmt, expected):


			




	
	
	
		
 
    amounts = testutil.balance_map(JPY=5000, EUR=-1500)


			




	
	
	
		
 
    amounts = [testutil.Amount(5000, 'JPY'), testutil.Amount(-1500, 'EUR')]


			




	
	
	
		
 
    balance = core.Balance(amounts)


			




	...
	
		
 
@@ -286,6 +279,5 @@ def test_format_fmt(fmt, expected):


			




	
	
	
		
 
def test_format_sep(sep):


			




	
	
	
		
 
    bal_kwargs, expected = DEFAULT_STRINGS[-1]


			




	
	
	
		
 
    mapping, expected = DEFAULT_STRINGS[-1]


			




	
	
	
		
 
    expected = expected.replace(', ', sep)


			




	
	
	
		
 
    amounts = testutil.balance_map(**bal_kwargs)


			




	
	
	
		
 
    balance = core.Balance(amounts)


			




	
	
	
		
 
    balance = core.Balance(amounts_from_map(mapping))


			




	
	
	
		
 
    assert balance.format(sep=sep) == expected


			




	...
	
		
 
@@ -293,5 +285,5 @@ def test_format_sep(sep):


			




	
	
	
		
 
def test_format_none():


			




	
	
	
		
 
    amounts = testutil.balance_map(BRL=65000)


			




	
	
	
		
 
    balance = core.Balance(amounts)


			




	
	
	
		
 
    expected = babel.numbers.format_currency(65000, 'BRL')


			




	
	
	
		
 
    args = (65000, 'BRL')


			




	
	
	
		
 
    balance = core.Balance([testutil.Amount(*args)])


			




	
	
	
		
 
    expected = babel.numbers.format_currency(*args)


			




	
	
	
		
 
    assert balance.format(None) == expected


			




        

    


    
    

    

        

                

                    tests/test_reports_related_postings.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	...
	
		
 
@@ -92,3 +92,3 @@ def test_balance_credit_card(credit_card_cycle, index, expected):


			




	
	
	
		
 
    )


			




	
	
	
		
 
    assert related.balance() == testutil.balance_map(USD=expected)


			




	
	
	
		
 
    assert related.balance() == {'USD': testutil.Amount(expected, 'USD')}


			




	
	
	
		
 

			




	...
	
		
 
@@ -101,3 +101,4 @@ def check_iter_with_balance(entries):


			




	
	
	
		
 
        balance_tally[currency] += number


			




	
	
	
		
 
        expect_balances.append(testutil.balance_map(balance_tally.items()))


			




	
	
	
		
 
        expect_balances.append({code: testutil.Amount(number, code)


			




	
	
	
		
 
                                for code, number in balance_tally.items()})


			




	
	
	
		
 
    related = core.RelatedPostings(expect_posts)


			




        

    


    
    

    

        

                

                    tests/testutil.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	...
	
		
 
@@ -158,14 +158,2 @@ OPENING_EQUITY_ACCOUNTS = itertools.cycle([


			




	
	
	
		
 

			




	
	
	
		
 
def balance_map(source=None, **kwargs):


			




	
	
	
		
 
    # The source and/or kwargs should map currency name strings to


			




	
	
	
		
 
    # things you can pass to Decimal (a decimal string, an int, etc.)


			




	
	
	
		
 
    # This returns a dict that maps currency name strings to Amount instances.


			




	
	
	
		
 
    retval = {}


			




	
	
	
		
 
    if source is not None:


			




	
	
	
		
 
        retval.update((currency, Amount(number, currency))


			




	
	
	
		
 
                      for currency, number in source)


			




	
	
	
		
 
    if kwargs:


			




	
	
	
		
 
        retval.update(balance_map(kwargs.items()))


			




	
	
	
		
 
    return retval


			




	
	
	
		
 

			




	
	
	
		
 
def OpeningBalance(acct=None, **txn_meta):


			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







    


    

  


    








    
        Server instance: kapok.sfconservancy.org-16613
    
    
        This site is powered by
            Kallithea 0.6.3,
        which is
        © 2010–2020 by various authors & licensed under GPLv3.
            – Support
        – Privacy Policy