qdata-quote 0.1.0__py3-none-any.whl

qdata_quote/__init__.py

@@ -0,0 +1,3 @@
+from .service import QuoteService
+
+__all__ = ["QuoteService"]

qdata_quote/bench.py

@@ -0,0 +1,112 @@
+"""性能基准测试：对比 easyquotation 与 qdata_quote 的采集速度"""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+import time
+
+
+def _load_stock_codes() -> list[str]:
+    """从 easyquotation 加载全市场股票代码"""
+    try:
+        from easyquotation import helpers
+
+        return helpers.get_stock_codes()
+    except ImportError:
+        print("需要安装 easyquotation: pip install easyquotation")
+        sys.exit(1)
+
+
+def _bench_easyquotation_sina(codes: list[str]) -> float:
+    """easyquotation 新浪源耗时"""
+    import easyquotation
+
+    q = easyquotation.use("sina")
+    start = time.perf_counter()
+    q.real(codes)
+    return time.perf_counter() - start
+
+
+def _bench_easyquotation_tencent(codes: list[str]) -> float:
+    """easyquotation 腾讯源耗时"""
+    import easyquotation
+
+    q = easyquotation.use("qq")
+    start = time.perf_counter()
+    q.real(codes)
+    return time.perf_counter() - start
+
+
+async def _bench_qdata_async(codes: list[str], source: str) -> float:
+    """qdata_quote 异步耗时"""
+    from qdata_quote import QuoteService
+
+    service = QuoteService()
+    async with service:
+        start = time.perf_counter()
+        await service.get_real(codes, source=source)
+        return time.perf_counter() - start
+
+
+def _bench_qdata_sync(codes: list[str], source: str) -> float:
+    """qdata_quote 同步耗时"""
+    from qdata_quote import QuoteService
+
+    service = QuoteService()
+    start = time.perf_counter()
+    service.get_real_sync(codes, source=source)
+    return time.perf_counter() - start
+
+
+def _print_result(name: str, elapsed: float, baseline: float | None = None):
+    suffix = ""
+    if baseline is not None and elapsed > 0:
+        suffix = f"  ({baseline / elapsed:.1f}x)"
+    print(f"  {name:<35s} {elapsed:.3f}s{suffix}")
+
+
+def run(codes: list[str] | None = None):
+    """运行基准测试
+
+    Args:
+        codes: 股票代码列表，为 None 时使用全市场代码
+    """
+    codes = codes or _load_stock_codes()
+    print(f"股票数量: {len(codes)}")
+    print()
+
+    # 新浪源对比
+    print("=== 新浪源 ===")
+    try:
+        baseline = _bench_easyquotation_sina(codes)
+        _print_result("easyquotation", baseline)
+    except Exception as e:
+        print(f"  easyquotation 失败: {e}")
+        baseline = None
+
+    sync_time = _bench_qdata_sync(codes, "sina")
+    _print_result("qdata_quote (sync)", sync_time, baseline)
+
+    async_time = asyncio.run(_bench_qdata_async(codes, "sina"))
+    _print_result("qdata_quote (async)", async_time, baseline)
+
+    # 腾讯源对比
+    print()
+    print("=== 腾讯源 ===")
+    try:
+        baseline_t = _bench_easyquotation_tencent(codes)
+        _print_result("easyquotation", baseline_t)
+    except Exception as e:
+        print(f"  easyquotation 失败: {e}")
+        baseline_t = None
+
+    sync_time_t = _bench_qdata_sync(codes, "tencent")
+    _print_result("qdata_quote (sync)", sync_time_t, baseline_t)
+
+    async_time_t = asyncio.run(_bench_qdata_async(codes, "tencent"))
+    _print_result("qdata_quote (async)", async_time_t, baseline_t)
+
+
+if __name__ == "__main__":
+    run()

qdata_quote/service.py

