onetick-py 1.177.0__py3-none-any.whl

onetick/doc_utilities/snippets.py

@@ -0,0 +1,279 @@
+import os
+import argparse
+import doctest
+import pkgutil
+import json
+from collections import defaultdict
+from typing import List, Optional
+from jupyter_core.paths import jupyter_data_dir, jupyter_config_dir
+import onetick.py as otp
+from onetick.doc_utilities.ot_doctest import OTDoctestParser
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Adding snippets configuration from onetick-py package')
+    parser.add_argument('extension',
+                        choices=['snippets', 'snippets_menu', 'jupyterlab_snippets'],
+                        default='snippets', nargs='?',
+                        help='adding configuration to selected extension')
+    parser.add_argument('-i', '--names-info', action='store_true',
+                        help='show snippet names as yaml "tree"')
+    args = parser.parse_args()
+    return args
+
+
+def collect_examples_from_obj(obj: doctest.DocTest) -> List:
+    """groups examples for one object (docstring)"""
+    snippets = []
+    id_ = 1
+    snippet = Snippet(obj_ref=f'{obj.name} {id_}')
+
+    for example in obj.examples:
+        snippet.append(example)
+        if example.want:
+            snippets.append(snippet)
+            id_ += 1
+            snippet = Snippet(obj_ref=f'{obj.name} {id_}')
+    return snippets
+
+
+def parse_string(string: str, caller: Optional[str] = None) -> str:
+    parser = OTDoctestParser(caller=caller)
+    lines = parser.parse(string)
+    res: List = []
+    snippet = Snippet()
+    for item in lines:
+        if isinstance(item, doctest.Example):
+            snippet.append(item)
+        else:
+            if snippet.code:
+                res.append(snippet)
+                snippet = Snippet()
+            res.append(item)
+    return ''.join(map(str, res))
+
+
+class SnippetInspectionError(Exception):
+    pass
+
+
+def inspect_modules():
+
+    """Inspect onetick.py modules and collect snippets"""
+
+    finder = doctest.DocTestFinder(parser=OTDoctestParser(caller='snippet'))
+    snippets = Snippets()
+
+    error_messages = []
+
+    for _, modname, _ in pkgutil.walk_packages(otp.__path__, prefix=otp.__name__ + '.'):
+        module = __import__(modname, fromlist=['__any__'])
+        for doc in finder.find(module):
+            for snippet in collect_examples_from_obj(doc):
+                try:
+                    snippets.append(snippet)
+                except Exception as e:
+                    error_messages.append(str(e))
+    if error_messages:
+        error_messages = '\t\n'.join(error_messages)
+        message = f"During collection of snippets following exception were raised:\n{error_messages}"
+        raise SnippetInspectionError(message)
+
+    return snippets
+
+
+def set_snippets(content):
+    """Set nbextension-contrib-snippets with content"""
+    snippets = {'snippets': content}
+    path = jupyter_data_dir()
+    path = os.path.join(path, 'nbextensions', 'snippets', 'snippets.json')
+    if not os.path.exists(path):
+        raise FileNotFoundError('Not able to set onetick snippets. Make sure nbextension snippets was installed.'
+                                f'File {path} not found')
+    with open(path, 'w') as f:
+        json.dump(snippets, f, indent=4, sort_keys=True)
+
+
+def set_snippets_menu(content):
+    """Set nbextension-contrib-snippets_menu with content"""
+    custom_js = f'''require(["nbextensions/snippets_menu/main"], function (snippets_menu) {{
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    var horizontal_line = '---';
+    var snippets = {{
+        'name' : 'OneTick snippets',
+        'sub-menu' : {json.dumps(content, indent=4, sort_keys=True)}
+    }};
+    snippets_menu.options['menus'].push(snippets);
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+}});'''
+    path = os.path.join(jupyter_config_dir(), 'custom', 'custom.js')
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, 'w') as f:
+        f.write(custom_js)
+
+
+def set_jupyterlab_snippets(content):
+    """Set jupyterlab-snippets with content"""
+
+    def traverse_snippets(path, node_list):
+        for node in node_list:
+            if "sub-menu" in node:
+                folder_path = os.path.join(path, node["name"])
+                os.makedirs(folder_path, exist_ok=True)
+                traverse_snippets(folder_path, node["sub-menu"])
+            elif "snippet" in node:
+                filename = os.path.join(path, node["name"].replace("|", " ").replace("/", " ")) + ".py"
+                print(filename)
+                with open(filename, 'w') as f:
+                    f.write("\n".join(node["snippet"]))
+
+    snippet_path = os.path.join(jupyter_data_dir(), "snippets", "OneTick snippets")
+    os.makedirs(snippet_path, exist_ok=True)
+    traverse_snippets(snippet_path, content)
+
+
+class Snippet:
+
+    """
+    Snippet container.
+    Contain code from doctest.Examples, add ability to set name.
+    Validate names get from doctest.Examples
+    """
+
+    def __init__(self,
+                 name: Optional[str] = None,
+                 examples: Optional[List[doctest.Example]] = None,
+                 obj_ref: Optional[str] = None):
+        self._name = name
+        self._examples = examples or []
+        self._obj_ref = obj_ref
+        self.skip_snippet = False
+
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, value):
+        if self._name:
+            raise ValueError(f'Two names set for one snippet in "{self._obj_ref}": {self._name}, {value}')
+        self._name = value
+
+    @property
+    def code(self) -> List[str]:
+        res = []
+        for ex in self._examples:
+            res.extend(ex.source.strip().split('\n'))
+        return res
+
+    @property
+    def code_raw(self) -> str:
+        res = []
+        for ex in self._examples:
+            for i, line in enumerate(ex.source.strip().split('\n')):
+                if i == 0:
+                    res.append('>>> ' + line)
+                else:
+                    res.append('... ' + line)
+            res.append(ex.want)
+        return '\n'.join(res)
+
+    def append(self, item: doctest.Example):
+        for attr in ['name', 'skip_snippet']:
+            if hasattr(item, attr):
+                setattr(self, attr, getattr(item, attr))
+        skip_example = False
+        if hasattr(item, 'skip'):
+            skip_example = getattr(item, 'skip')
+        if not skip_example and item.source.strip():
+            self._examples.append(item)
+
+    def __str__(self):
+        return self.code_raw
+
+
+class Snippets:
+
+    """Container for Snippet's"""
+
+    def __init__(self):
+        self._snippets = {}
+
+    def append(self, item: Snippet):
+        """
+        Validate Snippet name;
+        Add Snippet to container
+        """
+        if item.skip_snippet or not item.code:
+            return
+        if not item.name:
+            return  # skipping nameless snippets
+        if item.name in self._snippets:
+            raise ValueError('Snippet name is not unique. '
+                             f'Objects "{self._snippets[item.name]._obj_ref}", "{item._obj_ref}"')
+        self._snippets[item.name] = item
+
+    def extend(self, items: List):
+        for item in items:
+            self.append(item)
+
+    def __iter__(self):
+        yield from self._snippets.values()
+
+    def dict_view(self):
+        """Format snippets for nbextension-contrib-snippets"""
+        return {"snippets": [{"name": s.name, "code": s.code} for s in self]}
+
+    def menu_view(self):
+        """Format snippets for nbextension-contrib-snippets_menu"""
+
+        def tree():
+            return defaultdict(tree)
+
+        def set(t, keys: List, value):
+            tmp = t
+            for key in keys[:-1]:
+                tmp = tmp[key]
+            tmp[keys[-1]] = value
+
+        def walk(t):
+            res = []
+            names = []
+            for key in t.keys():
+                if not isinstance(t[key], defaultdict):
+                    res.append({"name": key, "snippet": t[key].code})
+                    names.append(key)
+                else:
+                    code, name = walk(t[key])
+                    res.append({"name": key, "sub-menu": code})
+                    names.append({key: name})
+            return res, names
+
+        res = tree()
+
+        for v in self:
+            names = v.name.split('.')
+            set(res, names, v)
+        return walk(res)
+
+
+def main():
+    args = parse_args()
+    snippets = inspect_modules()
+    if args.names_info:
+        import yaml
+        _, menu = snippets.menu_view()
+        print(yaml.dump(menu))
+    else:
+        if args.extension == 'snippets':
+            set_snippets(snippets.dict_view())
+        elif args.extension == 'snippets_menu':
+            s, _ = snippets.menu_view()
+            set_snippets_menu(s)
+        elif args.extension == 'jupyterlab_snippets':
+            s, _ = snippets.menu_view()
+            set_jupyterlab_snippets(s)
+
+
+if __name__ == '__main__':
+    main()

