Merge origin/main: adopt #1508's removal of code-bundle memoization

Main removed the alru_cache on build_code_bundle entirely (rebuild after
source changes), which solves the stale-bundle problem at the root. Drop
this branch's refresh_code_bundle_cache() and skip_cache memo-bypass —
they managed a cache that no longer exists. control_plane_available()
and Run.first_failure() / ActionDetails.error_message remain.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NwQixBcyR5va6BC75jaQx3

Author: cosmicBboy

examples/integration_tests.py

@@ -32,11 +32,6 @@
 # =============================================================================
 
 
-@pytest.fixture(autouse=True)
-def clear_lru_caches():
-    flyte.refresh_code_bundle_cache()
-
-
 @pytest.fixture(scope="session")
 def flyte_client():
     """

src/flyte/__init__.py

@@ -57,24 +57,6 @@ def version() -> str:
     return __version__
 
 
-def refresh_code_bundle_cache() -> None:
-    """
-    Forget every in-process memoized code bundle, so the next `flyte.run` / `flyte.deploy` /
-    `flyte.serve` (or a fork of a prior run) re-bundles the working tree as it is on disk *now*.
-
-    Code bundles are memoized per-process on their build arguments, not on file contents: a
-    long-lived process that launches a run, edits source files, and launches again would ship
-    the first launch's bundle — edits and all. Call this after changing files on disk (an agent
-    task rewriting a workflow it iterates on, a notebook cell editing a module, ...) and before
-    the next launch.
-    """
-    # Imported lazily: the bundling machinery is not part of the base `import flyte` cost, and
-    # if it was never imported there are no memoized bundles to forget.
-    from ._code_bundle import refresh_code_bundle_cache as _refresh
-
-    _refresh()
-
-
 __all__ = [
     "AMD_GPU",
     "GPU",
@@ -134,7 +116,6 @@ def refresh_code_bundle_cache() -> None:
     "logger",
     "map",
     "new_condition",
-    "refresh_code_bundle_cache",
     "rerun",
     "run",
     "run_python_script",

src/flyte/_code_bundle/__init__.py

@@ -71,10 +71,6 @@
   for `copy_style="custom"`.
 * `flyte._code_bundle.build_pkl_bundle` — cloudpickle the task/app in memory and
   upload. Returns a pkl `flyte.models.CodeBundle`.
-* `flyte._code_bundle.bundle.refresh_code_bundle_cache` (exported as
-  `flyte.refresh_code_bundle_cache`) — forget in-process memoized bundles so the
-  next launch re-bundles files as they are on disk now. For long-lived processes
-  that edit source between launches.
 * `flyte._code_bundle.download_bundle` — the counterpart that runs on the worker:
   fetch the tgz/pkl and extract it into the task's working directory.
 """
@@ -86,7 +82,6 @@
     build_code_bundle_from_relative_paths,
     build_pkl_bundle,
     download_bundle,
-    refresh_code_bundle_cache,
 )
 
 __all__ = [
@@ -97,7 +92,6 @@
     "build_pkl_bundle",
     "default_ignores",
     "download_bundle",
-    "refresh_code_bundle_cache",
 ]
 
 

src/flyte/_code_bundle/bundle.py

@@ -20,8 +20,6 @@
 except ImportError:  # pragma: no cover - Windows local dev; task containers are POSIX
     fcntl = None  # type: ignore[assignment]  # ty: ignore[invalid-assignment]
 
-from async_lru import alru_cache
-
 from flyte._logging import log, logger
 from flyte._status import status
 from flyte._utils import AsyncLRUCache
