Qubx 0.0.1__tar.gz

qubx-0.0.1/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.1
+Name: Qubx
+Version: 0.0.1
+Summary: Qubx - quantitative trading framework
+Home-page: https://github.com/dmarienko/Qubx
+Author: Dmitry Marienko
+Author-email: dmitry@gmail.com
+Requires-Python: >=3.9,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: cython (==3.0.8)
+Requires-Dist: loguru (>=0.7.2,<0.8.0)
+Requires-Dist: ntplib (>=0.4.0,<0.5.0)
+Requires-Dist: numpy (>=1.26.3,<2.0.0)
+Requires-Dist: pyarrow (>=15.0.0,<16.0.0)
+Requires-Dist: pydantic (>=1.10.2,<2.0.0)
+Requires-Dist: pymongo (>=4.6.1,<5.0.0)
+Requires-Dist: pytest[lazyfixture] (>=7.2.0,<8.0.0)
+Requires-Dist: python-binance (>=1.0.19,<2.0.0)
+Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
+Requires-Dist: scipy (>=1.12.0,<2.0.0)
+Requires-Dist: stackprinter (>=0.2.10,<0.3.0)
+Project-URL: Repository, https://github.com/dmarienko/Qubx
+Description-Content-Type: text/markdown
+
+# Qubx
+
+### Next generation of Qube quantitative backtesting framework (QUBX)
+```          
+   /////\    
+  /////  \   
+  \\\\\  /   
+   \\\\\/    (c) 2024, by M.D.E
+```                                          
+
+

qubx-0.0.1/README.md

@@ -0,0 +1,10 @@
+# Qubx
+
+### Next generation of Qube quantitative backtesting framework (QUBX)
+```          
+   /////\    
+  /////  \   
+  \\\\\  /   
+   \\\\\/    (c) 2024, by M.D.E
+```                                          
+

qubx-0.0.1/build.py

