Finished feature init-tox-config.

.gitignore

 __pycache__
 *.egg-info
+.coverage
+coverage.xml

geant_service_orchestrator/main.py

@@ -2,8 +2,8 @@ from orchestrator import OrchestratorCore
 from orchestrator.cli.main import app as core_cli
 from orchestrator.settings import AppSettings
 
-import products
-import workflows
+# from geant_service_orchestrator import products
+# from geant_service_orchestrator import workflows
 
 app = OrchestratorCore(base_settings=AppSettings())
 

geant_service_orchestrator/products/__init__.py

 from orchestrator.domain import SUBSCRIPTION_MODEL_REGISTRY
 
-from products.product_types.trunk import Trunk
-from products.product_types.trunk_config import TrunkConfig
-from products.product_types.trunk_config_common import TrunkConfigCommon
-from products.product_types.trunk_config_side import TrunkConfigSide
+from geant_service_orchestrator.products.product_types.trunk \
+    import Trunk
+from geant_service_orchestrator.products.product_types.trunk_config \
+    import TrunkConfig
+from geant_service_orchestrator.products.product_types.trunk_config_common \
+    import TrunkConfigCommon
+from geant_service_orchestrator.products.product_types.trunk_config_side \
+    import TrunkConfigSide
 
 SUBSCRIPTION_MODEL_REGISTRY.update(
     {

geant_service_orchestrator/products/product_blocks/trunk.py

@@ -4,19 +4,26 @@ from orchestrator.domain.base import ProductBlockModel
 from orchestrator.types import SubscriptionLifecycle
 
 
-class TrunkBlockInactive(ProductBlockModel, lifecycle=[SubscriptionLifecycle.INITIAL], product_block_name="TrunkBlock"):
+class TrunkBlockInactive(
+        ProductBlockModel,
+        lifecycle=[SubscriptionLifecycle.INITIAL],
+        product_block_name="TrunkBlock"):
     trunk_id: Optional[int] = None
     geant_s_sid: Optional[str] = None
     trunk_name: Optional[str] = None
 
 
-class TrunkBlockProvisioning(TrunkBlockInactive, lifecycle=[SubscriptionLifecycle.PROVISIONING]):
+class TrunkBlockProvisioning(
+        TrunkBlockInactive,
+        lifecycle=[SubscriptionLifecycle.PROVISIONING]):
     trunk_id: Optional[int] = None
     geant_s_sid: Optional[str] = None
     trunk_name: str
 
 
-class TrunkBlock(TrunkBlockProvisioning, lifecycle=[SubscriptionLifecycle.ACTIVE]):
+class TrunkBlock(
+        TrunkBlockProvisioning,
+        lifecycle=[SubscriptionLifecycle.ACTIVE]):
     trunk_id: int
     geant_s_sid: str
     trunk_name: str

geant_service_orchestrator/products/product_blocks/trunk_config.py

@@ -3,19 +3,27 @@ from typing import Optional
 from orchestrator.domain.base import ProductBlockModel
 from orchestrator.types import SubscriptionLifecycle
 
-from products.product_blocks.trunk import TrunkBlock, TrunkBlockInactive, TrunkBlockProvisioning
+from geant_service_orchestrator.products.product_blocks.trunk \
+    import TrunkBlock, TrunkBlockInactive, TrunkBlockProvisioning
 
 
-class TrunkConfigBlockInactive(ProductBlockModel, lifecycle=[SubscriptionLifecycle.INITIAL], product_block_name="TrunkConfigBlock"):
+class TrunkConfigBlockInactive(
+        ProductBlockModel,
+        lifecycle=[SubscriptionLifecycle.INITIAL],
+        product_block_name="TrunkConfigBlock"):
     trunk: TrunkBlockInactive
     trunk_config_id: Optional[int] = None
 
 
-class TrunkConfigBlockProvisioning(TrunkConfigBlockInactive, lifecycle=[SubscriptionLifecycle.PROVISIONING]):
+class TrunkConfigBlockProvisioning(
+        TrunkConfigBlockInactive,
+        lifecycle=[SubscriptionLifecycle.PROVISIONING]):
     trunk: TrunkBlockProvisioning
     trunk_config_id: Optional[int] = None
 
 
-class TrunkConfigBlock(TrunkConfigBlockProvisioning, lifecycle=[SubscriptionLifecycle.ACTIVE]):
+class TrunkConfigBlock(
+        TrunkConfigBlockProvisioning,
+        lifecycle=[SubscriptionLifecycle.ACTIVE]):
     trunk: TrunkBlock
     trunk_config_id: int

geant_service_orchestrator/products/product_blocks/trunk_config_common.py

@@ -3,10 +3,15 @@ from typing import Optional
 from orchestrator.domain.base import ProductBlockModel
 from orchestrator.types import SubscriptionLifecycle
 
-from products.product_blocks.trunk_config import TrunkConfigBlock, TrunkConfigBlockInactive, TrunkConfigBlockProvisioning
+from geant_service_orchestrator.products.product_blocks.trunk_config \
+    import TrunkConfigBlock, TrunkConfigBlockInactive, \
+    TrunkConfigBlockProvisioning
 
 
-class TrunkConfigCommonBlockInactive(ProductBlockModel, lifecycle=[SubscriptionLifecycle.INITIAL], product_block_name="TrunkConfigCommonBlock"):
+class TrunkConfigCommonBlockInactive(
+        ProductBlockModel,
+        lifecycle=[SubscriptionLifecycle.INITIAL],
+        product_block_name="TrunkConfigCommonBlock"):
     trunk_config: TrunkConfigBlockInactive
     trunk_config_common_id: Optional[int] = None
     speed: Optional[str] = None
@@ -15,7 +20,9 @@ class TrunkConfigCommonBlockInactive(ProductBlockModel, lifecycle=[SubscriptionL
     minimum_links: Optional[int] = None
 
 
-class TrunkConfigCommonBlockProvisioning(TrunkConfigCommonBlockInactive, lifecycle=[SubscriptionLifecycle.PROVISIONING]):
+class TrunkConfigCommonBlockProvisioning(
+        TrunkConfigCommonBlockInactive,
+        lifecycle=[SubscriptionLifecycle.PROVISIONING]):
     trunk_config: TrunkConfigBlockProvisioning
     trunk_config_common_id: Optional[int] = None
     speed: str
@@ -24,7 +31,9 @@ class TrunkConfigCommonBlockProvisioning(TrunkConfigCommonBlockInactive, lifecyc
     minimum_links: int
 
 
-class TrunkConfigCommonBlock(TrunkConfigCommonBlockProvisioning, lifecycle=[SubscriptionLifecycle.ACTIVE]):
+class TrunkConfigCommonBlock(
+        TrunkConfigCommonBlockProvisioning,
+        lifecycle=[SubscriptionLifecycle.ACTIVE]):
     trunk_config: TrunkConfigBlock
     trunk_config_common_id: int
     speed: str

geant_service_orchestrator/products/product_blocks/trunk_config_side.py

@@ -3,10 +3,15 @@ from typing import Optional
 from orchestrator.domain.base import ProductBlockModel
 from orchestrator.types import SubscriptionLifecycle
 
-from products.product_blocks.trunk_config import TrunkConfigBlock, TrunkConfigBlockInactive, TrunkConfigBlockProvisioning
+from geant_service_orchestrator.products.product_blocks.trunk_config \
+    import TrunkConfigBlock, TrunkConfigBlockInactive,\
+    TrunkConfigBlockProvisioning
 
 
-class TrunkConfigSideBlockInactive(ProductBlockModel, lifecycle=[SubscriptionLifecycle.INITIAL], product_block_name="TrunkConfigSideBlock"):
+class TrunkConfigSideBlockInactive(
+        ProductBlockModel,
+        lifecycle=[SubscriptionLifecycle.INITIAL],
+        product_block_name="TrunkConfigSideBlock"):
     trunk_config: TrunkConfigBlockInactive
     trunk_config_side_id: Optional[int] = None
     fqdn: Optional[str] = None
@@ -17,7 +22,9 @@ class TrunkConfigSideBlockInactive(ProductBlockModel, lifecycle=[SubscriptionLif
     members: Optional[list] = None
 
 
-class TrunkConfigSideBlockProvisioning(TrunkConfigSideBlockInactive, lifecycle=[SubscriptionLifecycle.PROVISIONING]):
+class TrunkConfigSideBlockProvisioning(
+        TrunkConfigSideBlockInactive,
+        lifecycle=[SubscriptionLifecycle.PROVISIONING]):
     trunk_config: TrunkConfigBlockProvisioning
     trunk_config_side_id: Optional[int] = None
     fqdn: str
@@ -28,7 +35,9 @@ class TrunkConfigSideBlockProvisioning(TrunkConfigSideBlockInactive, lifecycle=[
     members: Optional[list] = None
 
 
-class TrunkConfigSideBlock(TrunkConfigSideBlockProvisioning, lifecycle=[SubscriptionLifecycle.ACTIVE]):
+class TrunkConfigSideBlock(
+        TrunkConfigSideBlockProvisioning,
+        lifecycle=[SubscriptionLifecycle.ACTIVE]):
     trunk_config: TrunkConfigBlock
     trunk_config_side_id: int
     fqdn: str

geant_service_orchestrator/products/product_types/trunk.py

 from orchestrator.domain.base import SubscriptionModel
 from orchestrator.types import SubscriptionLifecycle
 
-from products.product_blocks.trunk import TrunkBlock, TrunkBlockInactive, TrunkBlockProvisioning
+from geant_service_orchestrator.products.product_blocks.trunk \
+    import TrunkBlock, TrunkBlockInactive, TrunkBlockProvisioning
 
 
-class TrunkInactive(SubscriptionModel, is_base=True, lifecycle=[SubscriptionLifecycle.INITIAL]):
+class TrunkInactive(
+        SubscriptionModel, is_base=True,
+        lifecycle=[SubscriptionLifecycle.INITIAL]):
     trunk: TrunkBlockInactive
 
 
-class TrunkProvisioning(TrunkInactive, lifecycle=[SubscriptionLifecycle.PROVISIONING]):
+class TrunkProvisioning(
+        TrunkInactive,
+        lifecycle=[SubscriptionLifecycle.PROVISIONING]):
     trunk: TrunkBlockProvisioning
 
 
-class Trunk(TrunkProvisioning, lifecycle=[SubscriptionLifecycle.ACTIVE]):
+class Trunk(
+        TrunkProvisioning,
+        lifecycle=[SubscriptionLifecycle.ACTIVE]):
     trunk: TrunkBlock

geant_service_orchestrator/products/product_types/trunk_config.py

 from orchestrator.domain.base import SubscriptionModel
 from orchestrator.types import SubscriptionLifecycle
 
-from products.product_blocks.trunk_config import TrunkConfigBlock, TrunkConfigBlockInactive, TrunkConfigBlockProvisioning
+from geant_service_orchestrator.products.product_blocks.trunk_config \
+    import TrunkConfigBlock, TrunkConfigBlockInactive,\
+    TrunkConfigBlockProvisioning
 
 
-class TrunkConfigInactive(SubscriptionModel, is_base=True, lifecycle=[SubscriptionLifecycle.INITIAL]):
+class TrunkConfigInactive(
+        SubscriptionModel,
+        is_base=True, lifecycle=[SubscriptionLifecycle.INITIAL]):
     trunk_config: TrunkConfigBlockInactive
 
 
-class TrunkConfigProvisioning(TrunkConfigInactive, lifecycle=[SubscriptionLifecycle.PROVISIONING]):
+class TrunkConfigProvisioning(
+        TrunkConfigInactive,
+        lifecycle=[SubscriptionLifecycle.PROVISIONING]):
     trunk_config: TrunkConfigBlockProvisioning
 
 
-class TrunkConfig(TrunkConfigProvisioning, lifecycle=[SubscriptionLifecycle.ACTIVE]):
+class TrunkConfig(
+        TrunkConfigProvisioning,
+        lifecycle=[SubscriptionLifecycle.ACTIVE]):
     trunk_config: TrunkConfigBlock

geant_service_orchestrator/products/product_types/trunk_config_common.py

 from orchestrator.domain.base import SubscriptionModel
 from orchestrator.types import SubscriptionLifecycle
 
-from products.product_blocks.trunk_config_common import TrunkConfigCommonBlock, TrunkConfigCommonBlockInactive, TrunkConfigCommonBlockProvisioning
+from geant_service_orchestrator.products.product_blocks.trunk_config_common \
+    import TrunkConfigCommonBlock, TrunkConfigCommonBlockInactive, \
+    TrunkConfigCommonBlockProvisioning
 
 
-class TrunkConfigCommonInactive(SubscriptionModel, is_base=True, lifecycle=[SubscriptionLifecycle.INITIAL]):
+class TrunkConfigCommonInactive(
+        SubscriptionModel,
+        is_base=True,
+        lifecycle=[SubscriptionLifecycle.INITIAL]):
     trunk_config_common: TrunkConfigCommonBlockInactive
 
 
-class TrunkConfigCommonProvisioning(TrunkConfigCommonInactive, lifecycle=[SubscriptionLifecycle.PROVISIONING]):
+class TrunkConfigCommonProvisioning(
+        TrunkConfigCommonInactive,
+        lifecycle=[SubscriptionLifecycle.PROVISIONING]):
     trunk_config_common: TrunkConfigCommonBlockProvisioning
 
 
-class TrunkConfigCommon(TrunkConfigCommonProvisioning, lifecycle=[SubscriptionLifecycle.ACTIVE]):
+class TrunkConfigCommon(
+        TrunkConfigCommonProvisioning,
+        lifecycle=[SubscriptionLifecycle.ACTIVE]):
     trunk_config_common: TrunkConfigCommonBlock

geant_service_orchestrator/products/product_types/trunk_config_side.py

 from orchestrator.domain.base import SubscriptionModel
 from orchestrator.types import SubscriptionLifecycle
 
-from products.product_blocks.trunk_config_side import TrunkConfigSideBlock, TrunkConfigSideBlockInactive, TrunkConfigSideBlockProvisioning
+from geant_service_orchestrator.products.product_blocks.trunk_config_side \
+    import TrunkConfigSideBlock, TrunkConfigSideBlockInactive, \
+    TrunkConfigSideBlockProvisioning
 
 
-class TrunkConfigSideInactive(SubscriptionModel, is_base=True, lifecycle=[SubscriptionLifecycle.INITIAL]):
+class TrunkConfigSideInactive(
+        SubscriptionModel,
+        is_base=True,
+        lifecycle=[SubscriptionLifecycle.INITIAL]):
     trunk_config_side: TrunkConfigSideBlockInactive
 
 
-class TrunkConfigSideProvisioning(TrunkConfigSideInactive, lifecycle=[SubscriptionLifecycle.PROVISIONING]):
+class TrunkConfigSideProvisioning(
+        TrunkConfigSideInactive,
+        lifecycle=[SubscriptionLifecycle.PROVISIONING]):
     trunk_config_side: TrunkConfigSideBlockProvisioning
 
 
-class TrunkConfigSide(TrunkConfigSideProvisioning, lifecycle=[SubscriptionLifecycle.ACTIVE]):
+class TrunkConfigSide(
+        TrunkConfigSideProvisioning,
+        lifecycle=[SubscriptionLifecycle.ACTIVE]):
     trunk_config_side: TrunkConfigSideBlock

geant_service_orchestrator/workflows/__init__.py

 from orchestrator.workflows import LazyWorkflowInstance
 
-LazyWorkflowInstance("workflows.trunk.create_trunk", "create_trunk")
-LazyWorkflowInstance("workflows.trunk_config.create_trunk_config", "create_trunk_config")
-LazyWorkflowInstance("workflows.trunk_config_common.create_trunk_config_common", "create_trunk_config_common")
-LazyWorkflowInstance("workflows.trunk_config_side.create_trunk_config_side", "create_trunk_config_side")
-LazyWorkflowInstance("workflows.trunk.terminate_trunk", "terminate_trunk")
-LazyWorkflowInstance("workflows.trunk_config.terminate_trunk_config", "terminate_trunk_config")
-LazyWorkflowInstance("workflows.trunk_config_common.terminate_trunk_config_common", "terminate_trunk_config_common")
-LazyWorkflowInstance("workflows.trunk_config_side.terminate_trunk_config_side", "terminate_trunk_config_side")
+LazyWorkflowInstance(
+    "workflows.trunk.create_trunk",
+    "create_trunk")
+LazyWorkflowInstance(
+    "workflows.trunk_config.create_trunk_config",
+    "create_trunk_config")
+LazyWorkflowInstance(
+    "workflows.trunk_config_common.create_trunk_config_common",
+    "create_trunk_config_common")
+LazyWorkflowInstance(
+    "workflows.trunk_config_side.create_trunk_config_side",
+    "create_trunk_config_side")
+LazyWorkflowInstance(
+    "workflows.trunk.terminate_trunk",
+    "terminate_trunk")
+LazyWorkflowInstance(
+    "workflows.trunk_config.terminate_trunk_config",
+    "terminate_trunk_config")
+LazyWorkflowInstance(
+    "workflows.trunk_config_common.terminate_trunk_config_common",
+    "terminate_trunk_config_common")
+LazyWorkflowInstance(
+    "workflows.trunk_config_side.terminate_trunk_config_side",
+    "terminate_trunk_config_side")

geant_service_orchestrator/workflows/trunk/create_trunk.py

@@ -3,12 +3,15 @@ from uuid import uuid4
 
 from orchestrator.forms import FormPage
 from orchestrator.targets import Target
-from orchestrator.types import FormGenerator, State, SubscriptionLifecycle, UUIDstr
+from orchestrator.types \
+    import FormGenerator, State, SubscriptionLifecycle, UUIDstr
 from orchestrator.workflow import done, init, step, workflow
-from orchestrator.workflows.steps import resync, set_status, store_process_subscription
+from orchestrator.workflows.steps \
+    import resync, set_status, store_process_subscription
 from orchestrator.workflows.utils import wrap_create_initial_input_form
 
-from products.product_types.trunk import TrunkInactive, TrunkProvisioning
+from geant_service_orchestrator.products.product_types.trunk \
+    import TrunkInactive, TrunkProvisioning
 
 
 def initial_input_form_generator(product_name: str) -> FormGenerator:
@@ -33,21 +36,30 @@ def _provision_in_gap(trunk_name: str) -> int:
 def create_subscription(product: UUIDstr) -> State:
     subscription = TrunkInactive.from_product_id(product, uuid4())
 
-    return {"subscription": subscription, "subscription_id": subscription.subscription_id}
+    return {
+        "subscription": subscription,
+        "subscription_id": subscription.subscription_id
+    }
 
 
 @step("Initialize subscription")
-def initialize_subscription(subscription: TrunkInactive, trunk_name: str, geant_s_sid: str) -> State:
+def initialize_subscription(
+        subscription: TrunkInactive,
+        trunk_name: str,
+        geant_s_sid: str) -> State:
     subscription.trunk.trunk_name = trunk_name
     subscription.trunk.geant_s_sid = geant_s_sid
     subscription.description = f"Trunk {trunk_name}"
-    subscription = TrunkProvisioning.from_other_lifecycle(subscription, SubscriptionLifecycle.PROVISIONING)
+    subscription = TrunkProvisioning.from_other_lifecycle(
+        subscription, SubscriptionLifecycle.PROVISIONING)
 
     return {"subscription": subscription}
 
 
 @step("Provision trunk")
-def provision_trunk(subscription: TrunkProvisioning, trunk_name: str) -> State:
+def provision_trunk(
+        subscription: TrunkProvisioning,
+        trunk_name: str) -> State:
     trunk_id = _provision_in_gap(trunk_name)
     subscription.trunk.trunk_id = trunk_id
 
@@ -56,7 +68,7 @@ def provision_trunk(subscription: TrunkProvisioning, trunk_name: str) -> State:
 
 @workflow(
     "Create trunk",
-    initial_input_form=wrap_create_initial_input_form(initial_input_form_generator),
+    initial_input_form=wrap_create_initial_input_form(initial_input_form_generator),  # noqa: E501
     target=Target.CREATE,
 )
 def create_trunk():

geant_service_orchestrator/workflows/trunk/terminate_trunk.py

@@ -3,17 +3,21 @@ from orchestrator.forms.validators import Label
 from orchestrator.targets import Target
 from orchestrator.types import InputForm, SubscriptionLifecycle, UUIDstr
 from orchestrator.workflow import done, init, step, workflow
-from orchestrator.workflows.steps import resync, set_status, store_process_subscription, unsync
+from orchestrator.workflows.steps \
+    import resync, set_status, store_process_subscription, unsync
 from orchestrator.workflows.utils import wrap_modify_initial_input_form
 
-from products import Trunk
+from geant_service_orchestrator.products import Trunk
 
 
-def initial_input_form_generator(subscription_id: UUIDstr, organisation: UUIDstr) -> InputForm:
+def initial_input_form_generator(
+        subscription_id: UUIDstr,
+        organisation: UUIDstr) -> InputForm:
     subscription = Trunk.from_subscription(subscription_id)
 
     class TerminateForm(FormPage):
-        are_you_sure: Label = f"Are you sure you want to remove {subscription.description}?"  # type:ignore
+        are_you_sure: Label = 'Are you sure you want to remove ' \
+                              f'{subscription.description}?'  # type:ignore
 
     return TerminateForm
 
@@ -29,7 +33,7 @@ def deprovision_trunk(subscription: Trunk) -> None:
 
 @workflow(
     "Terminate trunk",
-    initial_input_form=wrap_modify_initial_input_form(initial_input_form_generator),
+    initial_input_form=wrap_modify_initial_input_form(initial_input_form_generator),  # noqa: E501
     target=Target.TERMINATE,
 )
 def terminate_trunk():
@@ -42,4 +46,4 @@ def terminate_trunk():
         >> set_status(SubscriptionLifecycle.TERMINATED)
         >> resync
         >> done
-    )
\ No newline at end of file
+    )

geant_service_orchestrator/workflows/trunk_config/create_trunk_config.py

-from typing import List, Optional
+import random
+from typing import List
 from uuid import uuid4
-from random import randint
 
 from orchestrator.db.models import ProductTable, SubscriptionTable
 from orchestrator.forms import FormPage
 from orchestrator.forms.validators import Choice, choice_list
 from orchestrator.targets import Target
-from orchestrator.types import FormGenerator, State, SubscriptionLifecycle, UUIDstr
+from orchestrator.types \
+    import FormGenerator, State, SubscriptionLifecycle, UUIDstr
 from orchestrator.workflow import done, init, step, workflow
-from orchestrator.workflows.steps import resync, set_status, store_process_subscription
+from orchestrator.workflows.steps \
+    import resync, set_status, store_process_subscription
 from orchestrator.workflows.utils import wrap_create_initial_input_form
 
-from products.product_types.trunk_config import TrunkConfigInactive, TrunkConfigProvisioning
-from products.product_types.trunk import Trunk
+from geant_service_orchestrator.products.product_types.trunk_config \
+    import TrunkConfigInactive, TrunkConfigProvisioning
+from geant_service_orchestrator.products.product_types.trunk \
+    import Trunk
 
 
 def trunk_selector() -> list:
@@ -23,13 +27,17 @@ def trunk_selector() -> list:
             ProductTable.product_type == "Trunk",
             SubscriptionTable.status == "active",
         )
-        .with_entities(SubscriptionTable.subscription_id, SubscriptionTable.description)
+        .with_entities(
+            SubscriptionTable.subscription_id,
+            SubscriptionTable.description)
         .all()
     ):
         trunk_subscriptions[str(trunk_id)] = trunk_description
 
     return choice_list(
-        Choice("TrunkEnum", zip(trunk_subscriptions.keys(), trunk_subscriptions.items())),  # type:ignore
+        Choice("TrunkEnum", zip(
+            trunk_subscriptions.keys(),
+            trunk_subscriptions.items())),  # type:ignore
         min_items=1,
         max_items=1,
     )
@@ -56,20 +64,30 @@ def _provision_in_gap() -> int:
 def create_subscription(product: UUIDstr) -> State:
     subscription = TrunkConfigInactive.from_product_id(product, uuid4())
 
-    return {"subscription": subscription, "subscription_id": subscription.subscription_id}
+    return {
+        "subscription": subscription,
+        "subscription_id": subscription.subscription_id
+    }
 
 
 @step("Initialize subscription")
-def initialize_subscription(subscription: TrunkConfigInactive, trunk_ids: List[str]) -> State:
-    subscription.trunk_config.trunk = Trunk.from_subscription(trunk_ids[0]).trunk
-    subscription.description = f"TrunkConfig from Trunk {subscription.trunk_config.trunk.trunk_name}"
-    subscription = TrunkConfigProvisioning.from_other_lifecycle(subscription, SubscriptionLifecycle.PROVISIONING)
+def initialize_subscription(
+        subscription: TrunkConfigInactive,
+        trunk_ids: List[str]) -> State:
+    subscription.trunk_config.trunk \
+        = Trunk.from_subscription(trunk_ids[0]).trunk
+    subscription.description =\
+        "TrunkConfig from Trunk " \
+        f"{subscription.trunk_config.trunk.trunk_name}"
+    subscription = TrunkConfigProvisioning.from_other_lifecycle(
+        subscription, SubscriptionLifecycle.PROVISIONING)
 
     return {"subscription": subscription}
 
 
 @step("Provision trunk config")
-def provision_trunk_config(subscription: TrunkConfigProvisioning) -> State:
+def provision_trunk_config(
+        subscription: TrunkConfigProvisioning) -> State:
     trunk_config_id = _provision_in_gap()
     subscription.trunk_config.trunk_config_id = trunk_config_id
 
@@ -78,7 +96,7 @@ def provision_trunk_config(subscription: TrunkConfigProvisioning) -> State:
 
 @workflow(
     "Create trunk config",
-    initial_input_form=wrap_create_initial_input_form(initial_input_form_generator),
+    initial_input_form=wrap_create_initial_input_form(initial_input_form_generator),  # noqa: E501
     target=Target.CREATE,
 )
 def create_trunk_config():

geant_service_orchestrator/workflows/trunk_config/terminate_trunk_config.py

@@ -3,17 +3,22 @@ from orchestrator.forms.validators import Label
 from orchestrator.targets import Target
 from orchestrator.types import InputForm, SubscriptionLifecycle, UUIDstr
 from orchestrator.workflow import done, init, step, workflow
-from orchestrator.workflows.steps import resync, set_status, store_process_subscription, unsync
+from orchestrator.workflows.steps \
+    import resync, set_status, store_process_subscription, unsync
 from orchestrator.workflows.utils import wrap_modify_initial_input_form
 
 from products import TrunkConfig
 
 
-def initial_input_form_generator(subscription_id: UUIDstr, organisation: UUIDstr) -> InputForm:
+def initial_input_form_generator(
+        subscription_id: UUIDstr,
+        organisation: UUIDstr) -> InputForm:
     subscription = TrunkConfig.from_subscription(subscription_id)
 
     class TerminateForm(FormPage):
-        are_you_sure: Label = f"Are you sure you want to remove {subscription.description}?"  # type:ignore
+        are_you_sure: Label = \
+            "Are you sure you want to remove " \
+            f"{subscription.description}?"  # type:ignore
 
     return TerminateForm
 
@@ -29,7 +34,7 @@ def deprovision_trunk_config(subscription: TrunkConfig) -> None:
 
 @workflow(
     "Terminate trunk config",
-    initial_input_form=wrap_modify_initial_input_form(initial_input_form_generator),
+    initial_input_form=wrap_modify_initial_input_form(initial_input_form_generator),  # noqa: E501
     target=Target.TERMINATE,
 )
 def terminate_trunk_config():
@@ -42,4 +47,4 @@ def terminate_trunk_config():
         >> set_status(SubscriptionLifecycle.TERMINATED)
         >> resync
         >> done
-    )
\ No newline at end of file
+    )

geant_service_orchestrator/workflows/trunk_config_common/create_trunk_config_common.py

+import random
 from typing import List, Optional
 from uuid import uuid4
 
@@ -5,13 +6,17 @@ from orchestrator.db.models import ProductTable, SubscriptionTable
 from orchestrator.forms import FormPage
 from orchestrator.forms.validators import Choice, choice_list
 from orchestrator.targets import Target
-from orchestrator.types import FormGenerator, State, SubscriptionLifecycle, UUIDstr
+from orchestrator.types \
+    import FormGenerator, State, SubscriptionLifecycle, UUIDstr
 from orchestrator.workflow import done, init, step, workflow
-from orchestrator.workflows.steps import resync, set_status, store_process_subscription
+from orchestrator.workflows.steps \
+    import resync, set_status, store_process_subscription
 from orchestrator.workflows.utils import wrap_create_initial_input_form
 
-from products.product_types.trunk_config_common import TrunkConfigCommonInactive, TrunkConfigCommonProvisioning
-from products.product_types.trunk_config import TrunkConfig
+from geant_service_orchestrator.products.product_types.trunk_config_common \
+    import TrunkConfigCommonInactive, TrunkConfigCommonProvisioning
+from geant_service_orchestrator.products.product_types.trunk_config \
+    import TrunkConfig
 
 
 def trunk_config_selector() -> list:
@@ -22,13 +27,18 @@ def trunk_config_selector() -> list:
             ProductTable.product_type == "TrunkConfig",
             SubscriptionTable.status == "active",
         )
-        .with_entities(SubscriptionTable.subscription_id, SubscriptionTable.description)
+        .with_entities(
+            SubscriptionTable.subscription_id,
+            SubscriptionTable.description)
         .all()
     ):
-        trunk_config_subscriptions[str(trunk_config_id)] = trunk_config_description
+        trunk_config_subscriptions[
+            str(trunk_config_id)] = trunk_config_description
 
     return choice_list(
-        Choice("TrunkConfigEnum", zip(trunk_config_subscriptions.keys(), trunk_config_subscriptions.items())),  # type:ignore
+        Choice("TrunkConfigEnum", zip(
+            trunk_config_subscriptions.keys(),
+            trunk_config_subscriptions.items())),  # type:ignore
         min_items=1,
         max_items=1,
     )
@@ -38,15 +48,13 @@ def initial_input_form_generator(product_name: str) -> FormGenerator:
     class CreateTrunkConfigForm(FormPage):
         class Config:
             title = product_name
-
         speed: str
         is_leased_line: Optional[bool]
         isis_metric: int
         minimum_links: int
         trunk_config_ids: trunk_config_selector()  # type:ignore
 
-    user_input = yield CreateTrunkConfigCommonForm
-
+    user_input = yield CreateTrunkConfigForm
     return user_input.dict()
 
 
@@ -57,35 +65,52 @@ def _provision_in_gap() -> int:
 
 @step("Create subscription")
 def create_subscription(product: UUIDstr) -> State:
-    subscription = TrunkConfigCommonInactive.from_product_id(product, uuid4())
+    subscription \
+        = TrunkConfigCommonInactive.from_product_id(product, uuid4())
 
-    return {"subscription": subscription, "subscription_id": subscription.subscription_id}
+    return {
+        "subscription": subscription,
+        "subscription_id": subscription.subscription_id
+    }
 
 
 @step("Initialize subscription")
-def initialize_subscription(subscription: TrunkConfigCommonInactive, speed: str, is_leased_line: bool, isis_metric: int, minimum_links: int, trunk_config_ids: List[str]) -> State:
+def initialize_subscription(
+        subscription: TrunkConfigCommonInactive,
+        speed: str,
+        is_leased_line: bool,
+        isis_metric: int,
+        minimum_links: int,
+        trunk_config_ids: List[str]) -> State:
     subscription.trunk_config_common.speed = speed
     subscription.trunk_config_common.is_leased_line = is_leased_line
     subscription.trunk_config_common.isis_metric = isis_metric
     subscription.trunk_config_common.minimum_links = minimum_links
-    subscription.trunk_config_common.trunk_config = TrunkConfig.from_subscription(trunk_config_ids[0]).trunk_config
-    subscription.description = f"TrunkConfigCommon from TrunkConfig {subscription.trunk_config_common.trunk_config.trunk_config_id}"
-    subscription = TrunkConfigCommonProvisioning.from_other_lifecycle(subscription, SubscriptionLifecycle.PROVISIONING)
+    subscription.trunk_config_common.trunk_config \
+        = TrunkConfig.from_subscription(
+            trunk_config_ids[0]).trunk_config
+    subscription.description = \
+        "TrunkConfigCommon from TrunkConfig " \
+        f"{subscription.trunk_config_common.trunk_config.trunk_config_id}"
+    subscription = TrunkConfigCommonProvisioning.from_other_lifecycle(
+        subscription, SubscriptionLifecycle.PROVISIONING)
 
     return {"subscription": subscription}
 
 
 @step("Provision trunk config common")
-def provision_trunk_config_common(subscription: TrunkConfigCommonProvisioning) -> State:
+def provision_trunk_config_common(
+        subscription: TrunkConfigCommonProvisioning) -> State:
     trunk_config_common_id = _provision_in_gap()
-    subscription.trunk_config_common.trunk_config_common_id = trunk_config_common_id
+    subscription.trunk_config_common.trunk_config_common_id \
+        = trunk_config_common_id
 
     return {"subscription": subscription}
 
 
 @workflow(
     "Create trunk config common",
-    initial_input_form=wrap_create_initial_input_form(initial_input_form_generator),
+    initial_input_form=wrap_create_initial_input_form(initial_input_form_generator),  # noqa: E501
     target=Target.CREATE,
 )
 def create_trunk_config_common():

geant_service_orchestrator/workflows/trunk_config_common/terminate_trunk_config_common.py

@@ -3,17 +3,22 @@ from orchestrator.forms.validators import Label
 from orchestrator.targets import Target
 from orchestrator.types import InputForm, SubscriptionLifecycle, UUIDstr
 from orchestrator.workflow import done, init, step, workflow
-from orchestrator.workflows.steps import resync, set_status, store_process_subscription, unsync
+from orchestrator.workflows.steps \
+    import resync, set_status, store_process_subscription, unsync
 from orchestrator.workflows.utils import wrap_modify_initial_input_form
 
-from products import TrunkConfigCommon
+from geant_service_orchestrator.products import TrunkConfigCommon
 
 
-def initial_input_form_generator(subscription_id: UUIDstr, organisation: UUIDstr) -> InputForm:
+def initial_input_form_generator(
+        subscription_id: UUIDstr,
+        organisation: UUIDstr) -> InputForm:
     subscription = TrunkConfigCommon.from_subscription(subscription_id)
 
     class TerminateForm(FormPage):
-        are_you_sure: Label = f"Are you sure you want to remove {subscription.description}?"  # type:ignore
+        are_you_sure: Label = \
+            "Are you sure you want to remove " \
+            f"{subscription.description}?"  # type:ignore
 
     return TerminateForm
 
@@ -23,13 +28,15 @@ def _deprovision_in_gap(trunk_config_common_id: int) -> int:
 
 
 @step("Deprovision trunk config common")
-def deprovision_trunk_config_common(subscription: TrunkConfigCommon) -> None:
-    _deprovision_in_gap(subscription.trunk_config_common.trunk_config_common_id)
+def deprovision_trunk_config_common(
+        subscription: TrunkConfigCommon) -> None:
+    _deprovision_in_gap(
+        subscription.trunk_config_common.trunk_config_common_id)
 
 
 @workflow(
     "Terminate trunk config common",
-    initial_input_form=wrap_modify_initial_input_form(initial_input_form_generator),
+    initial_input_form=wrap_modify_initial_input_form(initial_input_form_generator),  # noqa: E501
     target=Target.TERMINATE,
 )
 def terminate_trunk_config_common():
@@ -42,4 +49,4 @@ def terminate_trunk_config_common():
         >> set_status(SubscriptionLifecycle.TERMINATED)
         >> resync
         >> done
-    )
\ No newline at end of file
+    )

