bigarraylist 0.2.0__py3-none-any.whl

bigarraylist/utils/scale.py

@@ -0,0 +1,139 @@
+"""量级判定 + 分块大小（简化版，去掉 ScaleValue 多层包装）。
+
+向后兼容：保留 ScaleHelper / ScaleValue / chunk_wise_processing /
+choose_chunk_size / choose_external_sort_chunk_size 全部公开符号，
+调用方零改动。内部只是把冗余的 ScaleValue 包装换成 int 常量。
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Iterator
+from typing import Final, TypeVar
+
+T = TypeVar("T")
+
+# ==================== 量级档位常量（int，去掉 ScaleValue 包装） ====================
+HUNDRED_THOUSAND: Final[int] = 100_000
+MILLION: Final[int] = 1_000_000
+TEN_MILLION: Final[int] = 10_000_000
+HUNDRED_MILLION: Final[int] = 100_000_000
+
+# 数据量 → 分块大小 映射表（每个 chunk 100~1000 条）
+# 数据量越大，分块越大：减少块数、摊薄调度开销；但不超过 1000，保证单块内存可控
+_CHUNK_SIZE_MAP: dict[int, int] = {
+    HUNDRED_THOUSAND: 100,
+    MILLION: 300,
+    TEN_MILLION: 800,
+    HUNDRED_MILLION: 1_000,
+}
+
+
+class ScaleValue:
+    """纯数据载体：保存一个数据量级的数值。
+
+    向后兼容保留——重构前公开 API 之一，外部代码可能直接 import 使用。
+    重构后已不再被内部使用，仅作为对外符号保留。
+    """
+
+    def __init__(self, value: int) -> None:
+        self._value: Final[int] = value
+
+    @property
+    def value(self) -> int:
+        return self._value
+
+    def __repr__(self) -> str:
+        return f"ScaleValue({self._value})"
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, ScaleValue) and self._value == other._value
+
+    def __hash__(self) -> int:
+        return hash(self._value)
+
+
+class ScaleHelper:
+    """数据量级助手。
+
+    向后兼容保留——重构前公开 API 之一。内部不再使用本类，
+    所有阈值改走 BigArrayConfig + 直接 int 常量。本类仅薄包装。
+    """
+
+    HUNDRED_THOUSAND = ScaleValue(HUNDRED_THOUSAND)
+    MILLION = ScaleValue(MILLION)
+    TEN_MILLION = ScaleValue(TEN_MILLION)
+    HUNDRED_MILLION = ScaleValue(HUNDRED_MILLION)
+
+    def __init__(self, value: int) -> None:
+        self.value = value
+
+    @staticmethod
+    def get_scale(total_count: int) -> ScaleValue:
+        """根据总条数返回对应量级对象。"""
+        if total_count >= HUNDRED_MILLION:
+            return ScaleHelper.HUNDRED_MILLION
+        if total_count >= TEN_MILLION:
+            return ScaleHelper.TEN_MILLION
+        if total_count >= MILLION:
+            return ScaleHelper.MILLION
+        if total_count >= HUNDRED_THOUSAND:
+            return ScaleHelper.HUNDRED_THOUSAND
+        raise ValueError(f"数据量 {total_count}，小于十万级阈值 {HUNDRED_THOUSAND}")
+
+    def __str__(self) -> str:
+        v = self.value
+        if v >= HUNDRED_MILLION:
+            tag = "HUNDRED_MILLION"
+        elif v >= TEN_MILLION:
+            tag = "TEN_MILLION"
+        elif v >= MILLION:
+            tag = "MILLION"
+        elif v >= HUNDRED_THOUSAND:
+            tag = "HUNDRED_THOUSAND"
+        else:
+            raise ValueError(f"数据量 {v}，小于十万级阈值 {HUNDRED_THOUSAND}")
+        return f"{self.__class__.__name__}({tag})"
+
+
+def chunk_wise_processing(iterable: Iterable[T]) -> Iterator[list[T]]:
+    """按 choose_chunk_size 选择的大小分块产出。
+
+    返回：迭代器，每一项是一个 list[T]（单块，长度 <= chunk_size）。
+    要求 iterable 有 __len__；没有的请先过 list(...)。
+    """
+    total = len(iterable)  # type: ignore[arg-type]
+    chunk_size = choose_chunk_size(total)
+
+    it = iter(iterable)
+    while True:
+        chunk: list[T] = []
+        for _ in range(chunk_size):
+            try:
+                chunk.append(next(it))
+            except StopIteration:
+                break
+        if not chunk:
+            return
+        yield chunk
+
+
+def choose_chunk_size(total_count: int) -> int:
+    """根据总条数选择分块大小（100~1000）。"""
+    scale = ScaleHelper.get_scale(total_count)
+    return _CHUNK_SIZE_MAP[scale.value]
+
+
+def choose_external_sort_chunk_size(
+    total_count: int,
+    *,
+    target: int = 32,
+    min_chunk: int = 100_000,
+    max_chunk: int = 5_000_000,
+) -> int:
+    """外部排序分块大小。
+
+    默认参数对齐重构前行为（目标 32 块，单块 100k~5M）。
+    新增 target/min_chunk/max_chunk 形参，支持通过 BigArrayConfig 覆盖。
+    """
+    chunk_size = total_count // target
+    return max(min_chunk, min(max_chunk, chunk_size))

bigarraylist/utils/validation.py

@@ -0,0 +1,171 @@
+"""参数校验工具：所有校验在调用时立即执行（参数非法立刻抛错，不等迭代）。
+
+向后兼容：默认仍抛 TypeError / IndexError / ValueError；
+当 raise_big_array_list_error=True 时改抛自定义异常子类（仍继承对应标准异常）。
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+from ..exceptions import (
+    DataSourceError,
+    IndexOutOfRangeError,
+    InvalidArgumentError,
+)
+
+
+def _raise(
+    err_cls: type[Exception],
+    std_cls: type[Exception],
+    msg: str,
+    use_custom: bool,
+) -> None:
+    """统一抛错：use_custom=True 走自定义异常（仍继承标准异常），
+    False 抛标准异常保持向后兼容。"""
+    if use_custom:
+        raise err_cls(msg) from None
+    raise std_cls(msg) from None
+
+
+def validate_index(name: str, value: object, length: int, *, use_custom: bool = False) -> None:
+    """校验单个索引参数：必须是 int（排除 bool）、范围 [0, length]。"""
+    if isinstance(value, bool) or not isinstance(value, int):
+        _raise(
+            InvalidArgumentError,
+            TypeError,
+            f"{name} 必须是整数，得到 {type(value).__name__}",
+            use_custom,
+        )
+    elif value < 0 or value > length:
+        _raise(
+            IndexOutOfRangeError,
+            IndexError,
+            f"{name}={value} 越界，有效范围 [0, {length}]",
+            use_custom,
+        )
+
+
+def validate_range(
+    start: int,
+    end: int,
+    length: int,
+    *,
+    use_custom: bool = False,
+) -> None:
+    """校验 [start, end) 区间：类型对、0 <= start <= end <= length。"""
+    validate_index("start", start, length, use_custom=use_custom)
+    validate_index("end", end, length, use_custom=use_custom)
+    if start > end:
+        _raise(
+            InvalidArgumentError,
+            ValueError,
+            f"start={start} 不能大于 end={end}",
+            use_custom,
+        )
+
+
+def validate_max_workers(value: int | None, *, use_custom: bool = False) -> None:
+    """校验 max_workers：None 或正整数（排除 bool）。"""
+    if value is None:
+        return
+    if isinstance(value, bool) or not isinstance(value, int):
+        _raise(
+            InvalidArgumentError,
+            TypeError,
+            f"max_workers 必须是正整数或 None，得到 {type(value).__name__}",
+            use_custom,
+        )
+    elif value < 1:
+        _raise(
+            InvalidArgumentError,
+            ValueError,
+            f"max_workers 必须 >= 1，得到 {value}",
+            use_custom,
+        )
+
+
+def validate_num_buckets(value: int | None, *, use_custom: bool = False) -> None:
+    """校验 num_buckets：None 或正整数（排除 bool）。"""
+    if value is None:
+        return
+    if isinstance(value, bool) or not isinstance(value, int):
+        _raise(
+            InvalidArgumentError,
+            TypeError,
+            f"num_buckets 必须是正整数或 None，得到 {type(value).__name__}",
+            use_custom,
+        )
+    elif value < 1:
+        _raise(
+            InvalidArgumentError,
+            ValueError,
+            f"num_buckets 必须 >= 1，得到 {value}",
+            use_custom,
+        )
+
+
+def validate_sample_k(value: int, *, use_custom: bool = False) -> None:
+    """校验 sample 的 k：正整数（排除 bool）。"""
+    if isinstance(value, bool) or not isinstance(value, int):
+        _raise(
+            InvalidArgumentError,
+            TypeError,
+            f"k 必须是正整数，得到 {type(value).__name__}",
+            use_custom,
+        )
+    elif value < 1:
+        _raise(
+            InvalidArgumentError,
+            ValueError,
+            f"k 必须 >= 1，得到 {value}",
+            use_custom,
+        )
+
+
+def validate_slice_arg(name: str, value: int | None, *, use_custom: bool = False) -> None:
+    """校验 slice 的 start/stop/step 参数。
+
+    - 允许 None（表示"不限制"）
+    - 不允许负数（惰性流无法反向、无法预知总长倒数）
+    - bool 排除（语义不该当索引用）
+    """
+    if value is None:
+        return
+    if isinstance(value, bool) or not isinstance(value, int):
+        _raise(
+            InvalidArgumentError,
+            TypeError,
+            f"{name} 必须是整数或 None，得到 {type(value).__name__}",
+            use_custom,
+        )
+    elif value < 0:
+        _raise(
+            InvalidArgumentError,
+            ValueError,
+            f"{name}={value} 不允许为负数（惰性流不支持反向切片）",
+            use_custom,
+        )
+
+
+def validate_callable(name: str, value: object, *, use_custom: bool = False) -> None:
+    """校验一个参数必须可调用（callable）。None 不视为 callable。"""
+    if not callable(value):
+        _raise(
+            InvalidArgumentError,
+            TypeError,
+            f"{name} 必须是可调用对象（函数/lambda/可调用类实例），得到 {type(value).__name__}",
+            use_custom,
+        )
+
+
+def validate_iterable(name: str, value: object, *, use_custom: bool = False) -> None:
+    """校验一个参数必须是可迭代对象（Iterable）。"""
+    if isinstance(value, Iterable):
+        return
+    _raise(
+        DataSourceError,
+        TypeError,
+        f"{name} 必须是可迭代对象（Iterable），得到 {type(value).__name__}",
+        use_custom,
+    )

