onetick-py 1.162.2__py3-none-any.whl

onetick/py/db/utils.py

@@ -0,0 +1,64 @@
+import os
+
+from onetick.py.otq import otli
+from onetick.py.db import DB
+from onetick.py.session import Session
+
+
+class TmpSession:
+    def __init__(self):
+        if Session._instance is None:
+            if "ONE_TICK_CONFIG" in os.environ:
+                # use external session
+                otli.OneTickLib()
+                self.session = None
+                self.session_is_owned = False
+            else:
+                self.session_is_owned = True
+                self.session = Session()
+
+        else:
+            self.session_is_owned = False
+            self.session = Session._instance
+            self.temp_dbs = []
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.session:  # exclude case when session is set externally, ie using ONE_TICK_CONFIG
+            if self.session_is_owned:
+                self.session.close()
+            else:
+                for db in self.temp_dbs:
+                    self.session.locator.remove(db)
+
+    def __db_is_registered(self, db):
+        base_db = str(db).split("//")[0]    # noqa
+        return (base_db in self.session.databases) or (base_db in self.session.locator.databases)
+
+    def use(self, db):
+        if self.session is None and isinstance(db, str) and "ONE_TICK_CONFIG" in os.environ:
+            # we assume that database is already in the locator, that is
+            # managed externally by user, and we don't need to add it
+            # into the locator
+            return
+
+        if not isinstance(db, (str, DB)):
+            raise TypeError(
+                "Only a DB object or a string can be passed as db into get_"
+                f"functions working with databases. Instead, {db.__class__} was provided."
+            )
+
+        if isinstance(db, str) and not self.__db_is_registered(db):
+            if self.session_is_owned:
+                raise TypeError(
+                    "When there is no active session, db argument must be a DB object, not a database name."
+                )
+            else:
+                raise TypeError(f"We can not find passed database {db} in the session")
+
+        if not self.__db_is_registered(db):
+            self.session.locator.add(db)
+            if not self.session_is_owned:
+                self.temp_dbs.append(db)

onetick/py/docs/docstring_parser.py

@@ -0,0 +1,112 @@
+import re
+
+from collections import OrderedDict
+from inspect import Parameter
+from textwrap import dedent
+
+
+class Docstring:
+
+    def __init__(self, doc: str):
+        if type(doc) is list:
+            doc = '\n'.join(doc)
+        self.doc = doc
+        self.indentation = ' ' * (len(doc.lstrip('\n')) - len(doc.lstrip()))
+        self.docstring = self._parse()  # NOSONAR
+
+        self.order = ('Description',
+                      'Parameters',
+                      'Return',
+                      'Returns',
+                      'Note',
+                      'Notes',
+                      'Example',
+                      'Examples',
+                      'See Also')
+
+    def _parse(self):
+        def get_prev_name(s: str):
+            doc_, name_ = s.rstrip('\n').rsplit('\n', maxsplit=1)
+            prefix_ = name_
+            name_ = name_.strip()
+            prefix_ += '\n' + ' ' * (len(prefix_) - len(name_)) + '-' * len(name_)
+            return doc_, name_, prefix_
+
+        docstring = OrderedDict()
+        res = re.split(' *?-{4,}', self.doc)  # NOSONAR
+        name = 'Description'
+        prefix = ''
+
+        # if there is no description part
+        if len(res[0].strip().splitlines()) == 1 and len(res) > 1:
+            name = res.pop(0).strip()
+            prefix = self.indentation + name + '\n' + self.indentation + '-' * len(name)
+
+        for i, part in enumerate(res):
+            if i == len(res) - 1:
+                docstring[name] = prefix + part
+                break
+            d, next_name, next_prefix = get_prev_name(part)
+            docstring[name] = prefix + d
+            name, prefix = next_name, next_prefix
+        return docstring
+
+    def get_sig(self, add_self=False):
+        """
+        Get signature from existing documentation string.
+        """
+        text = self.docstring.get('Parameters')
+        if not text:
+            return []
+        text = dedent(text)
+        text = re.split('-{4,}', text)[1]
+        parameters = []
+        for line in text.splitlines():
+            if not line or line[0] in (' ', '\t'):
+                continue
+            name, _, _ = line.partition(':')
+            if name == 'self' and not add_self:
+                continue
+            parameters.append(Parameter(name=name, kind=Parameter.POSITIONAL_OR_KEYWORD))
+        return parameters
+
+    def __setitem__(self, key, value):
+        if key not in self.docstring:
+            if key == 'Description':
+                self.docstring[key] = ''
+            else:
+                self.docstring[key] = self.indentation + key + '\n'
+                self.docstring[key] += self.indentation + '-' * len(key) + '\n'
+        for line in value.split('\n'):
+            self.docstring[key] += self.indentation + line + '\n'
+
+    def _apply_order(self):
+        key_map = dict((k.lower(), k) for k in self.docstring.keys())
+        for k in self.order[::-1]:
+            if k.lower() in key_map:
+                self.docstring.move_to_end(key_map[k.lower()], last=False)
+
+    def build(self):
+        self._apply_order()
+        res = ''
+        for k, value in self.docstring.items():
+            res += value + '\n'
+
+        return res
+
+    def update(self, other: 'Docstring'):
+        for key, value in other.docstring.items():
+
+            content = value.split('\n')
+            if key == 'Description':
+                content = content[1:]
+                if not '\n'.join(content).strip():
+                    continue
+            else:
+                content = content[2:]
+
+            if key in self.docstring:
+                self.docstring.pop(key)
+
+            for line in content:
+                self[key] = line[len(self.indentation):]

