rfcli 0.1.0__py3-none-any.whl

rfcli/config.py

@@ -0,0 +1,9 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+ROBOFLOW_API_KEY = os.getenv("ROBOFLOW_API_KEY")
+
+if not ROBOFLOW_API_KEY:
+    raise ValueError("❌ ROBOFLOW_API_KEY not found in .env")

rfcli/convert.py

@@ -0,0 +1,51 @@
+import os
+import json
+
+
+def coco_to_yolo(json_path, dataset_path):
+
+    labels_dir = os.path.join(dataset_path, "labels")
+    os.makedirs(labels_dir, exist_ok=True)
+
+    with open(json_path) as f:
+        data = json.load(f)
+
+    images = {img["id"]: img for img in data["images"]}
+    annotations = data["annotations"]
+
+    categories = data["categories"]
+    cat_map = {cat["id"]: i for i, cat in enumerate(categories)}
+
+    ann_by_image = {}
+
+    for ann in annotations:
+        ann_by_image.setdefault(ann["image_id"], []).append(ann)
+
+    for img_id, img_data in images.items():
+
+        file_name = img_data["file_name"]
+        width = float(img_data["width"])
+        height = float(img_data["height"])
+
+        label_path = os.path.join(
+            labels_dir,
+            os.path.splitext(file_name)[0] + ".txt"
+        )
+
+        with open(label_path, "w") as f:
+
+            for ann in ann_by_image.get(img_id, []):
+
+                # 🔥 FIX: ensure numeric
+                x, y, w, h = map(float, ann["bbox"])
+
+                x_center = (x + w / 2) / width
+                y_center = (y + h / 2) / height
+                w /= width
+                h /= height
+
+                class_id = cat_map[ann["category_id"]]
+
+                f.write(f"{class_id} {x_center} {y_center} {w} {h}\n")
+
+    print("✅ COCO → YOLO conversion complete!")

rfcli/main.py

@@ -0,0 +1,70 @@
+import click
+from rich import print
+from rfcli.upload import upload_images, upload_dataset
+from rfcli.version import create_version
+from rfcli.train_local import train_local
+from rfcli.predict import predict
+
+
+@click.group()
+def cli():
+    """Roboflow CLI - Dataset to Deployment"""
+    pass
+
+
+# 🔹 Single image upload
+@cli.command()
+@click.option('--workspace', required=True)
+@click.option('--project', required=True)
+@click.option('--folder', required=True)
+def upload(workspace, project, folder):
+    print("[bold blue]🚀 Uploading images...[/bold blue]")
+    upload_images(workspace, project, folder)
+
+
+# 🔥 Dataset upload
+@cli.command(name="upload-dataset")
+@click.option('--workspace', required=True)
+@click.option('--project', required=True)
+@click.option('--path', required=True)
+def upload_dataset_cmd(workspace, project, path):
+    print("[bold blue]🚀 Uploading dataset...[/bold blue]")
+    upload_dataset(workspace, project, path)
+
+
+# 🔥 Create version
+@cli.command(name="create-version")
+@click.option('--workspace', required=True)
+@click.option('--project', required=True)
+@click.option('--name', required=True)
+def create_version_cmd(workspace, project, name):
+    print("[bold blue]🚀 Creating dataset version...[/bold blue]")
+    create_version(workspace, project, name)
+
+#train local
+@cli.command(name="train-local")
+@click.option('--workspace', required=True)
+@click.option('--project', required=True)
+@click.option('--version', required=True, type=int)
+def train_local_cmd(workspace, project, version):
+    train_local(workspace, project, version)
+
+#predict
+@cli.command(name="predict")
+@click.option('--image', required=True)
+def predict_cmd(image):
+    predict(image)
+
+@click.group()
+@click.version_option("0.1.0")
+def cli():
+    """Roboflow CLI - Dataset to Deployment"""
+    pass
+
+@cli.command()
+def hello():
+    print("[bold green]Roboflow CLI is working! 🚀[/bold green]")
+
+
+if __name__ == "__main__":
+    cli()

rfcli/predict.py

@@ -0,0 +1,26 @@
+from ultralytics import YOLO
+import cv2
+import os
+
+
+def predict(image_path):
+
+    print("🚀 Running inference...")
+
+    model = YOLO("runs/detect/train/weights/best.pt")
+
+    results = model(image_path)
+
+    for r in results:
+        boxes = r.boxes
+
+        for box in boxes:
+            print(f"Detected class: {int(box.cls[0])}, Confidence: {float(box.conf[0]):.2f}")
+
+    # 🔥 Save output instead of showing
+    annotated = results[0].plot()
+
+    output_path = "prediction.jpg"
+    cv2.imwrite(output_path, annotated)
+
+    print(f"\n✅ Prediction saved at: {os.path.abspath(output_path)}")

rfcli/train_local.py

