term-plot-mc 0.1.0__tar.gz

term_plot_mc-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mehdi Maleki
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

term_plot_mc-0.1.0/PKG-INFO

@@ -0,0 +1,194 @@
+Metadata-Version: 2.4
+Name: term-plot-mc
+Version: 0.1.0
+Summary: Draw simple plots and charts in the terminal using ASCII symbols
+Author-email: Mehdi Maleki <mosioc79@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/mosioc/term-plot
+Project-URL: Repository, https://github.com/mosioc/term-plot
+Project-URL: Issues, https://github.com/mosioc/term-plot/issues
+Keywords: terminal,ascii,plot,chart,visualization,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Terminals
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Terminal Plot
+
+> Draw beautiful plots and charts in your terminal using ASCII and Unicode symbols
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+
+## Features
+
+- **Bar Charts** - Horizontal and vertical bar charts for categorical data
+- **Line Charts** - Single and multi-series line plots with automatic scaling
+- **Scatter Plots** - Visualize correlations and relationships
+- **Histograms** - Show data distributions with customizable bins
+- **Dual Modes** - Beautiful Unicode symbols or ASCII for compatibility
+- **Color Support** - Optional ANSI colors for better visualization
+- **Zero Dependencies** - Pure Python, works anywhere
+- **Lightweight** - Fast and minimal resource usage
+
+## Installation
+
+### From PyPI (once published)
+
+```bash
+pip install term-plot
+```
+
+### From source
+
+```bash
+git clone https://github.com/yourusername/term-plot.git
+cd term-plot
+pip install -e .
+```
+
+## Quick Start
+
+### Bar Chart
+
+```python
+from term_plot import BarChart
+
+# Simple horizontal bar chart
+data = [23, 45, 12, 67, 34, 89, 56]
+labels = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
+
+chart = BarChart(data, labels=labels, title="Daily Sales", width=50)
+print(chart.horizontal())
+
+# Vertical bar chart
+chart = BarChart(data, labels=labels, title="Daily Sales", height=15)
+print(chart.vertical())
+```
+
+### Line Chart
+
+```python
+from term_plot import LineChart
+
+# Single series
+data = [1, 3, 7, 4, 8, 6, 9, 12, 10]
+chart = LineChart(data, title="Temperature Over Time", width=60, height=15)
+print(chart.plot())
+
+# Multiple series
+data = {
+    "Product A": [5, 7, 9, 12, 15, 18, 20],
+    "Product B": [3, 5, 8, 10, 12, 15, 17]
+}
+chart = LineChart(data, title="Sales Comparison", width=70, height=20)
+print(chart.plot())
+```
+
+### Scatter Plot
+
+```python
+from term_plot import ScatterPlot
+
+x_data = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+y_data = [2, 4, 3, 5, 7, 6, 8, 9, 8]
+
+chart = ScatterPlot(x_data, y_data, title="Correlation Plot", width=50, height=15)
+print(chart.plot())
+```
+
+### Histogram
+
+```python
+from term_plot import Histogram
+import random
+
+# Generate sample data
+data = [random.gauss(50, 15) for _ in range(1000)]
+
+chart = Histogram(data, bins=15, title="Test Score Distribution", width=60, height=15)
+print(chart.plot())
+```
+
+## Customization Options
+
+### ASCII vs Unicode
+
+```python
+# Unicode mode (default) - prettier but requires Unicode support
+chart = BarChart(data, labels=labels, use_unicode=True)
+
+# ASCII mode - works everywhere
+chart = BarChart(data, labels=labels, use_unicode=False)
+```
+
+### Colors
+
+```python
+# With colors (default)
+chart = BarChart(data, labels=labels, color=True)
+
+# Without colors
+chart = BarChart(data, labels=labels, color=False)
+```
+
+### Size Control
+
+```python
+# Custom width and height
+chart = LineChart(data, width=80, height=25)
+```
+
+## Examples
+
+Check out the `examples/` directory for more:
+
+- `bar_chart_example.py` - Various bar chart styles
+- `line_chart_example.py` - Line chart examples including sine waves
+- `demo_all.py` - Comprehensive demo of all chart types
+
+Run examples:
+
+```bash
+cd examples
+python demo_all.py
+```
+
+## Testing
+
+```bash
+# Install development dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Run tests with coverage
+pytest --cov=term_plot
+```
+
+## Requirements
+
+- Python 3.8 or higher
+- No external dependencies!
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Acknowledgments
+
+- Inspired by various terminal plotting libraries
+- Unicode block elements from the Unicode standard
+- ANSI color codes for terminal colors

term_plot_mc-0.1.0/README.md

