guro 0.1.0__py3-none-any.whl

guro/__init__.py

@@ -0,0 +1,2 @@
+# guro/__init__.py
+__version__ = "1.0.0"

guro/cli/__init__.py

@@ -0,0 +1,4 @@
+# guro/cli/__init__.py
+from .main import cli
+
+__all__ = ['cli']

guro/cli/main.py

@@ -0,0 +1,161 @@
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.prompt import Prompt, Confirm
+from rich import print as rprint
+from typing import Optional
+from ..core.monitor import SystemMonitor
+from ..core.benchmark import SafeSystemBenchmark
+from ..core.heatmap import SystemHeatmap
+
+console = Console()
+
+def print_banner():
+    """Display the Guro banner"""
+    banner = """
+[bold cyan]
+   ██████╗ ██╗   ██╗██████╗  ██████╗ 
+  ██╔════╝ ██║   ██║██╔══██╗██╔═══██╗
+  ██║  ███╗██║   ██║██████╔╝██║   ██║
+  ██║   ██║██║   ██║██╔══██╗██║   ██║
+  ╚██████╔╝╚██████╔╝██║  ██║╚██████╔╝
+   ╚═════╝  ╚═════╝ ╚═╝  ╚═╝ ╚═════╝ 
+[/bold cyan]
+[yellow]A Simple System Monitoring & Benchmarking Toolkit[/yellow]
+    """
+    console.print(banner)
+
+@click.group()
+@click.version_option(version='1.0.0')
+def cli():
+    """🚀 Guro - A Simple System Monitoring & Benchmarking Toolkit"""
+    print_banner()
+
+@cli.command()
+@click.option('--interval', '-i', default=1.0, help='Monitoring interval in seconds')
+@click.option('--duration', '-d', default=None, type=int, help='Monitoring duration in seconds')
+@click.option('--export', '-e', is_flag=True, help='Export monitoring data to CSV')
+def monitor(interval: float, duration: Optional[int], export: bool):
+    """📊 Monitor system resources and performance in real-time"""
+    try:
+        monitor = SystemMonitor()
+        if export:
+            click.echo("📝 Monitoring data will be exported to 'monitoring_data.csv'")
+        
+        with console.status("[bold green]Initializing system monitor..."):
+            monitor.run_performance_test(
+                interval=interval,
+                duration=duration,
+                export_data=export
+            )
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Monitoring stopped by user[/yellow]")
+    except Exception as e:
+        console.print(f"\n[red]Error during monitoring: {str(e)}[/red]")
+
+@cli.command()
+@click.option('--type', '-t', 'test_type',
+              type=click.Choice(['mini', 'god'], case_sensitive=False),
+              help='Type of benchmark test to run')
+@click.option('--gpu-only', is_flag=True, help='Run only GPU benchmark')
+@click.option('--cpu-only', is_flag=True, help='Run only CPU benchmark')
+def benchmark(test_type: str, gpu_only: bool, cpu_only: bool):
+    """🔥 Run system benchmarks"""
+    try:
+        benchmark = SafeSystemBenchmark()
+        
+        if not test_type:
+            test_type = Prompt.ask(
+                "Select benchmark type",
+                choices=["mini", "god"],
+                default="mini"
+            )
+
+        with console.status("[bold green]Preparing benchmark..."):
+            if test_type == "mini":
+                benchmark.mini_test(gpu_only=gpu_only, cpu_only=cpu_only)
+            else:
+                benchmark.god_test(gpu_only=gpu_only, cpu_only=cpu_only)
+
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Benchmark stopped by user[/yellow]")
+    except Exception as e:
+        console.print(Panel(
+            f"[red]Error during benchmark: {str(e)}[/red]",
+            title="⚠️ Benchmark Error",
+            border_style="red"
+        ))
+
+@cli.command()  # Added the cli decorator here
+@click.option('--interval', '-i', 
+              type=click.FloatRange(min=0.1, min_open=False),
+              default=1.0, 
+              help='Update interval in seconds (must be greater than 0.1)')
+@click.option('--duration', '-d', 
+              type=click.IntRange(min=1, min_open=False),
+              default=10, 
+              help='Duration to run in seconds (default: 10)')
+def heatmap(interval: float, duration: int):
+    """🌡️ Display unified system temperature heatmap"""
+    try:
+        heatmap = SystemHeatmap()
+        
+        with console.status("[bold green]Initializing system heatmap..."):
+            updates = heatmap.run(
+                interval=interval,
+                duration=duration
+            )
+            
+        console.print(f"\n[green]Heatmap completed after {updates} updates[/green]")
+            
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Heatmap visualization stopped by user[/yellow]")
+    except Exception as e:
+        console.print(f"[red]Error during heatmap visualization: {str(e)}[/red]")
+
+@cli.command(name='list')
+def list_features():
+    """📋 List all available features and commands"""
+    table = Table(title="Guro Commands and Features")
+    table.add_column("Command", style="cyan")
+    table.add_column("Description", style="green")
+    table.add_column("Options", style="yellow")
+
+    commands = {
+        "monitor": ("📊 Real-time system monitoring", "-i/--interval, -d/--duration, -e/--export"),
+        "benchmark": ("🔥 System benchmarking", "-t/--type [mini/god], --gpu-only, --cpu-only"),
+        "heatmap": ("🌡️ Hardware Heatmap Analysis", "-i/--interval, -d/--duration"),
+        "about": ("ℹ️  About Guro", "None"),
+        "list": ("📋 List all commands", "None")
+    }
+
+    for cmd, (desc, opts) in commands.items():
+        table.add_row(cmd, desc, opts)
+
+    console.print(table)
+
+@cli.command(name='about')
+def about():
+    """ℹ️  Display information about Guro"""
+    about_text = """[bold cyan]Guro - A Simple System Monitoring & Benchmarking Toolkit[/bold cyan]
+        
+[green]Version:[/green] 1.0.0
+[green]Author:[/green] Dhanush Kandhan
+[green]License:[/green] MIT
+        
+🛠️  A Simple powerful toolkit for system monitoring and benchmarking.
+
+[yellow]Key Features:[/yellow]
+• 📊 Real-time system monitoring
+• 💾 Memory management
+• 🔥 Performance benchmarking
+• 🌡️ Hardware Heatmap Analysis
+
+[blue]GitHub:[/blue] https://github.com/dhanushk-offl/guro
+[blue]Documentation:[/blue] https://github.com/dhanushk-offl/guro/wiki"""
+
+    console.print(Panel(about_text, title="About Guro", border_style="blue"))
+
+if __name__ == '__main__':
+    cli()