bigarraylist-0.2.0.dist-info/METADATA

@@ -0,0 +1,158 @@
+Metadata-Version: 2.4
+Name: bigarraylist
+Version: 0.2.0
+Summary: 面向大数据量场景的惰性流式列表：惰性迭代 / 并行查找 / 分块排序 / 外部排序 / 蓄水池抽样 / 二级索引
+Author: PyBigArrayListObject
+License-Expression: MIT
+Keywords: big-data,lazy-stream,parallel,external-sort,generator
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4; extra == "dev"
+Requires-Dist: pytest-cov>=4.1; extra == "dev"
+Requires-Dist: ruff>=0.5; extra == "dev"
+Requires-Dist: mypy>=1.8; extra == "dev"
+Requires-Dist: pre-commit>=3.6; extra == "dev"
+Dynamic: license-file
+
+# BigArrayList
+
+> 面向大数据量场景的惰性流式列表：惰性迭代 / 并行查找 / 分块排序 / 低内存外部排序 /
+> 持久化分桶 / 蓄水池抽样 / 二级索引 / 链式算子。
+
+零第三方运行时依赖（只用标准库）。核心思想是**惰性流**——数据不一次性物化进内存，
+算子组合、按需产出，从而在内存可控的前提下处理远超内存的数据量。
+
+> 版本：0.2.0（重构为四层包结构 + 链式 API + 低内存外部排序 + 持久化分桶；
+> 旧 API 100% 向后兼容）
+
+## 安装
+
+开发环境（含测试 + 质量工具）：
+
+```bash
+pip install -e ".[dev]"
+```
+
+仅需运行时则零依赖，直接 `import` 即可。
+
+## 快速开始
+
+```python
+from bigarraylist import BigArrayList
+
+arr = BigArrayList([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 1])
+
+# 1) 惰性排序（生成器，按需产出）
+top3 = list(__import__("itertools").islice(arr.sort(), 3))   # [1, 1, 3]
+
+# 2) 线性并行查找（返回 (下标, 值)，惰性、可早停）
+for idx, val in arr.find(5):
+    print(idx, val)   # 4 5 / 8 5 / 10 5
+
+# 3) 链式 API（新）：.lazy() 进入 LazyChain，每个算子返回新 LazyChain
+result = (arr.lazy()
+             .filter(lambda x: x > 2)
+             .map(lambda x: x * 10)
+             .distinct()
+             .slice(0, 5)
+             .collect())           # [30, 40, 90, 60, 50]
+
+# 4) 持久化分桶（新）：建桶一次，多次 find 复用，O(n/N) 每次查询
+with arr.build_buckets() as idx:
+    for tgt in [3, 5, 9]:
+        hits = list(idx.find(tgt))
+        print(tgt, hits)
+```
+
+## 特性
+
+| 能力 | 方法 | 说明 |
+| --- | --- | --- |
+| 惰性迭代 | `__next__` / `cycle` | 标准协议耗尽即停；`.cycle()` 无限循环 |
+| 增删改插 | `append` / `remove` / `replace` / `insert` | 全惰性、不物化 |
+| 线性查找 | `find` | 多进程分块并行，惰性、可早停 |
+| 二分查找 | `binary_search` | 先排序后 bisect，返回排序后下标 |
+| 分桶查找（一次性） | `bucket_find` | 哈希分桶 + 单桶扫描，每次重建桶 |
+| **持久化分桶（新）** | `build_buckets` | 建桶一次返回 `BucketIndex`，多次 `find` 复用 |
+| 蓄水池抽样 | `sample` | O(k) 内存，无需预知总量 |
+| 二级索引 | `build_index` | `dict[key] -> list[下标]`，O(1) 判定 |
+| 统一查找 | `auto_find` | 按数据量自动选线性 / 分桶 |
+| 排序 | `sort` | 三级分流：<10w 直排 / 10w~100w 内存多进程 / ≥100w 外部排序 |
+| 流式算子（裸生成器） | `map`/`filter`/`reduce`/`slice`/`distinct`/`concat`/`chain`/`group_by`/`count_if` | 全惰性、非物化，向后兼容 |
+| **链式算子（新）** | `.lazy()` → `LazyChain` | `.filter().map().distinct().collect()` 链式组合 |
+| **配置对象（新）** | `BigArrayConfig` | 所有阈值可调，外部排序模式 / 桶上限 / 并行阈值 |
+| **自定义异常（新）** | `exceptions` | 继承标准异常，向后兼容；`raise_custom=True` 启用 |
+
+## 项目结构
+
+```
+PyBigArrayListObject/
+├── bigarraylist/                # 包
+│   ├── __init__.py              # 暴露公共 API
+│   ├── _api.py                  # BigArrayList 用户接口层（参数校验）
+│   ├── config.py                # BigArrayConfig（所有阈值可配置）
+│   ├── exceptions.py            # 自定义异常层次（继承标准异常）
+│   ├── core/
+│   │   └── base.py              # _CoreBase(__slots__+迭代协议+_fresh_iter)
+│   │                            #   + BaseBigArrayList(组合各 mixin)
+│   ├── operators/               # 算子 mixin 层
+│   │   ├── crud.py              #   append/remove/replace/insert
+│   │   ├── search.py            #   find/binary_search/bucket_find/build_buckets
+│   │   ├── sort.py              #   sort/is_sorted
+│   │   └── stream.py            #   map/filter/.../count_if + LazyChain
+│   ├── algorithms/              # 算法实现层（可独立调用）
+│   │   ├── parallel.py          #   模块级可 pickle 函数（子进程安全）
+│   │   ├── external_sort.py     #   低内存外部排序（streaming/block 两种）
+│   │   ├── bucket.py            #   BucketIndex + build_buckets 持久化分桶
+│   │   └── sample.py            #   蓄水池抽样
+│   └── utils/
+│       ├── scale.py             # ScaleHelper/choose_chunk_size/...
+│       └── validation.py        # 参数校验（标准异常 or 自定义异常切换）
+├── tests/                       # pytest 套件（test_core/test_api/test_scale + conftest）
+├── docs/                        # 架构说明 / API 参考
+├── examples/                    # 使用示例
+├── pyproject.toml               # 项目配置 + ruff/mypy/pytest/coverage
+├── .pre-commit-config.yaml
+└── README.md
+```
+
+## 质量工具
+
+```bash
+pytest                          # 跑测试（46 个）
+ruff check bigarraylist tests   # Lint
+ruff format bigarraylist tests  # 格式化
+mypy bigarraylist               # 静态类型检查（moderate，见 pyproject 注释）
+pytest --cov=bigarraylist       # 覆盖率
+pre-commit run --all-files      # 提交前检查
+```
+
+## 设计要点
+
+- **`_fresh_iter()`**：所有算子统一通过它拿一份**独立**的局部迭代器，全程操作局部变量，
+  绝不碰 `self.__data`——算子调用零副作用、可重复调用。
+- **三级排序分流**：按数据量选 `sorted()` / 内存多进程分块 / 外部排序，兼顾速度与内存。
+- **低内存外部排序（新）**：默认 streaming 模式——阶段 1 逐条 `pickle.dump` 落盘，
+  阶段 2 每个文件用 lazy 迭代器逐条 `pickle.load`，`heapq.merge` 同时驱动。
+  内存峰值 = O(块数) 文件句柄 + O(块数) 临时元素（≈ 32），**真正符合"外部排序"语义**，
+  能处理远超内存的数据。需要快 3~5 倍但内存放得下时，设
+  `BigArrayConfig(external_sort_streaming_merge=False)` 走整块模式。
+- **cooperative multiple inheritance**：`BaseBigArrayList` 多继承 `_CoreBase + CRUDMixin +
+  StreamMixin + SortMixin + SearchMixin` 组合各算子；mixin 不声明字段，通过
+  `self._fresh_iter()` / `len(self)` / `self._get_config()` 与核心协作，避免 `__slots__`
+  多继承冲突与 name mangling 问题。
+- **不支持随机访问 `[]`**：与惰性流设计冲突；要第 N 个用 `itertools.islice` 流式跳过。
+
+详见 [docs/architecture.md](docs/architecture.md) 与 [docs/api_reference.md](docs/api_reference.md)。
+
+## License
+
+MIT