geant_service_orchestrator/workflows/trunk_config_side/create_trunk_config_side.py

@@ -5,13 +5,17 @@ from orchestrator.db.models import ProductTable, SubscriptionTable
 from orchestrator.forms import FormPage
 from orchestrator.forms.validators import Choice, choice_list
 from orchestrator.targets import Target
-from orchestrator.types import FormGenerator, State, SubscriptionLifecycle, UUIDstr
+from orchestrator.types \
+    import FormGenerator, State, SubscriptionLifecycle, UUIDstr
 from orchestrator.workflow import done, init, step, workflow
-from orchestrator.workflows.steps import resync, set_status, store_process_subscription
+from orchestrator.workflows.steps \
+    import resync, set_status, store_process_subscription
 from orchestrator.workflows.utils import wrap_create_initial_input_form
 
-from products.product_types.trunk_config_side import TrunkConfigSideInactive, TrunkConfigSideProvisioning
-from products.product_types.trunk_config import TrunkConfig
+from geant_service_orchestrator.products.product_types.trunk_config_side \
+    import TrunkConfigSideInactive, TrunkConfigSideProvisioning
+from geant_service_orchestrator.products.product_types.trunk_config \
+    import TrunkConfig
 
 
 def trunk_config_selector() -> list:
@@ -22,20 +26,25 @@ def trunk_config_selector() -> list:
             ProductTable.product_type == "TrunkConfig",
             SubscriptionTable.status == "active",
         )
