lasmnemonicsid 0.0.1rc0__tar.gz → 0.0.3rc0__tar.gz

{lasmnemonicsid-0.0.1rc0 → lasmnemonicsid-0.0.3rc0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lasmnemonicsid
-Version: 0.0.1rc0
+Version: 0.0.3rc0
 Summary: Well log mnemonic identification using lasio and dlisio to load LAS/DLIS files into DataFrames
 Author-email: Nobleza Energy <info@nobleza-energy.com>
 License: MIT
@@ -36,7 +36,6 @@ Requires-Dist: flake8>=6.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
 Dynamic: license-file
 
-
 <p align="center">
   <img src="https://raw.githubusercontent.com/Nobleza-Energy/LASMnemonicsID/main/logo.png" alt="LASMnemonicsID Logo" width="200"/>
 </p>
@@ -61,10 +60,9 @@ Dynamic: license-file
 pip install lasmnemonicsid
 ```
 
-
-
 ## 🚀 QuickStart
-```
+
+```python
 from LASMnemonicsID.LAS import parseLAS
 
 # Load LAS file
@@ -72,12 +70,41 @@ df = parseLAS("your_well.las")
 print(df.head())
 ```
 
-## 🧪 Test with your Data
-```
+## 🧪 Test with your Data: Multiple files will load into a dictionary 
+
+```python
 from LASMnemonicsID.LAS import parseLAS
 
-# Load and inspect
-df = parseLAS("path/to/well.las")
-print(f"✅ {len(df)} rows, {len(df.columns)} curves")
-print(df.columns.tolist())
+# Load all .las within the Directory → {filename: df}
+data = parseLAS("/path/to/your/data/")
+print("Files:", list(data.keys()))
+
+# Dataframes
+df = parseLAS('/path/to/yourfile.las')
+print(df.head())
 ```
+
+## 📈 Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=Nobleza-Energy/LASMnemonicsID&type=Date)](https://star-history.com/#Nobleza-Energy/LASMnemonicsID&Date)
+
+
+## 📄 How to Cite
+
+If you use `LASMnemonicsID` in your research or project, please cite it as follows:
+
+**APA**
+
+> Nobleza Energy. (2025). LASMnemonicsID: Well log mnemonic identification using lasio and dlisio [Software]. GitHub. https://github.com/Nobleza-Energy/LASMnemonicsID
+
+**BibTeX**
+
+```bibtex
+@software{LASMnemonicsID,
+  author = {Nobleza Energy},
+  title = {LASMnemonicsID: Well log mnemonic identification using lasio and dlisio},
+  year = {2025},
+  publisher = {GitHub},
+  journal = {GitHub repository},
+  url = {https://github.com/Nobleza-Energy/LASMnemonicsID}
+}

lasmnemonicsid-0.0.3rc0/README.md

@@ -0,0 +1,72 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/Nobleza-Energy/LASMnemonicsID/main/logo.png" alt="LASMnemonicsID Logo" width="200"/>
+</p>
+
+<h1 align="center">LASMnemonicsID</h1>
+
+<p align="center">
+  <b>Well log mnemonic identification using lasio and dlisio</b>
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/lasmnemonicsid/"><img src="https://img.shields.io/pypi/v/lasmnemonicsid.svg" alt="PyPI"></a>
+  <a href="https://pypi.org/project/lasmnemonicsid/"><img src="https://img.shields.io/pypi/pyversions/lasmnemonicsid.svg" alt="Python Versions"></a>
+  <a href="https://github.com/Nobleza-Energy/LASMnemonicsID/blob/main/LICENSE"><img src="https://img.shields.io/github/license/Nobleza-Energy/LASMnemonicsID.svg" alt="License"></a>
+</p>
+
+---
+
+## 📦 Installation
+
+```bash
+pip install lasmnemonicsid
+```
+
+## 🚀 QuickStart
+
+```python
+from LASMnemonicsID.LAS import parseLAS
+
+# Load LAS file
+df = parseLAS("your_well.las")
+print(df.head())
+```
+
+## 🧪 Test with your Data: Multiple files will load into a dictionary 
+
+```python
+from LASMnemonicsID.LAS import parseLAS
+
+# Load all .las within the Directory → {filename: df}
+data = parseLAS("/path/to/your/data/")
+print("Files:", list(data.keys()))
+
+# Dataframes
+df = parseLAS('/path/to/yourfile.las')
+print(df.head())
+```
+
+## 📈 Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=Nobleza-Energy/LASMnemonicsID&type=Date)](https://star-history.com/#Nobleza-Energy/LASMnemonicsID&Date)
+
+
+## 📄 How to Cite
+
+If you use `LASMnemonicsID` in your research or project, please cite it as follows:
+
+**APA**
+
+> Nobleza Energy. (2025). LASMnemonicsID: Well log mnemonic identification using lasio and dlisio [Software]. GitHub. https://github.com/Nobleza-Energy/LASMnemonicsID
+
+**BibTeX**
+
+```bibtex
+@software{LASMnemonicsID,
+  author = {Nobleza Energy},
+  title = {LASMnemonicsID: Well log mnemonic identification using lasio and dlisio},
+  year = {2025},
+  publisher = {GitHub},
+  journal = {GitHub repository},
+  url = {https://github.com/Nobleza-Energy/LASMnemonicsID}
+}

{lasmnemonicsid-0.0.1rc0 → lasmnemonicsid-0.0.3rc0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lasmnemonicsid"
-version = "0.0.1c"  # ← NEW tag version
+version = "0.0.3c"  
 description = "Well log mnemonic identification using lasio and dlisio to load LAS/DLIS files into DataFrames"
 readme = "README.md"
 authors = [

lasmnemonicsid-0.0.3rc0/src/LASMnemonicsID/LAS/LAS.py

@@ -0,0 +1,194 @@
+import LASMnemonicsID.utils.mnemonics as mnm
+from LASMnemonicsID.utils.mnemonics import (
+    gamma_names,
+    sp_names,
+    caliper_names,
+    deepres_names,
+    rxo_names,
+    density_names,
+    density_correction_names,
+    neutron_names,
+    dtc_names,
+    dts_names,
+    pe_names,
+)
+import os
+import pathlib
+import pandas as pd
+import lasio
+from os.path import join
+from sys import stdout
+from pathlib import Path
+
+# Function that creates the mnemonic dictionary
+def create_mnemonic_dict(
+    gamma_names,
+    sp_names,
+    caliper_names,
+    deepres_names,
+    rxo_names,
+    density_names,
+    density_correction_names,
+    neutron_names,
+    dtc_names,
+    dts_names,
+    pe_names,
+):
+    """
+    Function that creates the mnemonic dictionary with the mnemonics per log type.
+    """
+    mnemonic_dict = {
+        "gamma": gamma_names,
+        "sp": sp_names,
+        "caliper": caliper_names,
+        "deepres": deepres_names,
+        "rxo": rxo_names,
+        "density": density_names,
+        "density_correction": density_correction_names,
+        "neutron": neutron_names,
+        "dtc": dtc_names,
+        "dts": dts_names,
+        "pe": pe_names,
+    }
+    return mnemonic_dict
+
+def parseLAS(input_path, verbose=True, preferred_names=None):
+    """
+    Parse LAS file or all in directory → DataFrame or {filename: df}.
+    
+    Args:
+        input_path (str/Path): LAS file or directory
+        verbose (bool): Print info
+        preferred_names (dict, optional): Mapping of curve types to preferred column names and preferred original columns.
+            Example: {"deepres": "RT", "deepres_preferred_original": "AT90", "gamma": "GR"}
+            If not provided, defaults to standard petrophysical names.
+        
+    Returns:
+        DataFrame (single) or dict {filename: df} (multiple/dir)
+    """
+    input_path = Path(input_path)
+    
+    # Define default standard names
+    std_names = {
+        "gamma": "GR",
+        "sp": "SP",
+        "caliper": "CALI",
+        "deepres": "RT",
+        "rxo": "RXO",
+        "density": "RHOB",
+        "density_correction": "DRHO",
+        "neutron": "NPHI",
+        "dtc": "DT",
+        "dts": "DTS",
+        "pe": "PEF"
+    }
+    
+    # Update with user preferences if provided
+    if preferred_names:
+        std_names.update(preferred_names)
+    
+    # Case 1: Single File
+    if input_path.is_file() and input_path.suffix.lower() == '.las':
+        df = _read_single_las(input_path, verbose, std_names)
+        return df if df is not None else None
+    
+    # Case 2: Directory (Recursive)
+    las_files = list(input_path.rglob("*.las"))
+    if not las_files:
+        if verbose:
+            print(f"No LAS files found in {input_path}")
+        return {}
+    
+    las_dict = {}
+    for las_file in las_files:
+        df = _read_single_las(las_file, verbose, std_names)
+        if df is not None:
+            filename = las_file.name
+            las_dict[filename] = df
+    
+    # Return single DF if only 1 file found, else dict
+    if len(las_dict) == 1:
+        return next(iter(las_dict.values()))
+    
+    return las_dict
+
+def _read_single_las(las_file_path, verbose, std_names):
+    """Read single LAS file to DataFrame and standardize ALL curves."""
+    try:
+        las_data = lasio.read(las_file_path)
+        df = las_data.df()
+        
+        if df is None or df.empty:
+            if verbose:
+                print(f"✗ Empty DataFrame: {las_file_path.name}")
+            return None
+            
+        # Ensure index is depth (float)
+        df.index = df.index.astype(float)
+        
+        # Standardize ALL curves (GR, RHOB, NPHI, etc.)
+        _standardize_all_curves(las_data, df, std_names)
+        
+        if verbose:
+            print(f"✓ {las_file_path.name}")
+        return df
+        
+    except lasio.exceptions.LASHeaderError as e:
+        if verbose:
+            print(f"✗ LASHeaderError in {las_file_path.name}: {e}")
+    except Exception as e:
+        if verbose:
+            print(f"✗ Error in {las_file_path.name}: {type(e).__name__}: {e}")
+    return None
+
+def _get_well_name(las_file_path):
+    """Extract well name from LAS file"""
+    try:
+        las_data = lasio.read(las_file_path)
+        return str(las_data.well.WELL.value).strip()
+    except:
+        return las_file_path.stem
+
+def _standardize_all_curves(las_data, df, std_names):
+    """
+    Rename ALL curves in the DataFrame to standard abbreviations 
+    based on the mnemonic dictionary.
+    """
+    # 1. Get the dictionary of aliases
+    mnem_dict = create_mnemonic_dict(
+        gamma_names, sp_names, caliper_names, deepres_names, rxo_names,
+        density_names, density_correction_names, neutron_names, 
+        dtc_names, dts_names, pe_names
+    )
+    
+    # 2. Track which columns we've already renamed to avoid duplicates
+    renamed = set()
+
+    # 3. For each curve type, find all aliases in the file
+    for curve_type, aliases in mnem_dict.items():
+        # Find all matching columns in df
+        matching = [col for col in df.columns if col.lower() in [a.lower() for a in aliases]]
+        
+        if not matching:
+            continue
+        
+        # Use standard name if provided, otherwise use curve_type.upper()
+        target_name = std_names.get(curve_type, curve_type.upper())
+        
+        # If a preferred original column is specified, use it
+        preferred_original = std_names.get(f"{curve_type}_preferred_original")
+        
+        if preferred_original and preferred_original in matching:
+            # Rename preferred original to target_name
+            df.rename(columns={preferred_original: target_name}, inplace=True)
+            renamed.add(target_name)
+        else:
+            # Otherwise, pick the first matching alias
+            df.rename(columns={matching[0]: target_name}, inplace=True)
+            renamed.add(target_name)
+        
+        # Remove all other matching columns
+        for col in matching:
+            if col != target_name and col in df.columns:
+                df.drop(columns=[col], inplace=True)
+

lasmnemonicsid-0.0.3rc0/src/LASMnemonicsID/LAS/__init__.py

@@ -0,0 +1,13 @@
+from .LAS import (
+    parseLAS,
+    create_mnemonic_dict,
+    _get_well_name,
+    _read_single_las  # Keep helpers if needed
+)
+
+__all__ = [
+    "parseLAS",
+    "create_mnemonic_dict",
+    "_get_well_name",
+    "_read_single_las"
+]

{lasmnemonicsid-0.0.1rc0 → lasmnemonicsid-0.0.3rc0}/src/LASMnemonicsID/utils/mnemonics.py

@@ -153,6 +153,8 @@ gamma_names = [
     "idgr",
     "gr_stgc",
     "gr_edtc_s",
+    "gradx",
+    "grarfm"
 ]
 
 # For spontanous potential logs

{lasmnemonicsid-0.0.1rc0 → lasmnemonicsid-0.0.3rc0}/src/lasmnemonicsid.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lasmnemonicsid
-Version: 0.0.1rc0
+Version: 0.0.3rc0
 Summary: Well log mnemonic identification using lasio and dlisio to load LAS/DLIS files into DataFrames
 Author-email: Nobleza Energy <info@nobleza-energy.com>
 License: MIT
@@ -36,7 +36,6 @@ Requires-Dist: flake8>=6.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
 Dynamic: license-file
 
-
 <p align="center">
   <img src="https://raw.githubusercontent.com/Nobleza-Energy/LASMnemonicsID/main/logo.png" alt="LASMnemonicsID Logo" width="200"/>
 </p>
@@ -61,10 +60,9 @@ Dynamic: license-file
 pip install lasmnemonicsid
 ```
 
-
-
 ## 🚀 QuickStart
-```
+
+```python
 from LASMnemonicsID.LAS import parseLAS
 
 # Load LAS file
@@ -72,12 +70,41 @@ df = parseLAS("your_well.las")
 print(df.head())
 ```
 
-## 🧪 Test with your Data
-```
+## 🧪 Test with your Data: Multiple files will load into a dictionary 
+
+```python
 from LASMnemonicsID.LAS import parseLAS
 
-# Load and inspect
-df = parseLAS("path/to/well.las")
-print(f"✅ {len(df)} rows, {len(df.columns)} curves")
-print(df.columns.tolist())
+# Load all .las within the Directory → {filename: df}
+data = parseLAS("/path/to/your/data/")
+print("Files:", list(data.keys()))
+
+# Dataframes
+df = parseLAS('/path/to/yourfile.las')
+print(df.head())
 ```
+
+## 📈 Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=Nobleza-Energy/LASMnemonicsID&type=Date)](https://star-history.com/#Nobleza-Energy/LASMnemonicsID&Date)
+
+
+## 📄 How to Cite
+
+If you use `LASMnemonicsID` in your research or project, please cite it as follows:
+
+**APA**
+
+> Nobleza Energy. (2025). LASMnemonicsID: Well log mnemonic identification using lasio and dlisio [Software]. GitHub. https://github.com/Nobleza-Energy/LASMnemonicsID
+
+**BibTeX**
+
+```bibtex
+@software{LASMnemonicsID,
+  author = {Nobleza Energy},
+  title = {LASMnemonicsID: Well log mnemonic identification using lasio and dlisio},
+  year = {2025},
+  publisher = {GitHub},
+  journal = {GitHub repository},
+  url = {https://github.com/Nobleza-Energy/LASMnemonicsID}
+}

lasmnemonicsid-0.0.3rc0/tests/test_las.py

@@ -0,0 +1,42 @@
+
+import lasio
+import pytest
+import pandas as pd
+from pathlib import Path
+from LASMnemonicsID.LAS import parseLAS
+from LASMnemonicsID.utils.mnemonics import (
+    gamma_names, density_names, neutron_names, 
+    dtc_names, sp_names, caliper_names  # All types
+)
+from LASMnemonicsID.utils.mnemonics import find_column
+
+
+def test_parseLAS_single_folder():
+    """Test directory → {filename: df} dict."""
+    data_dir = Path(__file__).parent / 'data'
+    result = parseLAS(data_dir, verbose=False)
+    assert isinstance(result, dict)
+    assert len(result) >= 1  # Adaptive: any # files
+    first_df = next(iter(result.values()))
+    assert isinstance(first_df, pd.DataFrame)
+    assert len(first_df) > 0
+    assert 'GR' in first_df.columns  # Standardization ✓
+
+
+def test_parseLAS_empty_dir():
+    empty_path = Path(__file__).parent / 'empty_dir'
+    empty_path.mkdir(exist_ok=True)
+    result = parseLAS(empty_path, verbose=False)
+    assert result == {}
+    empty_path.rmdir()  # Cleanup
+
+
+def test_parseLAS_single_file():
+    """Test single file → DataFrame."""
+    data_dir = Path(__file__).parent / 'data'
+    sample_las_paths = list(data_dir.glob('*.las'))
+    first_file = sample_las_paths[0]
+    df = parseLAS(first_file, verbose=False)
+    assert isinstance(df, pd.DataFrame)
+    assert len(df) > 0
+    assert 'GR' in df.columns  # Standardization ✓

lasmnemonicsid-0.0.1rc0/README.md

@@ -1,45 +0,0 @@
-
-<p align="center">
-  <img src="https://raw.githubusercontent.com/Nobleza-Energy/LASMnemonicsID/main/logo.png" alt="LASMnemonicsID Logo" width="200"/>
-</p>
-
-<h1 align="center">LASMnemonicsID</h1>
-
-<p align="center">
-  <b>Well log mnemonic identification using lasio and dlisio</b>
-</p>
-
-<p align="center">
-  <a href="https://pypi.org/project/lasmnemonicsid/"><img src="https://img.shields.io/pypi/v/lasmnemonicsid.svg" alt="PyPI"></a>
-  <a href="https://pypi.org/project/lasmnemonicsid/"><img src="https://img.shields.io/pypi/pyversions/lasmnemonicsid.svg" alt="Python Versions"></a>
-  <a href="https://github.com/Nobleza-Energy/LASMnemonicsID/blob/main/LICENSE"><img src="https://img.shields.io/github/license/Nobleza-Energy/LASMnemonicsID.svg" alt="License"></a>
-</p>
-
----
-
-## 📦 Installation
-
-```bash
-pip install lasmnemonicsid
-```
-
-
-
-## 🚀 QuickStart
-```
-from LASMnemonicsID.LAS import parseLAS
-
-# Load LAS file
-df = parseLAS("your_well.las")
-print(df.head())
-```
-
-## 🧪 Test with your Data
-```
-from LASMnemonicsID.LAS import parseLAS
-
-# Load and inspect
-df = parseLAS("path/to/well.las")
-print(f"✅ {len(df)} rows, {len(df.columns)} curves")
-print(df.columns.tolist())
-```

lasmnemonicsid-0.0.1rc0/src/LASMnemonicsID/LAS/LAS.py

@@ -1,148 +0,0 @@
-import LASMnemonicsID.utils.mnemonics as mnm
-from LASMnemonicsID.utils.mnemonics import (
-    gamma_names,
-    sp_names,
-    caliper_names,
-    deepres_names,
-    rxo_names,
-    density_names,
-    density_correction_names,
-    neutron_names,
-    dtc_names,
-    dts_names,
-    pe_names,
-)
-import os
-import pathlib
-import pandas as pd
-import lasio
-from os.path import join
-from sys import stdout
-from pathlib import Path
-
-
-
-
-
-# Function that create the mnemonic dictionary
-def create_mnemonic_dict(
-    gamma_names,
-    sp_names,
-    caliper_names,
-    deepres_names,
-    rxo_names,
-    density_names,
-    density_correction_names,
-    neutron_names,
-    dtc_names,
-    dts_names,
-    pe_names,
-):
-    """
-    Function that create the mnemonic dictionary with the mnemonics per log type in the utils module
-    """
-
-    mnemonic_dict = {
-        "gamma": gamma_names,
-        "sp": sp_names,
-        "caliper": caliper_names,
-        "deepres": deepres_names,
-        "rxo": rxo_names,
-        "density": density_names,
-        "density_correction": density_correction_names,
-        "neutron": neutron_names,
-        "dtc": dtc_names,
-        "dts": dts_names,
-        "pe": pe_names,
-    }
-    return mnemonic_dict
-
-
-
-def parseLAS(directory_path, verbose=True):
-    """
-    Parse all LAS files in directory (recursive) into dict of DataFrames or single DataFrame.
-    
-    Args:
-        directory_path (str/Path): Directory containing LAS files
-        verbose (bool): Print processing info
-        
-    Returns:
-        dict or DataFrame: {folder: {well: df}} or single df if one file found
-    """
-    directory_path = Path(directory_path)
-    well_logs = {}
-    
-    # Find all LAS files recursively
-    las_files = list(directory_path.rglob("*.las"))
-    
-    if not las_files:
-        if verbose:
-            print("No LAS files found.")
-        return {}
-    
-    if len(las_files) == 1:
-        # Return single DataFrame if only one file
-        return _read_single_las(las_files[0], verbose)
-    
-    # Multiple files: group by parent folder
-    for las_file in las_files:
-        folder_name = las_file.parent.name
-        if folder_name not in well_logs:
-            well_logs[folder_name] = {}
-        
-        df = _read_single_las(las_file, verbose)
-        if df is not None:
-            well_name = _get_well_name(las_file)
-            well_logs[folder_name][well_name] = df
-    
-    return well_logs
-
-
-def _read_single_las(las_file_path, verbose):
-    """Read single LAS file to DataFrame"""
-    try:
-        las_data = lasio.read(las_file_path)
-        df = las_data.df()
-        if df is None or df.empty:
-            if verbose:
-                print(f"✗ Empty DataFrame: {las_file_path.name}")
-            return None
-            
-        df.index = df.index.astype(float)
-#        df.dropna(inplace=True)
-        
-        # Standardize GR curve
-        _standardize_gr_curve(las_data, df)
-        
-        if verbose:
-            print(f"✓ {las_file_path.name}")
-        return df
-        
-    except lasio.exceptions.LASHeaderError as e:
-        if verbose:
-            print(f"✗ LASHeaderError in {las_file_path.name}: {e}")
-    except Exception as e:
-        if verbose:
-            print(f"✗ Error in {las_file_path.name}: {type(e).__name__}: {e}")
-    return None
-
-
-def _get_well_name(las_file_path):
-    """Extract well name from LAS file"""
-    try:
-        las_data = lasio.read(las_file_path)
-        return str(las_data.well.WELL.value).strip()
-    except:
-        return las_file_path.stem
-
-
-def _standardize_gr_curve(las_data, df):
-    """Rename gamma ray curve to GR"""
-    global gamma_names  # Assuming gamma_names defined elsewhere
-    for curve in las_data.curves:
-        if curve.mnemonic.lower() in gamma_names:
-            df.rename(columns={curve.mnemonic: "GR"}, inplace=True)
-            break
-
-

lasmnemonicsid-0.0.1rc0/src/LASMnemonicsID/LAS/__init__.py

@@ -1,12 +0,0 @@
-from .LAS import (
-    parseLAS,
-    create_mnemonic_dict,
-    _read_single_las,
-    _get_well_name,
-    _standardize_gr_curve
-)
-
-__all__ = [
-    'parseLAS',
-    'create_mnemonic_dict'
-]

lasmnemonicsid-0.0.1rc0/tests/test_las.py

@@ -1,63 +0,0 @@
-import lasio
-import pytest
-import pandas as pd
-from pathlib import Path
-from LASMnemonicsID.LAS import parseLAS
-from LASMnemonicsID.utils.mnemonics import (
-    gamma_names, density_names, neutron_names, 
-    dtc_names, sp_names, caliper_names  # All types
-)
-from LASMnemonicsID.utils.mnemonics import find_column
-
-
-def test_parseLAS_single_folder(sample_las_paths):
-    result = parseLAS(sample_las_paths[0].parent, verbose=False)
-    assert isinstance(result, dict)
-    assert len(result) == 1  # 'data' folder
-    wells = result['data']
-    assert len(wells) >= 10  # Multiple unique wells now
-    first_df = next(iter(wells.values()))
-    assert isinstance(first_df, pd.DataFrame)
-    assert len(first_df) > 0  # New files have data!
-    assert 'GR' in first_df.columns  # GR standardization
-
-def test_parseLAS_empty_dir():
-    result = parseLAS(Path(__file__).parent / 'empty_dir', verbose=False)
-    assert result == {}
-    
-
-
-# Test for parsing all curves and identifying and renaming all of them into a new dataframe
-def test_parse_all_curves_first_file():
-    data_dir = Path(__file__).parent / 'data'
-    first_file = next(data_dir.glob('*.las'))
-    
-    print(f"🔍 Parsing {first_file.name} for ALL curves...")
-    las_data = lasio.read(first_file)
-    df = las_data.df()
-    
-    # Test ALL curve types with find_column (your utils logic)
-    curve_types = {
-        'gamma': gamma_names,
-        'density': density_names, 
-        'neutron': neutron_names,
-        'dtc': dtc_names,
-        'sp': sp_names,
-        'caliper': caliper_names
-    }
-    
-    found_curves = {}
-    for curve_type, names in curve_types.items():
-        col = find_column(df, curve_type)
-        found_curves[curve_type] = col
-        status = "✅" if col else "❌"
-        print(f"{status} {curve_type.upper()}: {col}")
-    
-    print(f"\n📊 DataFrame: {df.shape}")
-    print("Columns:", list(df.columns[:20]), "...")
-    print("\nHead:")
-    print(df.head(10))
-    
-    # Assert key curves found
-    assert found_curves['gamma']  # GR required
-    assert len(df.columns) > 20