onetick-py 1.167.0__tar.gz → 1.169.0__tar.gz

{onetick_py-1.167.0 → onetick_py-1.169.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onetick-py
-Version: 1.167.0
+Version: 1.169.0
 Summary: Python package that allows you to work with OneTick
 Author-email: solutions <solutions@onetick.com>
 License-Expression: MIT

{onetick_py-1.167.0 → onetick_py-1.169.0}/src/onetick/lib/instance.py

@@ -5,7 +5,7 @@ import gc
 import inspect
 from enum import Enum
 
-if os.getenv("OTP_WEBAPI"):
+if os.getenv('OTP_WEBAPI', default='').lower() not in ('0', 'false', 'no', ''):
     import onetick.query_webapi as otq
 
     class OneTickLibMock:

{onetick_py-1.167.0 → onetick_py-1.169.0}/src/onetick/py/__init__.py

@@ -2,7 +2,7 @@
 import os
 from . import _version
 __version__ = _version.VERSION
-__webapi__: bool = bool(os.getenv("OTP_WEBAPI"))
+__webapi__: bool = os.getenv('OTP_WEBAPI', default='').lower() not in ('0', 'false', 'no', '')
 
 
 def __validate_onetick_query_integration():  # noqa
@@ -77,7 +77,8 @@ def __validate_onetick_query_integration():  # noqa
     if _otq_import_ex is None:
         return
 
-    # webapi is installed to pip and OTP_WEBAPI=1, we don't need to raise any exception
+    # PY-1033: if we can't import onetick.query, but can import onetick.query_webapi
+    # then we can just use it and don't need to raise any exception (even if OTP_WEBAPI is not set)
     try:
         import onetick.query_webapi
         __webapi__ = True

{onetick_py-1.167.0 → onetick_py-1.169.0}/src/onetick/py/_version.py

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

{onetick_py-1.167.0 → onetick_py-1.169.0}/src/onetick/py/compatibility.py

@@ -758,3 +758,19 @@ def is_include_market_order_ticks_supported(**kwargs):
     return _is_min_build_or_version(1.25, 20241229055942,
                                     20240812120000, min_update_number=2,
                                     **kwargs)
+
+
+def is_join_with_query_symbol_time_otq_supported():
+    # 20241209: Fixed 0034770: hours/minutes/seconds part of otq parameter _SYMBOL_TIME, expressed in
+    # milliseconds since 1970/01/01 00:00:00 GMT, is ignored
+    # 20250219: Implemented 0035092: passing otq param _SYMBOL_TIME should be just like setting symbol_date
+    # to the equivalent value, except in YYYYMMDDhhmmss format
+    return _is_min_build_or_version(None, None,
+                                    20250227120000)
+
+
+def is_show_db_list_show_description_supported():
+    # 20240301: Implemented 0032320: 0032320: SHOW_DB_LIST should have a new EP parameter, SHOW_DESCRIPTION
+    # However on 20240330 builds it returns SHOW_DESCRIPTION column instead of DESCRIPTION
+    return _is_min_build_or_version(1.25, 20241229055942,
+                                    20240501000000)

{onetick_py-1.167.0 → onetick_py-1.169.0}/src/onetick/py/configuration.py

@@ -537,6 +537,14 @@ class Config:
         allowed_types=str,
     )
 
