turboloader 2.2.0__tar.gz → 2.3.2__tar.gz

{turboloader-2.2.0 → turboloader-2.3.2}/MANIFEST.in

@@ -3,18 +3,13 @@ include README.md
 include LICENSE
 include AUTHORS.md
 include CONTRIBUTING.md
-include ARCHITECTURE.md
 
 # Include ALL C++ source files and headers
 graft src
-recursive-include src *.hpp *.h *.cpp *.c
+recursive-include src *.hpp *.cpp
 
 # Include CMake files
 include CMakeLists.txt
-recursive-include cmake *.cmake
-
-# Include Python bindings
-recursive-include python *.cpp *.hpp CMakeLists.txt
 
 # Include benchmarks
 recursive-include benchmarks *.py *.md
@@ -23,7 +18,7 @@ recursive-include benchmarks *.py *.md
 recursive-include examples *.py *.md
 
 # Include tests
-recursive-include tests *.cpp *.hpp
+recursive-include tests *.cpp *.py
 
 # Exclude build artifacts
 global-exclude *.pyc

{turboloader-2.2.0 → turboloader-2.3.2}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: turboloader
-Version: 2.2.0
+Version: 2.3.2
 Summary: Production-ready ML data loading library with distributed training support, SIMD-accelerated transforms, pipe operator composition, HDF5/TFRecord/Zarr support, and GPU transforms. Built with C++20 for maximum performance.
 Author: TurboLoader Contributors
 Author-email: Arnav Jain <arnav@example.com>
 Maintainer-email: Arnav Jain <arnav@example.com>
-License: MIT
+License-Expression: MIT
 Project-URL: Homepage, https://github.com/arnavjain/turboloader
 Project-URL: Documentation, https://github.com/arnavjain/turboloader/blob/main/README.md
 Project-URL: Repository, https://github.com/arnavjain/turboloader

{turboloader-2.2.0 → turboloader-2.3.2}/benchmarks/01_pil_baseline.py

@@ -42,12 +42,14 @@ class PILDataLoader:
     and batches them for training.
     """
 
-    def __init__(self,
-                 image_dir: str,
-                 batch_size: int = 32,
-                 shuffle: bool = False,
-                 num_epochs: int = 1,
-                 transform: bool = True):
+    def __init__(
+        self,
+        image_dir: str,
+        batch_size: int = 32,
+        shuffle: bool = False,
+        num_epochs: int = 1,
+        transform: bool = True,
+    ):
         """
         Initialize PIL DataLoader.
 
@@ -65,7 +67,7 @@ class PILDataLoader:
         self.transform = transform
 
         # Get all image files
-        self.image_files = sorted(self.image_dir.glob('*.jpg'))
+        self.image_files = sorted(self.image_dir.glob("*.jpg"))
         self.num_images = len(self.image_files)
 
         if self.num_images == 0:
@@ -90,7 +92,7 @@ class PILDataLoader:
             NumPy array (H, W, 3) with transformed image
         """
         # Load image
-        img = Image.open(img_path).convert('RGB')
+        img = Image.open(img_path).convert("RGB")
 
         if self.transform:
             # Resize to 224x224 (standard ImageNet size)
@@ -116,6 +118,7 @@ class PILDataLoader:
             # Shuffle if requested
             if self.shuffle:
                 import random
+
                 image_files = list(self.image_files)
                 random.shuffle(image_files)
             else:
@@ -123,7 +126,7 @@ class PILDataLoader:
 
             # Create batches
             for i in range(0, len(image_files), self.batch_size):
-                batch_files = image_files[i:i + self.batch_size]
+                batch_files = image_files[i : i + self.batch_size]
 
                 # Load and transform images
                 batch_images = []
@@ -137,10 +140,9 @@ class PILDataLoader:
                     yield batch
 
 
-def run_benchmark(image_dir: str,
-                  batch_size: int = 32,
-                  num_epochs: int = 3,
-                  shuffle: bool = False) -> Dict[str, Any]:
+def run_benchmark(
+    image_dir: str, batch_size: int = 32, num_epochs: int = 3, shuffle: bool = False
+) -> Dict[str, Any]:
     """
     Run PIL baseline benchmark.
 
