plotext-plus 1.0.7__py3-none-any.whl → 1.0.9__py3-none-any.whl

plotext_plus/__init__.py

@@ -26,6 +26,6 @@ from ._api import (
     Chart, Legend, PlotextAPI, api,
     ScatterChart, LineChart, BarChart, HistogramChart,
     CandlestickChart, HeatmapChart, MatrixChart, StemChart,
-    create_chart, quick_scatter, quick_line, quick_bar,
+    create_chart, quick_scatter, quick_line, quick_bar, quick_pie, quick_donut,
     enable_banners, log_info, log_success, log_warning, log_error
 )

plotext_plus/_api.py

@@ -84,6 +84,22 @@ class Chart:
         })
         return self
     
+    def pie(self, labels, values, colors=None, radius=None, show_values=True, show_percentages=True, show_values_on_slices=False, donut=False, remaining_color=None):
+        """Add pie chart data"""
+        self._data.append({
+            'type': 'pie',
+            'labels': labels,
+            'values': values,
+            'colors': colors,
+            'radius': radius,
+            'show_values': show_values,
+            'show_percentages': show_percentages,
+            'show_values_on_slices': show_values_on_slices,
+            'donut': donut,
+            'remaining_color': remaining_color
+        })
+        return self
+    
     def title(self, title):
         """Set chart title"""
         self._config['title'] = title
@@ -172,6 +188,18 @@ class Chart:
                     _core.horizontal_bar(data_item['labels'], data_item['values'], color=data_item['color'])
                 else:
                     _core.bar(data_item['labels'], data_item['values'], color=data_item['color'])
+            elif data_item['type'] == 'pie':
+                _core.pie(
+                    data_item['labels'], 
+                    data_item['values'], 
+                    colors=data_item['colors'],
+                    radius=data_item['radius'],
+                    show_values=data_item['show_values'],
+                    show_percentages=data_item['show_percentages'],
+                    show_values_on_slices=data_item['show_values_on_slices'],
+                    donut=data_item.get('donut', False),
+                    remaining_color=data_item.get('remaining_color', None)
+                )
             elif data_item['type'] == 'histogram':
                 _core.hist(data_item['data'], bins=data_item['bins'], color=data_item['color'])
         
@@ -763,6 +791,25 @@ class PlotextAPI:
         chart.show()
         return chart
     
+    @staticmethod 
+    def quick_pie(labels, values, colors=None, title=None, use_banners=False, banner_title=None, 
+                  show_values=True, show_percentages=True, show_values_on_slices=False, donut=False, remaining_color=None):
+        """Quickly create and display a pie chart"""
+        chart = Chart(use_banners, banner_title)
+        chart.pie(labels, values, colors=colors, show_values=show_values, show_percentages=show_percentages, show_values_on_slices=show_values_on_slices, donut=donut, remaining_color=remaining_color)
+        if title:
+            chart.title(title)
+        chart.show()
+        return chart
+    
+    @staticmethod
+    def quick_donut(labels, values, colors=None, title=None, use_banners=False, banner_title=None, 
+                    show_values=True, show_percentages=True, show_values_on_slices=False, remaining_color=None):
+        """Quickly create and display a doughnut chart"""
+        return api.quick_pie(labels, values, colors=colors, title=title, use_banners=use_banners, 
+                           banner_title=banner_title, show_values=show_values, 
+                           show_percentages=show_percentages, show_values_on_slices=show_values_on_slices, donut=True, remaining_color=remaining_color)
+    
     @staticmethod
     def enable_banners(enabled=True, default_title="Plotext Chart"):
         """Globally enable or disable banner mode"""
@@ -797,6 +844,8 @@ create_chart = api.create_chart
 quick_scatter = api.quick_scatter
 quick_line = api.quick_line
 quick_bar = api.quick_bar
+quick_pie = api.quick_pie
+quick_donut = api.quick_donut
 enable_banners = api.enable_banners
 log_info = api.log_info
 log_success = api.log_success
