well-log-toolkit 0.1.147__py3-none-any.whl → 0.1.149__py3-none-any.whl

well_log_toolkit/manager.py

@@ -1646,6 +1646,19 @@ class _ManagerMultiPropertyProxy:
         self._filters = filters or []
         self._custom_intervals = custom_intervals
 
+    def __getattr__(self, name: str) -> '_ManagerMultiPropertyProxy':
+        """
+        Attribute access as shorthand for filter().
+
+        Allows: manager.properties(['A', 'B']).Facies.sums_avg()
+        Same as: manager.properties(['A', 'B']).filter('Facies').sums_avg()
+        """
+        # Avoid recursion for private attributes
+        if name.startswith('_'):
+            raise AttributeError(f"'{type(self).__name__}' object has no attribute '{name}'")
+        # Treat as filter
+        return self.filter(name)
+
     def filter(
         self,
         property_name: str,
@@ -1759,13 +1772,10 @@ class _ManagerMultiPropertyProxy:
 
         >>> 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."
-            )
 
+        >>> # No filters - compute stats for full well
+        >>> manager.properties(['PHIE', 'PERM']).sums_avg()
+        """
         result = {}
 
         for well_name, well in self._manager._wells.items():
@@ -1787,6 +1797,18 @@ class _ManagerMultiPropertyProxy:
         """
         Compute multi-property sums_avg for a single well.
         """
+        # Check if this well has the required saved intervals (if using saved name)
+        if self._custom_intervals:
+            intervals = self._custom_intervals.get('intervals')
+            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
+            elif isinstance(intervals, dict):
+                # Well-specific intervals - check if this well is in the dict
+                if well.name not in intervals and well.sanitized_name not in intervals:
+                    return None  # Skip wells not in the dict
+
         # Collect results for each property
         property_results = {}
 
@@ -1798,7 +1820,7 @@ class _ManagerMultiPropertyProxy:
                 if self._custom_intervals:
                     prop = self._apply_filter_intervals(prop, well)
                     if prop is None:
-                        return None  # Well doesn't have the saved intervals
+                        continue  # Skip this property if intervals can't be applied
 
                 # Apply all filters
                 for filter_name, insert_boundaries in self._filters:
@@ -1815,13 +1837,17 @@ class _ManagerMultiPropertyProxy:
                 )
                 property_results[prop_name] = result
 
-            except (PropertyNotFoundError, PropertyTypeError, AttributeError, KeyError, ValueError):
-                # Property doesn't exist in this well, skip it
+            except (PropertyNotFoundError, PropertyTypeError, AttributeError, KeyError):
+                # Property doesn't exist in this well or filter error, skip it
                 pass
 
         if not property_results:
             return None
 
+        # If no filters/intervals, return simple merged result (no grouping)
+        if not self._filters and not self._custom_intervals:
+            return self._merge_flat_results(property_results)
+
         # Merge results: nest property-specific stats, keep common stats at group level
         return self._merge_property_results(property_results)
 
@@ -1869,6 +1895,54 @@ class _ManagerMultiPropertyProxy:
             save=save
         )
 
+    def _merge_flat_results(self, property_results: dict) -> dict:
+        """
+        Merge results when no filters are applied (flat structure).
+
+        Returns a single dict with property-specific stats nested under property
+        names and common stats at the top level.
+
+        Parameters
+        ----------
+        property_results : dict
+            {property_name: sums_avg_result}
+
+        Returns
+        -------
+        dict
+            {
+                "PropertyA": {"mean": ..., "median": ..., ...},
+                "PropertyB": {"mean": ..., ...},
+                "depth_range": {...},
+                "samples": ...,
+                ...
+            }
+        """
+        if not property_results:
+            return {}
+
+        result = {}
+
+        # Add property-specific stats for each property
+        for prop_name, prop_result in property_results.items():
+            if isinstance(prop_result, dict):
+                # Extract property-specific stats
+                prop_stats = {
+                    k: v for k, v in prop_result.items()
+                    if k in self.PROPERTY_STATS
+                }
+                if prop_stats:
+                    result[prop_name] = prop_stats
+
+        # Add common stats from first property
+        first_result = next(iter(property_results.values()))
+        if isinstance(first_result, dict):
+            for k, v in first_result.items():
+                if k in self.COMMON_STATS:
+                    result[k] = v
+
+        return result
+
     def _merge_property_results(self, property_results: dict) -> dict:
         """
         Merge results from multiple properties.