@@ -0,0 +1,168 @@
+# Terminal Plot
+
+> Draw beautiful plots and charts in your terminal using ASCII and Unicode symbols
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+
+## Features
+
+- **Bar Charts** - Horizontal and vertical bar charts for categorical data
+- **Line Charts** - Single and multi-series line plots with automatic scaling
+- **Scatter Plots** - Visualize correlations and relationships
+- **Histograms** - Show data distributions with customizable bins
+- **Dual Modes** - Beautiful Unicode symbols or ASCII for compatibility
+- **Color Support** - Optional ANSI colors for better visualization
+- **Zero Dependencies** - Pure Python, works anywhere
+- **Lightweight** - Fast and minimal resource usage
+
+## Installation
+
+### From PyPI (once published)
+
+```bash
+pip install term-plot
+```
+
+### From source
+
+```bash
+git clone https://github.com/yourusername/term-plot.git
+cd term-plot
+pip install -e .
+```
+
+## Quick Start
+
+### Bar Chart
+
+```python
+from term_plot import BarChart
+
+# Simple horizontal bar chart
+data = [23, 45, 12, 67, 34, 89, 56]
+labels = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
+
+chart = BarChart(data, labels=labels, title="Daily Sales", width=50)
+print(chart.horizontal())
+
+# Vertical bar chart
+chart = BarChart(data, labels=labels, title="Daily Sales", height=15)
+print(chart.vertical())
+```
+
+### Line Chart
+
+```python
+from term_plot import LineChart
+
+# Single series
+data = [1, 3, 7, 4, 8, 6, 9, 12, 10]
+chart = LineChart(data, title="Temperature Over Time", width=60, height=15)
+print(chart.plot())
+
+# Multiple series
+data = {
+    "Product A": [5, 7, 9, 12, 15, 18, 20],
+    "Product B": [3, 5, 8, 10, 12, 15, 17]
+}
+chart = LineChart(data, title="Sales Comparison", width=70, height=20)
+print(chart.plot())
+```
+
+### Scatter Plot
+
+```python
+from term_plot import ScatterPlot
+
+x_data = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+y_data = [2, 4, 3, 5, 7, 6, 8, 9, 8]
+
+chart = ScatterPlot(x_data, y_data, title="Correlation Plot", width=50, height=15)
+print(chart.plot())
+```
+
+### Histogram
+
+```python
+from term_plot import Histogram
+import random
+
+# Generate sample data
+data = [random.gauss(50, 15) for _ in range(1000)]
+
+chart = Histogram(data, bins=15, title="Test Score Distribution", width=60, height=15)
+print(chart.plot())
+```
+
+## Customization Options
+
+### ASCII vs Unicode
+
+```python
+# Unicode mode (default) - prettier but requires Unicode support
+chart = BarChart(data, labels=labels, use_unicode=True)
+
+# ASCII mode - works everywhere
+chart = BarChart(data, labels=labels, use_unicode=False)
+```
+
+### Colors
+
+```python
+# With colors (default)
+chart = BarChart(data, labels=labels, color=True)
+
+# Without colors
+chart = BarChart(data, labels=labels, color=False)
+```
+
+### Size Control
+
+```python
+# Custom width and height
+chart = LineChart(data, width=80, height=25)
+```
+
+## Examples
+
+Check out the `examples/` directory for more:
+
+- `bar_chart_example.py` - Various bar chart styles
+- `line_chart_example.py` - Line chart examples including sine waves
+- `demo_all.py` - Comprehensive demo of all chart types
+
+Run examples:
+
+```bash
+cd examples
+python demo_all.py
+```
+
+## Testing
+
+```bash
+# Install development dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Run tests with coverage
+pytest --cov=term_plot
+```
+
+## Requirements
+
+- Python 3.8 or higher
+- No external dependencies!
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Acknowledgments
+
+- Inspired by various terminal plotting libraries
+- Unicode block elements from the Unicode standard
+- ANSI color codes for terminal colors

term_plot_mc-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "term-plot-mc"
+version = "0.1.0"
+description = "Draw simple plots and charts in the terminal using ASCII symbols"
+readme = "README.md"
+authors = [{ name = "Mehdi Maleki", email = "mosioc79@gmail.com" }]
+license = { text = "MIT" }
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Terminals",
+]
+keywords = ["terminal", "ascii", "plot", "chart", "visualization", "cli"]
+requires-python = ">=3.8"
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/mosioc/term-plot"
+Repository = "https://github.com/mosioc/term-plot"
+Issues = "https://github.com/mosioc/term-plot/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+term_plot = ["py.typed"]

term_plot_mc-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

term_plot_mc-0.1.0/src/term_plot/__init__.py

