From fa3caf0df4630fdb2fdc9e485157c287b92f69d4 Mon Sep 17 00:00:00 2001
From: Alessandro Pomponio <alessandro.pomponio1@ibm.com>
Date: Fri, 24 Jul 2026 10:13:19 +0100
Subject: [PATCH 1/3] refactor(core): deprecate old fetch entities methods in
 favour of get_entities

Signed-off-by: Alessandro Pomponio <alessandro.pomponio1@ibm.com>
---
 ado/core/samplestore/base.py                  |   7 +-
 ado/core/samplestore/sql.py                   | 182 +++---------------
 .../operators/discovery_space_manager.py      |   5 +-
 tests/samplestore/create/test_create.py       |   5 +-
 tests/samplestore/get/test_get.py             |  62 ++++--
 5 files changed, 80 insertions(+), 181 deletions(-)

diff --git a/ado/core/samplestore/base.py b/ado/core/samplestore/base.py
index 79d6ee5df..e9b7c18e1 100644
--- a/ado/core/samplestore/base.py
+++ b/ado/core/samplestore/base.py
@@ -517,13 +517,16 @@ def addMeasurement(
     def entityWithIdentifier(
         self, entityIdentifier: str
     ) -> Entity | None:  # pragma: nocover
-        pass
+        """Deprecated: use :meth:`get_entities` instead.
+
+        Returns entity if it is in the store, otherwise returns ``None``.
+        """
 
     @abc.abstractmethod
     def entities_with_identifiers(
         self, entity_identifiers: set[str] | list[str]
     ) -> list[Entity]:
-        """Fetch the entities given by entity_identifiers.
+        """Deprecated: use :meth:`get_entities` instead.
 
         Args:
             entity_identifiers: Set or list of entity identifiers to fetch
diff --git a/ado/core/samplestore/sql.py b/ado/core/samplestore/sql.py
index 8d9d97fd2..53aae2e1a 100644
--- a/ado/core/samplestore/sql.py
+++ b/ado/core/samplestore/sql.py
@@ -222,7 +222,7 @@ def experimentCatalog(
 
         # Step 2: load those entities (with their measurement results) via the
         # existing method which handles caching, decoding, and result attachment.
-        entities = self.entities_with_identifiers(entity_ids)
+        entities = self.get_entities(identifiers=entity_ids, require_measurements=True)
 
         # Step 3: build the catalog from the fully-loaded entities.
         experiments: dict[str, Experiment] = {}
@@ -734,10 +734,7 @@ def refresh(self, force_fetch_all_entities: bool = False) -> tuple[int, int]:
     def entities_with_identifiers(
         self, entity_identifiers: set[str] | list[str]
     ) -> list[Entity]:
-        """Efficiently fetch entities by their identifiers without loading all entities.
-
-        This method queries only the specified entities from the database, making it
-        much more efficient than loading all entities and filtering in Python.
+        """Deprecated: use :meth:`get_entities` instead.
 
         Args:
             entity_identifiers: Set or list of entity identifiers to fetch
@@ -745,97 +742,15 @@ def entities_with_identifiers(
         Returns:
             List of Entity objects matching the provided identifiers
         """
-        if not entity_identifiers:
-            return []
-
-        # Convert to set for deduplication and efficient lookup
-        entity_ids_set = (
-            set(entity_identifiers)
-            if isinstance(entity_identifiers, list)
-            else entity_identifiers
-        )
-
-        # Partition into cached and uncached IDs
-        cached_keys = (
-            entity_ids_set.intersection(self._entities.keys())
-            if self._entities
-            else set()
+        warnings.warn(
+            "entities_with_identifiers is deprecated, use get_entities instead.",
+            DeprecationWarning,
+            stacklevel=2,
         )
-        uncached_ids = entity_ids_set.difference(cached_keys)
-        cached_entities = [self._entities[k] for k in cached_keys]
-
-        # All requested entities were already cached
-        if not uncached_ids:
-            return cached_entities
-
-        # Query database only for the uncached entities
-        # Use SQLAlchemy's expanding bindparam for IN clause
-        # This automatically handles the parameter expansion for the IN clause
-        query = sqlalchemy.text(f"""
-            SELECT ent.identifier, ent.representation, res.data
-            FROM {self._tablename} ent
-            LEFT OUTER JOIN {self._tablename}_measurement_results res ON res.entity_id = ent.identifier
-            WHERE ent.identifier IN :entity_ids
-        """).bindparams(  # noqa: S608 - self._tablename is not untrusted
-            sqlalchemy.bindparam(
-                key="entity_ids", value=list(uncached_ids), expanding=True
-            )
+        return self.get_entities(
+            identifiers=set(entity_identifiers), require_measurements=True
         )
 
-        try:
-            with self.engine.begin() as connectable:
-                cur = connectable.execute(query)
-        except SQLAlchemyError as error:
-            msg = f"Unable to fetch entities by identifiers from sample store {self._tablename}"
-            self.log.critical(f"{msg}. Error: {error}")
-            raise SystemError(f"{msg}. Error: {error}") from error
-
-        # Build result dictionary to handle multiple measurement results per entity
-        entities_dict: dict[str, Entity] = {}
-        for entity_identifier, entity_representation, result_data in cur:
-            if entity_identifier not in entities_dict:
-                try:
-                    entities_dict[entity_identifier] = Entity.model_validate(
-                        json.loads(entity_representation)
-                    )
-                    # Update cache if it exists
-                    if self._entities is not None:
-                        self._entities[entity_identifier] = entities_dict[
-                            entity_identifier
-                        ]
-                except Exception as error:
-                    raise FailedToDecodeStoredEntityError(
-                        entity_identifier=entity_identifier,
-                        entity_representation=entity_representation,
-                        cause=error,
-                    ) from error
-
-            if result_data is None:
-                self.log.debug(
-                    f"Entity {entity_identifier} had no measurements associated to it."
-                )
-                continue
-
-            try:
-                result_dict = json.loads(result_data)
-                if not result_dict.get("measurements", None):
-                    continue
-
-                measurement_result = ValidMeasurementResult.model_validate(result_dict)
-            except Exception as error:
-                raise FailedToDecodeStoredMeasurementResultForEntityError(
-                    entity_identifier=entity_identifier,
-                    result_representation=result_data,
-                    cause=error,
-                ) from error
-
-            # Add measurement result to entity
-            entities_dict[entity_identifier].add_measurement_result(
-                result=measurement_result
-            )
-
-        return cached_entities + list(entities_dict.values())
-
     def get_entities(
         self,
         identifiers: str | set[str] | None = None,
@@ -932,10 +847,12 @@ def entities_in_operations(self, operation_ids: str | set[str]) -> list[Entity]:
         Returns:
             List of Entity objects that were sampled in the specified operation(s)
         """
-        # Use entity_identifiers_in_operations + entities_with_identifiers so that
+        # Use entity_identifiers_in_operations + get_entities so that
         # the entity cache is used when fetching entities.
         entity_ids = self.entity_identifiers_in_operations(operation_ids)
-        return self.entities_with_identifiers(entity_ids)
+        return self.get_entities(
+            identifiers=set(entity_ids), require_measurements=False
+        )
 
     def entities_in_operation(self, operation_ids: str | set[str]) -> list[Entity]:
         """Deprecated: use entities_in_operations instead."""
@@ -1164,67 +1081,19 @@ def delete(self) -> None:
         pass
 
     def entityWithIdentifier(self, entityIdentifier: str) -> Entity | None:
-        """Returns entity if its in receiver otherwise returns None"""
+        """Deprecated: use :meth:`get_entities` instead.
 
-        query = sqlalchemy.text(f"""
-                SELECT ent.identifier, ent.representation, res.data
-                FROM (
-                    SELECT identifier, representation
-                    FROM {self._tablename} ent
-                    WHERE identifier = :identifier
-                ) ent
-                LEFT OUTER JOIN {self._tablename}_measurement_results res ON ent.identifier = res.entity_id
-            """).bindparams(  # noqa: S608 - self._tablename is not untrusted
-            identifier=entityIdentifier
+        Returns entity if it is in the store, otherwise returns ``None``.
+        """
+        warnings.warn(
+            "entityWithIdentifier is deprecated, use get_entities instead.",
+            DeprecationWarning,
+            stacklevel=2,
         )
-
-        try:
-            with self.engine.begin() as connectable:
-                cur = connectable.execute(query)
-        except SQLAlchemyError as error:
-            msg = f"Unable to fetch entity {entityIdentifier} and measurements from sample store {self._tablename}"
-            self.log.critical(f"{msg}. Error: {error}")
-            raise SystemError(f"{msg}. Error: {error}") from error
-
-        entity = None
-        failures = 0
-        for entity_identifier, entity_representation, result_data in cur:
-            if entity is None:
-                try:
-                    entity = Entity.model_validate(json.loads(entity_representation))
-                except Exception as error:
-                    self.log.warning(
-                        f"Unable to decode representation for entity {entity_identifier}.\n"
-                        f"Representation was: {entity_representation}.\n"
-                        f"Error was {error}"
-                    )
-                    return None
-
-            if result_data is None:
-                self.log.info(
-                    f"Entity {entity_identifier} had no measurements associated to it."
-                )
-                continue
-
-            try:
-                result_dict = json.loads(result_data)
-                if not result_dict.get("measurements", None):
-                    continue
-
-                measurement_result = ValidMeasurementResult.model_validate(result_dict)
-            except Exception as error:
-                self.log.warning(
-                    f"Unable to decode a measurement result for entity {entity_identifier}.\n"
-                    f"Data was: {result_data}.\n"
-                    f"Error was {error}"
-                )
-                failures += 1
-                continue
-
-            # We need to manually add valid measurements to the entity
-            entity.add_measurement_result(result=measurement_result)
-
-        return entity
+        results = self.get_entities(
+            identifiers=entityIdentifier, require_measurements=True
+        )
+        return results[0] if results else None
 
     @property
     def uri(self) -> str:
@@ -2076,7 +1945,10 @@ def _measurement_requests_cursor_to_pydantic(
 
             # We also need the entity referenced by the measurement
             if entity_id not in self._entities:
-                self._entities[entity_id] = self.entityWithIdentifier(entity_id)
+                results = self.get_entities(
+                    identifiers=entity_id, require_measurements=False
+                )
+                self._entities[entity_id] = results[0] if results else None
 
             entity = self._entities[entity_id]
 
diff --git a/ado/modules/operators/discovery_space_manager.py b/ado/modules/operators/discovery_space_manager.py
index 3a402ab26..ac436199c 100644
--- a/ado/modules/operators/discovery_space_manager.py
+++ b/ado/modules/operators/discovery_space_manager.py
@@ -211,9 +211,10 @@ async def entitiesSlice(self, start: int = 0, stop: int = 1) -> list["Entity"]:
 
     def storedEntityWithIdentifier(self, entityIdentifier: str) -> "Entity | None":
 
-        return self._discoverySpace.sample_store.entityWithIdentifier(
-            entityIdentifier=entityIdentifier
+        results = self._discoverySpace.sample_store.get_entities(
+            identifiers=entityIdentifier, require_measurements=False
         )
+        return results[0] if results else None
 
     def storedEntitiesWithConstitutivePropertyValues(
         self, propVals: list[PropertyValue]
diff --git a/tests/samplestore/create/test_create.py b/tests/samplestore/create/test_create.py
index fc16119e8..02beb92fa 100644
--- a/tests/samplestore/create/test_create.py
+++ b/tests/samplestore/create/test_create.py
@@ -177,7 +177,10 @@ def test_add_external_entities(
     assert len(sample_store.entity_identifiers().intersection({entity.identifier})) == 1
 
     #
-    retrieved_entity = sample_store.entityWithIdentifier(entity.identifier)
+    results = sample_store.get_entities(
+        identifiers=entity.identifier, require_measurements=False
+    )
+    retrieved_entity = results[0] if results else None
     assert retrieved_entity is not None
     assert len(retrieved_entity.propertyValues) == len(entity.propertyValues)
     for i, property_value in enumerate(entity.propertyValues):
diff --git a/tests/samplestore/get/test_get.py b/tests/samplestore/get/test_get.py
index 3120bfe91..4da06b995 100644
--- a/tests/samplestore/get/test_get.py
+++ b/tests/samplestore/get/test_get.py
@@ -659,9 +659,10 @@ def test_entity_results_keep_uids(
 ) -> None:
 
     ml_multi_cloud_sample_store.add_external_entities([entity])
-    retrieved_entity = ml_multi_cloud_sample_store.entityWithIdentifier(
-        entityIdentifier=entity.identifier
+    results = ml_multi_cloud_sample_store.get_entities(
+        identifiers=entity.identifier, require_measurements=True
     )
+    retrieved_entity = results[0]
 
     assert len(entity.measurement_results) == len(retrieved_entity.measurement_results)
     for i in range(len(retrieved_entity.measurement_results)):
@@ -726,10 +727,16 @@ def test_entities_by_identifiers_empty_input(
     ml_multi_cloud_sample_store: SQLSampleStore,
 ) -> None:
     """Test entities_with_identifiers with empty input returns empty list."""
-    result = ml_multi_cloud_sample_store.entities_with_identifiers([])
+    with pytest.warns(
+        DeprecationWarning, match="entities_with_identifiers is deprecated"
+    ):
+        result = ml_multi_cloud_sample_store.entities_with_identifiers([])
     assert result == []
 
-    result = ml_multi_cloud_sample_store.entities_with_identifiers(set())
+    with pytest.warns(
+        DeprecationWarning, match="entities_with_identifiers is deprecated"
+    ):
+        result = ml_multi_cloud_sample_store.entities_with_identifiers(set())
     assert result == []
 
 
@@ -737,13 +744,14 @@ def test_entities_by_identifiers_list_input(
     ml_multi_cloud_sample_store: SQLSampleStore,
 ) -> None:
     """Test entities_with_identifiers accepts list input."""
-    # Get some entity identifiers from the store
     all_entities = ml_multi_cloud_sample_store.get_entities(require_measurements=False)
     assert len(all_entities) > 0
 
-    # Test with list input
     entity_ids_list = [all_entities[0].identifier, all_entities[1].identifier]
-    result = ml_multi_cloud_sample_store.entities_with_identifiers(entity_ids_list)
+    with pytest.warns(
+        DeprecationWarning, match="entities_with_identifiers is deprecated"
+    ):
+        result = ml_multi_cloud_sample_store.entities_with_identifiers(entity_ids_list)
 
     assert len(result) == 2
     assert {e.identifier for e in result} == set(entity_ids_list)
@@ -753,13 +761,14 @@ def test_entities_by_identifiers_set_input(
     ml_multi_cloud_sample_store: SQLSampleStore,
 ) -> None:
     """Test entities_with_identifiers accepts set input."""
-    # Get some entity identifiers from the store
     all_entities = ml_multi_cloud_sample_store.get_entities(require_measurements=False)
     assert len(all_entities) > 0
 
-    # Test with set input
     entity_ids_set = {all_entities[0].identifier, all_entities[1].identifier}
-    result = ml_multi_cloud_sample_store.entities_with_identifiers(entity_ids_set)
+    with pytest.warns(
+        DeprecationWarning, match="entities_with_identifiers is deprecated"
+    ):
+        result = ml_multi_cloud_sample_store.entities_with_identifiers(entity_ids_set)
 
     assert len(result) == 2
     assert {e.identifier for e in result} == entity_ids_set
@@ -769,13 +778,14 @@ def test_entities_by_identifiers_subset(
     ml_multi_cloud_sample_store: SQLSampleStore,
 ) -> None:
     """Test entities_with_identifiers returns only requested entities."""
-    # Get all entities from the store
     all_entities = ml_multi_cloud_sample_store.get_entities(require_measurements=False)
     assert len(all_entities) >= 3
 
-    # Request only a subset
     requested_ids = {all_entities[0].identifier, all_entities[2].identifier}
-    result = ml_multi_cloud_sample_store.entities_with_identifiers(requested_ids)
+    with pytest.warns(
+        DeprecationWarning, match="entities_with_identifiers is deprecated"
+    ):
+        result = ml_multi_cloud_sample_store.entities_with_identifiers(requested_ids)
 
     assert len(result) == 2
     assert {e.identifier for e in result} == requested_ids
@@ -795,9 +805,11 @@ def test_entities_by_identifiers_nonexistent_entities(
     ml_multi_cloud_sample_store: SQLSampleStore,
 ) -> None:
     """Test entities_with_identifiers with non-existent entity identifiers."""
-    # Request entities that don't exist
     nonexistent_ids = {"nonexistent_id_1", "nonexistent_id_2"}
-    result = ml_multi_cloud_sample_store.entities_with_identifiers(nonexistent_ids)
+    with pytest.warns(
+        DeprecationWarning, match="entities_with_identifiers is deprecated"
+    ):
+        result = ml_multi_cloud_sample_store.entities_with_identifiers(nonexistent_ids)
 
     # Should return empty list, not raise an error
     assert result == []
@@ -810,13 +822,15 @@ def test_entities_by_identifiers_mixed_existing_nonexistent(
     all_entities = ml_multi_cloud_sample_store.get_entities(require_measurements=False)
     assert len(all_entities) > 0
 
-    # Mix of existing and non-existent
     mixed_ids = {
         all_entities[0].identifier,
         "nonexistent_id_1",
         all_entities[1].identifier if len(all_entities) > 1 else "nonexistent_id_2",
     }
-    result = ml_multi_cloud_sample_store.entities_with_identifiers(mixed_ids)
+    with pytest.warns(
+        DeprecationWarning, match="entities_with_identifiers is deprecated"
+    ):
+        result = ml_multi_cloud_sample_store.entities_with_identifiers(mixed_ids)
 
     # Should return only the existing entities
     existing_ids = {
@@ -844,9 +858,12 @@ def test_entities_by_identifiers_partial_cache_reuse(
     ml_multi_cloud_sample_store._entities = cached_only
 
     # Now request both the cached entity and an uncached one
-    result = ml_multi_cloud_sample_store.entities_with_identifiers(
-        {first_id, second_id}
-    )
+    with pytest.warns(
+        DeprecationWarning, match="entities_with_identifiers is deprecated"
+    ):
+        result = ml_multi_cloud_sample_store.entities_with_identifiers(
+            {first_id, second_id}
+        )
 
     assert len(result) == 2
     assert {e.identifier for e in result} == {first_id, second_id}
@@ -880,7 +897,10 @@ def test_entities_by_identifiers_with_measurement_results(
         entity_ids.update({e.identifier for e in r.entities})
 
     # Fetch entities by identifiers
-    retrieved_entities = sample_store.entities_with_identifiers(entity_ids)
+    with pytest.warns(
+        DeprecationWarning, match="entities_with_identifiers is deprecated"
+    ):
+        retrieved_entities = sample_store.entities_with_identifiers(entity_ids)
 
     assert len(retrieved_entities) == len(entity_ids)
 

From a14afd2956e8fd9dc76d6cff7c5bb565db1f2995 Mon Sep 17 00:00:00 2001
From: Alessandro Pomponio <alessandro.pomponio1@ibm.com>
Date: Mon, 27 Jul 2026 13:47:49 +0100
Subject: [PATCH 2/3] fix(core): require measurement where appropriate

Signed-off-by: Alessandro Pomponio <alessandro.pomponio1@ibm.com>
---
 ado/core/samplestore/base.py                        |  4 +++-
 ado/core/samplestore/csv.py                         |  4 +++-
 ado/core/samplestore/sql.py                         | 13 +++++++++++--
 .../profile_space/profile_space/operator.py         |  2 +-
 plugins/operators/ray_tune/ado_ray_tune/rifferla.py |  8 ++++++--
 5 files changed, 24 insertions(+), 7 deletions(-)

diff --git a/ado/core/samplestore/base.py b/ado/core/samplestore/base.py
index e9b7c18e1..8682a0061 100644
--- a/ado/core/samplestore/base.py
+++ b/ado/core/samplestore/base.py
@@ -369,7 +369,9 @@ def from_configuration(
                 f"Copying {sample_store_source.numberOfEntities} entities from "
                 f"{sample_store_source.identifier} to {sample_store.identifier}"
             )
-            sample_store.add_external_entities(sample_store_source.entities)
+            sample_store.add_external_entities(
+                sample_store_source.get_entities(require_measurements=True)
+            )
 
         return sample_store
 
diff --git a/ado/core/samplestore/csv.py b/ado/core/samplestore/csv.py
index 1e73c780d..2262901a1 100644
--- a/ado/core/samplestore/csv.py
+++ b/ado/core/samplestore/csv.py
@@ -307,7 +307,9 @@ def __init__(
                     for result in measurement_results:
                         entity.add_measurement_result(result)
 
-        self._entity_ids = [e.identifier for e in self.entities]
+        self._entity_ids = [
+            e.identifier for e in self.get_entities(require_measurements=False)
+        ]
 
     @property
     def config(self) -> CSVSampleStoreDescription:
diff --git a/ado/core/samplestore/sql.py b/ado/core/samplestore/sql.py
index 53aae2e1a..7b9fd8696 100644
--- a/ado/core/samplestore/sql.py
+++ b/ado/core/samplestore/sql.py
@@ -125,7 +125,9 @@ def from_csv(
             storageLocation=storeConfiguration,
             parameters={},
         )
-        sql_sample_store.add_external_entities(csv_sample_store.entities)
+        sql_sample_store.add_external_entities(
+            csv_sample_store.get_entities(require_measurements=True)
+        )
 
         return sql_sample_store
 
@@ -518,7 +520,14 @@ def _fetch_entities(self, entity_ids: set[str] | None = None) -> dict[str, Entit
             f"Fetched {len(entities)} entities"
             + (f" (filtered from {len(entity_ids)} requested)" if entity_ids else "")
         )
-        # Always merge fetched entities into the cache.
+        # When merging, invalidate measurement-loaded status for any entity
+        # whose cached object is being replaced — the fresh DB representation
+        # does not carry measurement results, so they must be re-fetched.
+        overwritten_ids = set(entities).intersection(
+            self._entities_with_measurements_loaded
+        )
+        if overwritten_ids:
+            self._entities_with_measurements_loaded.difference_update(overwritten_ids)
         self._entities.update(entities)
         return entities
 
diff --git a/plugins/operators/profile_space/profile_space/operator.py b/plugins/operators/profile_space/profile_space/operator.py
index 8a60d2741..4c0e97258 100644
--- a/plugins/operators/profile_space/profile_space/operator.py
+++ b/plugins/operators/profile_space/profile_space/operator.py
@@ -40,7 +40,7 @@ def profile(
     df = pd.DataFrame(
         data=[
             e.seriesRepresentation()
-            for e in discoverySpace.sample_store.entities
+            for e in discoverySpace.sample_store.get_entities(require_measurements=True)
             if len(e.observedPropertyValues) > 0
         ]
     )
diff --git a/plugins/operators/ray_tune/ado_ray_tune/rifferla.py b/plugins/operators/ray_tune/ado_ray_tune/rifferla.py
index 886b8e89a..5b527f281 100644
--- a/plugins/operators/ray_tune/ado_ray_tune/rifferla.py
+++ b/plugins/operators/ray_tune/ado_ray_tune/rifferla.py
@@ -175,7 +175,9 @@ def rifferla(
         all_entities = discoverySpace.matchingEntities()
     else:
         print("Getting all entities")
-        all_entities = discoverySpace.sample_store.entities
+        all_entities = discoverySpace.sample_store.get_entities(
+            require_measurements=True
+        )
 
     print(f"Number of entities: {len(all_entities)}")
 
@@ -344,7 +346,9 @@ def rifferla(
         print(
             "Rifferla space refinement] ...done. Copying entities (since it is a probabilistic space)..."
         )
-        copy_entities = list(discoverySpace.sample_store.entities)
+        copy_entities = discoverySpace.sample_store.get_entities(
+            require_measurements=True
+        )
         new_discovery_space.sample_store.add_external_entities(copy_entities)
 
     print(

From c2150c964c68db0fdd8ab2114503cedb5baefd87 Mon Sep 17 00:00:00 2001
From: Alessandro Pomponio <alessandro.pomponio1@ibm.com>
Date: Mon, 27 Jul 2026 13:49:12 +0100
Subject: [PATCH 3/3] build: bump plugin versions

Signed-off-by: Alessandro Pomponio <alessandro.pomponio1@ibm.com>
---
 plugins/operators/anomalous_series/VERSION                      | 2 +-
 plugins/operators/anomalous_series/anomalous_series/operator.py | 2 +-
 plugins/operators/profile_space/VERSION                         | 2 +-
 plugins/operators/profile_space/profile_space/operator.py       | 2 +-
 plugins/operators/ray_tune/VERSION                              | 2 +-
 plugins/operators/ray_tune/ado_ray_tune/operator.py             | 2 +-
 plugins/operators/ray_tune/ado_ray_tune/rifferla.py             | 2 +-
 7 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/plugins/operators/anomalous_series/VERSION b/plugins/operators/anomalous_series/VERSION
index ee90284c2..90a27f9ce 100644
--- a/plugins/operators/anomalous_series/VERSION
+++ b/plugins/operators/anomalous_series/VERSION
@@ -1 +1 @@
-1.0.4
+1.0.5
diff --git a/plugins/operators/anomalous_series/anomalous_series/operator.py b/plugins/operators/anomalous_series/anomalous_series/operator.py
index caece18ad..092129388 100644
--- a/plugins/operators/anomalous_series/anomalous_series/operator.py
+++ b/plugins/operators/anomalous_series/anomalous_series/operator.py
@@ -123,7 +123,7 @@ def example_configuration(cls) -> "DetectAnomalousSeries":
     """,
     configuration_model=DetectAnomalousSeries,
     example_configuration=DetectAnomalousSeries.example_configuration(),
-    version="1.0.4",
+    version="1.0.5",
 )
 def detect_anomalous_series(
     discoverySpace: DiscoverySpace,
diff --git a/plugins/operators/profile_space/VERSION b/plugins/operators/profile_space/VERSION
index 50ffc5aa7..2165f8f9b 100644
--- a/plugins/operators/profile_space/VERSION
+++ b/plugins/operators/profile_space/VERSION
@@ -1 +1 @@
-2.0.3
+2.0.4
diff --git a/plugins/operators/profile_space/profile_space/operator.py b/plugins/operators/profile_space/profile_space/operator.py
index 4c0e97258..d6652cc8a 100644
--- a/plugins/operators/profile_space/profile_space/operator.py
+++ b/plugins/operators/profile_space/profile_space/operator.py
@@ -18,7 +18,7 @@ class ProfileParameters(pydantic.BaseModel):
 # for documentation on the decorator and its parameters
 @characterize_operation(
     name="profile",
-    version="2.0.3",
+    version="2.0.4",
     configuration_model=ProfileParameters,
     example_configuration=ProfileParameters(),
     description="Returns a data_profiling ProfileReport for the space",
diff --git a/plugins/operators/ray_tune/VERSION b/plugins/operators/ray_tune/VERSION
index e01025862..157e54f3e 100644
--- a/plugins/operators/ray_tune/VERSION
+++ b/plugins/operators/ray_tune/VERSION
@@ -1 +1 @@
-2.0.5
+2.0.6
diff --git a/plugins/operators/ray_tune/ado_ray_tune/operator.py b/plugins/operators/ray_tune/ado_ray_tune/operator.py
index 836146b48..c92cbbaff 100644
--- a/plugins/operators/ray_tune/ado_ray_tune/operator.py
+++ b/plugins/operators/ray_tune/ado_ray_tune/operator.py
@@ -980,7 +980,7 @@ def operator_metadata(cls) -> OperatorMetadata:
         """Returns operator metadata for the ray_tune explore operator."""
         return OperatorMetadata(
             name="ray_tune",
-            version="2.0.5",
+            version="2.0.6",
             description=cls.description(),
             configuration_model=RayTuneConfiguration,
             example_configuration=RayTuneConfiguration(
diff --git a/plugins/operators/ray_tune/ado_ray_tune/rifferla.py b/plugins/operators/ray_tune/ado_ray_tune/rifferla.py
index 5b527f281..5a6886487 100644
--- a/plugins/operators/ray_tune/ado_ray_tune/rifferla.py
+++ b/plugins/operators/ray_tune/ado_ray_tune/rifferla.py
@@ -93,7 +93,7 @@ def example_configuration(cls) -> "RifferlaParameters":
     "It does this by identifying which entity space dimensions should be fixed to set values, which explored, and setting range limits for those dimensions. "
     "The method leverages Mutual Information to identify dimensions correlated with the desired observed property.",
     example_configuration=RifferlaParameters.example_configuration(),
-    version="2.0.3",
+    version="2.0.6",
 )
 def rifferla(
     discoverySpace: DiscoverySpace,