onetick-py 1.177.0__py3-none-any.whl

onetick/py/core/_internal/_state_vars.py

@@ -0,0 +1,93 @@
+from onetick.py.otq import otq
+from onetick.py import state
+from onetick.py.core._internal._op_utils.is_const import is_const
+
+from onetick.py.core.column_operations.base import _Operation
+from onetick.py.core._internal._state_objects import _StateColumn, _StateBase, _TickSequence
+from onetick.py.types import type2str, value2str
+
+
+class StateVars:
+    def __init__(self, owner, previous=None):
+        """ Class for organizing state variables
+
+        Parameters
+        ----------
+        owner: _Source
+            Owner of the object
+        previous: collections of dict of _Source, optional
+            Dictionaries to copy state variables from
+        """
+        self._owner = owner
+        self._columns = {}
+        previous = previous if isinstance(previous, (list, tuple)) else (previous,)
+        for p in previous:
+            if p:
+                for name, column in p.state_vars.items:
+                    value = column
+                    if isinstance(value, _StateBase):
+                        value = value.copy(obj_ref=self, name=name)
+                    self._columns[name] = value
+
+    def __contains__(self, item):
+        return item in self._columns
+
+    def __getitem__(self, item):
+        return self._columns[item]
+
+    def __setitem__(self, key, value):
+        if isinstance(value, _Operation):
+            value = self._set_var_from_operation(key, value)
+        elif isinstance(value, _StateBase):
+            value = value.copy(obj_ref=self, name=key)
+        elif key not in self._columns:
+            value = state.var(value).copy(obj_ref=self, name=key)
+
+        if key in self._columns:
+            self._owner._update_field(self._columns[key], value)
+        else:
+            self._declare_new_var(key, value)
+            self._columns[key] = value
+
+    def _set_var_from_operation(self, key, value):
+        if isinstance(value, _StateColumn):
+            assert not value.obj_ref, "You can't set state variable of one Source to another"
+            value.obj_ref = self._owner
+            value.name = key
+        else:
+            if not is_const(value):
+                assert (key in self._columns), "OneTick supports state variables creation with constants only"
+            else:
+                value = state.var(value).copy(obj_ref=self, name=key)
+        return value
+
+    @property
+    def items(self):
+        return tuple(self._columns.items())  # prevent mutation
+
+    @property
+    def names(self):
+        return tuple(self._columns.keys())
+
+    def _declare_new_var(self, name, value):
+        # obj_ref is None means that we need to declare it
+        base_type = value.dtype
+        str_type = ""
+
+        if isinstance(value, _TickSequence):
+            # TODO: maybe create definition() for _StateColumn too and move this logic there
+            str_type = value._definition()
+        else:
+            str_type = type2str(base_type)
+
+        expression = f'{str_type} {name}'
+
+        import onetick.py as otp
+        if value.default_value is not None:
+            if isinstance(value.default_value, otp.Source):
+                value_expression = otp.eval(value.default_value).to_eval_string(self._owner._tmp_otq)
+            else:
+                # TODO: PY-952: use to_eval_string(self._owner._tmp_otq) here if otp.eval is passed
+                value_expression = value2str(value.default_value)
+            expression += f' = {value_expression}'
+        self._owner.sink(otq.DeclareStateVariables(variables=expression, scope=value.scope))

onetick/py/core/_source/_symbol_param.py

