rogfrich/stlbs

A datatype to easily represent stones and pounds (lbs) in Python

stlbs's Issues

Overload `__mul__()` to allow multiplication of `StLb` objects

As well as overloading the + and - operators, StLb should have the ability to multiply as well:

The multiplication factor should be a number - instance.in_lbs should be multiplied by the factor with two possible outcomes depending on context:

• A new object is created from the result: new_instance = StLb(0, instance.in_lbs * factor)
• The existing instance has its whole_stones, remainder_lbs and in_lbs values updated in place

I can't imagine a use case where I'd need to multiply two StLb objects together.

Remove duplicated code

The __init__(), __add__() and __sub__() methods of StLb() have the same code duplicated in them.

From __init__():
self.in_lbs = (stones_lbs[0] * 14) + stones_lbs[1]

From __add__():
other_in_lbs = (other[0] * 14) + other[1]

From __sub__():
other_in_lbs = (other[0] * 14) + other[1]

Each of them has a requirement to take representation stones and lbs in the format whole_stones, remainder_lbs and convert it to lbs using the formula (whole_stones * 14) + remainder_lbs.

There should be a private function to do this. Given a whole_stones, remainder_lbs tuple, it should return another tuple in the format (0, value_in_lbs):

def _convert_stones_and_lbs_to_lbs((whole_stones, remainder_lbs)):
    in_lbs = (whole_stones * 14) + remainder_lbs
    return (0, in_lbs)

Write README.md

Update README.md with an intro and examples of use.

adding tuple to StLb instance results in incorrect whole_stones and remainder_lbs values

The remainder_lbs attribute of a StLb instance should never be more than 13, because at 14 it should increment whole_stones. Updating the values via the overloaded addition operator can result in such a case occurring:

>>> spam = StLb([1, 0])
>>> spam += (0, 15)
>>> spam
StLb object: 1 stones and 15lbs [29lbs]
# Should be 2 stones and 1 lb

This is a bug that needs to be fixed, and we need tests to ensure that remainder_lbs is never more than 13, and that whole_stones ticks up appropriately.

Overload __div__() to allow division of and with StLb

Dividing an StLb object by a numeric type returns a numeric type: StLb(8, 0) / 4 == 2
Dividing an StLb object by another StLb object returns a numeric type: StLb(8, 0) / StLb(2, 0) == 2

Simply `StLb` constructor

The constructor for the StLb object can be simplified if, regardless of the whole_stones, remainder_lbs values in the initial call, they are converted to lbs and then converted back to whole_stones, remainder_lbs - this will remove the need to handle cases where the input is invalid but mathematically possible, such as: (0, 15) and will remove the need for the current code branching.

Sort out pluralisation in `__repr()__` and `__str__()`

Currently the repr and str magic methods are hard coded in the format:
"StLb object: {self.whole_stones} stones and {self.remainder_lbs} lbs [{self.in_lbs} lbs]"

This means that the output is inappropriately pluralised when the value of whole_stones, remainder_lbs or in_lbs is 1.

Add some logic to handle this circumstance.