dgenerate-ultralytics-headless 8.3.248__py3-none-any.whl → 8.4.7__py3-none-any.whl

ultralytics/utils/callbacks/platform.py

@@ -2,6 +2,7 @@
 
 import os
 import platform
+import re
 import socket
 import sys
 from concurrent.futures import ThreadPoolExecutor
@@ -11,9 +12,18 @@ from time import time
 from ultralytics.utils import ENVIRONMENT, GIT, LOGGER, PYTHON_VERSION, RANK, SETTINGS, TESTS_RUNNING, colorstr
 
 PREFIX = colorstr("Platform: ")
-_last_upload = 0  # Rate limit model uploads
-_console_logger = None  # Global console logger instance
-_system_logger = None  # Cached system logger instance
+
+# Configurable platform URL for debugging (e.g. ULTRALYTICS_PLATFORM_URL=http://localhost:3000)
+PLATFORM_URL = os.getenv("ULTRALYTICS_PLATFORM_URL", "https://platform.ultralytics.com").rstrip("/")
+PLATFORM_API_URL = f"{PLATFORM_URL}/api/webhooks"
+
+
+def slugify(text):
+    """Convert text to URL-safe slug (e.g., 'My Project 1' -> 'my-project-1')."""
+    if not text:
+        return text
+    return re.sub(r"-+", "-", re.sub(r"[^a-z0-9\s-]", "", str(text).lower()).replace(" ", "-")).strip("-")[:128]
+
 
 try:
     assert not TESTS_RUNNING  # do not log pytest
@@ -32,6 +42,84 @@ except (AssertionError, ImportError):
     _api_key = None
 
 
+def resolve_platform_uri(uri, hard=True):
+    """Resolve ul:// URIs to signed URLs by authenticating with Ultralytics Platform.
+
+    Formats:
+        ul://username/datasets/slug  -> Returns signed URL to NDJSON file
+        ul://username/project/model  -> Returns signed URL to .pt file
+
+    Args:
+        uri (str): Platform URI starting with "ul://".
+        hard (bool): Whether to raise an error if resolution fails (FileNotFoundError only).
+
+    Returns:
+        (str | None): Signed URL on success, None if not found and hard=False.
+
+    Raises:
+        ValueError: If API key is missing/invalid or URI format is wrong.
+        PermissionError: If access is denied.
+        RuntimeError: If resource is not ready (e.g., dataset still processing).
+        FileNotFoundError: If resource not found and hard=True.
+        ConnectionError: If network request fails and hard=True.
+    """
+    import requests
+
+    path = uri[5:]  # Remove "ul://"
+    parts = path.split("/")
+
+    api_key = os.getenv("ULTRALYTICS_API_KEY") or SETTINGS.get("api_key")
+    if not api_key:
+        raise ValueError(f"ULTRALYTICS_API_KEY required for '{uri}'. Get key at {PLATFORM_URL}/settings")
+
+    base = PLATFORM_API_URL
+    headers = {"Authorization": f"Bearer {api_key}"}
+
+    # ul://username/datasets/slug
+    if len(parts) == 3 and parts[1] == "datasets":
+        username, _, slug = parts
+        url = f"{base}/datasets/{username}/{slug}/export"
+
+    # ul://username/project/model
+    elif len(parts) == 3:
+        username, project, model = parts
+        url = f"{base}/models/{username}/{project}/{model}/download"
+
+    else:
+        raise ValueError(f"Invalid platform URI: {uri}. Use ul://user/datasets/name or ul://user/project/model")
+
+    try:
+        timeout = 3600 if "/datasets/" in url else 90  # NDJSON generation can be slow for large datasets
+        r = requests.head(url, headers=headers, allow_redirects=False, timeout=timeout)
+
+        # Handle redirect responses (301, 302, 303, 307, 308)
+        if 300 <= r.status_code < 400 and "location" in r.headers:
+            return r.headers["location"]  # Return signed URL
+
+        # Handle error responses
+        if r.status_code == 401:
+            raise ValueError(f"Invalid ULTRALYTICS_API_KEY for '{uri}'")
+        if r.status_code == 403:
+            raise PermissionError(f"Access denied for '{uri}'. Check dataset/model visibility settings.")
+        if r.status_code == 404:
+            if hard:
+                raise FileNotFoundError(f"Not found on platform: {uri}")
+            LOGGER.warning(f"Not found on platform: {uri}")
+            return None
+        if r.status_code == 409:
+            raise RuntimeError(f"Resource not ready: {uri}. Dataset may still be processing.")
+
+        # Unexpected response
+        r.raise_for_status()
+        raise RuntimeError(f"Unexpected response from platform for '{uri}': {r.status_code}")
+
+    except requests.exceptions.RequestException as e:
+        if hard:
+            raise ConnectionError(f"Failed to resolve {uri}: {e}") from e
+        LOGGER.warning(f"Failed to resolve {uri}: {e}")
+        return None
+
+
 def _interp_plot(plot, n=101):
     """Interpolate plot curve data from 1000 to n points to reduce storage size."""
     import numpy as np