-        .with_entities(SubscriptionTable.subscription_id, SubscriptionTable.description)
+        .with_entities(
+            SubscriptionTable.subscription_id,
+            SubscriptionTable.description)
         .all()
     ):
-        trunk_config_subscriptions[str(trunk_config_id)] = trunk_config_description
+        trunk_config_subscriptions[
+            str(trunk_config_id)] = trunk_config_description
 
     return choice_list(
-        Choice("TrunkConfigEnum", zip(trunk_config_subscriptions.keys(), trunk_config_subscriptions.items())),  # type:ignore
+        Choice("TrunkConfigEnum", zip(
+            trunk_config_subscriptions.keys(),
+            trunk_config_subscriptions.items())),  # type:ignore
         min_items=1,
         max_items=1,
     )
 
 
 def initial_input_form_generator(product_name: str) -> FormGenerator:
-    class CreateTrunkConfigForm(FormPage):
+    class CreateTrunkConfigCommonForm(FormPage):
         class Config:
             title = product_name
 
@@ -47,40 +56,56 @@ def initial_input_form_generator(product_name: str) -> FormGenerator:
         members: Optional[list]
         trunk_config_ids: trunk_config_selector()  # type:ignore
 
-    user_input = yield CreateTrunkConfigSideForm
+    user_input = yield CreateTrunkConfigCommonForm
 
     return user_input.dict()
 
 
 def _provision_in_gap(fqdn: str) -> int:
