Qubx 0.5.7__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/trackers/sizers.py

@@ -0,0 +1,235 @@
+from typing import List
+
+import numpy as np
+
+from qubx import logger
+from qubx.core.basics import Signal, TargetPosition
+from qubx.core.interfaces import IPositionSizer, IStrategyContext
+
+
+class FixedSizer(IPositionSizer):
+    """
+    Simplest fixed sizer class. It uses same fixed size for all signals.
+    We use it for quick backtesting of generated signals in most cases.
+    """
+
+    def __init__(self, fixed_size: float, amount_in_quote: bool = True):
+        self.amount_in_quote = amount_in_quote
+        self.fixed_size = abs(fixed_size)
+
+    def calculate_target_positions(self, ctx: IStrategyContext, signals: List[Signal]) -> List[TargetPosition]:
+        if not self.amount_in_quote:
+            return [TargetPosition.create(ctx, s, s.signal * self.fixed_size) for s in signals]
+        positions = []
+        for signal in signals:
+            if (_entry := self.get_signal_entry_price(ctx, signal)) is None:
+                continue
+            positions.append(TargetPosition.create(ctx, signal, signal.signal * self.fixed_size / _entry))
+        return positions
+
+
+class FixedLeverageSizer(IPositionSizer):
+    """
+    Defines the leverage per each unit of signal. If leverage is 1.0, then
+    the position leverage will be equal to the signal value.
+    """
+
+    def __init__(self, leverage: float):
+        """
+        Args:
+            leverage (float): leverage value per a unit of signal.
+            split_by_symbols (bool): Should the calculated leverage by divided
+            by the number of symbols in the universe.
+        """
+        self.leverage = leverage
+
+    def calculate_target_positions(self, ctx: IStrategyContext, signals: List[Signal]) -> List[TargetPosition]:
+        total_capital = ctx.get_total_capital()
+        positions = []
+        for signal in signals:
+            if (_entry := self.get_signal_entry_price(ctx, signal)) is None:
+                continue
+
+            size = signal.signal * self.leverage * total_capital / _entry / len(ctx.instruments)
+            positions.append(TargetPosition.create(ctx, signal, size))
+        return positions
+
+
+class FixedRiskSizer(IPositionSizer):
+    def __init__(
+        self,
+        max_cap_in_risk: float,
+        max_allowed_position=np.inf,
+        reinvest_profit: bool = True,
+        divide_by_symbols: bool = True,
+        scale_by_signal: bool = False,
+    ):
+        """
+        Create fixed risk sizer calculator instance.
+        :param max_cap_in_risk: maximal risked capital (in percentage)
+        :param max_allowed_position: limitation for max position size in quoted currency (i.e. max 5000 in USDT)
+        :param reinvest_profit: if true use profit to reinvest
+        :param divide_by_symbols: if true divide position size by number of symbols
+        :param scale_by_signal: if true scale position size by signal's value
+        """
+        self.max_cap_in_risk = max_cap_in_risk / 100
+        self.max_allowed_position_quoted = max_allowed_position
+        self.reinvest_profit = reinvest_profit
+        self.divide_by_symbols = divide_by_symbols
+        self.scale_by_signal = scale_by_signal
+
+    def calculate_target_positions(self, ctx: IStrategyContext, signals: List[Signal]) -> List[TargetPosition]:
+        t_pos = []
+        for signal in signals:
+            target_position_size = 0
+            if signal.signal != 0:
+                if signal.stop and signal.stop > 0:
+                    # - get signal entry price
+                    if (_entry := self.get_signal_entry_price(ctx, signal)) is None:
+                        continue
+
+                    # - hey, we can't trade using negative balance ;)
+                    _cap = max(ctx.get_total_capital() if self.reinvest_profit else ctx.get_capital(), 0)
+                    _scale = abs(signal.signal) if self.scale_by_signal else 1
+
+                    # fmt: off
+                    _direction = np.sign(signal.signal)
+                    target_position_size = (  
+                        _direction
+                        *min((_cap * self.max_cap_in_risk) / abs(signal.stop / _entry - 1), self.max_allowed_position_quoted) / _entry
+                        / (len(ctx.instruments) if self.divide_by_symbols else 1)
+                        * _scale
+                    )
+                    # fmt: on
+
+                else:
+                    logger.warning(
+                        f" >>> {self.__class__.__name__}: stop is not specified for {str(signal)} - can't calculate position !"
+                    )
+                    continue
+
+            t_pos.append(TargetPosition.create(ctx, signal, target_position_size))
+
+        return t_pos
+
+
+class LongShortRatioPortfolioSizer(IPositionSizer):
+    """
+    Weighted portfolio sizer. Signals are cosidered as weigths.
+    It's supposed to split capital in the given ratio between longs and shorts positions.
+    For example if ratio is 1 capital invested in long and short positions should be the same.
+
+    So if we S_l = sum all long signals, S_s = abs sum all short signals, r (longs_shorts_ratio) given ratio
+
+        k_s * S_s + k_l * S_l = 1
+        k_l * S_l / k_s * S_s = r
+
+    then
+
+        k_s = 1 / S_s * (1 + r) or 0 if S_s == 0 (no short signals)
+        k_l = r / S_l * (1 + r) or 0 if S_l == 0 (no long signals)
+
+    and final positions:
+        P_i = S_i * available_capital * capital_using * (k_l if S_i > 0 else k_s)
+    """
+
+    _r: float
+
+    def __init__(self, capital_using: float = 1.0, longs_to_shorts_ratio: float = 1):
+        """
+        Create weighted portfolio sizer.
+
+        :param capital_using: how much of total capital to be used for positions
+        :param longs_shorts_ratio: ratio of longs to shorts positions
+        """
+        assert 0 < capital_using <= 1, f"Capital using factor must be between 0 and 1, got {capital_using}"
+        assert 0 < longs_to_shorts_ratio, f"Longs/shorts ratio must be greater 0, got {longs_to_shorts_ratio}"
+        self.capital_using = capital_using
+        self._r = longs_to_shorts_ratio
+
+    def calculate_target_positions(self, ctx: IStrategyContext, signals: List[Signal]) -> List[TargetPosition]:
+        """
+        Calculates target positions for each signal using weighted portfolio approach.
+
+        Parameters:
+        ctx (StrategyContext): The strategy context containing information about the current state of the strategy.
+        signals (List[Signal]): A list of signals generated by the strategy.
+
+        Returns:
+        List[TargetPosition]: A list of target positions for each signal, representing the desired size of the position
+        in the corresponding instrument.
+        """
+        total_capital = ctx.get_total_capital()
+        cap = self.capital_using * total_capital
+
+        _S_l, _S_s = 0, 0
+        for s in signals:
+            _S_l += s.signal if s.signal > 0 else 0
+            _S_s += abs(s.signal) if s.signal < 0 else 0
+        k_s = 1 / (_S_s * (1 + self._r)) if _S_s > 0 else 0
+        k_l = self._r / (_S_l * (1 + self._r)) if _S_l > 0 else 0
+
+        t_pos = []
+        for signal in signals:
+            if (_entry := self.get_signal_entry_price(ctx, signal)) is None:
+                continue
+
+            _p_q = cap / _entry
+            _p = k_l * signal.signal if signal.signal > 0 else k_s * signal.signal
+            t_pos.append(TargetPosition.create(ctx, signal, _p * _p_q))
+
+        return t_pos
+
+
+class FixedRiskSizerWithConstantCapital(IPositionSizer):
+    def __init__(
+        self,
+        capital: float,
+        max_cap_in_risk: float,
+        max_allowed_position=np.inf,
+        divide_by_symbols: bool = True,
+    ):
+        """
+        Create fixed risk sizer calculator instance.
+        :param max_cap_in_risk: maximal risked capital (in percentage)
+        :param max_allowed_position: limitation for max position size in quoted currency (i.e. max 5000 in USDT)
+        :param reinvest_profit: if true use profit to reinvest
+        """
+        self.capital = capital
+        assert self.capital > 0, f" >> {self.__class__.__name__}: Capital must be positive, got {self.capital}"
+        self.max_cap_in_risk = max_cap_in_risk / 100
+        self.max_allowed_position_quoted = max_allowed_position
+        self.divide_by_symbols = divide_by_symbols
+
+    def calculate_target_positions(self, ctx: IStrategyContext, signals: List[Signal]) -> List[TargetPosition]:
+        t_pos = []
+        for signal in signals:
+            target_position_size = 0
+            if signal.signal != 0:
+                if signal.stop and signal.stop > 0:
+                    # - get signal entry price
+                    if (_entry := self.get_signal_entry_price(ctx, signal)) is None:
+                        continue
+
+                    # - just use same fixed capital
+                    _cap = self.capital / (len(ctx.instruments) if self.divide_by_symbols else 1)
+
+                    # fmt: off
+                    _direction = np.sign(signal.signal)
+                    target_position_size = (  
+                        _direction * min(
+                            (_cap * self.max_cap_in_risk) / abs(signal.stop / _entry - 1), 
+                            self.max_allowed_position_quoted
+                        ) / _entry
+                    )  
+                    # fmt: on
+
+                else:
+                    logger.warning(
+                        f" >>> {self.__class__.__name__}: stop is not specified for {str(signal)} - can't calculate position !"
+                    )
+                    continue
+
+            t_pos.append(TargetPosition.create(ctx, signal, target_position_size))
+
+        return t_pos