@@ -60,22 +148,28 @@ def _interp_plot(plot, n=101):
     return result
 
 
-def _send(event, data, project, name):
-    """Send event to Platform endpoint."""
+def _send(event, data, project, name, model_id=None):
+    """Send event to Platform endpoint. Returns response JSON on success."""
     try:
-        requests.post(
-            "https://alpha.ultralytics.com/api/webhooks/training/metrics",
-            json={"event": event, "project": project, "name": name, "data": data},
+        payload = {"event": event, "project": project, "name": name, "data": data}
+        if model_id:
+            payload["modelId"] = model_id
+        r = requests.post(
+            f"{PLATFORM_API_URL}/training/metrics",
+            json=payload,
             headers={"Authorization": f"Bearer {_api_key}"},
             timeout=10,
-        ).raise_for_status()
+        )
+        r.raise_for_status()
+        return r.json()
     except Exception as e:
         LOGGER.debug(f"Platform: Failed to send {event}: {e}")
+        return None
 
 
-def _send_async(event, data, project, name):
+def _send_async(event, data, project, name, model_id=None):
     """Send event asynchronously using bounded thread pool."""
-    _executor.submit(_send, event, data, project, name)
+    _executor.submit(_send, event, data, project, name, model_id)
 
 
 def _upload_model(model_path, project, name):
@@ -87,7 +181,7 @@ def _upload_model(model_path, project, name):
 
         # Get signed upload URL
         response = requests.post(
-            "https://alpha.ultralytics.com/api/webhooks/models/upload",
+            f"{PLATFORM_API_URL}/models/upload",
             json={"project": project, "name": name, "filename": model_path.name},
             headers={"Authorization": f"Bearer {_api_key}"},
             timeout=10,
@@ -104,7 +198,7 @@ def _upload_model(model_path, project, name):
                 timeout=600,  # 10 min timeout for large models
             ).raise_for_status()
 
-        # url = f"https://alpha.ultralytics.com/{project}/{name}"
+        # url = f"{PLATFORM_URL}/{project}/{name}"
         # LOGGER.info(f"{PREFIX}Model uploaded to {url}")
         return data.get("gcsPath")
 
@@ -169,132 +263,146 @@ def _get_environment_info():
     return env
 
 
+def _get_project_name(trainer):
+    """Get slugified project and name from trainer args."""
+    raw = str(trainer.args.project)
+    parts = raw.split("/", 1)
+    project = f"{parts[0]}/{slugify(parts[1])}" if len(parts) == 2 else slugify(raw)
+    return project, slugify(str(trainer.args.name or "train"))
+
+
 def on_pretrain_routine_start(trainer):
     """Initialize Platform logging at training start."""
-    global _console_logger, _last_upload
-
     if RANK not in {-1, 0} or not trainer.args.project:
         return
 
-    # Initialize upload timer to now so first checkpoint waits 15 min from training start
-    _last_upload = time()
+    # Per-trainer state to isolate concurrent training runs
+    trainer._platform_model_id = None
+    trainer._platform_last_upload = time()
 
-    project, name = str(trainer.args.project), str(trainer.args.name or "train")
-    url = f"https://alpha.ultralytics.com/{project}/{name}"
+    project, name = _get_project_name(trainer)
+    url = f"{PLATFORM_URL}/{project}/{name}"
     LOGGER.info(f"{PREFIX}Streaming to {url}")
 
     # Create callback to send console output to Platform
     def send_console_output(content, line_count, chunk_id):
         """Send batched console output to Platform webhook."""
