orchestrator-core 4.4.0rc2__py3-none-any.whl → 5.0.0a1__py3-none-any.whl

orchestrator/__init__.py

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

orchestrator/api/api_v1/api.py

@@ -22,6 +22,7 @@ from orchestrator.api.api_v1.endpoints import (
     product_blocks,
     products,
     resource_types,
+    search,
     settings,
     subscription_customer_descriptions,
     subscriptions,
@@ -83,3 +84,9 @@ api_router.include_router(
     tags=["Core", "Translations"],
 )
 api_router.include_router(ws.router, prefix="/ws", tags=["Core", "Events"])
+
+api_router.include_router(
+    search.router,
+    prefix="/search",
+    tags=["Core", "Search"],
+)

orchestrator/api/api_v1/endpoints/agent.py

@@ -0,0 +1,62 @@
+import structlog
+from fastapi import FastAPI, HTTPException
+from starlette.types import ASGIApp
+
+from orchestrator.settings import app_settings
+
+logger = structlog.get_logger(__name__)
+
+
+def _disabled_agent_app(reason: str) -> FastAPI:
+    app = FastAPI(title="Agent disabled")
+
+    @app.api_route("/{path:path}", methods=["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"])
+    async def _disabled(path: str) -> None:
+        raise HTTPException(status_code=503, detail=f"Agent disabled: {reason}")
+
+    return app
+
+
+def build_agent_app() -> ASGIApp:
+    if not app_settings.AGENT_MODEL or not app_settings.OPENAI_API_KEY:
+        logger.warning("Agent route disabled: missing model or OPENAI_API_KEY")
+        return _disabled_agent_app("missing configuration")
+
+    try:
+        from pydantic_ai.ag_ui import StateDeps
+        from pydantic_ai.agent import Agent
+        from pydantic_ai.settings import ModelSettings
+
+        from orchestrator.search.agent.prompts import get_base_instructions, get_dynamic_instructions
+        from orchestrator.search.agent.state import SearchState
+        from orchestrator.search.agent.tools import search_toolset
+    except ImportError:
+        logger.error(
+            "\nRequired packages not installed:\n"
+            "WARNING: These packages are NOT compatible with the current "
+            "pydantic version in orchestrator-core.\n Upgrading pydantic to install "
+            "may cause incompatibilities or runtime errors.\n\n"
+            "  pydantic-ai==0.7.0\n"
+            "  ag-ui-protocol>=0.1.8\n\n"
+            "Install them locally to enable the agent:\n"
+            "  pip install 'pydantic-ai==0.7.0' 'ag-ui-protocol>=0.1.8'\n"
+        )
+        logger.warning("Agent route disabled: Missing required packages")
+        return _disabled_agent_app("Missing required packages")
+
+    try:
+        agent = Agent(
+            model=app_settings.AGENT_MODEL,
+            deps_type=StateDeps[SearchState],
+            model_settings=ModelSettings(
+                parallel_tool_calls=False
+            ),  # https://github.com/pydantic/pydantic-ai/issues/562
+            toolsets=[search_toolset],
+        )
+        agent.instructions(get_base_instructions)
+        agent.instructions(get_dynamic_instructions)
+
+        return agent.to_ag_ui(deps=StateDeps(SearchState()))
+    except Exception as e:
+        logger.error("Agent init failed; serving disabled stub.", error=str(e))
+        return _disabled_agent_app(str(e))

orchestrator/api/api_v1/endpoints/processes.py

@@ -25,7 +25,7 @@ from fastapi.param_functions import Body, Depends, Header
 from fastapi.routing import APIRouter
 from fastapi.websockets import WebSocket
 from fastapi_etag.dependency import CacheHit
-from more_itertools import chunked, first, last
+from more_itertools import chunked, last
 from sentry_sdk.tracing import trace
 from sqlalchemy import CompoundSelect, Select, select
 from sqlalchemy.orm import defer, joinedload
@@ -88,17 +88,11 @@ def check_global_lock() -> None:
         )
 
 
