aiogzip 0.1.0__tar.gz

aiogzip-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Geoff Davis
+
+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.

aiogzip-0.1.0/PKG-INFO

@@ -0,0 +1,179 @@
+Metadata-Version: 2.4
+Name: aiogzip
+Version: 0.1.0
+Summary: Asynchronous gzip file reader/writer with aiocsv support.
+Author-email: Geoff Davis <geoff@keksi.ai>
+Project-URL: Homepage, https://github.com/geoff-davis/aiogzip
+Project-URL: Issues, https://github.com/geoff-davis/aiogzip/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Framework :: AsyncIO
+Classifier: Topic :: System :: Archiving :: Compression
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiofiles>=23.0.0
+Provides-Extra: csv
+Requires-Dist: aiocsv>=1.2.0; extra == "csv"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: psutil; extra == "dev"
+Dynamic: license-file
+
+# aiogzip ⚡️
+
+**An asynchronous library for reading and writing gzip-compressed files.**
+
+`aiogzip` provides a fast, simple, and asyncio-native interface for handling `.gz` files, making it a useful complement to Python's built-in `gzip` module for asynchronous applications.
+
+It is designed for high-performance I/O operations, especially for text-based data pipelines, and integrates seamlessly with other `async` libraries like `aiocsv`.
+
+## Features
+
+- **Truly Asynchronous**: Built with `asyncio` and `aiofiles` for non-blocking file I/O.
+- **High-Performance Text Processing**: Significantly faster than the standard `gzip` library for text and JSONL file operations.
+- **Simple API**: Mimics the interface of `gzip.open()`, making it easy to adopt.
+- **Separate Binary and Text Modes**: `AsyncGzipBinaryFile` and `AsyncGzipTextFile` provide clear, type-safe handling of data.
+- **Excellent Compression Quality**: Achieves compression ratios nearly identical to the standard `gzip` module.
+- **`aiocsv` Integration**: Read and write compressed CSV files effortlessly.
+
+---
+
+## Installation
+
+Install `aiogzip` using pip. To include optional `aiocsv` support, specify the `[csv]` extra.
+
+```bash
+# Standard installation
+pip install aiogzip
+
+# With aiocsv support
+pip install aiogzip[csv]
+```
+
+---
+
+## Quickstart
+
+Using `aiogzip` is as simple as using the standard `gzip` module, but with `async`/`await`.
+
+### Writing to a Compressed File
+
+```python
+import asyncio
+from aiogzip import AsyncGzipFile
+
+async def main():
+    # Write binary data
+    async with AsyncGzipFile("file.gz", "wb") as f:
+        await f.write(b"Hello, async world!")
+
+    # Write text data
+    async with AsyncGzipFile("file.txt.gz", "wt") as f:
+        await f.write("This is a text file.")
+
+asyncio.run(main())
+```
+
+### Reading from a Compressed File
+
+```python
+import asyncio
+from aiogzip import AsyncGzipFile
+
+async def main():
+    # Read the entire file
+    async with AsyncGzipFile("file.gz", "rb") as f:
+        content = await f.read()
+        print(content)
+
+    # Iterate over lines in a text file
+    async with AsyncGzipFile("file.txt.gz", "rt") as f:
+        async for line in f:
+            print(line.strip())
+
+asyncio.run(main())
+```
+
+---
+
+## Performance
+
+`aiogzip` is a specialized tool that excels in text-based, async workflows but may be slower than the standard library for binary operations.
+
+According to the benchmarks, `aiogzip` is:
+
+- **4.3x faster** for general text file operations.
+- **1.6x faster** when processing structured text like JSONL files.
+- **1.1x slower** for binary file operations using 1KB chunk sizes.
+
+The key is to match the tool to the task. Use `aiogzip` where its async and text-handling capabilities provide the most significant advantage.
+
+### Async and Concurrent Processing Benefits
+
+`aiogzip` excels in scenarios where you need to process multiple files concurrently or integrate with other async libraries:
+
+- **Concurrent file processing**: Process multiple `.gz` files simultaneously without blocking
+- **Async pipeline integration**: Seamlessly works with `aiocsv`, `aiohttp`, and other async libraries
+- **Non-blocking I/O**: Allows your application to handle other tasks while file operations are in progress
+- **Better resource utilization**: More efficient use of system resources in I/O-bound applications
+
+**Note**: The benefits of async are most visible when there's actual I/O latency (network storage, remote APIs, etc.) or when mixing file operations with other async tasks. For purely local file processing on SSDs, the async overhead may exceed the benefits due to minimal I/O wait times.
+
+### When to Use `aiogzip`
+
+✅ **Recommended for:**
+
+- Async applications processing text, CSV, or JSONL files.
+- Streaming text-based data pipelines.
+- Applications where async integration and concurrent file processing are more important than raw binary I/O speed.
+
+### When to Use Standard `gzip`
+
+❌ **Consider standard `gzip` for:**
+
+- Purely synchronous applications.
+- Applications that are highly memory-constrained, as `aiogzip` may use more memory during decompression of highly compressible data due to internal buffering.
+- Workloads dominated by binary file I/O where maximum performance is essential.
+
+---
+
+## Limitations
+
+`aiogzip` focuses on the most common file-based read/write operations and does not implement the full API of the standard `gzip` module. Notably, it does not currently support:
+
+- In-memory compression/decompression (e.g., `gzip.compress`/`gzip.decompress`).
+- The `seek()` and `tell()` methods for navigating within a file stream.
+- Reading or writing gzip headers and metadata like `mtime`.
+
+## Development
+
+This project uses `setuptools` for packaging.
+
+1. **Clone the repository**:
+
+   ```bash
+   git clone https://github.com/geoff-davis/aiogzip.git
+   cd aiogzip
+   ```
+
+2. **Create a virtual environment and install dependencies**:
+
+   ```bash
+   python -m venv .venv
+   source .venv/bin/activate
+   pip install -e ".[csv]"  # Install in editable mode with extras
+   pip install -e ".[dev]" # Install dev dependencies
+   ```
+
+3. **Run tests**:
+
+   ```bash
+   pytest
+   ```
+
+## License
+
+This project is licensed under the **MIT License**. See the `LICENSE` file for details.

