onetick-py 1.162.2__py3-none-any.whl

onetick/py/license.py

@@ -0,0 +1,188 @@
+import os
+import abc
+import subprocess
+import pandas as pd
+
+from datetime import datetime
+import onetick.py as otp
+
+from . import utils, configuration
+
+
+class _LicenseBase(abc.ABC):
+    def __init__(self, file, dir):
+        self._dir = dir
+        self._file = file
+
+        if otp.__webapi__:
+            return
+
+        if self._file is None:
+            raise ValueError("Something goes wrong, you pass None instead of path to license file")
+
+        if self._dir is not None and not os.path.exists(self._dir):
+            raise FileNotFoundError(f'"{self._dir}" license directory does not exist')
+        if not os.path.exists(self._file):
+            raise FileNotFoundError(f'"{self._file}" license file does not exist')
+
+    @property
+    def dir(self):
+        return self._dir
+
+    @property
+    def file(self):
+        return self._file
+
+
+class Default(_LicenseBase):
+    """
+    Default license path
+    """
+
+    def __init__(self):
+        default_file = configuration.config.default_license_file
+        default_dir = configuration.config.default_license_dir
+        if default_file is None and not otp.__webapi__:
+            raise ValueError(
+                "I can't understand the default license path :( Please, use "
+                "onetick.py.license.Custom to specify a path to license."
+            )
+
+        super().__init__(default_file, default_dir)
+
+
+class Remote(_LicenseBase):
+
+    def __init__(self):
+        # remote license doesn't use local files
+        pass
+
+    @property
+    def dir(self):
+        return None
+
+    @property
+    def file(self):
+        return None
+
+
+class Custom(_LicenseBase):
+    """
+    Custom license path
+    """
+
+    def __init__(self, file, directory=None):
+        """
+        Parameters
+        ----------
+        file: str, os.PathLike
+            Path to license file.
+        directory: str, os.PathLike, optional
+            Path to license directory. Default is None, that means it is not used.
+        """
+        super().__init__(file, directory)
+
+
+class Server(_LicenseBase):
+    """
+    License that is based on license server. It generates new license file
+    """
+
+    def __init__(self, addresses=None, file=None, directory=None, reload=0):
+        """
+        Parameters
+        ----------
+        addresses: list of strings
+            List of ip address or domain names with ports where a license server is running.
+            For example: ['license.server.A:123', 'license.server.B:345']
+        file: str or PathLike, optional
+            License file path. Passed file path should exist. If file is not set or equal to None,
+            then temporary file will be used (temporary file lives while an instance lives).
+            NOTE: passed license file might be updated according to the 'reload' parameter.
+        directory: str or PathLike, optional
+            License directory path. Passed directory should exist. If directory is not set or
+            equal to None, then temporary directory will be used.
+        reload: 0 or offsets from onetick.py, ie onetick.py.Day, Hour, Month etc
+            Indicator to reload license from license server. 0 means that reload on creation,
+            offset means that if license file modification time more than offset, then it will
+            be updated from the server.
+        """
+        self._generated = False
+
+        if file is None:
+            file = utils.TmpFile()
+        else:
+            if isinstance(reload, pd.tseries.offsets.Tick):
+                modify = datetime.fromtimestamp(os.path.getmtime(file))
+                current = datetime.now()
+                diff_ms = (current - modify).total_seconds() * 1000000
+                expire_ms = reload.nanos / 1000
+
+                if diff_ms < expire_ms:
+                    self._generated = True
+            elif isinstance(reload, int):
+                if reload == 0:
+                    # always generate
+                    self._generated = False
+                else:
+                    raise ValueError("You've passed not supported value to the 'reload' parameter")
+            else:
+                raise ValueError("You've passed not supported value to the 'reload' parameter")
+
+        if directory is None:
+            directory = utils.TmpDir()
+
+        super().__init__(file, directory)
+
+        self._servers = ",".join(addresses)
+
+        if not self._generated:
+            self.__generate()
+
+    @property
+    def servers(self):
+        return self._servers
+
+    def __generate(self):
+        class EnvVarScope:
+            def __init__(self, cfg):
+                self._env = None
+                self._cfg = cfg
+
+            def __enter__(self):
+                if "ONE_TICK_CONFIG" in os.environ:
+                    self._env = os.environ["ONE_TICK_CONFIG"]
+                os.environ["ONE_TICK_CONFIG"] = str(self._cfg)
+
+            def __exit__(self, exc_type, exc_val, exc_tb):
+                if self._env is None:
+                    if "ONE_TICK_CONFIG" in os.environ:
+                        del os.environ["ONE_TICK_CONFIG"]
+                else:
+                    os.environ["ONE_TICK_CONFIG"] = self._env
+
+        tmp_locator = utils.tmp_locator(empty=True)
+        tmp_config = utils.tmp_config(
+            locator=tmp_locator, license_path=str(self.file), license_dir=self.dir, license_servers=self.servers
+        )
+
+        with EnvVarScope(tmp_config):
+            self.__generate_license()
+
+        self._generated = True
+
+    def __generate_license(self):
+        lic_generator = self.__license_getter_path(os.path.join(utils.omd_dist_path(), "one_tick", "bin"))
+
+        subprocess.run(
+            [lic_generator, "-features", "COLL,QUERY,LOAD"],
+            stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+            check=True,
+        )
+
+    @staticmethod
+    def __license_getter_path(omd_dist_path):
+        license_getter = os.path.join(omd_dist_path, "local_license_getter.exe")
+        assert os.path.exists(license_getter), f"license getter is not found by {license_getter}"
+
+        return license_getter

