orchestrator-core 4.6.1__tar.gz → 4.6.3__tar.gz

{orchestrator_core-4.6.1 → orchestrator_core-4.6.3}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: orchestrator-core
-Version: 4.6.1
+Version: 4.6.3
 Summary: This is the orchestrator workflow engine.
 Author-email: SURF <automation-beheer@surf.nl>
-Requires-Python: >=3.11,<3.14
+Requires-Python: >=3.11,<3.15
 Description-Content-Type: text/markdown
 License-Expression: Apache-2.0
 Classifier: Development Status :: 5 - Production/Stable
@@ -20,6 +20,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python
 Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
 Classifier: Topic :: Internet :: WWW/HTTP
@@ -30,40 +31,40 @@ Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development
 Classifier: Typing :: Typed
 License-File: LICENSE
-Requires-Dist: alembic==1.16.1
+Requires-Dist: alembic==1.17.2
 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
-Requires-Dist: fastapi~=0.115.14
+Requires-Dist: fastapi~=0.121.1
 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: more-itertools~=10.8.0
 Requires-Dist: nwa-stdlib~=1.10.3
 Requires-Dist: oauth2-lib>=2.5.0
-Requires-Dist: orjson==3.10.18
+Requires-Dist: orjson==3.11.4
 Requires-Dist: pgvector>=0.4.1
-Requires-Dist: prometheus-client==0.22.1
-Requires-Dist: psycopg2-binary==2.9.10
+Requires-Dist: prometheus-client==0.23.1
+Requires-Dist: psycopg2-binary==2.9.11
 Requires-Dist: pydantic-forms>=1.4.0
-Requires-Dist: pydantic-settings~=2.9.1
-Requires-Dist: pydantic[email]~=2.11.7
-Requires-Dist: python-dateutil==2.8.2
-Requires-Dist: python-rapidjson>=1.18,<1.21
+Requires-Dist: pydantic-settings~=2.12.0
+Requires-Dist: pydantic[email]~=2.12.4
+Requires-Dist: python-dateutil==2.9.0.post0
+Requires-Dist: python-rapidjson>=1.22,<1.23
 Requires-Dist: pytz==2025.2
 Requires-Dist: redis==5.1.1
 Requires-Dist: semver==3.0.4
 Requires-Dist: sentry-sdk[fastapi]>=2.29.1
-Requires-Dist: sqlalchemy==2.0.41
+Requires-Dist: sqlalchemy==2.0.44
 Requires-Dist: sqlalchemy-utils==0.41.2
-Requires-Dist: strawberry-graphql>=0.281.0
+Requires-Dist: strawberry-graphql>=0.281.0,<0.285.0
 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 >=1.3.0 ; extra == "agent"
+Requires-Dist: pydantic-ai-slim >=1.9.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"

{orchestrator_core-4.6.1 → orchestrator_core-4.6.3}/orchestrator/__init__.py

@@ -13,7 +13,7 @@
 
 """This is the orchestrator workflow engine."""
 
-__version__ = "4.6.1"
+__version__ = "4.6.3"
 
 
 from structlog import get_logger

{orchestrator_core-4.6.1 → orchestrator_core-4.6.3}/orchestrator/api/api_v1/endpoints/processes.py

@@ -101,7 +101,7 @@ def get_steps_to_evaluate_for_rbac(pstat: ProcessStat) -> StepList:
     return StepList(past_steps >> first(remaining_steps))
 
 
-def get_auth_callbacks(steps: StepList, workflow: Workflow) -> tuple[Authorizer | None, Authorizer | None]:
+def get_auth_callbacks(steps: StepList, workflow: Workflow | None) -> tuple[Authorizer | None, Authorizer | None]:
     """Iterate over workflow and prior steps to determine correct authorization callbacks for the current step.
 
     It's safest to always iterate through the steps. We could track these callbacks statefully
@@ -112,6 +112,9 @@ def get_auth_callbacks(steps: StepList, workflow: Workflow) -> tuple[Authorizer
     - RESUME callback is explicit RESUME callback, else previous START/RESUME callback
     - RETRY callback is explicit RETRY, else explicit RESUME, else previous RETRY
     """