@@ -820,6 +869,8 @@ __all__ = [
     'quick_scatter',
     'quick_line',
     'quick_bar',
+    'quick_pie',
+    'quick_donut',
     'enable_banners',
     'log_info',
     'log_success',

plotext_plus/_core.py

@@ -278,6 +278,27 @@ def matrix_plot(matrix, marker = None, style = None, fast = False):
     _figure._active.matrix_plot(matrix, marker = marker, style = style, fast = fast)
     _figure.show() if _figure._interactive else None
 
+def pie(labels, values, colors = None, radius = None, show_values = True, show_percentages = True, title = None, show_values_on_slices = False, donut = False, remaining_color = None):
+    """
+    Create a pie chart representation using terminal characters.
+    
+    Args:
+        labels (list): Labels for each slice
+        values (list): Values for each slice  
+        colors (list, optional): Colors for each slice
+        radius (int, optional): Radius of the pie chart
+        show_values (bool): Whether to show actual values in legend
+        show_percentages (bool): Whether to show percentages in legend
+        title (str, optional): Title for the chart
+        show_values_on_slices (bool): Whether to show values/percentages on pie slices themselves
+        donut (bool): If True, creates a doughnut chart with hollow center (inner radius = 1/3 outer radius)
+        remaining_color (str): If specified, colors the remaining slice with this color instead of leaving it as spaces
+    """
+    _figure._active.pie(labels, values, colors = colors, radius = radius, 
+                       show_values = show_values, show_percentages = show_percentages, 
+                       title = title, show_values_on_slices = show_values_on_slices, donut = donut, remaining_color = remaining_color)
+    _figure.show() if _figure._interactive else None
+
 def heatmap(dataframe, color = None, style=None):
     _figure._active.heatmap(dataframe, color = color, style = style)
     _figure.show() if _figure._interactive else None

plotext_plus/_dict.py

@@ -196,7 +196,7 @@ themes['solarized_dark'] = [(0, 43, 54), (5, 5, 5), (147, 161, 161), no_color, s
 # Solarized Light - light version of solarized
 sequence = [(42, 161, 152), (133, 153, 0), (181, 137, 0), (203, 75, 22), (211, 54, 130)]  # same colors as dark
 sequence += [el for el in color_sequence if el not in sequence] 
-themes['solarized_light'] = [(253, 246, 227), (101, 123, 131), (88, 110, 117), no_color, sequence]
+themes['solarized_light'] = [(253, 246, 227), (101, 123, 131), (64, 64, 64), no_color, sequence]
 
 # === CHUK-TERM COMPATIBLE THEMES ===
 # Import and integrate chuk-term compatible themes

plotext_plus/_figure.py

@@ -277,6 +277,9 @@ class _figure_class():
     def matrix_plot(self, matrix, marker = None, style = None, fast = False):
         self.monitor.draw_matrix(matrix, marker = marker, style = style, fast = fast) if self._no_plots else [[self._get_subplot(row, col).matrix_plot(matrix, marker = marker, style = style, fast = fast) for col in self._Cols] for row in self._Rows]
 
+    def pie(self, labels, values, colors = None, radius = None, show_values = True, show_percentages = True, title = None, show_values_on_slices = False, donut = False, remaining_color = None):
+        self.monitor.draw_pie(labels, values, colors = colors, radius = radius, show_values = show_values, show_percentages = show_percentages, title = title, show_values_on_slices = show_values_on_slices, donut = donut, remaining_color = remaining_color) if self._no_plots else [[self._get_subplot(row, col).pie(labels, values, colors = colors, radius = radius, show_values = show_values, show_percentages = show_percentages, title = title, show_values_on_slices = show_values_on_slices, donut = donut, remaining_color = remaining_color) for col in self._Cols] for row in self._Rows]
+
     def heatmap(self, dataframe, color = None, style = None):
         self.monitor.draw_heatmap(dataframe, color = color, style = style) if self._no_plots else [[self._get_subplot(row, col).heatmap(dataframe, color = color, style = style) for col in self._Cols] for row in self._Rows]
 

plotext_plus/_monitor.py

@@ -775,6 +775,409 @@ class monitor_class(build_class):
             self.matrix.canvas = '\n'.join([''.join(row) for row in matrix])
             self.fast_plot = True
 
+    def draw_pie(self, labels, values, colors = None, radius = None, show_values = True, show_percentages = True, title = None, show_values_on_slices = False, donut = False, remaining_color = None):
+        """
+        Draw a pie chart using filled colored segments and a legend.
+        
+        Args:
+            donut (bool): If True, creates a doughnut chart with hollow center (inner radius = 1/3 outer radius)
+            remaining_color (str): If specified, colors the remaining slice with this color instead of leaving it as spaces
+        """
+        import math
+        
+        # Input validation
+        if len(labels) != len(values):
+            raise ValueError("Labels and values must have the same length")
+        
+        # Calculate total and percentages
+        total = sum(values)
+        if total == 0:
+            raise ValueError("Total of values cannot be zero")
+            
+        percentages = [(value / total) * 100 for value in values]
+        
+        # Default colors if not provided
+        if colors is None:
+            color_cycle = ['red', 'blue', 'green', 'orange', 'magenta', 'cyan', 'white']
+            colors = [color_cycle[i % len(color_cycle)] for i in range(len(labels))]
+        
+        # Default radius - calculate based on available plot space
+        if radius is None:
+            # Get the actual plot area dimensions 
+            plot_width, plot_height = self.size
+            
+            # Set radius to half of the smaller dimension minus 4 for border margin
+            radius = (min(plot_width, plot_height) - 4) / 2.0
+            radius = max(radius, 3)  # Ensure minimum radius of 3
+        
+        # Center the pie chart
+        center_x = 0
+        center_y = 0
+        
+        # Terminal characters have an aspect ratio of approximately 1.5:1 (height:width)
+        # To make circles appear circular, we need to adjust the x-axis scaling
+        aspect_ratio = 1.5
+        
+        # Remove axes - pie charts don't have them
+        self.set_xfrequency(0)
+        self.set_yfrequency(0)
+        self.set_axes_color('default')
+        self.set_canvas_color('default')
+        
+        # Collect all points for each segment, then draw each segment in one call
+        # Use efficient scanning - just slightly beyond the actual pie radius
+        # For doughnuts, use denser scanning to ensure solid ring
+        if donut:
+            scan_radius_x = int(radius * aspect_ratio * 1.5 + 3)
+            scan_radius_y = int(radius * 1.5 + 3)
+        else:
+            scan_radius_x = int(radius * aspect_ratio * 1.2 + 2)
+            scan_radius_y = int(radius * 1.2 + 2)
+        
+        # Pre-calculate cumulative angles for segment boundaries
+        segment_boundaries = []
+        current_cumulative = 0
+        for value in values:
+            slice_angle = (value / total) * 2 * math.pi
+            segment_boundaries.append((current_cumulative, current_cumulative + slice_angle))
+            current_cumulative += slice_angle
+        
+        # Collect all points for each segment using sets to avoid duplicates
+        segment_points = [set() for _ in range(len(labels))]  # One set per segment
+        
+        # Use FLOOD FILL approach - systematically fill every position in concentric circles
+        # This ensures no gaps by filling from center outward
+        for y_offset in range(-scan_radius_y, scan_radius_y + 1):
+            for x_offset in range(-scan_radius_x, scan_radius_x + 1):
+                # Calculate distance from center with aspect ratio correction
+                # Since terminal chars are ~1.5x taller than wide, compress x coordinate
+                adjusted_x = x_offset / aspect_ratio
+                distance = math.sqrt(adjusted_x * adjusted_x + y_offset * y_offset)
+                
+                # For doughnut inner boundary, use elliptical check to create circular appearance
+                # The inner boundary should be elliptical in terminal coordinates to appear circular
+                inner_radius = radius / 3.0 if donut else 0
+                
+                # Check if point is outside the inner ellipse (for circular appearance)
+                if donut:
+                    # Create elliptical inner boundary: x^2/a^2 + y^2/b^2 > r^2
+                    # where a = inner_radius * aspect_ratio, b = inner_radius
+                    ellipse_x_term = (x_offset * x_offset) / (inner_radius * aspect_ratio * inner_radius * aspect_ratio)
+                    ellipse_y_term = (y_offset * y_offset) / (inner_radius * inner_radius)
+                    ellipse_value = ellipse_x_term + ellipse_y_term
+                    outside_inner = ellipse_value > 1.0
+                    
+                else:
+                    outside_inner = True
+                
+                # Use exact radius to stay within plot boundaries
+                threshold = radius
+                
+                if distance <= threshold and outside_inner:
+                    # Calculate angle for this position using adjusted coordinates
+                    angle = math.atan2(y_offset, adjusted_x)
+                    if angle < 0:
+                        angle += 2 * math.pi
+                    
+                    # Find which segment this position belongs to using robust angle detection
+                    segment_idx = 0
+                    found_segment = False
+                    epsilon = 0.02  # Even larger epsilon for maximum boundary coverage
+                    
+                    for i, (start_angle, end_angle) in enumerate(segment_boundaries):
+                        # Handle wraparound case for segments that cross 0 degrees
+                        if end_angle > 2 * math.pi:
+                            wrap_end = end_angle - 2 * math.pi
+                            if angle >= start_angle - epsilon or angle <= wrap_end + epsilon:
+                                segment_idx = i
+                                found_segment = True
+                                break
+                        else:
+                            # Use very generous boundary detection
+                            # For the last segment, use <= to include the boundary
+                            if i == len(segment_boundaries) - 1:
+                                if start_angle - epsilon <= angle <= end_angle + epsilon:
+                                    segment_idx = i
+                                    found_segment = True
+                                    break
+                            else:
+                                if start_angle - epsilon <= angle < end_angle + epsilon:
+                                    segment_idx = i
+                                    found_segment = True
+                                    break
+                    
+                    # If no segment found (due to floating point precision), assign based on closest angle
+                    if not found_segment:
+                        # Find the segment with the smallest angle distance
+                        min_distance = float('inf')
+                        for i, (start_angle, end_angle) in enumerate(segment_boundaries):
+                            mid_angle = (start_angle + end_angle) / 2
+                            # Handle wraparound for mid angle calculation
+                            if end_angle > 2 * math.pi:
+                                mid_angle = start_angle + ((end_angle - start_angle) / 2)
+                                if mid_angle > 2 * math.pi:
+                                    mid_angle -= 2 * math.pi
+                            
+                            # Calculate angular distance (accounting for circular nature)
+                            angle_diff = abs(angle - mid_angle)
+                            if angle_diff > math.pi:
+                                angle_diff = 2 * math.pi - angle_diff
+                            
+                            if angle_diff < min_distance:
+                                min_distance = angle_diff
+                                segment_idx = i
+                    
+                    # Add this exact character position to the appropriate segment
+                    char_x = center_x + x_offset  
+                    char_y = center_y + y_offset
+                    segment_points[segment_idx].add((char_x, char_y))
+        
+        # SECOND PASS: Fill any potential gaps by adding adjacent positions
+        # This ensures complete coverage by adding neighboring positions to existing points
+        additional_points = [set() for _ in range(len(labels))]
+        for segment_idx, points in enumerate(segment_points):
+            for (x, y) in points:
+                # Add neighboring positions to ensure no gaps
+                for dx in [-1, 0, 1]:
+                    for dy in [-1, 0, 1]:
+                        neighbor_x = x + dx
+                        neighbor_y = y + dy
+                        
+                        # Check if this neighbor is within the circular area using same logic as main pass
+                        x_offset = neighbor_x - center_x
+                        y_offset = neighbor_y - center_y
+                        adjusted_x = x_offset / aspect_ratio  
+                        neighbor_distance = math.sqrt(adjusted_x * adjusted_x + y_offset * y_offset)
+                        
+                        # Use same boundary checks as main algorithm
+                        inner_radius = radius / 3.0 if donut else 0
+                        
+                        # Check if point is outside the inner ellipse (for circular appearance)
+                        if donut:
+                            # Use same elliptical inner boundary as main pass
+                            ellipse_x_term = (x_offset * x_offset) / (inner_radius * aspect_ratio * inner_radius * aspect_ratio)
+                            ellipse_y_term = (y_offset * y_offset) / (inner_radius * inner_radius)
+                            outside_inner = ellipse_x_term + ellipse_y_term > 1.0
+                        else:
+                            outside_inner = True
+                        
+                        # Use exact radius to stay within plot boundaries (same as main pass)
+                        threshold = radius
+                        
+                        if neighbor_distance <= threshold and outside_inner:
+                            additional_points[segment_idx].add((neighbor_x, neighbor_y))
+        
+        # Merge additional points with main points
+        for segment_idx in range(len(labels)):
+            segment_points[segment_idx].update(additional_points[segment_idx])
+        
+        # Draw each segment using a different approach - draw filled shapes row by row
+        # This ensures complete filling without gaps
+        for segment_idx, (points, color) in enumerate(zip(segment_points, colors)):
+            if points:  # Only draw if segment has points
+                # Handle remaining_color for single-value pie charts
+                if color == "default":
+                    if remaining_color is not None:
+                        # Use the specified remaining_color instead of default
+                        color = remaining_color
+                    else:
+                        # Skip drawing - leave as spaces (current behavior)
+                        continue
+                    
+                points_list = list(points)
+                
+                # Group points by y-coordinate to draw horizontal filled lines
+                y_groups = {}
+                for x, y in points_list:
+                    if y not in y_groups:
+                        y_groups[y] = []
+                    y_groups[y].append(x)
+                
+                # For doughnut charts, use smart filling that avoids the hollow center
+                # For regular pie charts, use full horizontal line filling
+                if donut:
+                    # Smart filling for doughnut charts: fill gaps within ring segments but avoid center
+                    for y_coord, x_coords in y_groups.items():
+                        if x_coords:
+                            x_coords.sort()  # Sort x coordinates
+                            
+                            # Find continuous segments, avoiding the center gap
+                            fill_x_coords = []
+                            x_step = 0.5
+                            
+                            # Determine if this y_coord passes through the hollow center
+                            y_offset = y_coord - center_y
+                            center_x_range = []
+                            
+                            # Calculate the x-range that should be hollow at this y-coordinate
+                            if abs(y_offset) < inner_radius:
+                                # This y-line passes through the hollow center
+                                # Calculate x-bounds of the elliptical hollow area
+                                ellipse_y_term = (y_offset * y_offset) / (inner_radius * inner_radius)
+                                if ellipse_y_term < 1.0:
+                                    ellipse_x_term_needed = 1.0 - ellipse_y_term
+                                    max_x_offset = math.sqrt(ellipse_x_term_needed) * inner_radius * aspect_ratio
+                                    center_x_min = center_x - max_x_offset
+                                    center_x_max = center_x + max_x_offset
+                                    center_x_range = [center_x_min, center_x_max]
+                            
+                            # Fill between consecutive x-coordinates, but avoid the center region
+                            i = 0
+                            while i < len(x_coords):
+                                segment_start = x_coords[i]
+                                
+                                # Find the end of this continuous segment
+                                j = i
+                                while j < len(x_coords) - 1:
+                                    gap = x_coords[j + 1] - x_coords[j]
+                                    # If there's a large gap, this segment ends
+                                    if gap > 2.0:  # Allow small gaps but break on large ones
+                                        break
+                                    j += 1
+                                
+                                segment_end = x_coords[j]
+                                
+                                # Fill this segment, but avoid the center region
+                                if center_x_range:
+                                    # Split segment around the hollow center
+                                    center_min, center_max = center_x_range
+                                    
+                                    # Fill left part (before center)
+                                    if segment_start < center_min:
+                                        left_end = min(segment_end, center_min)
+                                        current_x = segment_start
+                                        while current_x <= left_end:
+                                            fill_x_coords.append(current_x)
+                                            current_x += x_step
+                                    
+                                    # Fill right part (after center)
+                                    if segment_end > center_max:
+                                        right_start = max(segment_start, center_max)
+                                        current_x = right_start
+                                        while current_x <= segment_end:
+                                            fill_x_coords.append(current_x)
+                                            current_x += x_step
+                                else:
+                                    # No center interference, fill entire segment
+                                    current_x = segment_start
+                                    while current_x <= segment_end:
+                                        fill_x_coords.append(current_x)
+                                        current_x += x_step
+                                
+                                i = j + 1
+                            
+                            # Draw the filled segments
+                            if fill_x_coords:
+                                fill_y_coords = [y_coord] * len(fill_x_coords)
+                                self.draw(fill_x_coords, fill_y_coords, marker='sd', color=color)
+                else:
+                    # For regular pie charts, use full horizontal line filling
+                    for y_coord, x_coords in y_groups.items():
+                        if x_coords:
+                            x_coords.sort()  # Sort x coordinates
+                            x_min, x_max = min(x_coords), max(x_coords)
+                            
+                            # Create a continuous range of x coordinates to fill the gap
+                            if x_max > x_min:
+                                # Draw filled horizontal line from x_min to x_max
+                                fill_x_coords = []
+                                x_step = 0.5  # Smaller step for better coverage
+                                current_x = x_min
+                                while current_x <= x_max:
+                                    fill_x_coords.append(current_x)
+                                    current_x += x_step
+                                fill_y_coords = [y_coord] * len(fill_x_coords)
+                                self.draw(fill_x_coords, fill_y_coords, marker='sd', color=color)
+                            else:
+                                # Single point
+                                self.draw([x_min], [y_coord], marker='sd', color=color)
+        
+        # Reset cumulative_angle for label drawing
+        cumulative_angle = 0
+        for i, (label, value, percentage, color) in enumerate(zip(labels, values, percentages, colors)):
+            slice_angle = (value / total) * 2 * math.pi
+            
+            # Add value labels on the pie slice (only if show_values_on_slices is True)
+            if show_values_on_slices and (show_values or show_percentages):
+                # Calculate middle angle of the slice for label placement
+                middle_angle = cumulative_angle + slice_angle / 2
+                # Position label at 70% of radius for better visibility
+                label_radius = radius * 0.7
+                label_x = center_x + (label_radius * math.cos(middle_angle)) * aspect_ratio
+                label_y = center_y + label_radius * math.sin(middle_angle)
+                
+                # Build label text for the slice
+                slice_label = ""
+                if show_values and show_percentages:
+                    slice_label = f"{value}\n({percentage:.1f}%)"
+                elif show_values:
+                    slice_label = str(value)
+                elif show_percentages:
+                    slice_label = f"{percentage:.1f}%"
+                
+                # Draw the label on the slice
+                self.draw_text(slice_label, label_x, label_y, color='white', alignment='center')
+            
+            cumulative_angle += slice_angle
+        
+        # Extend the plot area to accommodate legend (calculate before filtering)
+        max_text_length = max(len(f"{label}: {value} ({percentage:.1f}%)") 
+                              for label, value, percentage in zip(labels, values, percentages)
+                              if label.lower() != "remaining") if any(label.lower() != "remaining" for label in labels) else 20
+        
+        # Set plot limits to include legend area (adjust x for aspect ratio)
+        x_radius = radius * aspect_ratio
+        self.set_xlim(-x_radius - 1, x_radius + max_text_length + 2)
+        self.set_ylim(-radius - 1, radius + 1)
+        
+        # Create legend positioned in the bottom right corner of the chart
+        legend_start_x = x_radius + 1.5
+        legend_start_y = -radius + len(labels) * 1.0 - 0.5
+        
+        # Filter out "Remaining" labels and default colors for single-value pie charts
+        legend_items = []
+        for i, (label, value, percentage, color) in enumerate(zip(labels, values, percentages, colors)):
+            # Handle remaining_color logic for legend
+            if color == "default":
+                if remaining_color is not None:
+                    # Show "Remaining" in legend when remaining_color is specified
+                    legend_items.append((label, value, percentage, remaining_color))
+                # Skip if no remaining_color (leave as spaces)
+            else:
+                # Always show non-default colors
+                legend_items.append((label, value, percentage, color))
+        
+        # Adjust legend positioning for filtered items
+        legend_start_y = -radius + len(legend_items) * 1.0 - 0.5
+        
+        for i, (label, value, percentage, color) in enumerate(legend_items):
+            legend_x = legend_start_x
+            legend_y = legend_start_y - i * 1.2  # Space between legend items
+            
+            # Draw colored square for legend matching pie chart blocks
+            self.draw([legend_x], [legend_y], marker='sd', color=color)
+            
+            # Build legend text with colored block prefix
+            block_char = "█"  # Solid block character
+            legend_text = f"{block_char} {label}"
+            if show_values and show_percentages:
+                legend_text += f": {value} ({percentage:.1f}%)"
+            elif show_values:
+                legend_text += f": {value}"
+            elif show_percentages:
+                legend_text += f": {percentage:.1f}%"
+            
+            # Use draw_text for the legend with the same color as the segment
+            self.draw_text(legend_text, legend_x, legend_y, color=color)
+        
+        # Set title if provided
+        if title:
+            self.set_title(title)
+        
+        # Remove axis labels since pie charts don't need them
+        self.set_xlabel('')
+        self.set_ylabel('')
+
     def draw_heatmap(self, dataframe, color = None, style=None):
         color = self.default.cmatrix_color if color is None else self.check_color(color)
         style = self.default.cmatrix_style if style is None else self.check_style(style)

plotext_plus/_themes.py

@@ -53,6 +53,7 @@ rgb_colors = {
     'term_black': (0, 0, 0),
     'term_white': (255, 255, 255),
     'term_gray': (128, 128, 128),
+    'dark_gray': (64, 64, 64),  # Dark gray for better readability
 }
 
 def create_chuk_term_themes():
@@ -148,7 +149,7 @@ def create_chuk_term_themes():
                rgb_colors['sol_blue'], rgb_colors['sol_magenta'], rgb_colors['sol_red']]
     sequence += [el for el in color_sequence if el not in sequence]
     themes['solarized_light'] = [rgb_colors['sol_base3'], rgb_colors['sol_base01'], 
-                                rgb_colors['sol_base00'], no_color, sequence]
+                                rgb_colors['dark_gray'], no_color, sequence]
     
     # Matrix theme (enhanced version)
     sequence = [(0, 255, 65), (0, 200, 50), (0, 150, 35), (0, 100, 20)]

