orchestrator-core 4.0.0rc3__py3-none-any.whl → 4.0.0rc4__py3-none-any.whl

orchestrator/__init__.py

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

orchestrator/api/api_v1/endpoints/settings.py

@@ -22,9 +22,10 @@ from sqlalchemy.exc import SQLAlchemyError
 from oauth2_lib.fastapi import OIDCUserModel
 from orchestrator.api.error_handling import raise_status
 from orchestrator.db import EngineSettingsTable
-from orchestrator.schemas import EngineSettingsBaseSchema, EngineSettingsSchema, GlobalStatusEnum, WorkerStatus
+from orchestrator.schemas import EngineSettingsBaseSchema, EngineSettingsSchema, WorkerStatus
 from orchestrator.security import authenticate
 from orchestrator.services import processes, settings
+from orchestrator.services.settings import generate_engine_global_status
 from orchestrator.settings import ExecutorType, app_settings
 from orchestrator.utils.json import json_dumps
 from orchestrator.utils.redis import delete_keys_matching_pattern
@@ -165,17 +166,6 @@ def generate_engine_status_response(
         Engine StatusEnum
 
     """
-
-    if engine_settings.global_lock and engine_settings.running_processes > 0:
-        result = EngineSettingsSchema.model_validate(engine_settings)
-        result.global_status = GlobalStatusEnum.PAUSING
-        return result
-
-    if engine_settings.global_lock and engine_settings.running_processes == 0:
-        result = EngineSettingsSchema.model_validate(engine_settings)
-        result.global_status = GlobalStatusEnum.PAUSED
-        return result
-
     result = EngineSettingsSchema.model_validate(engine_settings)
-    result.global_status = GlobalStatusEnum.RUNNING
+    result.global_status = generate_engine_global_status(engine_settings)
     return result

orchestrator/app.py

@@ -25,6 +25,7 @@ import structlog
 import typer
 from fastapi.applications import FastAPI
 from fastapi_etag.dependency import add_exception_handler
+from prometheus_client import make_asgi_app
 from sentry_sdk.integrations import Integration
 from sentry_sdk.integrations.asyncio import AsyncioIntegration
 from sentry_sdk.integrations.fastapi import FastApiIntegration
@@ -54,6 +55,7 @@ from orchestrator.graphql.schema import ContextGetterFactory
 from orchestrator.graphql.schemas.subscription import SubscriptionInterface
 from orchestrator.graphql.types import ScalarOverrideType, StrawberryModelType
 from orchestrator.log_config import LOGGER_OVERRIDES
+from orchestrator.metrics import ORCHESTRATOR_METRICS_REGISTRY, initialize_default_metrics
 from orchestrator.services.process_broadcast_thread import ProcessDataBroadcastThread
 from orchestrator.settings import AppSettings, ExecutorType, app_settings
 from orchestrator.version import GIT_COMMIT_HASH
@@ -143,6 +145,11 @@ class OrchestratorCore(FastAPI):
         self.add_exception_handler(ProblemDetailException, problem_detail_handler)  # type: ignore[arg-type]
         add_exception_handler(self)
 
+        if base_settings.ENABLE_PROMETHEUS_METRICS_ENDPOINT:
+            initialize_default_metrics()
+            metrics_app = make_asgi_app(registry=ORCHESTRATOR_METRICS_REGISTRY)
+            self.mount("/api/metrics", metrics_app)
+
         @self.router.get("/", response_model=str, response_class=JSONResponse, include_in_schema=False)
         def _index() -> str:
             return "Orchestrator Core"

orchestrator/metrics/__init__.py

@@ -0,0 +1,3 @@
+from orchestrator.metrics.init import ORCHESTRATOR_METRICS_REGISTRY, initialize_default_metrics
+
+__all__ = ["initialize_default_metrics", "ORCHESTRATOR_METRICS_REGISTRY"]

orchestrator/metrics/engine.py

@@ -0,0 +1,49 @@
+from typing import Iterable
+
+from prometheus_client import Metric
+from prometheus_client.metrics_core import GaugeMetricFamily, StateSetMetricFamily
+from prometheus_client.registry import Collector
+
+from orchestrator.schemas.engine_settings import GlobalStatusEnum
+from orchestrator.services import settings
+
+
+def _get_engine_status() -> tuple[GlobalStatusEnum, int]:
+    """Query for getting the current status of the workflow engine.
+
+    This includes the engine status, and the amount of currently running processes.
+    """
+    engine_settings = settings.get_engine_settings()
+    engine_status = settings.generate_engine_global_status(engine_settings)
+
+    return engine_status, int(engine_settings.running_processes)
+
+
+class WorkflowEngineCollector(Collector):
+    """Initialize a Prometheus enum and a gauge.
+
+    The enum of the current workflow engine status takes three values:
+        - RUNNING
+        - PAUSING
+        - PAUSED
+
+    This metric also exports the amount of currently running processes.
+    """
+
+    def collect(self) -> Iterable[Metric]:
+        current_engine_status, running_process_count = _get_engine_status()
+
+        engine_status = StateSetMetricFamily(
+            "wfo_engine_status",
+            documentation="Current workflow engine status.",
+            value={status: status == current_engine_status for status in GlobalStatusEnum.values()},
+        )
+
+        engine_process_count = GaugeMetricFamily(
+            "wfo_active_process_count",
+            unit="count",
+            value=running_process_count,
+            documentation="Number of currently running processes in the workflow engine.",
+        )
+
+        return [engine_status, engine_process_count]

orchestrator/metrics/init.py

@@ -0,0 +1,14 @@
+from prometheus_client import CollectorRegistry
+
+from orchestrator.metrics.engine import WorkflowEngineCollector
+from orchestrator.metrics.processes import ProcessCollector
+from orchestrator.metrics.subscriptions import SubscriptionCollector
+
+ORCHESTRATOR_METRICS_REGISTRY = CollectorRegistry(auto_describe=True)
+
+
+def initialize_default_metrics() -> None:
+    """Register default Prometheus collectors."""
+    ORCHESTRATOR_METRICS_REGISTRY.register(SubscriptionCollector())
+    ORCHESTRATOR_METRICS_REGISTRY.register(ProcessCollector())
+    ORCHESTRATOR_METRICS_REGISTRY.register(WorkflowEngineCollector())

orchestrator/metrics/processes.py

@@ -0,0 +1,147 @@
+from typing import Iterable
+
+from prometheus_client.metrics_core import GaugeMetricFamily, Metric
+from prometheus_client.registry import Collector
+from pydantic import BaseModel
+from sqlalchemy import desc, func
+
+from orchestrator.db import ProcessTable, ProductTable, SubscriptionTable, WorkflowTable, db
+from orchestrator.db.models import ProcessSubscriptionTable
+from orchestrator.targets import Target
+from orchestrator.workflow import ProcessStatus
+from pydantic_forms.types import UUIDstr
+
+
+class ProcessTableQueryResult(BaseModel):
+    workflow_name: str
+    customer_id: UUIDstr
+    workflow_target: Target
+    last_status: ProcessStatus
+    created_by: str
+    is_task: bool
+    product_name: str
+    total_runtime: float
+    process_count: int
+
+
+def _get_processes() -> list[ProcessTableQueryResult]:
+    """Query for getting all processes.
+
+    Equivalent to the following SQL statement:
+    ```sql
+    SELECT
+      workflows."name"                                                                          AS workflow_name
+      , subscriptions.customer_id
+      , workflows.target                                                                        AS workflow_target
+      , processes.last_status
+      , processes.created_by
+      , processes.is_task
+      , products."name"                                                                         AS product_name
+      , Coalesce(Sum(Extract(EPOCH FROM processes.last_modified_at - processes.started_at)), 0) AS total_runtime
+      , Count(workflows."name")                                                                 AS process_count
+    FROM
+      processes
+    JOIN workflows
+      ON processes.workflow_id = workflows.workflow_id
+    JOIN processes_subscriptions
+      ON processes.pid = processes_subscriptions.pid
+    JOIN subscriptions
+      ON processes_subscriptions.subscription_id = subscriptions.subscription_id
+    JOIN products
+      ON subscriptions.product_id = products.product_id
+    GROUP BY
+      workflows."name"
+      , subscriptions.customer_id
+      , workflows.target
+      , processes.last_status
+      , processes.created_by
+      , processes.is_task
+      , products."name"
+    ;
+    ```
+    """
+    process_count = func.count(WorkflowTable.name).label("process_count")
+    total_process_time = func.coalesce(
+        func.sum(func.extract("epoch", (ProcessTable.last_modified_at - ProcessTable.started_at))), 0
+    ).label("total_runtime")
+    return (
+        db.session.query(
+            ProcessTable.last_status,
+            ProcessTable.created_by,
+            ProcessTable.is_task,
+            ProductTable.name.label("product_name"),
+            WorkflowTable.name.label("workflow_name"),
+            SubscriptionTable.customer_id,
+            WorkflowTable.target.label("workflow_target"),
+            process_count,
+            total_process_time,
+        )
+        .join(WorkflowTable, WorkflowTable.workflow_id == ProcessTable.workflow_id)
+        .join(ProcessSubscriptionTable, ProcessSubscriptionTable.process_id == ProcessTable.process_id)
+        .join(SubscriptionTable, SubscriptionTable.subscription_id == ProcessSubscriptionTable.subscription_id)
+        .join(ProductTable, ProductTable.product_id == SubscriptionTable.product_id)
+        .group_by(
+            ProcessTable.last_status,
+            ProcessTable.created_by,
+            ProcessTable.is_task,
+            ProductTable.name,
+            WorkflowTable.name,
+            SubscriptionTable.customer_id,
+            WorkflowTable.target,
+        )
+        .order_by(desc(process_count))
+    ).all()
+
+
+class ProcessCollector(Collector):
+    """Collector that contains two Prometheus gauges with process counts and total runtime.
+
+    These gauges contain the amount of processes, and the total runtime in seconds, per every combination of the labels
+    that are defined:
+        - Process last status
+        - Process created by
+        - Process is task
+        - Product name
+        - Workflow name
+        - Customer ID
+        - Workflow target
+    """
+
+    def collect(self) -> Iterable[Metric]:
+        label_names = [
+            "last_status",
+            "created_by",
+            "is_task",
+            "product_name",
+            "workflow_name",
+            "customer_id",
+            "workflow_target",
+        ]
+        process_counts = GaugeMetricFamily(
+            "wfo_process_count",
+            labels=label_names,
+            unit="count",
+            documentation="Number of processes per status, creator, task, product, workflow, customer, and target.",
+        )
+        process_seconds_total = GaugeMetricFamily(
+            "wfo_process_seconds_total",
+            labels=label_names,
+            unit="count",
+            documentation="Total time spent on processes in seconds.",
+        )
+
+        for row in _get_processes():
+            label_values = [
+                row.last_status,
+                str(row.created_by),
+                str(row.is_task),
+                row.product_name,
+                row.workflow_name,
+                row.customer_id,
+                row.workflow_target,
+            ]
+
+            process_counts.add_metric(label_values, row.process_count)
+            process_seconds_total.add_metric(label_values, row.total_runtime)
+
+        return [process_counts, process_seconds_total]

orchestrator/metrics/subscriptions.py

@@ -0,0 +1,93 @@
+from typing import Iterable
+
+from prometheus_client import Metric
+from prometheus_client.metrics_core import GaugeMetricFamily
+from prometheus_client.registry import Collector
+from pydantic import BaseModel
+from sqlalchemy import desc, func
+
+from orchestrator.db import ProductTable, SubscriptionTable, db
+from orchestrator.types import SubscriptionLifecycle
+from pydantic_forms.types import UUIDstr
+
+
+class SubscriptionTableQueryResult(BaseModel):
+    lifecycle_state: SubscriptionLifecycle
+    customer_id: UUIDstr
+    insync: bool
+    product_name: str
+    subscription_count: int
+
+
+def _get_subscriptions() -> list[SubscriptionTableQueryResult]:
+    """Query for getting all subscriptions.
+
+    Equivalent to the following SQL statement:
+    ```sql
+    SELECT
+        subscriptions.status                   AS lifecycle_state
+        , subscriptions.customer_id
+        , subscriptions.insync
+        , products."name"                      AS product_name
+        , Count(subscriptions.subscription_id) AS subscription_count
+    FROM
+      subscriptions
+      JOIN products
+        ON subscriptions.product_id = products.product_id
+    GROUP BY  subscriptions.status
+              , subscriptions.customer_id
+              , insync
+              , products."name"
+    ;
+    ```
+    """
+    subscription_count = func.count(SubscriptionTable.subscription_id).label("subscription_count")
+    return (
+        db.session.query(
+            SubscriptionTable.status.label("lifecycle_state"),
+            SubscriptionTable.customer_id,
+            SubscriptionTable.insync,
+            ProductTable.name.label("product_name"),
+            subscription_count,
+        )
+        .outerjoin(ProductTable, ProductTable.product_id == SubscriptionTable.product_id)
+        .group_by(
+            SubscriptionTable.status,
+            SubscriptionTable.customer_id,
+            SubscriptionTable.insync,
+            ProductTable.name,
+        )
+        .order_by(desc(subscription_count))
+    ).all()
+
+
+class SubscriptionCollector(Collector):
+    """Collector for Subscriptions stored in the subscription database.
+
+    This collector contains one gauge that contains the amount of subscriptions, per every combination of the labels
+    that are defined:
+        - Product name
+        - Subscription lifecycle
+        - Customer ID
+        - `insync` state
+    """
+
+    def collect(self) -> Iterable[Metric]:
+        subscriptions = GaugeMetricFamily(
+            name="wfo_subscriptions_count",
+            labels=[
+                "product_name",
+                "lifecycle_state",
+                "customer_id",
+                "insync",
+            ],
+            unit="count",
+            documentation="Number of subscriptions per product, lifecycle state, customer, and in sync state.",
+        )
+
+        for row in _get_subscriptions():
+            subscriptions.add_metric(
+                [row.product_name, row.lifecycle_state, row.customer_id, str(row.insync)], row.subscription_count
+            )
+
+        return [subscriptions]

orchestrator/services/settings.py

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

orchestrator/settings.py

@@ -84,6 +84,7 @@ class AppSettings(BaseSettings):
     ENABLE_GRAPHQL_DEPRECATION_CHECKER: bool = True
     ENABLE_GRAPHQL_PROFILING_EXTENSION: bool = False
     ENABLE_GRAPHQL_STATS_EXTENSION: bool = False
+    ENABLE_PROMETHEUS_METRICS_ENDPOINT: bool = False
     VALIDATE_OUT_OF_SYNC_SUBSCRIPTIONS: bool = False
     FILTER_BY_MODE: Literal["partial", "exact"] = "exact"
 

{orchestrator_core-4.0.0rc3.dist-info → orchestrator_core-4.0.0rc4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orchestrator-core
-Version: 4.0.0rc3
+Version: 4.0.0rc4
 Summary: This is the orchestrator workflow engine.
 Requires-Python: >=3.11,<3.14
 Classifier: Intended Audience :: Information Technology
@@ -39,6 +39,7 @@ Requires-Dist: more-itertools~=10.7.0
 Requires-Dist: itsdangerous
 Requires-Dist: Jinja2==3.1.6
 Requires-Dist: orjson==3.10.18
+Requires-Dist: prometheus-client==0.21.1
 Requires-Dist: psycopg2-binary==2.9.10
 Requires-Dist: pydantic[email]~=2.8.2
 Requires-Dist: pydantic-settings~=2.9.1

{orchestrator_core-4.0.0rc3.dist-info → orchestrator_core-4.0.0rc4.dist-info}/RECORD

@@ -1,10 +1,10 @@
-orchestrator/__init__.py,sha256=CHCsFHHEBg0NQRRUbkFuXwiTsB9v8mEpqs8-WcZlCUY,1066
-orchestrator/app.py,sha256=9uKJ68FvpeYDbmPNqOKzm6Euka60XlDASsECaq19F3I,11719
+orchestrator/__init__.py,sha256=4DxV-lt8lBVBK_FUrtqliQAVswqjM5XsXcx8oy7Yj0c,1066
+orchestrator/app.py,sha256=7UrXKjBKNSEaSSXAd5ww_RdMFhFqE4yvfj8faS2MzAA,12089
 orchestrator/exception_handlers.py,sha256=UsW3dw8q0QQlNLcV359bIotah8DYjMsj2Ts1LfX4ClY,1268
 orchestrator/log_config.py,sha256=1tPRX5q65e57a6a_zEii_PFK8SzWT0mnA5w2sKg4hh8,1853
 orchestrator/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orchestrator/security.py,sha256=iXFxGxab54aav7oHEKLAVkTgrQMJGHy6IYLojEnD7gI,2422
-orchestrator/settings.py,sha256=21BT1SviPllSL4-M1Qc-8zdgF_Sh7p79WC8sR_AmTmE,3826
+orchestrator/settings.py,sha256=ep4RXOIZfYb5ws4qT_E_iiANMQR91pvOhQQCv1t8osw,3879
 orchestrator/targets.py,sha256=WizBgnp8hWX9YLFUIju7ewSubiwQqinCvyiYNcXHbHI,802
 orchestrator/types.py,sha256=qzs7xx5AYRmKbpYRyJJP3wuDb0W0bcAzefCN0RWLAco,15459
 orchestrator/version.py,sha256=b58e08lxs47wUNXv0jXFO_ykpksmytuzEXD4La4W-NQ,1366
@@ -21,7 +21,7 @@ orchestrator/api/api_v1/endpoints/processes.py,sha256=i5GRoszvdmpZqOxSqON83DNuc0
 orchestrator/api/api_v1/endpoints/product_blocks.py,sha256=kZ6ywIOsS_S2qGq7RvZ4KzjvaS1LmwbGWR37AKRvWOw,2146
 orchestrator/api/api_v1/endpoints/products.py,sha256=BfFtwu9dZXEQbtKxYj9icc73GKGvAGMR5ytyf41nQlQ,3081
 orchestrator/api/api_v1/endpoints/resource_types.py,sha256=gGyuaDyOD0TAVoeFGaGmjDGnQ8eQQArOxKrrk4MaDzA,2145
-orchestrator/api/api_v1/endpoints/settings.py,sha256=QPBwrRGqBlYHNRnADKQ5hpj74X2DB5lROu8KwVnyN_0,6226
+orchestrator/api/api_v1/endpoints/settings.py,sha256=orcwFqGiQ3Ala3mLm_27ChXPkUFoGUeGNaDZnEIk2Ak,5848
 orchestrator/api/api_v1/endpoints/subscription_customer_descriptions.py,sha256=1_6LtgQleoq3M6z_W-Qz__Bj3OFUweoPrUqHMwSH6AM,3288
 orchestrator/api/api_v1/endpoints/subscriptions.py,sha256=EwkWBztI9xSMPkol49SM5csECthyu7HC38AhuW7pWUE,8724
 orchestrator/api/api_v1/endpoints/translations.py,sha256=dIWh_fCnZZUxJoGiNeJ49DK_xpf75IpR_0EIMSvzIvY,963
@@ -202,6 +202,11 @@ orchestrator/graphql/utils/get_subscription_product_blocks.py,sha256=NReel2uZuir
 orchestrator/graphql/utils/is_query_detailed.py,sha256=ESQiM8OyhGF5vEE__cLV61oEIfnFvznoNCxi02rMTsE,2156
 orchestrator/graphql/utils/override_class.py,sha256=blwPXVHxLyXQga3KjiDzWozmMhHEWNrhLL_GDmoj6y0,1373
 orchestrator/graphql/utils/to_graphql_result_page.py,sha256=8ObkJP8reVf-TQOQVPKv1mNdfmSEMS1sG7s_-T7-pUU,902
+orchestrator/metrics/__init__.py,sha256=onGOGku3DPlD6yylljxNYd9ztdsFzK31i3L1zdhOSAQ,171
+orchestrator/metrics/engine.py,sha256=dfpMrKWXNL_5J8zYjH2voOYLx5cZOpGgkz8VsiYF8sg,1708
+orchestrator/metrics/init.py,sha256=xBITvDjbNf-iabbBg0tAW8TPj6-wzr_MerOOqgDsoS4,608
+orchestrator/metrics/processes.py,sha256=SyogN5NSuhYoRv2CSUE1So9e8Gkrwa71J6oGLOdODQU,5333
+orchestrator/metrics/subscriptions.py,sha256=vC1O8VmTq5oJxNrn5CU99Rf8cxzdyhc7tXbZBSAU-O8,3036
 orchestrator/migrations/README,sha256=heMzebYwlGhnE8_4CWJ4LS74WoEZjBy-S-mIJRxAEKI,39
 orchestrator/migrations/alembic.ini,sha256=kMoADqhGeubU8xanILNaqm4oixLy9m4ngYtdGpZcc7I,873
 orchestrator/migrations/env.py,sha256=M_cPoAL2axuuup5fvMy8I_WTPHEw0RbPEHkhZ3QEGoE,3740
@@ -262,7 +267,7 @@ orchestrator/services/process_broadcast_thread.py,sha256=D44YbjF8mRqGuznkRUV4SoR
 orchestrator/services/processes.py,sha256=rTH6zLNsun3qDCPguz2LYS87MQR_LJREIPrgkGS6kwk,30494
 orchestrator/services/products.py,sha256=BP4KyE8zO-8z7Trrs5T6zKBOw53S9BfBJnHWI3p6u5Y,1943
 orchestrator/services/resource_types.py,sha256=_QBy_JOW_X3aSTqH0CuLrq4zBJL0p7Q-UDJUcuK2_qc,884
-orchestrator/services/settings.py,sha256=u-834F4KWloXS8zi7R9mp-D3cjl-rbVjKJRU35IqhXo,2723
+orchestrator/services/settings.py,sha256=HEWfFulgoEDwgfxGEO__QTr5fDiwNBEj1UhAeTAdbLQ,3159
 orchestrator/services/subscription_relations.py,sha256=9C126TUfFvyBe7y4x007kH_dvxJ9pZ1zSnaWeH6HC5k,12261
 orchestrator/services/subscriptions.py,sha256=nr2HI89nC0lYjzTh2j-lEQ5cPQK43LNZv3gvP6jbepw,27189
 orchestrator/services/tasks.py,sha256=NjPkuauQoh9UJDcjA7OcKFgPk0i6NoKdDO7HlpGbBJ8,6575
@@ -302,7 +307,7 @@ orchestrator/workflows/tasks/resume_workflows.py,sha256=MzJqlSXUvKStkT7NGzxZyRlf
 orchestrator/workflows/tasks/validate_product_type.py,sha256=paG-NAY1bdde3Adt8zItkcBKf5Pxw6f5ngGW6an6dYU,3192
 orchestrator/workflows/tasks/validate_products.py,sha256=GZJBoFF-WMphS7ghMs2-gqvV2iL1F0POhk0uSNt93n0,8510
 orchestrator/workflows/translations/en-GB.json,sha256=ST53HxkphFLTMjFHonykDBOZ7-P_KxksktZU3GbxLt0,846
-orchestrator_core-4.0.0rc3.dist-info/licenses/LICENSE,sha256=b-aA5OZQuuBATmLKo_mln8CQrDPPhg3ghLzjPjLn4Tg,11409
-orchestrator_core-4.0.0rc3.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-orchestrator_core-4.0.0rc3.dist-info/METADATA,sha256=iaUztDNdrjgbfWjxzDZeXdKA0XQ-4nqJX_ATeTig7QI,5032
-orchestrator_core-4.0.0rc3.dist-info/RECORD,,
+orchestrator_core-4.0.0rc4.dist-info/licenses/LICENSE,sha256=b-aA5OZQuuBATmLKo_mln8CQrDPPhg3ghLzjPjLn4Tg,11409
+orchestrator_core-4.0.0rc4.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+orchestrator_core-4.0.0rc4.dist-info/METADATA,sha256=I90LCMRMfzx83Wy3CsS1TkfSoxn6PMryPcjFj6WNaok,5073
+orchestrator_core-4.0.0rc4.dist-info/RECORD,,