-def get_steps_to_evaluate_for_rbac(pstat: ProcessStat) -> StepList:
-    """Extract all steps from the ProcessStat for a process that should be evaluated for a RBAC callback.
-
-    For a suspended process this includes all previously completed steps as well as the current step.
-    For a completed process this includes all steps.
-    """
-    if not (remaining_steps := pstat.log):
-        return pstat.workflow.steps
-
+def get_current_steps(pstat: ProcessStat) -> StepList:
+    """Extract past and current steps from the ProcessStat."""
+    remaining_steps = pstat.log
     past_steps = pstat.workflow.steps[: -len(remaining_steps)]
-    return StepList(past_steps >> first(remaining_steps))
+    return StepList(past_steps + [pstat.log[0]])
 
 
 def get_auth_callbacks(steps: StepList, workflow: Workflow) -> tuple[Authorizer | None, Authorizer | None]:
@@ -206,7 +200,7 @@ def resume_process_endpoint(
         raise_status(HTTPStatus.CONFLICT, f"Resuming a {process.last_status.lower()} workflow is not possible")
 
     pstat = load_process(process)
-    auth_resume, auth_retry = get_auth_callbacks(get_steps_to_evaluate_for_rbac(pstat), pstat.workflow)
+    auth_resume, auth_retry = get_auth_callbacks(get_current_steps(pstat), pstat.workflow)
     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")

orchestrator/api/api_v1/endpoints/search.py

@@ -0,0 +1,197 @@
+from typing import Any, TypeVar, cast
+
+from fastapi import APIRouter, HTTPException, Query, status
+from pydantic import BaseModel
+from sqlalchemy import case, select
+from sqlalchemy.orm import selectinload
+
+from orchestrator.db import (
+    ProcessTable,
+    ProductTable,
+    SubscriptionTable,
+    WorkflowTable,
+    db,
+)
+from orchestrator.schemas.search import (
+    ConnectionSchema,
+    PageInfoSchema,
+    PathsResponse,
+    ProcessSearchSchema,
+    ProductSearchSchema,
+    SubscriptionSearchResult,
+    WorkflowSearchSchema,
+)
+from orchestrator.schemas.subscription import SubscriptionDomainModelSchema
+from orchestrator.search.core.types import EntityType, FieldType, UIType
+from orchestrator.search.filters.definitions import generate_definitions
+from orchestrator.search.retrieval import execute_search
+from orchestrator.search.retrieval.builder import build_paths_query, create_path_autocomplete_lquery
+from orchestrator.search.retrieval.validation import is_lquery_syntactically_valid
+from orchestrator.search.schemas.parameters import (
+    BaseSearchParameters,
+    ProcessSearchParameters,
+    ProductSearchParameters,
+    SubscriptionSearchParameters,
+    WorkflowSearchParameters,
+)
+from orchestrator.search.schemas.results import PathInfo, TypeDefinition
+
+router = APIRouter()
+T = TypeVar("T", bound=BaseModel)
+
+
+async def _perform_search_and_fetch_simple(
+    search_params: BaseSearchParameters,
+    db_model: Any,
+    response_schema: type[BaseModel],
+    pk_column_name: str,
+    eager_loads: list[Any],
+) -> ConnectionSchema:
+    results = await execute_search(search_params=search_params, db_session=db.session, limit=20)
+
+    if not results:
+        data: dict[str, Any] = {"page_info": PageInfoSchema(), "page": []}
+        return ConnectionSchema(**cast(Any, data))
+
+    entity_ids = [res.entity_id for res in results]
+    pk_column = getattr(db_model, pk_column_name)
+    ordering_case = case({entity_id: i for i, entity_id in enumerate(entity_ids)}, value=pk_column)
+
+    stmt = select(db_model).options(*eager_loads).filter(pk_column.in_(entity_ids)).order_by(ordering_case)
+    entities = db.session.scalars(stmt).all()
+
+    page = [response_schema.model_validate(entity) for entity in entities]
+
+    data = {"page_info": PageInfoSchema(), "page": page}
+    return ConnectionSchema(**cast(Any, data))
+
+
+@router.post(
+    "/subscriptions",
+    response_model=ConnectionSchema[SubscriptionSearchResult],
+    response_model_by_alias=True,
+)
+async def search_subscriptions(
+    search_params: SubscriptionSearchParameters,
+) -> ConnectionSchema[SubscriptionSearchResult]:
+    search_results = await execute_search(search_params=search_params, db_session=db.session, limit=20)
+
+    if not search_results:
+        data = {"page_info": PageInfoSchema(), "page": []}
+        return ConnectionSchema(**cast(Any, data))
+
+    search_info_map = {res.entity_id: res for res in search_results}
+    entity_ids = list(search_info_map.keys())
+
+    pk_column = SubscriptionTable.subscription_id
+    ordering_case = case({entity_id: i for i, entity_id in enumerate(entity_ids)}, value=pk_column)
+
+    stmt = (
+        select(SubscriptionTable)
+        .options(
+            selectinload(SubscriptionTable.product),
+            selectinload(SubscriptionTable.customer_descriptions),
+        )
+        .filter(pk_column.in_(entity_ids))
+        .order_by(ordering_case)
+    )
+    subscriptions = db.session.scalars(stmt).all()
+
+    page = []
+    for sub in subscriptions:
+        search_data = search_info_map.get(str(sub.subscription_id))
+        if search_data:
+            subscription_model = SubscriptionDomainModelSchema.model_validate(sub)
+
+            result_item = SubscriptionSearchResult(
+                score=search_data.score,
+                highlight=search_data.highlight,
+                subscription=subscription_model.model_dump(),
+            )
+            page.append(result_item)
+
+    data = {"page_info": PageInfoSchema(), "page": page}
+    return ConnectionSchema(**cast(Any, data))
+
+
+@router.post("/workflows", response_model=ConnectionSchema[WorkflowSearchSchema], response_model_by_alias=True)
+async def search_workflows(search_params: WorkflowSearchParameters) -> ConnectionSchema[WorkflowSearchSchema]:
+    return await _perform_search_and_fetch_simple(
+        search_params=search_params,
+        db_model=WorkflowTable,
+        response_schema=WorkflowSearchSchema,
+        pk_column_name="workflow_id",
+        eager_loads=[selectinload(WorkflowTable.products)],
+    )
+
+
+@router.post("/products", response_model=ConnectionSchema[ProductSearchSchema], response_model_by_alias=True)
+async def search_products(search_params: ProductSearchParameters) -> ConnectionSchema[ProductSearchSchema]:
+    return await _perform_search_and_fetch_simple(
+        search_params=search_params,
+        db_model=ProductTable,
+        response_schema=ProductSearchSchema,
+        pk_column_name="product_id",
+        eager_loads=[
+            selectinload(ProductTable.workflows),
+            selectinload(ProductTable.fixed_inputs),
+            selectinload(ProductTable.product_blocks),
+        ],
+    )
+
+
+@router.post("/processes", response_model=ConnectionSchema[ProcessSearchSchema], response_model_by_alias=True)
+async def search_processes(search_params: ProcessSearchParameters) -> ConnectionSchema[ProcessSearchSchema]:
+    return await _perform_search_and_fetch_simple(
+        search_params=search_params,
+        db_model=ProcessTable,
+        response_schema=ProcessSearchSchema,
+        pk_column_name="process_id",
+        eager_loads=[
+            selectinload(ProcessTable.workflow),
+        ],
+    )
+
+
+@router.get(
+    "/paths",
+    response_model=PathsResponse,
+    response_model_exclude_none=True,
+)
+async def list_paths(
+    prefix: str = Query("", min_length=0),
+    q: str | None = Query(None, description="Query for path suggestions"),
+    entity_type: EntityType = Query(EntityType.SUBSCRIPTION),
+    limit: int = Query(10, ge=1, le=10),
+) -> PathsResponse:
+    if prefix:
+        lquery_pattern = create_path_autocomplete_lquery(prefix)
+
+        if not is_lquery_syntactically_valid(lquery_pattern, db.session):
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=f"Prefix '{prefix}' creates an invalid search pattern.",
+            )
+    stmt = build_paths_query(entity_type=entity_type, prefix=prefix, q=q)
+    stmt = stmt.limit(limit)
+    rows = db.session.execute(stmt).all()
+
+    paths = [
+        PathInfo(
+            path=str(path),
+            type=UIType.from_field_type(FieldType(value_type)),
+        )
+        for path, value_type in rows
+    ]
+
+    return PathsResponse(prefix=prefix, paths=paths)
+
+
+@router.get(
+    "/definitions",
+    response_model=dict[UIType, TypeDefinition],
+    response_model_exclude_none=True,
+)
+async def get_definitions() -> dict[UIType, TypeDefinition]:
+    """Provide a static definition of operators and schemas for each UI type."""
+    return generate_definitions()

