PyAlgoEngine 0.12.0.post3__cp313-cp313-win_amd64.whl

algo_engine/apps/backtest/tester.py

@@ -0,0 +1,252 @@
+import abc
+import datetime
+import time
+from typing import Literal
+
+import numpy as np
+
+from algo_engine.apps import LOGGER
+from algo_engine.apps.backtest.web_app import WebApp
+from algo_engine.backtest import ProgressReplay, SimMatch
+from algo_engine.backtest.metrics import TradeMetrics
+from algo_engine.base import MarketData, TradeInstruction, TradeReport
+
+
+class Tester(object, metaclass=abc.ABCMeta):
+    def __init__(
+            self,
+            start_date: datetime.date,
+            end_date: datetime.date,
+            dtype: list[str] = None,
+            **kwargs
+    ):
+        self.start_date = start_date
+        self.end_date = end_date
+        self.dtype = ['TickData', 'TradeData'] if dtype is None else dtype
+
+        self.timestamp = 0.
+        self.last_price = {}
+        self.subscription = set()
+        self.web_app = WebApp(start_date=start_date, end_date=end_date, **kwargs)
+        self.metrics: dict[str, TradeMetrics] = {}
+        self.sim_match: dict[str, SimMatch] = {}
+
+    def register_ticker(self, ticker: str, **kwargs):
+        self.subscription.add(ticker)
+
+        self.metrics[ticker] = TradeMetrics()
+
+        self.web_app.register(ticker=ticker, **kwargs)
+
+        sim_match = self.sim_match[ticker] = SimMatch(
+            ticker=ticker,
+            instant_fill=kwargs.get('instant_fill', True)
+        )
+
+        # to add callback function to sim_match, use following codes.
+        # sim_match.on_order = self.on_order
+        # sim_match.on_report = self.on_report
+
+    def unregister_ticker(self, ticker: str, **kwargs):
+        self.subscription.remove(ticker)
+
+        self.metrics.pop(ticker)
+
+        # the web app does not provide an unregister method, however, this is not a requirement
+
+        sim_match = self.sim_match.pop(ticker)
+        sim_match.unregister()
+
+    def _launch_order(self, ticker: str, volume: float, limit_price: float):
+        order = TradeInstruction(ticker=ticker, side=np.sign(volume), volume=abs(float), timestamp=self.timestamp)
+        self.sim_match[ticker].launch_order(order=order)
+
+    def buy(self, ticker: str, volume: float = None, limit_price: float = None):
+        if volume is None:
+            trade_metrics = self.metrics[ticker]
+            exposure = trade_metrics.exposure
+            volume = -exposure if exposure < 0 else 1
+
+        if limit_price is None:
+            limit_price = self.last_price[ticker]
+
+        self._launch_order(ticker=ticker, volume=volume, limit_price=limit_price)
+
+    def sell(self, ticker: str, volume: float = None, limit_price: float = None):
+        if volume is None:
+            trade_metrics = self.metrics[ticker]
+            exposure = trade_metrics.exposure
+            volume = -exposure if exposure > 0 else -1
+
+        if limit_price is None:
+            limit_price = self.last_price[ticker]
+
+        self._launch_order(ticker=ticker, volume=volume, limit_price=limit_price)
+
+    @abc.abstractmethod
+    def load_data(self, ticker: str, market_date: datetime.date, dtype: Literal['TickData', 'TradeData', 'TransactionData', 'OrderBook']) -> list[MarketData]:
+        ...
+
+    @abc.abstractmethod
+    def on_market_data(self, market_data: MarketData, **kwargs):
+        ...
+
+    @abc.abstractmethod
+    def on_report(self, report: TradeReport, **kwargs):
+        ...
+
+    @abc.abstractmethod
+    def on_order(self, order: TradeInstruction, **kwargs):
+        ...
+
+    def bod(self, market_date: datetime.date, **kwargs):
+        pass
+
+    def eod(self, market_date: datetime.date, **kwargs):
+        pass
+
+    def run(self, **kwargs):
+        replay = ProgressReplay(
+            loader=self.load_data,
+            start_date=self.start_date,
+            end_date=self.end_date,
+            bod=self.bod,
+            eod=self.eod,
+        )
+
+        for ticker in self.subscription:
+            replay.add_subscription(ticker, dtype='TickData')
+            replay.add_subscription(ticker, dtype='TradeData')
+
+        _start_ts = time.time()
+
+        for market_data in replay:
+            self.on_market_data(market_data=market_data)
+            self.sim_match[market_data.ticker](market_data=market_data)
+            self.web_app.update(market_data=market_data)
+
+            self.timestamp = market_data.timestamp
+            self.last_price[market_data.ticker] = market_data.market_price
+
+        LOGGER.info(f'All done! time_cost: {time.time() - _start_ts:,.3}s')
+
+
+class StrategyTester(Tester):
+    from ...strategy.strategy_engine import StrategyEngine
+
+    def __init__(self, start_date: datetime.date, end_date: datetime.date, data_loader, strategy: StrategyEngine, **kwargs):
+        self.data_loader = data_loader
+        self.strategy = strategy
+        self.event_engine = self.strategy.event_engine
+        self.topic_set = self.strategy.topic_set
+        self.multi_threading = kwargs.get('multi_threading', False)
+        self.lock = self.strategy.lock
+
+        super().__init__(
+            start_date=start_date,
+            end_date=end_date,
+            dtype=kwargs.pop('dtype', ['TickData', 'TradeData']),
+            event_engine=strategy.event_engine,
+            topic_set=strategy.topic_set,
+            multi_threading=kwargs.pop('multi_threading', False),
+            **kwargs
+        )
+
+    def register_ticker(self, ticker: str, **kwargs):
+        super().register_ticker(ticker=ticker, **kwargs)
+
+        for ticker, sim_match in self.sim_match.items():
+            sim_match.register(event_engine=self.event_engine, topic_set=self.topic_set)
+
+    def register(self):
+        self.event_engine.register_handler(topic=self.topic_set.realtime, handler=self.strategy.mds.on_market_data)
+        self.event_engine.register_handler(topic=self.topic_set.realtime, handler=self.strategy.position_tracker.on_market_data)
+        self.event_engine.register_handler(topic=self.topic_set.realtime, handler=self.on_market_data)
+
+        self.event_engine.register_handler(topic=self.topic_set.on_order, handler=self.strategy.balance.on_order)
+        self.event_engine.register_handler(topic=self.topic_set.on_order, handler=self.on_order)
+        self.event_engine.register_handler(topic=self.topic_set.on_report, handler=self.strategy.balance.on_report)
+        self.event_engine.register_handler(topic=self.topic_set.on_report, handler=self.on_report)
+
+    def initialize_position_management(self):
+        for ticker in self.subscription:
+            risk_profile = self.strategy.position_tracker.dma.risk_profile
+
+            risk_profile.set_rule(ticker=ticker, key='max_trade_long', value=np.inf)
+            risk_profile.set_rule(ticker=ticker, key='max_trade_short', value=np.inf)
+            risk_profile.set_rule(ticker=ticker, key='max_exposure_long', value=np.inf)
+            risk_profile.set_rule(ticker=ticker, key='max_exposure_short', value=np.inf)
+
+    def load_data(self, ticker: str, market_date: datetime.date, dtype: Literal['TickData', 'TradeData', 'TransactionData', 'OrderBook']) -> list[MarketData]:
+        return self.data_loader(ticker=ticker, market_date=market_date, dtype=dtype)
+
+    def bod(self, market_date: datetime.date, **kwargs):
+        super().bod(market_date=market_date, **kwargs)
+        self.bod(market_date=market_date, **kwargs)
+
+    def eod(self, market_date: datetime.date, **kwargs):
+        super().bod(market_date=market_date, **kwargs)
+        self.bod(market_date=market_date, **kwargs)
+
+    def on_market_data(self, market_data: MarketData, **kwargs):
+        self.strategy.__call__(market_data=market_data, **kwargs)
+
+        if self.lock.locked():
+            self.lock.release()
+
+    def on_report(self, report: TradeReport, **kwargs):
+        self.strategy.on_report(report=report, **kwargs)
+
+    def on_order(self, order: TradeInstruction, **kwargs):
+        self.strategy.on_order(order=order, **kwargs)
+
+    def _launch_order(self, ticker: str, volume: float, limit_price: float):
+        self.strategy.open_pos(ticker=ticker, volume=abs(volume), trade_side=np.sign(volume))
+
+    def buy(self, ticker: str, volume: float = None, limit_price: float = None):
+        if ticker not in self.subscription:
+            raise ValueError(f'{ticker} not subscribed for trading!')
+
+        super().buy(ticker=ticker, volume=volume, limit_price=limit_price)
+
+    def sell(self, ticker: str, volume: float = None, limit_price: float = None):
+        if ticker not in self.subscription:
+            raise ValueError(f'{ticker} not subscribed for trading!')
+
+        super().sell(ticker=ticker, volume=volume, limit_price=limit_price)
+
+    def run(self, **kwargs):
+        if not self.event_engine.active:
+            self.event_engine.start()
+
+        replay = ProgressReplay(
+            loader=self.load_data,
+            start_date=self.start_date,
+            end_date=self.end_date,
+            bod=self.bod,
+            eod=self.eod,
+        )
+
+        for ticker in self.subscription:
+            replay.add_subscription(ticker, dtype='TickData')
+            replay.add_subscription(ticker, dtype='TradeData')
+
+        _start_ts = time.time()
+
+        for market_data in replay:
+            if self.multi_threading:
+                self.lock.acquire()
+                self.event_engine.put(topic=self.topic_set.push(market_data=market_data), market_data=market_data)
+            else:
+                self.strategy.mds.on_market_data(market_data=market_data)
+                self.strategy.position_tracker.on_market_data(market_data=market_data)
+                self.strategy.on_market_data(market_data=market_data)
+
+                if market_data.ticker in self.subscription:
+                    self.sim_match[market_data.ticker](market_data=market_data)
+                    self.web_app.update(market_data=market_data)
+
+            self.timestamp = market_data.timestamp
+            self.last_price[market_data.ticker] = market_data.market_price
+
+        LOGGER.info(f'All done! time_cost: {time.time() - _start_ts:,.3}s')