@@ -0,0 +1,265 @@
+import datetime
+import itertools
+import os
+import platform
+import shutil
+import subprocess
+import sysconfig
+
+from pathlib import Path
+import os
+import numpy as np
+import toml
+from Cython.Build import build_ext
+from Cython.Build import cythonize
+from Cython.Compiler import Options
+from Cython.Compiler.Version import version as cython_compiler_version
+from setuptools import Distribution
+from setuptools import Extension
+
+
+BUILD_MODE = os.getenv("BUILD_MODE", "release")
+PROFILE_MODE = bool(os.getenv("PROFILE_MODE", ""))
+ANNOTATION_MODE = bool(os.getenv("ANNOTATION_MODE", ""))
+BUILD_DIR = "build/optimized"
+COPY_TO_SOURCE = os.getenv("COPY_TO_SOURCE", "true") == "true"
+
+################################################################################
+#  CYTHON BUILD
+################################################################################
+# https://cython.readthedocs.io/en/latest/src/userguide/source_files_and_compilation.html
+
+Options.docstrings = True  # Include docstrings in modules
+Options.fast_fail = True  # Abort the compilation on the first error occurred
+Options.annotate = ANNOTATION_MODE  # Create annotated HTML files for each .pyx
+if ANNOTATION_MODE:
+    Options.annotate_coverage_xml = "coverage.xml"
+Options.fast_fail = True  # Abort compilation on first error
+Options.warning_errors = True  # Treat compiler warnings as errors
+Options.extra_warnings = True
+
+CYTHON_COMPILER_DIRECTIVES = {
+    "language_level": "3",
+    "cdivision": True,  # If division is as per C with no check for zero (35% speed up)
+    "nonecheck": True,  # Insert extra check for field access on C extensions
+    "embedsignature": True,  # If docstrings should be embedded into C signatures
+    "profile": PROFILE_MODE,  # If we're debugging or profiling
+    "linetrace": PROFILE_MODE,  # If we're debugging or profiling
+    "warn.maybe_uninitialized": True,
+}
+
+
+def _build_extensions() -> list[Extension]:
+    # Regarding the compiler warning: #warning "Using deprecated NumPy API,
+    # disable it with " "#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION"
+    # https://stackoverflow.com/questions/52749662/using-deprecated-numpy-api
+    # From the Cython docs: "For the time being, it is just a warning that you can ignore."
+    define_macros: list[tuple[str, str | None]] = [
+        ("NPY_NO_DEPRECATED_API", "NPY_1_7_API_VERSION"),
+    ]
+    if PROFILE_MODE or ANNOTATION_MODE:
+        # Profiling requires special macro directives
+        define_macros.append(("CYTHON_TRACE", "1"))
+
+    extra_compile_args = []
+    extra_link_args = []
+    # extra_link_args = RUST_LIBS
+
+    if platform.system() != "Windows":
+        # Suppress warnings produced by Cython boilerplate
+        extra_compile_args.append("-Wno-unreachable-code")
+        if BUILD_MODE == "release":
+            extra_compile_args.append("-O2")
+            extra_compile_args.append("-pipe")
+
+    if platform.system() == "Windows":
+        extra_link_args += [
+            "AdvAPI32.Lib",
+            "bcrypt.lib",
+            "Crypt32.lib",
+            "Iphlpapi.lib",
+            "Kernel32.lib",
+            "ncrypt.lib",
+            "Netapi32.lib",
+            "ntdll.lib",
+            "Ole32.lib",
+            "OleAut32.lib",
+            "Pdh.lib",
+            "PowrProf.lib",
+            "Psapi.lib",
+            "schannel.lib",
+            "secur32.lib",
+            "Shell32.lib",
+            "User32.Lib",
+            "UserEnv.Lib",
+            "WS2_32.Lib",
+        ]
+
+    print("Creating C extension modules...")
+    print(f"define_macros={define_macros}")
+    print(f"extra_compile_args={extra_compile_args}")
+
+    return [
+        Extension(
+            name=str(pyx.relative_to(".")).replace(os.path.sep, ".")[:-4],
+            sources=[str(pyx)],
+            include_dirs=[np.get_include()], #, *RUST_INCLUDES],
+            define_macros=define_macros,
+            language="c",
+            extra_link_args=extra_link_args,
+            extra_compile_args=extra_compile_args,
+        ) for pyx in itertools.chain(Path("src/qubx").rglob("*.pyx"))
+    ]
+
+
+def _build_distribution(extensions: list[Extension]) -> Distribution:
+    nthreads = os.cpu_count() or 1
+    if platform.system() == "Windows":
+        nthreads = min(nthreads, 60)
+    print(f"nthreads={nthreads}")
+
+    distribution = Distribution(
+        {
+            "name": "qubx",
+            "ext_modules": cythonize(
+                module_list=extensions,
+                compiler_directives=CYTHON_COMPILER_DIRECTIVES,
+                nthreads=nthreads,
+                build_dir=BUILD_DIR,
+                gdb_debug=PROFILE_MODE,
+            ),
+            "zip_safe": False,
+        },
+    )
+    return distribution
+
+
+def _copy_build_dir_to_project(cmd: build_ext) -> None:
+    # Copy built extensions back to the project tree
+    for output in cmd.get_outputs():
+        relative_extension = Path(output).relative_to(cmd.build_lib)
+        if not Path(output).exists():
+            continue
+
+        # Copy the file and set permissions
+        shutil.copyfile(output, relative_extension)
+        mode = relative_extension.stat().st_mode
+        mode |= (mode & 0o444) >> 2
+        relative_extension.chmod(mode)
+
+    print("Copied all compiled dynamic library files into source")
+
+
+def _strip_unneeded_symbols() -> None:
+    try:
+        print("Stripping unneeded symbols from binaries...")
+        for so in itertools.chain(Path("nautilus_trader").rglob("*.so")):
+            if platform.system() == "Linux":
+                strip_cmd = ["strip", "--strip-unneeded", so]
+            elif platform.system() == "Darwin":
+                strip_cmd = ["strip", "-x", so]
+            else:
+                raise RuntimeError(f"Cannot strip symbols for platform {platform.system()}")
+            subprocess.run(
+                strip_cmd,  # type: ignore [arg-type] # noqa
+                check=True,
+                capture_output=True,
+            )
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"Error when stripping symbols.\n{e}") from e
+
+
+def build() -> None:
+    """
+    Construct the extensions and distribution.
+    """
+    # _build_rust_libs()
+    # _copy_rust_dylibs_to_project()
+
+    if True: #not PYO3_ONLY:
+        # Create C Extensions to feed into cythonize()
+        extensions = _build_extensions()
+        distribution = _build_distribution(extensions)
+
+        # Build and run the command
+        print("Compiling C extension modules...")
+        cmd: build_ext = build_ext(distribution)
+        # if PARALLEL_BUILD:
+            # cmd.parallel = os.cpu_count()
+        cmd.ensure_finalized()
+        cmd.run()
+
+        if COPY_TO_SOURCE:
+            # Copy the build back into the source tree for development and wheel packaging
+            _copy_build_dir_to_project(cmd)
+
+    if BUILD_MODE == "release" and platform.system() in ("Linux", "Darwin"):
+        # Only strip symbols for release builds
+        _strip_unneeded_symbols()
+
+
+if __name__ == "__main__":
+    qubx_platform = toml.load("pyproject.toml")["tool"]["poetry"]["version"]
+    print("\033[36m")
+    print("=====================================================================")
+    print(f"Qubx Builder {qubx_platform}")
+    print("=====================================================================\033[0m")
+    print(f"System: {platform.system()} {platform.machine()}")
+    # print(f"Clang:  {_get_clang_version()}")
+    # print(f"Rust:   {_get_rustc_version()}")
+    print(f"Python: {platform.python_version()}")
+    print(f"Cython: {cython_compiler_version}")
+    print(f"NumPy:  {np.__version__}\n")
+
+    print(f"BUILD_MODE={BUILD_MODE}")
+    print(f"BUILD_DIR={BUILD_DIR}")
+    print(f"PROFILE_MODE={PROFILE_MODE}")
+    print(f"ANNOTATION_MODE={ANNOTATION_MODE}")
+    # print(f"PARALLEL_BUILD={PARALLEL_BUILD}")
+    print(f"COPY_TO_SOURCE={COPY_TO_SOURCE}")
+    # print(f"PYO3_ONLY={PYO3_ONLY}\n")
+
+    print("Starting build...")
+    ts_start = datetime.datetime.now(datetime.timezone.utc)
+    build()
+    print(f"Build time: {datetime.datetime.now(datetime.timezone.utc) - ts_start}")
+    print("\033[32m" + "Build completed" + "\033[0m")
+
+# # See if Cython is installed
+# try:
+#     from Cython.Build import cythonize
+# # Do nothing if Cython is not available
+# except ImportError:
+#     # Got to provide this function. Otherwise, poetry will fail
+#     def build(setup_kwargs):
+#         pass
+
+# # Cython is installed. Compile
+# else:
+#     from setuptools import Extension
+#     from setuptools.dist import Distribution
+#     from distutils.command.build_ext import build_ext
+
+#     # This function will be executed in setup.py:
+#     def build(setup_kwargs):
+#         # The file you want to compile
+#         extensions = [
+#             "src/qubx/core/series.pyx",
+#             "src/qubx/core/utils.pyx",
+#             "src/qubx/ta/indicators.pyx",
+#         ]
+
+#         # gcc arguments hack: enable optimizations
+#         os.environ['CFLAGS'] = '-O3'
+
+#         # Build
+#         import numpy as np
+#         setup_kwargs.update({
+#             'ext_modules': cythonize(
+#                 extensions,
+#                 language_level=3,
+#                 compiler_directives={'linetrace': True},
+#                 include_path=[np.get_include()]
+#             ),
+#             'cmdclass': {'build_ext': build_ext}
+#         })

