stoneforge 0.2.0b2__tar.gz → 0.2.0b3__tar.gz

{stoneforge-0.2.0b2/stoneforge.egg-info → stoneforge-0.2.0b3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stoneforge
-Version: 0.2.0b2
+Version: 0.2.0b3
 Summary: Geophysics equations, algorithms and methods
 Author: GIECAR - UFF, Wagner M. Lupinacci, Fernando Vizeu, Fábio Júnior D Fernandes, José A. V. Dias, Mario M. Ramos, Jordan S. Cuno, João Vitor A. Estrella, Ana Carolina, Breno D. Chrispim
 License-Expression: MIT
@@ -21,7 +21,6 @@ Requires-Dist: matplotlib>=3.10.0
 Requires-Dist: pandas>=2.2.2
 Requires-Dist: lightgbm>=4.5.0
 Requires-Dist: ipympl>=0.8.4
-Requires-Dist: ipykernel>=6.30.0
 Dynamic: license-file
 
 <p align="center">

{stoneforge-0.2.0b2 → stoneforge-0.2.0b3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "stoneforge"
-version = "0.2.0-beta.2"
+version = "0.2.0-beta.3"
 authors = [
     {name = "GIECAR - UFF"},
     {name = "Wagner M. Lupinacci"},
@@ -27,7 +27,6 @@ dependencies = [
     "pandas>=2.2.2",
     "lightgbm>=4.5.0",
     "ipympl>=0.8.4",
-    "ipykernel>=6.30.0",
 ]
 classifiers = [
     "Development Status :: 5 - Production/Stable",

{stoneforge-0.2.0b2 → stoneforge-0.2.0b3}/stoneforge/io/__init__.py

@@ -1,3 +1,5 @@
 from . import dlisio_r  # noqa: F401
 from . import las2  # noqa: F401
+from . import las3  # noqa: F401
+from . import tabr  # noqa: F401
 from . import csv  # noqa: F401

{stoneforge-0.2.0b2 → stoneforge-0.2.0b3}/stoneforge/io/dlisio_r.py

@@ -37,7 +37,69 @@ class DLISAccess:
         return self.selected_header_df
             
     def get_info(self):
-        return self.dlis_dict_headers
+        """Module to get the DLIS file structure in a dictionary format."""
+        info = self.dlis_dict_headers
+        index = 0
+        d_file_data = {}  # store DataFrames per frame
+
+        for d_file in info:
+            frames_data = {}
+            for frame in info[d_file]:
+                rows = []
+                for mnemonic in info[d_file][frame]:
+                    _data_info = info[d_file][frame][mnemonic]
+                    _unit = _data_info['unit']
+                    _dim = _data_info['dim']
+                    _min = _data_info['min']
+                    _max = _data_info['max']
+                    _long_name = _data_info['long_name']
+                    rows.append((index, mnemonic, _unit, _dim, _min, _max, _long_name))
+                    index += 1
+                
+                # Create DataFrame for this frame
+                df = pd.DataFrame(rows, columns=["Index", "Mnemonic", "Unit", "Dim", "Min", "Max", "Long Name"])
+                df.set_index('Index', inplace=True)
+
+                frames_data[frame] = df
+            d_file_data[d_file] = frames_data
+        return d_file_data
+    
+    def mnemonic_search(self, mnemonics_list):
+        """"Module to search for mnemonics in the DLIS file headers. 
+        The search is case-sensitive and returns data for the matching mnemonics.
+        
+        Parameters
+        ----------
+        mnemonics_list : list
+            List of mnemonics to search for in the DLIS file headers.
+            
+        Returns
+        -------
+        dict
+            A dictionary containing the parsed DLIS data based on the searched mnemonics with the structure
+            {digital_file: {frame_name: {mnemonic: {unit, values}}}}
+        """
+        
+        info = self.dlis_dict_headers
+        index = 0
+        full_mnemonics = []  # store DataFrames per frame
+
+        for d_file in info:
+            frames_data = {}
+            for frame in info[d_file]:
+                rows = []
+                for mnemonic in info[d_file][frame]:
+                    full_mnemonics.append(mnemonic)
+
+        # find positions of matches
+        positions = [i for mnemonic in mnemonics_list 
+                    for i, val in enumerate(full_mnemonics) if val == mnemonic]
+        
+        positions = sorted(positions)
+        
+        self.select_header(idx=positions)
+        return self.get_data()
+
         
     def get_data(self):
         """Module to get the data selected in the checkbox.
@@ -311,8 +373,8 @@ class DLISAccess:
                             values = np.array(channel.curves())  # Convert to numpy array
 
                             extracted_data[logical_file_id][frame_name][mnemonic] = {
-                                'unit': unit,
-                                'values': values
+                                'values': values,
+                                'unit': unit
                             }
 
         return extracted_data

{stoneforge-0.2.0b2 → stoneforge-0.2.0b3}/stoneforge/io/las2.py

@@ -1,12 +1,12 @@
 import re
 import numpy as np
 import io
+import pandas as pd
 
 
 class LAS2Error(Exception):
     pass
 
-
 _default_line_format_format = (
     "{{mnemonic:<{mnemonic}}}."
     "{{unit:<{unit}}} "
@@ -84,6 +84,77 @@ _parsers = {
     "data": _parse_data_section,
 }
 
+class LAS2Parser:
+
+    def __init__(self, file_path):
+        """Manages the contents of a LAS 2.0 file
+        
+        Parameters
+        ----------
+        file_path : str
+            The path to the LAS 2.0 file to be read.
+        
+        Attributes
+        ----------
+        data : dict
+            A dictionary containing the well log data and metadata.
+        header : dict
+            A dictionary containing the header information of the LAS file.
+
+        Notes
+        -----
+        The structure of the returned dictionary is specified below.
+        The dictionary keys are the section names: 'version', 'well', 'parameter', 'curve', 'other', 'data'.
+        Not all sections must be present on a LAS 2.0 file.
+        For more information on the contents of each section, please refer to the LAS 2.0 standard [1]_.
+
+        The value of the 'data' section is a numpy ndarray where each row contains the data for a well log.
+
+        The value of the 'other' section is a list of lines exactly as found on the original file.
+
+        For all other sections, the values are dictionaries containing four keys: 'mnemonic', 'unit', 'value' and
+        'description'.
+        For information on the structure of a LAS 2.0 line, please also refer to its specification [1]_.
+
+        References
+        ----------
+        .. [1] LAS 2.0 standard - http://www.cwls.org/wp-content/uploads/2017/02/Las2_Update_Feb2017.pdf -
+        Retrieved August 14, 2019
+        
+        """
+        self.filepath = file_path
+        self.data = {}
+        self.header = {}
+
+        self._parser()
+
+    def _parser(self):
+        las2_file_path = self.filepath
+        las_data = read(las2_file_path)
+        header = {}
+        for key in las_data:
+            if key not in ['data']:
+                df = pd.DataFrame(las_data[key])
+                header[key] = df
+            data_header = list(las_data['curve'])
+        
+        log_main_data = {}
+        ii = 0
+        log_data = las_data['data']
+        for _log in data_header:
+            _mnem = _log['mnemonic']
+            _unit = _log['unit']
+            try:
+                _descr = _log['description']
+            except:
+                _descr = 'NONE'
+            _data = log_data[ii]
+            log_main_data[_mnem] = {'values':_data,'unit':_unit,'description':_descr}
+            ii += 1
+
+        self.data = log_main_data
+        self.header = header
+
 
 def read(lasfile):
     """Reads the contents of a LAS 2.0 file.
@@ -93,12 +164,12 @@ def read(lasfile):
     lasfile : string or file-like object
         The path of the file to read or an existing file-like object to read from.
 
-    Returns:
+    Returns
     -------
     dict
         A dictionary containing the sections of the LAS file.
 
-    Notes:
+    Notes
     -----
     The structure of the returned dictionary is specified below.
     The dictionary keys are the section names: 'version', 'well', 'parameter', 'curve', 'other', 'data'.
@@ -113,7 +184,7 @@ def read(lasfile):
     'description'.
     For information on the structure of a LAS 2.0 line, please also refer to its specification [1]_.
 
-    References:
+    References
     ----------
     .. [1] LAS 2.0 standard - http://www.cwls.org/wp-content/uploads/2017/02/Las2_Update_Feb2017.pdf -
        Retrieved August 14, 2019

stoneforge-0.2.0b3/stoneforge/io/las3.py

@@ -0,0 +1,180 @@
+import pandas as pd
+import numpy as np
+from collections import Counter
+import re
+
+class LAS3Parser:
+
+    def __init__(self, las3_file_path):
+        self.filepath = las3_file_path
+        self.data = self.parse_las3()
+        self.tables = list(self.data.keys())
+
+    def force_association(self, to_dict = True, forced=True, sep = "|"):
+        """
+        Given the parsed data dictionary and a description string,
+        return the associated DataFrame if it exists.
+        This method forces the association even if the description is not found.
+        """
+        _data = []
+        _desc = []
+        _clen = []
+
+        for i, k1 in enumerate(self.tables):
+            for j, k2 in enumerate(self.tables):
+                if i != j:
+                    # clean k2 if it has "|"
+                    k2_clean = k2.split("|")[0].strip()
+                    if k1 in k2:
+                        _data.append(k2)
+                        _desc.append(k1)
+                        _clen.append(k2_clean)
+
+        # --- remove all duplicates in _desc completely ---
+        counts = Counter(_desc)
+
+        _data_unique = []
+        _desc_unique = []
+        _clen_unique = []
+
+        for d, desc, c in zip(_data, _desc, _clen):
+            if counts[desc] == 1:  # keep only if desc is unique
+                _data_unique.append(d)
+                _desc_unique.append(desc)
+                _clen_unique.append(c)
+
+        for i in range(len(_desc_unique)):
+            _name = _clen_unique[i]
+            _key = _data_unique[i]
+            _val = _desc_unique[i]
+
+            self.data[_name] = self.table_association(_key, _val, forced=forced, to_dict = to_dict)
+            self.data.pop(_key)
+            self.data.pop(_val)
+
+        self.tables = list(self.data.keys())
+
+    def table_association(self, data, description, forced=True, to_dict = True):
+        """
+        Given the parsed data dictionary and a description string,
+        return the associated DataFrame if it exists.
+        """
+        
+        if forced:
+            try:
+                _desc = list(self.data[description][0])
+                _mnem = []
+                _unit = []
+
+                for item in _desc:
+                    # split only on first "."
+                    parts = item.split('.', 1)
+                    left = parts[0].strip().replace(" ", "")  # remove blanks and dot
+                    right = '.' + parts[1].strip() if len(parts) > 1 else ''  # keep dot, strip spaces
+                    
+                    _mnem.append(left)
+                    _unit.append(right)
+            except KeyError:
+                Warning (f"Description '{description}' not found in data. Using raw mnemonics and units.")
+                _mnem = list(_desc = list(self.data[description][0]))
+                _unit = list(_desc = list(self.data[description][1]))
+        else:
+            _mnem = list(_desc = list(self.data[description][0]))
+            _unit = list(_desc = list(self.data[description][1]))
+
+        self.data[data].columns = _mnem
+        main_data = self.data[data]
+        if to_dict:
+            main_data = main_data.to_dict(orient="list")
+
+            converted_data = {}
+            for key, values in main_data.items():
+                try:
+                    # Try converting to float
+                    converted_data[key] = np.array(values, dtype=float)
+                except ValueError:
+                    Warning(f"Could not convert column '{key}' to float. Keeping as string array.")
+                    # If fails, keep as string array
+                    converted_data[key] = np.array(values, dtype=str)
+
+            main_data = converted_data
+
+        overall_data = {}
+        for i in range(len(_mnem)):
+            _m = _mnem[i]
+            _u = _unit[i]
+            overall_data[_m] = {'values': main_data[_m], 'unit': _u}
+
+        return overall_data
+
+    def parse_las3(self):
+        "Take the path to a LAS3 file and return a dictionary of DataFrames, one for each section. utf-8 based"
+        data_sections = {}
+        current_key = None
+        current_data_lines = []
+
+        with open(self.filepath, 'r', encoding='utf-8') as file:
+            for line in file:
+                stripped = line.strip()
+
+                # Skip blank lines and comments
+                if not stripped or stripped.startswith('#'):
+                    continue
+
+                if stripped.startswith('~'):
+                    # Save previous section
+                    if current_key and current_data_lines:
+                        df = self._parse_data_block(current_data_lines)
+                        data_sections[current_key] = df
+                        current_data_lines = []
+
+                    current_key = stripped.lstrip('~').strip()
+                else:
+                    current_data_lines.append(stripped)
+
+            # Add the final section
+            if current_key and current_data_lines:
+                df = self._parse_data_block(current_data_lines)
+                data_sections[current_key] = df
+
+        return data_sections
+
+    def _parse_data_block(self, lines):
+        "Try to read the elements of a data block, first with default tab/space/colon logic, then with comma."
+        structured_data = []
+
+        # First parse with default (tab/space/colon) logic
+        for line in lines:
+            line = line.rstrip()
+            if not line.strip():
+                continue
+
+            parts = re.split(r'(?:\t| {4,})', line, maxsplit=1)
+
+            if len(parts) == 2:
+                key = parts[0].strip()
+                rest = parts[1].strip()
+                rest_parts = re.split(r'\s*:\s*', rest, maxsplit=1)
+
+                if len(rest_parts) == 2:
+                    structured_data.append([key, rest_parts[0].strip(), rest_parts[1].strip()])
+                else:
+                    structured_data.append([key, rest.strip(), ""])
+            else:
+                structured_data.append([parts[0].strip(), "", ""])
+
+        # Create initial DataFrame and drop empty columns
+        df_original = pd.DataFrame(structured_data)
+        df_original = df_original.loc[:, ~df_original.apply(lambda col: col.astype(str).str.strip().eq('').all(), axis=0)]
+        n_original_cols = df_original.shape[1]
+
+        # Try parsing with comma separator
+        comma_data = [line.split(",") for line in lines if line.strip()]
+        df_comma = pd.DataFrame(comma_data)
+        df_comma = df_comma.loc[:, ~df_comma.apply(lambda col: col.astype(str).str.strip().eq('').all(), axis=0)]
+
+        # Use the comma-parsed version only if it has more columns
+        if df_comma.shape[1] > n_original_cols:
+            return df_comma
+        else:
+            return df_original

stoneforge-0.2.0b3/stoneforge/io/tabr.py

@@ -0,0 +1,95 @@
+import warnings
+import re
+import numpy as np
+
+class TABParser:
+    def __init__(self, file_path, sep=",", std="US"):
+        """
+        Initializes the TabularDataLoader with the given file path, separator, and numeric format.
+        
+        Args:
+            file_path (str): Path to the CSV/TSV file.
+            sep (str): Field separator (default is ",").
+            std (str): Numeric formatting standard, either "US" [standard one] (1,234.56) or "BR" (1.234,56).
+        
+        Returns:
+            None
+        """
+        self.file_path = file_path
+        self.data = self._load_csv_as_dict(file_path = file_path, sep=sep, std=std)
+
+    def _load_csv_as_dict(self, file_path, sep=",", std="US"):
+        """
+        Reads a CSV/TSV file line by line, robust against malformed rows.
+
+        Args:
+            file_path (str): path to file
+            sep (str): field separator (default ",")
+            std (str): "US" (1,234.56) or "BR" (1.234,56) numeric formatting
+
+        Returns:
+            dict: { column_name: {"unit": str, "values": np.ndarray or list[str]} }
+        """
+        data_dict = {}
+
+        with open(file_path, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+
+        # --- Step 1: extract header
+        header_line = lines[0].strip()
+        headers = header_line.split(sep)
+
+        for col in headers:
+            col = col.strip()
+            name = col.split(" ", 1)[0].strip()
+            data_dict[name] = {"unit": "", "values": []}
+
+        # --- Step 2: normalization helper
+        def normalize_value(val):
+            val = val.strip().strip('"')
+            if re.match(r"^-?\d+[.,]?\d*$", val):  # numeric-like
+                if std.upper() == "US":
+                    val = val.replace(",", "")
+                elif std.upper() == "BR":
+                    val = val.replace(".", "").replace(",", ".")
+            return val
+
+        # --- Step 3: process rows
+        for i, line in enumerate(lines[1:], start=2):
+            row = line.strip().split(sep)
+            if len(row) != len(headers):
+                warnings.warn(
+                    f"Skipping line {i}: expected {len(headers)} fields, got {len(row)}"
+                )
+                continue
+
+            # units row
+            if i == 2:
+                for col_name, value in zip(headers, row):
+                    col_name = col_name.split(" ", 1)[0].strip()
+                    data_dict[col_name]["unit"] = value.strip().strip('"')
+                continue
+
+            # values rows
+            for col_name, value in zip(headers, row):
+                col_name = col_name.split(" ", 1)[0].strip()
+                data_dict[col_name]["values"].append(normalize_value(value))
+
+        # --- Step 4: convert lists to numpy arrays
+        for col, content in data_dict.items():
+            vals = content["values"]
+            try:
+                arr = np.array(vals, dtype=int)
+                data_dict[col]["values"] = arr
+            except ValueError:
+                try:
+                    arr = np.array(vals, dtype=float)
+                    data_dict[col]["values"] = arr
+                except ValueError:
+                    data_dict[col]["values"] = np.array(vals, dtype=str)
+
+        ordered_data_dict = {}
+        for k in data_dict.keys():
+            ordered_data_dict[k] = {'values' : data_dict[k]['values'], 'unit' : data_dict[k]['unit'], 'description' : ''}
+
+        return ordered_data_dict

{stoneforge-0.2.0b2 → stoneforge-0.2.0b3/stoneforge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stoneforge
-Version: 0.2.0b2
+Version: 0.2.0b3
 Summary: Geophysics equations, algorithms and methods
 Author: GIECAR - UFF, Wagner M. Lupinacci, Fernando Vizeu, Fábio Júnior D Fernandes, José A. V. Dias, Mario M. Ramos, Jordan S. Cuno, João Vitor A. Estrella, Ana Carolina, Breno D. Chrispim
 License-Expression: MIT
@@ -21,7 +21,6 @@ Requires-Dist: matplotlib>=3.10.0
 Requires-Dist: pandas>=2.2.2
 Requires-Dist: lightgbm>=4.5.0
 Requires-Dist: ipympl>=0.8.4
-Requires-Dist: ipykernel>=6.30.0
 Dynamic: license-file
 
 <p align="center">

{stoneforge-0.2.0b2 → stoneforge-0.2.0b3}/stoneforge.egg-info/SOURCES.txt

@@ -4,16 +4,6 @@ MANIFEST.in
 README.md
 pyproject.toml
 docs/conf.py
-docs/_build/html/_sources/index.rst.txt
-docs/_build/html/_sources/modules/petrophysics.rst.txt
-docs/_build/html/_sources/modules/preprocessing.rst.txt
-docs/_build/html/_sources/modules/pseudowells.rst.txt
-docs/_build/html/_sources/modules/rockphysics.rst.txt
-docs/_build/html/_sources/modules/machinelearning/classification.rst.txt
-docs/_build/html/_sources/modules/machinelearning/index.rst.txt
-docs/_build/html/_sources/modules/machinelearning/regression.rst.txt
-docs/_build/html/_sources/usage/installation.rst.txt
-docs/_build/html/_sources/usage/quickstart.rst.txt
 stoneforge/__init__.py
 stoneforge.egg-info/PKG-INFO
 stoneforge.egg-info/SOURCES.txt
@@ -31,7 +21,8 @@ stoneforge/io/__init__.py
 stoneforge/io/csv.py
 stoneforge/io/dlisio_r.py
 stoneforge/io/las2.py
-stoneforge/io/lasparser.py
+stoneforge/io/las3.py
+stoneforge/io/tabr.py
 stoneforge/machine_learning/__init__.py
 stoneforge/machine_learning/classification/__init__.py
 stoneforge/machine_learning/classification/evaluation.py

{stoneforge-0.2.0b2 → stoneforge-0.2.0b3}/stoneforge.egg-info/requires.txt

@@ -7,4 +7,3 @@ matplotlib>=3.10.0
 pandas>=2.2.2
 lightgbm>=4.5.0
 ipympl>=0.8.4
-ipykernel>=6.30.0

stoneforge-0.2.0b2/docs/_build/html/_sources/index.rst.txt

@@ -1,43 +0,0 @@
-.. Stoneforge documentation master file, created by
-   sphinx-quickstart on Mon May 27 13:42:11 2024.
-   You can adapt this file completely to your liking, but it should at least
-   contain the root `toctree` directive.
-
-Welcome to Stoneforge's documentation!
-======================================
-
-**Version**: 1.4
-
-**Stoneforge** is a Python library for geophysics equations, algorithms and methods that also,
-are used in the software Appy. It is linked to the GIECAR laboratory at the Universidade Federal
-Fluminense (UFF) related to the Geology and Geophysics Departament (GGO), and its purpose is to teach
-and develop routines in Python to solve geological and geophysical problems. Main APPy references are :footcite:t:`estrella2022sbgf,estrella2022seg`.
-
-.. note::
-   This project is under active development as of May 2024.
-
-.. toctree::
-   :maxdepth: 2
-   :caption: Contents:
-
-   usage/installation
-   usage/quickstart
-
-   modules/petrophysics
-   modules/rockphysics
-   modules/pseudowells
-   modules/machinelearning/index
-   modules/preprocessing
-
-
-Indices and tables
-==================
-
-* :ref:`genindex`
-* :ref:`modindex`
-* :ref:`search`
-
-References
-----------------
-
-.. footbibliography::

stoneforge-0.2.0b2/docs/_build/html/_sources/modules/machinelearning/classification.rst.txt

@@ -1,39 +0,0 @@
-=========================
-Classification
-=========================
-
-This section contains documentation for the Classification module (Machine learning).
-
-.. automodule:: stoneforge.machine_learning.classification
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-Settings (Classification)
---------------------------------
-
-.. automodule:: stoneforge.machine_learning.classification.settings
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-Fit (Classification)
---------------------------------
-
-.. automodule:: stoneforge.machine_learning.classification.fit
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-Predict (Classification)
---------------------------------
-
-.. automodule:: stoneforge.machine_learning.classification.predict
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-References
---------------------------------
-
-.. footbibliography::

stoneforge-0.2.0b2/docs/_build/html/_sources/modules/machinelearning/index.rst.txt

@@ -1,10 +0,0 @@
-Machine Learning
-================
-
-This section contains machine learning methods used in Stoneforge.
-
-.. toctree::
-   :maxdepth: 1
-
-   classification
-   regression