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

well_log_toolkit/manager.py

@@ -1507,7 +1507,10 @@ class WellDataManager:
     def load_las(
         self,
         filepath: Union[str, Path, list[Union[str, Path]]],
-        sampled: bool = False
+        path: Optional[Union[str, Path]] = None,
+        sampled: bool = False,
+        combine: Optional[str] = None,
+        source_name: Optional[str] = None
     ) -> 'WellDataManager':
         """
         Load LAS file(s), auto-create well if needed.
@@ -1515,10 +1518,26 @@ class WellDataManager:
         Parameters
         ----------
         filepath : Union[str, Path, list[Union[str, Path]]]
-            Path to LAS file or list of paths to LAS files
+            Path to LAS file or list of paths to LAS files.
+            When providing a list, filenames can be relative to the path parameter.
+        path : Union[str, Path], optional
+            Directory path to prepend to all filenames. Useful when loading multiple
+            files from the same directory. If None, filenames are used as-is.
         sampled : bool, default False
             If True, mark all properties from the LAS file(s) as 'sampled' type.
             Use this for core plug data or other point measurements.
+        combine : str, optional
+            When loading multiple files, combine files from the same well 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)
+            Files are automatically grouped by well name. If 4 files from 2 wells are loaded,
+            2 combined sources are created (one per well).
+        source_name : str, optional
+            Name for combined source when combine is specified. If not specified,
+            uses 'combined_match', 'combined_resample', or 'combined_concat'.
+            When files span multiple wells, the well name is prepended automatically.
 
         Returns
         -------
@@ -1535,26 +1554,134 @@ class WellDataManager:
         >>> manager = WellDataManager()
         >>> manager.load_las("well1.las")
         >>> manager.load_las(["well2.las", "well3.las"])
+
         >>> # Load core plug data
         >>> manager.load_las("core_data.las", sampled=True)
-        >>> well = manager.well_12_3_2_B
+
+        >>> # Load multiple files from same directory
+        >>> manager.load_las(
+        ...     ["file1.las", "file2.las", "file3.las"],
+        ...     path="data/well_logs"
+        ... )
+
+        >>> # Load and combine files (automatically groups by well)
+        >>> manager.load_las(
+        ...     ["36_7-5_B_CorePerm.las", "36_7-5_B_CorePor.las",
+        ...      "36_7-4_CorePerm.las", "36_7-4_CorePor.las"],
+        ...     path="data/",
+        ...     combine="match",
+        ...     source_name="CorePlugs"
+        ... )
+        Loaded sources:
+        - Well 36/7-5 B: CorePlugs (2 files combined)
+        - Well 36/7-4: CorePlugs (2 files combined)
         """
         # Handle list of files
         if isinstance(filepath, list):
-            for file in filepath:
-                self.load_las(file, sampled=sampled)
+            # Prepend path to all filenames if provided
+            if path is not None:
+                base_path = Path(path)
+                file_paths = [base_path / file for file in filepath]
+            else:
+                file_paths = filepath
+
+            # If combine is specified, group files by well and combine each group
+            if combine is not None:
+                # Group files by well name
+                from collections import defaultdict
+                well_groups = defaultdict(list)
+
+                for file_path in file_paths:
+                    las = LasFile(file_path)
+                    if las.well_name is None:
+                        raise LasFileError(
+                            f"LAS file {file_path} has no WELL name in header. "
+                            "Cannot determine which well to load into."
+                        )
+                    well_groups[las.well_name].append(file_path)
+
+                # Track loaded sources for debug output
+                loaded_sources = []
+
+                # Process each well group
+                for well_name, files_for_well in well_groups.items():
+                    sanitized_name = sanitize_well_name(well_name)
+                    well_key = f"well_{sanitized_name}"
+
+                    # Ensure well exists
+                    if well_key not in self._wells:
+                        self._wells[well_key] = Well(
+                            name=well_name,
+                            sanitized_name=sanitized_name,
+                            parent_manager=self
+                        )
+                        self._name_mapping[well_name] = well_key
+
+                    # Load files into well with combine
+                    self._wells[well_key].load_las(
+                        files_for_well,
+                        path=None,  # Path already prepended
+                        sampled=sampled,
+                        combine=combine,
+                        source_name=source_name
+                    )
+
+                    # Track what was loaded
+                    actual_source_name = source_name if source_name else f"combined_{combine}"
+                    loaded_sources.append(
+                        (well_name, actual_source_name, len(files_for_well))
+                    )
+
+                # Print debug output
+                print("Loaded sources:")
+                for well_name, src_name, file_count in loaded_sources:
+                    print(f"  - Well {well_name}: {src_name} ({file_count} file{'s' if file_count > 1 else ''} combined)")
+
+                return self
+
+            # No combine - load each file separately
+            loaded_sources = []
+            for file_path in file_paths:
+                # Read well name and source name before loading
+                las = LasFile(file_path)
+                if las.well_name is None:
+                    raise LasFileError(
+                        f"LAS file {file_path} has no WELL name in header. "
+                        "Cannot determine which well to load into."
+                    )
+                well_name = las.well_name
+                source_name_from_file = las.source_name
+
+                # Load the file
+                self.load_las(file_path, path=None, sampled=sampled, combine=None, source_name=None)
+
+                # Track what was loaded
+                loaded_sources.append((well_name, source_name_from_file))
+
+            # Print debug output
+            print("Loaded sources:")
+            for well_name, src_name in loaded_sources:
+                print(f"  - Well {well_name}: {src_name}")
+
             return self
 
         # Handle single file
