orchestrator-core 4.5.3__tar.gz → 4.6.0__tar.gz

{orchestrator_core-4.5.3 → orchestrator_core-4.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orchestrator-core
-Version: 4.5.3
+Version: 4.6.0
 Summary: This is the orchestrator workflow engine.
 Author-email: SURF <automation-beheer@surf.nl>
 Requires-Python: >=3.11,<3.14
@@ -41,8 +41,8 @@ Requires-Dist: fastapi-etag==0.4.0
 Requires-Dist: itsdangerous>=2.2.0
 Requires-Dist: jinja2==3.1.6
 Requires-Dist: more-itertools~=10.7.0
-Requires-Dist: nwa-stdlib~=1.9.2
-Requires-Dist: oauth2-lib>=2.4.1
+Requires-Dist: nwa-stdlib~=1.10.3
+Requires-Dist: oauth2-lib>=2.5.0
 Requires-Dist: orjson==3.10.18
 Requires-Dist: pgvector>=0.4.1
 Requires-Dist: prometheus-client==0.22.1
@@ -63,7 +63,7 @@ Requires-Dist: structlog>=25.4.0
 Requires-Dist: tabulate==0.9.0
 Requires-Dist: typer==0.15.4
 Requires-Dist: uvicorn[standard]~=0.34.0
-Requires-Dist: pydantic-ai-slim ==0.7.0 ; extra == "agent"
+Requires-Dist: pydantic-ai-slim >=1.3.0 ; extra == "agent"
 Requires-Dist: ag-ui-protocol>=0.1.8 ; extra == "agent"
 Requires-Dist: litellm>=1.75.7 ; extra == "agent"
 Requires-Dist: celery~=5.5.1 ; extra == "celery"
@@ -119,21 +119,26 @@ Configure the database URI in your local environment:
 export DATABASE_URI=postgresql://nwa:nwa@localhost:5432/orchestrator-core
 ```
 
-### Step 3 - Create main.py
+### Step 3 - Create main.py and wsgi.py
 
-Create a `main.py` file.
+Create a `main.py` file for running the CLI.
 
 ```python
-from orchestrator import OrchestratorCore
 from orchestrator.cli.main import app as core_cli
-from orchestrator.settings import AppSettings
-
-app = OrchestratorCore(base_settings=AppSettings())
 
 if __name__ == "__main__":
     core_cli()
 ```
 
+Create a `wsgi.py` file for running the web server.
+
+```python
+from orchestrator import OrchestratorCore
+from orchestrator.settings import AppSettings
+
+app = OrchestratorCore(base_settings=AppSettings())
+```
+
 ### Step 4 - Run the database migrations
 
 Initialize the migration environment and database tables.
@@ -147,7 +152,7 @@ python main.py db upgrade heads
 
 ```shell
 export OAUTH2_ACTIVE=False
-uvicorn --reload --host 127.0.0.1 --port 8080 main:app
+uvicorn --reload --host 127.0.0.1 --port 8080 wsgi:app
 ```
 
 Visit the [ReDoc](http://127.0.0.1:8080/api/redoc) or [OpenAPI](http://127.0.0.1:8080/api/docs) page to view and interact with the API.

{orchestrator_core-4.5.3 → orchestrator_core-4.6.0}/README.md

@@ -42,21 +42,26 @@ Configure the database URI in your local environment:
 export DATABASE_URI=postgresql://nwa:nwa@localhost:5432/orchestrator-core
 ```
 
-### Step 3 - Create main.py
+### Step 3 - Create main.py and wsgi.py
 
-Create a `main.py` file.
+Create a `main.py` file for running the CLI.
 
 ```python
-from orchestrator import OrchestratorCore
 from orchestrator.cli.main import app as core_cli
-from orchestrator.settings import AppSettings
-
-app = OrchestratorCore(base_settings=AppSettings())
 
 if __name__ == "__main__":
     core_cli()
 ```
 
+Create a `wsgi.py` file for running the web server.
+
+```python
+from orchestrator import OrchestratorCore
+from orchestrator.settings import AppSettings
+
+app = OrchestratorCore(base_settings=AppSettings())
+```
+
 ### Step 4 - Run the database migrations
 
 Initialize the migration environment and database tables.
@@ -70,7 +75,7 @@ python main.py db upgrade heads
 
 ```shell
 export OAUTH2_ACTIVE=False
-uvicorn --reload --host 127.0.0.1 --port 8080 main:app
+uvicorn --reload --host 127.0.0.1 --port 8080 wsgi:app
 ```
 
 Visit the [ReDoc](http://127.0.0.1:8080/api/redoc) or [OpenAPI](http://127.0.0.1:8080/api/docs) page to view and interact with the API.

{orchestrator_core-4.5.3 → orchestrator_core-4.6.0}/orchestrator/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2019-2025 SURF, GÉANT.
+# Copyright 2019-2025 SURF, GÉANT, ESnet.
 # 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
@@ -13,7 +13,7 @@
 
 """This is the orchestrator workflow engine."""
 
-__version__ = "4.5.3"
+__version__ = "4.6.0"
 
 
 from structlog import get_logger

{orchestrator_core-4.5.3 → orchestrator_core-4.6.0}/orchestrator/agentic_app.py

@@ -26,8 +26,7 @@ from orchestrator.cli.main import app as cli_app
 from orchestrator.llm_settings import LLMSettings, llm_settings
 
 if TYPE_CHECKING:
-    from pydantic_ai.models.openai import OpenAIModel
-    from pydantic_ai.toolsets import FunctionToolset
+    from pydantic_ai.models.openai import OpenAIChatModel
 
 logger = get_logger(__name__)
 
@@ -37,20 +36,18 @@ class LLMOrchestratorCore(OrchestratorCore):
         self,
         *args: Any,
         llm_settings: LLMSettings = llm_settings,
-        agent_model: "OpenAIModel | str | None" = None,
-        agent_tools: "list[FunctionToolset] | None" = None,
+        agent_model: "OpenAIChatModel | str | None" = None,
         **kwargs: Any,
     ) -> None:
         """Initialize the `LLMOrchestratorCore` class.
 
         This class extends `OrchestratorCore` with LLM features (search and agent).
-        It runs the search migration and mounts the agent endpoint based on feature flags.
+        It runs the search migration based on feature flags.
 
         Args:
             *args: All the normal arguments passed to the `OrchestratorCore` class.
             llm_settings: A class of settings for the LLM
             agent_model: Override the agent model (defaults to llm_settings.AGENT_MODEL)
-            agent_tools: A list of tools that can be used by the agent
             **kwargs: Additional arguments passed to the `OrchestratorCore` class.
 
         Returns:
@@ -58,7 +55,6 @@ class LLMOrchestratorCore(OrchestratorCore):
         """
         self.llm_settings = llm_settings
         self.agent_model = agent_model or llm_settings.AGENT_MODEL
-        self.agent_tools = agent_tools
 
         super().__init__(*args, **kwargs)
 
@@ -79,22 +75,6 @@ class LLMOrchestratorCore(OrchestratorCore):
                 )
                 raise
 