orchestrator/api/api_v1/endpoints/subscriptions.py

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

orchestrator/app.py

@@ -41,6 +41,7 @@ from nwastdlib.logging import ClearStructlogContextASGIMiddleware, initialise_lo
 from oauth2_lib.fastapi import AuthManager, Authorization, GraphqlAuthorization, OIDCAuth
 from orchestrator import __version__
 from orchestrator.api.api_v1.api import api_router
+from orchestrator.api.api_v1.endpoints.agent import build_agent_app
 from orchestrator.api.error_handling import ProblemDetailException
 from orchestrator.cli.main import app as cli_app
 from orchestrator.db import db, init_database
@@ -150,6 +151,9 @@ class OrchestratorCore(FastAPI):
             metrics_app = make_asgi_app(registry=ORCHESTRATOR_METRICS_REGISTRY)
             self.mount("/api/metrics", metrics_app)
 
+        agent_app = build_agent_app()
+        self.mount("/agent", agent_app)
+
         @self.router.get("/", response_model=str, response_class=JSONResponse, include_in_schema=False)
         def _index() -> str:
             return "Orchestrator Core"

orchestrator/cli/index_llm.py

@@ -0,0 +1,73 @@
+import typer
+
+from orchestrator.search.core.types import EntityType
+from orchestrator.search.indexing import run_indexing_for_entity
+
+app = typer.Typer(
+    name="index",
+    help="Index search indexes",
+)
+
+
+@app.command("subscriptions")
+def subscriptions_command(
+    subscription_id: str | None = typer.Option(None, help="UUID (default = all)"),
+    dry_run: bool = typer.Option(False, help="No DB writes"),
+    force_index: bool = typer.Option(False, help="Force re-index (ignore hash cache)"),
+) -> None:
+    """Index subscription_search_index."""
+    run_indexing_for_entity(
+        entity_kind=EntityType.SUBSCRIPTION,
+        entity_id=subscription_id,
+        dry_run=dry_run,
+        force_index=force_index,
+    )
+
+
+@app.command("products")
+def products_command(
+    product_id: str | None = typer.Option(None, help="UUID (default = all)"),
+    dry_run: bool = typer.Option(False, help="No DB writes"),
+    force_index: bool = typer.Option(False, help="Force re-index (ignore hash cache)"),
+) -> None:
+    """Index product_search_index."""
+    run_indexing_for_entity(
+        entity_kind=EntityType.PRODUCT,
+        entity_id=product_id,
+        dry_run=dry_run,
+        force_index=force_index,
+    )
+
+
+@app.command("processes")
+def processes_command(
+    process_id: str | None = typer.Option(None, help="UUID (default = all)"),
+    dry_run: bool = typer.Option(False, help="No DB writes"),
+    force_index: bool = typer.Option(False, help="Force re-index (ignore hash cache)"),
+) -> None:
+    """Index process_search_index."""
+    run_indexing_for_entity(
+        entity_kind=EntityType.PROCESS,
+        entity_id=process_id,
+        dry_run=dry_run,
+        force_index=force_index,
+    )
+
+
+@app.command("workflows")
+def workflows_command(
+    workflow_id: str | None = typer.Option(None, help="UUID (default = all)"),
+    dry_run: bool = typer.Option(False, help="No DB writes"),
+    force_index: bool = typer.Option(False, help="Force re-index (ignore hash cache)"),
+) -> None:
+    """Index workflow_search_index."""
+    run_indexing_for_entity(
+        entity_kind=EntityType.WORKFLOW,
+        entity_id=workflow_id,
+        dry_run=dry_run,
+        force_index=force_index,
+    )
+
+
+if __name__ == "__main__":
+    app()

