Merge pull request #10 from errnair/errnair/modernize-python-scripts

Modernize Python scripts (checkcpu.py and timer.py) LGTM

Author: errnair

python-scripts/checkcpu.py

@@ -1,9 +1,352 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 """
-Script to check the number of CPU cores.
-Usage: python checkcpu.py
+CPU Information Tool
+
+Displays comprehensive CPU information including count, model, frequency,
+cache sizes, and usage statistics.
+
+Usage:
+ python3 checkcpu.py [options]
 """
+
+import argparse
+import json
 import multiprocessing
+import os
+import platform
+import sys
+from typing import Dict, Any, Optional
+
+
+def get_cpu_count() -> Dict[str, int]:
+ """Get CPU count information."""
+ logical_count = multiprocessing.cpu_count()
+
+ # Try to get physical core count
+ try:
+ physical_count = os.cpu_count() or logical_count
+ except AttributeError:
+ physical_count = logical_count
+
+ return {
+ 'logical': logical_count,
+ 'physical': physical_count
+ }
+
+
+def get_cpu_info_linux() -> Dict[str, Any]:
+ """Get detailed CPU information on Linux."""
+ info = {}
+
+ try:
+ with open('/proc/cpuinfo', 'r') as f:
+ cpuinfo = f.read()
+
+ # Extract model name
+ for line in cpuinfo.split('\n'):
+ if 'model name' in line:
+ info['model'] = line.split(':')[1].strip()
+ break
+
+ # Extract vendor
+ for line in cpuinfo.split('\n'):
+ if 'vendor_id' in line:
+ info['vendor'] = line.split(':')[1].strip()
+ break
+
+ # Extract CPU MHz
+ for line in cpuinfo.split('\n'):
+ if 'cpu MHz' in line:
+ info['mhz'] = float(line.split(':')[1].strip())
+ break
+
+ # Extract cache size
+ for line in cpuinfo.split('\n'):
+ if 'cache size' in line:
+ info['cache_size'] = line.split(':')[1].strip()
+ break
+
+ # Extract flags/features (first processor only)
+ for line in cpuinfo.split('\n'):
+ if 'flags' in line:
+ flags = line.split(':')[1].strip().split()
+ info['flags'] = flags
+ info['flag_count'] = len(flags)
+ break
+
+ except FileNotFoundError:
+ pass
+
+ return info
+
+
+def get_cpu_info_macos() -> Dict[str, Any]:
+ """Get detailed CPU information on macOS."""
+ info = {}
+
+ try:
+ import subprocess
+
+ # Get CPU brand
+ result = subprocess.run(
+ ['sysctl', '-n', 'machdep.cpu.brand_string'],
+ capture_output=True,
+ text=True,
+ check=True
+ )
+ info['model'] = result.stdout.strip()
+
+ # Get CPU frequency
+ try:
+ result = subprocess.run(
+ ['sysctl', '-n', 'hw.cpufrequency'],
+ capture_output=True,
+ text=True,
+ check=True
+ )
+ if result.stdout.strip():
+ info['hz'] = int(result.stdout.strip())
+ info['mhz'] = info['hz'] / 1_000_000
+ except (subprocess.CalledProcessError, ValueError):
+ pass
+
+ # Get cache sizes
+ for cache_type in ['l1icachesize', 'l1dcachesize', 'l2cachesize', 'l3cachesize']:
+ try:
+ result = subprocess.run(
+ ['sysctl', '-n', f'hw.{cache_type}'],
+ capture_output=True,
+ text=True,
+ check=True
+ )
+ cache_bytes = int(result.stdout.strip())
+ cache_kb = cache_bytes / 1024
+ info[cache_type] = f"{cache_kb:.0f} KB"
+ except (subprocess.CalledProcessError, ValueError):
+ pass
+
+ # Get CPU features
+ try:
+ result = subprocess.run(
+ ['sysctl', '-n', 'machdep.cpu.features'],
+ capture_output=True,
+ text=True,
+ check=True
+ )
+ flags = result.stdout.strip().split()
+ info['flags'] = flags
+ info['flag_count'] = len(flags)
+ except subprocess.CalledProcessError:
+ pass
+
+ except (ImportError, FileNotFoundError):
+ pass
+
+ return info
+
+
+def get_cpu_usage() -> Optional[float]:
+ """Get current CPU usage percentage."""
+ try:
+ import psutil
+ return psutil.cpu_percent(interval=1)
+ except ImportError:
+ # Try Linux-specific method
+ try:
+ with open('/proc/stat', 'r') as f:
+ lines = f.readlines()
+
+ # First line is aggregate CPU stats
+ cpu_line = lines[0].split()
+
+ # Calculate usage (simplified)
+ user = int(cpu_line[1])
+ nice = int(cpu_line[2])
+ system = int(cpu_line[3])
+ idle = int(cpu_line[4])
+
+ total = user + nice + system + idle
+ used = user + nice + system
+
+ return (used / total) * 100 if total > 0 else 0.0
+ except (FileNotFoundError, IndexError, ValueError):
+ return None
+
+
+def get_cpu_temperature() -> Optional[float]:
+ """Get CPU temperature if available."""
+ try:
+ import psutil
+ temps = psutil.sensors_temperatures()
+
+ # Try common sensor names
+ for sensor_name in ['coretemp', 'cpu_thermal', 'k10temp']:
+ if sensor_name in temps:
+ return temps[sensor_name][0].current
+
+ # If no common sensor found, try first available
+ if temps:
+ first_sensor = list(temps.keys())[0]
+ return temps[first_sensor][0].current
+ except (ImportError, AttributeError):
+ pass
+
+ return None
+
+
+def is_virtual_cpu() -> bool:
+ """Detect if running on a virtual machine."""
+ system = platform.system()
+
+ if system == 'Linux':
+ try:
+ with open('/proc/cpuinfo', 'r') as f:
+ cpuinfo = f.read().lower()
+
+ # Check for hypervisor flags
+ if 'hypervisor' in cpuinfo:
+ return True
+
+ # Check for virtual CPU models
+ virtual_indicators = ['qemu', 'kvm', 'virtual', 'vmware', 'xen']
+ for indicator in virtual_indicators:
+ if indicator in cpuinfo:
+ return True
+ except FileNotFoundError:
+ pass
+
+ return False
+
+
+def format_text_output(cpu_data: Dict[str, Any], verbose: bool = False) -> str:
+ """Format CPU information as text."""
+ lines = []
+
+ lines.append("CPU Information")
+ lines.append("=" * 50)
+ lines.append("")
+
+ # Basic info
+ lines.append(f"Logical CPUs: {cpu_data['count']['logical']}")
+ lines.append(f"Physical CPUs: {cpu_data['count']['physical']}")
+
+ if cpu_data.get('model'):
+ lines.append(f"Model: {cpu_data['model']}")
+
+ if cpu_data.get('vendor'):
+ lines.append(f"Vendor: {cpu_data['vendor']}")
+
+ if cpu_data.get('mhz'):
+ lines.append(f"Frequency: {cpu_data['mhz']:.2f} MHz")
+
+ if cpu_data.get('cache_size'):
+ lines.append(f"Cache Size: {cpu_data['cache_size']}")
+
+ # Cache info (macOS)
+ for cache in ['l1icachesize', 'l1dcachesize', 'l2cachesize', 'l3cachesize']:
+ if cpu_data.get(cache):
+ cache_name = cache.replace('cachesize', '').upper()
+ lines.append(f"{cache_name} Cache: {cpu_data[cache]}")
+
+ if cpu_data.get('virtual') is not None:
+ lines.append(f"Virtual CPU: {'Yes' if cpu_data['virtual'] else 'No'}")
+
+ if cpu_data.get('usage') is not None:
+ lines.append(f"CPU Usage: {cpu_data['usage']:.1f}%")
+
+ if cpu_data.get('temperature') is not None:
+ lines.append(f"Temperature: {cpu_data['temperature']:.1f}°C")
+
+ lines.append(f"Platform: {cpu_data['platform']}")
+ lines.append(f"Architecture: {cpu_data['architecture']}")
+
+ if verbose and cpu_data.get('flags'):
+ lines.append("")
+ lines.append(f"CPU Flags ({cpu_data.get('flag_count', 0)}):")
+ lines.append("-" * 50)
+
+ # Display flags in columns
+ flags = cpu_data['flags']
+ col_width = 15
+ cols = 4
+
+ for i in range(0, len(flags), cols):
+ row_flags = flags[i:i+cols]
+ line = " ".join(f"{flag:<{col_width}}" for flag in row_flags)
+ lines.append(f" {line}")
+ elif cpu_data.get('flag_count'):
+ lines.append(f"CPU Flags: {cpu_data['flag_count']} features")
+
+ return "\n".join(lines)
+
+
+def format_json_output(cpu_data: Dict[str, Any]) -> str:
+ """Format CPU information as JSON."""
+ return json.dumps(cpu_data, indent=2)
+
+
+def main():
+ """Main entry point."""
+ parser = argparse.ArgumentParser(
+ description='Display detailed CPU information',
+ formatter_class=argparse.RawDescriptionHelpFormatter,
+ epilog="""
+Examples:
+ %(prog)s # Display CPU information
+ %(prog)s --json # JSON output
+ %(prog)s --verbose # Show all CPU flags/features
+ %(prog)s -v --json # Verbose JSON output
+ """
+ )
+
+ parser.add_argument(
+ '--json',
+ action='store_true',
+ help='Output in JSON format'
+ )
+
+ parser.add_argument(
+ '-v', '--verbose',
+ action='store_true',
+ help='Show detailed CPU flags and features'
+ )
+
+ args = parser.parse_args()
+
+ # Gather CPU information
+ cpu_data = {
+ 'count': get_cpu_count(),
+ 'platform': platform.system(),
+ 'architecture': platform.machine(),
+ }
+
+ # Get platform-specific info
+ system = platform.system()
+ if system == 'Linux':
+ cpu_data.update(get_cpu_info_linux())
+ elif system == 'Darwin':
+ cpu_data.update(get_cpu_info_macos())
+
+ # Get dynamic info
+ cpu_data['usage'] = get_cpu_usage()
+ cpu_data['temperature'] = get_cpu_temperature()
+ cpu_data['virtual'] = is_virtual_cpu()
+
+ # Output
+ if args.json:
+ # If not verbose, remove flags from JSON
+ if not args.verbose and 'flags' in cpu_data:
+ flag_count = cpu_data.get('flag_count')
+ del cpu_data['flags']
+ if flag_count:
+ cpu_data['flag_count'] = flag_count
+
+ print(format_json_output(cpu_data))
+ else:
+ print(format_text_output(cpu_data, verbose=args.verbose))
+
+ return 0
+
 
-cpu_count = multiprocessing.cpu_count()
-print (cpu_count)
+if __name__ == '__main__':
+ sys.exit(main())