-        # Mount agent endpoint if agent is enabled
-        if self.llm_settings.AGENT_ENABLED:
-            logger.info("Initializing agent features", model=self.agent_model)
-            try:
-                from orchestrator.search.agent import build_agent_router
-
-                agent_app = build_agent_router(self.agent_model, self.agent_tools)
-                self.mount("/agent", agent_app)
-            except ImportError as e:
-                logger.error(
-                    "Unable to initialize agent features. Please install agent dependencies: "
-                    "`pip install orchestrator-core[agent]`",
-                    error=str(e),
-                )
-                raise
-
 
 main_typer_app = typer.Typer()
 main_typer_app.add_typer(cli_app, name="orchestrator", help="The orchestrator CLI commands")

{orchestrator_core-4.5.3 → orchestrator_core-4.6.0}/orchestrator/api/api_v1/api.py

@@ -95,3 +95,8 @@ if llm_settings.SEARCH_ENABLED:
     api_router.include_router(
         search.router, prefix="/search", tags=["Core", "Search"], dependencies=[Depends(authorize)]
     )
+
+if llm_settings.AGENT_ENABLED:
+    from orchestrator.api.api_v1.endpoints import agent
+
+    api_router.include_router(agent.router, prefix="/agent", tags=["Core", "Agent"], dependencies=[Depends(authorize)])

orchestrator_core-4.6.0/orchestrator/api/api_v1/endpoints/agent.py

