httptrading 1.0.0__py3-none-any.whl

httptrading/model.py

@@ -0,0 +1,174 @@
+import enum
+from datetime import datetime
+from dataclasses import dataclass, field
+
+
+class TradeType(enum.Enum):
+    Securities = enum.auto()
+    Cryptocurrencies = enum.auto()
+
+
+class Unit(enum.Enum):
+    Share = enum.auto()
+    RoundLot = enum.auto()
+    Satoshi = enum.auto()
+
+
+class OrderType(enum.Enum):
+    """
+    订单的类型
+    """
+    Limit = enum.auto() # 限价单
+    Market = enum.auto() # 市价单
+
+
+class TimeInForce(enum.Enum):
+    """
+    订单的有效期, 一般的交易通道均支持当日有效和取消前有效
+    """
+    DAY = enum.auto()
+    GTC = enum.auto()
+
+
+class Lifecycle(enum.Enum):
+    """
+    订单交易时段
+    """
+    RTH = enum.auto() # 盘中
+    ETH = enum.auto() # 盘中 + 盘前盘后
+    OVERNIGHT = enum.auto() # 仅夜盘
+
+
+class UnifiedStatus(enum.Enum):
+    UNKNOWN = enum.auto() # 已知信息不能映射到的状态
+    OVERNIGHT = enum.auto() # 夜盘
+    PRE_HOURS = enum.auto() # 盘前
+    RTH = enum.auto() # 正常交易时段
+    REST = enum.auto()  # 休市
+    AFTER_HOURS = enum.auto() # 盘后
+    CLOSED = enum.auto() # 收盘
+
+
+@dataclass(frozen=True)
+class Contract:
+    """
+    Contract 定义了交易品种的精确描述.
+    根据交易种类, 区分为证券和加密货币;
+    根据 ticker 设置交易标的的代码;
+    对于支持多个市场的交易通道, 例如证券, 需要额外提供 region 加以区分标的的所属市场.
+    """
+    trade_type: TradeType
+    ticker: str
+    region: str
+
+    @property
+    def unique_pair(self):
+        return self.trade_type, self.ticker, self.region,
+
+    def __hash__(self):
+        return self.unique_pair.__hash__()
+
+    def __eq__(self, other):
+        if isinstance(other, Contract):
+            return self.unique_pair == other.unique_pair
+        return False
+
+
+@dataclass(frozen=True)
+class Position:
+    broker: str
+    broker_display: str
+    contract: Contract
+    unit: Unit
+    currency: str
+    qty: int
+
+
+@dataclass(frozen=True)
+class Cash:
+    currency: str
+    amount: float
+
+
+@dataclass(frozen=True)
+class MarketStatus:
+    region: str
+    origin_status: str
+    unified_status: UnifiedStatus
+
+
+@dataclass(frozen=True)
+class Quote:
+    contract: Contract
+    currency: str
+    is_tradable: bool
+    latest: float
+    pre_close: float
+    open_price: float
+    high_price: float
+    low_price: float
+    time: datetime
+
+
+@dataclass(frozen=True)
+class Order:
+    order_id: str
+    currency: str
+    qty: int
+    filled_qty: int = field(default=0)
+    avg_price: float = field(default=0.0)
+    error_reason: str = field(default='')
+    is_canceled: bool = field(default=False)
+
+    @property
+    def is_filled(self) -> bool:
+        is_filled = False
+        if self.filled_qty >= self.qty:
+            is_filled = True
+        return is_filled
+
+    @property
+    def is_completed(self) -> bool:
+        is_completed = False
+        if self.filled_qty >= self.qty:
+            is_completed = True
+        elif self.is_canceled:
+            is_completed = True
+        elif self.error_reason:
+            is_completed = True
+        return is_completed
+
+
+@dataclass(frozen=True)
+class DetectPkg:
+    """
+    如果需要在 BaseBroker 对象创建时检测相关的 sdk 包是否可以导入,
+    这个结构用于在 @broker_register 装饰器的参数中说明需要导入的模块名以及对应包的安装名.
+    """
+    pkg_name: str
+    import_name: str
+
+
+@dataclass(frozen=True)
+class BrokerMeta:
+    name: str
+    display: str
+    detect_package: DetectPkg = None
+
+
+__all__ = [
+    'TradeType',
+    'Unit',
+    'OrderType',
+    'TimeInForce',
+    'Lifecycle',
+    'UnifiedStatus',
+    'Contract',
+    'Position',
+    'Cash',
+    'MarketStatus',
+    'Quote',
+    'Order',
+    'DetectPkg',
+    'BrokerMeta',
+]