@@ -0,0 +1,28 @@
+from roboflow import Roboflow
+from ultralytics import YOLO
+from rfcli.config import ROBOFLOW_API_KEY
+
+
+def train_local(workspace, project, version):
+
+    print("🚀 Downloading dataset from Roboflow...")
+
+    rf = Roboflow(api_key=ROBOFLOW_API_KEY)
+    dataset = rf.workspace(workspace).project(project).version(version).download("yolov8")
+
+    print("✅ Dataset downloaded!")
+
+    print("🚀 Starting YOLO training...")
+
+    model = YOLO("yolov8n.pt")
+
+    model.train(
+        data=f"{dataset.location}/data.yaml",
+        epochs=50,
+        imgsz=640
+    )
+
+    print("✅ Training complete!")
+
+    print("📦 Best model saved at:")
+    print("runs/detect/train/weights/best.pt")

rfcli/upload.py

@@ -0,0 +1,147 @@
+import os
+from rich import print
+from roboflow import Roboflow
+from rfcli.config import ROBOFLOW_API_KEY
+from rfcli.convert import coco_to_yolo
+
+
+# -----------------------------
+# 🔹 SINGLE IMAGE UPLOAD
+# -----------------------------
+def upload_images(workspace, project_name, folder_path):
+
+    rf = Roboflow(api_key=ROBOFLOW_API_KEY)
+    project = rf.workspace(workspace).project(project_name)
+
+    images = [f for f in os.listdir(folder_path) if f.lower().endswith((".jpg", ".jpeg", ".png"))]
+
+    print(f"[blue]Uploading {len(images)} images...[/blue]")
+
+    for i, img_name in enumerate(images):
+        try:
+            project.upload(os.path.join(folder_path, img_name))
+            if i % 50 == 0:
+                print(f"[green]{i} uploaded...[/green]")
+        except Exception as e:
+            print(f"[red]Failed {img_name}: {e}[/red]")
+
+
+# -----------------------------
+# 🔥 MAIN DATASET UPLOAD
+# -----------------------------
+def upload_dataset(workspace, project_name, dataset_path):
+
+    print("[blue]🚀 Initializing Roboflow SDK...[/blue]")
+
+    rf = Roboflow(api_key=ROBOFLOW_API_KEY)
+    project = rf.workspace(workspace).project(project_name)
+
+    if not os.path.exists(dataset_path):
+        print("[red]❌ Invalid dataset path[/red]")
+        return
+
+    # 🔥 CASE 1: SPLIT DATASET
+    splits = ["train", "valid", "test"]
+    split_exists = any(os.path.exists(os.path.join(dataset_path, s)) for s in splits)
+
+    if split_exists:
+        print("[cyan]📂 Detected SPLIT dataset[/cyan]")
+        _handle_split_dataset(project, dataset_path)
+        return
+
+    # 🔥 CASE 2: COCO JSON in root
+    json_files = [f for f in os.listdir(dataset_path) if f.endswith(".json")]
+
+    if json_files:
+        print("[cyan]📦 Detected COCO dataset[/cyan]")
+
+        json_path = os.path.join(dataset_path, json_files[0])
+        coco_to_yolo(json_path, dataset_path)
+
+    # 🔥 CASE 3: YOLO FLAT DATASET
+    print("[cyan]📁 Detected YOLO flat dataset[/cyan]")
+    _handle_flat_dataset(project, dataset_path)
+
+
+# -----------------------------
+# 📂 HANDLE SPLIT DATASET
+# -----------------------------
+def _handle_split_dataset(project, dataset_path):
+
+    splits = ["train", "valid", "test"]
+
+    success, fail = 0, 0
+
+    for split in splits:
+
+        split_path = os.path.join(dataset_path, split)
+
+        if not os.path.exists(split_path):
+            continue
+
+        print(f"\n[bold cyan]Processing {split}...[/bold cyan]")
+
+        # Convert COCO if exists
+        json_files = [f for f in os.listdir(split_path) if f.endswith(".json")]
+        if json_files:
+            coco_to_yolo(os.path.join(split_path, json_files[0]), split_path)
+
+        labels_dir = os.path.join(split_path, "labels")
+
+        images = [f for f in os.listdir(split_path) if f.lower().endswith((".jpg", ".jpeg", ".png"))]
+
+        for i, img_name in enumerate(images):
+
+            img_path = os.path.join(split_path, img_name)
+            label_path = os.path.join(labels_dir, os.path.splitext(img_name)[0] + ".txt")
+
+            try:
+                if os.path.exists(label_path):
+                    project.upload(img_path, annotation_path=label_path, split=split)
+                else:
+                    project.upload(img_path, split=split)
+
+                success += 1
+
+                if success % 10 == 0:
+                    print(f"[green]{success} uploaded...[/green]")
+
+            except Exception as e:
+                print(f"[red]Failed {img_name}: {e}[/red]")
+                fail += 1
+
+    print(f"\n[bold]Done → Success: {success}, Failed: {fail}[/bold]")
+
+
+# -----------------------------
+# 📁 HANDLE FLAT DATASET
+# -----------------------------
+def _handle_flat_dataset(project, dataset_path):
+
+    images = [f for f in os.listdir(dataset_path) if f.lower().endswith((".jpg", ".jpeg", ".png"))]
+
+    labels_dir = os.path.join(dataset_path, "labels")
+
+    success, fail = 0, 0
+
+    for i, img_name in enumerate(images):
+
+        img_path = os.path.join(dataset_path, img_name)
+        label_path = os.path.join(labels_dir, os.path.splitext(img_name)[0] + ".txt")
+
+        try:
+            if os.path.exists(label_path):
+                project.upload(img_path, annotation_path=label_path, split="train")
+            else:
+                project.upload(img_path)
+
+            success += 1
+
+            if success % 100 == 0:
+                print(f"[green]{success} uploaded...[/green]")
+
+        except Exception as e:
+            print(f"[red]Failed {img_name}: {e}[/red]")
+            fail += 1
+
+    print(f"\n[bold]Done → Success: {success}, Failed: {fail}[/bold]")

