class Bill(models.Model): bill_number = models.CharField(max_length=30) bill_time = models.DateTimeField(null=True) total_amount = models.DecimalField(max_digits=10, decimal_places=2, null=True) def __str__(self): return '{0} (Total Rs. {1})'.format(self.bill_number, self.total_amount) def save(self, *args, **kwargs): super(Bill, self).save(*args, **kwargs) self.total_amount = Decimal(0.0) for bill_item in self.items(): self.total_amount += bill_item.medicine.unit_cost * bill_item.number super(Bill, self).save(*args, **kwargs) def items(self): return BillItem.objects.filter(bill=self.pk) def time(self): return self.bill_time.strftime('%H:%M:%S') def date(self): return self.bill_time.strftime('%d:%m:%Y') def grand_total(self): return '{0}0'.format(self.total_amount.__round__(1)) def round_off(self): return (self.total_amount - self.total_amount.__round__(1)).__round__(2)
def _convert_price_from_oz_to_other_unit(oz_price, unit_to): value = None try: if unit_to == 'oz': value = Decimal(oz_price).__round__(2) if unit_to == 'kg': val = Decimal(oz_price) * Decimal(32.15) value = val.__round__(2) if unit_to == 'g': val = Decimal(oz_price) / Decimal(31.1) value = val.__round__(2) except TypeError: return value return str(value)
def _collect_crypto_record(self, crypto_resource_obj=None): records = [] if crypto_resource_obj: val = Decimal(crypto_resource_obj.price) value = str(val.__round__(2)) records.append({ 'name': crypto_resource_obj.ticker_from.lower(), 'currency': 'USD', 'value': value }) if self.usdchf: val = Decimal(crypto_resource_obj.price) * Decimal( self.usdchf.price) value = str(val.__round__(2)) records.append({ 'name': crypto_resource_obj.ticker_from.lower(), 'currency': 'CHF', 'value': value }) if self.usdeur: val = Decimal(crypto_resource_obj.price) * Decimal( self.usdeur.price) value = str(val.__round__(2)) records.append({ 'name': crypto_resource_obj.ticker_from.lower(), 'currency': 'EUR', 'value': value }) if self.usdpln: val = Decimal(crypto_resource_obj.price) * Decimal( self.usdpln.price) value = str(val.__round__(2)) records.append({ 'name': crypto_resource_obj.ticker_from.lower(), 'currency': 'PLN', 'value': value }) for r in records: self._set_mongo_crypto_data(r)
class SigFig: """ Follows the rules of significant figures 1. All non zero numbers are significant 2. Zeros located between non-zero digits are significant 3. Trailing zeros are significant only if the number contains a decimal 4. Zeros to left of the first nonzero digit are insignificant Exact Numbers: exact counts don't affect sigfigs in calculations and are said to have an infinite number of significant figures """ _Inf = float("inf") def __new__(cls, value: Union[str, int, 'SigFig', Decimal], exact=False, precision=None, decimalplaces=None): self = object.__new__(cls) try: self.value = Decimal(value) except TypeError as e: if hasattr(value, "value"): self.value = Decimal(value.value) else: raise TypeError(f"cant convert from {value!r} to SigFig") from e if decimalplaces is None and precision is None: if '.' not in str(value): # no decimal . remove trailing zeroes self.value = self.value.normalize() else: if precision is not None: # if u are given a precision compute the best one given precision dp = precision - self.value.adjusted() - 1 decimalplaces = dp if decimalplaces is None else min(dp, decimalplaces) self.value = self.value.__round__(decimalplaces) if exact: self.precision = SigFig._Inf self.decimal_places = SigFig._Inf else: self.precision = len(self.value.as_tuple().digits) self.decimal_places = self.precision - self.value.adjusted() - 1 return self def __str__(self): if self.decimal_places == SigFig._Inf: return f"{self.value}" try: return f"{round(self.value, self.decimal_places)}" except decimal.InvalidOperation: return f"{self.value}" def __repr__(self): if self.precision == SigFig._Inf: return f"SigFig({str(self)!r},exact=True)" else: return f"SigFig({str(self)!r})" def __add__(self, other): """addition keeps the number of least precise decimal""" if not isinstance(other, self.__class__): other = self.__class__(other) return SigFig(self.value + other.value, decimalplaces=min(self.decimal_places, other.decimal_places)) __radd__ = __add__ def __sub__(self, other): """subtraction keeps the number of least precise decimal""" if not isinstance(other, self.__class__): other = self.__class__(other) return SigFig(self.value - other.value, decimalplaces=min(self.decimal_places, other.decimal_places)) def __rsub__(self, other): if not isinstance(other, self.__class__): other = self.__class__(other) return other - self def __mul__(self, other): """multiplication keeps the precision of number with the least amount of sigfigs""" if not isinstance(other, self.__class__): other = self.__class__(other) return SigFig(self.value * other.value, precision=min(self.precision, other.precision)) __rmul__ = __mul__ def __truediv__(self, other): """division keeps the precision of number with the least amount of sigfigs""" if not isinstance(other, self.__class__): other = self.__class__(other) return SigFig(self.value / other.value, precision=min(self.precision, other.precision)) def __rtruediv__(self, other): if not isinstance(other, self.__class__): other = self.__class__(other) return other / self def __neg__(self): return SigFig(-self.value, decimalplaces=self.decimalplaces, precision=self.precision) def __eq__(self, other): if hasattr(other, "value"): return self.value == other.value return self.value == Decimal(other) def __lt__(self, other): if hasattr(other, "value"): return self.value < other.value return self.value < Decimal(other) def __le__(self, other): if hasattr(other, "value"): return self.value <= other.value return self.value <= Decimal(other)
class ContractingDecimal: def _get_other(self, other): if type(other) == ContractingDecimal: return other._d elif type(other) == float or type(other) == int: o = str(other) return Decimal(neg_sci_not(o)) return other def __init__(self, a): if type(a) == float or type(a) == int: o = str(a) self._d = Decimal(neg_sci_not(o)) elif type(a) == Decimal: self._d = a elif type(a) == str: self._d = Decimal(neg_sci_not(a)) else: self._d = Decimal(a) def __bool__(self): return self._d > 0 def __eq__(self, other): return self._d.__eq__(self._get_other(other)) def __lt__(self, other): return self._d.__lt__(self._get_other(other)) def __le__(self, other): return self._d.__le__(self._get_other(other)) def __gt__(self, other): return self._d.__gt__(self._get_other(other)) def __ge__(self, other): return self._d.__ge__(self._get_other(other)) def __str__(self): return self._d.__str__() def __neg__(self): return self._d.__neg__() def __pos__(self): return self._d.__pos__() def __abs__(self): return self._d.__abs__() def __add__(self, other): x = self._d.__add__(self._get_other(other)) return fix_precision(x) def __radd__(self, other): return fix_precision(self._d.__radd__(self._get_other(other))) def __sub__(self, other): return fix_precision(self._d.__sub__(self._get_other(other))) def __rsub__(self, other): return fix_precision(self._d.__rsub__(self._get_other(other))) def __mul__(self, other): return fix_precision(self._d.__mul__(self._get_other(other))) def __rmul__(self, other): return fix_precision(self._d.__rmul__(self._get_other(other))) def __truediv__(self, other): return fix_precision(self._d.__truediv__(self._get_other(other))) def __rtruediv__(self, other): return fix_precision(self._d.__rtruediv__(self._get_other(other))) def __divmod__(self, other): return fix_precision(self._d.__divmod__(self._get_other(other))) def __rdivmod__(self, other): return fix_precision(self._d.__divmod__(self._get_other(other))) def __mod__(self, other): return fix_precision(self._d.__mod__(self._get_other(other))) def __rmod__(self, other): return fix_precision(self._d.__rmod__(self._get_other(other))) def __floordiv__(self, other): return fix_precision(self._d.__floordiv__(self._get_other(other))) def __rfloordiv__(self, other): return fix_precision(self._d.__rfloordiv__(self._get_other(other))) def __pow__(self, other): return fix_precision(self._d.__pow__(self._get_other(other))) def __rpow__(self, other): return fix_precision(self._d.__rpow__(self._get_other(other))) def __int__(self): return self._d.__int__() def __float__(self): return float(self._d) def __round__(self, n=None): return self._d.__round__(n)
def base_round_zero(val, n): if val is not None: val = Decimal(val, getcontext()) else: val = Decimal(0, getcontext()) return val.__round__(n)
def base_round(val, n): if val is not None: val = Decimal(val, getcontext()) return val.__round__(n) return None
def _convert_price_from_999_to_other(trial: str, price: str) -> str: if trial == "999": return price convert_price = Decimal(price) * (Decimal(trial) / 1000) return str(convert_price.__round__(2))