Merge remote-tracking branch 'origin/main' into uploadrfdetr

Author: tonylampada

.github/workflows/publish.yml

@@ -30,3 +30,35 @@ jobs:
           PYPI_TEST_PASSWORD: ${{ secrets.PYPI_TEST_PASSWORD }}
         run: |
           make publish -e PYPI_USERNAME=$PYPI_USERNAME -e PYPI_PASSWORD=$PYPI_PASSWORD -e PYPI_TEST_PASSWORD=$PYPI_TEST_PASSWORD
+
+  deploy-docs:
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: 🛎️ Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: 🐍 Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.8'
+
+      - name: 📚 Install MkDocs and dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install mkdocs-material mkdocstrings mkdocstrings[python]
+          pip install ".[dev]"
+
+      - name: 🏗️ Build documentation
+        run: |
+          mkdocs build
+
+      - name: 🚀 Deploy to GitHub Pages
+        uses: peaceiris/actions-gh-pages@v3
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: ./site

roboflow/__init__.py

@@ -15,7 +15,7 @@
 from roboflow.models import CLIPModel, GazeModel  # noqa: F401
 from roboflow.util.general import write_line
 
-__version__ = "1.1.58"
+__version__ = "1.1.60"
 
 
 def check_key(api_key, model, notebook, num_retries=0):

roboflow/adapters/deploymentapi.py

@@ -9,10 +9,13 @@ class DeploymentApiError(Exception):
     pass
 
 
