well-log-toolkit 0.1.144__tar.gz → 0.1.146__tar.gz

{well_log_toolkit-0.1.144 → well_log_toolkit-0.1.146}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "well-log-toolkit"
-version = "0.1.144"
+version = "0.1.146"
 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.144 → well_log_toolkit-0.1.146}/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:

{well_log_toolkit-0.1.144 → well_log_toolkit-0.1.146}/well_log_toolkit/property.py

@@ -1789,7 +1789,11 @@ class Property(PropertyOperationsMixin):
 
         return result
 
-    def discrete_summary(self, precision: int = 6) -> dict:
+    def discrete_summary(
+        self,
+        precision: int = 6,
+        skip: Optional[list[str]] = None
+    ) -> dict:
         """
         Compute summary statistics for discrete/categorical properties.
 
@@ -1801,6 +1805,9 @@ class Property(PropertyOperationsMixin):
         ----------
         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
         -------
@@ -1808,8 +1815,7 @@ class Property(PropertyOperationsMixin):
             Nested dictionary with statistics for each discrete value.
             If secondary properties (filters) exist, the structure is hierarchical.
 
-            For each discrete value, includes:
-            - label: Human-readable name (if labels defined)
+            For each discrete value, includes (unless skipped):
             - code: Numeric code for this category
             - count: Number of samples with this value
             - thickness: Total depth interval (meters) for this category
@@ -1824,6 +1830,10 @@ class Property(PropertyOperationsMixin):
         >>> # {'Sand': {'code': 1, 'count': 150, 'thickness': 25.5, 'fraction': 0.45, ...},
         >>> #  'Shale': {'code': 2, 'count': 180, 'thickness': 30.8, 'fraction': 0.55, ...}}
 
+        >>> # Skip certain fields
+        >>> stats = facies.discrete_summary(skip=['code', 'count'])
+        >>> # {'Sand': {'thickness': 25.5, 'fraction': 0.45}, ...}
+
         >>> # Grouped by zones
         >>> filtered = facies.filter('Well_Tops')
         >>> stats = filtered.discrete_summary()
@@ -1842,26 +1852,43 @@ class Property(PropertyOperationsMixin):
         # Check for custom intervals (from filter_intervals)
         # These are processed independently, allowing overlaps
         if hasattr(self, '_custom_intervals') and self._custom_intervals:
-            return self._compute_discrete_stats_by_intervals(
+            result = self._compute_discrete_stats_by_intervals(
                 gross_thickness=gross_thickness,
                 precision=precision
             )
-
-        if not self.secondary_properties:
+        elif not self.secondary_properties:
             # No filters, compute stats for all discrete values
-            return self._compute_discrete_stats(
+            result = self._compute_discrete_stats(
+                np.ones(len(self.depth), dtype=bool),
+                gross_thickness=gross_thickness,
+                precision=precision
+            )
+        else:
+            # Build hierarchical grouping
+            result = self._recursive_discrete_group(
+                0,
                 np.ones(len(self.depth), dtype=bool),
                 gross_thickness=gross_thickness,
                 precision=precision
             )
 
-        # Build hierarchical grouping
-        return self._recursive_discrete_group(
-            0,
-            np.ones(len(self.depth), dtype=bool),
-            gross_thickness=gross_thickness,
-            precision=precision
-        )
+        # Remove skipped fields from output
+        if skip:
+            result = self._remove_keys_recursive(result, skip)
+
+        return result
+
+    def _remove_keys_recursive(self, d: dict, keys_to_remove: list[str]) -> dict:
+        """Recursively remove specified keys from nested dicts."""
+        result = {}
+        for key, value in d.items():
+            if key in keys_to_remove:
+                continue
+            if isinstance(value, dict):
+                result[key] = self._remove_keys_recursive(value, keys_to_remove)
+            else:
+                result[key] = value
+        return result
 
     def _compute_discrete_stats_by_intervals(
         self,
@@ -2071,14 +2098,12 @@ class Property(PropertyOperationsMixin):
             count = int(np.sum(val_mask))
             fraction = thickness / gross_thickness if gross_thickness > 0 else 0.0
 
-            # Determine the key and label
+            # Determine the key (use label if available, otherwise name_code)
             int_val = int(val)
             if self.labels is not None and int_val in self.labels:
                 key = self.labels[int_val]
-                label = self.labels[int_val]
             else:
                 key = f"{self.name}_{int_val}"
-                label = None
 
             stats = {
                 'code': int_val,
@@ -2091,8 +2116,6 @@ class Property(PropertyOperationsMixin):
                     'min': round(float(np.min(val_depths)), precision),
                     'max': round(float(np.max(val_depths)), precision)
                 }
-            if label is not None:
-                stats['label'] = label
 
             result[key] = stats
 

{well_log_toolkit-0.1.144 → well_log_toolkit-0.1.146}/well_log_toolkit.egg-info/PKG-INFO

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