orchestrator-core 2.10.0rc1__py3-none-any.whl → 3.0.0__py3-none-any.whl

orchestrator/devtools/scripts/migrate_20.py

@@ -6,61 +6,17 @@ Refer to the 2.0 migration guide documentation for background.
 import re
 import sys
 from pathlib import Path
-from subprocess import run
 from typing import Iterable
 
-
-def remove_imports(text: str, module: str, symbol: str) -> tuple[str, bool]:
-    """Find imports and remove them.
-
-    Assumes code is formatted through Black to keep the regex somewhat readable.
-    """
-    text_orig = text
-
-    # single import from module (may have a #comment) -> remove line
-    rgx = r"(from %s import \b%s\b(\s*#[^\n]*)*\n)" % (re.escape(module), symbol)
-    text = re.sub(rgx, "", text)
-
-    # middle or last of multiple imports from module -> strip symbol
-    rgx = r"(from %s import .+)(, \b%s\b)" % (re.escape(module), symbol)
-    text = re.sub(rgx, r"\1", text)
-
-    # first of multiple imports from same module -> strip symbol
-    rgx = r"(from %s import )\b%s\b, " % (re.escape(module), symbol)
-    text = re.sub(rgx, r"\1", text)
-
-    # multiline import -> remove line with symbol
-    rgx_verbose = r"""(?P<before>^from\s%s\simport\s*\([^\n]*\n(?:^[^\n]+,\n)*)
-                      (^\s*\b%s\b,[^\n]*\n)
-                      (?P<after>(?:^[^\n]+,\n)*\)[^\n]*$)"""
-    text = re.sub(rgx_verbose % (re.escape(module), symbol), r"\g<before>\g<after>", text, flags=re.M | re.X)
-    return text, text_orig != text
-
-
-def insert_import(text: str, import_stmt: str) -> str:
-    # Find the first import line and add our line above that
-    # Rely on ruff & black for formatting
-    return re.sub(r"(^(?:from .+|import .+)$)", f"{import_stmt}\n" + r"\1", text, count=1, flags=re.M)
-
-
-def find_and_remove_aliases(text: str, symbol: str) -> tuple[str, list[str]]:
-    """In the given text find aliases of the given symbol and remove them.
-
-    Return updated text and aliases removed.
-    """
-    rgx = r"(\b%s as (\w+))" % (symbol,)
-    aliases = [aliasgroup for fullgroup, aliasgroup in re.findall(rgx, text)]
-    newtext = re.sub(rgx, symbol, text)
-    return newtext, aliases
-
-
-def replace_words(text: str, words: list[str], replace: str) -> str:
-    rgx = r"\b(%s)\b" % ("|".join(words),)
-    return re.sub(rgx, replace, text)
-
-
-def has_word(text: str, word: str) -> bool:
-    return bool(re.search(r"\b%s\b" % (word,), text))
+from orchestrator.devtools.scripts.shared import (
+    find_and_remove_aliases,
+    has_word,
+    insert_import,
+    migrate,
+    move_import,
+    remove_imports,
+    replace_words,
+)
 
 
 def rewrite_subscription_instance_lists(f: Path) -> list[str]:
@@ -124,17 +80,6 @@ def rewrite_subscription_instance_lists(f: Path) -> list[str]:
     return names
 
 
-def move_import(f: Path, symbol: str, old_module: str, new_module: str) -> bool:
-    text = f.read_text()
-    text, changed = remove_imports(text, old_module, symbol)
-    if not changed:
-        return False
-    text = insert_import(text, f"from {new_module} import {symbol}")
-    with f.open(mode="w"):
-        f.write_text(text)
-    return True
-
-
 re_serializable_property = re.compile(r"^(\s+)(@serializable_property)([^\n]*)\n", flags=re.MULTILINE)
 
 
@@ -167,7 +112,7 @@ def replace_serializable_props(f: Path) -> bool:
     return True
 
 