guro/core/__init__.py

@@ -0,0 +1,3 @@
+# guro/core/__init__.py
+from .monitor import SystemMonitor
+__all__ = ['SystemMonitor']

guro/core/benchmark.py

@@ -0,0 +1,317 @@
+import psutil
+import time
+import numpy as np
+import multiprocessing
+from rich.progress import Progress, SpinnerColumn, TimeElapsedColumn, BarColumn
+from rich.console import Console
+from rich.panel import Panel
+from rich.live import Live
+from rich.table import Table
+import subprocess
+import platform
+from threading import Thread
+import signal
+import sys
+
+try:
+    import GPUtil
+    HAS_GPU_STATS = True
+except ImportError:
+    HAS_GPU_STATS = False
+
+class SafeSystemBenchmark:
+    def __init__(self):
+        self.console = Console()
+        self.results = {}
+        self.running = False
+        self.baseline_scores = {
+            'cpu_single': 2.5,
+            'cpu_multi': 1.0,
+            'gpu_compute': 1.5
+        }
+        # Safety thresholds
+        self.MAX_CPU_USAGE = 80  # Maximum CPU usage percentage
+        self.MAX_MEMORY_USAGE = 80  # Maximum memory usage percentage
+        self.has_gpu = self._check_gpu()
+        
+    def _check_gpu(self):
+        """Check if GPU is available and get GPU information"""
+        gpu_info = {'available': False, 'info': None}
+        
+        if HAS_GPU_STATS:
+            try:
+                gpus = GPUtil.getGPUs()
+                if gpus and len(gpus) > 0:
+                    gpu = gpus[0]  # Get first GPU info
+                    gpu_info['available'] = True
+                    gpu_info['info'] = {
+                        'name': gpu.name,
+                        'count': len(gpus),
+                        'memory_total': gpu.memoryTotal,
+                        'driver_version': gpu.driver
+                    }
+            except Exception:
+                pass
+        return gpu_info
+        
+    def get_system_info(self):
+        """Get basic system information safely"""
+        info = {
+            'system': platform.system(),
+            'processor': platform.processor(),
+            'memory_total': psutil.virtual_memory().total,
+            'cpu_cores': psutil.cpu_count(logical=False),
+            'cpu_threads': psutil.cpu_count(logical=True),
+            'gpu': self.has_gpu
+        }
+        return info
+
+    def safe_gpu_test(self, duration):
+        """Safe GPU benchmark with controlled load"""
+        if not self.has_gpu['available']:
+            return {'times': [], 'loads': [], 'error': 'No GPU available'}
+            
+        result = {'times': [], 'loads': [], 'memory_usage': []}
+        start_time = time.time()
+        
+        try:
+            while time.time() - start_time < duration and self.running:
+                if HAS_GPU_STATS:
+                    gpus = GPUtil.getGPUs()
+                    if gpus and len(gpus) > 0:
+                        gpu = gpus[0]
+                        gpu_load = gpu.load * 100
+                        gpu_memory = gpu.memoryUsed
+                        
+                        result['times'].append(time.time() - start_time)
+                        result['loads'].append(gpu_load)
+                        result['memory_usage'].append(gpu_memory)
+                
+                time.sleep(0.1)
+                    
+        except Exception as e:
+            result['error'] = str(e)
+            
+        return result
+
+    def monitor_resources(self):
+        """Monitor system resources in real-time"""
+        while self.running:
+            cpu_percent = psutil.cpu_percent()
+            memory_percent = psutil.virtual_memory().percent
+            
+            # Safety check
+            if cpu_percent > self.MAX_CPU_USAGE or memory_percent > self.MAX_MEMORY_USAGE:
+                self.running = False
+                self.console.print("[red]Warning: System resource usage too high. Stopping benchmark.[/red]")
+                break
+            
+            time.sleep(0.5)
+
+    def safe_cpu_test(self, duration):
+        """Safe CPU benchmark with controlled load"""
+        start_time = time.time()
+        result = {'times': [], 'loads': []}
+        
+        while time.time() - start_time < duration and self.running:
+            # Matrix operations with controlled size
+            size = 100
+            matrix = np.random.rand(size, size)
+            np.dot(matrix, matrix.T)
+            
+            result['times'].append(time.time() - start_time)
+            result['loads'].append(psutil.cpu_percent())
+            time.sleep(0.1)
+            
+        return result
+
+    def safe_memory_test(self, duration):
+        """Safe memory benchmark"""
+        start_time = time.time()
+        result = {'times': [], 'usage': []}
+        
+        while time.time() - start_time < duration and self.running:
+            memory = psutil.virtual_memory()
+            result['times'].append(time.time() - start_time)
+            result['usage'].append(memory.percent)
+            time.sleep(0.1)
+            
+        return result
+
+    def mini_test(self, gpu_only=False, cpu_only=False):
+        """Run 30-second mini benchmark"""
+        self.running = True
+        duration = 30
+        
+        # Start resource monitoring
+        monitor_thread = Thread(target=self.monitor_resources)
+        monitor_thread.start()
+        
+        with Live(self.generate_status_table(), refresh_per_second=4) as live:
+            self.results = {
+                'system_info': self.get_system_info(),
+                'duration': duration
+            }
+            
+            if not gpu_only:
+                # CPU Test
+                self.results['cpu'] = self.safe_cpu_test(duration/2)
+                # Memory Test
+                self.results['memory'] = self.safe_memory_test(duration/2)
+                
+            if not cpu_only and self.has_gpu['available']:
+                # GPU Test
+                self.results['gpu'] = self.safe_gpu_test(duration/2)
+            
+            live.update(self.generate_status_table())
+        
+        self.running = False
+        monitor_thread.join()
+        self.display_results("Mini-Test")
+
+    def god_test(self, gpu_only=False, cpu_only=False):
+        """Running GOD - LEVEL comprehensive benchmark"""
+        self.running = True
+        duration = 60
+        
+        # Start resource monitoring
+        monitor_thread = Thread(target=self.monitor_resources)
+        monitor_thread.start()
+        
+        with Live(self.generate_status_table(), refresh_per_second=4) as live:
+            self.results = {
+                'system_info': self.get_system_info(),
+                'duration': duration
+            }
+            
+            if not gpu_only:
+                # Extended CPU Test
+                self.results['cpu'] = self.safe_cpu_test(duration/2)
+                # Extended Memory Test
+                self.results['memory'] = self.safe_memory_test(duration/2)
+                
+            if not cpu_only and self.has_gpu['available']:
+                # Extended GPU Test
+                self.results['gpu'] = self.safe_gpu_test(duration/2)
+            
+            live.update(self.generate_status_table())
+        
+        self.running = False
+        monitor_thread.join()
+        self.display_results("God-Test")
+
+    def generate_status_table(self):
+        """Generate real-time status table"""
+        table = Table(title="Benchmark Status")
+        table.add_column("Metric")
+        table.add_column("Value")
+        
+        cpu_percent = psutil.cpu_percent()
+        memory_percent = psutil.virtual_memory().percent
+        
+        table.add_row("CPU Usage", f"{cpu_percent}%")
+        table.add_row("Memory Usage", f"{memory_percent}%")
+        
+        if self.has_gpu['available'] and HAS_GPU_STATS:
+            gpus = GPUtil.getGPUs()
+            if gpus and len(gpus) > 0:
+                gpu = gpus[0]
+                table.add_row("GPU", f"[green]{gpu.name}[/green]")
+                table.add_row("GPU Usage", f"{gpu.load * 100}%")
+                table.add_row("GPU Memory", f"{gpu.memoryUsed} MB / {gpu.memoryTotal} MB")
+                
+        table.add_row("Status", "[green]Running[/green]" if self.running else "[red]Stopped[/red]")
+        
+        return table
+
+    def display_results(self, test_type):
+        """Display benchmark results"""
+        if not self.results:
+            return
+
+        result_text = f"[bold cyan]{test_type} Results[/bold cyan]\n\n"
+        
+        # System Information
+        result_text += "[green]System Information:[/green]\n"
+        sys_info = self.results.get('system_info', {})
+        result_text += f"• System: {sys_info.get('system', 'N/A')}\n"
+        result_text += f"• Processor: {sys_info.get('processor', 'N/A')}\n"
+        result_text += f"• CPU Cores: {sys_info.get('cpu_cores', 'N/A')}\n"
+        result_text += f"• CPU Threads: {sys_info.get('cpu_threads', 'N/A')}\n"
+        
+        # GPU Information
+        gpu_info = sys_info.get('gpu', {})
+        if gpu_info.get('available', False):
+            gpu_details = gpu_info.get('info', {})
+            result_text += f"• GPU: {gpu_details.get('name', 'N/A')}\n"
+            result_text += f"• GPU Count: {gpu_details.get('count', 'N/A')}\n"
+            result_text += f"• GPU Memory: {gpu_details.get('memory_total', 'N/A')} MB\n"
+            result_text += f"• Driver Version: {gpu_details.get('driver_version', 'N/A')}\n"
+        else:
+            result_text += "• GPU: Not Available\n"
+        
+        result_text += "\n[green]Performance Results:[/green]\n"
+        
+        # CPU Results
+        if 'cpu' in self.results:
+            cpu_loads = self.results['cpu'].get('loads', [])
+            if cpu_loads:
+                result_text += f"• Average CPU Load: {np.mean(cpu_loads):.2f}%\n"
+                result_text += f"• Peak CPU Load: {max(cpu_loads):.2f}%\n"
+            
+        # Memory Results
+        if 'memory' in self.results:
+            memory_usage = self.results['memory'].get('usage', [])
+            if memory_usage:
+                result_text += f"• Average Memory Usage: {np.mean(memory_usage):.2f}%\n"
+                result_text += f"• Peak Memory Usage: {max(memory_usage):.2f}%\n"
+            
+        # GPU Results
+        if 'gpu' in self.results and 'error' not in self.results['gpu']:
+            gpu_loads = self.results['gpu'].get('loads', [])
+            if gpu_loads:
+                result_text += f"• Average GPU Load: {np.mean(gpu_loads):.2f}%\n"
+                result_text += f"• Peak GPU Load: {max(gpu_loads):.2f}%\n"
+                if 'memory_usage' in self.results['gpu']:
+                    gpu_mem_usage = self.results['gpu'].get('memory_usage', [])
+                    if gpu_mem_usage:
+                        result_text += f"• Average GPU Memory Usage: {np.mean(gpu_mem_usage):.2f} MB\n"
+                        result_text += f"• Peak GPU Memory Usage: {max(gpu_mem_usage):.2f} MB\n"
+                
+        result_text += f"• Test Duration: {self.results.get('duration', 'N/A')} seconds\n"
+
+        self.console.print(Panel(
+            result_text,
+            title=f"System Benchmark Report - {test_type}",
+            border_style="blue"
+        ))
+
+def main():
+    benchmark = SafeSystemBenchmark()
+    
+    # Handle Ctrl+C gracefully
+    def signal_handler(sig, frame):
+        benchmark.running = False
+        print("\nBenchmark stopped by user.")
+        sys.exit(0)
+    
+    signal.signal(signal.SIGINT, signal_handler)
+    
+    # Test selection
+    console = Console()
+    console.print("\n[cyan]Select Benchmark Type:[/cyan]")
+    console.print("1. Mini-Test (30 seconds)")
+    console.print("2. God-Test (120 seconds)")
+    
+    choice = input("\nEnter your choice (1 or 2): ")
+    
+    if choice == "1":
+        benchmark.mini_test()
+    elif choice == "2":
+        benchmark.god_test()
+    else:
+        console.print("[red]Invalid choice. Exiting.[/red]")
+
+if __name__ == "__main__":
+    main()
+    