@@ -0,0 +1,139 @@
+"""行情服务主类"""
+
+from __future__ import annotations
+
+from typing import Literal
+
+import httpx
+import pandas as pd
+
+from qdata_quote.sources.sina import SinaSource
+from qdata_quote.sources.tencent import TencentSource
+from qdata_quote.types import add_prefix
+
+SourceName = Literal["sina", "tencent"]
+
+# 超时配置：连接 5 秒，读取 10 秒
+_TIMEOUT = httpx.Timeout(timeout=10.0, connect=5.0)
+
+
+class QuoteService:
+    """实时行情服务
+
+    支持新浪和腾讯两个数据源，提供异步和同步两套接口。
+    使用前通过 set_stock_codes 设置全市场股票代码列表。
+
+    用法:
+        service = QuoteService()
+        service.set_stock_codes(["000001", "600000", ...])
+
+        # 异步（高性能）
+        df = await service.get_real(["000001"])
+        df_all = await service.get_all()
+
+        # 同步（便捷）
+        df = service.get_real_sync(["000001"])
+        df_all = service.get_all_sync()
+    """
+
+    def __init__(self):
+        self._stock_codes: list[str] = []
+        self._sources = {
+            "sina": SinaSource(),
+            "tencent": TencentSource(),
+        }
+        self._async_client: httpx.AsyncClient | None = None
+        self._sync_client: httpx.Client | None = None
+        self._default_source: SourceName = "sina"
+
+    def set_stock_codes(self, codes: list[str]) -> None:
+        """设置全市场股票代码列表"""
+        self._stock_codes = codes
+
+    # --- 异步接口 ---
+
+    async def _get_async_client(self) -> httpx.AsyncClient:
+        """获取或创建异步客户端"""
+        if self._async_client is None or self._async_client.is_closed:
+            self._async_client = httpx.AsyncClient(timeout=_TIMEOUT)
+        return self._async_client
+
+    async def get_real(
+        self,
+        codes: list[str] | str,
+        source: SourceName | None = None,
+    ) -> pd.DataFrame:
+        """异步获取指定股票的实时行情
+
+        Args:
+            codes: 股票代码或代码列表，如 "000001" 或 ["000001", "600000"]
+            source: 数据源，"sina" 或 "tencent"，默认 "sina"
+
+        Returns:
+            统一格式的 DataFrame，index 为带前缀的股票代码
+        """
+        if isinstance(codes, str):
+            codes = [codes]
+        source = source or self._default_source
+        client = await self._get_async_client()
+        prefixed = [add_prefix(c) for c in codes]
+        return await self._sources[source].fetch(client, prefixed)
+
+    async def get_all(self, source: SourceName | None = None) -> pd.DataFrame:
+        """异步获取全市场行情快照"""
+        return await self.get_real(self._stock_codes, source)
+
+    async def close(self) -> None:
+        """关闭异步客户端"""
+        if self._async_client and not self._async_client.is_closed:
+            await self._async_client.aclose()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *args):
+        await self.close()
+
+    # --- 同步接口 ---
+
+    def _get_sync_client(self) -> httpx.Client:
+        """获取或创建同步客户端"""
+        if self._sync_client is None or self._sync_client.is_closed:
+            self._sync_client = httpx.Client(timeout=_TIMEOUT)
+        return self._sync_client
+
+    def get_real_sync(
+        self,
+        codes: list[str] | str,
+        source: SourceName | None = None,
+    ) -> pd.DataFrame:
+        """同步获取指定股票的实时行情
+
+        Args:
+            codes: 股票代码或代码列表
+            source: 数据源，"sina" 或 "tencent"，默认 "sina"
+
+        Returns:
+            统一格式的 DataFrame
+        """
+        if isinstance(codes, str):
+            codes = [codes]
+        source = source or self._default_source
+        client = self._get_sync_client()
+        prefixed = [add_prefix(c) for c in codes]
+        return self._sources[source].fetch_sync(client, prefixed)
+
+    def get_all_sync(self, source: SourceName | None = None) -> pd.DataFrame:
+        """同步获取全市场行情快照"""
+        return self.get_real_sync(self._stock_codes, source)
+
+    def close_sync(self) -> None:
+        """关闭同步客户端"""
+        if self._sync_client and not self._sync_client.is_closed:
+            self._sync_client.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close_sync()

qdata_quote/sources/base.py