algo_engine/apps/backtest/web_app.py

@@ -0,0 +1,125 @@
+import argparse
+import datetime
+import pathlib
+from threading import Thread
+
+from algo_engine.apps import LOGGER
+from algo_engine.apps.backtest.doc_server import CandleStick
+from algo_engine.apps.bokeh_server import DocManager, DocServer
+
+
+class WebApp(object):
+    def __init__(self, start_date: datetime.date, end_date: datetime.date, name: str = 'WebApp.Backtest', address: str = '0.0.0.0', port: int = 8080, **kwargs):
+        from flask import Flask
+        self.start_date = start_date
+        self.end_date = end_date
+        self.name = name
+        self.root_dir = pathlib.Path(__file__).parent
+        self.host = address
+        self.port = port
+
+        self.flask = Flask(
+            import_name=self.name,
+            template_folder=self.root_dir.joinpath('templates'),
+            static_folder=self.root_dir.joinpath('static')
+        )
+        self.doc_manager = DocManager(host='localhost', port=port)
+        self.dashboard: dict[str, dict[str, DocServer]] = {}
+
+    def update(self, **kwargs):
+        for doc_server in self.doc_manager.doc_server.values():
+            doc_server.update(**kwargs)
+
+    def register(self, ticker: str, **kwargs):
+        if ticker in self.dashboard:
+            raise ValueError(f'Ticker {ticker} already registered.')
+
+        dashboard = self.dashboard[ticker] = {}
+        candlestick = dashboard[f'candlesticks'] = CandleStick(ticker=ticker, start_date=self.start_date, end_date=self.end_date, **kwargs)
+
+        self.doc_manager.register(url=f'/candlesticks/{ticker}', doc_server=candlestick)
+
+    def render_index(self):
+        from flask import render_template
+
+        dashboard_url = {ticker: f'{self.url}/{ticker}' for ticker in self.dashboard}
+
+        html = render_template(
+            'index.html',
+            title=f'PyAlgoEngine.Backtest.App',
+            data=dashboard_url
+        )
+
+        return html
+
+    def render_dashboard(self, ticker: str):
+        from flask import render_template
+        from bokeh.embed import server_document
+
+        dashboard = self.dashboard[ticker]
+        bokeh_scripts = {}
+
+        for name, doc_server in dashboard.items():
+            url = self.doc_manager.doc_url[doc_server]
+            doc_script = server_document(url=f'http://{self.doc_manager.bokeh_host}:{self.doc_manager.bokeh_port}{url}')
+            bokeh_scripts[name] = doc_script
+
+        html = render_template(
+            'dash.html',
+            ticker=ticker,
+            framework="flask",
+            **bokeh_scripts
+        )
+        return html
+
+    def serve(self, blocking: bool = True):
+        from waitress import serve
+
+        LOGGER.info(f'starting {self} service...')
+
+        self.doc_manager.start()
+        self.flask.route(rule='/', methods=["GET"])(self.render_index)
+
+        for ticker in self.dashboard:
+            def renderer():
+                return self.render_dashboard(ticker=ticker)
+
+            self.flask.route(rule=f'/{ticker}', methods=["GET"])(renderer)
+
+        if blocking:
+            return serve(app=self.flask, host=self.host, port=self.port)
+
+        t = Thread(target=serve, kwargs=dict(app=self.flask, host=self.host, port=self.port))
+        t.start()
+
+        # a monkey patch to resolve flask double logging issues
+        for hdl in (logger := self.flask.logger).handlers:
+            logger.removeHandler(hdl)
+
+        for hdl in (logger := LOGGER.root).handlers:
+            logger.removeHandler(hdl)
+
+    @property
+    def url(self) -> str:
+        if self.host == '0.0.0.0':
+            return f'http://localhost:{self.port}/'
+        else:
+            return f'http://{self.host}:{self.port}/'
+
+
+def start_app(start_date: datetime.date, end_date: datetime.date, blocking: bool = True, **kwargs):
+    web_app = WebApp(start_date=start_date, end_date=end_date, **kwargs)
+    web_app.serve(blocking=blocking)
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Start Backtest.App')
+    parser.add_argument('--start_date', type=str, required=True, help='Start date in YYYY-MM-DD format')
+    parser.add_argument('--end_date', type=str, required=True, help='End date in YYYY-MM-DD format')
+
+    args = parser.parse_args()
+
+    start_app(
+        start_date=datetime.datetime.strptime(args.start_date, '%Y-%m-%d').date(),
+        end_date=datetime.datetime.strptime(args.end_date, '%Y-%m-%d').date(),
+    )