-        las = LasFile(filepath)
+        # Prepend path if provided
+        if path is not None:
+            file_path = Path(path) / filepath
+        else:
+            file_path = filepath
+
+        las = LasFile(file_path)
         well_name = las.well_name
 
         if well_name is None:
             raise LasFileError(
-                f"LAS file {filepath} has no WELL name in header. "
+                f"LAS file {file_path} has no WELL name in header. "
                 "Cannot determine which well to load into."
             )
 
+        source_name_from_file = las.source_name
         sanitized_name = sanitize_well_name(well_name)
         # Use well_ prefix for dictionary key (attribute access)
         well_key = f"well_{sanitized_name}"
@@ -1571,6 +1698,10 @@ class WellDataManager:
         # Load into well
         self._wells[well_key].load_las(las, sampled=sampled)
 
+        # Print debug output
+        print("Loaded sources:")
+        print(f"  - Well {well_name}: {source_name_from_file}")
+
         return self  # Enable chaining
 
     def load_tops(

well_log_toolkit/well.py

@@ -338,6 +338,7 @@ class Well:
     def load_las(
         self,
         las: Union[LasFile, str, Path, list[Union[str, Path]]],
+        path: Optional[Union[str, Path]] = None,
         sampled: bool = False,
         resample_method: Optional[str] = None,
         merge: bool = False,
@@ -355,7 +356,11 @@ class Well:
         Parameters
         ----------
         las : Union[LasFile, str, Path, list[Union[str, Path]]]
-            Either a LasFile instance, path to LAS file, or list of LAS file paths
+            Either a LasFile instance, path to LAS file, or list of LAS file paths.
+            When providing a list, filenames can be relative to the path parameter.
+        path : Union[str, Path], optional
+            Directory path to prepend to all filenames. Useful when loading multiple
+            files from the same directory. If None, filenames are used as-is.
         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
@@ -426,14 +431,36 @@ class Well:
         >>> # 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
+
+        >>> # Load multiple files from same directory
+        >>> well.load_las(
+        ...     ["file1.las", "file2.las", "file3.las"],
+        ...     path="data/well_logs",
+        ...     combine="match",
+        ...     source_name="AllLogs"
+        ... )
+        >>> # Loads: data/well_logs/file1.las, data/well_logs/file2.las, etc.
+
+        >>> # Mix of relative and absolute paths
+        >>> well.load_las(
+        ...     ["log1.las", "log2.las"],
+        ...     path="/absolute/path/to/logs"
+        ... )
         """
         # Handle list of files
         if isinstance(las, list):
+            # Prepend path to all filenames if provided
+            if path is not None:
+                base_path = Path(path)
+                las_files = [base_path / las_file for las_file in las]
+            else:
+                las_files = las
+
             # 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)
+            for las_file in las_files:
+                # Recursively call load_las for each file (without merge or combine, path already prepended)
+                self.load_las(las_file, path=None, sampled=sampled, resample_method=resample_method, merge=False, combine=None)
                 # Get the source name that was just created
                 loaded_sources.append(self.sources[-1])
 
@@ -465,8 +492,14 @@ class Well:
         # Parse if path provided
         filepath = None
         if isinstance(las, (str, Path)):
-            filepath = Path(las)
-            las = LasFile(las)
+            # Prepend path if provided
+            if path is not None:
+                las_path = Path(path) / las
+            else:
+                las_path = Path(las)
+
+            filepath = las_path
+            las = LasFile(las_path)
         elif hasattr(las, 'filepath') and las.filepath:
             filepath = Path(las.filepath)
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: well-log-toolkit
-Version: 0.1.122
+Version: 0.1.124
 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.122.dist-info → well_log_toolkit-0.1.124.dist-info}/RECORD

@@ -1,15 +1,15 @@
 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=Tj0mRfX1aX2s6uug7BBlY1m_mu3G50EGxHGzD0eEedE,53876
-well_log_toolkit/manager.py,sha256=Mc_zgC9pgbYq82msiAc0KMVmPFbCX90SZK5JfwGY4H4,102422
+well_log_toolkit/manager.py,sha256=oz67-IZvMEP7T_JEY7JMzeXWAvG1FmFSk8NKBif7yFI,108220
 well_log_toolkit/operations.py,sha256=z8j8fGBOwoJGUQFy-Vawjq9nm3OD_dUt0oaNh8yuG7o,18515
 well_log_toolkit/property.py,sha256=WOzoNQcmHCQ8moIKsnSyLgVC8s4LBu2x5IBXtFzmMe8,76236
 well_log_toolkit/regression.py,sha256=7D3oI-1XVlFb-mOoHTxTTtUHERFyvQSBAzJzAGVoZnk,25192
 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=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,,
+well_log_toolkit/well.py,sha256=kIN3Zr0sI3Zt3DeHbxDXADbQfWnVxXCQrHZ4UEMyeqI,103343
+well_log_toolkit-0.1.124.dist-info/METADATA,sha256=CfWF9CRjoyY3ZmsZ1CkKOSsuVUMg3yY3_XZE3B_lwf4,59810
+well_log_toolkit-0.1.124.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+well_log_toolkit-0.1.124.dist-info/top_level.txt,sha256=BMOo7OKLcZEnjo0wOLMclwzwTbYKYh31I8RGDOGSBdE,17
+well_log_toolkit-0.1.124.dist-info/RECORD,,