argus-cv 1.3.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

argus/__init__.py

@@ -1,3 +1,3 @@
 """Argus - Vision AI dataset toolkit."""
 
-__version__ = "1.3.0"
+__version__ = "1.5.0"

argus/cli.py

@@ -8,11 +8,18 @@ import cv2
 import numpy as np
 import typer
 from rich.console import Console
-from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.progress import (
+    BarColumn,
+    Progress,
+    SpinnerColumn,
+    TaskProgressColumn,
+    TextColumn,
+)
 from rich.table import Table
 
 from argus.core import COCODataset, Dataset, MaskDataset, YOLODataset
 from argus.core.base import DatasetFormat, TaskType
+from argus.core.convert import convert_mask_to_yolo_seg
 from argus.core.split import (
     is_coco_unsplit,
     parse_ratio,
@@ -534,13 +541,6 @@ def split_dataset(
             help="Train/val/test ratio (e.g. 0.8,0.1,0.1).",
         ),
     ] = "0.8,0.1,0.1",
-    stratify: Annotated[
-        bool,
-        typer.Option(
-            "--stratify/--no-stratify",
-            help="Stratify by class distribution when splitting.",
-        ),
-    ] = True,
     seed: Annotated[
         int,
         typer.Option(
@@ -593,9 +593,7 @@ def split_dataset(
         ) as progress:
             progress.add_task("Creating YOLO splits...", total=None)
             try:
-                counts = split_yolo_dataset(
-                    dataset, output_path, ratios, stratify, seed
-                )
+                counts = split_yolo_dataset(dataset, output_path, ratios, True, seed)
             except ValueError as exc:
                 console.print(f"[red]Error: {exc}[/red]")
                 raise typer.Exit(1) from exc
@@ -628,7 +626,7 @@ def split_dataset(
                     annotation_file,
                     output_path,
                     ratios,
-                    stratify,
+                    True,
                     seed,
                 )
             except ValueError as exc:
@@ -641,6 +639,148 @@ def split_dataset(
     )
 
 
+@app.command(name="convert")
+def convert_dataset(
+    input_path: Annotated[
+        Path,
+        typer.Option(
+            "--input-path",
+            "-i",
+            help="Path to the source dataset.",
+        ),
+    ] = Path("."),
+    output_path: Annotated[
+        Path,
+        typer.Option(
+            "--output-path",
+            "-o",
+            help="Output directory for converted dataset.",
+        ),
+    ] = Path("converted"),
+    to_format: Annotated[
+        str,
+        typer.Option(
+            "--to",
+            help="Target format (currently only 'yolo-seg' is supported).",
+        ),
+    ] = "yolo-seg",
+    epsilon_factor: Annotated[
+        float,
+        typer.Option(
+            "--epsilon-factor",
+            "-e",
+            help="Polygon simplification factor (Douglas-Peucker algorithm).",
+            min=0.0,
+            max=1.0,
+        ),
+    ] = 0.005,
+    min_area: Annotated[
+        float,
+        typer.Option(
+            "--min-area",
+            "-a",
+            help="Minimum contour area in pixels to include.",
+            min=0.0,
+        ),
+    ] = 100.0,
+) -> None:
+    """Convert a dataset from one format to another.
+
+    Currently supports converting MaskDataset to YOLO segmentation format.
+
+    Example:
+        uvx argus-cv convert -i /path/to/masks -o /path/to/output --to yolo-seg
+    """
+    # Validate format
+    if to_format != "yolo-seg":
+        console.print(
+            f"[red]Error: Unsupported target format '{to_format}'.[/red]\n"
+            "[yellow]Currently only 'yolo-seg' is supported.[/yellow]"
+        )
+        raise typer.Exit(1)
+
+    # Resolve and validate input path
+    input_path = input_path.resolve()
+    if not input_path.exists():
+        console.print(f"[red]Error: Path does not exist: {input_path}[/red]")
+        raise typer.Exit(1)
+    if not input_path.is_dir():
+        console.print(f"[red]Error: Path is not a directory: {input_path}[/red]")
+        raise typer.Exit(1)
+
+    # Detect source dataset - must be MaskDataset for yolo-seg conversion
+    dataset = MaskDataset.detect(input_path)
+    if not dataset:
+        console.print(
+            f"[red]Error: No MaskDataset found at {input_path}[/red]\n"
+            "[yellow]Ensure the path contains images/ + masks/ directories "
+            "(or equivalent patterns like img/+gt/ or leftImg8bit/+gtFine/).[/yellow]"
+        )
+        raise typer.Exit(1)
+
+    # Resolve output path
+    if not output_path.is_absolute():
+        output_path = input_path.parent / output_path
+    output_path = output_path.resolve()
+
+    # Check if output already exists
+    if output_path.exists() and any(output_path.iterdir()):
+        console.print(
+            f"[red]Error: Output directory already exists and is not empty: "
+            f"{output_path}[/red]"
+        )
+        raise typer.Exit(1)
+
+    # Show conversion info
+    console.print("[cyan]Converting MaskDataset to YOLO segmentation format[/cyan]")
+    console.print(f"  Source: {input_path}")
+    console.print(f"  Output: {output_path}")
+    console.print(f"  Classes: {dataset.num_classes}")
+    splits_str = ", ".join(dataset.splits) if dataset.splits else "unsplit"
+    console.print(f"  Splits: {splits_str}")
+    console.print()
+
+    # Run conversion with progress bar
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TaskProgressColumn(),
+        console=console,
+    ) as progress:
+        task = progress.add_task("Processing images...", total=None)
+
+        def update_progress(current: int, total: int) -> None:
+            progress.update(task, completed=current, total=total)
+
+        try:
+            stats = convert_mask_to_yolo_seg(
+                dataset=dataset,
+                output_path=output_path,
+                epsilon_factor=epsilon_factor,
+                min_area=min_area,
+                progress_callback=update_progress,
+            )
+        except Exception as exc:
+            console.print(f"[red]Error during conversion: {exc}[/red]")
+            raise typer.Exit(1) from exc
+
+    # Show results
+    console.print()
+    console.print("[green]Conversion complete![/green]")
+    console.print(f"  Images processed: {stats['images']}")
+    console.print(f"  Labels created: {stats['labels']}")
+    console.print(f"  Polygons extracted: {stats['polygons']}")
+
+    if stats["skipped"] > 0:
+        skipped = stats["skipped"]
+        console.print(f"  [yellow]Skipped: {skipped} (no mask or empty)[/yellow]")
+    if stats["warnings"] > 0:
+        console.print(f"  [yellow]Warnings: {stats['warnings']}[/yellow]")
+
+    console.print(f"\n[cyan]Output dataset: {output_path}[/cyan]")
+
+
 class _ImageViewer:
     """Interactive image viewer with zoom and pan support."""
 
@@ -1352,9 +1492,12 @@ def _draw_annotations(
             overlay = img.copy()
             cv2.fillPoly(overlay, [pts], color)
             cv2.addWeighted(overlay, 0.3, img, 0.7, 0, img)
+            # Draw small points at polygon vertices
+            for pt in pts:
+                cv2.circle(img, tuple(pt), radius=3, color=color, thickness=-1)
 
-        # Draw bounding box
-        if bbox:
+        # Draw bounding box (only for detection, not segmentation)
+        if bbox and not polygon:
             x, y, w, h = bbox
             x1, y1 = int(x), int(y)
             x2, y2 = int(x + w), int(y + h)

argus/core/__init__.py

@@ -2,6 +2,13 @@
 
 from argus.core.base import Dataset
 from argus.core.coco import COCODataset
+from argus.core.convert import (
+    ConversionParams,
+    Polygon,
+    convert_mask_to_yolo_labels,
+    convert_mask_to_yolo_seg,
+    mask_to_polygons,
+)
 from argus.core.mask import ConfigurationError, MaskDataset
 from argus.core.split import split_coco_dataset, split_yolo_dataset
 from argus.core.yolo import YOLODataset
@@ -14,4 +21,9 @@ __all__ = [
     "ConfigurationError",
     "split_coco_dataset",
     "split_yolo_dataset",
+    "ConversionParams",
+    "Polygon",
+    "mask_to_polygons",
+    "convert_mask_to_yolo_labels",
+    "convert_mask_to_yolo_seg",
 ]

argus/core/coco.py

@@ -75,6 +75,13 @@ class COCODataset(Dataset):
         # Also check root directory for single annotation file
         annotation_files.extend(path.glob("*.json"))
 
+        # Check split directories for Roboflow COCO format
+        for split_name in ["train", "valid", "val", "test"]:
+            split_dir = path / split_name
+            if split_dir.is_dir():
+                annotation_files.extend(split_dir.glob("*annotations*.json"))
+                annotation_files.extend(split_dir.glob("*coco*.json"))
+
         # Filter to only include files that might be COCO annotations
         # (exclude package.json, tsconfig.json, etc.)
         filtered_files = []
@@ -185,8 +192,10 @@ class COCODataset(Dataset):
                     if isinstance(cat, dict) and "id" in cat and "name" in cat:
                         id_to_name[cat["id"]] = cat["name"]
 
-                # Determine split from filename
-                split = self._get_split_from_filename(ann_file.stem)
+                # Determine split from filename or parent directory
+                split = self._get_split_from_filename(
+                    ann_file.stem, ann_file.parent.name
+                )
 
                 # Count annotations per category
                 split_counts: dict[str, int] = counts.get(split, {})
@@ -224,7 +233,9 @@ class COCODataset(Dataset):
                 if not isinstance(data, dict):
                     continue
 
-                split = self._get_split_from_filename(ann_file.stem)
+                split = self._get_split_from_filename(
+                    ann_file.stem, ann_file.parent.name
+                )
 
                 images = data.get("images", [])
                 annotations = data.get("annotations", [])
@@ -256,11 +267,12 @@ class COCODataset(Dataset):
         return counts
 
     @staticmethod
-    def _get_split_from_filename(filename: str) -> str:
-        """Extract split name from annotation filename.
+    def _get_split_from_filename(filename: str, parent_dir: str | None = None) -> str:
+        """Extract split name from annotation filename or parent directory.
 
         Args:
             filename: Annotation file stem (without extension).
+            parent_dir: Optional parent directory name (for Roboflow COCO format).
 
         Returns:
             Split name (train, val, test) or 'train' as default.
@@ -272,6 +284,17 @@ class COCODataset(Dataset):
             return "val"
         elif "test" in name_lower:
             return "test"
+
+        # Check parent directory name (Roboflow COCO format)
+        if parent_dir:
+            parent_lower = parent_dir.lower()
+            if parent_lower == "train":
+                return "train"
+            elif parent_lower in ("val", "valid"):
+                return "val"
+            elif parent_lower == "test":
+                return "test"
+
         return "train"
 
     @classmethod
@@ -301,7 +324,7 @@ class COCODataset(Dataset):
 
     @classmethod
     def _detect_splits(cls, annotation_files: list[Path]) -> list[str]:
-        """Detect available splits from annotation filenames.
+        """Detect available splits from annotation filenames or parent directories.
 
         Args:
             annotation_files: List of annotation file paths.
@@ -313,13 +336,22 @@ class COCODataset(Dataset):
 
         for ann_file in annotation_files:
             name_lower = ann_file.stem.lower()
+            parent_lower = ann_file.parent.name.lower()
 
+            # Check filename first
             if "train" in name_lower and "train" not in splits:
                 splits.append("train")
             elif "val" in name_lower and "val" not in splits:
                 splits.append("val")
             elif "test" in name_lower and "test" not in splits:
                 splits.append("test")
+            # Check parent directory (Roboflow COCO format)
+            elif parent_lower == "train" and "train" not in splits:
+                splits.append("train")
+            elif parent_lower in ("val", "valid") and "val" not in splits:
+                splits.append("val")
+            elif parent_lower == "test" and "test" not in splits:
+                splits.append("test")
 
         # If no splits detected from filenames, default to train
         if not splits:
@@ -342,7 +374,9 @@ class COCODataset(Dataset):
         for ann_file in self.annotation_files:
             # Filter by split if specified
             if split:
-                file_split = self._get_split_from_filename(ann_file.stem)
+                file_split = self._get_split_from_filename(
+                    ann_file.stem, ann_file.parent.name
+                )
                 if file_split != split:
                     continue
 
@@ -354,7 +388,9 @@ class COCODataset(Dataset):
                     continue
 
                 images = data.get("images", [])
-                file_split = self._get_split_from_filename(ann_file.stem)
+                file_split = self._get_split_from_filename(
+                    ann_file.stem, ann_file.parent.name
+                )
 
                 for img in images:
                     if not isinstance(img, dict) or "file_name" not in img:
@@ -371,6 +407,8 @@ class COCODataset(Dataset):
                         self.path / "images" / file_name,
                         self.path / file_split / file_name,
                         self.path / file_name,
+                        # Roboflow format: images alongside annotations
+                        ann_file.parent / file_name,
                     ]
 
                     for img_path in possible_paths:

argus/core/convert.py

@@ -0,0 +1,277 @@
+"""Conversion functions for dataset format transformation."""
+
+import logging
+import shutil
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+
+import cv2
+import numpy as np
+import yaml
+from numpy.typing import NDArray
+
+from argus.core.mask import MaskDataset
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ConversionParams:
+    """Parameters for mask-to-polygon conversion.
+
+    Attributes:
+        class_id: Class ID for the resulting polygon.
+        epsilon_factor: Douglas-Peucker simplification factor (relative to perimeter).
+        min_area: Minimum contour area in pixels to include.
+    """
+
+    class_id: int = 0
+    epsilon_factor: float = 0.005
+    min_area: float = 100.0
+
+
+@dataclass
+class Polygon:
+    """A polygon annotation with class ID and normalized points.
+
+    Attributes:
+        class_id: Class ID for this polygon.
+        points: List of (x, y) points normalized to [0, 1].
+    """
+
+    class_id: int
+    points: list[tuple[float, float]]
+
+    def to_yolo(self) -> str:
+        """Convert to YOLO segmentation format string.
+
+        Returns:
+            String in format: "class_id x1 y1 x2 y2 ... xn yn"
+        """
+        coords = " ".join(f"{x:.6f} {y:.6f}" for x, y in self.points)
+        return f"{self.class_id} {coords}"
+
+
+def mask_to_polygons(
+    mask: NDArray[np.uint8],
+    params: ConversionParams | None = None,
+) -> list[Polygon]:
+    """Convert a binary mask to simplified polygons.
+
+    Args:
+        mask: Binary mask (255 for foreground, 0 for background).
+        params: Conversion parameters. Uses defaults if None.
+
+    Returns:
+        List of Polygon objects with normalized coordinates.
+    """
+    if params is None:
+        params = ConversionParams()
+
+    h, w = mask.shape[:2]
+    polygons: list[Polygon] = []
+
+    # Find contours
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+    for contour in contours:
+        area = cv2.contourArea(contour)
+        if area < params.min_area:
+            continue
+
+        # Simplify polygon using Douglas-Peucker
+        perimeter = cv2.arcLength(contour, closed=True)
+        epsilon = params.epsilon_factor * perimeter
+        simplified = cv2.approxPolyDP(contour, epsilon, closed=True)
+
+        # Need at least 3 points for a valid polygon
+        if len(simplified) < 3:
+            continue
+
+        # Normalize coordinates to [0, 1]
+        points: list[tuple[float, float]] = []
+        for point in simplified:
+            x, y = point[0]
+            points.append((x / w, y / h))
+
+        polygons.append(Polygon(class_id=params.class_id, points=points))
+
+    return polygons
+
+
+def convert_mask_to_yolo_labels(
+    mask: np.ndarray,
+    class_ids: list[int],
+    epsilon_factor: float = 0.005,
+    min_area: float = 100.0,
+) -> list[str]:
+    """Convert a multi-class mask to YOLO label lines.
+
+    Args:
+        mask: Grayscale mask where pixel values represent class IDs.
+        class_ids: List of class IDs to extract (excluding ignore index).
+        epsilon_factor: Douglas-Peucker simplification factor.
+        min_area: Minimum contour area in pixels.
+
+    Returns:
+        List of YOLO format label strings.
+    """
+    lines: list[str] = []
+
+    for class_id in class_ids:
+        # Create binary mask for this class
+        binary_mask = (mask == class_id).astype(np.uint8) * 255
+
+        params = ConversionParams(
+            class_id=class_id,
+            epsilon_factor=epsilon_factor,
+            min_area=min_area,
+        )
+        polygons = mask_to_polygons(binary_mask, params)
+        lines.extend(poly.to_yolo() for poly in polygons)
+
+    return lines
+
+
+def convert_mask_to_yolo_seg(
+    dataset: MaskDataset,
+    output_path: Path,
+    epsilon_factor: float = 0.005,
+    min_area: float = 100.0,
+    progress_callback: Callable[[int, int], None] | None = None,
+) -> dict[str, int]:
+    """Convert a MaskDataset to YOLO segmentation format.
+
+    Args:
+        dataset: Source MaskDataset to convert.
+        output_path: Output directory for YOLO dataset.
+        epsilon_factor: Douglas-Peucker simplification factor.
+        min_area: Minimum contour area in pixels.
+        progress_callback: Optional callback(current, total) for progress updates.
+
+    Returns:
+        Dictionary with conversion statistics:
+        - "images": Total images processed
+        - "labels": Total label files created
+        - "polygons": Total polygons extracted
+        - "skipped": Images skipped (no mask or empty)
+        - "warnings": Number of warnings (dimension mismatch, etc.)
+    """
+    stats = {
+        "images": 0,
+        "labels": 0,
+        "polygons": 0,
+        "skipped": 0,
+        "warnings": 0,
+    }
+
+    # Create output directory structure
+    output_path.mkdir(parents=True, exist_ok=True)
+
+    # Get class mapping and build id-to-name for data.yaml
+    class_mapping = dataset.get_class_mapping()
+    class_ids = sorted(class_mapping.keys())
+
+    # Build data.yaml content
+    data_yaml: dict = {
+        "path": ".",
+        "names": {i: class_mapping[i] for i in class_ids},
+    }
+
+    # Determine splits to process
+    splits = dataset.splits if dataset.splits else [None]
+
+    # Count total images for progress
+    total_images = 0
+    for split in splits:
+        total_images += len(dataset.get_image_paths(split))
+
+    current_image = 0
+
+    for split in splits:
+        split_name = split if split else "train"  # Default to train if unsplit
+
+        # Create directories
+        images_dir = output_path / "images" / split_name
+        labels_dir = output_path / "labels" / split_name
+        images_dir.mkdir(parents=True, exist_ok=True)
+        labels_dir.mkdir(parents=True, exist_ok=True)
+
+        # Add split to data.yaml
+        data_yaml[split_name] = f"images/{split_name}"
+
+        # Process images in this split
+        image_paths = dataset.get_image_paths(split)
+
+        for image_path in image_paths:
+            current_image += 1
+            if progress_callback:
+                progress_callback(current_image, total_images)
+
+            stats["images"] += 1
+
+            # Load mask
+            mask = dataset.load_mask(image_path)
+            if mask is None:
+                logger.warning(f"No mask found for {image_path.name}, skipping")
+                stats["skipped"] += 1
+                continue
+
+            # Load image to check dimensions
+            img = cv2.imread(str(image_path))
+            if img is None:
+                logger.warning(f"Could not load image {image_path.name}, skipping")
+                stats["skipped"] += 1
+                continue
+
+            # Check dimension match
+            if img.shape[:2] != mask.shape[:2]:
+                logger.warning(
+                    f"Dimension mismatch for {image_path.name}: "
+                    f"image={img.shape[:2]}, mask={mask.shape[:2]}"
+                )
+                stats["warnings"] += 1
+                # Continue anyway - mask might still be usable
+
+            # Get unique class IDs present in this mask (excluding ignore index)
+            unique_ids = [
+                int(v)
+                for v in np.unique(mask)
+                if v != dataset.ignore_index and v in class_ids
+            ]
+
+            if not unique_ids:
+                # Empty mask (only background/ignored)
+                logger.debug(f"Empty mask for {image_path.name}")
+                stats["skipped"] += 1
+                continue
+
+            # Convert mask to YOLO labels
+            label_lines = convert_mask_to_yolo_labels(
+                mask, unique_ids, epsilon_factor, min_area
+            )
+
+            if not label_lines:
+                # No polygons extracted (all contours too small)
+                logger.debug(f"No valid polygons for {image_path.name}")
+                stats["skipped"] += 1
+                continue
+
+            # Copy image to output
+            dest_image = images_dir / image_path.name
+            shutil.copy2(image_path, dest_image)
+
+            # Write label file
+            label_file = labels_dir / f"{image_path.stem}.txt"
+            label_file.write_text("\n".join(label_lines) + "\n")
+
+            stats["labels"] += 1
+            stats["polygons"] += len(label_lines)
+
+    # Write data.yaml
+    data_yaml_path = output_path / "data.yaml"
+    with open(data_yaml_path, "w") as f:
+        yaml.dump(data_yaml, f, default_flow_style=False, sort_keys=False)
+
+    return stats

argus/core/yolo.py

@@ -1,5 +1,6 @@
 """YOLO dataset detection and handling."""
 
+import json
 from dataclasses import dataclass, field
 from pathlib import Path
 
@@ -200,6 +201,12 @@ class YOLODataset(Dataset):
         if not class_dirs:
             return None
 
+        # Check if any directory contains COCO annotation files
+        # (Roboflow COCO datasets have train/valid/test dirs with JSON files)
+        for class_dir in class_dirs:
+            if cls._has_coco_annotation(class_dir):
+                return None  # Not a classification dataset
+
         # Check if these are class directories (contain images directly)
         class_names_set = set()
         for class_dir in class_dirs:
@@ -225,6 +232,28 @@ class YOLODataset(Dataset):
             config_file=None,
         )
 