-        _send_async("console_output", {"chunkId": chunk_id, "content": content, "lineCount": line_count}, project, name)
+        _send_async(
+            "console_output",
+            {"chunkId": chunk_id, "content": content, "lineCount": line_count},
+            project,
+            name,
+            getattr(trainer, "_platform_model_id", None),
+        )
 
     # Start console capture with batching (5 lines or 5 seconds)
-    _console_logger = ConsoleLogger(batch_size=5, flush_interval=5.0, on_flush=send_console_output)
-    _console_logger.start_capture()
-
-    # Gather model info for richer metadata
-    model_info = {}
-    try:
-        info = model_info_for_loggers(trainer)
-        model_info = {
-            "parameters": info.get("model/parameters", 0),
-            "gflops": info.get("model/GFLOPs", 0),
-            "classes": getattr(trainer.model, "yaml", {}).get("nc", 0),  # number of classes
-        }
-    except Exception:
-        pass
+    trainer._platform_console_logger = ConsoleLogger(batch_size=5, flush_interval=5.0, on_flush=send_console_output)
+    trainer._platform_console_logger.start_capture()
 
     # Collect environment info (W&B-style metadata)
     environment = _get_environment_info()
 
-    _send_async(
+    # Build trainArgs - callback runs before get_dataset() so args.data is still original (e.g., ul:// URIs)
+    # Note: model_info is sent later in on_fit_epoch_end (epoch 0) when the model is actually loaded
+    train_args = {k: str(v) for k, v in vars(trainer.args).items()}
+
+    # Send synchronously to get modelId for subsequent webhooks
+    response = _send(
         "training_started",
         {
-            "trainArgs": {k: str(v) for k, v in vars(trainer.args).items()},
+            "trainArgs": train_args,
             "epochs": trainer.epochs,
             "device": str(trainer.device),
-            "modelInfo": model_info,
             "environment": environment,
         },
         project,
         name,
     )
+    if response and response.get("modelId"):
+        trainer._platform_model_id = response["modelId"]
 
 
 def on_fit_epoch_end(trainer):
     """Log training and system metrics at epoch end."""
-    global _system_logger
-
     if RANK not in {-1, 0} or not trainer.args.project:
         return
 
-    project, name = str(trainer.args.project), str(trainer.args.name or "train")
+    project, name = _get_project_name(trainer)
     metrics = {**trainer.label_loss_items(trainer.tloss, prefix="train"), **trainer.metrics}
 
     if trainer.optimizer and trainer.optimizer.param_groups:
         metrics["lr"] = trainer.optimizer.param_groups[0]["lr"]
+
+    # Extract model info at epoch 0 (sent as separate field, not in metrics)
+    model_info = None
     if trainer.epoch == 0:
         try:
-            metrics.update(model_info_for_loggers(trainer))
+            info = model_info_for_loggers(trainer)
+            model_info = {
+                "parameters": info.get("model/parameters", 0),
+                "gflops": info.get("model/GFLOPs", 0),
+                "speedMs": info.get("model/speed_PyTorch(ms)", 0),
+            }
         except Exception:
             pass
 
-    # Get system metrics (cache SystemLogger for efficiency)
+    # Get system metrics (cache SystemLogger on trainer for efficiency)
     system = {}
     try:
-        if _system_logger is None:
-            _system_logger = SystemLogger()
-        system = _system_logger.get_metrics(rates=True)
+        if not hasattr(trainer, "_platform_system_logger"):
+            trainer._platform_system_logger = SystemLogger()
+        system = trainer._platform_system_logger.get_metrics(rates=True)
     except Exception:
         pass
 
+    payload = {
+        "epoch": trainer.epoch,
+        "metrics": metrics,
+        "system": system,
+        "fitness": trainer.fitness,
+        "best_fitness": trainer.best_fitness,
+    }
+    if model_info:
+        payload["modelInfo"] = model_info
+
     _send_async(
         "epoch_end",
-        {
-            "epoch": trainer.epoch,
-            "metrics": metrics,
-            "system": system,
-            "fitness": trainer.fitness,
-            "best_fitness": trainer.best_fitness,
-        },
+        payload,
         project,
         name,
+        getattr(trainer, "_platform_model_id", None),
     )
 
 
 def on_model_save(trainer):
     """Upload model checkpoint (rate limited to every 15 min)."""
-    global _last_upload
-
     if RANK not in {-1, 0} or not trainer.args.project:
         return
 
     # Rate limit to every 15 minutes (900 seconds)
-    if time() - _last_upload < 900:
+    if time() - getattr(trainer, "_platform_last_upload", 0) < 900:
         return
 
     model_path = trainer.best if trainer.best and Path(trainer.best).exists() else trainer.last
     if not model_path:
         return
 
-    project, name = str(trainer.args.project), str(trainer.args.name or "train")
+    project, name = _get_project_name(trainer)
     _upload_model_async(model_path, project, name)
-    _last_upload = time()
+    trainer._platform_last_upload = time()
 
 
 def on_train_end(trainer):
     """Log final results, upload best model, and send validation plot data."""
-    global _console_logger
-
     if RANK not in {-1, 0} or not trainer.args.project:
         return
 
-    project, name = str(trainer.args.project), str(trainer.args.name or "train")
+    project, name = _get_project_name(trainer)
 
     # Stop console capture
-    if _console_logger:
-        _console_logger.stop_capture()
-        _console_logger = None
+    if hasattr(trainer, "_platform_console_logger") and trainer._platform_console_logger:
+        trainer._platform_console_logger.stop_capture()
+        trainer._platform_console_logger = None
 
     # Upload best model (blocking to ensure it completes)
     model_path = None
@@ -332,8 +440,9 @@ def on_train_end(trainer):
         },
         project,
         name,
