micro -> nano

Author: nholland94

CodaClient.py

@@ -10,18 +10,18 @@
 
 class CurrencyFormat(Enum):
   WHOLE = 1
-  MICRO = 2
+  NANO = 2
 
 class CurrencyUnderflow(Exception):
   pass
 
 class Currency():
   @classmethod
-  def __microcodas_from_int(_cls, n):
+  def __nanocodas_from_int(_cls, n):
     return n * 1000000000
 
   @classmethod
-  def __microcodas_from_string(_cls, s):
+  def __nanocodas_from_string(_cls, s):
     segments = s.split('.')
     if len(segments) == 1:
       return int(segments[0])
@@ -35,30 +35,30 @@ def __microcodas_from_string(_cls, s):
   def __init__(self, value, format=CurrencyFormat.WHOLE):
     if format == CurrencyFormat.WHOLE:
       if isinstance(value, int):
-        self.__microcodas = Currency.__microcodas_from_int(value)
+        self.__nanocodas = Currency.__nanocodas_from_int(value)
       elif isinstance(value, float):
-        self.__microcodas = Currency.__microcodas_from_string(str(value))
+        self.__nanocodas = Currency.__nanocodas_from_string(str(value))
       elif isinstance(value, str):
-        self.__microcodas = Currency.__microcodas_from_string(value)
+        self.__nanocodas = Currency.__nanocodas_from_string(value)
       else:
         raise Exception('cannot construct whole Currency from %s' % type(value))
-    elif format == CurrencyFormat.MICRO:
+    elif format == CurrencyFormat.NANO:
       if isinstance(value, int):
-        self.__microcodas = value
+        self.__nanocodas = value
       else:
-        raise Exception('cannot construct micro Currency from %s' % type(value))
+        raise Exception('cannot construct nano Currency from %s' % type(value))
     else:
       raise Exception('invalid Currency format %s' % format)
 
   def decimal_format(self):
-    s = str(self.__microcodas)
+    s = str(self.__nanocodas)
     if len(s) > 9:
       return s[:-9] + '.' + s[-9:]
     else:
       return '0.' + ('0' * (9 - len(s))) + s
 
-  def microcodas(self):
-    return self.__microcodas
+  def nanocodas(self):
+    return self.__nanocodas
 
   def __str__(self):
     return self.decimal_format()
@@ -68,25 +68,25 @@ def __repr__(self):
 
   def __add__(self, other):
     if isinstance(other, Currency):
-      return Currency(self.microcodas() + other.microcodas(), format=CurrencyFormat.MICRO)
+      return Currency(self.nanocodas() + other.nanocodas(), format=CurrencyFormat.NANO)
     else:
       raise Exception('cannot add Currency and %s' % type(other))
 
   def __sub__(self, other):
     if isinstance(other, Currency):
-      new_value = self.microcodas() - other.microcodas()
+      new_value = self.nanocodas() - other.nanocodas()
       if new_value >= 0:
-        return Currency(new_value, format=CurrencyFormat.MICRO)
+        return Currency(new_value, format=CurrencyFormat.NANO)
       else:
         raise CurrencyUnderflow()
     else:
       raise Exception('cannot subtract Currency and %s' % type(other))
 
   def __mul__(self, other):
     if isinstance(other, int):
-      return Currency(self.microcodas() * other, format=CurrencyFormat.MICRO)
+      return Currency(self.nanocodas() * other, format=CurrencyFormat.NANO)
     elif isinstance(other, Currency):
-      return Currency(self.microcodas() * other.microcodas(), format=CurrencyFormat.MICRO)
+      return Currency(self.nanocodas() * other.nanocodas(), format=CurrencyFormat.NANO)
     else:
       raise Exception('cannot multiply Currency and %s' % type(other))
 
@@ -507,8 +507,8 @@ def send_payment(self, to_pk: str, from_pk: str, amount: Currency, fee: Currency
     variables = {
       "from": from_pk,
       "to": to_pk,
-      "amount": amount.microcodas(),
-      "fee": fee.microcodas(),
+      "amount": amount.nanocodas(),
+      "fee": fee.nanocodas(),
       "memo": memo
     }
     res = self._send_mutation(query, variables)

tests/test_currency.py

@@ -4,25 +4,25 @@
 
 def test_constructor_whole_int():
   n = 500
-  assert Currency(n).microcodas() == n * precision
+  assert Currency(n).nanocodas() == n * precision
 
 def test_constructor_whole_float():
   n = 5.5
-  assert Currency(n).microcodas() == n * precision
+  assert Currency(n).nanocodas() == n * precision
 
 def test_constructor_whole_string():
   n = "5.5"
-  assert Currency(n).microcodas() == float(n) * precision
+  assert Currency(n).nanocodas() == float(n) * precision
 
-def test_constructor_micro_int():
+def test_constructor_nano_int():
   n = 500
   assert Currency(n, format=CurrencyFormat.MICRO)
 
 def test_add():
-  assert (Currency(5) + Currency(2)).microcodas() == 7 * precision
+  assert (Currency(5) + Currency(2)).nanocodas() == 7 * precision
 
 def test_sub():
-  assert (Currency(5) - Currency(2)).microcodas() == 3 * precision
+  assert (Currency(5) - Currency(2)).nanocodas() == 3 * precision
 
 def test_sub_underflow():
   try:
@@ -34,7 +34,7 @@ def test_sub_underflow():
     raise
 
 def test_mul_int():
-  assert (Currency(5) * 2).microcodas() == 10 * precision
+  assert (Currency(5) * 2).nanocodas() == 10 * precision
 
 def test_mul_currency():
-  assert (Currency(5) * Currency(2, format=CurrencyFormat.MICRO)).microcodas() == 10 * precision
+  assert (Currency(5) * Currency(2, format=CurrencyFormat.MICRO)).nanocodas() == 10 * precision