dstack 0.19.36__tar.gz → 0.19.37__tar.gz

{dstack-0.19.36 → dstack-0.19.37}/.github/workflows/build-artifacts.yml

@@ -187,7 +187,7 @@ jobs:
           if [[ "${{ inputs.staging }}" == "false" ]]; then
             sed \
               -i.old \
-              "s|@ git+https://github.com/dstackai/dstack.git@master|== ${{ inputs.version }}|" \
+              "s|@ https://github.com/dstackai/dstack/archive/refs/heads/master.tar.gz|== ${{ inputs.version }}|" \
               pyproject.toml
             diff pyproject.toml pyproject.toml.old > /dev/null && echo "Could not set version" && exit 1
           fi

{dstack-0.19.36 → dstack-0.19.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dstack
-Version: 0.19.36
+Version: 0.19.37
 Summary: dstack is an open-source orchestration engine for running AI workloads on any cloud or on-premises.
 Project-URL: Homepage, https://dstack.ai
 Project-URL: Source, https://github.com/dstackai/dstack

{dstack-0.19.36 → dstack-0.19.37}/contributing/LOCKING.md

@@ -108,3 +108,31 @@ Note that:
 
 * This pattern works assuming that Postgres is using default isolation level Read Committed. By the time a transaction acquires the advisory lock, all other transactions that can take the name have committed, so their changes can be seen and a unique name is taken.
 * SQLite needs a commit before selecting taken names due to Snapshot Isolation as noted above.
+
+**Use `AsyncExitStack`**
+
+In-memory locking typically requires taking lock for long (until commit).
+Using lock context managers for in-memory locking is often hard because the lock is tied to a block:
+
+```python
+if something:
+    # Can't do this because the lock will be released before commit. How to lock?
+    async with get_locker(get_db().dialect_name).lock_ctx(...):
+        # ...
+# ...
+await session.commit()
+```
+
+Use [`contextlib.AsyncExitStack`](https://docs.python.org/3/library/contextlib.html#contextlib.AsyncExitStack):
+
+```python
+async with AsyncExitStack() as exit_stack:
+    if something:
+        # The lock will be released only on stack exit, so it's ok.
+        await exit_stack.enter_async_context(
+            get_locker(get_db().dialect_name).lock_ctx(...)
+        )
+        # ...
+    # ...
+    await session.commit()
+```

{dstack-0.19.36 → dstack-0.19.37}/docs/docs/concepts/dev-environments.md

@@ -458,6 +458,10 @@ retry:
 
 </div>
 
+!!! info "Retry duration"
+    The duration period is calculated as a run age for `no-capacity` event
+    and as a time passed since the last `interruption` and `error` for `interruption` and `error` events..
+
 ### Inactivity duration
 
 Set [`inactivity_duration`](../reference/dstack.yml/dev-environment.md#inactivity_duration)

{dstack-0.19.36 → dstack-0.19.37}/docs/docs/concepts/services.md

@@ -821,6 +821,9 @@ retry:
 If one replica of a multi-replica service fails with retry enabled,
 `dstack` will resubmit only the failed replica while keeping active replicas running.
 
+!!! info "Retry duration"
+    The duration period is calculated as a run age for `no-capacity` event and as a time passed since the last `interruption` and `error` for `interruption` and `error` events..
+
 ### Spot policy
 
 By default, `dstack` uses on-demand instances. However, you can change that

{dstack-0.19.36 → dstack-0.19.37}/docs/docs/concepts/tasks.md

@@ -718,6 +718,9 @@ retry:
 If one job of a multi-node task fails with retry enabled,
 `dstack` will stop all the jobs and resubmit the run.
 
+!!! info "Retry duration"
+    The duration period is calculated as a run age for `no-capacity` event and as a time passed since the last `interruption` and `error` for `interruption` and `error` events..
+
 ### Priority
 
 Be default, submitted runs are scheduled in the order they were submitted.

{dstack-0.19.36 → dstack-0.19.37}/docs/docs/guides/clusters.md

@@ -15,7 +15,7 @@ Ensure a fleet is created before you run any distributed task. This can be eithe
 ### Cloud fleets
 
 [Cloud fleets](../concepts/fleets.md#cloud) allow to provision interconnected clusters across supported backends.
-For cloud fleets, fast interconnect is currently supported only on the `aws`, `gcp`, and `nebius` backends.
+For cloud fleets, fast interconnect is currently supported only on the `aws`, `gcp`, `nebius`, and `runpod` backends.
 
 === "AWS"
     When you create a cloud fleet with AWS, [Elastic Fabric Adapter :material-arrow-top-right-thin:{ .external }](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html){:target="_blank"} networking is automatically configured if it’s supported for the corresponding instance type.
@@ -36,6 +36,9 @@ For cloud fleets, fast interconnect is currently supported only on the `aws`, `g
 === "Nebius"
     When you create a cloud fleet with Nebius, [InfiniBand :material-arrow-top-right-thin:{ .external }](https://docs.nebius.com/compute/clusters/gpu){:target="_blank"} networking is automatically configured if it’s supported for the corresponding instance type.
 
+=== "Runpod"
+    When you run multinode tasks in a cluster cloud fleet with Runpod, `dstack` provisions [Runpod Instant Clusters](https://docs.runpod.io/instant-clusters) with InfiniBand networking configured.
+
 > To request fast interconnect support for other backends,
 file an [issue :material-arrow-top-right-thin:{ .external }](https://github.com/dstackai/dstack/issues){:target="_ blank"}.
 

{dstack-0.19.36 → dstack-0.19.37}/docs/docs/reference/environment-variables.md

@@ -115,6 +115,7 @@ For more details on the options below, refer to the [server deployment](../guide
 - `DSTACK_SERVER_GCP_LOGGING_PROJECT`{ #DSTACK_SERVER_GCP_LOGGING_PROJECT } – The GCP Logging project for storing workloads logs. If not set, the default file-based log storage is used.
 - `DSTACK_ENABLE_PROMETHEUS_METRICS`{ #DSTACK_ENABLE_PROMETHEUS_METRICS } — Enables Prometheus metrics collection and export.
 - `DSTACK_DEFAULT_SERVICE_CLIENT_MAX_BODY_SIZE`{ #DSTACK_DEFAULT_SERVICE_CLIENT_MAX_BODY_SIZE } – Request body size limit for services running with a gateway, in bytes. Defaults to 64 MiB.
+- `DSTACK_SERVICE_CLIENT_TIMEOUT`{ #DSTACK_SERVICE_CLIENT_TIMEOUT } – Timeout in seconds for HTTP requests sent from the in-server proxy and gateways to service replicas. Defaults to 60.
 - `DSTACK_FORBID_SERVICES_WITHOUT_GATEWAY`{ #DSTACK_FORBID_SERVICES_WITHOUT_GATEWAY } – Forbids registering new services without a gateway if set to any value.
 - `DSTACK_SERVER_CODE_UPLOAD_LIMIT`{ #DSTACK_SERVER_CODE_UPLOAD_LIMIT } - The repo size limit when uploading diffs or local repos, in bytes. Set to `0` to disable size limits. Defaults to `2MiB`.
 - `DSTACK_SERVER_S3_BUCKET`{ #DSTACK_SERVER_S3_BUCKET } - The bucket that repo diffs will be uploaded to if set. If unset, diffs are uploaded to the database.

{dstack-0.19.36 → dstack-0.19.37}/gateway/pyproject.toml

@@ -11,7 +11,7 @@ requires-python = ">=3.10"
 dynamic = ["version"]
 dependencies = [
     # release builds of dstack-gateway depend on a PyPI version of dstack instead
-    "dstack[gateway] @ git+https://github.com/dstackai/dstack.git@master",
+    "dstack[gateway] @ https://github.com/dstackai/dstack/archive/refs/heads/master.tar.gz",
 ]
 
 [tool.setuptools.package-data]

{dstack-0.19.36 → dstack-0.19.37}/pyproject.toml

@@ -108,6 +108,7 @@ dev = [
     "testcontainers>=4.9.2",
     "pytest-xdist>=3.6.1",
     "pyinstrument>=5.0.0",
+    "kubernetes-stubs-elephant-fork",
 ]
 
 [project.optional-dependencies]

{dstack-0.19.36 → dstack-0.19.37}/runner/.justfile

@@ -45,7 +45,7 @@ build-runner-binary:
     #!/usr/bin/env bash
     set -e
     echo "Building runner for linux/amd64"
-    cd {{source_directory()}}/cmd/runner && GOOS=linux GOARCH=amd64 go build -ldflags "-X 'main.Version=$version' -extldflags '-static'"
+    cd {{source_directory()}}/cmd/runner && CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags "-X 'main.Version=$version' -extldflags '-static'"
     echo "Runner build complete!"
 
 # Build shim
@@ -56,7 +56,12 @@ build-shim-binary:
     cd {{source_directory()}}/cmd/shim
     if [ -n "$shim_os" ] && [ -n "$shim_arch" ]; then
         echo "Building shim for $shim_os/$shim_arch"
-        GOOS=$shim_os GOARCH=$shim_arch go build -ldflags "-X 'main.Version=$version' -extldflags '-static'"
+        if [ "$shim_os" = "linux" ] && [ "$(uname -s)" != "Linux" ]; then
+            echo "WARNING: Cross-compiling to Linux, disabling CGO (DCGM unavailable)"
+            CGO_ENABLED=0 GOOS=$shim_os GOARCH=$shim_arch go build -ldflags "-X 'main.Version=$version' -extldflags '-static'"
+        else
+            CGO_ENABLED=1 GOOS=$shim_os GOARCH=$shim_arch go build -ldflags "-X 'main.Version=$version'"
+        fi
     else
         echo "Building shim for current platform"
         go build -ldflags "-X 'main.Version=$version' -extldflags '-static'"

{dstack-0.19.36 → dstack-0.19.37}/runner/internal/repo/manager.go

@@ -16,20 +16,26 @@ type Manager struct {
 	ctx       context.Context
 	localPath string
 	clo       git.CloneOptions
+	branch    string
 	hash      string
 }
 
 func NewManager(ctx context.Context, url, branch, hash string, singleBranch bool) *Manager {
 	ctx = log.AppendArgsCtx(ctx, "url", url, "branch", branch, "hash", hash)
 	m := &Manager{
-		ctx: ctx,
+		ctx:    ctx,
+		branch: branch,
+		hash:   hash,
 		clo: git.CloneOptions{
 			URL:               url,
 			RecurseSubmodules: git.DefaultSubmoduleRecursionDepth,
-			ReferenceName:     plumbing.NewBranchReferenceName(branch),
 			SingleBranch:      singleBranch,
 		},
-		hash: hash,
+	}
+	// Only set ReferenceName if branch is non-empty
+	// If empty, it will default to HEAD in CloneOptions.Validate()
+	if branch != "" {
+		m.clo.ReferenceName = plumbing.NewBranchReferenceName(branch)
 	}
 
 	return m
@@ -69,23 +75,41 @@ func (m *Manager) Checkout() error {
 		return fmt.Errorf("clone repo: %w", err)
 	}
 	if ref != nil {
-		branchRef, err := ref.Reference(m.clo.ReferenceName, true)
-		if err != nil {
-			return fmt.Errorf("get branch reference: %w", err)
-		}
 		var cho git.CheckoutOptions
-		if m.hash == "" || m.hash == branchRef.Hash().String() {
-			cho.Branch = m.clo.ReferenceName
+		needCheckout := false
+
+		if m.branch != "" {
+			branchRef, err := ref.Reference(m.clo.ReferenceName, true)
+			if err != nil {
+				return fmt.Errorf("get branch reference: %w", err)
+			}
+			if m.hash == "" || m.hash == branchRef.Hash().String() {
+				// Hash is empty or matches branch head: checkout branch
+				cho.Branch = m.clo.ReferenceName
+				needCheckout = true
+			} else {
+				// Hash is specified and different: checkout by hash
+				cho.Hash = plumbing.NewHash(m.hash)
+				needCheckout = true
+			}
 		} else {
-			cho.Hash = plumbing.NewHash(m.hash)
+			// Branch is empty: checkout by hash if specified, otherwise HEAD is already checked out
+			if m.hash != "" {
+				cho.Hash = plumbing.NewHash(m.hash)
+				needCheckout = true
+			}
+			// If hash is also empty, HEAD is already checked out by clone, no need to checkout again
 		}
-		workTree, err := ref.Worktree()
-		if err != nil {
-			return fmt.Errorf("get worktree: %w", err)
-		}
-		err = workTree.Checkout(&cho)
-		if err != nil {
-			return fmt.Errorf("checkout: %w", err)
+
+		if needCheckout {
+			workTree, err := ref.Worktree()
+			if err != nil {
+				return fmt.Errorf("get worktree: %w", err)
+			}
+			err = workTree.Checkout(&cho)
+			if err != nil {
+				return fmt.Errorf("checkout: %w", err)
+			}
 		}
 	} else {
 		log.Warning(m.ctx, "git clone ref==nil")

dstack-0.19.37/runner/internal/runner/api/ws.go

@@ -0,0 +1,103 @@
+package api
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"time"
+
+	"github.com/dstackai/dstack/runner/internal/log"
+	"github.com/gorilla/websocket"
+)
+
+type logsWsRequestParams struct {
+	startTimestamp int64
+}
+
+var upgrader = websocket.Upgrader{
+	CheckOrigin: func(r *http.Request) bool {
+		return true
+	},
+}
+
+func (s *Server) logsWsGetHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) {
+	conn, err := upgrader.Upgrade(w, r, nil)
+	if err != nil {
+		return nil, err
+	}
+	requestParams, err := parseRequestParams(r)
+	if err != nil {
+		_ = conn.WriteMessage(
+			websocket.CloseMessage,
+			websocket.FormatCloseMessage(websocket.CloseUnsupportedData, err.Error()),
+		)
+		_ = conn.Close()
+		return nil, nil
+	}
+	// todo memorize clientId?
+	go s.streamJobLogs(r.Context(), conn, requestParams)
+	return nil, nil
+}
+
+func parseRequestParams(r *http.Request) (logsWsRequestParams, error) {
+	query := r.URL.Query()
+	startTimeStr := query.Get("start_time")
+	var startTimestamp int64
+	if startTimeStr != "" {
+		t, err := time.Parse(time.RFC3339, startTimeStr)
+		if err != nil {
+			return logsWsRequestParams{}, errors.New("Failed to parse start_time value")
+		}
+		startTimestamp = t.Unix()
+	}
+	return logsWsRequestParams{startTimestamp: startTimestamp}, nil
+}
+
+func (s *Server) streamJobLogs(ctx context.Context, conn *websocket.Conn, params logsWsRequestParams) {
+	defer func() {
+		_ = conn.WriteMessage(websocket.CloseMessage, nil)
+		_ = conn.Close()
+	}()
+	currentPos := 0
+	startTimestampMs := params.startTimestamp * 1000
+	if startTimestampMs != 0 {
+		// TODO: Replace currentPos linear search with binary search
+		s.executor.RLock()
+		jobLogsWsHistory := s.executor.GetJobWsLogsHistory()
+		for _, logEntry := range jobLogsWsHistory {
+			if logEntry.Timestamp < startTimestampMs {
+				currentPos += 1
+			} else {
+				break
+			}
+		}
+		s.executor.RUnlock()
+	}
+	for {
+		s.executor.RLock()
+		jobLogsWsHistory := s.executor.GetJobWsLogsHistory()
+		select {
+		case <-s.shutdownCh:
+			if currentPos >= len(jobLogsWsHistory) {
+				s.executor.RUnlock()
+				close(s.wsDoneCh)
+				return
+			}
+		default:
+			if currentPos >= len(jobLogsWsHistory) {
+				s.executor.RUnlock()
+				time.Sleep(100 * time.Millisecond)
+				continue
+			}
+		}
+		for currentPos < len(jobLogsWsHistory) {
+			if err := conn.WriteMessage(websocket.BinaryMessage, jobLogsWsHistory[currentPos].Message); err != nil {
+				s.executor.RUnlock()
+				log.Error(ctx, "Failed to write message", "err", err)
+				return
+			}
+			currentPos++
+		}
+		s.executor.RUnlock()
+	}
+}

{dstack-0.19.36 → dstack-0.19.37}/runner/internal/schemas/schemas.go

@@ -16,7 +16,7 @@ type JobStateEvent struct {
 
 type LogEvent struct {
 	Message   []byte `json:"message"`
-	Timestamp int64  `json:"timestamp"`
+	Timestamp int64  `json:"timestamp"` // milliseconds
 }
 
 type SubmitBody struct {

{dstack-0.19.36 → dstack-0.19.37}/runner/internal/shim/dcgm/wrapper_linux.go

@@ -1,4 +1,4 @@
-//go:build linux
+//go:build linux && cgo
 
 package dcgm
 

dstack-0.19.37/runner/internal/shim/dcgm/wrapper_linux_nocgo.go

@@ -0,0 +1,9 @@
+//go:build linux && !cgo
+
+package dcgm
+
+import "fmt"
+
+func NewDCGMWrapper(address string) (DCGMWrapperInterface, error) {
+	return nil, fmt.Errorf("DCGM unavailable: built with CGO disabled (cross-compilation)")
+}

{dstack-0.19.36 → dstack-0.19.37}/runner/internal/shim/dcgm/wrapper_linux_test.go

@@ -1,4 +1,4 @@
-//go:build linux
+//go:build linux && cgo
 
 package dcgm
 

{dstack-0.19.36 → dstack-0.19.37}/src/dstack/_internal/cli/commands/attach.py

@@ -11,7 +11,7 @@ from dstack._internal.cli.services.configurators.run import (
     get_run_exit_code,
     print_finished_message,
 )
-from dstack._internal.cli.utils.common import console
+from dstack._internal.cli.utils.common import console, get_start_time
 from dstack._internal.core.consts import DSTACK_RUNNER_HTTP_PORT
 from dstack._internal.core.errors import CLIError
 from dstack._internal.utils.common import get_or_error
@@ -61,6 +61,14 @@ class AttachCommand(APIBaseCommand):
             type=int,
             default=0,
         )
+        self._parser.add_argument(
+            "--since",
+            help=(
+                "Show only logs newer than the specified date."
+                " Can be a duration (e.g. 10s, 5m, 1d) or an RFC 3339 string (e.g. 2023-09-24T15:30:00Z)."
+            ),
+            type=str,
+        )
         self._parser.add_argument("run_name").completer = RunNameCompleter()  # type: ignore[attr-defined]
 
     def _command(self, args: argparse.Namespace):
@@ -86,7 +94,9 @@ class AttachCommand(APIBaseCommand):
                 job_num=args.job,
             )
             if args.logs:
+                start_time = get_start_time(args.since)
                 logs = run.logs(
+                    start_time=start_time,
                     replica_num=args.replica,
                     job_num=args.job,
                 )

{dstack-0.19.36 → dstack-0.19.37}/src/dstack/_internal/cli/commands/logs.py

@@ -1,12 +1,10 @@
 import argparse
 import sys
-from datetime import datetime
-from typing import Optional
 
 from dstack._internal.cli.commands import APIBaseCommand
 from dstack._internal.cli.services.completion import RunNameCompleter
+from dstack._internal.cli.utils.common import get_start_time
 from dstack._internal.core.errors import CLIError
-from dstack._internal.utils.common import parse_since
 from dstack._internal.utils.logging import get_logger
 
 logger = get_logger(__name__)
@@ -49,7 +47,7 @@ class LogsCommand(APIBaseCommand):
         if run is None:
             raise CLIError(f"Run {args.run_name} not found")
 
-        start_time = _get_start_time(args.since)
+        start_time = get_start_time(args.since)
         logs = run.logs(
             start_time=start_time,
             diagnose=args.diagnose,
@@ -62,12 +60,3 @@ class LogsCommand(APIBaseCommand):
                 sys.stdout.buffer.flush()
         except KeyboardInterrupt:
             pass
-
-
-def _get_start_time(since: Optional[str]) -> Optional[datetime]:
-    if since is None:
-        return None
-    try:
-        return parse_since(since)
-    except ValueError as e:
-        raise CLIError(e.args[0])

{dstack-0.19.36 → dstack-0.19.37}/src/dstack/_internal/cli/services/configurators/run.py

@@ -562,8 +562,7 @@ class BaseRunConfigurator(
             local_path = Path.cwd()
             legacy_local_path = True
         if url:
-            # "master" is a dummy value, we'll fetch the actual default branch later
-            repo = RemoteRepo.from_url(repo_url=url, repo_branch="master")
+            repo = RemoteRepo.from_url(repo_url=url)
             repo_head = self.api.repos.get(repo_id=repo.repo_id, with_creds=True)
         elif local_path:
             if legacy_local_path:
@@ -628,15 +627,16 @@ class BaseRunConfigurator(
                 raise CLIError(*e.args) from e
 
             if repo_branch is None and repo_hash is None:
-                repo_branch = default_repo_branch
-                if repo_branch is None:
+                if default_repo_branch is None:
                     raise CLIError(
                         "Failed to automatically detect remote repo branch."
                         " Specify branch or hash."
                     )
-            repo = RemoteRepo.from_url(
-                repo_url=repo.repo_url, repo_branch=repo_branch, repo_hash=repo_hash
-            )
+                # TODO: remove in 0.20. Currently `default_repo_branch` is sent only for backward compatibility of `dstack-runner`.
+                repo_branch = default_repo_branch
+            repo.run_repo_data.repo_branch = repo_branch
+            if repo_hash is not None:
+                repo.run_repo_data.repo_hash = repo_hash
 
         if init:
             self.api.repos.init(

{dstack-0.19.36 → dstack-0.19.37}/src/dstack/_internal/cli/utils/common.py

@@ -1,7 +1,7 @@
 import logging
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any, Dict, Union
+from typing import Any, Dict, Optional, Union
 
 from rich.console import Console
 from rich.prompt import Confirm
@@ -11,7 +11,7 @@ from rich.theme import Theme
 from dstack._internal import settings
 from dstack._internal.cli.utils.rich import DstackRichHandler
 from dstack._internal.core.errors import CLIError, DstackError
-from dstack._internal.utils.common import get_dstack_dir
+from dstack._internal.utils.common import get_dstack_dir, parse_since
 
 _colors = {
     "secondary": "grey58",
@@ -110,3 +110,12 @@ def warn(message: str):
         # Additional blank line for better visibility if there are more than one warning
         message = f"{message}\n"
     console.print(f"[warning][bold]{message}[/]")
+
+
+def get_start_time(since: Optional[str]) -> Optional[datetime]:
+    if since is None:
+        return None
+    try:
+        return parse_since(since)
+    except ValueError as e:
+        raise CLIError(e.args[0])

{dstack-0.19.36 → dstack-0.19.37}/src/dstack/_internal/core/backends/base/compute.py

@@ -111,6 +111,7 @@ class Compute(ABC):
         project_ssh_public_key: str,
         project_ssh_private_key: str,
         volumes: List[Volume],
+        placement_group: Optional[PlacementGroup],
     ) -> JobProvisioningData:
         """
         Launches a new instance for the job. It should return `JobProvisioningData` ASAP.
@@ -287,6 +288,7 @@ class ComputeWithCreateInstanceSupport(ABC):
         project_ssh_public_key: str,
         project_ssh_private_key: str,
         volumes: List[Volume],
+        placement_group: Optional[PlacementGroup],
     ) -> JobProvisioningData:
         """
         The default `run_job()` implementation for all backends that support `create_instance()`.
@@ -303,7 +305,9 @@ class ComputeWithCreateInstanceSupport(ABC):
         )
         instance_offer = instance_offer.copy()
         self._restrict_instance_offer_az_to_volumes_az(instance_offer, volumes)
-        return self.create_instance(instance_offer, instance_config, placement_group=None)
+        return self.create_instance(
+            instance_offer, instance_config, placement_group=placement_group
+        )
 
     def _restrict_instance_offer_az_to_volumes_az(
         self,
@@ -335,6 +339,7 @@ class ComputeWithGroupProvisioningSupport(ABC):
         instance_offer: InstanceOfferWithAvailability,
         project_ssh_public_key: str,
         project_ssh_private_key: str,
+        placement_group: Optional[PlacementGroup],
     ) -> ComputeGroupProvisioningData:
         pass
 

{dstack-0.19.36 → dstack-0.19.37}/src/dstack/_internal/core/backends/base/offers.py

@@ -225,6 +225,7 @@ def get_offers_disk_modifier(
         offer_copy.instance.resources.disk = Disk(
             size_mib=get_or_error(disk_size_range.min) * 1024
         )
+        offer_copy.instance.resources.update_description()
         return offer_copy
 
     return modifier