onetick-py 1.173.0__tar.gz → 1.175.0__tar.gz

{onetick_py-1.173.0/src/onetick_py.egg-info → onetick_py-1.175.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onetick-py
-Version: 1.173.0
+Version: 1.175.0
 Summary: Python package that allows you to work with OneTick
 Author-email: solutions <solutions@onetick.com>
 License-Expression: MIT
@@ -36,7 +36,7 @@ Requires-Dist: numpy==1.26.4; python_version == "3.12" and extra == "strict"
 Requires-Dist: pandas==1.5.2; python_version == "3.9" and extra == "strict"
 Requires-Dist: pandas==1.5.3; python_version == "3.10" and extra == "strict"
 Requires-Dist: pandas==1.5.3; python_version == "3.11" and extra == "strict"
-Requires-Dist: pandas==2.2.0; python_version == "3.12" and extra == "strict"
+Requires-Dist: pandas==2.2.1; python_version == "3.12" and extra == "strict"
 Requires-Dist: pandas==2.3.0; python_version == "3.13" and extra == "strict"
 Requires-Dist: pandas==2.3.3; python_version == "3.14" and extra == "strict"
 Provides-Extra: webapi

{onetick_py-1.173.0 → onetick_py-1.175.0}/requirements.strict.txt

@@ -5,6 +5,6 @@ numpy==1.26.4; python_version == '3.12'
 pandas==1.5.2; python_version == '3.9'
 pandas==1.5.3; python_version == '3.10'
 pandas==1.5.3; python_version == '3.11'
-pandas==2.2.0; python_version == '3.12'
+pandas==2.2.1; python_version == '3.12'
 pandas==2.3.0; python_version == '3.13'
 pandas==2.3.3; python_version == '3.14'

{onetick_py-1.173.0 → onetick_py-1.175.0}/src/onetick/py/_version.py

@@ -1,2 +1,2 @@
 # This file was generated automatically. DO NOT CHANGE.
-VERSION = '1.173.0'
+VERSION = '1.175.0'

{onetick_py-1.173.0 → onetick_py-1.175.0}/src/onetick/py/aggregations/_base.py

@@ -547,7 +547,7 @@ class _AggregationTSSelection(_Aggregation):
 
 class _FloatAggregation(_Aggregation):
 
-    require_type = (int, float, ott._inf)
+    require_type = (int, float, ott._inf, ott.decimal)
 
     """
     Aggregation that expect int or float as input

{onetick_py-1.173.0 → onetick_py-1.175.0}/src/onetick/py/aggregations/order_book.py

@@ -229,6 +229,9 @@ class ObSnapshot(_OrderBookAggregation):
         # we don't want to set hard limit on the output of order book aggregations
         if self.show_full_detail:
             kwargs['all_fields'] = True
+        self._size_type = int
+        if self.size_max_fractional_digits > 0:
+            self._size_type = float  # type: ignore[assignment]
         super().__init__(*args, **kwargs)
 
     def _param_validation(self):
@@ -244,7 +247,7 @@ class ObSnapshot(_OrderBookAggregation):
     def _get_output_schema(self, src: 'Source', name: Optional[str] = None) -> dict:
         schema = {
             'PRICE': float,
-            'SIZE': int,
+            'SIZE': self._size_type,
             'LEVEL': int,
             'UPDATE_TIME': otp.nsectime,
             'BUY_SELL_FLAG': int,
@@ -265,10 +268,10 @@ class ObSnapshotWide(ObSnapshot):
     def _get_output_schema(self, src: 'Source', name: Optional[str] = None) -> dict:
         schema = {
             'BID_PRICE': float,
-            'BID_SIZE': int,
+            'BID_SIZE': self._size_type,
             'BID_UPDATE_TIME': otp.nsectime,
             'ASK_PRICE': float,
-            'ASK_SIZE': int,
+            'ASK_SIZE': self._size_type,
             'ASK_UPDATE_TIME': otp.nsectime,
             'LEVEL': int,
         }
@@ -299,10 +302,10 @@ class ObSnapshotFlat(ObSnapshot):
         for level in range(1, self.max_levels + 1):
             schema.update({
                 f'BID_PRICE{level}': float,
-                f'BID_SIZE{level}': int,
+                f'BID_SIZE{level}': self._size_type,
                 f'BID_UPDATE_TIME{level}': otp.nsectime,
                 f'ASK_PRICE{level}': float,
-                f'ASK_SIZE{level}': int,
+                f'ASK_SIZE{level}': self._size_type,
                 f'ASK_UPDATE_TIME{level}': otp.nsectime,
             })
         return schema
@@ -343,6 +346,9 @@ class ObSummary(_OrderBookAggregation):
         self.state_key_max_inactivity_sec = state_key_max_inactivity_sec
         self.size_max_fractional_digits = size_max_fractional_digits
         self.include_market_order_ticks = include_market_order_ticks
+        self._size_type = int
+        if self.size_max_fractional_digits > 0:
+            self._size_type = float   # type: ignore[assignment]
         super().__init__(*args, **kwargs)
 
     def _param_validation(self):
@@ -357,12 +363,12 @@ class ObSummary(_OrderBookAggregation):
 
     def _get_output_schema(self, src: 'Source', name: Optional[str] = None) -> dict:
         schema = {
-            'BID_SIZE': int,
+            'BID_SIZE': self._size_type,
             'BID_VWAP': float,
             'BEST_BID_PRICE': float,
             'WORST_BID_PRICE': float,
             'NUM_BID_LEVELS': int,
-            'ASK_SIZE': int,
+            'ASK_SIZE': self._size_type,
             'ASK_VWAP': float,
             'BEST_ASK_PRICE': float,
             'WORST_ASK_PRICE': float,

{onetick_py-1.173.0 → onetick_py-1.175.0}/src/onetick/py/aggregations/other.py

@@ -100,7 +100,7 @@ class Vwap(_Aggregation):
     FIELDS_TO_SKIP: List = ['column_name']
 
     output_field_type = float
-    require_type = (int, float, ott.nsectime)
+    require_type = (int, float, ott.nsectime, ott.decimal)
 
     def __init__(self,
                  price_column: str,
@@ -271,7 +271,7 @@ class Average(_FloatAggregation):
 class StdDev(_Aggregation):     # Stddev does not support inf, so no need to use _FloatAggregation
     NAME = "STDDEV"
     EP = otq.Stddev
-    require_type = (int, float)
+    require_type = (int, float, ott.decimal)
     output_field_type = float
     FIELDS_MAPPING = deepcopy(_Aggregation.FIELDS_MAPPING)
     FIELDS_MAPPING['biased'] = 'BIASED'

{onetick_py-1.173.0 → onetick_py-1.175.0}/src/onetick/py/core/_source/source_methods/misc.py

@@ -618,6 +618,9 @@ def pnl_realized(
         The name of the field with price, default is **PRICE**.
     buy_sell_flag_field: str, :py:class:`otp.Column <onetick.py.Column>`
         The name of the field with buy/sell flag, default is **BUY_SELL_FLAG**.
+        If the type of this field is string, then possible values are 'B' or 'b' for buy and 'S' or 's' for sell.
+        If the type of this field is integer, then possible values are 0 for buy and 1 for sell.
+
 
     See also
     --------
@@ -625,20 +628,63 @@ def pnl_realized(
 
     Examples
     --------
+    Let's generate some data:
 
-    Simple usage
-
-    >>> data = otp.DataSource('SOME_DATABASE', tick_type='TT', symbols='AA')  # doctest: +SKIP
-    >>> data = data.pnl_realized()  # doctest: +SKIP
-    >>> otp.run(data)  # doctest: +SKIP
-                         Time  BUY_SELL_FLAG  PRICE  SIZE  PNL_REALIZED
-    0 2003-12-01 00:00:00.000              0      5    20           0.0
-    1 2003-12-01 00:00:00.001              0      4    30           0.0
-    2 2003-12-01 00:00:00.002              1      3    15         -30.0
-    3 2003-12-01 00:00:00.003              0     10    50           0.0
-    4 2003-12-01 00:00:00.004              1      7    18          49.0
-    5 2003-12-01 00:00:00.005              1      9     6          30.0
-    6 2003-12-01 00:00:00.006              0      8    40           0.0
+    >>> trades = otp.Ticks(
+    ...     PRICE=[1.0, 2.0, 3.0, 2.5, 4.0, 5.0, 6.0, 7.0, 3.0, 4.0, 1.0],
+    ...     SIZE=[700, 20, 570, 600, 100, 100, 100, 100, 150, 10, 100],
+    ...     SELL_FLAG=[0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1],
+    ...     SIDE=['B', 'B', 'B', 'S', 'S', 'S', 'S', 'S', 'B', 'B', 'S'],
+    ... )
+    >>> otp.run(trades)
+                          Time  PRICE  SIZE  SELL_FLAG SIDE
+    0  2003-12-01 00:00:00.000    1.0   700          0    B
+    1  2003-12-01 00:00:00.001    2.0    20          0    B
+    2  2003-12-01 00:00:00.002    3.0   570          0    B
+    3  2003-12-01 00:00:00.003    2.5   600          1    S
+    4  2003-12-01 00:00:00.004    4.0   100          1    S
+    5  2003-12-01 00:00:00.005    5.0   100          1    S
+    6  2003-12-01 00:00:00.006    6.0   100          1    S
+    7  2003-12-01 00:00:00.007    7.0   100          1    S
+    8  2003-12-01 00:00:00.008    3.0   150          0    B
+    9  2003-12-01 00:00:00.009    4.0    10          0    B
+    10 2003-12-01 00:00:00.010    1.0   100          1    S
+
+    And then calculate profit and loss metric for it.
+
+    First let's use string ``buy_sell_flag_field`` field:
+
+    >>> data = trades.pnl_realized(buy_sell_flag_field='SIDE')  # doctest: +SKIP
+    >>> otp.run(data)[['Time', 'PRICE', 'SIZE', 'SIDE', 'PNL_REALIZED']]  # doctest: +SKIP
+                          Time  PRICE  SIZE  SIDE  PNL_REALIZED
+    0  2003-12-01 00:00:00.000    1.0   700     B           0.0
+    1  2003-12-01 00:00:00.001    2.0    20     B           0.0
+    2  2003-12-01 00:00:00.002    3.0   570     B           0.0
+    3  2003-12-01 00:00:00.003    2.5   600     S         900.0
+    4  2003-12-01 00:00:00.004    4.0   100     S         300.0
+    5  2003-12-01 00:00:00.005    5.0   100     S         220.0
+    6  2003-12-01 00:00:00.006    6.0   100     S         300.0
+    7  2003-12-01 00:00:00.007    7.0   100     S         400.0
+    8  2003-12-01 00:00:00.008    3.0   150     B           0.0
+    9  2003-12-01 00:00:00.009    4.0    10     B           0.0
+    10 2003-12-01 00:00:00.010    1.0   100     S        -200.0
+
+    We can get the same result using integer ``buy_sell_flag_field`` field:
+
+    >>> data = trades.pnl_realized(buy_sell_flag_field='SELL_FLAG')  # doctest: +SKIP
+    >>> otp.run(data)[['Time', 'PRICE', 'SIZE', 'SELL_FLAG', 'PNL_REALIZED']]  # doctest: +SKIP
+                          Time  PRICE  SIZE  SELL_FLAG  PNL_REALIZED
+    0  2003-12-01 00:00:00.000    1.0   700          0           0.0
+    1  2003-12-01 00:00:00.001    2.0    20          0           0.0
+    2  2003-12-01 00:00:00.002    3.0   570          0           0.0
+    3  2003-12-01 00:00:00.003    2.5   600          1         900.0
+    4  2003-12-01 00:00:00.004    4.0   100          1         300.0
+    5  2003-12-01 00:00:00.005    5.0   100          1         220.0
+    6  2003-12-01 00:00:00.006    6.0   100          1         300.0
+    7  2003-12-01 00:00:00.007    7.0   100          1         400.0
+    8  2003-12-01 00:00:00.008    3.0   150          0           0.0
+    9  2003-12-01 00:00:00.009    4.0    10          0           0.0
+    10 2003-12-01 00:00:00.010    1.0   100          1        -200.0
     """
     if computation_method not in ['fifo']:
         raise ValueError(

{onetick_py-1.173.0 → onetick_py-1.175.0}/src/onetick/py/core/column_operations/_methods/conversions.py

@@ -31,7 +31,7 @@ def float_to_str(prev_op, dtype=str):
     return MethodResult(op_str, dtype)
 
 
-def float_to_decimal(prev_op):
+def num_to_decimal(prev_op):
     return MethodResult(f'decimal({str(prev_op)})', ott.decimal)
 
 
@@ -192,7 +192,7 @@ class _ConversionsDict(UserDict):
 
 CONVERSIONS = _ConversionsDict({(float, int): float_to_int,
                                 (float, str): float_to_str,
-                                (float, ott.decimal): float_to_decimal,
+                                (float, ott.decimal): num_to_decimal,
                                 (ott.decimal, int): float_to_int,
                                 (ott.decimal, str): decimal_to_str,
                                 (ott.decimal, float): decimal_to_float,
@@ -206,6 +206,7 @@ CONVERSIONS = _ConversionsDict({(float, int): float_to_int,
                                 (int, float): int_to_float,
                                 (int, ott.nsectime): int_to_nsectime,
                                 (int, ott.msectime): int_to_msectime,
+                                (int, ott.decimal): num_to_decimal,
                                 (str, float): str_to_float,
                                 (str, ott.decimal): str_to_decimal,
                                 (str, int): str_to_int,

{onetick_py-1.173.0 → onetick_py-1.175.0}/src/onetick/py/core/column_operations/_methods/op_types.py

@@ -8,9 +8,12 @@ from onetick.py import types as ott
 
 
 def are_numerics(*dtypes):
-    return all(inspect.isclass(dtype)
-               and (issubclass(dtype, (float, int)) or np.issubdtype(dtype, np.integer))
-               and not issubclass(dtype, (ott.nsectime, ott.msectime)) for dtype in dtypes)
+    return all(
+        inspect.isclass(dtype)
+        and (issubclass(dtype, (float, int)) or np.issubdtype(dtype, np.integer) or issubclass(dtype, ott.decimal))
+        and not issubclass(dtype, (ott.nsectime, ott.msectime))
+        for dtype in dtypes
+    )
 
 
 def are_ints_not_time(*dtypes):
@@ -109,6 +112,12 @@ def _get_widest_type(left, right):
     (<class '...MyTime'>, None, <class '...MyNSec'>)
     """
 
+    # decimal takes precedence before integer and floating point types
+    if issubclass(left, ott.decimal) and are_numerics(right):
+        return left
+    if are_numerics(left) and issubclass(right, ott.decimal):
+        return right
+
     if issubclass(left, float) and issubclass(right, float):
         # between np.float and float we choose base float
         if left is not float and np.issubdtype(left, np.floating):

{onetick_py-1.173.0 → onetick_py-1.175.0}/src/onetick/py/core/column_operations/base.py

@@ -476,7 +476,7 @@ class Operation:
         Property that provides access to
         methods specific to float type.
         """
-        if issubclass(self.dtype, float) and self.dtype is not ott.decimal:
+        if issubclass(self.dtype, float):
             from onetick.py.core.column_operations.accessors.float_accessor import _FloatAccessor
             return _FloatAccessor(self)
         else:
@@ -1043,7 +1043,7 @@ class Raw(Operation):
     def __init__(self, raw, dtype):
         if dtype is str:
             warnings.warn(
-                f'Be careful, default string length in OneTick is {ott.string.DEFAULT_LENGTH}.'
+                f'Be careful, default string length in OneTick is {ott.string.DEFAULT_LENGTH}. '
                 "Length of the result raw expression can't be calculated automatically, "
                 "so you'd better use onetick.py.string type.",
                 stacklevel=2,

{onetick_py-1.173.0 → onetick_py-1.175.0}/src/onetick/py/core/source.py

@@ -947,7 +947,9 @@ class Source:
         view: bool = False,
         line_limit: Optional[Tuple[int, int]] = (10, 30),
         parse_eval_from_params: bool = False,
+        render_debug_info: bool = False,
         debug: bool = False,
+        graphviz_compat_mode: bool = False,
         **kwargs,
     ):
         """
@@ -973,8 +975,13 @@ class Source:
             If one of tuple values set to zero the corresponding limit disabled.
         parse_eval_from_params: bool
             Enable parsing and printing `eval` sub-queries from EP parameters.
+        render_debug_info: bool
+            Render additional debug information.
         debug: bool
             Allow to print stdout or stderr from `Graphviz` render.
+        graphviz_compat_mode: bool
+            Change internal parameters of result graph for better compatibility with old `Graphviz` versions.
+            Could produce larger and less readable graphs.
         kwargs:
             Additional arguments to be passed to :py:meth:`onetick.py.Source.to_otq` method (except
             ``file_name``, ``file_suffix`` and ``query_name`` parameters)
@@ -1006,7 +1013,8 @@ class Source:
 
         otq_path = self.to_otq(**kwargs)
         return render_otq(
-            otq_path, image_path, output_format, load_external_otqs, view, line_limit, parse_eval_from_params, debug,
+            otq_path, image_path, output_format, load_external_otqs, view, line_limit, parse_eval_from_params,
+            render_debug_info, debug, graphviz_compat_mode,
         )
 
     def copy(self, ep=None, columns=None, deep=False) -> 'Source':

{onetick_py-1.173.0 → onetick_py-1.175.0}/src/onetick/py/functions.py

@@ -327,6 +327,7 @@ def merge(sources, align_schema=True, symbols=None, identify_input_ts=False,
 
     if enforce_order:
         result.drop('OMDSEQ', inplace=True)
+        merged_columns.pop('OMDSEQ')
 
     if identify_input_ts:
         result.schema['SYMBOL_NAME' + added_field_name_suffix] = str
@@ -2030,7 +2031,7 @@ def _add_element(cur_res, element, format_spec_additional=None):
     if isinstance(element, Operation):
         if format_spec_additional is None:
             cur_res += element.apply(str)
-        elif issubclass(element.dtype, float) and re.fullmatch(r'\.\d+f', format_spec_additional):
+        elif issubclass(element.dtype, (float, ott.decimal)) and re.fullmatch(r'\.\d+f', format_spec_additional):
             # float has strange behavior when precision=0
             decimal_elem = element.apply(ott.decimal)
             precision_str = re.findall(r'\d+', format_spec_additional)[0]
@@ -2047,7 +2048,7 @@ def _add_element(cur_res, element, format_spec_additional=None):
     else:
         if format_spec_additional is None:
             cur_res += str(element)
-        elif isinstance(element, float):
+        elif isinstance(element, (float, ott.decimal)):
             formatting = f'{{:{format_spec_additional}}}'
             cur_res += formatting.format(element)
         else:

{onetick_py-1.173.0 → onetick_py-1.175.0}/src/onetick/py/types.py

@@ -2,6 +2,7 @@ import ctypes
 import functools
 import inspect
 import warnings
+import decimal as _decimal
 from typing import Optional, Type, Union
 from datetime import date as _date
 from datetime import datetime as _datetime
@@ -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)
 
@@ -1686,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)
 
 
@@ -1841,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):
@@ -1960,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)