@@ -0,0 +1,13 @@
+"""
+term-plot: Draw simple plots and charts in the terminal using ASCII/Unicode symbols.
+"""
+
+__version__ = "0.1.0"
+__author__ = "Mosioc"
+
+from .bar_chart import BarChart
+from .line_chart import LineChart
+from .scatter_plot import ScatterPlot
+from .histogram import Histogram
+
+__all__ = ["BarChart", "LineChart", "ScatterPlot", "Histogram"]

term_plot_mc-0.1.0/src/term_plot/bar_chart.py

@@ -0,0 +1,139 @@
+"""
+Bar chart implementation for terminal.
+"""
+
+from .utils import normalize_data, truncate_label, Symbols
+
+
+class BarChart:
+    """Create horizontal or vertical bar charts in the terminal."""
+    
+    def __init__(self, data, labels=None, title="", width=50, height=20, 
+                 use_unicode=True, color=True):
+        """
+        Initialize a bar chart.
+        
+        Args:
+            data: List of numeric values
+            labels: List of labels for each bar (optional)
+            title: Chart title
+            width: Maximum width of the chart
+            height: Maximum height of bars (for vertical charts)
+            use_unicode: Use Unicode symbols (prettier) vs ASCII
+            color: Use ANSI colors (if supported)
+        """
+        self.data = data
+        self.labels = labels or [f"Item {i+1}" for i in range(len(data))]
+        self.title = title
+        self.width = width
+        self.height = height
+        self.use_unicode = use_unicode
+        self.color = color
+        
+        if len(self.data) != len(self.labels):
+            raise ValueError("Data and labels must have the same length")
+    
+    def horizontal(self):
+        """Draw a horizontal bar chart."""
+        if not self.data:
+            return "No data to display"
+        
+        output = []
+        
+        # title
+        if self.title:
+            output.append(f"\n{self.title}")
+            output.append("=" * len(self.title))
+        
+        # find max label length
+        max_label_len = max(len(str(label)) for label in self.labels)
+        max_label_len = min(max_label_len, 20)  # Cap at 20 chars
+        
+        # normalize data to fit width
+        bar_width = self.width - max_label_len - 10  # Space for label and value
+        normalized = normalize_data(self.data, 0, bar_width)
+        
+        # choose symbols
+        if self.use_unicode:
+            bar_char = Symbols.UNICODE_FULL_BLOCK
+        else:
+            bar_char = Symbols.ASCII_BLOCK
+        
+        # draw bars
+        for i, (label, value, norm_value) in enumerate(zip(self.labels, self.data, normalized)):
+            label_str = truncate_label(label, max_label_len).ljust(max_label_len)
+            bar_len = int(norm_value)
+            bar = bar_char * bar_len
+            
+            # add color if enabled
+            if self.color:
+                colors = ['\033[91m', '\033[92m', '\033[93m', '\033[94m', '\033[95m', '\033[96m']
+                color_code = colors[i % len(colors)]
+                reset_code = '\033[0m'
+                bar = f"{color_code}{bar}{reset_code}"
+            
+            output.append(f"{label_str} | {bar} {value:.2f}")
+        
+        return "\n".join(output)
+    
+    def vertical(self):
+        """Draw a vertical bar chart."""
+        if not self.data:
+            return "No data to display"
+        
+        output = []
+        
+        # title
+        if self.title:
+            output.append(f"\n{self.title}")
+            output.append("=" * len(self.title))
+        
+        # normalize data to height
+        normalized = normalize_data(self.data, 0, self.height)
+        
+        # choose symbols
+        if self.use_unicode:
+            bar_char = Symbols.UNICODE_FULL_BLOCK
+            h_line = Symbols.UNICODE_HORIZONTAL
+        else:
+            bar_char = Symbols.ASCII_BLOCK
+            h_line = Symbols.ASCII_HORIZONTAL
+        
+        # draw from top to bottom
+        for level in range(self.height, 0, -1):
+            line = ""
+            for i, norm_value in enumerate(normalized):
+                if norm_value >= level:
+                    char = bar_char * 3
+                    if self.color:
+                        colors = ['\033[91m', '\033[92m', '\033[93m', '\033[94m', '\033[95m', '\033[96m']
+                        color_code = colors[i % len(colors)]
+                        reset_code = '\033[0m'
+                        char = f"{color_code}{char}{reset_code}"
+                    line += char + " "
+                else:
+                    line += "    "
+            output.append(line)
+        
+        # draw x-axis
+        output.append(h_line * (len(self.data) * 4))
+        
+        # draw labels
+        label_line = ""
+        for label in self.labels:
+            label_str = truncate_label(label, 3)
+            label_line += label_str.center(4)
+        output.append(label_line)
+        
+        # draw values
+        value_line = ""
+        for value in self.data:
+            value_str = f"{value:.1f}"
+            value_line += truncate_label(value_str, 3).center(4)
+        output.append(value_line)
+        
+        return "\n".join(output)
+    
+    def __str__(self):
+        """Default to horizontal bar chart."""
+        return self.horizontal()