@@ -0,0 +1,49 @@
+# Copyright 2019-2025 SURF, GÉANT.
+# 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 functools import cache
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, Request
+from pydantic_ai.ag_ui import StateDeps, handle_ag_ui_request
+from pydantic_ai.agent import Agent
+from starlette.responses import Response
+from structlog import get_logger
+
+from orchestrator.search.agent import build_agent_instance
+from orchestrator.search.agent.state import SearchState
+
+router = APIRouter()
+logger = get_logger(__name__)
+
+
+@cache
+def get_agent(request: Request) -> Agent[StateDeps[SearchState], str]:
+    """Dependency to provide the agent instance.
+
+    The agent is built once and cached for the lifetime of the application.
+    """
+    return build_agent_instance(request.app.agent_model)
+
+
+@router.post("/")
+async def agent_conversation(
+    request: Request,
+    agent: Annotated[Agent[StateDeps[SearchState], str], Depends(get_agent)],
+) -> Response:
+    """Agent conversation endpoint using pydantic-ai ag_ui protocol.
+
+    This endpoint handles the interactive agent conversation for search.
+    """
+    initial_state = SearchState()
+    return await handle_ag_ui_request(agent, request, deps=StateDeps(initial_state))

orchestrator_core-4.6.0/orchestrator/api/api_v1/endpoints/search.py

@@ -0,0 +1,215 @@
+# Copyright 2019-2025 SURF, GÉANT.
+# 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 structlog
+from fastapi import APIRouter, HTTPException, Query, status
+
+from orchestrator.db import db
+from orchestrator.schemas.search import (
+    ExportResponse,
+    PageInfoSchema,
+    PathsResponse,
+    SearchResultsSchema,
+)
+from orchestrator.search.core.exceptions import InvalidCursorError, QueryStateNotFoundError
+from orchestrator.search.core.types import EntityType, UIType
+from orchestrator.search.filters.definitions import generate_definitions
+from orchestrator.search.retrieval import SearchQueryState, execute_search, execute_search_for_export
+from orchestrator.search.retrieval.builder import build_paths_query, create_path_autocomplete_lquery, process_path_rows
+from orchestrator.search.retrieval.pagination import PageCursor, encode_next_page_cursor
+from orchestrator.search.retrieval.validation import is_lquery_syntactically_valid
+from orchestrator.search.schemas.parameters import (
+    ProcessSearchParameters,
+    ProductSearchParameters,
+    SearchParameters,
+    SubscriptionSearchParameters,
+    WorkflowSearchParameters,
+)
+from orchestrator.search.schemas.results import SearchResult, TypeDefinition
+
+router = APIRouter()
+logger = structlog.get_logger(__name__)
+
+
+async def _perform_search_and_fetch(
+    search_params: SearchParameters | None = None,
+    cursor: str | None = None,
+    query_id: str | None = None,
+) -> SearchResultsSchema[SearchResult]:
+    """Execute search with optional pagination.
+
+    Args:
+        search_params: Search parameters for new search
+        cursor: Pagination cursor (loads saved query state)
+        query_id: Saved query ID to retrieve and execute
+
+    Returns:
+        Search results with entity_id, score, and matching_field.
+    """
+    try:
+        page_cursor: PageCursor | None = None
+
+        if cursor:
+            page_cursor = PageCursor.decode(cursor)
+            query_state = SearchQueryState.load_from_id(page_cursor.query_id)
+        elif query_id:
+            query_state = SearchQueryState.load_from_id(query_id)
+        elif search_params:
+            query_state = SearchQueryState(parameters=search_params, query_embedding=None)
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Either search_params, cursor, or query_id must be provided",
+            )
+
+        search_response = await execute_search(
+            query_state.parameters, db.session, page_cursor, query_state.query_embedding
+        )
+        if not search_response.results:
+            return SearchResultsSchema(search_metadata=search_response.metadata)
+
+        next_page_cursor = encode_next_page_cursor(search_response, page_cursor, query_state.parameters)
+        has_next_page = next_page_cursor is not None
+        page_info = PageInfoSchema(has_next_page=has_next_page, next_page_cursor=next_page_cursor)
+
+        return SearchResultsSchema(
+            data=search_response.results, page_info=page_info, search_metadata=search_response.metadata
+        )
+    except (InvalidCursorError, ValueError) as e:
+        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(e))
+    except QueryStateNotFoundError as e:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(e))
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Search failed: {str(e)}",
+        )
+
+
+@router.post("/subscriptions", response_model=SearchResultsSchema[SearchResult])
+async def search_subscriptions(
+    search_params: SubscriptionSearchParameters,
+    cursor: str | None = None,
+) -> SearchResultsSchema[SearchResult]:
+    return await _perform_search_and_fetch(search_params, cursor)
+
+
+@router.post("/workflows", response_model=SearchResultsSchema[SearchResult])
+async def search_workflows(
+    search_params: WorkflowSearchParameters,
+    cursor: str | None = None,
+) -> SearchResultsSchema[SearchResult]:
+    return await _perform_search_and_fetch(search_params, cursor)
+
+
+@router.post("/products", response_model=SearchResultsSchema[SearchResult])
+async def search_products(
+    search_params: ProductSearchParameters,
+    cursor: str | None = None,
+) -> SearchResultsSchema[SearchResult]:
+    return await _perform_search_and_fetch(search_params, cursor)
+
+
+@router.post("/processes", response_model=SearchResultsSchema[SearchResult])
+async def search_processes(
+    search_params: ProcessSearchParameters,
+    cursor: str | None = None,
+) -> SearchResultsSchema[SearchResult]:
+    return await _perform_search_and_fetch(search_params, cursor)
+
+
+@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()
+
+    leaves, components = process_path_rows(rows)
+    return PathsResponse(leaves=leaves, components=components)
+
+
+@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()
+
+
+@router.get(
+    "/queries/{query_id}",
+    response_model=SearchResultsSchema[SearchResult],
+    summary="Retrieve saved search results by query_id",
+)
+async def get_by_query_id(
+    query_id: str,
+    cursor: str | None = None,
+) -> SearchResultsSchema[SearchResult]:
+    """Retrieve and execute a saved search by query_id."""
+    return await _perform_search_and_fetch(query_id=query_id, cursor=cursor)
+
+
+@router.get(
+    "/queries/{query_id}/export",
+    summary="Export query results by query_id",
+    response_model=ExportResponse,
+)
+async def export_by_query_id(query_id: str) -> ExportResponse:
+    """Export search results using query_id.
+
+    The query is retrieved from the database, re-executed, and results are returned
+    as flattened records suitable for CSV download.
+
+    Args:
+        query_id: Query UUID
+
+    Returns:
+        ExportResponse containing 'page' with an array of flattened entity records.
+
+    Raises:
+        HTTPException: 404 if query not found, 400 if invalid data
+    """
+    try:
+        query_state = SearchQueryState.load_from_id(query_id)
+        export_records = await execute_search_for_export(query_state, db.session)
+        return ExportResponse(page=export_records)
+    except ValueError as e:
+        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(e))
+    except QueryStateNotFoundError as e:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(e))
+    except Exception as e:
+        logger.error(e)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Error executing export: {str(e)}",
+        )