onetick/lib/__init__.py

@@ -0,0 +1,4 @@
+__version__ = '1.0.11'
+
+from onetick.lib.instance import OneTickLib
+from onetick.lib.instance import LoggingLevel

onetick/lib/instance.py

@@ -0,0 +1,141 @@
+# mypy: disable-error-code="attr-defined"
+
+import os
+import gc
+import inspect
+from enum import Enum
+
+if os.getenv('OTP_WEBAPI', default='').lower() not in ('0', 'false', 'no', ''):
+    import onetick.query_webapi as otq
+
+    class OneTickLibMock:
+        LOGGING_LEVEL_MIN = 0
+        LOGGING_LEVEL_LOW = 1
+        LOGGING_LEVEL_MEDIUM = 2
+        LOGGING_LEVEL_MAX = 3
+
+        def __init__(self, *args, **kwargs):
+            pass
+
+        def set_log_file(self, log_file):
+            pass
+
+    otq.OneTickLib = OneTickLibMock
+
+else:
+    import onetick.query as otq
+    import pyomd
+
+
+class LoggingLevel(Enum):
+    MIN = otq.OneTickLib.LOGGING_LEVEL_MIN
+    LOW = otq.OneTickLib.LOGGING_LEVEL_LOW
+    MEDIUM = otq.OneTickLib.LOGGING_LEVEL_MEDIUM
+    MAX = otq.OneTickLib.LOGGING_LEVEL_MAX
+
+
+class OneTickLib:
+    """
+    Singleton class for ``otq.OneTickLib`` to initialize it once.
+
+    Returns the same object if it was already initialized.
+    """
+    __otl_instance = None
+    __instance = None
+    __args = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls.__otl_instance is None:
+            cls.__otl_instance = super(OneTickLib, cls).__new__(cls)
+
+            def proxy_wrap(attr, static=False):
+
+                if static:
+                    def f(*args, **kwargs):  # type: ignore
+                        return getattr(OneTickLib.__instance, attr)(*args, **kwargs)
+                    return staticmethod(f)
+                else:
+                    def f(self, *args, **kwargs):  # type: ignore
+                        return getattr(OneTickLib.__instance, attr)(*args, **kwargs)
+                    return f
+
+            for attr, value in inspect.getmembers(otq.OneTickLib, callable):
+                if not attr.startswith('_') and not hasattr(OneTickLib, attr):
+                    fun = inspect.getattr_static(otq.OneTickLib, attr)
+                    static = isinstance(fun, staticmethod)
+                    setattr(OneTickLib, attr, proxy_wrap(attr, static=static))
+
+        return cls.__otl_instance
+
+    def __init__(self, *args, log_file=None):
+        if OneTickLib.__instance is None:
+            if not args:
+                args = (None,)
+            OneTickLib.__args = args
+            OneTickLib.__instance = otq.OneTickLib(*args)
+            if log_file:
+                self.set_log_file(log_file)
+        elif args != OneTickLib.__args and args:
+            raise ValueError("OneTickLib was already initialized with different "
+                             "parameters: Was: {} Now: {}".format(OneTickLib.__args, args))
+
+    def __eq__(self, otl):
+        return self.__dict__ == otl.__dict__
+
+    def __ne__(self, otl):
+        return self.__dict__ != otl.__dict__
+
+    def __str__(self):
+        return "Instance: {}".format(self.__instance.get_one_tick_lib())
+
+    def cleanup(self):
+        """
+        Destroy otq.OneTickLib instance and reset singleton class
+        """
+        del OneTickLib.__instance
+        gc.collect()
+        OneTickLib.__instance = None
+        OneTickLib.__args = None
+
+    def set_log_file(self, log_file):
+        """
+        Set log file for given instance of OneTickLib
+
+        :param log_file: path to log file
+        """
+        OneTickLib.__instance.set_log_file(str(log_file))
+        if hasattr(OneTickLib.__instance, 'close_log_file_in_destructor'):
+            # we need to check it to prevent failing CI on the builds that do not have this feature
+            OneTickLib.__instance.close_log_file_in_destructor()
+
+    def set_logging_level(self, lvl: LoggingLevel):
+        """
+        Logging level can be specified by using LoggingLevel Enum class
+
+        :param lvl: available values are LoggingLevel.MIN, LoggingLevel.LOW, LoggingLevel.MEDIUM or LoggingLevel.MAX
+        :return:
+        """
+        OneTickLib.__instance.set_logging_level(lvl)
+
+    def set_authentication_token(self, auth_token: str):
+        """
+        Set authentication token for given instance of OneTickLib
+
+        :param auth_token: authentication token
+        """
+        OneTickLib.__instance.set_authentication_token(auth_token)
+
+    @staticmethod
+    def override_config_value(config_parameter_name: str, config_parameter_value):
+        """
+        Override config value of OneTickConfig
+
+        :param config_parameter_name: param to override (could be both set or not set in OneTickConfig)
+        :param config_parameter_value: new value of the param
+        """
+        if OneTickLib.__instance:
+            raise RuntimeError('This method should be called before OneTickLib object is constructed to have effect.')
+        try:
+            pyomd.OneTickLib.override_config_value(config_parameter_name, config_parameter_value)  # noqa
+        except NameError:
+            raise RuntimeError('This method is not available in WebAPI mode')