-
     return abs(hash(fqdn))
 
 
 @step("Create subscription")
 def create_subscription(product: UUIDstr) -> State:
-    subscription = TrunkConfigSideInactive.from_product_id(product, uuid4())
+    subscription \
+        = TrunkConfigSideInactive.from_product_id(product, uuid4())
 
-    return {"subscription": subscription, "subscription_id": subscription.subscription_id}
+    return {
+        "subscription": subscription,
+        "subscription_id": subscription.subscription_id
+    }
 
 
 @step("Initialize subscription")
-def initialize_subscription(subscription: TrunkConfigSideInactive, fqdn: str, ae_name: str, geant_a_sid: str, ipv4_address: str, ipv6_address: str, members: list, trunk_config_ids: List[str]) -> State:
+def initialize_subscription(
+        subscription: TrunkConfigSideInactive,
+        fqdn: str,
+        ae_name: str,
+        geant_a_sid: str,
+        ipv4_address: str,
+        ipv6_address: str,
+        members: list,
+        trunk_config_ids: List[str]) -> State:
     subscription.trunk_config_side.fqdn = fqdn
     subscription.trunk_config_side.ae_name = ae_name
     subscription.trunk_config_side.geant_a_sid = geant_a_sid
     subscription.trunk_config_side.ipv4_address = ipv4_address
     subscription.trunk_config_side.ipv6_address = ipv6_address
     subscription.trunk_config_side.members = members