@@ -0,0 +1,99 @@
+"""数据源抽象基类，封装分批并发请求逻辑"""
+
+from __future__ import annotations
+
+import abc
+import asyncio
+
+import httpx
+import pandas as pd
+
+from qdata_quote.types import empty_dataframe
+
+
+class BaseSource(abc.ABC):
+    """行情数据源基类
+
+    子类需实现 _build_url、_get_headers、_parse。
+    """
+
+    batch_size: int = 800
+
+    @abc.abstractmethod
+    def _build_url(self, prefixed_codes: list[str]) -> str:
+        """根据股票代码列表构建请求 URL"""
+
+    @abc.abstractmethod
+    def _get_headers(self) -> dict:
+        """返回请求头"""
+
+    @abc.abstractmethod
+    def _parse(self, text: str) -> pd.DataFrame:
+        """解析响应文本为统一格式的 DataFrame"""
+
+    def _split_batches(self, codes: list[str]) -> list[list[str]]:
+        """将代码列表按 batch_size 分批"""
+        if len(codes) <= self.batch_size:
+            return [codes]
+        return [
+            codes[i : i + self.batch_size]
+            for i in range(0, len(codes), self.batch_size)
+        ]
+
+    async def fetch(
+        self, client: httpx.AsyncClient, codes: list[str]
+    ) -> pd.DataFrame:
+        """异步获取指定股票行情"""
+        batches = self._split_batches(codes)
+        tasks = [self._fetch_batch_async(client, batch) for batch in batches]
+        results = await asyncio.gather(*tasks)
+        dfs = [df for df in results if df is not None and not df.empty]
+        if not dfs:
+            return empty_dataframe()
+        return pd.concat(dfs)
+
+    async def _fetch_batch_async(
+        self, client: httpx.AsyncClient, codes: list[str]
+    ) -> pd.DataFrame | None:
+        """异步获取单个批次，失败重试一次"""
+        url = self._build_url(codes)
+        headers = self._get_headers()
+        for attempt in range(2):
+            try:
+                response = await client.get(url, headers=headers)
+                return self._parse(response.text)
+            except Exception:
+                if attempt == 0:
+                    continue
+                return None
+        return None
+
+    def fetch_sync(
+        self, client: httpx.Client, codes: list[str]
+    ) -> pd.DataFrame:
+        """同步获取指定股票行情"""
+        batches = self._split_batches(codes)
+        dfs = []
+        for batch in batches:
+            df = self._fetch_batch_sync(client, batch)
+            if df is not None and not df.empty:
+                dfs.append(df)
+        if not dfs:
+            return empty_dataframe()
+        return pd.concat(dfs)
+
+    def _fetch_batch_sync(
+        self, client: httpx.Client, codes: list[str]
+    ) -> pd.DataFrame | None:
+        """同步获取单个批次，失败重试一次"""
+        url = self._build_url(codes)
+        headers = self._get_headers()
+        for attempt in range(2):
+            try:
+                response = client.get(url, headers=headers)
+                return self._parse(response.text)
+            except Exception:
+                if attempt == 0:
+                    continue
+                return None
+        return None

qdata_quote/sources/sina.py