aiogzip-0.1.0/README.md

@@ -0,0 +1,155 @@
+# aiogzip ⚡️
+
+**An asynchronous library for reading and writing gzip-compressed files.**
+
+`aiogzip` provides a fast, simple, and asyncio-native interface for handling `.gz` files, making it a useful complement to Python's built-in `gzip` module for asynchronous applications.
+
+It is designed for high-performance I/O operations, especially for text-based data pipelines, and integrates seamlessly with other `async` libraries like `aiocsv`.
+
+## Features
+
+- **Truly Asynchronous**: Built with `asyncio` and `aiofiles` for non-blocking file I/O.
+- **High-Performance Text Processing**: Significantly faster than the standard `gzip` library for text and JSONL file operations.
+- **Simple API**: Mimics the interface of `gzip.open()`, making it easy to adopt.
+- **Separate Binary and Text Modes**: `AsyncGzipBinaryFile` and `AsyncGzipTextFile` provide clear, type-safe handling of data.
+- **Excellent Compression Quality**: Achieves compression ratios nearly identical to the standard `gzip` module.
+- **`aiocsv` Integration**: Read and write compressed CSV files effortlessly.
+
+---
+
+## Installation
+
+Install `aiogzip` using pip. To include optional `aiocsv` support, specify the `[csv]` extra.
+
+```bash
+# Standard installation
+pip install aiogzip
+
+# With aiocsv support
+pip install aiogzip[csv]
+```
+
+---
+
+## Quickstart
+
+Using `aiogzip` is as simple as using the standard `gzip` module, but with `async`/`await`.
+
+### Writing to a Compressed File
+
+```python
+import asyncio
+from aiogzip import AsyncGzipFile
+
+async def main():
+    # Write binary data
+    async with AsyncGzipFile("file.gz", "wb") as f:
+        await f.write(b"Hello, async world!")
+
+    # Write text data
+    async with AsyncGzipFile("file.txt.gz", "wt") as f:
+        await f.write("This is a text file.")
+
+asyncio.run(main())
+```
+
+### Reading from a Compressed File
+
+```python
+import asyncio
+from aiogzip import AsyncGzipFile
+
+async def main():
+    # Read the entire file
+    async with AsyncGzipFile("file.gz", "rb") as f:
+        content = await f.read()
+        print(content)
+
+    # Iterate over lines in a text file
+    async with AsyncGzipFile("file.txt.gz", "rt") as f:
+        async for line in f:
+            print(line.strip())
+
+asyncio.run(main())
+```
+
+---
+
+## Performance
+
+`aiogzip` is a specialized tool that excels in text-based, async workflows but may be slower than the standard library for binary operations.
+
+According to the benchmarks, `aiogzip` is:
+
+- **4.3x faster** for general text file operations.
+- **1.6x faster** when processing structured text like JSONL files.
+- **1.1x slower** for binary file operations using 1KB chunk sizes.
+
+The key is to match the tool to the task. Use `aiogzip` where its async and text-handling capabilities provide the most significant advantage.
+
+### Async and Concurrent Processing Benefits
+
+`aiogzip` excels in scenarios where you need to process multiple files concurrently or integrate with other async libraries:
+
+- **Concurrent file processing**: Process multiple `.gz` files simultaneously without blocking
+- **Async pipeline integration**: Seamlessly works with `aiocsv`, `aiohttp`, and other async libraries
+- **Non-blocking I/O**: Allows your application to handle other tasks while file operations are in progress
+- **Better resource utilization**: More efficient use of system resources in I/O-bound applications
+
+**Note**: The benefits of async are most visible when there's actual I/O latency (network storage, remote APIs, etc.) or when mixing file operations with other async tasks. For purely local file processing on SSDs, the async overhead may exceed the benefits due to minimal I/O wait times.
+
+### When to Use `aiogzip`
+
+✅ **Recommended for:**
+
+- Async applications processing text, CSV, or JSONL files.
+- Streaming text-based data pipelines.
+- Applications where async integration and concurrent file processing are more important than raw binary I/O speed.
+
+### When to Use Standard `gzip`
+
+❌ **Consider standard `gzip` for:**
+
+- Purely synchronous applications.
+- Applications that are highly memory-constrained, as `aiogzip` may use more memory during decompression of highly compressible data due to internal buffering.
+- Workloads dominated by binary file I/O where maximum performance is essential.
+
+---
+
+## Limitations
+
+`aiogzip` focuses on the most common file-based read/write operations and does not implement the full API of the standard `gzip` module. Notably, it does not currently support:
+
+- In-memory compression/decompression (e.g., `gzip.compress`/`gzip.decompress`).
+- The `seek()` and `tell()` methods for navigating within a file stream.
+- Reading or writing gzip headers and metadata like `mtime`.
+
+## Development
+
+This project uses `setuptools` for packaging.
+
+1. **Clone the repository**:
+
+   ```bash
+   git clone https://github.com/geoff-davis/aiogzip.git
+   cd aiogzip
+   ```
+
+2. **Create a virtual environment and install dependencies**:
+
+   ```bash
+   python -m venv .venv
+   source .venv/bin/activate
+   pip install -e ".[csv]"  # Install in editable mode with extras
+   pip install -e ".[dev]" # Install dev dependencies
+   ```
+
+3. **Run tests**:
+
+   ```bash
+   pytest
+   ```
+
+## License
+
+This project is licensed under the **MIT License**. See the `LICENSE` file for details.

