Added UserFloat to bases.

Author: domdfcoding

domdf_python_tools/bases.py

@@ -32,6 +32,7 @@
 
 # stdlib
 from abc import abstractmethod
+from numbers import Real
 from pprint import pformat
 from typing import (
 		Any,
@@ -41,6 +42,8 @@
 		List,
 		MutableSequence,
 		Optional,
+		SupportsFloat,
+		SupportsRound,
 		Tuple,
 		Type,
 		TypeVar,
@@ -50,11 +53,12 @@
 
 # 3rd party
 import pydash  # type: ignore
+from typing_extensions import Protocol
 
 # this package
 from domdf_python_tools.doctools import prettify_docstrings
 
-__all__ = ["Dictable", "NamedList", "namedlist", "UserList"]
+__all__ = ["Dictable", "NamedList", "namedlist", "UserList", "UserFloat"]
 
 _V = TypeVar("_V")
 
@@ -353,6 +357,165 @@ def extend(self, other: Iterable[_T]) -> None:
 			self.data.extend(other)
 
 
+class _SupportsIndex(Protocol):
+
+	def __index__(self) -> int:
+		...
+
+
+_F = TypeVar("_F", bound="UserFloat")
+
+
+@prettify_docstrings
+class UserFloat(Real, SupportsRound):
+	"""
+	Class that simulates a float.
+
+	:param value: Values to initialise the :class:`~domdf_python_tools.bases.UserFloat` with.
+
+	.. versionadded:: 1.6.0
+	"""
+
+	def __init__(self, value: Union[SupportsFloat, _SupportsIndex, str, bytes, bytearray] = 0.0):
+		self._value = (float(value), )
+
+	def as_integer_ratio(self) -> Tuple[int, int]:
+		return float(self).as_integer_ratio()
+
+	def hex(self) -> str:
+		return float(self).hex()
+
+	def is_integer(self) -> bool:
+		return float(self).is_integer()
+
+	@classmethod
+	def fromhex(cls: Type[_F], __s: str) -> _F:
+		return cls(float.fromhex(__s))
+
+	def __add__(self: _F, other: float) -> _F:
+		return self.__class__(float(self).__add__(other))
+
+	def __sub__(self: _F, other: float) -> _F:
+		return self.__class__(float(self).__sub__(other))
+
+	def __mul__(self: _F, other: float) -> _F:
+		return self.__class__(float(self).__mul__(other))
+
+	def __floordiv__(self: _F, other: float) -> _F:  # type: ignore
+		return self.__class__(float(self).__floordiv__(other))
+
+	def __truediv__(self: _F, other: float) -> _F:
+		return self.__class__(float(self).__truediv__(other))
+
+	def __mod__(self: _F, other: float) -> _F:
+		return self.__class__(float(self).__mod__(other))
+
+	def __divmod__(self: _F, other: float) -> Tuple[_F, _F]:
+		return tuple(self.__class__(x) for x in float(self).__divmod__(other))  # type: ignore
+
+	def __pow__(self: _F, other: float, mod=None) -> _F:
+		return self.__class__(float(self).__pow__(other, mod))
+
+	def __radd__(self: _F, other: float) -> _F:
+		return self.__class__(float(self).__radd__(other))
+
+	def __rsub__(self: _F, other: float) -> _F:
+		return self.__class__(float(self).__rsub__(other))
+
+	def __rmul__(self: _F, other: float) -> _F:
+		return self.__class__(float(self).__rmul__(other))
+
+	def __rfloordiv__(self: _F, other: float) -> _F:  # type: ignore
+		return self.__class__(float(self).__rfloordiv__(other))
+
+	def __rtruediv__(self: _F, other: float) -> _F:
+		return self.__class__(float(self).__rtruediv__(other))
+
+	def __rmod__(self: _F, other: float) -> _F:
+		return self.__class__(float(self).__rmod__(other))
+
+	def __rdivmod__(self: _F, other: float) -> Tuple[_F, _F]:
+		return tuple(self.__class__(x) for x in float(self).__rdivmod__(other))  # type: ignore
+
+	def __rpow__(self: _F, other: float, mod=None) -> _F:
+		return self.__class__(float(self).__rpow__(other, mod))
+
+	def __getnewargs__(self) -> Tuple[float]:
+		return self._value
+
+	def __trunc__(self) -> int:
+		return float(self).__trunc__()
+
+	def __round__(self, ndigits: Optional[int] = None) -> Union[int, float]:  # type: ignore
+		return float(self).__round__(ndigits)
+
+	def __eq__(self, other: object) -> bool:
+		if isinstance(other, UserFloat):
+			return self._value == other._value
+		else:
+			return float(self).__eq__(other)
+
+	def __ne__(self, other: object) -> bool:
+		if isinstance(other, UserFloat):
+			return self._value != other._value
+		else:
+			return float(self).__ne__(other)
+
+	def __lt__(self, other: Union[float, "UserFloat"]) -> bool:
+		if isinstance(other, UserFloat):
+			return self._value < other._value
+		else:
+			return float(self).__lt__(other)
+
+	def __le__(self, other: Union[float, "UserFloat"]) -> bool:
+		if isinstance(other, UserFloat):
+			return self._value <= other._value
+		else:
+			return float(self).__le__(other)
+
+	def __gt__(self, other: Union[float, "UserFloat"]) -> bool:
+		if isinstance(other, UserFloat):
+			return self._value > other._value
+		else:
+			return float(self).__gt__(other)
+
+	def __ge__(self, other: Union[float, "UserFloat"]) -> bool:
+		if isinstance(other, UserFloat):
+			return self._value >= other._value
+		else:
+			return float(self).__ge__(other)
+
+	def __neg__(self: _F) -> _F:
+		return self.__class__(float(self).__neg__())
+
+	def __pos__(self: _F) -> _F:
+		return self.__class__(float(self).__pos__())
+
+	def __str__(self) -> str:
+		return str(float(self))
+
+	def __int__(self) -> int:
+		return int(float(self))
+
+	def __float__(self) -> float:
+		return self._value[0]
+
+	def __abs__(self: _F) -> _F:
+		return self.__class__(float(self).__abs__())
+
+	def __hash__(self) -> int:
+		return float(self).__hash__()
+
+	def __repr__(self) -> str:
+		return str(self)
+
+	def __ceil__(self):
+		raise NotImplementedError
+
+	def __floor__(self):
+		raise NotImplementedError
+
+
 @prettify_docstrings
 class NamedList(UserList[_T]):
 	"""

tests/test_bases.py

@@ -9,14 +9,13 @@
 # stdlib
 import copy
 import pickle  # nosec: B101
-import sys
+from numbers import Number, Real
 
 # 3rd party
 import pytest
 
 # this package
-from domdf_python_tools.bases import Dictable, NamedList, UserList, namedlist
-from domdf_python_tools.utils import printr, printt
+from domdf_python_tools.bases import Dictable, UserFloat
 
 
 class Person(Dictable):
@@ -94,3 +93,184 @@ def test_subclass(self):
 		child = Child("Bob", 12, "Big School")
 		assert person == child
 		assert "School" not in person.__dict__
+
+
+seven = UserFloat(7)
+
+
+class TestUserFloat:
+
+	def test_creation(self):
+		assert isinstance(seven, Real)
+		assert isinstance(seven, Number)
+
+		assert seven == 7
+		assert seven == 7.0
+
+	def test_as_integer_ratio(self):
+		assert seven.as_integer_ratio() == (7, 1)
+		assert seven.as_integer_ratio() == 7.0.as_integer_ratio()
+
+	def test_hex(self):
+		assert seven.hex() == "0x1.c000000000000p+2"
+		assert seven.hex() == 7.0.hex()
+
+	def test_is_integer(self):
+		assert seven.is_integer()
+		assert seven.is_integer() == 7.0.is_integer()
+
+	def test_add(self):
+		assert isinstance(seven + 7, UserFloat)
+		assert seven + 7 == UserFloat(14)
+		assert seven + 7 == 14
+		assert seven + 7 == 14.0
+
+	def test_radd(self):
+		assert isinstance(7 + seven, UserFloat)
+		assert 7 + seven == UserFloat(14)
+		assert 7 + seven == 14
+		assert 7 + seven == 14.0
+
+	def test_sub(self):
+		assert isinstance(seven - 3, UserFloat)
+		assert seven - 3 == UserFloat(4)
+		assert seven - 3 == 4
+		assert seven - 3 == 4.0
+
+	def test_rsub(self):
+		assert isinstance(3 - seven, UserFloat)
+		assert 3 - seven == UserFloat(-4)
+		assert 3 - seven == -UserFloat(4)
+		assert 3 - seven == -4
+		assert 3 - seven == -4.0
+
+	def test_mul(self):
+		assert isinstance(seven * 3, UserFloat)
+		assert seven * 3 == UserFloat(21)
+		assert seven * 3 == 21
+		assert seven * 3 == 21.0
+
+	def test_rmul(self):
+		assert isinstance(3 * seven, UserFloat)
+		assert 3 * seven == UserFloat(21)
+		assert 3 * seven == UserFloat(21)
+		assert 3 * seven == 21
+		assert 3 * seven == 21.0
+
+	def test_div(self):
+		assert isinstance(seven / 3, UserFloat)
+		assert seven / 3 == UserFloat(7 / 3)
+		assert seven / 3 == 7 / 3
+
+	def test_rdiv(self):
+		assert isinstance(3 / seven, UserFloat)
+		assert 3 / seven == UserFloat(3 / 7)
+		assert 3 / seven == UserFloat(3 / 7)
+		assert 3 / seven == 3 / 7
+
+	def test_floordiv(self):
+		assert isinstance(seven // 3, UserFloat)
+		assert seven // 3 == UserFloat(2)
+		assert seven // 3 == 2
+		assert seven // 3 == 2.0
+
+	def test_rfloordiv(self):
+		assert isinstance(21 // seven, UserFloat)
+		assert 21 // seven == UserFloat(3)
+		assert 21 // seven == 3
+
+	def test_mod(self):
+		assert isinstance(seven % 3, UserFloat)
+		assert seven % 3 == UserFloat(1)
+		assert seven % 3 == 1.0
+		assert seven % 3 == 1
+
+	def test_rmod(self):
+		assert isinstance(20 % seven, UserFloat)
+		assert 20 % seven == UserFloat(6)
+		assert 20 % seven == 6.0
+		assert 20 % seven == 6
+
+	def test_pow(self):
+		assert isinstance(seven**3, UserFloat)
+		assert seven**3 == UserFloat(343)
+		assert seven**3 == 343.0
+		assert seven**3 == 343
+
+	def test_rpow(self):
+		assert isinstance(3**seven, UserFloat)
+		assert 3**seven == UserFloat(2187)
+		assert 3**seven == 2187.0
+		assert 3**seven == 2187
+
+	def test_round(self):
+		assert isinstance(round(seven), int)
+		assert round(seven) == 7
+		assert isinstance(round(UserFloat(7.5)), int)
+		assert round(UserFloat(7.5)) == 8
+
+	def test_repr_str_int(self):
+		assert repr(seven) == "7.0"
+		assert str(seven) == "7.0"
+		assert int(seven) == 7
+		assert isinstance(int(seven), int)
+
+	def test_lt(self):
+		assert seven < 8
+		assert seven < 8.0
+		assert seven < UserFloat(8)
+
+	def test_le(self):
+		assert seven <= 8
+		assert seven <= 8.0
+		assert seven <= UserFloat(8)
+		assert seven <= 7
+		assert seven <= 7.0
+		assert seven <= UserFloat(7)
+
+	def test_gt(self):
+		assert seven > 6
+		assert seven > 6.0
+		assert seven > UserFloat(6)
+
+	def test_ge(self):
+		assert seven >= 6
+		assert seven >= 6.0
+		assert seven >= UserFloat(6)
+		assert seven >= 7
+		assert seven >= 7.0
+		assert seven >= UserFloat(7)
+
+	def test_pos(self):
+		assert isinstance(+seven, UserFloat)
+		assert +seven == seven
+		assert +seven == 7
+		assert +seven == 7.0
+
+	def test_neg(self):
+		assert isinstance(-seven, UserFloat)
+		assert -seven == UserFloat(-7)
+		assert -seven == -7
+		assert -seven == -7.0
+
+	def test_abs(self):
+		assert isinstance(abs(+seven), UserFloat)
+		assert abs(+seven) == seven
+		assert abs(+seven) == 7
+		assert abs(+seven) == 7.0
+
+		assert isinstance(abs(-seven), UserFloat)
+		assert abs(-seven) == UserFloat(7)
+		assert abs(-seven) == 7
+		assert abs(-seven) == 7.0
+
+	def test_ne(self):
+		assert seven != UserFloat(8)
+		assert seven != 8
+		assert seven != 8.0
+
+	def test_hash(self):
+		assert hash(seven) == hash(UserFloat(7))
+		assert hash(seven) != hash(UserFloat(8))
+		assert hash(seven) == hash(7)
+		assert hash(seven) != hash(8)