orchestrator-core 4.5.2__py3-none-any.whl → 4.6.0__py3-none-any.whl

orchestrator/search/retrieval/retrievers/hybrid.py

@@ -20,7 +20,7 @@ from sqlalchemy.types import TypeEngine
 from orchestrator.db.models import AiSearchIndex
 from orchestrator.search.core.types import SearchMetadata
 
-from ..pagination import PaginationParams
+from ..pagination import PageCursor
 from .base import Retriever
 
 
@@ -127,14 +127,13 @@ class RrfHybridRetriever(Retriever):
         self,
         q_vec: list[float],
         fuzzy_term: str,
-        pagination_params: PaginationParams,
+        cursor: PageCursor | None,
         k: int = 60,
         field_candidates_limit: int = 100,
     ) -> None:
         self.q_vec = q_vec
         self.fuzzy_term = fuzzy_term
-        self.page_after_score = pagination_params.page_after_score
-        self.page_after_id = pagination_params.page_after_id
+        self.cursor = cursor
         self.k = k
         self.field_candidates_limit = field_candidates_limit
 
@@ -154,6 +153,7 @@ class RrfHybridRetriever(Retriever):
         field_candidates = (
             select(
                 AiSearchIndex.entity_id,
+                AiSearchIndex.entity_title,
                 AiSearchIndex.path,
                 AiSearchIndex.value,
                 sem_val,
@@ -178,9 +178,10 @@ class RrfHybridRetriever(Retriever):
         entity_scores = (
             select(
                 field_candidates.c.entity_id,
+                field_candidates.c.entity_title,
                 func.avg(field_candidates.c.semantic_distance).label("avg_semantic_distance"),
                 func.avg(field_candidates.c.fuzzy_score).label("avg_fuzzy_score"),
-            ).group_by(field_candidates.c.entity_id)
+            ).group_by(field_candidates.c.entity_id, field_candidates.c.entity_title)
         ).cte("entity_scores")
 
         entity_highlights = (
@@ -204,6 +205,7 @@ class RrfHybridRetriever(Retriever):
         ranked = (
             select(
                 entity_scores.c.entity_id,
+                entity_scores.c.entity_title,
                 entity_scores.c.avg_semantic_distance,
                 entity_scores.c.avg_fuzzy_score,
                 entity_highlights.c.highlight_text,
@@ -242,6 +244,7 @@ class RrfHybridRetriever(Retriever):
 
         stmt = select(
             ranked.c.entity_id,
+            ranked.c.entity_title,
             score,
             ranked.c.highlight_text,
             ranked.c.highlight_path,
@@ -262,12 +265,12 @@ class RrfHybridRetriever(Retriever):
         entity_id_column: ColumnElement,
     ) -> Select:
         """Keyset paginate by fused score + id."""
-        if self.page_after_score is not None and self.page_after_id is not None:
-            score_param = self._quantize_score_for_pagination(self.page_after_score)
+        if self.cursor is not None:
+            score_param = self._quantize_score_for_pagination(self.cursor.score)
             stmt = stmt.where(
                 or_(
                     score_column < score_param,
-                    and_(score_column == score_param, entity_id_column > self.page_after_id),
+                    and_(score_column == score_param, entity_id_column > self.cursor.id),
                 )
             )
         return stmt

orchestrator/search/retrieval/retrievers/semantic.py

@@ -17,17 +17,16 @@ from sqlalchemy.sql.expression import ColumnElement
 from orchestrator.db.models import AiSearchIndex
 from orchestrator.search.core.types import SearchMetadata
 
-from ..pagination import PaginationParams
+from ..pagination import PageCursor
 from .base import Retriever
 
 
 class SemanticRetriever(Retriever):
     """Ranks results based on the minimum semantic vector distance."""
 
-    def __init__(self, vector_query: list[float], pagination_params: PaginationParams) -> None:
+    def __init__(self, vector_query: list[float], cursor: PageCursor | None) -> None:
         self.vector_query = vector_query
-        self.page_after_score = pagination_params.page_after_score
-        self.page_after_id = pagination_params.page_after_id
+        self.cursor = cursor
 
     def apply(self, candidate_query: Select) -> Select:
         cand = candidate_query.subquery()
@@ -49,6 +48,7 @@ class SemanticRetriever(Retriever):
         combined_query = (
             select(
                 AiSearchIndex.entity_id,
+                AiSearchIndex.entity_title,
                 score,
                 func.first_value(AiSearchIndex.value)
                 .over(partition_by=AiSearchIndex.entity_id, order_by=[dist.asc(), AiSearchIndex.path.asc()])
@@ -60,12 +60,13 @@ class SemanticRetriever(Retriever):
             .select_from(AiSearchIndex)
             .join(cand, cand.c.entity_id == AiSearchIndex.entity_id)
             .where(AiSearchIndex.embedding.isnot(None))
-            .distinct(AiSearchIndex.entity_id)
+            .distinct(AiSearchIndex.entity_id, AiSearchIndex.entity_title)
         )
         final_query = combined_query.subquery("ranked_semantic")
 
         stmt = select(
             final_query.c.entity_id,
+            final_query.c.entity_title,
             final_query.c.score,
             final_query.c.highlight_text,
             final_query.c.highlight_path,
@@ -83,12 +84,12 @@ class SemanticRetriever(Retriever):
         self, stmt: Select, score_column: ColumnElement, entity_id_column: ColumnElement
     ) -> Select:
         """Apply semantic score pagination with precise Decimal handling."""
-        if self.page_after_score is not None and self.page_after_id is not None:
-            score_param = self._quantize_score_for_pagination(self.page_after_score)
+        if self.cursor is not None:
+            score_param = self._quantize_score_for_pagination(self.cursor.score)
             stmt = stmt.where(
                 or_(
                     score_column < score_param,
-                    and_(score_column == score_param, entity_id_column > self.page_after_id),
+                    and_(score_column == score_param, entity_id_column > self.cursor.id),
                 )
             )
         return stmt

orchestrator/search/retrieval/retrievers/structured.py

@@ -15,22 +15,22 @@ from sqlalchemy import Select, literal, select
 
 from orchestrator.search.core.types import SearchMetadata
 
-from ..pagination import PaginationParams
+from ..pagination import PageCursor
 from .base import Retriever
 
 
 class StructuredRetriever(Retriever):
     """Applies a dummy score for purely structured searches with no text query."""
 
-    def __init__(self, pagination_params: PaginationParams) -> None:
-        self.page_after_id = pagination_params.page_after_id
+    def __init__(self, cursor: PageCursor | None) -> None:
+        self.cursor = cursor
 
     def apply(self, candidate_query: Select) -> Select:
         cand = candidate_query.subquery()
-        stmt = select(cand.c.entity_id, literal(1.0).label("score")).select_from(cand)
+        stmt = select(cand.c.entity_id, cand.c.entity_title, literal(1.0).label("score")).select_from(cand)
 
-        if self.page_after_id:
-            stmt = stmt.where(cand.c.entity_id > self.page_after_id)
+        if self.cursor is not None:
+            stmt = stmt.where(cand.c.entity_id > self.cursor.id)
 
         return stmt.order_by(cand.c.entity_id.asc())
 

orchestrator/search/schemas/parameters.py

@@ -12,9 +12,9 @@
 # limitations under the License.
 
 import uuid
-from typing import Any, Literal
+from typing import Any, ClassVar, Literal
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, TypeAdapter
 
 from orchestrator.search.core.types import ActionType, EntityType
 from orchestrator.search.filters import FilterTree
@@ -23,6 +23,9 @@ from orchestrator.search.filters import FilterTree
 class BaseSearchParameters(BaseModel):
     """Base model with common search parameters."""
 
+    DEFAULT_EXPORT_LIMIT: ClassVar[int] = 1000
+    MAX_EXPORT_LIMIT: ClassVar[int] = 10000
+
     action: ActionType = Field(default=ActionType.SELECT, description="The action to perform.")
     entity_type: EntityType
 
@@ -33,14 +36,18 @@ class BaseSearchParameters(BaseModel):
     )
 
     limit: int = Field(default=10, ge=1, le=30, description="Maximum number of search results to return.")
+    export_limit: int = Field(
+        default=DEFAULT_EXPORT_LIMIT, ge=1, le=MAX_EXPORT_LIMIT, description="Maximum number of results to export."
+    )
     model_config = ConfigDict(extra="forbid")
 
     @classmethod
-    def create(cls, entity_type: EntityType, **kwargs: Any) -> "BaseSearchParameters":
-        try:
-            return PARAMETER_REGISTRY[entity_type](entity_type=entity_type, **kwargs)
-        except KeyError:
-            raise ValueError(f"No search parameter class found for entity type: {entity_type.value}")
+    def create(cls, **kwargs: Any) -> "SearchParameters":
+        """Create the correct search parameter subclass instance based on entity_type."""
+        from orchestrator.search.schemas.parameters import SearchParameters
+
+        adapter: TypeAdapter = TypeAdapter(SearchParameters)
+        return adapter.validate_python(kwargs)
 
     @property
     def vector_query(self) -> str | None:
@@ -121,9 +128,6 @@ class ProcessSearchParameters(BaseSearchParameters):
     )
 
 
-PARAMETER_REGISTRY: dict[EntityType, type[BaseSearchParameters]] = {
-    EntityType.SUBSCRIPTION: SubscriptionSearchParameters,
-    EntityType.PRODUCT: ProductSearchParameters,
-    EntityType.WORKFLOW: WorkflowSearchParameters,
-    EntityType.PROCESS: ProcessSearchParameters,
-}
+SearchParameters = (
+    SubscriptionSearchParameters | ProductSearchParameters | WorkflowSearchParameters | ProcessSearchParameters
+)

orchestrator/search/schemas/results.py

@@ -15,7 +15,7 @@ from typing import Literal
 
 from pydantic import BaseModel, ConfigDict
 
-from orchestrator.search.core.types import FilterOp, SearchMetadata, UIType
+from orchestrator.search.core.types import EntityType, FilterOp, SearchMetadata, UIType
 
 
 class MatchingField(BaseModel):
@@ -30,6 +30,8 @@ class SearchResult(BaseModel):
     """Represents a single search result item."""
 
     entity_id: str
+    entity_type: EntityType
+    entity_title: str
     score: float
     perfect_match: int = 0
     matching_field: MatchingField | None = None
@@ -40,6 +42,7 @@ class SearchResponse(BaseModel):
 
     results: list[SearchResult]
     metadata: SearchMetadata
+    query_embedding: list[float] | None = None
 
 
 class ValueSchema(BaseModel):

orchestrator/settings.py

@@ -57,6 +57,7 @@ class AppSettings(BaseSettings):
     EXECUTOR: str = ExecutorType.THREADPOOL
     WORKFLOWS_SWAGGER_HOST: str = "localhost"
     WORKFLOWS_GUI_URI: str = "http://localhost:3000"
+    BASE_URL: str = "http://localhost:8080"  # Base URL for the API (used for generating export URLs)
     DATABASE_URI: PostgresDsn = "postgresql://nwa:nwa@localhost/orchestrator-core"  # type: ignore
     MAX_WORKERS: int = 5
     MAIL_SERVER: str = "localhost"

orchestrator/utils/auth.py

@@ -1,9 +1,10 @@
 from collections.abc import Callable
-from typing import TypeAlias
+from typing import TypeAlias, TypeVar
 
 from oauth2_lib.fastapi import OIDCUserModel
 
 # This file is broken out separately to avoid circular imports.
 
 # Can instead use "type Authorizer = ..." in later Python versions.
-Authorizer: TypeAlias = Callable[[OIDCUserModel | None], bool]
+T = TypeVar("T", bound=OIDCUserModel)
+Authorizer: TypeAlias = Callable[[T | None], bool]

orchestrator/workflow.py

@@ -235,7 +235,10 @@ def make_workflow(
     return wrapping_function
 
 
-def step(name: str) -> Callable[[StepFunc], Step]:
+def step(
+    name: str,
+    retry_auth_callback: Authorizer | None = None,
+) -> Callable[[StepFunc], Step]:
     """Mark a function as a workflow step."""
 
     def decorator(func: StepFunc) -> Step:
@@ -255,12 +258,19 @@ def step(name: str) -> Callable[[StepFunc], Step]:
                     logger.warning("Step failed", exc_info=ex)
                     return Failed(ex)
 
-        return make_step_function(wrapper, name)
+        return make_step_function(
+            wrapper,
+            name,
+            retry_auth_callback=retry_auth_callback,
+        )
 
     return decorator
 
 
-def retrystep(name: str) -> Callable[[StepFunc], Step]:
+def retrystep(
+    name: str,
+    retry_auth_callback: Authorizer | None = None,
+) -> Callable[[StepFunc], Step]:
     """Mark a function as a retryable workflow step.
 
     If this step fails it goes to `Waiting` were it will be retried periodically. If it `Success` it acts as a normal
@@ -283,7 +293,11 @@ def retrystep(name: str) -> Callable[[StepFunc], Step]:
                 except Exception as ex:
                     return Waiting(ex)
 
-        return make_step_function(wrapper, name)
+        return make_step_function(
+            wrapper,
+            name,
+            retry_auth_callback=retry_auth_callback,
+        )
 
     return decorator
 
@@ -349,7 +363,9 @@ def _extend_step_group_steps(name: str, steps: StepList) -> StepList:
     return enter_step >> steps >> exit_step
 
 
-def step_group(name: str, steps: StepList, extract_form: bool = True) -> Step:
+def step_group(
+    name: str, steps: StepList, extract_form: bool = True, retry_auth_callback: Authorizer | None = None
+) -> Step:
     """Add a group of steps to the workflow as a single step.
 
     A step group is a sequence of steps that act as a single step.
@@ -362,6 +378,7 @@ def step_group(name: str, steps: StepList, extract_form: bool = True) -> Step:
         name: The name of the step
         steps: The sub steps in the step group
         extract_form: Whether to attach the first form of the sub steps to the step group
+        retry_auth_callback: Callback to determine if user is authorized to retry this group on failure
     """
 
     steps = _extend_step_group_steps(name, steps)
@@ -392,7 +409,7 @@ def step_group(name: str, steps: StepList, extract_form: bool = True) -> Step:
 
     # Make sure we return a form is a sub step has a form
     form = next((sub_step.form for sub_step in steps if sub_step.form), None) if extract_form else None
-    return make_step_function(func, name, form)
+    return make_step_function(func, name, form, retry_auth_callback=retry_auth_callback)
 
 
 def _create_endpoint_step(key: str = DEFAULT_CALLBACK_ROUTE_KEY) -> StepFunc:

orchestrator/workflows/tasks/validate_product_type.py

@@ -16,7 +16,7 @@ from typing import Any
 import structlog
 
 from orchestrator.db import ProductTable
-from orchestrator.forms import FormPage
+from orchestrator.forms import SubmitFormPage
 from orchestrator.forms.validators import Choice
 from orchestrator.services.subscriptions import (
     get_subscriptions_on_product_table_in_sync,
@@ -32,7 +32,7 @@ from pydantic_forms.types import FormGenerator, State
 logger = structlog.get_logger(__name__)
 
 
-def create_select_product_type_form() -> type[FormPage]:
+def create_select_product_type_form() -> type[SubmitFormPage]:
     """Get and create the choices form for the product type."""
 
     @cache
@@ -41,7 +41,7 @@ def create_select_product_type_form() -> type[FormPage]:
 
     ProductTypeChoices = Choice.__call__("Product Type", get_product_type_choices())
 
-    class SelectProductTypeForm(FormPage):
+    class SelectProductTypeForm(SubmitFormPage):
         product_type: ProductTypeChoices  # type: ignore
 
     return SelectProductTypeForm

{orchestrator_core-4.5.2.dist-info → orchestrator_core-4.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orchestrator-core
-Version: 4.5.2
+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
@@ -55,7 +55,7 @@ Requires-Dist: python-rapidjson>=1.18,<1.21
 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: sentry-sdk[fastapi]>=2.29.1
 Requires-Dist: sqlalchemy==2.0.41
 Requires-Dist: sqlalchemy-utils==0.41.2
 Requires-Dist: strawberry-graphql>=0.281.0
@@ -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.