@@ -153,14 +155,14 @@ def run_benchmark(image_dir: str,
     Returns:
         Dictionary with benchmark results
     """
-    print("="*80)
+    print("=" * 80)
     print("PIL BASELINE BENCHMARK")
-    print("="*80)
+    print("=" * 80)
     print(f"Dataset: {image_dir}")
     print(f"Batch size: {batch_size}")
     print(f"Epochs: {num_epochs}")
     print(f"Shuffle: {shuffle}")
-    print("="*80)
+    print("=" * 80)
 
     # Create dataloader
     loader = PILDataLoader(
@@ -168,7 +170,7 @@ def run_benchmark(image_dir: str,
         batch_size=batch_size,
         shuffle=shuffle,
         num_epochs=num_epochs,
-        transform=True
+        transform=True,
     )
 
     # Track metrics
@@ -216,48 +218,53 @@ def run_benchmark(image_dir: str,
 
     # Calculate statistics
     results = {
-        'framework': 'PIL Baseline',
-        'batch_size': batch_size,
-        'num_epochs': num_epochs,
-        'shuffle': shuffle,
-        'total_time': total_time,
-        'epoch_times': epoch_times,
-        'avg_epoch_time': np.mean(epoch_times),
-        'std_epoch_time': np.std(epoch_times),
-        'avg_batch_time': np.mean(batch_times),
-        'std_batch_time': np.std(batch_times),
-        'throughput': loader.num_images * num_epochs / total_time,
-        'peak_memory_mb': max(memory_usage) if memory_usage else 0,
-        'avg_memory_mb': np.mean(memory_usage) if memory_usage else 0,
+        "framework": "PIL Baseline",
+        "batch_size": batch_size,
+        "num_epochs": num_epochs,
+        "shuffle": shuffle,
+        "total_time": total_time,
+        "epoch_times": epoch_times,
+        "avg_epoch_time": np.mean(epoch_times),
+        "std_epoch_time": np.std(epoch_times),
+        "avg_batch_time": np.mean(batch_times),
+        "std_batch_time": np.std(batch_times),
+        "throughput": loader.num_images * num_epochs / total_time,
+        "peak_memory_mb": max(memory_usage) if memory_usage else 0,
+        "avg_memory_mb": np.mean(memory_usage) if memory_usage else 0,
     }
 
     # Print summary
-    print("\n" + "="*80)
+    print("\n" + "=" * 80)
     print("BENCHMARK RESULTS")
-    print("="*80)
+    print("=" * 80)
     print(f"Total time: {total_time:.2f}s")
-    print(f"Average epoch time: {results['avg_epoch_time']:.2f}s ± {results['std_epoch_time']:.2f}s")
-    print(f"Average batch time: {results['avg_batch_time']*1000:.2f}ms ± {results['std_batch_time']*1000:.2f}ms")
+    print(
+        f"Average epoch time: {results['avg_epoch_time']:.2f}s ± {results['std_epoch_time']:.2f}s"
+    )
+    print(
+        f"Average batch time: {results['avg_batch_time']*1000:.2f}ms ± {results['std_batch_time']*1000:.2f}ms"
+    )
     print(f"Throughput: {results['throughput']:.1f} images/sec")
     print(f"Peak memory: {results['peak_memory_mb']:.1f} MB")
     print(f"Average memory: {results['avg_memory_mb']:.1f} MB")
-    print("="*80)
+    print("=" * 80)
 
     return results
 
 
 def main():
-    parser = argparse.ArgumentParser(description='PIL baseline benchmark')
-    parser.add_argument('--image-dir', '-dir', type=str, default="/private/tmp/benchmark_datasets/bench_2k/images/",
-                       help='Directory containing JPEG images')
-    parser.add_argument('--batch-size', '-b', type=int, default=32,
-                       help='Batch size (default: 32)')
-    parser.add_argument('--epochs', '-e', type=int, default=3,
-                       help='Number of epochs (default: 3)')
-    parser.add_argument('--shuffle', '-s', action='store_true',
-                       help='Shuffle data')
-    parser.add_argument('--output', '-o', type=str,
-                       help='Output JSON file for results')
+    parser = argparse.ArgumentParser(description="PIL baseline benchmark")
+    parser.add_argument(
+        "--image-dir",
+        "-dir",
+        type=str,
+        default="/private/tmp/benchmark_datasets/bench_2k/images/",
+        help="Directory containing JPEG images",
+    )
+    parser.add_argument("--batch-size", "-b", type=int, default=32, help="Batch size (default: 32)")
+    parser.add_argument("--epochs", "-e", type=int, default=3, help="Number of epochs (default: 3)")
+    parser.add_argument("--shuffle", "-s", action="store_true", help="Shuffle data")
+    parser.add_argument("--output", "-o", type=str, help="Output JSON file for results")
 
     args = parser.parse_args()
 
@@ -266,15 +273,15 @@ def main():
         image_dir=args.image_dir,
         batch_size=args.batch_size,
         num_epochs=args.epochs,
-        shuffle=args.shuffle
+        shuffle=args.shuffle,
     )
 
     # Save results if requested
     if args.output:
-        with open(args.output, 'w') as f:
+        with open(args.output, "w") as f:
             json.dump(results, f, indent=2)
         print(f"\nResults saved to {args.output}")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

{turboloader-2.2.0 → turboloader-2.3.2}/benchmarks/02_pytorch_naive.py

@@ -54,7 +54,7 @@ class ImageDataset(data.Dataset):
             transform: Optional torchvision transforms
         """
         self.image_dir = Path(image_dir)
-        self.image_files = sorted(self.image_dir.glob('*.jpg'))
+        self.image_files = sorted(self.image_dir.glob("*.jpg"))
         self.transform = transform
 
         if len(self.image_files) == 0:
@@ -68,7 +68,7 @@ class ImageDataset(data.Dataset):
         img_path = self.image_files[idx]
 
         # Load image with PIL
-        image = Image.open(img_path).convert('RGB')
+        image = Image.open(img_path).convert("RGB")
 
         # Apply transforms
         if self.transform is not None:
@@ -87,21 +87,19 @@ def get_transforms():
     Returns:
         torchvision.transforms.Compose
     """
-    return transforms.Compose([
-        transforms.Resize(256),
-        transforms.CenterCrop(224),
-        transforms.ToTensor(),
-        transforms.Normalize(
-            mean=[0.485, 0.456, 0.406],
-            std=[0.229, 0.224, 0.225]
-        )
-    ])
-
-
-def run_benchmark(image_dir: str,
-                  batch_size: int = 32,
-                  num_workers: int = 4,
-                  num_epochs: int = 3) -> Dict[str, Any]:
+    return transforms.Compose(
+        [
+            transforms.Resize(256),
+            transforms.CenterCrop(224),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+        ]
+    )
+
+
+def run_benchmark(
+    image_dir: str, batch_size: int = 32, num_workers: int = 4, num_epochs: int = 3
+) -> Dict[str, Any]:
     """
     Run naive PyTorch DataLoader benchmark.
 
@@ -114,20 +112,17 @@ def run_benchmark(image_dir: str,
     Returns:
         Dictionary with benchmark results
     """
-    print("="*80)
+    print("=" * 80)
     print("NAIVE PYTORCH DATALOADER BENCHMARK")
-    print("="*80)
+    print("=" * 80)
     print(f"Dataset: {image_dir}")
     print(f"Batch size: {batch_size}")
     print(f"Num workers: {num_workers}")
     print(f"Epochs: {num_epochs}")
-    print("="*80)
+    print("=" * 80)
 
     # Create dataset
-    dataset = ImageDataset(
-        image_dir=image_dir,
-        transform=get_transforms()
-    )
+    dataset = ImageDataset(image_dir=image_dir, transform=get_transforms())
 
     print(f"\nDataset initialized:")
     print(f"  Total images: {len(dataset)}")
@@ -141,7 +136,7 @@ def run_benchmark(image_dir: str,
         num_workers=num_workers,
         pin_memory=False,  # Naive: no pin_memory
         prefetch_factor=2,  # Default PyTorch prefetch
-        persistent_workers=False  # Naive: restart workers each epoch
+        persistent_workers=False,  # Naive: restart workers each epoch
     )
 
     # Track metrics
@@ -189,50 +184,57 @@ def run_benchmark(image_dir: str,
 
     # Calculate statistics
     results = {
-        'framework': 'PyTorch Naive DataLoader',
-        'batch_size': batch_size,
-        'num_workers': num_workers,
-        'num_epochs': num_epochs,
-        'persistent_workers': False,
-        'pin_memory': False,
-        'total_time': total_time,
-        'epoch_times': epoch_times,
-        'avg_epoch_time': np.mean(epoch_times),
-        'std_epoch_time': np.std(epoch_times),
-        'avg_batch_time': np.mean(batch_times),
-        'std_batch_time': np.std(batch_times),
-        'throughput': len(dataset) * num_epochs / total_time,
-        'peak_memory_mb': max(memory_usage) if memory_usage else 0,
-        'avg_memory_mb': np.mean(memory_usage) if memory_usage else 0,
+        "framework": "PyTorch Naive DataLoader",
+        "batch_size": batch_size,
+        "num_workers": num_workers,
+        "num_epochs": num_epochs,
+        "persistent_workers": False,
+        "pin_memory": False,
+        "total_time": total_time,
+        "epoch_times": epoch_times,
+        "avg_epoch_time": np.mean(epoch_times),
+        "std_epoch_time": np.std(epoch_times),
+        "avg_batch_time": np.mean(batch_times),
+        "std_batch_time": np.std(batch_times),
+        "throughput": len(dataset) * num_epochs / total_time,
+        "peak_memory_mb": max(memory_usage) if memory_usage else 0,
+        "avg_memory_mb": np.mean(memory_usage) if memory_usage else 0,
     }
 
     # Print summary
-    print("\n" + "="*80)
+    print("\n" + "=" * 80)
     print("BENCHMARK RESULTS")
-    print("="*80)
+    print("=" * 80)
     print(f"Total time: {total_time:.2f}s")
-    print(f"Average epoch time: {results['avg_epoch_time']:.2f}s ± {results['std_epoch_time']:.2f}s")
-    print(f"Average batch time: {results['avg_batch_time']*1000:.2f}ms ± {results['std_batch_time']*1000:.2f}ms")
+    print(
+        f"Average epoch time: {results['avg_epoch_time']:.2f}s ± {results['std_epoch_time']:.2f}s"
+    )
+    print(
+        f"Average batch time: {results['avg_batch_time']*1000:.2f}ms ± {results['std_batch_time']*1000:.2f}ms"
+    )
     print(f"Throughput: {results['throughput']:.1f} images/sec")
     print(f"Peak memory: {results['peak_memory_mb']:.1f} MB")
     print(f"Average memory: {results['avg_memory_mb']:.1f} MB")
-    print("="*80)
+    print("=" * 80)
 
     return results
 
 
 def main():
-    parser = argparse.ArgumentParser(description='Naive PyTorch DataLoader benchmark')
-    parser.add_argument('--image-dir', '-dir', type=str, default="/private/tmp/benchmark_datasets/bench_2k/images/",
-                        help='Directory containing JPEG images')
-    parser.add_argument('--batch-size', '-b', type=int, default=32,
-                       help='Batch size (default: 32)')
-    parser.add_argument('--num-workers', '-w', type=int, default=4,
-                       help='Number of worker processes (default: 4)')
-    parser.add_argument('--epochs', '-e', type=int, default=3,
-                       help='Number of epochs (default: 3)')
-    parser.add_argument('--output', '-o', type=str,
-                       help='Output JSON file for results')
+    parser = argparse.ArgumentParser(description="Naive PyTorch DataLoader benchmark")
+    parser.add_argument(
+        "--image-dir",
+        "-dir",
+        type=str,
+        default="/private/tmp/benchmark_datasets/bench_2k/images/",
+        help="Directory containing JPEG images",
+    )
+    parser.add_argument("--batch-size", "-b", type=int, default=32, help="Batch size (default: 32)")
+    parser.add_argument(
+        "--num-workers", "-w", type=int, default=4, help="Number of worker processes (default: 4)"
+    )
+    parser.add_argument("--epochs", "-e", type=int, default=3, help="Number of epochs (default: 3)")
+    parser.add_argument("--output", "-o", type=str, help="Output JSON file for results")
 
     args = parser.parse_args()
 
@@ -241,15 +243,15 @@ def main():
         image_dir=args.image_dir,
         batch_size=args.batch_size,
         num_workers=args.num_workers,
-        num_epochs=args.epochs
+        num_epochs=args.epochs,
     )
 
     # Save results if requested
     if args.output:
-        with open(args.output, 'w') as f:
+        with open(args.output, "w") as f:
             json.dump(results, f, indent=2)
         print(f"\nResults saved to {args.output}")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

{turboloader-2.2.0 → turboloader-2.3.2}/benchmarks/03_pytorch_optimized.py

@@ -41,7 +41,7 @@ class ImageDataset(data.Dataset):
 
     def __init__(self, image_dir: str, transform=None):
         self.image_dir = Path(image_dir)
-        self.image_files = sorted(self.image_dir.glob('*.jpg'))
+        self.image_files = sorted(self.image_dir.glob("*.jpg"))
         self.transform = transform
 
         if len(self.image_files) == 0:
@@ -52,7 +52,7 @@ class ImageDataset(data.Dataset):
 
     def __getitem__(self, idx):
         img_path = self.image_files[idx]
-        image = Image.open(img_path).convert('RGB')
+        image = Image.open(img_path).convert("RGB")
 
         if self.transform is not None:
             image = self.transform(image)
@@ -63,21 +63,19 @@ class ImageDataset(data.Dataset):
 
 def get_transforms():
     """Get optimized ImageNet-style transforms"""
-    return transforms.Compose([
-        transforms.Resize(256),
-        transforms.CenterCrop(224),
-        transforms.ToTensor(),
-        transforms.Normalize(
-            mean=[0.485, 0.456, 0.406],
-            std=[0.229, 0.224, 0.225]
-        )
-    ])
-
-
-def run_benchmark(image_dir: str,
-                  batch_size: int = 32,
-                  num_workers: int = 8,
-                  num_epochs: int = 3) -> Dict[str, Any]:
+    return transforms.Compose(
+        [
+            transforms.Resize(256),
+            transforms.CenterCrop(224),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+        ]
+    )
+
+
+def run_benchmark(
+    image_dir: str, batch_size: int = 32, num_workers: int = 8, num_epochs: int = 3
+) -> Dict[str, Any]:
     """
     Run optimized PyTorch DataLoader benchmark.
 
@@ -90,21 +88,18 @@ def run_benchmark(image_dir: str,
     Returns:
         Dictionary with benchmark results
     """
-    print("="*80)
+    print("=" * 80)
     print("OPTIMIZED PYTORCH DATALOADER BENCHMARK")
-    print("="*80)
+    print("=" * 80)
     print(f"Dataset: {image_dir}")
     print(f"Batch size: {batch_size}")
     print(f"Num workers: {num_workers}")
     print(f"Epochs: {num_epochs}")
     print(f"Optimizations: pin_memory=True, persistent_workers=True, prefetch_factor=4")
-    print("="*80)
+    print("=" * 80)
 
     # Create dataset
-    dataset = ImageDataset(
-        image_dir=image_dir,
-        transform=get_transforms()
-    )
+    dataset = ImageDataset(image_dir=image_dir, transform=get_transforms())
 
     print(f"\nDataset initialized:")
     print(f"  Total images: {len(dataset)}")
@@ -118,7 +113,7 @@ def run_benchmark(image_dir: str,
         num_workers=num_workers,
         pin_memory=True,  # Optimized: pin memory for faster GPU transfer
         prefetch_factor=4,  # Optimized: increased prefetching
-        persistent_workers=True  # Optimized: keep workers alive between epochs
+        persistent_workers=True,  # Optimized: keep workers alive between epochs
     )
 
     # Track metrics
@@ -166,51 +161,58 @@ def run_benchmark(image_dir: str,
 
     # Calculate statistics
     results = {
-        'framework': 'PyTorch Optimized DataLoader',
-        'batch_size': batch_size,
-        'num_workers': num_workers,
-        'num_epochs': num_epochs,
-        'persistent_workers': True,
-        'pin_memory': True,
-        'prefetch_factor': 4,
-        'total_time': total_time,
-        'epoch_times': epoch_times,
-        'avg_epoch_time': np.mean(epoch_times),
-        'std_epoch_time': np.std(epoch_times),
-        'avg_batch_time': np.mean(batch_times),
-        'std_batch_time': np.std(batch_times),
-        'throughput': len(dataset) * num_epochs / total_time,
-        'peak_memory_mb': max(memory_usage) if memory_usage else 0,
-        'avg_memory_mb': np.mean(memory_usage) if memory_usage else 0,
+        "framework": "PyTorch Optimized DataLoader",
+        "batch_size": batch_size,
+        "num_workers": num_workers,
+        "num_epochs": num_epochs,
+        "persistent_workers": True,
+        "pin_memory": True,
+        "prefetch_factor": 4,
+        "total_time": total_time,
+        "epoch_times": epoch_times,
+        "avg_epoch_time": np.mean(epoch_times),
+        "std_epoch_time": np.std(epoch_times),
+        "avg_batch_time": np.mean(batch_times),
+        "std_batch_time": np.std(batch_times),
+        "throughput": len(dataset) * num_epochs / total_time,
+        "peak_memory_mb": max(memory_usage) if memory_usage else 0,
+        "avg_memory_mb": np.mean(memory_usage) if memory_usage else 0,
     }
 
     # Print summary
-    print("\n" + "="*80)
+    print("\n" + "=" * 80)
     print("BENCHMARK RESULTS")
-    print("="*80)
+    print("=" * 80)
     print(f"Total time: {total_time:.2f}s")
-    print(f"Average epoch time: {results['avg_epoch_time']:.2f}s ± {results['std_epoch_time']:.2f}s")
-    print(f"Average batch time: {results['avg_batch_time']*1000:.2f}ms ± {results['std_batch_time']*1000:.2f}ms")
+    print(
+        f"Average epoch time: {results['avg_epoch_time']:.2f}s ± {results['std_epoch_time']:.2f}s"
+    )
+    print(
+        f"Average batch time: {results['avg_batch_time']*1000:.2f}ms ± {results['std_batch_time']*1000:.2f}ms"
+    )
     print(f"Throughput: {results['throughput']:.1f} images/sec")
     print(f"Peak memory: {results['peak_memory_mb']:.1f} MB")
     print(f"Average memory: {results['avg_memory_mb']:.1f} MB")
-    print("="*80)
+    print("=" * 80)
 
     return results
 
 
 def main():
-    parser = argparse.ArgumentParser(description='Optimized PyTorch DataLoader benchmark')
-    parser.add_argument('--image-dir', '-dir', type=str, default="/private/tmp/benchmark_datasets/bench_2k/images/",
-                        help='Directory containing JPEG images')
-    parser.add_argument('--batch-size', '-b', type=int, default=32,
-                       help='Batch size (default: 32)')
-    parser.add_argument('--num-workers', '-w', type=int, default=8,
-                       help='Number of worker processes (default: 8)')
-    parser.add_argument('--epochs', '-e', type=int, default=3,
-                       help='Number of epochs (default: 3)')
-    parser.add_argument('--output', '-o', type=str,
-                       help='Output JSON file for results')
+    parser = argparse.ArgumentParser(description="Optimized PyTorch DataLoader benchmark")
+    parser.add_argument(
+        "--image-dir",
+        "-dir",
+        type=str,
+        default="/private/tmp/benchmark_datasets/bench_2k/images/",
+        help="Directory containing JPEG images",
+    )
+    parser.add_argument("--batch-size", "-b", type=int, default=32, help="Batch size (default: 32)")
+    parser.add_argument(
+        "--num-workers", "-w", type=int, default=8, help="Number of worker processes (default: 8)"
+    )
+    parser.add_argument("--epochs", "-e", type=int, default=3, help="Number of epochs (default: 3)")
+    parser.add_argument("--output", "-o", type=str, help="Output JSON file for results")
 
     args = parser.parse_args()
 
@@ -219,15 +221,15 @@ def main():
         image_dir=args.image_dir,
         batch_size=args.batch_size,
         num_workers=args.num_workers,
-        num_epochs=args.epochs
+        num_epochs=args.epochs,
     )
 
     # Save results if requested
     if args.output:
-        with open(args.output, 'w') as f:
+        with open(args.output, "w") as f:
             json.dump(results, f, indent=2)
         print(f"\nResults saved to {args.output}")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()