@@ -2867,6 +2941,18 @@ class WellDataManager:
             # Delete sources marked for deletion
             well.delete_marked_sources(well_folder)
 
+            # Save filter intervals if any exist
+            if hasattr(well, '_saved_filter_intervals') and well._saved_filter_intervals:
+                import json
+                intervals_file = well_folder / "intervals.json"
+                with open(intervals_file, 'w') as f:
+                    json.dump(well._saved_filter_intervals, f, indent=2)
+            else:
+                # Remove intervals file if no intervals (in case they were deleted)
+                intervals_file = well_folder / "intervals.json"
+                if intervals_file.exists():
+                    intervals_file.unlink()
+
         # Save templates
         if self._templates:
             templates_folder = save_path / "templates"
@@ -2957,6 +3043,20 @@ class WellDataManager:
             for las_file in las_files:
                 self.load_las(las_file, silent=True)
 
+            # Load saved filter intervals if they exist
+            intervals_file = well_folder / "intervals.json"
+            if intervals_file.exists():
+                import json
+                try:
+                    with open(intervals_file, 'r') as f:
+                        saved_intervals = json.load(f)
+                    # Find the well for this folder and set its intervals
+                    well_key = well_folder.name  # e.g., "well_35_9_16_A"
+                    if well_key in self._wells:
+                        self._wells[well_key]._saved_filter_intervals = saved_intervals
+                except Exception as e:
+                    warnings.warn(f"Could not load intervals from {intervals_file}: {e}")
+
         return self
 
     def add_well(self, well_name: str) -> Well:

well_log_toolkit/property.py

@@ -11,6 +11,7 @@ from scipy.interpolate import interp1d
 from .exceptions import PropertyError, PropertyNotFoundError, PropertyTypeError, DepthAlignmentError
 from .statistics import (
     compute_intervals,
+    compute_zone_intervals,
     mean as stat_mean, sum as stat_sum, std as stat_std, percentile as stat_percentile
 )
 from .utils import filter_names
@@ -1429,8 +1430,8 @@ class Property(PropertyOperationsMixin):
         max_valid_depth = valid_depths.max()
 
         # Find boundaries that fall within the valid data range
-        # Filter to boundaries within valid range first
-        mask = (boundary_depths > min_valid_depth) & (boundary_depths < max_valid_depth)
+        # Filter to boundaries within valid range (inclusive on both ends)
+        mask = (boundary_depths >= min_valid_depth) & (boundary_depths <= max_valid_depth)
         potential_boundaries = boundary_depths[mask]
 
         if len(potential_boundaries) == 0:
@@ -1760,6 +1761,9 @@ class Property(PropertyOperationsMixin):
 
         This allows overlapping intervals where the same depths can
         contribute to multiple zones.
+
+        Uses zone-aware intervals that are truncated at zone boundaries to ensure
+        thickness is correctly attributed to each zone.
         """
         result = {}
 
@@ -1768,8 +1772,12 @@ class Property(PropertyOperationsMixin):
             top = float(interval['top'])
             base = float(interval['base'])
 
-            # Create mask for this interval (top <= depth < base)
-            interval_mask = (self.depth >= top) & (self.depth < base)
+            # Compute zone-aware intervals truncated at zone boundaries
+            zone_intervals = compute_zone_intervals(self.depth, top, base)
+
+            # Create mask based on zone intervals - includes any sample that
+            # contributes to this zone (even boundary samples with partial intervals)
+            interval_mask = zone_intervals > 0
 
             # If there are secondary properties, group within this interval
             if self.secondary_properties:
@@ -1779,7 +1787,8 @@ class Property(PropertyOperationsMixin):
                     weighted=weighted,
                     arithmetic=arithmetic,
                     gross_thickness=gross_thickness,
-                    precision=precision
+                    precision=precision,
+                    zone_intervals=zone_intervals
                 )
             else:
                 # No secondary properties, compute stats directly for interval
@@ -1788,7 +1797,8 @@ class Property(PropertyOperationsMixin):
                     weighted=weighted,
                     arithmetic=arithmetic,
                     gross_thickness=gross_thickness,
-                    precision=precision
+                    precision=precision,
+                    zone_intervals=zone_intervals
                 )
 
         return result
@@ -1905,6 +1915,9 @@ class Property(PropertyOperationsMixin):
         This allows overlapping intervals where the same depths can
         contribute to multiple zones. Zone-level metadata (depth_range, thickness)
         is shown at the interval level, and fractions are relative to zone thickness.
+
+        Uses zone-aware intervals that are truncated at zone boundaries to ensure
+        thickness is correctly attributed to each zone.
         """
         result = {}
 