-    subscription.trunk_config_side.trunk_config = TrunkConfig.from_subscription(trunk_config_ids[0]).trunk_config
-    subscription.description = f"TrunkConfigSide from TrunkConfig {subscription.trunk_config_side.trunk_config.trunk_config_id}"
-    subscription = TrunkConfigSideProvisioning.from_other_lifecycle(subscription, SubscriptionLifecycle.PROVISIONING)
+    subscription.trunk_config_side.trunk_config \
+        = TrunkConfig.from_subscription(trunk_config_ids[0]).trunk_config
+    subscription.description = \
+        "TrunkConfigSide from TrunkConfig " \
+        f"{subscription.trunk_config_side.trunk_config.trunk_config_id}"
+    subscription = TrunkConfigSideProvisioning.from_other_lifecycle(
+        subscription, SubscriptionLifecycle.PROVISIONING)
 
     return {"subscription": subscription}
 
 
 @step("Provision trunk config side")
-def provision_trunk_config_side(subscription: TrunkConfigSideProvisioning, fqdn: str) -> State:
+def provision_trunk_config_side(
+        subscription: TrunkConfigSideProvisioning, fqdn: str) -> State:
     trunk_config_side_id = _provision_in_gap(fqdn)
     subscription.trunk_config_side.trunk_config_side_id = trunk_config_side_id
 
@@ -89,7 +114,7 @@ def provision_trunk_config_side(subscription: TrunkConfigSideProvisioning, fqdn:
 
 @workflow(
     "Create trunk config side",
-    initial_input_form=wrap_create_initial_input_form(initial_input_form_generator),
+    initial_input_form=wrap_create_initial_input_form(initial_input_form_generator),  # noqa: E501
     target=Target.CREATE,
 )
 def create_trunk_config_side():