qubx/utils/__init__.py

@@ -0,0 +1,5 @@
+from .misc import Stopwatch, Struct, generate_name, runtime_env, this_project_root, version
+
+from .charting.lookinglass import LookingGlass  # isort: skip
+from .charting.mpl_helpers import ellips, fig, hline, ohlc_plot, plot_trends, sbp, set_mpl_theme, vline  # isort: skip
+from .time import convert_seconds_to_str, convert_tf_str_td64, floor_t64, infer_series_frequency, time_to_str

qubx/utils/_pyxreloader.py

@@ -0,0 +1,281 @@
+
+import importlib, glob, os, sys
+from importlib.abc import MetaPathFinder
+from importlib.util import spec_from_file_location
+from importlib.machinery import ExtensionFileLoader, SourceFileLoader
+from typing import List
+
+
+PYX_EXT = ".pyx"
+PYXDEP_EXT = ".pyxdep"
+PYXBLD_EXT = ".pyxbld"
+
+
+def handle_dependencies(pyxfilename):
+    testing = '_test_files' in globals()
+    dependfile = os.path.splitext(pyxfilename)[0] + PYXDEP_EXT
+
+    # by default let distutils decide whether to rebuild on its own
+    # (it has a better idea of what the output file will be)
+
+    # but we know more about dependencies so force a rebuild if
+    # some of the dependencies are newer than the pyxfile.
+    if os.path.exists(dependfile):
+        with open(dependfile) as fid:
+            depends = fid.readlines()
+        depends = [depend.strip() for depend in depends]
+
+        # gather dependencies in the "files" variable
+        # the dependency file is itself a dependency
+        files = [dependfile]
+        for depend in depends:
+            fullpath = os.path.join(os.path.dirname(dependfile),
+                                    depend)
+            files.extend(glob.glob(fullpath))
+
+        # if any file that the pyxfile depends upon is newer than
+        # the pyx file, 'touch' the pyx file so that distutils will
+        # be tricked into rebuilding it.
+        for file in files:
+            from distutils.dep_util import newer
+            if newer(file, pyxfilename):
+                print("Rebuilding %s because of %s", pyxfilename, file)
+                filetime = os.path.getmtime(file)
+                os.utime(pyxfilename, (filetime, filetime))
+
+
+def handle_special_build(modname, pyxfilename):
+    try:
+        import imp
+    except:
+        return None, None
+    special_build = os.path.splitext(pyxfilename)[0] + PYXBLD_EXT
+    ext = None
+    setup_args={}
+    if os.path.exists(special_build):
+        # globls = {}
+        # locs = {}
+        # execfile(special_build, globls, locs)
+        # ext = locs["make_ext"](modname, pyxfilename)
+        with open(special_build) as fid:
+            mod = imp.load_source("XXXX", special_build, fid)
+        make_ext = getattr(mod,'make_ext',None)
+        if make_ext:
+            ext = make_ext(modname, pyxfilename)
+            assert ext and ext.sources, "make_ext in %s did not return Extension" % special_build
+        make_setup_args = getattr(mod, 'make_setup_args',None)
+        if make_setup_args:
+            setup_args = make_setup_args()
+            assert isinstance(setup_args,dict), ("make_setup_args in %s did not return a dict"
+                                         % special_build)
+        assert set or setup_args, ("neither make_ext nor make_setup_args %s" % special_build)
+        ext.sources = [os.path.join(os.path.dirname(special_build), source) for source in ext.sources]
+    return ext, setup_args
+
+
+def get_distutils_extension(modname, pyxfilename, language_level=None):
+    extension_mod, setup_args = handle_special_build(modname, pyxfilename)
+    if not extension_mod:
+        if not isinstance(pyxfilename, str):
+            # distutils is stupid in Py2 and requires exactly 'str'
+            # => encode accidentally coerced unicode strings back to str
+            pyxfilename = pyxfilename.encode(sys.getfilesystemencoding())
+        from distutils.extension import Extension
+        extension_mod = Extension(name = modname, sources=[pyxfilename])
+        if language_level is not None:
+            extension_mod.cython_directives = {'language_level': language_level}
+    return extension_mod, setup_args
+
+
+def build_module(name, pyxfilename, user_setup_args, pyxbuild_dir=None, inplace=False, language_level=None, 
+                 build_in_temp=False, reload_support=True):
+    assert os.path.exists(pyxfilename), "Path does not exist: %s" % pyxfilename
+    handle_dependencies(pyxfilename)
+
+    extension_mod, setup_args = get_distutils_extension(name, pyxfilename, language_level)
+    build_in_temp = True
+    sargs = user_setup_args.copy() if user_setup_args else dict()
+    sargs.update(setup_args)
+    build_in_temp = sargs.pop('build_in_temp',build_in_temp)
+
+    from pyximport import pyxbuild
+    olddir = os.getcwd()
+    common = ''
+    if pyxbuild_dir:
+        # Windows concatenates the pyxbuild_dir to the pyxfilename when
+        # compiling, and then complains that the filename is too long
+        common = os.path.commonprefix([pyxbuild_dir, pyxfilename])
+    if len(common) > 30:
+        pyxfilename = os.path.relpath(pyxfilename)
+        pyxbuild_dir = os.path.relpath(pyxbuild_dir)
+        os.chdir(common)
+    try:
+        so_path = pyxbuild.pyx_to_dll(pyxfilename, extension_mod,
+                                      force_rebuild=1,
+                                      build_in_temp=build_in_temp,
+                                      pyxbuild_dir=pyxbuild_dir,
+                                      setup_args=sargs,
+                                      inplace=inplace,
+                                      reload_support=reload_support)
+    finally:
+        os.chdir(olddir)
+    so_path = os.path.join(common, so_path)
+    assert os.path.exists(so_path), "Cannot find: %s" % so_path
+
+    junkpath = os.path.join(os.path.dirname(so_path), name+"_*")  #very dangerous with --inplace ? yes, indeed, trying to eat my files ;)
+    junkstuff = glob.glob(junkpath)
+    for path in junkstuff:
+        if path != so_path:
+            try:
+                os.remove(path)
+            except IOError:
+                print("Couldn't remove %s", path)
+
+    return so_path
+
+
+def load_module(name, pyxfilename, pyxbuild_dir=None, is_package=False, build_inplace=False, language_level=None, so_path=None):
+    try:
+        import imp
+    except:
+        return None
+    try:
+        if so_path is None:
+            if is_package:
+                module_name = name + '.__init__'
+            else:
+                module_name = name
+            so_path = build_module(module_name, pyxfilename, pyxbuild_dir, inplace=build_inplace, language_level=language_level)
+        mod = imp.load_dynamic(name, so_path)
+        if is_package and not hasattr(mod, '__path__'):
+            mod.__path__ = [os.path.dirname(so_path)]
+        assert mod.__file__ == so_path, (mod.__file__, so_path)
+    except Exception as failure_exc:
+        print("Failed to load extension module: %r" % failure_exc)
+        # if pyxargs.load_py_module_on_import_failure and pyxfilename.endswith('.py'):
+        if False and pyxfilename.endswith('.py'):
+            # try to fall back to normal import
+            mod = imp.load_source(name, pyxfilename)
+            assert mod.__file__ in (pyxfilename, pyxfilename+'c', pyxfilename+'o'), (mod.__file__, pyxfilename)
+        else:
+            tb = sys.exc_info()[2]
+            import traceback
+            exc = ImportError("Building module %s failed: %s" % (name, traceback.format_exception_only(*sys.exc_info()[:2])))
+            if sys.version_info[0] >= 3:
+                raise exc.with_traceback(tb)
+            else:
+                exec("raise exc, None, tb", {'exc': exc, 'tb': tb})
+    return mod
+
+
+class PyxImportLoader(ExtensionFileLoader):
+
+    def __init__(self, filename, setup_args, pyxbuild_dir, inplace, language_level, reload_support):
+        module_name = os.path.splitext(os.path.basename(filename))[0]
+        super().__init__(module_name, filename)
+        self._pyxbuild_dir = pyxbuild_dir
+        self._inplace = inplace
+        self._language_level = language_level
+        self._setup_args = setup_args 
+        self._reload_support = reload_support
+
+    def create_module(self, spec):
+        try:
+            # print(f"CREATING MODULE: {spec.name} -> {spec.origin}")
+            so_path = build_module(spec.name, pyxfilename=spec.origin, user_setup_args=self._setup_args, pyxbuild_dir=self._pyxbuild_dir,
+                                   inplace=self._inplace, language_level=self._language_level, reload_support=self._reload_support)
+            self.path = so_path
+            spec.origin = so_path
+            return super().create_module(spec)
+        except Exception as failure_exc:
+            # print("LOADING on FAILURE MODULE")
+            # if pyxargs.load_py_module_on_import_failure and spec.origin.endswith('.pyx'):
+            if False and spec.origin.endswith(PYX_EXT):
+                spec = importlib.util.spec_from_file_location(spec.name, spec.origin,
+                                                              loader=SourceFileLoader(spec.name, spec.origin))
+                mod = importlib.util.module_from_spec(spec)
+                assert mod.__file__ in (spec.origin, spec.origin + 'c', spec.origin + 'o'), (mod.__file__, spec.origin)
+                return mod
+            else:
+                tb = sys.exc_info()[2]
+                import traceback
+                exc = ImportError("Building module %s failed: %s" % (
+                    spec.name, traceback.format_exception_only(*sys.exc_info()[:2])))
+                raise exc.with_traceback(tb)
+
+    def exec_module(self, module):
+        try:
+            # print(f"EXEC MODULE: {module}")
+            return super().exec_module(module)
+        except Exception as failure_exc:
+            import traceback
+            print("Failed to load extension module: %r" % failure_exc)
+            raise ImportError("Executing module %s failed %s" % (
+                    module.__file__, traceback.format_exception_only(*sys.exc_info()[:2])))
+
+
+class CustomPyxImportMetaFinder(MetaPathFinder):
+
+    def __init__(self, modules_to_check: List[str], extension=PYX_EXT, setup_args=None, pyxbuild_dir=None, inplace=False, language_level=None, reload_support=True):
+        self.valid_modules = modules_to_check
+        self.pyxbuild_dir = pyxbuild_dir
+        self.inplace = inplace
+        self.language_level = language_level
+        self.extension = extension
+        self.setup_args = setup_args if setup_args else dict()
+        self.reload_support = reload_support
+
+    def find_spec(self, fullname, path, target=None):
+        def _is_valid(module):
+            if not self.valid_modules:
+                return True
+            for m in self.valid_modules:
+                if module.startswith(m):
+                    return True
+            return False
+
+        if not path:
+            path = [os.getcwd()]  # top level import --
+        if "." in fullname:
+            *parents, name = fullname.split(".")
+        else:
+            name = fullname
+        for entry in path:
+            if os.path.isdir(os.path.join(entry, name)):
+                # this module has child modules
+                filename = os.path.join(entry, name, "__init__" + self.extension)
+                submodule_locations = [os.path.join(entry, name)]
+            else:
+                filename = os.path.join(entry, name + self.extension)
+                submodule_locations = None
+            if not os.path.exists(filename):
+                continue
+
+            if not _is_valid(fullname):
+                continue
+
+            return spec_from_file_location(
+                fullname, filename,
+                loader=PyxImportLoader(filename, self.setup_args, self.pyxbuild_dir, self.inplace, self.language_level, self.reload_support),
+                submodule_search_locations=submodule_locations)
+
+        return None  # we don't know how to import this
+
+
+__pyx_finder_installed = False
+
+def pyx_install_loader(modules_to_check: List[str]):
+    import numpy as np
+    import pyximport
+    global __pyx_finder_installed
+
+    if not __pyx_finder_installed:
+        build_dir = os.path.expanduser("~/.pyxbld")
+        setup_args = {'include_dirs': np.get_include()}
+        sys.meta_path.insert(0, CustomPyxImportMetaFinder(
+            modules_to_check,
+            PYX_EXT, setup_args=setup_args, pyxbuild_dir=build_dir, 
+            language_level=3, reload_support=True
+        ))
+        pyximport.install(setup_args=setup_args, build_dir=build_dir, reload_support=True, language_level=3)
+