orchestrator/cli/main.py

@@ -13,12 +13,19 @@
 
 import typer
 
-from orchestrator.cli import database, generate, scheduler
+from orchestrator.cli import database, generate, index_llm, resize_embedding, scheduler, search_explore
 
 app = typer.Typer()
 app.add_typer(scheduler.app, name="scheduler", help="Access all the scheduler functions")
 app.add_typer(database.app, name="db", help="Interact with the application database")
 app.add_typer(generate.app, name="generate", help="Generate products, workflows and other artifacts")
+app.add_typer(index_llm.app, name="index", help="(Re-)Index the search table.")
+app.add_typer(search_explore.app, name="search", help="Try out different search types.")
+app.add_typer(
+    resize_embedding.app,
+    name="embedding",
+    help="Resize the vector dimension of the embedding column in the search table.",
+)
 
 
 if __name__ == "__main__":

orchestrator/cli/resize_embedding.py

@@ -0,0 +1,136 @@
+import typer
+import structlog
+from sqlalchemy import text
+from sqlalchemy.exc import SQLAlchemyError
+from settings import app_settings
+from orchestrator.db import db
+from orchestrator.db.models import AiSearchIndex
+
+logger = structlog.get_logger(__name__)
+
+app = typer.Typer(
+    name="embedding",
+    help="Resize vector dimensions of the embeddings.",
+)
+
+
+def get_current_embedding_dimension() -> int | None:
+    """Get the current dimension of the embedding column from ai_search_index table.
+
+    Returns:
+        Current dimension size or None if no records exist or column doesn't exist
+    """
+    try:
+        query = text(
+            """
+            SELECT vector_dims(embedding) as dimension
+            FROM ai_search_index
+            WHERE embedding IS NOT NULL
+            LIMIT 1
+        """
+        )
+        result = db.session.execute(query).fetchone()
+        if result and result[0]:
+            return result[0]
+        return None
+
+    except SQLAlchemyError as e:
+        logger.error("Failed to get current embedding dimension", error=str(e))
+        return None
+
+
+def drop_all_embeddings() -> int:
+    """Drop all records from the ai_search_index table.
+
+    Returns:
+        Number of records deleted
+    """
+    try:
+        result = db.session.query(AiSearchIndex).delete()
+        db.session.commit()
+        logger.info(f"Deleted {result} records from ai_search_index")
+        return result
+
+    except SQLAlchemyError as e:
+        db.session.rollback()
+        logger.error("Failed to drop embeddings records", error=str(e))
+        raise
+
+
+def alter_embedding_column_dimension(new_dimension: int) -> None:
+    """Alter the embedding column to use the new dimension size.
+
+    Args:
+        new_dimension: New vector dimension size
+    """
+    try:
+        drop_query = text("ALTER TABLE ai_search_index DROP COLUMN IF EXISTS embedding")
+        db.session.execute(drop_query)
+
+        add_query = text(f"ALTER TABLE ai_search_index ADD COLUMN embedding vector({new_dimension})")
+        db.session.execute(add_query)
+
+        db.session.commit()
+        logger.info(f"Altered embedding column to dimension {new_dimension}")
+
+    except SQLAlchemyError as e:
+        db.session.rollback()
+        logger.error("Failed to alter embedding column dimension", error=str(e))
+        raise
+
+
+@app.command("resize")
+def resize_embeddings_command() -> None:
+    """Resize vector dimensions of the ai_search_index embedding column.
+
+    Compares the current embedding dimension in the database with the configured
+    dimension in app_settings. If they differ, drops all records and alters the
+    column to match the new dimension.
+    """
+    new_dimension = app_settings.EMBEDDING_DIMENSION
+
+    logger.info("Starting embedding dimension resize", new_dimension=new_dimension)
+
+    current_dimension = get_current_embedding_dimension()
+
+    if current_dimension is None:
+        logger.warning("Could not determine current dimension for embedding column")
+
+    if current_dimension == new_dimension:
+        logger.info(
+            "Embedding dimensions match, no resize needed",
+            current_dimension=current_dimension,
+            new_dimension=new_dimension,
+        )
+        return
+
+    logger.info("Dimension mismatch detected", current_dimension=current_dimension, new_dimension=new_dimension)
+
+    if not typer.confirm(
+        f"This will DELETE ALL RECORDS from ai_search_index and alter the embedding column. Continue?"
+    ):
+        logger.info("Operation cancelled by user")
+        return
+
+    try:
+        # Drop all records first.
+        logger.info("Dropping all embedding records...")
+        deleted_count = drop_all_embeddings()
+
+        # Then alter column dimension.
+        logger.info(f"Altering embedding column to dimension {new_dimension}...")
+        alter_embedding_column_dimension(new_dimension)
+
+        logger.info(
+            "Embedding dimension resize completed successfully",
+            records_deleted=deleted_count,
+            new_dimension=new_dimension,
+        )
+
+    except Exception as e:
+        logger.error("Embedding dimension resize failed", error=str(e))
+        raise typer.Exit(1)
+
+
+if __name__ == "__main__":
+    app()