aiogzip-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "aiogzip"
+version = "0.1.0"
+authors = [
+  { name="Geoff Davis", email="geoff@keksi.ai" },
+]
+description = "Asynchronous gzip file reader/writer with aiocsv support."
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Framework :: AsyncIO",
+    "Topic :: System :: Archiving :: Compression",
+]
+dependencies = [
+    "aiofiles>=23.0.0",
+]
+[project.optional-dependencies]
+csv = [
+    "aiocsv>=1.2.0",
+]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio",
+    "psutil",
+]
+[project.urls]
+Homepage = "https://github.com/geoff-davis/aiogzip"
+Issues = "https://github.com/geoff-davis/aiogzip/issues"

aiogzip-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

aiogzip-0.1.0/src/__init__.py

@@ -0,0 +1,12 @@
+# src/aiogzip/__init__.py
+"""AsyncGzipFile - Asynchronous gzip file reader/writer."""
+
+__version__ = "0.1.0"
+
+from .aiogzip import AsyncGzipBinaryFile, AsyncGzipFile, AsyncGzipTextFile
+
+__all__ = [
+    "AsyncGzipFile",
+    "AsyncGzipBinaryFile",
+    "AsyncGzipTextFile",
+]

aiogzip-0.1.0/src/aiogzip.egg-info/PKG-INFO