httptrading/tool/leaky_bucket.py

@@ -0,0 +1,87 @@
+import math
+import asyncio
+from threading import Lock
+from httptrading.tool.time import TimeTools
+
+
+class LeakyBucket:
+    def __init__(self, leak_rate: float = 10, capacity: int = None, used_tokens: int = None):
+        assert isinstance(leak_rate, (int, float, ))
+        assert leak_rate > 0
+
+        if capacity is None:
+            capacity = 1
+        assert isinstance(capacity, int)
+        assert capacity > 0
+
+        if used_tokens is None:
+            used_tokens = 0
+        assert isinstance(used_tokens, int)
+        assert used_tokens >= 0
+
+        assert capacity >= used_tokens
+        self._capacity = capacity
+        self._used_tokens = used_tokens
+        self._leak_rate = float(leak_rate)
+        self._last_time = TimeTools.utc_now().timestamp()
+        self._lock = Lock()
+        self._alock = asyncio.Lock()
+
+    async def __aenter__(self):
+        await self.consume_async()
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+    def __enter__(self):
+        self.consume()
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+    @property
+    def used_tokens(self):
+        return self._get_used_tokens(rewrite_tokens=False)
+
+    @property
+    def available_tokens(self):
+        return self._capacity - self.used_tokens
+
+    def _get_used_tokens(self, rewrite_tokens=False):
+        now = TimeTools.utc_now().timestamp()
+        delta = self._leak_rate / 60.0 * (now - self._last_time)
+        delta = math.floor(delta)
+        new_used_tokens = max(0, self._used_tokens - delta)
+        if rewrite_tokens:
+            self._used_tokens = new_used_tokens
+        return new_used_tokens
+
+    def _consume(self):
+        while True:
+            with self._lock:
+                if 1 + self._get_used_tokens(rewrite_tokens=True) <= self._capacity:
+                    self._used_tokens += 1
+                    self._last_time = TimeTools.utc_now().timestamp()
+                    break
+                last_time = self._last_time
+            now = TimeTools.utc_now().timestamp()
+            secs = last_time + 60.0 / self._leak_rate - now
+            TimeTools.sleep(secs=secs)
+
+    def consume(self):
+        self._consume()
+
+    async def consume_async(self):
+        while True:
+            async with self._alock:
+                if 1 + self._get_used_tokens(rewrite_tokens=True) <= self._capacity:
+                    self._used_tokens += 1
+                    self._last_time = TimeTools.utc_now().timestamp()
+                    break
+                last_time = self._last_time
+            now = TimeTools.utc_now().timestamp()
+            secs = last_time + 60.0 / self._leak_rate - now
+            await asyncio.sleep(secs)
+
+
+__all__ = ["LeakyBucket", ]

httptrading/tool/locate.py