term_plot_mc-0.1.0/src/term_plot/histogram.py

@@ -0,0 +1,104 @@
+"""
+Histogram implementation for terminal.
+"""
+
+from .utils import Symbols
+
+
+class Histogram:
+    """Create histograms in the terminal."""
+    
+    def __init__(self, data, bins=10, title="", width=60, height=20, use_unicode=True):
+        """
+        Initialize a histogram.
+        
+        Args:
+            data: List of numeric values
+            bins: Number of bins (default 10)
+            title: Chart title
+            width: Chart width in characters
+            height: Chart height in lines
+            use_unicode: Use Unicode symbols vs ASCII
+        """
+        self.data = data
+        self.bins = bins
+        self.title = title
+        self.width = width
+        self.height = height
+        self.use_unicode = use_unicode
+    
+    def plot(self):
+        """Draw the histogram."""
+        if not self.data:
+            return "No data to display"
+        
+        output = []
+        
+        # title
+        if self.title:
+            output.append(f"\n{self.title}")
+            output.append("=" * len(self.title))
+        
+        # calculate bins
+        data_min = min(self.data)
+        data_max = max(self.data)
+        
+        if data_min == data_max:
+            return "All values are the same, cannot create histogram"
+        
+        bin_width = (data_max - data_min) / self.bins
+        bin_counts = [0] * self.bins
+        bin_edges = [data_min + i * bin_width for i in range(self.bins + 1)]
+        
+        # count values in each bin
+        for value in self.data:
+            bin_idx = min(int((value - data_min) / bin_width), self.bins - 1)
+            bin_counts[bin_idx] += 1
+        
+        # choose symbols
+        if self.use_unicode:
+            bar_char = Symbols.UNICODE_FULL_BLOCK
+            h_char = Symbols.UNICODE_HORIZONTAL
+        else:
+            bar_char = Symbols.ASCII_BLOCK
+            h_char = Symbols.ASCII_HORIZONTAL
+        
+        # scale to height
+        max_count = max(bin_counts) if bin_counts else 1
+        
+        # draw histogram from top to bottom
+        for level in range(self.height, 0, -1):
+            line = ""
+            threshold = (level / self.height) * max_count
+            
+            for count in bin_counts:
+                if count >= threshold:
+                    line += bar_char * 3 + " "
+                else:
+                    line += "    "
+            output.append(line)
+        
+        # draw x-axis
+        output.append(h_char * (self.bins * 4))
+        
+        # draw bin labels
+        label_line = ""
+        for i in range(self.bins):
+            bin_start = bin_edges[i]
+            label = f"{bin_start:.1f}"
+            if len(label) > 3:
+                label = label[:3]
+            label_line += label.center(4)
+        output.append(label_line)
+        
+        # statistics
+        output.append(f"\nTotal values: {len(self.data)}")
+        output.append(f"Range: {data_min:.2f} to {data_max:.2f}")
+        output.append(f"Mean: {sum(self.data)/len(self.data):.2f}")
+        output.append(f"Max frequency: {max_count}")
+        
+        return "\n".join(output)
+    
+    def __str__(self):
+        """Default string representation."""
+        return self.plot()

term_plot_mc-0.1.0/src/term_plot/line_chart.py