@@ -0,0 +1,103 @@
+"""新浪行情数据源"""
+
+from __future__ import annotations
+
+import re
+import time
+
+import pandas as pd
+
+from qdata_quote.sources.base import BaseSource
+from qdata_quote.types import (
+    DATA_COLUMNS,
+    empty_dataframe,
+    safe_float,
+    safe_int,
+)
+
+
+class SinaSource(BaseSource):
+    """新浪免费行情源"""
+
+    # 匹配带前缀的股票代码和 29 个数值字段 + 2 个日期时间字段
+    _pattern = re.compile(
+        r"(\w{2}\d+)=[^\s]([^\s,]+?)"
+        + r",([\.\d]+)" * 29
+        + r",([-\.\d:]+)" * 2
+    )
+    _empty_pattern = re.compile(r'(\w{2}\d+)="";')
+
+    def _build_url(self, prefixed_codes: list[str]) -> str:
+        """构建请求 URL"""
+        codes_str = ",".join(prefixed_codes)
+        return f"http://hq.sinajs.cn/rn={int(time.time() * 1000)}&list={codes_str}"
+
+    def _get_headers(self) -> dict:
+        return {
+            "Referer": "http://finance.sina.com.cn/",
+            "User-Agent": (
+                "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+                "AppleWebKit/537.36 (KHTML, like Gecko) "
+                "Chrome/120.0.0.0 Safari/537.36"
+            ),
+        }
+
+    def _parse(self, text: str) -> pd.DataFrame:
+        """解析新浪行情响应，返回统一格式的 DataFrame"""
+        # 移除空数据行
+        text = self._empty_pattern.sub("", text)
+        text = text.replace(" ", "")
+
+        rows = []
+        for match in self._pattern.finditer(text):
+            g = match.groups()
+            try:
+                row = {
+                    "name": g[1],
+                    "open": safe_float(g[2]),
+                    "close": safe_float(g[3]),
+                    "now": safe_float(g[4]),
+                    "high": safe_float(g[5]),
+                    "low": safe_float(g[6]),
+                    "buy": safe_float(g[7]),
+                    "sell": safe_float(g[8]),
+                    "volume": safe_int(g[9]),
+                    "turnover": safe_float(g[10]),
+                    "bid1_volume": safe_int(g[11]),
+                    "bid1": safe_float(g[12]),
+                    "bid2_volume": safe_int(g[13]),
+                    "bid2": safe_float(g[14]),
+                    "bid3_volume": safe_int(g[15]),
+                    "bid3": safe_float(g[16]),
+                    "bid4_volume": safe_int(g[17]),
+                    "bid4": safe_float(g[18]),
+                    "bid5_volume": safe_int(g[19]),
+                    "bid5": safe_float(g[20]),
+                    "ask1_volume": safe_int(g[21]),
+                    "ask1": safe_float(g[22]),
+                    "ask2_volume": safe_int(g[23]),
+                    "ask2": safe_float(g[24]),
+                    "ask3_volume": safe_int(g[25]),
+                    "ask3": safe_float(g[26]),
+                    "ask4_volume": safe_int(g[27]),
+                    "ask4": safe_float(g[28]),
+                    "ask5_volume": safe_int(g[29]),
+                    "ask5": safe_float(g[30]),
+                    "datetime": f"{g[31]} {g[32]}",
+                }
+                rows.append((g[0], row))
+            except (IndexError, ValueError):
+                continue
+
+        if not rows:
+            return empty_dataframe()
+
+        codes, data = zip(*rows)
+        df = pd.DataFrame(list(data), index=list(codes))
+        df.index.name = "code"
+        # 确保所有统一列都存在（新浪缺失的字段自动为 NaN）
+        for col in DATA_COLUMNS:
+            if col not in df.columns:
+                df[col] = float("nan")
+        df = df[DATA_COLUMNS]
+        return df

qdata_quote/sources/tencent.py

