orchestrator-core 4.3.1__tar.gz → 4.4.0rc2__tar.gz

{orchestrator_core-4.3.1 → orchestrator_core-4.4.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orchestrator-core
-Version: 4.3.1
+Version: 4.4.0rc2
 Summary: This is the orchestrator workflow engine.
 Author-email: SURF <automation-beheer@surf.nl>
 Requires-Python: >=3.11,<3.14
@@ -32,6 +32,7 @@ Classifier: Typing :: Typed
 License-File: LICENSE
 Requires-Dist: alembic==1.16.1
 Requires-Dist: anyio>=3.7.0
+Requires-Dist: apscheduler>=3.11.0
 Requires-Dist: click==8.*
 Requires-Dist: deepmerge==2.0
 Requires-Dist: deprecated>=1.2.18
@@ -52,7 +53,6 @@ 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

{orchestrator_core-4.3.1 → orchestrator_core-4.4.0rc2}/orchestrator/__init__.py

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

{orchestrator_core-4.3.1 → orchestrator_core-4.4.0rc2}/orchestrator/api/api_v1/endpoints/subscriptions.py

@@ -12,6 +12,7 @@
 # limitations under the License.
 
 """Module that implements subscription related API endpoints."""
+
 from http import HTTPStatus
 from typing import Any
 from uuid import UUID

orchestrator_core-4.4.0rc2/orchestrator/cli/scheduler.py

@@ -0,0 +1,73 @@
+# Copyright 2019-2020 SURF.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import logging
+
+import typer
+from apscheduler.schedulers.blocking import BlockingScheduler
+
+from orchestrator.schedules.scheduler import get_paused_scheduler, jobstores, scheduler_dispose_db_connections
+
+log = logging.getLogger(__name__)
+
+app: typer.Typer = typer.Typer()
+
+
+@app.command()
+def run() -> None:
+    """Start scheduler and loop eternally to keep thread alive."""
+    # necessary to add the schedules to the DB since they are added to the BackgroundScheduler
+    with get_paused_scheduler() as scheduler:
+        scheduler.resume()
+        scheduler.pause()
+
+    blocking_scheduler = BlockingScheduler(jobstores=jobstores, jobstore_update_interval=5)
+
+    try:
+        blocking_scheduler.start()
+    finally:
+        blocking_scheduler.shutdown()
+        scheduler_dispose_db_connections()
+
+
+@app.command()
+def show_schedule() -> None:
+    """Show the currently configured schedule.
+
+    in cli underscore is replaced by a dash `show-schedule`
+    """
+    with get_paused_scheduler() as scheduler:
+        jobs = scheduler.get_jobs()
+
+    for job in jobs:
+        typer.echo(f"[{job.id}] Next run: {job.next_run_time} | Trigger: {job.trigger}")
+
+
+@app.command()
+def force(job_id: str) -> None:
+    """Force the execution of (a) scheduler(s) based on a job_id."""
+    with get_paused_scheduler() as scheduler:
+        job = scheduler.get_job(job_id)
+
+    if not job:
+        typer.echo(f"Job '{job_id}' not found.")
+        raise typer.Exit(code=1)
+
+    typer.echo(f"Running job [{job.id}] now...")
+    try:
+        job.func(*job.args or (), **job.kwargs or {})
+        typer.echo("Job executed successfully.")
+    except Exception as e:
+        typer.echo(f"Job execution failed: {e}")
+        raise typer.Exit(code=1)

orchestrator_core-4.4.0rc2/orchestrator/graphql/resolvers/scheduled_tasks.py

@@ -0,0 +1,36 @@
+import structlog
+
+from orchestrator.db.filters import Filter
+from orchestrator.db.sorting import Sort
+from orchestrator.graphql.pagination import Connection
+from orchestrator.graphql.schemas.scheduled_task import ScheduledTaskGraphql
+from orchestrator.graphql.types import GraphqlFilter, GraphqlSort, OrchestratorInfo
+from orchestrator.graphql.utils import create_resolver_error_handler, to_graphql_result_page
+from orchestrator.graphql.utils.is_query_detailed import is_querying_page_data
+from orchestrator.schedules.scheduler import get_scheduler_tasks, scheduled_task_filter_keys, scheduled_task_sort_keys
+
+logger = structlog.get_logger(__name__)
+
+
+async def resolve_scheduled_tasks(
+    info: OrchestratorInfo,
+    filter_by: list[GraphqlFilter] | None = None,
+    sort_by: list[GraphqlSort] | None = None,
+    first: int = 10,
+    after: int = 0,
+) -> Connection[ScheduledTaskGraphql]:
+    _error_handler = create_resolver_error_handler(info)
+
+    pydantic_filter_by: list[Filter] = [item.to_pydantic() for item in filter_by] if filter_by else []
+    pydantic_sort_by: list[Sort] = [item.to_pydantic() for item in sort_by] if sort_by else []
+    scheduled_tasks, total = get_scheduler_tasks(
+        first=first, after=after, filter_by=pydantic_filter_by, sort_by=pydantic_sort_by, error_handler=_error_handler
+    )
+
+    graphql_scheduled_tasks = []
+    if is_querying_page_data(info):
+        graphql_scheduled_tasks = [ScheduledTaskGraphql.from_pydantic(p) for p in scheduled_tasks]
+
+    return to_graphql_result_page(
+        graphql_scheduled_tasks, first, after, total, scheduled_task_filter_keys, scheduled_task_sort_keys
+    )

{orchestrator_core-4.3.1 → orchestrator_core-4.4.0rc2}/orchestrator/graphql/schema.py

@@ -51,12 +51,14 @@ from orchestrator.graphql.resolvers import (
     resolve_version,
     resolve_workflows,
 )
+from orchestrator.graphql.resolvers.scheduled_tasks import resolve_scheduled_tasks
 from orchestrator.graphql.schemas import DEFAULT_GRAPHQL_MODELS
 from orchestrator.graphql.schemas.customer import CustomerType
 from orchestrator.graphql.schemas.process import ProcessType
 from orchestrator.graphql.schemas.product import ProductType
 from orchestrator.graphql.schemas.product_block import ProductBlock
 from orchestrator.graphql.schemas.resource_type import ResourceType
+from orchestrator.graphql.schemas.scheduled_task import ScheduledTaskGraphql
 from orchestrator.graphql.schemas.settings import StatusType
 from orchestrator.graphql.schemas.subscription import SubscriptionInterface
 from orchestrator.graphql.schemas.version import VersionType
@@ -99,6 +101,9 @@ class OrchestratorQuery:
         description="Returns information about cache, workers, and global engine settings",
     )
     version: VersionType = authenticated_field(resolver=resolve_version, description="Returns version information")