@@ -0,0 +1,164 @@
+"""
+Line chart implementation for terminal.
+"""
+
+from .utils import normalize_data, Symbols
+
+
+class LineChart:
+    """Create line charts in the terminal."""
+    
+    def __init__(self, data, title="", width=60, height=20, use_unicode=True):
+        """
+        Initialize a line chart.
+        
+        Args:
+            data: List of numeric values or dict of {label: values} for multiple lines
+            title: Chart title
+            width: Chart width in characters
+            height: Chart height in lines
+            use_unicode: Use Unicode symbols vs ASCII
+        """
+        # support both single series and multiple series
+        if isinstance(data, dict):
+            self.data = data
+            self.multi_series = True
+        else:
+            self.data = {"Series 1": data}
+            self.multi_series = False
+        
+        self.title = title
+        self.width = width
+        self.height = height
+        self.use_unicode = use_unicode
+    
+    def plot(self):
+        """Draw the line chart."""
+        if not self.data:
+            return "No data to display"
+        
+        output = []
+        
+        # title
+        if self.title:
+            output.append(f"\n{self.title}")
+            output.append("=" * len(self.title))
+        
+        # create the canvas
+        canvas = [[' ' for _ in range(self.width)] for _ in range(self.height)]
+        
+        # choose symbols
+        if self.use_unicode:
+            point_char = Symbols.UNICODE_DOT
+            line_chars = ['•', '○', '◆', '◇', '▪', '▫']
+        else:
+            point_char = Symbols.ASCII_POINT
+            line_chars = ['*', 'o', '+', 'x', '#', '@']
+        
+        # plot each series
+        series_idx = 0
+        all_values = []
+        for values in self.data.values():
+            all_values.extend(values)
+        
+        # normalize all data together for consistent scale
+        if all_values:
+            global_min = min(all_values)
+            global_max = max(all_values)
+        else:
+            return "No data to display"
+        
+        for label, values in self.data.items():
+            if not values:
+                continue
+            
+            char = line_chars[series_idx % len(line_chars)]
+            
+            # normalize to height
+            normalized = normalize_data(values, 0, self.height - 1)
+            
+            # calculate x positions
+            if len(values) > 1:
+                x_step = (self.width - 1) / (len(values) - 1)
+            else:
+                x_step = 0
+            
+            # plot points and connect them
+            for i, norm_value in enumerate(normalized):
+                x = int(i * x_step)
+                y = self.height - 1 - int(norm_value)
+                
+                if 0 <= x < self.width and 0 <= y < self.height:
+                    canvas[y][x] = char
+                
+                # draw line to next point
+                if i < len(normalized) - 1:
+                    next_x = int((i + 1) * x_step)
+                    next_y = self.height - 1 - int(normalized[i + 1])
+                    
+                    # simple line drawing between points
+                    self._draw_line(canvas, x, y, next_x, next_y, char)
+            
+            series_idx += 1
+        
+        # add y-axis
+        if self.use_unicode:
+            v_char = Symbols.UNICODE_VERTICAL
+        else:
+            v_char = Symbols.ASCII_VERTICAL
+        
+        for y in range(self.height):
+            canvas[y][0] = v_char
+        
+        # convert canvas to string
+        for row in canvas:
+            output.append(''.join(row))
+        
+        # add x-axis
+        if self.use_unicode:
+            h_char = Symbols.UNICODE_HORIZONTAL
+        else:
+            h_char = Symbols.ASCII_HORIZONTAL
+        output.append(h_char * self.width)
+        
+        # add legend if multiple series
+        if self.multi_series and len(self.data) > 1:
+            output.append("\nLegend:")
+            for idx, label in enumerate(self.data.keys()):
+                char = line_chars[idx % len(line_chars)]
+                output.append(f"  {char} {label}")
+        
+        # add scale info
+        output.append(f"\nScale: {global_min:.2f} to {global_max:.2f}")
+        
+        return "\n".join(output)
+    
+    def _draw_line(self, canvas, x1, y1, x2, y2, char):
+        """Draw a simple line between two points using Bresenham's algorithm."""
+        dx = abs(x2 - x1)
+        dy = abs(y2 - y1)
+        sx = 1 if x1 < x2 else -1
+        sy = 1 if y1 < y2 else -1
+        err = dx - dy
+        
+        x, y = x1, y1
+        
+        while True:
+            if 0 <= x < self.width and 0 <= y < self.height:
+                if canvas[y][x] == ' ' or canvas[y][x] in ['│', '|']:
+                    canvas[y][x] = char
+            
+            if x == x2 and y == y2:
+                break
+            
+            e2 = 2 * err
+            if e2 > -dy:
+                err -= dy
+                x += sx
+            if e2 < dx:
+                err += dx
+                y += sy
+    
+    def __str__(self):
+        """Default string representation."""
+        return self.plot()

term_plot_mc-0.1.0/src/term_plot/scatter_plot.py

