well-log-toolkit 0.1.120__py3-none-any.whl → 0.1.122__py3-none-any.whl

well_log_toolkit/las_file.py

@@ -104,7 +104,10 @@ class LasFile:
         source_name: str = 'external_df',
         unit_mappings: Optional[dict[str, str]] = None,
         type_mappings: Optional[dict[str, str]] = None,
-        label_mappings: Optional[dict[str, dict[int, str]]] = None
+        label_mappings: Optional[dict[str, dict[int, str]]] = None,
+        color_mappings: Optional[dict[str, dict[int, str]]] = None,
+        style_mappings: Optional[dict[str, dict[int, str]]] = None,
+        thickness_mappings: Optional[dict[str, dict[int, float]]] = None
     ) -> 'LasFile':
         """
         Create a LasFile object from a DataFrame.
@@ -123,6 +126,12 @@ class LasFile:
             Mapping of column names to 'continuous' or 'discrete'
         label_mappings : dict[str, dict[int, str]], optional
             Label mappings for discrete properties
+        color_mappings : dict[str, dict[int, str]], optional
+            Color mappings for discrete property values
+        style_mappings : dict[str, dict[int, str]], optional
+            Style mappings for discrete property values
+        thickness_mappings : dict[str, dict[int, float]], optional
+            Thickness mappings for discrete property values
 
         Returns
         -------
@@ -148,6 +157,9 @@ class LasFile:
         unit_mappings = unit_mappings or {}
         type_mappings = type_mappings or {}
         label_mappings = label_mappings or {}
+        color_mappings = color_mappings or {}
+        style_mappings = style_mappings or {}
+        thickness_mappings = thickness_mappings or {}
 
         # Create instance without parsing file
         instance = cls(source_name, _from_dataframe=True)
@@ -176,7 +188,7 @@ class LasFile:
                 'multiplier': None
             }
 
-        # Set parameter info (discrete labels)
+        # Set parameter info (discrete labels and metadata)
         if label_mappings:
             discrete_props = ','.join(sorted(label_mappings.keys()))
             instance.parameter_info['DISCRETE_PROPS'] = discrete_props
@@ -186,6 +198,27 @@ class LasFile:
                     param_name = f"{prop_name}_{value}"
                     instance.parameter_info[param_name] = label
 
+        # Add color mappings to parameter section
+        if color_mappings:
+            for prop_name, colors in color_mappings.items():
+                for value, color in colors.items():
+                    param_name = f"{prop_name}_{value}_COLOR"
+                    instance.parameter_info[param_name] = color
+
+        # Add style mappings to parameter section
+        if style_mappings:
+            for prop_name, styles in style_mappings.items():
+                for value, style in styles.items():
+                    param_name = f"{prop_name}_{value}_STYLE"
+                    instance.parameter_info[param_name] = style
+
+        # Add thickness mappings to parameter section
+        if thickness_mappings:
+            for prop_name, thicknesses in thickness_mappings.items():
+                for value, thickness in thicknesses.items():
+                    param_name = f"{prop_name}_{value}_THICKNESS"
+                    instance.parameter_info[param_name] = str(thickness)
+
         # Set data directly
         instance._data = df.copy()
 

well_log_toolkit/well.py

@@ -335,9 +335,17 @@ class Well:
         # Mark source as modified
         self._sources[source_name]['modified'] = True
 
-    def load_las(self, las: Union[LasFile, str, Path], sampled: bool = False, resample_method: Optional[str] = None, merge: bool = False) -> 'Well':
+    def load_las(
+        self,
+        las: Union[LasFile, str, Path, list[Union[str, Path]]],
+        sampled: bool = False,
+        resample_method: Optional[str] = None,
+        merge: bool = False,
+        combine: Optional[str] = None,
+        source_name: Optional[str] = None
+    ) -> 'Well':
         """
-        Load LAS file into this well, organized by source.
+        Load LAS file(s) into this well, organized by source.
 
         Properties are grouped by source (LAS file). The source name is derived
         from the filename stem (without extension), sanitized for Python attribute
