From 133e8131df9453a409b99d54757f0b0071c2da24 Mon Sep 17 00:00:00 2001 From: vatsrahul1001 Date: Mon, 1 Jun 2026 15:24:06 +0530 Subject: [PATCH] Update Python Client to 3.2.2rc1 --- CHANGELOG.md | 17 + airflow_client/client/__init__.py | 8 +- airflow_client/client/api/asset_api.py | 140 ++- airflow_client/client/api/connection_api.py | 29 +- airflow_client/client/api/dag_api.py | 170 ++- airflow_client/client/api/dag_parsing_api.py | 6 +- airflow_client/client/api/dag_run_api.py | 186 ++- airflow_client/client/api/dag_version_api.py | 6 +- airflow_client/client/api/dag_warning_api.py | 6 +- airflow_client/client/api/event_log_api.py | 145 ++- airflow_client/client/api/experimental_api.py | 6 +- airflow_client/client/api/extra_links_api.py | 17 + airflow_client/client/api/import_error_api.py | 29 +- airflow_client/client/api/pool_api.py | 29 +- airflow_client/client/api/task_api.py | 6 +- .../client/api/task_instance_api.py | 451 +++++-- airflow_client/client/api/variable_api.py | 29 +- airflow_client/client/api/x_com_api.py | 142 ++- airflow_client/client/api_client.py | 34 +- airflow_client/client/configuration.py | 4 +- airflow_client/client/models/__init__.py | 3 + ...clear_task_instance_collection_response.py | 98 ++ .../client/models/connection_body.py | 3 + .../client/models/dag_collection_response.py | 2 +- .../client/models/dag_details_response.py | 2 +- airflow_client/client/models/dag_response.py | 2 +- .../client/models/dag_run_clear_body.py | 6 +- .../models/dag_run_collection_response.py | 14 +- .../client/models/dag_run_patch_body.py | 2 +- .../client/models/dag_run_patch_states.py | 2 +- .../client/models/dag_run_response.py | 2 +- .../client/models/dag_runs_batch_body.py | 2 +- .../models/dag_schedule_asset_reference.py | 2 +- .../client/models/dag_source_response.py | 2 +- .../models/dag_stats_collection_response.py | 2 +- .../client/models/dag_stats_response.py | 2 +- .../models/dag_tag_collection_response.py | 2 +- .../client/models/dag_tag_response.py | 2 +- .../models/dag_version_collection_response.py | 2 +- .../models/dag_warning_collection_response.py | 2 +- .../client/models/dag_warning_response.py | 2 +- .../client/models/new_task_response.py | 90 ++ .../client/models/response_clear_dag_run.py | 28 +- .../task_instance_collection_response.py | 14 +- .../client/models/task_instances_inner.py | 137 +++ .../models/trigger_dag_run_post_body.py | 2 +- docs/AssetApi.md | 44 +- docs/ClearTaskInstanceCollectionResponse.md | 31 + docs/ConnectionApi.md | 10 +- docs/DAGApi.md | 58 +- docs/DAGCollectionResponse.md | 2 +- docs/DAGDetailsResponse.md | 2 +- docs/DAGParsingApi.md | 2 +- docs/DAGResponse.md | 2 +- docs/DAGRunApi.md | 55 +- docs/DAGRunClearBody.md | 3 +- docs/DAGRunCollectionResponse.md | 6 +- docs/DAGRunPatchBody.md | 2 +- docs/DAGRunPatchStates.md | 2 +- docs/DAGRunResponse.md | 2 +- docs/DAGRunsBatchBody.md | 2 +- docs/DAGSourceResponse.md | 2 +- docs/DAGTagCollectionResponse.md | 2 +- docs/DAGVersionCollectionResponse.md | 2 +- docs/DAGWarningCollectionResponse.md | 2 +- docs/DAGWarningResponse.md | 2 +- docs/DagScheduleAssetReference.md | 2 +- docs/DagStatsCollectionResponse.md | 2 +- docs/DagStatsResponse.md | 2 +- docs/DagTagResponse.md | 2 +- docs/DagVersionApi.md | 4 +- docs/DagWarningApi.md | 2 +- docs/EventLogApi.md | 34 +- docs/ExperimentalApi.md | 2 +- docs/ExtraLinksApi.md | 6 +- docs/ImportErrorApi.md | 10 +- docs/NewTaskResponse.md | 31 + docs/PoolApi.md | 10 +- docs/ResponseClearDagRun.md | 2 +- docs/TaskApi.md | 2 +- docs/TaskInstanceApi.md | 115 +- docs/TaskInstanceCollectionResponse.md | 6 +- docs/TaskInstancesInner.md | 62 + docs/TriggerDAGRunPostBody.md | 2 +- docs/VariableApi.md | 10 +- docs/XComApi.md | 32 +- pyproject.toml | 6 +- spec/v2.yaml | 1032 +++++++++++++++-- ...clear_task_instance_collection_response.py | 58 + test/test_dag_run_clear_body.py | 1 + test/test_dag_run_collection_response.py | 3 +- test/test_new_task_response.py | 54 + test/test_response_clear_dag_run.py | 72 +- .../test_task_instance_collection_response.py | 3 +- test/test_task_instances_inner.py | 122 ++ version.txt | 2 +- 96 files changed, 3104 insertions(+), 707 deletions(-) create mode 100644 airflow_client/client/models/clear_task_instance_collection_response.py create mode 100644 airflow_client/client/models/new_task_response.py create mode 100644 airflow_client/client/models/task_instances_inner.py create mode 100644 docs/ClearTaskInstanceCollectionResponse.md create mode 100644 docs/NewTaskResponse.md create mode 100644 docs/TaskInstancesInner.md create mode 100644 test/test_clear_task_instance_collection_response.py create mode 100644 test/test_new_task_response.py create mode 100644 test/test_task_instances_inner.py diff --git a/CHANGELOG.md b/CHANGELOG.md index e482fad4..c1418c80 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,6 +17,23 @@ under the License. --> +# v3.2.2 + +## Improvements: + +- UI: Filter task instances by rendered map index (#66008) (#67163) +- UI: Enable queue up new tasks (#63484) (#66869) +- Pass ``try_number`` to extra links API (#65661) (#66171) +- Update search parameters to better leverage DB indexes (#64963) (#65964) +- Add cursor-based pagination for ``get_dag_runs`` endpoint (#65604) (#65746) +- Support ordering ``XCom`` entries in the REST API and UI (#65418) (#65600) +- UI: Add Dag runs filters for Consuming Asset (#63624) (#65306) +- Align Dag capitalization from "DAG" to "Dag" in ``core_api`` (#66211) (#66304) + +## Bug Fixes: + +- Fix backfill params not overriding existing Dag run conf (#64939) (#65599) +- Fix ``PATCH /dags`` pagination bug and document wildcard ``dag_id_pattern`` (#65309) # v3.2.1 diff --git a/airflow_client/client/__init__.py b/airflow_client/client/__init__.py index 50a6230e..2913aacc 100644 --- a/airflow_client/client/__init__.py +++ b/airflow_client/client/__init__.py @@ -14,7 +14,7 @@ """ # noqa: E501 -__version__ = "3.2.1" +__version__ = "3.2.2" # Define package exports __all__ = [ @@ -91,6 +91,7 @@ "BulkUpdateActionConnectionBody", "BulkUpdateActionPoolBody", "BulkUpdateActionVariableBody", + "ClearTaskInstanceCollectionResponse", "ClearTaskInstancesBody", "ClearTaskInstancesBodyTaskIdsInner", "Config", @@ -158,6 +159,7 @@ "LastAssetEventResponse", "LocationInner", "MaterializeAssetBody", + "NewTaskResponse", "PatchTaskInstanceBody", "PluginCollectionResponse", "PluginImportErrorCollectionResponse", @@ -187,6 +189,7 @@ "TaskInstanceResponse", "TaskInstanceState", "TaskInstancesBatchBody", + "TaskInstancesInner", "TaskInstancesLogResponse", "TaskOutletAssetReference", "TaskResponse", @@ -287,6 +290,7 @@ from airflow_client.client.models.bulk_update_action_connection_body import BulkUpdateActionConnectionBody as BulkUpdateActionConnectionBody from airflow_client.client.models.bulk_update_action_pool_body import BulkUpdateActionPoolBody as BulkUpdateActionPoolBody from airflow_client.client.models.bulk_update_action_variable_body import BulkUpdateActionVariableBody as BulkUpdateActionVariableBody +from airflow_client.client.models.clear_task_instance_collection_response import ClearTaskInstanceCollectionResponse as ClearTaskInstanceCollectionResponse from airflow_client.client.models.clear_task_instances_body import ClearTaskInstancesBody as ClearTaskInstancesBody from airflow_client.client.models.clear_task_instances_body_task_ids_inner import ClearTaskInstancesBodyTaskIdsInner as ClearTaskInstancesBodyTaskIdsInner from airflow_client.client.models.config import Config as Config @@ -354,6 +358,7 @@ from airflow_client.client.models.last_asset_event_response import LastAssetEventResponse as LastAssetEventResponse from airflow_client.client.models.location_inner import LocationInner as LocationInner from airflow_client.client.models.materialize_asset_body import MaterializeAssetBody as MaterializeAssetBody +from airflow_client.client.models.new_task_response import NewTaskResponse as NewTaskResponse from airflow_client.client.models.patch_task_instance_body import PatchTaskInstanceBody as PatchTaskInstanceBody from airflow_client.client.models.plugin_collection_response import PluginCollectionResponse as PluginCollectionResponse from airflow_client.client.models.plugin_import_error_collection_response import PluginImportErrorCollectionResponse as PluginImportErrorCollectionResponse @@ -383,6 +388,7 @@ from airflow_client.client.models.task_instance_response import TaskInstanceResponse as TaskInstanceResponse from airflow_client.client.models.task_instance_state import TaskInstanceState as TaskInstanceState from airflow_client.client.models.task_instances_batch_body import TaskInstancesBatchBody as TaskInstancesBatchBody +from airflow_client.client.models.task_instances_inner import TaskInstancesInner as TaskInstancesInner from airflow_client.client.models.task_instances_log_response import TaskInstancesLogResponse as TaskInstancesLogResponse from airflow_client.client.models.task_outlet_asset_reference import TaskOutletAssetReference as TaskOutletAssetReference from airflow_client.client.models.task_response import TaskResponse as TaskResponse diff --git a/airflow_client/client/api/asset_api.py b/airflow_client/client/api/asset_api.py index 2c4b3e9a..5618976a 100644 --- a/airflow_client/client/api/asset_api.py +++ b/airflow_client/client/api/asset_api.py @@ -647,7 +647,7 @@ def delete_dag_asset_queued_event( ) -> None: """Delete Dag Asset Queued Event - Delete a queued asset event for a DAG. + Delete a queued asset event for a Dag. :param dag_id: (required) :type dag_id: str @@ -727,7 +727,7 @@ def delete_dag_asset_queued_event_with_http_info( ) -> ApiResponse[None]: """Delete Dag Asset Queued Event - Delete a queued asset event for a DAG. + Delete a queued asset event for a Dag. :param dag_id: (required) :type dag_id: str @@ -807,7 +807,7 @@ def delete_dag_asset_queued_event_without_preload_content( ) -> RESTResponseType: """Delete Dag Asset Queued Event - Delete a queued asset event for a DAG. + Delete a queued asset event for a Dag. :param dag_id: (required) :type dag_id: str @@ -1779,7 +1779,8 @@ def get_asset_aliases( self, limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, - name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``name_prefix_pattern`` parameter when possible.")] = None, + name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, name`")] = None, _request_timeout: Union[ None, @@ -1802,8 +1803,10 @@ def get_asset_aliases( :type limit: int :param offset: :type offset: int - :param name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``name_prefix_pattern`` parameter when possible. :type name_pattern: str + :param name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type name_prefix_pattern: str :param order_by: Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, name` :type order_by: List[str] :param _request_timeout: timeout setting for this request. If one @@ -1832,6 +1835,7 @@ def get_asset_aliases( limit=limit, offset=offset, name_pattern=name_pattern, + name_prefix_pattern=name_prefix_pattern, order_by=order_by, _request_auth=_request_auth, _content_type=_content_type, @@ -1862,7 +1866,8 @@ def get_asset_aliases_with_http_info( self, limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, - name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``name_prefix_pattern`` parameter when possible.")] = None, + name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, name`")] = None, _request_timeout: Union[ None, @@ -1885,8 +1890,10 @@ def get_asset_aliases_with_http_info( :type limit: int :param offset: :type offset: int - :param name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``name_prefix_pattern`` parameter when possible. :type name_pattern: str + :param name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type name_prefix_pattern: str :param order_by: Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, name` :type order_by: List[str] :param _request_timeout: timeout setting for this request. If one @@ -1915,6 +1922,7 @@ def get_asset_aliases_with_http_info( limit=limit, offset=offset, name_pattern=name_pattern, + name_prefix_pattern=name_prefix_pattern, order_by=order_by, _request_auth=_request_auth, _content_type=_content_type, @@ -1945,7 +1953,8 @@ def get_asset_aliases_without_preload_content( self, limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, - name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``name_prefix_pattern`` parameter when possible.")] = None, + name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, name`")] = None, _request_timeout: Union[ None, @@ -1968,8 +1977,10 @@ def get_asset_aliases_without_preload_content( :type limit: int :param offset: :type offset: int - :param name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``name_prefix_pattern`` parameter when possible. :type name_pattern: str + :param name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type name_prefix_pattern: str :param order_by: Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, name` :type order_by: List[str] :param _request_timeout: timeout setting for this request. If one @@ -1998,6 +2009,7 @@ def get_asset_aliases_without_preload_content( limit=limit, offset=offset, name_pattern=name_pattern, + name_prefix_pattern=name_prefix_pattern, order_by=order_by, _request_auth=_request_auth, _content_type=_content_type, @@ -2024,6 +2036,7 @@ def _get_asset_aliases_serialize( limit, offset, name_pattern, + name_prefix_pattern, order_by, _request_auth, _content_type, @@ -2060,6 +2073,10 @@ def _get_asset_aliases_serialize( _query_params.append(('name_pattern', name_pattern)) + if name_prefix_pattern is not None: + + _query_params.append(('name_prefix_pattern', name_prefix_pattern)) + if order_by is not None: _query_params.append(('order_by', order_by)) @@ -2113,7 +2130,8 @@ def get_asset_events( source_task_id: Optional[StrictStr] = None, source_run_id: Optional[StrictStr] = None, source_map_index: Optional[StrictInt] = None, - name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``name_prefix_pattern`` parameter when possible.")] = None, + name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, timestamp_gte: Optional[datetime] = None, timestamp_gt: Optional[datetime] = None, timestamp_lte: Optional[datetime] = None, @@ -2151,8 +2169,10 @@ def get_asset_events( :type source_run_id: str :param source_map_index: :type source_map_index: int - :param name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``name_prefix_pattern`` parameter when possible. :type name_pattern: str + :param name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type name_prefix_pattern: str :param timestamp_gte: :type timestamp_gte: datetime :param timestamp_gt: @@ -2193,6 +2213,7 @@ def get_asset_events( source_run_id=source_run_id, source_map_index=source_map_index, name_pattern=name_pattern, + name_prefix_pattern=name_prefix_pattern, timestamp_gte=timestamp_gte, timestamp_gt=timestamp_gt, timestamp_lte=timestamp_lte, @@ -2232,7 +2253,8 @@ def get_asset_events_with_http_info( source_task_id: Optional[StrictStr] = None, source_run_id: Optional[StrictStr] = None, source_map_index: Optional[StrictInt] = None, - name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``name_prefix_pattern`` parameter when possible.")] = None, + name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, timestamp_gte: Optional[datetime] = None, timestamp_gt: Optional[datetime] = None, timestamp_lte: Optional[datetime] = None, @@ -2270,8 +2292,10 @@ def get_asset_events_with_http_info( :type source_run_id: str :param source_map_index: :type source_map_index: int - :param name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``name_prefix_pattern`` parameter when possible. :type name_pattern: str + :param name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type name_prefix_pattern: str :param timestamp_gte: :type timestamp_gte: datetime :param timestamp_gt: @@ -2312,6 +2336,7 @@ def get_asset_events_with_http_info( source_run_id=source_run_id, source_map_index=source_map_index, name_pattern=name_pattern, + name_prefix_pattern=name_prefix_pattern, timestamp_gte=timestamp_gte, timestamp_gt=timestamp_gt, timestamp_lte=timestamp_lte, @@ -2351,7 +2376,8 @@ def get_asset_events_without_preload_content( source_task_id: Optional[StrictStr] = None, source_run_id: Optional[StrictStr] = None, source_map_index: Optional[StrictInt] = None, - name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``name_prefix_pattern`` parameter when possible.")] = None, + name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, timestamp_gte: Optional[datetime] = None, timestamp_gt: Optional[datetime] = None, timestamp_lte: Optional[datetime] = None, @@ -2389,8 +2415,10 @@ def get_asset_events_without_preload_content( :type source_run_id: str :param source_map_index: :type source_map_index: int - :param name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``name_prefix_pattern`` parameter when possible. :type name_pattern: str + :param name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type name_prefix_pattern: str :param timestamp_gte: :type timestamp_gte: datetime :param timestamp_gt: @@ -2431,6 +2459,7 @@ def get_asset_events_without_preload_content( source_run_id=source_run_id, source_map_index=source_map_index, name_pattern=name_pattern, + name_prefix_pattern=name_prefix_pattern, timestamp_gte=timestamp_gte, timestamp_gt=timestamp_gt, timestamp_lte=timestamp_lte, @@ -2466,6 +2495,7 @@ def _get_asset_events_serialize( source_run_id, source_map_index, name_pattern, + name_prefix_pattern, timestamp_gte, timestamp_gt, timestamp_lte, @@ -2529,6 +2559,10 @@ def _get_asset_events_serialize( _query_params.append(('name_pattern', name_pattern)) + if name_prefix_pattern is not None: + + _query_params.append(('name_prefix_pattern', name_prefix_pattern)) + if timestamp_gte is not None: if isinstance(timestamp_gte, datetime): _query_params.append( @@ -2912,8 +2946,10 @@ def get_assets( self, limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, - name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - uri_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``name_prefix_pattern`` parameter when possible.")] = None, + name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + uri_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``uri_prefix_pattern`` parameter when possible.")] = None, + uri_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, dag_ids: Optional[List[StrictStr]] = None, only_active: Optional[StrictBool] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, name, uri, created_at, updated_at`")] = None, @@ -2938,10 +2974,14 @@ def get_assets( :type limit: int :param offset: :type offset: int - :param name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``name_prefix_pattern`` parameter when possible. :type name_pattern: str - :param uri_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type name_prefix_pattern: str + :param uri_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``uri_prefix_pattern`` parameter when possible. :type uri_pattern: str + :param uri_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type uri_prefix_pattern: str :param dag_ids: :type dag_ids: List[str] :param only_active: @@ -2974,7 +3014,9 @@ def get_assets( limit=limit, offset=offset, name_pattern=name_pattern, + name_prefix_pattern=name_prefix_pattern, uri_pattern=uri_pattern, + uri_prefix_pattern=uri_prefix_pattern, dag_ids=dag_ids, only_active=only_active, order_by=order_by, @@ -3007,8 +3049,10 @@ def get_assets_with_http_info( self, limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, - name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - uri_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``name_prefix_pattern`` parameter when possible.")] = None, + name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + uri_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``uri_prefix_pattern`` parameter when possible.")] = None, + uri_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, dag_ids: Optional[List[StrictStr]] = None, only_active: Optional[StrictBool] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, name, uri, created_at, updated_at`")] = None, @@ -3033,10 +3077,14 @@ def get_assets_with_http_info( :type limit: int :param offset: :type offset: int - :param name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``name_prefix_pattern`` parameter when possible. :type name_pattern: str - :param uri_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type name_prefix_pattern: str + :param uri_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``uri_prefix_pattern`` parameter when possible. :type uri_pattern: str + :param uri_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type uri_prefix_pattern: str :param dag_ids: :type dag_ids: List[str] :param only_active: @@ -3069,7 +3117,9 @@ def get_assets_with_http_info( limit=limit, offset=offset, name_pattern=name_pattern, + name_prefix_pattern=name_prefix_pattern, uri_pattern=uri_pattern, + uri_prefix_pattern=uri_prefix_pattern, dag_ids=dag_ids, only_active=only_active, order_by=order_by, @@ -3102,8 +3152,10 @@ def get_assets_without_preload_content( self, limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, - name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - uri_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``name_prefix_pattern`` parameter when possible.")] = None, + name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + uri_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``uri_prefix_pattern`` parameter when possible.")] = None, + uri_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, dag_ids: Optional[List[StrictStr]] = None, only_active: Optional[StrictBool] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, name, uri, created_at, updated_at`")] = None, @@ -3128,10 +3180,14 @@ def get_assets_without_preload_content( :type limit: int :param offset: :type offset: int - :param name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``name_prefix_pattern`` parameter when possible. :type name_pattern: str - :param uri_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type name_prefix_pattern: str + :param uri_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``uri_prefix_pattern`` parameter when possible. :type uri_pattern: str + :param uri_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type uri_prefix_pattern: str :param dag_ids: :type dag_ids: List[str] :param only_active: @@ -3164,7 +3220,9 @@ def get_assets_without_preload_content( limit=limit, offset=offset, name_pattern=name_pattern, + name_prefix_pattern=name_prefix_pattern, uri_pattern=uri_pattern, + uri_prefix_pattern=uri_prefix_pattern, dag_ids=dag_ids, only_active=only_active, order_by=order_by, @@ -3193,7 +3251,9 @@ def _get_assets_serialize( limit, offset, name_pattern, + name_prefix_pattern, uri_pattern, + uri_prefix_pattern, dag_ids, only_active, order_by, @@ -3233,10 +3293,18 @@ def _get_assets_serialize( _query_params.append(('name_pattern', name_pattern)) + if name_prefix_pattern is not None: + + _query_params.append(('name_prefix_pattern', name_prefix_pattern)) + if uri_pattern is not None: _query_params.append(('uri_pattern', uri_pattern)) + if uri_prefix_pattern is not None: + + _query_params.append(('uri_prefix_pattern', uri_prefix_pattern)) + if dag_ids is not None: _query_params.append(('dag_ids', dag_ids)) @@ -3308,7 +3376,7 @@ def get_dag_asset_queued_event( ) -> QueuedEventResponse: """Get Dag Asset Queued Event - Get a queued asset event for a DAG. + Get a queued asset event for a Dag. :param dag_id: (required) :type dag_id: str @@ -3387,7 +3455,7 @@ def get_dag_asset_queued_event_with_http_info( ) -> ApiResponse[QueuedEventResponse]: """Get Dag Asset Queued Event - Get a queued asset event for a DAG. + Get a queued asset event for a Dag. :param dag_id: (required) :type dag_id: str @@ -3466,7 +3534,7 @@ def get_dag_asset_queued_event_without_preload_content( ) -> RESTResponseType: """Get Dag Asset Queued Event - Get a queued asset event for a DAG. + Get a queued asset event for a Dag. :param dag_id: (required) :type dag_id: str @@ -3613,7 +3681,7 @@ def get_dag_asset_queued_events( ) -> QueuedEventCollectionResponse: """Get Dag Asset Queued Events - Get queued asset events for a DAG. + Get queued asset events for a Dag. :param dag_id: (required) :type dag_id: str @@ -3687,7 +3755,7 @@ def get_dag_asset_queued_events_with_http_info( ) -> ApiResponse[QueuedEventCollectionResponse]: """Get Dag Asset Queued Events - Get queued asset events for a DAG. + Get queued asset events for a Dag. :param dag_id: (required) :type dag_id: str @@ -3761,7 +3829,7 @@ def get_dag_asset_queued_events_without_preload_content( ) -> RESTResponseType: """Get Dag Asset Queued Events - Get queued asset events for a DAG. + Get queued asset events for a Dag. :param dag_id: (required) :type dag_id: str @@ -3901,7 +3969,7 @@ def materialize_asset( ) -> DAGRunResponse: """Materialize Asset - Materialize an asset by triggering a DAG run that produces it. + Materialize an asset by triggering a Dag run that produces it. :param asset_id: (required) :type asset_id: int @@ -3978,7 +4046,7 @@ def materialize_asset_with_http_info( ) -> ApiResponse[DAGRunResponse]: """Materialize Asset - Materialize an asset by triggering a DAG run that produces it. + Materialize an asset by triggering a Dag run that produces it. :param asset_id: (required) :type asset_id: int @@ -4055,7 +4123,7 @@ def materialize_asset_without_preload_content( ) -> RESTResponseType: """Materialize Asset - Materialize an asset by triggering a DAG run that produces it. + Materialize an asset by triggering a Dag run that produces it. :param asset_id: (required) :type asset_id: int diff --git a/airflow_client/client/api/connection_api.py b/airflow_client/client/api/connection_api.py index 5fce05b0..8b13f201 100644 --- a/airflow_client/client/api/connection_api.py +++ b/airflow_client/client/api/connection_api.py @@ -1134,7 +1134,8 @@ def get_connections( limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `conn_id, conn_type, description, host, port, id, team_name, connection_id`")] = None, - connection_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + connection_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``connection_id_prefix_pattern`` parameter when possible.")] = None, + connection_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -1158,8 +1159,10 @@ def get_connections( :type offset: int :param order_by: Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `conn_id, conn_type, description, host, port, id, team_name, connection_id` :type order_by: List[str] - :param connection_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param connection_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``connection_id_prefix_pattern`` parameter when possible. :type connection_id_pattern: str + :param connection_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type connection_id_prefix_pattern: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -1187,6 +1190,7 @@ def get_connections( offset=offset, order_by=order_by, connection_id_pattern=connection_id_pattern, + connection_id_prefix_pattern=connection_id_prefix_pattern, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1217,7 +1221,8 @@ def get_connections_with_http_info( limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `conn_id, conn_type, description, host, port, id, team_name, connection_id`")] = None, - connection_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + connection_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``connection_id_prefix_pattern`` parameter when possible.")] = None, + connection_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -1241,8 +1246,10 @@ def get_connections_with_http_info( :type offset: int :param order_by: Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `conn_id, conn_type, description, host, port, id, team_name, connection_id` :type order_by: List[str] - :param connection_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param connection_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``connection_id_prefix_pattern`` parameter when possible. :type connection_id_pattern: str + :param connection_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type connection_id_prefix_pattern: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -1270,6 +1277,7 @@ def get_connections_with_http_info( offset=offset, order_by=order_by, connection_id_pattern=connection_id_pattern, + connection_id_prefix_pattern=connection_id_prefix_pattern, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1300,7 +1308,8 @@ def get_connections_without_preload_content( limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `conn_id, conn_type, description, host, port, id, team_name, connection_id`")] = None, - connection_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + connection_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``connection_id_prefix_pattern`` parameter when possible.")] = None, + connection_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -1324,8 +1333,10 @@ def get_connections_without_preload_content( :type offset: int :param order_by: Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `conn_id, conn_type, description, host, port, id, team_name, connection_id` :type order_by: List[str] - :param connection_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param connection_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``connection_id_prefix_pattern`` parameter when possible. :type connection_id_pattern: str + :param connection_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type connection_id_prefix_pattern: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -1353,6 +1364,7 @@ def get_connections_without_preload_content( offset=offset, order_by=order_by, connection_id_pattern=connection_id_pattern, + connection_id_prefix_pattern=connection_id_prefix_pattern, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1379,6 +1391,7 @@ def _get_connections_serialize( offset, order_by, connection_id_pattern, + connection_id_prefix_pattern, _request_auth, _content_type, _headers, @@ -1418,6 +1431,10 @@ def _get_connections_serialize( _query_params.append(('connection_id_pattern', connection_id_pattern)) + if connection_id_prefix_pattern is not None: + + _query_params.append(('connection_id_prefix_pattern', connection_id_prefix_pattern)) + # process the header parameters # process the form parameters # process the body parameter diff --git a/airflow_client/client/api/dag_api.py b/airflow_client/client/api/dag_api.py index 58488769..2458f284 100644 --- a/airflow_client/client/api/dag_api.py +++ b/airflow_client/client/api/dag_api.py @@ -62,7 +62,7 @@ def delete_dag( ) -> object: """Delete Dag - Delete the specific DAG. + Delete the specific Dag. :param dag_id: (required) :type dag_id: str @@ -134,7 +134,7 @@ def delete_dag_with_http_info( ) -> ApiResponse[object]: """Delete Dag - Delete the specific DAG. + Delete the specific Dag. :param dag_id: (required) :type dag_id: str @@ -206,7 +206,7 @@ def delete_dag_without_preload_content( ) -> RESTResponseType: """Delete Dag - Delete the specific DAG. + Delete the specific Dag. :param dag_id: (required) :type dag_id: str @@ -339,7 +339,7 @@ def favorite_dag( ) -> None: """Favorite Dag - Mark the DAG as favorite. + Mark the Dag as favorite. :param dag_id: (required) :type dag_id: str @@ -410,7 +410,7 @@ def favorite_dag_with_http_info( ) -> ApiResponse[None]: """Favorite Dag - Mark the DAG as favorite. + Mark the Dag as favorite. :param dag_id: (required) :type dag_id: str @@ -481,7 +481,7 @@ def favorite_dag_without_preload_content( ) -> RESTResponseType: """Favorite Dag - Mark the DAG as favorite. + Mark the Dag as favorite. :param dag_id: (required) :type dag_id: str @@ -613,7 +613,7 @@ def get_dag( ) -> DAGResponse: """Get Dag - Get basic information about a DAG. + Get basic information about a Dag. :param dag_id: (required) :type dag_id: str @@ -685,7 +685,7 @@ def get_dag_with_http_info( ) -> ApiResponse[DAGResponse]: """Get Dag - Get basic information about a DAG. + Get basic information about a Dag. :param dag_id: (required) :type dag_id: str @@ -757,7 +757,7 @@ def get_dag_without_preload_content( ) -> RESTResponseType: """Get Dag - Get basic information about a DAG. + Get basic information about a Dag. :param dag_id: (required) :type dag_id: str @@ -890,7 +890,7 @@ def get_dag_details( ) -> DAGDetailsResponse: """Get Dag Details - Get details of DAG. + Get details of Dag. :param dag_id: (required) :type dag_id: str @@ -962,7 +962,7 @@ def get_dag_details_with_http_info( ) -> ApiResponse[DAGDetailsResponse]: """Get Dag Details - Get details of DAG. + Get details of Dag. :param dag_id: (required) :type dag_id: str @@ -1034,7 +1034,7 @@ def get_dag_details_without_preload_content( ) -> RESTResponseType: """Get Dag Details - Get details of DAG. + Get details of Dag. :param dag_id: (required) :type dag_id: str @@ -1154,7 +1154,8 @@ def get_dag_tags( limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `name`")] = None, - tag_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + tag_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``tag_name_prefix_pattern`` parameter when possible.")] = None, + tag_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -1170,7 +1171,7 @@ def get_dag_tags( ) -> DAGTagCollectionResponse: """Get Dag Tags - Get all DAG tags. + Get all Dag tags. :param limit: :type limit: int @@ -1178,8 +1179,10 @@ def get_dag_tags( :type offset: int :param order_by: Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `name` :type order_by: List[str] - :param tag_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param tag_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``tag_name_prefix_pattern`` parameter when possible. :type tag_name_pattern: str + :param tag_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type tag_name_prefix_pattern: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -1207,6 +1210,7 @@ def get_dag_tags( offset=offset, order_by=order_by, tag_name_pattern=tag_name_pattern, + tag_name_prefix_pattern=tag_name_prefix_pattern, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1236,7 +1240,8 @@ def get_dag_tags_with_http_info( limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `name`")] = None, - tag_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + tag_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``tag_name_prefix_pattern`` parameter when possible.")] = None, + tag_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -1252,7 +1257,7 @@ def get_dag_tags_with_http_info( ) -> ApiResponse[DAGTagCollectionResponse]: """Get Dag Tags - Get all DAG tags. + Get all Dag tags. :param limit: :type limit: int @@ -1260,8 +1265,10 @@ def get_dag_tags_with_http_info( :type offset: int :param order_by: Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `name` :type order_by: List[str] - :param tag_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param tag_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``tag_name_prefix_pattern`` parameter when possible. :type tag_name_pattern: str + :param tag_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type tag_name_prefix_pattern: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -1289,6 +1296,7 @@ def get_dag_tags_with_http_info( offset=offset, order_by=order_by, tag_name_pattern=tag_name_pattern, + tag_name_prefix_pattern=tag_name_prefix_pattern, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1318,7 +1326,8 @@ def get_dag_tags_without_preload_content( limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `name`")] = None, - tag_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + tag_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``tag_name_prefix_pattern`` parameter when possible.")] = None, + tag_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -1334,7 +1343,7 @@ def get_dag_tags_without_preload_content( ) -> RESTResponseType: """Get Dag Tags - Get all DAG tags. + Get all Dag tags. :param limit: :type limit: int @@ -1342,8 +1351,10 @@ def get_dag_tags_without_preload_content( :type offset: int :param order_by: Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `name` :type order_by: List[str] - :param tag_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param tag_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``tag_name_prefix_pattern`` parameter when possible. :type tag_name_pattern: str + :param tag_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type tag_name_prefix_pattern: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -1371,6 +1382,7 @@ def get_dag_tags_without_preload_content( offset=offset, order_by=order_by, tag_name_pattern=tag_name_pattern, + tag_name_prefix_pattern=tag_name_prefix_pattern, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1396,6 +1408,7 @@ def _get_dag_tags_serialize( offset, order_by, tag_name_pattern, + tag_name_prefix_pattern, _request_auth, _content_type, _headers, @@ -1435,6 +1448,10 @@ def _get_dag_tags_serialize( _query_params.append(('tag_name_pattern', tag_name_pattern)) + if tag_name_prefix_pattern is not None: + + _query_params.append(('tag_name_prefix_pattern', tag_name_prefix_pattern)) + # process the header parameters # process the form parameters # process the body parameter @@ -1481,8 +1498,10 @@ def get_dags( tags: Optional[List[StrictStr]] = None, tags_match_mode: Optional[StrictStr] = None, owners: Optional[List[StrictStr]] = None, - dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - dag_display_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible.")] = None, + dag_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + dag_display_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_display_name_prefix_pattern`` parameter when possible.")] = None, + dag_display_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, exclude_stale: Optional[StrictBool] = None, paused: Optional[StrictBool] = None, has_import_errors: Annotated[Optional[StrictBool], Field(description="Filter Dags by having import errors. Only Dags that have been successfully loaded before will be returned.")] = None, @@ -1518,7 +1537,7 @@ def get_dags( ) -> DAGCollectionResponse: """Get Dags - Get all DAGs. + Get all Dags. :param limit: :type limit: int @@ -1530,10 +1549,14 @@ def get_dags( :type tags_match_mode: str :param owners: :type owners: List[str] - :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. :type dag_id_pattern: str - :param dag_display_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param dag_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type dag_id_prefix_pattern: str + :param dag_display_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_display_name_prefix_pattern`` parameter when possible. :type dag_display_name_pattern: str + :param dag_display_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type dag_display_name_prefix_pattern: str :param exclude_stale: :type exclude_stale: bool :param paused: @@ -1603,7 +1626,9 @@ def get_dags( tags_match_mode=tags_match_mode, owners=owners, dag_id_pattern=dag_id_pattern, + dag_id_prefix_pattern=dag_id_prefix_pattern, dag_display_name_pattern=dag_display_name_pattern, + dag_display_name_prefix_pattern=dag_display_name_prefix_pattern, exclude_stale=exclude_stale, paused=paused, has_import_errors=has_import_errors, @@ -1655,8 +1680,10 @@ def get_dags_with_http_info( tags: Optional[List[StrictStr]] = None, tags_match_mode: Optional[StrictStr] = None, owners: Optional[List[StrictStr]] = None, - dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - dag_display_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible.")] = None, + dag_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + dag_display_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_display_name_prefix_pattern`` parameter when possible.")] = None, + dag_display_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, exclude_stale: Optional[StrictBool] = None, paused: Optional[StrictBool] = None, has_import_errors: Annotated[Optional[StrictBool], Field(description="Filter Dags by having import errors. Only Dags that have been successfully loaded before will be returned.")] = None, @@ -1692,7 +1719,7 @@ def get_dags_with_http_info( ) -> ApiResponse[DAGCollectionResponse]: """Get Dags - Get all DAGs. + Get all Dags. :param limit: :type limit: int @@ -1704,10 +1731,14 @@ def get_dags_with_http_info( :type tags_match_mode: str :param owners: :type owners: List[str] - :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. :type dag_id_pattern: str - :param dag_display_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param dag_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type dag_id_prefix_pattern: str + :param dag_display_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_display_name_prefix_pattern`` parameter when possible. :type dag_display_name_pattern: str + :param dag_display_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type dag_display_name_prefix_pattern: str :param exclude_stale: :type exclude_stale: bool :param paused: @@ -1777,7 +1808,9 @@ def get_dags_with_http_info( tags_match_mode=tags_match_mode, owners=owners, dag_id_pattern=dag_id_pattern, + dag_id_prefix_pattern=dag_id_prefix_pattern, dag_display_name_pattern=dag_display_name_pattern, + dag_display_name_prefix_pattern=dag_display_name_prefix_pattern, exclude_stale=exclude_stale, paused=paused, has_import_errors=has_import_errors, @@ -1829,8 +1862,10 @@ def get_dags_without_preload_content( tags: Optional[List[StrictStr]] = None, tags_match_mode: Optional[StrictStr] = None, owners: Optional[List[StrictStr]] = None, - dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - dag_display_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible.")] = None, + dag_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + dag_display_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_display_name_prefix_pattern`` parameter when possible.")] = None, + dag_display_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, exclude_stale: Optional[StrictBool] = None, paused: Optional[StrictBool] = None, has_import_errors: Annotated[Optional[StrictBool], Field(description="Filter Dags by having import errors. Only Dags that have been successfully loaded before will be returned.")] = None, @@ -1866,7 +1901,7 @@ def get_dags_without_preload_content( ) -> RESTResponseType: """Get Dags - Get all DAGs. + Get all Dags. :param limit: :type limit: int @@ -1878,10 +1913,14 @@ def get_dags_without_preload_content( :type tags_match_mode: str :param owners: :type owners: List[str] - :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. :type dag_id_pattern: str - :param dag_display_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param dag_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type dag_id_prefix_pattern: str + :param dag_display_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_display_name_prefix_pattern`` parameter when possible. :type dag_display_name_pattern: str + :param dag_display_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type dag_display_name_prefix_pattern: str :param exclude_stale: :type exclude_stale: bool :param paused: @@ -1951,7 +1990,9 @@ def get_dags_without_preload_content( tags_match_mode=tags_match_mode, owners=owners, dag_id_pattern=dag_id_pattern, + dag_id_prefix_pattern=dag_id_prefix_pattern, dag_display_name_pattern=dag_display_name_pattern, + dag_display_name_prefix_pattern=dag_display_name_prefix_pattern, exclude_stale=exclude_stale, paused=paused, has_import_errors=has_import_errors, @@ -1999,7 +2040,9 @@ def _get_dags_serialize( tags_match_mode, owners, dag_id_pattern, + dag_id_prefix_pattern, dag_display_name_pattern, + dag_display_name_prefix_pattern, exclude_stale, paused, has_import_errors, @@ -2071,10 +2114,18 @@ def _get_dags_serialize( _query_params.append(('dag_id_pattern', dag_id_pattern)) + if dag_id_prefix_pattern is not None: + + _query_params.append(('dag_id_prefix_pattern', dag_id_prefix_pattern)) + if dag_display_name_pattern is not None: _query_params.append(('dag_display_name_pattern', dag_display_name_pattern)) + if dag_display_name_prefix_pattern is not None: + + _query_params.append(('dag_display_name_prefix_pattern', dag_display_name_prefix_pattern)) + if exclude_stale is not None: _query_params.append(('exclude_stale', exclude_stale)) @@ -2286,7 +2337,7 @@ def patch_dag( ) -> DAGResponse: """Patch Dag - Patch the specific DAG. + Patch the specific Dag. :param dag_id: (required) :type dag_id: str @@ -2366,7 +2417,7 @@ def patch_dag_with_http_info( ) -> ApiResponse[DAGResponse]: """Patch Dag - Patch the specific DAG. + Patch the specific Dag. :param dag_id: (required) :type dag_id: str @@ -2446,7 +2497,7 @@ def patch_dag_without_preload_content( ) -> RESTResponseType: """Patch Dag - Patch the specific DAG. + Patch the specific Dag. :param dag_id: (required) :type dag_id: str @@ -2598,7 +2649,8 @@ def patch_dags( tags: Optional[List[StrictStr]] = None, tags_match_mode: Optional[StrictStr] = None, owners: Optional[List[StrictStr]] = None, - dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible.")] = None, + dag_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, exclude_stale: Optional[StrictBool] = None, paused: Optional[StrictBool] = None, _request_timeout: Union[ @@ -2616,7 +2668,7 @@ def patch_dags( ) -> DAGCollectionResponse: """Patch Dags - Patch multiple DAGs. + Patch multiple Dags. If neither `dag_id_pattern` nor `dag_id_prefix_pattern` is provided, no Dags will be matched regardless of other filters. To match all Dags, pass a wildcard value such as `~` or `%` for `dag_id_pattern`. :param dag_patch_body: (required) :type dag_patch_body: DAGPatchBody @@ -2632,8 +2684,10 @@ def patch_dags( :type tags_match_mode: str :param owners: :type owners: List[str] - :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. :type dag_id_pattern: str + :param dag_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type dag_id_prefix_pattern: str :param exclude_stale: :type exclude_stale: bool :param paused: @@ -2669,6 +2723,7 @@ def patch_dags( tags_match_mode=tags_match_mode, owners=owners, dag_id_pattern=dag_id_pattern, + dag_id_prefix_pattern=dag_id_prefix_pattern, exclude_stale=exclude_stale, paused=paused, _request_auth=_request_auth, @@ -2706,7 +2761,8 @@ def patch_dags_with_http_info( tags: Optional[List[StrictStr]] = None, tags_match_mode: Optional[StrictStr] = None, owners: Optional[List[StrictStr]] = None, - dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible.")] = None, + dag_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, exclude_stale: Optional[StrictBool] = None, paused: Optional[StrictBool] = None, _request_timeout: Union[ @@ -2724,7 +2780,7 @@ def patch_dags_with_http_info( ) -> ApiResponse[DAGCollectionResponse]: """Patch Dags - Patch multiple DAGs. + Patch multiple Dags. If neither `dag_id_pattern` nor `dag_id_prefix_pattern` is provided, no Dags will be matched regardless of other filters. To match all Dags, pass a wildcard value such as `~` or `%` for `dag_id_pattern`. :param dag_patch_body: (required) :type dag_patch_body: DAGPatchBody @@ -2740,8 +2796,10 @@ def patch_dags_with_http_info( :type tags_match_mode: str :param owners: :type owners: List[str] - :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. :type dag_id_pattern: str + :param dag_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type dag_id_prefix_pattern: str :param exclude_stale: :type exclude_stale: bool :param paused: @@ -2777,6 +2835,7 @@ def patch_dags_with_http_info( tags_match_mode=tags_match_mode, owners=owners, dag_id_pattern=dag_id_pattern, + dag_id_prefix_pattern=dag_id_prefix_pattern, exclude_stale=exclude_stale, paused=paused, _request_auth=_request_auth, @@ -2814,7 +2873,8 @@ def patch_dags_without_preload_content( tags: Optional[List[StrictStr]] = None, tags_match_mode: Optional[StrictStr] = None, owners: Optional[List[StrictStr]] = None, - dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible.")] = None, + dag_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, exclude_stale: Optional[StrictBool] = None, paused: Optional[StrictBool] = None, _request_timeout: Union[ @@ -2832,7 +2892,7 @@ def patch_dags_without_preload_content( ) -> RESTResponseType: """Patch Dags - Patch multiple DAGs. + Patch multiple Dags. If neither `dag_id_pattern` nor `dag_id_prefix_pattern` is provided, no Dags will be matched regardless of other filters. To match all Dags, pass a wildcard value such as `~` or `%` for `dag_id_pattern`. :param dag_patch_body: (required) :type dag_patch_body: DAGPatchBody @@ -2848,8 +2908,10 @@ def patch_dags_without_preload_content( :type tags_match_mode: str :param owners: :type owners: List[str] - :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. :type dag_id_pattern: str + :param dag_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type dag_id_prefix_pattern: str :param exclude_stale: :type exclude_stale: bool :param paused: @@ -2885,6 +2947,7 @@ def patch_dags_without_preload_content( tags_match_mode=tags_match_mode, owners=owners, dag_id_pattern=dag_id_pattern, + dag_id_prefix_pattern=dag_id_prefix_pattern, exclude_stale=exclude_stale, paused=paused, _request_auth=_request_auth, @@ -2918,6 +2981,7 @@ def _patch_dags_serialize( tags_match_mode, owners, dag_id_pattern, + dag_id_prefix_pattern, exclude_stale, paused, _request_auth, @@ -2973,6 +3037,10 @@ def _patch_dags_serialize( _query_params.append(('dag_id_pattern', dag_id_pattern)) + if dag_id_prefix_pattern is not None: + + _query_params.append(('dag_id_prefix_pattern', dag_id_prefix_pattern)) + if exclude_stale is not None: _query_params.append(('exclude_stale', exclude_stale)) @@ -3053,7 +3121,7 @@ def unfavorite_dag( ) -> None: """Unfavorite Dag - Unmark the DAG as favorite. + Unmark the Dag as favorite. :param dag_id: (required) :type dag_id: str @@ -3125,7 +3193,7 @@ def unfavorite_dag_with_http_info( ) -> ApiResponse[None]: """Unfavorite Dag - Unmark the DAG as favorite. + Unmark the Dag as favorite. :param dag_id: (required) :type dag_id: str @@ -3197,7 +3265,7 @@ def unfavorite_dag_without_preload_content( ) -> RESTResponseType: """Unfavorite Dag - Unmark the DAG as favorite. + Unmark the Dag as favorite. :param dag_id: (required) :type dag_id: str diff --git a/airflow_client/client/api/dag_parsing_api.py b/airflow_client/client/api/dag_parsing_api.py index c2044284..f35c1910 100644 --- a/airflow_client/client/api/dag_parsing_api.py +++ b/airflow_client/client/api/dag_parsing_api.py @@ -55,7 +55,7 @@ def reparse_dag_file( ) -> object: """Reparse Dag File - Request re-parsing a DAG file. + Request re-parsing a Dag file. :param file_token: (required) :type file_token: str @@ -126,7 +126,7 @@ def reparse_dag_file_with_http_info( ) -> ApiResponse[object]: """Reparse Dag File - Request re-parsing a DAG file. + Request re-parsing a Dag file. :param file_token: (required) :type file_token: str @@ -197,7 +197,7 @@ def reparse_dag_file_without_preload_content( ) -> RESTResponseType: """Reparse Dag File - Request re-parsing a DAG file. + Request re-parsing a Dag file. :param file_token: (required) :type file_token: str diff --git a/airflow_client/client/api/dag_run_api.py b/airflow_client/client/api/dag_run_api.py index a81f9dff..eefe1f12 100644 --- a/airflow_client/client/api/dag_run_api.py +++ b/airflow_client/client/api/dag_run_api.py @@ -380,7 +380,7 @@ def delete_dag_run( ) -> None: """Delete Dag Run - Delete a DAG Run entry. + Delete a Dag Run entry. :param dag_id: (required) :type dag_id: str @@ -456,7 +456,7 @@ def delete_dag_run_with_http_info( ) -> ApiResponse[None]: """Delete Dag Run - Delete a DAG Run entry. + Delete a Dag Run entry. :param dag_id: (required) :type dag_id: str @@ -532,7 +532,7 @@ def delete_dag_run_without_preload_content( ) -> RESTResponseType: """Delete Dag Run - Delete a DAG Run entry. + Delete a Dag Run entry. :param dag_id: (required) :type dag_id: str @@ -942,6 +942,7 @@ def _get_dag_run_serialize( def get_dag_runs( self, dag_id: StrictStr, + cursor: Annotated[Optional[StrictStr], Field(description="Cursor for keyset-based pagination. Pass an empty string for the first page, then use ``next_cursor`` from the response. When ``cursor`` is provided, ``offset`` is ignored.")] = None, limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, run_after_gte: Optional[datetime] = None, @@ -974,10 +975,15 @@ def get_dag_runs( dag_version: Optional[List[StrictInt]] = None, bundle_version: Optional[StrictStr] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, state, dag_id, run_id, logical_date, run_after, start_date, end_date, updated_at, conf, duration, dag_run_id`")] = None, - run_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - triggering_user_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - partition_key_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + run_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible.")] = None, + run_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + triggering_user_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``triggering_user_name_prefix_pattern`` parameter when possible.")] = None, + triggering_user_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible.")] = None, + dag_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + partition_key_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``partition_key_prefix_pattern`` parameter when possible.")] = None, + partition_key_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + consuming_asset_pattern: Annotated[Optional[StrictStr], Field(description="Filter by consuming asset name or URI using pattern matching")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -993,10 +999,12 @@ def get_dag_runs( ) -> DAGRunCollectionResponse: """Get Dag Runs - Get all DAG Runs. This endpoint allows specifying `~` as the dag_id to retrieve Dag Runs for all DAGs. + Get all Dag Runs. This endpoint allows specifying `~` as the dag_id to retrieve Dag Runs for all Dags. Supports two pagination modes: **Offset (default):** use `limit` and `offset` query parameters. Returns `total_entries`. **Cursor:** pass `cursor` (empty string for the first page, then `next_cursor` from the response). When `cursor` is provided, `offset` is ignored and `total_entries` is not returned. ``next_cursor`` is ``null`` when there are no more pages; ``previous_cursor`` is ``null`` on the first page. :param dag_id: (required) :type dag_id: str + :param cursor: Cursor for keyset-based pagination. Pass an empty string for the first page, then use ``next_cursor`` from the response. When ``cursor`` is provided, ``offset`` is ignored. + :type cursor: str :param limit: :type limit: int :param offset: @@ -1061,14 +1069,24 @@ def get_dag_runs( :type bundle_version: str :param order_by: Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, state, dag_id, run_id, logical_date, run_after, start_date, end_date, updated_at, conf, duration, dag_run_id` :type order_by: List[str] - :param run_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param run_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible. :type run_id_pattern: str - :param triggering_user_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param run_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type run_id_prefix_pattern: str + :param triggering_user_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``triggering_user_name_prefix_pattern`` parameter when possible. :type triggering_user_name_pattern: str - :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param triggering_user_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type triggering_user_name_prefix_pattern: str + :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. :type dag_id_pattern: str - :param partition_key_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param dag_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type dag_id_prefix_pattern: str + :param partition_key_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``partition_key_prefix_pattern`` parameter when possible. :type partition_key_pattern: str + :param partition_key_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type partition_key_prefix_pattern: str + :param consuming_asset_pattern: Filter by consuming asset name or URI using pattern matching + :type consuming_asset_pattern: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -1093,6 +1111,7 @@ def get_dag_runs( _param = self._get_dag_runs_serialize( dag_id=dag_id, + cursor=cursor, limit=limit, offset=offset, run_after_gte=run_after_gte, @@ -1126,9 +1145,14 @@ def get_dag_runs( bundle_version=bundle_version, order_by=order_by, run_id_pattern=run_id_pattern, + run_id_prefix_pattern=run_id_prefix_pattern, triggering_user_name_pattern=triggering_user_name_pattern, + triggering_user_name_prefix_pattern=triggering_user_name_prefix_pattern, dag_id_pattern=dag_id_pattern, + dag_id_prefix_pattern=dag_id_prefix_pattern, partition_key_pattern=partition_key_pattern, + partition_key_prefix_pattern=partition_key_prefix_pattern, + consuming_asset_pattern=consuming_asset_pattern, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1157,6 +1181,7 @@ def get_dag_runs( def get_dag_runs_with_http_info( self, dag_id: StrictStr, + cursor: Annotated[Optional[StrictStr], Field(description="Cursor for keyset-based pagination. Pass an empty string for the first page, then use ``next_cursor`` from the response. When ``cursor`` is provided, ``offset`` is ignored.")] = None, limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, run_after_gte: Optional[datetime] = None, @@ -1189,10 +1214,15 @@ def get_dag_runs_with_http_info( dag_version: Optional[List[StrictInt]] = None, bundle_version: Optional[StrictStr] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, state, dag_id, run_id, logical_date, run_after, start_date, end_date, updated_at, conf, duration, dag_run_id`")] = None, - run_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - triggering_user_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - partition_key_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + run_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible.")] = None, + run_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + triggering_user_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``triggering_user_name_prefix_pattern`` parameter when possible.")] = None, + triggering_user_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible.")] = None, + dag_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + partition_key_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``partition_key_prefix_pattern`` parameter when possible.")] = None, + partition_key_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + consuming_asset_pattern: Annotated[Optional[StrictStr], Field(description="Filter by consuming asset name or URI using pattern matching")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -1208,10 +1238,12 @@ def get_dag_runs_with_http_info( ) -> ApiResponse[DAGRunCollectionResponse]: """Get Dag Runs - Get all DAG Runs. This endpoint allows specifying `~` as the dag_id to retrieve Dag Runs for all DAGs. + Get all Dag Runs. This endpoint allows specifying `~` as the dag_id to retrieve Dag Runs for all Dags. Supports two pagination modes: **Offset (default):** use `limit` and `offset` query parameters. Returns `total_entries`. **Cursor:** pass `cursor` (empty string for the first page, then `next_cursor` from the response). When `cursor` is provided, `offset` is ignored and `total_entries` is not returned. ``next_cursor`` is ``null`` when there are no more pages; ``previous_cursor`` is ``null`` on the first page. :param dag_id: (required) :type dag_id: str + :param cursor: Cursor for keyset-based pagination. Pass an empty string for the first page, then use ``next_cursor`` from the response. When ``cursor`` is provided, ``offset`` is ignored. + :type cursor: str :param limit: :type limit: int :param offset: @@ -1276,14 +1308,24 @@ def get_dag_runs_with_http_info( :type bundle_version: str :param order_by: Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, state, dag_id, run_id, logical_date, run_after, start_date, end_date, updated_at, conf, duration, dag_run_id` :type order_by: List[str] - :param run_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param run_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible. :type run_id_pattern: str - :param triggering_user_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param run_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type run_id_prefix_pattern: str + :param triggering_user_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``triggering_user_name_prefix_pattern`` parameter when possible. :type triggering_user_name_pattern: str - :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param triggering_user_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type triggering_user_name_prefix_pattern: str + :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. :type dag_id_pattern: str - :param partition_key_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param dag_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type dag_id_prefix_pattern: str + :param partition_key_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``partition_key_prefix_pattern`` parameter when possible. :type partition_key_pattern: str + :param partition_key_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type partition_key_prefix_pattern: str + :param consuming_asset_pattern: Filter by consuming asset name or URI using pattern matching + :type consuming_asset_pattern: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -1308,6 +1350,7 @@ def get_dag_runs_with_http_info( _param = self._get_dag_runs_serialize( dag_id=dag_id, + cursor=cursor, limit=limit, offset=offset, run_after_gte=run_after_gte, @@ -1341,9 +1384,14 @@ def get_dag_runs_with_http_info( bundle_version=bundle_version, order_by=order_by, run_id_pattern=run_id_pattern, + run_id_prefix_pattern=run_id_prefix_pattern, triggering_user_name_pattern=triggering_user_name_pattern, + triggering_user_name_prefix_pattern=triggering_user_name_prefix_pattern, dag_id_pattern=dag_id_pattern, + dag_id_prefix_pattern=dag_id_prefix_pattern, partition_key_pattern=partition_key_pattern, + partition_key_prefix_pattern=partition_key_prefix_pattern, + consuming_asset_pattern=consuming_asset_pattern, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1372,6 +1420,7 @@ def get_dag_runs_with_http_info( def get_dag_runs_without_preload_content( self, dag_id: StrictStr, + cursor: Annotated[Optional[StrictStr], Field(description="Cursor for keyset-based pagination. Pass an empty string for the first page, then use ``next_cursor`` from the response. When ``cursor`` is provided, ``offset`` is ignored.")] = None, limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, run_after_gte: Optional[datetime] = None, @@ -1404,10 +1453,15 @@ def get_dag_runs_without_preload_content( dag_version: Optional[List[StrictInt]] = None, bundle_version: Optional[StrictStr] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, state, dag_id, run_id, logical_date, run_after, start_date, end_date, updated_at, conf, duration, dag_run_id`")] = None, - run_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - triggering_user_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - partition_key_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + run_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible.")] = None, + run_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + triggering_user_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``triggering_user_name_prefix_pattern`` parameter when possible.")] = None, + triggering_user_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible.")] = None, + dag_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + partition_key_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``partition_key_prefix_pattern`` parameter when possible.")] = None, + partition_key_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + consuming_asset_pattern: Annotated[Optional[StrictStr], Field(description="Filter by consuming asset name or URI using pattern matching")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -1423,10 +1477,12 @@ def get_dag_runs_without_preload_content( ) -> RESTResponseType: """Get Dag Runs - Get all DAG Runs. This endpoint allows specifying `~` as the dag_id to retrieve Dag Runs for all DAGs. + Get all Dag Runs. This endpoint allows specifying `~` as the dag_id to retrieve Dag Runs for all Dags. Supports two pagination modes: **Offset (default):** use `limit` and `offset` query parameters. Returns `total_entries`. **Cursor:** pass `cursor` (empty string for the first page, then `next_cursor` from the response). When `cursor` is provided, `offset` is ignored and `total_entries` is not returned. ``next_cursor`` is ``null`` when there are no more pages; ``previous_cursor`` is ``null`` on the first page. :param dag_id: (required) :type dag_id: str + :param cursor: Cursor for keyset-based pagination. Pass an empty string for the first page, then use ``next_cursor`` from the response. When ``cursor`` is provided, ``offset`` is ignored. + :type cursor: str :param limit: :type limit: int :param offset: @@ -1491,14 +1547,24 @@ def get_dag_runs_without_preload_content( :type bundle_version: str :param order_by: Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, state, dag_id, run_id, logical_date, run_after, start_date, end_date, updated_at, conf, duration, dag_run_id` :type order_by: List[str] - :param run_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param run_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible. :type run_id_pattern: str - :param triggering_user_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param run_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type run_id_prefix_pattern: str + :param triggering_user_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``triggering_user_name_prefix_pattern`` parameter when possible. :type triggering_user_name_pattern: str - :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param triggering_user_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type triggering_user_name_prefix_pattern: str + :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. :type dag_id_pattern: str - :param partition_key_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param dag_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type dag_id_prefix_pattern: str + :param partition_key_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``partition_key_prefix_pattern`` parameter when possible. :type partition_key_pattern: str + :param partition_key_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type partition_key_prefix_pattern: str + :param consuming_asset_pattern: Filter by consuming asset name or URI using pattern matching + :type consuming_asset_pattern: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -1523,6 +1589,7 @@ def get_dag_runs_without_preload_content( _param = self._get_dag_runs_serialize( dag_id=dag_id, + cursor=cursor, limit=limit, offset=offset, run_after_gte=run_after_gte, @@ -1556,9 +1623,14 @@ def get_dag_runs_without_preload_content( bundle_version=bundle_version, order_by=order_by, run_id_pattern=run_id_pattern, + run_id_prefix_pattern=run_id_prefix_pattern, triggering_user_name_pattern=triggering_user_name_pattern, + triggering_user_name_prefix_pattern=triggering_user_name_prefix_pattern, dag_id_pattern=dag_id_pattern, + dag_id_prefix_pattern=dag_id_prefix_pattern, partition_key_pattern=partition_key_pattern, + partition_key_prefix_pattern=partition_key_prefix_pattern, + consuming_asset_pattern=consuming_asset_pattern, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1582,6 +1654,7 @@ def get_dag_runs_without_preload_content( def _get_dag_runs_serialize( self, dag_id, + cursor, limit, offset, run_after_gte, @@ -1615,9 +1688,14 @@ def _get_dag_runs_serialize( bundle_version, order_by, run_id_pattern, + run_id_prefix_pattern, triggering_user_name_pattern, + triggering_user_name_prefix_pattern, dag_id_pattern, + dag_id_prefix_pattern, partition_key_pattern, + partition_key_prefix_pattern, + consuming_asset_pattern, _request_auth, _content_type, _headers, @@ -1646,6 +1724,10 @@ def _get_dag_runs_serialize( if dag_id is not None: _path_params['dag_id'] = dag_id # process the query parameters + if cursor is not None: + + _query_params.append(('cursor', cursor)) + if limit is not None: _query_params.append(('limit', limit)) @@ -1958,18 +2040,38 @@ def _get_dag_runs_serialize( _query_params.append(('run_id_pattern', run_id_pattern)) + if run_id_prefix_pattern is not None: + + _query_params.append(('run_id_prefix_pattern', run_id_prefix_pattern)) + if triggering_user_name_pattern is not None: _query_params.append(('triggering_user_name_pattern', triggering_user_name_pattern)) + if triggering_user_name_prefix_pattern is not None: + + _query_params.append(('triggering_user_name_prefix_pattern', triggering_user_name_prefix_pattern)) + if dag_id_pattern is not None: _query_params.append(('dag_id_pattern', dag_id_pattern)) + if dag_id_prefix_pattern is not None: + + _query_params.append(('dag_id_prefix_pattern', dag_id_prefix_pattern)) + if partition_key_pattern is not None: _query_params.append(('partition_key_pattern', partition_key_pattern)) + if partition_key_prefix_pattern is not None: + + _query_params.append(('partition_key_prefix_pattern', partition_key_prefix_pattern)) + + if consuming_asset_pattern is not None: + + _query_params.append(('consuming_asset_pattern', consuming_asset_pattern)) + # process the header parameters # process the form parameters # process the body parameter @@ -2028,7 +2130,7 @@ def get_list_dag_runs_batch( ) -> DAGRunCollectionResponse: """Get List Dag Runs Batch - Get a list of DAG Runs. + Get a list of Dag Runs. :param dag_id: (required) :type dag_id: str @@ -2103,7 +2205,7 @@ def get_list_dag_runs_batch_with_http_info( ) -> ApiResponse[DAGRunCollectionResponse]: """Get List Dag Runs Batch - Get a list of DAG Runs. + Get a list of Dag Runs. :param dag_id: (required) :type dag_id: str @@ -2178,7 +2280,7 @@ def get_list_dag_runs_batch_without_preload_content( ) -> RESTResponseType: """Get List Dag Runs Batch - Get a list of DAG Runs. + Get a list of Dag Runs. :param dag_id: (required) :type dag_id: str @@ -2621,7 +2723,7 @@ def patch_dag_run( ) -> DAGRunResponse: """Patch Dag Run - Modify a DAG Run. + Modify a Dag Run. :param dag_id: (required) :type dag_id: str @@ -2705,7 +2807,7 @@ def patch_dag_run_with_http_info( ) -> ApiResponse[DAGRunResponse]: """Patch Dag Run - Modify a DAG Run. + Modify a Dag Run. :param dag_id: (required) :type dag_id: str @@ -2789,7 +2891,7 @@ def patch_dag_run_without_preload_content( ) -> RESTResponseType: """Patch Dag Run - Modify a DAG Run. + Modify a Dag Run. :param dag_id: (required) :type dag_id: str @@ -2957,7 +3059,7 @@ def trigger_dag_run( ) -> DAGRunResponse: """Trigger Dag Run - Trigger a DAG. + Trigger a Dag. :param dag_id: (required) :type dag_id: object @@ -3034,7 +3136,7 @@ def trigger_dag_run_with_http_info( ) -> ApiResponse[DAGRunResponse]: """Trigger Dag Run - Trigger a DAG. + Trigger a Dag. :param dag_id: (required) :type dag_id: object @@ -3111,7 +3213,7 @@ def trigger_dag_run_without_preload_content( ) -> RESTResponseType: """Trigger Dag Run - Trigger a DAG. + Trigger a Dag. :param dag_id: (required) :type dag_id: object @@ -3267,7 +3369,7 @@ def wait_dag_run_until_finished( ) -> object: """Experimental: Wait for a dag run to complete, and return task results if requested. - 🚧 This is an experimental endpoint and may change or be removed without notice.Successful response are streamed as newline-delimited JSON (NDJSON). Each line is a JSON object representing the DAG run state. + 🚧 This is an experimental endpoint and may change or be removed without notice.Successful response are streamed as newline-delimited JSON (NDJSON). Each line is a JSON object representing the Dag run state. :param dag_id: (required) :type dag_id: str @@ -3350,7 +3452,7 @@ def wait_dag_run_until_finished_with_http_info( ) -> ApiResponse[object]: """Experimental: Wait for a dag run to complete, and return task results if requested. - 🚧 This is an experimental endpoint and may change or be removed without notice.Successful response are streamed as newline-delimited JSON (NDJSON). Each line is a JSON object representing the DAG run state. + 🚧 This is an experimental endpoint and may change or be removed without notice.Successful response are streamed as newline-delimited JSON (NDJSON). Each line is a JSON object representing the Dag run state. :param dag_id: (required) :type dag_id: str @@ -3433,7 +3535,7 @@ def wait_dag_run_until_finished_without_preload_content( ) -> RESTResponseType: """Experimental: Wait for a dag run to complete, and return task results if requested. - 🚧 This is an experimental endpoint and may change or be removed without notice.Successful response are streamed as newline-delimited JSON (NDJSON). Each line is a JSON object representing the DAG run state. + 🚧 This is an experimental endpoint and may change or be removed without notice.Successful response are streamed as newline-delimited JSON (NDJSON). Each line is a JSON object representing the Dag run state. :param dag_id: (required) :type dag_id: str diff --git a/airflow_client/client/api/dag_version_api.py b/airflow_client/client/api/dag_version_api.py index 1f24f017..26f2bb48 100644 --- a/airflow_client/client/api/dag_version_api.py +++ b/airflow_client/client/api/dag_version_api.py @@ -353,7 +353,7 @@ def get_dag_versions( ) -> DAGVersionCollectionResponse: """Get Dag Versions - Get all DAG Versions. This endpoint allows specifying `~` as the dag_id to retrieve DAG Versions for all DAGs. + Get all Dag Versions. This endpoint allows specifying `~` as the dag_id to retrieve Dag Versions for all Dags. :param dag_id: (required) :type dag_id: str @@ -448,7 +448,7 @@ def get_dag_versions_with_http_info( ) -> ApiResponse[DAGVersionCollectionResponse]: """Get Dag Versions - Get all DAG Versions. This endpoint allows specifying `~` as the dag_id to retrieve DAG Versions for all DAGs. + Get all Dag Versions. This endpoint allows specifying `~` as the dag_id to retrieve Dag Versions for all Dags. :param dag_id: (required) :type dag_id: str @@ -543,7 +543,7 @@ def get_dag_versions_without_preload_content( ) -> RESTResponseType: """Get Dag Versions - Get all DAG Versions. This endpoint allows specifying `~` as the dag_id to retrieve DAG Versions for all DAGs. + Get all Dag Versions. This endpoint allows specifying `~` as the dag_id to retrieve Dag Versions for all Dags. :param dag_id: (required) :type dag_id: str diff --git a/airflow_client/client/api/dag_warning_api.py b/airflow_client/client/api/dag_warning_api.py index f94244ed..e9a0fb1a 100644 --- a/airflow_client/client/api/dag_warning_api.py +++ b/airflow_client/client/api/dag_warning_api.py @@ -61,7 +61,7 @@ def list_dag_warnings( ) -> DAGWarningCollectionResponse: """List Dag Warnings - Get a list of DAG warnings. + Get a list of Dag warnings. :param dag_id: :type dag_id: str @@ -147,7 +147,7 @@ def list_dag_warnings_with_http_info( ) -> ApiResponse[DAGWarningCollectionResponse]: """List Dag Warnings - Get a list of DAG warnings. + Get a list of Dag warnings. :param dag_id: :type dag_id: str @@ -233,7 +233,7 @@ def list_dag_warnings_without_preload_content( ) -> RESTResponseType: """List Dag Warnings - Get a list of DAG warnings. + Get a list of Dag warnings. :param dag_id: :type dag_id: str diff --git a/airflow_client/client/api/event_log_api.py b/airflow_client/client/api/event_log_api.py index f00fc780..724c206b 100644 --- a/airflow_client/client/api/event_log_api.py +++ b/airflow_client/client/api/event_log_api.py @@ -328,11 +328,16 @@ def get_event_logs( included_events: Optional[List[StrictStr]] = None, before: Optional[datetime] = None, after: Optional[datetime] = None, - dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - task_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - run_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - owner_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - event_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible.")] = None, + task_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_id_prefix_pattern`` parameter when possible.")] = None, + run_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible.")] = None, + owner_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``owner_prefix_pattern`` parameter when possible.")] = None, + event_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``event_prefix_pattern`` parameter when possible.")] = None, + dag_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + task_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + run_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + owner_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + event_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -378,16 +383,26 @@ def get_event_logs( :type before: datetime :param after: :type after: datetime - :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. :type dag_id_pattern: str - :param task_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param task_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_id_prefix_pattern`` parameter when possible. :type task_id_pattern: str - :param run_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param run_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible. :type run_id_pattern: str - :param owner_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param owner_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``owner_prefix_pattern`` parameter when possible. :type owner_pattern: str - :param event_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param event_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``event_prefix_pattern`` parameter when possible. :type event_pattern: str + :param dag_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type dag_id_prefix_pattern: str + :param task_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type task_id_prefix_pattern: str + :param run_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type run_id_prefix_pattern: str + :param owner_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type owner_prefix_pattern: str + :param event_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type event_prefix_pattern: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -430,6 +445,11 @@ def get_event_logs( run_id_pattern=run_id_pattern, owner_pattern=owner_pattern, event_pattern=event_pattern, + dag_id_prefix_pattern=dag_id_prefix_pattern, + task_id_prefix_pattern=task_id_prefix_pattern, + run_id_prefix_pattern=run_id_prefix_pattern, + owner_prefix_pattern=owner_prefix_pattern, + event_prefix_pattern=event_prefix_pattern, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -470,11 +490,16 @@ def get_event_logs_with_http_info( included_events: Optional[List[StrictStr]] = None, before: Optional[datetime] = None, after: Optional[datetime] = None, - dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - task_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - run_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - owner_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - event_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible.")] = None, + task_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_id_prefix_pattern`` parameter when possible.")] = None, + run_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible.")] = None, + owner_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``owner_prefix_pattern`` parameter when possible.")] = None, + event_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``event_prefix_pattern`` parameter when possible.")] = None, + dag_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + task_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + run_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + owner_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + event_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -520,16 +545,26 @@ def get_event_logs_with_http_info( :type before: datetime :param after: :type after: datetime - :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. :type dag_id_pattern: str - :param task_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param task_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_id_prefix_pattern`` parameter when possible. :type task_id_pattern: str - :param run_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param run_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible. :type run_id_pattern: str - :param owner_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param owner_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``owner_prefix_pattern`` parameter when possible. :type owner_pattern: str - :param event_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param event_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``event_prefix_pattern`` parameter when possible. :type event_pattern: str + :param dag_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type dag_id_prefix_pattern: str + :param task_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type task_id_prefix_pattern: str + :param run_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type run_id_prefix_pattern: str + :param owner_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type owner_prefix_pattern: str + :param event_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type event_prefix_pattern: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -572,6 +607,11 @@ def get_event_logs_with_http_info( run_id_pattern=run_id_pattern, owner_pattern=owner_pattern, event_pattern=event_pattern, + dag_id_prefix_pattern=dag_id_prefix_pattern, + task_id_prefix_pattern=task_id_prefix_pattern, + run_id_prefix_pattern=run_id_prefix_pattern, + owner_prefix_pattern=owner_prefix_pattern, + event_prefix_pattern=event_prefix_pattern, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -612,11 +652,16 @@ def get_event_logs_without_preload_content( included_events: Optional[List[StrictStr]] = None, before: Optional[datetime] = None, after: Optional[datetime] = None, - dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - task_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - run_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - owner_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - event_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible.")] = None, + task_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_id_prefix_pattern`` parameter when possible.")] = None, + run_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible.")] = None, + owner_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``owner_prefix_pattern`` parameter when possible.")] = None, + event_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``event_prefix_pattern`` parameter when possible.")] = None, + dag_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + task_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + run_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + owner_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + event_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -662,16 +707,26 @@ def get_event_logs_without_preload_content( :type before: datetime :param after: :type after: datetime - :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. :type dag_id_pattern: str - :param task_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param task_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_id_prefix_pattern`` parameter when possible. :type task_id_pattern: str - :param run_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param run_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible. :type run_id_pattern: str - :param owner_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param owner_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``owner_prefix_pattern`` parameter when possible. :type owner_pattern: str - :param event_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param event_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``event_prefix_pattern`` parameter when possible. :type event_pattern: str + :param dag_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type dag_id_prefix_pattern: str + :param task_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type task_id_prefix_pattern: str + :param run_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type run_id_prefix_pattern: str + :param owner_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type owner_prefix_pattern: str + :param event_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type event_prefix_pattern: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -714,6 +769,11 @@ def get_event_logs_without_preload_content( run_id_pattern=run_id_pattern, owner_pattern=owner_pattern, event_pattern=event_pattern, + dag_id_prefix_pattern=dag_id_prefix_pattern, + task_id_prefix_pattern=task_id_prefix_pattern, + run_id_prefix_pattern=run_id_prefix_pattern, + owner_prefix_pattern=owner_prefix_pattern, + event_prefix_pattern=event_prefix_pattern, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -754,6 +814,11 @@ def _get_event_logs_serialize( run_id_pattern, owner_pattern, event_pattern, + dag_id_prefix_pattern, + task_id_prefix_pattern, + run_id_prefix_pattern, + owner_prefix_pattern, + event_prefix_pattern, _request_auth, _content_type, _headers, @@ -873,6 +938,26 @@ def _get_event_logs_serialize( _query_params.append(('event_pattern', event_pattern)) + if dag_id_prefix_pattern is not None: + + _query_params.append(('dag_id_prefix_pattern', dag_id_prefix_pattern)) + + if task_id_prefix_pattern is not None: + + _query_params.append(('task_id_prefix_pattern', task_id_prefix_pattern)) + + if run_id_prefix_pattern is not None: + + _query_params.append(('run_id_prefix_pattern', run_id_prefix_pattern)) + + if owner_prefix_pattern is not None: + + _query_params.append(('owner_prefix_pattern', owner_prefix_pattern)) + + if event_prefix_pattern is not None: + + _query_params.append(('event_prefix_pattern', event_prefix_pattern)) + # process the header parameters # process the form parameters # process the body parameter diff --git a/airflow_client/client/api/experimental_api.py b/airflow_client/client/api/experimental_api.py index 36492252..68207fab 100644 --- a/airflow_client/client/api/experimental_api.py +++ b/airflow_client/client/api/experimental_api.py @@ -59,7 +59,7 @@ def wait_dag_run_until_finished( ) -> object: """Experimental: Wait for a dag run to complete, and return task results if requested. - 🚧 This is an experimental endpoint and may change or be removed without notice.Successful response are streamed as newline-delimited JSON (NDJSON). Each line is a JSON object representing the DAG run state. + 🚧 This is an experimental endpoint and may change or be removed without notice.Successful response are streamed as newline-delimited JSON (NDJSON). Each line is a JSON object representing the Dag run state. :param dag_id: (required) :type dag_id: str @@ -142,7 +142,7 @@ def wait_dag_run_until_finished_with_http_info( ) -> ApiResponse[object]: """Experimental: Wait for a dag run to complete, and return task results if requested. - 🚧 This is an experimental endpoint and may change or be removed without notice.Successful response are streamed as newline-delimited JSON (NDJSON). Each line is a JSON object representing the DAG run state. + 🚧 This is an experimental endpoint and may change or be removed without notice.Successful response are streamed as newline-delimited JSON (NDJSON). Each line is a JSON object representing the Dag run state. :param dag_id: (required) :type dag_id: str @@ -225,7 +225,7 @@ def wait_dag_run_until_finished_without_preload_content( ) -> RESTResponseType: """Experimental: Wait for a dag run to complete, and return task results if requested. - 🚧 This is an experimental endpoint and may change or be removed without notice.Successful response are streamed as newline-delimited JSON (NDJSON). Each line is a JSON object representing the DAG run state. + 🚧 This is an experimental endpoint and may change or be removed without notice.Successful response are streamed as newline-delimited JSON (NDJSON). Each line is a JSON object representing the Dag run state. :param dag_id: (required) :type dag_id: str diff --git a/airflow_client/client/api/extra_links_api.py b/airflow_client/client/api/extra_links_api.py index e4a88c49..28130ef5 100644 --- a/airflow_client/client/api/extra_links_api.py +++ b/airflow_client/client/api/extra_links_api.py @@ -44,6 +44,7 @@ def get_extra_links( dag_run_id: StrictStr, task_id: StrictStr, map_index: Optional[StrictInt] = None, + try_number: Optional[StrictInt] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -69,6 +70,8 @@ def get_extra_links( :type task_id: str :param map_index: :type map_index: int + :param try_number: + :type try_number: int :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -96,6 +99,7 @@ def get_extra_links( dag_run_id=dag_run_id, task_id=task_id, map_index=map_index, + try_number=try_number, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -127,6 +131,7 @@ def get_extra_links_with_http_info( dag_run_id: StrictStr, task_id: StrictStr, map_index: Optional[StrictInt] = None, + try_number: Optional[StrictInt] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -152,6 +157,8 @@ def get_extra_links_with_http_info( :type task_id: str :param map_index: :type map_index: int + :param try_number: + :type try_number: int :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -179,6 +186,7 @@ def get_extra_links_with_http_info( dag_run_id=dag_run_id, task_id=task_id, map_index=map_index, + try_number=try_number, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -210,6 +218,7 @@ def get_extra_links_without_preload_content( dag_run_id: StrictStr, task_id: StrictStr, map_index: Optional[StrictInt] = None, + try_number: Optional[StrictInt] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -235,6 +244,8 @@ def get_extra_links_without_preload_content( :type task_id: str :param map_index: :type map_index: int + :param try_number: + :type try_number: int :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -262,6 +273,7 @@ def get_extra_links_without_preload_content( dag_run_id=dag_run_id, task_id=task_id, map_index=map_index, + try_number=try_number, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -288,6 +300,7 @@ def _get_extra_links_serialize( dag_run_id, task_id, map_index, + try_number, _request_auth, _content_type, _headers, @@ -320,6 +333,10 @@ def _get_extra_links_serialize( _query_params.append(('map_index', map_index)) + if try_number is not None: + + _query_params.append(('try_number', try_number)) + # process the header parameters # process the form parameters # process the body parameter diff --git a/airflow_client/client/api/import_error_api.py b/airflow_client/client/api/import_error_api.py index fe93a308..b3dbf425 100644 --- a/airflow_client/client/api/import_error_api.py +++ b/airflow_client/client/api/import_error_api.py @@ -319,7 +319,8 @@ def get_import_errors( limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, timestamp, filename, bundle_name, stacktrace, import_error_id`")] = None, - filename_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + filename_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``filename_prefix_pattern`` parameter when possible.")] = None, + filename_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -343,8 +344,10 @@ def get_import_errors( :type offset: int :param order_by: Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, timestamp, filename, bundle_name, stacktrace, import_error_id` :type order_by: List[str] - :param filename_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param filename_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``filename_prefix_pattern`` parameter when possible. :type filename_pattern: str + :param filename_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type filename_prefix_pattern: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -372,6 +375,7 @@ def get_import_errors( offset=offset, order_by=order_by, filename_pattern=filename_pattern, + filename_prefix_pattern=filename_prefix_pattern, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -401,7 +405,8 @@ def get_import_errors_with_http_info( limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, timestamp, filename, bundle_name, stacktrace, import_error_id`")] = None, - filename_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + filename_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``filename_prefix_pattern`` parameter when possible.")] = None, + filename_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -425,8 +430,10 @@ def get_import_errors_with_http_info( :type offset: int :param order_by: Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, timestamp, filename, bundle_name, stacktrace, import_error_id` :type order_by: List[str] - :param filename_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param filename_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``filename_prefix_pattern`` parameter when possible. :type filename_pattern: str + :param filename_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type filename_prefix_pattern: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -454,6 +461,7 @@ def get_import_errors_with_http_info( offset=offset, order_by=order_by, filename_pattern=filename_pattern, + filename_prefix_pattern=filename_prefix_pattern, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -483,7 +491,8 @@ def get_import_errors_without_preload_content( limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, timestamp, filename, bundle_name, stacktrace, import_error_id`")] = None, - filename_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + filename_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``filename_prefix_pattern`` parameter when possible.")] = None, + filename_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -507,8 +516,10 @@ def get_import_errors_without_preload_content( :type offset: int :param order_by: Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, timestamp, filename, bundle_name, stacktrace, import_error_id` :type order_by: List[str] - :param filename_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param filename_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``filename_prefix_pattern`` parameter when possible. :type filename_pattern: str + :param filename_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type filename_prefix_pattern: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -536,6 +547,7 @@ def get_import_errors_without_preload_content( offset=offset, order_by=order_by, filename_pattern=filename_pattern, + filename_prefix_pattern=filename_prefix_pattern, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -561,6 +573,7 @@ def _get_import_errors_serialize( offset, order_by, filename_pattern, + filename_prefix_pattern, _request_auth, _content_type, _headers, @@ -600,6 +613,10 @@ def _get_import_errors_serialize( _query_params.append(('filename_pattern', filename_pattern)) + if filename_prefix_pattern is not None: + + _query_params.append(('filename_prefix_pattern', filename_prefix_pattern)) + # process the header parameters # process the form parameters # process the body parameter diff --git a/airflow_client/client/api/pool_api.py b/airflow_client/client/api/pool_api.py index 8eb83a35..a19b856e 100644 --- a/airflow_client/client/api/pool_api.py +++ b/airflow_client/client/api/pool_api.py @@ -884,7 +884,8 @@ def get_pools( limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, pool, name`")] = None, - pool_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + pool_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``pool_name_prefix_pattern`` parameter when possible.")] = None, + pool_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -908,8 +909,10 @@ def get_pools( :type offset: int :param order_by: Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, pool, name` :type order_by: List[str] - :param pool_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param pool_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``pool_name_prefix_pattern`` parameter when possible. :type pool_name_pattern: str + :param pool_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type pool_name_prefix_pattern: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -937,6 +940,7 @@ def get_pools( offset=offset, order_by=order_by, pool_name_pattern=pool_name_pattern, + pool_name_prefix_pattern=pool_name_prefix_pattern, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -967,7 +971,8 @@ def get_pools_with_http_info( limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, pool, name`")] = None, - pool_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + pool_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``pool_name_prefix_pattern`` parameter when possible.")] = None, + pool_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -991,8 +996,10 @@ def get_pools_with_http_info( :type offset: int :param order_by: Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, pool, name` :type order_by: List[str] - :param pool_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param pool_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``pool_name_prefix_pattern`` parameter when possible. :type pool_name_pattern: str + :param pool_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type pool_name_prefix_pattern: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -1020,6 +1027,7 @@ def get_pools_with_http_info( offset=offset, order_by=order_by, pool_name_pattern=pool_name_pattern, + pool_name_prefix_pattern=pool_name_prefix_pattern, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1050,7 +1058,8 @@ def get_pools_without_preload_content( limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, pool, name`")] = None, - pool_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + pool_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``pool_name_prefix_pattern`` parameter when possible.")] = None, + pool_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -1074,8 +1083,10 @@ def get_pools_without_preload_content( :type offset: int :param order_by: Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, pool, name` :type order_by: List[str] - :param pool_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param pool_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``pool_name_prefix_pattern`` parameter when possible. :type pool_name_pattern: str + :param pool_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type pool_name_prefix_pattern: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -1103,6 +1114,7 @@ def get_pools_without_preload_content( offset=offset, order_by=order_by, pool_name_pattern=pool_name_pattern, + pool_name_prefix_pattern=pool_name_prefix_pattern, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1129,6 +1141,7 @@ def _get_pools_serialize( offset, order_by, pool_name_pattern, + pool_name_prefix_pattern, _request_auth, _content_type, _headers, @@ -1168,6 +1181,10 @@ def _get_pools_serialize( _query_params.append(('pool_name_pattern', pool_name_pattern)) + if pool_name_prefix_pattern is not None: + + _query_params.append(('pool_name_prefix_pattern', pool_name_prefix_pattern)) + # process the header parameters # process the form parameters # process the body parameter diff --git a/airflow_client/client/api/task_api.py b/airflow_client/client/api/task_api.py index 811210e1..0e91b6f4 100644 --- a/airflow_client/client/api/task_api.py +++ b/airflow_client/client/api/task_api.py @@ -350,7 +350,7 @@ def get_tasks( ) -> TaskCollectionResponse: """Get Tasks - Get tasks for DAG. + Get tasks for Dag. :param dag_id: (required) :type dag_id: str @@ -426,7 +426,7 @@ def get_tasks_with_http_info( ) -> ApiResponse[TaskCollectionResponse]: """Get Tasks - Get tasks for DAG. + Get tasks for Dag. :param dag_id: (required) :type dag_id: str @@ -502,7 +502,7 @@ def get_tasks_without_preload_content( ) -> RESTResponseType: """Get Tasks - Get tasks for DAG. + Get tasks for Dag. :param dag_id: (required) :type dag_id: str diff --git a/airflow_client/client/api/task_instance_api.py b/airflow_client/client/api/task_instance_api.py index 3e0c1839..dee47c33 100644 --- a/airflow_client/client/api/task_instance_api.py +++ b/airflow_client/client/api/task_instance_api.py @@ -1037,6 +1037,7 @@ def get_extra_links( dag_run_id: StrictStr, task_id: StrictStr, map_index: Optional[StrictInt] = None, + try_number: Optional[StrictInt] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -1062,6 +1063,8 @@ def get_extra_links( :type task_id: str :param map_index: :type map_index: int + :param try_number: + :type try_number: int :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -1089,6 +1092,7 @@ def get_extra_links( dag_run_id=dag_run_id, task_id=task_id, map_index=map_index, + try_number=try_number, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1120,6 +1124,7 @@ def get_extra_links_with_http_info( dag_run_id: StrictStr, task_id: StrictStr, map_index: Optional[StrictInt] = None, + try_number: Optional[StrictInt] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -1145,6 +1150,8 @@ def get_extra_links_with_http_info( :type task_id: str :param map_index: :type map_index: int + :param try_number: + :type try_number: int :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -1172,6 +1179,7 @@ def get_extra_links_with_http_info( dag_run_id=dag_run_id, task_id=task_id, map_index=map_index, + try_number=try_number, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1203,6 +1211,7 @@ def get_extra_links_without_preload_content( dag_run_id: StrictStr, task_id: StrictStr, map_index: Optional[StrictInt] = None, + try_number: Optional[StrictInt] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -1228,6 +1237,8 @@ def get_extra_links_without_preload_content( :type task_id: str :param map_index: :type map_index: int + :param try_number: + :type try_number: int :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -1255,6 +1266,7 @@ def get_extra_links_without_preload_content( dag_run_id=dag_run_id, task_id=task_id, map_index=map_index, + try_number=try_number, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1281,6 +1293,7 @@ def _get_extra_links_serialize( dag_run_id, task_id, map_index, + try_number, _request_auth, _content_type, _headers, @@ -1313,6 +1326,10 @@ def _get_extra_links_serialize( _query_params.append(('map_index', map_index)) + if try_number is not None: + + _query_params.append(('try_number', try_number)) + # process the header parameters # process the form parameters # process the body parameter @@ -2012,16 +2029,18 @@ def get_hitl_details( limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `ti_id, subject, responded_at, created_at, responded_by_user_id, responded_by_user_name, dag_id, run_id, task_display_name, run_after, rendered_map_index, task_instance_operator, task_instance_state`")] = None, - dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible.")] = None, + dag_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, task_id: Optional[StrictStr] = None, - task_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + task_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_id_prefix_pattern`` parameter when possible.")] = None, + task_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, map_index: Optional[StrictInt] = None, state: Optional[List[StrictStr]] = None, response_received: Optional[StrictBool] = None, responded_by_user_id: Optional[List[StrictStr]] = None, responded_by_user_name: Optional[List[StrictStr]] = None, - subject_search: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - body_search: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + subject_search: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``subject_search`` parameter when possible.")] = None, + body_search: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``body_search`` parameter when possible.")] = None, created_at_gte: Optional[datetime] = None, created_at_gt: Optional[datetime] = None, created_at_lte: Optional[datetime] = None, @@ -2053,12 +2072,16 @@ def get_hitl_details( :type offset: int :param order_by: Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `ti_id, subject, responded_at, created_at, responded_by_user_id, responded_by_user_name, dag_id, run_id, task_display_name, run_after, rendered_map_index, task_instance_operator, task_instance_state` :type order_by: List[str] - :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. :type dag_id_pattern: str + :param dag_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type dag_id_prefix_pattern: str :param task_id: :type task_id: str - :param task_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param task_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_id_prefix_pattern`` parameter when possible. :type task_id_pattern: str + :param task_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type task_id_prefix_pattern: str :param map_index: :type map_index: int :param state: @@ -2069,9 +2092,9 @@ def get_hitl_details( :type responded_by_user_id: List[str] :param responded_by_user_name: :type responded_by_user_name: List[str] - :param subject_search: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param subject_search: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``subject_search`` parameter when possible. :type subject_search: str - :param body_search: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param body_search: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``body_search`` parameter when possible. :type body_search: str :param created_at_gte: :type created_at_gte: datetime @@ -2110,8 +2133,10 @@ def get_hitl_details( offset=offset, order_by=order_by, dag_id_pattern=dag_id_pattern, + dag_id_prefix_pattern=dag_id_prefix_pattern, task_id=task_id, task_id_pattern=task_id_pattern, + task_id_prefix_pattern=task_id_prefix_pattern, map_index=map_index, state=state, response_received=response_received, @@ -2154,16 +2179,18 @@ def get_hitl_details_with_http_info( limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `ti_id, subject, responded_at, created_at, responded_by_user_id, responded_by_user_name, dag_id, run_id, task_display_name, run_after, rendered_map_index, task_instance_operator, task_instance_state`")] = None, - dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible.")] = None, + dag_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, task_id: Optional[StrictStr] = None, - task_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + task_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_id_prefix_pattern`` parameter when possible.")] = None, + task_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, map_index: Optional[StrictInt] = None, state: Optional[List[StrictStr]] = None, response_received: Optional[StrictBool] = None, responded_by_user_id: Optional[List[StrictStr]] = None, responded_by_user_name: Optional[List[StrictStr]] = None, - subject_search: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - body_search: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + subject_search: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``subject_search`` parameter when possible.")] = None, + body_search: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``body_search`` parameter when possible.")] = None, created_at_gte: Optional[datetime] = None, created_at_gt: Optional[datetime] = None, created_at_lte: Optional[datetime] = None, @@ -2195,12 +2222,16 @@ def get_hitl_details_with_http_info( :type offset: int :param order_by: Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `ti_id, subject, responded_at, created_at, responded_by_user_id, responded_by_user_name, dag_id, run_id, task_display_name, run_after, rendered_map_index, task_instance_operator, task_instance_state` :type order_by: List[str] - :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. :type dag_id_pattern: str + :param dag_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type dag_id_prefix_pattern: str :param task_id: :type task_id: str - :param task_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param task_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_id_prefix_pattern`` parameter when possible. :type task_id_pattern: str + :param task_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type task_id_prefix_pattern: str :param map_index: :type map_index: int :param state: @@ -2211,9 +2242,9 @@ def get_hitl_details_with_http_info( :type responded_by_user_id: List[str] :param responded_by_user_name: :type responded_by_user_name: List[str] - :param subject_search: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param subject_search: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``subject_search`` parameter when possible. :type subject_search: str - :param body_search: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param body_search: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``body_search`` parameter when possible. :type body_search: str :param created_at_gte: :type created_at_gte: datetime @@ -2252,8 +2283,10 @@ def get_hitl_details_with_http_info( offset=offset, order_by=order_by, dag_id_pattern=dag_id_pattern, + dag_id_prefix_pattern=dag_id_prefix_pattern, task_id=task_id, task_id_pattern=task_id_pattern, + task_id_prefix_pattern=task_id_prefix_pattern, map_index=map_index, state=state, response_received=response_received, @@ -2296,16 +2329,18 @@ def get_hitl_details_without_preload_content( limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `ti_id, subject, responded_at, created_at, responded_by_user_id, responded_by_user_name, dag_id, run_id, task_display_name, run_after, rendered_map_index, task_instance_operator, task_instance_state`")] = None, - dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible.")] = None, + dag_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, task_id: Optional[StrictStr] = None, - task_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + task_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_id_prefix_pattern`` parameter when possible.")] = None, + task_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, map_index: Optional[StrictInt] = None, state: Optional[List[StrictStr]] = None, response_received: Optional[StrictBool] = None, responded_by_user_id: Optional[List[StrictStr]] = None, responded_by_user_name: Optional[List[StrictStr]] = None, - subject_search: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - body_search: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + subject_search: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``subject_search`` parameter when possible.")] = None, + body_search: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``body_search`` parameter when possible.")] = None, created_at_gte: Optional[datetime] = None, created_at_gt: Optional[datetime] = None, created_at_lte: Optional[datetime] = None, @@ -2337,12 +2372,16 @@ def get_hitl_details_without_preload_content( :type offset: int :param order_by: Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `ti_id, subject, responded_at, created_at, responded_by_user_id, responded_by_user_name, dag_id, run_id, task_display_name, run_after, rendered_map_index, task_instance_operator, task_instance_state` :type order_by: List[str] - :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. :type dag_id_pattern: str + :param dag_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type dag_id_prefix_pattern: str :param task_id: :type task_id: str - :param task_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param task_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_id_prefix_pattern`` parameter when possible. :type task_id_pattern: str + :param task_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type task_id_prefix_pattern: str :param map_index: :type map_index: int :param state: @@ -2353,9 +2392,9 @@ def get_hitl_details_without_preload_content( :type responded_by_user_id: List[str] :param responded_by_user_name: :type responded_by_user_name: List[str] - :param subject_search: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param subject_search: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``subject_search`` parameter when possible. :type subject_search: str - :param body_search: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param body_search: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``body_search`` parameter when possible. :type body_search: str :param created_at_gte: :type created_at_gte: datetime @@ -2394,8 +2433,10 @@ def get_hitl_details_without_preload_content( offset=offset, order_by=order_by, dag_id_pattern=dag_id_pattern, + dag_id_prefix_pattern=dag_id_prefix_pattern, task_id=task_id, task_id_pattern=task_id_pattern, + task_id_prefix_pattern=task_id_prefix_pattern, map_index=map_index, state=state, response_received=response_received, @@ -2434,8 +2475,10 @@ def _get_hitl_details_serialize( offset, order_by, dag_id_pattern, + dag_id_prefix_pattern, task_id, task_id_pattern, + task_id_prefix_pattern, map_index, state, response_received, @@ -2493,6 +2536,10 @@ def _get_hitl_details_serialize( _query_params.append(('dag_id_pattern', dag_id_pattern)) + if dag_id_prefix_pattern is not None: + + _query_params.append(('dag_id_prefix_pattern', dag_id_prefix_pattern)) + if task_id is not None: _query_params.append(('task_id', task_id)) @@ -2501,6 +2548,10 @@ def _get_hitl_details_serialize( _query_params.append(('task_id_pattern', task_id_pattern)) + if task_id_prefix_pattern is not None: + + _query_params.append(('task_id_prefix_pattern', task_id_prefix_pattern)) + if map_index is not None: _query_params.append(('map_index', map_index)) @@ -4003,15 +4054,20 @@ def get_mapped_task_instances( duration_lt: Optional[Union[StrictFloat, StrictInt]] = None, state: Optional[List[StrictStr]] = None, pool: Optional[List[StrictStr]] = None, - pool_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + pool_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``pool_name_prefix_pattern`` parameter when possible.")] = None, + pool_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, queue: Optional[List[StrictStr]] = None, - queue_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + queue_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``queue_name_prefix_pattern`` parameter when possible.")] = None, + queue_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, executor: Optional[List[StrictStr]] = None, version_number: Optional[List[StrictInt]] = None, try_number: Optional[List[StrictInt]] = None, operator: Optional[List[StrictStr]] = None, - operator_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + operator_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``operator_name_prefix_pattern`` parameter when possible.")] = None, + operator_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, map_index: Optional[List[StrictInt]] = None, + rendered_map_index_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``rendered_map_index_prefix_pattern`` parameter when possible.")] = None, + rendered_map_index_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, state, duration, start_date, end_date, map_index, try_number, logical_date, run_after, data_interval_start, data_interval_end, rendered_map_index, operator, run_after, logical_date, data_interval_start, data_interval_end`")] = None, @@ -4090,12 +4146,16 @@ def get_mapped_task_instances( :type state: List[str] :param pool: :type pool: List[str] - :param pool_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param pool_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``pool_name_prefix_pattern`` parameter when possible. :type pool_name_pattern: str + :param pool_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type pool_name_prefix_pattern: str :param queue: :type queue: List[str] - :param queue_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param queue_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``queue_name_prefix_pattern`` parameter when possible. :type queue_name_pattern: str + :param queue_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type queue_name_prefix_pattern: str :param executor: :type executor: List[str] :param version_number: @@ -4104,10 +4164,16 @@ def get_mapped_task_instances( :type try_number: List[int] :param operator: :type operator: List[str] - :param operator_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param operator_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``operator_name_prefix_pattern`` parameter when possible. :type operator_name_pattern: str + :param operator_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type operator_name_prefix_pattern: str :param map_index: :type map_index: List[int] + :param rendered_map_index_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``rendered_map_index_prefix_pattern`` parameter when possible. + :type rendered_map_index_pattern: str + :param rendered_map_index_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type rendered_map_index_prefix_pattern: str :param limit: :type limit: int :param offset: @@ -4167,14 +4233,19 @@ def get_mapped_task_instances( state=state, pool=pool, pool_name_pattern=pool_name_pattern, + pool_name_prefix_pattern=pool_name_prefix_pattern, queue=queue, queue_name_pattern=queue_name_pattern, + queue_name_prefix_pattern=queue_name_prefix_pattern, executor=executor, version_number=version_number, try_number=try_number, operator=operator, operator_name_pattern=operator_name_pattern, + operator_name_prefix_pattern=operator_name_prefix_pattern, map_index=map_index, + rendered_map_index_pattern=rendered_map_index_pattern, + rendered_map_index_prefix_pattern=rendered_map_index_prefix_pattern, limit=limit, offset=offset, order_by=order_by, @@ -4234,15 +4305,20 @@ def get_mapped_task_instances_with_http_info( duration_lt: Optional[Union[StrictFloat, StrictInt]] = None, state: Optional[List[StrictStr]] = None, pool: Optional[List[StrictStr]] = None, - pool_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + pool_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``pool_name_prefix_pattern`` parameter when possible.")] = None, + pool_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, queue: Optional[List[StrictStr]] = None, - queue_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + queue_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``queue_name_prefix_pattern`` parameter when possible.")] = None, + queue_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, executor: Optional[List[StrictStr]] = None, version_number: Optional[List[StrictInt]] = None, try_number: Optional[List[StrictInt]] = None, operator: Optional[List[StrictStr]] = None, - operator_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + operator_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``operator_name_prefix_pattern`` parameter when possible.")] = None, + operator_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, map_index: Optional[List[StrictInt]] = None, + rendered_map_index_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``rendered_map_index_prefix_pattern`` parameter when possible.")] = None, + rendered_map_index_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, state, duration, start_date, end_date, map_index, try_number, logical_date, run_after, data_interval_start, data_interval_end, rendered_map_index, operator, run_after, logical_date, data_interval_start, data_interval_end`")] = None, @@ -4321,12 +4397,16 @@ def get_mapped_task_instances_with_http_info( :type state: List[str] :param pool: :type pool: List[str] - :param pool_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param pool_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``pool_name_prefix_pattern`` parameter when possible. :type pool_name_pattern: str + :param pool_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type pool_name_prefix_pattern: str :param queue: :type queue: List[str] - :param queue_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param queue_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``queue_name_prefix_pattern`` parameter when possible. :type queue_name_pattern: str + :param queue_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type queue_name_prefix_pattern: str :param executor: :type executor: List[str] :param version_number: @@ -4335,10 +4415,16 @@ def get_mapped_task_instances_with_http_info( :type try_number: List[int] :param operator: :type operator: List[str] - :param operator_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param operator_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``operator_name_prefix_pattern`` parameter when possible. :type operator_name_pattern: str + :param operator_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type operator_name_prefix_pattern: str :param map_index: :type map_index: List[int] + :param rendered_map_index_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``rendered_map_index_prefix_pattern`` parameter when possible. + :type rendered_map_index_pattern: str + :param rendered_map_index_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type rendered_map_index_prefix_pattern: str :param limit: :type limit: int :param offset: @@ -4398,14 +4484,19 @@ def get_mapped_task_instances_with_http_info( state=state, pool=pool, pool_name_pattern=pool_name_pattern, + pool_name_prefix_pattern=pool_name_prefix_pattern, queue=queue, queue_name_pattern=queue_name_pattern, + queue_name_prefix_pattern=queue_name_prefix_pattern, executor=executor, version_number=version_number, try_number=try_number, operator=operator, operator_name_pattern=operator_name_pattern, + operator_name_prefix_pattern=operator_name_prefix_pattern, map_index=map_index, + rendered_map_index_pattern=rendered_map_index_pattern, + rendered_map_index_prefix_pattern=rendered_map_index_prefix_pattern, limit=limit, offset=offset, order_by=order_by, @@ -4465,15 +4556,20 @@ def get_mapped_task_instances_without_preload_content( duration_lt: Optional[Union[StrictFloat, StrictInt]] = None, state: Optional[List[StrictStr]] = None, pool: Optional[List[StrictStr]] = None, - pool_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + pool_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``pool_name_prefix_pattern`` parameter when possible.")] = None, + pool_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, queue: Optional[List[StrictStr]] = None, - queue_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + queue_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``queue_name_prefix_pattern`` parameter when possible.")] = None, + queue_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, executor: Optional[List[StrictStr]] = None, version_number: Optional[List[StrictInt]] = None, try_number: Optional[List[StrictInt]] = None, operator: Optional[List[StrictStr]] = None, - operator_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + operator_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``operator_name_prefix_pattern`` parameter when possible.")] = None, + operator_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, map_index: Optional[List[StrictInt]] = None, + rendered_map_index_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``rendered_map_index_prefix_pattern`` parameter when possible.")] = None, + rendered_map_index_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, state, duration, start_date, end_date, map_index, try_number, logical_date, run_after, data_interval_start, data_interval_end, rendered_map_index, operator, run_after, logical_date, data_interval_start, data_interval_end`")] = None, @@ -4552,12 +4648,16 @@ def get_mapped_task_instances_without_preload_content( :type state: List[str] :param pool: :type pool: List[str] - :param pool_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param pool_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``pool_name_prefix_pattern`` parameter when possible. :type pool_name_pattern: str + :param pool_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type pool_name_prefix_pattern: str :param queue: :type queue: List[str] - :param queue_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param queue_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``queue_name_prefix_pattern`` parameter when possible. :type queue_name_pattern: str + :param queue_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type queue_name_prefix_pattern: str :param executor: :type executor: List[str] :param version_number: @@ -4566,10 +4666,16 @@ def get_mapped_task_instances_without_preload_content( :type try_number: List[int] :param operator: :type operator: List[str] - :param operator_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param operator_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``operator_name_prefix_pattern`` parameter when possible. :type operator_name_pattern: str + :param operator_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type operator_name_prefix_pattern: str :param map_index: :type map_index: List[int] + :param rendered_map_index_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``rendered_map_index_prefix_pattern`` parameter when possible. + :type rendered_map_index_pattern: str + :param rendered_map_index_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type rendered_map_index_prefix_pattern: str :param limit: :type limit: int :param offset: @@ -4629,14 +4735,19 @@ def get_mapped_task_instances_without_preload_content( state=state, pool=pool, pool_name_pattern=pool_name_pattern, + pool_name_prefix_pattern=pool_name_prefix_pattern, queue=queue, queue_name_pattern=queue_name_pattern, + queue_name_prefix_pattern=queue_name_prefix_pattern, executor=executor, version_number=version_number, try_number=try_number, operator=operator, operator_name_pattern=operator_name_pattern, + operator_name_prefix_pattern=operator_name_prefix_pattern, map_index=map_index, + rendered_map_index_pattern=rendered_map_index_pattern, + rendered_map_index_prefix_pattern=rendered_map_index_prefix_pattern, limit=limit, offset=offset, order_by=order_by, @@ -4692,14 +4803,19 @@ def _get_mapped_task_instances_serialize( state, pool, pool_name_pattern, + pool_name_prefix_pattern, queue, queue_name_pattern, + queue_name_prefix_pattern, executor, version_number, try_number, operator, operator_name_pattern, + operator_name_prefix_pattern, map_index, + rendered_map_index_pattern, + rendered_map_index_prefix_pattern, limit, offset, order_by, @@ -5028,6 +5144,10 @@ def _get_mapped_task_instances_serialize( _query_params.append(('pool_name_pattern', pool_name_pattern)) + if pool_name_prefix_pattern is not None: + + _query_params.append(('pool_name_prefix_pattern', pool_name_prefix_pattern)) + if queue is not None: _query_params.append(('queue', queue)) @@ -5036,6 +5156,10 @@ def _get_mapped_task_instances_serialize( _query_params.append(('queue_name_pattern', queue_name_pattern)) + if queue_name_prefix_pattern is not None: + + _query_params.append(('queue_name_prefix_pattern', queue_name_prefix_pattern)) + if executor is not None: _query_params.append(('executor', executor)) @@ -5056,10 +5180,22 @@ def _get_mapped_task_instances_serialize( _query_params.append(('operator_name_pattern', operator_name_pattern)) + if operator_name_prefix_pattern is not None: + + _query_params.append(('operator_name_prefix_pattern', operator_name_prefix_pattern)) + if map_index is not None: _query_params.append(('map_index', map_index)) + if rendered_map_index_pattern is not None: + + _query_params.append(('rendered_map_index_pattern', rendered_map_index_pattern)) + + if rendered_map_index_prefix_pattern is not None: + + _query_params.append(('rendered_map_index_prefix_pattern', rendered_map_index_prefix_pattern)) + if limit is not None: _query_params.append(('limit', limit)) @@ -6716,6 +6852,7 @@ def get_task_instances( self, dag_id: StrictStr, dag_run_id: StrictStr, + cursor: Annotated[Optional[StrictStr], Field(description="Cursor for keyset-based pagination. Pass an empty string for the first page, then use ``next_cursor`` from the response. When ``cursor`` is provided, ``offset`` is ignored.")] = None, task_id: Optional[StrictStr] = None, run_after_gte: Optional[datetime] = None, run_after_gt: Optional[datetime] = None, @@ -6741,21 +6878,29 @@ def get_task_instances( duration_gt: Optional[Union[StrictFloat, StrictInt]] = None, duration_lte: Optional[Union[StrictFloat, StrictInt]] = None, duration_lt: Optional[Union[StrictFloat, StrictInt]] = None, - task_display_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + task_display_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_display_name_prefix_pattern`` parameter when possible.")] = None, + task_display_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match on task display name: optional ``_task_display_property_value`` else ``task_id`` (same as ``coalesce``). Case-sensitive. Index-friendly alternative to ``task_display_name_pattern``. On large databases, combine with ``dag_id_prefix_pattern`` (or a specific Dag in the path) so ``(dag_id, task_id, ...)`` indexes apply. Use ``|`` for OR. Use ``~`` to match all. Trailing non-alphanumeric characters in the term are stripped before matching so the range scan stays index-compatible under locale-aware collations.")] = None, task_group_id: Annotated[Optional[StrictStr], Field(description="Filter by exact task group ID. Returns all tasks within the specified task group.")] = None, - dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - run_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible.")] = None, + dag_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + run_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible.")] = None, + run_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, state: Optional[List[StrictStr]] = None, pool: Optional[List[StrictStr]] = None, - pool_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + pool_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``pool_name_prefix_pattern`` parameter when possible.")] = None, + pool_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, queue: Optional[List[StrictStr]] = None, - queue_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + queue_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``queue_name_prefix_pattern`` parameter when possible.")] = None, + queue_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, executor: Optional[List[StrictStr]] = None, version_number: Optional[List[StrictInt]] = None, try_number: Optional[List[StrictInt]] = None, operator: Optional[List[StrictStr]] = None, - operator_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + operator_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``operator_name_prefix_pattern`` parameter when possible.")] = None, + operator_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, map_index: Optional[List[StrictInt]] = None, + rendered_map_index_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``rendered_map_index_prefix_pattern`` parameter when possible.")] = None, + rendered_map_index_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, state, duration, start_date, end_date, map_index, try_number, logical_date, run_after, data_interval_start, data_interval_end, rendered_map_index, operator, logical_date, run_after, data_interval_start, data_interval_end`")] = None, @@ -6774,12 +6919,14 @@ def get_task_instances( ) -> TaskInstanceCollectionResponse: """Get Task Instances - Get list of task instances. This endpoint allows specifying `~` as the dag_id, dag_run_id to retrieve Task Instances for all DAGs and DAG runs. + Get list of task instances. This endpoint allows specifying `~` as the dag_id, dag_run_id to retrieve task instances for all Dags and Dag runs. Supports two pagination modes: **Offset (default):** use `limit` and `offset` query parameters. Returns `total_entries`. **Cursor:** pass `cursor` (empty string for the first page, then `next_cursor` from the response). When `cursor` is provided, `offset` is ignored and `total_entries` is not returned. ``next_cursor`` is ``null`` when there are no more pages; ``previous_cursor`` is ``null`` on the first page. :param dag_id: (required) :type dag_id: str :param dag_run_id: (required) :type dag_run_id: str + :param cursor: Cursor for keyset-based pagination. Pass an empty string for the first page, then use ``next_cursor`` from the response. When ``cursor`` is provided, ``offset`` is ignored. + :type cursor: str :param task_id: :type task_id: str :param run_after_gte: @@ -6830,24 +6977,34 @@ def get_task_instances( :type duration_lte: float :param duration_lt: :type duration_lt: float - :param task_display_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param task_display_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_display_name_prefix_pattern`` parameter when possible. :type task_display_name_pattern: str + :param task_display_name_prefix_pattern: Prefix match on task display name: optional ``_task_display_property_value`` else ``task_id`` (same as ``coalesce``). Case-sensitive. Index-friendly alternative to ``task_display_name_pattern``. On large databases, combine with ``dag_id_prefix_pattern`` (or a specific Dag in the path) so ``(dag_id, task_id, ...)`` indexes apply. Use ``|`` for OR. Use ``~`` to match all. Trailing non-alphanumeric characters in the term are stripped before matching so the range scan stays index-compatible under locale-aware collations. + :type task_display_name_prefix_pattern: str :param task_group_id: Filter by exact task group ID. Returns all tasks within the specified task group. :type task_group_id: str - :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. :type dag_id_pattern: str - :param run_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param dag_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type dag_id_prefix_pattern: str + :param run_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible. :type run_id_pattern: str + :param run_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type run_id_prefix_pattern: str :param state: :type state: List[str] :param pool: :type pool: List[str] - :param pool_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param pool_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``pool_name_prefix_pattern`` parameter when possible. :type pool_name_pattern: str + :param pool_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type pool_name_prefix_pattern: str :param queue: :type queue: List[str] - :param queue_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param queue_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``queue_name_prefix_pattern`` parameter when possible. :type queue_name_pattern: str + :param queue_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type queue_name_prefix_pattern: str :param executor: :type executor: List[str] :param version_number: @@ -6856,10 +7013,16 @@ def get_task_instances( :type try_number: List[int] :param operator: :type operator: List[str] - :param operator_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param operator_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``operator_name_prefix_pattern`` parameter when possible. :type operator_name_pattern: str + :param operator_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type operator_name_prefix_pattern: str :param map_index: :type map_index: List[int] + :param rendered_map_index_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``rendered_map_index_prefix_pattern`` parameter when possible. + :type rendered_map_index_pattern: str + :param rendered_map_index_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type rendered_map_index_prefix_pattern: str :param limit: :type limit: int :param offset: @@ -6891,6 +7054,7 @@ def get_task_instances( _param = self._get_task_instances_serialize( dag_id=dag_id, dag_run_id=dag_run_id, + cursor=cursor, task_id=task_id, run_after_gte=run_after_gte, run_after_gt=run_after_gt, @@ -6917,20 +7081,28 @@ def get_task_instances( duration_lte=duration_lte, duration_lt=duration_lt, task_display_name_pattern=task_display_name_pattern, + task_display_name_prefix_pattern=task_display_name_prefix_pattern, task_group_id=task_group_id, dag_id_pattern=dag_id_pattern, + dag_id_prefix_pattern=dag_id_prefix_pattern, run_id_pattern=run_id_pattern, + run_id_prefix_pattern=run_id_prefix_pattern, state=state, pool=pool, pool_name_pattern=pool_name_pattern, + pool_name_prefix_pattern=pool_name_prefix_pattern, queue=queue, queue_name_pattern=queue_name_pattern, + queue_name_prefix_pattern=queue_name_prefix_pattern, executor=executor, version_number=version_number, try_number=try_number, operator=operator, operator_name_pattern=operator_name_pattern, + operator_name_prefix_pattern=operator_name_prefix_pattern, map_index=map_index, + rendered_map_index_pattern=rendered_map_index_pattern, + rendered_map_index_prefix_pattern=rendered_map_index_prefix_pattern, limit=limit, offset=offset, order_by=order_by, @@ -6964,6 +7136,7 @@ def get_task_instances_with_http_info( self, dag_id: StrictStr, dag_run_id: StrictStr, + cursor: Annotated[Optional[StrictStr], Field(description="Cursor for keyset-based pagination. Pass an empty string for the first page, then use ``next_cursor`` from the response. When ``cursor`` is provided, ``offset`` is ignored.")] = None, task_id: Optional[StrictStr] = None, run_after_gte: Optional[datetime] = None, run_after_gt: Optional[datetime] = None, @@ -6989,21 +7162,29 @@ def get_task_instances_with_http_info( duration_gt: Optional[Union[StrictFloat, StrictInt]] = None, duration_lte: Optional[Union[StrictFloat, StrictInt]] = None, duration_lt: Optional[Union[StrictFloat, StrictInt]] = None, - task_display_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + task_display_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_display_name_prefix_pattern`` parameter when possible.")] = None, + task_display_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match on task display name: optional ``_task_display_property_value`` else ``task_id`` (same as ``coalesce``). Case-sensitive. Index-friendly alternative to ``task_display_name_pattern``. On large databases, combine with ``dag_id_prefix_pattern`` (or a specific Dag in the path) so ``(dag_id, task_id, ...)`` indexes apply. Use ``|`` for OR. Use ``~`` to match all. Trailing non-alphanumeric characters in the term are stripped before matching so the range scan stays index-compatible under locale-aware collations.")] = None, task_group_id: Annotated[Optional[StrictStr], Field(description="Filter by exact task group ID. Returns all tasks within the specified task group.")] = None, - dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - run_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible.")] = None, + dag_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + run_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible.")] = None, + run_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, state: Optional[List[StrictStr]] = None, pool: Optional[List[StrictStr]] = None, - pool_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + pool_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``pool_name_prefix_pattern`` parameter when possible.")] = None, + pool_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, queue: Optional[List[StrictStr]] = None, - queue_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + queue_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``queue_name_prefix_pattern`` parameter when possible.")] = None, + queue_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, executor: Optional[List[StrictStr]] = None, version_number: Optional[List[StrictInt]] = None, try_number: Optional[List[StrictInt]] = None, operator: Optional[List[StrictStr]] = None, - operator_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + operator_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``operator_name_prefix_pattern`` parameter when possible.")] = None, + operator_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, map_index: Optional[List[StrictInt]] = None, + rendered_map_index_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``rendered_map_index_prefix_pattern`` parameter when possible.")] = None, + rendered_map_index_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, state, duration, start_date, end_date, map_index, try_number, logical_date, run_after, data_interval_start, data_interval_end, rendered_map_index, operator, logical_date, run_after, data_interval_start, data_interval_end`")] = None, @@ -7022,12 +7203,14 @@ def get_task_instances_with_http_info( ) -> ApiResponse[TaskInstanceCollectionResponse]: """Get Task Instances - Get list of task instances. This endpoint allows specifying `~` as the dag_id, dag_run_id to retrieve Task Instances for all DAGs and DAG runs. + Get list of task instances. This endpoint allows specifying `~` as the dag_id, dag_run_id to retrieve task instances for all Dags and Dag runs. Supports two pagination modes: **Offset (default):** use `limit` and `offset` query parameters. Returns `total_entries`. **Cursor:** pass `cursor` (empty string for the first page, then `next_cursor` from the response). When `cursor` is provided, `offset` is ignored and `total_entries` is not returned. ``next_cursor`` is ``null`` when there are no more pages; ``previous_cursor`` is ``null`` on the first page. :param dag_id: (required) :type dag_id: str :param dag_run_id: (required) :type dag_run_id: str + :param cursor: Cursor for keyset-based pagination. Pass an empty string for the first page, then use ``next_cursor`` from the response. When ``cursor`` is provided, ``offset`` is ignored. + :type cursor: str :param task_id: :type task_id: str :param run_after_gte: @@ -7078,24 +7261,34 @@ def get_task_instances_with_http_info( :type duration_lte: float :param duration_lt: :type duration_lt: float - :param task_display_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param task_display_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_display_name_prefix_pattern`` parameter when possible. :type task_display_name_pattern: str + :param task_display_name_prefix_pattern: Prefix match on task display name: optional ``_task_display_property_value`` else ``task_id`` (same as ``coalesce``). Case-sensitive. Index-friendly alternative to ``task_display_name_pattern``. On large databases, combine with ``dag_id_prefix_pattern`` (or a specific Dag in the path) so ``(dag_id, task_id, ...)`` indexes apply. Use ``|`` for OR. Use ``~`` to match all. Trailing non-alphanumeric characters in the term are stripped before matching so the range scan stays index-compatible under locale-aware collations. + :type task_display_name_prefix_pattern: str :param task_group_id: Filter by exact task group ID. Returns all tasks within the specified task group. :type task_group_id: str - :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. :type dag_id_pattern: str - :param run_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param dag_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type dag_id_prefix_pattern: str + :param run_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible. :type run_id_pattern: str + :param run_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type run_id_prefix_pattern: str :param state: :type state: List[str] :param pool: :type pool: List[str] - :param pool_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param pool_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``pool_name_prefix_pattern`` parameter when possible. :type pool_name_pattern: str + :param pool_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type pool_name_prefix_pattern: str :param queue: :type queue: List[str] - :param queue_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param queue_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``queue_name_prefix_pattern`` parameter when possible. :type queue_name_pattern: str + :param queue_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type queue_name_prefix_pattern: str :param executor: :type executor: List[str] :param version_number: @@ -7104,10 +7297,16 @@ def get_task_instances_with_http_info( :type try_number: List[int] :param operator: :type operator: List[str] - :param operator_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param operator_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``operator_name_prefix_pattern`` parameter when possible. :type operator_name_pattern: str + :param operator_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type operator_name_prefix_pattern: str :param map_index: :type map_index: List[int] + :param rendered_map_index_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``rendered_map_index_prefix_pattern`` parameter when possible. + :type rendered_map_index_pattern: str + :param rendered_map_index_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type rendered_map_index_prefix_pattern: str :param limit: :type limit: int :param offset: @@ -7139,6 +7338,7 @@ def get_task_instances_with_http_info( _param = self._get_task_instances_serialize( dag_id=dag_id, dag_run_id=dag_run_id, + cursor=cursor, task_id=task_id, run_after_gte=run_after_gte, run_after_gt=run_after_gt, @@ -7165,20 +7365,28 @@ def get_task_instances_with_http_info( duration_lte=duration_lte, duration_lt=duration_lt, task_display_name_pattern=task_display_name_pattern, + task_display_name_prefix_pattern=task_display_name_prefix_pattern, task_group_id=task_group_id, dag_id_pattern=dag_id_pattern, + dag_id_prefix_pattern=dag_id_prefix_pattern, run_id_pattern=run_id_pattern, + run_id_prefix_pattern=run_id_prefix_pattern, state=state, pool=pool, pool_name_pattern=pool_name_pattern, + pool_name_prefix_pattern=pool_name_prefix_pattern, queue=queue, queue_name_pattern=queue_name_pattern, + queue_name_prefix_pattern=queue_name_prefix_pattern, executor=executor, version_number=version_number, try_number=try_number, operator=operator, operator_name_pattern=operator_name_pattern, + operator_name_prefix_pattern=operator_name_prefix_pattern, map_index=map_index, + rendered_map_index_pattern=rendered_map_index_pattern, + rendered_map_index_prefix_pattern=rendered_map_index_prefix_pattern, limit=limit, offset=offset, order_by=order_by, @@ -7212,6 +7420,7 @@ def get_task_instances_without_preload_content( self, dag_id: StrictStr, dag_run_id: StrictStr, + cursor: Annotated[Optional[StrictStr], Field(description="Cursor for keyset-based pagination. Pass an empty string for the first page, then use ``next_cursor`` from the response. When ``cursor`` is provided, ``offset`` is ignored.")] = None, task_id: Optional[StrictStr] = None, run_after_gte: Optional[datetime] = None, run_after_gt: Optional[datetime] = None, @@ -7237,21 +7446,29 @@ def get_task_instances_without_preload_content( duration_gt: Optional[Union[StrictFloat, StrictInt]] = None, duration_lte: Optional[Union[StrictFloat, StrictInt]] = None, duration_lt: Optional[Union[StrictFloat, StrictInt]] = None, - task_display_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + task_display_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_display_name_prefix_pattern`` parameter when possible.")] = None, + task_display_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match on task display name: optional ``_task_display_property_value`` else ``task_id`` (same as ``coalesce``). Case-sensitive. Index-friendly alternative to ``task_display_name_pattern``. On large databases, combine with ``dag_id_prefix_pattern`` (or a specific Dag in the path) so ``(dag_id, task_id, ...)`` indexes apply. Use ``|`` for OR. Use ``~`` to match all. Trailing non-alphanumeric characters in the term are stripped before matching so the range scan stays index-compatible under locale-aware collations.")] = None, task_group_id: Annotated[Optional[StrictStr], Field(description="Filter by exact task group ID. Returns all tasks within the specified task group.")] = None, - dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - run_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + dag_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible.")] = None, + dag_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + run_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible.")] = None, + run_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, state: Optional[List[StrictStr]] = None, pool: Optional[List[StrictStr]] = None, - pool_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + pool_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``pool_name_prefix_pattern`` parameter when possible.")] = None, + pool_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, queue: Optional[List[StrictStr]] = None, - queue_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + queue_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``queue_name_prefix_pattern`` parameter when possible.")] = None, + queue_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, executor: Optional[List[StrictStr]] = None, version_number: Optional[List[StrictInt]] = None, try_number: Optional[List[StrictInt]] = None, operator: Optional[List[StrictStr]] = None, - operator_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + operator_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``operator_name_prefix_pattern`` parameter when possible.")] = None, + operator_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, map_index: Optional[List[StrictInt]] = None, + rendered_map_index_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``rendered_map_index_prefix_pattern`` parameter when possible.")] = None, + rendered_map_index_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, state, duration, start_date, end_date, map_index, try_number, logical_date, run_after, data_interval_start, data_interval_end, rendered_map_index, operator, logical_date, run_after, data_interval_start, data_interval_end`")] = None, @@ -7270,12 +7487,14 @@ def get_task_instances_without_preload_content( ) -> RESTResponseType: """Get Task Instances - Get list of task instances. This endpoint allows specifying `~` as the dag_id, dag_run_id to retrieve Task Instances for all DAGs and DAG runs. + Get list of task instances. This endpoint allows specifying `~` as the dag_id, dag_run_id to retrieve task instances for all Dags and Dag runs. Supports two pagination modes: **Offset (default):** use `limit` and `offset` query parameters. Returns `total_entries`. **Cursor:** pass `cursor` (empty string for the first page, then `next_cursor` from the response). When `cursor` is provided, `offset` is ignored and `total_entries` is not returned. ``next_cursor`` is ``null`` when there are no more pages; ``previous_cursor`` is ``null`` on the first page. :param dag_id: (required) :type dag_id: str :param dag_run_id: (required) :type dag_run_id: str + :param cursor: Cursor for keyset-based pagination. Pass an empty string for the first page, then use ``next_cursor`` from the response. When ``cursor`` is provided, ``offset`` is ignored. + :type cursor: str :param task_id: :type task_id: str :param run_after_gte: @@ -7326,24 +7545,34 @@ def get_task_instances_without_preload_content( :type duration_lte: float :param duration_lt: :type duration_lt: float - :param task_display_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param task_display_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_display_name_prefix_pattern`` parameter when possible. :type task_display_name_pattern: str + :param task_display_name_prefix_pattern: Prefix match on task display name: optional ``_task_display_property_value`` else ``task_id`` (same as ``coalesce``). Case-sensitive. Index-friendly alternative to ``task_display_name_pattern``. On large databases, combine with ``dag_id_prefix_pattern`` (or a specific Dag in the path) so ``(dag_id, task_id, ...)`` indexes apply. Use ``|`` for OR. Use ``~`` to match all. Trailing non-alphanumeric characters in the term are stripped before matching so the range scan stays index-compatible under locale-aware collations. + :type task_display_name_prefix_pattern: str :param task_group_id: Filter by exact task group ID. Returns all tasks within the specified task group. :type task_group_id: str - :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param dag_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. :type dag_id_pattern: str - :param run_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param dag_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type dag_id_prefix_pattern: str + :param run_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible. :type run_id_pattern: str + :param run_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type run_id_prefix_pattern: str :param state: :type state: List[str] :param pool: :type pool: List[str] - :param pool_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param pool_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``pool_name_prefix_pattern`` parameter when possible. :type pool_name_pattern: str + :param pool_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type pool_name_prefix_pattern: str :param queue: :type queue: List[str] - :param queue_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param queue_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``queue_name_prefix_pattern`` parameter when possible. :type queue_name_pattern: str + :param queue_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type queue_name_prefix_pattern: str :param executor: :type executor: List[str] :param version_number: @@ -7352,10 +7581,16 @@ def get_task_instances_without_preload_content( :type try_number: List[int] :param operator: :type operator: List[str] - :param operator_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param operator_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``operator_name_prefix_pattern`` parameter when possible. :type operator_name_pattern: str + :param operator_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type operator_name_prefix_pattern: str :param map_index: :type map_index: List[int] + :param rendered_map_index_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``rendered_map_index_prefix_pattern`` parameter when possible. + :type rendered_map_index_pattern: str + :param rendered_map_index_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type rendered_map_index_prefix_pattern: str :param limit: :type limit: int :param offset: @@ -7387,6 +7622,7 @@ def get_task_instances_without_preload_content( _param = self._get_task_instances_serialize( dag_id=dag_id, dag_run_id=dag_run_id, + cursor=cursor, task_id=task_id, run_after_gte=run_after_gte, run_after_gt=run_after_gt, @@ -7413,20 +7649,28 @@ def get_task_instances_without_preload_content( duration_lte=duration_lte, duration_lt=duration_lt, task_display_name_pattern=task_display_name_pattern, + task_display_name_prefix_pattern=task_display_name_prefix_pattern, task_group_id=task_group_id, dag_id_pattern=dag_id_pattern, + dag_id_prefix_pattern=dag_id_prefix_pattern, run_id_pattern=run_id_pattern, + run_id_prefix_pattern=run_id_prefix_pattern, state=state, pool=pool, pool_name_pattern=pool_name_pattern, + pool_name_prefix_pattern=pool_name_prefix_pattern, queue=queue, queue_name_pattern=queue_name_pattern, + queue_name_prefix_pattern=queue_name_prefix_pattern, executor=executor, version_number=version_number, try_number=try_number, operator=operator, operator_name_pattern=operator_name_pattern, + operator_name_prefix_pattern=operator_name_prefix_pattern, map_index=map_index, + rendered_map_index_pattern=rendered_map_index_pattern, + rendered_map_index_prefix_pattern=rendered_map_index_prefix_pattern, limit=limit, offset=offset, order_by=order_by, @@ -7455,6 +7699,7 @@ def _get_task_instances_serialize( self, dag_id, dag_run_id, + cursor, task_id, run_after_gte, run_after_gt, @@ -7481,20 +7726,28 @@ def _get_task_instances_serialize( duration_lte, duration_lt, task_display_name_pattern, + task_display_name_prefix_pattern, task_group_id, dag_id_pattern, + dag_id_prefix_pattern, run_id_pattern, + run_id_prefix_pattern, state, pool, pool_name_pattern, + pool_name_prefix_pattern, queue, queue_name_pattern, + queue_name_prefix_pattern, executor, version_number, try_number, operator, operator_name_pattern, + operator_name_prefix_pattern, map_index, + rendered_map_index_pattern, + rendered_map_index_prefix_pattern, limit, offset, order_by, @@ -7533,6 +7786,10 @@ def _get_task_instances_serialize( if dag_run_id is not None: _path_params['dag_run_id'] = dag_run_id # process the query parameters + if cursor is not None: + + _query_params.append(('cursor', cursor)) + if task_id is not None: _query_params.append(('task_id', task_id)) @@ -7817,6 +8074,10 @@ def _get_task_instances_serialize( _query_params.append(('task_display_name_pattern', task_display_name_pattern)) + if task_display_name_prefix_pattern is not None: + + _query_params.append(('task_display_name_prefix_pattern', task_display_name_prefix_pattern)) + if task_group_id is not None: _query_params.append(('task_group_id', task_group_id)) @@ -7825,10 +8086,18 @@ def _get_task_instances_serialize( _query_params.append(('dag_id_pattern', dag_id_pattern)) + if dag_id_prefix_pattern is not None: + + _query_params.append(('dag_id_prefix_pattern', dag_id_prefix_pattern)) + if run_id_pattern is not None: _query_params.append(('run_id_pattern', run_id_pattern)) + if run_id_prefix_pattern is not None: + + _query_params.append(('run_id_prefix_pattern', run_id_prefix_pattern)) + if state is not None: _query_params.append(('state', state)) @@ -7841,6 +8110,10 @@ def _get_task_instances_serialize( _query_params.append(('pool_name_pattern', pool_name_pattern)) + if pool_name_prefix_pattern is not None: + + _query_params.append(('pool_name_prefix_pattern', pool_name_prefix_pattern)) + if queue is not None: _query_params.append(('queue', queue)) @@ -7849,6 +8122,10 @@ def _get_task_instances_serialize( _query_params.append(('queue_name_pattern', queue_name_pattern)) + if queue_name_prefix_pattern is not None: + + _query_params.append(('queue_name_prefix_pattern', queue_name_prefix_pattern)) + if executor is not None: _query_params.append(('executor', executor)) @@ -7869,10 +8146,22 @@ def _get_task_instances_serialize( _query_params.append(('operator_name_pattern', operator_name_pattern)) + if operator_name_prefix_pattern is not None: + + _query_params.append(('operator_name_prefix_pattern', operator_name_prefix_pattern)) + if map_index is not None: _query_params.append(('map_index', map_index)) + if rendered_map_index_pattern is not None: + + _query_params.append(('rendered_map_index_pattern', rendered_map_index_pattern)) + + if rendered_map_index_prefix_pattern is not None: + + _query_params.append(('rendered_map_index_prefix_pattern', rendered_map_index_prefix_pattern)) + if limit is not None: _query_params.append(('limit', limit)) diff --git a/airflow_client/client/api/variable_api.py b/airflow_client/client/api/variable_api.py index 3b750c7b..dc492290 100644 --- a/airflow_client/client/api/variable_api.py +++ b/airflow_client/client/api/variable_api.py @@ -880,7 +880,8 @@ def get_variables( limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `key, id, _val, description, is_encrypted, team_name`")] = None, - variable_key_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + variable_key_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``variable_key_prefix_pattern`` parameter when possible.")] = None, + variable_key_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -904,8 +905,10 @@ def get_variables( :type offset: int :param order_by: Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `key, id, _val, description, is_encrypted, team_name` :type order_by: List[str] - :param variable_key_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param variable_key_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``variable_key_prefix_pattern`` parameter when possible. :type variable_key_pattern: str + :param variable_key_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type variable_key_prefix_pattern: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -933,6 +936,7 @@ def get_variables( offset=offset, order_by=order_by, variable_key_pattern=variable_key_pattern, + variable_key_prefix_pattern=variable_key_prefix_pattern, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -962,7 +966,8 @@ def get_variables_with_http_info( limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `key, id, _val, description, is_encrypted, team_name`")] = None, - variable_key_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + variable_key_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``variable_key_prefix_pattern`` parameter when possible.")] = None, + variable_key_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -986,8 +991,10 @@ def get_variables_with_http_info( :type offset: int :param order_by: Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `key, id, _val, description, is_encrypted, team_name` :type order_by: List[str] - :param variable_key_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param variable_key_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``variable_key_prefix_pattern`` parameter when possible. :type variable_key_pattern: str + :param variable_key_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type variable_key_prefix_pattern: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -1015,6 +1022,7 @@ def get_variables_with_http_info( offset=offset, order_by=order_by, variable_key_pattern=variable_key_pattern, + variable_key_prefix_pattern=variable_key_prefix_pattern, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1044,7 +1052,8 @@ def get_variables_without_preload_content( limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `key, id, _val, description, is_encrypted, team_name`")] = None, - variable_key_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + variable_key_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``variable_key_prefix_pattern`` parameter when possible.")] = None, + variable_key_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -1068,8 +1077,10 @@ def get_variables_without_preload_content( :type offset: int :param order_by: Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `key, id, _val, description, is_encrypted, team_name` :type order_by: List[str] - :param variable_key_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param variable_key_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``variable_key_prefix_pattern`` parameter when possible. :type variable_key_pattern: str + :param variable_key_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type variable_key_prefix_pattern: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -1097,6 +1108,7 @@ def get_variables_without_preload_content( offset=offset, order_by=order_by, variable_key_pattern=variable_key_pattern, + variable_key_prefix_pattern=variable_key_prefix_pattern, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1122,6 +1134,7 @@ def _get_variables_serialize( offset, order_by, variable_key_pattern, + variable_key_prefix_pattern, _request_auth, _content_type, _headers, @@ -1161,6 +1174,10 @@ def _get_variables_serialize( _query_params.append(('variable_key_pattern', variable_key_pattern)) + if variable_key_prefix_pattern is not None: + + _query_params.append(('variable_key_prefix_pattern', variable_key_prefix_pattern)) + # process the header parameters # process the form parameters # process the body parameter diff --git a/airflow_client/client/api/x_com_api.py b/airflow_client/client/api/x_com_api.py index 3af5fb33..ffecaa13 100644 --- a/airflow_client/client/api/x_com_api.py +++ b/airflow_client/client/api/x_com_api.py @@ -17,7 +17,7 @@ from datetime import datetime from pydantic import Field, StrictBool, StrictInt, StrictStr -from typing import Optional +from typing import List, Optional from typing_extensions import Annotated from airflow_client.client.models.response_get_xcom_entry import ResponseGetXcomEntry from airflow_client.client.models.x_com_collection_response import XComCollectionResponse @@ -727,10 +727,14 @@ def get_xcom_entries( map_index: Optional[Annotated[int, Field(strict=True, ge=-1)]] = None, limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, - xcom_key_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - dag_display_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - run_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - task_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + xcom_key_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``xcom_key_prefix_pattern`` parameter when possible.")] = None, + xcom_key_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + dag_display_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_display_name_prefix_pattern`` parameter when possible.")] = None, + dag_display_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + run_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible.")] = None, + run_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + task_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_id_prefix_pattern`` parameter when possible.")] = None, + task_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, map_index_filter: Optional[StrictInt] = None, logical_date_gte: Optional[datetime] = None, logical_date_gt: Optional[datetime] = None, @@ -740,6 +744,7 @@ def get_xcom_entries( run_after_gt: Optional[datetime] = None, run_after_lte: Optional[datetime] = None, run_after_lt: Optional[datetime] = None, + order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `key, dag_id, run_id, task_id, map_index, timestamp, run_after`")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -755,7 +760,7 @@ def get_xcom_entries( ) -> XComCollectionResponse: """Get Xcom Entries - Get all XCom entries. This endpoint allows specifying `~` as the dag_id, dag_run_id, task_id to retrieve XCom entries for all DAGs. + Get all XCom entries. This endpoint allows specifying `~` as the dag_id, dag_run_id, task_id to retrieve XCom entries for all Dags. :param dag_id: (required) :type dag_id: str @@ -771,14 +776,22 @@ def get_xcom_entries( :type limit: int :param offset: :type offset: int - :param xcom_key_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param xcom_key_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``xcom_key_prefix_pattern`` parameter when possible. :type xcom_key_pattern: str - :param dag_display_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param xcom_key_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type xcom_key_prefix_pattern: str + :param dag_display_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_display_name_prefix_pattern`` parameter when possible. :type dag_display_name_pattern: str - :param run_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param dag_display_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type dag_display_name_prefix_pattern: str + :param run_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible. :type run_id_pattern: str - :param task_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param run_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type run_id_prefix_pattern: str + :param task_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_id_prefix_pattern`` parameter when possible. :type task_id_pattern: str + :param task_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type task_id_prefix_pattern: str :param map_index_filter: :type map_index_filter: int :param logical_date_gte: @@ -797,6 +810,8 @@ def get_xcom_entries( :type run_after_lte: datetime :param run_after_lt: :type run_after_lt: datetime + :param order_by: Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `key, dag_id, run_id, task_id, map_index, timestamp, run_after` + :type order_by: List[str] :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -828,9 +843,13 @@ def get_xcom_entries( limit=limit, offset=offset, xcom_key_pattern=xcom_key_pattern, + xcom_key_prefix_pattern=xcom_key_prefix_pattern, dag_display_name_pattern=dag_display_name_pattern, + dag_display_name_prefix_pattern=dag_display_name_prefix_pattern, run_id_pattern=run_id_pattern, + run_id_prefix_pattern=run_id_prefix_pattern, task_id_pattern=task_id_pattern, + task_id_prefix_pattern=task_id_prefix_pattern, map_index_filter=map_index_filter, logical_date_gte=logical_date_gte, logical_date_gt=logical_date_gt, @@ -840,6 +859,7 @@ def get_xcom_entries( run_after_gt=run_after_gt, run_after_lte=run_after_lte, run_after_lt=run_after_lt, + order_by=order_by, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -875,10 +895,14 @@ def get_xcom_entries_with_http_info( map_index: Optional[Annotated[int, Field(strict=True, ge=-1)]] = None, limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, - xcom_key_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - dag_display_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - run_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - task_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + xcom_key_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``xcom_key_prefix_pattern`` parameter when possible.")] = None, + xcom_key_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + dag_display_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_display_name_prefix_pattern`` parameter when possible.")] = None, + dag_display_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + run_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible.")] = None, + run_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + task_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_id_prefix_pattern`` parameter when possible.")] = None, + task_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, map_index_filter: Optional[StrictInt] = None, logical_date_gte: Optional[datetime] = None, logical_date_gt: Optional[datetime] = None, @@ -888,6 +912,7 @@ def get_xcom_entries_with_http_info( run_after_gt: Optional[datetime] = None, run_after_lte: Optional[datetime] = None, run_after_lt: Optional[datetime] = None, + order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `key, dag_id, run_id, task_id, map_index, timestamp, run_after`")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -903,7 +928,7 @@ def get_xcom_entries_with_http_info( ) -> ApiResponse[XComCollectionResponse]: """Get Xcom Entries - Get all XCom entries. This endpoint allows specifying `~` as the dag_id, dag_run_id, task_id to retrieve XCom entries for all DAGs. + Get all XCom entries. This endpoint allows specifying `~` as the dag_id, dag_run_id, task_id to retrieve XCom entries for all Dags. :param dag_id: (required) :type dag_id: str @@ -919,14 +944,22 @@ def get_xcom_entries_with_http_info( :type limit: int :param offset: :type offset: int - :param xcom_key_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param xcom_key_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``xcom_key_prefix_pattern`` parameter when possible. :type xcom_key_pattern: str - :param dag_display_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param xcom_key_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type xcom_key_prefix_pattern: str + :param dag_display_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_display_name_prefix_pattern`` parameter when possible. :type dag_display_name_pattern: str - :param run_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param dag_display_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type dag_display_name_prefix_pattern: str + :param run_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible. :type run_id_pattern: str - :param task_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param run_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type run_id_prefix_pattern: str + :param task_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_id_prefix_pattern`` parameter when possible. :type task_id_pattern: str + :param task_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type task_id_prefix_pattern: str :param map_index_filter: :type map_index_filter: int :param logical_date_gte: @@ -945,6 +978,8 @@ def get_xcom_entries_with_http_info( :type run_after_lte: datetime :param run_after_lt: :type run_after_lt: datetime + :param order_by: Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `key, dag_id, run_id, task_id, map_index, timestamp, run_after` + :type order_by: List[str] :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -976,9 +1011,13 @@ def get_xcom_entries_with_http_info( limit=limit, offset=offset, xcom_key_pattern=xcom_key_pattern, + xcom_key_prefix_pattern=xcom_key_prefix_pattern, dag_display_name_pattern=dag_display_name_pattern, + dag_display_name_prefix_pattern=dag_display_name_prefix_pattern, run_id_pattern=run_id_pattern, + run_id_prefix_pattern=run_id_prefix_pattern, task_id_pattern=task_id_pattern, + task_id_prefix_pattern=task_id_prefix_pattern, map_index_filter=map_index_filter, logical_date_gte=logical_date_gte, logical_date_gt=logical_date_gt, @@ -988,6 +1027,7 @@ def get_xcom_entries_with_http_info( run_after_gt=run_after_gt, run_after_lte=run_after_lte, run_after_lt=run_after_lt, + order_by=order_by, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1023,10 +1063,14 @@ def get_xcom_entries_without_preload_content( map_index: Optional[Annotated[int, Field(strict=True, ge=-1)]] = None, limit: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None, - xcom_key_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - dag_display_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - run_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, - task_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported.")] = None, + xcom_key_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``xcom_key_prefix_pattern`` parameter when possible.")] = None, + xcom_key_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + dag_display_name_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_display_name_prefix_pattern`` parameter when possible.")] = None, + dag_display_name_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + run_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible.")] = None, + run_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, + task_id_pattern: Annotated[Optional[StrictStr], Field(description="SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_id_prefix_pattern`` parameter when possible.")] = None, + task_id_prefix_pattern: Annotated[Optional[StrictStr], Field(description="Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`.")] = None, map_index_filter: Optional[StrictInt] = None, logical_date_gte: Optional[datetime] = None, logical_date_gt: Optional[datetime] = None, @@ -1036,6 +1080,7 @@ def get_xcom_entries_without_preload_content( run_after_gt: Optional[datetime] = None, run_after_lte: Optional[datetime] = None, run_after_lt: Optional[datetime] = None, + order_by: Annotated[Optional[List[StrictStr]], Field(description="Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `key, dag_id, run_id, task_id, map_index, timestamp, run_after`")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], @@ -1051,7 +1096,7 @@ def get_xcom_entries_without_preload_content( ) -> RESTResponseType: """Get Xcom Entries - Get all XCom entries. This endpoint allows specifying `~` as the dag_id, dag_run_id, task_id to retrieve XCom entries for all DAGs. + Get all XCom entries. This endpoint allows specifying `~` as the dag_id, dag_run_id, task_id to retrieve XCom entries for all Dags. :param dag_id: (required) :type dag_id: str @@ -1067,14 +1112,22 @@ def get_xcom_entries_without_preload_content( :type limit: int :param offset: :type offset: int - :param xcom_key_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param xcom_key_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``xcom_key_prefix_pattern`` parameter when possible. :type xcom_key_pattern: str - :param dag_display_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param xcom_key_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type xcom_key_prefix_pattern: str + :param dag_display_name_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_display_name_prefix_pattern`` parameter when possible. :type dag_display_name_pattern: str - :param run_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param dag_display_name_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type dag_display_name_prefix_pattern: str + :param run_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible. :type run_id_pattern: str - :param task_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. + :param run_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type run_id_prefix_pattern: str + :param task_id_pattern: SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_id_prefix_pattern`` parameter when possible. :type task_id_pattern: str + :param task_id_prefix_pattern: Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. + :type task_id_prefix_pattern: str :param map_index_filter: :type map_index_filter: int :param logical_date_gte: @@ -1093,6 +1146,8 @@ def get_xcom_entries_without_preload_content( :type run_after_lte: datetime :param run_after_lt: :type run_after_lt: datetime + :param order_by: Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `key, dag_id, run_id, task_id, map_index, timestamp, run_after` + :type order_by: List[str] :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -1124,9 +1179,13 @@ def get_xcom_entries_without_preload_content( limit=limit, offset=offset, xcom_key_pattern=xcom_key_pattern, + xcom_key_prefix_pattern=xcom_key_prefix_pattern, dag_display_name_pattern=dag_display_name_pattern, + dag_display_name_prefix_pattern=dag_display_name_prefix_pattern, run_id_pattern=run_id_pattern, + run_id_prefix_pattern=run_id_prefix_pattern, task_id_pattern=task_id_pattern, + task_id_prefix_pattern=task_id_prefix_pattern, map_index_filter=map_index_filter, logical_date_gte=logical_date_gte, logical_date_gt=logical_date_gt, @@ -1136,6 +1195,7 @@ def get_xcom_entries_without_preload_content( run_after_gt=run_after_gt, run_after_lte=run_after_lte, run_after_lt=run_after_lt, + order_by=order_by, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, @@ -1167,9 +1227,13 @@ def _get_xcom_entries_serialize( limit, offset, xcom_key_pattern, + xcom_key_prefix_pattern, dag_display_name_pattern, + dag_display_name_prefix_pattern, run_id_pattern, + run_id_prefix_pattern, task_id_pattern, + task_id_prefix_pattern, map_index_filter, logical_date_gte, logical_date_gt, @@ -1179,6 +1243,7 @@ def _get_xcom_entries_serialize( run_after_gt, run_after_lte, run_after_lt, + order_by, _request_auth, _content_type, _headers, @@ -1188,6 +1253,7 @@ def _get_xcom_entries_serialize( _host = None _collection_formats: Dict[str, str] = { + 'order_by': 'multi', } _path_params: Dict[str, str] = {} @@ -1227,18 +1293,34 @@ def _get_xcom_entries_serialize( _query_params.append(('xcom_key_pattern', xcom_key_pattern)) + if xcom_key_prefix_pattern is not None: + + _query_params.append(('xcom_key_prefix_pattern', xcom_key_prefix_pattern)) + if dag_display_name_pattern is not None: _query_params.append(('dag_display_name_pattern', dag_display_name_pattern)) + if dag_display_name_prefix_pattern is not None: + + _query_params.append(('dag_display_name_prefix_pattern', dag_display_name_prefix_pattern)) + if run_id_pattern is not None: _query_params.append(('run_id_pattern', run_id_pattern)) + if run_id_prefix_pattern is not None: + + _query_params.append(('run_id_prefix_pattern', run_id_prefix_pattern)) + if task_id_pattern is not None: _query_params.append(('task_id_pattern', task_id_pattern)) + if task_id_prefix_pattern is not None: + + _query_params.append(('task_id_prefix_pattern', task_id_prefix_pattern)) + if map_index_filter is not None: _query_params.append(('map_index_filter', map_index_filter)) @@ -1347,6 +1429,10 @@ def _get_xcom_entries_serialize( else: _query_params.append(('run_after_lt', run_after_lt)) + if order_by is not None: + + _query_params.append(('order_by', order_by)) + # process the header parameters # process the form parameters # process the body parameter diff --git a/airflow_client/client/api_client.py b/airflow_client/client/api_client.py index a1e8a00b..76ef20ca 100644 --- a/airflow_client/client/api_client.py +++ b/airflow_client/client/api_client.py @@ -91,7 +91,7 @@ def __init__( self.default_headers[header_name] = header_value self.cookie = cookie # Set default User-Agent. - self.user_agent = 'OpenAPI-Generator/3.2.1/python' + self.user_agent = 'OpenAPI-Generator/3.2.2/python' self.client_side_validation = configuration.client_side_validation def __enter__(self): @@ -371,28 +371,24 @@ def sanitize_for_serialization(self, obj): return obj.isoformat() elif isinstance(obj, decimal.Decimal): return str(obj) - elif isinstance(obj, dict): - obj_dict = obj + return { + key: self.sanitize_for_serialization(val) + for key, val in obj.items() + } + + # Convert model obj to dict except + # attributes `openapi_types`, `attribute_map` + # and attributes which value is not None. + # Convert attribute name to json key in + # model definition for request. + if hasattr(obj, 'to_dict') and callable(getattr(obj, 'to_dict')): + obj_dict = obj.to_dict() else: - # Convert model obj to dict except - # attributes `openapi_types`, `attribute_map` - # and attributes which value is not None. - # Convert attribute name to json key in - # model definition for request. - if hasattr(obj, 'to_dict') and callable(getattr(obj, 'to_dict')): - obj_dict = obj.to_dict() - else: - obj_dict = obj.__dict__ + obj_dict = obj.__dict__ - if isinstance(obj_dict, list): - # here we handle instances that can either be a list or something else, and only became a real list by calling to_dict() - return self.sanitize_for_serialization(obj_dict) + return self.sanitize_for_serialization(obj_dict) - return { - key: self.sanitize_for_serialization(val) - for key, val in obj_dict.items() - } def deserialize(self, response_text: str, response_type: str, content_type: Optional[str]): """Deserializes response into an object. diff --git a/airflow_client/client/configuration.py b/airflow_client/client/configuration.py index 4723793c..9d68ec92 100644 --- a/airflow_client/client/configuration.py +++ b/airflow_client/client/configuration.py @@ -196,7 +196,7 @@ def __init__( server_operation_variables: Optional[Dict[int, ServerVariablesT]]=None, ignore_operation_servers: bool=False, ssl_ca_cert: Optional[str]=None, - retries: Optional[Union[int, Any]] = None, + retries: Optional[Union[int, urllib3.util.retry.Retry]] = None, ca_cert_data: Optional[Union[str, bytes]] = None, cert_file: Optional[str]=None, key_file: Optional[str]=None, @@ -541,7 +541,7 @@ def to_debug_report(self) -> str: "OS: {env}\n"\ "Python Version: {pyversion}\n"\ "Version of the API: 2\n"\ - "SDK Package Version: 3.2.1".\ + "SDK Package Version: 3.2.2".\ format(env=sys.platform, pyversion=sys.version) def get_host_settings(self) -> List[HostSetting]: diff --git a/airflow_client/client/models/__init__.py b/airflow_client/client/models/__init__.py index 4262e200..a63cafa2 100644 --- a/airflow_client/client/models/__init__.py +++ b/airflow_client/client/models/__init__.py @@ -51,6 +51,7 @@ from airflow_client.client.models.bulk_update_action_connection_body import BulkUpdateActionConnectionBody from airflow_client.client.models.bulk_update_action_pool_body import BulkUpdateActionPoolBody from airflow_client.client.models.bulk_update_action_variable_body import BulkUpdateActionVariableBody +from airflow_client.client.models.clear_task_instance_collection_response import ClearTaskInstanceCollectionResponse from airflow_client.client.models.clear_task_instances_body import ClearTaskInstancesBody from airflow_client.client.models.clear_task_instances_body_task_ids_inner import ClearTaskInstancesBodyTaskIdsInner from airflow_client.client.models.config import Config @@ -118,6 +119,7 @@ from airflow_client.client.models.last_asset_event_response import LastAssetEventResponse from airflow_client.client.models.location_inner import LocationInner from airflow_client.client.models.materialize_asset_body import MaterializeAssetBody +from airflow_client.client.models.new_task_response import NewTaskResponse from airflow_client.client.models.patch_task_instance_body import PatchTaskInstanceBody from airflow_client.client.models.plugin_collection_response import PluginCollectionResponse from airflow_client.client.models.plugin_import_error_collection_response import PluginImportErrorCollectionResponse @@ -147,6 +149,7 @@ from airflow_client.client.models.task_instance_response import TaskInstanceResponse from airflow_client.client.models.task_instance_state import TaskInstanceState from airflow_client.client.models.task_instances_batch_body import TaskInstancesBatchBody +from airflow_client.client.models.task_instances_inner import TaskInstancesInner from airflow_client.client.models.task_instances_log_response import TaskInstancesLogResponse from airflow_client.client.models.task_outlet_asset_reference import TaskOutletAssetReference from airflow_client.client.models.task_response import TaskResponse diff --git a/airflow_client/client/models/clear_task_instance_collection_response.py b/airflow_client/client/models/clear_task_instance_collection_response.py new file mode 100644 index 00000000..cd7a8e28 --- /dev/null +++ b/airflow_client/client/models/clear_task_instance_collection_response.py @@ -0,0 +1,98 @@ +# coding: utf-8 + +""" + Airflow API + + Airflow API. All endpoints located under ``/api/v2`` can be used safely, are stable and backward compatible. Endpoints located under ``/ui`` are dedicated to the UI and are subject to breaking change depending on the need of the frontend. Users should not rely on those but use the public ones instead. + + The version of the OpenAPI document: 2 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from pydantic import BaseModel, ConfigDict, StrictInt +from typing import Any, ClassVar, Dict, List +from airflow_client.client.models.task_instances_inner import TaskInstancesInner +from typing import Optional, Set +from typing_extensions import Self +from pydantic_core import to_jsonable_python + +class ClearTaskInstanceCollectionResponse(BaseModel): + """ + Response for clear dag run dry run, which may contain new tasks without full TaskInstance data. + """ # noqa: E501 + task_instances: List[TaskInstancesInner] + total_entries: StrictInt + __properties: ClassVar[List[str]] = ["task_instances", "total_entries"] + + model_config = ConfigDict( + validate_by_name=True, + validate_by_alias=True, + validate_assignment=True, + protected_namespaces=(), + ) + + + def to_str(self) -> str: + """Returns the string representation of the model using alias""" + return pprint.pformat(self.model_dump(by_alias=True)) + + def to_json(self) -> str: + """Returns the JSON representation of the model using alias""" + return json.dumps(to_jsonable_python(self.to_dict())) + + @classmethod + def from_json(cls, json_str: str) -> Optional[Self]: + """Create an instance of ClearTaskInstanceCollectionResponse from a JSON string""" + return cls.from_dict(json.loads(json_str)) + + def to_dict(self) -> Dict[str, Any]: + """Return the dictionary representation of the model using alias. + + This has the following differences from calling pydantic's + `self.model_dump(by_alias=True)`: + + * `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + """ + excluded_fields: Set[str] = set([ + ]) + + _dict = self.model_dump( + by_alias=True, + exclude=excluded_fields, + exclude_none=True, + ) + # override the default output from pydantic by calling `to_dict()` of each item in task_instances (list) + _items = [] + if self.task_instances: + for _item_task_instances in self.task_instances: + if _item_task_instances: + _items.append(_item_task_instances.to_dict()) + _dict['task_instances'] = _items + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of ClearTaskInstanceCollectionResponse from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate({ + "task_instances": [TaskInstancesInner.from_dict(_item) for _item in obj["task_instances"]] if obj.get("task_instances") is not None else None, + "total_entries": obj.get("total_entries") + }) + return _obj + + diff --git a/airflow_client/client/models/connection_body.py b/airflow_client/client/models/connection_body.py index e1f13825..a1107cd8 100644 --- a/airflow_client/client/models/connection_body.py +++ b/airflow_client/client/models/connection_body.py @@ -43,6 +43,9 @@ class ConnectionBody(BaseModel): @field_validator('connection_id') def connection_id_validate_regular_expression(cls, value): """Validates the regular expression""" + if not isinstance(value, str): + value = str(value) + if not re.match(r"^[\w.-]+$", value): raise ValueError(r"must validate the regular expression /^[\w.-]+$/") return value diff --git a/airflow_client/client/models/dag_collection_response.py b/airflow_client/client/models/dag_collection_response.py index ff4081d3..afbd588d 100644 --- a/airflow_client/client/models/dag_collection_response.py +++ b/airflow_client/client/models/dag_collection_response.py @@ -26,7 +26,7 @@ class DAGCollectionResponse(BaseModel): """ - DAG Collection serializer for responses. + Dag Collection serializer for responses. """ # noqa: E501 dags: List[DAGResponse] total_entries: StrictInt diff --git a/airflow_client/client/models/dag_details_response.py b/airflow_client/client/models/dag_details_response.py index bd63f24b..942c90c8 100644 --- a/airflow_client/client/models/dag_details_response.py +++ b/airflow_client/client/models/dag_details_response.py @@ -29,7 +29,7 @@ class DAGDetailsResponse(BaseModel): """ - Specific serializer for DAG Details responses. + Specific serializer for Dag Details responses. """ # noqa: E501 active_runs_count: Optional[StrictInt] = 0 allowed_run_types: Optional[List[DagRunType]] = None diff --git a/airflow_client/client/models/dag_response.py b/airflow_client/client/models/dag_response.py index 9b913e29..7b01599b 100644 --- a/airflow_client/client/models/dag_response.py +++ b/airflow_client/client/models/dag_response.py @@ -28,7 +28,7 @@ class DAGResponse(BaseModel): """ - DAG serializer for responses. + Dag serializer for responses. """ # noqa: E501 allowed_run_types: Optional[List[DagRunType]] = None bundle_name: Optional[StrictStr] = None diff --git a/airflow_client/client/models/dag_run_clear_body.py b/airflow_client/client/models/dag_run_clear_body.py index 835194c3..52969e2e 100644 --- a/airflow_client/client/models/dag_run_clear_body.py +++ b/airflow_client/client/models/dag_run_clear_body.py @@ -25,12 +25,13 @@ class DAGRunClearBody(BaseModel): """ - DAG Run serializer for clear endpoint body. + Dag Run serializer for clear endpoint body. """ # noqa: E501 dry_run: Optional[StrictBool] = True only_failed: Optional[StrictBool] = False + only_new: Optional[StrictBool] = Field(default=False, description="Only queue newly added tasks in the latest DAG version without clearing existing tasks.") run_on_latest_version: Optional[StrictBool] = Field(default=False, description="(Experimental) Run on the latest bundle version of the Dag after clearing the Dag Run.") - __properties: ClassVar[List[str]] = ["dry_run", "only_failed", "run_on_latest_version"] + __properties: ClassVar[List[str]] = ["dry_run", "only_failed", "only_new", "run_on_latest_version"] model_config = ConfigDict( validate_by_name=True, @@ -85,6 +86,7 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: _obj = cls.model_validate({ "dry_run": obj.get("dry_run") if obj.get("dry_run") is not None else True, "only_failed": obj.get("only_failed") if obj.get("only_failed") is not None else False, + "only_new": obj.get("only_new") if obj.get("only_new") is not None else False, "run_on_latest_version": obj.get("run_on_latest_version") if obj.get("run_on_latest_version") is not None else False }) return _obj diff --git a/airflow_client/client/models/dag_run_collection_response.py b/airflow_client/client/models/dag_run_collection_response.py index 5c2f7031..6bd2a971 100644 --- a/airflow_client/client/models/dag_run_collection_response.py +++ b/airflow_client/client/models/dag_run_collection_response.py @@ -17,8 +17,8 @@ import re # noqa: F401 import json -from pydantic import BaseModel, ConfigDict, StrictInt -from typing import Any, ClassVar, Dict, List +from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr +from typing import Any, ClassVar, Dict, List, Optional from airflow_client.client.models.dag_run_response import DAGRunResponse from typing import Optional, Set from typing_extensions import Self @@ -26,11 +26,13 @@ class DAGRunCollectionResponse(BaseModel): """ - DAG Run Collection serializer for responses. + Dag Run collection response supporting both offset and cursor pagination. A single flat model is used instead of a discriminated union (``Annotated[Offset | Cursor, Field(discriminator=...)]``) because the OpenAPI ``oneOf`` + ``discriminator`` construct is not handled correctly by ``@hey-api/openapi-ts`` / ``@7nohe/openapi-react-query-codegen``: return types degrade to ``unknown`` in JSDoc and can produce incorrect TypeScript types (see hey-api/openapi-ts#1613, #3270). """ # noqa: E501 dag_runs: List[DAGRunResponse] - total_entries: StrictInt - __properties: ClassVar[List[str]] = ["dag_runs", "total_entries"] + next_cursor: Optional[StrictStr] = None + previous_cursor: Optional[StrictStr] = None + total_entries: Optional[StrictInt] = None + __properties: ClassVar[List[str]] = ["dag_runs", "next_cursor", "previous_cursor", "total_entries"] model_config = ConfigDict( validate_by_name=True, @@ -91,6 +93,8 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: _obj = cls.model_validate({ "dag_runs": [DAGRunResponse.from_dict(_item) for _item in obj["dag_runs"]] if obj.get("dag_runs") is not None else None, + "next_cursor": obj.get("next_cursor"), + "previous_cursor": obj.get("previous_cursor"), "total_entries": obj.get("total_entries") }) return _obj diff --git a/airflow_client/client/models/dag_run_patch_body.py b/airflow_client/client/models/dag_run_patch_body.py index ad308162..6960f918 100644 --- a/airflow_client/client/models/dag_run_patch_body.py +++ b/airflow_client/client/models/dag_run_patch_body.py @@ -27,7 +27,7 @@ class DAGRunPatchBody(BaseModel): """ - DAG Run Serializer for PATCH requests. + Dag Run Serializer for PATCH requests. """ # noqa: E501 note: Optional[Annotated[str, Field(strict=True, max_length=1000)]] = None state: Optional[DAGRunPatchStates] = None diff --git a/airflow_client/client/models/dag_run_patch_states.py b/airflow_client/client/models/dag_run_patch_states.py index 94ce2d7e..e1f5bf29 100644 --- a/airflow_client/client/models/dag_run_patch_states.py +++ b/airflow_client/client/models/dag_run_patch_states.py @@ -20,7 +20,7 @@ class DAGRunPatchStates(str, Enum): """ - Enum for DAG Run states when updating a DAG Run. + Enum for Dag Run states when updating a Dag Run. """ """ diff --git a/airflow_client/client/models/dag_run_response.py b/airflow_client/client/models/dag_run_response.py index a888a09c..bfd470a5 100644 --- a/airflow_client/client/models/dag_run_response.py +++ b/airflow_client/client/models/dag_run_response.py @@ -30,7 +30,7 @@ class DAGRunResponse(BaseModel): """ - DAG Run serializer for responses. + Dag Run serializer for responses. """ # noqa: E501 bundle_version: Optional[StrictStr] = None conf: Optional[Dict[str, Any]] = None diff --git a/airflow_client/client/models/dag_runs_batch_body.py b/airflow_client/client/models/dag_runs_batch_body.py index 67ebf9b9..a2f1b2ef 100644 --- a/airflow_client/client/models/dag_runs_batch_body.py +++ b/airflow_client/client/models/dag_runs_batch_body.py @@ -28,7 +28,7 @@ class DAGRunsBatchBody(BaseModel): """ - List DAG Runs body for batch endpoint. + List Dag Runs body for batch endpoint. """ # noqa: E501 conf_contains: Optional[StrictStr] = None dag_ids: Optional[List[StrictStr]] = None diff --git a/airflow_client/client/models/dag_schedule_asset_reference.py b/airflow_client/client/models/dag_schedule_asset_reference.py index 8aec05a7..602bfd91 100644 --- a/airflow_client/client/models/dag_schedule_asset_reference.py +++ b/airflow_client/client/models/dag_schedule_asset_reference.py @@ -26,7 +26,7 @@ class DagScheduleAssetReference(BaseModel): """ - DAG schedule reference serializer for assets. + Dag schedule reference serializer for assets. """ # noqa: E501 created_at: datetime dag_id: StrictStr diff --git a/airflow_client/client/models/dag_source_response.py b/airflow_client/client/models/dag_source_response.py index eea33a33..e5a2b041 100644 --- a/airflow_client/client/models/dag_source_response.py +++ b/airflow_client/client/models/dag_source_response.py @@ -25,7 +25,7 @@ class DAGSourceResponse(BaseModel): """ - DAG Source serializer for responses. + Dag Source serializer for responses. """ # noqa: E501 content: Optional[StrictStr] = None dag_display_name: StrictStr diff --git a/airflow_client/client/models/dag_stats_collection_response.py b/airflow_client/client/models/dag_stats_collection_response.py index 4866f04a..1acdf4e8 100644 --- a/airflow_client/client/models/dag_stats_collection_response.py +++ b/airflow_client/client/models/dag_stats_collection_response.py @@ -26,7 +26,7 @@ class DagStatsCollectionResponse(BaseModel): """ - DAG Stats Collection serializer for responses. + Dag Stats Collection serializer for responses. """ # noqa: E501 dags: List[DagStatsResponse] total_entries: StrictInt diff --git a/airflow_client/client/models/dag_stats_response.py b/airflow_client/client/models/dag_stats_response.py index d724e6b3..e981d6fd 100644 --- a/airflow_client/client/models/dag_stats_response.py +++ b/airflow_client/client/models/dag_stats_response.py @@ -26,7 +26,7 @@ class DagStatsResponse(BaseModel): """ - DAG Stats serializer for responses. + Dag Stats serializer for responses. """ # noqa: E501 dag_display_name: StrictStr dag_id: StrictStr diff --git a/airflow_client/client/models/dag_tag_collection_response.py b/airflow_client/client/models/dag_tag_collection_response.py index 316597c4..67ea5a6d 100644 --- a/airflow_client/client/models/dag_tag_collection_response.py +++ b/airflow_client/client/models/dag_tag_collection_response.py @@ -25,7 +25,7 @@ class DAGTagCollectionResponse(BaseModel): """ - DAG Tags Collection serializer for responses. + Dag Tags Collection serializer for responses. """ # noqa: E501 tags: List[StrictStr] total_entries: StrictInt diff --git a/airflow_client/client/models/dag_tag_response.py b/airflow_client/client/models/dag_tag_response.py index 962dd616..bbe041a2 100644 --- a/airflow_client/client/models/dag_tag_response.py +++ b/airflow_client/client/models/dag_tag_response.py @@ -25,7 +25,7 @@ class DagTagResponse(BaseModel): """ - DAG Tag serializer for responses. + Dag Tag serializer for responses. """ # noqa: E501 dag_display_name: StrictStr dag_id: StrictStr diff --git a/airflow_client/client/models/dag_version_collection_response.py b/airflow_client/client/models/dag_version_collection_response.py index 69862c5b..446f5b1f 100644 --- a/airflow_client/client/models/dag_version_collection_response.py +++ b/airflow_client/client/models/dag_version_collection_response.py @@ -26,7 +26,7 @@ class DAGVersionCollectionResponse(BaseModel): """ - DAG Version Collection serializer for responses. + Dag Version Collection serializer for responses. """ # noqa: E501 dag_versions: List[DagVersionResponse] total_entries: StrictInt diff --git a/airflow_client/client/models/dag_warning_collection_response.py b/airflow_client/client/models/dag_warning_collection_response.py index 60013d8b..d969e5e4 100644 --- a/airflow_client/client/models/dag_warning_collection_response.py +++ b/airflow_client/client/models/dag_warning_collection_response.py @@ -26,7 +26,7 @@ class DAGWarningCollectionResponse(BaseModel): """ - DAG warning collection serializer for responses. + Dag warning collection serializer for responses. """ # noqa: E501 dag_warnings: List[DAGWarningResponse] total_entries: StrictInt diff --git a/airflow_client/client/models/dag_warning_response.py b/airflow_client/client/models/dag_warning_response.py index 7b571bf3..a9688a22 100644 --- a/airflow_client/client/models/dag_warning_response.py +++ b/airflow_client/client/models/dag_warning_response.py @@ -27,7 +27,7 @@ class DAGWarningResponse(BaseModel): """ - DAG Warning serializer for responses. + Dag Warning serializer for responses. """ # noqa: E501 dag_display_name: StrictStr dag_id: StrictStr diff --git a/airflow_client/client/models/new_task_response.py b/airflow_client/client/models/new_task_response.py new file mode 100644 index 00000000..30e5bfdc --- /dev/null +++ b/airflow_client/client/models/new_task_response.py @@ -0,0 +1,90 @@ +# coding: utf-8 + +""" + Airflow API + + Airflow API. All endpoints located under ``/api/v2`` can be used safely, are stable and backward compatible. Endpoints located under ``/ui`` are dedicated to the UI and are subject to breaking change depending on the need of the frontend. Users should not rely on those but use the public ones instead. + + The version of the OpenAPI document: 2 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from pydantic import BaseModel, ConfigDict, StrictStr +from typing import Any, ClassVar, Dict, List +from typing import Optional, Set +from typing_extensions import Self +from pydantic_core import to_jsonable_python + +class NewTaskResponse(BaseModel): + """ + Lightweight response for new tasks that don't have TaskInstances yet. + """ # noqa: E501 + task_display_name: StrictStr + task_id: StrictStr + __properties: ClassVar[List[str]] = ["task_display_name", "task_id"] + + model_config = ConfigDict( + validate_by_name=True, + validate_by_alias=True, + validate_assignment=True, + protected_namespaces=(), + ) + + + def to_str(self) -> str: + """Returns the string representation of the model using alias""" + return pprint.pformat(self.model_dump(by_alias=True)) + + def to_json(self) -> str: + """Returns the JSON representation of the model using alias""" + return json.dumps(to_jsonable_python(self.to_dict())) + + @classmethod + def from_json(cls, json_str: str) -> Optional[Self]: + """Create an instance of NewTaskResponse from a JSON string""" + return cls.from_dict(json.loads(json_str)) + + def to_dict(self) -> Dict[str, Any]: + """Return the dictionary representation of the model using alias. + + This has the following differences from calling pydantic's + `self.model_dump(by_alias=True)`: + + * `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + """ + excluded_fields: Set[str] = set([ + ]) + + _dict = self.model_dump( + by_alias=True, + exclude=excluded_fields, + exclude_none=True, + ) + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of NewTaskResponse from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate({ + "task_display_name": obj.get("task_display_name"), + "task_id": obj.get("task_id") + }) + return _obj + + diff --git a/airflow_client/client/models/response_clear_dag_run.py b/airflow_client/client/models/response_clear_dag_run.py index bfc0ab7b..8164a658 100644 --- a/airflow_client/client/models/response_clear_dag_run.py +++ b/airflow_client/client/models/response_clear_dag_run.py @@ -19,28 +19,28 @@ import re # noqa: F401 from pydantic import BaseModel, ConfigDict, Field, StrictStr, ValidationError, field_validator from typing import Optional +from airflow_client.client.models.clear_task_instance_collection_response import ClearTaskInstanceCollectionResponse from airflow_client.client.models.dag_run_response import DAGRunResponse -from airflow_client.client.models.task_instance_collection_response import TaskInstanceCollectionResponse from typing import Union, Any, List, Set, TYPE_CHECKING, Optional, Dict from typing_extensions import Literal, Self from pydantic import Field -RESPONSECLEARDAGRUN_ANY_OF_SCHEMAS = ["DAGRunResponse", "TaskInstanceCollectionResponse"] +RESPONSECLEARDAGRUN_ANY_OF_SCHEMAS = ["ClearTaskInstanceCollectionResponse", "DAGRunResponse"] class ResponseClearDagRun(BaseModel): """ ResponseClearDagRun """ - # data type: TaskInstanceCollectionResponse - anyof_schema_1_validator: Optional[TaskInstanceCollectionResponse] = None + # data type: ClearTaskInstanceCollectionResponse + anyof_schema_1_validator: Optional[ClearTaskInstanceCollectionResponse] = None # data type: DAGRunResponse anyof_schema_2_validator: Optional[DAGRunResponse] = None if TYPE_CHECKING: - actual_instance: Optional[Union[DAGRunResponse, TaskInstanceCollectionResponse]] = None + actual_instance: Optional[Union[ClearTaskInstanceCollectionResponse, DAGRunResponse]] = None else: actual_instance: Any = None - any_of_schemas: Set[str] = { "DAGRunResponse", "TaskInstanceCollectionResponse" } + any_of_schemas: Set[str] = { "ClearTaskInstanceCollectionResponse", "DAGRunResponse" } model_config = { "validate_assignment": True, @@ -61,9 +61,9 @@ def __init__(self, *args, **kwargs) -> None: def actual_instance_must_validate_anyof(cls, v): instance = ResponseClearDagRun.model_construct() error_messages = [] - # validate data type: TaskInstanceCollectionResponse - if not isinstance(v, TaskInstanceCollectionResponse): - error_messages.append(f"Error! Input type `{type(v)}` is not `TaskInstanceCollectionResponse`") + # validate data type: ClearTaskInstanceCollectionResponse + if not isinstance(v, ClearTaskInstanceCollectionResponse): + error_messages.append(f"Error! Input type `{type(v)}` is not `ClearTaskInstanceCollectionResponse`") else: return v @@ -75,7 +75,7 @@ def actual_instance_must_validate_anyof(cls, v): if error_messages: # no match - raise ValueError("No match found when setting the actual_instance in ResponseClearDagRun with anyOf schemas: DAGRunResponse, TaskInstanceCollectionResponse. Details: " + ", ".join(error_messages)) + raise ValueError("No match found when setting the actual_instance in ResponseClearDagRun with anyOf schemas: ClearTaskInstanceCollectionResponse, DAGRunResponse. Details: " + ", ".join(error_messages)) else: return v @@ -88,9 +88,9 @@ def from_json(cls, json_str: str) -> Self: """Returns the object represented by the json string""" instance = cls.model_construct() error_messages = [] - # anyof_schema_1_validator: Optional[TaskInstanceCollectionResponse] = None + # anyof_schema_1_validator: Optional[ClearTaskInstanceCollectionResponse] = None try: - instance.actual_instance = TaskInstanceCollectionResponse.from_json(json_str) + instance.actual_instance = ClearTaskInstanceCollectionResponse.from_json(json_str) return instance except (ValidationError, ValueError) as e: error_messages.append(str(e)) @@ -103,7 +103,7 @@ def from_json(cls, json_str: str) -> Self: if error_messages: # no match - raise ValueError("No match found when deserializing the JSON string into ResponseClearDagRun with anyOf schemas: DAGRunResponse, TaskInstanceCollectionResponse. Details: " + ", ".join(error_messages)) + raise ValueError("No match found when deserializing the JSON string into ResponseClearDagRun with anyOf schemas: ClearTaskInstanceCollectionResponse, DAGRunResponse. Details: " + ", ".join(error_messages)) else: return instance @@ -117,7 +117,7 @@ def to_json(self) -> str: else: return json.dumps(self.actual_instance) - def to_dict(self) -> Optional[Union[Dict[str, Any], DAGRunResponse, TaskInstanceCollectionResponse]]: + def to_dict(self) -> Optional[Union[Dict[str, Any], ClearTaskInstanceCollectionResponse, DAGRunResponse]]: """Returns the dict representation of the actual instance""" if self.actual_instance is None: return None diff --git a/airflow_client/client/models/task_instance_collection_response.py b/airflow_client/client/models/task_instance_collection_response.py index f9598fdf..45369765 100644 --- a/airflow_client/client/models/task_instance_collection_response.py +++ b/airflow_client/client/models/task_instance_collection_response.py @@ -17,8 +17,8 @@ import re # noqa: F401 import json -from pydantic import BaseModel, ConfigDict, StrictInt -from typing import Any, ClassVar, Dict, List +from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr +from typing import Any, ClassVar, Dict, List, Optional from airflow_client.client.models.task_instance_response import TaskInstanceResponse from typing import Optional, Set from typing_extensions import Self @@ -26,11 +26,13 @@ class TaskInstanceCollectionResponse(BaseModel): """ - Task Instance Collection serializer for responses. + Task instance collection response supporting both offset and cursor pagination. A single flat model is used instead of a discriminated union (``Annotated[Offset | Cursor, Field(discriminator=...)]``) because the OpenAPI ``oneOf`` + ``discriminator`` construct is not handled correctly by ``@hey-api/openapi-ts`` / ``@7nohe/openapi-react-query-codegen``: return types degrade to ``unknown`` in JSDoc and can produce incorrect TypeScript types (see hey-api/openapi-ts#1613, #3270). """ # noqa: E501 + next_cursor: Optional[StrictStr] = None + previous_cursor: Optional[StrictStr] = None task_instances: List[TaskInstanceResponse] - total_entries: StrictInt - __properties: ClassVar[List[str]] = ["task_instances", "total_entries"] + total_entries: Optional[StrictInt] = None + __properties: ClassVar[List[str]] = ["next_cursor", "previous_cursor", "task_instances", "total_entries"] model_config = ConfigDict( validate_by_name=True, @@ -90,6 +92,8 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: return cls.model_validate(obj) _obj = cls.model_validate({ + "next_cursor": obj.get("next_cursor"), + "previous_cursor": obj.get("previous_cursor"), "task_instances": [TaskInstanceResponse.from_dict(_item) for _item in obj["task_instances"]] if obj.get("task_instances") is not None else None, "total_entries": obj.get("total_entries") }) diff --git a/airflow_client/client/models/task_instances_inner.py b/airflow_client/client/models/task_instances_inner.py new file mode 100644 index 00000000..375ea89a --- /dev/null +++ b/airflow_client/client/models/task_instances_inner.py @@ -0,0 +1,137 @@ +# coding: utf-8 + +""" + Airflow API + + Airflow API. All endpoints located under ``/api/v2`` can be used safely, are stable and backward compatible. Endpoints located under ``/ui`` are dedicated to the UI and are subject to breaking change depending on the need of the frontend. Users should not rely on those but use the public ones instead. + + The version of the OpenAPI document: 2 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import json +import pprint +from pydantic import BaseModel, ConfigDict, Field, StrictStr, ValidationError, field_validator +from typing import Any, List, Optional +from airflow_client.client.models.new_task_response import NewTaskResponse +from airflow_client.client.models.task_instance_response import TaskInstanceResponse +from pydantic import StrictStr, Field +from typing import Union, List, Set, Optional, Dict +from typing_extensions import Literal, Self + +TASKINSTANCESINNER_ONE_OF_SCHEMAS = ["NewTaskResponse", "TaskInstanceResponse"] + +class TaskInstancesInner(BaseModel): + """ + TaskInstancesInner + """ + # data type: TaskInstanceResponse + oneof_schema_1_validator: Optional[TaskInstanceResponse] = None + # data type: NewTaskResponse + oneof_schema_2_validator: Optional[NewTaskResponse] = None + actual_instance: Optional[Union[NewTaskResponse, TaskInstanceResponse]] = None + one_of_schemas: Set[str] = { "NewTaskResponse", "TaskInstanceResponse" } + + model_config = ConfigDict( + validate_assignment=True, + protected_namespaces=(), + ) + + + def __init__(self, *args, **kwargs) -> None: + if args: + if len(args) > 1: + raise ValueError("If a position argument is used, only 1 is allowed to set `actual_instance`") + if kwargs: + raise ValueError("If a position argument is used, keyword arguments cannot be used.") + super().__init__(actual_instance=args[0]) + else: + super().__init__(**kwargs) + + @field_validator('actual_instance') + def actual_instance_must_validate_oneof(cls, v): + instance = TaskInstancesInner.model_construct() + error_messages = [] + match = 0 + # validate data type: TaskInstanceResponse + if not isinstance(v, TaskInstanceResponse): + error_messages.append(f"Error! Input type `{type(v)}` is not `TaskInstanceResponse`") + else: + match += 1 + # validate data type: NewTaskResponse + if not isinstance(v, NewTaskResponse): + error_messages.append(f"Error! Input type `{type(v)}` is not `NewTaskResponse`") + else: + match += 1 + if match > 1: + # more than 1 match + raise ValueError("Multiple matches found when setting `actual_instance` in TaskInstancesInner with oneOf schemas: NewTaskResponse, TaskInstanceResponse. Details: " + ", ".join(error_messages)) + elif match == 0: + # no match + raise ValueError("No match found when setting `actual_instance` in TaskInstancesInner with oneOf schemas: NewTaskResponse, TaskInstanceResponse. Details: " + ", ".join(error_messages)) + else: + return v + + @classmethod + def from_dict(cls, obj: Union[str, Dict[str, Any]]) -> Self: + return cls.from_json(json.dumps(obj)) + + @classmethod + def from_json(cls, json_str: str) -> Self: + """Returns the object represented by the json string""" + instance = cls.model_construct() + error_messages = [] + match = 0 + + # deserialize data into TaskInstanceResponse + try: + instance.actual_instance = TaskInstanceResponse.from_json(json_str) + match += 1 + except (ValidationError, ValueError) as e: + error_messages.append(str(e)) + # deserialize data into NewTaskResponse + try: + instance.actual_instance = NewTaskResponse.from_json(json_str) + match += 1 + except (ValidationError, ValueError) as e: + error_messages.append(str(e)) + + if match > 1: + # more than 1 match + raise ValueError("Multiple matches found when deserializing the JSON string into TaskInstancesInner with oneOf schemas: NewTaskResponse, TaskInstanceResponse. Details: " + ", ".join(error_messages)) + elif match == 0: + # no match + raise ValueError("No match found when deserializing the JSON string into TaskInstancesInner with oneOf schemas: NewTaskResponse, TaskInstanceResponse. Details: " + ", ".join(error_messages)) + else: + return instance + + def to_json(self) -> str: + """Returns the JSON representation of the actual instance""" + if self.actual_instance is None: + return "null" + + if hasattr(self.actual_instance, "to_json") and callable(self.actual_instance.to_json): + return self.actual_instance.to_json() + else: + return json.dumps(self.actual_instance) + + def to_dict(self) -> Optional[Union[Dict[str, Any], NewTaskResponse, TaskInstanceResponse]]: + """Returns the dict representation of the actual instance""" + if self.actual_instance is None: + return None + + if hasattr(self.actual_instance, "to_dict") and callable(self.actual_instance.to_dict): + return self.actual_instance.to_dict() + else: + # primitive type + return self.actual_instance + + def to_str(self) -> str: + """Returns the string representation of the actual instance""" + return pprint.pformat(self.model_dump()) + + diff --git a/airflow_client/client/models/trigger_dag_run_post_body.py b/airflow_client/client/models/trigger_dag_run_post_body.py index f1363356..d20dbfaa 100644 --- a/airflow_client/client/models/trigger_dag_run_post_body.py +++ b/airflow_client/client/models/trigger_dag_run_post_body.py @@ -21,7 +21,7 @@ class TriggerDAGRunPostBody(BaseModel): """ - Trigger DAG Run Serializer for POST body. + Trigger Dag Run Serializer for POST body. """ conf: Optional[Dict[str, Any]] = None dag_run_id: Optional[StrictStr] = None diff --git a/docs/AssetApi.md b/docs/AssetApi.md index 827680bf..71a20a79 100644 --- a/docs/AssetApi.md +++ b/docs/AssetApi.md @@ -194,7 +194,7 @@ void (empty response body) Delete Dag Asset Queued Event -Delete a queued asset event for a DAG. +Delete a queued asset event for a Dag. ### Example @@ -529,7 +529,7 @@ Name | Type | Description | Notes [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) # **get_asset_aliases** -> AssetAliasCollectionResponse get_asset_aliases(limit=limit, offset=offset, name_pattern=name_pattern, order_by=order_by) +> AssetAliasCollectionResponse get_asset_aliases(limit=limit, offset=offset, name_pattern=name_pattern, name_prefix_pattern=name_prefix_pattern, order_by=order_by) Get Asset Aliases @@ -570,12 +570,13 @@ with airflow_client.client.ApiClient(configuration) as api_client: api_instance = airflow_client.client.AssetApi(api_client) limit = 50 # int | (optional) (default to 50) offset = 0 # int | (optional) (default to 0) - name_pattern = 'name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) + name_pattern = 'name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``name_prefix_pattern`` parameter when possible. (optional) + name_prefix_pattern = 'name_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) order_by = ["id"] # List[str] | Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, name` (optional) (default to ["id"]) try: # Get Asset Aliases - api_response = api_instance.get_asset_aliases(limit=limit, offset=offset, name_pattern=name_pattern, order_by=order_by) + api_response = api_instance.get_asset_aliases(limit=limit, offset=offset, name_pattern=name_pattern, name_prefix_pattern=name_prefix_pattern, order_by=order_by) print("The response of AssetApi->get_asset_aliases:\n") pprint(api_response) except Exception as e: @@ -591,7 +592,8 @@ Name | Type | Description | Notes ------------- | ------------- | ------------- | ------------- **limit** | **int**| | [optional] [default to 50] **offset** | **int**| | [optional] [default to 0] - **name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] + **name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``name_prefix_pattern`` parameter when possible. | [optional] + **name_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] **order_by** | [**List[str]**](str.md)| Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, name` | [optional] [default to ["id"]] ### Return type @@ -620,7 +622,7 @@ Name | Type | Description | Notes [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) # **get_asset_events** -> AssetEventCollectionResponse get_asset_events(limit=limit, offset=offset, order_by=order_by, asset_id=asset_id, source_dag_id=source_dag_id, source_task_id=source_task_id, source_run_id=source_run_id, source_map_index=source_map_index, name_pattern=name_pattern, timestamp_gte=timestamp_gte, timestamp_gt=timestamp_gt, timestamp_lte=timestamp_lte, timestamp_lt=timestamp_lt) +> AssetEventCollectionResponse get_asset_events(limit=limit, offset=offset, order_by=order_by, asset_id=asset_id, source_dag_id=source_dag_id, source_task_id=source_task_id, source_run_id=source_run_id, source_map_index=source_map_index, name_pattern=name_pattern, name_prefix_pattern=name_prefix_pattern, timestamp_gte=timestamp_gte, timestamp_gt=timestamp_gt, timestamp_lte=timestamp_lte, timestamp_lt=timestamp_lt) Get Asset Events @@ -667,7 +669,8 @@ with airflow_client.client.ApiClient(configuration) as api_client: source_task_id = 'source_task_id_example' # str | (optional) source_run_id = 'source_run_id_example' # str | (optional) source_map_index = 56 # int | (optional) - name_pattern = 'name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) + name_pattern = 'name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``name_prefix_pattern`` parameter when possible. (optional) + name_prefix_pattern = 'name_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) timestamp_gte = '2013-10-20T19:20:30+01:00' # datetime | (optional) timestamp_gt = '2013-10-20T19:20:30+01:00' # datetime | (optional) timestamp_lte = '2013-10-20T19:20:30+01:00' # datetime | (optional) @@ -675,7 +678,7 @@ with airflow_client.client.ApiClient(configuration) as api_client: try: # Get Asset Events - api_response = api_instance.get_asset_events(limit=limit, offset=offset, order_by=order_by, asset_id=asset_id, source_dag_id=source_dag_id, source_task_id=source_task_id, source_run_id=source_run_id, source_map_index=source_map_index, name_pattern=name_pattern, timestamp_gte=timestamp_gte, timestamp_gt=timestamp_gt, timestamp_lte=timestamp_lte, timestamp_lt=timestamp_lt) + api_response = api_instance.get_asset_events(limit=limit, offset=offset, order_by=order_by, asset_id=asset_id, source_dag_id=source_dag_id, source_task_id=source_task_id, source_run_id=source_run_id, source_map_index=source_map_index, name_pattern=name_pattern, name_prefix_pattern=name_prefix_pattern, timestamp_gte=timestamp_gte, timestamp_gt=timestamp_gt, timestamp_lte=timestamp_lte, timestamp_lt=timestamp_lt) print("The response of AssetApi->get_asset_events:\n") pprint(api_response) except Exception as e: @@ -697,7 +700,8 @@ Name | Type | Description | Notes **source_task_id** | **str**| | [optional] **source_run_id** | **str**| | [optional] **source_map_index** | **int**| | [optional] - **name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] + **name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``name_prefix_pattern`` parameter when possible. | [optional] + **name_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] **timestamp_gte** | **datetime**| | [optional] **timestamp_gt** | **datetime**| | [optional] **timestamp_lte** | **datetime**| | [optional] @@ -815,7 +819,7 @@ Name | Type | Description | Notes [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) # **get_assets** -> AssetCollectionResponse get_assets(limit=limit, offset=offset, name_pattern=name_pattern, uri_pattern=uri_pattern, dag_ids=dag_ids, only_active=only_active, order_by=order_by) +> AssetCollectionResponse get_assets(limit=limit, offset=offset, name_pattern=name_pattern, name_prefix_pattern=name_prefix_pattern, uri_pattern=uri_pattern, uri_prefix_pattern=uri_prefix_pattern, dag_ids=dag_ids, only_active=only_active, order_by=order_by) Get Assets @@ -856,15 +860,17 @@ with airflow_client.client.ApiClient(configuration) as api_client: api_instance = airflow_client.client.AssetApi(api_client) limit = 50 # int | (optional) (default to 50) offset = 0 # int | (optional) (default to 0) - name_pattern = 'name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) - uri_pattern = 'uri_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) + name_pattern = 'name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``name_prefix_pattern`` parameter when possible. (optional) + name_prefix_pattern = 'name_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) + uri_pattern = 'uri_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``uri_prefix_pattern`` parameter when possible. (optional) + uri_prefix_pattern = 'uri_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) dag_ids = ['dag_ids_example'] # List[str] | (optional) only_active = True # bool | (optional) (default to True) order_by = ["id"] # List[str] | Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, name, uri, created_at, updated_at` (optional) (default to ["id"]) try: # Get Assets - api_response = api_instance.get_assets(limit=limit, offset=offset, name_pattern=name_pattern, uri_pattern=uri_pattern, dag_ids=dag_ids, only_active=only_active, order_by=order_by) + api_response = api_instance.get_assets(limit=limit, offset=offset, name_pattern=name_pattern, name_prefix_pattern=name_prefix_pattern, uri_pattern=uri_pattern, uri_prefix_pattern=uri_prefix_pattern, dag_ids=dag_ids, only_active=only_active, order_by=order_by) print("The response of AssetApi->get_assets:\n") pprint(api_response) except Exception as e: @@ -880,8 +886,10 @@ Name | Type | Description | Notes ------------- | ------------- | ------------- | ------------- **limit** | **int**| | [optional] [default to 50] **offset** | **int**| | [optional] [default to 0] - **name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] - **uri_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] + **name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``name_prefix_pattern`` parameter when possible. | [optional] + **name_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] + **uri_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``uri_prefix_pattern`` parameter when possible. | [optional] + **uri_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] **dag_ids** | [**List[str]**](str.md)| | [optional] **only_active** | **bool**| | [optional] [default to True] **order_by** | [**List[str]**](str.md)| Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, name, uri, created_at, updated_at` | [optional] [default to ["id"]] @@ -916,7 +924,7 @@ Name | Type | Description | Notes Get Dag Asset Queued Event -Get a queued asset event for a DAG. +Get a queued asset event for a Dag. ### Example @@ -1005,7 +1013,7 @@ Name | Type | Description | Notes Get Dag Asset Queued Events -Get queued asset events for a DAG. +Get queued asset events for a Dag. ### Example @@ -1091,7 +1099,7 @@ Name | Type | Description | Notes Materialize Asset -Materialize an asset by triggering a DAG run that produces it. +Materialize an asset by triggering a Dag run that produces it. ### Example diff --git a/docs/ClearTaskInstanceCollectionResponse.md b/docs/ClearTaskInstanceCollectionResponse.md new file mode 100644 index 00000000..23f0558a --- /dev/null +++ b/docs/ClearTaskInstanceCollectionResponse.md @@ -0,0 +1,31 @@ +# ClearTaskInstanceCollectionResponse + +Response for clear dag run dry run, which may contain new tasks without full TaskInstance data. + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**task_instances** | [**List[TaskInstancesInner]**](TaskInstancesInner.md) | | +**total_entries** | **int** | | + +## Example + +```python +from airflow_client.client.models.clear_task_instance_collection_response import ClearTaskInstanceCollectionResponse + +# TODO update the JSON string below +json = "{}" +# create an instance of ClearTaskInstanceCollectionResponse from a JSON string +clear_task_instance_collection_response_instance = ClearTaskInstanceCollectionResponse.from_json(json) +# print the JSON string representation of the object +print(ClearTaskInstanceCollectionResponse.to_json()) + +# convert the object into a dict +clear_task_instance_collection_response_dict = clear_task_instance_collection_response_instance.to_dict() +# create an instance of ClearTaskInstanceCollectionResponse from a dict +clear_task_instance_collection_response_from_dict = ClearTaskInstanceCollectionResponse.from_dict(clear_task_instance_collection_response_dict) +``` +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/docs/ConnectionApi.md b/docs/ConnectionApi.md index 14dcdb20..0e25a791 100644 --- a/docs/ConnectionApi.md +++ b/docs/ConnectionApi.md @@ -343,7 +343,7 @@ Name | Type | Description | Notes [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) # **get_connections** -> ConnectionCollectionResponse get_connections(limit=limit, offset=offset, order_by=order_by, connection_id_pattern=connection_id_pattern) +> ConnectionCollectionResponse get_connections(limit=limit, offset=offset, order_by=order_by, connection_id_pattern=connection_id_pattern, connection_id_prefix_pattern=connection_id_prefix_pattern) Get Connections @@ -385,11 +385,12 @@ with airflow_client.client.ApiClient(configuration) as api_client: limit = 50 # int | (optional) (default to 50) offset = 0 # int | (optional) (default to 0) order_by = ["id"] # List[str] | Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `conn_id, conn_type, description, host, port, id, team_name, connection_id` (optional) (default to ["id"]) - connection_id_pattern = 'connection_id_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) + connection_id_pattern = 'connection_id_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``connection_id_prefix_pattern`` parameter when possible. (optional) + connection_id_prefix_pattern = 'connection_id_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) try: # Get Connections - api_response = api_instance.get_connections(limit=limit, offset=offset, order_by=order_by, connection_id_pattern=connection_id_pattern) + api_response = api_instance.get_connections(limit=limit, offset=offset, order_by=order_by, connection_id_pattern=connection_id_pattern, connection_id_prefix_pattern=connection_id_prefix_pattern) print("The response of ConnectionApi->get_connections:\n") pprint(api_response) except Exception as e: @@ -406,7 +407,8 @@ Name | Type | Description | Notes **limit** | **int**| | [optional] [default to 50] **offset** | **int**| | [optional] [default to 0] **order_by** | [**List[str]**](str.md)| Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `conn_id, conn_type, description, host, port, id, team_name, connection_id` | [optional] [default to ["id"]] - **connection_id_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] + **connection_id_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``connection_id_prefix_pattern`` parameter when possible. | [optional] + **connection_id_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] ### Return type diff --git a/docs/DAGApi.md b/docs/DAGApi.md index 888662fd..2ce5d907 100644 --- a/docs/DAGApi.md +++ b/docs/DAGApi.md @@ -20,7 +20,7 @@ Method | HTTP request | Description Delete Dag -Delete the specific DAG. +Delete the specific Dag. ### Example @@ -105,7 +105,7 @@ Name | Type | Description | Notes Favorite Dag -Mark the DAG as favorite. +Mark the Dag as favorite. ### Example @@ -187,7 +187,7 @@ void (empty response body) Get Dag -Get basic information about a DAG. +Get basic information about a Dag. ### Example @@ -273,7 +273,7 @@ Name | Type | Description | Notes Get Dag Details -Get details of DAG. +Get details of Dag. ### Example @@ -355,11 +355,11 @@ Name | Type | Description | Notes [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) # **get_dag_tags** -> DAGTagCollectionResponse get_dag_tags(limit=limit, offset=offset, order_by=order_by, tag_name_pattern=tag_name_pattern) +> DAGTagCollectionResponse get_dag_tags(limit=limit, offset=offset, order_by=order_by, tag_name_pattern=tag_name_pattern, tag_name_prefix_pattern=tag_name_prefix_pattern) Get Dag Tags -Get all DAG tags. +Get all Dag tags. ### Example @@ -397,11 +397,12 @@ with airflow_client.client.ApiClient(configuration) as api_client: limit = 50 # int | (optional) (default to 50) offset = 0 # int | (optional) (default to 0) order_by = ["name"] # List[str] | Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `name` (optional) (default to ["name"]) - tag_name_pattern = 'tag_name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) + tag_name_pattern = 'tag_name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``tag_name_prefix_pattern`` parameter when possible. (optional) + tag_name_prefix_pattern = 'tag_name_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) try: # Get Dag Tags - api_response = api_instance.get_dag_tags(limit=limit, offset=offset, order_by=order_by, tag_name_pattern=tag_name_pattern) + api_response = api_instance.get_dag_tags(limit=limit, offset=offset, order_by=order_by, tag_name_pattern=tag_name_pattern, tag_name_prefix_pattern=tag_name_prefix_pattern) print("The response of DAGApi->get_dag_tags:\n") pprint(api_response) except Exception as e: @@ -418,7 +419,8 @@ Name | Type | Description | Notes **limit** | **int**| | [optional] [default to 50] **offset** | **int**| | [optional] [default to 0] **order_by** | [**List[str]**](str.md)| Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `name` | [optional] [default to ["name"]] - **tag_name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] + **tag_name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``tag_name_prefix_pattern`` parameter when possible. | [optional] + **tag_name_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] ### Return type @@ -445,11 +447,11 @@ Name | Type | Description | Notes [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) # **get_dags** -> DAGCollectionResponse get_dags(limit=limit, offset=offset, tags=tags, tags_match_mode=tags_match_mode, owners=owners, dag_id_pattern=dag_id_pattern, dag_display_name_pattern=dag_display_name_pattern, exclude_stale=exclude_stale, paused=paused, has_import_errors=has_import_errors, last_dag_run_state=last_dag_run_state, bundle_name=bundle_name, bundle_version=bundle_version, has_asset_schedule=has_asset_schedule, asset_dependency=asset_dependency, dag_run_start_date_gte=dag_run_start_date_gte, dag_run_start_date_gt=dag_run_start_date_gt, dag_run_start_date_lte=dag_run_start_date_lte, dag_run_start_date_lt=dag_run_start_date_lt, dag_run_end_date_gte=dag_run_end_date_gte, dag_run_end_date_gt=dag_run_end_date_gt, dag_run_end_date_lte=dag_run_end_date_lte, dag_run_end_date_lt=dag_run_end_date_lt, dag_run_state=dag_run_state, order_by=order_by, is_favorite=is_favorite, timetable_type=timetable_type) +> DAGCollectionResponse get_dags(limit=limit, offset=offset, tags=tags, tags_match_mode=tags_match_mode, owners=owners, dag_id_pattern=dag_id_pattern, dag_id_prefix_pattern=dag_id_prefix_pattern, dag_display_name_pattern=dag_display_name_pattern, dag_display_name_prefix_pattern=dag_display_name_prefix_pattern, exclude_stale=exclude_stale, paused=paused, has_import_errors=has_import_errors, last_dag_run_state=last_dag_run_state, bundle_name=bundle_name, bundle_version=bundle_version, has_asset_schedule=has_asset_schedule, asset_dependency=asset_dependency, dag_run_start_date_gte=dag_run_start_date_gte, dag_run_start_date_gt=dag_run_start_date_gt, dag_run_start_date_lte=dag_run_start_date_lte, dag_run_start_date_lt=dag_run_start_date_lt, dag_run_end_date_gte=dag_run_end_date_gte, dag_run_end_date_gt=dag_run_end_date_gt, dag_run_end_date_lte=dag_run_end_date_lte, dag_run_end_date_lt=dag_run_end_date_lt, dag_run_state=dag_run_state, order_by=order_by, is_favorite=is_favorite, timetable_type=timetable_type) Get Dags -Get all DAGs. +Get all Dags. ### Example @@ -489,8 +491,10 @@ with airflow_client.client.ApiClient(configuration) as api_client: tags = ['tags_example'] # List[str] | (optional) tags_match_mode = 'tags_match_mode_example' # str | (optional) owners = ['owners_example'] # List[str] | (optional) - dag_id_pattern = 'dag_id_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) - dag_display_name_pattern = 'dag_display_name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) + dag_id_pattern = 'dag_id_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. (optional) + dag_id_prefix_pattern = 'dag_id_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) + dag_display_name_pattern = 'dag_display_name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_display_name_prefix_pattern`` parameter when possible. (optional) + dag_display_name_prefix_pattern = 'dag_display_name_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) exclude_stale = True # bool | (optional) (default to True) paused = True # bool | (optional) has_import_errors = True # bool | Filter Dags by having import errors. Only Dags that have been successfully loaded before will be returned. (optional) @@ -514,7 +518,7 @@ with airflow_client.client.ApiClient(configuration) as api_client: try: # Get Dags - api_response = api_instance.get_dags(limit=limit, offset=offset, tags=tags, tags_match_mode=tags_match_mode, owners=owners, dag_id_pattern=dag_id_pattern, dag_display_name_pattern=dag_display_name_pattern, exclude_stale=exclude_stale, paused=paused, has_import_errors=has_import_errors, last_dag_run_state=last_dag_run_state, bundle_name=bundle_name, bundle_version=bundle_version, has_asset_schedule=has_asset_schedule, asset_dependency=asset_dependency, dag_run_start_date_gte=dag_run_start_date_gte, dag_run_start_date_gt=dag_run_start_date_gt, dag_run_start_date_lte=dag_run_start_date_lte, dag_run_start_date_lt=dag_run_start_date_lt, dag_run_end_date_gte=dag_run_end_date_gte, dag_run_end_date_gt=dag_run_end_date_gt, dag_run_end_date_lte=dag_run_end_date_lte, dag_run_end_date_lt=dag_run_end_date_lt, dag_run_state=dag_run_state, order_by=order_by, is_favorite=is_favorite, timetable_type=timetable_type) + api_response = api_instance.get_dags(limit=limit, offset=offset, tags=tags, tags_match_mode=tags_match_mode, owners=owners, dag_id_pattern=dag_id_pattern, dag_id_prefix_pattern=dag_id_prefix_pattern, dag_display_name_pattern=dag_display_name_pattern, dag_display_name_prefix_pattern=dag_display_name_prefix_pattern, exclude_stale=exclude_stale, paused=paused, has_import_errors=has_import_errors, last_dag_run_state=last_dag_run_state, bundle_name=bundle_name, bundle_version=bundle_version, has_asset_schedule=has_asset_schedule, asset_dependency=asset_dependency, dag_run_start_date_gte=dag_run_start_date_gte, dag_run_start_date_gt=dag_run_start_date_gt, dag_run_start_date_lte=dag_run_start_date_lte, dag_run_start_date_lt=dag_run_start_date_lt, dag_run_end_date_gte=dag_run_end_date_gte, dag_run_end_date_gt=dag_run_end_date_gt, dag_run_end_date_lte=dag_run_end_date_lte, dag_run_end_date_lt=dag_run_end_date_lt, dag_run_state=dag_run_state, order_by=order_by, is_favorite=is_favorite, timetable_type=timetable_type) print("The response of DAGApi->get_dags:\n") pprint(api_response) except Exception as e: @@ -533,8 +537,10 @@ Name | Type | Description | Notes **tags** | [**List[str]**](str.md)| | [optional] **tags_match_mode** | **str**| | [optional] **owners** | [**List[str]**](str.md)| | [optional] - **dag_id_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] - **dag_display_name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] + **dag_id_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. | [optional] + **dag_id_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] + **dag_display_name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_display_name_prefix_pattern`` parameter when possible. | [optional] + **dag_display_name_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] **exclude_stale** | **bool**| | [optional] [default to True] **paused** | **bool**| | [optional] **has_import_errors** | **bool**| Filter Dags by having import errors. Only Dags that have been successfully loaded before will be returned. | [optional] @@ -585,7 +591,7 @@ Name | Type | Description | Notes Patch Dag -Patch the specific DAG. +Patch the specific Dag. ### Example @@ -672,11 +678,15 @@ Name | Type | Description | Notes [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) # **patch_dags** -> DAGCollectionResponse patch_dags(dag_patch_body, update_mask=update_mask, limit=limit, offset=offset, tags=tags, tags_match_mode=tags_match_mode, owners=owners, dag_id_pattern=dag_id_pattern, exclude_stale=exclude_stale, paused=paused) +> DAGCollectionResponse patch_dags(dag_patch_body, update_mask=update_mask, limit=limit, offset=offset, tags=tags, tags_match_mode=tags_match_mode, owners=owners, dag_id_pattern=dag_id_pattern, dag_id_prefix_pattern=dag_id_prefix_pattern, exclude_stale=exclude_stale, paused=paused) Patch Dags -Patch multiple DAGs. +Patch multiple Dags. + +If neither `dag_id_pattern` nor `dag_id_prefix_pattern` is provided, no Dags will be +matched regardless of other filters. To match all Dags, pass a wildcard value such as +`~` or `%` for `dag_id_pattern`. ### Example @@ -719,13 +729,14 @@ with airflow_client.client.ApiClient(configuration) as api_client: tags = ['tags_example'] # List[str] | (optional) tags_match_mode = 'tags_match_mode_example' # str | (optional) owners = ['owners_example'] # List[str] | (optional) - dag_id_pattern = 'dag_id_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) + dag_id_pattern = 'dag_id_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. (optional) + dag_id_prefix_pattern = 'dag_id_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) exclude_stale = True # bool | (optional) (default to True) paused = True # bool | (optional) try: # Patch Dags - api_response = api_instance.patch_dags(dag_patch_body, update_mask=update_mask, limit=limit, offset=offset, tags=tags, tags_match_mode=tags_match_mode, owners=owners, dag_id_pattern=dag_id_pattern, exclude_stale=exclude_stale, paused=paused) + api_response = api_instance.patch_dags(dag_patch_body, update_mask=update_mask, limit=limit, offset=offset, tags=tags, tags_match_mode=tags_match_mode, owners=owners, dag_id_pattern=dag_id_pattern, dag_id_prefix_pattern=dag_id_prefix_pattern, exclude_stale=exclude_stale, paused=paused) print("The response of DAGApi->patch_dags:\n") pprint(api_response) except Exception as e: @@ -746,7 +757,8 @@ Name | Type | Description | Notes **tags** | [**List[str]**](str.md)| | [optional] **tags_match_mode** | **str**| | [optional] **owners** | [**List[str]**](str.md)| | [optional] - **dag_id_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] + **dag_id_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. | [optional] + **dag_id_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] **exclude_stale** | **bool**| | [optional] [default to True] **paused** | **bool**| | [optional] @@ -781,7 +793,7 @@ Name | Type | Description | Notes Unfavorite Dag -Unmark the DAG as favorite. +Unmark the Dag as favorite. ### Example diff --git a/docs/DAGCollectionResponse.md b/docs/DAGCollectionResponse.md index 44779ecf..48679716 100644 --- a/docs/DAGCollectionResponse.md +++ b/docs/DAGCollectionResponse.md @@ -1,6 +1,6 @@ # DAGCollectionResponse -DAG Collection serializer for responses. +Dag Collection serializer for responses. ## Properties diff --git a/docs/DAGDetailsResponse.md b/docs/DAGDetailsResponse.md index df51a5c0..80880a1c 100644 --- a/docs/DAGDetailsResponse.md +++ b/docs/DAGDetailsResponse.md @@ -1,6 +1,6 @@ # DAGDetailsResponse -Specific serializer for DAG Details responses. +Specific serializer for Dag Details responses. ## Properties diff --git a/docs/DAGParsingApi.md b/docs/DAGParsingApi.md index 063e7b15..655920e1 100644 --- a/docs/DAGParsingApi.md +++ b/docs/DAGParsingApi.md @@ -12,7 +12,7 @@ Method | HTTP request | Description Reparse Dag File -Request re-parsing a DAG file. +Request re-parsing a Dag file. ### Example diff --git a/docs/DAGResponse.md b/docs/DAGResponse.md index b82c433a..a5bc6be1 100644 --- a/docs/DAGResponse.md +++ b/docs/DAGResponse.md @@ -1,6 +1,6 @@ # DAGResponse -DAG serializer for responses. +Dag serializer for responses. ## Properties diff --git a/docs/DAGRunApi.md b/docs/DAGRunApi.md index 5f086855..67f3db3e 100644 --- a/docs/DAGRunApi.md +++ b/docs/DAGRunApi.md @@ -108,7 +108,7 @@ Name | Type | Description | Notes Delete Dag Run -Delete a DAG Run entry. +Delete a Dag Run entry. ### Example @@ -274,13 +274,22 @@ Name | Type | Description | Notes [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) # **get_dag_runs** -> DAGRunCollectionResponse get_dag_runs(dag_id, limit=limit, offset=offset, run_after_gte=run_after_gte, run_after_gt=run_after_gt, run_after_lte=run_after_lte, run_after_lt=run_after_lt, logical_date_gte=logical_date_gte, logical_date_gt=logical_date_gt, logical_date_lte=logical_date_lte, logical_date_lt=logical_date_lt, start_date_gte=start_date_gte, start_date_gt=start_date_gt, start_date_lte=start_date_lte, start_date_lt=start_date_lt, end_date_gte=end_date_gte, end_date_gt=end_date_gt, end_date_lte=end_date_lte, end_date_lt=end_date_lt, duration_gte=duration_gte, duration_gt=duration_gt, duration_lte=duration_lte, duration_lt=duration_lt, updated_at_gte=updated_at_gte, updated_at_gt=updated_at_gt, updated_at_lte=updated_at_lte, updated_at_lt=updated_at_lt, conf_contains=conf_contains, run_type=run_type, state=state, dag_version=dag_version, bundle_version=bundle_version, order_by=order_by, run_id_pattern=run_id_pattern, triggering_user_name_pattern=triggering_user_name_pattern, dag_id_pattern=dag_id_pattern, partition_key_pattern=partition_key_pattern) +> DAGRunCollectionResponse get_dag_runs(dag_id, cursor=cursor, limit=limit, offset=offset, run_after_gte=run_after_gte, run_after_gt=run_after_gt, run_after_lte=run_after_lte, run_after_lt=run_after_lt, logical_date_gte=logical_date_gte, logical_date_gt=logical_date_gt, logical_date_lte=logical_date_lte, logical_date_lt=logical_date_lt, start_date_gte=start_date_gte, start_date_gt=start_date_gt, start_date_lte=start_date_lte, start_date_lt=start_date_lt, end_date_gte=end_date_gte, end_date_gt=end_date_gt, end_date_lte=end_date_lte, end_date_lt=end_date_lt, duration_gte=duration_gte, duration_gt=duration_gt, duration_lte=duration_lte, duration_lt=duration_lt, updated_at_gte=updated_at_gte, updated_at_gt=updated_at_gt, updated_at_lte=updated_at_lte, updated_at_lt=updated_at_lt, conf_contains=conf_contains, run_type=run_type, state=state, dag_version=dag_version, bundle_version=bundle_version, order_by=order_by, run_id_pattern=run_id_pattern, run_id_prefix_pattern=run_id_prefix_pattern, triggering_user_name_pattern=triggering_user_name_pattern, triggering_user_name_prefix_pattern=triggering_user_name_prefix_pattern, dag_id_pattern=dag_id_pattern, dag_id_prefix_pattern=dag_id_prefix_pattern, partition_key_pattern=partition_key_pattern, partition_key_prefix_pattern=partition_key_prefix_pattern, consuming_asset_pattern=consuming_asset_pattern) Get Dag Runs -Get all DAG Runs. +Get all Dag Runs. -This endpoint allows specifying `~` as the dag_id to retrieve Dag Runs for all DAGs. +This endpoint allows specifying `~` as the dag_id to retrieve Dag Runs for all Dags. + +Supports two pagination modes: + +**Offset (default):** use `limit` and `offset` query parameters. Returns `total_entries`. + +**Cursor:** pass `cursor` (empty string for the first page, then `next_cursor` from the response). +When `cursor` is provided, `offset` is ignored and `total_entries` is not returned. +``next_cursor`` is ``null`` when there are no more pages; ``previous_cursor`` is ``null`` +on the first page. ### Example @@ -316,6 +325,7 @@ with airflow_client.client.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = airflow_client.client.DagRunApi(api_client) dag_id = 'dag_id_example' # str | + cursor = 'cursor_example' # str | Cursor for keyset-based pagination. Pass an empty string for the first page, then use ``next_cursor`` from the response. When ``cursor`` is provided, ``offset`` is ignored. (optional) limit = 50 # int | (optional) (default to 50) offset = 0 # int | (optional) (default to 0) run_after_gte = '2013-10-20T19:20:30+01:00' # datetime | (optional) @@ -348,14 +358,19 @@ with airflow_client.client.ApiClient(configuration) as api_client: dag_version = [56] # List[int] | (optional) bundle_version = 'bundle_version_example' # str | (optional) order_by = ["id"] # List[str] | Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, state, dag_id, run_id, logical_date, run_after, start_date, end_date, updated_at, conf, duration, dag_run_id` (optional) (default to ["id"]) - run_id_pattern = 'run_id_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) - triggering_user_name_pattern = 'triggering_user_name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) - dag_id_pattern = 'dag_id_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) - partition_key_pattern = 'partition_key_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) + run_id_pattern = 'run_id_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible. (optional) + run_id_prefix_pattern = 'run_id_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) + triggering_user_name_pattern = 'triggering_user_name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``triggering_user_name_prefix_pattern`` parameter when possible. (optional) + triggering_user_name_prefix_pattern = 'triggering_user_name_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) + dag_id_pattern = 'dag_id_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. (optional) + dag_id_prefix_pattern = 'dag_id_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) + partition_key_pattern = 'partition_key_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``partition_key_prefix_pattern`` parameter when possible. (optional) + partition_key_prefix_pattern = 'partition_key_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) + consuming_asset_pattern = 'consuming_asset_pattern_example' # str | Filter by consuming asset name or URI using pattern matching (optional) try: # Get Dag Runs - api_response = api_instance.get_dag_runs(dag_id, limit=limit, offset=offset, run_after_gte=run_after_gte, run_after_gt=run_after_gt, run_after_lte=run_after_lte, run_after_lt=run_after_lt, logical_date_gte=logical_date_gte, logical_date_gt=logical_date_gt, logical_date_lte=logical_date_lte, logical_date_lt=logical_date_lt, start_date_gte=start_date_gte, start_date_gt=start_date_gt, start_date_lte=start_date_lte, start_date_lt=start_date_lt, end_date_gte=end_date_gte, end_date_gt=end_date_gt, end_date_lte=end_date_lte, end_date_lt=end_date_lt, duration_gte=duration_gte, duration_gt=duration_gt, duration_lte=duration_lte, duration_lt=duration_lt, updated_at_gte=updated_at_gte, updated_at_gt=updated_at_gt, updated_at_lte=updated_at_lte, updated_at_lt=updated_at_lt, conf_contains=conf_contains, run_type=run_type, state=state, dag_version=dag_version, bundle_version=bundle_version, order_by=order_by, run_id_pattern=run_id_pattern, triggering_user_name_pattern=triggering_user_name_pattern, dag_id_pattern=dag_id_pattern, partition_key_pattern=partition_key_pattern) + api_response = api_instance.get_dag_runs(dag_id, cursor=cursor, limit=limit, offset=offset, run_after_gte=run_after_gte, run_after_gt=run_after_gt, run_after_lte=run_after_lte, run_after_lt=run_after_lt, logical_date_gte=logical_date_gte, logical_date_gt=logical_date_gt, logical_date_lte=logical_date_lte, logical_date_lt=logical_date_lt, start_date_gte=start_date_gte, start_date_gt=start_date_gt, start_date_lte=start_date_lte, start_date_lt=start_date_lt, end_date_gte=end_date_gte, end_date_gt=end_date_gt, end_date_lte=end_date_lte, end_date_lt=end_date_lt, duration_gte=duration_gte, duration_gt=duration_gt, duration_lte=duration_lte, duration_lt=duration_lt, updated_at_gte=updated_at_gte, updated_at_gt=updated_at_gt, updated_at_lte=updated_at_lte, updated_at_lt=updated_at_lt, conf_contains=conf_contains, run_type=run_type, state=state, dag_version=dag_version, bundle_version=bundle_version, order_by=order_by, run_id_pattern=run_id_pattern, run_id_prefix_pattern=run_id_prefix_pattern, triggering_user_name_pattern=triggering_user_name_pattern, triggering_user_name_prefix_pattern=triggering_user_name_prefix_pattern, dag_id_pattern=dag_id_pattern, dag_id_prefix_pattern=dag_id_prefix_pattern, partition_key_pattern=partition_key_pattern, partition_key_prefix_pattern=partition_key_prefix_pattern, consuming_asset_pattern=consuming_asset_pattern) print("The response of DagRunApi->get_dag_runs:\n") pprint(api_response) except Exception as e: @@ -370,6 +385,7 @@ with airflow_client.client.ApiClient(configuration) as api_client: Name | Type | Description | Notes ------------- | ------------- | ------------- | ------------- **dag_id** | **str**| | + **cursor** | **str**| Cursor for keyset-based pagination. Pass an empty string for the first page, then use ``next_cursor`` from the response. When ``cursor`` is provided, ``offset`` is ignored. | [optional] **limit** | **int**| | [optional] [default to 50] **offset** | **int**| | [optional] [default to 0] **run_after_gte** | **datetime**| | [optional] @@ -402,10 +418,15 @@ Name | Type | Description | Notes **dag_version** | [**List[int]**](int.md)| | [optional] **bundle_version** | **str**| | [optional] **order_by** | [**List[str]**](str.md)| Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, state, dag_id, run_id, logical_date, run_after, start_date, end_date, updated_at, conf, duration, dag_run_id` | [optional] [default to ["id"]] - **run_id_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] - **triggering_user_name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] - **dag_id_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] - **partition_key_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] + **run_id_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible. | [optional] + **run_id_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] + **triggering_user_name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``triggering_user_name_prefix_pattern`` parameter when possible. | [optional] + **triggering_user_name_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] + **dag_id_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. | [optional] + **dag_id_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] + **partition_key_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``partition_key_prefix_pattern`` parameter when possible. | [optional] + **partition_key_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] + **consuming_asset_pattern** | **str**| Filter by consuming asset name or URI using pattern matching | [optional] ### Return type @@ -437,7 +458,7 @@ Name | Type | Description | Notes Get List Dag Runs Batch -Get a list of DAG Runs. +Get a list of Dag Runs. ### Example @@ -612,7 +633,7 @@ Name | Type | Description | Notes Patch Dag Run -Modify a DAG Run. +Modify a Dag Run. ### Example @@ -705,7 +726,7 @@ Name | Type | Description | Notes Trigger Dag Run -Trigger a DAG. +Trigger a Dag. ### Example @@ -795,7 +816,7 @@ Name | Type | Description | Notes Experimental: Wait for a dag run to complete, and return task results if requested. -🚧 This is an experimental endpoint and may change or be removed without notice.Successful response are streamed as newline-delimited JSON (NDJSON). Each line is a JSON object representing the DAG run state. +🚧 This is an experimental endpoint and may change or be removed without notice.Successful response are streamed as newline-delimited JSON (NDJSON). Each line is a JSON object representing the Dag run state. ### Example diff --git a/docs/DAGRunClearBody.md b/docs/DAGRunClearBody.md index 485ec587..c43cb46b 100644 --- a/docs/DAGRunClearBody.md +++ b/docs/DAGRunClearBody.md @@ -1,6 +1,6 @@ # DAGRunClearBody -DAG Run serializer for clear endpoint body. +Dag Run serializer for clear endpoint body. ## Properties @@ -8,6 +8,7 @@ Name | Type | Description | Notes ------------ | ------------- | ------------- | ------------- **dry_run** | **bool** | | [optional] [default to True] **only_failed** | **bool** | | [optional] [default to False] +**only_new** | **bool** | Only queue newly added tasks in the latest DAG version without clearing existing tasks. | [optional] [default to False] **run_on_latest_version** | **bool** | (Experimental) Run on the latest bundle version of the Dag after clearing the Dag Run. | [optional] [default to False] ## Example diff --git a/docs/DAGRunCollectionResponse.md b/docs/DAGRunCollectionResponse.md index 03e7ae9c..9a4c9cb7 100644 --- a/docs/DAGRunCollectionResponse.md +++ b/docs/DAGRunCollectionResponse.md @@ -1,13 +1,15 @@ # DAGRunCollectionResponse -DAG Run Collection serializer for responses. +Dag Run collection response supporting both offset and cursor pagination. A single flat model is used instead of a discriminated union (``Annotated[Offset | Cursor, Field(discriminator=...)]``) because the OpenAPI ``oneOf`` + ``discriminator`` construct is not handled correctly by ``@hey-api/openapi-ts`` / ``@7nohe/openapi-react-query-codegen``: return types degrade to ``unknown`` in JSDoc and can produce incorrect TypeScript types (see hey-api/openapi-ts#1613, #3270). ## Properties Name | Type | Description | Notes ------------ | ------------- | ------------- | ------------- **dag_runs** | [**List[DAGRunResponse]**](DAGRunResponse.md) | | -**total_entries** | **int** | | +**next_cursor** | **str** | | [optional] +**previous_cursor** | **str** | | [optional] +**total_entries** | **int** | | [optional] ## Example diff --git a/docs/DAGRunPatchBody.md b/docs/DAGRunPatchBody.md index 5527ac4a..8230a667 100644 --- a/docs/DAGRunPatchBody.md +++ b/docs/DAGRunPatchBody.md @@ -1,6 +1,6 @@ # DAGRunPatchBody -DAG Run Serializer for PATCH requests. +Dag Run Serializer for PATCH requests. ## Properties diff --git a/docs/DAGRunPatchStates.md b/docs/DAGRunPatchStates.md index d6f059c5..74de607a 100644 --- a/docs/DAGRunPatchStates.md +++ b/docs/DAGRunPatchStates.md @@ -1,6 +1,6 @@ # DAGRunPatchStates -Enum for DAG Run states when updating a DAG Run. +Enum for Dag Run states when updating a Dag Run. ## Enum diff --git a/docs/DAGRunResponse.md b/docs/DAGRunResponse.md index 00ef7cca..458cf4d1 100644 --- a/docs/DAGRunResponse.md +++ b/docs/DAGRunResponse.md @@ -1,6 +1,6 @@ # DAGRunResponse -DAG Run serializer for responses. +Dag Run serializer for responses. ## Properties diff --git a/docs/DAGRunsBatchBody.md b/docs/DAGRunsBatchBody.md index 217af31d..52111c86 100644 --- a/docs/DAGRunsBatchBody.md +++ b/docs/DAGRunsBatchBody.md @@ -1,6 +1,6 @@ # DAGRunsBatchBody -List DAG Runs body for batch endpoint. +List Dag Runs body for batch endpoint. ## Properties diff --git a/docs/DAGSourceResponse.md b/docs/DAGSourceResponse.md index c806e901..28bad04f 100644 --- a/docs/DAGSourceResponse.md +++ b/docs/DAGSourceResponse.md @@ -1,6 +1,6 @@ # DAGSourceResponse -DAG Source serializer for responses. +Dag Source serializer for responses. ## Properties diff --git a/docs/DAGTagCollectionResponse.md b/docs/DAGTagCollectionResponse.md index 362da02f..f768629d 100644 --- a/docs/DAGTagCollectionResponse.md +++ b/docs/DAGTagCollectionResponse.md @@ -1,6 +1,6 @@ # DAGTagCollectionResponse -DAG Tags Collection serializer for responses. +Dag Tags Collection serializer for responses. ## Properties diff --git a/docs/DAGVersionCollectionResponse.md b/docs/DAGVersionCollectionResponse.md index e204d6f1..720bd9fb 100644 --- a/docs/DAGVersionCollectionResponse.md +++ b/docs/DAGVersionCollectionResponse.md @@ -1,6 +1,6 @@ # DAGVersionCollectionResponse -DAG Version Collection serializer for responses. +Dag Version Collection serializer for responses. ## Properties diff --git a/docs/DAGWarningCollectionResponse.md b/docs/DAGWarningCollectionResponse.md index 5ff1623d..5acc2bf3 100644 --- a/docs/DAGWarningCollectionResponse.md +++ b/docs/DAGWarningCollectionResponse.md @@ -1,6 +1,6 @@ # DAGWarningCollectionResponse -DAG warning collection serializer for responses. +Dag warning collection serializer for responses. ## Properties diff --git a/docs/DAGWarningResponse.md b/docs/DAGWarningResponse.md index c16e9797..c2c5121c 100644 --- a/docs/DAGWarningResponse.md +++ b/docs/DAGWarningResponse.md @@ -1,6 +1,6 @@ # DAGWarningResponse -DAG Warning serializer for responses. +Dag Warning serializer for responses. ## Properties diff --git a/docs/DagScheduleAssetReference.md b/docs/DagScheduleAssetReference.md index 40e23560..cb602af8 100644 --- a/docs/DagScheduleAssetReference.md +++ b/docs/DagScheduleAssetReference.md @@ -1,6 +1,6 @@ # DagScheduleAssetReference -DAG schedule reference serializer for assets. +Dag schedule reference serializer for assets. ## Properties diff --git a/docs/DagStatsCollectionResponse.md b/docs/DagStatsCollectionResponse.md index 71de5e9b..98a7aec7 100644 --- a/docs/DagStatsCollectionResponse.md +++ b/docs/DagStatsCollectionResponse.md @@ -1,6 +1,6 @@ # DagStatsCollectionResponse -DAG Stats Collection serializer for responses. +Dag Stats Collection serializer for responses. ## Properties diff --git a/docs/DagStatsResponse.md b/docs/DagStatsResponse.md index a061c1ef..1c7684fd 100644 --- a/docs/DagStatsResponse.md +++ b/docs/DagStatsResponse.md @@ -1,6 +1,6 @@ # DagStatsResponse -DAG Stats serializer for responses. +Dag Stats serializer for responses. ## Properties diff --git a/docs/DagTagResponse.md b/docs/DagTagResponse.md index 95b94b28..60a329ac 100644 --- a/docs/DagTagResponse.md +++ b/docs/DagTagResponse.md @@ -1,6 +1,6 @@ # DagTagResponse -DAG Tag serializer for responses. +Dag Tag serializer for responses. ## Properties diff --git a/docs/DagVersionApi.md b/docs/DagVersionApi.md index a416294d..52ba851c 100644 --- a/docs/DagVersionApi.md +++ b/docs/DagVersionApi.md @@ -100,9 +100,9 @@ Name | Type | Description | Notes Get Dag Versions -Get all DAG Versions. +Get all Dag Versions. -This endpoint allows specifying `~` as the dag_id to retrieve DAG Versions for all DAGs. +This endpoint allows specifying `~` as the dag_id to retrieve Dag Versions for all Dags. ### Example diff --git a/docs/DagWarningApi.md b/docs/DagWarningApi.md index e2ef2df6..09e5aa50 100644 --- a/docs/DagWarningApi.md +++ b/docs/DagWarningApi.md @@ -12,7 +12,7 @@ Method | HTTP request | Description List Dag Warnings -Get a list of DAG warnings. +Get a list of Dag warnings. ### Example diff --git a/docs/EventLogApi.md b/docs/EventLogApi.md index 782e8e60..53c31542 100644 --- a/docs/EventLogApi.md +++ b/docs/EventLogApi.md @@ -92,7 +92,7 @@ Name | Type | Description | Notes [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) # **get_event_logs** -> EventLogCollectionResponse get_event_logs(limit=limit, offset=offset, order_by=order_by, dag_id=dag_id, task_id=task_id, run_id=run_id, map_index=map_index, try_number=try_number, owner=owner, event=event, excluded_events=excluded_events, included_events=included_events, before=before, after=after, dag_id_pattern=dag_id_pattern, task_id_pattern=task_id_pattern, run_id_pattern=run_id_pattern, owner_pattern=owner_pattern, event_pattern=event_pattern) +> EventLogCollectionResponse get_event_logs(limit=limit, offset=offset, order_by=order_by, dag_id=dag_id, task_id=task_id, run_id=run_id, map_index=map_index, try_number=try_number, owner=owner, event=event, excluded_events=excluded_events, included_events=included_events, before=before, after=after, dag_id_pattern=dag_id_pattern, task_id_pattern=task_id_pattern, run_id_pattern=run_id_pattern, owner_pattern=owner_pattern, event_pattern=event_pattern, dag_id_prefix_pattern=dag_id_prefix_pattern, task_id_prefix_pattern=task_id_prefix_pattern, run_id_prefix_pattern=run_id_prefix_pattern, owner_prefix_pattern=owner_prefix_pattern, event_prefix_pattern=event_prefix_pattern) Get Event Logs @@ -145,15 +145,20 @@ with airflow_client.client.ApiClient(configuration) as api_client: included_events = ['included_events_example'] # List[str] | (optional) before = '2013-10-20T19:20:30+01:00' # datetime | (optional) after = '2013-10-20T19:20:30+01:00' # datetime | (optional) - dag_id_pattern = 'dag_id_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) - task_id_pattern = 'task_id_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) - run_id_pattern = 'run_id_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) - owner_pattern = 'owner_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) - event_pattern = 'event_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) + dag_id_pattern = 'dag_id_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. (optional) + task_id_pattern = 'task_id_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_id_prefix_pattern`` parameter when possible. (optional) + run_id_pattern = 'run_id_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible. (optional) + owner_pattern = 'owner_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``owner_prefix_pattern`` parameter when possible. (optional) + event_pattern = 'event_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``event_prefix_pattern`` parameter when possible. (optional) + dag_id_prefix_pattern = 'dag_id_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) + task_id_prefix_pattern = 'task_id_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) + run_id_prefix_pattern = 'run_id_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) + owner_prefix_pattern = 'owner_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) + event_prefix_pattern = 'event_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) try: # Get Event Logs - api_response = api_instance.get_event_logs(limit=limit, offset=offset, order_by=order_by, dag_id=dag_id, task_id=task_id, run_id=run_id, map_index=map_index, try_number=try_number, owner=owner, event=event, excluded_events=excluded_events, included_events=included_events, before=before, after=after, dag_id_pattern=dag_id_pattern, task_id_pattern=task_id_pattern, run_id_pattern=run_id_pattern, owner_pattern=owner_pattern, event_pattern=event_pattern) + api_response = api_instance.get_event_logs(limit=limit, offset=offset, order_by=order_by, dag_id=dag_id, task_id=task_id, run_id=run_id, map_index=map_index, try_number=try_number, owner=owner, event=event, excluded_events=excluded_events, included_events=included_events, before=before, after=after, dag_id_pattern=dag_id_pattern, task_id_pattern=task_id_pattern, run_id_pattern=run_id_pattern, owner_pattern=owner_pattern, event_pattern=event_pattern, dag_id_prefix_pattern=dag_id_prefix_pattern, task_id_prefix_pattern=task_id_prefix_pattern, run_id_prefix_pattern=run_id_prefix_pattern, owner_prefix_pattern=owner_prefix_pattern, event_prefix_pattern=event_prefix_pattern) print("The response of EventLogApi->get_event_logs:\n") pprint(api_response) except Exception as e: @@ -181,11 +186,16 @@ Name | Type | Description | Notes **included_events** | [**List[str]**](str.md)| | [optional] **before** | **datetime**| | [optional] **after** | **datetime**| | [optional] - **dag_id_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] - **task_id_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] - **run_id_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] - **owner_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] - **event_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] + **dag_id_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. | [optional] + **task_id_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_id_prefix_pattern`` parameter when possible. | [optional] + **run_id_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible. | [optional] + **owner_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``owner_prefix_pattern`` parameter when possible. | [optional] + **event_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``event_prefix_pattern`` parameter when possible. | [optional] + **dag_id_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] + **task_id_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] + **run_id_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] + **owner_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] + **event_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] ### Return type diff --git a/docs/ExperimentalApi.md b/docs/ExperimentalApi.md index 940b81ef..fb0bc9cc 100644 --- a/docs/ExperimentalApi.md +++ b/docs/ExperimentalApi.md @@ -12,7 +12,7 @@ Method | HTTP request | Description Experimental: Wait for a dag run to complete, and return task results if requested. -🚧 This is an experimental endpoint and may change or be removed without notice.Successful response are streamed as newline-delimited JSON (NDJSON). Each line is a JSON object representing the DAG run state. +🚧 This is an experimental endpoint and may change or be removed without notice.Successful response are streamed as newline-delimited JSON (NDJSON). Each line is a JSON object representing the Dag run state. ### Example diff --git a/docs/ExtraLinksApi.md b/docs/ExtraLinksApi.md index 94acdca6..f793b629 100644 --- a/docs/ExtraLinksApi.md +++ b/docs/ExtraLinksApi.md @@ -8,7 +8,7 @@ Method | HTTP request | Description # **get_extra_links** -> ExtraLinkCollectionResponse get_extra_links(dag_id, dag_run_id, task_id, map_index=map_index) +> ExtraLinkCollectionResponse get_extra_links(dag_id, dag_run_id, task_id, map_index=map_index, try_number=try_number) Get Extra Links @@ -51,10 +51,11 @@ with airflow_client.client.ApiClient(configuration) as api_client: dag_run_id = 'dag_run_id_example' # str | task_id = 'task_id_example' # str | map_index = -1 # int | (optional) (default to -1) + try_number = 56 # int | (optional) try: # Get Extra Links - api_response = api_instance.get_extra_links(dag_id, dag_run_id, task_id, map_index=map_index) + api_response = api_instance.get_extra_links(dag_id, dag_run_id, task_id, map_index=map_index, try_number=try_number) print("The response of ExtraLinksApi->get_extra_links:\n") pprint(api_response) except Exception as e: @@ -72,6 +73,7 @@ Name | Type | Description | Notes **dag_run_id** | **str**| | **task_id** | **str**| | **map_index** | **int**| | [optional] [default to -1] + **try_number** | **int**| | [optional] ### Return type diff --git a/docs/ImportErrorApi.md b/docs/ImportErrorApi.md index 936d049f..d2cac046 100644 --- a/docs/ImportErrorApi.md +++ b/docs/ImportErrorApi.md @@ -94,7 +94,7 @@ Name | Type | Description | Notes [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) # **get_import_errors** -> ImportErrorCollectionResponse get_import_errors(limit=limit, offset=offset, order_by=order_by, filename_pattern=filename_pattern) +> ImportErrorCollectionResponse get_import_errors(limit=limit, offset=offset, order_by=order_by, filename_pattern=filename_pattern, filename_prefix_pattern=filename_prefix_pattern) Get Import Errors @@ -136,11 +136,12 @@ with airflow_client.client.ApiClient(configuration) as api_client: limit = 50 # int | (optional) (default to 50) offset = 0 # int | (optional) (default to 0) order_by = ["id"] # List[str] | Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, timestamp, filename, bundle_name, stacktrace, import_error_id` (optional) (default to ["id"]) - filename_pattern = 'filename_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) + filename_pattern = 'filename_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``filename_prefix_pattern`` parameter when possible. (optional) + filename_prefix_pattern = 'filename_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) try: # Get Import Errors - api_response = api_instance.get_import_errors(limit=limit, offset=offset, order_by=order_by, filename_pattern=filename_pattern) + api_response = api_instance.get_import_errors(limit=limit, offset=offset, order_by=order_by, filename_pattern=filename_pattern, filename_prefix_pattern=filename_prefix_pattern) print("The response of ImportErrorApi->get_import_errors:\n") pprint(api_response) except Exception as e: @@ -157,7 +158,8 @@ Name | Type | Description | Notes **limit** | **int**| | [optional] [default to 50] **offset** | **int**| | [optional] [default to 0] **order_by** | [**List[str]**](str.md)| Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, timestamp, filename, bundle_name, stacktrace, import_error_id` | [optional] [default to ["id"]] - **filename_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] + **filename_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``filename_prefix_pattern`` parameter when possible. | [optional] + **filename_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] ### Return type diff --git a/docs/NewTaskResponse.md b/docs/NewTaskResponse.md new file mode 100644 index 00000000..0b791bb5 --- /dev/null +++ b/docs/NewTaskResponse.md @@ -0,0 +1,31 @@ +# NewTaskResponse + +Lightweight response for new tasks that don't have TaskInstances yet. + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**task_display_name** | **str** | | +**task_id** | **str** | | + +## Example + +```python +from airflow_client.client.models.new_task_response import NewTaskResponse + +# TODO update the JSON string below +json = "{}" +# create an instance of NewTaskResponse from a JSON string +new_task_response_instance = NewTaskResponse.from_json(json) +# print the JSON string representation of the object +print(NewTaskResponse.to_json()) + +# convert the object into a dict +new_task_response_dict = new_task_response_instance.to_dict() +# create an instance of NewTaskResponse from a dict +new_task_response_from_dict = NewTaskResponse.from_dict(new_task_response_dict) +``` +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/docs/PoolApi.md b/docs/PoolApi.md index 2579552f..6c883ec2 100644 --- a/docs/PoolApi.md +++ b/docs/PoolApi.md @@ -266,7 +266,7 @@ Name | Type | Description | Notes [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) # **get_pools** -> PoolCollectionResponse get_pools(limit=limit, offset=offset, order_by=order_by, pool_name_pattern=pool_name_pattern) +> PoolCollectionResponse get_pools(limit=limit, offset=offset, order_by=order_by, pool_name_pattern=pool_name_pattern, pool_name_prefix_pattern=pool_name_prefix_pattern) Get Pools @@ -308,11 +308,12 @@ with airflow_client.client.ApiClient(configuration) as api_client: limit = 50 # int | (optional) (default to 50) offset = 0 # int | (optional) (default to 0) order_by = ["id"] # List[str] | Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, pool, name` (optional) (default to ["id"]) - pool_name_pattern = 'pool_name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) + pool_name_pattern = 'pool_name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``pool_name_prefix_pattern`` parameter when possible. (optional) + pool_name_prefix_pattern = 'pool_name_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) try: # Get Pools - api_response = api_instance.get_pools(limit=limit, offset=offset, order_by=order_by, pool_name_pattern=pool_name_pattern) + api_response = api_instance.get_pools(limit=limit, offset=offset, order_by=order_by, pool_name_pattern=pool_name_pattern, pool_name_prefix_pattern=pool_name_prefix_pattern) print("The response of PoolApi->get_pools:\n") pprint(api_response) except Exception as e: @@ -329,7 +330,8 @@ Name | Type | Description | Notes **limit** | **int**| | [optional] [default to 50] **offset** | **int**| | [optional] [default to 0] **order_by** | [**List[str]**](str.md)| Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, pool, name` | [optional] [default to ["id"]] - **pool_name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] + **pool_name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``pool_name_prefix_pattern`` parameter when possible. | [optional] + **pool_name_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] ### Return type diff --git a/docs/ResponseClearDagRun.md b/docs/ResponseClearDagRun.md index d51c77cc..3fd7f4d3 100644 --- a/docs/ResponseClearDagRun.md +++ b/docs/ResponseClearDagRun.md @@ -5,7 +5,7 @@ Name | Type | Description | Notes ------------ | ------------- | ------------- | ------------- -**task_instances** | [**List[TaskInstanceResponse]**](TaskInstanceResponse.md) | | +**task_instances** | [**List[TaskInstancesInner]**](TaskInstancesInner.md) | | **total_entries** | **int** | | **bundle_version** | **str** | | [optional] **conf** | **Dict[str, object]** | | [optional] diff --git a/docs/TaskApi.md b/docs/TaskApi.md index c1247b76..3eaa41a1 100644 --- a/docs/TaskApi.md +++ b/docs/TaskApi.md @@ -101,7 +101,7 @@ Name | Type | Description | Notes Get Tasks -Get tasks for DAG. +Get tasks for Dag. ### Example diff --git a/docs/TaskInstanceApi.md b/docs/TaskInstanceApi.md index 1ac25cf6..267a2b03 100644 --- a/docs/TaskInstanceApi.md +++ b/docs/TaskInstanceApi.md @@ -305,7 +305,7 @@ Name | Type | Description | Notes [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) # **get_extra_links** -> ExtraLinkCollectionResponse get_extra_links(dag_id, dag_run_id, task_id, map_index=map_index) +> ExtraLinkCollectionResponse get_extra_links(dag_id, dag_run_id, task_id, map_index=map_index, try_number=try_number) Get Extra Links @@ -348,10 +348,11 @@ with airflow_client.client.ApiClient(configuration) as api_client: dag_run_id = 'dag_run_id_example' # str | task_id = 'task_id_example' # str | map_index = -1 # int | (optional) (default to -1) + try_number = 56 # int | (optional) try: # Get Extra Links - api_response = api_instance.get_extra_links(dag_id, dag_run_id, task_id, map_index=map_index) + api_response = api_instance.get_extra_links(dag_id, dag_run_id, task_id, map_index=map_index, try_number=try_number) print("The response of TaskInstanceApi->get_extra_links:\n") pprint(api_response) except Exception as e: @@ -369,6 +370,7 @@ Name | Type | Description | Notes **dag_run_id** | **str**| | **task_id** | **str**| | **map_index** | **int**| | [optional] [default to -1] + **try_number** | **int**| | [optional] ### Return type @@ -580,7 +582,7 @@ Name | Type | Description | Notes [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) # **get_hitl_details** -> HITLDetailCollection get_hitl_details(dag_id, dag_run_id, limit=limit, offset=offset, order_by=order_by, dag_id_pattern=dag_id_pattern, task_id=task_id, task_id_pattern=task_id_pattern, map_index=map_index, state=state, response_received=response_received, responded_by_user_id=responded_by_user_id, responded_by_user_name=responded_by_user_name, subject_search=subject_search, body_search=body_search, created_at_gte=created_at_gte, created_at_gt=created_at_gt, created_at_lte=created_at_lte, created_at_lt=created_at_lt) +> HITLDetailCollection get_hitl_details(dag_id, dag_run_id, limit=limit, offset=offset, order_by=order_by, dag_id_pattern=dag_id_pattern, dag_id_prefix_pattern=dag_id_prefix_pattern, task_id=task_id, task_id_pattern=task_id_pattern, task_id_prefix_pattern=task_id_prefix_pattern, map_index=map_index, state=state, response_received=response_received, responded_by_user_id=responded_by_user_id, responded_by_user_name=responded_by_user_name, subject_search=subject_search, body_search=body_search, created_at_gte=created_at_gte, created_at_gt=created_at_gt, created_at_lte=created_at_lte, created_at_lt=created_at_lt) Get Hitl Details @@ -624,16 +626,18 @@ with airflow_client.client.ApiClient(configuration) as api_client: limit = 50 # int | (optional) (default to 50) offset = 0 # int | (optional) (default to 0) order_by = ["ti_id"] # List[str] | Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `ti_id, subject, responded_at, created_at, responded_by_user_id, responded_by_user_name, dag_id, run_id, task_display_name, run_after, rendered_map_index, task_instance_operator, task_instance_state` (optional) (default to ["ti_id"]) - dag_id_pattern = 'dag_id_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) + dag_id_pattern = 'dag_id_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. (optional) + dag_id_prefix_pattern = 'dag_id_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) task_id = 'task_id_example' # str | (optional) - task_id_pattern = 'task_id_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) + task_id_pattern = 'task_id_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_id_prefix_pattern`` parameter when possible. (optional) + task_id_prefix_pattern = 'task_id_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) map_index = 56 # int | (optional) state = ['state_example'] # List[str] | (optional) response_received = True # bool | (optional) responded_by_user_id = ['responded_by_user_id_example'] # List[str] | (optional) responded_by_user_name = ['responded_by_user_name_example'] # List[str] | (optional) - subject_search = 'subject_search_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) - body_search = 'body_search_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) + subject_search = 'subject_search_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``subject_search`` parameter when possible. (optional) + body_search = 'body_search_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``body_search`` parameter when possible. (optional) created_at_gte = '2013-10-20T19:20:30+01:00' # datetime | (optional) created_at_gt = '2013-10-20T19:20:30+01:00' # datetime | (optional) created_at_lte = '2013-10-20T19:20:30+01:00' # datetime | (optional) @@ -641,7 +645,7 @@ with airflow_client.client.ApiClient(configuration) as api_client: try: # Get Hitl Details - api_response = api_instance.get_hitl_details(dag_id, dag_run_id, limit=limit, offset=offset, order_by=order_by, dag_id_pattern=dag_id_pattern, task_id=task_id, task_id_pattern=task_id_pattern, map_index=map_index, state=state, response_received=response_received, responded_by_user_id=responded_by_user_id, responded_by_user_name=responded_by_user_name, subject_search=subject_search, body_search=body_search, created_at_gte=created_at_gte, created_at_gt=created_at_gt, created_at_lte=created_at_lte, created_at_lt=created_at_lt) + api_response = api_instance.get_hitl_details(dag_id, dag_run_id, limit=limit, offset=offset, order_by=order_by, dag_id_pattern=dag_id_pattern, dag_id_prefix_pattern=dag_id_prefix_pattern, task_id=task_id, task_id_pattern=task_id_pattern, task_id_prefix_pattern=task_id_prefix_pattern, map_index=map_index, state=state, response_received=response_received, responded_by_user_id=responded_by_user_id, responded_by_user_name=responded_by_user_name, subject_search=subject_search, body_search=body_search, created_at_gte=created_at_gte, created_at_gt=created_at_gt, created_at_lte=created_at_lte, created_at_lt=created_at_lt) print("The response of TaskInstanceApi->get_hitl_details:\n") pprint(api_response) except Exception as e: @@ -660,16 +664,18 @@ Name | Type | Description | Notes **limit** | **int**| | [optional] [default to 50] **offset** | **int**| | [optional] [default to 0] **order_by** | [**List[str]**](str.md)| Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `ti_id, subject, responded_at, created_at, responded_by_user_id, responded_by_user_name, dag_id, run_id, task_display_name, run_after, rendered_map_index, task_instance_operator, task_instance_state` | [optional] [default to ["ti_id"]] - **dag_id_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] + **dag_id_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. | [optional] + **dag_id_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] **task_id** | **str**| | [optional] - **task_id_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] + **task_id_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_id_prefix_pattern`` parameter when possible. | [optional] + **task_id_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] **map_index** | **int**| | [optional] **state** | [**List[str]**](str.md)| | [optional] **response_received** | **bool**| | [optional] **responded_by_user_id** | [**List[str]**](str.md)| | [optional] **responded_by_user_name** | [**List[str]**](str.md)| | [optional] - **subject_search** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] - **body_search** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] + **subject_search** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``subject_search`` parameter when possible. | [optional] + **body_search** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``body_search`` parameter when possible. | [optional] **created_at_gte** | **datetime**| | [optional] **created_at_gt** | **datetime**| | [optional] **created_at_lte** | **datetime**| | [optional] @@ -1070,7 +1076,7 @@ Name | Type | Description | Notes [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) # **get_mapped_task_instances** -> TaskInstanceCollectionResponse get_mapped_task_instances(dag_id, dag_run_id, task_id, run_after_gte=run_after_gte, run_after_gt=run_after_gt, run_after_lte=run_after_lte, run_after_lt=run_after_lt, logical_date_gte=logical_date_gte, logical_date_gt=logical_date_gt, logical_date_lte=logical_date_lte, logical_date_lt=logical_date_lt, start_date_gte=start_date_gte, start_date_gt=start_date_gt, start_date_lte=start_date_lte, start_date_lt=start_date_lt, end_date_gte=end_date_gte, end_date_gt=end_date_gt, end_date_lte=end_date_lte, end_date_lt=end_date_lt, updated_at_gte=updated_at_gte, updated_at_gt=updated_at_gt, updated_at_lte=updated_at_lte, updated_at_lt=updated_at_lt, duration_gte=duration_gte, duration_gt=duration_gt, duration_lte=duration_lte, duration_lt=duration_lt, state=state, pool=pool, pool_name_pattern=pool_name_pattern, queue=queue, queue_name_pattern=queue_name_pattern, executor=executor, version_number=version_number, try_number=try_number, operator=operator, operator_name_pattern=operator_name_pattern, map_index=map_index, limit=limit, offset=offset, order_by=order_by) +> TaskInstanceCollectionResponse get_mapped_task_instances(dag_id, dag_run_id, task_id, run_after_gte=run_after_gte, run_after_gt=run_after_gt, run_after_lte=run_after_lte, run_after_lt=run_after_lt, logical_date_gte=logical_date_gte, logical_date_gt=logical_date_gt, logical_date_lte=logical_date_lte, logical_date_lt=logical_date_lt, start_date_gte=start_date_gte, start_date_gt=start_date_gt, start_date_lte=start_date_lte, start_date_lt=start_date_lt, end_date_gte=end_date_gte, end_date_gt=end_date_gt, end_date_lte=end_date_lte, end_date_lt=end_date_lt, updated_at_gte=updated_at_gte, updated_at_gt=updated_at_gt, updated_at_lte=updated_at_lte, updated_at_lt=updated_at_lt, duration_gte=duration_gte, duration_gt=duration_gt, duration_lte=duration_lte, duration_lt=duration_lt, state=state, pool=pool, pool_name_pattern=pool_name_pattern, pool_name_prefix_pattern=pool_name_prefix_pattern, queue=queue, queue_name_pattern=queue_name_pattern, queue_name_prefix_pattern=queue_name_prefix_pattern, executor=executor, version_number=version_number, try_number=try_number, operator=operator, operator_name_pattern=operator_name_pattern, operator_name_prefix_pattern=operator_name_prefix_pattern, map_index=map_index, rendered_map_index_pattern=rendered_map_index_pattern, rendered_map_index_prefix_pattern=rendered_map_index_prefix_pattern, limit=limit, offset=offset, order_by=order_by) Get Mapped Task Instances @@ -1138,22 +1144,27 @@ with airflow_client.client.ApiClient(configuration) as api_client: duration_lt = 3.4 # float | (optional) state = ['state_example'] # List[str] | (optional) pool = ['pool_example'] # List[str] | (optional) - pool_name_pattern = 'pool_name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) + pool_name_pattern = 'pool_name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``pool_name_prefix_pattern`` parameter when possible. (optional) + pool_name_prefix_pattern = 'pool_name_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) queue = ['queue_example'] # List[str] | (optional) - queue_name_pattern = 'queue_name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) + queue_name_pattern = 'queue_name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``queue_name_prefix_pattern`` parameter when possible. (optional) + queue_name_prefix_pattern = 'queue_name_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) executor = ['executor_example'] # List[str] | (optional) version_number = [56] # List[int] | (optional) try_number = [56] # List[int] | (optional) operator = ['operator_example'] # List[str] | (optional) - operator_name_pattern = 'operator_name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) + operator_name_pattern = 'operator_name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``operator_name_prefix_pattern`` parameter when possible. (optional) + operator_name_prefix_pattern = 'operator_name_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) map_index = [56] # List[int] | (optional) + rendered_map_index_pattern = 'rendered_map_index_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``rendered_map_index_prefix_pattern`` parameter when possible. (optional) + rendered_map_index_prefix_pattern = 'rendered_map_index_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) limit = 50 # int | (optional) (default to 50) offset = 0 # int | (optional) (default to 0) order_by = ["map_index"] # List[str] | Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, state, duration, start_date, end_date, map_index, try_number, logical_date, run_after, data_interval_start, data_interval_end, rendered_map_index, operator, run_after, logical_date, data_interval_start, data_interval_end` (optional) (default to ["map_index"]) try: # Get Mapped Task Instances - api_response = api_instance.get_mapped_task_instances(dag_id, dag_run_id, task_id, run_after_gte=run_after_gte, run_after_gt=run_after_gt, run_after_lte=run_after_lte, run_after_lt=run_after_lt, logical_date_gte=logical_date_gte, logical_date_gt=logical_date_gt, logical_date_lte=logical_date_lte, logical_date_lt=logical_date_lt, start_date_gte=start_date_gte, start_date_gt=start_date_gt, start_date_lte=start_date_lte, start_date_lt=start_date_lt, end_date_gte=end_date_gte, end_date_gt=end_date_gt, end_date_lte=end_date_lte, end_date_lt=end_date_lt, updated_at_gte=updated_at_gte, updated_at_gt=updated_at_gt, updated_at_lte=updated_at_lte, updated_at_lt=updated_at_lt, duration_gte=duration_gte, duration_gt=duration_gt, duration_lte=duration_lte, duration_lt=duration_lt, state=state, pool=pool, pool_name_pattern=pool_name_pattern, queue=queue, queue_name_pattern=queue_name_pattern, executor=executor, version_number=version_number, try_number=try_number, operator=operator, operator_name_pattern=operator_name_pattern, map_index=map_index, limit=limit, offset=offset, order_by=order_by) + api_response = api_instance.get_mapped_task_instances(dag_id, dag_run_id, task_id, run_after_gte=run_after_gte, run_after_gt=run_after_gt, run_after_lte=run_after_lte, run_after_lt=run_after_lt, logical_date_gte=logical_date_gte, logical_date_gt=logical_date_gt, logical_date_lte=logical_date_lte, logical_date_lt=logical_date_lt, start_date_gte=start_date_gte, start_date_gt=start_date_gt, start_date_lte=start_date_lte, start_date_lt=start_date_lt, end_date_gte=end_date_gte, end_date_gt=end_date_gt, end_date_lte=end_date_lte, end_date_lt=end_date_lt, updated_at_gte=updated_at_gte, updated_at_gt=updated_at_gt, updated_at_lte=updated_at_lte, updated_at_lt=updated_at_lt, duration_gte=duration_gte, duration_gt=duration_gt, duration_lte=duration_lte, duration_lt=duration_lt, state=state, pool=pool, pool_name_pattern=pool_name_pattern, pool_name_prefix_pattern=pool_name_prefix_pattern, queue=queue, queue_name_pattern=queue_name_pattern, queue_name_prefix_pattern=queue_name_prefix_pattern, executor=executor, version_number=version_number, try_number=try_number, operator=operator, operator_name_pattern=operator_name_pattern, operator_name_prefix_pattern=operator_name_prefix_pattern, map_index=map_index, rendered_map_index_pattern=rendered_map_index_pattern, rendered_map_index_prefix_pattern=rendered_map_index_prefix_pattern, limit=limit, offset=offset, order_by=order_by) print("The response of TaskInstanceApi->get_mapped_task_instances:\n") pprint(api_response) except Exception as e: @@ -1196,15 +1207,20 @@ Name | Type | Description | Notes **duration_lt** | **float**| | [optional] **state** | [**List[str]**](str.md)| | [optional] **pool** | [**List[str]**](str.md)| | [optional] - **pool_name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] + **pool_name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``pool_name_prefix_pattern`` parameter when possible. | [optional] + **pool_name_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] **queue** | [**List[str]**](str.md)| | [optional] - **queue_name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] + **queue_name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``queue_name_prefix_pattern`` parameter when possible. | [optional] + **queue_name_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] **executor** | [**List[str]**](str.md)| | [optional] **version_number** | [**List[int]**](int.md)| | [optional] **try_number** | [**List[int]**](int.md)| | [optional] **operator** | [**List[str]**](str.md)| | [optional] - **operator_name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] + **operator_name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``operator_name_prefix_pattern`` parameter when possible. | [optional] + **operator_name_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] **map_index** | [**List[int]**](int.md)| | [optional] + **rendered_map_index_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``rendered_map_index_prefix_pattern`` parameter when possible. | [optional] + **rendered_map_index_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] **limit** | **int**| | [optional] [default to 50] **offset** | **int**| | [optional] [default to 0] **order_by** | [**List[str]**](str.md)| Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, state, duration, start_date, end_date, map_index, try_number, logical_date, run_after, data_interval_start, data_interval_end, rendered_map_index, operator, run_after, logical_date, data_interval_start, data_interval_end` | [optional] [default to ["map_index"]] @@ -1690,14 +1706,23 @@ Name | Type | Description | Notes [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) # **get_task_instances** -> TaskInstanceCollectionResponse get_task_instances(dag_id, dag_run_id, task_id=task_id, run_after_gte=run_after_gte, run_after_gt=run_after_gt, run_after_lte=run_after_lte, run_after_lt=run_after_lt, logical_date_gte=logical_date_gte, logical_date_gt=logical_date_gt, logical_date_lte=logical_date_lte, logical_date_lt=logical_date_lt, start_date_gte=start_date_gte, start_date_gt=start_date_gt, start_date_lte=start_date_lte, start_date_lt=start_date_lt, end_date_gte=end_date_gte, end_date_gt=end_date_gt, end_date_lte=end_date_lte, end_date_lt=end_date_lt, updated_at_gte=updated_at_gte, updated_at_gt=updated_at_gt, updated_at_lte=updated_at_lte, updated_at_lt=updated_at_lt, duration_gte=duration_gte, duration_gt=duration_gt, duration_lte=duration_lte, duration_lt=duration_lt, task_display_name_pattern=task_display_name_pattern, task_group_id=task_group_id, dag_id_pattern=dag_id_pattern, run_id_pattern=run_id_pattern, state=state, pool=pool, pool_name_pattern=pool_name_pattern, queue=queue, queue_name_pattern=queue_name_pattern, executor=executor, version_number=version_number, try_number=try_number, operator=operator, operator_name_pattern=operator_name_pattern, map_index=map_index, limit=limit, offset=offset, order_by=order_by) +> TaskInstanceCollectionResponse get_task_instances(dag_id, dag_run_id, cursor=cursor, task_id=task_id, run_after_gte=run_after_gte, run_after_gt=run_after_gt, run_after_lte=run_after_lte, run_after_lt=run_after_lt, logical_date_gte=logical_date_gte, logical_date_gt=logical_date_gt, logical_date_lte=logical_date_lte, logical_date_lt=logical_date_lt, start_date_gte=start_date_gte, start_date_gt=start_date_gt, start_date_lte=start_date_lte, start_date_lt=start_date_lt, end_date_gte=end_date_gte, end_date_gt=end_date_gt, end_date_lte=end_date_lte, end_date_lt=end_date_lt, updated_at_gte=updated_at_gte, updated_at_gt=updated_at_gt, updated_at_lte=updated_at_lte, updated_at_lt=updated_at_lt, duration_gte=duration_gte, duration_gt=duration_gt, duration_lte=duration_lte, duration_lt=duration_lt, task_display_name_pattern=task_display_name_pattern, task_display_name_prefix_pattern=task_display_name_prefix_pattern, task_group_id=task_group_id, dag_id_pattern=dag_id_pattern, dag_id_prefix_pattern=dag_id_prefix_pattern, run_id_pattern=run_id_pattern, run_id_prefix_pattern=run_id_prefix_pattern, state=state, pool=pool, pool_name_pattern=pool_name_pattern, pool_name_prefix_pattern=pool_name_prefix_pattern, queue=queue, queue_name_pattern=queue_name_pattern, queue_name_prefix_pattern=queue_name_prefix_pattern, executor=executor, version_number=version_number, try_number=try_number, operator=operator, operator_name_pattern=operator_name_pattern, operator_name_prefix_pattern=operator_name_prefix_pattern, map_index=map_index, rendered_map_index_pattern=rendered_map_index_pattern, rendered_map_index_prefix_pattern=rendered_map_index_prefix_pattern, limit=limit, offset=offset, order_by=order_by) Get Task Instances Get list of task instances. -This endpoint allows specifying `~` as the dag_id, dag_run_id to retrieve Task Instances for all DAGs -and DAG runs. +This endpoint allows specifying `~` as the dag_id, dag_run_id +to retrieve task instances for all Dags and Dag runs. + +Supports two pagination modes: + +**Offset (default):** use `limit` and `offset` query parameters. Returns `total_entries`. + +**Cursor:** pass `cursor` (empty string for the first page, then `next_cursor` from the response). +When `cursor` is provided, `offset` is ignored and `total_entries` is not returned. +``next_cursor`` is ``null`` when there are no more pages; ``previous_cursor`` is ``null`` +on the first page. ### Example @@ -1734,6 +1759,7 @@ with airflow_client.client.ApiClient(configuration) as api_client: api_instance = airflow_client.client.TaskInstanceApi(api_client) dag_id = 'dag_id_example' # str | dag_run_id = 'dag_run_id_example' # str | + cursor = 'cursor_example' # str | Cursor for keyset-based pagination. Pass an empty string for the first page, then use ``next_cursor`` from the response. When ``cursor`` is provided, ``offset`` is ignored. (optional) task_id = 'task_id_example' # str | (optional) run_after_gte = '2013-10-20T19:20:30+01:00' # datetime | (optional) run_after_gt = '2013-10-20T19:20:30+01:00' # datetime | (optional) @@ -1759,28 +1785,36 @@ with airflow_client.client.ApiClient(configuration) as api_client: duration_gt = 3.4 # float | (optional) duration_lte = 3.4 # float | (optional) duration_lt = 3.4 # float | (optional) - task_display_name_pattern = 'task_display_name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) + task_display_name_pattern = 'task_display_name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_display_name_prefix_pattern`` parameter when possible. (optional) + task_display_name_prefix_pattern = 'task_display_name_prefix_pattern_example' # str | Prefix match on task display name: optional ``_task_display_property_value`` else ``task_id`` (same as ``coalesce``). Case-sensitive. Index-friendly alternative to ``task_display_name_pattern``. On large databases, combine with ``dag_id_prefix_pattern`` (or a specific Dag in the path) so ``(dag_id, task_id, ...)`` indexes apply. Use ``|`` for OR. Use ``~`` to match all. Trailing non-alphanumeric characters in the term are stripped before matching so the range scan stays index-compatible under locale-aware collations. (optional) task_group_id = 'task_group_id_example' # str | Filter by exact task group ID. Returns all tasks within the specified task group. (optional) - dag_id_pattern = 'dag_id_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) - run_id_pattern = 'run_id_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) + dag_id_pattern = 'dag_id_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. (optional) + dag_id_prefix_pattern = 'dag_id_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) + run_id_pattern = 'run_id_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible. (optional) + run_id_prefix_pattern = 'run_id_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) state = ['state_example'] # List[str] | (optional) pool = ['pool_example'] # List[str] | (optional) - pool_name_pattern = 'pool_name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) + pool_name_pattern = 'pool_name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``pool_name_prefix_pattern`` parameter when possible. (optional) + pool_name_prefix_pattern = 'pool_name_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) queue = ['queue_example'] # List[str] | (optional) - queue_name_pattern = 'queue_name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) + queue_name_pattern = 'queue_name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``queue_name_prefix_pattern`` parameter when possible. (optional) + queue_name_prefix_pattern = 'queue_name_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) executor = ['executor_example'] # List[str] | (optional) version_number = [56] # List[int] | (optional) try_number = [56] # List[int] | (optional) operator = ['operator_example'] # List[str] | (optional) - operator_name_pattern = 'operator_name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) + operator_name_pattern = 'operator_name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``operator_name_prefix_pattern`` parameter when possible. (optional) + operator_name_prefix_pattern = 'operator_name_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) map_index = [56] # List[int] | (optional) + rendered_map_index_pattern = 'rendered_map_index_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``rendered_map_index_prefix_pattern`` parameter when possible. (optional) + rendered_map_index_prefix_pattern = 'rendered_map_index_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) limit = 50 # int | (optional) (default to 50) offset = 0 # int | (optional) (default to 0) order_by = ["map_index"] # List[str] | Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, state, duration, start_date, end_date, map_index, try_number, logical_date, run_after, data_interval_start, data_interval_end, rendered_map_index, operator, logical_date, run_after, data_interval_start, data_interval_end` (optional) (default to ["map_index"]) try: # Get Task Instances - api_response = api_instance.get_task_instances(dag_id, dag_run_id, task_id=task_id, run_after_gte=run_after_gte, run_after_gt=run_after_gt, run_after_lte=run_after_lte, run_after_lt=run_after_lt, logical_date_gte=logical_date_gte, logical_date_gt=logical_date_gt, logical_date_lte=logical_date_lte, logical_date_lt=logical_date_lt, start_date_gte=start_date_gte, start_date_gt=start_date_gt, start_date_lte=start_date_lte, start_date_lt=start_date_lt, end_date_gte=end_date_gte, end_date_gt=end_date_gt, end_date_lte=end_date_lte, end_date_lt=end_date_lt, updated_at_gte=updated_at_gte, updated_at_gt=updated_at_gt, updated_at_lte=updated_at_lte, updated_at_lt=updated_at_lt, duration_gte=duration_gte, duration_gt=duration_gt, duration_lte=duration_lte, duration_lt=duration_lt, task_display_name_pattern=task_display_name_pattern, task_group_id=task_group_id, dag_id_pattern=dag_id_pattern, run_id_pattern=run_id_pattern, state=state, pool=pool, pool_name_pattern=pool_name_pattern, queue=queue, queue_name_pattern=queue_name_pattern, executor=executor, version_number=version_number, try_number=try_number, operator=operator, operator_name_pattern=operator_name_pattern, map_index=map_index, limit=limit, offset=offset, order_by=order_by) + api_response = api_instance.get_task_instances(dag_id, dag_run_id, cursor=cursor, task_id=task_id, run_after_gte=run_after_gte, run_after_gt=run_after_gt, run_after_lte=run_after_lte, run_after_lt=run_after_lt, logical_date_gte=logical_date_gte, logical_date_gt=logical_date_gt, logical_date_lte=logical_date_lte, logical_date_lt=logical_date_lt, start_date_gte=start_date_gte, start_date_gt=start_date_gt, start_date_lte=start_date_lte, start_date_lt=start_date_lt, end_date_gte=end_date_gte, end_date_gt=end_date_gt, end_date_lte=end_date_lte, end_date_lt=end_date_lt, updated_at_gte=updated_at_gte, updated_at_gt=updated_at_gt, updated_at_lte=updated_at_lte, updated_at_lt=updated_at_lt, duration_gte=duration_gte, duration_gt=duration_gt, duration_lte=duration_lte, duration_lt=duration_lt, task_display_name_pattern=task_display_name_pattern, task_display_name_prefix_pattern=task_display_name_prefix_pattern, task_group_id=task_group_id, dag_id_pattern=dag_id_pattern, dag_id_prefix_pattern=dag_id_prefix_pattern, run_id_pattern=run_id_pattern, run_id_prefix_pattern=run_id_prefix_pattern, state=state, pool=pool, pool_name_pattern=pool_name_pattern, pool_name_prefix_pattern=pool_name_prefix_pattern, queue=queue, queue_name_pattern=queue_name_pattern, queue_name_prefix_pattern=queue_name_prefix_pattern, executor=executor, version_number=version_number, try_number=try_number, operator=operator, operator_name_pattern=operator_name_pattern, operator_name_prefix_pattern=operator_name_prefix_pattern, map_index=map_index, rendered_map_index_pattern=rendered_map_index_pattern, rendered_map_index_prefix_pattern=rendered_map_index_prefix_pattern, limit=limit, offset=offset, order_by=order_by) print("The response of TaskInstanceApi->get_task_instances:\n") pprint(api_response) except Exception as e: @@ -1796,6 +1830,7 @@ Name | Type | Description | Notes ------------- | ------------- | ------------- | ------------- **dag_id** | **str**| | **dag_run_id** | **str**| | + **cursor** | **str**| Cursor for keyset-based pagination. Pass an empty string for the first page, then use ``next_cursor`` from the response. When ``cursor`` is provided, ``offset`` is ignored. | [optional] **task_id** | **str**| | [optional] **run_after_gte** | **datetime**| | [optional] **run_after_gt** | **datetime**| | [optional] @@ -1821,21 +1856,29 @@ Name | Type | Description | Notes **duration_gt** | **float**| | [optional] **duration_lte** | **float**| | [optional] **duration_lt** | **float**| | [optional] - **task_display_name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] + **task_display_name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_display_name_prefix_pattern`` parameter when possible. | [optional] + **task_display_name_prefix_pattern** | **str**| Prefix match on task display name: optional ``_task_display_property_value`` else ``task_id`` (same as ``coalesce``). Case-sensitive. Index-friendly alternative to ``task_display_name_pattern``. On large databases, combine with ``dag_id_prefix_pattern`` (or a specific Dag in the path) so ``(dag_id, task_id, ...)`` indexes apply. Use ``|`` for OR. Use ``~`` to match all. Trailing non-alphanumeric characters in the term are stripped before matching so the range scan stays index-compatible under locale-aware collations. | [optional] **task_group_id** | **str**| Filter by exact task group ID. Returns all tasks within the specified task group. | [optional] - **dag_id_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] - **run_id_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] + **dag_id_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_id_prefix_pattern`` parameter when possible. | [optional] + **dag_id_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] + **run_id_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible. | [optional] + **run_id_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] **state** | [**List[str]**](str.md)| | [optional] **pool** | [**List[str]**](str.md)| | [optional] - **pool_name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] + **pool_name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``pool_name_prefix_pattern`` parameter when possible. | [optional] + **pool_name_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] **queue** | [**List[str]**](str.md)| | [optional] - **queue_name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] + **queue_name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``queue_name_prefix_pattern`` parameter when possible. | [optional] + **queue_name_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] **executor** | [**List[str]**](str.md)| | [optional] **version_number** | [**List[int]**](int.md)| | [optional] **try_number** | [**List[int]**](int.md)| | [optional] **operator** | [**List[str]**](str.md)| | [optional] - **operator_name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] + **operator_name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``operator_name_prefix_pattern`` parameter when possible. | [optional] + **operator_name_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] **map_index** | [**List[int]**](int.md)| | [optional] + **rendered_map_index_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``rendered_map_index_prefix_pattern`` parameter when possible. | [optional] + **rendered_map_index_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] **limit** | **int**| | [optional] [default to 50] **offset** | **int**| | [optional] [default to 0] **order_by** | [**List[str]**](str.md)| Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, state, duration, start_date, end_date, map_index, try_number, logical_date, run_after, data_interval_start, data_interval_end, rendered_map_index, operator, logical_date, run_after, data_interval_start, data_interval_end` | [optional] [default to ["map_index"]] diff --git a/docs/TaskInstanceCollectionResponse.md b/docs/TaskInstanceCollectionResponse.md index daca357a..e95e26c9 100644 --- a/docs/TaskInstanceCollectionResponse.md +++ b/docs/TaskInstanceCollectionResponse.md @@ -1,13 +1,15 @@ # TaskInstanceCollectionResponse -Task Instance Collection serializer for responses. +Task instance collection response supporting both offset and cursor pagination. A single flat model is used instead of a discriminated union (``Annotated[Offset | Cursor, Field(discriminator=...)]``) because the OpenAPI ``oneOf`` + ``discriminator`` construct is not handled correctly by ``@hey-api/openapi-ts`` / ``@7nohe/openapi-react-query-codegen``: return types degrade to ``unknown`` in JSDoc and can produce incorrect TypeScript types (see hey-api/openapi-ts#1613, #3270). ## Properties Name | Type | Description | Notes ------------ | ------------- | ------------- | ------------- +**next_cursor** | **str** | | [optional] +**previous_cursor** | **str** | | [optional] **task_instances** | [**List[TaskInstanceResponse]**](TaskInstanceResponse.md) | | -**total_entries** | **int** | | +**total_entries** | **int** | | [optional] ## Example diff --git a/docs/TaskInstancesInner.md b/docs/TaskInstancesInner.md new file mode 100644 index 00000000..5d60a972 --- /dev/null +++ b/docs/TaskInstancesInner.md @@ -0,0 +1,62 @@ +# TaskInstancesInner + + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**dag_display_name** | **str** | | +**dag_id** | **str** | | +**dag_run_id** | **str** | | +**dag_version** | [**DagVersionResponse**](DagVersionResponse.md) | | [optional] +**duration** | **float** | | [optional] +**end_date** | **datetime** | | [optional] +**executor** | **str** | | [optional] +**executor_config** | **str** | | +**hostname** | **str** | | [optional] +**id** | **UUID** | | +**logical_date** | **datetime** | | [optional] +**map_index** | **int** | | +**max_tries** | **int** | | +**note** | **str** | | [optional] +**operator** | **str** | | [optional] +**operator_name** | **str** | | [optional] +**pid** | **int** | | [optional] +**pool** | **str** | | +**pool_slots** | **int** | | +**priority_weight** | **int** | | [optional] +**queue** | **str** | | [optional] +**queued_when** | **datetime** | | [optional] +**rendered_fields** | **Dict[str, object]** | | [optional] +**rendered_map_index** | **str** | | [optional] +**run_after** | **datetime** | | +**scheduled_when** | **datetime** | | [optional] +**start_date** | **datetime** | | [optional] +**state** | [**TaskInstanceState**](TaskInstanceState.md) | | [optional] +**task_display_name** | **str** | | +**task_id** | **str** | | +**trigger** | [**TriggerResponse**](TriggerResponse.md) | | [optional] +**triggerer_job** | [**JobResponse**](JobResponse.md) | | [optional] +**try_number** | **int** | | +**unixname** | **str** | | [optional] + +## Example + +```python +from airflow_client.client.models.task_instances_inner import TaskInstancesInner + +# TODO update the JSON string below +json = "{}" +# create an instance of TaskInstancesInner from a JSON string +task_instances_inner_instance = TaskInstancesInner.from_json(json) +# print the JSON string representation of the object +print(TaskInstancesInner.to_json()) + +# convert the object into a dict +task_instances_inner_dict = task_instances_inner_instance.to_dict() +# create an instance of TaskInstancesInner from a dict +task_instances_inner_from_dict = TaskInstancesInner.from_dict(task_instances_inner_dict) +``` +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/docs/TriggerDAGRunPostBody.md b/docs/TriggerDAGRunPostBody.md index 1ff157e3..03cde0af 100644 --- a/docs/TriggerDAGRunPostBody.md +++ b/docs/TriggerDAGRunPostBody.md @@ -1,6 +1,6 @@ # TriggerDAGRunPostBody -Trigger DAG Run Serializer for POST body. +Trigger Dag Run Serializer for POST body. ## Properties diff --git a/docs/VariableApi.md b/docs/VariableApi.md index 6354be5c..075a9db8 100644 --- a/docs/VariableApi.md +++ b/docs/VariableApi.md @@ -265,7 +265,7 @@ Name | Type | Description | Notes [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) # **get_variables** -> VariableCollectionResponse get_variables(limit=limit, offset=offset, order_by=order_by, variable_key_pattern=variable_key_pattern) +> VariableCollectionResponse get_variables(limit=limit, offset=offset, order_by=order_by, variable_key_pattern=variable_key_pattern, variable_key_prefix_pattern=variable_key_prefix_pattern) Get Variables @@ -307,11 +307,12 @@ with airflow_client.client.ApiClient(configuration) as api_client: limit = 50 # int | (optional) (default to 50) offset = 0 # int | (optional) (default to 0) order_by = ["id"] # List[str] | Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `key, id, _val, description, is_encrypted, team_name` (optional) (default to ["id"]) - variable_key_pattern = 'variable_key_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) + variable_key_pattern = 'variable_key_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``variable_key_prefix_pattern`` parameter when possible. (optional) + variable_key_prefix_pattern = 'variable_key_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) try: # Get Variables - api_response = api_instance.get_variables(limit=limit, offset=offset, order_by=order_by, variable_key_pattern=variable_key_pattern) + api_response = api_instance.get_variables(limit=limit, offset=offset, order_by=order_by, variable_key_pattern=variable_key_pattern, variable_key_prefix_pattern=variable_key_prefix_pattern) print("The response of VariableApi->get_variables:\n") pprint(api_response) except Exception as e: @@ -328,7 +329,8 @@ Name | Type | Description | Notes **limit** | **int**| | [optional] [default to 50] **offset** | **int**| | [optional] [default to 0] **order_by** | [**List[str]**](str.md)| Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `key, id, _val, description, is_encrypted, team_name` | [optional] [default to ["id"]] - **variable_key_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] + **variable_key_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``variable_key_prefix_pattern`` parameter when possible. | [optional] + **variable_key_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] ### Return type diff --git a/docs/XComApi.md b/docs/XComApi.md index 52154dfd..36020704 100644 --- a/docs/XComApi.md +++ b/docs/XComApi.md @@ -196,13 +196,13 @@ void (empty response body) [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) # **get_xcom_entries** -> XComCollectionResponse get_xcom_entries(dag_id, dag_run_id, task_id, xcom_key=xcom_key, map_index=map_index, limit=limit, offset=offset, xcom_key_pattern=xcom_key_pattern, dag_display_name_pattern=dag_display_name_pattern, run_id_pattern=run_id_pattern, task_id_pattern=task_id_pattern, map_index_filter=map_index_filter, logical_date_gte=logical_date_gte, logical_date_gt=logical_date_gt, logical_date_lte=logical_date_lte, logical_date_lt=logical_date_lt, run_after_gte=run_after_gte, run_after_gt=run_after_gt, run_after_lte=run_after_lte, run_after_lt=run_after_lt) +> XComCollectionResponse get_xcom_entries(dag_id, dag_run_id, task_id, xcom_key=xcom_key, map_index=map_index, limit=limit, offset=offset, xcom_key_pattern=xcom_key_pattern, xcom_key_prefix_pattern=xcom_key_prefix_pattern, dag_display_name_pattern=dag_display_name_pattern, dag_display_name_prefix_pattern=dag_display_name_prefix_pattern, run_id_pattern=run_id_pattern, run_id_prefix_pattern=run_id_prefix_pattern, task_id_pattern=task_id_pattern, task_id_prefix_pattern=task_id_prefix_pattern, map_index_filter=map_index_filter, logical_date_gte=logical_date_gte, logical_date_gt=logical_date_gt, logical_date_lte=logical_date_lte, logical_date_lt=logical_date_lt, run_after_gte=run_after_gte, run_after_gt=run_after_gt, run_after_lte=run_after_lte, run_after_lt=run_after_lt, order_by=order_by) Get Xcom Entries Get all XCom entries. -This endpoint allows specifying `~` as the dag_id, dag_run_id, task_id to retrieve XCom entries for all DAGs. +This endpoint allows specifying `~` as the dag_id, dag_run_id, task_id to retrieve XCom entries for all Dags. ### Example @@ -244,10 +244,14 @@ with airflow_client.client.ApiClient(configuration) as api_client: map_index = 56 # int | (optional) limit = 50 # int | (optional) (default to 50) offset = 0 # int | (optional) (default to 0) - xcom_key_pattern = 'xcom_key_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) - dag_display_name_pattern = 'dag_display_name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) - run_id_pattern = 'run_id_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) - task_id_pattern = 'task_id_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. (optional) + xcom_key_pattern = 'xcom_key_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``xcom_key_prefix_pattern`` parameter when possible. (optional) + xcom_key_prefix_pattern = 'xcom_key_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) + dag_display_name_pattern = 'dag_display_name_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_display_name_prefix_pattern`` parameter when possible. (optional) + dag_display_name_prefix_pattern = 'dag_display_name_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) + run_id_pattern = 'run_id_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible. (optional) + run_id_prefix_pattern = 'run_id_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) + task_id_pattern = 'task_id_pattern_example' # str | SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_id_prefix_pattern`` parameter when possible. (optional) + task_id_prefix_pattern = 'task_id_prefix_pattern_example' # str | Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. (optional) map_index_filter = 56 # int | (optional) logical_date_gte = '2013-10-20T19:20:30+01:00' # datetime | (optional) logical_date_gt = '2013-10-20T19:20:30+01:00' # datetime | (optional) @@ -257,10 +261,11 @@ with airflow_client.client.ApiClient(configuration) as api_client: run_after_gt = '2013-10-20T19:20:30+01:00' # datetime | (optional) run_after_lte = '2013-10-20T19:20:30+01:00' # datetime | (optional) run_after_lt = '2013-10-20T19:20:30+01:00' # datetime | (optional) + order_by = ["dag_id","task_id","run_id","map_index","key"] # List[str] | Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `key, dag_id, run_id, task_id, map_index, timestamp, run_after` (optional) (default to ["dag_id","task_id","run_id","map_index","key"]) try: # Get Xcom Entries - api_response = api_instance.get_xcom_entries(dag_id, dag_run_id, task_id, xcom_key=xcom_key, map_index=map_index, limit=limit, offset=offset, xcom_key_pattern=xcom_key_pattern, dag_display_name_pattern=dag_display_name_pattern, run_id_pattern=run_id_pattern, task_id_pattern=task_id_pattern, map_index_filter=map_index_filter, logical_date_gte=logical_date_gte, logical_date_gt=logical_date_gt, logical_date_lte=logical_date_lte, logical_date_lt=logical_date_lt, run_after_gte=run_after_gte, run_after_gt=run_after_gt, run_after_lte=run_after_lte, run_after_lt=run_after_lt) + api_response = api_instance.get_xcom_entries(dag_id, dag_run_id, task_id, xcom_key=xcom_key, map_index=map_index, limit=limit, offset=offset, xcom_key_pattern=xcom_key_pattern, xcom_key_prefix_pattern=xcom_key_prefix_pattern, dag_display_name_pattern=dag_display_name_pattern, dag_display_name_prefix_pattern=dag_display_name_prefix_pattern, run_id_pattern=run_id_pattern, run_id_prefix_pattern=run_id_prefix_pattern, task_id_pattern=task_id_pattern, task_id_prefix_pattern=task_id_prefix_pattern, map_index_filter=map_index_filter, logical_date_gte=logical_date_gte, logical_date_gt=logical_date_gt, logical_date_lte=logical_date_lte, logical_date_lt=logical_date_lt, run_after_gte=run_after_gte, run_after_gt=run_after_gt, run_after_lte=run_after_lte, run_after_lt=run_after_lt, order_by=order_by) print("The response of XComApi->get_xcom_entries:\n") pprint(api_response) except Exception as e: @@ -281,10 +286,14 @@ Name | Type | Description | Notes **map_index** | **int**| | [optional] **limit** | **int**| | [optional] [default to 50] **offset** | **int**| | [optional] [default to 0] - **xcom_key_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] - **dag_display_name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] - **run_id_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] - **task_id_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. | [optional] + **xcom_key_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``xcom_key_prefix_pattern`` parameter when possible. | [optional] + **xcom_key_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] + **dag_display_name_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``dag_display_name_prefix_pattern`` parameter when possible. | [optional] + **dag_display_name_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] + **run_id_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``run_id_prefix_pattern`` parameter when possible. | [optional] + **run_id_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] + **task_id_pattern** | **str**| SQL LIKE expression — use `%` / `_` wildcards (e.g. `%customer_%`). or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions are **not** supported. **Performance note:** this full-match pattern is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database from using B-tree indexes, which can be very slow on large tables. Prefer the equivalent ``task_id_prefix_pattern`` parameter when possible. | [optional] + **task_id_prefix_pattern** | **str**| Prefix match — returns items whose value starts with the given string (case-sensitive, index-friendly). Use the pipe `|` operator for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric characters in the prefix are stripped before matching so the range scan stays index-compatible under locale-aware collations — e.g. `test_` effectively matches items starting with `test`, and `s3://` matches items starting with `s3`. | [optional] **map_index_filter** | **int**| | [optional] **logical_date_gte** | **datetime**| | [optional] **logical_date_gt** | **datetime**| | [optional] @@ -294,6 +303,7 @@ Name | Type | Description | Notes **run_after_gt** | **datetime**| | [optional] **run_after_lte** | **datetime**| | [optional] **run_after_lt** | **datetime**| | [optional] + **order_by** | [**List[str]**](str.md)| Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `key, dag_id, run_id, task_id, map_index, timestamp, run_after` | [optional] [default to ["dag_id","task_id","run_id","map_index","key"]] ### Return type diff --git a/pyproject.toml b/pyproject.toml index ed91dbb3..449bf808 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -18,11 +18,11 @@ [build-system] requires = [ "hatchling==1.29.0", - "packaging==26.1", - "pathspec==1.0.4", + "packaging==26.2", + "pathspec==1.1.1", "pluggy==1.6.0", "tomli==2.4.1; python_version < '3.11'", - "trove-classifiers==2026.1.14.14", + "trove-classifiers==2026.5.20.19", ] build-backend = "hatchling.build" diff --git a/spec/v2.yaml b/spec/v2.yaml index d4fe7bdb..198a6c6b 100644 --- a/spec/v2.yaml +++ b/spec/v2.yaml @@ -271,8 +271,7 @@ components: type: string dag_run_conf: additionalProperties: true - default: {} - title: Dag Run Conf + nullable: true type: object from_date: format: date-time @@ -834,6 +833,25 @@ components: - entities title: BulkUpdateAction[VariableBody] type: object + ClearTaskInstanceCollectionResponse: + description: Response for clear dag run dry run, which may contain new tasks + without full TaskInstance data. + properties: + task_instances: + items: + oneOf: + - $ref: '#/components/schemas/TaskInstanceResponse' + - $ref: '#/components/schemas/NewTaskResponse' + title: Task Instances + type: array + total_entries: + title: Total Entries + type: integer + required: + - task_instances + - total_entries + title: ClearTaskInstanceCollectionResponse + type: object ClearTaskInstancesBody: additionalProperties: false description: Request body for Clear Task Instances endpoint. @@ -1086,7 +1104,7 @@ components: title: CreateAssetEventsBody type: object DAGCollectionResponse: - description: DAG Collection serializer for responses. + description: Dag Collection serializer for responses. properties: dags: items: @@ -1102,7 +1120,7 @@ components: title: DAGCollectionResponse type: object DAGDetailsResponse: - description: Specific serializer for DAG Details responses. + description: Specific serializer for Dag Details responses. properties: active_runs_count: default: 0 @@ -1306,7 +1324,7 @@ components: title: DAGPatchBody type: object DAGResponse: - description: DAG serializer for responses. + description: Dag serializer for responses. properties: allowed_run_types: items: @@ -1424,7 +1442,7 @@ components: type: object DAGRunClearBody: additionalProperties: false - description: DAG Run serializer for clear endpoint body. + description: Dag Run serializer for clear endpoint body. properties: dry_run: default: true @@ -1434,6 +1452,12 @@ components: default: false title: Only Failed type: boolean + only_new: + default: false + description: Only queue newly added tasks in the latest DAG version without + clearing existing tasks. + title: Only New + type: boolean run_on_latest_version: default: false description: (Experimental) Run on the latest bundle version of the Dag @@ -1443,24 +1467,43 @@ components: title: DAGRunClearBody type: object DAGRunCollectionResponse: - description: DAG Run Collection serializer for responses. + description: 'Dag Run collection response supporting both offset and cursor + pagination. + + + A single flat model is used instead of a discriminated union + + (``Annotated[Offset | Cursor, Field(discriminator=...)]``) because + + the OpenAPI ``oneOf`` + ``discriminator`` construct is not handled + + correctly by ``@hey-api/openapi-ts`` / ``@7nohe/openapi-react-query-codegen``: + + return types degrade to ``unknown`` in JSDoc and can produce + + incorrect TypeScript types (see hey-api/openapi-ts#1613, #3270).' properties: dag_runs: items: $ref: '#/components/schemas/DAGRunResponse' title: Dag Runs type: array + next_cursor: + nullable: true + type: string + previous_cursor: + nullable: true + type: string total_entries: - title: Total Entries + nullable: true type: integer required: - dag_runs - - total_entries title: DAGRunCollectionResponse type: object DAGRunPatchBody: additionalProperties: false - description: DAG Run Serializer for PATCH requests. + description: Dag Run Serializer for PATCH requests. properties: note: maxLength: 1000 @@ -1472,7 +1515,7 @@ components: title: DAGRunPatchBody type: object DAGRunPatchStates: - description: Enum for DAG Run states when updating a DAG Run. + description: Enum for Dag Run states when updating a Dag Run. enum: - queued - success @@ -1480,7 +1523,7 @@ components: title: DAGRunPatchStates type: string DAGRunResponse: - description: DAG Run serializer for responses. + description: Dag Run serializer for responses. properties: bundle_version: nullable: true @@ -1566,7 +1609,7 @@ components: type: object DAGRunsBatchBody: additionalProperties: false - description: List DAG Runs body for batch endpoint. + description: List Dag Runs body for batch endpoint. properties: conf_contains: nullable: true @@ -1675,7 +1718,7 @@ components: title: DAGRunsBatchBody type: object DAGSourceResponse: - description: DAG Source serializer for responses. + description: Dag Source serializer for responses. properties: content: nullable: true @@ -1695,7 +1738,7 @@ components: title: DAGSourceResponse type: object DAGTagCollectionResponse: - description: DAG Tags Collection serializer for responses. + description: Dag Tags Collection serializer for responses. properties: tags: items: @@ -1711,7 +1754,7 @@ components: title: DAGTagCollectionResponse type: object DAGVersionCollectionResponse: - description: DAG Version Collection serializer for responses. + description: Dag Version Collection serializer for responses. properties: dag_versions: items: @@ -1727,7 +1770,7 @@ components: title: DAGVersionCollectionResponse type: object DAGWarningCollectionResponse: - description: DAG warning collection serializer for responses. + description: Dag warning collection serializer for responses. properties: dag_warnings: items: @@ -1743,7 +1786,7 @@ components: title: DAGWarningCollectionResponse type: object DAGWarningResponse: - description: DAG Warning serializer for responses. + description: Dag Warning serializer for responses. properties: dag_display_name: title: Dag Display Name @@ -1864,7 +1907,7 @@ components: type: string DagScheduleAssetReference: additionalProperties: false - description: DAG schedule reference serializer for assets. + description: Dag schedule reference serializer for assets. properties: created_at: format: date-time @@ -1884,7 +1927,7 @@ components: title: DagScheduleAssetReference type: object DagStatsCollectionResponse: - description: DAG Stats Collection serializer for responses. + description: Dag Stats Collection serializer for responses. properties: dags: items: @@ -1900,7 +1943,7 @@ components: title: DagStatsCollectionResponse type: object DagStatsResponse: - description: DAG Stats serializer for responses. + description: Dag Stats serializer for responses. properties: dag_display_name: title: Dag Display Name @@ -1933,7 +1976,7 @@ components: title: DagStatsStateResponse type: object DagTagResponse: - description: DAG Tag serializer for responses. + description: Dag Tag serializer for responses. properties: dag_display_name: title: Dag Display Name @@ -2575,6 +2618,21 @@ components: type: string title: MaterializeAssetBody type: object + NewTaskResponse: + description: Lightweight response for new tasks that don't have TaskInstances + yet. + properties: + task_display_name: + title: Task Display Name + type: string + task_id: + title: Task Id + type: string + required: + - task_id + - task_display_name + title: NewTaskResponse + type: object PatchTaskInstanceBody: additionalProperties: false description: Request body for Clear Task Instances endpoint. @@ -3079,19 +3137,38 @@ components: title: TaskInletAssetReference type: object TaskInstanceCollectionResponse: - description: Task Instance Collection serializer for responses. + description: 'Task instance collection response supporting both offset and cursor + pagination. + + + A single flat model is used instead of a discriminated union + + (``Annotated[Offset | Cursor, Field(discriminator=...)]``) because + + the OpenAPI ``oneOf`` + ``discriminator`` construct is not handled + + correctly by ``@hey-api/openapi-ts`` / ``@7nohe/openapi-react-query-codegen``: + + return types degrade to ``unknown`` in JSDoc and can produce + + incorrect TypeScript types (see hey-api/openapi-ts#1613, #3270).' properties: + next_cursor: + nullable: true + type: string + previous_cursor: + nullable: true + type: string task_instances: items: $ref: '#/components/schemas/TaskInstanceResponse' title: Task Instances type: array total_entries: - title: Total Entries + nullable: true type: integer required: - task_instances - - total_entries title: TaskInstanceCollectionResponse type: object TaskInstanceHistoryCollectionResponse: @@ -3661,7 +3738,7 @@ components: type: object TriggerDAGRunPostBody: additionalProperties: false - description: Trigger DAG Run Serializer for POST body. + description: Trigger Dag Run Serializer for POST body. properties: conf: additionalProperties: true @@ -4102,22 +4179,56 @@ paths: type: integer - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``name_prefix_pattern`` parameter when possible." in: query name: name_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: name_prefix_pattern + required: false + schema: + nullable: true + type: string - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``uri_prefix_pattern`` parameter when possible." in: query name: uri_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: uri_prefix_pattern + required: false + schema: + nullable: true + type: string - in: query name: dag_ids required: false @@ -4209,13 +4320,30 @@ paths: type: integer - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``name_prefix_pattern`` parameter when possible." in: query name: name_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: name_prefix_pattern + required: false + schema: + nullable: true + type: string - description: 'Attributes to order by, multi criteria sort is supported. Prefix with `-` for descending order. Supported attributes: `id, name`' in: query @@ -4383,13 +4511,30 @@ paths: type: integer - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``name_prefix_pattern`` parameter when possible." in: query name: name_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: name_prefix_pattern + required: false + schema: + nullable: true + type: string - in: query name: timestamp_gte required: false @@ -4551,7 +4696,7 @@ paths: - Asset /api/v2/assets/{asset_id}/materialize: post: - description: Materialize an asset by triggering a DAG run that produces it. + description: Materialize an asset by triggering a Dag run that produces it. operationId: materialize_asset parameters: - in: path @@ -5353,13 +5498,30 @@ paths: type: array - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``connection_id_prefix_pattern`` parameter when possible." in: query name: connection_id_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: connection_id_prefix_pattern + required: false + schema: + nullable: true + type: string responses: '200': content: @@ -5855,7 +6017,7 @@ paths: - DagStats /api/v2/dagTags: get: - description: Get all DAG tags. + description: Get all Dag tags. operationId: get_dag_tags parameters: - in: query @@ -5890,13 +6052,30 @@ paths: type: array - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``tag_name_prefix_pattern`` parameter when possible." in: query name: tag_name_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: tag_name_prefix_pattern + required: false + schema: + nullable: true + type: string responses: '200': content: @@ -5930,7 +6109,7 @@ paths: - DAG /api/v2/dagWarnings: get: - description: Get a list of DAG warnings. + description: Get a list of Dag warnings. operationId: list_dag_warnings parameters: - in: query @@ -6010,7 +6189,7 @@ paths: - DagWarning /api/v2/dags: get: - description: Get all DAGs. + description: Get all Dags. operationId: get_dags parameters: - in: query @@ -6056,22 +6235,56 @@ paths: type: array - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``dag_id_prefix_pattern`` parameter when possible." in: query name: dag_id_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: dag_id_prefix_pattern + required: false + schema: + nullable: true + type: string - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``dag_display_name_prefix_pattern`` parameter when possible." in: query name: dag_display_name_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: dag_display_name_prefix_pattern + required: false + schema: + nullable: true + type: string - in: query name: exclude_stale required: false @@ -6251,7 +6464,16 @@ paths: tags: - DAG patch: - description: Patch multiple DAGs. + description: 'Patch multiple Dags. + + + If neither `dag_id_pattern` nor `dag_id_prefix_pattern` is provided, no Dags + will be + + matched regardless of other filters. To match all Dags, pass a wildcard value + such as + + `~` or `%` for `dag_id_pattern`.' operationId: patch_dags parameters: - in: query @@ -6305,13 +6527,30 @@ paths: type: array - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``dag_id_prefix_pattern`` parameter when possible." in: query name: dag_id_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: dag_id_prefix_pattern + required: false + schema: + nullable: true + type: string - in: query name: exclude_stale required: false @@ -6376,7 +6615,7 @@ paths: - DAG /api/v2/dags/{dag_id}: delete: - description: Delete the specific DAG. + description: Delete the specific Dag. operationId: delete_dag parameters: - in: path @@ -6428,7 +6667,7 @@ paths: tags: - DAG get: - description: Get basic information about a DAG. + description: Get basic information about a Dag. operationId: get_dag parameters: - in: path @@ -6481,7 +6720,7 @@ paths: tags: - DAG patch: - description: Patch the specific DAG. + description: Patch the specific Dag. operationId: patch_dag parameters: - in: path @@ -6603,7 +6842,7 @@ paths: tags: - Asset get: - description: Get queued asset events for a DAG. + description: Get queued asset events for a Dag. operationId: get_dag_asset_queued_events parameters: - in: path @@ -6651,7 +6890,7 @@ paths: - Asset /api/v2/dags/{dag_id}/assets/{asset_id}/queuedEvents: delete: - description: Delete a queued asset event for a DAG. + description: Delete a queued asset event for a Dag. operationId: delete_dag_asset_queued_event parameters: - in: path @@ -6712,7 +6951,7 @@ paths: tags: - Asset get: - description: Get a queued asset event for a DAG. + description: Get a queued asset event for a Dag. operationId: get_dag_asset_queued_event parameters: - in: path @@ -6832,11 +7071,29 @@ paths: - Task Instance /api/v2/dags/{dag_id}/dagRuns: get: - description: 'Get all DAG Runs. + description: 'Get all Dag Runs. This endpoint allows specifying `~` as the dag_id to retrieve Dag Runs for - all DAGs.' + all Dags. + + + Supports two pagination modes: + + + **Offset (default):** use `limit` and `offset` query parameters. Returns `total_entries`. + + + **Cursor:** pass `cursor` (empty string for the first page, then `next_cursor` + from the response). + + When `cursor` is provided, `offset` is ignored and `total_entries` is not + returned. + + ``next_cursor`` is ``null`` when there are no more pages; ``previous_cursor`` + is ``null`` + + on the first page.' operationId: get_dag_runs parameters: - in: path @@ -6845,6 +7102,15 @@ paths: schema: title: Dag Id type: string + - description: Cursor for keyset-based pagination. Pass an empty string for + the first page, then use ``next_cursor`` from the response. When ``cursor`` + is provided, ``offset`` is ignored. + in: query + name: cursor + required: false + schema: + nullable: true + type: string - in: query name: limit required: false @@ -7081,40 +7347,116 @@ paths: type: array - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``run_id_prefix_pattern`` parameter when possible." in: query name: run_id_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: run_id_prefix_pattern + required: false + schema: + nullable: true + type: string - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``triggering_user_name_prefix_pattern`` parameter when\ + \ possible." in: query name: triggering_user_name_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: triggering_user_name_prefix_pattern + required: false + schema: + nullable: true + type: string - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``dag_id_prefix_pattern`` parameter when possible." in: query name: dag_id_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: dag_id_prefix_pattern + required: false + schema: + nullable: true + type: string - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``partition_key_prefix_pattern`` parameter when possible." in: query name: partition_key_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: partition_key_prefix_pattern + required: false + schema: + nullable: true + type: string + - description: Filter by consuming asset name or URI using pattern matching + in: query + name: consuming_asset_pattern + required: false + schema: + nullable: true + type: string responses: '200': content: @@ -7153,7 +7495,7 @@ paths: tags: - DagRun post: - description: Trigger a DAG. + description: Trigger a Dag. operationId: trigger_dag_run parameters: - in: path @@ -7218,7 +7560,7 @@ paths: - DagRun /api/v2/dags/{dag_id}/dagRuns/list: post: - description: Get a list of DAG Runs. + description: Get a list of Dag Runs. operationId: get_list_dag_runs_batch parameters: - in: path @@ -7273,7 +7615,7 @@ paths: - DagRun /api/v2/dags/{dag_id}/dagRuns/{dag_run_id}: delete: - description: Delete a DAG Run entry. + description: Delete a Dag Run entry. operationId: delete_dag_run parameters: - in: path @@ -7380,7 +7722,7 @@ paths: tags: - DagRun patch: - description: Modify a DAG Run. + description: Modify a Dag Run. operationId: patch_dag_run parameters: - in: path @@ -7480,7 +7822,7 @@ paths: application/json: schema: anyOf: - - $ref: '#/components/schemas/TaskInstanceCollectionResponse' + - $ref: '#/components/schemas/ClearTaskInstanceCollectionResponse' - $ref: '#/components/schemas/DAGRunResponse' title: Response Clear Dag Run description: Successful Response @@ -7569,13 +7911,30 @@ paths: type: array - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``dag_id_prefix_pattern`` parameter when possible." in: query name: dag_id_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: dag_id_prefix_pattern + required: false + schema: + nullable: true + type: string - in: query name: task_id required: false @@ -7584,13 +7943,30 @@ paths: type: string - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``task_id_prefix_pattern`` parameter when possible." in: query name: task_id_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: task_id_prefix_pattern + required: false + schema: + nullable: true + type: string - in: query name: map_index required: false @@ -7629,7 +8005,10 @@ paths: type: array - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``subject_search`` parameter when possible." in: query name: subject_search required: false @@ -7638,7 +8017,10 @@ paths: type: string - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``body_search`` parameter when possible." in: query name: body_search required: false @@ -7709,10 +8091,27 @@ paths: description: 'Get list of task instances. - This endpoint allows specifying `~` as the dag_id, dag_run_id to retrieve - Task Instances for all DAGs + This endpoint allows specifying `~` as the dag_id, dag_run_id + + to retrieve task instances for all Dags and Dag runs. + + + Supports two pagination modes: + + + **Offset (default):** use `limit` and `offset` query parameters. Returns `total_entries`. - and DAG runs.' + + **Cursor:** pass `cursor` (empty string for the first page, then `next_cursor` + from the response). + + When `cursor` is provided, `offset` is ignored and `total_entries` is not + returned. + + ``next_cursor`` is ``null`` when there are no more pages; ``previous_cursor`` + is ``null`` + + on the first page.' operationId: get_task_instances parameters: - in: path @@ -7727,6 +8126,15 @@ paths: schema: title: Dag Run Id type: string + - description: Cursor for keyset-based pagination. Pass an empty string for + the first page, then use ``next_cursor`` from the response. When ``cursor`` + is provided, ``offset`` is ignored. + in: query + name: cursor + required: false + schema: + nullable: true + type: string - in: query name: task_id required: false @@ -7899,13 +8307,29 @@ paths: type: number - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``task_display_name_prefix_pattern`` parameter when possible." in: query name: task_display_name_pattern required: false schema: nullable: true type: string + - description: 'Prefix match on task display name: optional ``_task_display_property_value`` + else ``task_id`` (same as ``coalesce``). Case-sensitive. Index-friendly + alternative to ``task_display_name_pattern``. On large databases, combine + with ``dag_id_prefix_pattern`` (or a specific Dag in the path) so ``(dag_id, + task_id, ...)`` indexes apply. Use ``|`` for OR. Use ``~`` to match all. + Trailing non-alphanumeric characters in the term are stripped before matching + so the range scan stays index-compatible under locale-aware collations.' + in: query + name: task_display_name_prefix_pattern + required: false + schema: + nullable: true + type: string - description: Filter by exact task group ID. Returns all tasks within the specified task group. in: query @@ -7916,22 +8340,56 @@ paths: type: string - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``dag_id_prefix_pattern`` parameter when possible." in: query name: dag_id_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: dag_id_prefix_pattern + required: false + schema: + nullable: true + type: string - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``run_id_prefix_pattern`` parameter when possible." in: query name: run_id_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: run_id_prefix_pattern + required: false + schema: + nullable: true + type: string - in: query name: state required: false @@ -7950,13 +8408,30 @@ paths: type: array - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``pool_name_prefix_pattern`` parameter when possible." in: query name: pool_name_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: pool_name_prefix_pattern + required: false + schema: + nullable: true + type: string - in: query name: queue required: false @@ -7967,13 +8442,30 @@ paths: type: array - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``queue_name_prefix_pattern`` parameter when possible." in: query name: queue_name_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: queue_name_prefix_pattern + required: false + schema: + nullable: true + type: string - in: query name: executor required: false @@ -8008,13 +8500,30 @@ paths: type: array - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``operator_name_prefix_pattern`` parameter when possible." in: query name: operator_name_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: operator_name_prefix_pattern + required: false + schema: + nullable: true + type: string - in: query name: map_index required: false @@ -8023,6 +8532,32 @@ paths: type: integer title: Map Index type: array + - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ + \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``rendered_map_index_prefix_pattern`` parameter when possible." + in: query + name: rendered_map_index_pattern + required: false + schema: + nullable: true + type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: rendered_map_index_prefix_pattern + required: false + schema: + nullable: true + type: string - in: query name: limit required: false @@ -8696,6 +9231,12 @@ paths: default: -1 title: Map Index type: integer + - in: query + name: try_number + required: false + schema: + nullable: true + type: integer responses: '200': content: @@ -8939,13 +9480,30 @@ paths: type: array - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``pool_name_prefix_pattern`` parameter when possible." in: query name: pool_name_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: pool_name_prefix_pattern + required: false + schema: + nullable: true + type: string - in: query name: queue required: false @@ -8956,13 +9514,30 @@ paths: type: array - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``queue_name_prefix_pattern`` parameter when possible." in: query name: queue_name_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: queue_name_prefix_pattern + required: false + schema: + nullable: true + type: string - in: query name: executor required: false @@ -8997,13 +9572,30 @@ paths: type: array - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``operator_name_prefix_pattern`` parameter when possible." in: query name: operator_name_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: operator_name_prefix_pattern + required: false + schema: + nullable: true + type: string - in: query name: map_index required: false @@ -9012,6 +9604,32 @@ paths: type: integer title: Map Index type: array + - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ + \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``rendered_map_index_prefix_pattern`` parameter when possible." + in: query + name: rendered_map_index_pattern + required: false + schema: + nullable: true + type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: rendered_map_index_prefix_pattern + required: false + schema: + nullable: true + type: string - in: query name: limit required: false @@ -9337,7 +9955,7 @@ paths: This endpoint allows specifying `~` as the dag_id, dag_run_id, task_id to - retrieve XCom entries for all DAGs.' + retrieve XCom entries for all Dags.' operationId: get_xcom_entries parameters: - in: path @@ -9389,40 +10007,108 @@ paths: type: integer - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``xcom_key_prefix_pattern`` parameter when possible." in: query name: xcom_key_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: xcom_key_prefix_pattern + required: false + schema: + nullable: true + type: string - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``dag_display_name_prefix_pattern`` parameter when possible." in: query name: dag_display_name_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: dag_display_name_prefix_pattern + required: false + schema: + nullable: true + type: string - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``run_id_prefix_pattern`` parameter when possible." in: query name: run_id_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: run_id_prefix_pattern + required: false + schema: + nullable: true + type: string - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``task_id_prefix_pattern`` parameter when possible." in: query name: task_id_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: task_id_prefix_pattern + required: false + schema: + nullable: true + type: string - in: query name: map_index_filter required: false @@ -9485,6 +10171,26 @@ paths: format: date-time nullable: true type: string + - description: 'Attributes to order by, multi criteria sort is supported. Prefix + with `-` for descending order. Supported attributes: `key, dag_id, run_id, + task_id, map_index, timestamp, run_after`' + in: query + name: order_by + required: false + schema: + default: + - dag_id + - task_id + - run_id + - map_index + - key + description: 'Attributes to order by, multi criteria sort is supported. + Prefix with `-` for descending order. Supported attributes: `key, dag_id, + run_id, task_id, map_index, timestamp, run_after`' + items: + type: string + title: Order By + type: array responses: '200': content: @@ -10567,7 +11273,7 @@ paths: get: description: "\U0001F6A7 This is an experimental endpoint and may change or\ \ be removed without notice.Successful response are streamed as newline-delimited\ - \ JSON (NDJSON). Each line is a JSON object representing the DAG run state." + \ JSON (NDJSON). Each line is a JSON object representing the Dag run state." operationId: wait_dag_run_until_finished parameters: - in: path @@ -10648,11 +11354,11 @@ paths: - experimental /api/v2/dags/{dag_id}/dagVersions: get: - description: 'Get all DAG Versions. + description: 'Get all Dag Versions. - This endpoint allows specifying `~` as the dag_id to retrieve DAG Versions - for all DAGs.' + This endpoint allows specifying `~` as the dag_id to retrieve Dag Versions + for all Dags.' operationId: get_dag_versions parameters: - in: path @@ -10804,7 +11510,7 @@ paths: - DagVersion /api/v2/dags/{dag_id}/details: get: - description: Get details of DAG. + description: Get details of Dag. operationId: get_dag_details parameters: - in: path @@ -10858,7 +11564,7 @@ paths: - DAG /api/v2/dags/{dag_id}/favorite: post: - description: Mark the DAG as favorite. + description: Mark the Dag as favorite. operationId: favorite_dag parameters: - in: path @@ -10902,7 +11608,7 @@ paths: - DAG /api/v2/dags/{dag_id}/tasks: get: - description: Get tasks for DAG. + description: Get tasks for Dag. operationId: get_tasks parameters: - in: path @@ -11022,7 +11728,7 @@ paths: - Task /api/v2/dags/{dag_id}/unfavorite: post: - description: Unmark the DAG as favorite. + description: Unmark the Dag as favorite. operationId: unfavorite_dag parameters: - in: path @@ -11181,7 +11887,10 @@ paths: type: string - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``dag_id_prefix_pattern`` parameter when possible." in: query name: dag_id_pattern required: false @@ -11190,7 +11899,10 @@ paths: type: string - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``task_id_prefix_pattern`` parameter when possible." in: query name: task_id_pattern required: false @@ -11199,7 +11911,10 @@ paths: type: string - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``run_id_prefix_pattern`` parameter when possible." in: query name: run_id_pattern required: false @@ -11208,7 +11923,10 @@ paths: type: string - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``owner_prefix_pattern`` parameter when possible." in: query name: owner_pattern required: false @@ -11217,13 +11935,86 @@ paths: type: string - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``event_prefix_pattern`` parameter when possible." in: query name: event_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: dag_id_prefix_pattern + required: false + schema: + nullable: true + type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: task_id_prefix_pattern + required: false + schema: + nullable: true + type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: run_id_prefix_pattern + required: false + schema: + nullable: true + type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: owner_prefix_pattern + required: false + schema: + nullable: true + type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: event_prefix_pattern + required: false + schema: + nullable: true + type: string responses: '200': content: @@ -11341,13 +12132,30 @@ paths: type: array - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``filename_prefix_pattern`` parameter when possible." in: query name: filename_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: filename_prefix_pattern + required: false + schema: + nullable: true + type: string responses: '200': content: @@ -11604,7 +12412,7 @@ paths: - Monitor /api/v2/parseDagFile/{file_token}: put: - description: Request re-parsing a DAG file. + description: Request re-parsing a Dag file. operationId: reparse_dag_file parameters: - in: path @@ -11766,13 +12574,30 @@ paths: type: array - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``pool_name_prefix_pattern`` parameter when possible." in: query name: pool_name_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: pool_name_prefix_pattern + required: false + schema: + nullable: true + type: string responses: '200': content: @@ -12151,13 +12976,30 @@ paths: type: array - description: "SQL LIKE expression \u2014 use `%` / `_` wildcards (e.g. `%customer_%`).\ \ or the pipe `|` operator for OR logic (e.g. `dag1 | dag2`). Regular expressions\ - \ are **not** supported." + \ are **not** supported. \n\n**Performance note:** this full-match pattern\ + \ is evaluated as ``ILIKE '%term%'`` and most of the time prevents the database\ + \ from using B-tree indexes, which can be very slow on large tables. Prefer\ + \ the equivalent ``variable_key_prefix_pattern`` parameter when possible." in: query name: variable_key_pattern required: false schema: nullable: true type: string + - description: "Prefix match \u2014 returns items whose value starts with the\ + \ given string (case-sensitive, index-friendly). Use the pipe `|` operator\ + \ for OR logic (e.g. `dag1|dag2`). Use `~` to match all. Wildcard characters\ + \ (`%`, `_`) are treated as literal characters. Trailing non-alphanumeric\ + \ characters in the prefix are stripped before matching so the range scan\ + \ stays index-compatible under locale-aware collations \u2014 e.g. `test_`\ + \ effectively matches items starting with `test`, and `s3://` matches items\ + \ starting with `s3`." + in: query + name: variable_key_prefix_pattern + required: false + schema: + nullable: true + type: string responses: '200': content: diff --git a/test/test_clear_task_instance_collection_response.py b/test/test_clear_task_instance_collection_response.py new file mode 100644 index 00000000..1524b955 --- /dev/null +++ b/test/test_clear_task_instance_collection_response.py @@ -0,0 +1,58 @@ +# coding: utf-8 + +""" + Airflow API + + Airflow API. All endpoints located under ``/api/v2`` can be used safely, are stable and backward compatible. Endpoints located under ``/ui`` are dedicated to the UI and are subject to breaking change depending on the need of the frontend. Users should not rely on those but use the public ones instead. + + The version of the OpenAPI document: 2 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import unittest + +from airflow_client.client.models.clear_task_instance_collection_response import ClearTaskInstanceCollectionResponse + +class TestClearTaskInstanceCollectionResponse(unittest.TestCase): + """ClearTaskInstanceCollectionResponse unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def make_instance(self, include_optional) -> ClearTaskInstanceCollectionResponse: + """Test ClearTaskInstanceCollectionResponse + include_optional is a boolean, when False only required + params are included, when True both required and + optional params are included """ + # uncomment below to create an instance of `ClearTaskInstanceCollectionResponse` + """ + model = ClearTaskInstanceCollectionResponse() + if include_optional: + return ClearTaskInstanceCollectionResponse( + task_instances = [ + null + ], + total_entries = 56 + ) + else: + return ClearTaskInstanceCollectionResponse( + task_instances = [ + null + ], + total_entries = 56, + ) + """ + + def testClearTaskInstanceCollectionResponse(self): + """Test ClearTaskInstanceCollectionResponse""" + # inst_req_only = self.make_instance(include_optional=False) + # inst_req_and_optional = self.make_instance(include_optional=True) + +if __name__ == '__main__': + unittest.main() diff --git a/test/test_dag_run_clear_body.py b/test/test_dag_run_clear_body.py index 669df417..8f29905f 100644 --- a/test/test_dag_run_clear_body.py +++ b/test/test_dag_run_clear_body.py @@ -37,6 +37,7 @@ def make_instance(self, include_optional) -> DAGRunClearBody: return DAGRunClearBody( dry_run = True, only_failed = True, + only_new = True, run_on_latest_version = True ) else: diff --git a/test/test_dag_run_collection_response.py b/test/test_dag_run_collection_response.py index 47792588..49807e46 100644 --- a/test/test_dag_run_collection_response.py +++ b/test/test_dag_run_collection_response.py @@ -69,6 +69,8 @@ def make_instance(self, include_optional) -> DAGRunCollectionResponse: triggered_by = null, triggering_user_name = '', ) ], + next_cursor = '', + previous_cursor = '', total_entries = 56 ) else: @@ -107,7 +109,6 @@ def make_instance(self, include_optional) -> DAGRunCollectionResponse: triggered_by = null, triggering_user_name = '', ) ], - total_entries = 56, ) """ diff --git a/test/test_new_task_response.py b/test/test_new_task_response.py new file mode 100644 index 00000000..6f6f2b0c --- /dev/null +++ b/test/test_new_task_response.py @@ -0,0 +1,54 @@ +# coding: utf-8 + +""" + Airflow API + + Airflow API. All endpoints located under ``/api/v2`` can be used safely, are stable and backward compatible. Endpoints located under ``/ui`` are dedicated to the UI and are subject to breaking change depending on the need of the frontend. Users should not rely on those but use the public ones instead. + + The version of the OpenAPI document: 2 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import unittest + +from airflow_client.client.models.new_task_response import NewTaskResponse + +class TestNewTaskResponse(unittest.TestCase): + """NewTaskResponse unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def make_instance(self, include_optional) -> NewTaskResponse: + """Test NewTaskResponse + include_optional is a boolean, when False only required + params are included, when True both required and + optional params are included """ + # uncomment below to create an instance of `NewTaskResponse` + """ + model = NewTaskResponse() + if include_optional: + return NewTaskResponse( + task_display_name = '', + task_id = '' + ) + else: + return NewTaskResponse( + task_display_name = '', + task_id = '', + ) + """ + + def testNewTaskResponse(self): + """Test NewTaskResponse""" + # inst_req_only = self.make_instance(include_optional=False) + # inst_req_and_optional = self.make_instance(include_optional=True) + +if __name__ == '__main__': + unittest.main() diff --git a/test/test_response_clear_dag_run.py b/test/test_response_clear_dag_run.py index 92a43625..73be45db 100644 --- a/test/test_response_clear_dag_run.py +++ b/test/test_response_clear_dag_run.py @@ -36,41 +36,7 @@ def make_instance(self, include_optional) -> ResponseClearDagRun: if include_optional: return ResponseClearDagRun( task_instances = [ - airflow_client.client.models.task_instance_response.TaskInstanceResponse( - dag_display_name = '', - dag_id = '', - dag_run_id = '', - dag_version = null, - duration = 1.337, - end_date = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), - executor = '', - executor_config = '', - hostname = '', - id = '', - logical_date = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), - map_index = 56, - max_tries = 56, - note = '', - operator = '', - operator_name = '', - pid = 56, - pool = '', - pool_slots = 56, - priority_weight = 56, - queue = '', - queued_when = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), - rendered_fields = { }, - rendered_map_index = '', - run_after = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), - scheduled_when = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), - start_date = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), - state = null, - task_display_name = '', - task_id = '', - trigger = null, - triggerer_job = null, - try_number = 56, - unixname = '', ) + null ], total_entries = 56, bundle_version = '', @@ -108,41 +74,7 @@ def make_instance(self, include_optional) -> ResponseClearDagRun: else: return ResponseClearDagRun( task_instances = [ - airflow_client.client.models.task_instance_response.TaskInstanceResponse( - dag_display_name = '', - dag_id = '', - dag_run_id = '', - dag_version = null, - duration = 1.337, - end_date = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), - executor = '', - executor_config = '', - hostname = '', - id = '', - logical_date = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), - map_index = 56, - max_tries = 56, - note = '', - operator = '', - operator_name = '', - pid = 56, - pool = '', - pool_slots = 56, - priority_weight = 56, - queue = '', - queued_when = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), - rendered_fields = { }, - rendered_map_index = '', - run_after = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), - scheduled_when = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), - start_date = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), - state = null, - task_display_name = '', - task_id = '', - trigger = null, - triggerer_job = null, - try_number = 56, - unixname = '', ) + null ], total_entries = 56, dag_display_name = '', diff --git a/test/test_task_instance_collection_response.py b/test/test_task_instance_collection_response.py index 0bb10b8f..20ef44ad 100644 --- a/test/test_task_instance_collection_response.py +++ b/test/test_task_instance_collection_response.py @@ -35,6 +35,8 @@ def make_instance(self, include_optional) -> TaskInstanceCollectionResponse: model = TaskInstanceCollectionResponse() if include_optional: return TaskInstanceCollectionResponse( + next_cursor = '', + previous_cursor = '', task_instances = [ airflow_client.client.models.task_instance_response.TaskInstanceResponse( dag_display_name = '', @@ -113,7 +115,6 @@ def make_instance(self, include_optional) -> TaskInstanceCollectionResponse: try_number = 56, unixname = '', ) ], - total_entries = 56, ) """ diff --git a/test/test_task_instances_inner.py b/test/test_task_instances_inner.py new file mode 100644 index 00000000..a9d16d3a --- /dev/null +++ b/test/test_task_instances_inner.py @@ -0,0 +1,122 @@ +# coding: utf-8 + +""" + Airflow API + + Airflow API. All endpoints located under ``/api/v2`` can be used safely, are stable and backward compatible. Endpoints located under ``/ui`` are dedicated to the UI and are subject to breaking change depending on the need of the frontend. Users should not rely on those but use the public ones instead. + + The version of the OpenAPI document: 2 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import unittest + +from airflow_client.client.models.task_instances_inner import TaskInstancesInner + +class TestTaskInstancesInner(unittest.TestCase): + """TaskInstancesInner unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def make_instance(self, include_optional) -> TaskInstancesInner: + """Test TaskInstancesInner + include_optional is a boolean, when False only required + params are included, when True both required and + optional params are included """ + # uncomment below to create an instance of `TaskInstancesInner` + """ + model = TaskInstancesInner() + if include_optional: + return TaskInstancesInner( + dag_display_name = '', + dag_id = '', + dag_run_id = '', + dag_version = airflow_client.client.models.dag_version_response.DagVersionResponse( + bundle_name = '', + bundle_url = '', + bundle_version = '', + created_at = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), + dag_display_name = '', + dag_id = '', + id = '', + version_number = 56, ), + duration = 1.337, + end_date = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), + executor = '', + executor_config = '', + hostname = '', + id = '', + logical_date = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), + map_index = 56, + max_tries = 56, + note = '', + operator = '', + operator_name = '', + pid = 56, + pool = '', + pool_slots = 56, + priority_weight = 56, + queue = '', + queued_when = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), + rendered_fields = { }, + rendered_map_index = '', + run_after = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), + scheduled_when = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), + start_date = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), + state = 'removed', + task_display_name = '', + task_id = '', + trigger = airflow_client.client.models.trigger_response.TriggerResponse( + classpath = '', + created_date = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), + id = 56, + kwargs = '', + queue = '', + triggerer_id = 56, ), + triggerer_job = airflow_client.client.models.job_response.JobResponse( + dag_display_name = '', + dag_id = '', + end_date = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), + executor_class = '', + hostname = '', + id = 56, + job_type = '', + latest_heartbeat = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), + start_date = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), + state = '', + unixname = '', ), + try_number = 56, + unixname = '' + ) + else: + return TaskInstancesInner( + dag_display_name = '', + dag_id = '', + dag_run_id = '', + executor_config = '', + id = '', + map_index = 56, + max_tries = 56, + pool = '', + pool_slots = 56, + run_after = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), + task_display_name = '', + task_id = '', + try_number = 56, + ) + """ + + def testTaskInstancesInner(self): + """Test TaskInstancesInner""" + # inst_req_only = self.make_instance(include_optional=False) + # inst_req_and_optional = self.make_instance(include_optional=True) + +if __name__ == '__main__': + unittest.main() diff --git a/version.txt b/version.txt index e4604e3a..be94e6f5 100644 --- a/version.txt +++ b/version.txt @@ -1 +1 @@ -3.2.1 +3.2.2