algo_engine/apps/bokeh_server.py

@@ -0,0 +1,245 @@
+import abc
+import uuid
+from copy import deepcopy
+from functools import partial
+from threading import Event, Lock, Thread
+from typing import overload
+
+from algo_engine.base import MarketData
+from . import LOGGER
+
+
+class DocTheme(object, metaclass=abc.ABCMeta):
+    pass
+
+
+class DocServer(object, metaclass=abc.ABCMeta):
+    def __init__(self, theme: DocTheme = None, max_size: int = None, update_interval: float = 0., lock: Lock = None, **kwargs):
+        from bokeh.document import Document
+        from bokeh.models import ColumnDataSource
+
+        self.theme: DocTheme = theme
+        self.max_size: int = max_size
+        self.update_interval: float = update_interval
+        self.lock = Lock() if lock is None else lock
+
+        self.bokeh_documents: dict[int, Document] = {}
+        # self.bokeh_source: dict[int, ColumnDataSource] = {}
+        self.bokeh_data_pipe: dict[int, dict[str, list[...]]] = {}
+        self.bokeh_data_patch: dict[int, dict[str, list[tuple[int, ...]]]] = {}
+        self.bokeh_data_source: dict[int, ColumnDataSource] = {}
+
+    def __str__(self):
+        return f'<{self.__class__.__name__}>(id={id(self.__class__)})'
+
+    def __call__(self, doc):
+        self.register_document(doc=doc)
+
+    def __hash__(self):
+        return id(self)
+
+    @overload
+    def update(self, timestamp: float, market_price: float, **kwargs):
+        ...
+
+    @overload
+    def update(self, timestamp: float, open_price: float, close_price: float, high_price: float, low_price: float, **kwargs):
+        ...
+
+    @overload
+    def update(self, market_data: MarketData, **kwargs):
+        ...
+
+    @abc.abstractmethod
+    def update(self, **kwargs):
+        ...
+
+    @abc.abstractmethod
+    def layout(self, doc_id: int):
+        ...
+
+    def stream(self, doc_id: int = None):
+        if doc_id is None:
+            for doc_id in list(self.bokeh_documents):
+                self.stream(doc_id=doc_id)
+            return
+
+        # doc = self.bokeh_documents[doc_id]
+        data_pipe = self.bokeh_data_pipe[doc_id]
+        source = self.bokeh_data_source[doc_id]
+
+        source.stream(new_data=deepcopy(data_pipe), rollover=self.max_size)
+        for key, seq in data_pipe.items():
+            seq.clear()
+
+        LOGGER.debug(f'{self.__class__} <stream> updated!')
+
+    def patch(self, doc_id: int = None):
+        if doc_id is None:
+            for doc_id in list(self.bokeh_documents):
+                self.patch(doc_id=doc_id)
+            return
+
+        # doc = self.bokeh_documents[doc_id]
+        data_patch = self.bokeh_data_patch[doc_id]
+        source = self.bokeh_data_source[doc_id]
+
+        source.patch(patches=deepcopy(data_patch))
+        for key, seq in data_patch.items():
+            seq.clear()
+
+        LOGGER.debug(f'{self.__class__} <patch> updated!')
+
+    def register_document(self, doc):
+        from bokeh.models import ColumnDataSource
+
+        self.lock.acquire()
+
+        doc_id = uuid.uuid4().int
+
+        data = deepcopy(self.data)
+        self.bokeh_documents[doc_id] = doc
+        self.bokeh_data_pipe[doc_id] = {key: [] for key in data}
+        self.bokeh_data_patch[doc_id] = {key: [] for key in data}
+        self.bokeh_data_source[doc_id] = ColumnDataSource(data=data)
+
+        self.layout(doc_id=doc_id)
+
+        if self.update_interval:
+            doc.add_periodic_callback(callback=partial(self.stream, doc_id=doc_id), period_milliseconds=int(self.update_interval * 1000))
+            doc.add_periodic_callback(callback=partial(self.patch, doc_id=doc_id), period_milliseconds=int(self.update_interval * 1000))
+
+        doc.on_session_destroyed(partial(self._unregister_document, doc_id=doc_id))
+
+        LOGGER.info(f'{self} registered Bokeh document id = {doc_id}!')
+        self.lock.release()
+
+    def _unregister_document(self, session_context, doc_id: int):
+        self.lock.acquire()
+        LOGGER.info(f'Session {doc_id} disconnected!')
+
+        self.bokeh_documents.pop(doc_id)
+        self.bokeh_data_pipe.pop(doc_id)
+        self.bokeh_data_patch.pop(doc_id)
+        self.bokeh_data_source.pop(doc_id)
+        self.lock.release()
+
+    @property
+    @abc.abstractmethod
+    def data(self) -> dict[str, list]:
+        """
+        the data used to provide initial values for new bokeh.ColumnDataSource.
+        """
+        ...
+
+
+class DocManager(object):
+    def __init__(self, host: str = 'localhost', port: int = 21543, **kwargs):
+        self.host = host
+        self.port = port
+
+        self.bokeh_host = kwargs.get('bokeh_host', 'localhost')
+        self.bokeh_port = kwargs.get('bokeh_port', 5006)
+        self.bokeh_check_unused_sessions = kwargs.get('bokeh_check_unused_sessions', 1)
+
+        self.doc_server: dict[str, DocServer] = {}
+        self.doc_url: dict[DocServer, str] = {}
+        self.bokeh_thread = Thread(target=self.serve_bokeh)
+        self.stop_event = Event()
+        self.bokeh_server = None
+
+    def __getitem__(self, url: str):
+        return self.doc_server.__getitem__(url)
+
+    def __setitem__(self, url: str, doc_server: DocServer):
+        return self.register(url=url, doc_server=doc_server)
+
+    def __contains__(self, url: str):
+        return self.doc_server.__contains__(url)
+
+    def register(self, url: str, doc_server: DocServer):
+        if url in self.doc_server:
+            LOGGER.warning(f'{url} already registered! Existed doc_server {self.doc_server[url]} overridden!')
+
+        self.doc_server[url] = doc_server
+        self.doc_url[doc_server] = url
+        return doc_server
+
+    def serve_bokeh(self):
+        from bokeh.server.server import Server
+        import psutil
+        import socket
+
+        # Get all network interfaces and their IP addresses
+        addrs = psutil.net_if_addrs()
+        websocket_origin = [
+            f"{self.host}:{self.port}"
+        ]
+
+        for interface, addr_info in addrs.items():
+            for addr in addr_info:
+                if addr.family == socket.AF_INET:  # Filter only IPv4 addresses
+                    LOGGER.info(f"Binding network interface: {interface}, IP Address: {addr.address}")
+                    websocket_origin.append(f"{addr.address}:{self.port}")
+                    websocket_origin.append(f"{addr.address}:{self.bokeh_port}")
+
+        if (_ := f'localhost:{self.port}') not in websocket_origin:
+            websocket_origin.append(_)
+        if (_ := f'127.0.0.1:{self.port}') not in websocket_origin:
+            websocket_origin.append(_)
+        if (_ := f'localhost:{self.bokeh_port}') not in websocket_origin:
+            websocket_origin.append(_)
+        if (_ := f'127.0.0.1:{self.bokeh_port}') not in websocket_origin:
+            websocket_origin.append(_)
+        if (_ := f'{self.bokeh_host}:{self.port}') not in websocket_origin:
+            websocket_origin.append(_)
+        if (_ := f'{self.bokeh_host}:{self.bokeh_port}') not in websocket_origin:
+            websocket_origin.append(_)
+
+        self.bokeh_server = Server(
+            applications=self.doc_server,
+            address='0.0.0.0',
+            port=self.bokeh_port,
+            check_unused_sessions_milliseconds=(self.bokeh_check_unused_sessions * 1000),
+            allow_websocket_origin=websocket_origin,
+            use_xheaders=True,
+            # num_procs=1
+        )
+
+        LOGGER.info(
+            f'bokeh service started at {self.bokeh_host}:{self.bokeh_port}!\n' +
+            '\n'.join([f'http://{self.bokeh_host}:{self.bokeh_port}{url} => {app}' for url, app in self.doc_server.items()])
+        )
+
+        self.bokeh_server.start()
+
+        # Start the Bokeh server IOLoop unless stop_event is triggered
+        while not self.stop_event.is_set():
+            try:
+                self.bokeh_server.io_loop.start()
+            except Exception as e:
+                LOGGER.error(f"Error in Bokeh server: {e}")
+            finally:
+                LOGGER.info("Bokeh server has been stopped.")
+                break
+
+    def start(self):
+        LOGGER.info(f'Starting Bokeh service...')
+        self.bokeh_thread.start()
+
+    def stop(self):
+        LOGGER.info(f'Stopping Bokeh service...')
+
+        # Signal the event to stop
+        self.stop_event.set()
+
+        # Stop the Bokeh server gracefully
+        if self.bokeh_server is not None:
+            self.bokeh_server.io_loop.stop()  # Stop the IOLoop
+            self.bokeh_server.stop()  # Stop the Bokeh server itself
+
+        # Wait for the Bokeh thread to finish if it's still running
+        if self.bokeh_thread.is_alive():
+            self.bokeh_thread.join()
+
+        LOGGER.info('Bokeh service has been stopped.')

