las-read-rs 0.1.1__cp310-cp310-manylinux_2_34_x86_64.whl

las_read_rs-0.1.1.dist-info/METADATA

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: las_read_rs
+Version: 0.1.1
+Summary: A high-performance LAS (Log ASCII Standard) file reader written in Rust
+Author-email: Emiliano Flores <jemilianofl@github.com>
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# LAS_read_rs
+
+**LAS_read_rs** is a high-performance Python library for reading **LAS (Log ASCII Standard)** files, written in **Rust** using `pyo3` and `nom`. It is designed to be a faster alternative to pure Python implementations, capable of parsing large geophysical log files efficiently.
+
+## Features
+
+- 🚀 **High Performance**: Built with Rust's `nom` parser combinators and parallelized with `rayon` for maximum speed.
+- 🧵 **Multi-threaded**: parses the data section (`~ASCII`) in parallel chunks.
+- 📦 **Easy Installation**: Distributed as a standard Python wheel via PyPI.
+- 🐍 **Pythonic Interface**: Simple `read()` function returning a `LASFile` object.
+- ✅ **Standard Compliant**: Supports LAS 2.0 (and 1.2 compatible structure).
+
+## Benchmarks
+
+Parsed a LAS file with **100,000 lines** of data:
+- **LAS_read_rs**: ~0.8s (Pure parsing time) / ~3.8s (Including CLI overhead benchmarks)
+- **Pure Python**: Significantly slower (typically 10x-50x slower depending on implementation).
+
+## Installation
+
+```bash
+pip install LAS_read_rs
+```
+
+## Usage
+
+```python
+import lasio_rs
+
+# Read a LAS file
+las = lasio_rs.read("path/to/well_log.las")
+
+# Access Version Information
+print(las.version)
+# Output (JSON representation):
+# {
+#   "VERS": {"mnemonic": "VERS", "value": "2.0", "descr": "CWLS LOG ASCII STANDARD - VERSION 2.0"},
+#   "WRAP": {"mnemonic": "WRAP", "value": "NO", "descr": "One line per depth step"}
+# }
+
+# Access Well Metadata (e.g., STRT, STOP, NULL)
+# Note: Currently exposed mainly via debug getters or verifying structure
+# Future versions will expose a full dictionary-like interface.
+
+print(f"Well Name: {las.well_name}")
+```
+
+## Structure
+
+The library maps LAS sections to Rust structs:
+- `~Version` -> `las.version`
+- `~Well` -> `las.well`
+- `~Curves` -> `las.curves` (Metadata)
+- `~ASCII` -> Data columns (Stored internally as efficient vectors)
+
+## Building from Source
+
+Requirements:
+- Python 3.7+
+- Rust (cargo, rustc)
+- `maturin`
+
+```bash
+pip install maturin
+maturin develop --release
+```
+
+## License
+
+MIT
+

las_read_rs-0.1.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+las_read_rs-0.1.1.dist-info/METADATA,sha256=VOYbTSMyNgWnAxv6vHvFTg3TR8oAA_eu3q4KJxbg4Q0,2333
+las_read_rs-0.1.1.dist-info/WHEEL,sha256=wWeP6JRxAL_oJlqLsckA512CC09LPG7OAdt_mycafo4,109
+lasio_rs/__init__.py,sha256=EgGxrSR3njk8PPL7ev0prizObOipRyfBui-QVI7dkjQ,31
+lasio_rs/_lasio_rs.cp313-win_amd64.pyd,sha256=sE_eS52Q2ayVUdKwPSgzQQxzUy2WN1NnVtaVASjKc_8,1380352
+lasio_rs/_lasio_rs.cpython-310-x86_64-linux-gnu.so,sha256=yvH5W_qywWqcrNws3lnjEuCTnr8fGZRVLoZqJz8gQbw,928496
+lasio_rs/las.py,sha256=EKQzfFfnXo_RyY3Ip6h0eQQvkjjyh5_y6yEizaE6Hys,4382
+las_read_rs-0.1.1.dist-info/RECORD,,

las_read_rs-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.11.5)
+Root-Is-Purelib: false
+Tag: cp310-cp310-manylinux_2_34_x86_64

lasio_rs/__init__.py

@@ -0,0 +1 @@
+from .las import read, LASFile

lasio_rs/las.py

