onetick-py 1.172.0__py3-none-any.whl → 1.174.0__py3-none-any.whl

onetick/py/types.py

@@ -2,15 +2,16 @@ import ctypes
 import functools
 import inspect
 import warnings
+import decimal as _decimal
 from typing import Optional, Type, Union
-from packaging.version import parse as parse_version
-
-import pandas as pd
-import numpy as np
 from datetime import date as _date
 from datetime import datetime as _datetime
+from datetime import timedelta as _timedelta
 
+import pandas as pd
+import numpy as np
 from pandas.tseries import offsets
+from packaging.version import parse as parse_version
 
 import onetick.py as otp
 from onetick.py.otq import otq, pyomd
@@ -707,18 +708,23 @@ class _inf(float, metaclass=_nan_base):
 inf = _inf()
 
 
-class _decimal_str(type):
-    def __str__(cls):
-        return 'decimal'
-
-
-class decimal(float, metaclass=_decimal_str):
+class decimal:
     """
     Object that represents decimal OneTick value.
     Decimal is 128 bit base 10 floating point number.
 
+    Parameters
+    ----------
+    value: int, float, str
+        The value to initialize decimal from.
+        Note that float values may be converted with precision lost.
+
     Examples
     --------
+
+    :py:class:`~onetick.py.types.decimal` objects can be used in tick generators
+    and column operations as any other onetick-py type:
+
     >>> t = otp.Ticks({'A': [otp.decimal(1), otp.decimal(2)]})
     >>> t['B'] = otp.decimal(1.23456789)
     >>> t['C'] = t['A'] / 0
@@ -727,43 +733,107 @@ class decimal(float, metaclass=_decimal_str):
                          Time    A         B    C    D
     0 2003-12-01 00:00:00.000  1.0  1.234568  inf  NaN
     1 2003-12-01 00:00:00.001  2.0  1.234568  inf  NaN
-    """
-    def __wrap(self, res):
-        # if parent class doesn't support some operation, it returns NotImplemented and so do we
-        # In other case we wrap float result with our decimal class
-        if isinstance(res, type(NotImplemented)):
-            return NotImplemented
-        return self.__class__(res)
 
-    def __add__(self, other):
-        return self.__wrap(super().__add__(other))
-
-    def __radd__(self, other):
-        return self.__wrap(super().__radd__(other))
-
-    def __sub__(self, other):
-        return self.__wrap(super().__sub__(other))
+    Additionally, any arithmetic operation with :py:class:`~onetick.py.types.decimal` object will return
+    an :py:class:`~onetick.py.Operation` object:
 
-    def __rsub__(self, other):
-        return self.__wrap(super().__rsub__(other))
+    >>> t = otp.Tick(A=1)
+    >>> t['X'] = otp.decimal(1) / 0
+    >>> otp.run(t)
+            Time    A    X
+    0 2003-12-01    1  inf
+
+    Note that converting from float (first row) may result in losing precision.
+    :py:class:`~onetick.py.types.decimal` objects are created from strings or integers, so they don't lose precision:
+
+    >>> t0 = otp.Tick(A=0.1)
+    >>> t1 = otp.Tick(A=otp.decimal(0.01))
+    >>> t2 = otp.Tick(A=otp.decimal('0.001'))
+    >>> t3 = otp.Tick(A=otp.decimal(1) / otp.decimal(10_000))
+    >>> t = otp.merge([t0, t1, t2, t3], enforce_order=True)
+    >>> t['STR_A'] = t['A'].decimal.str(34)
+    >>> otp.run(t)
+            Time       A                                 STR_A
+    0 2003-12-01  0.1000  0.1000000000000000055511151231257827
+    1 2003-12-01  0.0100  0.0100000000000000000000000000000000
+    2 2003-12-01  0.0010  0.0010000000000000000000000000000000
+    3 2003-12-01  0.0001  0.0001000000000000000000000000000000
 
