onetick-py 1.162.2__py3-none-any.whl

locator_parser/io.py

@@ -0,0 +1,41 @@
+import weakref
+from locator_parser.common import Reader, Writer
+
+
+class FileWriter(Writer):
+
+    def __init__(self, file_path):
+        self.__path = file_path
+
+        super(FileWriter, self).__init__()
+
+    def flush(self):
+        with open(self.__path, "w") as fout:
+            for line in self.lines:
+                if line[-1:] != "\n":
+                    line += "\n"
+
+                fout.write(line)
+
+
+class PrintWriter(Writer):
+
+    def flush(self):
+        print("\n".join(self.lines))
+
+
+class FileReader(Reader):
+
+    def __init__(self, file_path):
+        self.iterable_object = open(file_path.replace('"', ""), "r")
+        self.__finalizer = weakref.finalize(self, lambda x: x.close(), self.iterable_object)
+
+        super(FileReader, self).__init__()
+
+
+class LinesReader(Reader):
+
+    def __init__(self, lines):
+        self.iterable_object = lines.split("\n")
+
+        super(LinesReader, self).__init__()

locator_parser/locator.py

@@ -0,0 +1,150 @@
+import os
+import re
+
+from locator_parser.common import Entity
+from locator_parser.io import FileReader, PrintWriter
+from locator_parser.actions import DoNothing
+
+
+class Include(Entity):
+    TAG = "INCLUDE"
+    SINGLE = True
+    RECURSIVELY = False
+
+    def parse(self, reader, writer, action):
+        path = self.path
+        matched = re.search(r"\$\{(.*)\}", path)
+
+        # env variable found in the path
+        if matched:
+            if matched.group(0)[2:-1] not in os.environ:
+                raise Exception("Includes use not defined environment variable: % s" % matched.group(0))
+
+            path = path.replace(matched.group(0), os.environ[matched.group(0)[2:-1]])
+
+        # read locator recursivly
+        if Include.RECURSIVELY:
+            parse_locator(FileReader(path), PrintWriter(), action, recursively=True)
+
+
+class Includes(Entity):
+    TAG = "INCLUDES"
+    CHILDREN = [Include]
+
+
+class Location(Entity):
+    TAG = "LOCATION"
+    SINGLE = True
+
+
+class Locations(Entity):
+    TAG = "LOCATIONS"
+    CHILDREN = [Location]
+
+
+class RawDB(Entity):
+    TAG = "RAW_DB"
+    CHILDREN = [Locations]
+    HAS_PROPERTIES = True
+
+
+class RawData(Entity):
+    TAG = "RAW_DATA"
+    CHILDREN = [RawDB]
+
+
+class FeedOptions(Entity):
+    TAG = "OPTIONS"
+    SINGLE = True
+
+
+class Feed(Entity):
+    TAG = "FEED"
+    HAS_PROPERTIES = True
+    CHILDREN = [FeedOptions]
+
+
+class DB(Entity):
+    TAG = "DB"
+    CHILDREN = [Locations, RawData, Feed]
+    HAS_PROPERTIES = True
+
+
+class DBs(Entity):
+    TAG = "DATABASES"
+    CHILDREN = [DB]
+
+
+class ServerLocation(Entity):
+    TAG = "LOCATION"
+    SINGLE = True
+
+
+class TickServers(Entity):
+    TAG = "TICK_SERVERS"
+    CHILDREN = [ServerLocation]
+
+
+class CEPServerLocation(Entity):
+    TAG = "LOCATION"
+    SINGLE = True
+
+
+class CEPTickServers(Entity):
+    TAG = "CEP_TICK_SERVERS"
+    CHILDREN = [CEPServerLocation]
+
+
+class Range(Entity):
+    TAG = "RANGE"
+    SINGLE = True
+
+
+class TimeInterval(Entity):
+    TAG = "TIME_INTERVAL"
+    HAS_PROPERTIES = True
+    CHILDREN = [Range]
+
+
+class VirtualDB(Entity):
+    TAG = "DB"
+    HAS_PROPERTIES = True
+    CHILDREN = [TimeInterval]
+
+
+class VirtualDBs(Entity):
+    TAG = "VIRTUAL_DATABASES"
+    CHILDREN = [VirtualDB]
+
+
+def parse_locator(reader, writer, action=DoNothing(), recursively=False):
+    Include.RECURSIVELY = recursively
+    writer.refresh()
+    reader.set_writer(writer)
+
+    databases_p = DBs()
+    v_databases_p = VirtualDBs()
+    tick_servers_p = TickServers()
+    cep_tick_servers_p = CEPTickServers()
+    includes_p = Includes()
+
+    for _ in reader:
+        databases_p(reader, writer, action)
+        v_databases_p(reader, writer, action)
+        tick_servers_p(reader, writer, action)
+        cep_tick_servers_p(reader, writer, action)
+        includes_p(reader, writer, action)
+
+
+# ----------------------------------------- #
+# set parent
+for _, cls in list(globals().items()):
+    try:
+        if issubclass(cls, Entity) and cls != Entity:
+            for child in cls.CHILDREN:
+                child.PARENT = Entity
+
+                if not cls.HAS_PROPERTIES and not cls.SINGLE:
+                    child.PARENT = cls
+    except Exception:
+        continue

