lasmnemonicsid 0.0.2__py3-none-any.whl → 0.0.3rc0__py3-none-any.whl

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-0.0.2.dist-info → lasmnemonicsid-0.0.3rc0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lasmnemonicsid
-Version: 0.0.2
+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.dist-info/RECORD

@@ -0,0 +1,11 @@
+LASMnemonicsID/__init__.py,sha256=IjJHoiHWr1CfP3K01xW61UhnJYP_9LOOaCqJnhLFlPc,309
+LASMnemonicsID/DLIS/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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.3rc0.dist-info/licenses/LICENSE,sha256=6r9JOUiNw1exfcc0jlOi50fDStidfqyQ2PAYQh4lzEQ,1071
+lasmnemonicsid-0.0.3rc0.dist-info/METADATA,sha256=AXUCpIS5uLGwI6yGlBIctpyI0EN-KZGo5u6cimjOi_E,3706
+lasmnemonicsid-0.0.3rc0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+lasmnemonicsid-0.0.3rc0.dist-info/top_level.txt,sha256=bdt6EHMrwbzFA9jA_xbTqRrOV6T4zDs3QojjEz8HSBk,15
+lasmnemonicsid-0.0.3rc0.dist-info/RECORD,,

{lasmnemonicsid-0.0.2.dist-info → lasmnemonicsid-0.0.3rc0.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/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,,