qubx-0.0.1/pyproject.toml

@@ -0,0 +1,56 @@
+[tool.poetry]
+name = "Qubx"
+version = "0.0.1"
+description = "Qubx - quantitative trading framework"
+authors = ["Dmitry Marienko <dmitry@gmail.com>"]
+readme = "README.md"
+packages = [
+    { include = "qubx", from = "src" },
+]
+repository = "https://github.com/dmarienko/Qubx"
+include = [
+    # Compiled extensions must be included in the wheel distributions
+    { path = "src/**/*.so", format = "wheel" },
+    { path = "src/**/*.pyd", format = "wheel" },
+]
+
+[tool.poetry.dependencies]
+python = ">=3.9,<4.0"
+pytest = {extras = ["lazyfixture"], version = "^7.2.0"}
+numpy = "^1.26.3"
+ntplib = "^0.4.0"
+loguru = "^0.7.2"
+stackprinter = "^0.2.10"
+#websocket-client = "^1.6.3"
+#websockets = "^11.0.3"
+pymongo = "^4.6.1"
+pydantic = "^1.10.2"
+python-dotenv = "^1.0.0"
+python-binance = "^1.0.19"
+pyarrow = "^15.0.0"
+scipy = "^1.12.0"
+cython = "3.0.8"
+
+[tool.poetry.group.dev.dependencies]
+pre-commit = "^2.20.0"
+pytest = "^7.1.3"
+
+#[project.optional-dependencies]
+#numba = "^0.57.1"
+
+[build-system]
+requires = ["poetry-core", "setuptools", "numpy>=1.26.3", "cython==3.0.8", "toml>=0.10.2",]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.build]
+script = "build.py"
+generate-setup-file = false
+
+
+[tool.poetry.group.test.dependencies]
+pytest = "^7.1.3"
+pytest-mock = "*"
+
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]