+    @staticmethod
+    def _has_coco_annotation(directory: Path) -> bool:
+        """Check if directory contains COCO annotation files.
+
+        Args:
+            directory: Directory to check.
+
+        Returns:
+            True if COCO annotation files are found, False otherwise.
+        """
+        for f in directory.glob("*.json"):
+            try:
+                with open(f, encoding="utf-8") as fp:
+                    data = json.load(fp)
+                if isinstance(data, dict) and any(
+                    k in data for k in ["images", "annotations", "categories"]
+                ):
+                    return True
+            except (json.JSONDecodeError, OSError):
+                pass
+        return False
+
     def get_instance_counts(self) -> dict[str, dict[str, int]]:
         """Get the number of annotation instances per class, per split.
 

{argus_cv-1.3.0.dist-info → argus_cv-1.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: argus-cv
-Version: 1.3.0
+Version: 1.5.0
 Summary: CLI tool for working with vision AI datasets
 Requires-Python: >=3.10
 Requires-Dist: numpy>=1.24.0
@@ -12,7 +12,7 @@ Description-Content-Type: text/markdown
 
 # argus-cv
 
-Vision AI dataset toolkit for working with YOLO and COCO datasets.
+Vision AI dataset toolkit for working with YOLO, COCO, and semantic mask datasets.
 
 **[Documentation](https://pirnerjonas.github.io/argus/)**
 
@@ -22,6 +22,13 @@ Vision AI dataset toolkit for working with YOLO and COCO datasets.
 uvx argus-cv
 ```
 
+## Highlights
+
+- Detects YOLO, COCO, and folder-based semantic mask datasets.
+- Reports per-class stats (pixel coverage for mask datasets).
+- Interactive viewer with bounding boxes, polygons, or mask overlays.
+- Split unsplit YOLO/COCO datasets into train/val/test.
+
 ## Usage
 
 ```bash

argus_cv-1.5.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+argus/__init__.py,sha256=-NDJwMF-NWlPd0dIFWTu3SjgVWZy8SJxBD9g3YQXfrY,64
+argus/__main__.py,sha256=63ezHx8eL_lCMoZrCbKhmpao0fmdvYVw1chbknGg-oI,104
+argus/cli.py,sha256=hQ4t69E-clFvn9ZIeQ4Rf7cAqC0TgPtz1HEAFqNajcg,52706
+argus/commands/__init__.py,sha256=i2oor9hpVpF-_1qZWCGDLwwi1pZGJfZnUKJZ_NMBG18,30
+argus/core/__init__.py,sha256=sP206E44GdnnjKwyWNvuWntvO7D8oy0qs1yUUaPDThI,738
+argus/core/base.py,sha256=WBrB7XWz125YZ1UQfHQwsYAuIFY_XGEhG_0ybgPhn6s,3696
+argus/core/coco.py,sha256=V3Ifh6KUbifBTLefUuMxQkejgkwsPZNfKLn0newDZJ4,17539
+argus/core/convert.py,sha256=cHuw1E9B4vyozpikS2PJnFfiJ_eRMPIHblizyeZz1Ps,8471
+argus/core/mask.py,sha256=m7Ztf4lAZx5ITpk3F3mETcvCC6hGydlxK0-2nCjeTfU,21835
+argus/core/split.py,sha256=kEWtbdg6bH-WiNFf83HkqZD90EL4gsavw6JiefuAETs,10776
+argus/core/yolo.py,sha256=Vtw2sga40VooaRE8bmjKtr_aYhfoV7ZcVijFjg1DVwo,29644
+argus_cv-1.5.0.dist-info/METADATA,sha256=9iwY-3C6t-vzZOA9wBvrvIY10YBUaHgsDRN5x5Uk_8c,1353
+argus_cv-1.5.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+argus_cv-1.5.0.dist-info/entry_points.txt,sha256=dvJFH7BkrOxJnifSjPhwq1YCafPaqdngWyBuFYE73yY,43
+argus_cv-1.5.0.dist-info/RECORD,,

argus_cv-1.3.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-argus/__init__.py,sha256=277ASQvH6ZWVWUzOCVB7vAxn3OYciow4nVkjG16-kio,64
-argus/__main__.py,sha256=63ezHx8eL_lCMoZrCbKhmpao0fmdvYVw1chbknGg-oI,104
-argus/cli.py,sha256=th1Rgn1Sm9juWoavopEXLBT8XEh5lKzOMX-pccwvDgA,47904
-argus/commands/__init__.py,sha256=i2oor9hpVpF-_1qZWCGDLwwi1pZGJfZnUKJZ_NMBG18,30
-argus/core/__init__.py,sha256=II2wYJpGUUGGKOFZ5BCpMIBTfv0WP-F15U_xbpWGjk8,453
-argus/core/base.py,sha256=WBrB7XWz125YZ1UQfHQwsYAuIFY_XGEhG_0ybgPhn6s,3696
-argus/core/coco.py,sha256=atVurZV2T7cszydyD9GfDTWHGYDd-JNK5RD7nse5avc,15823
-argus/core/mask.py,sha256=m7Ztf4lAZx5ITpk3F3mETcvCC6hGydlxK0-2nCjeTfU,21835
-argus/core/split.py,sha256=kEWtbdg6bH-WiNFf83HkqZD90EL4gsavw6JiefuAETs,10776
-argus/core/yolo.py,sha256=tTc9jJzXcwa8LQ_s8nv-D_i2b9k_x-LT1O0eWr4sZ2k,28616
-argus_cv-1.3.0.dist-info/METADATA,sha256=1CCYLSnGHaAdS5jjwUuTJWRHu5OM_oFfvi1L_v3SkQw,1070
-argus_cv-1.3.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-argus_cv-1.3.0.dist-info/entry_points.txt,sha256=dvJFH7BkrOxJnifSjPhwq1YCafPaqdngWyBuFYE73yY,43
-argus_cv-1.3.0.dist-info/RECORD,,