-    def __mul__(self, other):
-        return self.__wrap(super().__mul__(other))
+    Note that :py:class:`otp.Ticks <onetick.py.Ticks>` will convert everything from string under the hood,
+    so even the float values will not lose precision:
 
-    def __rmul__(self, other):
-        return self.__wrap(super().__rmul__(other))
+    >>> t = otp.Ticks({'A': [0.1, otp.decimal(0.01), otp.decimal('0.001'), otp.decimal(1e-4)]})
+    >>> t['STR_A'] = t['A'].decimal.str(34)
+    >>> otp.run(t)
+                         Time       A                                 STR_A
+    0 2003-12-01 00:00:00.000  0.1000  0.1000000000000000000000000000000000
+    1 2003-12-01 00:00:00.001  0.0100  0.0100000000000000000000000000000000
+    2 2003-12-01 00:00:00.002  0.0010  0.0010000000000000000000000000000000
+    3 2003-12-01 00:00:00.003  0.0001  0.0001000000000000000000000000000000
+    """
+    def __new__(cls, *args, **kwargs):
+        # this method dynamically adds properties and methods
+        # from otp.Operation class to this one
+
+        # otp.decimal class doesn't fit well in onetick-py type system,
+        # so this class is a mix of both type and Operation logic
+
+        # Basically it works like this:
+        #   otp.decimal is a OneTick type
+        #   otp.decimal(1) is a decimal type object
+        # Doing anything with this object returns an otp.Operation:
+        #   otp.decimal(1) / 2
+
+        def proxy_wrap(attr, value):
+            if callable(value):
+                @functools.wraps(value)
+                def f(self, *args, **kwargs):
+                    op = self.to_operation()
+                    return getattr(op, attr)(*args, **kwargs)
+                return f
+            else:
+                @functools.wraps(value)
+                def f(self):
+                    op = self.to_operation()
+                    return getattr(op, attr)
+                return property(f)
+
+        for attr, value in inspect.getmembers(otp.Operation):
+            # comparison methods are defined by default for some reason,
+            # but we want to get them from otp.Operation
+            if not hasattr(cls, attr) or attr in ('__lt__', '__le__', '__eq__', '__ne__', '__gt__', '__ge__'):
+                setattr(cls, attr, proxy_wrap(attr, value))
+
+        return super().__new__(cls)
+
+    def __init__(self, value):
+        supported_types = (str, int, float)
+        if not isinstance(value, supported_types):
+            raise TypeError("Parameter 'value' must be one of these types: {supported_types}")
+        self.__value = value
+
+    @classmethod
+    def _to_onetick_type_string(cls):
+        # called by ott.type2str
+        return 'decimal'
 
-    def __truediv__(self, other):
-        return self.__wrap(super().__truediv__(other))
+    def _to_onetick_string(self):
+        # called by ott.value2str
+        value = str(self.__value)
+        return f'STRING_TO_DECIMAL({value2str(value)})'
 
-    def __rtruediv__(self, other):
-        return self.__wrap(super().__rtruediv__(other))
+    def to_operation(self):
+        return otp.Operation(op_str=self._to_onetick_string(), dtype=decimal)
 
     def __str__(self):
-        return super().__repr__()
+        # called by otp.CSV, we don't need to convert the value with OneTick functions in this case
+        return str(self.__value)
 
     def __repr__(self):
-        return f"{self.__class__.__name__}({self})"
+        return f"{self.__class__.__name__}({value2str(self.__value)})"
+
+    def __format__(self, __format_spec: str) -> str:
+        return _decimal.Decimal(self.__value).__format__(__format_spec)
 
 # --------------------------------------------------------------- #
 # AUXILIARY FUNCTIONS
@@ -809,7 +879,7 @@ def get_source_base_type(value):
         value_type = nsectime
 
     # check valid value type
-    if get_base_type(value_type) not in [int, float, str, bool]:
+    if get_base_type(value_type) not in [int, float, str, bool, decimal]:
         raise TypeError(f'Type "{repr(value_type)}" is not supported.')
 
     if not is_type_basic(value_type):
@@ -818,7 +888,7 @@ def get_source_base_type(value):
 
 
 def is_type_supported(dtype):
-    return get_base_type(dtype) in [int, float, str, bool] or issubclass(dtype, (datetime, date))
+    return get_base_type(dtype) in [int, float, str, bool, decimal] or issubclass(dtype, (datetime, date))
 
 
 def get_base_type(obj):
@@ -830,6 +900,8 @@ def get_base_type(obj):
         return int
     elif issubclass(obj, float):
         return float
+    elif issubclass(obj, decimal):
+        return decimal
 
     return type(None)
 
@@ -1095,7 +1167,9 @@ class datetime(AbstractTime):
     def _process_timezones_args(self, tz, tzinfo):
         if tz is not None:
             if tzinfo is None:
-                tzinfo = get_tzfile_by_name(tz)  # pandas is broken https://github.com/pandas-dev/pandas/issues/31929
+                # parameter tz in pandas.Timestamp is broken https://github.com/pandas-dev/pandas/issues/31929
+                # it is fixed in pandas>=2.0.0, but we need to support older versions
+                tzinfo = get_tzfile_by_name(tz)
                 tz = None
             else:
                 raise ValueError(
@@ -1684,6 +1758,8 @@ def type2str(t):
         return "double"
     if t is None:
         return ''
+    if t is decimal:
+        return t._to_onetick_type_string()
     return str(t)
 
 
@@ -1839,15 +1915,16 @@ def value2str(v):
         # there is no escape, so replacing double quotes with concatenation with it
         return '"' + str(v).replace('"', '''"+'"'+"''') + '"'
 
-    if isinstance(v, (float, decimal)) and not (isinstance(v, (_inf, _nan))):
+    if isinstance(v, decimal):
+        return v._to_onetick_string()
+
+    if isinstance(v, float) and not (isinstance(v, (_inf, _nan))):
         # PY-286: support science notation
         s = str(v)
         if "e" in s:
-            s = f"{v:.20f}".rstrip("0")
+            return f'atof({value2str(s)})'
         if s == "nan":
             return str(nan)
-        if isinstance(v, decimal):
-            return f'DECIMAL({s})'
         return s
 
     if is_time_type(v):
@@ -1936,21 +2013,12 @@ def is_time_type(time):
 
 def next_day(dt_obj: Union[_date, _datetime, date, datetime, pd.Timestamp]) -> _datetime:
     """
