Utils

def format_memory(bytes_value: Optional[Union[int, float]]) -> str

from tfmemprof.utils import format_memory

print(format_memory(1024))           # "1.00 KB"
print(format_memory(1024 * 1024))    # "1.00 MB"
print(format_memory(2.5 * 1024**3))  # "2.50 GB"
print(format_memory(None))           # "N/A"

def get_gpu_info() -> Dict[str, Any]

from tfmemprof.utils import get_gpu_info

info = get_gpu_info()
print(f"GPU available: {info['available']}")
print(f"GPU count: {info['count']}")
print(f"Total memory: {info['total_memory']:.2f} MB")

for device in info['devices']:
    print(f"GPU {device['id']}: {device['current_memory_mb']:.2f} MB")

def get_system_info() -> Dict[str, Any]

def get_backend_info() -> BackendInfo

def analyze_fragmentation(snapshots: List[MemorySnapshot]) -> Dict[str, float]

def suggest_optimizations(profile_result: ProfileResult) -> List[str]

from tfmemprof.utils import suggest_optimizations

suggestions = suggest_optimizations(results)
for i, suggestion in enumerate(suggestions, 1):
    print(f"{i}. {suggestion}")

def generate_summary_report(profile_result: ProfileResult) -> str

from tfmemprof.utils import generate_summary_report

report = generate_summary_report(results)
print(report)

# Or save to file
with open('memory_report.txt', 'w') as f:
    f.write(report)

def get_tensorflow_memory_usage() -> Dict[str, float]

def optimize_tensorflow_memory() -> List[str]

from tfmemprof.utils import optimize_tensorflow_memory

applied = optimize_tensorflow_memory()
for opt in applied:
    print(f"✓ {opt}")

def clear_tensorflow_session() -> None

def validate_tensorflow_environment() -> Dict[str, Any]

from tfmemprof.utils import validate_tensorflow_environment

validation = validate_tensorflow_environment()

if validation['tensorflow_available']:
    print("✓ TensorFlow available")
if validation['gpu_available']:
    print("✓ GPU available")
    
if validation['issues']:
    print("\nIssues found:")
    for issue in validation['issues']:
        print(f"  - {issue}")

from tfmemprof.profiler import TFMemoryProfiler
from tfmemprof.utils import (
    format_memory,
    get_system_info,
    get_gpu_info,
    analyze_fragmentation,
    suggest_optimizations,
    generate_summary_report,
    optimize_tensorflow_memory,
    validate_tensorflow_environment
)

# Validate environment
validation = validate_tensorflow_environment()
if not validation['tensorflow_available']:
    print("Error: TensorFlow not available")
    exit(1)

# Get system info
sys_info = get_system_info()
print(f"TensorFlow {sys_info['tensorflow_version']}")
print(f"Python {sys_info['python_version']}")

gpu_info = get_gpu_info()
if gpu_info['available']:
    print(f"GPUs: {gpu_info['count']}")
    print(f"Total GPU memory: {format_memory(gpu_info['total_memory'] * 1024 * 1024)}")

# Apply optimizations
print("\nApplying optimizations...")
optimizations = optimize_tensorflow_memory()
for opt in optimizations:
    print(f"  ✓ {opt}")

# Profile your code
profiler = TFMemoryProfiler()

with profiler.profile_context("training"):
    # Your training code
    pass

results = profiler.get_results()

# Analyze fragmentation
frag = analyze_fragmentation(results.snapshots)
print(f"\nFragmentation score: {frag['fragmentation_score']:.3f}")

# Get suggestions
suggestions = suggest_optimizations(results)
print("\nOptimization suggestions:")
for i, suggestion in enumerate(suggestions[:5], 1):
    print(f"  {i}. {suggestion}")

# Generate full report
report = generate_summary_report(results)
print("\n" + "="*50)
print(report)

# Save report
with open('memory_analysis_report.txt', 'w') as f:
    f.write(report)