@@ -184,7 +182,7 @@ async def build_pkl_bundle(
             return CodeBundle(pkl=str(dest), computed_version=str_digest)
 
 
-async def _build_code_bundle(
+async def build_code_bundle(
     from_dir: Path,
     *ignore: Type[Ignore],
     extract_dir: str = ".",
@@ -194,7 +192,25 @@ async def _build_code_bundle(
     skip_cache: bool = False,
     additional_files: tuple[str, ...] = (),
 ) -> CodeBundle:
-    """Unmemoized implementation of `build_code_bundle` — see it for the parameter docs."""
+    """
+    Build the code bundle for the current environment.
+
+    Args:
+        from_dir: The directory of the code to bundle. This is the root directory for the source.
+        extract_dir: The directory to extract the code bundle to, when in the container. It defaults to the current
+            working directory.
+        ignore: The list of ignores to apply. This is a list of Ignore classes.
+        dryrun: If dryrun is enabled, files will not be uploaded to the control plane.
+        copy_bundle_to: If set, the bundle will be copied to this path. This is used for testing purposes.
+        copy_style: What to put into the tarball. (either all, or loaded_modules. if none, skip this function)
+        skip_cache: If true, skip the persistent SQLite cache lookup and always rebuild/re-upload.
+        additional_files: Extra absolute paths to bundle in addition to whatever `copy_style`
+            discovers. Used to implement `Environment.include`. When `copy_style='none'` and
+            `additional_files` is non-empty, falls back to a relative-paths-only bundle.
+
+    Returns:
+        The code bundle, which contains the path where the code was zipped to.
+    """
     if copy_style == "none":
         if additional_files:
             return await build_code_bundle_from_relative_paths(
@@ -203,7 +219,6 @@ async def _build_code_bundle(
                 extract_dir=extract_dir,
                 dryrun=dryrun,
                 copy_bundle_to=copy_bundle_to,
-                skip_cache=skip_cache,
             )
         raise ValueError("If copy_style is 'none', just don't make a code bundle")
 
@@ -274,73 +289,29 @@ async def _build_code_bundle(
         return CodeBundle(tgz=remote_path, destination=extract_dir, computed_version=hash_digest, files=files)
 
 
-_memoized_build_code_bundle = alru_cache(_build_code_bundle)
-
-
-async def build_code_bundle(
+async def build_code_bundle_from_relative_paths(
+    relative_paths: tuple[str, ...],
     from_dir: Path,
-    *ignore: Type[Ignore],
     extract_dir: str = ".",
     dryrun: bool = False,
     copy_bundle_to: pathlib.Path | None = None,
-    copy_style: CopyFiles = "loaded_modules",
     skip_cache: bool = False,
-    additional_files: tuple[str, ...] = (),
 ) -> CodeBundle:
     """
-    Build the code bundle for the current environment.
-
-    Results are memoized in-process on the arguments alone (so one `flyte deploy` bundling many
-    environments scans and uploads once). If files on disk change while the process lives — e.g.
-    an agent task that rewrites source and re-launches — call `flyte.refresh_code_bundle_cache`
-    (or pass `skip_cache=True`) so the next bundle reflects the working tree as it is now.
+    Build a code bundle from a list of relative paths.
 
     Args:
+        relative_paths: The list of relative paths to bundle.
         from_dir: The directory of the code to bundle. This is the root directory for the source.
         extract_dir: The directory to extract the code bundle to, when in the container. It defaults to the current
             working directory.
-        ignore: The list of ignores to apply. This is a list of Ignore classes.
         dryrun: If dryrun is enabled, files will not be uploaded to the control plane.
         copy_bundle_to: If set, the bundle will be copied to this path. This is used for testing purposes.
-        copy_style: What to put into the tarball. (either all, or loaded_modules. if none, skip this function)
-        skip_cache: If true, bypass the in-process memoization and the persistent SQLite cache
-            lookup — always rescan the working tree and rebuild/re-upload.
-        additional_files: Extra absolute paths to bundle in addition to whatever `copy_style`
-            discovers. Used to implement `Environment.include`. When `copy_style='none'` and
-            `additional_files` is non-empty, falls back to a relative-paths-only bundle.
+        skip_cache: If true, skip the persistent SQLite cache lookup and always rebuild/re-upload.
 
     Returns:
         The code bundle, which contains the path where the code was zipped to.
     """
-    builder = _build_code_bundle if skip_cache else _memoized_build_code_bundle
-    return await builder(
-        from_dir,
-        *ignore,
-        extract_dir=extract_dir,
-        dryrun=dryrun,
-        copy_bundle_to=copy_bundle_to,
-        copy_style=copy_style,
-        skip_cache=skip_cache,
-        additional_files=additional_files,
-    )
-
-
-# Kept for callers that historically reached for `build_code_bundle.cache_clear()`; prefer
-# `flyte.refresh_code_bundle_cache`.
-build_code_bundle.cache_clear = (  # type: ignore[attr-defined]  # ty: ignore[unresolved-attribute]
-    _memoized_build_code_bundle.cache_clear
-)
-
-
-async def _build_code_bundle_from_relative_paths(
-    relative_paths: tuple[str, ...],
-    from_dir: Path,
-    extract_dir: str = ".",
-    dryrun: bool = False,
-    copy_bundle_to: pathlib.Path | None = None,
-    skip_cache: bool = False,
-) -> CodeBundle:
-    """Unmemoized implementation of `build_code_bundle_from_relative_paths` — see it for the parameter docs."""
     status.step("Bundling code...")
     logger.debug("Building code bundle from relative paths.")
     from flyte.remote import upload_file
@@ -380,70 +351,6 @@ async def _build_code_bundle_from_relative_paths(
         return CodeBundle(tgz=remote_path, destination=extract_dir, computed_version=hash_digest, files=files)
 
 
-_memoized_build_code_bundle_from_relative_paths = alru_cache(_build_code_bundle_from_relative_paths)
-
-
-async def build_code_bundle_from_relative_paths(
-    relative_paths: tuple[str, ...],
-    from_dir: Path,
-    extract_dir: str = ".",
-    dryrun: bool = False,
-    copy_bundle_to: pathlib.Path | None = None,
-    skip_cache: bool = False,
-) -> CodeBundle:
-    """
-    Build a code bundle from a list of relative paths.
-
-    Results are memoized in-process on the arguments alone — see `build_code_bundle` for when
-    and how to bypass that.
-
-    Args:
-        relative_paths: The list of relative paths to bundle.
-        from_dir: The directory of the code to bundle. This is the root directory for the source.
-        extract_dir: The directory to extract the code bundle to, when in the container. It defaults to the current
-            working directory.
-        dryrun: If dryrun is enabled, files will not be uploaded to the control plane.
-        copy_bundle_to: If set, the bundle will be copied to this path. This is used for testing purposes.
-        skip_cache: If true, bypass the in-process memoization and the persistent SQLite cache
-            lookup — always rescan the listed files and rebuild/re-upload.
-
-    Returns:
-        The code bundle, which contains the path where the code was zipped to.
-    """
-    builder = _build_code_bundle_from_relative_paths if skip_cache else _memoized_build_code_bundle_from_relative_paths
-    return await builder(
-        relative_paths,
-        from_dir=from_dir,
-        extract_dir=extract_dir,
-        dryrun=dryrun,
-        copy_bundle_to=copy_bundle_to,
-        skip_cache=skip_cache,
-    )
-
-
-# Kept for callers that historically reached for `.cache_clear()`; prefer
-# `flyte.refresh_code_bundle_cache`.
-build_code_bundle_from_relative_paths.cache_clear = (  # type: ignore[attr-defined]  # ty: ignore[unresolved-attribute]
-    _memoized_build_code_bundle_from_relative_paths.cache_clear
-)
-
-
-def refresh_code_bundle_cache() -> None:
-    """
-    Forget every in-process memoized code bundle, so the next `flyte.run` / `flyte.deploy` /
-    `flyte.serve` (or a fork of a prior run) re-bundles the working tree as it is on disk *now*.
-
-    Code bundles are memoized per-process on their build arguments, not on file contents: a
-    long-lived process that launches a run, edits source files, and launches again would ship
-    the first launch's bundle — edits and all. Call this after changing files on disk (an agent
-    task rewriting a workflow it iterates on, a notebook cell editing a module, ...) and before
-    the next launch. The persistent content-addressed cache underneath needs no refreshing — a
-    changed working tree produces a new digest, which simply misses and re-uploads.
-    """
-    _memoized_build_code_bundle.cache_clear()
-    _memoized_build_code_bundle_from_relative_paths.cache_clear()
-
-
 @contextlib.asynccontextmanager
 async def _bundle_lock(lock_path: pathlib.Path) -> AsyncIterator[bool]:
     """

src/flyte/connectors/_connector.py

@@ -1,6 +1,8 @@
 import asyncio
 import json
 import os
+import pathlib
+import tempfile
 import typing
 from abc import ABC, abstractmethod
 from dataclasses import asdict, dataclass
@@ -248,24 +250,12 @@ async def execute(self, **kwargs) -> Any:
             if not storage.is_remote(tctx.raw_data_path.path):
                 return await TaskTemplate.execute(self, **kwargs)
             else:
-                local_code_bundle = await build_code_bundle(
-                    from_dir=cfg.root_dir,
-                    dryrun=True,
-                )
-                if local_code_bundle.tgz is None:
-                    raise RuntimeError("no tgz found in code bundle")
-                remote_code_path = await storage.put(
-                    local_code_bundle.tgz, prefix + "/code_bundle/" + os.path.basename(local_code_bundle.tgz)
-                )
+                code_bundle = await _build_and_upload_code_bundle(cfg.root_dir, prefix)
                 sc = SerializationContext(
                     project=tctx.action.project,
                     domain=tctx.action.domain,
                     org=tctx.action.org,
-                    code_bundle=CodeBundle(
-                        tgz=remote_code_path,
-                        computed_version=local_code_bundle.computed_version,
-                        destination="/opt/flyte/",
-                    ),
+                    code_bundle=code_bundle,
                     version=tctx.version,
                     image_cache=await build_images.aio(task.parent_env()) if task.parent_env else None,
                     root_dir=cfg.root_dir,
@@ -331,6 +321,25 @@ async def execute(self, **kwargs) -> Any:
         return tuple(resource.outputs.values())
 
 
+async def _build_and_upload_code_bundle(from_dir: pathlib.Path, prefix: str) -> CodeBundle:
+    with tempfile.TemporaryDirectory(prefix="flyte-code-bundle-") as tmp_dir:
+        local_code_bundle = await build_code_bundle(
+            from_dir=from_dir,
+            dryrun=True,
+            copy_bundle_to=pathlib.Path(tmp_dir),
+        )
+        if local_code_bundle.tgz is None:
+            raise RuntimeError("no tgz found in code bundle")
+        remote_code_path = await storage.put(
+            local_code_bundle.tgz, prefix + "/code_bundle/" + os.path.basename(local_code_bundle.tgz)
+        )
+    return CodeBundle(
+        tgz=remote_code_path,
+        computed_version=local_code_bundle.computed_version,
+        destination="/opt/flyte/",
+    )
+
+
 async def get_resource_proto(resource: Resource) -> connector_pb2.Resource:
     if resource.outputs:
         interface = NativeInterface.from_types(inputs={}, outputs={k: type(v) for k, v in resource.outputs.items()})

tests/flyte/app/test_app_code_bundling.py

@@ -50,7 +50,7 @@ async def test_code_bundle_consistency_with_include_files(temp_app_directory):
         from_dir=temp_app_directory,
         dryrun=True,
     )
-    build_code_bundle_from_relative_paths.cache_clear()
+
     bundle2 = await build_code_bundle_from_relative_paths(
         relative_paths=include_files,
         from_dir=temp_app_directory,
@@ -70,7 +70,7 @@ async def test_code_bundle_consistency_with_subdirectory_files(temp_app_director
         from_dir=temp_app_directory,
         dryrun=True,
     )
-    build_code_bundle_from_relative_paths.cache_clear()
+
     bundle2 = await build_code_bundle_from_relative_paths(
         relative_paths=include_files,
         from_dir=temp_app_directory,
@@ -89,7 +89,7 @@ async def test_code_bundle_different_files_produce_different_versions(temp_app_d
         from_dir=temp_app_directory,
         dryrun=True,
     )
-    build_code_bundle_from_relative_paths.cache_clear()
+
     bundle2 = await build_code_bundle_from_relative_paths(
         relative_paths=("app.py", "utils.py"),
         from_dir=temp_app_directory,
@@ -106,7 +106,7 @@ async def test_code_bundle_file_content_changes_version(temp_app_directory):
         from_dir=temp_app_directory,
         dryrun=True,
     )
-    build_code_bundle_from_relative_paths.cache_clear()
+
     (temp_app_directory / "app.py").write_text("print('Modified content!')")
     bundle2 = await build_code_bundle_from_relative_paths(
         relative_paths=("app.py",),