onetick/__init__.py

@@ -0,0 +1,101 @@
+import sys
+
+
+def __search_main_one_tick_dir():
+    try:
+        import onetick.query_webapi  # noqa
+        # if onetick.query_webapi is imported successfully, do not raise any warnings
+        return __search_main_one_tick_dir_catch(show_warnings=False)
+    except ImportError:
+        return __search_main_one_tick_dir_catch(show_warnings=True)
+
+
+def __search_main_one_tick_dir_catch(show_warnings=True):  # noqa: C901
+    import os
+    import warnings
+    import sysconfig
+    from pathlib import Path
+
+    if os.environ.get('OTP_SKIP_OTQ_VALIDATION', False):
+        try:
+            import onetick_stubs  # noqa
+        except ImportError:
+            if show_warnings:
+                warnings.warn(
+                    "OTP_SKIP_OTQ_VALIDATION environment variable is set,"
+                    " but onetick_stubs module is not available."
+                    " Please, install onetick-query-stubs to avoid import errors"
+                    " or unset OTP_SKIP_OTQ_VALIDATION to use onetick.query module."
+                )
+        return tuple()
+
+    config_vars = sysconfig.get_config_vars()
+
+    ot_bin_path = os.path.join("bin")
+    ot_python_path = os.path.join(ot_bin_path, "python")
+    ot_numpy_path = os.path.join(
+        ot_bin_path,
+        "numpy",
+        "python"
+        # short python version 27, 36, 37, etc
+        + config_vars["py_version_nodot"]
+        # suffix at the end, either empty string for python with the standard memory allocator,
+        # or 'm' for python with the py-malloc allocator
+        + config_vars["abiflags"],
+    )
+
+    if os.name == "nt":
+        default_main_one_tick_dir = "C:/OMD/one_market_data/one_tick"
+    elif os.name == "posix":
+        default_main_one_tick_dir = "/opt/one_market_data/one_tick"
+    else:
+        default_main_one_tick_dir = None
+
+    main_one_tick_dir = os.environ.get("MAIN_ONE_TICK_DIR")
+
+    if not main_one_tick_dir:
+        message = (
+            "MAIN_ONE_TICK_DIR environment variable is not set."
+            " It is a recommended way to let onetick-py know where OneTick python libraries are located."
+        )
+        if not default_main_one_tick_dir:
+            if show_warnings:
+                warnings.warn(message)
+            return
+        message += f" We will try to use default value for your system: {default_main_one_tick_dir}."
+        if show_warnings:
+            warnings.warn(message)
+        main_one_tick_dir = default_main_one_tick_dir
+
+    main_one_tick_dir = Path(main_one_tick_dir)
+
+    if not main_one_tick_dir.is_dir():
+        if show_warnings:
+            warnings.warn(
+                f"MAIN_ONE_TICK_DIR is set to '{main_one_tick_dir}',"
+                " but this path is not a directory or doesn't exist."
+            )
+        return
+
+    ot_bin_path = main_one_tick_dir / ot_bin_path
+    ot_python_path = main_one_tick_dir / ot_python_path
+
+    for directory in (ot_python_path, ot_bin_path):
+        if not directory.is_dir():
+            if show_warnings:
+                warnings.warn(
+                    f"MAIN_ONE_TICK_DIR is set to '{main_one_tick_dir}',"
+                    f" and it must contain '{directory}' directory,"
+                    " but this path is not a directory or doesn't exist."
+                )
+            return
+
+    ot_numpy_path = main_one_tick_dir / ot_numpy_path
+
+    return (ot_bin_path, ot_python_path, ot_numpy_path)
+
+
+for directory in __search_main_one_tick_dir() or []:
+    sys.path.append(str(directory))
+
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)

onetick/doc_utilities/__init__.py

@@ -0,0 +1,3 @@
+from .ot_doctest import (register_ot_directive,
+                         apply_directive,
+                         OTDoctestParser)

onetick/doc_utilities/napoleon.py

@@ -0,0 +1,40 @@
+from typing import List
+from sphinx.ext.napoleon.docstring import NumpyDocstring
+from sphinx.locale import get_translation
+from onetick.doc_utilities.snippets import parse_string
+
+
+class OTNumpyDocstring(NumpyDocstring):
+
+    def _parse_examples_section(self, section: str) -> List[str]:
+
+        """Applies OT directives for all lines"""
+
+        # combining super()._parse_examples_section and super()._parse_generic_section
+        # due to super()._parse_examples_section just prepare parameters and
+        # super()._parse_generic_section get lines and modify them.
+        # but we need to add logic on lines but before super()._parse_generic_section modification
+        labels = {
+            'example': get_translation('sphinx')('Example'),
+            'examples': get_translation('sphinx')('Examples'),
+        }
+        use_admonition = self._config.napoleon_use_admonition_for_examples
+        section = labels.get(section.lower(), section)
+
+        lines = self._strip_empty(self._consume_to_next_section())
+        lines = self._dedent(lines)
+
+        # OneTick custom logic start
+        doc = parse_string('\n'.join(lines), caller='doc')
+        lines = doc.split('\n')
+        # OneTick custom logic end
+
+        if use_admonition:
+            header = '.. admonition:: %s' % section     # noqa
+            lines = self._indent(lines, 3)
+        else:
+            header = '.. rubric:: %s' % section     # noqa
+        if lines:
+            return [header, ''] + lines + ['']
+        else:
+            return [header, '']