-def add_deployment(api_key, machine_type, duration, delete_on_expiration, deployment_name, inference_version):
+def add_deployment(
+    api_key, creator_email, machine_type, duration, delete_on_expiration, deployment_name, inference_version
+):
     url = f"{DEDICATED_DEPLOYMENT_URL}/add"
     params = {
         "api_key": api_key,
+        "creator_email": creator_email,
         # "security_level": security_level,
         "duration": duration,
         "delete_on_expiration": delete_on_expiration,
@@ -69,6 +72,22 @@ def get_deployment_usage(api_key, deployment_name, from_timestamp, to_timestamp)
     return response.status_code, response.json()
 
 
+def pause_deployment(api_key, deployment_name):
+    url = f"{DEDICATED_DEPLOYMENT_URL}/pause"
+    response = requests.post(url, json={"api_key": api_key, "deployment_name": deployment_name})
+    if response.status_code != 200:
+        return response.status_code, response.text
+    return response.status_code, response.json()
+
+
+def resume_deployment(api_key, deployment_name):
+    url = f"{DEDICATED_DEPLOYMENT_URL}/resume"
+    response = requests.post(url, json={"api_key": api_key, "deployment_name": deployment_name})
+    if response.status_code != 200:
+        return response.status_code, response.text
+    return response.status_code, response.json()
+
+
 def delete_deployment(api_key, deployment_name):
     url = f"{DEDICATED_DEPLOYMENT_URL}/delete"
     response = requests.post(url, json={"api_key": api_key, "deployment_name": deployment_name})

roboflow/deployment.py

@@ -61,6 +61,8 @@ def add_deployment_parser(subparsers):
     deployment_usage_deployment_parser = deployment_subparsers.add_parser(
         "usage_deployment", help="get usage of a specific dedicated deployments"
     )
+    deployment_pause_parser = deployment_subparsers.add_parser("pause", help="pause a dedicated deployment")
+    deployment_resume_parser = deployment_subparsers.add_parser("resume", help="resume a dedicated deployment")
     deployment_delete_parser = deployment_subparsers.add_parser("delete", help="delete a dedicated deployment")
     deployment_log_parser = deployment_subparsers.add_parser("log", help="show log info for a dedicated deployment")
 
@@ -77,7 +79,13 @@ def add_deployment_parser(subparsers):
     #     "-s", "--security_level", help="security level (protected)", default="protected"
     # )
     deployment_add_parser.add_argument(
-        "-m", "--machine_type", help="machine type, run `roboflow deployment machine_type` to see available options"
+        "-m",
+        "--machine_type",
+        help="machine type, run `roboflow deployment machine_type` to see available options",
+        required=True,
+    )
+    deployment_add_parser.add_argument(
+        "-e", "--creator_email", help="your email address (must be added to the workspace)", required=True
     )
     deployment_add_parser.add_argument(
         "-t",
@@ -87,7 +95,7 @@ def add_deployment_parser(subparsers):
         default=3,
     )
     deployment_add_parser.add_argument(
-        "-e", "--no_delete_on_expiration", help="keep when expired (default: False)", action="store_true"
+        "-nodel", "--no_delete_on_expiration", help="keep when expired (default: False)", action="store_true"
     )
     deployment_add_parser.add_argument(
         "-v",
@@ -128,6 +136,14 @@ def add_deployment_parser(subparsers):
         "-t", "--to_timestamp", help="end time stamp in ISO8601 format (YYYY-MM-DD HH:MM:SS)", default=None
     )
 
+    deployment_pause_parser.set_defaults(func=pause_deployment)
+    deployment_pause_parser.add_argument("-a", "--api_key", help="api key")
+    deployment_pause_parser.add_argument("deployment_name", help="deployment name")
+
+    deployment_resume_parser.set_defaults(func=resume_deployment)
+    deployment_resume_parser.add_argument("-a", "--api_key", help="api key")
+    deployment_resume_parser.add_argument("deployment_name", help="deployment name")
+
     deployment_delete_parser.set_defaults(func=delete_deployment)
     deployment_delete_parser.add_argument("-a", "--api_key", help="api key")
     deployment_delete_parser.add_argument("deployment_name", help="deployment name")
@@ -163,6 +179,7 @@ def add_deployment(args):
         exit(1)
     status_code, msg = deploymentapi.add_deployment(
         api_key,
+        args.creator_email,
         # args.security_level,
         args.machine_type,
         args.duration,
@@ -241,6 +258,30 @@ def get_deployment_usage(args):
     print(json.dumps(msg, indent=2))
 
 
+def pause_deployment(args):
+    api_key = args.api_key or load_roboflow_api_key(None)
+    if api_key is None:
+        print("Please provide an api key")
+        exit(1)
+    status_code, msg = deploymentapi.pause_deployment(api_key, args.deployment_name)
+    if status_code != 200:
+        print(f"{status_code}: {msg}")
+        exit(status_code)
+    print(json.dumps(msg, indent=2))
+
+
+def resume_deployment(args):
+    api_key = args.api_key or load_roboflow_api_key(None)
+    if api_key is None:
+        print("Please provide an api key")
+        exit(1)
+    status_code, msg = deploymentapi.resume_deployment(api_key, args.deployment_name)
+    if status_code != 200:
+        print(f"{status_code}: {msg}")
+        exit(status_code)
+    print(json.dumps(msg, indent=2))
+
+
 def delete_deployment(args):
     api_key = args.api_key or load_roboflow_api_key(None)
     if api_key is None:

roboflow/util/model_processor.py

@@ -114,29 +114,56 @@ def _process_yolo(model_type: str, model_path: str, filename: str) -> str:
 
         print_warn_for_wrong_dependencies_versions([("ultralytics", ">=", "8.3.0")], ask_to_continue=True)
 
-    model = torch.load(os.path.join(model_path, filename), map_location="cpu")
+    elif "yolov12" in model_type:
+        try:
+            import torch
+            import ultralytics
+
+        except ImportError:
+            raise RuntimeError(
+                "The ultralytics python package is required to deploy yolov12"
+                " models. Please install it from `https://github.com/sunsmarterjie/yolov12`"
+            )
+
+        print(
+            "\n!!! ATTENTION !!!\n"
+            "Model must be trained and uploaded using ultralytics from https://github.com/sunsmarterjie/yolov12\n"
+            "or through the Roboflow platform\n"
+            "!!! ATTENTION !!!\n"
+        )
+
+        print_warn_for_wrong_dependencies_versions([("ultralytics", "==", "8.3.63")], ask_to_continue=True)
 
-    if isinstance(model["model"].names, list):
-        class_names = model["model"].names
+    model = torch.load(os.path.join(model_path, filename), weights_only=False)
+
+    model_instance = model["model"] if "model" in model and model["model"] is not None else model["ema"]
+
+    if isinstance(model_instance.names, list):
+        class_names = model_instance.names
     else:
         class_names = []
-        for i, val in enumerate(model["model"].names):
-            class_names.append((val, model["model"].names[val]))
+        for i, val in enumerate(model_instance.names):
+            class_names.append((val, model_instance.names[val]))
         class_names.sort(key=lambda x: x[0])
         class_names = [x[1] for x in class_names]
 
-    if "yolov8" in model_type or "yolov10" in model_type or "yolov11" in model_type:
+    if "yolov8" in model_type or "yolov10" in model_type or "yolov11" in model_type or "yolov12" in model_type:
         # try except for backwards compatibility with older versions of ultralytics
-        if "-cls" in model_type or model_type.startswith("yolov10") or model_type.startswith("yolov11"):
-            nc = model["model"].yaml["nc"]
+        if (
+            "-cls" in model_type
+            or model_type.startswith("yolov10")
+            or model_type.startswith("yolov11")
+            or model_type.startswith("yolov12")
+        ):
+            nc = model_instance.yaml["nc"]
             args = model["train_args"]
         else:
-            nc = model["model"].nc
-            args = model["model"].args
+            nc = model_instance.nc
+            args = model_instance.args
         try:
             model_artifacts = {
                 "names": class_names,
-                "yaml": model["model"].yaml,
+                "yaml": model_instance.yaml,
                 "nc": nc,
                 "args": {k: val for k, val in args.items() if ((k == "model") or (k == "imgsz") or (k == "batch"))},
                 "ultralytics_version": ultralytics.__version__,
@@ -145,7 +172,7 @@ def _process_yolo(model_type: str, model_path: str, filename: str) -> str:
         except Exception:
             model_artifacts = {
                 "names": class_names,
-                "yaml": model["model"].yaml,
+                "yaml": model_instance.yaml,
                 "nc": nc,
                 "args": {
                     k: val for k, val in args.__dict__.items() if ((k == "model") or (k == "imgsz") or (k == "batch"))
@@ -161,20 +188,20 @@ def _process_yolo(model_type: str, model_path: str, filename: str) -> str:
 
         model_artifacts = {
             "names": class_names,
-            "nc": model["model"].nc,
+            "nc": model_instance.nc,
             "args": {
                 "imgsz": opts["imgsz"] if "imgsz" in opts else opts["img_size"],
                 "batch": opts["batch_size"],
             },
             "model_type": model_type,
         }
-        if hasattr(model["model"], "yaml"):
-            model_artifacts["yaml"] = model["model"].yaml
+        if hasattr(model_instance, "yaml"):
+            model_artifacts["yaml"] = model_instance.yaml
 
     with open(os.path.join(model_path, "model_artifacts.json"), "w") as fp:
         json.dump(model_artifacts, fp)
 
-    torch.save(model["model"].state_dict(), os.path.join(model_path, "state_dict.pt"))
+    torch.save(model_instance.state_dict(), os.path.join(model_path, "state_dict.pt"))
 
     list_files = [
         "results.csv",
@@ -300,6 +327,7 @@ def get_classnames_txt_for_rfdetr(model_path: str, pt_file: str):
         f"please create a class_names.txt file in the model path with the class names in new lines in the order of the classes in the model.\n"
     )
 
+
 def maybe_prepend_dummy_class(class_name_file: str):
     with open(class_name_file, "r") as f:
         class_names = f.readlines()