@@ -0,0 +1,93 @@
+"""
+Scatter plot implementation for terminal.
+"""
+
+from .utils import normalize_data, Symbols
+
+
+class ScatterPlot:
+    """Create scatter plots in the terminal."""
+    
+    def __init__(self, x_data, y_data, title="", width=60, height=20, use_unicode=True):
+        """
+        Initialize a scatter plot.
+        
+        Args:
+            x_data: List of x coordinates
+            y_data: List of y coordinates
+            title: Chart title
+            width: Chart width in characters
+            height: Chart height in lines
+            use_unicode: Use Unicode symbols vs ASCII
+        """
+        if len(x_data) != len(y_data):
+            raise ValueError("x_data and y_data must have the same length")
+        
+        self.x_data = x_data
+        self.y_data = y_data
+        self.title = title
+        self.width = width
+        self.height = height
+        self.use_unicode = use_unicode
+    
+    def plot(self):
+        """Draw the scatter plot."""
+        if not self.x_data or not self.y_data:
+            return "No data to display"
+        
+        output = []
+        
+        # title
+        if self.title:
+            output.append(f"\n{self.title}")
+            output.append("=" * len(self.title))
+        
+        # create the canvas
+        canvas = [[' ' for _ in range(self.width)] for _ in range(self.height)]
+        
+        # choose symbols
+        if self.use_unicode:
+            point_char = Symbols.UNICODE_DOT
+            v_char = Symbols.UNICODE_VERTICAL
+            h_char = Symbols.UNICODE_HORIZONTAL
+        else:
+            point_char = Symbols.ASCII_POINT
+            v_char = Symbols.ASCII_VERTICAL
+            h_char = Symbols.ASCII_HORIZONTAL
+        
+        # normalize data
+        x_normalized = normalize_data(self.x_data, 1, self.width - 1)
+        y_normalized = normalize_data(self.y_data, 0, self.height - 1)
+        
+        # plot points
+        for x, y in zip(x_normalized, y_normalized):
+            x_pos = int(x)
+            y_pos = self.height - 1 - int(y)
+            
+            if 0 <= x_pos < self.width and 0 <= y_pos < self.height:
+                canvas[y_pos][x_pos] = point_char
+        
+        # add y-axis
+        for y in range(self.height):
+            if canvas[y][0] == ' ':
+                canvas[y][0] = v_char
+        
+        # convert canvas to string
+        for row in canvas:
+            output.append(''.join(row))
+        
+        # add x-axis
+        output.append(h_char * self.width)
+        
+        # add scale info
+        x_min, x_max = min(self.x_data), max(self.x_data)
+        y_min, y_max = min(self.y_data), max(self.y_data)
+        output.append(f"\nX: {x_min:.2f} to {x_max:.2f}")
+        output.append(f"Y: {y_min:.2f} to {y_max:.2f}")
+        output.append(f"Points: {len(self.x_data)}")
+        
+        return "\n".join(output)
+    
+    def __str__(self):
+        """Default string representation."""
+        return self.plot()

term_plot_mc-0.1.0/src/term_plot/utils.py

@@ -0,0 +1,73 @@
+"""
+Utility functions for terminal plotting.
+"""
+
+def normalize_data(data, min_val=0, max_val=100):
+    """Normalize data to a specific range."""
+    if not data:
+        return []
+    
+    data_min = min(data)
+    data_max = max(data)
+    
+    if data_max == data_min:
+        return [min_val] * len(data)
+    
+    scale = (max_val - min_val) / (data_max - data_min)
+    return [min_val + (x - data_min) * scale for x in data]
+
+
+def get_terminal_width():
+    """Get the current terminal width."""
+    import shutil
+    return shutil.get_terminal_size().columns
+
+
+def get_terminal_height():
+    """Get the current terminal height."""
+    import shutil
+    return shutil.get_terminal_size().lines
+
+
+def truncate_label(label, max_length):
+    """Truncate label to max_length with ellipsis if needed."""
+    label = str(label)
+    if len(label) <= max_length:
+        return label
+    return label[:max_length-3] + "..."
+
+
+class Symbols:
+    """ASCII and Unicode symbols for plotting."""
+    
+    # ASCII symbols
+    ASCII_HORIZONTAL = "-"
+    ASCII_VERTICAL = "|"
+    ASCII_BLOCK = "#"
+    ASCII_POINT = "*"
+    ASCII_CORNER = "+"
+    
+    # unicode symbols (prettier but may not work on all terminals)
+    UNICODE_HORIZONTAL = "─"
+    UNICODE_VERTICAL = "│"
+    UNICODE_CORNER_TL = "┌"
+    UNICODE_CORNER_TR = "┐"
+    UNICODE_CORNER_BL = "└"
+    UNICODE_CORNER_BR = "┘"
+    UNICODE_CROSS = "┼"
+    UNICODE_T_DOWN = "┬"
+    UNICODE_T_UP = "┴"
+    UNICODE_T_RIGHT = "├"
+    UNICODE_T_LEFT = "┤"
+    
+    # block elements
+    UNICODE_BLOCKS = ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"]
+    UNICODE_FULL_BLOCK = "█"
+    UNICODE_LIGHT_SHADE = "░"
+    UNICODE_MEDIUM_SHADE = "▒"
+    UNICODE_DARK_SHADE = "▓"
+    
+    # dots and points
+    UNICODE_DOT = "•"
+    UNICODE_CIRCLE = "○"
+    UNICODE_SQUARE = "■"

term_plot_mc-0.1.0/src/term_plot_mc.egg-info/PKG-INFO