onetick/doc_utilities/ot_doctest.py

@@ -0,0 +1,140 @@
+import doctest
+import re
+import inspect
+
+from typing import Union, Optional
+from onetick.py.backports import Literal
+
+
+def snippet_name(example: Union[doctest.Example, str], value):
+    if isinstance(example, doctest.Example):
+        example.name = value    # type: ignore
+    return example
+
+
+def skip_snippet(example: Union[doctest.Example, str], value):
+    if isinstance(example, doctest.Example):
+        example.skip_snippet = True    # type: ignore
+    return example
+
+
+def skip_example(example, value, caller=None):
+    if caller is not None and value != '' and value != caller:  # do nothing if caller passed and value not caller
+        return example
+    if isinstance(example, doctest.Example):
+        example.skip = True
+        return example
+
+
+OT_DIRECTIVES = {'skip-example': skip_example,
+                 'snippet-name': snippet_name,
+                 'skip-snippet': skip_snippet}
+
+
+def register_ot_directive(directive, fun):
+    """
+    Register OT directive.
+
+    directive sintax: ...    OTdirective: <directive>: <directive_parameter>;
+
+    Parameters
+    ----------
+    directive: str
+        directive name
+    fun: callable
+        fun will be executed if `directive` will be found
+        fun should have two positional parameters:
+            first: string or doctest.Example
+            second: direction parameter
+        fun should return str, doctest.Example or None
+    """
+    OT_DIRECTIVES[directive] = fun
+
+
+class ApplyDirective:
+
+    _OT_DIRECTIVE_RE = r'(.*?)\s*# OTdirective: (.*)'
+    _OT_DIRECTIVE_PARSER = re.compile(r'\s*?(?P<func>[A-Za-z_\-0-9]*)\s*?:(?P<param>[^:;]*);')
+
+    def __init__(self, caller: Optional[str] = None):
+        self.caller = caller
+
+    def _get_directives(self, item):
+        is_example = isinstance(item, doctest.Example)
+        string = item
+        if is_example:
+            string = item.source
+        res = []
+        funcs = []
+        for doc in string.split('\n'):
+            s, f = self._get_directives_impl(doc)
+            res.append(s)
+            funcs.extend(f)
+
+        string = '\n'.join(res)
+        if is_example:
+            item.source = string
+            return item, funcs
+        return string, funcs
+
+    def _get_directives_impl(self, string: str):
+        directives = re.match(self._OT_DIRECTIVE_RE, string, re.MULTILINE | re.DOTALL)
+        if directives is None:
+            return string, {}
+        doc, directive_str = directives.groups()
+        funcs = []
+        for fun, v in re.findall(self._OT_DIRECTIVE_PARSER, directive_str):
+            if fun.strip() not in OT_DIRECTIVES:
+                raise KeyError(f"Unknown directive: '{fun.strip()}'. Original: '{directive_str}'")
+            funcs.append((OT_DIRECTIVES[fun.strip()], v.strip()))
+        return doc, funcs
+
+    def __call__(self, item):
+        doc, funcs = self._get_directives(item)
+        for fun, param in funcs:
+            params = {}
+            if self.caller and 'caller' in inspect.signature(fun).parameters.keys():
+                params['caller'] = self.caller
+            doc = fun(doc, param, **params)
+        return doc
+
+
+def apply_directive(example: Union[doctest.Example, str], caller: Optional[str] = None):
+
+    """
+    Applies OT directive to `example`
+    Drops directive comment
+
+    See Also
+    --------
+    register_ot_directive
+    """
+
+    return ApplyDirective(caller)(example)
+
+
+class OTDoctestParser(doctest.DocTestParser):
+
+    """
+    This class applicable only to parse doctest example!
+    Do not run tests with this parser!
+    """
+
+    def __init__(self, *args, caller: Optional[str] = None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.caller = caller
+
+    def _IS_BLANK_OR_COMMENT(self, value):
+
+        if value.strip().startswith('# OTdirective'):
+            return False
+        else:
+            return super()._IS_BLANK_OR_COMMENT(value)
+
+    def parse(self, *args, **kwargs):
+        """
+        Applies OT directive for all examples
+        """
+        examples = super().parse(*args, **kwargs)
+        res = [apply_directive(x, self.caller) for x in examples]
+        return res