rhizo 0.1.1__tar.gz

rhizo-0.1.1/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: rhizo
+Version: 0.1.1
+Summary: Data, connected. Versioned data with SQL, time travel, and cross-table ACID transactions.
+License: MIT
+Project-URL: Homepage, https://rhizodata.dev
+Project-URL: Repository, https://github.com/rhizodata/rhizo
+Keywords: data,sql,duckdb,arrow,versioning,time-travel,transactions
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: rhizo-core>=0.1.0
+Requires-Dist: pyarrow>=14.0.0
+Requires-Dist: duckdb>=0.9.0
+Requires-Dist: pandas>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: maturin>=1.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+
+# rhizo
+
+Query layer for [Rhizo](https://rhizodata.dev) - versioned data with SQL, time travel, and cross-table ACID transactions.
+
+## Installation
+
+```bash
+pip install rhizo
+```
+
+### From Source
+
+```bash
+git clone https://github.com/rhizodata/rhizo.git
+cd rhizo/python
+pip install -e .
+```
+
+Note: Requires `rhizo-core` (Rust) to be built first. See the main [README](https://github.com/rhizodata/rhizo) for full build instructions.
+
+## Quick Start
+
+```python
+import rhizo
+from rhizo import QueryEngine
+import pandas as pd
+
+# Initialize storage
+store = rhizo.PyChunkStore("./data/chunks")
+catalog = rhizo.PyCatalog("./data/catalog")
+engine = QueryEngine(store, catalog)
+
+# Write data
+df = pd.DataFrame({"id": [1, 2, 3], "name": ["Alice", "Bob", "Charlie"]})
+engine.write_table("users", df)
+
+# SQL queries with DuckDB
+result = engine.query("SELECT * FROM users WHERE id > 1")
+print(result.to_pandas())
+
+# Time travel to any version
+result_v1 = engine.query("SELECT * FROM users", versions={"users": 1})
+```
+
+## Features
+
+- **SQL Queries**: DuckDB-powered analytical queries
+- **Time Travel**: Query any historical version
+- **Cross-Table ACID**: Atomic transactions across multiple tables
+- **Git-like Branching**: Zero-copy branches for experimentation
+- **Change Tracking**: Subscribe to data changes
+
+## Documentation
+
+See [rhizodata.dev](https://rhizodata.dev) for full documentation.
+
+## License
+
+MIT

rhizo-0.1.1/README.md

@@ -0,0 +1,59 @@
+# rhizo
+
+Query layer for [Rhizo](https://rhizodata.dev) - versioned data with SQL, time travel, and cross-table ACID transactions.
+
+## Installation
+
+```bash
+pip install rhizo
+```
+
+### From Source
+
+```bash
+git clone https://github.com/rhizodata/rhizo.git
+cd rhizo/python
+pip install -e .
+```
+
+Note: Requires `rhizo-core` (Rust) to be built first. See the main [README](https://github.com/rhizodata/rhizo) for full build instructions.
+
+## Quick Start
+
+```python
+import rhizo
+from rhizo import QueryEngine
+import pandas as pd
+
+# Initialize storage
+store = rhizo.PyChunkStore("./data/chunks")
+catalog = rhizo.PyCatalog("./data/catalog")
+engine = QueryEngine(store, catalog)
+
+# Write data
+df = pd.DataFrame({"id": [1, 2, 3], "name": ["Alice", "Bob", "Charlie"]})
+engine.write_table("users", df)
+
+# SQL queries with DuckDB
+result = engine.query("SELECT * FROM users WHERE id > 1")
+print(result.to_pandas())
+
+# Time travel to any version
+result_v1 = engine.query("SELECT * FROM users", versions={"users": 1})
+```
+
+## Features
+
+- **SQL Queries**: DuckDB-powered analytical queries
+- **Time Travel**: Query any historical version
+- **Cross-Table ACID**: Atomic transactions across multiple tables
+- **Git-like Branching**: Zero-copy branches for experimentation
+- **Change Tracking**: Subscribe to data changes
+
+## Documentation
+
+See [rhizodata.dev](https://rhizodata.dev) for full documentation.
+
+## License
+
+MIT

rhizo-0.1.1/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rhizo"
+version = "0.1.1"
+description = "Data, connected. Versioned data with SQL, time travel, and cross-table ACID transactions."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+keywords = ["data", "sql", "duckdb", "arrow", "versioning", "time-travel", "transactions"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Database",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+    "rhizo-core>=0.1.0",
+    "pyarrow>=14.0.0",
+    "duckdb>=0.9.0",
+    "pandas>=2.0.0",
+]
+
+[project.urls]
+Homepage = "https://rhizodata.dev"
+Repository = "https://github.com/rhizodata/rhizo"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "maturin>=1.0.0",
+    "ruff>=0.1.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["rhizo*"]

rhizo-0.1.1/rhizo/__init__.py

@@ -0,0 +1,151 @@
+"""
+Rhizo - Data, connected. SQL queries over versioned, content-addressable data.
+
+This module provides:
+- TableWriter: Write DataFrames as chunked Parquet files
+- TableReader: Read and assemble tables from chunks
+- QueryEngine: SQL interface with time travel support (DuckDB-based)
+- OLAPEngine: High-performance analytical queries (DataFusion-based)
+- CacheManager: LRU cache for Arrow tables
+- TransactionContext: ACID transactions across multiple tables
+- Subscriber: Stream changelog events with polling or callbacks
+- ChangeEvent: Individual table change within a transaction
+- Filter: Predicate filter builder for pushdown optimization
+
+Low-level types (from _rhizo):
+- PyChunkStore: Content-addressable chunk storage
+- PyCatalog: Table version catalog
+- PyBranchManager: Git-like branching
+- PyTransactionManager: Cross-table ACID transactions
+- PyMerkleConfig, merkle_build_tree, merkle_diff_trees, merkle_verify_tree: Merkle tree operations
+- PyParquetEncoder, PyParquetDecoder: High-performance Parquet I/O
+- PyPredicateFilter: Predicate pushdown filters
+- PyOpType, PyAlgebraicValue: Algebraic merge types
+- PyTableAlgebraicSchema, PyAlgebraicSchemaRegistry: Schema-level merge configuration
+"""
+
+from .writer import TableWriter
+from .reader import TableReader, Filter
+from .engine import QueryEngine
+from .transaction import TransactionContext
+from .subscriber import Subscriber, ChangeEvent
+from .cache import CacheManager, CacheKey, CacheStats
+from .olap_engine import OLAPEngine, is_datafusion_available
+
+# Re-export low-level types from _rhizo for convenience
+from _rhizo import (
+    PyChunkStore,
+    PyCatalog,
+    PyBranchManager,
+    PyTransactionManager,
+    PyTableVersion,
+    PyBranch,
+    PyBranchDiff,
+    PyMerkleConfig,
+    PyMerkleTree,
+    PyMerkleDiff,
+    PyDataChunk,
+    PyMerkleNode,
+    merkle_build_tree,
+    merkle_diff_trees,
+    merkle_verify_tree,
+    PyParquetEncoder,
+    PyParquetDecoder,
+    PyPredicateFilter,
+    PyFilterOp,
+    PyScalarValue,
+    PyChangelogEntry,
+    PyTableChange,
+    PyTransactionInfo,
+    PyRecoveryReport,
+    # Algebraic types
+    PyOpType,
+    PyAlgebraicValue,
+    PyTableAlgebraicSchema,
+    PyAlgebraicSchemaRegistry,
+    PyMergeAnalysis,
+    PyMergeOutcome,
+    algebraic_merge,
+    # Distributed types (coordination-free transactions)
+    PyNodeId,
+    PyCausalOrder,
+    PyVectorClock,
+    # Local commit protocol (coordination-free transactions)
+    PyAlgebraicOperation,
+    PyAlgebraicTransaction,
+    PyVersionedUpdate,
+    PyLocalCommitProtocol,
+    # Simulation types (multi-node convergence testing)
+    PyNetworkCondition,
+    PySimulationConfig,
+    PySimulationStats,
+    PySimulatedNode,
+    PySimulatedCluster,
+    PySimulationBuilder,
+)
+
+__version__ = "0.4.0"
+__all__ = [
+    # High-level API
+    "TableWriter",
+    "TableReader",
+    "QueryEngine",
+    "OLAPEngine",
+    "CacheManager",
+    "CacheKey",
+    "CacheStats",
+    "is_datafusion_available",
+    "TransactionContext",
+    "Subscriber",
+    "ChangeEvent",
+    "Filter",
+    # Low-level types
+    "PyChunkStore",
+    "PyCatalog",
+    "PyBranchManager",
+    "PyTransactionManager",
+    "PyTableVersion",
+    "PyBranch",
+    "PyBranchDiff",
+    "PyMerkleConfig",
+    "PyMerkleTree",
+    "PyMerkleDiff",
+    "PyDataChunk",
+    "PyMerkleNode",
+    "merkle_build_tree",
+    "merkle_diff_trees",
+    "merkle_verify_tree",
+    "PyParquetEncoder",
+    "PyParquetDecoder",
+    "PyPredicateFilter",
+    "PyFilterOp",
+    "PyScalarValue",
+    "PyChangelogEntry",
+    "PyTableChange",
+    "PyTransactionInfo",
+    "PyRecoveryReport",
+    # Algebraic types
+    "PyOpType",
+    "PyAlgebraicValue",
+    "PyTableAlgebraicSchema",
+    "PyAlgebraicSchemaRegistry",
+    "PyMergeAnalysis",
+    "PyMergeOutcome",
+    "algebraic_merge",
+    # Distributed types
+    "PyNodeId",
+    "PyCausalOrder",
+    "PyVectorClock",
+    # Local commit protocol
+    "PyAlgebraicOperation",
+    "PyAlgebraicTransaction",
+    "PyVersionedUpdate",
+    "PyLocalCommitProtocol",
+    # Simulation types
+    "PyNetworkCondition",
+    "PySimulationConfig",
+    "PySimulationStats",
+    "PySimulatedNode",
+    "PySimulatedCluster",
+    "PySimulationBuilder",
+]

rhizo-0.1.1/rhizo/__init__.pyi

@@ -0,0 +1,51 @@
+"""Type stubs for the rhizo package."""
+
+from typing import List, Dict, Optional, Tuple, Union
+
+# High-level API
+from .writer import TableWriter as TableWriter
+from .reader import TableReader as TableReader, Filter as Filter
+from .engine import QueryEngine as QueryEngine
+from .transaction import TransactionContext as TransactionContext
+from .subscriber import Subscriber as Subscriber, ChangeEvent as ChangeEvent
+from .cache import CacheManager as CacheManager, CacheKey as CacheKey, CacheStats as CacheStats
+from .olap_engine import OLAPEngine as OLAPEngine, is_datafusion_available as is_datafusion_available
+
+# Re-exports from _rhizo
+from _rhizo import (
+    PyChunkStore as PyChunkStore,
+    PyCatalog as PyCatalog,
+    PyBranchManager as PyBranchManager,
+    PyTransactionManager as PyTransactionManager,
+    PyTableVersion as PyTableVersion,
+    PyBranch as PyBranch,
+    PyBranchDiff as PyBranchDiff,
+    PyMerkleConfig as PyMerkleConfig,
+    PyMerkleTree as PyMerkleTree,
+    PyMerkleDiff as PyMerkleDiff,
+    PyDataChunk as PyDataChunk,
+    PyMerkleNode as PyMerkleNode,
+    merkle_build_tree as merkle_build_tree,
+    merkle_diff_trees as merkle_diff_trees,
+    merkle_verify_tree as merkle_verify_tree,
+    PyParquetEncoder as PyParquetEncoder,
+    PyParquetDecoder as PyParquetDecoder,
+    PyPredicateFilter as PyPredicateFilter,
+    PyFilterOp as PyFilterOp,
+    PyScalarValue as PyScalarValue,
+    PyChangelogEntry as PyChangelogEntry,
+    PyTableChange as PyTableChange,
+    PyTransactionInfo as PyTransactionInfo,
+    PyRecoveryReport as PyRecoveryReport,
+    # Algebraic types
+    PyOpType as PyOpType,
+    PyAlgebraicValue as PyAlgebraicValue,
+    PyTableAlgebraicSchema as PyTableAlgebraicSchema,
+    PyAlgebraicSchemaRegistry as PyAlgebraicSchemaRegistry,
+    PyMergeAnalysis as PyMergeAnalysis,
+    PyMergeOutcome as PyMergeOutcome,
+    algebraic_merge as algebraic_merge,
+)
+
+__version__: str
+__all__: List[str]