@@ -0,0 +1,194 @@
+Metadata-Version: 2.4
+Name: term-plot-mc
+Version: 0.1.0
+Summary: Draw simple plots and charts in the terminal using ASCII symbols
+Author-email: Mehdi Maleki <mosioc79@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/mosioc/term-plot
+Project-URL: Repository, https://github.com/mosioc/term-plot
+Project-URL: Issues, https://github.com/mosioc/term-plot/issues
+Keywords: terminal,ascii,plot,chart,visualization,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Terminals
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Terminal Plot
+
+> Draw beautiful plots and charts in your terminal using ASCII and Unicode symbols
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+
+## Features
+
+- **Bar Charts** - Horizontal and vertical bar charts for categorical data
+- **Line Charts** - Single and multi-series line plots with automatic scaling
+- **Scatter Plots** - Visualize correlations and relationships
+- **Histograms** - Show data distributions with customizable bins
+- **Dual Modes** - Beautiful Unicode symbols or ASCII for compatibility
+- **Color Support** - Optional ANSI colors for better visualization
+- **Zero Dependencies** - Pure Python, works anywhere
+- **Lightweight** - Fast and minimal resource usage
+
+## Installation
+
+### From PyPI (once published)
+
+```bash
+pip install term-plot
+```
+
+### From source
+
+```bash
+git clone https://github.com/yourusername/term-plot.git
+cd term-plot
+pip install -e .
+```
+
+## Quick Start
+
+### Bar Chart
+
+```python
+from term_plot import BarChart
+
+# Simple horizontal bar chart
+data = [23, 45, 12, 67, 34, 89, 56]
+labels = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
+
+chart = BarChart(data, labels=labels, title="Daily Sales", width=50)
+print(chart.horizontal())
+
+# Vertical bar chart
+chart = BarChart(data, labels=labels, title="Daily Sales", height=15)
+print(chart.vertical())
+```
+
+### Line Chart
+
+```python
+from term_plot import LineChart
+
+# Single series
+data = [1, 3, 7, 4, 8, 6, 9, 12, 10]
+chart = LineChart(data, title="Temperature Over Time", width=60, height=15)
+print(chart.plot())
+
+# Multiple series
+data = {
+    "Product A": [5, 7, 9, 12, 15, 18, 20],
+    "Product B": [3, 5, 8, 10, 12, 15, 17]
+}
+chart = LineChart(data, title="Sales Comparison", width=70, height=20)
+print(chart.plot())
+```
+
+### Scatter Plot
+
+```python
+from term_plot import ScatterPlot
+
+x_data = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+y_data = [2, 4, 3, 5, 7, 6, 8, 9, 8]
+
+chart = ScatterPlot(x_data, y_data, title="Correlation Plot", width=50, height=15)
+print(chart.plot())
+```
+
+### Histogram
+
+```python
+from term_plot import Histogram
+import random
+
+# Generate sample data
+data = [random.gauss(50, 15) for _ in range(1000)]
+
+chart = Histogram(data, bins=15, title="Test Score Distribution", width=60, height=15)
+print(chart.plot())
+```
+
+## Customization Options
+
+### ASCII vs Unicode
+
+```python
+# Unicode mode (default) - prettier but requires Unicode support
+chart = BarChart(data, labels=labels, use_unicode=True)
+
+# ASCII mode - works everywhere
+chart = BarChart(data, labels=labels, use_unicode=False)
+```
+
+### Colors
+
+```python
+# With colors (default)
+chart = BarChart(data, labels=labels, color=True)
+
+# Without colors
+chart = BarChart(data, labels=labels, color=False)
+```
+
+### Size Control
+
+```python
+# Custom width and height
+chart = LineChart(data, width=80, height=25)
+```
+
+## Examples
+
+Check out the `examples/` directory for more:
+
+- `bar_chart_example.py` - Various bar chart styles
+- `line_chart_example.py` - Line chart examples including sine waves
+- `demo_all.py` - Comprehensive demo of all chart types
+
+Run examples:
+
+```bash
+cd examples
+python demo_all.py
+```
+
+## Testing
+
+```bash
+# Install development dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Run tests with coverage
+pytest --cov=term_plot
+```
+
+## Requirements
+
+- Python 3.8 or higher
+- No external dependencies!
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Acknowledgments
+
+- Inspired by various terminal plotting libraries
+- Unicode block elements from the Unicode standard
+- ANSI color codes for terminal colors

term_plot_mc-0.1.0/src/term_plot_mc.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+src/term_plot/__init__.py
+src/term_plot/bar_chart.py
+src/term_plot/histogram.py
+src/term_plot/line_chart.py
+src/term_plot/scatter_plot.py
+src/term_plot/utils.py
+src/term_plot_mc.egg-info/PKG-INFO
+src/term_plot_mc.egg-info/SOURCES.txt
+src/term_plot_mc.egg-info/dependency_links.txt
+src/term_plot_mc.egg-info/top_level.txt
+tests/test_bar_chart.py
+tests/test_utils.py