+        getattr(trainer, "_platform_model_id", None),
     )
-    url = f"https://alpha.ultralytics.com/{project}/{name}"
+    url = f"{PLATFORM_URL}/{project}/{name}"
     LOGGER.info(f"{PREFIX}View results at {url}")
 
 

ultralytics/utils/callbacks/tensorboard.py

@@ -1,6 +1,7 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
 from ultralytics.utils import LOGGER, SETTINGS, TESTS_RUNNING, colorstr, torch_utils
+from ultralytics.utils.torch_utils import smart_inference_mode
 
 try:
     assert not TESTS_RUNNING  # do not log pytest
@@ -38,6 +39,7 @@ def _log_scalars(scalars: dict, step: int = 0) -> None:
             WRITER.add_scalar(k, v, step)
 
 
+@smart_inference_mode()
 def _log_tensorboard_graph(trainer) -> None:
     """Log model graph to TensorBoard.
 

ultralytics/utils/callbacks/wb.py

@@ -128,10 +128,15 @@ def _log_plots(plots, step):
 def on_pretrain_routine_start(trainer):
     """Initialize and start wandb project if module is present."""
     if not wb.run:
+        from datetime import datetime
+
+        name = str(trainer.args.name).replace("/", "-").replace(" ", "_")
         wb.init(
             project=str(trainer.args.project).replace("/", "-") if trainer.args.project else "Ultralytics",
-            name=str(trainer.args.name).replace("/", "-"),
+            name=name,
             config=vars(trainer.args),
+            id=f"{name}_{datetime.now().strftime('%Y%m%d_%H%M%S')}",  # add unique id
+            dir=str(trainer.save_dir),
         )
 
 

ultralytics/utils/checks.py

@@ -530,7 +530,7 @@ def check_torchvision():
             )
 
 
-def check_suffix(file="yolo11n.pt", suffix=".pt", msg=""):
+def check_suffix(file="yolo26n.pt", suffix=".pt", msg=""):
     """Check file(s) for acceptable suffix.
 
     Args:
@@ -584,7 +584,7 @@ def check_model_file_from_stem(model="yolo11n"):
     """
     path = Path(model)
     if not path.suffix and path.stem in downloads.GITHUB_ASSETS_STEMS:
-        return path.with_suffix(".pt")  # add suffix, i.e. yolo11n -> yolo11n.pt
+        return path.with_suffix(".pt")  # add suffix, i.e. yolo26n -> yolo26n.pt
     return model
 
 
@@ -592,7 +592,7 @@ def check_file(file, suffix="", download=True, download_dir=".", hard=True):
     """Search/download file (if necessary), check suffix (if provided), and return path.
 
     Args:
-        file (str): File name or path.
+        file (str): File name or path, URL, platform URI (ul://), or GCS path (gs://).
         suffix (str | tuple): Acceptable suffix or tuple of suffixes to validate against the file.
         download (bool): Whether to download the file if it doesn't exist locally.
         download_dir (str): Directory to download the file to.
@@ -610,7 +610,26 @@ def check_file(file, suffix="", download=True, download_dir=".", hard=True):
         or file.lower().startswith("grpc://")
     ):  # file exists or gRPC Triton images
         return file
