lasmnemonicsid 0.0.2__py3-none-any.whl → 0.0.5__py3-none-any.whl

LASMnemonicsID/ASCII/ASCII.py

@@ -0,0 +1,134 @@
+
+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 pandas as pd
+from pathlib import Path
+
+# Import helper functions from LAS module
+from ..LAS.LAS import create_mnemonic_dict, _standardize_all_curves
+
+
+def parseASCII(input_path, verbose=True, preferred_names=None, depth_col="DEPTH", delimiter=","):
+    """
+    Parse ASCII/CSV/TXT well log file or all in directory → DataFrame or {filename: df}.
+    
+    Args:
+        input_path (str/Path): ASCII/CSV/TXT file or directory
+        verbose (bool): Print info
+        preferred_names (dict, optional): Mapping of curve types to preferred column names.
+            Example: {"deepres": "RT", "gamma": "GR"}
+            If not provided, defaults to standard petrophysical names.
+        depth_col (str): Name of depth column (default: "DEPTH")
+        delimiter (str): CSV delimiter (default: ",")
+        
+    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)
+    
+    # All supported ASCII extensions (case-insensitive)
+    ascii_extensions = ['.csv', '.txt', '.asc', '.dat', '.ascii']
+    
+    # Case 1: Single File
+    if input_path.is_file() and input_path.suffix.lower() in ascii_extensions:
+        df = _read_single_ascii(input_path, verbose, std_names, depth_col, delimiter)
+        return df if df is not None else None
+    
+    # Case 2: Directory (Recursive) - CASE-INSENSITIVE
+    ascii_files = [f for f in input_path.rglob("*") if f.suffix.lower() in ascii_extensions]
+    if not ascii_files:
+        if verbose:
+            print(f"No ASCII/CSV files found in {input_path}")
+        return {}
+    
+    ascii_dict = {}
+    for ascii_file in ascii_files:
+        df = _read_single_ascii(ascii_file, verbose, std_names, depth_col, delimiter)
+        if df is not None:
+            filename = ascii_file.name
+            ascii_dict[filename] = df
+    
+    # Return single DF if only 1 file found, else dict
+    if len(ascii_dict) == 1:
+        return next(iter(ascii_dict.values()))
+    
+    return ascii_dict
+
+
+def _read_single_ascii(ascii_file_path, verbose, std_names, depth_col, delimiter):
+    """Read single ASCII/CSV file to DataFrame and standardize ALL curves."""
+    try:
+        # Try reading the file
+        df = pd.read_csv(ascii_file_path, delimiter=delimiter)
+        
+        if df.empty:
+            if verbose:
+                print(f"✗ Empty DataFrame: {ascii_file_path.name}")
+            return None
+        
+        # Handle depth column (case-insensitive)
+        depth_cols = [col for col in df.columns if col.upper() == depth_col.upper()]
+        if depth_cols:
+            df.set_index(depth_cols[0], inplace=True)
+        else:
+            # Use first column as depth
+            df.set_index(df.columns[0], inplace=True)
+        
+        # Ensure index is float
+        df.index = df.index.astype(float)
+        df.index.name = "DEPTH"
+        
+        # Create fake las_data object for standardization
+        class FakeLASData:
+            pass
+        
+        fake_las = FakeLASData()
+        
+        # Standardize ALL curves (GR, RHOB, NPHI, etc.)
+        _standardize_all_curves(fake_las, df, std_names)
+        
+        if verbose:
+            print(f"✓ {ascii_file_path.name}")
+        return df
+        
+    except Exception as e:
+        if verbose:
+            print(f"✗ Error in {ascii_file_path.name}: {type(e).__name__}: {e}")
+    return None
+
+
+def _get_well_name(ascii_file_path):
+    """Extract well name from ASCII file (use filename)"""
+    return ascii_file_path.stem

LASMnemonicsID/ASCII/__init__.py

@@ -0,0 +1,2 @@
+
+from .ASCII import *

LASMnemonicsID/DLIS/DLIS.py

@@ -0,0 +1,150 @@
+
+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 pandas as pd
+import dlisio
+from pathlib import Path
+
+# Import helper functions from LAS module
+from ..LAS.LAS import create_mnemonic_dict, _standardize_all_curves
+
+
+def parseDLIS(input_path, verbose=True, preferred_names=None):
+    """
+    Parse DLIS file or all in directory → DataFrame or {filename: df}.
+    
+    Args:
+        input_path (str/Path): DLIS file or directory
+        verbose (bool): Print info
+        preferred_names (dict, optional): Mapping of curve types to preferred column names.
+            Example: {"deepres": "RT", "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 (case-insensitive)
+    if input_path.is_file() and input_path.suffix.lower() == '.dlis':
+        df = _read_single_dlis(input_path, verbose, std_names)
+        return df if df is not None else None
+    
+    # Case 2: Directory (Recursive) - CASE-INSENSITIVE
+    dlis_files = [f for f in input_path.rglob("*") if f.suffix.lower() == '.dlis']
+    if not dlis_files:
+        if verbose:
+            print(f"No DLIS files found in {input_path}")
+        return {}
+    
+    dlis_dict = {}
+    for dlis_file in dlis_files:
+        df = _read_single_dlis(dlis_file, verbose, std_names)
+        if df is not None:
+            filename = dlis_file.name
+            dlis_dict[filename] = df
+    
+    # Return single DF if only 1 file found, else dict
+    if len(dlis_dict) == 1:
+        return next(iter(dlis_dict.values()))
+    
+    return dlis_dict
+
+
+def _read_single_dlis(dlis_file_path, verbose, std_names):
+    """Read single DLIS file to DataFrame and standardize ALL curves."""
+    try:
+        with dlisio.dlis.load(str(dlis_file_path)) as (f, *rest):
+            if not f.frames:
+                if verbose:
+                    print(f"✗ No frames: {dlis_file_path.name}")
+                return None
+            
+            # Use first frame (typically contains main log data)
+            frame = f.frames[0]
+            curves_data = frame.curves()
+            
+            # Get channel names
+            channels = [ch.name for ch in frame.channels]
+            
+            # Create DataFrame
+            df = pd.DataFrame(curves_data, columns=channels)
+            
+            if df.empty:
+                if verbose:
+                    print(f"✗ Empty DataFrame: {dlis_file_path.name}")
+                return None
+            
+            # Set depth index (typically first column or frame.index)
+            if frame.index:
+                index_name = frame.index
+                if index_name in df.columns:
+                    df.set_index(index_name, inplace=True)
+            else:
+                # Use first column as depth
+                df.set_index(df.columns[0], inplace=True)
+            
+            # Ensure index is float
+            df.index = df.index.astype(float)
+            df.index.name = "DEPTH"
+            
+            # Create fake las_data object for standardization
+            class FakeLASData:
+                pass
+            
+            fake_las = FakeLASData()
+            
+            # Standardize ALL curves (GR, RHOB, NPHI, etc.)
+            _standardize_all_curves(fake_las, df, std_names)
+            
+            if verbose:
+                print(f"✓ {dlis_file_path.name}")
+            return df
+            
+    except Exception as e:
+        if verbose:
+            print(f"✗ Error in {dlis_file_path.name}: {type(e).__name__}: {e}")
+    return None
+
+
+def _get_well_name(dlis_file_path):
+    """Extract well name from DLIS file"""
+    try:
+        with dlisio.dlis.load(str(dlis_file_path)) as (f, *rest):
+            if f.origins:
+                return str(f.origins[0].well_name).strip()
+    except:
+        pass
+    return dlis_file_path.stem

LASMnemonicsID/DLIS/__init__.py

@@ -0,0 +1,2 @@
+
+from .DLIS import parseDLIS

LASMnemonicsID/LAS/LAS.py

@@ -20,11 +20,7 @@ from os.path import join
 from sys import stdout
 from pathlib import Path
 
-
-
-
-
-# Function that create the mnemonic dictionary
+# Function that creates the mnemonic dictionary
 def create_mnemonic_dict(
     gamma_names,
     sp_names,
@@ -39,9 +35,8 @@ def create_mnemonic_dict(
     pe_names,
 ):
     """
-    Function that create the mnemonic dictionary with the mnemonics per log type in the utils module
+    Function that creates the mnemonic dictionary with the mnemonics per log type.
     """
-
     mnemonic_dict = {
         "gamma": gamma_names,
         "sp": sp_names,
@@ -57,63 +52,82 @@ def create_mnemonic_dict(
     }
     return mnemonic_dict
 
-
-
-def parseLAS(directory_path, verbose=True):
+def parseLAS(input_path, verbose=True, preferred_names=None):
     """
-    Parse all LAS files in directory (recursive) into dict of DataFrames or single DataFrame.
+    Parse LAS file or all in directory → DataFrame or {filename: df}.
     
     Args:
-        directory_path (str/Path): Directory containing LAS files
-        verbose (bool): Print processing info
+        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:
-        dict or DataFrame: {folder: {well: df}} or single df if one file found
+        DataFrame (single) or dict {filename: df} (multiple/dir)
     """
-    directory_path = Path(directory_path)
-    well_logs = {}
+    input_path = Path(input_path)
     
-    # Find all LAS files recursively
-    las_files = list(directory_path.rglob("*.las"))
+    # 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("No LAS files found.")
+            print(f"No LAS files found in {input_path}")
         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
+    las_dict = {}
     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)
+        df = _read_single_las(las_file, verbose, std_names)
         if df is not None:
-            well_name = _get_well_name(las_file)
-            well_logs[folder_name][well_name] = df
+            filename = las_file.name
+            las_dict[filename] = df
     
-    return well_logs
-
+    # 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):
-    """Read single LAS file to DataFrame"""
+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)
-#        df.dropna(inplace=True)
         
-        # Standardize GR curve
-        _standardize_gr_curve(las_data, df)
+        # Standardize ALL curves (GR, RHOB, NPHI, etc.)
+        _standardize_all_curves(las_data, df, std_names)
         
         if verbose:
             print(f"✓ {las_file_path.name}")
@@ -127,7 +141,6 @@ def _read_single_las(las_file_path, 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:
@@ -136,13 +149,46 @@ def _get_well_name(las_file_path):
     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()
 
-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
-
+    # 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/LAS/__init__.py

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

LASMnemonicsID/__init__.py

@@ -1,16 +1,15 @@
-
 # src/LASMnemonicsID/__init__.py
 
 """LASMnemonicsID package for well log analysis."""
 
-# Import submodules as objects
 from . import LAS
-#from . import DLIS
+from . import DLIS
+from . import ASCII
 from . import utils
 
-# Import all functions directly for convenience
-from .LAS import *
-from .DLIS import *
-from .utils import *
+from .LAS.LAS import *
+from .DLIS.DLIS import *
+from .ASCII.ASCII import *
+from .utils.mnemonics import *
 
 __version__ = "0.0.1"

lasmnemonicsid-0.0.5.dist-info/METADATA

@@ -0,0 +1,276 @@
+Metadata-Version: 2.4
+Name: lasmnemonicsid
+Version: 0.0.5
+Summary: Well log mnemonic identification using lasio and dlisio to load LAS/DLIS/ASCII files into DataFrames
+Author-email: Nobleza Energy <info@nobleza-energy.com>
+License: MIT
+Project-URL: Homepage, https://nobleza-energy.github.io/LASMnemonicsID
+Project-URL: Repository, https://github.com/Nobleza-Energy/LASMnemonicsID
+Project-URL: Documentation, https://nobleza-energy.github.io/LASMnemonicsID/
+Project-URL: Bug Tracker, https://github.com/Nobleza-Energy/LASMnemonicsID/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: pandas>=2.0.1
+Requires-Dist: lasio>=0.30
+Requires-Dist: dlisio>=1.0.0
+Provides-Extra: docs
+Requires-Dist: mkdocs>=1.5.0; extra == "docs"
+Requires-Dist: mkdocs-material>=9.0.0; extra == "docs"
+Requires-Dist: mkdocstrings[python]>=0.24.0; extra == "docs"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: isort>=5.12.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Dynamic: license-file
+
+# LASMnemonicsID
+
+<p align="center">
+  <img src="https://github.com/Nobleza-Energy/LASMnemonicsID/blob/e44bfb606fef5cfc9c3df6e41c3d1bd0d7bb08ae/logo.png?raw=true" alt="LASMnemonicsID Logo" width="200"/>
+</p>
+
+<p align="center">
+  <b>Well log mnemonic identification and standardization for LAS, DLIS, and ASCII formats</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>
+
+---
+
+## Features
+
+- **Multi-format support**: LAS, DLIS, ASCII/CSV/TXT/DAT
+- **Automatic mnemonic standardization**: GR, RHOB, NPHI, DT, SP, CALI, RT, etc.
+- **Batch processing**: Parse entire directories recursively
+- **Customizable naming**: Override default standard names
+- **Case-insensitive extensions**: Works with .las/.LAS, .dlis/.DLIS, .csv/.CSV, etc.
+- **Pandas integration**: Returns clean DataFrames ready for analysis
+
+---
+
+## Installation
+
+```bash
+pip install lasmnemonicsid
+```
+
+This installs support for **all formats** (LAS, DLIS, ASCII/CSV/TXT).
+
+---
+
+## Quick Start
+
+### LAS Files
+
+```python
+from LASMnemonicsID import parseLAS
+
+# Parse single LAS file
+df = parseLAS("well.las")
+print(df.head())
+
+# Parse directory
+data = parseLAS("/path/to/las/files/")
+for filename, df in data.items():
+    print(f"{filename}: {df.shape}")
+```
+
+### DLIS Files
+
+```python
+from LASMnemonicsID import parseDLIS
+
+# Parse single DLIS file
+df = parseDLIS("well.dlis")
+print(df.columns)
+
+# Parse directory
+data = parseDLIS("/path/to/dlis/files/")
+```
+
+### ASCII/CSV/TXT Files
+
+```python
+from LASMnemonicsID import parseASCII
+
+# Parse CSV
+df = parseASCII("well_log.csv", depth_col="DEPTH")
+
+# Parse tab-separated TXT
+df = parseASCII("well_log.txt", delimiter="\t")
+
+# Parse directory
+data = parseASCII("/path/to/csv/files/")
+```
+
+---
+
+## Advanced Usage
+
+### Custom Preferred Names
+
+```python
+preferred = {
+    "deepres": "RT",
+    "deepres_preferred_original": "AT90",
+    "gamma": "GR"
+}
+
+df = parseLAS("well.las", preferred_names=preferred)
+```
+
+### Batch Processing
+
+```python
+from pathlib import Path
+
+dir_path = Path("/data/wells/")
+data = parseLAS(dir_path, verbose=True, preferred_names=preferred)
+
+for fname, df in data.items():
+    print(f"{fname}: {df.shape}")
+    print(df.head(3))
+```
+
+### Mixed Format Directories
+
+```python
+las_data = parseLAS("/data/wells/")
+dlis_data = parseDLIS("/data/wells/")
+ascii_data = parseASCII("/data/wells/")
+
+all_data = {**las_data, **dlis_data, **ascii_data}
+```
+
+---
+
+## Supported Mnemonics
+
+The package automatically standardizes these curve types:
+
+| Curve Type | Standard Name | Example Aliases |
+|------------|---------------|-------------|
+| Gamma Ray | `GR` | gr, cggr, cgr, gam, gamma, gammaray, grc, grd, hgr, sgr, lgr, pgr |
+| Spontaneous Potential | `SP` | sp, idsp, spr, spl, spdl, spdhp, spc, sp0, sp1, cgsp, dlsp |
+| Caliper | `CALI` | caliper, calip, cal, dcal, acal, cala, cald, cale, calh, hcal, xcal, ycal |
+| Deep Resistivity | `RT` | rt, rtao, rt90, ild, idph, rild, rd, ae90, at90, atrt, lld, lldc, res, resd |
+| Shallow Resistivity | `RXO` | rxo, rxoz, msfl, mcfl, sflcc, mgl, m1rx, r40o, aht10 |
+| Density | `RHOB` | rhob, rhoz, den, denb, denc, hrho, hrhob, zden, hden, denf, denn |
+| Density Correction | `DRHO` | dcor, dcorr, dc, decr, drh, zcor, zcorr, hhdr, denscorr |
+| Neutron Porosity | `NPHI` | cn, phin, cnc, cns, hnphi, nphi, npor, cncc, nprl, neut, neutpor |
+| Sonic (Compressional) | `DT` | dt, dtc, dtco, dtcomp, deltat, slow, slowness, tt, ac, acco, delt, dtcomp |
+| Sonic (Shear) | `DTS` | dts, dtsh, dtsm, dtsc, dtsd, dtsqi, dtshear, deltas, tts, stt, dtshear |
+| Photoelectric Factor | `PEF` | pe, pef, pefz, pdpe, pedf, pedn, hpedn, pe2, pef8, lpe |
+
+
+---
+
+## Testing
+
+```bash
+pytest tests/ -v
+pytest tests/test_las.py -v
+pytest tests/test_dlis.py -v
+pytest tests/test_ascii.py -v
+```
+
+---
+
+## API Reference
+
+### parseLAS(input_path, verbose=True, preferred_names=None)
+
+Parse LAS file(s) and standardize mnemonics.
+
+**Parameters:**
+- input_path (str/Path): LAS file or directory
+- verbose (bool): Print parsing info
+- preferred_names (dict): Custom name mappings
+
+**Returns:** DataFrame (single file) or dict (multiple files)
+
+### parseDLIS(input_path, verbose=True, preferred_names=None)
+
+Parse DLIS file(s) and standardize mnemonics.
+
+**Parameters:**
+- input_path (str/Path): DLIS file or directory
+- verbose (bool): Print parsing info
+- preferred_names (dict): Custom name mappings
+
+**Returns:** DataFrame (single file) or dict (multiple files)
+
+### parseASCII(input_path, verbose=True, preferred_names=None, depth_col="DEPTH", delimiter=",")
+
+Parse ASCII/CSV/TXT file(s) and standardize mnemonics.
+
+**Parameters:**
+- input_path (str/Path): ASCII file or directory
+- verbose (bool): Print parsing info
+- preferred_names (dict): Custom name mappings
+- depth_col (str): Name of depth column
+- delimiter (str): Field separator
+
+**Returns:** DataFrame (single file) or dict (multiple files)
+
+---
+
+## How to Cite
+
+**APA**
+
+> Nobleza Energy. (2026). LASMnemonicsID: Well log mnemonic identification for LAS, DLIS, and ASCII formats [Software]. GitHub. https://github.com/Nobleza-Energy/LASMnemonicsID
+
+**BibTeX**
+
+```bibtex
+@software{LASMnemonicsID,
+  author = {Nobleza Energy},
+  title = {LASMnemonicsID: Well log mnemonic identification for LAS, DLIS, and ASCII formats},
+  year = {2026},
+  publisher = {GitHub},
+  url = {https://github.com/Nobleza-Energy/LASMnemonicsID}
+}
+```
+
+---
+
+## License
+
+MIT License - see [LICENSE](LICENSE) file.
+
+---
+
+## Contributing
+
+Contributions welcome! Submit a Pull Request.
+
+---
+
+## Support
+
+- **Issues:** [GitHub Issues](https://github.com/Nobleza-Energy/LASMnemonicsID/issues)
+- **Discussions:** [GitHub Discussions](https://github.com/Nobleza-Energy/LASMnemonicsID/discussions)
+
+---
+
+<p align="center">
+  Made with ❤️ by <a href="https://nobleza-energy.com">Nobleza Energy</a>
+</p>

lasmnemonicsid-0.0.5.dist-info/RECORD

@@ -0,0 +1,14 @@
+LASMnemonicsID/__init__.py,sha256=gsIy4CT1aZrfdm7yngD5CyGx0c0VrUS-2kL9aPMWqNU,294
+LASMnemonicsID/ASCII/ASCII.py,sha256=55_KyVai0W6WABAav-tqx5XvZOOrnxYspjoAbcbF0ws,4260
+LASMnemonicsID/ASCII/__init__.py,sha256=hvl0pDTh7kEEGMi2D36hw17ftnWY6SOM3IkxBNcaaLQ,22
+LASMnemonicsID/DLIS/DLIS.py,sha256=byYJoKAiahlKUORt5c_iZZ4aQmjdiDIXLp2Qr7Hbiyk,4663
+LASMnemonicsID/DLIS/__init__.py,sha256=UVM8tn6cpFT8H-wl7mqMDiE8GObkIWbYR-FGq4Oqoj8,29
+LASMnemonicsID/LAS/LAS.py,sha256=gxeLlARZJV3ECxIQaoqO8YeOUfnlMUBKXqRFY-JivCs,6048
+LASMnemonicsID/LAS/__init__.py,sha256=dTM87nn0zNUaKp29HocOODJT_-VM1CZED9Ar_FSOr-4,232
+LASMnemonicsID/utils/__init__.py,sha256=ree81DUTsdjXfO3h-q7YyNrV6mTIKSGxgWPWGGTSVU0,1388
+LASMnemonicsID/utils/mnemonics.py,sha256=VU25CXmQvUo0sS3Y6kG_G7KwRE2CiuoJeC7LT6FmNzg,7283
+lasmnemonicsid-0.0.5.dist-info/licenses/LICENSE,sha256=6r9JOUiNw1exfcc0jlOi50fDStidfqyQ2PAYQh4lzEQ,1071
+lasmnemonicsid-0.0.5.dist-info/METADATA,sha256=F9TC9atDWz404-_5_4V6L73WTkYJrv1iIbhr6osc2xA,7852
+lasmnemonicsid-0.0.5.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+lasmnemonicsid-0.0.5.dist-info/top_level.txt,sha256=bdt6EHMrwbzFA9jA_xbTqRrOV6T4zDs3QojjEz8HSBk,15
+lasmnemonicsid-0.0.5.dist-info/RECORD,,

{lasmnemonicsid-0.0.2.dist-info → lasmnemonicsid-0.0.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

lasmnemonicsid-0.0.2.dist-info/METADATA

@@ -1,83 +0,0 @@
-Metadata-Version: 2.4
-Name: lasmnemonicsid
-Version: 0.0.2
-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
-Project-URL: Homepage, https://nobleza-energy.github.io/LASMnemonicsID
-Project-URL: Repository, https://github.com/Nobleza-Energy/LASMnemonicsID
-Project-URL: Documentation, https://nobleza-energy.github.io/LASMnemonicsID/
-Project-URL: Bug Tracker, https://github.com/Nobleza-Energy/LASMnemonicsID/issues
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: numpy>=1.21.0
-Requires-Dist: pandas>=2.0.1
-Requires-Dist: lasio>=0.30
-Requires-Dist: dlisio>=1.0.0
-Provides-Extra: docs
-Requires-Dist: mkdocs>=1.5.0; extra == "docs"
-Requires-Dist: mkdocs-material>=9.0.0; extra == "docs"
-Requires-Dist: mkdocstrings[python]>=0.24.0; extra == "docs"
-Provides-Extra: dev
-Requires-Dist: pytest>=7.0.0; extra == "dev"
-Requires-Dist: black>=23.0.0; extra == "dev"
-Requires-Dist: isort>=5.12.0; extra == "dev"
-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>
-
-<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.2.dist-info/RECORD

@@ -1,11 +0,0 @@
-LASMnemonicsID/__init__.py,sha256=IjJHoiHWr1CfP3K01xW61UhnJYP_9LOOaCqJnhLFlPc,309
-LASMnemonicsID/DLIS/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-LASMnemonicsID/LAS/LAS.py,sha256=7WRetjZG9-M39KNxpUisAkbh8mv60BWW-uTEUkwvkF8,3849
-LASMnemonicsID/LAS/__init__.py,sha256=4cNesZ581Cl_PN_c4DHTGfkc5HiKtnbhP81vJ6-3nPM,187
-LASMnemonicsID/utils/__init__.py,sha256=ree81DUTsdjXfO3h-q7YyNrV6mTIKSGxgWPWGGTSVU0,1388
-LASMnemonicsID/utils/mnemonics.py,sha256=VU25CXmQvUo0sS3Y6kG_G7KwRE2CiuoJeC7LT6FmNzg,7283
-lasmnemonicsid-0.0.2.dist-info/licenses/LICENSE,sha256=6r9JOUiNw1exfcc0jlOi50fDStidfqyQ2PAYQh4lzEQ,1071
-lasmnemonicsid-0.0.2.dist-info/METADATA,sha256=9XdXauxiGe80GgPo9GWFrbAjSGxoyOibBPmGPmJ-WLk,2811
-lasmnemonicsid-0.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lasmnemonicsid-0.0.2.dist-info/top_level.txt,sha256=bdt6EHMrwbzFA9jA_xbTqRrOV6T4zDs3QojjEz8HSBk,15
-lasmnemonicsid-0.0.2.dist-info/RECORD,,