scitex 2.0.0__py2.py3-none-any.whl

scitex/plt/_subplots/_export_as_csv_formatters/test_formatters.py

@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-18 22:05:10 (ywatanabe)"
+# File: /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/plt/_subplots/_export_as_csv_formatters/test_formatters.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters/test_formatters.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import unittest
+import numpy as np
+import pandas as pd
+
+# Import formatters directly
+from ._format_plot import _format_plot
+from ._format_plot_kde import _format_plot_kde
+from ._format_plot_ecdf import _format_plot_ecdf
+from ._format_plot_heatmap import _format_plot_heatmap
+from ._format_plot_violin import _format_plot_violin
+from ._format_plot_shaded_line import _format_plot_shaded_line
+from ._format_plot_scatter_hist import _format_plot_scatter_hist
+
+
+class FormattersTest(unittest.TestCase):
+    """Test the formatter functions."""
+
+    def test_format_plot_kde(self):
+        """Test _format_plot_kde function."""
+        # Test case 1: Normal input
+        tracked_dict = {
+            'x': np.linspace(-3, 3, 100),
+            'kde': np.exp(-np.linspace(-3, 3, 100)**2/2),
+            'n': 500
+        }
+        id = 'test_kde'
+        df = _format_plot_kde(id, tracked_dict, {})
+        
+        # Verify columns
+        self.assertIn(f"{id}_kde_x", df.columns)
+        self.assertIn(f"{id}_kde_density", df.columns)
+        self.assertIn(f"{id}_kde_n", df.columns)
+        
+        # Test case 2: Empty tracked_dict
+        df = _format_plot_kde(id, {}, {})
+        self.assertTrue(df.empty)
+        
+        # Test case 3: Missing 'x' key
+        tracked_dict = {'kde': np.exp(-np.linspace(-3, 3, 100)**2/2)}
+        df = _format_plot_kde(id, tracked_dict, {})
+        self.assertTrue(df.empty)
+
+    def test_format_plot(self):
+        """Test _format_plot function."""
+        # Test case 1: Normal input
+        tracked_dict = {
+            'plot_df': pd.DataFrame({
+                'x': np.linspace(0, 10, 100),
+                'y': np.sin(np.linspace(0, 10, 100))
+            })
+        }
+        id = 'test_plot'
+        df = _format_plot(id, tracked_dict, {})
+        
+        # Verify it returned the DataFrame with added prefix
+        self.assertFalse(df.empty)
+        
+        # Test case 2: Empty tracked_dict
+        df = _format_plot(id, {}, {})
+        self.assertTrue(df.empty)
+
+    def test_format_plot_ecdf(self):
+        """Test _format_plot_ecdf function."""
+        # Test case 1: Normal input
+        tracked_dict = {
+            'ecdf_df': pd.DataFrame({
+                'x': np.linspace(-3, 3, 100),
+                'ecdf': np.linspace(0, 1, 100)
+            })
+        }
+        id = 'test_ecdf'
+        df = _format_plot_ecdf(id, tracked_dict, {})
+        
+        # Verify it returned the DataFrame
+        self.assertFalse(df.empty)
+        
+        # Test case 2: Empty tracked_dict
+        df = _format_plot_ecdf(id, {}, {})
+        self.assertTrue(df.empty)
+
+    def test_format_plot_heatmap(self):
+        """Test _format_plot_heatmap function."""
+        # Test case 1: Normal input with labels
+        data = np.random.rand(3, 4)
+        x_labels = ['A', 'B', 'C']
+        y_labels = ['W', 'X', 'Y', 'Z']
+        
+        tracked_dict = {
+            'data': data,
+            'x_labels': x_labels,
+            'y_labels': y_labels
+        }
+        id = 'test_heatmap'
+        df = _format_plot_heatmap(id, tracked_dict, {})
+        
+        # Verify it returned the DataFrame with the expected shape
+        self.assertFalse(df.empty)
+        self.assertEqual(df.shape[0], 12)  # 3 rows * 4 columns = 12 cells
+        # We should have 5 columns: row, col, value, row_label, col_label
+        self.assertEqual(df.shape[1], 5)
+        
+        # Test case 2: No labels
+        tracked_dict = {'data': data}
+        df = _format_plot_heatmap(id, tracked_dict, {})
+        self.assertFalse(df.empty)
+        
+        # Test case 3: Empty tracked_dict
+        df = _format_plot_heatmap(id, {}, {})
+        self.assertTrue(df.empty)
+
+    def test_format_plot_violin(self):
+        """Test _format_plot_violin function."""
+        # Test case 1: List data
+        data = [np.random.normal(0, 1, 100), np.random.normal(2, 1, 100)]
+        labels = ['Group A', 'Group B']
+        
+        tracked_dict = {
+            'data': data,
+            'labels': labels
+        }
+        id = 'test_violin'
+        df = _format_plot_violin(id, tracked_dict, {})
+        
+        # Verify it returned the DataFrame
+        self.assertFalse(df.empty)
+        
+        # Test case 2: DataFrame data
+        data_df = pd.DataFrame({
+            'values': np.concatenate([np.random.normal(0, 1, 100), np.random.normal(2, 1, 100)]),
+            'group': ['A'] * 100 + ['B'] * 100
+        })
+        tracked_dict = {
+            'data': data_df,
+            'x': 'group',
+            'y': 'values'
+        }
+        df = _format_plot_violin(id, tracked_dict, {})
+        self.assertFalse(df.empty)
+        
+        # Test case 3: Empty tracked_dict
+        df = _format_plot_violin(id, {}, {})
+        self.assertTrue(df.empty)
+
+    def test_format_plot_shaded_line(self):
+        """Test _format_plot_shaded_line function."""
+        # Test case 1: Normal input
+        tracked_dict = {
+            'plot_df': pd.DataFrame({
+                'x': np.linspace(0, 10, 100),
+                'y_lower': np.sin(np.linspace(0, 10, 100)) - 0.2,
+                'y_middle': np.sin(np.linspace(0, 10, 100)),
+                'y_upper': np.sin(np.linspace(0, 10, 100)) + 0.2
+            })
+        }
+        id = 'test_shaded'
+        df = _format_plot_shaded_line(id, tracked_dict, {})
+        
+        # Verify it returned the DataFrame
+        self.assertFalse(df.empty)
+        
+        # Test case 2: Empty tracked_dict
+        df = _format_plot_shaded_line(id, {}, {})
+        self.assertTrue(df.empty)
+
+    def test_format_plot_scatter_hist(self):
+        """Test _format_plot_scatter_hist function."""
+        # Test case 1: Normal input
+        tracked_dict = {
+            'x': np.random.normal(0, 1, 100),
+            'y': np.random.normal(0, 1, 100),
+            'hist_x': np.random.rand(10),
+            'hist_y': np.random.rand(10),
+            'bin_edges_x': np.linspace(-3, 3, 11),
+            'bin_edges_y': np.linspace(-3, 3, 11)
+        }
+        id = 'test_scatter_hist'
+        df = _format_plot_scatter_hist(id, tracked_dict, {})
+        
+        # Verify it returned the DataFrame with expected columns
+        self.assertFalse(df.empty)
+        self.assertTrue(any(col.startswith(f"{id}_scatter_hist_x") for col in df.columns))
+        self.assertTrue(any(col.startswith(f"{id}_scatter_hist_y") for col in df.columns))
+        
+        # Test case 2: Missing keys
+        tracked_dict = {
+            'x': np.random.normal(0, 1, 100),
+            'y': np.random.normal(0, 1, 100)
+        }
+        df = _format_plot_scatter_hist(id, tracked_dict, {})
+        self.assertFalse(df.empty)  # Should still work with just x,y
+        
+        # Test case 3: Empty tracked_dict
+        df = _format_plot_scatter_hist(id, {}, {})
+        self.assertTrue(df.empty)
+
+
+if __name__ == '__main__':
+    unittest.main()