rfcli/version.py

@@ -0,0 +1,47 @@
+from rich import print
+from roboflow import Roboflow
+from rfcli.config import ROBOFLOW_API_KEY
+
+
+def create_version(workspace, project_name, version_name):
+
+    print("[blue]🚀 Creating dataset version with split...[/blue]")
+
+    try:
+        rf = Roboflow(api_key=ROBOFLOW_API_KEY)
+        project = rf.workspace(workspace).project(project_name)
+
+        # 🔥 Create version with splits
+        version = project.generate_version(
+            {
+                "name": version_name,
+
+                # ✅ SPLIT CONFIG
+                "splits": {
+                    "train": 70,
+                    "valid": 20,
+                    "test": 10
+                },
+
+                # ✅ PREPROCESSING
+                "preprocessing": {
+                    "resize": {
+                        "width": 640,
+                        "height": 640,
+                        "format": "Stretch to"
+                    }
+                },
+
+                # (optional)
+                "augmentation": {}
+            }
+        )
+
+        print("[green]✅ Version created successfully![/green]")
+        print(f"[bold]Version Name:[/bold] {version_name}")
+
+        print("\n[cyan]📊 Version Info:[/cyan]")
+        print(version)
+
+    except Exception as e:
+        print(f"[red]❌ Failed to create version: {str(e)}[/red]")

rfcli-0.1.0.dist-info/METADATA

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: rfcli
+Version: 0.1.0
+Summary: Dataset-to-Deployment CLI for Object Detection
+Author: Your Name
+Requires-Python: >=3.8
+Requires-Dist: click
+Requires-Dist: rich
+Requires-Dist: roboflow
+Requires-Dist: ultralytics
+Requires-Dist: fastapi
+Requires-Dist: uvicorn
+Requires-Dist: python-multipart
+Requires-Dist: opencv-python
+Dynamic: author
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

rfcli-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+rfcli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rfcli/config.py,sha256=HIGrW9zdsi_eSsWQtQX-VILHbaB2i6n8FtCZ9iB_KCs,202
+rfcli/convert.py,sha256=ERR2FzInpfBNeLreYXxWDVIHoEA8v62dWrH-35TLkhI,1407
+rfcli/infer.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rfcli/main.py,sha256=8DSjLVCF1QsoHnaNfOOmu7oYQyi0jupuFNb2H8Mbiqw,2021
+rfcli/predict.py,sha256=KIVOB1k0EOHpxGMpetU-YVmrd4ECeayPYClZsisSXOo,623
+rfcli/train.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rfcli/train_local.py,sha256=rnLiHBkX6pACmz_P7Q_X67WoPOpmezE9ZYFhw0Z3oAo,713
+rfcli/upload.py,sha256=-DDbvPmf6ElpK9CmYtitvzl61VuWI7Kzbf5F3G9LxMw,4757
+rfcli/utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rfcli/version.py,sha256=iG6ER0lHXo3MYKkTQzKV02VoDk6wsuoX7MqLaRg5tqQ,1369
+rfcli-0.1.0.dist-info/METADATA,sha256=BKOPzb9c8u50NJTTFitVpkARzt8ST5HzNV7tccyo-LU,444
+rfcli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+rfcli-0.1.0.dist-info/entry_points.txt,sha256=0Chj2OlbTO3opMPJxQnu48Za9FEj5pqaa14wCs6DWq0,41
+rfcli-0.1.0.dist-info/top_level.txt,sha256=kUvqUMu0dwIFSNVQTJxO142ucSH2mXty47hD4LM8U-I,6
+rfcli-0.1.0.dist-info/RECORD,,

rfcli-0.1.0.dist-info/WHEEL

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

rfcli-0.1.0.dist-info/entry_points.txt

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

rfcli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+rfcli