orchestrator-core 3.2.3__py3-none-any.whl → 4.0.0__py3-none-any.whl

orchestrator/migrations/helpers.py

@@ -135,18 +135,21 @@ def create_workflow(conn: sa.engine.Connection, workflow: dict) -> None:
         >>> workflow = {
             "name": "workflow_name",
             "target": "SYSTEM",
+            "is_task": False,
             "description": "workflow description",
             "product_type": "product_type",
         }
         >>> create_workflow(conn, workflow)
     """
+    if not workflow.get("is_task", False):
+        workflow["is_task"] = False
 
     conn.execute(
         sa.text(
             """
                 WITH new_workflow AS (
-                INSERT INTO workflows(name, target, description)
-                    VALUES (:name, :target, :description)
+                INSERT INTO workflows(name, target, is_task, description)
+                    VALUES (:name, :target, :is_task, :description)
                     ON CONFLICT DO NOTHING
                     RETURNING workflow_id)
                 INSERT
@@ -184,8 +187,8 @@ def create_task(conn: sa.engine.Connection, task: dict) -> None:
     conn.execute(
         sa.text(
             """
-                INSERT INTO workflows(name, target, description)
-                    VALUES (:name, 'SYSTEM', :description)
+                INSERT INTO workflows(name, target, is_task, description)
+                    VALUES (:name, 'SYSTEM', TRUE, :description)
                     ON CONFLICT DO NOTHING
                     RETURNING workflow_id
             """
@@ -206,6 +209,7 @@ def create_workflows(conn: sa.engine.Connection, new: dict) -> None:
                 "workflow_name": {
                     "workflow_id": "f2702074-3203-454c-b298-6dfa7675423d",
                     "target": "CREATE",
+                    "is_task": False,
                     "description": "Workflow description",
                     "tag": "ProductBlockName1",
                     "search_phrase": "Search Phrase%",
@@ -214,12 +218,16 @@ def create_workflows(conn: sa.engine.Connection, new: dict) -> None:
     """
     for name, workflow in new.items():
         workflow["name"] = name
+
+        if not workflow.get("is_task", False):
+            workflow["is_task"] = False
+
         conn.execute(
             sa.text(
                 """
                 WITH new_workflow AS (
-                    INSERT INTO workflows(workflow_id, name, target, description)
-                    VALUES (:workflow_id, :name, :target, :description)
+                    INSERT INTO workflows(workflow_id, name, target, is_task, description)
+                    VALUES (:workflow_id, :name, :target, :is_task, :description)
                     RETURNING workflow_id)
                 INSERT
                 INTO products_workflows (product_id, workflow_id)

orchestrator/migrations/templates/alembic.ini.j2

@@ -6,8 +6,7 @@ file_template = %%(year)d-%%(month).2d-%%(day).2d_%%(rev)s_%%(slug)s
 
 # set to 'true' to run the environment during
 # the 'revision' command, regardless of autogenerate
-# revision_environment = false
-script_location = {{ migrations_dir }}
+script_location = %(here)s/{{ migrations_dir }}
 version_locations = %(here)s/{{ migrations_dir }}/versions/schema
 # Logging configuration
 [loggers]

orchestrator/migrations/templates/env.py.j2

@@ -1,9 +1,7 @@
-import logging
-import os
+import structlog
 from alembic import context
 from sqlalchemy import engine_from_config, pool
 
-import orchestrator
 from orchestrator.db.database import BaseModel
 from orchestrator.settings import app_settings
 
@@ -11,11 +9,10 @@ from orchestrator.settings import app_settings
 # access to the values within the .ini file in use.
 config = context.config
 
-# Interpret the config file for Python logging.
-# This line sets up loggers basically.
-logger = logging.getLogger("alembic.env")
+# Setup logging
+logger = structlog.get_logger()
 
-config.set_main_option("sqlalchemy.url", app_settings.DATABASE_URI)
+config.set_main_option("sqlalchemy.url", str(app_settings.DATABASE_URI))
 
 # add your model's MetaData object here
 # for 'autogenerate' support

orchestrator/migrations/versions/schema/2025-02-20_68d14db1b8da_make_workflow_description_mandatory.py

@@ -0,0 +1,33 @@
+"""Make workflow description mandatory.
+
+Revision ID: 68d14db1b8da
+Revises: bac6be6f2b4f
+Create Date: 2025-02-20 16:39:34.889953
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+from structlog import get_logger
+
+logger = get_logger(__name__)
+
+# revision identifiers, used by Alembic.
+revision = "68d14db1b8da"
+down_revision = "fc5c993a4b4a"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    try:
+        op.alter_column("workflows", "description", existing_type=sa.TEXT(), nullable=False)
+    except sa.exc.IntegrityError:
+        logger.error(
+            "Unable to execute migrations due to missing descriptions in workflow table, please create a migration to backfill this column."
+        )
+        raise
+
+
+def downgrade() -> None:
+    op.alter_column("workflows", "description", existing_type=sa.TEXT(), nullable=True)

orchestrator/migrations/versions/schema/2025-05-08_161918133bec_add_is_task_to_workflow.py

@@ -0,0 +1,28 @@
+"""Add is_task to workflow.
+
+Revision ID: 161918133bec
+Revises: 68d14db1b8da
+Create Date: 2025-05-08 11:25:51.966410
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "161918133bec"
+down_revision = "68d14db1b8da"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column("workflows", sa.Column("is_task", sa.Boolean(), server_default=sa.text("false"), nullable=False))
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column("workflows", "is_task")
+    # ### end Alembic commands ###

orchestrator/schedules/validate_subscriptions.py

@@ -22,7 +22,7 @@ from orchestrator.services.subscriptions import (
     get_subscriptions_on_product_table_in_sync,
 )
 from orchestrator.services.workflows import (
-    get_system_product_workflows_for_subscription,
+    get_validation_product_workflows_for_subscription,
     start_validation_workflow_for_workflows,
 )
 from orchestrator.settings import app_settings
@@ -42,9 +42,9 @@ def validate_subscriptions() -> None:
         subscriptions = get_subscriptions_on_product_table_in_sync()
 
     for subscription in subscriptions:
-        system_product_workflows = get_system_product_workflows_for_subscription(subscription)
+        validation_product_workflows = get_validation_product_workflows_for_subscription(subscription)
 
-        if not system_product_workflows:
+        if not validation_product_workflows:
             logger.warning(
                 "SubscriptionTable has no validation workflow",
                 subscription=subscription,
@@ -52,4 +52,4 @@ def validate_subscriptions() -> None:
             )
             break
 
-        start_validation_workflow_for_workflows(subscription=subscription, workflows=system_product_workflows)
+        start_validation_workflow_for_workflows(subscription=subscription, workflows=validation_product_workflows)

orchestrator/schemas/workflow.py

@@ -15,7 +15,7 @@ from datetime import datetime
 from typing import Any
 from uuid import UUID
 
-from pydantic import ConfigDict
+from pydantic import ConfigDict, Field
 
 from orchestrator.schemas.base import OrchestratorBaseModel
 from orchestrator.targets import Target
@@ -24,6 +24,7 @@ from orchestrator.targets import Target
 class WorkflowBaseSchema(OrchestratorBaseModel):
     name: str
     target: Target
+    is_task: bool = False
     description: str | None = None
     created_at: datetime | None = None
 
@@ -59,6 +60,7 @@ class SubscriptionWorkflowListsSchema(OrchestratorBaseModel):
     modify: list[WorkflowListItemSchema]
     terminate: list[WorkflowListItemSchema]
     system: list[WorkflowListItemSchema]
+    validate_: list[WorkflowListItemSchema] = Field(default_factory=list, alias="validate")
 
 
 class WorkflowPatchSchema(OrchestratorBaseModel):

orchestrator/services/celery.py

@@ -24,7 +24,7 @@ from orchestrator.api.error_handling import raise_status
 from orchestrator.db import ProcessTable, db
 from orchestrator.services.input_state import store_input_state
 from orchestrator.services.processes import create_process, delete_process
-from orchestrator.targets import Target
+from orchestrator.services.workflows import get_workflow_by_name
 from orchestrator.workflows import get_workflow
 from pydantic_forms.types import State
 
@@ -51,7 +51,11 @@ def _celery_start_process(
     if not workflow:
         raise_status(HTTPStatus.NOT_FOUND, "Workflow does not exist")
 
-    task_name = NEW_TASK if workflow.target == Target.SYSTEM else NEW_WORKFLOW
+    wf_table = get_workflow_by_name(workflow.name)
+    if not wf_table:
+        raise_status(HTTPStatus.NOT_FOUND, "Workflow in Database does not exist")
+
+    task_name = NEW_TASK if wf_table.is_task else NEW_WORKFLOW
     trigger_task = get_celery_task(task_name)
     pstat = create_process(workflow_key, user_inputs, user)
     try:
@@ -68,8 +72,8 @@ def _celery_start_process(
 def _celery_resume_process(
     process: ProcessTable,
     *,
-    user_inputs: list[State] | None,
-    user: str | None,
+    user_inputs: list[State] | None = None,
+    user: str | None = None,
     **kwargs: Any,
 ) -> UUID:
     """Client side call of Celery."""
@@ -80,7 +84,11 @@ def _celery_resume_process(
     last_process_status = process.last_status
     workflow = pstat.workflow
 
-    task_name = RESUME_TASK if workflow.target == Target.SYSTEM else RESUME_WORKFLOW
+    wf_table = get_workflow_by_name(workflow.name)
+    if not workflow or not wf_table:
+        raise_status(HTTPStatus.NOT_FOUND, "Workflow does not exist")
+
+    task_name = RESUME_TASK if wf_table.is_task else RESUME_WORKFLOW
     trigger_task = get_celery_task(task_name)
 
     user_inputs = user_inputs or [{}]

orchestrator/services/processes.py

@@ -34,7 +34,6 @@ from orchestrator.services.input_state import store_input_state
 from orchestrator.services.settings import get_engine_settings_for_update
 from orchestrator.services.workflows import get_workflow_by_name
 from orchestrator.settings import ExecutorType, app_settings
-from orchestrator.targets import Target
 from orchestrator.types import BroadcastFunc
 from orchestrator.utils.datetime import nowtz
 from orchestrator.utils.errors import error_state_to_dict
@@ -108,7 +107,7 @@ def _db_create_process(stat: ProcessStat) -> None:
         workflow_id=wf_table.workflow_id,
         last_status=ProcessStatus.CREATED,
         created_by=stat.current_user,
-        is_task=stat.workflow.target == Target.SYSTEM,
+        is_task=wf_table.is_task,
     )
     db.session.add(p)
     db.session.commit()
@@ -441,6 +440,7 @@ def create_process(
     }
 
     try:
+
         state = post_form(workflow.initial_input_form, initial_state, user_inputs)
     except FormValidationError:
         logger.exception("Validation errors", user_inputs=user_inputs)

orchestrator/services/settings.py

@@ -19,7 +19,7 @@ from sqlalchemy import select, text
 from sqlalchemy.exc import SQLAlchemyError
 
 from orchestrator.db import EngineSettingsTable, db
-from orchestrator.schemas.engine_settings import EngineSettingsSchema
+from orchestrator.schemas.engine_settings import EngineSettingsSchema, GlobalStatusEnum
 from orchestrator.settings import app_settings
 
 logger = structlog.get_logger(__name__)
@@ -35,6 +35,15 @@ def get_engine_settings_for_update() -> EngineSettingsTable:
     return db.session.execute(select(EngineSettingsTable).with_for_update()).scalar_one()
 
 
+def generate_engine_global_status(engine_settings: EngineSettingsTable) -> GlobalStatusEnum:
+    """Returns the global status of the engine."""
+    if engine_settings.global_lock and engine_settings.running_processes > 0:
+        return GlobalStatusEnum.PAUSING
+    if engine_settings.global_lock and engine_settings.running_processes == 0:
+        return GlobalStatusEnum.PAUSED
+    return GlobalStatusEnum.RUNNING
+
+
 def post_update_to_slack(engine_status: EngineSettingsSchema, user: str) -> None:
     """Post engine settings update to slack.
 

orchestrator/services/subscriptions.py

@@ -505,6 +505,7 @@ TARGET_DEFAULT_USABLE_MAP: dict[Target, list[str]] = {
     Target.MODIFY: ["active"],
     Target.TERMINATE: ["active", "provisioning"],
     Target.SYSTEM: ["active"],
+    Target.VALIDATE: ["active"],
 }
 
 WF_USABLE_MAP: dict[str, list[str]] = {}
@@ -530,6 +531,7 @@ def subscription_workflows(subscription: SubscriptionTable) -> dict[str, Any]:
         ...     "modify": [],
         ...     "terminate": [],
         ...     "system": [],
+        ...     "validate": [],
         ... }
 
     """
@@ -549,9 +551,10 @@ def subscription_workflows(subscription: SubscriptionTable) -> dict[str, Any]:
         "modify": [],
         "terminate": [],
         "system": [],
+        "validate": [],
     }
     for workflow in subscription.product.workflows:
-        if workflow.name in WF_USABLE_WHILE_OUT_OF_SYNC or workflow.target == Target.SYSTEM:
+        if workflow.name in WF_USABLE_WHILE_OUT_OF_SYNC or workflow.is_task:
             # validations and modify note are also possible with: not in sync or locked relations
             workflow_json = {"name": workflow.name, "description": workflow.description}
         else:
@@ -605,7 +608,6 @@ def build_domain_model(subscription_model: SubscriptionModel) -> dict:
 
 def build_extended_domain_model(subscription_model: SubscriptionModel) -> dict:
     """Create a subscription dict from the SubscriptionModel with additional keys."""
-    from orchestrator.settings import app_settings
 
     stmt = select(SubscriptionCustomerDescriptionTable).where(
         SubscriptionCustomerDescriptionTable.subscription_id == subscription_model.subscription_id
@@ -615,27 +617,12 @@ def build_extended_domain_model(subscription_model: SubscriptionModel) -> dict:
     with cache_subscription_models():
         subscription = subscription_model.model_dump()
 
-    def inject_in_use_by_ids(path_to_block: str) -> None:
-        if not (in_use_by_subs := getattr_in(subscription_model, f"{path_to_block}.in_use_by")):
-            return
-
-        in_use_by_ids = [obj.in_use_by_id for obj in in_use_by_subs.col]
-        in_use_by_relations = [convert_to_in_use_by_relation(instance) for instance in in_use_by_subs]
-        update_in(subscription, f"{path_to_block}.in_use_by_ids", in_use_by_ids)
-        update_in(subscription, f"{path_to_block}.in_use_by_relations", in_use_by_relations)
-
-    if app_settings.ENABLE_SUBSCRIPTION_MODEL_OPTIMIZATIONS:
-        # TODO #900 remove toggle and make this path the default
-        # query all subscription instances and inject the in_use_by_ids/in_use_by_relations into the subscription dict.
-        instance_to_in_use_by = {
-            instance.subscription_instance_id: instance.in_use_by
-            for instance in eagerload_all_subscription_instances_only_inuseby(subscription_model.subscription_id)
-        }
-        inject_in_use_by_ids_v2(subscription, instance_to_in_use_by)
-    else:
-        # find all product blocks, check if they have in_use_by and inject the in_use_by_ids into the subscription dict.
-        for path in product_block_paths(subscription):
-            inject_in_use_by_ids(path)
+    # query all subscription instances and inject the in_use_by_ids/in_use_by_relations into the subscription dict.
+    instance_to_in_use_by = {
+        instance.subscription_instance_id: instance.in_use_by
+        for instance in eagerload_all_subscription_instances_only_inuseby(subscription_model.subscription_id)
+    }
+    inject_in_use_by_ids_v2(subscription, instance_to_in_use_by)
 
     subscription["customer_descriptions"] = customer_descriptions
 

orchestrator/services/workflows.py

@@ -39,6 +39,7 @@ def _to_workflow_schema(workflow: WorkflowTable, include_steps: bool = False) ->
         workflow_id=workflow.workflow_id,
         name=workflow.name,
         target=workflow.target,
+        is_task=workflow.is_task,
         description=workflow.description,
         created_at=workflow.created_at,
         **extra_kwargs,
@@ -63,10 +64,10 @@ def get_workflow_by_name(workflow_name: str) -> WorkflowTable | None:
     return db.session.scalar(select(WorkflowTable).where(WorkflowTable.name == workflow_name))
 
 
-def get_system_product_workflows_for_subscription(
+def get_validation_product_workflows_for_subscription(
     subscription: SubscriptionTable,
 ) -> list:
-    return [workflow.name for workflow in subscription.product.workflows if workflow.target == Target.SYSTEM]
+    return [workflow.name for workflow in subscription.product.workflows if workflow.target == Target.VALIDATE]
 
 
 def start_validation_workflow_for_workflows(
@@ -78,9 +79,12 @@ def start_validation_workflow_for_workflows(
     result = []
 
     for workflow_name in workflows:
-        default = TARGET_DEFAULT_USABLE_MAP[Target.SYSTEM]
-        usable_when = WF_USABLE_MAP.get(workflow_name, default)
+        target_system = TARGET_DEFAULT_USABLE_MAP[Target.SYSTEM]
+        system_usable_when = WF_USABLE_MAP.get(workflow_name, target_system)
+        target_validate = TARGET_DEFAULT_USABLE_MAP[Target.VALIDATE]
+        validate_usable_when = WF_USABLE_MAP.get(workflow_name, target_validate)
 
+        usable_when = system_usable_when + validate_usable_when
         if subscription.status in usable_when and (
             product_type_filter is None or subscription.product.product_type == product_type_filter
         ):

orchestrator/settings.py

@@ -55,7 +55,6 @@ class AppSettings(BaseSettings):
     MAIL_PORT: int = 25
     MAIL_STARTTLS: bool = False
     CACHE_URI: RedisDsn = "redis://localhost:6379/0"  # type: ignore
-    CACHE_DOMAIN_MODELS: bool = False
     CACHE_HMAC_SECRET: str | None = None  # HMAC signing key, used when pickling results in the cache
     REDIS_RETRY_COUNT: NonNegativeInt = Field(
         2, description="Number of retries for redis connection errors/timeouts, 0 to disable"
@@ -85,11 +84,9 @@ class AppSettings(BaseSettings):
     ENABLE_GRAPHQL_DEPRECATION_CHECKER: bool = True
     ENABLE_GRAPHQL_PROFILING_EXTENSION: bool = False
     ENABLE_GRAPHQL_STATS_EXTENSION: bool = False
+    ENABLE_PROMETHEUS_METRICS_ENDPOINT: bool = False
     VALIDATE_OUT_OF_SYNC_SUBSCRIPTIONS: bool = False
     FILTER_BY_MODE: Literal["partial", "exact"] = "exact"
-    ENABLE_SUBSCRIPTION_MODEL_OPTIMIZATIONS: bool = (
-        True  # True=ignore cache + optimized DB queries; False=use cache + unoptimized DB queries. Remove in #900
-    )
 
 
 app_settings = AppSettings()

orchestrator/targets.py

@@ -22,3 +22,4 @@ class Target(strEnum):
     MODIFY = "MODIFY"
     TERMINATE = "TERMINATE"
     SYSTEM = "SYSTEM"
+    VALIDATE = "VALIDATE"

orchestrator/utils/get_subscription_dict.py

@@ -2,15 +2,11 @@ from uuid import UUID
 
 from orchestrator.domain.base import SubscriptionModel
 from orchestrator.services.subscriptions import _generate_etag, build_domain_model, build_extended_domain_model
-from orchestrator.utils.redis import from_redis
 
 
 async def get_subscription_dict(subscription_id: UUID, inject_inuseby: bool = True) -> tuple[dict, str]:
     """Helper function to get subscription dict by uuid from db or cache."""
 
-    if cached_model := from_redis(subscription_id):
-        return cached_model  # type: ignore
-
     subscription_model = SubscriptionModel.from_subscription(subscription_id)
 
     if not inject_inuseby:

orchestrator/utils/redis.py

@@ -10,11 +10,9 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-import functools
 from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
-from os import getenv
-from typing import Any, Callable
+from typing import Any
 from uuid import UUID
 
 from anyio import CancelScope, get_cancelled_exc_class
@@ -22,9 +20,7 @@ from redis.asyncio import Redis as AIORedis
 from redis.asyncio.client import Pipeline, PubSub
 from structlog import get_logger
 
-from orchestrator.services.subscriptions import _generate_etag
 from orchestrator.settings import app_settings
-from orchestrator.utils.json import PY_JSON_TYPES, json_dumps, json_loads
 from orchestrator.utils.redis_client import (
     create_redis_asyncio_client,
     create_redis_client,
@@ -37,52 +33,6 @@ cache = create_redis_client(app_settings.CACHE_URI)
 ONE_WEEK = 3600 * 24 * 7
 
 
-def caching_models_enabled() -> bool:
-    return getenv("AIOCACHE_DISABLE", "0") == "0" and app_settings.CACHE_DOMAIN_MODELS
-
-
-def to_redis(subscription: dict[str, Any]) -> str | None:
-    if caching_models_enabled():
-        logger.info("Setting cache for subscription", subscription=subscription["subscription_id"])
-        etag = _generate_etag(subscription)
-        cache.set(f"orchestrator:domain:{subscription['subscription_id']}", json_dumps(subscription), ex=ONE_WEEK)
-        cache.set(f"orchestrator:domain:etag:{subscription['subscription_id']}", etag, ex=ONE_WEEK)
-        return etag
-
-    logger.warning("Caching disabled, not caching subscription", subscription=subscription["subscription_id"])
-    return None
-
-
-def from_redis(subscription_id: UUID) -> tuple[PY_JSON_TYPES, str] | None:
-    log = logger.bind(subscription_id=subscription_id)
-
-    if app_settings.ENABLE_SUBSCRIPTION_MODEL_OPTIMIZATIONS:
-        # TODO #900 remove toggle and remove usage of this function in get_subscription_dict
-        log.info("Using SubscriptionModel optimization, not loading subscription from redis cache")
-        return None
-
-    if caching_models_enabled():
-        log.debug("Try to retrieve subscription from cache")
-        obj = cache.get(f"orchestrator:domain:{subscription_id}")
-        etag = cache.get(f"orchestrator:domain:etag:{subscription_id}")
-        if obj and etag:
-            log.info("Retrieved subscription from cache")
-            return json_loads(obj), etag.decode("utf-8")
-        log.info("Subscription not found in cache")
-        return None
-    log.warning("Caching disabled, not loading subscription")
-    return None
-
-
-def delete_from_redis(subscription_id: UUID) -> None:
-    if caching_models_enabled():
-        logger.info("Deleting subscription object from cache", subscription_id=subscription_id)
-        cache.delete(f"orchestrator:domain:{subscription_id}")
-        cache.delete(f"orchestrator:domain:etag:{subscription_id}")
-    else:
-        logger.warning("Caching disabled, not deleting subscription", subscription=subscription_id)
-
-
 def default_get_subscription_id(data: Any) -> UUID:
     if hasattr(data, "subscription_id"):
         return data.subscription_id
@@ -91,22 +41,6 @@ def default_get_subscription_id(data: Any) -> UUID:
     return data
 
 
-def delete_subscription_from_redis(
-    extract_fn: Callable[..., UUID] = default_get_subscription_id,
-) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
-    def _delete_subscription_from_redis(func: Callable[..., Any]) -> Callable[..., Any]:
-        @functools.wraps(func)
-        async def wrapper(*args: tuple, **kwargs: dict[str, Any]) -> Any:
-            data = await func(*args, **kwargs)
-            key = extract_fn(data)
-            delete_from_redis(key)
-            return data
-
-        return wrapper
-
-    return _delete_subscription_from_redis
-
-
 async def delete_keys_matching_pattern(_cache: AIORedis, pattern: str, chunksize: int = 5000) -> int:
     """Delete all keys matching the given pattern.
 

orchestrator/workflows/modify_note.py

@@ -13,11 +13,10 @@
 from orchestrator.db import db
 from orchestrator.forms import SubmitFormPage
 from orchestrator.services import subscriptions
-from orchestrator.settings import app_settings
 from orchestrator.targets import Target
 from orchestrator.utils.json import to_serializable
-from orchestrator.workflow import StepList, conditional, done, init, step, workflow
-from orchestrator.workflows.steps import cache_domain_models, store_process_subscription
+from orchestrator.workflow import StepList, done, init, step, workflow
+from orchestrator.workflows.steps import store_process_subscription
 from orchestrator.workflows.utils import wrap_modify_initial_input_form
 from pydantic_forms.types import FormGenerator, State, UUIDstr
 from pydantic_forms.validators import LongText
@@ -54,11 +53,4 @@ def store_subscription_note(subscription_id: UUIDstr, note: str) -> State:
 
 @workflow("Modify Note", initial_input_form=wrap_modify_initial_input_form(initial_input_form), target=Target.MODIFY)
 def modify_note() -> StepList:
-    push_subscriptions = conditional(lambda _: app_settings.CACHE_DOMAIN_MODELS)
-    return (
-        init
-        >> store_process_subscription(Target.MODIFY)
-        >> store_subscription_note
-        >> push_subscriptions(cache_domain_models)
-        >> done
-    )
+    return init >> store_process_subscription(Target.MODIFY) >> store_subscription_note >> done