qubx-0.0.1/src/qubx/__init__.py

@@ -0,0 +1,164 @@
+from qubx.utils import set_mpl_theme, runtime_env, install_pyx_recompiler_for_dev
+install_pyx_recompiler_for_dev()
+
+from loguru import logger
+import os, sys, stackprinter
+from qubx.core.lookups import InstrumentsLookup
+
+
+def formatter(record):
+    end = record["extra"].get("end", "\n")
+    fmt = "<lvl>{message}</lvl>%s" % end
+    if record["level"].name in {"WARNING", "SNAKY"}:
+        fmt = "<cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - %s" % fmt
+
+    prefix = "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> [ <level>%s</level> ] " % record["level"].icon
+
+    if record["exception"] is not None:
+        # stackprinter.set_excepthook(style='darkbg2')
+        record["extra"]["stack"] = stackprinter.format(record["exception"], style="darkbg")
+        fmt += "\n{extra[stack]}\n"
+
+    if record["level"].name in {"TEXT"}:
+        prefix = ""
+
+    return prefix + fmt
+
+
+config = {
+    "handlers": [ {"sink": sys.stdout, "format": "{time} - {message}"}, ],
+    "extra": {"user": "someone"},
+}
+
+
+logger.configure(**config)
+logger.remove(None)
+logger.add(sys.stdout, format=formatter, colorize=True)
+logger = logger.opt(colors=True)
+
+lookup = InstrumentsLookup()
+
+# registering magic for jupyter notebook
+if runtime_env() in ['notebook', 'shell']:
+    from IPython.core.magic import (Magics, magics_class, line_magic, line_cell_magic)
+    from IPython import get_ipython
+
+    @magics_class
+    class QubxMagics(Magics):
+        # process data manager
+        __manager = None
+
+        @line_magic
+        def qubxd(self, line: str):
+            self.qubx_setup('dark')
+
+        @line_magic
+        def qubxl(self, line: str):
+            self.qubx_setup('light')
+
+        @line_magic
+        def qubx_setup(self, line: str):
+            """
+            QUBE framework initialization
+            """
+            import os
+
+            tpl_path = os.path.join(os.path.dirname(__file__), "_nb_magic.py")
+            # print("TPL:", tpl_path)
+            with open(tpl_path, 'r', encoding="utf8") as myfile:
+                s = myfile.read()
+
+            exec(s, self.shell.user_ns)
+
+            # setup more funcy mpl theme instead of ugly default
+            if line:
+                if 'dark' in line.lower():
+                    set_mpl_theme('dark')
+
+                elif 'light' in line.lower():
+                    set_mpl_theme('light')
+
+            # install additional plotly helpers
+            # from qube.charting.plot_helpers import install_plotly_helpers
+            # install_plotly_helpers()
+
+        def _get_manager(self):
+            if self.__manager is None:
+                import multiprocessing as m
+                self.__manager = m.Manager()
+            return self.__manager
+
+        @line_cell_magic
+        def proc(self, line, cell=None):
+            """
+            Run cell in separate process
+
+            >>> %%proc x, y as MyProc1
+            >>> x.set('Hello')
+            >>> y.set([1,2,3,4])
+            
+            """
+            import multiprocessing as m
+            import time, re
+
+            # create ext args
+            name = None
+            if line:
+                # check if custom process name was provided
+                if ' as ' in line:
+                    line, name = line.split('as')
+                    if not name.isspace():
+                        name = name.strip()
+                    else:
+                        print('>>> Process name must be specified afer "as" keyword !')
+                        return
+
+                ipy = get_ipython()
+                for a in [x for x in re.split('[\ ,;]', line.strip()) if x]:
+                    ipy.push({a: self._get_manager().Value(None, None)})
+
+            # code to run
+            lines = '\n'.join(['    %s' % x for x in cell.split('\n')])
+
+            def fn():
+                result = get_ipython().run_cell(lines)
+
+                # send errors to parent
+                if result.error_before_exec:
+                    raise result.error_before_exec
+
+                if result.error_in_exec:
+                    raise result.error_in_exec
+
+            t_start = str(time.time()).replace('.', '_')
+            f_id = f'proc_{t_start}' if name is None else name
+            if self._is_task_name_already_used(f_id):
+                f_id = f"{f_id}_{t_start}"
+
+            task = m.Process(target=fn, name=f_id)
+            task.start()
+            print(' -> Task %s is started' % f_id)
+
+        def _is_task_name_already_used(self, name):
+            import multiprocessing as m
+            for p in m.active_children():
+                if p.name == name:
+                    return True
+            return False
+
+        @line_magic
+        def list_proc(self, line):
+            import multiprocessing as m
+            for p in m.active_children():
+                print(p.name)
+
+        @line_magic
+        def kill_proc(self, line):
+            import multiprocessing as m
+            for p in m.active_children():
+                if line and p.name.startswith(line):
+                    p.terminate()
+
+
+    # - registering magic here
+    get_ipython().register_magics(QubxMagics)

