Được TopGit lập chỉ mục từ metadata GitHub: ranaroussi/pystore có 612 sao, viết chủ yếu bằng Python. Fast data store for Pandas time-series data
Tóm tắt dựng từ metadata GitHub của chính dự án — chưa có bài review TopGit. Trang sẽ tự động cập nhật khi bài review đầy đủ được xuất bản.
VÌ SAO CHƯA CÓ REVIEW
TopGit viết bài đầy đủ cho repo có nhiều sao nhất và được yêu cầu nhiều nhất. Trang này là snapshot trong thời gian chờ — xem README gốc ở tab READ ME.
PyStore - Fast data store for Pandas timeseries data
PyStore is a simple (yet powerful) datastore for Pandas dataframes, and while it can store any Pandas object, it was designed with storing timeseries data in mind.
It's built on top of Pandas, Numpy, Dask, and Parquet (via pyarrow), to provide an easy to use datastore for Python developers that can easily query millions of rows per second per client.
New in 2025 Release (PR #77):
MultiIndex Support - Store and retrieve DataFrames with Pandas MultiIndex
Complex Data Types - Full support for Timedelta, Period, Interval, Categorical dtypes
Timezone-Aware Operations - Proper handling of timezone data with UTC storage
Async/Await Support - Non-blocking I/O operations for better performance
Data Validation Framework - Extensible validation rules for data integrity
Schema Evolution - Handle schema changes over time with flexible strategies
Transaction Support - Atomic operations with rollback capabilities
Performance Optimizations - Streaming operations and memory management
Performance Enhancements (Phase 3 Release):
Streaming Operations - Memory-efficient append for datasets larger than RAM
Intelligent Partitioning - Automatic time-based and size-based partitioning
Memory Management - 70-90% memory reduction with monitoring and optimization
Metadata Caching - 100x faster metadata access with TTL cache
Query Optimization - Column selection and predicate pushdown at storage level
Performance improvements include:
Append 1M rows: 3.75x faster, 90% less memory
Batch operations: 6x faster for multiple items
Column selection: 4x faster when reading subset of columns
Filtered reads: 8x faster with predicate pushdown
Check out this blog post for the reasoning and philosophy behind PyStore, as well as a detailed tutorial with code examples.
Follow this PyStore tutorial in Jupyter notebook format.
Quickstart
Install PyStore
Install using pip:
pip install pystore --upgrade --no-cache-dir
Install using conda:
conda install -c ranaroussi pystore
INSTALLATION NOTE:
If you don't have Snappy installed (compression/decompression library), you'll need to install it first.
Using PyStore
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import pystore
import yfinance as yf
# Set storage path (optional)
# Defaults to `~/pystore` or `PYSTORE_PATH` environment variable (if set)
pystore.set_path("~/pystore")
# List stores
pystore.list_stores()
# Connect to datastore (create it if not exist)
store = pystore.store("mydatastore")
# List existing collections
store.list_collections()
# Access a collection (create it if not exist)
collection = store.collection("NASDAQ")
# List items in collection
collection.list_items()
# Load some data from yfinance
aapl = yf.download("AAPL", multi_level_index=False)
# Store the first 100 rows of the data in the collection under "AAPL"
collection.write("AAPL", aapl[:100], metadata={"source": "yfinance"})
# Reading the item's data
item = collection.item("AAPL")
data = item.data # <-- Dask dataframe (see dask.pydata.org)
metadata = item.metadata
df = item.to_pandas()
# Append the rest of the rows to the "AAPL" item
collection.append("AAPL", aapl[100:])
# Reading the item's data
item = collection.item("AAPL")
data = item.data
metadata = item.metadata
df = item.to_pandas()
# --- Query functionality ---
# Query available symbols based on metadata
collection.list_items(some_key="some_value", other_key="other_value")
# --- Snapshot functionality ---
# Snapshot a collection
# (Point-in-time named reference for all current symbols in a collection)
collection.create_snapshot("snapshot_name")
# List available snapshots
collection.list_snapshots()
# Get a version of a symbol given a snapshot name
collection.item("AAPL", snapshot="snapshot_name")
# Delete a collection snapshot
collection.delete_snapshot("snapshot_name")
# ...
# Delete the item from the current version
collection.delete_item("AAPL")
# Delete the collection
store.delete_collection("NASDAQ")
Advanced Features
Async Operations:
import asyncio
from pystore import async_pystore
async def async_example():
async with async_pystore.store("mydatastore") as store:
async with store.collection("NASDAQ") as collection:
# Async write
await collection.write("AAPL", df)
# Async read
df = await collection.item("AAPL").to_pandas()
asyncio.run(async_example())
Data Validation:
from pystore import create_validator, ColumnExistsRule, RangeRule
# Create a validator
validator = create_validator([
ColumnExistsRule(["Open", "High", "Low", "Close"]),
RangeRule("Close", min_value=0),
])
# Apply validator to collection
collection.set_validator(validator)
Schema Evolution:
from pystore import SchemaEvolution, EvolutionStrategy
# Enable schema evolution
evolution = collection.enable_schema_evolution(
"AAPL",
strategy=EvolutionStrategy.FLEXIBLE,
)
# Schema changes are handled automatically during append
collection.append("AAPL", new_data_with_extra_columns)
PyStore provides namespaced collections of data. These collections allow bucketing data by source, user or some other metric (for example, frequency: End-Of-Day, Minute Bars, etc.). Each collection (or namespace) maps to directory containing partitioned parquet files for each item (e.g., symbol).
A good practice it to create collections that may look something like this:
PyStore was tested to work on *nix-like systems, including macOS.
Dependencies
PyStore utilizes Snappy, a fast and efficient compression/decompression library developed by Google. You'll need to install Snappy on your system before installing PyStore.
See the python-snappy GitHub repo for more information.
Windows users should check out Snappy for Windows and this Stack Overflow post for help on installing Snappy and python-snappy.
Current Status
Core Features:
Local filesystem support with Parquet storage
Full Pandas DataFrame compatibility, including MultiIndex
Snapshots for point-in-time data versioning
Metadata support for data organization
Advanced Features (July 2025 Release):
Complex data type serialization (Period, Interval, Categorical, nested objects)
Timezone-aware datetime handling with UTC storage
Async/await operations for non-blocking I/O
Data validation framework with extensible rules
Schema evolution for handling data structure changes
Transaction support with rollback capabilities
Performance Features:
Streaming operations for datasets larger than RAM
Batch read/write with parallel processing
Intelligent partitioning (time-based and size-based)
Memory optimization with automatic type downcasting
Metadata caching for faster access
Query optimization with column selection and predicate pushdown
Known Limitations:
MultiIndex append operations have limited support due to Dask limitations - while there's a workaround that converts MultiIndex to regular columns, it may not fully preserve the MultiIndex structure after append (test remains marked as expected failure)
Some Parquet limitations with preserving exact index metadata
Future Plans:
Amazon S3 support (via s3fs)
Google Cloud Storage support (via gcsfs)
Hadoop Distributed File System support (via hdfs3)
Acknowledgements
PyStore is hugely inspired by Man AHL's Arctic which uses MongoDB for storage and allows for versioning and other features. I highly recommend you check it out.
License
PyStore is licensed under the Apache License, Version 2.0. A copy of which is included in LICENSE.txt.
I'm very interested in your experience with PyStore. Please drop me a note with any feedback you have.
ranaroussi/pystore có 612 sao GitHub — tải lại trang để xem số mới nhất, hoặc xem trực tiếp github.com/ranaroussi/pystore. TopGit phản chiếu số sao của GitHub nhưng không cam kết đến từng phút.
ranaroussi/pystore có những chủ đề gì?
GitHub topics của ranaroussi/pystore: "dask", "database", "dataframe", "datastore", "pandas", "parquet", "timeseries". TopGit xếp repo vào nhóm Data.
ranaroussi/pystore còn đang phát triển không?
Commit gần nhất trên ranaroussi/pystore là 6 tháng trước (theo timestamp GitHub). Repo có 103 fork — một chỉ báo về mức độ quan tâm của cộng đồng.
ranaroussi/pystore là gì?
ranaroussi/pystore (ranaroussi/pystore) là dự án Python trên GitHub. Theo mô tả gốc: Fast data store for Pandas time-series data
ranaroussi/pystore so với các dự án Data khác thế nào?
ranaroussi/pystore được TopGit xếp vào nhóm Data, với 612 sao GitHub và viết bằng Python. Xem trang chủ đề Data trên TopGit để so sánh với các dự án tương tự theo số sao và mức độ hoạt động.
ranaroussi/pystore viết bằng ngôn ngữ gì?
ranaroussi/pystore chủ yếu viết bằng Python. Trường "language" của GitHub dựa trên phần lớn byte ở nhánh mặc định.
Vì sao ranaroussi/pystore được xếp vào nhóm Data?
TopGit xếp ranaroussi/pystore vào nhóm Data dựa trên GitHub topics và mô tả của repo (gắn thẻ: "dask", "database", "dataframe"). Việc phân loại dựa trên metadata thật của repo, không phải đoán theo cảm tính biên tập.
Đọc đầy đủ README ở tab phía trên.
Muốn nghe thêm một ý kiến về pystore?
Hỏi một AI đọc được trang này — một cú bấm là có ngay nhận định về pystore.