algo_engine/apps/demo/test.py

@@ -0,0 +1,40 @@
+import datetime
+import time
+
+from algo_engine.apps.backtest import LOGGER, WebApp
+from algo_engine.base import Progress
+from algo_engine.exchange_profile import PROFILE_CN
+from algo_engine.utils import fake_data
+
+
+def main():
+    PROFILE_CN.activate()
+
+    ticker = '000016.SH'
+    market_date = datetime.date.today()
+
+    data_set = fake_data(market_date=market_date)
+    web_app = WebApp(start_date=market_date, end_date=market_date)
+    LOGGER.info(f'{len(data_set)} fake data generated for {ticker} {market_date}.')
+
+    web_app.register(ticker=ticker)
+    web_app.serve(blocking=False)
+
+    LOGGER.info(f'web app started at {web_app.url}')
+
+    for ts, row in Progress(list(data_set.iterrows())):
+        web_app.update(
+            timestamp=ts,
+            ticker=ticker,
+            open_price=row['open_price'],
+            close_price=row['close_price'],
+            high_price=row['high_price'],
+            low_price=row['low_price'],
+        )
+        time.sleep(0.05)
+
+
+if __name__ == '__main__':
+    main()
+
+    # sys.exit(-1)

algo_engine/apps/sim_input/__init__.py

@@ -0,0 +1,23 @@
+import platform
+
+from .. import LOGGER
+
+
+def check_windows_version(min_version=(6, 1)):
+    """
+    Ensure the script is running on a compatible Windows version.
+    :param min_version: Minimum required version as a tuple (major, minor).
+                        Default is (6, 1) for Windows 7 (major=6, minor=1).
+    """
+    # Get the Windows version
+    if not platform.system() == "Windows":
+        raise EnvironmentError("This script only works on Windows.")
+
+    version_str = platform.version()
+    version_tuple = tuple(map(int, platform.win32_ver()[1].split('.')))
+
+    if version_tuple < min_version:
+        raise EnvironmentError(f"Unsupported Windows version: {version_str}. Minimum required is {min_version[0]}.{min_version[1]}.")
+
+
+LOGGER = LOGGER.getChild('SimInput')