@@ -0,0 +1,122 @@
+"""腾讯行情数据源"""
+
+from __future__ import annotations
+
+import re
+
+import pandas as pd
+
+from qdata_quote.sources.base import BaseSource
+from qdata_quote.types import (
+    DATA_COLUMNS,
+    empty_dataframe,
+    safe_float,
+    safe_int,
+)
+
+
+class TencentSource(BaseSource):
+    """腾讯免费行情源"""
+
+    batch_size: int = 200
+
+    _code_pattern = re.compile(r"(?<=_)\w+")
+
+    def _build_url(self, prefixed_codes: list[str]) -> str:
+        """构建请求 URL"""
+        codes_str = ",".join(prefixed_codes)
+        return f"http://qt.gtimg.cn/q={codes_str}"
+
+    def _get_headers(self) -> dict:
+        return {
+            "User-Agent": (
+                "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+                "AppleWebKit/537.36 (KHTML, like Gecko) "
+                "Chrome/120.0.0.0 Safari/537.36"
+            ),
+        }
+
+    def _parse(self, text: str) -> pd.DataFrame:
+        """解析腾讯行情响应，返回统一格式的 DataFrame"""
+        rows = []
+        for segment in text.split(";"):
+            segment = segment.strip().rstrip('"')
+            if not segment:
+                continue
+            fields = segment.split("~")
+            if len(fields) <= 49:
+                continue
+            try:
+                # 从 v_sh600000="1 中提取带前缀的代码
+                code_match = self._code_pattern.search(fields[0])
+                if not code_match:
+                    continue
+                code = code_match.group()
+
+                row = {
+                    "name": fields[1],
+                    "open": safe_float(fields[5]),
+                    "close": safe_float(fields[4]),
+                    "now": safe_float(fields[3]),
+                    "high": safe_float(fields[33]),
+                    "low": safe_float(fields[34]),
+                    "volume": safe_int(fields[6]) * 100,  # 手 → 股
+                    "turnover": safe_float(fields[37]) * 10000,  # 万 → 元
+                    "bid1": safe_float(fields[9]),
+                    "bid1_volume": safe_int(fields[10]) * 100,
+                    "bid2": safe_float(fields[11]),
+                    "bid2_volume": safe_int(fields[12]) * 100,
+                    "bid3": safe_float(fields[13]),
+                    "bid3_volume": safe_int(fields[14]) * 100,
+                    "bid4": safe_float(fields[15]),
+                    "bid4_volume": safe_int(fields[16]) * 100,
+                    "bid5": safe_float(fields[17]),
+                    "bid5_volume": safe_int(fields[18]) * 100,
+                    "ask1": safe_float(fields[19]),
+                    "ask1_volume": safe_int(fields[20]) * 100,
+                    "ask2": safe_float(fields[21]),
+                    "ask2_volume": safe_int(fields[22]) * 100,
+                    "ask3": safe_float(fields[23]),
+                    "ask3_volume": safe_int(fields[24]) * 100,
+                    "ask4": safe_float(fields[25]),
+                    "ask4_volume": safe_int(fields[26]) * 100,
+                    "ask5": safe_float(fields[27]),
+                    "ask5_volume": safe_int(fields[28]) * 100,
+                    "datetime": fields[30],
+                    "change": safe_float(fields[31]),
+                    "change_pct": safe_float(fields[32]),
+                    "amplitude": safe_float(fields[43]),
+                    "pe_dynamic": _safe_float_at(fields, 52),
+                    "pe_static": _safe_float_at(fields, 53),
+                    "pb": safe_float(fields[46]),
+                    "total_market_cap": safe_float(fields[45]),
+                    "circulating_market_cap": safe_float(fields[44]),
+                    "volume_ratio": _safe_float_at(fields, 49),
+                    "bid_ask_ratio": _safe_float_at(fields, 50),
+                    "avg_price": _safe_float_at(fields, 51),
+                    "limit_up": safe_float(fields[47]),
+                    "limit_down": safe_float(fields[48]),
+                }
+                rows.append((code, row))
+            except (IndexError, ValueError):
+                continue
+
+        if not rows:
+            return empty_dataframe()
+
+        codes, data = zip(*rows)
+        df = pd.DataFrame(list(data), index=list(codes))
+        df.index.name = "code"
+        for col in DATA_COLUMNS:
+            if col not in df.columns:
+                df[col] = float("nan")
+        df = df[DATA_COLUMNS]
+        return df
+
+
+def _safe_float_at(fields: list[str], index: int) -> float:
+    """安全获取指定索引的浮点值，越界返回 NaN"""
+    try:
+        return safe_float(fields[index])
+    except IndexError:
+        return float("nan")

qdata_quote/types.py