plotext_plus/charts.py

@@ -20,7 +20,7 @@ from ._api import (
     CandlestickChart, HeatmapChart, MatrixChart, StemChart,
     
     # Convenience functions
-    create_chart, quick_scatter, quick_line, quick_bar,
+    create_chart, quick_scatter, quick_line, quick_bar, quick_pie, quick_donut,
     
     # Banner and logging utilities
     enable_banners, log_info, log_success, log_warning, log_error,
@@ -35,7 +35,7 @@ __all__ = [
     'CandlestickChart', 'HeatmapChart', 'MatrixChart', 'StemChart',
     
     # Convenience functions
-    'create_chart', 'quick_scatter', 'quick_line', 'quick_bar',
+    'create_chart', 'quick_scatter', 'quick_line', 'quick_bar', 'quick_pie', 'quick_donut',
     
     # Utilities
     'enable_banners', 'log_info', 'log_success', 'log_warning', 'log_error',

plotext_plus/mcp_server.py

@@ -71,11 +71,15 @@ async def scatter_plot(x: List[Union[int, float]], y: List[Union[int, float]],
     Returns:
         The rendered plot as text
     """
+    # Convert string inputs to float
+    x_numeric = [float(val) if isinstance(val, str) else val for val in x]
+    y_numeric = [float(val) if isinstance(val, str) else val for val in y]
+    
     plotting.clear_figure()
     if title:
         plotting.title(title)
     
-    _, output = _capture_plot_output(plotting.scatter, x, y, marker=marker, color=color)
+    _, output = _capture_plot_output(plotting.scatter, x_numeric, y_numeric, marker=marker, color=color)
     _, show_output = _capture_plot_output(plotting.show)
     
     return output + show_output
@@ -95,14 +99,41 @@ async def line_plot(x: List[Union[int, float]], y: List[Union[int, float]],
     Returns:
         The rendered plot as text
     """
-    plotting.clear_figure()
-    if title:
-        plotting.title(title)
+    import sys
+    print(f"DEBUG: line_plot called with x={x}, y={y}, title={title}", file=sys.stderr)
     
-    _, output = _capture_plot_output(plotting.plot, x, y, color=color)
-    _, show_output = _capture_plot_output(plotting.show)
+    # Convert string inputs to float
+    try:
+        x_numeric = [float(val) if isinstance(val, str) else val for val in x]
+        y_numeric = [float(val) if isinstance(val, str) else val for val in y]
+        print(f"DEBUG: Converted to x_numeric={x_numeric}, y_numeric={y_numeric}", file=sys.stderr)
+    except Exception as e:
+        print(f"DEBUG: Error converting inputs: {e}", file=sys.stderr)
+        raise
     
-    return output + show_output
+    try:
+        plotting.clear_figure()
+        print("DEBUG: Cleared figure", file=sys.stderr)
+        
+        if title:
+            plotting.title(title)
+            print(f"DEBUG: Set title: {title}", file=sys.stderr)
+        
+        _, output = _capture_plot_output(plotting.plot, x_numeric, y_numeric, color=color)
+        print(f"DEBUG: Generated plot output, length: {len(output)}", file=sys.stderr)
+        
+        _, show_output = _capture_plot_output(plotting.show)
+        print(f"DEBUG: Generated show output, length: {len(show_output)}", file=sys.stderr)
+        
+        result = output + show_output
+        print(f"DEBUG: Returning result, total length: {len(result)}", file=sys.stderr)
+        return result
+        
+    except Exception as e:
+        print(f"DEBUG: Error during plotting: {e}", file=sys.stderr)
+        import traceback
+        traceback.print_exc(file=sys.stderr)
+        raise
 
 
 @tool
@@ -119,11 +150,14 @@ async def bar_chart(labels: List[str], values: List[Union[int, float]],
     Returns:
         The rendered plot as text
     """
+    # Convert string inputs to float
+    values_numeric = [float(val) if isinstance(val, str) else val for val in values]
+    
     plotting.clear_figure()
     if title:
         plotting.title(title)
     
-    _, output = _capture_plot_output(plotting.bar, labels, values, color=color)
+    _, output = _capture_plot_output(plotting.bar, labels, values_numeric, color=color)
     _, show_output = _capture_plot_output(plotting.show)
     
     return output + show_output
@@ -150,6 +184,53 @@ async def matrix_plot(data: List[List[Union[int, float]]], title: Optional[str]
     return output + show_output
 
 
+@tool
+async def image_plot(image_path: str, title: Optional[str] = None, 
+                    marker: Optional[str] = None, style: Optional[str] = None, 
+                    fast: bool = False, grayscale: bool = False) -> str:
+    """Display an image in the terminal using ASCII art.
+    
+    Args:
+        image_path: Path to the image file to display
+        title: Plot title (optional)
+        marker: Custom marker for image rendering (optional)
+        style: Style for image rendering (optional)
+        fast: Enable fast rendering mode for better performance (optional)
+        grayscale: Render image in grayscale (optional)
+        
+    Returns:
+        The rendered image plot as text
+    """
+    plotting.clear_figure()
+    if title:
+        plotting.title(title)
+    
+    _, output = _capture_plot_output(plotting.image_plot, image_path, 
+                                   marker=marker, style=style, 
+                                   fast=fast, grayscale=grayscale)
+    _, show_output = _capture_plot_output(plotting.show)
+    
+    return output + show_output
+
+
+@tool
+async def play_gif(gif_path: str) -> str:
+    """Play a GIF animation in the terminal.
+    
+    Args:
+        gif_path: Path to the GIF file to play
+        
+    Returns:
+        Confirmation message (GIF plays automatically)
+    """
+    plotting.clear_figure()
+    
+    # play_gif handles its own output and doesn't need show()
+    plotting.play_gif(gif_path)
+    
+    return f"Playing GIF: {gif_path}"
+
+
 # Chart Class Tools
 @tool
 async def quick_scatter(x: List[Union[int, float]], y: List[Union[int, float]], 
@@ -165,7 +246,11 @@ async def quick_scatter(x: List[Union[int, float]], y: List[Union[int, float]],
     Returns:
         The rendered chart as text
     """
-    _, output = _capture_plot_output(charts.quick_scatter, x, y, title=title, theme=theme_name)
+    # Convert string inputs to float
+    x_numeric = [float(val) if isinstance(val, str) else val for val in x]
+    y_numeric = [float(val) if isinstance(val, str) else val for val in y]
+    
+    _, output = _capture_plot_output(charts.quick_scatter, x_numeric, y_numeric, title=title, theme=theme_name)
     return output
 
 
@@ -183,7 +268,11 @@ async def quick_line(x: List[Union[int, float]], y: List[Union[int, float]],
     Returns:
         The rendered chart as text
     """
-    _, output = _capture_plot_output(charts.quick_line, x, y, title=title, theme=theme_name)
+    # Convert string inputs to float
+    x_numeric = [float(val) if isinstance(val, str) else val for val in x]
+    y_numeric = [float(val) if isinstance(val, str) else val for val in y]
+    
+    _, output = _capture_plot_output(charts.quick_line, x_numeric, y_numeric, title=title, theme=theme_name)
     return output
 
 
@@ -201,7 +290,75 @@ async def quick_bar(labels: List[str], values: List[Union[int, float]],
     Returns:
         The rendered chart as text
     """
-    _, output = _capture_plot_output(charts.quick_bar, labels, values, title=title, theme=theme_name)
+    # Convert string inputs to float
+    values_numeric = [float(val) if isinstance(val, str) else val for val in values]
+    
+    _, output = _capture_plot_output(charts.quick_bar, labels, values_numeric, title=title, theme=theme_name)
+    return output
+
+
+@tool
+async def quick_pie(labels: List[str], values: List[Union[int, float]], 
+                   colors: Optional[List[str]] = None, title: Optional[str] = None, 
+                   show_values: bool = True, show_percentages: bool = True,
+                   show_values_on_slices: bool = False, donut: bool = False,
+                   remaining_color: Optional[str] = None) -> str:
+    """Create a quick pie chart using the chart classes API.
+    
+    Args:
+        labels: List of pie segment labels
+        values: List of pie segment values
+        colors: List of colors for segments (optional)
+        title: Chart title (optional)
+        show_values: Show values in legend (optional, default True)
+        show_percentages: Show percentages in legend (optional, default True)
+        show_values_on_slices: Show values directly on pie slices (optional, default False)
+        donut: Create doughnut chart with hollow center (optional, default False)
+        remaining_color: Color for remaining slice in single-value charts (optional)
+        
+    Returns:
+        The rendered pie chart as text
+    """
+    # Convert string inputs to float
+    values_numeric = [float(val) if isinstance(val, str) else val for val in values]
+    
+    _, output = _capture_plot_output(charts.quick_pie, labels, values_numeric, colors=colors, 
+                                   title=title, show_values=show_values, 
+                                   show_percentages=show_percentages,
+                                   show_values_on_slices=show_values_on_slices,
+                                   donut=donut, remaining_color=remaining_color)
+    return output
+
+
+@tool
+async def quick_donut(labels: List[str], values: List[Union[int, float]], 
+                     colors: Optional[List[str]] = None, title: Optional[str] = None, 
+                     show_values: bool = True, show_percentages: bool = True,
+                     show_values_on_slices: bool = False,
+                     remaining_color: Optional[str] = None) -> str:
+    """Create a quick doughnut chart (pie chart with hollow center) using the chart classes API.
+    
+    Args:
+        labels: List of pie segment labels
+        values: List of pie segment values
+        colors: List of colors for segments (optional)
+        title: Chart title (optional)
+        show_values: Show values in legend (optional, default True)
+        show_percentages: Show percentages in legend (optional, default True)
+        show_values_on_slices: Show values directly on pie slices (optional, default False)
+        remaining_color: Color for remaining slice in single-value charts (optional)
+        
+    Returns:
+        The rendered doughnut chart as text
+    """
+    # Convert string inputs to float
+    values_numeric = [float(val) if isinstance(val, str) else val for val in values]
+    
+    _, output = _capture_plot_output(charts.quick_donut, labels, values_numeric, colors=colors, 
+                                   title=title, show_values=show_values, 
+                                   show_percentages=show_percentages,
+                                   show_values_on_slices=show_values_on_slices,
+                                   remaining_color=remaining_color)
     return output
 
 
@@ -371,6 +528,66 @@ async def get_plot_config() -> Dict[str, Any]:
     }
 
 
+# Resource for tool documentation/info
+@resource("info://plotext")
+async def get_tool_info() -> Dict[str, Any]:
+    """Get comprehensive information about all available plotting tools."""
+    return {
+        "server_info": {
+            "name": "Plotext Plus MCP Server",
+            "description": "Model Context Protocol server for plotext_plus terminal plotting library",
+            "version": "1.0.0",
+            "capabilities": ["plotting", "theming", "multimedia", "charts"]
+        },
+        "plotting_tools": {
+            "scatter_plot": "Create scatter plots with x/y data points",
+            "line_plot": "Create line plots for time series and continuous data", 
+            "bar_chart": "Create bar charts for categorical data",
+            "matrix_plot": "Create heatmaps from 2D matrix data",
+            "image_plot": "Display images in terminal using ASCII art",
+            "play_gif": "Play animated GIFs in the terminal"
+        },
+        "quick_chart_tools": {
+            "quick_scatter": "Quickly create scatter charts with theming",
+            "quick_line": "Quickly create line charts with theming",
+            "quick_bar": "Quickly create bar charts with theming", 
+            "quick_pie": "Quickly create pie charts with custom colors, donut mode, and remaining_color options",
+            "quick_donut": "Quickly create doughnut charts (hollow center pie charts)"
+        },
+        "theme_tools": {
+            "get_available_themes": "List all available color themes",
+            "apply_plot_theme": "Apply a theme to plots"
+        },
+        "utility_tools": {
+            "get_terminal_width": "Get current terminal width",
+            "colorize_text": "Apply colors to text output",
+            "log_info": "Output informational messages",
+            "log_success": "Output success messages", 
+            "log_warning": "Output warning messages",
+            "log_error": "Output error messages"
+        },
+        "configuration_tools": {
+            "set_plot_size": "Set plot dimensions",
+            "enable_banner_mode": "Enable/disable banner mode",
+            "clear_plot": "Clear current plot"
+        },
+        "supported_formats": {
+            "image_formats": ["PNG", "JPG", "JPEG", "BMP", "GIF (static)"],
+            "gif_formats": ["GIF (animated)"],
+            "chart_types": ["scatter", "line", "bar", "pie", "doughnut", "matrix/heatmap", "image"],
+            "themes": "20+ built-in themes including solarized, dracula, cyberpunk"
+        },
+        "usage_tips": {
+            "pie_charts": "Best for 3-7 categories, use full terminal dimensions",
+            "doughnut_charts": "Modern alternative to pie charts with hollow center, great for progress indicators",
+            "single_value_charts": "Perfect for progress/completion rates: ['Complete', 'Remaining'] with 'default' color",
+            "images": "Use fast=True for better performance with large images",
+            "themes": "Apply themes before creating plots for consistent styling",
+            "banners": "Enable banner mode for professional-looking outputs"
+        }
+    }
+
+
 # MCP Prompts for common plotting scenarios
 @prompt("basic_scatter")
 async def basic_scatter_prompt() -> str:
@@ -494,11 +711,295 @@ async def complete_workflow_prompt() -> str:
 6. Generate a summary report"""
 
 
+@prompt("image_display")
+async def image_display_prompt() -> str:
+    """Image plotting example"""
+    return """Display an image in the terminal:
+1. First download the test cat image using utilities.download() with the test_image_url
+2. Display it using image_plot with title 'Test Image Display'
+3. Try both normal and grayscale versions
+4. Clean up by deleting the file afterward"""
+
+
+@prompt("gif_animation")
+async def gif_animation_prompt() -> str:
+    """GIF animation example"""
+    return """Play a GIF animation in terminal:
+1. Download the test Homer Simpson GIF using utilities.download() with test_gif_url
+2. Play the GIF animation using play_gif
+3. Clean up the file afterward
+Note: The GIF will play automatically in the terminal"""
+
+
+@prompt("image_styling")
+async def image_styling_prompt() -> str:
+    """Custom image styling example"""
+    return """Experiment with image rendering styles:
+1. Display the same image with different markers (try 'CuteCat' as marker)
+2. Use 'inverted' style for visual effects
+3. Compare fast vs normal rendering modes
+4. Show both color and grayscale versions"""
+
+
+@prompt("multimedia_showcase")
+async def multimedia_showcase_prompt() -> str:
+    """Complete multimedia demonstration"""
+    return """Showcase multimedia capabilities:
+1. Download and display a static image with custom styling
+2. Download and play an animated GIF
+3. Set appropriate plot sizes for optimal viewing
+4. Add descriptive titles to each display
+5. Clean up all downloaded files"""
+
+
+@prompt("basic_pie_chart")
+async def basic_pie_chart_prompt() -> str:
+    """Basic pie chart example"""
+    return """Create a simple pie chart showing market share data:
+- Categories: ['iOS', 'Android', 'Windows', 'Other']  
+- Values: [35, 45, 15, 5]
+- Use colors: ['blue', 'green', 'orange', 'gray']
+- Add title 'Mobile OS Market Share'
+- Use quick_pie tool for fast creation"""
+
+
+@prompt("pie_chart_styling")
+async def pie_chart_styling_prompt() -> str:
+    """Advanced pie chart styling example"""
+    return """Create a styled pie chart with advanced features:
+1. Use quick_pie with show_values_on_slices=True
+2. Data: Budget categories ['Housing', 'Food', 'Transport', 'Entertainment'] 
+3. Values: [1200, 400, 300, 200] (monthly budget)
+4. Custom colors for each category
+5. Add meaningful title and ensure full terminal usage"""
+
+
+@prompt("pie_chart_comparison")
+async def pie_chart_comparison_prompt() -> str:
+    """Pie chart comparison example"""
+    return """Create multiple pie charts for comparison:
+1. Q1 Sales: ['Product A', 'Product B', 'Product C'] = [30, 45, 25]
+2. Q2 Sales: ['Product A', 'Product B', 'Product C'] = [25, 50, 25] 
+3. Show both charts with different colors
+4. Use appropriate titles ('Q1 Sales Distribution', 'Q2 Sales Distribution')
+5. Discuss the trends visible in the comparison"""
+
+
+@prompt("pie_chart_best_practices")
+async def pie_chart_best_practices_prompt() -> str:
+    """Pie chart best practices demonstration"""
+    return """Demonstrate pie chart best practices:
+1. Start with many categories: ['A', 'B', 'C', 'D', 'E', 'F', 'G'] = [5, 8, 12, 15, 25, 20, 15]
+2. Show why this is problematic (too many small segments)
+3. Combine small categories: ['A+B+C', 'D', 'E', 'F', 'G'] = [25, 15, 25, 20, 15] 
+4. Create the improved version with title 'Improved: Combined Small Categories'
+5. Explain the improvement in readability"""
+
+
+@prompt("single_value_pie_chart")
+async def single_value_pie_chart_prompt() -> str:
+    """Single-value pie chart for progress indicators"""
+    return """Create single-value pie charts perfect for progress indicators:
+1. Basic progress chart: ['Complete', 'Remaining'] = [75, 25], colors=['green', 'default']
+2. Title: 'Project Progress: 75%'  
+3. Show only percentages (show_values=False, show_percentages=True)
+4. Note: Remaining area appears as spaces, legend only shows 'Complete' entry
+5. Perfect for dashboards, completion meters, utilization rates"""
+
+
+@prompt("single_value_pie_with_remaining_color")
+async def single_value_pie_with_remaining_color_prompt() -> str:
+    """Single-value pie chart with colored remaining area"""
+    return """Create single-value pie chart with remaining_color parameter:
+1. Data: ['Complete', 'Remaining'] = [60, 40], colors=['blue', 'default']
+2. Add remaining_color='gray' to color the remaining slice
+3. Title: 'Task Completion: 60%'
+4. Compare with version without remaining_color
+5. Note: When remaining_color is specified, 'Remaining' appears in legend"""
+
+
+@prompt("doughnut_chart_basic")
+async def doughnut_chart_basic_prompt() -> str:
+    """Basic doughnut chart with hollow center"""
+    return """Create a doughnut chart with hollow center:
+1. Data: ['Sales', 'Marketing', 'Support', 'Development'] = [40, 25, 15, 20]
+2. Colors: ['blue', 'orange', 'green', 'red']  
+3. Add donut=True parameter to create hollow center
+4. Title: 'Department Budget - Doughnut Chart'
+5. Note: Inner radius automatically set to 1/3 of outer radius, center remains empty"""
+
+
+@prompt("doughnut_progress_indicator")
+async def doughnut_progress_indicator_prompt() -> str:
+    """Doughnut chart as progress indicator"""
+    return """Create a doughnut chart progress indicator:
+1. Single-value data: ['Completed', 'Remaining'] = [85, 15]
+2. Colors: ['cyan', 'default'] 
+3. Use both donut=True and show only percentages
+4. Title: 'Project Progress - 85% Complete'
+5. Perfect for modern dashboards - combines hollow center with progress visualization"""
+
+
+@prompt("quick_donut_convenience")
+async def quick_donut_convenience_prompt() -> str:
+    """Using quick_donut convenience function"""
+    return """Demonstrate the quick_donut convenience function:
+1. Use quick_donut instead of quick_pie with donut=True
+2. Data: ['Task A', 'Task B', 'Task C'] = [30, 45, 25]
+3. Colors: ['purple', 'yellow', 'green']
+4. Title: 'Task Distribution'
+5. Show how quick_donut automatically creates hollow center charts"""
+
+
 # Main server entry point
 def start_server():
     """Start the MCP server."""
-    print("Starting Plotext Plus MCP Server...")
-    run()
+    import sys
+    import os
+    
+    # Check if we're being run in STDIO mode (by MCP CLI)
+    # Force HTTP mode if MCP_HTTP_MODE is set, otherwise detect based on stdin
+    force_http = os.getenv('MCP_HTTP_MODE', '').lower() == 'true'
+    force_stdio = os.getenv('MCP_STDIO_MODE', '').lower() == 'true'
+    
+    if force_http:
+        is_stdio_mode = False
+    elif force_stdio:
+        is_stdio_mode = True
+    else:
+        # Auto-detect: STDIO mode when stdin is not a terminal (pipes/redirects)
+        is_stdio_mode = not sys.stdin.isatty()
+    
+    if is_stdio_mode:
+        # STDIO mode for MCP CLI - simple JSON-RPC implementation
+        import json
+        import asyncio
+        
+        async def handle_stdio():
+            try:
+                for line in sys.stdin:
+                    if not line.strip():
+                        continue
+                    
+                    try:
+                        request = json.loads(line)
+                        method = request.get('method')
+                        request_id = request.get('id')
+                        
+                        if method == 'initialize':
+                            response = {
+                                "jsonrpc": "2.0",
+                                "id": request_id,
+                                "result": {
+                                    "protocolVersion": "2024-11-05",
+                                    "capabilities": {
+                                        "tools": {},
+                                        "prompts": {},
+                                        "resources": {}
+                                    },
+                                    "serverInfo": {
+                                        "name": "Plotext Plus MCP Server",
+                                        "version": "1.0.0"
+                                    }
+                                }
+                            }
+                        elif method == 'tools/list':
+                            response = {
+                                "jsonrpc": "2.0",
+                                "id": request_id,
+                                "result": {
+                                    "tools": [
+                                        {
+                                            "name": "line_plot",
+                                            "description": "Create a line plot with given x and y data points",
+                                            "inputSchema": {
+                                                "type": "object",
+                                                "properties": {
+                                                    "x": {"type": "array", "items": {"type": "number"}},
+                                                    "y": {"type": "array", "items": {"type": "number"}},
+                                                    "title": {"type": "string"}
+                                                },
+                                                "required": ["x", "y"]
+                                            }
+                                        }
+                                    ]
+                                }
+                            }
+                        elif method == 'tools/call':
+                            tool_name = request['params']['name']
+                            arguments = request['params']['arguments']
+                            
+                            if tool_name == 'line_plot':
+                                try:
+                                    result = await line_plot(**arguments)
+                                    response = {
+                                        "jsonrpc": "2.0",
+                                        "id": request_id,
+                                        "result": {
+                                            "content": [
+                                                {
+                                                    "type": "text",
+                                                    "text": result
+                                                }
+                                            ]
+                                        }
+                                    }
+                                except Exception as e:
+                                    response = {
+                                        "jsonrpc": "2.0",
+                                        "id": request_id,
+                                        "error": {
+                                            "code": -32000,
+                                            "message": str(e)
+                                        }
+                                    }
+                            else:
+                                response = {
+                                    "jsonrpc": "2.0",
+                                    "id": request_id,
+                                    "error": {
+                                        "code": -32601,
+                                        "message": f"Unknown tool: {tool_name}"
+                                    }
+                                }
+                        else:
+                            response = {
+                                "jsonrpc": "2.0",
+                                "id": request_id,
+                                "error": {
+                                    "code": -32601,
+                                    "message": f"Unknown method: {method}"
+                                }
+                            }
+                        
+                        print(json.dumps(response), flush=True)
+                        
+                    except Exception as e:
+                        error_response = {
+                            "jsonrpc": "2.0",
+                            "id": request.get('id') if 'request' in locals() else None,
+                            "error": {
+                                "code": -32700,
+                                "message": f"Parse error: {str(e)}"
+                            }
+                        }
+                        print(json.dumps(error_response), flush=True)
+                        
+            except Exception as e:
+                print(f"STDIO handler error: {e}", file=sys.stderr)
+        
+        asyncio.run(handle_stdio())
+    else:
+        # HTTP server mode (default)
+        print("Starting Plotext Plus MCP Server...")
+        from chuk_mcp_server import ChukMCPServer
+        server = ChukMCPServer(
+            name="Plotext Plus MCP Server", 
+            version="1.0.0",
+            prompts=True,  # Enable prompts capability
+            logging=True   # Enable logging capability for MCP clients
+        )
+        server.run()
 
 
 if __name__ == "__main__":

plotext_plus/plotting.py

@@ -12,7 +12,7 @@ All the core plotting capabilities are exposed through clean, public interfaces.
 # Import all main plotting functions from the internal core module
 from ._core import (
     # Basic plotting functions
-    scatter, plot, bar, 
+    scatter, plot, bar, pie,
     matrix_plot, candlestick,
     
     # Plot customization

{plotext_plus-1.0.7.dist-info → plotext_plus-1.0.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plotext_plus
-Version: 1.0.7
+Version: 1.0.9
 Summary: Modern terminal plotting library with enhanced visual features, themes, and AI integration
 Project-URL: Homepage, https://github.com/ccmitchellusa/plotext_plus
 Project-URL: Repository, https://github.com/ccmitchellusa/plotext_plus.git
@@ -52,7 +52,7 @@ Description-Content-Type: text/markdown
 
 ## ✨ Key Features
 
-🎯 **Multiple Plot Types**: [scatter](docs/basic.md#scatter-plot), [line](docs/basic.md#line-plot), [bar](docs/bar.md), [histogram](docs/bar.md#histogram-plot), [candlestick](docs/datetime.md#candlestick-plot), [heatmap](docs/special.md), [confusion matrix](docs/special.md#confusion-matrix), and more
+🎯 **Multiple Plot Types**: [scatter](docs/basic.md#scatter-plot), [line](docs/basic.md#line-plot), [bar](docs/bar.md), [histogram](docs/bar.md#histogram-plot), [candlestick](docs/datetime.md#candlestick-plot), [heatmap](docs/special.md), [confusion matrix](docs/special.md#confusion-matrix), [pie](docs/basic.md#pie-plot), [doughnut](docs/basic.md#doughnut-charts) and more
 
 🎨 **Rich Visuals**: [Banner mode](docs/chart_classes.md), [themes](docs/themes.md), [colored text](docs/utilities.md#colored-text), automatic terminal width detection
 

{plotext_plus-1.0.7.dist-info → plotext_plus-1.0.9.dist-info}/RECORD

@@ -1,33 +1,33 @@
-plotext_plus/__init__.py,sha256=lFka1k6nnii0o746a8J6xzpy9rfHK6x1zQ24R1DHFf8,831
+plotext_plus/__init__.py,sha256=ZqQT3ybOtVRB4rY406K_RzBZ3CJ1Z3z2FZU0J_Wwc04,855
 plotext_plus/__main__.py,sha256=UkpSWVzOAfWBm3O1jyN1QO6KILQWhaSw4DcIdohJlbI,37
-plotext_plus/_api.py,sha256=E3AR-hNkQalVdZ2yv9lWv6PJxdDWgi81vPyrNYzA-lA,28429
+plotext_plus/_api.py,sha256=EwP0LePRoqvid0IyqhYZzCKTTknAbspa4R2WeVGhxk8,31026
 plotext_plus/_build.py,sha256=sW7Fm2hYEkRDFapbk_B7sp7u9addBOzFH9MSULn54U8,20936
-plotext_plus/_core.py,sha256=dST_wXAHsJMrILPkUzON7eJz41bwVlsz_oi2X8oWTLU,20673
+plotext_plus/_core.py,sha256=sP3WIzXFO4ltdNX-QXm00Duc4GXe71b8gI02kb1DrkM,22025
 plotext_plus/_date.py,sha256=kTjx-_df5M0yvUTJlg1LqGyDRLxOL2or0op6Si0CUU0,2879
 plotext_plus/_default.py,sha256=bbPO60SFziIpPOI8jY6xtP3urri0H2vhYzwasfmybz4,3316
-plotext_plus/_dict.py,sha256=Ip4YUgkoZAZ2tDwcKLjZEYaX9gD9MeDnC3SFMr8AwSI,21834
+plotext_plus/_dict.py,sha256=I9Wb2YZauMaHjv-1p4oyQ4kRncvhjJGXzwHefeVirMI,21832
 plotext_plus/_doc.py,sha256=qJ--cy1sssH_1EDDkrcOtLeAHahmdqSaYyhOrj4gk54,37183
 plotext_plus/_doc_utils.py,sha256=vVwtDnAJ7vVUafL9zulkILXupGNK3v3Z9aeddX1F828,10397
-plotext_plus/_figure.py,sha256=zXLV-GAUo-VpVPrcKbo9RobEwY9iIAXxuiv94HM5zHU,31144
+plotext_plus/_figure.py,sha256=xLkCqi5nu8NHY9Lv9Zo2jcg-5BP07ggkJ35rs8peSiY,31924
 plotext_plus/_global.py,sha256=NFEupN17WY2Xk4EgDY-On_1J3MOvwNBYubnt6Rg8QW4,15387
 plotext_plus/_matrix.py,sha256=e4sHwghNZeclBORUgWc5BZxdfqoH0yDeh49XymPNHlY,8298
-plotext_plus/_monitor.py,sha256=ccBuN1DcY85LVJ7ScUrstlKhqYxeEQ6yxi3DGEZ8f_Q,40749
+plotext_plus/_monitor.py,sha256=TH-WC2qQj-GRMxtrcvHdgXi67VPsY4_xSGr9kJWJMtI,62946
 plotext_plus/_output.py,sha256=9hBPOum2R6FA1EgIyIMgkMsL7DjtSpX3En8zXGbdx-c,4315
 plotext_plus/_shtab.py,sha256=l1bDdxUbbg5urjNjyC5agbdiYu-OLbruRJZ_AuyirbQ,281
-plotext_plus/_themes.py,sha256=6Imn9hwcb8uEbCm2u_ihg3ZN9dUzdkMe0IGdAX3ErKU,14111
+plotext_plus/_themes.py,sha256=2KQFpAxBvksV_iE8QCMs3lbjq5Tv2TsK_OQLiRg5Gmg,14177
 plotext_plus/_utility.py,sha256=kp5FvE5kooOw0fcVfK_k4o0Fr9ClyFIXMYh4BiXOMlc,32918
 plotext_plus/api.py,sha256=56xYn9uzkMe88iELbanRQ-12bC8Rvv2Jk0BX45Fk8zY,28424
-plotext_plus/charts.py,sha256=jQcIe_9MQBFN845l-11-VIhnaYjTca6hxkQhnc_j4dY,1263
+plotext_plus/charts.py,sha256=VfL0keEo02TPwjUZ6eNFx2q2qOTpiVoq_igL5rGE-gY,1315
 plotext_plus/core.py,sha256=k6g2dYuHFcNevLJM0elkYupz7fC8Qqk_vLEyrXu2V3I,20668
 plotext_plus/mcp_cli.py,sha256=otZaP1tolvAL2vx84TVNiTlFdJyDx1cMIMcbhqsSna8,2651
-plotext_plus/mcp_server.py,sha256=6DW98E38TTR8OfTp-nBumcQf9Djz1w5980ueN2_O12M,14528
+plotext_plus/mcp_server.py,sha256=cL-6CL3nQ53LbC3ZReC77_zxFrRVA8UgqQEqNRakaXI,37130
 plotext_plus/plotext_cli.py,sha256=o3JmSNc7Ify4C6Wkva8x8QRh-pLeiD3VArc3E78xlVU,17677
-plotext_plus/plotting.py,sha256=upSC-HTcamuWV89G-GkLWH2ClzhezZKVd1FLgskJg08,2059
+plotext_plus/plotting.py,sha256=7YUISs2Aolqo-lMEX8amGfMNOSFV9zcSqlrEMwVK2RM,2063
 plotext_plus/themes.py,sha256=xX6XqL2U-7MQmv-k1HU-UTSZRbTfv9op5_4ZRXm435g,725
 plotext_plus/utilities.py,sha256=scdPDGf6po2rvEL5DX7y1pY41uxlCXTVVIo0w5qA8JE,1170
 plotext_plus/utils.py,sha256=NFEupN17WY2Xk4EgDY-On_1J3MOvwNBYubnt6Rg8QW4,15387
-plotext_plus-1.0.7.dist-info/METADATA,sha256=6p_C9FXFIAh3E3PXCMhL3AsIuRmvdWLa1o4O8FxbXI0,11282
-plotext_plus-1.0.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-plotext_plus-1.0.7.dist-info/entry_points.txt,sha256=XocAh2z8hTGtuQL1zEcGTulrgfZ2g5UMyHSV-JOSNN8,103
-plotext_plus-1.0.7.dist-info/licenses/LICENSE,sha256=MkgUiRFwIvXwUVDEPy11uIULq7pGDHpIulD4KulsjnM,1150
-plotext_plus-1.0.7.dist-info/RECORD,,
+plotext_plus-1.0.9.dist-info/METADATA,sha256=mMcu8ukY6WNT9L86-ROTSG9-PVhxTi2ENtP2owMLtmE,11355
+plotext_plus-1.0.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+plotext_plus-1.0.9.dist-info/entry_points.txt,sha256=XocAh2z8hTGtuQL1zEcGTulrgfZ2g5UMyHSV-JOSNN8,103
+plotext_plus-1.0.9.dist-info/licenses/LICENSE,sha256=MkgUiRFwIvXwUVDEPy11uIULq7pGDHpIulD4KulsjnM,1150
+plotext_plus-1.0.9.dist-info/RECORD,,