orchestrator-core 2.9.2rc3__tar.gz → 2.10.0rc1__tar.gz

{orchestrator_core-2.9.2rc3 → orchestrator_core-2.10.0rc1}/.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 2.9.2rc3
+current_version = 2.10.0rc1
 commit = False
 tag = False
 parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(rc(?P<build>\d+))?

{orchestrator_core-2.9.2rc3 → orchestrator_core-2.10.0rc1}/.github/workflows/build-push-container.yml

@@ -56,5 +56,3 @@ jobs:
           push: true
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
-          build-args: |
-            VERSION=${{ fromJSON(steps.meta.outputs.json).labels['org.opencontainers.image.version'] }}

orchestrator_core-2.10.0rc1/Dockerfile

@@ -0,0 +1,24 @@
+# Build stage
+FROM python:3.11-slim AS build
+WORKDIR /app
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends git build-essential \
+    && rm -rf /var/lib/apt/lists/*
+COPY . .
+RUN pip install --upgrade pip --no-cache-dir
+RUN pip install build --no-cache-dir
+RUN python -m build --wheel --outdir dist
+
+# Final stage
+FROM python:3.11-slim
+ENV PIP_ROOT_USER_ACTION=ignore
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends git \
+    && rm -rf /var/lib/apt/lists/*
+RUN pip install --upgrade pip --no-cache-dir
+COPY --from=build /app/dist/*.whl /tmp/
+RUN pip install /tmp/*.whl --no-cache-dir
+RUN useradd orchestrator
+USER orchestrator
+WORKDIR /home/orchestrator
+CMD ["uvicorn", "--host", "0.0.0.0", "--port", "8080", "main:app"]

{orchestrator_core-2.9.2rc3 → orchestrator_core-2.10.0rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: orchestrator-core
-Version: 2.9.2rc3
+Version: 2.10.0rc1
 Summary: This is the orchestrator workflow engine.
 Requires-Python: >=3.11,<3.14
 Classifier: Intended Audience :: Information Technology
@@ -27,30 +27,30 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
 Classifier: Topic :: Internet :: WWW/HTTP
-Requires-Dist: alembic==1.13.3
+Requires-Dist: alembic==1.14.1
 Requires-Dist: anyio>=3.7.0
 Requires-Dist: click==8.*
 Requires-Dist: deprecated
 Requires-Dist: deepmerge==1.1.1
 Requires-Dist: fastapi~=0.115.2
 Requires-Dist: fastapi-etag==0.4.0
-Requires-Dist: more-itertools~=10.5.0
+Requires-Dist: more-itertools~=10.6.0
 Requires-Dist: itsdangerous
 Requires-Dist: Jinja2==3.1.5
-Requires-Dist: orjson==3.10.9
+Requires-Dist: orjson==3.10.15
 Requires-Dist: psycopg2-binary==2.9.10
 Requires-Dist: pydantic[email]~=2.8.2
-Requires-Dist: pydantic-settings~=2.5.2
+Requires-Dist: pydantic-settings~=2.7.1
 Requires-Dist: python-dateutil==2.8.2
 Requires-Dist: python-rapidjson>=1.18,<1.21
 Requires-Dist: pytz==2024.1
 Requires-Dist: redis==5.0.3
 Requires-Dist: schedule==1.1.0
 Requires-Dist: sentry-sdk[fastapi]~=2.18.0
-Requires-Dist: SQLAlchemy==2.0.36
+Requires-Dist: SQLAlchemy==2.0.38
 Requires-Dist: SQLAlchemy-Utils==0.41.2
 Requires-Dist: structlog
-Requires-Dist: typer==0.12.5
+Requires-Dist: typer==0.15.1
 Requires-Dist: uvicorn[standard]~=0.32.0
 Requires-Dist: nwa-stdlib~=1.9.0
 Requires-Dist: oauth2-lib~=2.4.0

{orchestrator_core-2.9.2rc3 → orchestrator_core-2.10.0rc1}/docs/reference-docs/cli.md

@@ -26,21 +26,16 @@ Interact with the application database. By default, does nothing, specify `main.
       show_symbol_type_toc: false
       show_symbol_type_heading: false
       members:
-        - init
-        - revision
-        - upgrade
         - downgrade
         - heads
         - history
-        - merge
-        - migrate_workflows
-        - heads
-        - history
         - init
         - merge
         - migrate_workflows
+        - migrate_tasks
         - revision
         - upgrade
+
       heading_level: 3
 
 ### migrate-domain-models

{orchestrator_core-2.9.2rc3 → orchestrator_core-2.10.0rc1}/docs/reference-docs/graphql.md

@@ -677,3 +677,10 @@ customer_field.name = "customer"
 override_class(ProcessType, [customer_field])
 custom_subscription_interface = override_class(SubscriptionInterface, [customer_field])
 ```
+
+### Behavior of filterBy
+By default, string matching is configured for exact matches, i.e a search for `10` will return ONLY `10`
+and won't include `10G` or `100G`.
+Searching can also be configured for partial matching as well, where a search for `10` would include `10G` and `100G`.
+
+This can be controlled by setting the variable `FILTER_BY_MODE` can be set to a value of `exact` or `partial` as needed.

{orchestrator_core-2.9.2rc3 → orchestrator_core-2.10.0rc1}/docs/reference-docs/search.md

@@ -47,6 +47,7 @@ Some search query examples for Subscriptions:
 | `test*`                                                  | any field starting with `test` (Prefix search)                       |
 
 Note that:
+
 * For other objects the query syntax is the same
 * Searching is case-insensitive
 * Ordering of words does not matter (unless it is a Phrase)
@@ -87,6 +88,7 @@ Postgres _Full Text Search_ (TS) has extensive [documentation](https://www.postg
 The query behind `subscriptions_search` retrieves Subscriptions joined with several other tables (as shown in the previous diagram), forming a "document" of keywords that in some way relate to the subscription.
 
 Each document is turned into a _tsvector_ with Postgres function `to_tsvector()` which consists of these phases:
+
 * Parse document into _tokens_: split text into _tokens_ using special characters as delimiters
 * Convert tokens into _lexemes_: a lexeme is a normalized token, i.e. this folds upper-case to lower-case. This step can also normalize based on language, but we disable that by using the `'simple'` dictionary (shown in diagram above)
 * Create vector optimized for search: store array of _lexemes_ along with positional information

{orchestrator_core-2.9.2rc3 → orchestrator_core-2.10.0rc1}/orchestrator/__init__.py

@@ -13,7 +13,7 @@
 
 """This is the orchestrator workflow engine."""
 
-__version__ = "2.9.2rc3"
+__version__ = "2.10.0rc1"
 
 from orchestrator.app import OrchestratorCore
 from orchestrator.settings import app_settings

{orchestrator_core-2.9.2rc3 → orchestrator_core-2.10.0rc1}/orchestrator/api/api_v1/endpoints/processes.py

@@ -240,6 +240,7 @@ def abort_process_endpoint(process_id: UUID, request: Request, user: str = Depen
     broadcast_func = api_broadcast_process_data(request)
     try:
         abort_process(process, user, broadcast_func=broadcast_func)
+        broadcast_invalidate_status_counts()
         return
     except Exception as e:
         raise_status(HTTPStatus.INTERNAL_SERVER_ERROR, str(e))

{orchestrator_core-2.9.2rc3 → orchestrator_core-2.10.0rc1}/orchestrator/cli/database.py

@@ -25,6 +25,7 @@ import orchestrator.workflows
 from orchestrator.cli.domain_gen_helpers.types import ModelUpdates
 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
 from orchestrator.cli.migrate_workflows import create_workflows_migration_wizard
 from orchestrator.cli.migration_helpers import create_migration_file
 from orchestrator.db import init_database
@@ -397,3 +398,80 @@ def migrate_workflows(
 
     create_migration_file(alembic_cfg(), sql_upgrade_str, sql_downgrade_str, message, preamble=preamble)
     return None
+
+
+@app.command(help="Create migration file based on diff tasks in db")
+def migrate_tasks(
+    message: str = typer.Argument(..., help="Migration name"),
+    test: bool = typer.Option(False, help="Optional boolean if you don't want to generate a migration file"),
+) -> tuple[list[dict], list[dict]] | None:
+    """The `migrate-tasks` command creates a migration file based on the difference between tasks in the database and registered TaskInstances in your codebase.
+
+    !!! warning "BACKUP YOUR DATABASE BEFORE USING THE MIGRATION!"
+
+    You will be prompted with inputs for new models and resource type updates.
+    Resource type updates are only handled when it's renamed in all product blocks.
+
+    Args:
+        message: Message/description of the generated migration.
+        test: Optional boolean if you don't want to generate a migration file.
+
+    Returns None unless `--test` is used, in which case it returns:
+        - tuple:
+            - list of upgrade SQL statements in string format.
+            - list of downgrade SQL statements in string format.
+
+    CLI Arguments:
+        ```sh
+        Arguments:
+            MESSAGE  Migration name  [required]
+
+        Options:
+            --test / --no-test  Optional boolean if you don't want to generate a migration
+            file  [default: no-test]
+        ```
+    """
+    if not app_settings.TESTING:
+        init_database(app_settings)
+
+    if test:
+        print(  # noqa: T001, T201
+            f"{str_fmt('NOTE:', flags=[COLOR.BOLD, COLOR.CYAN])} Running in test mode. No migration file will be generated.\n"
+        )
+
+    tasks_to_add, tasks_to_delete = create_tasks_migration_wizard()
+
+    # String 'template' arguments
+    import_str = "from orchestrator.migrations.helpers import create_task, delete_workflow\n"
+    tpl_preamble_lines = []
+    tpl_upgrade_lines = []
+    tpl_downgrade_lines = []
+
+    if tasks_to_add:
+        tpl_preamble_lines.append(f"new_tasks = {json.dumps(tasks_to_add, indent=4)}\n")
+        tpl_upgrade_lines.extend([(" " * 4) + "for task in new_tasks:", (" " * 8) + "create_task(conn, task)"])
+        tpl_downgrade_lines.extend(
+            [(" " * 4) + "for task in new_tasks:", (" " * 8) + 'delete_workflow(conn, task["name"])']
+        )
+
+    if tasks_to_delete:
+        tpl_preamble_lines.append(f"old_tasks = {json.dumps(tasks_to_delete, indent=4)}\n")
+        tpl_upgrade_lines.extend(
+            [(" " * 4) + "for task in old_tasks:", (" " * 8) + 'delete_workflow(conn, task["name"])']
+        )
+        tpl_downgrade_lines.extend([(" " * 4) + "for task in old_tasks:", (" " * 8) + "create_task(conn, task)"])
+
+    preamble = "\n".join(
+        [
+            import_str,
+            *tpl_preamble_lines,
+        ]
+    )
+    sql_upgrade_str = "\n".join(tpl_upgrade_lines)
+    sql_downgrade_str = "\n".join(tpl_downgrade_lines)
+
+    if test:
+        return tasks_to_add, tasks_to_delete
+
+    create_migration_file(alembic_cfg(), sql_upgrade_str, sql_downgrade_str, message, preamble=preamble)
+    return None

orchestrator_core-2.10.0rc1/orchestrator/cli/migrate_tasks.py

@@ -0,0 +1,188 @@
+import itertools
+import operator
+from collections.abc import Iterable
+from typing import TypeVar, cast
+
+import structlog
+from sqlalchemy import select
+from tabulate import tabulate
+
+import orchestrator.workflows
+from orchestrator.cli.helpers.input_helpers import _enumerate_menu_keys, _prompt_user_menu, get_user_input
+from orchestrator.cli.helpers.print_helpers import COLOR, noqa_print, print_fmt
+from orchestrator.db import WorkflowTable, db
+from orchestrator.targets import Target
+from orchestrator.workflow import Workflow
+from orchestrator.workflows import get_workflow
+
+logger = structlog.get_logger(__name__)
+
+T = TypeVar("T")
+
+
+def _print_tasks_table(tasks: list[WorkflowTable]) -> None:
+    items = [(task.name, task.description) for task in tasks]
+    print_fmt(
+        tabulate(
+            items,
+            headers=["#", "name", "description"],
+            showindex=itertools.count(1),
+        ),
+        end="\n\n",
+    )
+
+
+def _add_task(tasks: dict[str, Workflow], state: dict) -> dict:
+    print_fmt("\nAdd new task\n", flags=[COLOR.UNDERLINE])
+
+    if not tasks:
+        noqa_print("No registered tasks found to add to the database")
+        return state
+
+    noqa_print("\nWhich task should be added?")
+
+    already_used_tasks = {task["name"] for task in state["tasks_to_add"] + state["tasks_to_delete"]}
+    task_options = [(task, task) for task in tasks.keys() if task not in already_used_tasks]
+    task_name = _prompt_user_menu([*task_options, ("cancel", None)], keys=[*_enumerate_menu_keys(task_options), "q"])
+    if not task_name:
+        # Menu cancelled
+        return state
+
+    task_to_add = {"name": task_name, "description": tasks[task_name].description}
+    return {**state, "tasks_to_add": [*state["tasks_to_add"], task_to_add]}
+
+
+def _delete_task(tasks: Iterable[WorkflowTable], state: dict) -> dict:
+    print_fmt("\nDelete existing task\n", flags=[COLOR.UNDERLINE])
+    already_used_tasks = {task["name"] for task in state["tasks_to_add"] + state["tasks_to_delete"]}
+    items = [(task.name, task.description) for task in tasks if task not in already_used_tasks]
+    items = sorted(items, key=operator.itemgetter(1, 1))
+    keys = ["#", "name", "description"]
+    if not items:
+        noqa_print("No deletable tasks in database")
+        return state
+
+    print_fmt(
+        tabulate(
+            items,
+            headers=keys,
+            showindex=itertools.count(1),
+        ),
+        end="\n\n",
+    )
+    task_num = get_user_input("Which task do you want to delete? (q to cancel) ", "q")
+    if not task_num.isdigit():
+        return state
+    task_index = int(task_num) - 1
+    if 0 <= task_index < len(items):
+        item = dict(zip(keys[1:], items[task_index]))
+        return {**state, "tasks_to_delete": [*state["tasks_to_delete"], item]}
+    return state
+
+
+def _show_state(state: dict) -> dict:
+    print_fmt("\nTasks to add:", flags=[COLOR.GREEN])
+    print_fmt(
+        tabulate(
+            state["tasks_to_add"],
+            headers="keys",
+            showindex=itertools.count(1),
+        ),
+        end="\n\n",
+    )
+
+    print_fmt("Tasks to delete:", flags=[COLOR.RED])
+    print_fmt(
+        tabulate(
+            state["tasks_to_delete"],
+            headers="keys",
+            showindex=itertools.count(1),
+        ),
+        end="\n\n",
+    )
+    return state
+
+
+def delete_dangling_tasks(tasks: list[WorkflowTable], state: dict) -> dict:
+    if not tasks:
+        noqa_print("No dangling tasks found.")
+        return state
+
+    print_fmt(
+        "\nThe following tasks were found in the database that do not have a corresponding LazyWorkflowInstance:\n"
+    )
+    _print_tasks_table(tasks)
+    should_delete_dangling_tasks = (
+        get_user_input("Do you wish to delete all dangling tasks from the database? [y/n]: ", "n").lower() == "y"
+    )
+
+    if not should_delete_dangling_tasks:
+        noqa_print("Cancelling")
+        return state
+
+    already_used_tasks = {task["name"] for task in state["tasks_to_add"] + state["tasks_to_delete"]}
+    keys = ["name", "description"]
+    items = [
+        {"name": task.name, "description": task.description}
+        for k, task in zip(keys, tasks)
+        if task.name not in already_used_tasks
+    ]
+    return {**state, "tasks_to_delete": [*state["tasks_to_delete"], *items]}
+
+
+def create_tasks_migration_wizard() -> tuple[list[dict], list[dict]]:
+    """Create tuple with lists for tasks to add and delete.
+
+    Returns tuple:
+        - list of task items to add in the migration
+        - list of task items to delete in the migration
+    """
+    database_tasks = {
+        task.name: task for task in list(db.session.scalars(select(WorkflowTable))) if task.target == Target.SYSTEM
+    }
+    registered_wf_instances = {
+        task: cast(Workflow, get_workflow(task)) for task in orchestrator.workflows.ALL_WORKFLOWS.keys()
+    }
+
+    registered_tasks = dict(
+        filter(
+            lambda task: task[1].target == Target.SYSTEM and task[0] in database_tasks.keys(),
+            registered_wf_instances.items(),
+        )
+    )
+    available_tasks = dict(
+        filter(
+            lambda task: task[1].target == Target.SYSTEM and task[0] not in database_tasks.keys(),
+            registered_wf_instances.items(),
+        )
+    )
+    unregistered_tasks = [task for task in database_tasks.values() if task.name not in registered_tasks.keys()]
+
+    # Main menu loop
+    state = {"tasks_to_add": [], "tasks_to_delete": [], "done": False}
+    while not state["done"]:
+        print_fmt("\nWhat do you want to do?\n", flags=[COLOR.UNDERLINE, COLOR.BOLD])
+        choice_fn = _prompt_user_menu(
+            [
+                ("Add task to database", lambda s: _add_task(available_tasks, s)),
+                ("Delete task from database", lambda s: _delete_task(database_tasks.values(), s)),
+                (
+                    "Delete unregistered tasks from database",
+                    lambda s: delete_dangling_tasks(unregistered_tasks, s),
+                ),
+                ("Finish and create migration file", lambda s: {**s, "done": True, "abort": False}),
+                ("Show current diff", _show_state),
+                ("Quit menu without creating a migration file", lambda s: {**s, "done": True, "abort": True}),
+            ],
+            keys=["a", "x", "c", "y", "d", "q"],
+        )
+        if choice_fn:
+            state = choice_fn(state)  # type: ignore
+
+    if state.get("abort"):
+        return [], []
+
+    logger.info("Create tasks", create_tasks=state["tasks_to_add"])
+    logger.info("Delete tasks", delete_tasks=state["tasks_to_delete"])
+
+    return state["tasks_to_add"], state["tasks_to_delete"]  # type: ignore

{orchestrator_core-2.9.2rc3 → orchestrator_core-2.10.0rc1}/orchestrator/db/filters/search_filters/inferred_filter.py

@@ -21,6 +21,7 @@ from sqlalchemy import BinaryExpression, Cast, ColumnClause, ColumnElement, Stri
 from sqlalchemy.sql.functions import coalesce
 from sqlalchemy.sql.operators import eq
 
+from orchestrator.settings import app_settings
 from orchestrator.utils.search_query import Node, WhereCondGenerator
 
 
@@ -67,7 +68,7 @@ def _filter_string(field: ColumnElement) -> WhereCondGenerator:
         if node[0] == "ValueGroup":
             vals = [w[1] for w in node[1] if w[0] in ["Word", "PrefixWord"]]  # Only works for (Prefix)Words atm
             return field.in_(vals)
-        return field.ilike(f"%{node[1]}%")
+        return field.ilike(f"{node[1]}") if app_settings.FILTER_BY_MODE == "exact" else field.ilike(f"%{node[1]}%")
 
     return _clause_gen
 

{orchestrator_core-2.9.2rc3 → orchestrator_core-2.10.0rc1}/orchestrator/graphql/resolvers/__init__.py

@@ -5,6 +5,7 @@ from orchestrator.graphql.resolvers.product_block import resolve_product_blocks
 from orchestrator.graphql.resolvers.resource_type import resolve_resource_types
 from orchestrator.graphql.resolvers.settings import SettingsMutation, resolve_settings
 from orchestrator.graphql.resolvers.subscription import resolve_subscription, resolve_subscriptions
+from orchestrator.graphql.resolvers.version import resolve_version
 from orchestrator.graphql.resolvers.workflow import resolve_workflows
 
 __all__ = [
@@ -19,4 +20,5 @@ __all__ = [
     "resolve_customer",
     "resolve_resource_types",
     "resolve_workflows",
+    "resolve_version",
 ]

orchestrator_core-2.10.0rc1/orchestrator/graphql/resolvers/version.py

@@ -0,0 +1,25 @@
+from structlog import get_logger
+
+from orchestrator import __version__
+from orchestrator.graphql.schemas.version import VersionType
+from orchestrator.graphql.types import OrchestratorInfo
+from orchestrator.graphql.utils import create_resolver_error_handler
+
+logger = get_logger(__name__)
+
+
+VERSIONS = [f"orchestrator-core: {__version__}"]
+
+
+def resolve_version(info: OrchestratorInfo) -> VersionType | None:
+    logger.debug("resolve_version() called")
+    _error_handler = create_resolver_error_handler(info)
+
+    ver = None
+    try:
+        ver = VersionType(application_versions=VERSIONS)
+    except Exception as e:
+        logger.error(f"Error getting version: {str(e)}")
+        _error_handler("Failed to retrieve orchestrator_core version", extensions={"code": "PACKAGE_VERSION_ERROR"})
+
+    return ver

{orchestrator_core-2.9.2rc3 → orchestrator_core-2.10.0rc1}/orchestrator/graphql/schema.py

@@ -47,6 +47,7 @@ from orchestrator.graphql.resolvers import (
     resolve_settings,
     resolve_subscription,
     resolve_subscriptions,
+    resolve_version,
     resolve_workflows,
 )
 from orchestrator.graphql.schemas import DEFAULT_GRAPHQL_MODELS
@@ -57,6 +58,7 @@ from orchestrator.graphql.schemas.product_block import ProductBlock
 from orchestrator.graphql.schemas.resource_type import ResourceType
 from orchestrator.graphql.schemas.settings import StatusType
 from orchestrator.graphql.schemas.subscription import SubscriptionInterface
+from orchestrator.graphql.schemas.version import VersionType
 from orchestrator.graphql.schemas.workflow import Workflow
 from orchestrator.graphql.types import SCALAR_OVERRIDES, OrchestratorContext, ScalarOverrideType, StrawberryModelType
 from orchestrator.services.process_broadcast_thread import ProcessDataBroadcastThread
@@ -95,6 +97,7 @@ class OrchestratorQuery:
         resolver=resolve_settings,
         description="Returns information about cache, workers, and global engine settings",
     )
+    version: VersionType = authenticated_field(resolver=resolve_version, description="Returns version information")
 
 
 @strawberry.federation.type(description="Orchestrator customer Query")

orchestrator_core-2.10.0rc1/orchestrator/graphql/schemas/version.py

@@ -0,0 +1,6 @@
+import strawberry
+
+
+@strawberry.type
+class VersionType:
+    application_versions: list[str]

{orchestrator_core-2.9.2rc3 → orchestrator_core-2.10.0rc1}/orchestrator/migrations/helpers.py

@@ -164,6 +164,36 @@ def create_workflow(conn: sa.engine.Connection, workflow: dict) -> None:
     )
 
 
+def create_task(conn: sa.engine.Connection, task: dict) -> None:
+    """Create a new task.
+
+    Args:
+        conn: DB connection as available in migration main file.
+        task: Dict with data for a new workflow.
+            name: Name of the task.
+            description: Description of the workflow.
+
+    Usage:
+        >>> task = {
+            "name": "task_name",
+            "description": "task description",
+        }
+        >>> create_workflow(conn, task)
+    """
+
+    conn.execute(
+        sa.text(
+            """
+                INSERT INTO workflows(name, target, description)
+                    VALUES (:name, 'SYSTEM', :description)
+                    ON CONFLICT DO NOTHING
+                    RETURNING workflow_id
+            """
+        ),
+        task,
+    )
+
+
 def create_workflows(conn: sa.engine.Connection, new: dict) -> None:
     """Create new workflows.
 
@@ -894,7 +924,7 @@ def delete_product_block(conn: sa.engine.Connection, name: str) -> None:
 
 
 def delete_workflow(conn: sa.engine.Connection, name: str) -> None:
-    """Delete a workflow and it's occurrences in products.
+    """Delete a workflow and its occurrences in products.
 
     Note: the cascading delete rules in postgres will also ensure removal from `products_workflows`.
 

{orchestrator_core-2.9.2rc3 → orchestrator_core-2.10.0rc1}/orchestrator/settings.py

@@ -14,6 +14,7 @@
 import secrets
 import string
 from pathlib import Path
+from typing import Literal
 
 from pydantic import PostgresDsn, RedisDsn
 from pydantic_settings import BaseSettings
@@ -82,6 +83,7 @@ class AppSettings(BaseSettings):
     ENABLE_GRAPHQL_PROFILING_EXTENSION: bool = False
     ENABLE_GRAPHQL_STATS_EXTENSION: bool = False
     VALIDATE_OUT_OF_SYNC_SUBSCRIPTIONS: bool = False
+    FILTER_BY_MODE: Literal["partial", "exact"] = "exact"
 
 
 app_settings = AppSettings()

{orchestrator_core-2.9.2rc3 → orchestrator_core-2.10.0rc1}/orchestrator/utils/search_query.py

@@ -5,12 +5,10 @@ from itertools import chain
 from typing import Any, Union, cast
 
 import structlog
-from sqlalchemy import BinaryExpression, ColumnElement, CompoundSelect, Select, column, false, func, not_, or_, select
+from sqlalchemy import BinaryExpression, ColumnElement, CompoundSelect, Select, false, not_, or_
 from sqlalchemy.orm import InstrumentedAttribute, MappedColumn
 
-from orchestrator.db import db
 from orchestrator.db.database import BaseModel
-from orchestrator.db.helpers import get_postgres_version
 from orchestrator.utils.helpers import camel_to_snake
 
 logger = structlog.getLogger(__name__)
@@ -257,28 +255,10 @@ class Parser:
 
 
 class TSQueryVisitor:
-
     _glue_chars = re.compile(r"[-_@#$%^&]")
 
     @staticmethod
     def _split_term(term: str) -> list[str]:
-        """Workaround for the way Postgres <14 parses text with to_tsquery.
-
-        For Postgres <14, we issue a database query to parse the text for us in a way that is compatible with to_tsvector. This is the same behavior as Postgres >=14.
-        """
-
-        # TODO: Remove this workaround when support for Postgres <14 is dropped
-        # https://github.com/workfloworchestrator/orchestrator-core/issues/621
-
-        if get_postgres_version() < 14:
-            # tokid 12 is the space separator token
-            stmt = (
-                select(func.array_agg(column("token")))
-                .select_from(func.ts_parse("default", func.replace(term, "-", "_")))
-                .where(column("tokid") != 12)
-            )
-            return db.session.scalar(stmt) or []
-
         return [part.strip() for part in TSQueryVisitor._glue_chars.split(term) if part and not part.isspace()]
 
     @staticmethod

{orchestrator_core-2.9.2rc3 → orchestrator_core-2.10.0rc1}/orchestrator/utils/state.py

@@ -183,11 +183,12 @@ def _build_arguments(func: StepFunc | InputStepFunc, state: State) -> list:  # n
                     raise KeyError(f"Could not find key '{name}' in state.")
             elif is_list_type(param.annotation, SubscriptionModel):
                 subscription_ids = map(_get_sub_id, state.get(name, []))
-                subscriptions = [
-                    # Actual type is first argument from list type
-                    get_args(param.annotation)[0].from_subscription(subscription_id)
-                    for subscription_id in subscription_ids
-                ]
+                # Actual type is first argument from list type
+                if (actual_type := get_args(param.annotation)[0]) == Any:
+                    raise ValueError(
+                        f"Step function argument '{param.name}' cannot be serialized from database with type 'Any'"
+                    )
+                subscriptions = [actual_type.from_subscription(subscription_id) for subscription_id in subscription_ids]
                 arguments.append(subscriptions)
             elif is_optional_type(param.annotation, SubscriptionModel):
                 subscription_id = _get_sub_id(state.get(name))