@@ -0,0 +1,85 @@
+import os
+import re
+import sys
+import pkgutil
+import importlib
+
+
+class LocateTools:
+    """
+    文件系统定位工具
+    帮助在 $PATH, IDE 和 $PYTHONPATH 等位置中搜索需要的文件和目录
+    """
+    ENVIRONMENT_KEY_PYTHON_PATH = 'PYTHONPATH'
+    ENVIRONMENT_KEY_IDE_ROOTS = 'IDE_PROJECT_ROOTS'
+
+    @classmethod
+    def _build_path_list(cls) -> list:
+        path_list = list()
+        python_path_list = list()
+        if cls.ENVIRONMENT_KEY_PYTHON_PATH in os.environ:
+            python_path_list = os.environ[cls.ENVIRONMENT_KEY_PYTHON_PATH].split(":")
+        if cls.ENVIRONMENT_KEY_IDE_ROOTS in os.environ:
+            path_list.append(os.environ[cls.ENVIRONMENT_KEY_IDE_ROOTS])
+        path_list.extend(python_path_list)
+        path_list.extend(sys.path)
+        return path_list
+
+    @classmethod
+    def locate_file(cls, file_path) -> str:
+        path_list = cls._build_path_list()
+        for path in path_list:
+            detect_path = os.path.join(path, file_path)
+            if os.path.isfile(detect_path):
+                return detect_path
+        raise FileNotFoundError
+
+    @classmethod
+    def locate_folder(cls, folder_path) -> str:
+        path_list = cls._build_path_list()
+        for path in path_list:
+            detect_path = os.path.join(path, folder_path)
+            if os.path.isdir(detect_path):
+                return detect_path
+        raise FileNotFoundError
+
+    @classmethod
+    def scan_folder(cls, folder_path, re_search: str) -> list[str]:
+        result = list()
+        for root, dirs, files in os.walk(folder_path):
+            for file in files:
+                if re.search(re_search, file.lower()):
+                    path = os.path.join(root, file)
+                    result.append(path)
+        return result
+
+    @classmethod
+    def read_file(cls, path: str) -> None | str:
+        if os.path.exists(path):
+            with open(path, 'r', encoding='utf8') as f:
+                text = f.read()
+            return text
+        else:
+            return None
+
+    @classmethod
+    def write_file(cls, path: str, text: str, mode: str = 'w'):
+        args = dict(
+            file=path,
+            mode=mode,
+        )
+        if mode == 'w':
+            args |= dict(encoding='utf8')
+        with open(**args) as f:
+            f.write(text)
+
+    @classmethod
+    def discover_plugins(cls, package_name):
+        package = importlib.import_module(package_name)
+        for _, module_name, is_pkg in pkgutil.walk_packages(package.__path__, package.__name__ + '.'):
+            if is_pkg:
+                continue
+            importlib.import_module(module_name)
+
+
+__all__ = ['LocateTools', ]

httptrading/tool/time.py

@@ -0,0 +1,77 @@
+import re
+import time
+from zoneinfo import ZoneInfo
+from datetime import datetime, timedelta, UTC, timezone
+import humanize
+
+
+class TimeTools:
+    @classmethod
+    def _get_utc(cls):
+        return datetime.now(timezone.utc)
+
+    @classmethod
+    def utc_now(cls):
+        return cls._get_utc()
+
+    @classmethod
+    def date_to_ymd(cls, date: datetime, join=True) -> str:
+        if join:
+            return date.strftime('%Y-%m-%d')
+        else:
+            return date.strftime('%Y%m%d')
+
+    @classmethod
+    def format_ymd(cls, s: str | int) -> str:
+        if s is None:
+            return '--'
+        elif isinstance(s, int):
+            s = str(s)
+        if m := re.match(r'^(\d{4})(\d{2})(\d{2})$', s):
+            yyyy, mm, dd = m.groups()
+            return f'{yyyy}-{mm}-{dd}'
+        elif re.match(r'^(\d{4})-(\d{2})-(\d{2})$', s):
+            return s
+        else:
+            return s
+
+    @classmethod
+    def timedelta(cls, date: datetime, days=0, minutes=0, seconds=0):
+        return date + timedelta(days=days, minutes=minutes, seconds=seconds)
+
+    @classmethod
+    def from_timestamp(cls, timestamp, tz: str = None) -> datetime:
+        """
+        秒单位时间戳
+        :param timestamp:
+        :param tz:
+        :return:
+        """
+        tz = tz if tz else cls.current_tz()
+        date = datetime.fromtimestamp(timestamp, UTC)
+        return date.astimezone(ZoneInfo(tz))
+
+    @classmethod
+    def from_params(cls, year: int, month: int, day: int, hour: int, minute: int, second: int, tz: str):
+        return datetime(
+            year=year,
+            month=month,
+            day=day,
+            hour=hour,
+            minute=minute,
+            second=second,
+            tzinfo=ZoneInfo(tz),
+        )
+
+    @classmethod
+    def sleep(cls, secs: float):
+        if secs <= 0.0:
+            return
+        time.sleep(secs)
+
+    @classmethod
+    def precisedelta(cls, value, minimum_unit='seconds', suppress=(), format='%0.2f'):
+        return humanize.precisedelta(value=value, minimum_unit=minimum_unit, suppress=suppress, format=format)
+
+
+__all__ = ['TimeTools', ]