@@ -0,0 +1,95 @@
+import onetick.py as otp
+import onetick.py.types as ott
+from onetick.py.core.column import _Column
+from onetick.py.core.column_operations.base import _Operation
+
+
+class _SymbolParamColumn(_Column):
+    """
+    Internal object representing OneTick's symbol parameters.
+    Can be used in other onetick.py methods to specify if object is symbol parameter.
+    """
+
+    def __init__(self, *args, default=None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._default = default
+
+    def __str__(self):
+        result = super().__str__()
+
+        # TODO: PY-35
+        # This is ad-hoc check, really we need to change column formatting to
+        # pre- and post-formats, and copy columns through the .copy() method
+        # on the _Column instead of copying them manually in different places
+        # of the _Source class
+        if self.name != '_SYMBOL_NAME':
+            result = f'_SYMBOL_PARAM.{self.name}'
+
+        if self._default is not None:
+            default_formatted = ott.value2str(self._default)
+            default_formatted = f'TOSTRING({default_formatted})'
+            result = f'CASE(UNDEFINED("{result}"), false, {result}, {default_formatted})'
+
+        # symbol params are always string, need to convert
+        result = _Operation(op_str=result, dtype=str)
+
+        if self.dtype is ott.nsectime:
+            result = result.str.to_datetime(unit='ns')
+        elif self.dtype is ott.msectime:
+            result = result.str.to_datetime(unit='ms')
+        else:
+            result = result.astype(self.dtype)
+
+        return str(result)
+
+
+class _SymbolParamSource:
+    """
+    Internal container that provides access to symbol parameters.
+    The object is read-only, you can only get symbol parameters with it.
+    """
+
+    def __init__(self, **columns):
+
+        if 'name' in columns:
+            raise ValueError(
+                'name field is a specific field for accessing _SYMBOL_NAME variable, please rename your parameter'
+            )
+
+        # "SYMBOL_NAME" field won't be propagated as a symbol parameter by onetick, so we should remove it here
+        columns.pop('SYMBOL_NAME', None)
+
+        for key, dtype in columns.items():
+            # TODO: change to immutable Column, PY-35
+            self.__dict__[key] = _SymbolParamColumn(key, dtype, self)
+
+        self.__dict__['name'] = _SymbolParamColumn('_SYMBOL_NAME', str, self)
+        self.__dict__['_SYMBOL_NAME'] = self.__dict__['name']
+
+        # set schema
+        schema = columns.copy()
+
+        for meta_c in otp.meta_fields.get_onetick_fields_and_types():
+            schema.pop(meta_c, None)
+
+        self.__dict__['_schema'] = schema
+
+    @property
+    def schema(self):
+        """
+        Represents actual python data schema in the column name -> type format.
+        """
+        return self._schema
+
+    def __getitem__(self, key):
+        """
+        Get symbol parameter with corresponding ``key``.
+        Raises an error if such column does not exist.
+        """
+        if key not in self.__dict__:
+            raise AttributeError(f"There is no '{key}' column")
+
+        return self.__dict__[key]
+
+    def __setattr__(self, key, value):
+        raise NotImplementedError('Symbol params are read only')

onetick/py/core/_source/schema.py

@@ -0,0 +1,97 @@
+from typing import Dict
+import collections.abc
+
+
+class Schema(collections.abc.Mapping):
+    """
+    A source data schema proxy. It allows to work with source schema in
+    a frozen-dict manner. It also allows to set using the ``set``
+    and update a source schema using the ``update`` methods.
+    """
+
+    dict_cls = dict
+
+    def __init__(self, _base_source=None, _hidden_columns=None, **kwargs):
+        self._dict = self.dict_cls(**kwargs)
+        self._base_source = _base_source
+        self._hash = None
+        self._hidden_columns = _hidden_columns if _hidden_columns else {}
+
+    def __getitem__(self, item):
+        if isinstance(item, list):
+            return {key: value for key, value in self._dict.items()
+                    if key in item}
+
+        if item in self._hidden_columns:
+            return self._hidden_columns[item]
+
+        return self._dict[item]
+
+    def __setitem__(self, key, value):
+        self.update(**{key: value})
+
+    def __contains__(self, item):
+        if item in self._hidden_columns:
+            return True
+
+        return item in self._dict
+
+    def __iter__(self):
+        return iter(self._dict)
+
+    def items(self):
+        return self._dict.items()
+
+    def keys(self):
+        return self._dict.keys()
+
+    def copy(self):
+        return self._dict.copy()
+
+    def set(self, **new_schema: type):
+        """
+        Drops the python schema representation of a source and sets the new one from the `new_schema`
+
+        Parameters
+        ----------
+        new_schema: Dict[str, type]
+            schema in the column-name -> type format
+
+        Returns
+        -------
+            None
+        """
+        self._base_source.set_schema(**new_schema)
+
+    def update(self, **other_schema: type):
+        """
+        Updates the python schema representation of a source: values from matching keys
+        will be overridden from the `other_schema`, values from new keys will be added.
+
+        Parameters
+        ----------
+        other_schema:
+            schema in the column-name -> type format
+
+        Returns
+        -------
+            None
+        """
+        current_schema = self._base_source.columns(skip_meta_fields=True)
+        current_schema.update(other_schema)
+
+        self._base_source.set_schema(**current_schema)
+
+    def __len__(self):
+        return len(self._dict)
+
+    def __repr__(self):
+        return repr(self._dict)
+
+    def __hash__(self):
+        if self._hash is None:
+            h = 0
+            for key, value in self._dict.items():
+                h ^= hash((key, value))
+            self._hash = h
+        return self._hash