guro/core/heatmap.py

@@ -0,0 +1,349 @@
+import time
+import psutil
+import platform
+import numpy as np
+from typing import List, Optional, Dict
+from rich.live import Live
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+import subprocess
+from pathlib import Path
+import ctypes
+from ctypes import Structure
+import os
+
+# Import platform-specific modules
+if platform.system() == "Windows":
+    from ctypes import windll, wintypes, byref, POINTER
+    
+    class SYSTEM_POWER_STATUS(Structure):
+        _fields_ = [
+            ('ACLineStatus', wintypes.BYTE),
+            ('BatteryFlag', wintypes.BYTE),
+            ('BatteryLifePercent', wintypes.BYTE),
+            ('SystemStatusFlag', wintypes.BYTE),
+            ('BatteryLifeTime', wintypes.DWORD),
+            ('BatteryFullLifeTime', wintypes.DWORD),
+        ]
+
+    class PROCESSOR_POWER_INFORMATION(Structure):
+        _fields_ = [
+            ("CurrentFrequency", wintypes.ULONG),
+            ("MaxMhz", wintypes.ULONG),
+            ("CurrentMhz", wintypes.ULONG),
+            ("MhzLimit", wintypes.ULONG),
+            ("MaxIdleState", wintypes.ULONG),
+            ("CurrentIdleState", wintypes.ULONG),
+        ]
+
+class SystemHeatmap:
+    def __init__(self):
+        self.console = Console()
+        self.history_size = 60
+        self.system = platform.system()
+        self.components = {
+            'CPU': {'position': (2, 5), 'size': (8, 15)},
+            'GPU': {'position': (12, 5), 'size': (8, 15)},
+            'Motherboard': {'position': (0, 0), 'size': (25, 40)},
+            'RAM': {'position': (2, 25), 'size': (4, 10)},
+            'Storage': {'position': (18, 25), 'size': (4, 10)}
+        }
+        self.initialize_temp_maps()
+        if self.system == "Windows":
+            self.setup_windows_api()
+
+    def setup_windows_api(self):
+        if platform.system() == "Windows":
+            self.GetSystemPowerStatus = windll.kernel32.GetSystemPowerStatus
+            self.GetSystemPowerStatus.argtypes = [POINTER(SYSTEM_POWER_STATUS)]
+            self.GetSystemPowerStatus.restype = wintypes.BOOL
+            self.NtQuerySystemInformation = windll.ntdll.NtQuerySystemInformation
+            self.CallNtPowerInformation = windll.powrprof.CallNtPowerInformation
+
+    def initialize_temp_maps(self):
+        self.temp_maps = {
+            component: np.zeros(dims['size']) 
+            for component, dims in self.components.items()
+        }
+
+    def get_windows_temps(self) -> Dict[str, float]:
+        if platform.system() != "Windows":
+            return self.get_fallback_temps()
+            
+        return {
+            'CPU': self.get_windows_cpu_temp(),
+            'GPU': self.get_windows_gpu_temp(),
+            'Motherboard': self.get_windows_motherboard_temp(),
+            'Storage': self.get_windows_storage_temp(),
+            'RAM': self.get_windows_ram_temp()
+        }
+
+    def get_windows_cpu_temp(self) -> float:
+        if platform.system() != "Windows":
+            return self.get_cpu_load_temp()
+            
+        try:
+            buffer_size = ctypes.sizeof(PROCESSOR_POWER_INFORMATION)
+            buffer = ctypes.create_string_buffer(buffer_size)
+            if self.CallNtPowerInformation(11, None, 0, buffer, buffer_size) == 0:
+                info = PROCESSOR_POWER_INFORMATION.from_buffer_copy(buffer)
+                return float(40 + (info.CurrentMhz / max(info.MaxMhz, 1)) * 40)  # Fixed division by zero
+            return self.get_cpu_load_temp()
+        except:
+            return self.get_cpu_load_temp()
+
+    def get_windows_gpu_temp(self) -> float:
+        if platform.system() != "Windows":
+            return self.get_gpu_load_temp()
+            
+        try:
+            if hasattr(windll, 'd3d11'):
+                device = ctypes.c_void_p()
+                if windll.d3d11.D3D11CreateDevice(None, 0, None, 0, None, 0, 0, 
+                                                ctypes.byref(device), None, None) == 0:
+                    return self.get_gpu_load_temp()
+            return self.get_gpu_load_temp()
+        except:
+            return self.get_gpu_load_temp()
+
+    def get_windows_motherboard_temp(self) -> float:
+        if platform.system() != "Windows":
+            return 45.0
+            
+        try:
+            status = SYSTEM_POWER_STATUS()
+            if self.GetSystemPowerStatus(byref(status)):
+                return float(35 + (status.BatteryLifePercent / 100) * 15)  # Fixed type conversion
+            return 45.0
+        except:
+            return 45.0
+
+    def get_windows_storage_temp(self) -> float:
+        if platform.system() != "Windows":
+            return 35.0
+            
+        try:
+            if hasattr(windll, 'kernel32'):
+                hDevice = windll.kernel32.CreateFileW(
+                    "\\\\.\\PhysicalDrive0", 
+                    0x80000000,
+                    0x3,
+                    None,
+                    3,
+                    0,
+                    None
+                )
+                if hDevice != -1:
+                    return self.get_disk_load_temp()
+            return 35.0
+        except:
+            return 35.0
+
+    def get_windows_ram_temp(self) -> float:
+        return float(psutil.virtual_memory().percent / 2)  # Fixed type conversion
+
+    def get_linux_temps(self) -> Dict[str, float]:
+        temps = {
+            'CPU': 0.0,
+            'GPU': 0.0,
+            'Motherboard': 0.0,
+            'Storage': 0.0,
+            'RAM': 0.0
+        }
+        
+        try:
+            # CPU Temperature
+            cpu_temps = psutil.sensors_temperatures()
+            if 'coretemp' in cpu_temps:
+                temps['CPU'] = float(max(temp.current for temp in cpu_temps['coretemp']))
+            
+            # GPU Temperature
+            try:
+                nvidia_output = subprocess.check_output(
+                    ["nvidia-smi", "--query-gpu=temperature.gpu", "--format=csv,noheader"],
+                    stderr=subprocess.DEVNULL
+                ).decode()
+                temps['GPU'] = float(nvidia_output.strip())
+            except:
+                try:
+                    for card in Path('/sys/class/drm').glob('card?'):
+                        temp_file = next(card.glob('device/hwmon/hwmon*/temp1_input'))
+                        with open(temp_file) as f:
+                            temps['GPU'] = float(f.read().strip()) / 1000
+                            break
+                except:
+                    temps['GPU'] = self.get_gpu_load_temp()
+            
+            # Motherboard Temperature
+            if 'acpitz' in cpu_temps:
+                temps['Motherboard'] = float(cpu_temps['acpitz'][0].current)
+            
+            # Storage Temperature
+            try:
+                output = subprocess.check_output(['smartctl', '-A', '/dev/sda']).decode()
+                for line in output.split('\n'):
+                    if 'Temperature' in line:
+                        temps['Storage'] = float(line.split()[9])
+                        break
+            except:
+                temps['Storage'] = self.get_disk_load_temp()
+            
+            temps['RAM'] = float(psutil.virtual_memory().percent / 2)
+            
+            return temps
+        except:
+            return self.get_fallback_temps()
+
+    def get_macos_temps(self) -> Dict[str, float]:
+        temps = self.get_fallback_temps()  # Start with fallback temperatures
+        
+        try:
+            # SMC temperature readings
+            output = subprocess.check_output(
+                ['sudo', 'powermetrics', '-n', '1'],
+                stderr=subprocess.DEVNULL
+            ).decode()
+            
+            for line in output.split('\n'):
+                if 'CPU die temperature' in line:
+                    temps['CPU'] = float(line.split(':')[1].split()[0])
+                elif 'GPU die temperature' in line:
+                    temps['GPU'] = float(line.split(':')[1].split()[0])
+            
+            temps['Motherboard'] = float(temps['CPU'] * 0.8)
+            temps['RAM'] = float(psutil.virtual_memory().percent / 2)
+            
+            try:
+                output = subprocess.check_output(['smartctl', '-A', '/dev/disk0']).decode()
+                for line in output.split('\n'):
+                    if 'Temperature' in line:
+                        temps['Storage'] = float(line.split()[9])
+                        break
+            except:
+                temps['Storage'] = self.get_disk_load_temp()
+            
+            return temps
+        except:
+            return temps  # Return the fallback temps if anything fails
+
+    def get_cpu_load_temp(self) -> float:
+        return float(40 + (psutil.cpu_percent() * 0.6))
+
+    def get_gpu_load_temp(self) -> float:
+        return float(35 + (psutil.cpu_percent() * 0.5))
+
+    def get_disk_load_temp(self) -> float:
+        disk_io = psutil.disk_io_counters()
+        if disk_io:
+            return float(30 + (disk_io.read_bytes + disk_io.write_bytes) / (1024 * 1024 * 1024))
+        return 30.0
+
+    def get_fallback_temps(self) -> Dict[str, float]:
+        cpu_percent = float(psutil.cpu_percent())
+        memory_percent = float(psutil.virtual_memory().percent)
+        return {
+            'CPU': float(40 + (cpu_percent * 0.4)),
+            'GPU': float(35 + (cpu_percent * 0.3)),
+            'Motherboard': float(35 + (cpu_percent * 0.2)),
+            'Storage': float(30 + (cpu_percent * 0.1)),
+            'RAM': float(30 + (memory_percent * 0.2))
+        }
+
+    def get_system_temps(self) -> Dict[str, float]:
+        if self.system == "Windows":
+            return self.get_windows_temps()
+        elif self.system == "Linux":
+            return self.get_linux_temps()
+        elif self.system == "Darwin":
+            return self.get_macos_temps()
+        return self.get_fallback_temps()
+
+    def get_temp_char(self, temp: float) -> tuple:
+        if temp < 45:
+            return ('·', "green")
+        elif temp < 70:
+            return ('▒', "yellow")
+        else:
+            return ('█', "red")
+
+    def update_component_map(self, component: str, temp: float):
+        rows, cols = self.components[component]['size']
+        base_temp = float(temp)  # Ensure temp is float
+        noise = np.random.normal(0, 2, (rows, cols))
+        self.temp_maps[component] = np.clip(base_temp + noise, 0, 100)
+
+    def generate_system_layout(self) -> Panel:
+        layout = [[' ' for _ in range(40)] for _ in range(25)]
+        colors = [[None for _ in range(40)] for _ in range(25)]
+        temps = self.get_system_temps()
+        
+        for component, info in self.components.items():
+            pos_x, pos_y = info['position']
+            size_x, size_y = info['size']
+            
+            self.update_component_map(component, temps[component])
+            
+            for i in range(size_x):
+                for j in range(size_y):
+                    temp = float(self.temp_maps[component][i, j])  # Ensure float conversion
+                    char, color = self.get_temp_char(temp)
+                    layout[pos_x + i][pos_y + j] = char
+                    colors[pos_x + i][pos_y + j] = color
+            
+            label_x = pos_x + size_x // 2
+            label_y = pos_y + size_y // 2
+            label = f"{component[:3]} {temps[component]:.1f}°C"
+            for idx, char in enumerate(label):
+                if 0 <= label_y + idx < len(layout[0]):
+                    layout[label_x][label_y + idx] = char
+                    colors[label_x][label_y + idx] = "white"
+
+        text = Text()
+        for row in range(len(layout)):
+            for col in range(len(layout[0])):
+                text.append(layout[row][col], style=colors[row][col])
+            text.append("\n")
+
+        return Panel(
+            text, 
+            title=f"System Temperature Heatmap ({self.system})", 
+            border_style="blue"
+        )
+
+    def run(self, interval: float = 1.0, duration: Optional[int] = None) -> int:
+        """
+        Run the system heatmap visualization.
+        
+        Args:
+            interval (float): Update interval in seconds
+            duration (Optional[int]): Total duration to run in seconds
+            
+        Returns:
+            int: Number of updates performed
+            
+        Raises:
+            ValueError: If duration is negative or interval is zero/negative
+        """
+        if duration is not None and duration <= 0:
+            raise ValueError("Duration must be positive")
+        if interval <= 0:
+            raise ValueError("Interval must be positive")
+
+        start_time = time.time()
+        update_count = 0
+        
+        with Live(self.generate_system_layout(), refresh_per_second=1) as live:
+            try:
+                while True:
+                    live.update(self.generate_system_layout())
+                    update_count += 1
+                    
+                    if duration and (time.time() - start_time) >= duration:
+                        break
+                    
+                    time.sleep(interval)
+            except KeyboardInterrupt:
+                pass
+            
+            return update_count

