well-log-toolkit 0.1.114__tar.gz → 0.1.116__tar.gz

{well_log_toolkit-0.1.114 → well_log_toolkit-0.1.116}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "well-log-toolkit"
-version = "0.1.114"
+version = "0.1.116"
 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.114 → well_log_toolkit-0.1.116}/well_log_toolkit/manager.py

@@ -2466,6 +2466,9 @@ class WellDataManager:
         depth_range: Optional[tuple[float, float]] = None,
         show_colorbar: bool = True,
         show_legend: bool = True,
+        regression: Optional[Union[str, dict]] = None,
+        regression_by_color: Optional[Union[str, dict]] = None,
+        regression_by_group: Optional[Union[str, dict]] = None,
     ) -> 'Crossplot':
         """
         Create a multi-well crossplot.
@@ -2531,6 +2534,19 @@ class WellDataManager:
             Show colorbar when using color mapping. Default: True
         show_legend : bool, optional
             Show legend. Default: True
+        regression : str or dict, optional
+            Regression type to apply to all data points. Can be a string (e.g., "linear") or
+            dict with keys: type, line_color, line_width, line_style, line_alpha, x_range.
+            Default: None
+        regression_by_color : str or dict, optional
+            Regression type to apply separately for each color group in the plot. Creates
+            separate regression lines based on what determines colors in the visualization:
+            explicit color mapping if specified, otherwise shape groups (e.g., wells when
+            shape='well'). Accepts string or dict format. Default: None
+        regression_by_group : str or dict, optional
+            Regression type to apply separately for each well. Creates separate
+            regression lines for each well. Accepts string or dict format.
+            Default: None
 
         Returns
         -------
@@ -2608,6 +2624,9 @@ class WellDataManager:
             depth_range=depth_range,
             show_colorbar=show_colorbar,
             show_legend=show_legend,
+            regression=regression,
+            regression_by_color=regression_by_color,
+            regression_by_group=regression_by_group,
         )
 
     def __repr__(self) -> str:

{well_log_toolkit-0.1.114 → well_log_toolkit-0.1.116}/well_log_toolkit/visualization.py

@@ -2827,9 +2827,10 @@ class Crossplot:
         dict with keys: type, line_color, line_width, line_style, line_alpha, x_range.
         Default: None
     regression_by_color : str or dict, optional
-        Regression type to apply separately for each color group. Creates separate
-        regression lines for each unique color value. Accepts string or dict format.
-        Default: None
+        Regression type to apply separately for each color group in the plot. Creates
+        separate regression lines based on what determines colors in the visualization:
+        explicit color mapping if specified, otherwise shape groups (e.g., wells when
+        shape='well'). Accepts string or dict format. Default: None
     regression_by_group : str or dict, optional
         Regression type to apply separately for each group (well or shape). Creates
         separate regression lines for each well or shape category. Accepts string or dict.
@@ -2961,6 +2962,9 @@ class Crossplot:
         self._regressions = {}
         self.regression_lines = {}
 
+        # Pending regressions (added before plot() is called)
+        self._pending_regressions = []
+
         # Data cache
         self._data = None
 
@@ -3159,53 +3163,70 @@ class Crossplot:
             config = self._parse_regression_config(self.regression_by_color)
             reg_type = config['type']
 
-            if not self.color:
-                warnings.warn("regression_by_color specified but no color mapping defined, skipping")
+            # Determine grouping column based on what's being used for colors in the plot
+            group_column = None
+            group_label = None
+
+            if self.color and 'color_val' in data.columns:
+                # User specified explicit color mapping
+                group_column = 'color_val'
+                group_label = self.color
+            elif self.shape == "well" and 'well' in data.columns:
+                # When shape="well", each well gets a different color in the plot
+                group_column = 'well'
+                group_label = 'well'
+            elif self.shape and self.shape != "well" and 'shape_val' in data.columns:
+                # When shape is a property, each shape group gets a different color
+                group_column = 'shape_val'
+                group_label = self.shape
+
+            if group_column is None:
+                warnings.warn(
+                    "regression_by_color specified but no color grouping detected in plot. "
+                    "Use color=<property>, shape='well', or shape=<property> parameter."
+                )
             else:
-                # Get unique color groups
-                if 'color_val' in data.columns:
-                    # For continuous color values, we need to bin them or use unique values
-                    # Check if color is categorical (well, shape) or continuous
-                    if self.color == 'depth' or pd.api.types.is_numeric_dtype(data['color_val']):
-                        # For continuous values, we can't create separate regressions
-                        warnings.warn(
-                            f"regression_by_color requires categorical color mapping, "
-                            f"but '{self.color}' is continuous. Use regression_by_group instead."
+                # Check if color is categorical (not continuous like depth)
+                if group_column == 'color_val' and (self.color == 'depth' or pd.api.types.is_numeric_dtype(data[group_column])):
+                    # For continuous values, we can't create separate regressions
+                    warnings.warn(
+                        f"regression_by_color requires categorical color mapping, "
+                        f"but '{self.color}' is continuous. Use regression_by_group instead."
+                    )
+                else:
+                    # Categorical values - group and create regressions
+                    color_groups = data.groupby(group_column)
+                    n_groups = len(color_groups)
+
+                    # Validate regression count
+                    if regression_count + n_groups > total_points / 2:
+                        raise ValueError(
+                            f"Too many regression lines requested: {regression_count + n_groups} lines "
+                            f"for {total_points} data points (average < 2 points per line). "
+                            f"Reduce the number of groups or use a different regression strategy."
                         )
-                    else:
-                        # Categorical color values
-                        color_groups = data.groupby('color_val')
-                        n_groups = len(color_groups)
-
-                        # Validate regression count
-                        if regression_count + n_groups > total_points / 2:
-                            raise ValueError(
-                                f"Too many regression lines requested: {regression_count + n_groups} lines "
-                                f"for {total_points} data points (average < 2 points per line). "
-                                f"Reduce the number of groups or use a different regression strategy."
-                            )
 
-                        for idx, (group_name, group_data) in enumerate(color_groups):
-                            x_vals = group_data['x'].values
-                            y_vals = group_data['y'].values
-                            mask = np.isfinite(x_vals) & np.isfinite(y_vals)
-                            if np.sum(mask) >= 2:
-                                # Copy config and set default line color if not specified
-                                group_config = config.copy()
-                                if 'line_color' not in group_config:
-                                    group_config['line_color'] = regression_colors[color_idx % len(regression_colors)]
-
-                                # Skip legend update for all but last regression
-                                is_last = (idx == n_groups - 1)
-                                self._add_group_regression(
-                                    x_vals[mask], y_vals[mask],
-                                    reg_type,
-                                    name=f"{self.color}={group_name}",
-                                    config=group_config,
-                                    update_legend=is_last
-                                )
-                                regression_count += 1
-                                color_idx += 1
+                    for idx, (group_name, group_data) in enumerate(color_groups):
+                        x_vals = group_data['x'].values
+                        y_vals = group_data['y'].values
+                        mask = np.isfinite(x_vals) & np.isfinite(y_vals)
+                        if np.sum(mask) >= 2:
+                            # Copy config and set default line color if not specified
+                            group_config = config.copy()
+                            if 'line_color' not in group_config:
+                                group_config['line_color'] = regression_colors[color_idx % len(regression_colors)]
+
+                            # Skip legend update for all but last regression
+                            is_last = (idx == n_groups - 1)
+                            self._add_group_regression(
+                                x_vals[mask], y_vals[mask],
+                                reg_type,
+                                name=f"{group_label}={group_name}",
+                                config=group_config,
+                                update_legend=is_last
+                            )
+                            regression_count += 1
+                            color_idx += 1
 
         # Add regression by groups (well or shape)
         if self.regression_by_group:
@@ -3355,6 +3376,51 @@ class Crossplot:
         # Add automatic regressions if specified
         self._add_automatic_regressions(data)
 
+        # Apply pending regressions (added via add_regression() before plot() was called)
+        if self._pending_regressions:
+            for pending in self._pending_regressions:
+                # Get the already-fitted regression object
+                reg_type = pending['regression_type']
+                reg_name = pending['name'] if pending['name'] else reg_type
+
+                # Retrieve stored regression
+                if reg_type in self._regressions and reg_name in self._regressions[reg_type]:
+                    reg = self._regressions[reg_type][reg_name]
+
+                    # Draw the regression line
+                    try:
+                        x_line, y_line = reg.get_plot_data(x_range=pending['x_range'], num_points=200)
+                    except ValueError as e:
+                        warnings.warn(f"Could not generate plot data for {reg_type} regression: {e}")
+                        continue
+
+                    # Create label
+                    label_parts = [reg_name]
+                    if pending['show_equation']:
+                        label_parts.append(reg.equation())
+                    if pending['show_r2']:
+                        label_parts.append(f"R² = {reg.r_squared:.4f}")
+                    label = "\n".join(label_parts)
+
+                    # Plot line
+                    line = self.ax.plot(
+                        x_line, y_line,
+                        color=pending['line_color'],
+                        linewidth=pending['line_width'],
+                        linestyle=pending['line_style'],
+                        alpha=pending['line_alpha'],
+                        label=label
+                    )[0]
+
+                    self.regression_lines[reg_name] = line
+
+            # Update legend once after all pending regressions
+            if self.ax is not None:
+                self.ax.legend(loc='best', frameon=True, framealpha=0.9, edgecolor='black')
+
+            # Clear pending list
+            self._pending_regressions = []
+
         # Tight layout
         self.fig.tight_layout()
 
@@ -3575,7 +3641,7 @@ class Crossplot:
         reg_name = name if name else regression_type
         self._store_regression(regression_type, reg_name, reg)
 
-        # Plot regression line if figure exists
+        # Plot regression line if figure exists, otherwise store for later
         if self.ax is not None:
             # Get plot data using the regression helper method
             try:
@@ -3606,6 +3672,20 @@ class Crossplot:
 
             # Update legend
             self.ax.legend(loc='best', frameon=True, framealpha=0.9, edgecolor='black')
+        else:
+            # Store for later when plot() is called
+            self._pending_regressions.append({
+                'regression_type': regression_type,
+                'name': name,
+                'line_color': line_color,
+                'line_width': line_width,
+                'line_style': line_style,
+                'line_alpha': line_alpha,
+                'show_equation': show_equation,
+                'show_r2': show_r2,
+                'x_range': x_range,
+                'kwargs': kwargs
+            })
 
         return self
 

{well_log_toolkit-0.1.114 → well_log_toolkit-0.1.116}/well_log_toolkit.egg-info/PKG-INFO

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