myplot 0.1.0__py3-none-any.whl

myplot/README.md

@@ -0,0 +1,98 @@
+# MyPlot - Uniform Plotting Module for Matplotlib
+
+A Python module for creating publication-quality matplotlib plots with automatic font detection and consistent formatting.
+
+## Features
+
+- **Automatic Font Detection**: Searches for Source Han Serif font across system paths and project directories
+- **Cross-platform Support**: Works on Windows, macOS, and Linux
+- **Consistent Formatting**: Pre-configured plot styling parameters
+- **Flexible Configuration**: Platform-specific configuration directories
+- **Utility Functions**: Formatters for radians, degrees, and dB values
+- **Easy Integration**: Simple decorator for creating plots
+
+## Installation
+
+```bash
+# Install dependencies
+pip install matplotlib numpy
+
+# For development/testing (optional)
+pip install hatch
+```
+
+## Usage
+
+### Basic Plotting
+
+```python
+from myplot import myplot, plt, np
+
+@myplot()
+def my_function():
+    x = np.linspace(0, 10, 100)
+    y = np.sin(x)
+    plt.plot(x, y)
+    plt.xlabel('x')
+    plt.ylabel('sin(x)')
+    plt.title('Sine Wave')
+```
+
+### Custom Figure Size and Save Options
+
+```python
+@myplot(figsize=(8, 6), save=True, log=True)
+def custom_plot():
+    # Your plotting code here
+    pass
+```
+
+### Utilities
+
+```python
+from myplot import myUtilities
+
+# Use custom formatters
+ax.xaxis.set_major_formatter(myUtilities.radFormatter())
+ax.xaxis.set_major_formatter(myUtilities.degFormatter())
+ax.xaxis.set_major_formatter(myUtilities.dBFormatter())
+
+# Use custom locator
+ax.xaxis.set_major_locator(myUtilities.radLocator())
+```
+
+### Configuration
+
+The module uses platform-specific configuration directories:
+- **Windows**: `%USERPROFILE%\AppData\Local\myplot\`
+- **macOS**: `~/Library/Application Support/myplot/`
+- **Linux**: `~/.config/myplot/`
+
+## Font Detection
+
+The module automatically searches for Source Han Serif font in:
+- System font directories
+- User font directories
+- Project local directories (fonts/, resources/fonts/, src/fonts/)
+- Current directory
+
+## Testing
+
+Run the test suite:
+
+```bash
+python minimal_test.py
+python test_myplot.py
+```
+
+## Development
+
+To install in development mode:
+
+```bash
+pip install -e .
+```
+
+## License
+
+MIT License

myplot/__init__.py

@@ -0,0 +1,427 @@
+"""
+MyPlot - A uniform plotting module for matplotlib with proper font handling.
+
+This module provides decorators and utilities for creating publication-quality plots
+with consistent formatting and automatic font detection.
+"""
+
+import platform
+import matplotlib.pyplot as plt
+import matplotlib.font_manager as fm
+import matplotlib.ticker as ticker
+import numpy as np
+import functools
+import sys
+import builtins
+from pathlib import Path
+import json
+import os
+
+__all__ = ['myplot', 'plt', 'np', 'myparams', 'myUtilities']
+
+
+class myparams:
+    """Configuration parameter manager with JSON storage."""
+
+    def __init__(self, file="myplot_params.json", config_dir=None):
+        if config_dir:
+            config_path = Path(config_dir)
+        else:
+            # Use platform-specific configuration directories
+            if platform.system() == 'Windows':
+                config_path = Path.home() / 'AppData' / 'Local' / 'myplot'
+            elif platform.system() == 'Darwin':  # macOS
+                config_path = Path.home() / 'Library' / 'Application Support' / 'myplot'
+            else:  # Linux and other Unix-like systems
+                config_path = Path.home() / '.config' / 'myplot'
+
+        self.f = config_path / file
+        self.f.parent.mkdir(parents=True, exist_ok=True)
+
+        try:
+            with open(self.f, 'r') as ff:
+                self.p = json.load(ff)
+        except (FileNotFoundError, json.JSONDecodeError):
+            self.p = {}
+
+    def get(self, key):
+        return self.p.get(key)
+
+    def put(self, arg: dict = None, **kwargs):
+        d = (arg or {}) | (kwargs or {})
+        for k in d:
+            self.p[k] = d[k]
+        self.update()
+
+    def update(self):
+        with open(self.f, 'w') as ff:
+            json.dump(self.p, ff, indent=4)
+
+    def __getitem__(self, key):
+        return self.get(key)
+
+    def __setitem__(self, key, value):
+        self.put({key: value})
+
+    def __delitem__(self, key):
+        if key in self.p:
+            del self.p[key]
+            self.update()
+
+    def __contains__(self, key):
+        return key in self.p
+
+
+def get_font_search_paths():
+    """Get platform-specific font search paths."""
+    system = platform.system()
+    paths = []
+
+    # Add system font paths
+    if system == 'Windows':
+        system_font_dirs = [
+            Path('C:/Windows/Fonts'),
+            Path('C:/Windows/Fonts/simhei'),  # Chinese fonts
+        ]
+        if 'LOCALAPPDATA' in os.environ:
+            user_font_dir = Path(os.environ['LOCALAPPDATA']) / 'Microsoft' / 'Windows' / 'Fonts'
+            if user_font_dir.exists():
+                paths.append(user_font_dir)
+
+    elif system == 'Darwin':  # macOS
+        system_font_dirs = [
+            Path('/System/Library/Fonts'),
+            Path('/System/Library/Fonts/ChineseSimplified'),
+            Path('/Library/Fonts'),
+            Path('/Library/Fonts/ChineseSimplified'),
+        ]
+        user_font_dir = Path.home() / 'Library' / 'Fonts'
+        if user_font_dir.exists():
+            paths.append(user_font_dir)
+    else:  # Linux
+        system_font_dirs = [
+            Path('/usr/share/fonts'),
+            Path('/usr/share/fonts/truetype'),
+            Path('/usr/share/fonts/opentype'),
+            Path('/usr/share/fonts/truetype/freefont'),
+            Path('/usr/share/fonts/opentype/noto'),
+        ]
+        user_font_dir = Path.home() / '.local' / 'share' / 'fonts'
+        if user_font_dir.exists():
+            paths.append(user_font_dir)
+
+    # Add existing system font directories
+    for font_dir in system_font_dirs:
+        if font_dir.exists():
+            paths.append(font_dir)
+
+    # Add current directory and relative paths (for local font files)
+    current_dir = Path.cwd()
+    paths.extend([
+        current_dir,
+        current_dir / 'fonts',
+        current_dir / 'resources' / 'fonts',
+        current_dir / 'src' / 'fonts',
+    ])
+
+    return paths
+
+
+def find_source_han_serif_font():
+    """Find Source Han Serif font across multiple search paths."""
+    font_names_variants = [
+        'SourceHanSerifSC-Medium.otf',
+        'SourceHanSerif-Medium.otf',
+        'SourceHanSerifSC-Regular.otf',
+        'SourceHanSerif-Regular.otf',
+        'SourceHanSerif-Heavy.otf',
+        'NotoSerifCJK-Regular.otf',  # Alternative
+        'NotoSerifCJK-Medium.otf',   # Alternative
+        'NotoSerifCJK-SC-Regular.otf',
+        'NotoSerifCJK-TC-Regular.otf'
+    ]
+
+    # Search in all possible paths
+    search_paths = get_font_search_paths()
+
+    print(f"Searching in {len(search_paths)} paths:")
+    for i, path in enumerate(search_paths, 1):
+        print(f"  {i}. {path}")
+
+    # First, try to find font files in the directory
+    for font_variant in font_names_variants:
+        for search_path in search_paths:
+            font_path = search_path / font_variant
+            if font_path.exists():
+                print(f"Found font file: {font_path}")
+                return font_path.resolve()
+
+    # Second, check matplotlib's known fonts
+    print("\nChecking matplotlib's known fonts...")
+    font_list = fm.findSystemFonts()
+    for font_file in font_list:
+        font_name = Path(font_file).name
+        for font_variant in font_names_variants:
+            if font_variant.lower() in font_name.lower():
+                font_path = Path(font_file).resolve()
+                print(f"Found font in system: {font_path}")
+                return font_path
+
+    # Check if any font variant is already registered
+    print("\nChecking registered fonts...")
+    try:
+        for font_variant in font_names_variants:
+            font_list = fm.findSystemFonts()
+            for font_file in font_list:
+                try:
+                    font_obj = fm.FontProperties(fname=font_file)
+                    font_name = font_obj.get_name()
+                    if ('source' in font_name.lower() and 'serif' in font_name.lower()) or \
+                       font_variant.replace('.otf', '') in font_name.replace(' ', ''):
+                        font_path = Path(font_file).resolve()
+                        print(f"Found matching font: {font_path}")
+                        print(f"  Font name: {font_name}")
+                        return font_path
+                except Exception:
+                    continue
+    except Exception as e:
+        print(f"Error checking fonts: {e}")
+
+    print('⚠ Cannot find Source Han Serif font, using default settings')
+    return None
+
+
+def setup_font_properties():
+    """Setup matplotlib font properties if Source Han Serif is found."""
+    font_path = find_source_han_serif_font()
+
+    if font_path:
+        try:
+            # Force register the font
+            fontManager = fm.fontManager
+            fontManager.addfont(str(font_path))
+
+            # Create font properties
+            font_prop = fm.FontProperties(fname=str(font_path))
+            font_name = font_prop.get_name()
+            print(f"Font file found: {font_path}")
+            print(f"Font name detected: {font_name}")
+
+            # Try multiple possible family names
+            possible_families = [
+                'Source Han Serif',
+                'Source Han Serif SC',
+                'Source Han Serif TC',
+                'Noto Serif CJK SC',
+                'Noto Serif CJK'
+            ]
+
+            # Set matplotlib font configuration
+            plt.rcParams['mathtext.fontset'] = 'stix'
+            plt.rcParams['axes.unicode_minus'] = False
+            plt.rcParams['font.family'] = 'sans-serif'  # fallback
+            plt.rcParams['font.sans-serif'] = ['Source Han Serif'] + plt.rcParams['font.sans-serif']
+
+            # Manually set the font for the current session
+            try:
+                # Try to find the correct family name from the registered font
+                for family in possible_families:
+                    if family in fontManager.get_font_names():
+                        plt.rcParams['font.family'] = family
+                        plt.rcParams['font.sans-serif'] = [family] + plt.rcParams['font.sans-serif']
+                        print(f"Set font family to: {family}")
+                        break
+            except Exception as e:
+                print(f"Note: Could not set font family explicitly: {e}")
+
+            return True
+        except Exception as e:
+            print(f"Error setting up font: {e}")
+            return False
+    return False
+
+
+# Initialize font setup
+setup_successful = setup_font_properties()
+myparams.font = None
+
+# Load the font into myparams if setup was successful
+if setup_successful:
+    font_path = find_source_han_serif_font()
+    if font_path:
+        try:
+            myparams.font = fm.FontProperties(fname=str(font_path))
+            print("Font loaded into myparams")
+        except Exception as e:
+            print(f"Could not load font into myparams: {e}")
+
+# Character size settings
+plt.rcParams['font.size'] = 9
+plt.rcParams['axes.titlesize'] = 11
+plt.rcParams['axes.labelsize'] = 10
+plt.rcParams['xtick.labelsize'] = 9
+plt.rcParams['ytick.labelsize'] = 9
+plt.rcParams['lines.linewidth'] = 1.2
+plt.rcParams['lines.markersize'] = 4
+plt.rcParams['errorbar.capsize'] = 3
+elinewidth = 0.8
+
+
+def myplot(figsize=(4.8, 3.6), save=True, log=True, savename='', config_dir=None):
+    """
+    Decorator for creating uniformly formatted matplotlib plots.
+
+    Args:
+        figsize: Figure size in inches (width, height)
+        save: Whether to save the figure
+        log: Whether to log plot creation
+        savename: Filename for saved figure (defaults to function name)
+        config_dir: Directory for configuration files (optional)
+
+    Returns:
+        Decorator function
+    """
+    def decorator(func):
+        @functools.wraps(func)
+        def wrap(*args, **kwargs):
+            # Process keyword arguments
+            recfg_list = ['figsize', 'save', 'log', 'savename', 'config_dir']
+            p = {}
+            for rec in recfg_list:
+                if rec in kwargs:
+                    p[rec] = kwargs[rec]
+                    del kwargs[rec]
+                else:
+                    p[rec] = {
+                        'figsize': figsize,
+                        'save': save,
+                        'log': log,
+                        'savename': savename or func.__name__,
+                        'config_dir': config_dir
+                    }.get(rec)
+
+            # Setup plot environment
+            plt.figure(figsize=p['figsize'])
+            biprint = builtins.print
+
+            # Setup logging and save paths
+            if p['log'] or p['save']:
+                # Determine save directories
+                if p['config_dir']:
+                    base_path = Path(p['config_dir'])
+                else:
+                    # Use platform-specific directories
+                    if platform.system() == 'Windows':
+                        base_path = Path.home() / 'Documents' / 'MyPlots'
+                    elif platform.system() == 'Darwin':  # macOS
+                        base_path = Path.home() / 'Documents' / 'MyPlots'
+                    else:  # Linux
+                        base_path = Path.home() / 'Documents' / 'MyPlots'
+
+                stats_dir = base_path / 'stats'
+                imags_dir = base_path / 'images'
+
+                stats_dir.mkdir(parents=True, exist_ok=True)
+                imags_dir.mkdir(parents=True, exist_ok=True)
+
+                if p['log'] and p['save']:
+                    logpath = stats_dir / f"{p['savename']}.txt"
+                    with open(logpath, 'w') as f:
+                        pass
+                    biprint(f"{p['savename']} created stats into path:\n{logpath.absolute()}")
+                    builtins.print = myprint(logpath)(biprint)
+
+            # Call parent function
+            result = func(*args, **kwargs)
+
+            # Cleanup
+            plt.tight_layout()
+            builtins.print = biprint
+            if p['save']:
+                pltpath = imags_dir / f"{p['savename']}.png"
+                pltpath.parent.mkdir(parents=True, exist_ok=True)
+                plt.savefig(pltpath, dpi=400, bbox_inches='tight')
+                print(f"{p['savename']} saved figure into path:\n{pltpath.absolute()}")
+            plt.show()
+            return result
+
+        return wrap
+    return decorator
+
+
+def myprint(target):
+    """Decorator for redirecting print output to a file."""
+    def decorator(func):
+        def wrap(*args, **kwargs):
+            temp = sys.stdout
+            try:
+                with open(target, 'a') as f:
+                    sys.stdout = f
+                    func(*args, **kwargs)
+            finally:
+                sys.stdout = temp
+        return wrap
+    return decorator
+
+
+# Override errorbar with custom line width
+def _myerrorbar(errorbar):
+    def wrap(*args, **kwargs):
+        if 'elinewidth' not in kwargs:
+            kwargs['elinewidth'] = elinewidth
+        return errorbar(*args, **kwargs)
+    return wrap
+
+
+plt.errorbar = _myerrorbar(plt.errorbar)
+plt.Axes.errorbar = _myerrorbar(plt.Axes.errorbar)
+
+
+class myUtilities:
+    """Utility functions for plot formatting."""
+
+    @staticmethod
+    def radFormatter(dig='.2f'):
+        """Create radian tick formatter (e.g., 0.5π)."""
+        return ticker.FuncFormatter(lambda x, pos: f"{x / np.pi:{dig}}π")
+
+    @staticmethod
+    def degFormatter(dig='1.0f'):
+        """Create degree tick formatter (e.g., 90°)."""
+        return ticker.FuncFormatter(lambda x, pos: f"{x:{dig}}°")
+
+    @staticmethod
+    def dBFormatter(dig='1.2f'):
+        """Create dB tick formatter."""
+        return ticker.FuncFormatter(lambda x, pos: f"{x:{dig}} dB")
+
+    @staticmethod
+    def radLocator(base=np.pi / 4):
+        """Create radian tick locator."""
+        return ticker.MultipleLocator(base=base)
+
+    @staticmethod
+    def get_available_fonts():
+        """Get list of available fonts."""
+        return fm.findSystemFonts()
+
+    @staticmethod
+    def get_font_properties(font_path):
+        """Get font properties from font file."""
+        return fm.FontProperties(fname=str(font_path))
+
+
+# Examples for documentation
+if __name__ == "__main__":
+    # Test the module
+    print(f"Platform: {platform.system()}")
+    print(f"Font setup successful: {setup_successful}")
+
+    # List some available fonts
+    available_fonts = myUtilities.get_available_fonts()
+    print(f"Found {len(available_fonts)} fonts")
+
+    # Test font finding
+    source_han_font = find_source_han_serif_font()
+    if source_han_font:
+        print(f"Source Han Serif found at: {source_han_font}")

myplot-0.1.0.dist-info/METADATA

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: myplot
+Version: 0.1.0
+Summary: A uniform plotting module for matplotlib with automatic font detection
+Requires-Python: >=3.8
+Requires-Dist: matplotlib>=3.5.0
+Requires-Dist: numpy>=1.20.0
+Description-Content-Type: text/markdown
+
+# MyPlot
+
+A uniform plotting module for matplotlib with automatic font detection and cross-platform support.
+
+## Features
+
+- **Uniform Formatting**: Consistent plot styling across all your projects
+- **Automatic Font Detection**: Finds and configures Source Han Serif font for Chinese characters
+- **Cross-Platform Support**: Works on Windows, macOS, and Linux
+- **Easy to Use**: Simple decorator interface for creating publication-quality plots
+- **Built-in Utilities**: Radian/degree formatters and other plotting utilities
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from myplot import myplot, plt, np
+
+@myplot()
+def simple_plot():
+    x = np.linspace(0, 10, 100)
+    plt.plot(x, np.sin(x))
+    plt.xlabel('x')
+    plt.ylabel('sin(x)')
+    plt.title('Simple Plot')
+
+simple_plot()
+```
+
+## Advanced Usage
+
+### Custom Figure Size
+```python
+@myplot(figsize=(8, 6))
+def large_plot():
+    # Your plotting code here
+    pass
+```
+
+### Save Plots Automatically
+```python
+@myplot(save=True, log=True)
+def save_plot():
+    # Plot will be saved automatically
+    pass
+```
+
+### Using Utilities
+```python
+from myplot import myUtilities
+
+ax.xaxis.set_major_formatter(myUtilities.radFormatter())
+ax.xaxis.set_major_locator(myUtilities.radLocator(np.pi/4))
+```
+
+## Requirements
+
+- Python 3.8+
+- matplotlib >= 3.5.0
+- numpy >= 1.20.0
+
+## License
+
+MIT License

myplot-0.1.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+myplot/README.md,sha256=_lfv96hxr9egsEzmma1SieNolWcDQCrjIm90l3C4PR4,2152
+myplot/__init__.py,sha256=hEohqksp6EjfFkWBn64J4TIE3eTHQIVQoF_bhyrh60U,14532
+myplot-0.1.0.dist-info/METADATA,sha256=OzI1Y8dw-eUlv-bVya6y5E4spUoOJE0tX8uPVz1gRFw,1629
+myplot-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+myplot-0.1.0.dist-info/RECORD,,

myplot-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any