+    scheduled_tasks: Connection[ScheduledTaskGraphql] = authenticated_field(
+        resolver=resolve_scheduled_tasks, description="Returns scheduled job information"
+    )
 
 
 @strawberry.federation.type(description="Orchestrator customer Query")

orchestrator_core-4.4.0rc2/orchestrator/graphql/schemas/scheduled_task.py

@@ -0,0 +1,8 @@
+import strawberry
+
+from orchestrator.schedules.scheduler import ScheduledTask
+
+
+@strawberry.experimental.pydantic.type(model=ScheduledTask, all_fields=True)
+class ScheduledTaskGraphql:
+    pass

{orchestrator_core-4.3.1 → orchestrator_core-4.4.0rc2}/orchestrator/graphql/utils/create_resolver_error_handler.py

@@ -25,6 +25,6 @@ def _format_context(context: dict) -> str:
 
 def create_resolver_error_handler(info: OrchestratorInfo) -> CallableErrorHandler:
     def handle_error(message: str, **context) -> None:  # type: ignore
-        return register_error(" ".join([message, _format_context(context)]), info, error_type=ErrorType.BAD_REQUEST)
+        return register_error(f"{message} {_format_context(context)}", info, error_type=ErrorType.BAD_REQUEST)
 
     return handle_error

{orchestrator_core-4.3.1 → orchestrator_core-4.4.0rc2}/orchestrator/schedules/__init__.py

@@ -13,12 +13,11 @@
 
 
 from orchestrator.schedules.resume_workflows import run_resume_workflows
-from orchestrator.schedules.scheduling import SchedulingFunction
 from orchestrator.schedules.task_vacuum import vacuum_tasks
 from orchestrator.schedules.validate_products import validate_products
 from orchestrator.schedules.validate_subscriptions import validate_subscriptions
 