guro/core/monitor.py

@@ -0,0 +1,303 @@
+import psutil
+import platform
+import datetime
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.layout import Layout
+import os
+import time
+from collections import deque
+import threading
+import subprocess
+from typing import Dict, List, Optional
+import shutil
+from rich import box
+# import click
+import csv
+
+class GPUDetector:
+    @staticmethod
+    def get_nvidia_info():
+        try:
+            nvidia_smi = "nvidia-smi"
+            output = subprocess.check_output([nvidia_smi, "--query-gpu=gpu_name,memory.total,memory.used,memory.free,temperature.gpu,utilization.gpu,fan.speed,power.draw", "--format=csv,noheader,nounits"], 
+                                          universal_newlines=True)
+            lines = output.strip().split('\n')
+            gpus = []
+            for line in lines:
+                name, total, used, free, temp, util, fan, power = line.split(',')
+                gpus.append({
+                    'name': name.strip(),
+                    'memory_total': float(total) * 1024**2,
+                    'memory_used': float(used) * 1024**2,
+                    'memory_free': float(free) * 1024**2,
+                    'temperature': float(temp),
+                    'utilization': float(util),
+                    'fan_speed': float(fan) if fan.strip() != '[N/A]' else None,
+                    'power_draw': float(power) if power.strip() != '[N/A]' else None,
+                    'type': 'NVIDIA'
+                })
+            return gpus
+        except:
+            return []
+
+    @staticmethod
+    def get_amd_info():
+        try:
+            rocm_smi = "rocm-smi"
+            output = subprocess.check_output([rocm_smi, "--showuse", "--showmeminfo", "--showtemp"], 
+                                          universal_newlines=True)
+            gpus = []
+            lines = output.strip().split('\n')
+            current_gpu = {}
+            for line in lines:
+                if 'GPU' in line and 'Card' in line:
+                    if current_gpu:
+                        gpus.append(current_gpu)
+                    current_gpu = {'type': 'AMD'}
+                if 'GPU Memory Use' in line:
+                    try:
+                        used = float(line.split(':')[1].strip().split()[0]) * 1024**2
+                        current_gpu['memory_used'] = used
+                    except:
+                        pass
+                if 'Total GPU Memory' in line:
+                    try:
+                        total = float(line.split(':')[1].strip().split()[0]) * 1024**2
+                        current_gpu['memory_total'] = total
+                        current_gpu['memory_free'] = total - current_gpu.get('memory_used', 0)
+                    except:
+                        pass
+                if 'Temperature' in line:
+                    try:
+                        temp = float(line.split(':')[1].strip().split()[0])
+                        current_gpu['temperature'] = temp
+                    except:
+                        pass
+            if current_gpu:
+                gpus.append(current_gpu)
+            return gpus
+        except:
+            return []
+
+    @staticmethod
+    def get_all_gpus():
+        gpu_info = {
+            'available': False,
+            'gpus': []
+        }
+        
+        nvidia_gpus = GPUDetector.get_nvidia_info()
+        amd_gpus = GPUDetector.get_amd_info()
+        
+        all_gpus = nvidia_gpus + amd_gpus
+        
+        if all_gpus:
+            gpu_info['available'] = True
+            gpu_info['gpus'] = all_gpus
+            
+        return gpu_info
+
+class ASCIIGraph:
+    def __init__(self, width=70, height=10):
+        self.width = width
+        self.height = height
+        self.data = deque(maxlen=width)
+        self.chars = ' ▁▂▃▄▅▆▇█'
+
+    def add_point(self, value):
+        self.data.append(value)
+
+    def render(self, title=""):
+        if not self.data:
+            return ""
+
+        # Normalize data
+        max_val = max(self.data)
+        if max_val == 0:
+            normalized = [0] * len(self.data)
+        else:
+            normalized = [min(int((val / max_val) * (len(self.chars) - 1)), len(self.chars) - 1) 
+                         for val in self.data]
+
+        # Generate graph
+        lines = []
+        lines.append("╔" + "═" * (self.width + 2) + "╗")
+        lines.append("║ " + title.center(self.width) + " ║")
+        lines.append("║ " + "─" * self.width + " ║")
+
+        graph_str = ""
+        for val in normalized:
+            graph_str += self.chars[val]
+        lines.append("║ " + graph_str.ljust(self.width) + " ║")
+        
+        lines.append("╚" + "═" * (self.width + 2) + "╝")
+        return "\n".join(lines)
+
+class SystemMonitor:
+    def __init__(self):
+        self.console = Console()
+        self.cpu_graph = ASCIIGraph()
+        self.memory_graph = ASCIIGraph()
+        self.monitoring_data = []
+        
+    def _get_cpu_temperature(self):
+        if platform.system() == 'Linux':
+            try:
+                temp_file = '/sys/class/thermal/thermal_zone0/temp'
+                if os.path.exists(temp_file):
+                    with open(temp_file, 'r') as f:
+                        return float(f.read()) / 1000.0
+            except:
+                pass
+        return None
+
+    def get_system_info(self):
+        cpu_freq = psutil.cpu_freq()
+        memory = psutil.virtual_memory()
+        
+        system_info = {
+            'os': f"{platform.system()} {platform.release()}",
+            'cpu_model': platform.processor(),
+            'cpu_cores': psutil.cpu_count(),
+            'cpu_threads': psutil.cpu_count(logical=True),
+            'cpu_freq': f"{cpu_freq.current:.2f}MHz" if cpu_freq else "N/A",
+            'memory_total': f"{memory.total / (1024**3):.2f}GB",
+            'memory_available': f"{memory.available / (1024**3):.2f}GB",
+        }
+        
+        temp = self._get_cpu_temperature()
+        if temp:
+            system_info['cpu_temp'] = f"{temp:.1f}°C"
+            
+        return system_info
+
+    def export_monitoring_data(self):
+        if not self.monitoring_data:
+            return
+        
+        with open('monitoring_data.csv', 'w', newline='') as csvfile:
+            fieldnames = ['timestamp', 'cpu_usage', 'memory_usage']
+            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+            
+            writer.writeheader()
+            for data in self.monitoring_data:
+                writer.writerow(data)
+
+    def run_performance_test(self, interval: float = 1.0, duration: Optional[int] = 30, export_data: bool = False):
+        self.console.clear()
+        self.console.print(Panel.fit(
+            "[bold cyan]Welcome to System Performance Monitor[/bold cyan]\n" +
+            f"[yellow]Running performance test for {duration if duration else 'unlimited'} seconds...[/yellow]",
+            box=box.DOUBLE
+        ))
+        
+        # System Information
+        sys_info = self.get_system_info()
+        sys_table = Table(title="System Information", box=box.HEAVY)
+        sys_table.add_column("Component", style="cyan")
+        sys_table.add_column("Details", style="green")
+        
+        for key, value in sys_info.items():
+            sys_table.add_row(key.replace('_', ' ').title(), str(value))
+        
+        self.console.print(sys_table)
+        self.console.print("")
+        
+        # GPU Information
+        gpu_info = GPUDetector.get_all_gpus()
+        if gpu_info['available']:
+            gpu_table = Table(title="GPU Information", box=box.HEAVY)
+            gpu_table.add_column("Metric", style="cyan")
+            gpu_table.add_column("Value", style="green")
+            
+            for i, gpu in enumerate(gpu_info['gpus']):
+                gpu_table.add_row(f"GPU {i} Type", gpu.get('type', 'Unknown'))
+                gpu_table.add_row(f"GPU {i} Name", gpu.get('name', 'Unknown'))
+                if gpu.get('memory_total'):
+                    gpu_table.add_row(f"Memory Total", f"{gpu['memory_total'] / (1024**3):.2f} GB")
+                if gpu.get('temperature'):
+                    gpu_table.add_row(f"Temperature", f"{gpu['temperature']}°C")
+            
+            self.console.print(gpu_table)
+            self.console.print("")
+        
+        # Performance Test
+        start_time = time.time()
+        try:
+            while True:
+                current_time = time.time()
+                if duration and (current_time - start_time >= duration):
+                    break
+                
+                cpu_percent = psutil.cpu_percent()
+                memory_percent = psutil.virtual_memory().percent
+                
+                self.cpu_graph.add_point(cpu_percent)
+                self.memory_graph.add_point(memory_percent)
+                
+                if export_data:
+                    self.monitoring_data.append({
+                        'timestamp': datetime.datetime.now().isoformat(),
+                        'cpu_usage': cpu_percent,
+                        'memory_usage': memory_percent
+                    })
+                
+                self.console.clear()
+                self.console.print(Panel.fit(
+                    f"[bold cyan]Performance Test Progress: {int(current_time - start_time)}s{f'/{duration}s' if duration else ''}[/bold cyan]",
+                    box=box.DOUBLE
+                ))
+                
+                self.console.print(self.cpu_graph.render(f"CPU Usage: {cpu_percent:.1f}%"))
+                self.console.print("")
+                self.console.print(self.memory_graph.render(f"Memory Usage: {memory_percent:.1f}%"))
+                
+                time.sleep(interval)
+        
+        except KeyboardInterrupt:
+            self.console.print("\n[yellow]Monitoring stopped by user[/yellow]")
+        
+        # Final Summary
+        self.console.clear()
+        summary_table = Table(title="Performance Test Summary", box=box.HEAVY)
+        summary_table.add_column("Metric", style="cyan")
+        summary_table.add_column("Average", style="green")
+        summary_table.add_column("Maximum", style="red")
+        
+        cpu_values = list(self.cpu_graph.data)
+        mem_values = list(self.memory_graph.data)
+        
+        if cpu_values:
+            summary_table.add_row(
+                "CPU Usage",
+                f"{sum(cpu_values) / len(cpu_values):.1f}%",
+                f"{max(cpu_values):.1f}%"
+            )
+        if mem_values:
+            summary_table.add_row(
+                "Memory Usage",
+                f"{sum(mem_values) / len(mem_values):.1f}%",
+                f"{max(mem_values):.1f}%"
+            )
+        
+        self.console.print(Panel.fit(
+            "[bold green]Performance Test Completed![/bold green]",
+            box=box.DOUBLE
+        ))
+        self.console.print(summary_table)
+        
+        # Final Graphs
+        self.console.print(self.cpu_graph.render("CPU Usage History"))
+        self.console.print("")
+        self.console.print(self.memory_graph.render("Memory Usage History"))
+        
+        if export_data:
+            self.export_monitoring_data()
+            self.console.print("\n[green]Monitoring data exported to 'monitoring_data.csv'[/green]")
+
+# @click.group()
+# def cli():
+#     """🖥️ System Performance Monitor CLI"""
+#     pass