-    Return next day of ``dt_obj`` as datetime.datetime.
-    """
-    updated_dt = dt_obj + Day(1)
-
-    # If we switch ts on timezone transition time, ts changes its timezone offset
-    if hasattr(dt_obj, "tzinfo") and updated_dt.tzinfo != dt_obj.tzinfo:
-        dt_offset = dt_obj.tzinfo.utcoffset(dt_obj)
-        updated_dt_offset = updated_dt.tzinfo.utcoffset(updated_dt)
-
-        tz_diff = dt_offset - updated_dt_offset
-        updated_dt += tz_diff
+    Return the start of the next day of ``dt_obj`` as timezone-naive :py:class:`datetime.datetime`.
 
-    updated_date = updated_dt.date()
-
-    return _datetime(updated_date.year, updated_date.month, updated_date.day)
+    Next day in this case means simply incrementing day/month/year number,
+    not adding 24 hours (which may return the same date on DST days).
+    """
+    return _datetime(dt_obj.year, dt_obj.month, dt_obj.day) + _timedelta(days=1)
 
 
 def default_by_type(dtype):
@@ -1967,7 +2035,7 @@ def default_by_type(dtype):
     >>> otp.default_by_type(float)
     nan
     >>> otp.default_by_type(otp.decimal)
-    decimal(0.0)
+    decimal(0)
     >>> otp.default_by_type(int)
     0
     >>> otp.default_by_type(otp.ulong)