@@ -0,0 +1,100 @@
+"""统一字段定义与工具函数"""
+
+from __future__ import annotations
+
+import pandas as pd
+
+# 统一 DataFrame 列定义（code 作为 index，不在 columns 中）
+UNIFIED_COLUMNS = [
+    "code",
+    "name",
+    "open",
+    "close",
+    "now",
+    "high",
+    "low",
+    "buy",
+    "sell",
+    "volume",
+    "turnover",
+    "bid1",
+    "bid2",
+    "bid3",
+    "bid4",
+    "bid5",
+    "bid1_volume",
+    "bid2_volume",
+    "bid3_volume",
+    "bid4_volume",
+    "bid5_volume",
+    "ask1",
+    "ask2",
+    "ask3",
+    "ask4",
+    "ask5",
+    "ask1_volume",
+    "ask2_volume",
+    "ask3_volume",
+    "ask4_volume",
+    "ask5_volume",
+    "datetime",
+    "change",
+    "change_pct",
+    "amplitude",
+    "pe_dynamic",
+    "pe_static",
+    "pb",
+    "total_market_cap",
+    "circulating_market_cap",
+    "volume_ratio",
+    "bid_ask_ratio",
+    "avg_price",
+    "limit_up",
+    "limit_down",
+]
+
+# DataFrame 的数据列（不含 code，因为 code 是 index）
+DATA_COLUMNS = UNIFIED_COLUMNS[1:]
+
+
+def safe_float(value: str) -> float:
+    """安全转换为 float，失败返回 NaN"""
+    try:
+        return float(value)
+    except (ValueError, TypeError):
+        return float("nan")
+
+
+def safe_int(value: str) -> float:
+    """安全转换为 int，失败返回 NaN（用 float 承载以支持 NaN）"""
+    try:
+        return int(value)
+    except (ValueError, TypeError):
+        return float("nan")
+
+
+def get_stock_prefix(code: str) -> str:
+    """根据股票代码判断市场前缀 (sh/sz/bj)"""
+    bj_head = ("43", "83", "87", "92")
+    sh_head = ("5", "6", "7", "9", "110", "113", "118", "132", "204")
+    if code.startswith(("sh", "sz", "bj")):
+        return code[:2]
+    if code.startswith(bj_head):
+        return "bj"
+    if code.startswith(sh_head):
+        return "sh"
+    return "sz"
+
+
+def add_prefix(code: str) -> str:
+    """为股票代码添加市场前缀"""
+    prefix = get_stock_prefix(code)
+    pure = code[-6:] if code.startswith(("sh", "sz", "bj")) else code
+    return f"{prefix}{pure}"
+
+
+def empty_dataframe() -> pd.DataFrame:
+    """返回带统一列结构的空 DataFrame"""
+    df = pd.DataFrame(columns=DATA_COLUMNS)
+    df.index.name = "code"
+    return df

qdata_quote-0.1.0.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: qdata-quote
+Version: 0.1.0
+Summary: 实时行情采集服务，支持新浪和腾讯数据源
+License-Expression: MIT
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: pandas>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# qdata-quote
+
+实时行情采集服务，支持新浪和腾讯数据源。

qdata_quote-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+qdata_quote/__init__.py,sha256=XyZmOoiDQYPsv-rZw7MlKAh5wc7UiST0DZpDIiMoEe8,62
+qdata_quote/bench.py,sha256=H4HcRXT2nhyYuccBDzYXucnHyAU-Lz_f4hZDtsw8KHY,3153
+qdata_quote/service.py,sha256=_LA3dgYcrZhE7DQmIb7WWN7gJ0ZRl4u-npvMGT9Fydg,4390
+qdata_quote/types.py,sha256=pvgN1kZ6kIQSs8yOUCY7LYUXRVAo5EyLLxbmluGEGoU,2199
+qdata_quote/sources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qdata_quote/sources/base.py,sha256=fpERTmDaI3nOcP9m25vZJX7VFBHekLF-TZWPCyRaRsI,3082
+qdata_quote/sources/sina.py,sha256=rOU_BxWtSo7w8vVxR4ywIPjHVS5e4-UHFfcHRZ3-jsI,3563
+qdata_quote/sources/tencent.py,sha256=HpNdsYaqPWPz8fKSMVM_ysahJ7Px6R83bII6GAWj7to,4628
+qdata_quote-0.1.0.dist-info/METADATA,sha256=U86WYdvZd7NddhKk6BhSOBvQRsU3EOTlIsnzJAcQtxQ,456
+qdata_quote-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+qdata_quote-0.1.0.dist-info/RECORD,,

qdata_quote-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any