Although it could be both a question and a proposal at a time, is there any reason why Money is unhashable?

>>> m = money.Money(123, 'KRW')
>>> hash(m)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'Money'

Money.__hash__ is set to None, and it disallows Money to be hashed.

decimal.Decimal is also hashable:

>>> d = decimal.Decimal(123)
>>> hash(d)
123

So I think __hash__ could be easily implemented e.g.:

def __hash__(self):
    return hash((self.amount, self.currency))

Implementing __composite_values__() method is pretty trivial, but it makes Money/XMoney possible to work fantastically with SQLAlchemy through composite columns:

class Product(Base):

    amount = Column(Numeric, nullable=False)
    currency = Column(String(3), nullable=False)
    price = composite(Money, amount, currency)

It even doesn’t need to depend on SQLAlchemy. :smile:

Also, should it be documented in README.rst?

Hi,

Thanks for this wonderful package. Did you know there is another money package for python: https://github.com/limist/py-moneyed

I like your approach more, integration with Babel is a very good thing. I'm planning to integrate your package to SQLAlchemy-Utils by providing Money type for declarative models.

Allow comparisons between Money and 0 (integer, decimal, or otherwise). This shortens code from:

this._ZERO = Money(0, this.currency)
if x > this._ZERO:
...

to:

if x > 0:
...

Using Python 2.7.11, money 1.2.1, Babel 2.3.3:

>>> from money import Money
>>> Money('10', 'USD')
USD 10
>>> Money('10', 'USD').format()
Traceback (most recent call last):
  File "<console>", line 1, in <module>
  File "/home/chris/proj/move/carts/eggs/money-1.2.1-py2.7.egg/money/money.py", line 249, in format
    pattern = babel.numbers.parse_pattern(pattern)
  File "/home/chris/proj/move/carts/eggs/Babel-2.3.3-py2.7.egg/babel/numbers.py", line 491, in parse_pattern
    if ';' in pattern:
TypeError: argument of type 'NoneType' is not iterable
>>> Money('10', 'USD').format('en_US')
Traceback (most recent call last):
  File "<console>", line 1, in <module>
  File "/home/chris/proj/move/carts/eggs/money-1.2.1-py2.7.egg/money/money.py", line 249, in format
    pattern = babel.numbers.parse_pattern(pattern)
  File "/home/chris/proj/move/carts/eggs/Babel-2.3.3-py2.7.egg/babel/numbers.py", line 491, in parse_pattern
    if ';' in pattern:
TypeError: argument of type 'NoneType' is not iterable
>>> 

I really like your library so far. Thank you for writing it!

There is however one problem, as I'm working with cryptocurrencies, that are not always compliant to the ISO currency standard. Can you remove the ISO check when creating currencies? Or can you make it configurable to be able to switch it off?

Extend money.exchange.ExchangeRates.install to accept a class or instance in addition to the currently supported dotted Python path string. This makes configuration at runtime a little easier in some cases.

Compare:

>>> from decimal import Decimal
>>> Decimal("2.3") * 1.2
TypeError: unsupported operand type(s) for *: 'decimal.Decimal' and 'float'

There are extremely good reasons for this behaviour, and is one of the primary reasons that you would choose to use Decimal to represent money. A decimal library must never do a lossy conversion, and I use the Python Decimal module precisely because I can rely on it to do this correctly, and throw an exception if I ever make the mistake (and it's always a mistake) of mixing floats into my decimal calculations.

With money, on the other hand:

>>> Money(amount='2.3', currency='GBP') * 1.2
>>> GBP 2.759999999999999897859481734

This behaviour is extremely surprising, and should instead raise an exception, the same one as above. In my opinion, with the current behaviour, this library is seriously flawed.

from money import Money

m = Money('0', 'BTC') + Money('0', 'BTC')
# BTC 0

class BTC(Money):
    def __init__(self, amount=0):
        super().__init__(amount=amount, currency='BTC')

m = BTC('0') + BTC('0')

crash

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File ".../site-packages/money/money.py", line 119, in __add__
    return self.__class__(amount, self._currency)
TypeError: __init__() takes from 1 to 2 positional arguments but 3 were given

I would like to get the subclass instances to implement arithmetic, equality, and comparison operators.

Do I have to implement all of the special methods and delegate a call using super, or is there an artificial limit to the current implementation?

Hi, I'm trying to use money into a GAE app.

For testing purposes, I've tried into the console and keep raising the same error. Here's a simple print from the console:

drwxr-xr-x   7 me  admin   238B 28 Mai 12:05 ./
drwxr-xr-x@ 14 me  admin   476B 28 Mai 12:02 ../
-rw-r--r--@  1 me  admin   6,0K 28 Mai 12:05 .DS_Store
-rw-r--r--@  1 me  admin     0B 28 Mai 10:57 __init__.py
drwxr-xr-x@ 19 me  admin   646B 28 Mai 12:06 babel/
drwxr-xr-x@  9 me  admin   306B 28 Mai 11:47 money/
drwxr-xr-x@  9 me  admin   306B 28 Mai 11:14 moneyed/
mymac:libs $ python
Python 2.7.9 (default, Apr  7 2015, 07:58:25) 
[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.57)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import babel
>>> import money
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "money/__init__.py", line 5, in <module>
    from .money import Money, XMoney
  File "money/money.py", line 33
    "Decimal(): '{}'".format(amount)) from None
                                         ^