scitex/plt/_subplots/_export_as_csv_formatters/verify_formatters.py

@@ -0,0 +1,342 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-18 23:14:10 (ywatanabe)"
+# File: /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/plt/_subplots/_export_as_csv_formatters/verify_formatters.py
+# ----------------------------------------
+import os
+import sys
+import numpy as np
+import pandas as pd
+import matplotlib
+matplotlib.use('Agg')  # Non-interactive backend
+
+# Add src to path if needed
+src_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '../../../../../'))
+if src_path not in sys.path:
+    sys.path.insert(0, src_path)
+
+import scitex
+
+# Create output directory
+OUTPUT_DIR = os.path.join(os.path.dirname(__file__), 'formatter_test_output')
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+def test_all_formatters():
+    """
+    Test all formatters by creating actual plots and saving both image and CSV files.
+    Each function will create a different type of plot, save it, and verify the CSV export.
+    """
+    # Test each formatter with a real plot
+    test_plot_kde()
+    test_plot_image()
+    test_plot_shaded_line()
+    test_plot_scatter_hist()
+    test_plot_violin()
+    test_plot_heatmap()
+    test_plot_ecdf()
+    test_multiple_plots()
+
+def test_plot_kde():
+    """Test KDE plotting and CSV export."""
+    print("Testing plot_kde...")
+    
+    # Create figure
+    fig, ax = scitex.plt.subplots()
+    
+    # Generate data
+    np.random.seed(42)  # For reproducibility
+    data = np.concatenate([np.random.normal(0, 1, 500), np.random.normal(5, 1, 300)])
+    
+    # Plot with ID for tracking
+    ax.plot_kde(data, label="Bimodal Distribution", id="kde_test")
+    
+    # Style the plot
+    ax.set_xyt("Value", "Density", "KDE Test")
+    ax.legend()
+    
+    # Save both image and data
+    save_path = os.path.join(OUTPUT_DIR, "kde_test.png")
+    scitex.io.save(fig, save_path)
+    
+    # Verify CSV was created
+    csv_path = save_path.replace(".png", ".csv")
+    assert os.path.exists(csv_path), f"CSV file not created: {csv_path}"
+    
+    # Read CSV and verify contents
+    df = pd.read_csv(csv_path)
+    assert "kde_test_kde_x" in df.columns, "Expected column 'kde_test_kde_x' not found"
+    assert "kde_test_kde_density" in df.columns, "Expected column 'kde_test_kde_density' not found"
+    
+    # Close figure
+    scitex.plt.close(fig)
+    print("✓ plot_kde test successful")
+
+def test_plot_image():
+    """Test image plotting and CSV export."""
+    print("Testing plot_image...")
+    
+    # Create figure
+    fig, ax = scitex.plt.subplots()
+    
+    # Generate data
+    np.random.seed(42)  # For reproducibility
+    data = np.random.rand(20, 20)
+    
+    # Plot with ID for tracking
+    ax.plot_image(data, cmap="viridis", id="image_test")
+    
+    # Style the plot
+    ax.set_xyt("X", "Y", "Image Test")
+    
+    # Save both image and data
+    save_path = os.path.join(OUTPUT_DIR, "image_test.png")
+    scitex.io.save(fig, save_path)
+    
+    # Verify CSV was created
+    csv_path = save_path.replace(".png", ".csv")
+    assert os.path.exists(csv_path), f"CSV file not created: {csv_path}"
+    
+    # Read CSV and verify contents
+    df = pd.read_csv(csv_path)
+    # The formatter should have converted the 2D array to a DataFrame
+    assert not df.empty, "CSV file is empty"
+    
+    # Close figure
+    scitex.plt.close(fig)
+    print("✓ plot_image test successful")
+
+def test_plot_shaded_line():
+    """Test shaded line plotting and CSV export."""
+    print("Testing plot_shaded_line...")
+    
+    # Create figure
+    fig, ax = scitex.plt.subplots()
+    
+    # Generate data
+    np.random.seed(42)  # For reproducibility
+    x = np.linspace(0, 10, 100)
+    y_middle = np.sin(x)
+    y_lower = y_middle - 0.2
+    y_upper = y_middle + 0.2
+    
+    # Plot with ID for tracking
+    ax.plot_shaded_line(x, y_lower, y_middle, y_upper, label="Sine with error", id="shaded_line_test")
+    
+    # Style the plot
+    ax.set_xyt("X", "Y", "Shaded Line Test")
+    ax.legend()
+    
+    # Save both image and data
+    save_path = os.path.join(OUTPUT_DIR, "shaded_line_test.png")
+    scitex.io.save(fig, save_path)
+    
+    # Verify CSV was created
+    csv_path = save_path.replace(".png", ".csv")
+    assert os.path.exists(csv_path), f"CSV file not created: {csv_path}"
+    
+    # Read CSV and verify contents
+    df = pd.read_csv(csv_path)
+    assert not df.empty, "CSV file is empty"
+    
+    # Close figure
+    scitex.plt.close(fig)
+    print("✓ plot_shaded_line test successful")
+
+def test_plot_scatter_hist():
+    """Test scatter histogram plotting and CSV export."""
+    print("Testing plot_scatter_hist...")
+    
+    # Create figure
+    fig, ax = scitex.plt.subplots(figsize=(8, 8))
+    
+    # Generate data
+    np.random.seed(42)  # For reproducibility
+    x = np.random.normal(0, 1, 500)
+    y = x + np.random.normal(0, 0.5, 500)
+    
+    # Plot with ID for tracking
+    ax.plot_scatter_hist(x, y, hist_bins=30, scatter_alpha=0.7, id="scatter_hist_test")
+    
+    # Style the plot
+    ax.set_xyt("X Values", "Y Values", "Scatter Histogram Test")
+    
+    # Save both image and data
+    save_path = os.path.join(OUTPUT_DIR, "scatter_hist_test.png")
+    scitex.io.save(fig, save_path)
+    
+    # Verify CSV was created
+    csv_path = save_path.replace(".png", ".csv")
+    assert os.path.exists(csv_path), f"CSV file not created: {csv_path}"
+    
+    # Read CSV and verify contents
+    df = pd.read_csv(csv_path)
+    assert not df.empty, "CSV file is empty"
+    
+    # Close figure
+    scitex.plt.close(fig)
+    print("✓ plot_scatter_hist test successful")
+
+def test_plot_violin():
+    """Test violin plotting and CSV export."""
+    print("Testing plot_violin...")
+    
+    # Create figure
+    fig, ax = scitex.plt.subplots()
+    
+    # Generate data
+    np.random.seed(42)  # For reproducibility
+    data = [
+        np.random.normal(0, 1, 100),
+        np.random.normal(2, 1.5, 100),
+        np.random.normal(5, 0.8, 100),
+    ]
+    labels = ["Group A", "Group B", "Group C"]
+    
+    # Plot with ID for tracking
+    ax.plot_violin(data, labels=labels, colors=["red", "blue", "green"], id="violin_test")
+    
+    # Style the plot
+    ax.set_xyt("Groups", "Values", "Violin Plot Test")
+    
+    # Save both image and data
+    save_path = os.path.join(OUTPUT_DIR, "violin_test.png")
+    scitex.io.save(fig, save_path)
+    
+    # Verify CSV was created
+    csv_path = save_path.replace(".png", ".csv")
+    assert os.path.exists(csv_path), f"CSV file not created: {csv_path}"
+    
+    # Read CSV and verify contents
+    df = pd.read_csv(csv_path)
+    assert not df.empty, "CSV file is empty"
+    
+    # Close figure
+    scitex.plt.close(fig)
+    print("✓ plot_violin test successful")
+
+def test_plot_heatmap():
+    """Test heatmap plotting and CSV export."""
+    print("Testing plot_heatmap...")
+    
+    # Create figure
+    fig, ax = scitex.plt.subplots()
+    
+    # Generate data
+    np.random.seed(42)  # For reproducibility
+    data = np.random.rand(5, 10)
+    x_labels = [f"X{ii+1}" for ii in range(5)]
+    y_labels = [f"Y{ii+1}" for ii in range(10)]
+    
+    # Plot with ID for tracking
+    ax.plot_heatmap(
+        data,
+        x_labels=x_labels,
+        y_labels=y_labels,
+        cbar_label="Values",
+        show_annot=True,
+        value_format="{x:.2f}",
+        cmap="viridis",
+        id="heatmap_test",
+    )
+    
+    # Style the plot
+    ax.set_title("Heatmap Test")
+    
+    # Save both image and data
+    save_path = os.path.join(OUTPUT_DIR, "heatmap_test.png")
+    scitex.io.save(fig, save_path)
+    
+    # Verify CSV was created
+    csv_path = save_path.replace(".png", ".csv")
+    assert os.path.exists(csv_path), f"CSV file not created: {csv_path}"
+    
+    # Read CSV and verify contents
+    df = pd.read_csv(csv_path)
+    assert not df.empty, "CSV file is empty"
+    
+    # Close figure
+    scitex.plt.close(fig)
+    print("✓ plot_heatmap test successful")
+
+def test_plot_ecdf():
+    """Test ECDF plotting and CSV export."""
+    print("Testing plot_ecdf...")
+    
+    # Create figure
+    fig, ax = scitex.plt.subplots()
+    
+    # Generate data
+    np.random.seed(42)  # For reproducibility
+    data = np.random.normal(0, 1, 1000)
+    
+    # Plot with ID for tracking
+    ax.plot_ecdf(data, label="Normal Distribution", id="ecdf_test")
+    
+    # Style the plot
+    ax.set_xyt("Value", "Cumulative Probability", "ECDF Test")
+    ax.legend()
+    
+    # Save both image and data
+    save_path = os.path.join(OUTPUT_DIR, "ecdf_test.png")
+    scitex.io.save(fig, save_path)
+    
+    # Verify CSV was created
+    csv_path = save_path.replace(".png", ".csv")
+    assert os.path.exists(csv_path), f"CSV file not created: {csv_path}"
+    
+    # Read CSV and verify contents
+    df = pd.read_csv(csv_path)
+    assert not df.empty, "CSV file is empty"
+    
+    # Close figure
+    scitex.plt.close(fig)
+    print("✓ plot_ecdf test successful")
+
+def test_multiple_plots():
+    """Test multiple plots on the same axis."""
+    print("Testing multiple plots on the same axis...")
+    
+    # Create figure
+    fig, ax = scitex.plt.subplots()
+    
+    # Generate data
+    np.random.seed(42)  # For reproducibility
+    x = np.linspace(0, 10, 100)
+    y1 = np.sin(x)
+    y2 = np.cos(x)
+    
+    # Create multiple plots with different IDs
+    ax.plot_line(y1, label="Sine", id="multi_test_sine")
+    ax.plot_line(y2, label="Cosine", id="multi_test_cosine")
+    
+    # Style the plot
+    ax.set_xyt("X", "Y", "Multiple Plots Test")
+    ax.legend()
+    
+    # Save both image and data
+    save_path = os.path.join(OUTPUT_DIR, "multiple_plots_test.png")
+    scitex.io.save(fig, save_path)
+    
+    # Verify CSV was created
+    csv_path = save_path.replace(".png", ".csv")
+    assert os.path.exists(csv_path), f"CSV file not created: {csv_path}"
+    
+    # Read CSV and verify contents
+    df = pd.read_csv(csv_path)
+    assert not df.empty, "CSV file is empty"
+    
+    # Check that both plots are in the CSV
+    sine_cols = [col for col in df.columns if col.startswith("multi_test_sine")]
+    cosine_cols = [col for col in df.columns if col.startswith("multi_test_cosine")]
+    assert len(sine_cols) > 0, "Sine plot data not found in CSV"
+    assert len(cosine_cols) > 0, "Cosine plot data not found in CSV"
+    
+    # Close figure
+    scitex.plt.close(fig)
+    print("✓ Multiple plots test successful")
+
+if __name__ == "__main__":
+    print("Starting formatter verification tests...")
+    test_all_formatters()
+    print("\nAll formatter tests completed successfully!")
+    print(f"Output files are in: {OUTPUT_DIR}")