@@ -1913,13 +1926,16 @@ class Property(PropertyOperationsMixin):
             top = float(interval['top'])
             base = float(interval['base'])
 
-            # Create mask for this interval (top <= depth < base)
-            interval_mask = (self.depth >= top) & (self.depth < base)
+            # Compute zone-aware intervals truncated at zone boundaries
+            zone_intervals = compute_zone_intervals(self.depth, top, base)
+
+            # Create mask based on zone intervals - includes any sample that
+            # contributes to this zone (even boundary samples with partial intervals)
+            interval_mask = zone_intervals > 0
 
-            # Calculate zone thickness for fraction calculation
-            full_intervals = compute_intervals(self.depth)
+            # Calculate zone thickness using zone-aware intervals
             valid_mask = ~np.isnan(self.values) & interval_mask
-            zone_thickness = float(np.sum(full_intervals[valid_mask]))
+            zone_thickness = float(np.sum(zone_intervals[valid_mask]))
 
             # Get actual depth range within the interval (where we have data)
             if np.any(valid_mask):
@@ -1944,7 +1960,8 @@ class Property(PropertyOperationsMixin):
                     interval_mask,
                     gross_thickness=zone_thickness,  # Use zone thickness for fractions
                     precision=precision,
-                    include_depth_range=False  # Don't include depth_range per facies
+                    include_depth_range=False,  # Don't include depth_range per facies
+                    zone_intervals=zone_intervals  # Pass zone-aware intervals
                 )
             else:
                 # No secondary properties, compute stats directly for interval
@@ -1952,7 +1969,8 @@ class Property(PropertyOperationsMixin):
                     interval_mask,
                     gross_thickness=zone_thickness,  # Use zone thickness for fractions
                     precision=precision,
-                    include_depth_range=False  # Don't include depth_range per facies
+                    include_depth_range=False,  # Don't include depth_range per facies
+                    zone_intervals=zone_intervals  # Pass zone-aware intervals
                 )
 
             # Nest facies stats under 'facies' key for cleaner structure
@@ -1967,7 +1985,8 @@ class Property(PropertyOperationsMixin):
         mask: np.ndarray,
         gross_thickness: float,
         precision: int = 6,
-        include_depth_range: bool = True
+        include_depth_range: bool = True,
+        zone_intervals: Optional[np.ndarray] = None
     ) -> dict:
         """
         Recursively group discrete statistics by secondary properties.
@@ -1984,6 +2003,9 @@ class Property(PropertyOperationsMixin):
             Number of decimal places for rounding
         include_depth_range : bool, default True
             Whether to include depth_range in per-facies stats
+        zone_intervals : np.ndarray, optional
+            Pre-computed zone-aware intervals truncated at zone boundaries.
+            If None, computes intervals using standard midpoint method.
 
         Returns
         -------
@@ -1992,7 +2014,7 @@ class Property(PropertyOperationsMixin):
         """
         if filter_idx >= len(self.secondary_properties):
             # Base case: compute discrete statistics for this group
-            return self._compute_discrete_stats(mask, gross_thickness, precision, include_depth_range)
+            return self._compute_discrete_stats(mask, gross_thickness, precision, include_depth_range, zone_intervals)
 
         # Get unique values for current filter
         current_filter = self.secondary_properties[filter_idx]
@@ -2002,12 +2024,16 @@ class Property(PropertyOperationsMixin):
 
         if len(unique_vals) == 0:
             # No valid values, return stats for current mask