-def migrate_file(f: Path) -> int:
+def migrate_file(f: Path) -> bool:
     imports = {
         "SI": move_import(f, "SI", "orchestrator.domain.base", "orchestrator.types"),
         "VlanRanges": move_import(f, "VlanRanges", "orchestrator.utils.vlans", "nwastdlib.vlans"),
@@ -189,46 +134,6 @@ def migrate_file(f: Path) -> int:
     return bool(lines)
 
 
-def run_tool(*args: str) -> bool:
-    cmd = " ".join(args)
-    try:
-        r = run(args, capture_output=True)  # noqa: S603
-        if r.returncode == 0:
-            return True
-        print(f"{cmd} failed:", r.stdout, r.stderr)
-    except FileNotFoundError:
-        print(f"{cmd }failed: could not find executable in the current venv")
-    return False
-
-
-def migrate(target_dir: Path) -> bool:
-    abs_path = str(target_dir.resolve())
-
-    def run_tools() -> bool:
-        return run_tool("ruff", "--fix", abs_path) and run_tool("black", "--quiet", abs_path)
-
-    print(f"\n### Verifing files in {abs_path}... ", end="")
-    if not run_tools():
-        print("Failed to verify files, aborting migration. Please resolve the errors.")
-        return False
-    print("Ok")
-
-    files_migrated = files_checked = 0
-    print(f"\n### Migrating files in {abs_path}")
-    try:
-        for f in target_dir.glob("**/*.py"):
-            if migrate_file(f):
-                files_migrated += 1
-            files_checked += 1
-    except KeyboardInterrupt:
-        print("Interrupted...")
-
-    print(f"\n### Migrated {files_migrated}/{files_checked} files in {abs_path}")
-
-    print(f"\n### Formatting files in {abs_path}")
-    return run_tools()
-
-
 if __name__ == "__main__":
     try:
         _target_dir = Path(sys.argv[1])
@@ -237,4 +142,4 @@ if __name__ == "__main__":
         print("Need a directory as parameter")
         sys.exit(1)
 
-    sys.exit(0 if migrate(_target_dir) else 1)
+    sys.exit(0 if migrate(_target_dir, migrate_file) else 1)

orchestrator/devtools/scripts/migrate_30.py

@@ -0,0 +1,61 @@
+"""Helper script to rewrite import statements in your orchestrator.
+
+Since types have been externalised in `pydantic_forms`, they were re-imported in `orchestrator.types` for backwards
+compatibility. These import statements have been removed, and therefore need to be updated in orchestrator
+implementations.
+"""
+
+import sys
+from pathlib import Path
+
+from orchestrator.devtools.scripts.shared import migrate, move_import
+
+
+def migrate_file(f: Path) -> bool:
+    imports = {
+        "JSON": move_import(f, "JSON", "orchestrator.types", "pydantic_forms.types"),
+        "AcceptData": move_import(f, "AcceptData", "orchestrator.types", "pydantic_forms.types"),
+        "AcceptItemType": move_import(f, "AcceptItemType", "orchestrator.types", "pydantic_forms.types"),
+        "FormGenerator": move_import(f, "FormGenerator", "orchestrator.types", "pydantic_forms.types"),
+        "FormGeneratorAsync": move_import(f, "FormGeneratorAsync", "orchestrator.types", "pydantic_forms.types"),
+        "InputForm": move_import(f, "InputForm", "orchestrator.types", "pydantic_forms.types"),
+        "InputFormGenerator": move_import(f, "InputFormGenerator", "orchestrator.types", "pydantic_forms.types"),
+        "InputStepFunc": move_import(f, "InputStepFunc", "orchestrator.types", "pydantic_forms.types"),
+        "SimpleInputFormGenerator": move_import(
+            f, "SimpleInputFormGenerator", "orchestrator.types", "pydantic_forms.types"
+        ),
+        "State": move_import(f, "State", "orchestrator.types", "pydantic_forms.types"),
+        "StateInputFormGenerator": move_import(
+            f, "StateInputFormGenerator", "orchestrator.types", "pydantic_forms.types"
+        ),
+        "StateInputFormGeneratorAsync": move_import(
+            f, "StateInputFormGeneratorAsync", "orchestrator.types", "pydantic_forms.types"
+        ),
+        "StateInputStepFunc": move_import(f, "StateInputStepFunc", "orchestrator.types", "pydantic_forms.types"),
+        "StateSimpleInputFormGenerator": move_import(
+            f, "StateSimpleInputFormGenerator", "orchestrator.types", "pydantic_forms.types"
+        ),
+        "SubscriptionMapping": move_import(f, "SubscriptionMapping", "orchestrator.types", "pydantic_forms.types"),
+        "SummaryData": move_import(f, "SummaryData", "orchestrator.types", "pydantic_forms.types"),
+        "UUIDstr": move_import(f, "UUIDstr", "orchestrator.types", "pydantic_forms.types"),
+        "strEnum": move_import(f, "strEnum", "orchestrator.types", "pydantic_forms.types"),
+    }
+    lines = []
+    lines.extend([f"Moved {k} import" for k, v in imports.items() if v])
+
+    if lines:
+        formatted_lines = "\n".join(f" - {line}" for line in lines)
+        print(f"Updated {f.name:50s}\n{formatted_lines}")
+
+    return bool(lines)
+
+
+if __name__ == "__main__":
+    try:
+        _target_dir = Path(sys.argv[1])
+        assert _target_dir.is_dir()
+    except Exception:
+        print("Need a directory as parameter")
+        sys.exit(1)
+
+    sys.exit(0 if migrate(_target_dir, migrate_file) else 1)

orchestrator/devtools/scripts/shared.py

@@ -0,0 +1,108 @@
+import re
+from pathlib import Path
+from subprocess import run
+from typing import Callable
+
+
+def remove_imports(text: str, module: str, symbol: str) -> tuple[str, bool]:
+    """Find imports and remove them.
+
+    Assumes code is formatted through Black to keep the regex somewhat readable.
+    """
+    text_orig = text
+
+    # single import from module (may have a #comment) -> remove line
+    rgx = r"(from %s import \b%s\b(\s*#[^\n]*)*\n)" % (re.escape(module), symbol)
+    text = re.sub(rgx, "", text)
+
+    # middle or last of multiple imports from module -> strip symbol
+    rgx = r"(from %s import .+)(, \b%s\b)" % (re.escape(module), symbol)
+    text = re.sub(rgx, r"\1", text)
+
+    # first of multiple imports from same module -> strip symbol
+    rgx = r"(from %s import )\b%s\b, " % (re.escape(module), symbol)
+    text = re.sub(rgx, r"\1", text)
+
+    # multiline import -> remove line with symbol
+    rgx_verbose = r"""(?P<before>^from\s%s\simport\s*\([^\n]*\n(?:^[^\n]+,\n)*)
+                      (^\s*\b%s\b,[^\n]*\n)
+                      (?P<after>(?:^[^\n]+,\n)*\)[^\n]*$)"""
+    text = re.sub(rgx_verbose % (re.escape(module), symbol), r"\g<before>\g<after>", text, flags=re.M | re.X)
+    return text, text_orig != text
+
+
+def insert_import(text: str, import_stmt: str) -> str:
+    # Find the first import line and add our line above that
+    # Rely on ruff & black for formatting
+    return re.sub(r"(^(?:from .+|import .+)$)", f"{import_stmt}\n" + r"\1", text, count=1, flags=re.M)
+
+
+def move_import(f: Path, symbol: str, old_module: str, new_module: str) -> bool:
+    text = f.read_text()
+    text, changed = remove_imports(text, old_module, symbol)
+    if not changed:
+        return False
+    text = insert_import(text, f"from {new_module} import {symbol}")
+    with f.open(mode="w"):
+        f.write_text(text)
+    return True
+
+
+def find_and_remove_aliases(text: str, symbol: str) -> tuple[str, list[str]]:
+    """In the given text find aliases of the given symbol and remove them.
+
+    Return updated text and aliases removed.
+    """
+    rgx = r"(\b%s as (\w+))" % (symbol,)
+    aliases = [aliasgroup for fullgroup, aliasgroup in re.findall(rgx, text)]
+    newtext = re.sub(rgx, symbol, text)
+    return newtext, aliases
+
+
+def replace_words(text: str, words: list[str], replace: str) -> str:
+    rgx = r"\b(%s)\b" % ("|".join(words),)
+    return re.sub(rgx, replace, text)
+
+
+def has_word(text: str, word: str) -> bool:
+    return bool(re.search(r"\b%s\b" % (word,), text))
+
+
+def run_tool(*args: str) -> bool:
+    cmd = " ".join(args)
+    try:
+        r = run(args, capture_output=True)  # noqa: S603
+        if r.returncode == 0:
+            return True
+        print(f"{cmd} failed:", r.stdout, r.stderr)
+    except FileNotFoundError:
+        print(f"{cmd} failed: could not find executable in the current venv")
+    return False
+
+
+def migrate(target_dir: Path, migrate_file: Callable[[Path], bool]) -> bool:
+    abs_path = str(target_dir.resolve())
+
+    def run_tools() -> bool:
+        return run_tool("ruff", "check", "--fix", abs_path) and run_tool("black", "--quiet", abs_path)
+
+    print(f"\n### Verifying files in {abs_path}... ", end="")
+    if not run_tools():
+        print("Failed to verify files, aborting migration. Please resolve errors.")
+        return False
+    print("Ok")
+
+    files_migrated = files_checked = 0
+    print(f"\n### Migrating files in {abs_path}")
+    try:
+        for f in target_dir.glob("**/*.py"):
+            if migrate_file(f):
+                files_migrated += 1
+            files_checked += 1
+    except KeyboardInterrupt:
+        print("Interrupted...")
+
+    print(f"\n### Migrated {files_migrated}/{files_checked} files in {abs_path}")
+
+    print(f"\n### Formatting files in {abs_path}")
+    return run_tools()

orchestrator/distlock/managers/redis_distlock_manager.py

@@ -20,6 +20,7 @@ from redis.lock import Lock as SyncLock
 from structlog import get_logger
 
 from orchestrator.settings import app_settings
+from orchestrator.utils.redis_client import create_redis_asyncio_client, create_redis_client
 
 logger = get_logger(__name__)
 
@@ -37,7 +38,7 @@ class RedisDistLockManager:
         self.redis_address = redis_address
 
     async def connect_redis(self) -> None:
-        self.redis_conn = AIORedis.from_url(str(self.redis_address))
+        self.redis_conn = create_redis_asyncio_client(self.redis_address)
 
     async def disconnect_redis(self) -> None:
         if self.redis_conn:
@@ -78,7 +79,7 @@ class RedisDistLockManager:
     def release_sync(self, lock: Lock) -> None:
         redis_conn: Redis | None = None
         try:
-            redis_conn = Redis.from_url(str(app_settings.CACHE_URI))
+            redis_conn = create_redis_client(app_settings.CACHE_URI)
             sync_lock: SyncLock = SyncLock(
                 redis=redis_conn,
                 name=lock.name,  # type: ignore

orchestrator/domain/base.py

@@ -55,9 +55,7 @@ from orchestrator.domain.lifecycle import (
 from orchestrator.services.products import get_product_by_id
 from orchestrator.types import (
     SAFE_USED_BY_TRANSITIONS_FOR_STATUS,
-    State,
     SubscriptionLifecycle,
-    UUIDstr,
     filter_nonetype,
     get_origin_and_args,
     get_possible_product_block_types,
@@ -69,6 +67,7 @@ from orchestrator.types import (
 )
 from orchestrator.utils.datetime import nowtz
 from orchestrator.utils.docs import make_product_block_docstring, make_subscription_model_docstring
+from pydantic_forms.types import State, UUIDstr
 
 logger = structlog.get_logger(__name__)
 

orchestrator/domain/lifecycle.py

@@ -16,7 +16,8 @@ from typing import TYPE_CHECKING, TypeVar
 import strawberry
 import structlog
 
-from orchestrator.types import SubscriptionLifecycle, strEnum
+from orchestrator.types import SubscriptionLifecycle
+from pydantic_forms.types import strEnum
 
 if TYPE_CHECKING:
     from orchestrator.domain.base import DomainModel

orchestrator/graphql/resolvers/settings.py

@@ -21,6 +21,7 @@ from orchestrator.services.processes import SYSTEM_USER, ThreadPoolWorkerStatus,
 from orchestrator.services.settings import get_engine_settings, get_engine_settings_for_update, post_update_to_slack
 from orchestrator.settings import ExecutorType, app_settings
 from orchestrator.utils.redis import delete_keys_matching_pattern
+from orchestrator.utils.redis_client import create_redis_asyncio_client
 
 logger = structlog.get_logger(__name__)
 
@@ -57,7 +58,7 @@ def resolve_settings(info: OrchestratorInfo) -> StatusType:
 
 # Mutations
 async def clear_cache(info: OrchestratorInfo, name: str) -> CacheClearSuccess | Error:
-    cache: AIORedis = AIORedis.from_url(str(app_settings.CACHE_URI))
+    cache: AIORedis = create_redis_asyncio_client(app_settings.CACHE_URI)
     if name not in CACHE_FLUSH_OPTIONS:
         return Error(message="Invalid cache name")
 

orchestrator/graphql/schemas/product.py

@@ -1,11 +1,11 @@
-from typing import TYPE_CHECKING, Annotated
+from typing import TYPE_CHECKING, Annotated, Iterable
 
 import strawberry
 from strawberry import UNSET
 from strawberry.federation.schema_directives import Key
 
 from oauth2_lib.strawberry import authenticated_field
-from orchestrator.db import ProductTable
+from orchestrator.db import ProductBlockTable, ProductTable
 from orchestrator.domain.base import ProductModel
 from orchestrator.graphql.pagination import Connection
 from orchestrator.graphql.schemas.fixed_input import FixedInput
@@ -51,6 +51,23 @@ class ProductType:
         filter_by_with_related_subscriptions = (filter_by or []) + [GraphqlFilter(field="product", value=self.name)]
         return await resolve_subscriptions(info, filter_by_with_related_subscriptions, sort_by, first, after)
 
+    @strawberry.field(description="Returns list of all nested productblock names")  # type: ignore
+    async def all_pb_names(self) -> list[str]:
+
+        model = get_original_model(self, ProductTable)
+
+        def get_all_pb_names(product_blocks: list[ProductBlockTable]) -> Iterable[str]:
+            for product_block in product_blocks:
+                yield product_block.name
+
+                if product_block.depends_on:
+                    yield from get_all_pb_names(product_block.depends_on)
+
+        names: list[str] = list(get_all_pb_names(model.product_blocks))
+        names.sort()
+
+        return names
+
     @strawberry.field(description="Return product blocks")  # type: ignore
     async def product_blocks(self) -> list[Annotated["ProductBlock", strawberry.lazy(".product_block")]]:
         from orchestrator.graphql.schemas.product_block import ProductBlock

orchestrator/migrations/helpers.py

@@ -19,7 +19,7 @@ import sqlalchemy as sa
 import structlog
 
 from orchestrator.settings import app_settings
-from orchestrator.types import UUIDstr
+from pydantic_forms.types import UUIDstr
 
 logger = structlog.get_logger(__name__)
 

orchestrator/migrations/versions/schema/2025-02-12_bac6be6f2b4f_added_input_state_table.py

@@ -0,0 +1,56 @@
+"""Added Input State Table.
+
+Revision ID: bac6be6f2b4f
+Revises: 4fjdn13f83ga
+Create Date: 2025-02-12 14:39:53.664284
+
+"""
+
+import sqlalchemy as sa
+import sqlalchemy_utils
+from alembic import op
+from sqlalchemy.dialects import postgresql
+
+from orchestrator import db
+
+# revision identifiers, used by Alembic.
+revision = "bac6be6f2b4f"
+down_revision = "4fjdn13f83ga"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table(
+        "input_states",
+        sa.Column(
+            "input_state_id",
+            sqlalchemy_utils.types.uuid.UUIDType(),
+            server_default=sa.text("uuid_generate_v4()"),
+            nullable=False,
+        ),
+        sa.Column("pid", sqlalchemy_utils.types.uuid.UUIDType(), nullable=False),
+        sa.Column("input_state", postgresql.JSONB(astext_type=sa.Text()), nullable=False),  # type: ignore
+        sa.Column(
+            "input_time",
+            db.models.UtcTimestamp(timezone=True),
+            server_default=sa.text("current_timestamp"),
+            nullable=False,
+        ),
+        sa.Column("input_type", sa.Enum("user_input", "initial_state", name="inputtype"), nullable=False),
+        sa.ForeignKeyConstraint(
+            ["pid"],
+            ["processes.pid"],
+        ),
+        sa.PrimaryKeyConstraint("input_state_id"),
+    )
+    op.create_index(op.f("ix_input_state_input_state_id"), "input_states", ["input_state_id"], unique=False)
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f("ix_input_state_input_state_id"), table_name="input_states")
+    op.drop_table("input_statse")
+    # ### end Alembic commands ###

orchestrator/schemas/engine_settings.py

@@ -16,7 +16,7 @@ import strawberry
 from pydantic import ConfigDict
 
 from orchestrator.schemas.base import OrchestratorBaseModel
-from orchestrator.types import strEnum
+from pydantic_forms.types import strEnum
 
 
 @strawberry.enum

orchestrator/schemas/product.py

@@ -41,3 +41,7 @@ class ProductSchema(ProductBaseSchema):
     product_blocks: list[ProductBlockSchema]
     fixed_inputs: list[FixedInputSchema]
     workflows: list[WorkflowSchema]
+
+
+class ProductPatchSchema(OrchestratorBaseModel):
+    description: str | None = None

orchestrator/schemas/product_block.py

@@ -37,3 +37,7 @@ class ProductBlockSchema(ProductBlockBaseSchema):
     end_date: datetime | None = None
     resource_types: list[ResourceTypeSchema] | None = None  # type: ignore
     model_config = ConfigDict(from_attributes=True)
+
+
+class ProductBlockPatchSchema(OrchestratorBaseModel):
+    description: str | None = None

orchestrator/schemas/resource_type.py

@@ -27,3 +27,7 @@ class ResourceTypeBaseSchema(OrchestratorBaseModel):
 class ResourceTypeSchema(ResourceTypeBaseSchema):
     resource_type_id: UUID
     model_config = ConfigDict(from_attributes=True)
+
+
+class ResourceTypePatchSchema(OrchestratorBaseModel):
+    description: str | None = None

orchestrator/schemas/subscription.py

@@ -22,7 +22,8 @@ from orchestrator.schemas.product import ProductBaseSchema
 from orchestrator.schemas.product_block import ProductBlockSchema
 from orchestrator.schemas.resource_type import ResourceTypeSchema
 from orchestrator.schemas.subscription_descriptions import SubscriptionDescriptionSchema
-from orchestrator.types import SubscriptionLifecycle, strEnum
+from orchestrator.types import SubscriptionLifecycle
+from pydantic_forms.types import strEnum
 
 
 class PortMode(strEnum):

orchestrator/schemas/workflow.py

@@ -59,3 +59,7 @@ class SubscriptionWorkflowListsSchema(OrchestratorBaseModel):
     modify: list[WorkflowListItemSchema]
     terminate: list[WorkflowListItemSchema]
     system: list[WorkflowListItemSchema]
+
+
+class WorkflowPatchSchema(OrchestratorBaseModel):
+    description: str | None = None

orchestrator/services/celery.py

@@ -22,10 +22,11 @@ from kombu.exceptions import ConnectionError, OperationalError
 from orchestrator import app_settings
 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.types import State
 from orchestrator.workflows import get_workflow
+from pydantic_forms.types import State
 
 SYSTEM_USER = "SYSTEM"
 
@@ -53,9 +54,8 @@ def _celery_start_process(
     task_name = NEW_TASK if workflow.target == Target.SYSTEM else NEW_WORKFLOW
     trigger_task = get_celery_task(task_name)
     pstat = create_process(workflow_key, user_inputs, user)
-    tasks = pstat.state.s
     try:
-        result = trigger_task.delay(pstat.process_id, workflow_key, tasks, user)
+        result = trigger_task.delay(pstat.process_id, workflow_key, user)
         _block_when_testing(result)
         return pstat.process_id
     except (ConnectionError, OperationalError) as e:
@@ -82,9 +82,12 @@ def _celery_resume_process(
 
     task_name = RESUME_TASK if workflow.target == Target.SYSTEM else RESUME_WORKFLOW
     trigger_task = get_celery_task(task_name)
+
+    user_inputs = user_inputs or [{}]
+    store_input_state(pstat.process_id, user_inputs, "user_input")
     try:
         _celery_set_process_status_resumed(process)
-        result = trigger_task.delay(pstat.process_id, user_inputs, user)
+        result = trigger_task.delay(pstat.process_id, user)
         _block_when_testing(result)
 
         return pstat.process_id

orchestrator/services/input_state.py

@@ -0,0 +1,76 @@
+# Copyright 2019-2025 SURF.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+from typing import Any, Literal
+from uuid import UUID
+
+import structlog
+from sqlalchemy import select
+
+from orchestrator.db import db
+from orchestrator.db.models import InputStateTable
+
+logger = structlog.get_logger(__name__)
+
+InputType = Literal["initial_state", "user_input"]
+
+
+def retrieve_input_state(process_id: UUID, input_type: InputType) -> InputStateTable:
+    """Get user input.
+
+    Args:
+        process_id: Process ID
+        input_type: The type of the input.
+
+    Returns:
+        User input table
+
+    """
+
+    res: InputStateTable | None = db.session.scalars(
+        select(InputStateTable)
+        .filter(InputStateTable.process_id == process_id)
+        .filter(InputStateTable.input_type == input_type)
+        .order_by(InputStateTable.input_time.asc())
+    ).first()
+
+    if res:
+        logger.debug("Retrieved input state", process_id=process_id, input_state=res, input_type=input_type)
+        return res
+    raise ValueError(f"No input state for pid: {process_id}")
+
+
+def store_input_state(
+    process_id: UUID,
+    input_state: dict[str, Any] | list[dict[str, Any]],
+    input_type: InputType,
+) -> None:
+    """Store user input state.
+
+    Args:
+        process_id: Process ID
+        input_state: Dictionary of user input state
+        input_type: The type of the input.
+
+    Returns:
+        None
+
+    """
+    logger.debug("Store input state", process_id=process_id, input_state=input_state, input_type=input_type)
+    db.session.add(
+        InputStateTable(
+            process_id=process_id,
+            input_state=input_state,
+            input_type=input_type,
+        )
+    )
+    db.session.commit()