orchestrator-core 4.2.0rc1__tar.gz → 4.2.0rc3__tar.gz

{orchestrator_core-4.2.0rc1 → orchestrator_core-4.2.0rc3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orchestrator-core
-Version: 4.2.0rc1
+Version: 4.2.0rc3
 Summary: This is the orchestrator workflow engine.
 Author-email: SURF <automation-beheer@surf.nl>
 Requires-Python: >=3.11,<3.14

{orchestrator_core-4.2.0rc1 → orchestrator_core-4.2.0rc3}/orchestrator/__init__.py

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

{orchestrator_core-4.2.0rc1 → orchestrator_core-4.2.0rc3}/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
@@ -212,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")
 

{orchestrator_core-4.2.0rc1 → orchestrator_core-4.2.0rc3}/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.0rc3/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.2.0rc1 → orchestrator_core-4.2.0rc3}/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.2.0rc1 → orchestrator_core-4.2.0rc3}/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 {

{orchestrator_core-4.2.0rc1 → orchestrator_core-4.2.0rc3}/orchestrator/cli/domain_gen_helpers/types.py

@@ -1,8 +1,14 @@
 from pydantic import BaseModel
+from typing_extensions import TypedDict
 
 from orchestrator.domain.base import ProductBlockModel, SubscriptionModel
 
 
+class BlockRelationDict(TypedDict):
+    name: str
+    attribute_name: str
+
+
 class DomainModelChanges(BaseModel):
     create_products: dict[str, type[SubscriptionModel]] = {}
     delete_products: set[str] = set()
@@ -10,7 +16,7 @@ class DomainModelChanges(BaseModel):
     delete_product_to_block_relations: dict[str, set[str]] = {}
     create_product_blocks: dict[str, type[ProductBlockModel]] = {}
     delete_product_blocks: set[str] = set()
-    create_product_block_relations: dict[str, set[str]] = {}
+    create_product_block_relations: dict[str, list[BlockRelationDict]] = {}
     delete_product_block_relations: dict[str, set[str]] = {}
     create_product_fixed_inputs: dict[str, set[str]] = {}
     update_product_fixed_inputs: dict[str, dict[str, str]] = {}

{orchestrator_core-4.2.0rc1 → orchestrator_core-4.2.0rc3}/orchestrator/cli/migrate_domain_models.py

@@ -21,6 +21,7 @@ from orchestrator.cli.domain_gen_helpers.fixed_input_helpers import (
 from orchestrator.cli.domain_gen_helpers.helpers import (
     map_create_fixed_inputs,
     map_create_product_block_relations,
+    map_create_product_to_product_block_relations,
     map_create_resource_type_relations,
     map_delete_fixed_inputs,
     map_delete_product_block_relations,
@@ -191,6 +192,7 @@ def map_changes(
     db_product_names: list[str],
     inputs: dict[str, dict[str, str]],
     updates: ModelUpdates | None,
+    confirm_warnings: bool,
 ) -> DomainModelChanges:
     """Map changes that need to be made to fix differences between models and database.
 
@@ -203,6 +205,7 @@ def map_changes(
         db_product_names: Product names out of the database.
         inputs: Optional Dict with prefilled values.
         updates: Optional Dict.
+        confirm_warnings: confirm warnings to continue, fully knowing that things can go wrong.
 
     Returns: Mapped changes.
     """
@@ -231,7 +234,7 @@ def map_changes(
         create_product_fixed_inputs=map_create_fixed_inputs(model_diffs["products"]),
         update_product_fixed_inputs=updates.fixed_inputs,
         delete_product_fixed_inputs=map_delete_fixed_inputs(model_diffs["products"]),
-        create_product_to_block_relations=map_create_product_block_relations(model_diffs["products"]),
+        create_product_to_block_relations=map_create_product_to_product_block_relations(model_diffs["products"]),
         delete_product_to_block_relations=map_delete_product_block_relations(model_diffs["products"]),
         rename_resource_types=updates.resource_types,
         update_block_resource_types=updates.block_resource_types,
@@ -242,12 +245,14 @@ def map_changes(
         delete_resource_type_relations=delete_resource_type_relations,
         create_product_blocks=map_create_product_blocks(product_blocks),
         delete_product_blocks=map_delete_product_blocks(product_blocks),
-        create_product_block_relations=map_create_product_block_relations(model_diffs["blocks"]),
+        create_product_block_relations=map_create_product_block_relations(
+            model_diffs["blocks"], product_blocks, confirm_warnings
+        ),
         delete_product_block_relations=map_delete_product_block_relations(model_diffs["blocks"]),
     )
 
     changes = map_product_additional_relations(changes)
-    changes = map_product_block_additional_relations(changes)
+    changes = map_product_block_additional_relations(changes, product_blocks, confirm_warnings)
     temp = {key for v in changes.update_block_resource_types.values() for key in v.values()}
     related_resource_type_names = set(changes.create_resource_type_relations.keys()) | temp
     existing_renamed_rts = set(changes.rename_resource_types.values())
@@ -334,8 +339,12 @@ def generate_downgrade_sql(changes: DomainModelChanges) -> list[str]:
     sql_revert_create_product_product_block_relations = generate_delete_product_relations_sql(
         changes.create_product_to_block_relations,
     )
+
+    downgrade_block_relations = {
+        k: {b["name"] for b in blocks} for k, blocks in changes.create_product_block_relations.items()
+    }
     sql_revert_create_product_block_depends_blocks = generate_delete_product_block_relations_sql(
-        changes.create_product_block_relations
+        downgrade_block_relations
     )
 
     sql_revert_create_product_blocks = generate_delete_product_blocks_sql(set(changes.create_product_blocks.keys()))
@@ -361,6 +370,7 @@ def create_domain_models_migration_sql(
     inputs: dict[str, dict[str, str]],
     updates: ModelUpdates | None,
     is_test: bool = False,
+    confirm_warnings: bool = False,
 ) -> tuple[list[str], list[str]]:
     """Create tuple with list for upgrade and downgrade SQL statements based on SubscriptionModel.diff_product_in_database.
 
@@ -370,6 +380,7 @@ def create_domain_models_migration_sql(
         inputs: dict with pre-defined input values
         updates: The model
         is_test: the bool for if it is test
+        confirm_warnings: confirm warnings to continue, fully knowing that things can go wrong.
 
     Returns tuple:
         list of upgrade SQL statements in string format.
@@ -384,7 +395,7 @@ def create_domain_models_migration_sql(
     product_blocks = map_product_blocks(list(SUBSCRIPTION_MODEL_REGISTRY.values()))
     model_diffs = map_differences_unique(products, existing_products)
 
-    changes = map_changes(model_diffs, products, product_blocks, db_product_names, inputs, updates)
+    changes = map_changes(model_diffs, products, product_blocks, db_product_names, inputs, updates, confirm_warnings)
 
     logger.info("create_products", create_products=changes.create_products)
     logger.info("delete_products", delete_products=changes.delete_products)

{orchestrator_core-4.2.0rc1 → orchestrator_core-4.2.0rc3}/orchestrator/services/settings_env_variables.py

@@ -14,7 +14,7 @@
 from typing import Any, Dict, Type
 
 from pydantic import SecretStr as PydanticSecretStr
-from pydantic_core import MultiHostUrl
+from pydantic_core import MultiHostUrl, Url
 from pydantic_settings import BaseSettings
 
 from orchestrator.utils.expose_settings import SecretStr as OrchSecretStr
@@ -32,21 +32,9 @@ def expose_settings(settings_name: str, base_settings: Type[BaseSettings]) -> Ty
 
 def mask_value(key: str, value: Any) -> Any:
     key_lower = key.lower()
+    is_sensitive_key = "secret" in key_lower or "password" in key_lower
 
-    if "secret" in key_lower or "password" in key_lower:
-        # Mask sensitive information
-        return MASK
-
-    if isinstance(value, PydanticSecretStr):
-        # Need to convert SecretStr to str for serialization
-        return str(value)
-
-    if isinstance(value, OrchSecretStr):
-        return MASK
-
-    # PostgresDsn is just MultiHostUrl with extra metadata (annotations)
-    if isinstance(value, MultiHostUrl):
-        # Convert PostgresDsn to str for serialization
+    if is_sensitive_key or isinstance(value, (OrchSecretStr, PydanticSecretStr, MultiHostUrl, Url)):
         return MASK
 
     return value

{orchestrator_core-4.2.0rc1 → orchestrator_core-4.2.0rc3}/orchestrator/settings.py

@@ -72,7 +72,7 @@ class AppSettings(BaseSettings):
     TRACING_ENABLED: bool = False
     TRACE_HOST: str = "http://localhost:4317"
     TRANSLATIONS_DIR: Path | None = None
-    WEBSOCKET_BROADCASTER_URL: str = "memory://"
+    WEBSOCKET_BROADCASTER_URL: OrchSecretStr = "memory://"  # type: ignore
     ENABLE_WEBSOCKETS: bool = True
     DISABLE_INSYNC_CHECK: bool = False
     DEFAULT_PRODUCT_WORKFLOWS: list[str] = ["modify_note"]

{orchestrator_core-4.2.0rc1 → orchestrator_core-4.2.0rc3}/orchestrator/utils/errors.py

@@ -128,12 +128,13 @@ def _(err: Exception) -> ErrorDict:
     # We can't dispatch on ApiException, see is_api_exception docstring
     if is_api_exception(err):
         err = cast(ApiException, err)
+        headers = err.headers or {}
         return {
             "class": type(err).__name__,
             "error": err.reason,
             "status_code": err.status,
             "body": err.body,
-            "headers": "\n".join(f"{k}: {v}" for k, v in err.headers.items()),
+            "headers": "\n".join(f"{k}: {v}" for k, v in headers.items()),
             "traceback": show_ex(err),
         }
 

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

@@ -1,55 +0,0 @@
-from collections.abc import Iterable
-from itertools import groupby
-
-import structlog
-from sqlalchemy.dialects import postgresql
-from sqlalchemy.sql.dml import UpdateBase
-
-from orchestrator.domain.base import ProductBlockModel
-
-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_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 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))