-            return self._compute_discrete_stats(mask, gross_thickness, precision, include_depth_range)
+            return self._compute_discrete_stats(mask, gross_thickness, precision, include_depth_range, zone_intervals)
 
         # Group by each unique value
         depth_array = self.depth
         values_array = self.values
-        full_intervals = compute_intervals(depth_array)
+        # Use zone intervals if provided, otherwise compute on full array
+        if zone_intervals is not None:
+            full_intervals = zone_intervals
+        else:
+            full_intervals = compute_intervals(depth_array)
 
         result = {}
         for val in unique_vals:
@@ -2038,7 +2064,7 @@ class Property(PropertyOperationsMixin):
                 key = f"{current_filter.name}_{val:.2f}"
 
             result[key] = self._recursive_discrete_group(
-                filter_idx + 1, sub_mask, group_thickness, precision, include_depth_range
+                filter_idx + 1, sub_mask, group_thickness, precision, include_depth_range, zone_intervals
             )
 
         return result
@@ -2048,7 +2074,8 @@ class Property(PropertyOperationsMixin):
         mask: np.ndarray,
         gross_thickness: float,
         precision: int = 6,
-        include_depth_range: bool = True
+        include_depth_range: bool = True,
+        zone_intervals: Optional[np.ndarray] = None
     ) -> dict:
         """
         Compute categorical statistics for discrete property values.
@@ -2064,6 +2091,9 @@ class Property(PropertyOperationsMixin):
         include_depth_range : bool, default True
             Whether to include depth_range in per-facies stats.
             Set to False when using filter_intervals (depth_range shown at zone level).
+        zone_intervals : np.ndarray, optional
+            Pre-computed zone-aware intervals truncated at zone boundaries.
+            If None, computes intervals using standard midpoint method.
 
         Returns
         -------
@@ -2077,9 +2107,12 @@ class Property(PropertyOperationsMixin):
         values = values_array[mask]
         depths = depth_array[mask]
 
-        # Compute intervals on full array then mask
-        full_intervals = compute_intervals(depth_array)
-        intervals = full_intervals[mask]
+        # Use zone intervals if provided, otherwise compute on full array
+        if zone_intervals is not None:
+            intervals = zone_intervals[mask]
+        else:
+            full_intervals = compute_intervals(depth_array)
+            intervals = full_intervals[mask]
 
         # Find unique discrete values
         valid_mask_local = ~np.isnan(values)
@@ -2132,7 +2165,8 @@ class Property(PropertyOperationsMixin):
         weighted: bool,
         arithmetic: bool,
         gross_thickness: float,
-        precision: int = 6
+        precision: int = 6,
+        zone_intervals: Optional[np.ndarray] = None
     ) -> dict:
         """
         Recursively group by secondary properties.
@@ -2151,6 +2185,9 @@ class Property(PropertyOperationsMixin):
             Total gross thickness for fraction calculation
         precision : int, default 6
             Number of decimal places for rounding
+        zone_intervals : np.ndarray, optional
+            Pre-computed zone-aware intervals truncated at zone boundaries.
+            If None, computes intervals using standard midpoint method.
 
         Returns
         -------
@@ -2159,7 +2196,7 @@ class Property(PropertyOperationsMixin):
         """
         if filter_idx >= len(self.secondary_properties):
             # Base case: compute statistics for this group
-            return self._compute_stats(mask, weighted, arithmetic, gross_thickness, precision)
+            return self._compute_stats(mask, weighted, arithmetic, gross_thickness, precision, zone_intervals)
 
         # Get unique values for current filter
         current_filter = self.secondary_properties[filter_idx]
@@ -2170,14 +2207,18 @@ class Property(PropertyOperationsMixin):
 
         if len(unique_vals) == 0:
             # No valid values, return stats for current mask
-            return self._compute_stats(mask, weighted, arithmetic, gross_thickness, precision)
+            return self._compute_stats(mask, weighted, arithmetic, gross_thickness, precision, zone_intervals)
 
         # Calculate parent thickness BEFORE subdividing
         # This becomes the gross_thickness for all child groups
         # Cache property access to avoid overhead
         depth_array = self.depth
         values_array = self.values
-        parent_intervals = compute_intervals(depth_array)
+        # Use zone intervals if provided, otherwise compute on full array
+        if zone_intervals is not None:
+            parent_intervals = zone_intervals
+        else:
+            parent_intervals = compute_intervals(depth_array)
         parent_valid = mask & ~np.isnan(values_array)
         parent_thickness = float(np.sum(parent_intervals[parent_valid]))
 
@@ -2212,7 +2253,7 @@ class Property(PropertyOperationsMixin):
                 key = f"{current_filter.name}_{val:.2f}"
 
             result[key] = self._recursive_group(
-                filter_idx + 1, sub_mask, weighted, arithmetic, parent_thickness, precision
+                filter_idx + 1, sub_mask, weighted, arithmetic, parent_thickness, precision, zone_intervals
             )
 
         return result
@@ -2223,7 +2264,8 @@ class Property(PropertyOperationsMixin):
         weighted: bool = True,
         arithmetic: bool = False,
         gross_thickness: float = 0.0,
-        precision: int = 6
+        precision: int = 6,
+        zone_intervals: Optional[np.ndarray] = None
     ) -> dict:
         """
         Compute statistics for values selected by mask.