-ALL_SCHEDULERS: list[SchedulingFunction] = [
+ALL_SCHEDULERS: list = [
     run_resume_workflows,
     vacuum_tasks,
     validate_subscriptions,

{orchestrator_core-4.3.1 → orchestrator_core-4.4.0rc2}/orchestrator/schedules/resume_workflows.py

@@ -12,10 +12,10 @@
 # limitations under the License.
 
 
-from orchestrator.schedules.scheduling import scheduler
+from orchestrator.schedules.scheduler import scheduler
 from orchestrator.services.processes import start_process
 
 
-@scheduler(name="Resume workflows", time_unit="hour", period=1)
+@scheduler.scheduled_job(id="resume-workflows", name="Resume workflows", trigger="interval", hours=1)  # type: ignore[misc]
 def run_resume_workflows() -> None:
     start_process("task_resume_workflows")

orchestrator_core-4.4.0rc2/orchestrator/schedules/scheduler.py

@@ -0,0 +1,163 @@
+# Copyright 2019-2020 SURF.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from contextlib import contextmanager
+from datetime import datetime
+from typing import Any, Generator
+
+from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
+from apscheduler.schedulers.background import BackgroundScheduler
+from more_itertools import partition
+from pydantic import BaseModel
+
+from orchestrator.db.filters import Filter
+from orchestrator.db.filters.filters import CallableErrorHandler
+from orchestrator.db.sorting import Sort
+from orchestrator.db.sorting.sorting import SortOrder
+from orchestrator.settings import app_settings
+from orchestrator.utils.helpers import camel_to_snake, to_camel
+
+jobstores = {"default": SQLAlchemyJobStore(url=str(app_settings.DATABASE_URI))}
+
+scheduler = BackgroundScheduler(jobstores=jobstores)
+
+
+def scheduler_dispose_db_connections() -> None:
+    jobstores["default"].engine.dispose()
+
+
+@contextmanager
+def get_paused_scheduler() -> Generator[BackgroundScheduler, Any, None]:
+    scheduler.start(paused=True)
+
+    try:
+        yield scheduler
+    finally:
+        scheduler.shutdown(wait=False)
+        scheduler_dispose_db_connections()
+
+
+class ScheduledTask(BaseModel):
+    id: str
+    name: str | None = None
+    next_run_time: datetime | None = None
+    trigger: str
+
+
+scheduled_task_keys = set(ScheduledTask.model_fields.keys())
+scheduled_task_filter_keys = sorted(scheduled_task_keys | {to_camel(key) for key in scheduled_task_keys})
+scheduled_task_sort_keys = scheduled_task_filter_keys
+
+
+def scheduled_task_in_filter(job: ScheduledTask, filter_by: list[Filter]) -> bool:
+    return any(f.value.lower() in getattr(job, camel_to_snake(f.field), "").lower() for f in filter_by)
+
+
+def filter_scheduled_tasks(
+    scheduled_tasks: list[ScheduledTask],
+    handle_filter_error: CallableErrorHandler,
+    filter_by: list[Filter] | None = None,
+) -> list[ScheduledTask]:
+    if not filter_by:
+        return scheduled_tasks
+
+    try:
+        invalid_filters, valid_filters = partition(lambda x: x.field in scheduled_task_filter_keys, filter_by)
+
+        if invalid_list := [item.field for item in invalid_filters]:
+            handle_filter_error(
+                "Invalid filter arguments", invalid_filters=invalid_list, valid_filter_keys=scheduled_task_filter_keys
+            )
+
+        valid_filter_list = list(valid_filters)
+        return [task for task in scheduled_tasks if scheduled_task_in_filter(task, valid_filter_list)]
+    except Exception as e:
+        handle_filter_error(str(e))
+        return []
+
+
+def _invert(value: Any) -> Any:
+    """Invert value for descending order."""
+    if isinstance(value, (int, float)):
+        return -value
+    if isinstance(value, str):
+        return tuple(-ord(c) for c in value)
+    if isinstance(value, datetime):
+        return -value.timestamp()
+    return value
+
+
+def sort_key(sort_field: str, sort_order: SortOrder) -> Any:
+    def _sort_key(task: Any) -> Any:
+        value = getattr(task, camel_to_snake(sort_field), None)
+        if sort_field == "next_run_time" and value is None:
+            return float("inf") if sort_order == SortOrder.ASC else float("-inf")
+        return value if sort_order == SortOrder.ASC else _invert(value)
+
+    return _sort_key
+
+
+def sort_scheduled_tasks(
+    scheduled_tasks: list[ScheduledTask], handle_sort_error: CallableErrorHandler, sort_by: list[Sort] | None = None
+) -> list[ScheduledTask]:
+    if not sort_by:
+        return scheduled_tasks
+
+    try:
+        invalid_sorting, valid_sorting = partition(lambda x: x.field in scheduled_task_sort_keys, sort_by)
+        if invalid_list := [item.field for item in invalid_sorting]:
+            handle_sort_error(
+                "Invalid sort arguments", invalid_sorting=invalid_list, valid_sort_keys=scheduled_task_sort_keys
+            )
+
+        valid_sort_list = list(valid_sorting)
+        return sorted(
+            scheduled_tasks, key=lambda task: tuple(sort_key(sort.field, sort.order)(task) for sort in valid_sort_list)
+        )
+    except Exception as e:
+        handle_sort_error(str(e))
+        return []
+
+
+def default_error_handler(message: str, **context) -> None:  # type: ignore
+    from orchestrator.graphql.utils.create_resolver_error_handler import _format_context
+
+    raise ValueError(f"{message} {_format_context(context)}")
+
+
+def get_scheduler_tasks(
+    first: int = 10,
+    after: int = 0,
+    filter_by: list[Filter] | None = None,
+    sort_by: list[Sort] | None = None,
+    error_handler: CallableErrorHandler = default_error_handler,
+) -> tuple[list[ScheduledTask], int]:
+    with get_paused_scheduler() as pauzed_scheduler:
+        scheduled_tasks = pauzed_scheduler.get_jobs()
+
+    scheduled_tasks = filter_scheduled_tasks(scheduled_tasks, error_handler, filter_by)
+    scheduled_tasks = sort_scheduled_tasks(scheduled_tasks, error_handler, sort_by)
+
+    total = len(scheduled_tasks)
+    paginated_tasks = scheduled_tasks[after : after + first + 1]
+
+    return [
+        ScheduledTask(
+            id=task.id,
+            name=task.name,
+            next_run_time=task.next_run_time,
+            trigger=str(task.trigger),
+        )
+        for task in paginated_tasks
+    ], total

orchestrator_core-4.4.0rc2/orchestrator/schedules/scheduling.py

@@ -0,0 +1,88 @@
+# Copyright 2019-2020 SURF.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from collections.abc import Callable
+from typing import TypeVar
+
+from apscheduler.schedulers.base import BaseScheduler
+from deprecated import deprecated
+
+from orchestrator.schedules.scheduler import scheduler as default_scheduler  # your global scheduler instance
+
+F = TypeVar("F", bound=Callable[..., object])
+
+
+@deprecated(
+    reason="We changed from scheduler to apscheduler which has its own decoractor, use `@scheduler.scheduled_job()` from `from orchestrator.scheduling.scheduler import scheduler`"
+)
+def scheduler(
+    name: str,
+    time_unit: str,
+    period: int = 1,
+    at: str | None = None,
+    *,
+    id: str | None = None,
+    scheduler: BaseScheduler = default_scheduler,
+) -> Callable[[F], F]:
+    """APScheduler-compatible decorator to schedule a function.
+
+    id is necessary with apscheduler, if left empty it takes the function name.
+
+    - `time_unit = "hours", period = 12`  → every 12 hours
+    - `time_unit = "day", at = "01:00"`   → every day at 1 AM
+    """
+
+    def decorator(func: F) -> F:
+        job_id = id or func.__name__
+
+        trigger = "interval"
+        kwargs: dict[str, int] = {}
+        if time_unit == "day" and at:
+            trigger = "cron"
+            try:
+                hour, minute = map(int, at.split(":"))
+            except ValueError:
+                raise ValueError(f"Invalid time format for 'at': {at}, expected 'HH:MM'")
+
+            kwargs = {
+                "hour": hour,
+                "minute": minute,
+            }
+        else:
+            # Map string units to timedelta kwargs for IntervalTrigger
+            unit_map = {
+                "seconds": "seconds",
+                "second": "seconds",
+                "minutes": "minutes",
+                "minute": "minutes",
+                "hours": "hours",
+                "hour": "hours",
+                "days": "days",
+                "day": "days",
+            }
+
+            interval_arg = unit_map.get(time_unit.lower(), time_unit.lower())
+            kwargs = {interval_arg: period}
+
+        scheduler.add_job(
+            func,
+            trigger=trigger,
+            id=job_id,
+            name=name,
+            replace_existing=True,
+            **kwargs,
+        )
+
+        return func
+
+    return decorator

{orchestrator_core-4.3.1 → orchestrator_core-4.4.0rc2}/orchestrator/schedules/task_vacuum.py

@@ -12,10 +12,10 @@
 # limitations under the License.
 
 
-from orchestrator.schedules.scheduling import scheduler
+from orchestrator.schedules.scheduler import scheduler
 from orchestrator.services.processes import start_process
 
 
-@scheduler(name="Clean up tasks", time_unit="hours", period=6)
+@scheduler.scheduled_job(id="clean-tasks", name="Clean up tasks", trigger="interval", hours=6)  # type: ignore[misc]
 def vacuum_tasks() -> None:
     start_process("task_clean_up_tasks")

{orchestrator_core-4.3.1 → orchestrator_core-4.4.0rc2}/orchestrator/schedules/validate_products.py

@@ -14,11 +14,17 @@ from sqlalchemy import func, select
 
 from orchestrator.db import db
 from orchestrator.db.models import ProcessTable
-from orchestrator.schedules.scheduling import scheduler
+from orchestrator.schedules.scheduler import scheduler
 from orchestrator.services.processes import start_process
 
 
-@scheduler(name="Validate Products and inactive subscriptions", time_unit="day", at="02:30")
+@scheduler.scheduled_job(  # type: ignore[misc]
+    id="validate-products",
+    name="Validate Products and inactive subscriptions",
+    trigger="cron",
+    hour=2,
+    minute=30,
+)
 def validate_products() -> None:
     uncompleted_products = db.session.scalar(
         select(func.count())

{orchestrator_core-4.3.1 → orchestrator_core-4.4.0rc2}/orchestrator/schedules/validate_subscriptions.py

@@ -16,7 +16,7 @@ from threading import BoundedSemaphore
 
 import structlog
 
-from orchestrator.schedules.scheduling import scheduler
+from orchestrator.schedules.scheduler import scheduler
 from orchestrator.services.subscriptions import (
     get_subscriptions_on_product_table,
     get_subscriptions_on_product_table_in_sync,
@@ -33,7 +33,7 @@ logger = structlog.get_logger(__name__)
 task_semaphore = BoundedSemaphore(value=2)
 
 
-@scheduler(name="Subscriptions Validator", time_unit="day", at="00:10")
+@scheduler.scheduled_job(id="subscriptions-validator", name="Subscriptions Validator", trigger="cron", hour=0, minute=10)  # type: ignore[misc]
 def validate_subscriptions() -> None:
     if app_settings.VALIDATE_OUT_OF_SYNC_SUBSCRIPTIONS:
         # Automatically re-validate out-of-sync subscriptions. This is not recommended for production.

{orchestrator_core-4.3.1 → orchestrator_core-4.4.0rc2}/orchestrator/services/subscriptions.py

@@ -12,6 +12,7 @@
 # limitations under the License.
 
 """Module that provides service functions on subscriptions."""
+
 import pickle  # noqa: S403
 from collections import defaultdict
 from collections.abc import Sequence
@@ -506,6 +507,7 @@ TARGET_DEFAULT_USABLE_MAP: dict[Target, list[str]] = {
     Target.TERMINATE: ["active", "provisioning"],
     Target.SYSTEM: ["active"],
     Target.VALIDATE: ["active"],
+    Target.RECONCILE: ["active"],
 }
 
 WF_USABLE_MAP: dict[str, list[str]] = {}
@@ -532,6 +534,7 @@ def subscription_workflows(subscription: SubscriptionTable) -> dict[str, Any]:
         ...     "terminate": [],
         ...     "system": [],
         ...     "validate": [],
+        ...     "reconcile: [],
         ... }
 
     """
@@ -552,6 +555,7 @@ def subscription_workflows(subscription: SubscriptionTable) -> dict[str, Any]:
         "terminate": [],
         "system": [],
         "validate": [],
+        "reconcile": [],
     }
     for workflow in subscription.product.workflows:
         if workflow.name in WF_USABLE_WHILE_OUT_OF_SYNC or workflow.is_task:

{orchestrator_core-4.3.1 → orchestrator_core-4.4.0rc2}/orchestrator/targets.py

@@ -23,3 +23,4 @@ class Target(strEnum):
     TERMINATE = "TERMINATE"
     SYSTEM = "SYSTEM"
     VALIDATE = "VALIDATE"
+    RECONCILE = "RECONCILE"

{orchestrator_core-4.3.1 → orchestrator_core-4.4.0rc2}/orchestrator/workflows/utils.py

@@ -154,7 +154,7 @@ def _generate_modify_form(workflow_target: str, workflow_name: str) -> InputForm
 
 
 def wrap_modify_initial_input_form(initial_input_form: InputStepFunc | None) -> StateInputStepFunc | None:
-    """Wrap initial input for modify and terminate workflows.
+    """Wrap initial input for modify, reconcile and terminate workflows.
 
     This is needed because the frontend expects all modify workflows to start with a page that only contains the
     subscription id. It also expects the second page to have some user visible inputs and the subscription id *again*.
@@ -355,6 +355,53 @@ def validate_workflow(description: str) -> Callable[[Callable[[], StepList]], Wo
     return _validate_workflow
 
 
+def reconcile_workflow(
+    description: str,
+    additional_steps: StepList | None = None,
+    authorize_callback: Authorizer | None = None,
+    retry_auth_callback: Authorizer | None = None,
+) -> Callable[[Callable[[], StepList]], Workflow]:
+    """Similar to a modify_workflow but without required input user input to perform a sync with external systems based on the subscriptions existing configuration.
+
+    Use this for subscription reconcile workflows.
+
+    Example::
+
+        @reconcile_workflow("Reconcile l2vpn")
+        def reconcile_l2vpn() -> StepList:
+            return (
+                begin
+                >> update_l2vpn_in_external_systems
+            )
+    """
+
+    wrapped_reconcile_initial_input_form_generator = wrap_modify_initial_input_form(None)
+
+    def _reconcile_workflow(f: Callable[[], StepList]) -> Workflow:
+        steplist = (
+            init
+            >> store_process_subscription()
+            >> unsync
+            >> f()
+            >> (additional_steps or StepList())
+            >> resync
+            >> refresh_subscription_search_index
+            >> done
+        )
+
+        return make_workflow(
+            f,
+            description,
+            wrapped_reconcile_initial_input_form_generator,
+            Target.RECONCILE,
+            steplist,
+            authorize_callback=authorize_callback,
+            retry_auth_callback=retry_auth_callback,
+        )
+
+    return _reconcile_workflow
+
+
 def ensure_provisioning_status(modify_steps: Step | StepList) -> StepList:
     """Decorator to ensure subscription modifications are executed only during Provisioning status."""
     return (

{orchestrator_core-4.3.1 → orchestrator_core-4.4.0rc2}/pyproject.toml

@@ -36,6 +36,7 @@ classifiers = [
 dependencies = [
     "alembic==1.16.1",
     "anyio>=3.7.0",
+    "apscheduler>=3.11.0",
     "click==8.*",
     "deepmerge==2.0",
     "deprecated>=1.2.18",
@@ -56,7 +57,6 @@ dependencies = [
     "python-rapidjson>=1.18,<1.21",
     "pytz==2025.2",
     "redis==5.1.1",
-    "schedule==1.1.0",
     "semver==3.0.4",
     "sentry-sdk[fastapi]~=2.29.1",
     "sqlalchemy==2.0.41",
@@ -230,3 +230,6 @@ known-first-party = [
     "oauth2_lib",
     "pydantic_forms",
 ]
+
+[tool.uv]
+index-url = "https://pypi.org/simple"