@@ -0,0 +1,147 @@
+from ._lasio_rs import read as _rust_read
+import json
+
+
+class SectionItems:
+    def __init__(self, data_dict):
+        # Allow init from dict of HeaderItems or dict of dicts (from json)
+        self._data = {}
+        for k, v in data_dict.items():
+            if isinstance(v, dict):
+                # Check if it is a Curve dict or Header dict
+                self._data[k] = HeaderItem(v)
+            else:
+                self._data[k] = v
+
+    def __getitem__(self, key):
+        item = self._data.get(key)
+        if item:
+            return item
+        raise KeyError(f"{key} not found")
+
+    def keys(self):
+        return self._data.keys()
+
+    def values(self):
+        return self._data.values()
+
+    def items(self):
+        return self._data.items()
+
+    def get(self, key, default=None):
+        return self._data.get(key, default)
+
+    def __repr__(self):
+        return f"SectionItems({list(self.keys())})"
+
+
+class HeaderItem:
+    def __init__(self, item_dict):
+        self.mnemonic = item_dict.get("mnemonic")
+        self.unit = item_dict.get("unit")
+        self.value = item_dict.get("value")
+        self.descr = item_dict.get("descr")
+        self.original_mnemonic = self.mnemonic  # Compatibility
+
+    def __repr__(self):
+        return f'HeaderItem(mnemonic="{self.mnemonic}", unit="{self.unit}", value="{self.value}", descr="{self.descr}")'
+
+
+class CurveItem(HeaderItem):
+    def __init__(self, item_dict, las_file_ref):
+        super().__init__(item_dict)
+        self._las = las_file_ref
+        self._data = None
+
+    @property
+    def data(self):
+        if self._data is None:
+            # Lazy load from Rust
+            self._data = self._las._rust.get_curve_data(self.mnemonic)
+            if self._data is None:
+                self._data = []
+        return self._data
+
+    def __getitem__(self, index):
+        return self.data[index]
+
+    def __len__(self):
+        return len(self.data)
+
+    def __repr__(self):
+        return f'CurveItem(mnemonic="{self.mnemonic}", unit="{self.unit}", value="{self.value}", descr="{self.descr}", data.shape=({len(self)},))'
+
+
+class LASFile:
+    def __init__(self, rust_las):
+        self._rust = rust_las
+
+        # Hydrate metadata from JSON
+        header_json = rust_las.json_headers
+        header_data = json.loads(header_json)
+
+        self.version = SectionItems(header_data.get("version", {}))
+        self.well = SectionItems(header_data.get("well", {}))
+        self.params = SectionItems(header_data.get("params", {}))
+
+        # Curves needs special handling to link back to Rust for data
+        raw_curves = header_data.get("curves", {})
+        self.curves = SectionItems({})
+        # Overwrite with CurveItems
+        curve_dict = {}
+        for k, v in raw_curves.items():
+            curve_dict[k] = CurveItem(v, self)
+        self.curves = SectionItems(curve_dict)
+
+    def __getitem__(self, key):
+        # Access curve data directly by mnemonic
+        if isinstance(key, str):
+            if key in self.curves.keys():
+                return self.curves[key].data
+        raise KeyError(f"Curve {key} not found")
+
+    def keys(self):
+        return self.curves.keys()
+
+    def to_df(self):
+        """Convert LAS data to a pandas DataFrame.
+
+        Returns:
+            pandas.DataFrame: DataFrame with curve mnemonics as columns.
+        """
+        try:
+            import pandas as pd
+        except ImportError:
+            raise ImportError(
+                "pandas is required for to_df(). Install with: pip install pandas"
+            )
+
+        data = {}
+        for mnemonic in self.curves.keys():
+            curve = self.curves[mnemonic]
+            data[mnemonic] = curve.data
+        return pd.DataFrame(data)
+
+    def to_polars(self):
+        """Convert LAS data to a polars DataFrame.
+
+        Returns:
+            polars.DataFrame: DataFrame with curve mnemonics as columns.
+        """
+        try:
+            import polars as pl
+        except ImportError:
+            raise ImportError(
+                "polars is required for to_polars(). Install with: pip install polars"
+            )
+
+        data = {}
+        for mnemonic in self.curves.keys():
+            curve = self.curves[mnemonic]
+            data[mnemonic] = curve.data
+        return pl.DataFrame(data)
+
+
+def read(file_path):
+    rust_obj = _rust_read(str(file_path))
+    return LASFile(rust_obj)