{orchestrator_core-4.5.3 → orchestrator_core-4.6.0}/orchestrator/app.py

@@ -5,7 +5,7 @@ This module contains the main `OrchestratorCore` class for the `FastAPI` backend
 provides the ability to run the CLI.
 """
 
-# Copyright 2019-2020 SURF, ESnet, GÉANT.
+# Copyright 2019-2025 SURF, ESnet, GÉANT.
 # 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

{orchestrator_core-4.5.3 → orchestrator_core-4.6.0}/orchestrator/cli/database.py

@@ -23,6 +23,8 @@ from structlog import get_logger
 
 import orchestrator.workflows
 from orchestrator.cli.domain_gen_helpers.types import ModelUpdates
+from orchestrator.cli.generate import create_writer, get_template_environment
+from orchestrator.cli.generator.generator.migration import create_data_head_if_not_exists
 from orchestrator.cli.helpers.print_helpers import COLOR, str_fmt
 from orchestrator.cli.migrate_domain_models import create_domain_models_migration_sql
 from orchestrator.cli.migrate_tasks import create_tasks_migration_wizard
@@ -223,6 +225,7 @@ def revision(
             --head TEXT                     Determine the head you need to add your migration to.
         ```
     """
+    create_data_head_if_not_exists({"writer": create_writer(), "environment": get_template_environment()})
     command.revision(alembic_cfg(), message, version_path=version_path, autogenerate=autogenerate, head=head)
 
 

{orchestrator_core-4.5.3 → orchestrator_core-4.6.0}/orchestrator/cli/generate.py

@@ -14,6 +14,7 @@
 # ruff: noqa: S603
 import subprocess
 from pathlib import Path
+from typing import Callable
 
 import structlog
 import typer
@@ -78,7 +79,7 @@ def ruff(content: str) -> str:
     return content
 
 
-def create_context(config_file: Path, dryrun: bool, force: bool, python_version: str, tdd: bool | None = False) -> dict:
+def create_writer(dryrun: bool = False, force: bool = False) -> Callable[..., None]:
     def writer(path: Path, content: str, append: bool = False) -> None:
         content = ruff(content) if path.suffix == ".py" else content
         if dryrun:
