well-log-toolkit 0.1.145__tar.gz → 0.1.147__tar.gz

{well_log_toolkit-0.1.145 → well_log_toolkit-0.1.147}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: well-log-toolkit
-Version: 0.1.145
+Version: 0.1.147
 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.145 → well_log_toolkit-0.1.147}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "well-log-toolkit"
-version = "0.1.145"
+version = "0.1.147"
 description = "Fast LAS file processing with lazy loading and filtering for well log analysis"
 readme = "README.md"
 requires-python = ">=3.9"

{well_log_toolkit-0.1.145 → well_log_toolkit-0.1.147}/well_log_toolkit/manager.py

@@ -132,11 +132,12 @@ class _ManagerPropertyProxy:
     When assigned to a manager attribute, the operation is broadcast to all wells.
     """
 
-    def __init__(self, manager: 'WellDataManager', property_name: str, operation=None, filters=None):
+    def __init__(self, manager: 'WellDataManager', property_name: str, operation=None, filters=None, custom_intervals=None):
         self._manager = manager
         self._property_name = property_name
         self._operation = operation  # Function to apply to each property
         self._filters = filters or []  # List of (filter_name, insert_boundaries) tuples
+        self._custom_intervals = custom_intervals  # For filter_intervals: str (saved name) or dict (well-specific)
 
     def _apply_operation(self, prop: Property):
         """Apply stored operation to a property."""
@@ -147,9 +148,50 @@ class _ManagerPropertyProxy:
             # Apply the operation
             return self._operation(prop)
 
+    def _apply_filter_intervals(self, prop: Property, well):
+        """
+        Apply filter_intervals to a property if custom_intervals is set.
+
+        Returns None if the well doesn't have the required saved intervals.
+        """
+        if not self._custom_intervals:
+            return prop
+
+        intervals_config = self._custom_intervals
+        intervals = intervals_config['intervals']
+        name = intervals_config['name']
+        insert_boundaries = intervals_config['insert_boundaries']
+        save = intervals_config['save']
+
+        # Resolve intervals for this well
+        if isinstance(intervals, str):
+            # Saved filter name - check if this well has it
+            if intervals not in well._saved_filter_intervals:
+                return None  # Skip wells that don't have this saved filter
+            well_intervals = intervals
+        elif isinstance(intervals, dict):
+            # Well-specific intervals
+            well_intervals = None
+            if well.name in intervals:
+                well_intervals = intervals[well.name]
+            elif well.sanitized_name in intervals:
+                well_intervals = intervals[well.sanitized_name]
+            if well_intervals is None:
+                return None  # Skip wells not in the dict
+        else:
+            return None
+
+        # Apply filter_intervals
+        return prop.filter_intervals(
+            well_intervals,
+            name=name,
+            insert_boundaries=insert_boundaries,
+            save=save
+        )
+
     def _create_proxy_with_operation(self, operation):
         """Create a new proxy with an operation."""
-        return _ManagerPropertyProxy(self._manager, self._property_name, operation, self._filters)
+        return _ManagerPropertyProxy(self._manager, self._property_name, operation, self._filters, self._custom_intervals)
 
     def _extract_statistic_from_grouped(self, grouped_result: dict, stat_name: str, **kwargs) -> dict:
         """
@@ -1115,7 +1157,141 @@ class _ManagerPropertyProxy:
         new_filters = self._filters + [(property_name, insert_boundaries)]
 
         # Return new proxy with filter added