+    default_username = OtpProperty(
+        description='Default username to call queries. '
+                    'By default the name of the owner of the current process is used.',
+        base_default=None,
+        allowed_types=str,
+        env_var_name='OTP_DEFAULT_USERNAME',
+    )
+
     default_auth_username = OtpProperty(
         description='Default username used for authentication.',
         base_default=None,

{onetick_py-1.167.0 → onetick_py-1.169.0}/src/onetick/py/core/_source/source_methods/joins.py

@@ -14,6 +14,7 @@ from onetick.py.core.eval_query import prepare_params
 from onetick.py.otq import otq
 from onetick.py.compatibility import (
     is_supported_point_in_time,
+    is_join_with_query_symbol_time_otq_supported,
     is_join_with_snapshot_snapshot_fields_parameter_supported,
 )
 
@@ -72,6 +73,19 @@ def _columns_to_params_for_joins(columns, query_params=False):
             else:
                 raise ValueError('Parameter symbol_time has to be a datetime value!')
 
+        elif key == '_SYMBOL_TIME' and query_params:
+            # hack to support passing _SYMBOL_TIME to called query as a parameter
+            if dtype is otp.nsectime:
+                convert_rule += get_msecs_expression(ott.value2str(value))
+            elif dtype is str:
+                ns = f'PARSE_NSECTIME("%Y%m%d%H%M%S", {ott.value2str(value)}, _TIMEZONE)'
+                convert_rule += get_msecs_expression(ns)
+            elif dtype is otp.msectime:
+                # for backward compatibility
+                convert_rule += get_msecs_expression(value)
+            else:
+                raise ValueError('Parameter symbol_time has to be a datetime value!')
+
         elif dtype is str:
             if are_strings(getattr(value, "dtype", None)):
                 convert_rule += str(value)
@@ -80,17 +94,7 @@ def _columns_to_params_for_joins(columns, query_params=False):
         elif dtype is otp.msectime:
             convert_rule += get_msecs_expression(value)
         elif dtype is otp.nsectime:
-            if key == '_SYMBOL_TIME' and query_params:
-                # hack to support passing _SYMBOL_TIME to called query as a parameter
-                warnings.warn(
-                    'Query parameter _SYMBOL_TIME passed to join_with_query! '
-                    'This is deprecated. Please use a dedicated `symbol_time` parameter of the '
-                    'join_with_query function',
-                    FutureWarning,
-                    stacklevel=3,
-                )
-                convert_rule += get_msecs_expression(value)
-            elif query_params:
+            if query_params:
                 # this can be used for query params but cannot be used for symbol params
                 # overall it's better
                 convert_rule += "'NSECTIME('+tostring(NSECTIME_TO_LONG(" + str(value) + "))+')'"
@@ -672,10 +676,10 @@ def join_with_query(
     Function object as query is also supported (Note it will be executed only once in python's code):
 
     >>> def func(symbol):
-    ...    d = otp.Ticks(TYPE=["six"])
-    ...    d = d.update(dict(TYPE="three"), where=(symbol.name == "3"))  # symbol is always converted to string
-    ...    d["TYPE"] = symbol['PREF'] + d["TYPE"] + symbol['POST']
-    ...    return d
+    ...     d = otp.Ticks(TYPE=["six"])
+    ...     d = d.update(dict(TYPE="three"), where=(symbol.name == "3"))  # symbol is always converted to string
+    ...     d["TYPE"] = symbol['PREF'] + d["TYPE"] + symbol['POST']
+    ...     return d
     >>> # OTdirective: snippet-name: Special functions.join with query.with a function
     >>> data = otp.Ticks(A=[1, 2], B=[2, 4])
     >>> res = data.join_with_query(func, how='inner', symbol=(data['A'] + data['B'], dict(PREF="_", POST="$")))
@@ -689,9 +693,9 @@ def join_with_query(
     accessible through the "symbol" object:
 
     >>> def func(symbol):
-    ...    d = otp.Ticks(TYPE=["six"])
-    ...    d["TYPE"] = symbol['PREF'] + d["TYPE"] + symbol['POST']
-    ...    return d
+    ...     d = otp.Ticks(TYPE=["six"])
+    ...     d["TYPE"] = symbol['PREF'] + d["TYPE"] + symbol['POST']
+    ...     return d
     >>> # OTdirective: snippet-name: 'Source' operations.join with query.source as symbol;
     >>> data = otp.Ticks(A=[1, 2], B=[2, 4], PREF=["_", "$"], POST=["$", "_"])
     >>> res = data.join_with_query(func, how='inner', symbol=data)
@@ -834,22 +838,20 @@ def join_with_query(
             'object (dict or Source), or a tuple containing both'
         )
 
-    # adding symbol time
     if '_PARAM_SYMBOL_TIME' in converted_symbol_param_columns.keys():
         warnings.warn(
             '"_PARAM_SYMBOL_TIME" explicitly passed among join_with_query symbol parameters! '
-            'This is deprecated - please use symbol_time parameter instead. '
-            'If you specify symbol_time parameter, it will override the explicitly passed value',
+            'This is deprecated - please use symbol_time parameter instead.',
+            FutureWarning,
+            stacklevel=2,
+        )
+    if '_SYMBOL_TIME' in params.keys():
+        warnings.warn(
+            'Query parameter "_SYMBOL_TIME" passed to join_with_query! '
+            'This is deprecated. Please use a dedicated `symbol_time` parameter.',
             FutureWarning,
             stacklevel=2,
         )
-    if symbol_time is not None:
-        if ott.get_object_type(symbol_time) is not otp.nsectime and ott.get_object_type(symbol_time) is not str:
-            raise ValueError(
-                f'Parameter of type {ott.get_object_type(symbol_time)} passed as symbol_time! '
-                'This parameter only supports datetime values or strings'
-            )
-        converted_symbol_param_columns['_PARAM_SYMBOL_TIME'] = symbol_time
 
     # prepare temporary file
     # ------------------------------------ #
@@ -875,6 +877,19 @@ def join_with_query(
     if not sub_source._is_unbound_required():
         sub_source += otp.Empty()
 
+    # adding symbol time
+    if symbol_time is not None:
+        if ott.get_object_type(symbol_time) is not otp.nsectime and ott.get_object_type(symbol_time) is not str:
+            raise ValueError(
+                f'Parameter of type {ott.get_object_type(symbol_time)} passed as symbol_time! '
+                'This parameter only supports datetime values or strings'
+            )
+        if is_join_with_query_symbol_time_otq_supported():
+            params = params.copy()
+            params['_SYMBOL_TIME'] = symbol_time
+        else:
+            converted_symbol_param_columns['_PARAM_SYMBOL_TIME'] = symbol_time
+
     params_str = _columns_to_params_for_joins(params, query_params=True)
     symbol_params_str = _columns_to_params_for_joins(converted_symbol_param_columns)
 

{onetick_py-1.167.0 → onetick_py-1.169.0}/src/onetick/py/db/_inspection.py

@@ -7,7 +7,7 @@ from dateutil.tz import gettz
 
 import onetick.py as otp
 from onetick.py import configuration, utils
-from onetick.py.compatibility import is_native_plus_zstd_supported
+from onetick.py.compatibility import is_native_plus_zstd_supported, is_show_db_list_show_description_supported
 from onetick.py.core import db_constants
 from onetick.py.otq import otq
 
@@ -25,8 +25,9 @@ class DB:
     dates with data, symbols, tick schema, etc.
     """
 
-    def __init__(self, name, context=utils.default):
+    def __init__(self, name, description='', context=utils.default):
         self.name = name
+        self.description = description
         if context is utils.default or context is None:
             self.context = otp.config.context
         else:
@@ -907,7 +908,9 @@ class DB:
         return df
 
 
-def databases(context=utils.default, derived=False, readable_only: bool = True) -> dict[str, DB]:
+def databases(
+    context=utils.default, derived: bool = False, readable_only: bool = True, fetch_description: bool = False,
+) -> dict[str, DB]:
     """
     Gets all available databases in the ``context``
 
@@ -925,6 +928,9 @@ def databases(context=utils.default, derived=False, readable_only: bool = True)
     readable_only: bool
         If set to True (default), then return only the databases with read-access for the current user.
         Otherwise return all databases visible from the current process.
+    fetch_description: bool
+        If set to True, retrieves descriptions for databases and puts them into ``description`` property of
+        :py:class:`~onetick.py.DB` objects in a returned dict.
 
     See also
     --------
@@ -938,17 +944,47 @@ def databases(context=utils.default, derived=False, readable_only: bool = True)
         Dict where keys are database names and values are :class:`DB <onetick.py.db._inspection.DB>` objects
         with ``context`` specified.
     """
+    if fetch_description and not is_show_db_list_show_description_supported():
+        fetch_description = False
+
     if readable_only:
         node = (
             otq.AccessInfo(info_type='DATABASES', show_for_all_users=False, deep_scan=True).tick_type('ANY')
             >> otq.Passthrough('DB_NAME,READ_ACCESS')
             >> otq.WhereClause(where='READ_ACCESS = 1')
         )
+
+        if fetch_description:
+            join = otq.Join(
+                left_source='LEFT', join_type='LEFT_OUTER', join_criteria='LEFT.DB_NAME = RIGHT.DATABASE_NAME'
+            )
+
+            _ = node.set_node_name('LEFT') >> join
+            _ = (
+                otq.ShowDbList(show_description=fetch_description).tick_type('ANY')
+                >> otq.Passthrough('DATABASE_NAME,DESCRIPTION').set_node_name('RIGHT')
+                >> join
+            )
+
+            node = (
+                join >> otq.Passthrough('LEFT.DB_NAME,RIGHT.DESCRIPTION')
+                >> otq.RenameFields("LEFT.DB_NAME=DB_NAME,RIGHT.DESCRIPTION=DESCRIPTION")
+            )
     else:
+        db_list_kwargs = {}
+        output_fields = ['DATABASE_NAME']
+        if fetch_description:
+            db_list_kwargs['show_description'] = fetch_description
+            output_fields.append('DESCRIPTION')
+
         node = (
-            otq.ShowDbList().tick_type('ANY')
-            >> otq.Passthrough('DATABASE_NAME')
+            otq.ShowDbList(**db_list_kwargs).tick_type('ANY')
+            >> otq.Passthrough(','.join(output_fields))
         )
+
+    if not fetch_description:
+        node = node >> otq.AddField('DESCRIPTION', '""')
+
     dbs = otp.run(node,
                   symbols='LOCAL::',
                   # start and end times don't matter for this query, use some constants
@@ -961,9 +997,14 @@ def databases(context=utils.default, derived=False, readable_only: bool = True)
         return {}
 
     db_list = list(dbs['DB_NAME'] if readable_only else dbs['DATABASE_NAME'])
-    db_dict = {db_name: DB(db_name, context=context) for db_name in db_list}
+    merged_db_list = list(zip(db_list, dbs['DESCRIPTION']))
+
+    db_dict = {
+        db_name: DB(db_name, description=db_description, context=context) for db_name, db_description in merged_db_list
+    }
+
     if derived:
-        kwargs = derived if isinstance(derived, dict) else {}
+        kwargs: dict = derived if isinstance(derived, dict) else {}
         kwargs.setdefault('context', context)
         db_dict.update(
             derived_databases(**kwargs)

{onetick_py-1.167.0 → onetick_py-1.169.0}/src/onetick/py/run.py

@@ -84,14 +84,14 @@ def run(query: Union[Callable, Dict, otp.Source, otp.MultiOutputSource,  # NOSON
     start: :py:class:`datetime.datetime`, :py:class:`otp.datetime <onetick.py.datetime>`,\
             :py:class:`pyomd.timeval_t`, optional
         The start time of the query. Can be timezone-naive or timezone-aware. See also ``timezone`` argument.
-        onetick.py uses :py:attr:`default_start_time<onetick.py.configuration.Config.default_start_time>`
+        onetick.py uses :py:attr:`otp.config.default_start_time<onetick.py.configuration.Config.default_start_time>`
         as default value, if you don't want to specify start time, e.g. to use saved time of the query,
         then you should specify None value.
     end: :py:class:`datetime.datetime`, :py:class:`otp.datetime <onetick.py.datetime>`,\
           :py:class:`pyomd.timeval_t`, optional
         The end time of the query (note that it's non-inclusive).
         Can be timezone-naive or timezone-aware. See also ``timezone`` argument.
-        onetick.py uses :py:attr:`default_end_time<onetick.py.configuration.Config.default_end_time>`
+        onetick.py uses :py:attr:`otp.config.default_end_time<onetick.py.configuration.Config.default_end_time>`
         as default value, if you don't want to specify end time, e.g. to use saved time of the query,
         then you should specify None value.
     date: :py:class:`datetime.date`, :py:class:`otp.date <onetick.py.date>`, optional
@@ -109,28 +109,30 @@ def run(query: Union[Callable, Dict, otp.Source, otp.MultiOutputSource,  # NOSON
          The timezone of output timestamps.
          Also, when start and/or end arguments are timezone-naive, it will define their timezone.
          If parameter is omitted timestamps of ticks will be formatted
-         with the default :py:attr:`tz<onetick.py.configuration.Config.tz>`.
+         with the default :py:attr:`otp.config.tz<onetick.py.configuration.Config.tz>`.
     context: str, optional
         Allows specification of different contexts from OneTick configuration to connect to.
-        If not set then default :py:attr:`context<onetick.py.configuration.Config.context>` is used.
+        If not set then default :py:attr:`otp.config.context<onetick.py.configuration.Config.context>` is used.
         See :ref:`guide about switching contexts <switching contexts>` for examples.
     username
         The username to make the connection.
-        By default the user which executed the process is used.
+        By default the user which executed the process is used or the value specified in
+        :py:attr:`otp.config.default_username<onetick.py.configuration.Config.default_username>`.
     alternative_username: str
         The username used for authentication.
         Needs to be set only when the tick server is configured to use password-based authentication.
-        By default, :py:attr:`default_auth_username<onetick.py.configuration.Config.default_auth_username>` is used.
+        By default,
+        :py:attr:`otp.config.default_auth_username<onetick.py.configuration.Config.default_auth_username>` is used.
         Not supported for WebAPI mode.
     password: str, optional
         The password used for authentication.
         Needs to be set only when the tick server is configured to use password-based authentication.
         Note: not supported and ignored on older OneTick versions.
-        By default, :py:attr:`default_password<onetick.py.configuration.Config.default_password>` is used.
+        By default, :py:attr:`otp.config.default_password<onetick.py.configuration.Config.default_password>` is used.
     batch_size: int
         number of symbols to run in one batch.
         By default, the value from
-        :py:attr:`default_batch_size<onetick.py.configuration.Config.default_batch_size>` is used.
+        :py:attr:`otp.config.default_batch_size<onetick.py.configuration.Config.default_batch_size>` is used.
         Not supported for WebAPI mode.
     running: bool, optional
         Indicates whether a query is CEP or not. Default is `False`.
@@ -139,7 +141,7 @@ def run(query: Union[Callable, Dict, otp.Source, otp.MultiOutputSource,  # NOSON
     concurrency: int, optional
         The maximum number of CPU cores to use to process the query.
         By default, the value from
-        :py:attr:`default_concurrency<onetick.py.configuration.Config.default_concurrency>` is used.
+        :py:attr:`otp.config.default_concurrency<onetick.py.configuration.Config.default_concurrency>` is used.
     apply_times_daily: bool
         Runs the query for every day in the ``start``-``end`` time range,
         using the time components of ``start`` and ``end`` datetimes.
@@ -195,9 +197,8 @@ def run(query: Union[Callable, Dict, otp.Source, otp.MultiOutputSource,  # NOSON
         If set to True, result will be forced to be a dictionary even if it's returned for a single symbol
     max_expected_ticks_per_symbol: int
         Expected maximum number of ticks per symbol (used for performance optimizations).
-        By default,
-        :py:attr:`max_expected_ticks_per_symbol<onetick.py.configuration.Config.max_expected_ticks_per_symbol>`
-        is used.
+        By default, :py:attr:`otp.config.max_expected_ticks_per_symbol \
+            <onetick.py.configuration.Config.max_expected_ticks_per_symbol>` is used.
         Not supported for WebAPI mode.
     log_symbol: bool
         Log currently executed symbol.
@@ -547,6 +548,7 @@ def run(query: Union[Callable, Dict, otp.Source, otp.MultiOutputSource,  # NOSON
     start, end = _get_start_end(start, end, timezone)
 
     # authentication
+    username = username or otp.config.default_username
     alternative_username = alternative_username or otp.config.default_auth_username
     password = password or otp.config.default_password
     kwargs = {}

{onetick_py-1.167.0 → onetick_py-1.169.0}/src/onetick_py.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onetick-py
-Version: 1.167.0
+Version: 1.169.0
 Summary: Python package that allows you to work with OneTick
 Author-email: solutions <solutions@onetick.com>
 License-Expression: MIT