@@ -88,9 +89,15 @@ def create_context(config_file: Path, dryrun: bool, force: bool, python_version:
         else:
             write_file(path, content, append=append, force=force)
 
+    return writer
+
+
+def get_template_environment() -> Environment:
     search_path = (settings.CUSTOM_TEMPLATES, Path(__file__).parent / "generator" / "templates")
-    environment = Environment(loader=FileSystemLoader(search_path), autoescape=True, keep_trailing_newline=True)
+    return Environment(loader=FileSystemLoader(search_path), autoescape=True, keep_trailing_newline=True)
 
+
+def create_context(config_file: Path, dryrun: bool, force: bool, python_version: str, tdd: bool | None = False) -> dict:
     config = read_config(config_file)
     config["variable"] = get_variable(config)
     for pb in config["product_blocks"]:
@@ -98,10 +105,10 @@ def create_context(config_file: Path, dryrun: bool, force: bool, python_version:
 
     return {
         "config": config,
-        "environment": environment,
+        "environment": get_template_environment(),
         "python_version": python_version,
         "tdd": tdd,
-        "writer": writer,
+        "writer": create_writer(dryrun=dryrun, force=force),
     }
 
 

{orchestrator_core-4.5.3 → orchestrator_core-4.6.0}/orchestrator/cli/generator/generator/migration.py

@@ -79,6 +79,12 @@ def create_data_head(context: dict, depends_on: str) -> None:
     writer(path, content)
 
 
+def create_data_head_if_not_exists(context: dict) -> None:
+    heads = get_heads()
+    if "data" not in heads:
+        create_data_head(context=context, depends_on=heads["schema"])
+
+
 def extract_revision_info(content: list[str]) -> dict:
     def process() -> Generator:
         for line in content:
@@ -136,9 +142,7 @@ def generate_product_migration(context: dict) -> None:
     environment = context["environment"]
     writer = context["writer"]
 
-    heads = get_heads()
-    if "data" not in heads:
-        create_data_head(context=context, depends_on=heads["schema"])
+    create_data_head_if_not_exists(context=context)
 
     if not (migration_file := create_migration_file(message=f"add {config['name']}", head="data")):
         logger.error("Could not create migration file")

{orchestrator_core-4.5.3 → orchestrator_core-4.6.0}/orchestrator/cli/main.py

@@ -1,4 +1,4 @@
-# Copyright 2019-2020 SURF.
+# Copyright 2019-2025 SURF, ESnet, GÉANT.
 # 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

{orchestrator_core-4.5.3 → orchestrator_core-4.6.0}/orchestrator/cli/scheduler.py

@@ -12,26 +12,23 @@
 # limitations under the License.
 
 
-import logging
 import time
 
 import typer
 
 from orchestrator.schedules.scheduler import (
-    get_paused_scheduler,
+    get_all_scheduler_tasks,
+    get_scheduler,
+    get_scheduler_task,
 )
 
-log = logging.getLogger(__name__)
-
 app: typer.Typer = typer.Typer()
 
 
 @app.command()
 def run() -> None:
     """Start scheduler and loop eternally to keep thread alive."""
-    with get_paused_scheduler() as scheduler:
-        scheduler.resume()
-
+    with get_scheduler():
         while True:
             time.sleep(1)
 
@@ -42,27 +39,23 @@ def show_schedule() -> None:
 
     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}")
+    for task in get_all_scheduler_tasks():
+        typer.echo(f"[{task.id}] Next run: {task.next_run_time} | Trigger: {task.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)
+def force(task_id: str) -> None:
+    """Force the execution of (a) scheduler(s) based on a task_id."""
+    task = get_scheduler_task(task_id)
 
-    if not job:
-        typer.echo(f"Job '{job_id}' not found.")
+    if not task:
+        typer.echo(f"Task '{task_id}' not found.")
         raise typer.Exit(code=1)
 
-    typer.echo(f"Running job [{job.id}] now...")
+    typer.echo(f"Running Task [{task.id}] now...")
     try:
-        job.func(*job.args or (), **job.kwargs or {})
-        typer.echo("Job executed successfully.")
+        task.func(*task.args or (), **task.kwargs or {})
+        typer.echo("Task executed successfully.")
     except Exception as e:
-        typer.echo(f"Job execution failed: {e}")
+        typer.echo(f"Task execution failed: {e}")
         raise typer.Exit(code=1)