scitex/plt/_subplots/_export_as_csv_formatters.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-18 18:14:26 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/plt/_subplots/_export_as_csv_formatters.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/_subplots/_export_as_csv_formatters.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+# Import formatters from the submodule
+from scitex.plt._subplots._export_as_csv_formatters import (
+    # Standard matplotlib formatters
+    _format_plot,
+    _format_scatter,
+    _format_bar,
+    _format_barh,
+    _format_hist,
+    _format_boxplot,
+    _format_contour,
+    _format_errorbar,
+    _format_eventplot,
+    _format_fill,
+    _format_fill_between,
+    _format_imshow,
+    _format_imshow2d,
+    _format_violin,
+    _format_violinplot,
+    
+    # Custom plotting formatters
+    _format_plot_box,
+    _format_plot_conf_mat,
+    _format_plot_ecdf,
+    _format_plot_fillv,
+    _format_plot_heatmap,
+    _format_plot_image,
+    _format_plot_joyplot,
+    _format_plot_kde,
+    _format_plot_line,
+    _format_plot_mean_ci,
+    _format_plot_mean_std,
+    _format_plot_median_iqr,
+    _format_plot_raster,
+    _format_plot_rectangle,
+    _format_plot_scatter_hist,
+    _format_plot_shaded_line,
+    _format_plot_violin,
+    
+    # Seaborn formatters
+    _format_sns_barplot,
+    _format_sns_boxplot,
+    _format_sns_heatmap,
+    _format_sns_histplot,
+    _format_sns_jointplot,
+    _format_sns_kdeplot,
+    _format_sns_lineplot,
+    _format_sns_pairplot,
+    _format_sns_scatterplot,
+    _format_sns_stripplot,
+    _format_sns_swarmplot,
+    _format_sns_violinplot,
+)
+
+def main():
+    # Line
+    import scitex
+    import matplotlib.pyplot as plt
+    
+    fig, ax = scitex.plt.subplots()
+    ax.plot([1, 2, 3], [4, 5, 6], id="plot1")
+    ax.plot([4, 5, 6], [1, 2, 3], id="plot2")
+    scitex.io.save(fig, "./plots.png")
+    scitex.io.save(ax.export_as_csv(), "./plots.csv")
+
+    # No tracking
+    fig, ax = scitex.plt.subplots(track=False)
+    ax.plot([1, 2, 3], [4, 5, 6], id="plot3")
+    ax.plot([4, 5, 6], [1, 2, 3], id="plot4")
+    scitex.io.save(fig, "./plots_wo_tracking.png")
+    scitex.io.save(ax.export_as_csv(), "./plots_wo_tracking.csv")
+
+    # Scatter
+    fig, ax = scitex.plt.subplots()
+    ax.scatter([1, 2, 3], [4, 5, 6], id="scatter1")
+    ax.scatter([4, 5, 6], [1, 2, 3], id="scatter2")
+    scitex.io.save(fig, "./scatters.png")
+    scitex.io.save(ax.export_as_csv(), "./scatters.csv")
+
+    # Box
+    fig, ax = scitex.plt.subplots()
+    ax.boxplot([1, 2, 3], id="boxplot1")
+    scitex.io.save(fig, "./boxplot1.png")
+    scitex.io.save(ax.export_as_csv(), "./boxplot1.csv")
+
+    # Bar
+    fig, ax = scitex.plt.subplots()
+    ax.bar(["A", "B", "C"], [4, 5, 6], id="bar1")
+    scitex.io.save(fig, "./bar1.png")
+    scitex.io.save(ax.export_as_csv(), "./bar1.csv")
+
+
+if __name__ == "__main__":
+    # Main
+    import sys
+    import scitex
+
+    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.gen.start(
+        sys, plt, verbose=False, agg=True
+    )
+    main()
+    scitex.gen.close(CONFIG, verbose=False, notify=False)
+
+# EOF

scitex/plt/_tpl.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-03-31 11:58:28 (ywatanabe)"
+
+import numpy as np
+import termplotlib as tpl
+
+
+def termplot(*args):
+    """
+    Plots given y values against x using termplotlib, or plots a single y array against its indices if x is not provided.
+
+    Parameters:
+    - *args: Accepts either one argument (y values) or two arguments (x and y values).
+
+    Returns:
+    None. Displays the plot in the terminal.
+    """
+    if len(args) == 1:
+        y = args[0]  # [REVISED]
+        x = np.arange(len(y))
+
+    if len(args) == 2:
+        x, y = args
+
+    fig = tpl.figure()
+    fig.plot(x, y)
+    fig.show()