onetick/py/log.py

@@ -0,0 +1,88 @@
+import os
+import sys
+import json
+import logging
+import warnings
+from pathlib import Path
+from .configuration import config
+
+
+class CustomStreamHandler(logging.StreamHandler):
+    # workaround for https://github.com/pytest-dev/pytest/issues/5502
+    # pytest doesn't work well when you initialize logging at import time
+    # and then try logging to stdout at application exit
+    # (we do it when deleting temporary files)
+    # in this case logging system writes very cumbersome error messages,
+    # so here we override them
+    def handleError(self, record):
+        if logging.raiseExceptions and sys.stderr:
+            try:
+                msg = self.format(record)
+                sys.stderr.write(msg + self.terminator)
+                sys.stderr.flush()
+            except Exception:
+                pass
+
+
+def get_stream_handler():
+    handler = CustomStreamHandler()
+    formatter = logging.Formatter('[%(asctime)s] %(levelname)s (%(name)s): %(message)s')
+    handler.setFormatter(formatter)
+    return handler
+
+
+ROOT_LOGGER_NAME = 'onetick.py'
+ROOT_LOGGER = None
+
+
+def __init_root_logger():
+    global ROOT_LOGGER
+
+    if ROOT_LOGGER is not None:
+        return
+
+    ROOT_LOGGER = logging.getLogger(ROOT_LOGGER_NAME)
+    ROOT_LOGGER.addHandler(logging.NullHandler())
+
+    if not config.logging:
+        return
+
+    if os.sep in config.logging:
+        config_file = Path(config.logging)
+        if not config_file.exists():
+            warnings.warn(f"Configuration file '{config_file}' doesn't exist, can't initialize logging system")
+            return
+
+        # Config file is crafted and loaded by user, so we can ignore SonarQube warnings
+        if config_file.suffix == '.json':
+            with config_file.open() as f:
+                json_data = json.load(f)
+            logging.config.dictConfig(json_data)  # NOSONAR
+        else:
+            logging.config.fileConfig(config_file)  # NOSONAR
+    else:
+        try:
+            ROOT_LOGGER.setLevel(config.logging)
+        except ValueError:
+            warnings.warn(f"Unknown logging level name: '{config.logging}', can't initialize logging system")
+            return
+        ROOT_LOGGER.addHandler(get_stream_handler())
+
+    ROOT_LOGGER.debug(f'Initialized {ROOT_LOGGER_NAME} logging system')
+
+
+__init_root_logger()
+
+
+def get_logger(*parts):
+    name = '.'.join(parts)
+    if not name.startswith(ROOT_LOGGER_NAME):
+        raise ValueError(f"Logger name '{name}' must start with root logger name '{ROOT_LOGGER_NAME}'")
+    logger = logging.getLogger(name)
+    return logger
+
+
+def get_debug_logger():
+    logger = logging.getLogger('onetick.py.otq_debug_mode')
+    logger.setLevel("DEBUG" if config.otq_debug_mode else "INFO")
+    return logger