@@ -2244,6 +2286,9 @@ class Property(PropertyOperationsMixin):
             Total gross thickness for fraction calculation
         precision : int, default 6
             Number of decimal places for rounding
+        zone_intervals : np.ndarray, optional
+            Pre-computed zone-aware intervals truncated at zone boundaries.
+            If None, computes intervals using standard midpoint method.
 
         Returns
         -------
@@ -2263,12 +2308,17 @@ class Property(PropertyOperationsMixin):
         values = values_array[mask]
         valid = values[~np.isnan(values)]
 
-        # Compute depth intervals on FULL depth array first, then mask
-        # This is critical! Intervals must be computed on full grid so that
-        # zone boundary samples get correct weights based on their neighbors
-        # in the full sequence, not just within their zone.
-        full_intervals = compute_intervals(depth_array)
-        intervals = full_intervals[mask]
+        # Use zone intervals if provided, otherwise compute on full array
+        # Zone intervals are truncated at zone boundaries for accurate thickness
+        if zone_intervals is not None:
+            intervals = zone_intervals[mask]
+        else:
+            # Compute depth intervals on FULL depth array first, then mask
+            # This is critical! Intervals must be computed on full grid so that
+            # zone boundary samples get correct weights based on their neighbors
+            # in the full sequence, not just within their zone.
+            full_intervals = compute_intervals(depth_array)
+            intervals = full_intervals[mask]
         valid_mask_local = ~np.isnan(values)
         valid_intervals = intervals[valid_mask_local]
 

well_log_toolkit/statistics.py

@@ -61,6 +61,83 @@ def compute_intervals(depth: np.ndarray) -> np.ndarray:
     return intervals
 
 