term_plot_mc-0.1.0/src/term_plot_mc.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

term_plot_mc-0.1.0/src/term_plot_mc.egg-info/top_level.txt

@@ -0,0 +1 @@
+term_plot

term_plot_mc-0.1.0/tests/test_bar_chart.py

@@ -0,0 +1,86 @@
+"""
+Tests for BarChart class.
+"""
+
+import pytest
+from term_plot import BarChart
+
+
+def test_bar_chart_creation():
+    """Test basic bar chart creation."""
+    data = [1, 2, 3, 4, 5]
+    labels = ['A', 'B', 'C', 'D', 'E']
+    
+    chart = BarChart(data, labels=labels)
+    assert chart.data == data
+    assert chart.labels == labels
+
+
+def test_bar_chart_mismatched_lengths():
+    """Test that mismatched data and labels raises error."""
+    data = [1, 2, 3]
+    labels = ['A', 'B']
+    
+    with pytest.raises(ValueError):
+        BarChart(data, labels=labels)
+
+
+def test_bar_chart_horizontal():
+    """Test horizontal bar chart generation."""
+    data = [10, 20, 30]
+    labels = ['X', 'Y', 'Z']
+    
+    chart = BarChart(data, labels=labels, title="Test Chart")
+    output = chart.horizontal()
+    
+    assert "Test Chart" in output
+    assert "X" in output
+    assert "Y" in output
+    assert "Z" in output
+
+
+def test_bar_chart_vertical():
+    """Test vertical bar chart generation."""
+    data = [5, 10, 15]
+    labels = ['A', 'B', 'C']
+    
+    chart = BarChart(data, labels=labels)
+    output = chart.vertical()
+    
+    assert output is not None
+    assert len(output) > 0
+
+
+def test_bar_chart_empty_data():
+    """Test bar chart with empty data."""
+    data = []
+    labels = []
+    
+    chart = BarChart(data, labels=labels)
+    output = chart.horizontal()
+    
+    assert "No data" in output
+
+
+def test_bar_chart_auto_labels():
+    """Test automatic label generation."""
+    data = [1, 2, 3]
+    
+    chart = BarChart(data)
+    assert len(chart.labels) == len(data)
+    assert chart.labels[0] == "Item 1"
+
+
+def test_bar_chart_unicode_vs_ascii():
+    """Test Unicode vs ASCII mode."""
+    data = [10, 20]
+    labels = ['A', 'B']
+    
+    unicode_chart = BarChart(data, labels=labels, use_unicode=True)
+    ascii_chart = BarChart(data, labels=labels, use_unicode=False)
+    
+    unicode_output = unicode_chart.horizontal()
+    ascii_output = ascii_chart.horizontal()
+    
+    # They should be different
+    assert unicode_output != ascii_output

term_plot_mc-0.1.0/tests/test_utils.py

@@ -0,0 +1,53 @@
+"""
+Tests for utility functions.
+"""
+
+import pytest
+from term_plot.utils import normalize_data, truncate_label, Symbols
+
+
+def test_normalize_data():
+    """Test data normalization."""
+    data = [0, 50, 100]
+    normalized = normalize_data(data, 0, 10)
+    
+    assert normalized[0] == 0
+    assert normalized[1] == 5
+    assert normalized[2] == 10
+
+
+def test_normalize_data_same_values():
+    """Test normalization with same values."""
+    data = [5, 5, 5]
+    normalized = normalize_data(data, 0, 10)
+    
+    # all values should be the same (min_val)
+    assert all(v == 0 for v in normalized)
+
+
+def test_normalize_data_empty():
+    """Test normalization with empty data."""
+    data = []
+    normalized = normalize_data(data)
+    
+    assert normalized == []
+
+
+def test_truncate_label():
+    """Test label truncation."""
+    # short label
+    assert truncate_label("Test", 10) == "Test"
+    
+    # song label
+    assert truncate_label("ThisIsAVeryLongLabel", 10) == "ThisIs..."
+    
+    # exact length
+    assert truncate_label("ExactLen", 8) == "ExactLen"
+
+
+def test_symbols_exist():
+    """Test that symbol constants exist."""
+    assert hasattr(Symbols, 'ASCII_BLOCK')
+    assert hasattr(Symbols, 'UNICODE_FULL_BLOCK')
+    assert hasattr(Symbols, 'ASCII_HORIZONTAL')
+    assert hasattr(Symbols, 'UNICODE_DOT')