@@ -346,8 +354,8 @@ class Well:
 
         Parameters
         ----------
-        las : Union[LasFile, str, Path]
-            Either a LasFile instance or path to LAS file
+        las : Union[LasFile, str, Path, list[Union[str, Path]]]
+            Either a LasFile instance, path to LAS file, or list of LAS file paths
         sampled : bool, default False
             If True, mark all properties from this source as 'sampled' type.
             Use this for core plug data or other point measurements where
@@ -365,6 +373,15 @@ class Well:
             properties into the existing source instead of overwriting it.
             When merging with incompatible depth grids, resample_method must be specified.
             If False (default), existing source is overwritten with warning.
+        combine : str, optional
+            When loading multiple files (list), combine them into a single source:
+            - None (default): Load files as separate sources, no combining
+            - 'match': Combine using match method (safest, errors on mismatch)
+            - 'resample': Combine using resample method (interpolates to first file)
+            - 'concat': Combine using concat method (merges all unique depths)
+        source_name : str, optional
+            Name for combined source when combine is specified. If not specified,
+            uses 'combined_match', 'combined_resample', or 'combined_concat'
 
         Returns
         -------
@@ -381,23 +398,70 @@ class Well:
 
         Examples
         --------
-        >>> well = manager.well_36_7_5_B
+        >>> # Load single file
         >>> well.load_las("36_7-5_B_CorePor.las")  # Source name: "CorePor"
-        >>> well.load_las("36_7-5_B_Log.las")      # Source name: "Log"
-        >>> well.load_las("formation_tops.las")    # Source name: "formation_tops"
+
+        >>> # Load multiple files as separate sources
+        >>> well.load_las(["file1.las", "file2.las", "file3.las"])
+        >>> print(well.sources)  # ['file1', 'file2', 'file3']
+
+        >>> # Load and combine multiple files
+        >>> well.load_las(
+        ...     ["file1.las", "file2.las", "file3.las"],
+        ...     combine="match",
+        ...     source_name="CombinedLogs"
+        ... )
+        >>> print(well.sources)  # ['CombinedLogs']
+
         >>> # Load core plug data as sampled
         >>> well.load_las("36_7-5_B_Core.las", sampled=True)
-        >>> # Load data with incompatible depths
-        >>> well.load_las("interpreted.las", resample_method='linear')
-        >>> # Merge additional properties into existing source
+
+        >>> # Load with resample combining
+        >>> well.load_las(
+        ...     ["log1.las", "log2.las"],
+        ...     combine="resample",
+        ...     source_name="CombinedLogs"
+        ... )
+
+        >>> # Merge into existing source (legacy behavior)
         >>> well.load_las("CorePor.las")  # Load initial properties