+    if not workflow:
+        return None, None
+
     # Default to workflow start callbacks
     auth_resume = workflow.authorize_callback
     # auth_retry defaults to the workflow start callback if not otherwise specified.

{orchestrator_core-4.6.1 → orchestrator_core-4.6.3}/orchestrator/api/api_v1/endpoints/search.py

@@ -21,35 +21,32 @@ from orchestrator.schemas.search import (
     PathsResponse,
     SearchResultsSchema,
 )
+from orchestrator.schemas.search_requests import SearchRequest
 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.filters.definitions import TypeDefinition, generate_definitions
+from orchestrator.search.query import QueryState, engine
+from orchestrator.search.query.builder import build_paths_query, create_path_autocomplete_lquery, process_path_rows
+from orchestrator.search.query.queries import ExportQuery, SelectQuery
+from orchestrator.search.query.results import SearchResult
+from orchestrator.search.query.validation import is_lquery_syntactically_valid
 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,
+    entity_type: EntityType | None = None,
+    request: SearchRequest | 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
+        entity_type: Entity type to search
+        request: Search request for new search
         cursor: Pagination cursor (loads saved query state)
         query_id: Saved query ID to retrieve and execute
 
@@ -58,27 +55,31 @@ async def _perform_search_and_fetch(
     """
     try:
         page_cursor: PageCursor | None = None
+        query: SelectQuery
 
         if cursor:
             page_cursor = PageCursor.decode(cursor)
-            query_state = SearchQueryState.load_from_id(page_cursor.query_id)
+            query_state = QueryState.load_from_id(page_cursor.query_id, SelectQuery)
+            query = query_state.query
+
         elif query_id:
-            query_state = SearchQueryState.load_from_id(query_id)
-        elif search_params:
-            query_state = SearchQueryState(parameters=search_params, query_embedding=None)
+            query_state = QueryState.load_from_id(query_id, SelectQuery)
+            query = query_state.query
+
+        elif request and entity_type:
+            query = request.to_query(entity_type)
+            query_state = QueryState(query=query, query_embedding=None)
         else:
             raise HTTPException(
                 status_code=status.HTTP_400_BAD_REQUEST,
-                detail="Either search_params, cursor, or query_id must be provided",
+                detail="Either (request + entity_type), cursor, or query_id must be provided",
             )
 
-        search_response = await execute_search(
-            query_state.parameters, db.session, page_cursor, query_state.query_embedding
-        )
+        search_response = await engine.execute_search(query, 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)
+        next_page_cursor = encode_next_page_cursor(search_response, page_cursor, query)
         has_next_page = next_page_cursor is not None
         page_info = PageInfoSchema(has_next_page=has_next_page, next_page_cursor=next_page_cursor)
 
@@ -98,34 +99,34 @@ async def _perform_search_and_fetch(
 
 @router.post("/subscriptions", response_model=SearchResultsSchema[SearchResult])
 async def search_subscriptions(
-    search_params: SubscriptionSearchParameters,
+    request: SearchRequest,
     cursor: str | None = None,
 ) -> SearchResultsSchema[SearchResult]:
-    return await _perform_search_and_fetch(search_params, cursor)
+    return await _perform_search_and_fetch(EntityType.SUBSCRIPTION, request, cursor)
 
 
 @router.post("/workflows", response_model=SearchResultsSchema[SearchResult])
 async def search_workflows(
-    search_params: WorkflowSearchParameters,
+    request: SearchRequest,
     cursor: str | None = None,
 ) -> SearchResultsSchema[SearchResult]:
-    return await _perform_search_and_fetch(search_params, cursor)
+    return await _perform_search_and_fetch(EntityType.WORKFLOW, request, cursor)
 
 
 @router.post("/products", response_model=SearchResultsSchema[SearchResult])
 async def search_products(
-    search_params: ProductSearchParameters,
+    request: SearchRequest,
     cursor: str | None = None,
 ) -> SearchResultsSchema[SearchResult]:
-    return await _perform_search_and_fetch(search_params, cursor)
+    return await _perform_search_and_fetch(EntityType.PRODUCT, request, cursor)
 
 
 @router.post("/processes", response_model=SearchResultsSchema[SearchResult])
 async def search_processes(
-    search_params: ProcessSearchParameters,
+    request: SearchRequest,
     cursor: str | None = None,
 ) -> SearchResultsSchema[SearchResult]:
-    return await _perform_search_and_fetch(search_params, cursor)
+    return await _perform_search_and_fetch(EntityType.PROCESS, request, cursor)
 
 
 @router.get(
@@ -191,7 +192,7 @@ async def export_by_query_id(query_id: str) -> ExportResponse:
     as flattened records suitable for CSV download.
 
     Args:
-        query_id: Query UUID
+        query_id: QueryTypes UUID
 
     Returns:
         ExportResponse containing 'page' with an array of flattened entity records.
@@ -200,8 +201,17 @@ async def export_by_query_id(query_id: str) -> ExportResponse:
         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)
+        # Load SelectQuery from the database (what gets saved during search)
+        query_state = QueryState.load_from_id(query_id, SelectQuery)
+
+        # Convert to ExportQuery with export-appropriate limit
+        export_query = ExportQuery(
+            entity_type=query_state.query.entity_type,
+            filters=query_state.query.filters,
+            query_text=query_state.query.query_text,
+        )
+
+        export_records = await engine.execute_export(export_query, db.session, query_state.query_embedding)
         return ExportResponse(page=export_records)
     except ValueError as e:
         raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(e))

orchestrator_core-4.6.1/orchestrator/search/retrieval/utils.py → orchestrator_core-4.6.3/orchestrator/cli/search/display.py

@@ -12,7 +12,6 @@
 # limitations under the License.
 
 import json
-import re
 
 import structlog
 from sqlalchemy import and_
@@ -22,37 +21,13 @@ from orchestrator.db.database import WrappedSession
 from orchestrator.db.models import AiSearchIndex
 from orchestrator.search.core.types import EntityType
 from orchestrator.search.indexing.registry import ENTITY_CONFIG_REGISTRY
-from orchestrator.search.schemas.parameters import BaseSearchParameters
-from orchestrator.search.schemas.results import SearchResult
+from orchestrator.search.query.queries import BaseQuery
+from orchestrator.search.query.results import SearchResult
 
 logger = structlog.get_logger(__name__)
 
 
-def generate_highlight_indices(text: str, term: str) -> list[tuple[int, int]]:
-    """Finds all occurrences of individual words from the term, including both word boundary and substring matches."""
-    if not text or not term:
-        return []
-
-    all_matches = []
-    words = [w.strip() for w in term.split() if w.strip()]
-
-    for word in words:
-        # First find word boundary matches
-        word_boundary_pattern = rf"\b{re.escape(word)}\b"
-        word_matches = list(re.finditer(word_boundary_pattern, text, re.IGNORECASE))
-        all_matches.extend([(m.start(), m.end()) for m in word_matches])
-
-        # Then find all substring matches
-        substring_pattern = re.escape(word)
-        substring_matches = list(re.finditer(substring_pattern, text, re.IGNORECASE))
-        all_matches.extend([(m.start(), m.end()) for m in substring_matches])
-
-    return sorted(set(all_matches))
-
-
-def display_filtered_paths_only(
-    results: list[SearchResult], search_params: BaseSearchParameters, db_session: WrappedSession
-) -> None:
+def display_filtered_paths_only(results: list[SearchResult], query: BaseQuery, db_session: WrappedSession) -> None:
     """Display only the paths that were searched for in the results."""
     if not results:
         logger.info("No results found.")
@@ -60,7 +35,7 @@ def display_filtered_paths_only(
 
     logger.info("--- Search Results ---")
 
-    searched_paths = search_params.filters.get_all_paths() if search_params.filters else []
+    searched_paths = query.filters.get_all_paths() if query.filters else []
     if not searched_paths:
         return
 

{orchestrator_core-4.6.1 → orchestrator_core-4.6.3}/orchestrator/cli/search/search_explore.py

@@ -4,13 +4,13 @@ import structlog
 import typer
 from pydantic import ValidationError
 
+from orchestrator.cli.search.display import display_filtered_paths_only, display_results
 from orchestrator.db import db
 from orchestrator.search.core.types import EntityType, FilterOp, UIType
 from orchestrator.search.filters import EqualityFilter, FilterTree, LtreeFilter, PathFilter
-from orchestrator.search.retrieval import execute_search
-from orchestrator.search.retrieval.utils import display_filtered_paths_only, display_results
-from orchestrator.search.retrieval.validation import get_structured_filter_schema
-from orchestrator.search.schemas.parameters import BaseSearchParameters
+from orchestrator.search.query import engine
+from orchestrator.search.query.queries import SelectQuery
+from orchestrator.search.query.validation import get_structured_filter_schema
 
 app = typer.Typer(help="Experiment with the subscription search indexes.")
 
@@ -31,16 +31,14 @@ def structured(path: str, value: str, entity_type: EntityType = EntityType.SUBSC
         ...
     """
     path_filter = PathFilter(path=path, condition=EqualityFilter(op=FilterOp.EQ, value=value), value_kind=UIType.STRING)
-    search_params = BaseSearchParameters.create(
-        entity_type=entity_type, filters=FilterTree.from_flat_and([path_filter]), limit=limit
-    )
-    search_response = asyncio.run(execute_search(search_params=search_params, db_session=db.session))
-    display_filtered_paths_only(search_response.results, search_params, db.session)
+    query = SelectQuery(entity_type=entity_type, filters=FilterTree.from_flat_and([path_filter]), limit=limit)
+    search_response = asyncio.run(engine.execute_search(query=query, db_session=db.session))
+    display_filtered_paths_only(search_response.results, query, db.session)
     display_results(search_response.results, db.session, "Match")
 
 
 @app.command()
-def semantic(query: str, entity_type: EntityType = EntityType.SUBSCRIPTION, limit: int = 10) -> None:
+def semantic(query_text: str, entity_type: EntityType = EntityType.SUBSCRIPTION, limit: int = 10) -> None:
     """Finds subscriptions that are conceptually most similar to the query text.
 
     Example:
@@ -52,8 +50,8 @@ def semantic(query: str, entity_type: EntityType = EntityType.SUBSCRIPTION, limi
         },
         ...
     """
-    search_params = BaseSearchParameters.create(entity_type=entity_type, query=query, limit=limit)
-    search_response = asyncio.run(execute_search(search_params=search_params, db_session=db.session))
+    query = SelectQuery(entity_type=entity_type, query_text=query_text, limit=limit)
+    search_response = asyncio.run(engine.execute_search(query=query, db_session=db.session))
     display_results(search_response.results, db.session, "Distance")
 
 
@@ -70,8 +68,8 @@ def fuzzy(term: str, entity_type: EntityType = EntityType.SUBSCRIPTION, limit: i
         },
         ...
     """
-    search_params = BaseSearchParameters.create(entity_type=entity_type, query=term, limit=limit)
-    search_response = asyncio.run(execute_search(search_params=search_params, db_session=db.session))
+    query = SelectQuery(entity_type=entity_type, query_text=term, limit=limit)
+    search_response = asyncio.run(engine.execute_search(query=query, db_session=db.session))
     display_results(search_response.results, db.session, "Similarity")
 
 
@@ -79,7 +77,7 @@ def fuzzy(term: str, entity_type: EntityType = EntityType.SUBSCRIPTION, limit: i
 def hierarchical(
     op: str = typer.Argument(..., help="The hierarchical operation to perform."),
     path: str = typer.Argument(..., help="The ltree path or lquery pattern for the operation."),
-    query: str | None = typer.Option(None, "--query", "-f", help="An optional fuzzy term to rank the results."),
+    query_text: str | None = typer.Option(None, "--query", "-q", help="An optional fuzzy term to rank the results."),
     entity_type: EntityType = EntityType.SUBSCRIPTION,
     limit: int = 10,
 ) -> None:
@@ -96,23 +94,23 @@ def hierarchical(
 
     path_filter = PathFilter(path="ltree_hierarchical_filter", condition=condition, value_kind=UIType.STRING)
 
-    search_params = BaseSearchParameters.create(
-        entity_type=entity_type, filters=FilterTree.from_flat_and([path_filter]), query=query, limit=limit
+    query = SelectQuery(
+        entity_type=entity_type, filters=FilterTree.from_flat_and([path_filter]), query_text=query_text, limit=limit
     )
-    search_response = asyncio.run(execute_search(search_params=search_params, db_session=db.session))
+    search_response = asyncio.run(engine.execute_search(query=query, db_session=db.session))
     display_results(search_response.results, db.session, "Hierarchical Score")
 
 
 @app.command()
-def hybrid(query: str, term: str, entity_type: EntityType = EntityType.SUBSCRIPTION, limit: int = 10) -> None:
+def hybrid(query_text: str, term: str, entity_type: EntityType = EntityType.SUBSCRIPTION, limit: int = 10) -> None:
     """Performs a hybrid search, combining semantic and fuzzy matching.
 
     Example:
         dotenv run python main.py search hybrid "reptile store" "Kingswood"
     """
-    search_params = BaseSearchParameters.create(entity_type=entity_type, query=query, limit=limit)
-    logger.info("Executing Hybrid Search", query=query, term=term)
-    search_response = asyncio.run(execute_search(search_params=search_params, db_session=db.session))
+    query = SelectQuery(entity_type=entity_type, query_text=query_text, limit=limit)
+    logger.info("Executing Hybrid Search", query_text=query_text, term=term)
+    search_response = asyncio.run(engine.execute_search(query=query, db_session=db.session))
     display_results(search_response.results, db.session, "Hybrid Score")
 
 
@@ -198,8 +196,8 @@ def nested_demo(entity_type: EntityType = EntityType.SUBSCRIPTION, limit: int =
         }
     )
 
-    params = BaseSearchParameters.create(entity_type=entity_type, filters=tree, limit=limit)
-    search_response = asyncio.run(execute_search(params, db.session))
+    query = SelectQuery(entity_type=entity_type, filters=tree, limit=limit)
+    search_response = asyncio.run(engine.execute_search(query=query, db_session=db.session))
 
     display_results(search_response.results, db.session, "Score")
 

{orchestrator_core-4.6.1 → orchestrator_core-4.6.3}/orchestrator/cli/search/speedtest.py

@@ -12,8 +12,8 @@ from orchestrator.db import db
 from orchestrator.search.core.embedding import QueryEmbedder
 from orchestrator.search.core.types import EntityType
 from orchestrator.search.core.validators import is_uuid
-from orchestrator.search.retrieval.engine import execute_search
-from orchestrator.search.schemas.parameters import BaseSearchParameters
+from orchestrator.search.query import engine
+from orchestrator.search.query.queries import SelectQuery
 
 logger = structlog.get_logger(__name__)
 console = Console()
@@ -50,23 +50,25 @@ async def generate_embeddings_for_queries(queries: list[str]) -> dict[str, list[
     return embedding_lookup
 
 
-async def run_single_query(query: str, embedding_lookup: dict[str, list[float]]) -> dict[str, Any]:
-    search_params = BaseSearchParameters(entity_type=EntityType.SUBSCRIPTION, query=query, limit=30)
+async def run_single_query(query_text: str, embedding_lookup: dict[str, list[float]]) -> dict[str, Any]:
+    query = SelectQuery(entity_type=EntityType.SUBSCRIPTION, query_text=query_text, limit=30)
 
     query_embedding = None
 
-    if is_uuid(query):
-        logger.debug("Using fuzzy-only ranking for full UUID", query=query)
+    if is_uuid(query_text):
+        logger.debug("Using fuzzy-only ranking for full UUID", query_text=query_text)
     else:
-        query_embedding = embedding_lookup[query]
+        query_embedding = embedding_lookup[query_text]
 
     with db.session as session:
         start_time = time.perf_counter()
-        response = await execute_search(search_params, session, cursor=None, query_embedding=query_embedding)
+        response = await engine.execute_search(
+            query=query, db_session=session, cursor=None, query_embedding=query_embedding
+        )
         end_time = time.perf_counter()
 
         return {
-            "query": query,
+            "query": query_text,
             "time": end_time - start_time,
             "results": len(response.results),
             "search_type": response.metadata.search_type if hasattr(response, "metadata") else "unknown",

{orchestrator_core-4.6.1 → orchestrator_core-4.6.3}/orchestrator/db/models.py

@@ -60,7 +60,7 @@ from orchestrator.utils.datetime import nowtz
 from orchestrator.version import GIT_COMMIT_HASH
 
 if TYPE_CHECKING:
-    from orchestrator.search.retrieval.query_state import SearchQueryState
+    from orchestrator.search.query.state import QueryState
 
 logger = structlog.get_logger(__name__)
 
@@ -707,7 +707,7 @@ class SearchQueryTable(BaseModel):
     )
     query_number = mapped_column(Integer, nullable=False)
 
-    # Search parameters as JSONB (maps to BaseSearchParameters subclasses)
+    # Search parameters as JSONB (maps to BaseQuery subclasses)
     parameters = mapped_column(pg.JSONB, nullable=False)
 
     # Query embedding for semantic search (pgvector)
@@ -726,14 +726,14 @@ class SearchQueryTable(BaseModel):
     @classmethod
     def from_state(
         cls,
-        state: "SearchQueryState",
+        state: "QueryState",
         run_id: "UUID | None" = None,
         query_number: int = 1,
     ) -> "SearchQueryTable":
-        """Create a SearchQueryTable instance from a SearchQueryState.
+        """Create a SearchQueryTable instance from a QueryState.
 
         Args:
-            state: The search query state with parameters and embedding
+            state: QueryState wrapping the query and embedding
             run_id: Optional agent run ID (NULL for regular API searches)
             query_number: Query number within the run (default=1)
 
@@ -743,7 +743,7 @@ class SearchQueryTable(BaseModel):
         return cls(
             run_id=run_id,
             query_number=query_number,
-            parameters=state.parameters.model_dump(),
+            parameters=state.query.model_dump(),
             query_embedding=state.query_embedding,
         )
 

{orchestrator_core-4.6.1 → orchestrator_core-4.6.3}/orchestrator/graphql/resolvers/helpers.py

@@ -1,11 +1,17 @@
 from collections.abc import Sequence
+from functools import wraps
+from typing import Callable, Coroutine
 
+import structlog
 from sqlalchemy import CompoundSelect, Select, select
 from sqlalchemy.orm.strategy_options import _AbstractLoad
+from starlette.concurrency import run_in_threadpool
 
 from orchestrator.db import db
 from orchestrator.db.database import BaseModel
 
+logger = structlog.get_logger(__name__)
+
 
 def rows_from_statement(
     stmt: Select | CompoundSelect,
@@ -19,3 +25,12 @@ def rows_from_statement(
     result = db.session.scalars(from_stmt)
     uresult = result.unique() if unique else result
     return uresult.all()
+
+
+def make_async(f: Callable):  # type: ignore
+    @wraps(f)
+    async def wrapper(*args, **kwargs) -> Coroutine:  # type: ignore
+        logger.debug(f"**async, calling fn {f.__name__}")
+        return await run_in_threadpool(f, *args, **kwargs)
+
+    return wrapper

{orchestrator_core-4.6.1 → orchestrator_core-4.6.3}/orchestrator/graphql/resolvers/process.py

@@ -25,7 +25,7 @@ from orchestrator.db.range import apply_range_to_statement
 from orchestrator.db.sorting import Sort
 from orchestrator.db.sorting.process import process_sort_fields, sort_processes
 from orchestrator.graphql.pagination import Connection
-from orchestrator.graphql.resolvers.helpers import rows_from_statement
+from orchestrator.graphql.resolvers.helpers import make_async, rows_from_statement
 from orchestrator.graphql.schemas.process import ProcessType
 from orchestrator.graphql.types import GraphqlFilter, GraphqlSort, OrchestratorInfo
 from orchestrator.graphql.utils import (
@@ -55,7 +55,8 @@ def _enrich_process(process: ProcessTable, with_details: bool = False) -> Proces
     return ProcessSchema(**process_data)
 
 
-async def resolve_process(info: OrchestratorInfo, process_id: UUID) -> ProcessType | None:
+@make_async
+def resolve_process(info: OrchestratorInfo, process_id: UUID) -> ProcessType | None:
     query_loaders = get_query_loaders_for_gql_fields(ProcessTable, info)
     stmt = select(ProcessTable).options(*query_loaders).where(ProcessTable.process_id == process_id)
     if process := db.session.scalar(stmt):
@@ -64,7 +65,8 @@ async def resolve_process(info: OrchestratorInfo, process_id: UUID) -> ProcessTy
     return None
 
 
-async def resolve_processes(
+@make_async
+def resolve_processes(
     info: OrchestratorInfo,
     filter_by: list[GraphqlFilter] | None = None,
     sort_by: list[GraphqlSort] | None = None,

{orchestrator_core-4.6.1 → orchestrator_core-4.6.3}/orchestrator/graphql/resolvers/product.py

@@ -9,7 +9,7 @@ from orchestrator.db.range.range import apply_range_to_statement
 from orchestrator.db.sorting import Sort
 from orchestrator.db.sorting.product import product_sort_fields, sort_products
 from orchestrator.graphql.pagination import Connection
-from orchestrator.graphql.resolvers.helpers import rows_from_statement
+from orchestrator.graphql.resolvers.helpers import make_async, rows_from_statement
 from orchestrator.graphql.schemas.product import ProductType
 from orchestrator.graphql.types import GraphqlFilter, GraphqlSort, OrchestratorInfo
 from orchestrator.graphql.utils import create_resolver_error_handler, is_querying_page_data, to_graphql_result_page
@@ -19,7 +19,8 @@ from orchestrator.utils.search_query import create_sqlalchemy_select
 logger = structlog.get_logger(__name__)
 
 
-async def resolve_products(
+@make_async
+def resolve_products(
     info: OrchestratorInfo,
     filter_by: list[GraphqlFilter] | None = None,
     sort_by: list[GraphqlSort] | None = None,

{orchestrator_core-4.6.1 → orchestrator_core-4.6.3}/orchestrator/graphql/resolvers/product_block.py

@@ -13,7 +13,7 @@ from orchestrator.db.range.range import apply_range_to_statement
 from orchestrator.db.sorting import Sort
 from orchestrator.db.sorting.product_block import product_block_sort_fields, sort_product_blocks
 from orchestrator.graphql.pagination import Connection
-from orchestrator.graphql.resolvers.helpers import rows_from_statement
+from orchestrator.graphql.resolvers.helpers import make_async, rows_from_statement
 from orchestrator.graphql.schemas.product_block import ProductBlock
 from orchestrator.graphql.types import GraphqlFilter, GraphqlSort, OrchestratorInfo
 from orchestrator.graphql.utils import create_resolver_error_handler, is_querying_page_data, to_graphql_result_page
@@ -23,7 +23,8 @@ from orchestrator.utils.search_query import create_sqlalchemy_select
 logger = structlog.get_logger(__name__)
 
 
-async def resolve_product_blocks(
+@make_async
+def resolve_product_blocks(
     info: OrchestratorInfo,
     filter_by: list[GraphqlFilter] | None = None,
     sort_by: list[GraphqlSort] | None = None,

{orchestrator_core-4.6.1 → orchestrator_core-4.6.3}/orchestrator/graphql/resolvers/resource_type.py

@@ -13,7 +13,7 @@ from orchestrator.db.range import apply_range_to_statement
 from orchestrator.db.sorting import Sort
 from orchestrator.db.sorting.resource_type import resource_type_sort_fields, sort_resource_types
 from orchestrator.graphql.pagination import Connection
-from orchestrator.graphql.resolvers.helpers import rows_from_statement
+from orchestrator.graphql.resolvers.helpers import make_async, rows_from_statement
 from orchestrator.graphql.schemas.resource_type import ResourceType
 from orchestrator.graphql.types import GraphqlFilter, GraphqlSort, OrchestratorInfo
 from orchestrator.graphql.utils import create_resolver_error_handler, is_querying_page_data, to_graphql_result_page
@@ -23,7 +23,8 @@ from orchestrator.utils.search_query import create_sqlalchemy_select
 logger = structlog.get_logger(__name__)
 
 
-async def resolve_resource_types(
+@make_async
+def resolve_resource_types(
     info: OrchestratorInfo,
     filter_by: list[GraphqlFilter] | None = None,
     sort_by: list[GraphqlSort] | None = None,