-    elif download and file.lower().startswith(("https://", "http://", "rtsp://", "rtmp://", "tcp://")):  # download
+    elif download and file.lower().startswith("ul://"):  # Ultralytics Platform URI
+        from ultralytics.utils.callbacks.platform import resolve_platform_uri
+
+        url = resolve_platform_uri(file, hard=hard)  # Convert to signed HTTPS URL
+        if url is None:
+            return []  # Not found, soft fail (consistent with file search behavior)
+        # Use URI path for unique directory structure: ul://user/project/model -> user/project/model/filename.pt
+        uri_path = file[5:]  # Remove "ul://"
+        local_file = Path(download_dir) / uri_path / url2file(url)
+        if local_file.exists():
+            LOGGER.info(f"Found {clean_url(url)} locally at {local_file}")
+        else:
+            local_file.parent.mkdir(parents=True, exist_ok=True)
+            downloads.safe_download(url=url, file=local_file, unzip=False)
+        return str(local_file)
+    elif download and file.lower().startswith(
+        ("https://", "http://", "rtsp://", "rtmp://", "tcp://", "gs://")
+    ):  # download
+        if file.startswith("gs://"):
+            file = "https://storage.googleapis.com/" + file[5:]  # convert gs:// to public HTTPS URL
         url = file  # warning: Pathlib turns :// -> :/
         file = Path(download_dir) / url2file(file)  # '%2F' to '/', split https://url.com/file.txt?auth
         if file.exists():
@@ -793,7 +812,7 @@ def check_amp(model):
     Examples:
         >>> from ultralytics import YOLO
         >>> from ultralytics.utils.checks import check_amp
-        >>> model = YOLO("yolo11n.pt").model.cuda()
+        >>> model = YOLO("yolo26n.pt").model.cuda()
         >>> check_amp(model)
     """
     from ultralytics.utils.torch_utils import autocast
@@ -832,14 +851,14 @@ def check_amp(model):
     try:
         from ultralytics import YOLO
 
-        assert amp_allclose(YOLO("yolo11n.pt"), im)
+        assert amp_allclose(YOLO("yolo26n.pt"), im)
         LOGGER.info(f"{prefix}checks passed ✅")
     except ConnectionError:
-        LOGGER.warning(f"{prefix}checks skipped. Offline and unable to download YOLO11n for AMP checks. {warning_msg}")
+        LOGGER.warning(f"{prefix}checks skipped. Offline and unable to download YOLO26n for AMP checks. {warning_msg}")
     except (AttributeError, ModuleNotFoundError):
         LOGGER.warning(
             f"{prefix}checks skipped. "
-            f"Unable to load YOLO11n for AMP checks due to possible Ultralytics package modifications. {warning_msg}"
+            f"Unable to load YOLO26n for AMP checks due to possible Ultralytics package modifications. {warning_msg}"
         )
     except AssertionError:
         LOGGER.error(
@@ -945,7 +964,7 @@ def is_rockchip():
             with open("/proc/device-tree/compatible") as f:
                 dev_str = f.read()
                 *_, soc = dev_str.split(",")
-                if soc.replace("\x00", "") in RKNN_CHIPS:
+                if soc.replace("\x00", "").split("-", 1)[0] in RKNN_CHIPS:
                     return True
         except OSError:
             return False

ultralytics/utils/dist.py

@@ -49,6 +49,7 @@ def generate_ddp_file(trainer):
 
     content = f"""
 # Ultralytics Multi-GPU training temp file (should be automatically deleted after use)
+from pathlib import Path, PosixPath  # For model arguments stored as Path instead of str
 overrides = {vars(trainer.args)}
 
 if __name__ == "__main__":

ultralytics/utils/downloads.py