guro-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 DHANUSH KANDHAN
+
+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.

guro-0.1.0.dist-info/METADATA

@@ -0,0 +1,126 @@
+Metadata-Version: 2.2
+Name: guro
+Version: 0.1.0
+Summary: A Simple System Monitoring & Benchmarking Toolkit
+Home-page: https://github.com/dhanushk-offl/guro
+Author: Dhanush Kandhan
+Author-email: dhanushkandhan75@gmail.com
+Project-URL: Bug Reports, https://github.com/dhanushk-offl/guro/issues
+Project-URL: Source, https://github.com/dhanushk-offl/guro
+Project-URL: Documentation, https://github.com/dhanushk-offl/guro/wiki
+Keywords: system-monitoring,gpu-optimization,performance-tuning,hardware-monitoring,system-administration,nvidia-gpu,amd-gpu,intel-gpu,resource-monitoring,system-optimization
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Topic :: System :: Hardware
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: System :: Operating System
+Classifier: Topic :: System :: Hardware :: Hardware Drivers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Intended Audience :: System Administrators
+Classifier: Intended Audience :: Developers
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Natural Language :: English
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.0.0
+Requires-Dist: rich>=10.0.0
+Requires-Dist: psutil>=5.8.0
+Requires-Dist: gputil>=1.4.0
+Requires-Dist: matplotlib>=3.5.0
+Requires-Dist: nvidia-ml-py>=11.515.0
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: plotly>=5.5.0
+Requires-Dist: termcolor>=2.0.0
+Requires-Dist: tabulate>=0.8.9
+Requires-Dist: py-cpuinfo>=8.0.0
+Requires-Dist: setproctitle>=1.2.2
+Requires-Dist: keyboard>=0.13.5
+Requires-Dist: pytest>=7.0.0
+Requires-Dist: pytest-mock>=3.10.0
+Requires-Dist: pytest-cov>=4.0.0
+Requires-Dist: pytest-timeout>=2.1.0
+Provides-Extra: nvidia
+Requires-Dist: py3nvml>=0.2.7; extra == "nvidia"
+Requires-Dist: nvidia-ml-py>=11.515.0; extra == "nvidia"
+Provides-Extra: amd
+Requires-Dist: pyamdgpuinfo>=2.1.0; extra == "amd"
+Provides-Extra: all
+Requires-Dist: py3nvml>=0.2.7; extra == "all"
+Requires-Dist: nvidia-ml-py>=11.515.0; extra == "all"
+Requires-Dist: pyamdgpuinfo>=2.1.0; extra == "all"
+Requires-Dist: matplotlib>=3.5.0; extra == "all"
+Requires-Dist: plotly>=5.5.0; extra == "all"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == "test"
+Requires-Dist: pytest-mock>=3.10.0; extra == "test"
+Requires-Dist: pytest-cov>=4.0.0; extra == "test"
+Requires-Dist: pytest-timeout>=2.1.0; extra == "test"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Guro - A Simple System Monitoring & Benchmarking Toolkit 🚀
+
+
+Welcome to **Guro**, the ultimate toolkit for **system monitoring** and **benchmarking**. It’s simple, fast, and designed for developers and enthusiasts who want to monitor system performance, run benchmarks, and visualize system heatmaps in an intuitive way.
+
+### Features:
+- 📊 **Real-time system monitoring** – Monitor CPU, memory, and disk usage in real-time.
+- 🔥 **Performance benchmarking** – Run benchmarks with mini and full-scale tests for your CPU and GPU.
+- 🌡️ **Hardware heatmap** – Visualize your system's temperature with a heatmap in real-time.
+- 💾 **Export data** – Export monitoring data to CSV for analysis.
+  
+### Installation
+
+```bash
+pip install guro
+```
+
+### Usage
+
+Run the following commands for monitoring, benchmarking, or heatmap analysis:
+
+#### 1. **Monitor System Resources**
+```bash
+guro monitor --interval 1.0 --duration 60
+```
+
+#### 2. **Run Benchmark Tests**
+```bash
+guro benchmark --type mini --cpu-only
+```
+
+#### 3. **Visualize System Heatmap**
+```bash
+guro heatmap --interval 1.0 --duration 30
+```
+
+#### 4. **List All Commands**
+```bash
+guro list
+```
+
+For more details, check out our [documentation](https://github.com/dhanushk-offl/guro/wiki).
+
+### Demo
+
+[Watch the demo video here](https://www.youtube.com/watch?v=xyz123)
+
+### License
+
+MIT License. See LICENSE for more details.

guro-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+guro/__init__.py,sha256=jfsfKFXPEm3Vw2kGvN0tF6BdymKeuVwD-BKDa4UcdZI,41
+guro/cli/__init__.py,sha256=Yf6zQAso40qDlQxYRO7I69vJAeZFARH3Mb4uuyVkZw8,66
+guro/cli/main.py,sha256=uRS2YaI6ohK5b8SC7ls3v9yVaK3xeZQYeYa5v2siW8E,6454
+guro/core/__init__.py,sha256=QnMaN9YZAoGFCQUc96je7epXpuDtxYJkIp2CmLpaJGg,88
+guro/core/benchmark.py,sha256=HekY0qw18fZmDm6dAUPnYDWsYdxJAfZ1O0oQOKi27fQ,12079
+guro/core/heatmap.py,sha256=x7YX7KjkBHQ89VEdISqkx8P1C2VrTNm1f6k4UdY0-Ao,13452
+guro/core/monitor.py,sha256=ZgaF0U3lQdChDkjgP3g3VTODgclBWscRoRSlyndWY9g,11625
+guro-0.1.0.dist-info/LICENSE,sha256=MHJpjnxHbUoDnq3h1-egX5V2xYAlKwwElYlzl_J8nHk,1093
+guro-0.1.0.dist-info/METADATA,sha256=4OzeNSX5JxHev_Qm6NvHgHVqFfzemXAcIpdg6UNfJQs,4484
+guro-0.1.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+guro-0.1.0.dist-info/entry_points.txt,sha256=9JtiZiie5WKQ-qCDaAeZJMIOggcorlq8UKCBAM0tFMs,43
+guro-0.1.0.dist-info/top_level.txt,sha256=eUjx5tz9mwVwUwI_XxhkCZeBBH0GYj8zkwGDrsWHxOg,5
+guro-0.1.0.dist-info/RECORD,,

guro-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

guro-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+guro = guro.cli.main:cli

guro-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+guro