orchestrator-core 4.1.0rc2__tar.gz → 4.2.0rc2__tar.gz

orchestrator_core-4.2.0rc2/PKG-INFO

@@ -0,0 +1,167 @@
+Metadata-Version: 2.4
+Name: orchestrator-core
+Version: 4.2.0rc2
+Summary: This is the orchestrator workflow engine.
+Author-email: SURF <automation-beheer@surf.nl>
+Requires-Python: >=3.11,<3.14
+Description-Content-Type: text/markdown
+License-Expression: Apache-2.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: Intended Audience :: Telecommunications Industry
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Internet
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development
+Classifier: Typing :: Typed
+License-File: LICENSE
+Requires-Dist: alembic==1.16.1
+Requires-Dist: anyio>=3.7.0
+Requires-Dist: click==8.*
+Requires-Dist: deepmerge==2.0
+Requires-Dist: deprecated>=1.2.18
+Requires-Dist: fastapi~=0.115.2
+Requires-Dist: fastapi-etag==0.4.0
+Requires-Dist: itsdangerous>=2.2.0
+Requires-Dist: jinja2==3.1.6
+Requires-Dist: more-itertools~=10.7.0
+Requires-Dist: nwa-stdlib~=1.9.0
+Requires-Dist: oauth2-lib~=2.4.0
+Requires-Dist: orjson==3.10.18
+Requires-Dist: prometheus-client==0.22.1
+Requires-Dist: psycopg2-binary==2.9.10
+Requires-Dist: pydantic-forms>=1.4.0,<=2.1.0
+Requires-Dist: pydantic-settings~=2.9.1
+Requires-Dist: pydantic[email]~=2.8.2
+Requires-Dist: python-dateutil==2.8.2
+Requires-Dist: python-rapidjson>=1.18,<1.21
+Requires-Dist: pytz==2025.2
+Requires-Dist: redis==5.1.1
+Requires-Dist: schedule==1.1.0
+Requires-Dist: semver==3.0.4
+Requires-Dist: sentry-sdk[fastapi]~=2.29.1
+Requires-Dist: sqlalchemy==2.0.41
+Requires-Dist: sqlalchemy-utils==0.41.2
+Requires-Dist: strawberry-graphql>=0.246.2
+Requires-Dist: structlog>=25.4.0
+Requires-Dist: tabulate==0.9.0
+Requires-Dist: typer==0.15.4
+Requires-Dist: uvicorn[standard]~=0.34.0
+Requires-Dist: celery~=5.5.1 ; extra == "celery"
+Project-URL: Documentation, https://workfloworchestrator.org/orchestrator-core
+Project-URL: Homepage, https://workfloworchestrator.org/orchestrator-core
+Project-URL: Source, https://github.com/workfloworchestrator/orchestrator-core
+Provides-Extra: celery
+
+# Orchestrator-Core
+
+[![Downloads](https://pepy.tech/badge/orchestrator-core/month)](https://pepy.tech/project/orchestrator-core)
+[![codecov](https://codecov.io/gh/workfloworchestrator/orchestrator-core/branch/main/graph/badge.svg?token=5ANQFI2DHS)](https://codecov.io/gh/workfloworchestrator/orchestrator-core)
+[![pypi_version](https://img.shields.io/pypi/v/orchestrator-core?color=%2334D058&label=pypi%20package)](https://pypi.org/project/orchestrator-core)
+[![Supported python versions](https://img.shields.io/pypi/pyversions/orchestrator-core.svg?color=%2334D058)](https://pypi.org/project/orchestrator-core)
+![Discord](https://img.shields.io/discord/1295834294270558280?style=flat&logo=discord&label=discord&link=https%3A%2F%2Fdiscord.gg%2FKNgF6gE8)
+
+<p style="text-align: center"><em>Production ready Orchestration Framework to manage product lifecycle and workflows. Easy to use, built on top of FastAPI and Pydantic</em></p>
+
+## Documentation
+
+The documentation can be found at [workfloworchestrator.org](https://workfloworchestrator.org/orchestrator-core/).
+
+## Installation (quick start)
+
+Simplified steps to install and use the orchestrator-core.
+For more details, read the [Getting started](https://workfloworchestrator.org/orchestrator-core/getting-started/base/) documentation.
+
+### Step 1 - Install the package
+
+Create a virtualenv and install the orchestrator-core.
+
+```shell
+python -m venv .venv
+source .venv/bin/activate
+pip install orchestrator-core
+```
+
+### Step 2 - Setup the database
+
+Create a postgres database:
+
+```shell
+createuser -sP nwa
+createdb orchestrator-core -O nwa  # set password to 'nwa'
+```
+
+Configure the database URI in your local environment:
+
+```
+export DATABASE_URI=postgresql://nwa:nwa@localhost:5432/orchestrator-core
+```
+
+### Step 3 - Create main.py
+
+Create a `main.py` file.
+
+```python
+from orchestrator import OrchestratorCore
+from orchestrator.cli.main import app as core_cli
+from orchestrator.settings import AppSettings
+
+app = OrchestratorCore(base_settings=AppSettings())
+
+if __name__ == "__main__":
+    core_cli()
+```
+
+### Step 4 - Run the database migrations
+
+Initialize the migration environment and database tables.
+
+```shell
+python main.py db init
+python main.py db upgrade heads
+```
+
+### Step 5 - Run the app
+
+```shell
+export OAUTH2_ACTIVE=False
+uvicorn --reload --host 127.0.0.1 --port 8080 main:app
+```
+
+Visit the [ReDoc](http://127.0.0.1:8080/api/redoc) or [OpenAPI](http://127.0.0.1:8080/api/docs) page to view and interact with the API.
+
+## Contributing
+
+We use [uv](https://docs.astral.sh/uv/getting-started/installation/) to manage dependencies.
+
+To get started, follow these steps:
+
+```shell
+# in your postgres database
+createdb orchestrator-core-test -O nwa  # set password to 'nwa'
+
+# on your local machine
+git clone https://github.com/workfloworchestrator/orchestrator-core
+cd orchestrator-core
+export DATABASE_URI=postgresql://nwa:nwa@localhost:5432/orchestrator-core-test
+uv sync --all-extras --all-groups
+uv run pytest
+```
+
+For more details please read the [development docs](https://workfloworchestrator.org/orchestrator-core/contributing/development/).
+

orchestrator_core-4.2.0rc2/README.md

@@ -0,0 +1,96 @@
+# Orchestrator-Core
+
+[![Downloads](https://pepy.tech/badge/orchestrator-core/month)](https://pepy.tech/project/orchestrator-core)
+[![codecov](https://codecov.io/gh/workfloworchestrator/orchestrator-core/branch/main/graph/badge.svg?token=5ANQFI2DHS)](https://codecov.io/gh/workfloworchestrator/orchestrator-core)
+[![pypi_version](https://img.shields.io/pypi/v/orchestrator-core?color=%2334D058&label=pypi%20package)](https://pypi.org/project/orchestrator-core)
+[![Supported python versions](https://img.shields.io/pypi/pyversions/orchestrator-core.svg?color=%2334D058)](https://pypi.org/project/orchestrator-core)
+![Discord](https://img.shields.io/discord/1295834294270558280?style=flat&logo=discord&label=discord&link=https%3A%2F%2Fdiscord.gg%2FKNgF6gE8)
+
+<p style="text-align: center"><em>Production ready Orchestration Framework to manage product lifecycle and workflows. Easy to use, built on top of FastAPI and Pydantic</em></p>
+
+## Documentation
+
+The documentation can be found at [workfloworchestrator.org](https://workfloworchestrator.org/orchestrator-core/).
+
+## Installation (quick start)
+
+Simplified steps to install and use the orchestrator-core.
+For more details, read the [Getting started](https://workfloworchestrator.org/orchestrator-core/getting-started/base/) documentation.
+
+### Step 1 - Install the package
+
+Create a virtualenv and install the orchestrator-core.
+
+```shell
+python -m venv .venv
+source .venv/bin/activate
+pip install orchestrator-core
+```
+
+### Step 2 - Setup the database
+
+Create a postgres database:
+
+```shell
+createuser -sP nwa
+createdb orchestrator-core -O nwa  # set password to 'nwa'
+```
+
+Configure the database URI in your local environment:
+
+```
+export DATABASE_URI=postgresql://nwa:nwa@localhost:5432/orchestrator-core
+```
+
+### Step 3 - Create main.py
+
+Create a `main.py` file.
+
+```python
+from orchestrator import OrchestratorCore
+from orchestrator.cli.main import app as core_cli
+from orchestrator.settings import AppSettings
+
+app = OrchestratorCore(base_settings=AppSettings())
+
+if __name__ == "__main__":
+    core_cli()
+```
+
+### Step 4 - Run the database migrations
+
+Initialize the migration environment and database tables.
+
+```shell
+python main.py db init
+python main.py db upgrade heads
+```
+
+### Step 5 - Run the app
+
+```shell
+export OAUTH2_ACTIVE=False
+uvicorn --reload --host 127.0.0.1 --port 8080 main:app
+```
+
+Visit the [ReDoc](http://127.0.0.1:8080/api/redoc) or [OpenAPI](http://127.0.0.1:8080/api/docs) page to view and interact with the API.
+
+## Contributing
+
+We use [uv](https://docs.astral.sh/uv/getting-started/installation/) to manage dependencies.
+
+To get started, follow these steps:
+
+```shell
+# in your postgres database
+createdb orchestrator-core-test -O nwa  # set password to 'nwa'
+
+# on your local machine
+git clone https://github.com/workfloworchestrator/orchestrator-core
+cd orchestrator-core
+export DATABASE_URI=postgresql://nwa:nwa@localhost:5432/orchestrator-core-test
+uv sync --all-extras --all-groups
+uv run pytest
+```
+
+For more details please read the [development docs](https://workfloworchestrator.org/orchestrator-core/contributing/development/).

{orchestrator_core-4.1.0rc2 → orchestrator_core-4.2.0rc2}/orchestrator/__init__.py

@@ -13,7 +13,7 @@
 
 """This is the orchestrator workflow engine."""
 
-__version__ = "4.1.0rc2"
+__version__ = "4.2.0rc2"
 
 from orchestrator.app import OrchestratorCore
 from orchestrator.settings import app_settings

{orchestrator_core-4.1.0rc2 → orchestrator_core-4.2.0rc2}/orchestrator/api/api_v1/endpoints/processes.py

@@ -123,6 +123,7 @@ def get_auth_callbacks(steps: StepList, workflow: Workflow) -> tuple[Authorizer
 def can_be_resumed(status: ProcessStatus) -> bool:
     return status in (
         ProcessStatus.SUSPENDED,  # Can be resumed
+        ProcessStatus.WAITING,  # Can be retried
         ProcessStatus.FAILED,  # Can be retried
         ProcessStatus.API_UNAVAILABLE,  # subtype of FAILED
         ProcessStatus.INCONSISTENT_DATA,  # subtype of FAILED
@@ -158,6 +159,9 @@ def delete(process_id: UUID) -> None:
     if not process:
         raise_status(HTTPStatus.NOT_FOUND)
 
+    if not process.is_task:
+        raise_status(HTTPStatus.BAD_REQUEST)
+
     db.session.delete(db.session.get(ProcessTable, process_id))
     db.session.commit()
 
@@ -209,7 +213,7 @@ def resume_process_endpoint(
     if process.last_status == ProcessStatus.SUSPENDED:
         if auth_resume is not None and not auth_resume(user_model):
             raise_status(HTTPStatus.FORBIDDEN, "User is not authorized to resume step")
-    elif process.last_status == ProcessStatus.FAILED:
+    elif process.last_status in (ProcessStatus.FAILED, ProcessStatus.WAITING):
         if auth_retry is not None and not auth_retry(user_model):
             raise_status(HTTPStatus.FORBIDDEN, "User is not authorized to retry step")
 
@@ -270,7 +274,7 @@ def update_progress_on_awaiting_process_endpoint(
 @router.put(
     "/resume-all", response_model=ProcessResumeAllSchema, dependencies=[Depends(check_global_lock, use_cache=False)]
 )
-async def resume_all_processess_endpoint(request: Request, user: str = Depends(user_name)) -> dict[str, int]:
+async def resume_all_processes_endpoint(request: Request, user: str = Depends(user_name)) -> dict[str, int]:
     """Retry all task processes in status Failed, Waiting, API Unavailable or Inconsistent Data.
 
     The retry is started in the background, returning status 200 and number of processes in message.

{orchestrator_core-4.1.0rc2 → orchestrator_core-4.2.0rc2}/orchestrator/api/api_v1/endpoints/subscriptions.py

@@ -47,10 +47,12 @@ from orchestrator.services.subscriptions import (
     subscription_workflows,
 )
 from orchestrator.settings import app_settings
+from orchestrator.targets import Target
 from orchestrator.types import SubscriptionLifecycle
 from orchestrator.utils.deprecation_logger import deprecated_endpoint
 from orchestrator.utils.get_subscription_dict import get_subscription_dict
 from orchestrator.websocket import sync_invalidate_subscription_cache
+from orchestrator.workflows import get_workflow
 
 router = APIRouter()
 
@@ -100,6 +102,25 @@ def _filter_statuses(filter_statuses: str | None = None) -> list[str]:
     return statuses
 
 
+def _authorized_subscription_workflows(
+    subscription: SubscriptionTable, current_user: OIDCUserModel | None
+) -> dict[str, list[dict[str, list[Any] | str]]]:
+    subscription_workflows_dict = subscription_workflows(subscription)
+
+    for workflow_target in Target.values():
+        for workflow_dict in subscription_workflows_dict[workflow_target.lower()]:
+            workflow = get_workflow(workflow_dict["name"])
+            if not workflow:
+                continue
+            if (
+                not workflow.authorize_callback(current_user)  # The current user isn't allowed to run this workflow
+                and "reason" not in workflow_dict  # and there isn't already a reason why this workflow cannot run
+            ):
+                workflow_dict["reason"] = "subscription.insufficient_workflow_permissions"
+
+    return subscription_workflows_dict
+
+
 @router.get(
     "/domain-model/{subscription_id}",
     response_model=SubscriptionDomainModelSchema | None,
@@ -169,7 +190,9 @@ def subscriptions_search(
     description="This endpoint is deprecated and will be removed in a future release. Please use the GraphQL query",
     dependencies=[Depends(deprecated_endpoint)],
 )
-def subscription_workflows_by_id(subscription_id: UUID) -> dict[str, list[dict[str, list[Any] | str]]]:
+def subscription_workflows_by_id(
+    subscription_id: UUID, current_user: OIDCUserModel | None = Depends(authenticate)
+) -> dict[str, list[dict[str, list[Any] | str]]]:
     subscription = db.session.get(
         SubscriptionTable,
         subscription_id,
@@ -181,7 +204,7 @@ def subscription_workflows_by_id(subscription_id: UUID) -> dict[str, list[dict[s
     if not subscription:
         raise_status(HTTPStatus.NOT_FOUND)
 
-    return subscription_workflows(subscription)
+    return _authorized_subscription_workflows(subscription, current_user)
 
 
 @router.put("/{subscription_id}/set_in_sync", response_model=None, status_code=HTTPStatus.OK)

{orchestrator_core-4.1.0rc2 → orchestrator_core-4.2.0rc2}/orchestrator/cli/database.py

@@ -256,6 +256,9 @@ def migrate_domain_models(
     test: bool = typer.Option(False, help="Optional boolean if you don't want to generate a migration file"),
     inputs: str = typer.Option("{}", help="Stringified dict to prefill inputs"),
     updates: str = typer.Option("{}", help="Stringified dict to map updates instead of using inputs"),
+    confirm_warnings: bool = typer.Option(
+        False, help="Optional boolean if you want to accept all warning inputs, fully knowing things can go wrong"
+    ),
 ) -> tuple[list[str], list[str]] | None:
     """Create migration file based on SubscriptionModel.diff_product_in_database. BACKUP DATABASE BEFORE USING THE MIGRATION!.
 
@@ -282,6 +285,8 @@ def migrate_domain_models(
                 - `updates = { "resource_types": { "old_resource_type_name": "new_resource_type_name" } }`
             - renaming a resource type to existing resource type: `updates = { "resource_types": { "old_resource_type_name": "new_resource_type_name" } }`
 
+        confirm_warnings: Optional boolean if you want to accept all warning inputs, fully knowing things can go wrong.
+
     Returns None unless `--test` is used, in which case it returns:
         - tuple:
             - list of upgrade SQL statements in string format.
@@ -304,7 +309,9 @@ def migrate_domain_models(
             resource_types=updates_dict.get("resource_types", {}),
             block_resource_types=updates_dict.get("block_resource_types", {}),
         )
-    sql_upgrade_stmts, sql_downgrade_stmts = create_domain_models_migration_sql(inputs_dict, updates_class, bool(test))
+    sql_upgrade_stmts, sql_downgrade_stmts = create_domain_models_migration_sql(
+        inputs_dict, updates_class, test, confirm_warnings
+    )
 
     if test:
         return sql_upgrade_stmts, sql_downgrade_stmts

orchestrator_core-4.2.0rc2/orchestrator/cli/domain_gen_helpers/helpers.py

@@ -0,0 +1,97 @@
+from collections.abc import Iterable
+from itertools import groupby
+
+import structlog
+import typer
+from more_itertools import first
+from sqlalchemy.dialects import postgresql
+from sqlalchemy.sql.dml import UpdateBase
+
+from orchestrator.cli.domain_gen_helpers.types import BlockRelationDict
+from orchestrator.cli.helpers.input_helpers import _prompt_user_menu
+from orchestrator.cli.helpers.print_helpers import noqa_print
+from orchestrator.domain.base import ProductBlockModel, SubscriptionModel
+
+logger = structlog.get_logger(__name__)
+
+
+def sql_compile(sql: UpdateBase) -> str:
+    sql_string = str(sql.compile(dialect=postgresql.dialect(), compile_kwargs={"literal_binds": True}))  # type: ignore[no-untyped-call]
+    sql_string = sql_string.replace("\n", "")
+    logger.debug("generated SQL", sql_string=sql_string)
+    return sql_string
+
+
+def generic_mapper(prop_name: str, model_diffs: dict[str, dict[str, set[str]]]) -> dict[str, set[str]]:
+    model_by_resource = [
+        (prop_name_value, model_name)
+        for model_name, diff in model_diffs.items()
+        for prop_name_value in diff.get(prop_name, [])
+    ]
+    grouped = groupby(model_by_resource, lambda x: x[0])
+    return {k: {val[1] for val in v} for k, v in grouped}
+
+
+def map_create_fixed_inputs(model_diffs: dict[str, dict[str, set[str]]]) -> dict[str, set[str]]:
+    return generic_mapper("missing_fixed_inputs_in_db", model_diffs)
+
+
+def map_delete_fixed_inputs(model_diffs: dict[str, dict[str, set[str]]]) -> dict[str, set[str]]:
+    return generic_mapper("missing_fixed_inputs_in_model", model_diffs)
+
+
+def map_create_resource_type_relations(model_diffs: dict[str, dict[str, set[str]]]) -> dict[str, set[str]]:
+    return generic_mapper("missing_resource_types_in_db", model_diffs)
+
+
+def map_delete_resource_type_relations(model_diffs: dict[str, dict[str, set[str]]]) -> dict[str, set[str]]:
+    return generic_mapper("missing_resource_types_in_model", model_diffs)
+
+
+def map_create_product_to_product_block_relations(model_diffs: dict[str, dict[str, set[str]]]) -> dict[str, set[str]]:
+    return generic_mapper("missing_product_blocks_in_db", model_diffs)
+
+
+def format_block_relation_to_dict(
+    model_name: str,
+    block_to_find_in_props: str,
+    models: dict[str, type[SubscriptionModel]] | dict[str, type[ProductBlockModel]],
+    confirm_warnings: bool,
+) -> BlockRelationDict:
+    model = models[model_name]
+    block_props = model._get_depends_on_product_block_types()
+    props = {k for k, v in block_props.items() if v.name == block_to_find_in_props}  # type: ignore
+
+    if len(props) > 1 and not confirm_warnings:
+        noqa_print("WARNING: Relating a Product Block multiple times is not supported by this migrator!")
+        noqa_print(
+            "You will need to create your own migration to create a Product Block Instance for each attribute that is related"
+        )
+        noqa_print(f"Product Block '{block_to_find_in_props}' has been related multiple times to '{model_name}'")
+        noqa_print(f"Attributes the block ('{block_to_find_in_props}') has been related with: {', '.join(props)}")
+        noqa_print(f"The relation will only be added to the first attribute ('{first(props)}') want to continue?")
+
+        if _prompt_user_menu([("yes", "yes"), ("no", "no")]) == "no":
+            typer.echo("Aborted.")
+            raise typer.Exit(code=1)
+
+    return BlockRelationDict(name=model_name, attribute_name=first(props))
+
+
+def map_create_product_block_relations(
+    model_diffs: dict[str, dict[str, set[str]]],
+    models: dict[str, type[SubscriptionModel]] | dict[str, type[ProductBlockModel]],
+    confirm_warnings: bool,
+) -> dict[str, list[BlockRelationDict]]:
+    data = generic_mapper("missing_product_blocks_in_db", model_diffs)
+    return {
+        k: [format_block_relation_to_dict(b, k, models, confirm_warnings) for b in blocks] for k, blocks in data.items()
+    }
+
+
+def map_delete_product_block_relations(model_diffs: dict[str, dict[str, set[str]]]) -> dict[str, set[str]]:
+    return generic_mapper("missing_product_blocks_in_model", model_diffs)
+
+
+def get_product_block_names(pbs: list[type[ProductBlockModel]]) -> Iterable[str]:
+    return filter(None, (pb.name for pb in pbs))

{orchestrator_core-4.1.0rc2 → orchestrator_core-4.2.0rc2}/orchestrator/cli/domain_gen_helpers/product_block_helpers.py

@@ -7,8 +7,12 @@ from sqlalchemy import select
 from sqlalchemy.sql.expression import Delete, Insert
 from sqlalchemy.sql.selectable import ScalarSelect
 
-from orchestrator.cli.domain_gen_helpers.helpers import get_product_block_names, sql_compile
-from orchestrator.cli.domain_gen_helpers.types import DomainModelChanges
+from orchestrator.cli.domain_gen_helpers.helpers import (
+    format_block_relation_to_dict,
+    get_product_block_names,
+    sql_compile,
+)
+from orchestrator.cli.domain_gen_helpers.types import BlockRelationDict, DomainModelChanges
 from orchestrator.cli.helpers.input_helpers import get_user_input
 from orchestrator.cli.helpers.print_helpers import COLOR, print_fmt, str_fmt
 from orchestrator.db import db
@@ -68,13 +72,17 @@ def map_delete_product_blocks(product_blocks: dict[str, type[ProductBlockModel]]
     return {name for name in existing_product_blocks if name not in product_blocks}
 
 
-def map_product_block_additional_relations(changes: DomainModelChanges) -> DomainModelChanges:
+def map_product_block_additional_relations(
+    changes: DomainModelChanges, models: dict[str, type[ProductBlockModel]], confirm_warnings: bool
+) -> DomainModelChanges:
     """Map additional relations for created product blocks.
 
     Adds resource type and product block relations.
 
     Args:
         changes: DomainModelChanges class with all changes.
+        models: All product block models.
+        confirm_warnings: confirm warnings to continue, fully knowing that things can go wrong.
 
     Returns: Updated DomainModelChanges.
     """
@@ -86,7 +94,12 @@ def map_product_block_additional_relations(changes: DomainModelChanges) -> Domai
         product_blocks_in_model = block_class._get_depends_on_product_block_types()
         product_blocks_types_in_model = get_depends_on_product_block_type_list(product_blocks_in_model)
         for product_block_name in get_product_block_names(product_blocks_types_in_model):
-            changes.create_product_block_relations.setdefault(product_block_name, set()).add(block_name)
+            relation_list = changes.create_product_block_relations.get(product_block_name, [])
+            new_relation = format_block_relation_to_dict(block_name, product_block_name, models, confirm_warnings)
+
+            if new_relation not in relation_list:
+                changes.create_product_block_relations[product_block_name] = relation_list + [new_relation]
+
     return changes
 
 
@@ -147,31 +160,35 @@ def generate_delete_product_blocks_sql(delete_product_blocks: set[str]) -> list[
     ]
 
 
-def generate_create_product_block_relations_sql(create_block_relations: dict[str, set[str]]) -> list[str]:
+def generate_create_product_block_relations_sql(
+    create_block_relations: dict[str, list[BlockRelationDict]],
+) -> list[str]:
     """Generate SQL to create product block to product block relations.
 
     Args:
         create_block_relations: Dict with product blocks by product block
             - key: product block name.
-            - value: Set of product block names to relate with.
+            - list: List of product blocks to relate with by prop names.
 
     Returns: List of SQL to create relation between product blocks.
     """
 
-    def create_block_relation(depends_block_name: str, block_names: set[str]) -> str:
+    def create_block_relation(depends_block_name: str, block_relations: list[BlockRelationDict]) -> str:
         depends_block_id_sql = get_product_block_id(depends_block_name)
 
-        def create_block_relation_dict(block_name: str) -> dict[str, ScalarSelect]:
-            block_id_sql = get_product_block_id(block_name)
+        def create_block_relation_dict(block_relation: BlockRelationDict) -> dict[str, ScalarSelect]:
+            block_id_sql = get_product_block_id(block_relation["name"])
             return {"in_use_by_id": block_id_sql, "depends_on_id": depends_block_id_sql}
 
-        product_product_block_relation_dicts = [create_block_relation_dict(block_name) for block_name in block_names]
+        product_product_block_relation_dicts = [create_block_relation_dict(block) for block in block_relations]
         return sql_compile(Insert(ProductBlockRelationTable).values(product_product_block_relation_dicts))
 
     return [create_block_relation(*item) for item in create_block_relations.items()]
 
 
-def generate_create_product_block_instance_relations_sql(product_block_relations: dict[str, set[str]]) -> list[str]:
+def generate_create_product_block_instance_relations_sql(
+    product_block_relations: dict[str, list[BlockRelationDict]],
+) -> list[str]:
     """Generate SQL to create resource type instance values for existing instances.
 
     Args:
@@ -183,12 +200,14 @@ def generate_create_product_block_instance_relations_sql(product_block_relations
     """
 
     def create_subscription_instance_relations(
-        depends_block_name: str, block_names: set[str]
+        depends_block_name: str, block_relations: list[BlockRelationDict]
     ) -> Generator[str, None, None]:
         depends_block_id_sql = get_product_block_id(depends_block_name)
 
-        def map_subscription_instances(block_name: str) -> dict[str, list[dict[str, str | ScalarSelect]]]:
-            in_use_by_id_sql = get_product_block_id(block_name)
+        def map_subscription_instances(
+            block_relation: BlockRelationDict,
+        ) -> dict[str, list[dict[str, str | ScalarSelect]]]:
+            in_use_by_id_sql = get_product_block_id(block_relation["name"])
             stmt = select(
                 SubscriptionInstanceTable.subscription_instance_id, SubscriptionInstanceTable.subscription_id
             ).where(SubscriptionInstanceTable.product_block_id.in_(in_use_by_id_sql))
@@ -206,13 +225,14 @@ def generate_create_product_block_instance_relations_sql(product_block_relations
                     "in_use_by_id": instance.subscription_instance_id,
                     "depends_on_id": get_subscription_instance(instance.subscription_id, depends_block_id_sql),
                     "order_id": 0,
+                    "domain_model_attr": block_relation["attribute_name"],
                 }
                 for instance in subscription_instances
             ]
 
             return {"instance_list": instance_list, "instance_relation_list": instance_relation_list}
 
-        create_instance_list = [map_subscription_instances(block_name) for block_name in block_names]
+        create_instance_list = [map_subscription_instances(block_relation) for block_relation in block_relations]
 
         subscription_instance_dicts = list(flatten(item["instance_list"] for item in create_instance_list))
         subscription_relation_dicts = list(flatten(item["instance_relation_list"] for item in create_instance_list))

{orchestrator_core-4.1.0rc2 → orchestrator_core-4.2.0rc2}/orchestrator/cli/domain_gen_helpers/resource_type_helpers.py

@@ -9,7 +9,7 @@ from sqlalchemy.sql.selectable import ScalarSelect
 
 from orchestrator.cli.domain_gen_helpers.helpers import sql_compile
 from orchestrator.cli.domain_gen_helpers.product_block_helpers import get_product_block_id, get_product_block_ids
-from orchestrator.cli.domain_gen_helpers.types import DomainModelChanges
+from orchestrator.cli.domain_gen_helpers.types import BlockRelationDict, DomainModelChanges
 from orchestrator.cli.helpers.input_helpers import _enumerate_menu_keys, _prompt_user_menu, get_user_input
 from orchestrator.cli.helpers.print_helpers import COLOR, noqa_print, print_fmt, str_fmt
 from orchestrator.db import db
@@ -262,8 +262,8 @@ def _has_product_existing_instances(product_name: str) -> bool:
     return bool(product and get_product_instance_count(product.product_id))
 
 
-def _find_new_relations(block_name: str, relations: dict[str, set[str]]) -> set[str]:
-    return set(flatten((list(v) for k, v in relations.items() if block_name in k)))
+def _find_new_block_relations(block_name: str, relations: dict[str, list[BlockRelationDict]]) -> set[str]:
+    return {r["name"] for r in relations.get(block_name, [])}
 
 
 def map_create_resource_type_instances(changes: DomainModelChanges) -> dict[str, set[str]]:
@@ -285,11 +285,11 @@ def map_create_resource_type_instances(changes: DomainModelChanges) -> dict[str,
         if block and get_block_instance_count(block.product_block_id):
             return True
 
-        related_block_names = _find_new_relations(block_name, changes.create_product_block_relations)
+        related_block_names = _find_new_block_relations(block_name, changes.create_product_block_relations)
         if related_block_names:
             return any(_has_existing_instances(name) for name in related_block_names)
 
-        related_product_names = _find_new_relations(block_name, changes.create_product_to_block_relations)
+        related_product_names = changes.create_product_to_block_relations.get(block_name, set())
         return any(_has_product_existing_instances(name) for name in related_product_names)
 
     return {