@@ -18,12 +18,14 @@ GITHUB_ASSETS_NAMES = frozenset(
     [f"yolov8{k}{suffix}.pt" for k in "nsmlx" for suffix in ("", "-cls", "-seg", "-pose", "-obb", "-oiv7")]
     + [f"yolo11{k}{suffix}.pt" for k in "nsmlx" for suffix in ("", "-cls", "-seg", "-pose", "-obb")]
     + [f"yolo12{k}{suffix}.pt" for k in "nsmlx" for suffix in ("",)]  # detect models only currently
+    + [f"yolo26{k}{suffix}.pt" for k in "nsmlx" for suffix in ("", "-cls", "-seg", "-pose", "-obb")]
     + [f"yolov5{k}{resolution}u.pt" for k in "nsmlx" for resolution in ("", "6")]
     + [f"yolov3{k}u.pt" for k in ("", "-spp", "-tiny")]
     + [f"yolov8{k}-world.pt" for k in "smlx"]
     + [f"yolov8{k}-worldv2.pt" for k in "smlx"]
     + [f"yoloe-v8{k}{suffix}.pt" for k in "sml" for suffix in ("-seg", "-seg-pf")]
     + [f"yoloe-11{k}{suffix}.pt" for k in "sml" for suffix in ("-seg", "-seg-pf")]
+    + [f"yoloe-26{k}{suffix}.pt" for k in "nsmlx" for suffix in ("-seg", "-seg-pf")]
     + [f"yolov9{k}.pt" for k in "tsmce"]
     + [f"yolov10{k}.pt" for k in "nsmblx"]
     + [f"yolo_nas_{k}.pt" for k in "sml"]
@@ -418,13 +420,13 @@ def get_github_assets(
         LOGGER.warning(f"GitHub assets check failure for {url}: {r.status_code} {r.reason}")
         return "", []
     data = r.json()
-    return data["tag_name"], [x["name"] for x in data["assets"]]  # tag, assets i.e. ['yolo11n.pt', 'yolov8s.pt', ...]
+    return data["tag_name"], [x["name"] for x in data["assets"]]  # tag, assets i.e. ['yolo26n.pt', 'yolo11s.pt', ...]
 
 
 def attempt_download_asset(
     file: str | Path,
     repo: str = "ultralytics/assets",
-    release: str = "v8.3.0",
+    release: str = "v8.4.0",
     **kwargs,
 ) -> str:
     """Attempt to download a file from GitHub release assets if it is not found locally.
@@ -439,7 +441,7 @@ def attempt_download_asset(
         (str): The path to the downloaded file.
 
     Examples:
-        >>> file_path = attempt_download_asset("yolo11n.pt", repo="ultralytics/assets", release="latest")
+        >>> file_path = attempt_download_asset("yolo26n.pt", repo="ultralytics/assets", release="latest")
     """
     from ultralytics.utils import SETTINGS  # scoped for circular import
 

ultralytics/utils/export/engine.py

@@ -143,7 +143,7 @@ def onnx2engine(
         for inp in inputs:
             profile.set_shape(inp.name, min=min_shape, opt=shape, max=max_shape)
         config.add_optimization_profile(profile)
-        if int8:
+        if int8 and not is_trt10:  # deprecated in TensorRT 10, causes internal errors
             config.set_calibration_profile(profile)
 
     LOGGER.info(f"{prefix} building {'INT8' if int8 else 'FP' + ('16' if half else '32')} engine as {engine_file}")
@@ -226,12 +226,21 @@ def onnx2engine(
         config.set_flag(trt.BuilderFlag.FP16)
 
     # Write file
-    build = builder.build_serialized_network if is_trt10 else builder.build_engine
-    with build(network, config) as engine, open(engine_file, "wb") as t:
-        # Metadata
-        if metadata is not None:
-            meta = json.dumps(metadata)
-            t.write(len(meta).to_bytes(4, byteorder="little", signed=True))
-            t.write(meta.encode())
-        # Model
-        t.write(engine if is_trt10 else engine.serialize())
+    if is_trt10:
+        # TensorRT 10+ returns bytes directly, not a context manager
+        engine = builder.build_serialized_network(network, config)
+        if engine is None:
+            raise RuntimeError("TensorRT engine build failed, check logs for errors")
+        with open(engine_file, "wb") as t:
+            if metadata is not None:
+                meta = json.dumps(metadata)
+                t.write(len(meta).to_bytes(4, byteorder="little", signed=True))
+                t.write(meta.encode())
+            t.write(engine)
+    else:
+        with builder.build_engine(network, config) as engine, open(engine_file, "wb") as t:
+            if metadata is not None:
+                meta = json.dumps(metadata)
+                t.write(len(meta).to_bytes(4, byteorder="little", signed=True))
+                t.write(meta.encode())
+            t.write(engine.serialize())