Mutable named tuple with default value and conditional rounding support

Question

I have following code to create a mutable namedtuple. based my understand I can use dataclass to do it. is there a better way to do it or clean up the code?

@dataclass
class Price:
    """
    This describes how to map default price value for product
    """
    profit: float = 0.5
    cost: float = 0.1
    sale: float = 25.0

    def round(self, n: float):
        if n < 1:
            return round(n, 2)
        elif n < 100:
            n = round(n / 1)
        elif n < 1000:
            n = round(n / 5) * 5
        elif n < 10000:
            n = round(n / 50) * 50
        else:
            n = round(n / 500) * 500
        return n

    def update(self, **kwargs):
        rate = kwargs.get('rate', 1)
        for k, v in asdict(self).items():
            if k != 'sale':
                v = self.round(v * rate)
            v = kwargs.get(k) or v
            setattr(self, k, float(v))

#run test
p = Price()
p.update(rate=1) #p = Price(profit=0.5, cost=0.1, sale=25.0)

p = Price()
p.update(**{sale=450}, **dict(rate=0.9073)) #p = Price(profit=0.45, cost=0.1, sale=450.0)

p = Price()
p.update(**{sale=800}, **dict(rate=301.377)) #p = Price(profit=150.0, cost=0.1, sale=800.0)

p = Price()
p.update(rate=301.377) #p = Price(profit=150.0, cost=0.1, sale=7550.0)

p = Price(0.0, 0.5, 50.0)
p.update(rate=1) #p = Price(profit=0.0, cost=0.5, sale=50.0)

p = Price(0.0, 0.5, 50.0)
p.update(**{sale=600}, **dict(rate=0.9073)) #p = Price(profit=0.0, cost=0.5, sale=600.0)

p = Price(0.0, 0.5, 50.0)
p.update(**{sale=1200}, **dict(rate=301.377)) #p = Price(profit=0.0, cost=0.5, sale=1200.0)

p = Price(0.0, 0.5, 50.0)
p.update(rate=301.377) #p = Price(profit=0.0, cost=0.5, sale=15000.0)

Answer 1

In short:

• dataclass is the right thing to use as a mutable named tuple. It's basically custom-built to be a great version of that idea.

• Use decimal.Decimal for any financial numbers.

• Don't re-implement round. There's a built-in version that behaves in nice, configurable ways with the Decimal object.

• Not sure what the p.update(**{sale=600}, **dict(rate=0.9073)) is all about, just use p.update(sale=600, rate=0.9073) (except with Decimals)

Answer 2

The line v = kwargs.get(k) or v means you cannot use the update method to set any of the properties to 0. get can take an additional argument for the default value to return. If you change that line to v = kwargs.get(k, v), then price.update(sale=0) works as expected.

Answer 3

I suggest some correction and simplification of your update method.

Result:

def update(self, rate=1, **kwargs):
  self_dict = asdict(self)
  self_dict.update(kwargs)

  for k, v in self_dict.items():
    if k != 'sale':
      v = self.round(v * rate)

    setattr(self, k, float(v))

Explanation:

1. The rate = kwargs.get('rate', 1) can be replaced to the rate=1 keyword argument. It does the same: if the rate argument was passed - use it, otherwise use default value 1.

2. The v = kwargs.get(k) or v line doesn't work as you want I suspect. I found two problems:

   • Test your code with these arguments:

      p.update(sale=450, rate=0.9073, cost=1023)
     

     The rate and round function wouldn't affect the cost. In fact, none of passed keyword arguments will be processed.

     Why? Because the v = kwargs.get(k) or v says literally: get keyword argument named k from the kwargs dictionary and assign it to v. If kwargs doesn't have such item use v (previously processed in the for loop). See? If k argument was passed it is used directly - bypassing processing.

   • Also, as was mentioned in other answer, you can't pass 0 as value of keyword argument, because in this case the kwargs.get(k) will return 0, which is interpreted as FALSE and the v will be used.

3. Both asdict(self) and kwargs are dictionaries, so we can use the dictionary's update method to replace current self values to passed keyword arguments:

   self_dict = asdict(self)
   self_dict.update(kwargs)
   

We can do this at the beginning of function and then use updated, relevant dictionary further.

Also, I think the round function should be more predictable. Now, it returns float in one case, int in others...