@@ -0,0 +1,179 @@
+Metadata-Version: 2.4
+Name: aiogzip
+Version: 0.1.0
+Summary: Asynchronous gzip file reader/writer with aiocsv support.
+Author-email: Geoff Davis <geoff@keksi.ai>
+Project-URL: Homepage, https://github.com/geoff-davis/aiogzip
+Project-URL: Issues, https://github.com/geoff-davis/aiogzip/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Framework :: AsyncIO
+Classifier: Topic :: System :: Archiving :: Compression
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiofiles>=23.0.0
+Provides-Extra: csv
+Requires-Dist: aiocsv>=1.2.0; extra == "csv"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: psutil; extra == "dev"
+Dynamic: license-file
+
+# aiogzip ⚡️
+
+**An asynchronous library for reading and writing gzip-compressed files.**
+
+`aiogzip` provides a fast, simple, and asyncio-native interface for handling `.gz` files, making it a useful complement to Python's built-in `gzip` module for asynchronous applications.
+
+It is designed for high-performance I/O operations, especially for text-based data pipelines, and integrates seamlessly with other `async` libraries like `aiocsv`.
+
+## Features
+
+- **Truly Asynchronous**: Built with `asyncio` and `aiofiles` for non-blocking file I/O.
+- **High-Performance Text Processing**: Significantly faster than the standard `gzip` library for text and JSONL file operations.
+- **Simple API**: Mimics the interface of `gzip.open()`, making it easy to adopt.
+- **Separate Binary and Text Modes**: `AsyncGzipBinaryFile` and `AsyncGzipTextFile` provide clear, type-safe handling of data.
+- **Excellent Compression Quality**: Achieves compression ratios nearly identical to the standard `gzip` module.
+- **`aiocsv` Integration**: Read and write compressed CSV files effortlessly.
+
+---
+
+## Installation
+
+Install `aiogzip` using pip. To include optional `aiocsv` support, specify the `[csv]` extra.
+
+```bash
+# Standard installation
+pip install aiogzip
+
+# With aiocsv support
+pip install aiogzip[csv]
+```
+
+---
+
+## Quickstart
+
+Using `aiogzip` is as simple as using the standard `gzip` module, but with `async`/`await`.
+
+### Writing to a Compressed File
+
+```python
+import asyncio
+from aiogzip import AsyncGzipFile
+
+async def main():
+    # Write binary data
+    async with AsyncGzipFile("file.gz", "wb") as f:
+        await f.write(b"Hello, async world!")
+
+    # Write text data
+    async with AsyncGzipFile("file.txt.gz", "wt") as f:
+        await f.write("This is a text file.")
+
+asyncio.run(main())
+```
+
+### Reading from a Compressed File
+
+```python
+import asyncio
+from aiogzip import AsyncGzipFile
+
+async def main():
+    # Read the entire file
+    async with AsyncGzipFile("file.gz", "rb") as f:
+        content = await f.read()
+        print(content)
+
+    # Iterate over lines in a text file
+    async with AsyncGzipFile("file.txt.gz", "rt") as f:
+        async for line in f:
+            print(line.strip())
+
+asyncio.run(main())
+```
+
+---
+
+## Performance
+
+`aiogzip` is a specialized tool that excels in text-based, async workflows but may be slower than the standard library for binary operations.
+
+According to the benchmarks, `aiogzip` is:
+
+- **4.3x faster** for general text file operations.
+- **1.6x faster** when processing structured text like JSONL files.
+- **1.1x slower** for binary file operations using 1KB chunk sizes.
+
+The key is to match the tool to the task. Use `aiogzip` where its async and text-handling capabilities provide the most significant advantage.
+
+### Async and Concurrent Processing Benefits
+
+`aiogzip` excels in scenarios where you need to process multiple files concurrently or integrate with other async libraries:
+
+- **Concurrent file processing**: Process multiple `.gz` files simultaneously without blocking
+- **Async pipeline integration**: Seamlessly works with `aiocsv`, `aiohttp`, and other async libraries
+- **Non-blocking I/O**: Allows your application to handle other tasks while file operations are in progress
+- **Better resource utilization**: More efficient use of system resources in I/O-bound applications
+
+**Note**: The benefits of async are most visible when there's actual I/O latency (network storage, remote APIs, etc.) or when mixing file operations with other async tasks. For purely local file processing on SSDs, the async overhead may exceed the benefits due to minimal I/O wait times.
+
+### When to Use `aiogzip`
+
+✅ **Recommended for:**
+
+- Async applications processing text, CSV, or JSONL files.
+- Streaming text-based data pipelines.
+- Applications where async integration and concurrent file processing are more important than raw binary I/O speed.
+
+### When to Use Standard `gzip`
+
+❌ **Consider standard `gzip` for:**
+
+- Purely synchronous applications.
+- Applications that are highly memory-constrained, as `aiogzip` may use more memory during decompression of highly compressible data due to internal buffering.
+- Workloads dominated by binary file I/O where maximum performance is essential.
+
+---
+
+## Limitations
+
+`aiogzip` focuses on the most common file-based read/write operations and does not implement the full API of the standard `gzip` module. Notably, it does not currently support:
+
+- In-memory compression/decompression (e.g., `gzip.compress`/`gzip.decompress`).
+- The `seek()` and `tell()` methods for navigating within a file stream.
+- Reading or writing gzip headers and metadata like `mtime`.
+
+## Development
+
+This project uses `setuptools` for packaging.
+
+1. **Clone the repository**:
+
+   ```bash
+   git clone https://github.com/geoff-davis/aiogzip.git
+   cd aiogzip
+   ```
+
+2. **Create a virtual environment and install dependencies**:
+
+   ```bash
+   python -m venv .venv
+   source .venv/bin/activate
+   pip install -e ".[csv]"  # Install in editable mode with extras
+   pip install -e ".[dev]" # Install dev dependencies
+   ```
+
+3. **Run tests**:
+
+   ```bash
+   pytest
+   ```
+
+## License
+
+This project is licensed under the **MIT License**. See the `LICENSE` file for details.

aiogzip-0.1.0/src/aiogzip.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+src/__init__.py
+src/aiogzip.py
+src/aiogzip.egg-info/PKG-INFO
+src/aiogzip.egg-info/SOURCES.txt
+src/aiogzip.egg-info/dependency_links.txt
+src/aiogzip.egg-info/requires.txt
+src/aiogzip.egg-info/top_level.txt
+tests/test_aiogzip.py

aiogzip-0.1.0/src/aiogzip.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

aiogzip-0.1.0/src/aiogzip.egg-info/requires.txt

@@ -0,0 +1,9 @@
+aiofiles>=23.0.0
+
+[csv]
+aiocsv>=1.2.0
+
+[dev]
+pytest>=8.0.0
+pytest-asyncio
+psutil

aiogzip-0.1.0/src/aiogzip.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+__init__
+aiogzip