qubx-0.0.1/src/qubx/_nb_magic.py

@@ -0,0 +1,69 @@
+""""
+Here stuff we want to have in every Jupyter notebook after calling %qube magic
+"""
+import importlib_metadata
+
+import qubx
+from qubx.utils import runtime_env
+from qubx.utils.misc import add_project_to_system_path
+
+
+def np_fmt_short():
+    # default np output is 75 columns so extend it a bit and suppress scientific fmt for small floats
+    np.set_printoptions(linewidth=240, suppress=True)
+
+
+def np_fmt_reset():
+    # reset default np printing options
+    np.set_printoptions(edgeitems=3, infstr='inf', linewidth=75, nanstr='nan', precision=8,
+                        suppress=False, threshold=1000, formatter=None)
+
+
+if runtime_env() in ['notebook', 'shell']:
+
+    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    # -- all imports below will appear in notebook after calling %%alphalab magic ---
+    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+    # - - - - Common stuff - - - -
+    import numpy as np
+    import pandas as pd
+    from datetime import time, timedelta
+    from tqdm.auto import tqdm
+
+    # - - - - TA stuff and indicators - - - -
+    # - - - - Portfolio analysis - - - -
+    # - - - - Simulator stuff - - - -
+    # - - - - Learn stuff - - - -
+    # - - - - Charting stuff - - - -
+    from matplotlib import pyplot as plt
+    from qubx.utils.charting.mpl_helpers import fig, subplot, sbp
+    # - - - - Utils - - - -
+
+    # - setup short numpy output format
+    np_fmt_short()
+    
+    # - add project home to system path
+    add_project_to_system_path()
+
+    # - check current version
+    try: 
+        version = importlib_metadata.version('qube2')
+    except:
+        version = 'Dev'
+
+    # some new logo
+    if not hasattr(qubx.QubxMagics, '__already_initialized__'):
+        from qubx.utils.misc import (green, yellow, cyan, magenta, white, blue, red)
+
+        print(
+        f"""
+                   {red("╻")}
+   {green("┏┓      ╻     ")}  {red("┃")}  {yellow("┏┓")}       {cyan("Quantitative Backtesting Environment")} 
+   {green("┃┃  ┓┏  ┣┓  ┏┓")}  {red("┃")}  {yellow("┏┛")}       
+   {green("┗┻  ┗┻  ┗┛  ┗ ")}  {red("┃")}  {yellow("┗━")}       (c) 2024,  ver. {magenta(version.rstrip())}
+                   {red("╹")}       
+"""
+        )
+        qubx.QubxMagics.__already_initialized__ = True
+