openfund-core 0.0.2__tar.gz → 0.0.4__tar.gz

{openfund_core-0.0.2 → openfund_core-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openfund-core
-Version: 0.0.2
+Version: 0.0.4
 Summary: 
 Author: yang99love
 Author-email: yang99love@hotmail.com
@@ -12,6 +12,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: apscheduler (>=3.10.4,<4.0.0)
 Requires-Dist: binance-connector (>=3.9.0,<4.0.0)
 Requires-Dist: binance-futures-connector (>=4.1.0,<5.0.0)
 Requires-Dist: httpretty (>=1.1.4,<2.0.0)

{openfund_core-0.0.2 → openfund_core-0.0.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "openfund-core"
-version = "0.0.2"
+version = "0.0.4"
 description = ""
 authors = ["yang99love <yang99love@hotmail.com>"]
 readme = "README.md"
@@ -11,18 +11,17 @@ include = [
 
 [tool.poetry.dependencies] # main dependency group
 python = "^3.8"
-binance-futures-connector = "^4.1.0"
-binance-connector = "^3.9.0"
 poetry = "^1.8.4"
 httpretty = "^1.1.4"
+apscheduler = "^3.10.4"
+binance-connector = "^3.9.0"
+binance-futures-connector = "^4.1.0"
 
 [tool.poetry.group.dev.dependencies]
 pre-commit = ">=2.15.0"
 vendoring = ">=1.0"
 
 [tool.poetry.group.test.dependencies]
-binance-futures-connector = "^4.1.0"
-binance-connector = "^3.9.0"
 httpretty = "^1.1.4"
 pytest = ">=7.1.2"
 pytest-cov = ">=3.0.0"

openfund_core-0.0.4/src/openfund/core/__init__.py

@@ -0,0 +1,14 @@
+# import time
+# from apscheduler.schedulers.blocking import BlockingScheduler
+
+
+# def taskDetail(taskName: str):
+#     currTime = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
+#     print(f"{taskName}-->", "currTime:", currTime)
+
+
+# if __name__ == "__main__":
+#     apSchedule = BlockingScheduler()
+#     apSchedule.add_job(func=taskDetail, trigger="interval", seconds=5, args=["task-A"])
+
+#     apSchedule.start()

openfund_core-0.0.4/src/openfund/core/api_tools/binance_futures_tools.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import logging
+
+from openfund.core.base_tool import Tool as BaseTool
+from openfund.core.pyopenfund import Openfund
+
+
+logger = logging.getLogger(__name__)
+
+
+class BinanceUMFuturesTool(BaseTool):
+    def __init__(self, openfund: Openfund | None = None) -> None:
+        super().__init__(openfund, "binance")
+
+    def time(self):
+        return self.umclient.time()
+
+    def ping(self):
+        return self.umclient.ping()
+
+    def klines(self, symbol: str, interval: str = "1m", **kwargs):
+        return self.umclient.klines(symbol=symbol, interval=interval, **kwargs)

openfund_core-0.0.4/src/openfund/core/api_tools/binance_tools.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+import logging
+from poetry.utils.authenticator import Authenticator
+
+from typing import TYPE_CHECKING
+
+from openfund.core.base_tool import Tool as BaseTool
+from openfund.core.pyopenfund import Openfund
+
+
+logger = logging.getLogger(__name__)
+
+
+class BinanceTools(BaseTool):
+    def __init__(self, openfund: Openfund | None = None) -> None:
+        super().__init__(openfund, "binance")
+
+    def get_time(self):
+        return self.client.time()
+
+    def get_account(self):
+        return self.client.account()
+
+    def get_klines(self, symbol: str, interval: str, **kwargs):
+        return self.client.klines(symbol=symbol, interval=interval, **kwargs)

{openfund_core-0.0.2/src/openfund/core/libs → openfund_core-0.0.4/src/openfund/core/api_tools}/enums.py

@@ -10,22 +10,54 @@ ORDER_STATUS_PENDING_CANCEL = "PENDING_CANCEL"
 ORDER_STATUS_REJECTED = "REJECTED"
 ORDER_STATUS_EXPIRED = "EXPIRED"
 
-KLINE_INTERVAL_1SECOND = "1s"
-KLINE_INTERVAL_1MINUTE = "1m"
-KLINE_INTERVAL_3MINUTE = "3m"
-KLINE_INTERVAL_5MINUTE = "5m"
-KLINE_INTERVAL_15MINUTE = "15m"
-KLINE_INTERVAL_30MINUTE = "30m"
-KLINE_INTERVAL_1HOUR = "1h"
-KLINE_INTERVAL_2HOUR = "2h"
-KLINE_INTERVAL_4HOUR = "4h"
-KLINE_INTERVAL_6HOUR = "6h"
-KLINE_INTERVAL_8HOUR = "8h"
-KLINE_INTERVAL_12HOUR = "12h"
-KLINE_INTERVAL_1DAY = "1d"
-KLINE_INTERVAL_3DAY = "3d"
-KLINE_INTERVAL_1WEEK = "1w"
-KLINE_INTERVAL_1MONTH = "1M"
+
+class KlineInterval(Enum):
+    KLINE_INTERVAL_1SECOND = ("1s", 1, "s")
+    KLINE_INTERVAL_1MINUTE = ("1m", 1, "m")
+    KLINE_INTERVAL_3MINUTE = ("3m", 3, "m")
+    KLINE_INTERVAL_5MINUTE = ("5m", 5, "m")
+    KLINE_INTERVAL_15MINUTE = ("15m", 15, "m")
+    KLINE_INTERVAL_30MINUTE = ("30m", 30, "m")
+    KLINE_INTERVAL_1HOUR = ("1h", 1, "h")
+    KLINE_INTERVAL_2HOUR = ("2h", 2, "h")
+    KLINE_INTERVAL_4HOUR = ("4h", 4, "h")
+    KLINE_INTERVAL_6HOUR = ("6h", 6, "h")
+    KLINE_INTERVAL_8HOUR = ("8h", 8, "h")
+    KLINE_INTERVAL_12HOUR = ("12h", 12, "h")
+    KLINE_INTERVAL_1DAY = ("1d", 1, "d")
+    KLINE_INTERVAL_3DAY = ("3d", 3, "d")
+    KLINE_INTERVAL_1WEEK = ("1w", 1, "d")
+    KLINE_INTERVAL_1MONTH = ("1M", 1, "M")
+
+    def __init__(self, value: str, unit: int, unitType: str):
+        self._value_ = value
+        self.unit = unit
+        self.unitType = unitType
+
+    @classmethod
+    def getByUnit(cls, unit: int, unitType: str) -> str:
+        for interval in KlineInterval:
+            if interval.unit == unit and interval.unitType == unitType:
+                return interval.value
+        return None
+
+
+# KLINE_INTERVAL_1SECOND = "1s"
+# KLINE_INTERVAL_1MINUTE = "1m"
+# KLINE_INTERVAL_3MINUTE = "3m"
+# KLINE_INTERVAL_5MINUTE = "5m"
+# KLINE_INTERVAL_15MINUTE = "15m"
+# KLINE_INTERVAL_30MINUTE = "30m"
+# KLINE_INTERVAL_1HOUR = "1h"
+# KLINE_INTERVAL_2HOUR = "2h"
+# KLINE_INTERVAL_4HOUR = "4h"
+# KLINE_INTERVAL_6HOUR = "6h"
+# KLINE_INTERVAL_8HOUR = "8h"
+# KLINE_INTERVAL_12HOUR = "12h"
+# KLINE_INTERVAL_1DAY = "1d"
+# KLINE_INTERVAL_3DAY = "3d"
+# KLINE_INTERVAL_1WEEK = "1w"
+# KLINE_INTERVAL_1MONTH = "1M"
 
 SIDE_BUY = "BUY"
 SIDE_SELL = "SELL"

openfund_core-0.0.4/src/openfund/core/base_collector.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import logging
+import csv
+
+from abc import abstractmethod
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from apscheduler.job import Job
+
+from openfund.core.pyopenfund import Openfund
+from openfund.core.factory import Factory
+
+
+logger = logging.getLogger(__name__)
+
+
+class Collector:
+    def __init__(self, openfund: Openfund | None = None) -> None:
+        self._openfund: Openfund = openfund
+        if self._openfund is None:
+            self._openfund = Factory.create_openfund()
+        self._job: Job = None
+
+    @property
+    def openfund(self) -> Openfund:
+        return self._openfund
+
+    @abstractmethod
+    def collect(self) -> None:
+        raise NotImplementedError()
+
+    @abstractmethod
+    def start(self) -> int:
+        raise NotImplementedError()
+        # from apscheduler.schedulers.background import BlockingScheduler
+
+        # apSchedule = BlockingScheduler()
+        # self.openfund.scheduler.add_job(
+        #     func=self.collect, trigger="interval", minutes=5,seconds=5 id="um_futures_collector"
+        # )
+
+    def stop(self) -> int:
+        if self._job is not None:
+            self._job.remove()
+        logger.debug(f"{self._job.name} is stop .")
+        return 0
+
+    def pause(self) -> int:
+        if self._job is not None:
+            self._job.pause()
+        logger.debug(f"{self._job.name} is pause .")
+        return 0
+
+    def resume(self) -> int:
+        if self._job is not None:
+            self._job.resume()
+        logger.debug(f"{self._job.name} is resume .")
+        return 0
+
+    def _write_to_csv(self, file: Path, listData: list) -> None:
+
+        # 如果路径不存在，创建路径
+        file.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(file, "a", newline="") as file:
+            writer = csv.writer(file)
+            # 时间戳倒序，插入文件尾部
+            writer.writerows(sorted(listData, key=lambda x: x[0], reverse=True))
+
+        logger.debug("2、{}条写入{}文件...".format(len(listData), file))

openfund_core-0.0.4/src/openfund/core/base_tool.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import logging
+
+from pathlib import Path
+
+from typing import TYPE_CHECKING
+
+from poetry.utils.authenticator import Authenticator
+from binance.spot import Spot as Client
+from binance.um_futures import UMFutures as UMClient
+
+from openfund.core.pyopenfund import Openfund
+from openfund.core.factory import Factory
+
+
+logger = logging.getLogger(__name__)
+
+
+class Tool:
+    def __init__(
+        self, openfund: Openfund | None = None, toolname: str = "binance"
+    ) -> None:
+        self._openfund: Openfund = openfund
+        if self._openfund is None:
+            self._openfund = Factory.create_openfund()
+
+        self._toolname = toolname
+        self._password_manager = Authenticator(
+            self._openfund._poetry.config
+        )._password_manager
+
+        self._client = None
+        self._umclient = None
+
+    @property
+    def api_key(self) -> str:
+        return self._password_manager.get_http_auth(self._toolname).get("username")
+
+    @property
+    def apk_secret(self) -> str:
+        return self._password_manager.get_http_auth(self._toolname).get("password")
+
+    @property
+    def openfund(self) -> Openfund:
+        return self._openfund
+
+    @property
+    def client(self) -> Client:
+        if self._client is None:
+            self._client = Client(self.api_key, self.apk_secret)
+        return self._client
+
+    @property
+    def umclient(self) -> UMClient:
+        if self._umclient is None:
+            self._umclient = UMClient(self.api_key, self.apk_secret)
+        return self._umclient

openfund_core-0.0.4/src/openfund/core/factory.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import logging
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from poetry.factory import Factory as BaseFactory
+from openfund.core.pyopenfund import Openfund
+
+
+if TYPE_CHECKING:
+    from poetry.poetry import Poetry
+
+
+logger = logging.getLogger(__name__)
+_APP_NAME = "pyopenfund"
+
+
+class Factory(BaseFactory):
+    _openfund: Openfund = None
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._init_log()
+
+    def create_poetry(
+        self,
+        cwd: Path | None = None,
+        with_groups: bool = True,
+    ) -> Poetry:
+        poetry = super().create_poetry(cwd=cwd, with_groups=with_groups)
+        return poetry
+
+    @classmethod
+    def create_openfund(
+        cls,
+        cwd: Path | None = None,
+        with_groups: bool = True,
+    ) -> Openfund:
+        if cls._openfund is not None:
+            return cls._openfund
+
+        if cwd is None:
+            cwd = Path.cwd()
+
+        poetry = Factory().create_poetry(cwd=cwd, with_groups=with_groups)
+        cls._openfund = Openfund(poetry)
+        cls._openfund.scheduler.start()
+        return cls._openfund
+
+    def _init_log(self):
+        from openfund.core.pyopenfund import user_log_path
+
+        log_file = user_log_path(
+            _APP_NAME, appauthor=False, ensure_exists=True
+        ).resolve()
+        log_file = (
+            user_log_path(_APP_NAME, appauthor=False, ensure_exists=True)
+            .joinpath("openfund-core.log")
+            .resolve()
+        )
+        fileHandler = FileHandler(log_file)
+        fileHandler.setFormatter(FileFormatter())
+        console_handler = logging.StreamHandler()
+        console_handler.setFormatter(FileFormatter())
+        logging.basicConfig(
+            level=logging.DEBUG,
+            handlers=[console_handler, fileHandler],
+        )
+
+
+from logging.handlers import TimedRotatingFileHandler
+
+
+class FileHandler(TimedRotatingFileHandler):
+    def __init__(
+        self,
+        filename,
+        when="midnight",
+        interval=1,
+        backupCount=7,
+        encoding=None,
+        delay=False,
+        utc=False,
+    ) -> None:
+        super().__init__(filename, when, interval, backupCount, encoding, delay, utc)
+
+
+class FileFormatter(logging.Formatter):
+
+    _format = "%(asctime)s - %(process)d | %(threadName)s | %(module)s.%(funcName)s:%(lineno)d - %(levelname)s -%(message)s"
+
+    _datefmt = "%Y-%m-%d-%H:%M:%S"  # 时间
+
+    def __init__(self, fmt=_format, datefmt=_datefmt, style="%") -> None:
+        super().__init__(fmt, datefmt, style)

openfund_core-0.0.4/src/openfund/core/pyopenfund.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import logging
+import os
+import sys
+
+from typing import TYPE_CHECKING
+
+from pathlib import Path
+
+from platformdirs import user_cache_path
+from platformdirs import user_config_path
+from platformdirs import user_data_path
+from platformdirs import user_log_path
+from apscheduler.schedulers.background import BackgroundScheduler
+
+if TYPE_CHECKING:
+    from poetry.poetry import Poetry
+    from openfund.core.factory import Factory
+
+logger = logging.getLogger(__name__)
+_APP_NAME = "pyopenfund"
+
+
+class Openfund:
+    def __init__(self, poetry: Openfund) -> None:
+        self._poetry: Poetry = poetry
+        self._schedule: BackgroundScheduler = None
+
+    @property
+    def poetry(self) -> Poetry:
+        from pathlib import Path
+
+        if self._poetry is not None:
+            return self._poetry
+
+        project_path = Path.cwd()
+
+        self._poetry = Factory().create_poetry(
+            cwd=project_path,
+        )
+
+        return self._poetry
+
+    @property
+    def dataDir(self) -> Path:
+        # openfund_home = os.getenv("OPENFUND_HOME")
+        # if openfund_home:
+        #     return Path(openfund_home).expanduser()
+        return Path(
+            os.getenv("OPENFUND_DATA_DIR")
+            or user_data_path(_APP_NAME, appauthor=False, roaming=True)
+        ).joinpath("data")
+
+    @property
+    def cacheDir(self) -> Path:
+        return Path(
+            os.getenv("OPENFUND_CACHE_DIR")
+            or user_cache_path(_APP_NAME, appauthor=False)
+        )
+
+    @property
+    def configDir(self) -> Path:
+
+        return Path(
+            os.getenv("OPENFUND_CONFIG_DIR")
+            or user_config_path(_APP_NAME, appauthor=False, roaming=True)
+        ).joinpath("config")
+
+    @property
+    def logDir(self) -> Path:
+
+        return Path(
+            os.getenv("OPENFUND_LOG_DIR")
+            or user_log_path(_APP_NAME, appauthor=False, roaming=True)
+        )
+
+    @property
+    def scheduler(self) -> BackgroundScheduler:
+        if self._schedule is None:
+            self._schedule = BackgroundScheduler(
+                timezone="MST",
+            )
+
+        return self._schedule

openfund_core-0.0.4/src/openfund/core/services/um_futures_collector.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+
+import logging
+import time
+from pathlib import Path
+
+from openfund.core.api_tools.enums import KlineInterval
+from openfund.core.base_tool import Tool as BaseTool
+from openfund.core.api_tools.binance_futures_tools import BinanceUMFuturesTool
+from openfund.core.base_collector import Collector as BaseCollector
+
+from openfund.core.utils.time_tools import TimeTools
+
+logger = logging.getLogger(__name__)
+
+
+class KLinesCollector(BaseCollector):
+    def __init__(
+        self,
+        hisSwitch: int = 0,
+        hisDateTime: int = 0,
+        pool: list = None,
+        interval: int = 5,
+        client: BaseTool = None,
+    ) -> None:
+        super().__init__()
+        self._pool = pool
+        if self._pool is None:
+            self._pool = ["BTCUSDT", "ETHUSDT"]
+        logger.debug("+++++++++++++++ KLinesCollector init +++++++++++++ ")
+
+        self._interval = interval
+        self._hisSwitch = hisSwitch
+        self._hisDateTime = hisDateTime
+        self._dataDir = self.openfund.dataDir
+        self._client = client
+        if self._client is None:
+            self._client = BinanceUMFuturesTool().umclient
+        # self._job = None
+
+    def collect(self) -> None:
+
+        for symbol in self._pool:
+            logger.debug("{} symbol 开始 ++++++++++++++++++++++++++++ ".format(symbol))
+            latestRecords = 1  # 采集最近一次的记录数量
+            records = 0  # 累计记录数
+            queryCount = 0  # 执行次数
+            nextEndTime = 0
+            params = {"limit": 1000}
+            while latestRecords != 0:  # 循环读取，直到记录为空
+                queryCount += 1
+                if nextEndTime != 0:
+                    params = {"limit": 1000, "endTime": nextEndTime}
+
+                logger.debug("1、{}第{}次开始执行...".format(symbol, queryCount))
+                listData = []
+                try:
+                    listData = self._client.klines(
+                        symbol,
+                        KlineInterval.getByUnit(self._interval, "m"),
+                        **params,
+                    )
+                except Exception as e:
+                    # print("Error:", e)
+                    logger.error(e)
+                    time.sleep(10)
+                    continue
+
+                latestRecords = len(listData)
+                data_file = Path(
+                    self._dataDir.joinpath("klines")
+                    .joinpath(symbol)
+                    .joinpath(
+                        "klines_{}.csv".format(
+                            KlineInterval.getByUnit(self._interval, "m")
+                        )
+                    )
+                )
+                self._write_to_csv(data_file, listData)
+
+                if latestRecords > 0:
+                    nextEndTime = (
+                        # -1 不和close时间戳相同,避免重新拉取重复数据
+                        listData[0][0]
+                        - 1
+                    )
+
+                    logger.debug(
+                        "3、下次结束时间 %s %s"
+                        % (TimeTools.format_timestamp(nextEndTime), nextEndTime)
+                    )
+
+                    if self._hisSwitch == 0 or nextEndTime <= self._hisDateTime:
+                        break
+                else:
+                    logger.debug("4、结束...")
+
+                # time.sleep(0.1)
+            records = latestRecords + records
+            logger.info("5、{} 抓取数据 {} 条记录...".format(symbol, records))
+            logger.debug("{} symbol --------------------------------- ".format(symbol))
+
+    # def taskDetail(taskName: str):
+    #     currTime = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
+    #     logger.debug(f"{taskName}-->", "currTime:", currTime)
+
+    def start(self) -> int:
+
+        # self.collect()
+        self._job = self.openfund.scheduler.add_job(
+            func=self.collect,
+            trigger="interval",
+            # minutes=self._interval,
+            seconds=self._interval,
+            id="um_futures_collector",
+        )
+
+        logger.debug("调度任务已启动,每%s分钟执行一次。", self._interval)
+
+        return 0
+
+
+# if __name__ == "__main__":
+#     from openfund.core.services.um_futures_collector import KLinesCollector
+
+#     collector = KLinesCollector()
+
+#     collector.start()
+#     logger.debug(f"main   collector.start()  ===== ")
+#     i = 0
+#     while i < 10:
+
+#         logger.debug("main i=%s ===== ", i)
+#         if i == 2:
+#             collector.pause()
+#         if i == 4:
+#             collector.resume()
+#         if i == 8:
+#             collector.stop()
+#         time.sleep(5)
+#         i += 1

openfund_core-0.0.4/src/openfund/core/utils/time_tools.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python
+
+import time
+from datetime import date, datetime, timedelta
+
+
+class TimeTools:
+
+    @staticmethod
+    def print_timestamp(timestamp):
+        print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(timestamp / 1000)))
+
+    @staticmethod
+    def format_timestamp(timestamp):
+        return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(timestamp / 1000))
+
+    @staticmethod
+    def format_date(timestamp):
+        return time.strftime("%Y-%m-%d", time.localtime(timestamp / 1000))
+
+    @staticmethod
+    def format_date_to(to_days):
+        now = date.today()
+        to = now + timedelta(days=to_days)
+        return to