scientific-writer 2.3.1__py3-none-any.whl

scientific_writer/.claude/skills/scientific-schematics/scripts/circuit_generator.py

@@ -0,0 +1,307 @@
+#!/usr/bin/env python3
+"""
+Generate circuit diagrams using Schemdraw.
+
+This script provides a high-level interface for creating publication-quality
+electrical circuit diagrams for scientific papers.
+
+Requirements:
+    pip install schemdraw
+
+Usage:
+    from circuit_generator import CircuitBuilder
+    
+    builder = CircuitBuilder()
+    builder.add_voltage_source('Vs', '5V')
+    builder.add_resistor('R1', '1kΩ')
+    builder.add_capacitor('C1', '10µF')
+    builder.add_ground()
+    builder.save('circuit.pdf')
+"""
+
+import argparse
+from typing import Optional, Dict, Any
+
+try:
+    import schemdraw
+    import schemdraw.elements as elm
+except ImportError:
+    print("Error: schemdraw not installed. Install with: pip install schemdraw")
+    exit(1)
+
+
+class CircuitBuilder:
+    """High-level interface for building circuits with Schemdraw."""
+    
+    def __init__(self, fontsize: int = 10, font: str = 'Arial'):
+        """
+        Initialize circuit builder.
+        
+        Args:
+            fontsize: Font size for labels
+            font: Font family for labels
+        """
+        self.drawing = schemdraw.Drawing(fontsize=fontsize, font=font)
+        self.elements = {}
+        self.last_element = None
+        
+    def add_voltage_source(self, label: str, value: str, 
+                          direction: str = 'down') -> 'CircuitBuilder':
+        """
+        Add a voltage source.
+        
+        Args:
+            label: Element label (e.g., 'Vs')
+            value: Voltage value (e.g., '5V')
+            direction: up, down, left, right
+            
+        Returns:
+            self for chaining
+        """
+        element = self.drawing.add(elm.SourceV().label(f'{label}\\n{value}'))
+        self.elements[label] = element
+        self.last_element = element
+        return self
+    
+    def add_current_source(self, label: str, value: str,
+                          direction: str = 'down') -> 'CircuitBuilder':
+        """Add a current source."""
+        element = self.drawing.add(elm.SourceI().label(f'{label}\\n{value}'))
+        self.elements[label] = element
+        self.last_element = element
+        return self
+    
+    def add_resistor(self, label: str, value: str, 
+                    direction: str = 'right') -> 'CircuitBuilder':
+        """
+        Add a resistor.
+        
+        Args:
+            label: Element label (e.g., 'R1')
+            value: Resistance value (e.g., '1kΩ')
+            direction: up, down, left, right
+        """
+        cmd = getattr(self.drawing.add(elm.Resistor()), direction)
+        element = cmd().label(f'{label}\\n{value}')
+        self.elements[label] = element
+        self.last_element = element
+        return self
+    
+    def add_capacitor(self, label: str, value: str,
+                     direction: str = 'down') -> 'CircuitBuilder':
+        """Add a capacitor."""
+        cmd = getattr(self.drawing.add(elm.Capacitor()), direction)
+        element = cmd().label(f'{label}\\n{value}')
+        self.elements[label] = element
+        self.last_element = element
+        return self
+    
+    def add_inductor(self, label: str, value: str,
+                    direction: str = 'right') -> 'CircuitBuilder':
+        """Add an inductor."""
+        cmd = getattr(self.drawing.add(elm.Inductor()), direction)
+        element = cmd().label(f'{label}\\n{value}')
+        self.elements[label] = element
+        self.last_element = element
+        return self
+    
+    def add_diode(self, label: str, direction: str = 'right') -> 'CircuitBuilder':
+        """Add a diode."""
+        cmd = getattr(self.drawing.add(elm.Diode()), direction)
+        element = cmd().label(label)
+        self.elements[label] = element
+        self.last_element = element
+        return self
+    
+    def add_led(self, label: str, direction: str = 'right') -> 'CircuitBuilder':
+        """Add an LED."""
+        cmd = getattr(self.drawing.add(elm.LED()), direction)
+        element = cmd().label(label)
+        self.elements[label] = element
+        self.last_element = element
+        return self
+    
+    def add_opamp(self, label: str) -> 'CircuitBuilder':
+        """Add an operational amplifier."""
+        element = self.drawing.add(elm.Opamp().label(label))
+        self.elements[label] = element
+        self.last_element = element
+        return self
+    
+    def add_ground(self) -> 'CircuitBuilder':
+        """Add a ground symbol."""
+        element = self.drawing.add(elm.Ground())
+        self.last_element = element
+        return self
+    
+    def add_line(self, direction: str = 'right', 
+                length: Optional[float] = None) -> 'CircuitBuilder':
+        """
+        Add a connecting wire.
+        
+        Args:
+            direction: up, down, left, right
+            length: Optional line length
+        """
+        line = elm.Line()
+        cmd = getattr(line, direction)
+        if length:
+            element = self.drawing.add(cmd(length))
+        else:
+            element = self.drawing.add(cmd())
+        self.last_element = element
+        return self
+    
+    def add_dot(self, label: Optional[str] = None) -> 'CircuitBuilder':
+        """Add a connection dot (for junctions)."""
+        element = self.drawing.add(elm.Dot())
+        if label:
+            element.label(label)
+        self.last_element = element
+        return self
+    
+    def push(self) -> 'CircuitBuilder':
+        """Save current position (push to stack)."""
+        self.drawing.push()
+        return self
+    
+    def pop(self) -> 'CircuitBuilder':
+        """Return to saved position (pop from stack)."""
+        self.drawing.pop()
+        return self
+    
+    def save(self, filename: str, dpi: int = 300):
+        """
+        Save circuit diagram.
+        
+        Args:
+            filename: Output filename (.pdf, .svg, .png)
+            dpi: Resolution for raster outputs
+        """
+        if filename.endswith('.png'):
+            self.drawing.save(filename, dpi=dpi)
+        else:
+            self.drawing.save(filename)
+        print(f"Circuit saved to {filename}")
+    
+    def show(self):
+        """Display circuit (for interactive use)."""
+        self.drawing.draw()
+
+
+def create_rc_filter(output: str = 'rc_filter.pdf'):
+    """Create an RC low-pass filter circuit."""
+    builder = CircuitBuilder()
+    
+    # Input
+    builder.add_dot('$V_{in}$')
+    builder.add_resistor('R', '1kΩ', 'right')
+    
+    # Junction
+    builder.add_dot()
+    builder.push()
+    
+    # Capacitor to ground
+    builder.add_capacitor('C', '10µF', 'down')
+    builder.add_ground()
+    
+    # Output
+    builder.pop()
+    builder.add_line('right')
+    builder.add_dot('$V_{out}$')
+    
+    builder.save(output)
+    return builder
+
+
+def create_voltage_divider(output: str = 'voltage_divider.pdf'):
+    """Create a voltage divider circuit."""
+    builder = CircuitBuilder()
+    
+    # Voltage source
+    builder.add_voltage_source('$V_s$', '5V', 'down')
+    
+    # First resistor
+    builder.add_resistor('$R_1$', '1kΩ', 'right')
+    
+    # Junction and output
+    builder.add_dot('$V_{out}$')
+    builder.push()
+    
+    # Second resistor to ground
+    builder.add_resistor('$R_2$', '2kΩ', 'down')
+    builder.add_line('left')
+    builder.add_ground()
+    
+    builder.save(output)
+    return builder
+
+
+def create_opamp_amplifier(output: str = 'opamp_circuit.pdf'):
+    """Create a non-inverting amplifier circuit."""
+    builder = CircuitBuilder()
+    
+    # Input
+    builder.add_dot('$V_{in}$')
+    builder.add_line('right', 1)
+    builder.add_opamp('OA1')
+    builder.add_line('right', 1)
+    builder.add_dot('$V_{out}$')
+    
+    builder.save(output)
+    return builder
+
+
+def main():
+    """Command-line interface."""
+    parser = argparse.ArgumentParser(
+        description='Generate circuit diagrams using Schemdraw',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Generate example circuits
+  python circuit_generator.py --example rc_filter
+  python circuit_generator.py --example voltage_divider
+  python circuit_generator.py --example opamp
+  
+  # Custom output
+  python circuit_generator.py --example rc_filter -o my_filter.pdf
+        """
+    )
+    
+    parser.add_argument('--example', 
+                       choices=['rc_filter', 'voltage_divider', 'opamp'],
+                       help='Generate example circuit')
+    parser.add_argument('-o', '--output', 
+                       help='Output filename (default: based on example name)')
+    parser.add_argument('--dpi', type=int, default=300,
+                       help='DPI for PNG output (default: 300)')
+    
+    args = parser.parse_args()
+    
+    if not args.example:
+        parser.print_help()
+        return
+    
+    # Determine output filename
+    if args.output:
+        output = args.output
+    else:
+        output = f"{args.example}.pdf"
+    
+    # Generate circuit
+    if args.example == 'rc_filter':
+        create_rc_filter(output)
+    elif args.example == 'voltage_divider':
+        create_voltage_divider(output)
+    elif args.example == 'opamp':
+        create_opamp_amplifier(output)
+    
+    print(f"\nCircuit diagram saved to: {output}")
+    print("\nTo use in LaTeX:")
+    print(f"  \\includegraphics{{{output}}}")
+
+
+if __name__ == '__main__':
+    main()
+

scientific_writer/.claude/skills/scientific-schematics/scripts/compile_tikz.py

@@ -0,0 +1,292 @@
+#!/usr/bin/env python3
+"""
+Compile TikZ diagrams to PDF and PNG.
+
+This script provides a convenient interface for compiling standalone TikZ
+files to various output formats, with options for preview and cleanup.
+
+Requirements:
+    - pdflatex (from TeX distribution)
+    - convert (ImageMagick, for PNG output)
+
+Usage:
+    python compile_tikz.py diagram.tex
+    python compile_tikz.py diagram.tex --png --dpi 300
+    python compile_tikz.py diagram.tex --preview
+"""
+
+import argparse
+import os
+import subprocess
+import sys
+import tempfile
+import shutil
+from pathlib import Path
+from typing import Optional, List
+
+
+class TikZCompiler:
+    """Compile TikZ diagrams to various formats."""
+    
+    def __init__(self, verbose: bool = False):
+        """
+        Initialize compiler.
+        
+        Args:
+            verbose: Print detailed output
+        """
+        self.verbose = verbose
+        
+    def _run_command(self, cmd: List[str], cwd: Optional[str] = None) -> bool:
+        """Run a command and return success status."""
+        if self.verbose:
+            print(f"Running: {' '.join(cmd)}")
+        
+        try:
+            result = subprocess.run(
+                cmd, 
+                cwd=cwd,
+                stdout=subprocess.PIPE if not self.verbose else None,
+                stderr=subprocess.PIPE if not self.verbose else None,
+                text=True
+            )
+            
+            if result.returncode != 0:
+                if not self.verbose and result.stderr:
+                    print(f"Error: {result.stderr}")
+                return False
+            return True
+            
+        except FileNotFoundError:
+            print(f"Error: Command not found: {cmd[0]}")
+            return False
+        except Exception as e:
+            print(f"Error running command: {e}")
+            return False
+    
+    def compile_to_pdf(self, tex_file: str, output: Optional[str] = None,
+                      cleanup: bool = True) -> Optional[str]:
+        """
+        Compile TikZ file to PDF.
+        
+        Args:
+            tex_file: Input .tex file
+            output: Output .pdf filename (default: same as input)
+            cleanup: Remove auxiliary files
+            
+        Returns:
+            Path to output PDF if successful, None otherwise
+        """
+        tex_path = Path(tex_file).resolve()
+        
+        if not tex_path.exists():
+            print(f"Error: File not found: {tex_file}")
+            return None
+        
+        # Determine output path
+        if output:
+            pdf_path = Path(output).resolve()
+        else:
+            pdf_path = tex_path.with_suffix('.pdf')
+        
+        # Create temporary directory for compilation
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Copy tex file to temp directory
+            temp_tex = Path(tmpdir) / tex_path.name
+            shutil.copy(tex_path, temp_tex)
+            
+            # Copy any additional files (tikz_styles.tex, etc.)
+            for aux_file in tex_path.parent.glob('*.tex'):
+                if aux_file != tex_path:
+                    shutil.copy(aux_file, tmpdir)
+            
+            # Compile with pdflatex
+            print(f"Compiling {tex_path.name} to PDF...")
+            
+            # Run pdflatex (may need to run twice for references)
+            for i in range(2):
+                success = self._run_command(
+                    ['pdflatex', '-interaction=nonstopmode', temp_tex.name],
+                    cwd=tmpdir
+                )
+                
+                if not success:
+                    print(f"Compilation failed (pass {i+1}/2)")
+                    if i == 1:  # Only fail on second pass
+                        return None
+            
+            # Copy PDF to output location
+            temp_pdf = temp_tex.with_suffix('.pdf')
+            if temp_pdf.exists():
+                shutil.copy(temp_pdf, pdf_path)
+                print(f"✓ PDF created: {pdf_path}")
+                return str(pdf_path)
+            else:
+                print("Error: PDF not created")
+                return None
+    
+    def pdf_to_png(self, pdf_file: str, output: Optional[str] = None,
+                   dpi: int = 300) -> Optional[str]:
+        """
+        Convert PDF to PNG using ImageMagick.
+        
+        Args:
+            pdf_file: Input PDF file
+            output: Output PNG filename (default: same as input)
+            dpi: Resolution in DPI
+            
+        Returns:
+            Path to output PNG if successful, None otherwise
+        """
+        pdf_path = Path(pdf_file)
+        
+        if not pdf_path.exists():
+            print(f"Error: PDF not found: {pdf_file}")
+            return None
+        
+        # Determine output path
+        if output:
+            png_path = Path(output)
+        else:
+            png_path = pdf_path.with_suffix('.png')
+        
+        print(f"Converting to PNG ({dpi} DPI)...")
+        
+        # Use ImageMagick convert
+        success = self._run_command([
+            'convert',
+            '-density', str(dpi),
+            '-quality', '100',
+            str(pdf_path),
+            '-flatten',  # Remove transparency
+            str(png_path)
+        ])
+        
+        if success and png_path.exists():
+            print(f"✓ PNG created: {png_path}")
+            return str(png_path)
+        else:
+            print("Error: PNG conversion failed")
+            print("Hint: Make sure ImageMagick is installed")
+            return None
+    
+    def preview_pdf(self, pdf_file: str) -> bool:
+        """
+        Open PDF in system viewer.
+        
+        Args:
+            pdf_file: PDF file to preview
+            
+        Returns:
+            True if successful
+        """
+        pdf_path = Path(pdf_file)
+        
+        if not pdf_path.exists():
+            print(f"Error: PDF not found: {pdf_file}")
+            return False
+        
+        print(f"Opening {pdf_path.name}...")
+        
+        # Determine system-specific open command
+        if sys.platform == 'darwin':  # macOS
+            cmd = ['open', str(pdf_path)]
+        elif sys.platform.startswith('linux'):  # Linux
+            cmd = ['xdg-open', str(pdf_path)]
+        elif sys.platform == 'win32':  # Windows
+            cmd = ['start', str(pdf_path)]
+        else:
+            print(f"Error: Unsupported platform: {sys.platform}")
+            return False
+        
+        return self._run_command(cmd)
+
+
+def main():
+    """Command-line interface."""
+    parser = argparse.ArgumentParser(
+        description='Compile TikZ diagrams to PDF and PNG',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Compile to PDF
+  python compile_tikz.py diagram.tex
+  
+  # Compile to PDF and PNG
+  python compile_tikz.py diagram.tex --png --dpi 300
+  
+  # Compile and preview
+  python compile_tikz.py diagram.tex --preview
+  
+  # Custom output filenames
+  python compile_tikz.py diagram.tex -o my_diagram.pdf
+  python compile_tikz.py diagram.tex --png --png-output my_diagram.png
+  
+  # Verbose output
+  python compile_tikz.py diagram.tex --verbose
+        """
+    )
+    
+    parser.add_argument('input', help='Input .tex file')
+    parser.add_argument('-o', '--output', help='Output PDF filename')
+    parser.add_argument('--png', action='store_true', 
+                       help='Also generate PNG')
+    parser.add_argument('--png-output', help='PNG output filename')
+    parser.add_argument('--dpi', type=int, default=300,
+                       help='DPI for PNG output (default: 300)')
+    parser.add_argument('--preview', action='store_true',
+                       help='Open PDF after compilation')
+    parser.add_argument('--no-cleanup', action='store_true',
+                       help='Keep auxiliary files')
+    parser.add_argument('-v', '--verbose', action='store_true',
+                       help='Verbose output')
+    
+    args = parser.parse_args()
+    
+    # Check input file
+    if not Path(args.input).exists():
+        print(f"Error: Input file not found: {args.input}")
+        sys.exit(1)
+    
+    if not args.input.endswith('.tex'):
+        print("Warning: Input file doesn't have .tex extension")
+    
+    # Initialize compiler
+    compiler = TikZCompiler(verbose=args.verbose)
+    
+    # Compile to PDF
+    pdf_file = compiler.compile_to_pdf(
+        args.input,
+        output=args.output,
+        cleanup=not args.no_cleanup
+    )
+    
+    if not pdf_file:
+        print("\n❌ Compilation failed")
+        sys.exit(1)
+    
+    # Convert to PNG if requested
+    if args.png:
+        png_file = compiler.pdf_to_png(
+            pdf_file,
+            output=args.png_output,
+            dpi=args.dpi
+        )
+        
+        if not png_file:
+            print("\n⚠ PDF created but PNG conversion failed")
+    
+    # Preview if requested
+    if args.preview:
+        compiler.preview_pdf(pdf_file)
+    
+    print("\n✓ Done!")
+    print(f"\nTo use in LaTeX:")
+    print(f"  \\input{{{Path(pdf_file).stem}.tex}}")
+    print(f"  or")
+    print(f"  \\includegraphics{{{Path(pdf_file).name}}}")
+
+
+if __name__ == '__main__':
+    main()
+