orchestrator/cli/scheduler.py

@@ -13,11 +13,12 @@
 
 
 import logging
+from time import sleep
 
+import schedule
 import typer
-from apscheduler.schedulers.blocking import BlockingScheduler
 
-from orchestrator.schedules.scheduler import get_paused_scheduler, jobstores, scheduler_dispose_db_connections
+from orchestrator.schedules import ALL_SCHEDULERS
 
 log = logging.getLogger(__name__)
 
@@ -26,48 +27,36 @@ 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()
+    """Loop eternally and run schedulers at configured times."""
+    for s in ALL_SCHEDULERS:
+        job = getattr(schedule.every(s.period), s.time_unit)
+        if s.at:
+            job = job.at(s.at)
+        job.do(s).tag(s.name)
+    log.info("Starting Schedule")
+    for j in schedule.jobs:
+        log.info("%s: %s", ", ".join(j.tags), j)
+    while True:
+        schedule.run_pending()
+        idle = schedule.idle_seconds()
+        if idle < 0:
+            log.info("Next job in queue is scheduled in the past, run it now.")
+        else:
+            log.info("Sleeping for %d seconds", idle)
+            sleep(idle)
 
 
 @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}")
+    """Show the currently configured schedule."""
+    for s in ALL_SCHEDULERS:
+        at_str = f"@ {s.at} " if s.at else ""
+        typer.echo(f"{s.name}: {s.__name__} {at_str}every {s.period} {s.time_unit}")
 
 
 @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)
+def force(keyword: str) -> None:
+    """Force the execution of (a) scheduler(s) based on a keyword."""
+    for s in ALL_SCHEDULERS:
+        if keyword in s.name or keyword in s.__name__:
+            s()