bigarraylist-0.2.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+bigarraylist/__init__.py,sha256=vFWbpR-42gWGG-DV2JY_4o6tpag5Ih0bEC0rL7DKWwE,2063
+bigarraylist/_api.py,sha256=dFyJHI09RH7BueqgfvB-XKFeE-5SB_EoxgqmuCsoOX4,20038
+bigarraylist/config.py,sha256=LadYURM1ySyh2Jq5hkIeGaOdWo_vOnU-i6DqAuwY_Is,3163
+bigarraylist/exceptions.py,sha256=iVcGWTJd_hpRI8W05Yf1gUL6XzcVDs5AdF5yoHhznQE,1713
+bigarraylist/algorithms/__init__.py,sha256=X4BC419GWVvVh31ExBGUNNu_wGwcui2zj3EciLtsYo0,537
+bigarraylist/algorithms/bucket.py,sha256=JOikFaVPPVbbyAq0rnv7kNBbG7I_HhXW6Xzit4tJDGg,6701
+bigarraylist/algorithms/external_sort.py,sha256=2vhlYhHJVEgVJPqPZ6pnIX5RgRMRc-dzQ81T8d4IR5s,8491
+bigarraylist/algorithms/parallel.py,sha256=fbf44swcYSEyhKT049q0mhhv5vn4qrVoRHLJBSt2tKk,2571
+bigarraylist/algorithms/sample.py,sha256=vD6XlCbWJpg88wG6c4ygCr2bZqEJqPfJ27BWekV5WPk,1699
+bigarraylist/core/__init__.py,sha256=0FRAGry5jGGlevtRxEw5uiMNLnBHgDBxHA0JQsoirN0,141
+bigarraylist/core/base.py,sha256=i-HhvanimUw_u0I12onl2S8Zx92sl6ed61XA2L0OiVA,9836
+bigarraylist/operators/__init__.py,sha256=5eVkoxDe2T6dedf6PyeBzgY_SQbTMn5c4msWwQyuoCI,302
+bigarraylist/operators/crud.py,sha256=g2V1XT14JKFm7mI3ps--PsVswa_zwe69aqhb7GIc26M,3094
+bigarraylist/operators/search.py,sha256=PmmJQw0QCbMh_jBTvxh-Pk8zdBuKl30jRJyvNU8Id7w,8296
+bigarraylist/operators/sort.py,sha256=jr1HNQ9WztF4XbWoQYETGJIGrSqWoNFKlYzIDXrX9zg,8628
+bigarraylist/operators/stream.py,sha256=AheXVF7mgmWIDpx8v53cZQaawGEf6InEOp3UvaTe0HU,13661
+bigarraylist/utils/__init__.py,sha256=LhSS09XW2qEmh4zFVglyHZVtW0_6pcKaLmCMxuiE1ls,932
+bigarraylist/utils/scale.py,sha256=ozrZedlyVYpam0CdsBLRH6POKz_SDwPru6AIKuTE8wg,4540
+bigarraylist/utils/validation.py,sha256=3eRbgnz1PStI0NWB40w4JhdrrbrLoWdfA_26zxNcWzY,5395
+bigarraylist-0.2.0.dist-info/licenses/LICENSE,sha256=2NnL9V_jfGVWPoNFTOlffbBI92nwaTm8lFy0wvo5quw,1077
+bigarraylist-0.2.0.dist-info/METADATA,sha256=3ux7qvfxM7RFM6WJOTHJmcjA1yNAP7zSLuTZlGWBo8Q,7831
+bigarraylist-0.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+bigarraylist-0.2.0.dist-info/top_level.txt,sha256=y-BkL-WF_RaACC5vL1eKE4MkGOPf4KgACElN5hIYreg,13
+bigarraylist-0.2.0.dist-info/RECORD,,

bigarraylist-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

bigarraylist-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PyBigArrayListObject
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bigarraylist-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+bigarraylist