+def compute_zone_intervals(
+    depth: np.ndarray,
+    top: float,
+    base: float
+) -> np.ndarray:
+    """
+    Compute depth intervals truncated to zone boundaries.
+
+    Uses the midpoint method but truncates intervals at zone boundaries
+    to ensure thickness is correctly attributed to each zone.
+
+    Parameters
+    ----------
+    depth : np.ndarray
+        Depth values (must be sorted ascending)
+    top : float
+        Zone top depth (inclusive)
+    base : float
+        Zone base depth (exclusive)
+
+    Returns
+    -------
+    np.ndarray
+        Interval thickness for each depth point, truncated to zone boundaries.
+        Points outside the zone have zero interval.
+
+    Examples
+    --------
+    >>> depth = np.array([2708.0, 2708.3, 2708.4, 2708.6])
+    >>> # Zone from 2708.0 to 2708.4
+    >>> compute_zone_intervals(depth, 2708.0, 2708.4)
+    array([0.15, 0.2, 0.05, 0.0])
+
+    The intervals are truncated at zone boundary 2708.4:
+    - 2708.0: from 2708.0 to midpoint(2708.0, 2708.3)=2708.15 = 0.15m
+    - 2708.3: from 2708.15 to midpoint(2708.3, 2708.4)=2708.35 = 0.2m
+    - 2708.4: from 2708.35 to 2708.4 (zone boundary) = 0.05m (truncated)
+    - 2708.6: outside zone = 0.0m
+    """
+    if len(depth) == 0:
+        return np.array([])
+
+    if len(depth) == 1:
+        # Single point - check if it's in the zone
+        if top <= depth[0] < base:
+            return np.array([base - top])
+        return np.array([0.0])
+
+    zone_intervals = np.zeros(len(depth))
+
+    for i in range(len(depth)):
+        d = depth[i]
+
+        # Calculate midpoint bounds for this sample
+        if i == 0:
+            lower_bound = d - (depth[1] - d) / 2.0  # Mirror first interval
+        else:
+            lower_bound = (depth[i - 1] + d) / 2.0
+
+        if i == len(depth) - 1:
+            upper_bound = d + (d - depth[-2]) / 2.0  # Mirror last interval
+        else:
+            upper_bound = (d + depth[i + 1]) / 2.0
+
+        # Truncate to zone boundaries
+        effective_lower = max(lower_bound, top)
+        effective_upper = min(upper_bound, base)
+
+        # Only count if there's overlap with the zone
+        if effective_upper > effective_lower:
+            zone_intervals[i] = effective_upper - effective_lower
+        else:
+            zone_intervals[i] = 0.0
+
+    return zone_intervals
+
+
 def mean(
     values: np.ndarray,
     weights: Optional[np.ndarray] = None,

{well_log_toolkit-0.1.147.dist-info → well_log_toolkit-0.1.149.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: well-log-toolkit
-Version: 0.1.147
+Version: 0.1.149
 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.147.dist-info → well_log_toolkit-0.1.149.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=WQHzNOXj7jVLeQlWG_uqfd93qemi5Mbe__z9NQRqk_Y,132563
+well_log_toolkit/manager.py,sha256=Jx0w1KpxRB2Oex6bC0FQFZOlJkoTKNexW3HMXxndL68,136713
 well_log_toolkit/operations.py,sha256=z8j8fGBOwoJGUQFy-Vawjq9nm3OD_dUt0oaNh8yuG7o,18515
-well_log_toolkit/property.py,sha256=GsiD9c4SfBw8ar7ZJXS0NNejPlpvFRHKck_eBR2lLmo,100965
+well_log_toolkit/property.py,sha256=TkBuqgunIGIGdsLtWtQkwwXPdh0yqY37PgO_150FilA,103782
 well_log_toolkit/regression.py,sha256=JDcRxaODJnFikAdPJyTq8eUV7iY0vCDmvnGufqlojxs,31625
-well_log_toolkit/statistics.py,sha256=_huPMbv2H3o9ezunjEM94mJknX5wPK8V4nDv2lIZZRw,16814
+well_log_toolkit/statistics.py,sha256=cpUbaRGlqyqpGWKtETk9XpXWrMJIIjVacdqEqIBkvqQ,19118
 well_log_toolkit/utils.py,sha256=O2KPq4htIoUlL74V2zKftdqqTjRfezU9M-568zPLme0,6866
 well_log_toolkit/visualization.py,sha256=nnpmFmbj44TbP0fsnLMR1GaKRkqKCEpI6Fd8Cp0oqBc,204716
 well_log_toolkit/well.py,sha256=n6XfaGSjGtyXCIaAr0ytslIK0DMUY_fSPQ_VCqj8jaU,106173
-well_log_toolkit-0.1.147.dist-info/METADATA,sha256=U89SvoBEewtJiCSN0ZNvevh1UGV__w7-8C3YGGIQZUM,63473
-well_log_toolkit-0.1.147.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-well_log_toolkit-0.1.147.dist-info/top_level.txt,sha256=BMOo7OKLcZEnjo0wOLMclwzwTbYKYh31I8RGDOGSBdE,17
-well_log_toolkit-0.1.147.dist-info/RECORD,,
+well_log_toolkit-0.1.149.dist-info/METADATA,sha256=g__8aYidDAd_oKi-MQ7PLGX0Ss63NHRbxjudCfdGtF8,63473
+well_log_toolkit-0.1.149.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+well_log_toolkit-0.1.149.dist-info/top_level.txt,sha256=BMOo7OKLcZEnjo0wOLMclwzwTbYKYh31I8RGDOGSBdE,17
+well_log_toolkit-0.1.149.dist-info/RECORD,,