SyntaxError: invalid syntax
>>> 

Any guidance?

The exception classes in this package currently don't all inherit from the same base class. This makes it difficult to "do some money calculations" and stop whenever an error occurs. For example:

from decimal import Decimal
from money import xrates, Money, XMoney
xrates.install('money.exchange.SimpleBackend')
xrates.base = 'GBP'
xrates.setrate('EUR', Decimal('2'))

# Raises money.exceptions.ExchangeRateNotFound:
price1 = XMoney('3.00', 'GBP') + Money('50.00', 'AUD')

# Raises money.exceptions.CurrencyMismatch:
price2 = Money('3.00', 'GBP') + XMoney('50.00', 'AUD')

This means as a developer I basically have to inspect the money code to know what exceptions can be raised. I would like to write:

try:
    price1 = XMoney('3.00', 'GBP') + Money('50.00', 'AUD')
    price2 = Money('3.00', 'GBP') + XMoney('50.00', 'AUD')
except (all money exceptions to catch here):
    print("Something went wrong")

but I can't because I'd need to know what all those exceptions are. By introducing a base class we can catch and handle everything:

try:
    price1 = XMoney('3.00', 'GBP') + Money('50.00', 'AUD')
    price2 = Money('3.00', 'GBP') + XMoney('50.00', 'AUD')
except MoneyException:
    print("Something went wrong")

Also, please don't consider these several issue reports as a bad thing; I'm considering to use this package and I want to make sure we don't run into unexpected issues down the line.

I am trying to combine money with Python's statistics module.

When I am e.g. using the mean function on a list of Money objects, I am getting the error

Exception(TypeError("can't convert type 'Money' to numerator/denominator"))

At the moment, I am subclassing Money:

class EUR(Money, Decimal):
    def __init__(self, amount="0", currency="EUR"):
        super().__init__(amount=amount, currency=currency)

    def as_integer_ratio(self):
        """Express a Money instance in the form n / d"""

        return self.amount.as_integer_ratio()

This still leaves me with statistics returning Decimal objects but maybe a fix for this may be found later.

I would appreciate if you could add an as_integer_ratio method to Money as displayed above. If subclassing Money from Decimal is not leading to issues, it may also be worth a thought.

Both of the last lines here fail....

from money import Money

AUD='AUD'

a=Money(10,AUD)
b=Money(20,AUD)
c=a+b
print(a)
print(b)
print(c)
d=Money(c)
d=Money(c,AUD)

would it be worth adding a check in init to see if isinstance(amount,Money) and if the currency matches, use the amount._amount value from the passed in arg?

I guess its bad form to create another instance for the same value rather than returning c.

Operations convert to the same currency as the left operand. == is not defined because that would either make the class unhashable, or make hashing an expensive operation.

Since we can't reasonably be both hashable and have an == operator that converts types. An alternative approach would be to create subclass of XMoney that isn't hashable and includes all the comparison operators.

I have my very easy code:

#!/usr/bin/env python
# -*- coding: UTF-8 -*-

from money import Money								
x = Money(amount='0.01', currency='USD')

words = 'alphabet'

for i in words:
	x += 0.01

print (x)

But it just won't run:

Traceback (most recent call last):
  File "test.py", line 10, in <module>
    x += 0.01
  File "C:\Program Files\Python36\lib\site-packages\money\money.py", line 118, in __add__
    amount = self._amount + other
TypeError: unsupported operand type(s) for +: 'decimal.Decimal' and 'float'

I believe += is the problem. Any way out?

I have an use-case where I'm comparing different exchange rates. From Wikipedia: A currency pair is EUR/USD. Here, EUR is the base currency and USD is the quote currency. The quotation EUR/USD 1.2500 means that one euro is exchanged for 1.2500 US dollars.

I'd like to write something like

# Convert here 1 EUR for 1 USD
exchange1 = CurrencyPair(base = 'EUR', quote = 'USD', rate = '1.25')

# Convert here 1 EUR for 2 USD
exchange2 = CurrencyPair(base = 'EUR', quote = 'USD', rate = '2.50')

euro = Money(amount='1.00', currency='EUR')
dollar1 = exchange1 * euro   # dollar1 is now equal to Money(amount='1.25', currency='USD')
dollar2 = exchange2 * euro   # dollar2 is now equal to Money(amount='2.50', currency='USD')

I made this quickly by duplicating the Money class and changing some of it's multiplication operations.

Is this something you'd like to support? If so, I can make a proper pull request.