-        return _ManagerPropertyProxy(self._manager, self._property_name, self._operation, new_filters)
+        return _ManagerPropertyProxy(self._manager, self._property_name, self._operation, new_filters, self._custom_intervals)
+
+    def filter_intervals(
+        self,
+        intervals: Union[str, dict],
+        name: str = "Custom_Intervals",
+        insert_boundaries: Optional[bool] = None,
+        save: Optional[str] = None
+    ) -> '_ManagerPropertyProxy':
+        """
+        Filter by custom depth intervals across all wells.
+
+        Parameters
+        ----------
+        intervals : str | dict
+            - str: Name of saved filter intervals (looks up per-well)
+            - dict: Well-specific intervals {well_name: [intervals]}
+        name : str, default "Custom_Intervals"
+            Name for the filter property (used in output labels)
+        insert_boundaries : bool, optional
+            If True, insert synthetic samples at interval boundaries.
+        save : str, optional
+            If provided, save the intervals to the well(s) under this name.
+
+        Returns
+        -------
+        _ManagerPropertyProxy
+            New proxy with intervals filter added
+
+        Examples
+        --------
+        >>> # Use saved intervals (only wells with saved intervals are included)
+        >>> manager.Facies.filter_intervals("Reservoir_Zones").discrete_summary()
+
+        >>> # Well-specific intervals
+        >>> manager.Facies.filter_intervals({
+        ...     "well_A": [{"name": "Zone1", "top": 2500, "base": 2700}],
+        ...     "well_B": [{"name": "Zone1", "top": 2600, "base": 2800}]
+        ... }).discrete_summary()
+        """
+        # Store intervals config for use when computing stats
+        intervals_config = {
+            'intervals': intervals,
+            'name': name,
+            'insert_boundaries': insert_boundaries,
+            'save': save
+        }
+
+        return _ManagerPropertyProxy(
+            self._manager, self._property_name, self._operation,
+            self._filters, intervals_config
+        )
+
+    def discrete_summary(
+        self,
+        precision: int = 6,
+        skip: Optional[list] = None
+    ) -> dict:
+        """
+        Compute discrete summary statistics across all wells.
+
+        Parameters
+        ----------
+        precision : int, default 6
+            Number of decimal places for rounding numeric results
+        skip : list[str], optional
+            List of field names to exclude from the output.
+            Valid fields: 'code', 'count', 'thickness', 'fraction', 'depth_range'
+
+        Returns
+        -------
+        dict
+            Nested dictionary with structure:
+            {
+                "well_name": {
+                    "zone_name": {
+                        "depth_range": {...},
+                        "thickness": ...,
+                        "facies": {...}
+                    }
+                }
+            }
+
+        Examples
+        --------
+        >>> # Use saved intervals
+        >>> manager.Facies.filter_intervals("Reservoir_Zones").discrete_summary()
+
+        >>> # Skip certain fields
+        >>> manager.Facies.filter_intervals("Zones").discrete_summary(skip=["code", "count"])
+        """
+        if not self._custom_intervals:
+            raise ValueError(
+                "discrete_summary() requires filter_intervals(). "
+                "Use .filter_intervals('saved_name') or .filter_intervals({...}) first."
+            )
+
+        result = {}
+
+        for well_name, well in self._manager._wells.items():
+            well_result = self._compute_discrete_summary_for_well(well, precision, skip)
+            if well_result is not None:
+                result[well_name] = well_result
+
+        return _sanitize_for_json(result)
+
+    def _compute_discrete_summary_for_well(
+        self,
+        well,
+        precision: int,
+        skip: Optional[list]
+    ):
+        """
+        Helper to compute discrete_summary for a property in a well.
+        """
+        try:
+            prop = well.get_property(self._property_name)
+            prop = self._apply_operation(prop)
+
+            # Apply filter_intervals
+            prop = self._apply_filter_intervals(prop, well)
+            if prop is None:
+                return None  # Well doesn't have the saved intervals
+
+            # Apply any additional filters
+            for filter_name, filter_insert_boundaries in self._filters:
+                if filter_insert_boundaries is not None:
+                    prop = prop.filter(filter_name, insert_boundaries=filter_insert_boundaries)
+                else:
+                    prop = prop.filter(filter_name)
+
+            return prop.discrete_summary(precision=precision, skip=skip)
+
+        except (PropertyNotFoundError, PropertyTypeError, AttributeError, KeyError, ValueError):
+            return None
 
     def sums_avg(
         self,
@@ -1206,11 +1382,19 @@ class _ManagerPropertyProxy:
         >>> #         "core": {"Zone_1": {...}}
         >>> #     }
         >>> # }
+
+        >>> # With custom intervals
+        >>> manager.PHIE.filter_intervals("Reservoir_Zones").sums_avg()
+        >>> # Returns:
+        >>> # {
+        >>> #     "well_A": {"Zone_1": {"mean": 0.18, ...}},
+        >>> #     "well_B": {"Zone_1": {"mean": 0.21, ...}}
+        >>> # }
         """
-        if not self._filters:
+        if not self._filters and not self._custom_intervals:
             raise ValueError(
-                "sums_avg() requires at least one filter. "
-                "Use .filter('property_name') before calling sums_avg()"
+                "sums_avg() requires at least one filter or filter_intervals(). "
+                "Use .filter('property_name') or .filter_intervals(...) before calling sums_avg()"
             )
 
         result = {}
@@ -1247,6 +1431,11 @@ class _ManagerPropertyProxy:
                     prop = well.get_property(self._property_name, source=source_name)
                     prop = self._apply_operation(prop)
 
+                    # Apply filter_intervals if set
+                    prop = self._apply_filter_intervals(prop, well)
+                    if prop is None:
+                        continue  # Well doesn't have the saved intervals
+
                     # Apply all filters (specify source to avoid ambiguity)
                     # If a filter doesn't exist, PropertyNotFoundError will be raised and caught below
                     for filter_name, insert_boundaries in self._filters:
@@ -1274,6 +1463,11 @@ class _ManagerPropertyProxy:
             prop = well.get_property(self._property_name)
             prop = self._apply_operation(prop)
 
+            # Apply filter_intervals if set
+            prop = self._apply_filter_intervals(prop, well)
+            if prop is None:
+                return None  # Well doesn't have the saved intervals
+
             # Apply all filters
             for filter_name, insert_boundaries in self._filters:
                 if insert_boundaries is not None:
@@ -1299,6 +1493,11 @@ class _ManagerPropertyProxy:
                         prop = well.get_property(self._property_name, source=source_name)
                         prop = self._apply_operation(prop)
 
+                        # Apply filter_intervals if set
+                        prop = self._apply_filter_intervals(prop, well)
+                        if prop is None:
+                            continue  # Well doesn't have the saved intervals
+
                         # Apply all filters (specify source to avoid ambiguity)
                         # If a filter doesn't exist, PropertyNotFoundError will be raised and caught below
                         for filter_name, insert_boundaries in self._filters:
@@ -1419,6 +1618,346 @@ class _ManagerPropertyProxy:
             )
 
 
+class _ManagerMultiPropertyProxy:
+    """
+    Proxy for computing statistics across multiple properties on all wells.
+
+    Supports filter(), filter_intervals(), and sums_avg() methods.
+    Multi-property results nest property-specific stats under property names
+    while keeping common stats (depth_range, samples, thickness, etc.) at
+    the group level.
+    """
+
+    # Stats that are specific to each property (nested under property name)
+    PROPERTY_STATS = {'mean', 'median', 'mode', 'sum', 'std_dev', 'percentile', 'range'}
+
+    # Stats that are common across properties (stay at group level)
+    COMMON_STATS = {'depth_range', 'samples', 'thickness', 'gross_thickness', 'thickness_fraction', 'calculation'}
+
+    def __init__(
+        self,
+        manager: 'WellDataManager',
+        property_names: list[str],
+        filters: Optional[list[tuple]] = None,
+        custom_intervals: Optional[dict] = None
+    ):
+        self._manager = manager
+        self._property_names = property_names
+        self._filters = filters or []
+        self._custom_intervals = custom_intervals
+
+    def filter(
+        self,
+        property_name: str,
+        insert_boundaries: Optional[bool] = None
+    ) -> '_ManagerMultiPropertyProxy':
+        """
+        Add a filter (discrete property) to group statistics by.
+
+        Parameters
+        ----------
+        property_name : str
+            Name of discrete property to group by
+        insert_boundaries : bool, optional
+            Whether to insert boundary values at filter transitions
+
+        Returns
+        -------
+        _ManagerMultiPropertyProxy
+            New proxy with filter added
+        """
+        new_filters = self._filters + [(property_name, insert_boundaries)]
+        return _ManagerMultiPropertyProxy(
+            self._manager, self._property_names, new_filters, self._custom_intervals
+        )
+
+    def filter_intervals(
+        self,
+        intervals: Union[str, list, dict],
+        name: str = "Custom_Intervals",
+        insert_boundaries: Optional[bool] = None,
+        save: Optional[str] = None
+    ) -> '_ManagerMultiPropertyProxy':
+        """
+        Filter by custom depth intervals.
+
+        Parameters
+        ----------
+        intervals : str, list, or dict
+            - str: Name of saved intervals to retrieve from each well
+            - list: List of interval dicts [{"name": "Zone_A", "top": 2500, "base": 2700}, ...]
+            - dict: Well-specific intervals {"well_name": [...], ...}
+        name : str, default "Custom_Intervals"
+            Name for the interval filter in results
+        insert_boundaries : bool, optional
+            Whether to insert boundary values at interval edges
+        save : str, optional
+            If provided, save intervals to wells with this name
+
+        Returns
+        -------
+        _ManagerMultiPropertyProxy
+            New proxy with custom intervals set
+        """
+        intervals_config = {
+            'intervals': intervals,
+            'name': name,
+            'insert_boundaries': insert_boundaries,
+            'save': save
+        }
+        return _ManagerMultiPropertyProxy(
+            self._manager, self._property_names, self._filters, intervals_config
+        )
+
+    def sums_avg(
+        self,
+        weighted: Optional[bool] = None,
+        arithmetic: Optional[bool] = None,
+        precision: int = 6
+    ) -> dict:
+        """
+        Compute statistics for multiple properties across all wells.
+
+        Multi-property results nest property-specific stats (mean, median, etc.)
+        under each property name, while common stats (depth_range, samples,
+        thickness, etc.) remain at the group level.
+
+        Parameters
+        ----------
+        weighted : bool, optional
+            Include depth-weighted statistics.
+            Default: True for continuous/discrete, False for sampled
+        arithmetic : bool, optional
+            Include arithmetic (unweighted) statistics.
+            Default: False for continuous/discrete, True for sampled
+        precision : int, default 6
+            Number of decimal places for rounding numeric results
+
+        Returns
+        -------
+        dict
+            Nested dictionary with structure:
+            {
+                "well_name": {
+                    "interval_name": {  # if using filter_intervals
+                        "filter_value": {
+                            "PropertyA": {"mean": ..., "median": ..., ...},
+                            "PropertyB": {"mean": ..., "median": ..., ...},
+                            "depth_range": {...},
+                            "samples": ...,
+                            "thickness": ...,
+                            ...
+                        }
+                    }
+                }
+            }
+
+        Examples
+        --------
+        >>> manager.properties(['PHIE', 'PERM']).filter('Facies').sums_avg()
+        >>> # Returns stats for both properties grouped by facies
+
+        >>> manager.properties(['PHIE', 'PERM']).filter_intervals("Zones").sums_avg()
+        >>> # Returns stats for both properties grouped by custom intervals
+        """
+        if not self._filters and not self._custom_intervals:
+            raise ValueError(
+                "sums_avg() requires at least one filter or filter_intervals(). "
+                "Use .filter('property_name') or .filter_intervals(...) first."
+            )
+
+        result = {}
+
+        for well_name, well in self._manager._wells.items():
+            well_result = self._compute_sums_avg_for_well(
+                well, weighted, arithmetic, precision
+            )
+            if well_result is not None:
+                result[well_name] = well_result
+
+        return _sanitize_for_json(result)
+
+    def _compute_sums_avg_for_well(
+        self,
+        well,
+        weighted: Optional[bool],
+        arithmetic: Optional[bool],
+        precision: int
+    ):
+        """
+        Compute multi-property sums_avg for a single well.
+        """
+        # Collect results for each property
+        property_results = {}
+
+        for prop_name in self._property_names:
+            try:
+                prop = well.get_property(prop_name)
+
+                # Apply filter_intervals if set
+                if self._custom_intervals:
+                    prop = self._apply_filter_intervals(prop, well)
+                    if prop is None:
+                        return None  # Well doesn't have the saved intervals
+
+                # Apply all filters
+                for filter_name, insert_boundaries in self._filters:
+                    if insert_boundaries is not None:
+                        prop = prop.filter(filter_name, insert_boundaries=insert_boundaries)
+                    else:
+                        prop = prop.filter(filter_name)
+
+                # Compute sums_avg
+                result = prop.sums_avg(
+                    weighted=weighted,
+                    arithmetic=arithmetic,
+                    precision=precision
+                )
+                property_results[prop_name] = result
+
+            except (PropertyNotFoundError, PropertyTypeError, AttributeError, KeyError, ValueError):
+                # Property doesn't exist in this well, skip it
+                pass
+
+        if not property_results:
+            return None
+
+        # Merge results: nest property-specific stats, keep common stats at group level
+        return self._merge_property_results(property_results)
+
+    def _apply_filter_intervals(self, prop, well):
+        """
+        Apply filter_intervals to a property if custom_intervals is set.
+
+        Returns None if the well doesn't have the required saved intervals.
+        """
+        if not self._custom_intervals:
+            return prop
+
+        intervals_config = self._custom_intervals
+        intervals = intervals_config['intervals']
+        name = intervals_config['name']
+        insert_boundaries = intervals_config['insert_boundaries']
+        save = intervals_config['save']
+
+        # Resolve intervals for this well
+        if isinstance(intervals, str):
+            # Saved filter name - check if this well has it
+            if intervals not in well._saved_filter_intervals:
+                return None  # Skip wells that don't have this saved filter
+            well_intervals = intervals
+        elif isinstance(intervals, dict):
+            # Well-specific intervals
+            well_intervals = None
+            if well.name in intervals:
+                well_intervals = intervals[well.name]
+            elif well.sanitized_name in intervals:
+                well_intervals = intervals[well.sanitized_name]
+            if well_intervals is None:
+                return None  # Skip wells not in the dict
+        elif isinstance(intervals, list):
+            # Direct list of intervals
+            well_intervals = intervals
+        else:
+            return None
+
+        # Apply filter_intervals
+        return prop.filter_intervals(
+            well_intervals,
+            name=name,
+            insert_boundaries=insert_boundaries,
+            save=save
+        )
+
+    def _merge_property_results(self, property_results: dict) -> dict:
+        """
+        Merge results from multiple properties.
+
+        Nests property-specific stats under property names while keeping
+        common stats at the group level.
+
+        Parameters
+        ----------
+        property_results : dict
+            {property_name: sums_avg_result}
+
+        Returns
+        -------
+        dict
+            Merged result with structure:
+            {
+                "group_value": {
+                    "PropertyA": {"mean": ..., ...},
+                    "PropertyB": {"mean": ..., ...},
+                    "depth_range": {...},
+                    "samples": ...,
+                    ...
+                }
+            }
+        """
+        if not property_results:
+            return {}
+
+        # Use first property result as the structure template
+        first_prop = next(iter(property_results.keys()))
+        first_result = property_results[first_prop]
+
+        return self._merge_recursive(property_results, first_result)
+
+    def _merge_recursive(self, property_results: dict, template: dict) -> dict:
+        """
+        Recursively merge property results following the template structure.
+        """
+        result = {}
+
+        for key, value in template.items():
+            if isinstance(value, dict):
+                # Check if this is a stats dict (has property-specific keys)
+                if any(k in value for k in self.PROPERTY_STATS):
+                    # This is a leaf stats dict - merge property stats here
+                    merged = {}
+
+                    # Add property-specific stats for each property
+                    for prop_name, prop_result in property_results.items():
+                        # Navigate to the same key in this property's result
+                        prop_value = self._get_nested_value(prop_result, key)
+                        if prop_value and isinstance(prop_value, dict):
+                            # Extract property-specific stats
+                            prop_stats = {
+                                k: v for k, v in prop_value.items()
+                                if k in self.PROPERTY_STATS
+                            }
+                            if prop_stats:
+                                merged[prop_name] = prop_stats
+
+                    # Add common stats from the first property
+                    for k, v in value.items():
+                        if k in self.COMMON_STATS:
+                            merged[k] = v
+
+                    result[key] = merged
+                else:
+                    # This is an intermediate nesting level - recurse
+                    # Collect corresponding sub-dicts from all properties
+                    sub_property_results = {}
+                    for prop_name, prop_result in property_results.items():
+                        prop_value = self._get_nested_value(prop_result, key)
+                        if prop_value and isinstance(prop_value, dict):
+                            sub_property_results[prop_name] = prop_value
+
+                    if sub_property_results:
+                        result[key] = self._merge_recursive(sub_property_results, value)
+            else:
+                # Non-dict value, just copy from template
+                result[key] = value
+
+        return result
+
+    def _get_nested_value(self, d: dict, key: str):
+        """Get value from dict, returning None if key doesn't exist."""
+        return d.get(key) if isinstance(d, dict) else None
+
+
 class WellDataManager:
     """
     Global orchestrator for multi-well analysis.
@@ -1511,6 +2050,60 @@ class WellDataManager:
         # Return a proxy that can be used for operations across all wells
         return _ManagerPropertyProxy(self, name)
 
+    def properties(self, property_names: list[str]) -> _ManagerMultiPropertyProxy:
+        """
+        Create a multi-property proxy for computing statistics across multiple properties.
+
+        This allows computing statistics for multiple properties at once, with
+        property-specific stats (mean, median, etc.) nested under property names
+        and common stats (depth_range, samples, thickness, etc.) at the group level.
+
+        Parameters
+        ----------
+        property_names : list[str]
+            List of property names to include in statistics
+
+        Returns
+        -------
+        _ManagerMultiPropertyProxy
+            Proxy that supports filter(), filter_intervals(), and sums_avg()
+
+        Examples
+        --------
+        >>> # Compute stats for multiple properties grouped by facies
+        >>> manager.properties(['PHIE', 'PERM']).filter('Facies').sums_avg()
+        >>> # Returns:
+        >>> # {
+        >>> #     "well_A": {
+        >>> #         "Sand": {
+        >>> #             "PHIE": {"mean": 0.18, "median": 0.17, ...},
+        >>> #             "PERM": {"mean": 150, "median": 120, ...},
+        >>> #             "depth_range": {...},
+        >>> #             "samples": 387,
+        >>> #             "thickness": 29.4,
+        >>> #             ...
+        >>> #         }
+        >>> #     }
+        >>> # }
+
+        >>> # With custom intervals
+        >>> manager.properties(['PHIE', 'PERM']).filter('Facies').filter_intervals("Zones").sums_avg()
+        >>> # Returns:
+        >>> # {
+        >>> #     "well_A": {
+        >>> #         "Zone_1": {
+        >>> #             "Sand": {
+        >>> #                 "PHIE": {"mean": 0.18, ...},
+        >>> #                 "PERM": {"mean": 150, ...},
+        >>> #                 "depth_range": {...},
+        >>> #                 ...
+        >>> #             }
+        >>> #         }
+        >>> #     }
+        >>> # }
+        """
+        return _ManagerMultiPropertyProxy(self, property_names)
+
     def load_las(
         self,
         filepath: Union[str, Path, list[Union[str, Path]]],

{well_log_toolkit-0.1.145 → well_log_toolkit-0.1.147}/well_log_toolkit/property.py

@@ -1165,6 +1165,10 @@ class Property(PropertyOperationsMixin):
         new_prop._original_sample_count = len(self.depth)
         new_prop._boundary_samples_inserted = len(new_depth) - len(self.depth)
 
+        # Preserve custom intervals if they exist (from filter_intervals)
+        if hasattr(self, '_custom_intervals') and self._custom_intervals:
+            new_prop._custom_intervals = self._custom_intervals
+
         return new_prop
 
     def filter_intervals(

{well_log_toolkit-0.1.145 → well_log_toolkit-0.1.147}/well_log_toolkit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: well-log-toolkit
-Version: 0.1.145
+Version: 0.1.147
 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