-        >>> well.load_las("CorePor_Extra.las", merge=True)  # Merge new properties into "CorePor"
-        >>> # Access by source
-        >>> well.CorePor.PHIE
-        >>> well.Log.GR
-        >>> # Access directly if unique
-        >>> well.PHIE  # Error if both CorePor and Log have PHIE
+        >>> well.load_las("CorePor_Extra.las", merge=True)  # Merge new properties
         """
+        # Handle list of files
+        if isinstance(las, list):
+            # Load all files as separate sources
+            loaded_sources = []
+            for las_file in las:
+                # Recursively call load_las for each file (without merge or combine)
+                self.load_las(las_file, sampled=sampled, resample_method=resample_method, merge=False, combine=None)
+                # Get the source name that was just created
+                loaded_sources.append(self.sources[-1])
+
+            # Combine if requested
+            if combine in {'match', 'resample', 'concat'}:
+                # Determine combined source name
+                combined_source_name = source_name or f'combined_{combine}'
+
+                # Merge all loaded sources
+                self.merge(
+                    method=combine,
+                    sources=loaded_sources,
+                    source_name=combined_source_name
+                )
+
+                # Remove original sources
+                self.remove_source(loaded_sources)
+
+            return self
+
+        # Single file logic below
+        # Validate combine parameter for single file
+        if combine is not None:
+            raise ValueError(
+                f"combine='{combine}' is only valid when loading multiple files (list). "
+                f"For single file loading, use merge=True to merge into existing source."
+            )
+
         # Parse if path provided
         filepath = None
         if isinstance(las, (str, Path)):
@@ -2247,7 +2311,7 @@ class Well:
 
                 df = pd.DataFrame(data)
 
-                # Create LasFile from DataFrame
+                # Create LasFile from DataFrame with all metadata
                 las = LasFile.from_dataframe(
                     df=df,
                     well_name=self.name,

{well_log_toolkit-0.1.120.dist-info → well_log_toolkit-0.1.122.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: well-log-toolkit
-Version: 0.1.120
+Version: 0.1.122
 Summary: Fast LAS file processing with lazy loading and filtering for well log analysis
 Author-email: Kristian dF Kollsgård <kkollsg@gmail.com>
 License: MIT

{well_log_toolkit-0.1.120.dist-info → well_log_toolkit-0.1.122.dist-info}/RECORD

@@ -1,6 +1,6 @@
 well_log_toolkit/__init__.py,sha256=ilJAIIhh68pYfD9I3V53juTEJpoMN8oHpcpEFNpuXAQ,3793
 well_log_toolkit/exceptions.py,sha256=X_fzC7d4yaBFO9Vx74dEIB6xmI9Agi6_bTU3MPxn6ko,985
-well_log_toolkit/las_file.py,sha256=yRCIiVbdoqFzoXKRKfx7Lt11INmwB_bXdpHpwVaNpjk,52156
+well_log_toolkit/las_file.py,sha256=Tj0mRfX1aX2s6uug7BBlY1m_mu3G50EGxHGzD0eEedE,53876
 well_log_toolkit/manager.py,sha256=Mc_zgC9pgbYq82msiAc0KMVmPFbCX90SZK5JfwGY4H4,102422
 well_log_toolkit/operations.py,sha256=z8j8fGBOwoJGUQFy-Vawjq9nm3OD_dUt0oaNh8yuG7o,18515
 well_log_toolkit/property.py,sha256=WOzoNQcmHCQ8moIKsnSyLgVC8s4LBu2x5IBXtFzmMe8,76236
@@ -8,8 +8,8 @@ well_log_toolkit/regression.py,sha256=7D3oI-1XVlFb-mOoHTxTTtUHERFyvQSBAzJzAGVoZn
 well_log_toolkit/statistics.py,sha256=_huPMbv2H3o9ezunjEM94mJknX5wPK8V4nDv2lIZZRw,16814
 well_log_toolkit/utils.py,sha256=O2KPq4htIoUlL74V2zKftdqqTjRfezU9M-568zPLme0,6866
 well_log_toolkit/visualization.py,sha256=xb870FG5FghU2gEkqdn1b2NbWNu07oDmFDN1Cx1HIi0,157280
-well_log_toolkit/well.py,sha256=-huYBLw_nEmZm_sEAiPq0_az9WFmZ-TyHmM-Vn_vxQk,99591
-well_log_toolkit-0.1.120.dist-info/METADATA,sha256=LxF_4YtWXQyNFXG0dOoZ0-SJaN4OJoF5o2CTiUZOS60,59810
-well_log_toolkit-0.1.120.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-well_log_toolkit-0.1.120.dist-info/top_level.txt,sha256=BMOo7OKLcZEnjo0wOLMclwzwTbYKYh31I8RGDOGSBdE,17
-well_log_toolkit-0.1.120.dist-info/RECORD,,
+well_log_toolkit/well.py,sha256=u2KhhMfXkMPIOKRgH3SB3k-2knotqWdBGY4Lup31Pxc,102017
+well_log_toolkit-0.1.122.dist-info/METADATA,sha256=MxrNyJ2HeEdC6VUmRFSPdVT6te10N5Buy-iJLzwHEFY,59810
+well_log_toolkit-0.1.122.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+well_log_toolkit-0.1.122.dist-info/top_level.txt,sha256=BMOo7OKLcZEnjo0wOLMclwzwTbYKYh31I8RGDOGSBdE,17
+well_log_toolkit-0.1.122.dist-info/RECORD,,