onetick/py/docs/utils.py

@@ -0,0 +1,81 @@
+import os
+import re
+from typing import Tuple, Optional, TYPE_CHECKING
+from inspect import Parameter, formatannotation, Signature
+from functools import wraps
+
+from onetick.py.docs.docstring_parser import Docstring
+
+if TYPE_CHECKING:
+    from onetick.py.core.source import Source
+
+
+def param_doc(name,
+              str_annotation=None,
+              str_default=None,
+              desc=None,
+              annotation=Parameter.empty,
+              default=Parameter.empty,
+              kind=Parameter.POSITIONAL_OR_KEYWORD) -> Tuple[str, Parameter]:
+    doc = f"""{name}"""
+
+    if str_annotation is None and annotation is not Parameter.empty:
+        str_annotation = formatannotation(annotation)
+
+    if str_annotation:
+        doc += f": {str_annotation}"
+        if str_default:
+            doc += f", default={str_default}"
+        elif default is not Parameter.empty:
+            doc += f", default={default}"
+    if desc:
+        doc += f"    {desc}"
+    param = Parameter(name=name,
+                      kind=kind,
+                      default=default,
+                      annotation=annotation)
+    return doc, param
+
+
+def docstring(parameters: Optional[list] = None, add_self=False):
+    parameters = parameters or []
+
+    def _decorator(fun):
+        @wraps(fun)
+        def _inner(*args, **kwargs):
+            return fun(*args, **kwargs)
+        doc = fun.__doc__ or ''
+        doc = Docstring(doc)
+        sig = []
+        if add_self:
+            sig.append(Parameter(name='self', kind=Parameter.POSITIONAL_OR_KEYWORD))
+        sig.extend(doc.get_sig())
+        for d, param in parameters:
+            doc['Parameters'] = d
+            sig.append(param)
+        _inner.__doc__ = doc.build()
+        _inner.__signature__ = Signature(sig)
+        return _inner
+    return _decorator
+
+
+def alias(aliased_fun, doc_replacer=None, skip_ot_directives=True):
+    """
+    Returns new function with docstring and
+    signature copied from ``aliased_fun``.
+    """
+
+    @wraps(aliased_fun)
+    def fun(*args, **kwargs):
+        return aliased_fun(*args, **kwargs)
+
+    if doc_replacer:
+        fun.__doc__ = doc_replacer(fun.__doc__)
+    if skip_ot_directives:
+        fun.__doc__ = re.sub('# OTdirective: .*', '', fun.__doc__)
+    return fun
+
+
+def is_windows():
+    # PY-866: needed to be used in :skipif: sphinx doctest directives
+    return os.name == 'nt'