Update Python Client to 3.2.2rc1 (#155)
diff --git a/CHANGELOG.md b/CHANGELOG.md
index e482fad..c1418c8 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 50a6230..2913aac 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 2c4b3e9..5618976 100644
--- a/airflow_client/client/api/asset_api.py
+++ b/airflow_client/client/api/asset_api.py
@@ -647,7 +647,7 @@
) -> 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 @@
) -> 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 @@
) -> 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 @@
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 @@
: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 @@
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 @@
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 @@
: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 @@
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 @@
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 @@
: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 @@
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 @@
limit,
offset,
name_pattern,
+ name_prefix_pattern,
order_by,
_request_auth,
_content_type,
@@ -2060,6 +2073,10 @@
_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 @@
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 @@
: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 @@
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 @@
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 @@
: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 @@
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 @@
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 @@
: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 @@
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 @@
source_run_id,
source_map_index,
name_pattern,
+ name_prefix_pattern,
timestamp_gte,
timestamp_gt,
timestamp_lte,
@@ -2529,6 +2559,10 @@
_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 @@
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 @@
: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 @@
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 @@
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 @@
: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 @@
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 @@
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 @@
: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 @@
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 @@
limit,
offset,
name_pattern,
+ name_prefix_pattern,
uri_pattern,
+ uri_prefix_pattern,
dag_ids,
only_active,
order_by,
@@ -3233,10 +3293,18 @@
_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 @@
) -> 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 @@
) -> 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 @@
) -> 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 @@
) -> 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 @@
) -> 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 @@
) -> 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 @@
) -> 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 @@
) -> 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 @@
) -> 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 5fce05b..8b13f20 100644
--- a/airflow_client/client/api/connection_api.py
+++ b/airflow_client/client/api/connection_api.py
@@ -1134,7 +1134,8 @@
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 @@
: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 @@
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 @@
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 @@
: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 @@
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 @@
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 @@
: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 @@
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 @@
offset,
order_by,
connection_id_pattern,
+ connection_id_prefix_pattern,
_request_auth,
_content_type,
_headers,
@@ -1418,6 +1431,10 @@
_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 5848876..2458f28 100644
--- a/airflow_client/client/api/dag_api.py
+++ b/airflow_client/client/api/dag_api.py
@@ -62,7 +62,7 @@
) -> object:
"""Delete Dag
- Delete the specific DAG.
+ Delete the specific Dag.
:param dag_id: (required)
:type dag_id: str
@@ -134,7 +134,7 @@
) -> ApiResponse[object]:
"""Delete Dag
- Delete the specific DAG.
+ Delete the specific Dag.
:param dag_id: (required)
:type dag_id: str
@@ -206,7 +206,7 @@
) -> RESTResponseType:
"""Delete Dag
- Delete the specific DAG.
+ Delete the specific Dag.
:param dag_id: (required)
:type dag_id: str
@@ -339,7 +339,7 @@
) -> 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 @@
) -> 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 @@
) -> 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 @@
) -> 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 @@
) -> 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 @@
) -> 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 @@
) -> DAGDetailsResponse:
"""Get Dag Details
- Get details of DAG.
+ Get details of Dag.
:param dag_id: (required)
:type dag_id: str
@@ -962,7 +962,7 @@
) -> 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 @@
) -> RESTResponseType:
"""Get Dag Details
- Get details of DAG.
+ Get details of Dag.
:param dag_id: (required)
:type dag_id: str
@@ -1154,7 +1154,8 @@
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 @@
) -> DAGTagCollectionResponse:
"""Get Dag Tags
- Get all DAG tags.
+ Get all Dag tags.
:param limit:
:type limit: int
@@ -1178,8 +1179,10 @@
: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 @@
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 @@
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 @@
) -> ApiResponse[DAGTagCollectionResponse]:
"""Get Dag Tags
- Get all DAG tags.
+ Get all Dag tags.
:param limit:
:type limit: int
@@ -1260,8 +1265,10 @@
: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 @@
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 @@
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 @@
) -> RESTResponseType:
"""Get Dag Tags
- Get all DAG tags.
+ Get all Dag tags.
:param limit:
:type limit: int
@@ -1342,8 +1351,10 @@
: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 @@
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 @@
offset,
order_by,
tag_name_pattern,
+ tag_name_prefix_pattern,
_request_auth,
_content_type,
_headers,
@@ -1435,6 +1448,10 @@
_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 @@
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 @@
) -> DAGCollectionResponse:
"""Get Dags
- Get all DAGs.
+ Get all Dags.
:param limit:
:type limit: int
@@ -1530,10 +1549,14 @@
: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 @@
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 @@
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 @@
) -> ApiResponse[DAGCollectionResponse]:
"""Get Dags
- Get all DAGs.
+ Get all Dags.
:param limit:
:type limit: int
@@ -1704,10 +1731,14 @@
: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 @@
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 @@
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 @@
) -> RESTResponseType:
"""Get Dags
- Get all DAGs.
+ Get all Dags.
:param limit:
:type limit: int
@@ -1878,10 +1913,14 @@
: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 @@
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 @@
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 @@
_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 @@
) -> DAGResponse:
"""Patch Dag
- Patch the specific DAG.
+ Patch the specific Dag.
:param dag_id: (required)
:type dag_id: str
@@ -2366,7 +2417,7 @@
) -> ApiResponse[DAGResponse]:
"""Patch Dag
- Patch the specific DAG.
+ Patch the specific Dag.
:param dag_id: (required)
:type dag_id: str
@@ -2446,7 +2497,7 @@
) -> RESTResponseType:
"""Patch Dag
- Patch the specific DAG.
+ Patch the specific Dag.
:param dag_id: (required)
:type dag_id: str
@@ -2598,7 +2649,8 @@
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 @@
) -> 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 @@
: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 @@
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 @@
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 @@
) -> 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 @@
: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 @@
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 @@
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 @@
) -> 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 @@
: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 @@
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 @@
tags_match_mode,
owners,
dag_id_pattern,
+ dag_id_prefix_pattern,
exclude_stale,
paused,
_request_auth,
@@ -2973,6 +3037,10 @@
_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 @@
) -> 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 @@
) -> 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 @@
) -> 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 c204428..f35c191 100644
--- a/airflow_client/client/api/dag_parsing_api.py
+++ b/airflow_client/client/api/dag_parsing_api.py
@@ -55,7 +55,7 @@
) -> 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 @@
) -> 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 @@
) -> 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 a81f9df..eefe1f1 100644
--- a/airflow_client/client/api/dag_run_api.py
+++ b/airflow_client/client/api/dag_run_api.py
@@ -380,7 +380,7 @@
) -> 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 @@
) -> 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 @@
) -> 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_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 @@
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 @@
) -> 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 @@
: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 @@
_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 @@
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_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 @@
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 @@
) -> 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 @@
: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 @@
_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 @@
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_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 @@
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 @@
) -> 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 @@
: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 @@
_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 @@
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_serialize(
self,
dag_id,
+ cursor,
limit,
offset,
run_after_gte,
@@ -1615,9 +1688,14 @@
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 @@
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 @@
_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 @@
) -> 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 @@
) -> 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 @@
) -> 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 @@
) -> DAGRunResponse:
"""Patch Dag Run
- Modify a DAG Run.
+ Modify a Dag Run.
:param dag_id: (required)
:type dag_id: str
@@ -2705,7 +2807,7 @@
) -> 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 @@
) -> RESTResponseType:
"""Patch Dag Run
- Modify a DAG Run.
+ Modify a Dag Run.
:param dag_id: (required)
:type dag_id: str
@@ -2957,7 +3059,7 @@
) -> DAGRunResponse:
"""Trigger Dag Run
- Trigger a DAG.
+ Trigger a Dag.
:param dag_id: (required)
:type dag_id: object
@@ -3034,7 +3136,7 @@
) -> ApiResponse[DAGRunResponse]:
"""Trigger Dag Run
- Trigger a DAG.
+ Trigger a Dag.
:param dag_id: (required)
:type dag_id: object
@@ -3111,7 +3213,7 @@
) -> RESTResponseType:
"""Trigger Dag Run
- Trigger a DAG.
+ Trigger a Dag.
:param dag_id: (required)
:type dag_id: object
@@ -3267,7 +3369,7 @@
) -> 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 @@
) -> 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 @@
) -> 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 1f24f01..26f2bb4 100644
--- a/airflow_client/client/api/dag_version_api.py
+++ b/airflow_client/client/api/dag_version_api.py
@@ -353,7 +353,7 @@
) -> 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 @@
) -> 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 @@
) -> 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 f94244e..e9a0fb1 100644
--- a/airflow_client/client/api/dag_warning_api.py
+++ b/airflow_client/client/api/dag_warning_api.py
@@ -61,7 +61,7 @@
) -> 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 @@
) -> 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 @@
) -> 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 f00fc78..724c206 100644
--- a/airflow_client/client/api/event_log_api.py
+++ b/airflow_client/client/api/event_log_api.py
@@ -328,11 +328,16 @@
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 @@
: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 @@
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 @@
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 @@
: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 @@
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 @@
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 @@
: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 @@
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 @@
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 @@
_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 3649225..68207fa 100644
--- a/airflow_client/client/api/experimental_api.py
+++ b/airflow_client/client/api/experimental_api.py
@@ -59,7 +59,7 @@
) -> 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 @@
) -> 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 @@
) -> 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 e4a88c4..28130ef 100644
--- a/airflow_client/client/api/extra_links_api.py
+++ b/airflow_client/client/api/extra_links_api.py
@@ -44,6 +44,7 @@
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 @@
: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 @@
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 @@
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 @@
: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 @@
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 @@
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 @@
: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 @@
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 @@
dag_run_id,
task_id,
map_index,
+ try_number,
_request_auth,
_content_type,
_headers,
@@ -320,6 +333,10 @@
_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 fe93a30..b3dbf42 100644
--- a/airflow_client/client/api/import_error_api.py
+++ b/airflow_client/client/api/import_error_api.py
@@ -319,7 +319,8 @@
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 @@
: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 @@
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 @@
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 @@
: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 @@
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 @@
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 @@
: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 @@
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 @@
offset,
order_by,
filename_pattern,
+ filename_prefix_pattern,
_request_auth,
_content_type,
_headers,
@@ -600,6 +613,10 @@
_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 8eb83a3..a19b856 100644
--- a/airflow_client/client/api/pool_api.py
+++ b/airflow_client/client/api/pool_api.py
@@ -884,7 +884,8 @@
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 @@
: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 @@
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 @@
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 @@
: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 @@
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 @@
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 @@
: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 @@
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 @@
offset,
order_by,
pool_name_pattern,
+ pool_name_prefix_pattern,
_request_auth,
_content_type,
_headers,
@@ -1168,6 +1181,10 @@
_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 811210e..0e91b6f 100644
--- a/airflow_client/client/api/task_api.py
+++ b/airflow_client/client/api/task_api.py
@@ -350,7 +350,7 @@
) -> TaskCollectionResponse:
"""Get Tasks
- Get tasks for DAG.
+ Get tasks for Dag.
:param dag_id: (required)
:type dag_id: str
@@ -426,7 +426,7 @@
) -> ApiResponse[TaskCollectionResponse]:
"""Get Tasks
- Get tasks for DAG.
+ Get tasks for Dag.
:param dag_id: (required)
:type dag_id: str
@@ -502,7 +502,7 @@
) -> 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 3e0c183..dee47c3 100644
--- a/airflow_client/client/api/task_instance_api.py
+++ b/airflow_client/client/api/task_instance_api.py
@@ -1037,6 +1037,7 @@
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 @@
: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 @@
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 @@
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 @@
: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 @@
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 @@
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 @@
: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 @@
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 @@
dag_run_id,
task_id,
map_index,
+ try_number,
_request_auth,
_content_type,
_headers,
@@ -1313,6 +1326,10 @@
_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 @@
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 @@
: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 @@
: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 @@
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 @@
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 @@
: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 @@
: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 @@
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 @@
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 @@
: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 @@
: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 @@
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 @@
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 @@
_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 @@
_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 @@
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 @@
: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 @@
: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 @@
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 @@
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 @@
: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 @@
: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 @@
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 @@
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 @@
: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 @@
: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 @@
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 @@
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 @@
_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 @@
_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 @@
_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 @@
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 @@
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 @@
) -> 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 @@
: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 @@
: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 @@
_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 @@
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 @@
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 @@
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 @@
) -> 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 @@
: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 @@
: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 @@
_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 @@
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 @@
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 @@
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 @@
) -> 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 @@
: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 @@
: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 @@
_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 @@
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 @@
self,
dag_id,
dag_run_id,
+ cursor,
task_id,
run_after_gte,
run_after_gt,
@@ -7481,20 +7726,28 @@
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 @@
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 @@
_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 @@
_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 @@
_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 @@
_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 @@
_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 3b750c7..dc49229 100644
--- a/airflow_client/client/api/variable_api.py
+++ b/airflow_client/client/api/variable_api.py
@@ -880,7 +880,8 @@
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 @@
: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 @@
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 @@
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 @@
: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 @@
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 @@
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 @@
: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 @@
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 @@
offset,
order_by,
variable_key_pattern,
+ variable_key_prefix_pattern,
_request_auth,
_content_type,
_headers,
@@ -1161,6 +1174,10 @@
_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 3af5fb3..ffecaa1 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 @@
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 @@
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 @@
) -> 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 @@
: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 @@
: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 @@
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 @@
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 @@
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 @@
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 @@
) -> 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 @@
: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 @@
: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 @@
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 @@
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 @@
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 @@
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 @@
) -> 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 @@
: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 @@
: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 @@
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 @@
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 @@
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 @@
run_after_gt,
run_after_lte,
run_after_lt,
+ order_by,
_request_auth,
_content_type,
_headers,
@@ -1188,6 +1253,7 @@
_host = None
_collection_formats: Dict[str, str] = {
+ 'order_by': 'multi',
}
_path_params: Dict[str, str] = {}
@@ -1227,18 +1293,34 @@
_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 @@
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 a1e8a00..76ef20c 100644
--- a/airflow_client/client/api_client.py
+++ b/airflow_client/client/api_client.py
@@ -91,7 +91,7 @@
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 @@
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 4723793..9d68ec9 100644
--- a/airflow_client/client/configuration.py
+++ b/airflow_client/client/configuration.py
@@ -196,7 +196,7 @@
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 @@
"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 4262e20..a63cafa 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 0000000..cd7a8e2
--- /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 e1f1382..a1107cd 100644
--- a/airflow_client/client/models/connection_body.py
+++ b/airflow_client/client/models/connection_body.py
@@ -43,6 +43,9 @@
@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 ff4081d..afbd588 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 bd63f24..942c90c 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 9b913e2..7b01599 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 835194c..52969e2 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 @@
_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 5c2f703..6bd2a97 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 @@
_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 ad30816..6960f91 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 94ce2d7..e1f5bf2 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 a888a09..bfd470a 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 67ebf9b..a2f1b2e 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 8aec05a..602bfd9 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 eea33a3..e5a2b04 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 4866f04..1acdf4e 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 d724e6b..e981d6f 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 316597c..67ea5a6 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 962dd61..bbe041a 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 69862c5..446f5b1 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 60013d8..d969e5e 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 7b571bf..a9688a2 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 0000000..30e5bfd
--- /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 bfc0ab7..8164a65 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 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 @@
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 @@
"""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 @@
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 @@
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 f9598fd..4536976 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 @@
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 0000000..375ea89
--- /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 f136335..d20dbfa 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 827680b..71a20a7 100644
--- a/docs/AssetApi.md
+++ b/docs/AssetApi.md
@@ -194,7 +194,7 @@
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 @@
[[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 @@
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 @@
------------- | ------------- | ------------- | -------------
**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 @@
[[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 @@
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 @@
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 @@
**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 @@
[[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 @@
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 @@
------------- | ------------- | ------------- | -------------
**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 @@
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 @@
Get Dag Asset Queued Events
-Get queued asset events for a DAG.
+Get queued asset events for a Dag.
### Example
@@ -1091,7 +1099,7 @@
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 0000000..23f0558
--- /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 14dcdb2..0e25a79 100644
--- a/docs/ConnectionApi.md
+++ b/docs/ConnectionApi.md
@@ -343,7 +343,7 @@
[[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 @@
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 @@
**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 888662f..2ce5d90 100644
--- a/docs/DAGApi.md
+++ b/docs/DAGApi.md
@@ -20,7 +20,7 @@
Delete Dag
-Delete the specific DAG.
+Delete the specific Dag.
### Example
@@ -105,7 +105,7 @@
Favorite Dag
-Mark the DAG as favorite.
+Mark the Dag as favorite.
### Example
@@ -187,7 +187,7 @@
Get Dag
-Get basic information about a DAG.
+Get basic information about a Dag.
### Example
@@ -273,7 +273,7 @@
Get Dag Details
-Get details of DAG.
+Get details of Dag.
### Example
@@ -355,11 +355,11 @@
[[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 @@
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 @@
**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 @@
[[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 @@
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 @@
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 @@
**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 @@
Patch Dag
-Patch the specific DAG.
+Patch the specific Dag.
### Example
@@ -672,11 +678,15 @@
[[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 @@
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 @@
**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 @@
Unfavorite Dag
-Unmark the DAG as favorite.
+Unmark the Dag as favorite.
### Example
diff --git a/docs/DAGCollectionResponse.md b/docs/DAGCollectionResponse.md
index 44779ec..4867971 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 df51a5c..80880a1 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 063e7b1..655920e 100644
--- a/docs/DAGParsingApi.md
+++ b/docs/DAGParsingApi.md
@@ -12,7 +12,7 @@
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 b82c433..a5bc6be 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 5f08685..67f3db3 100644
--- a/docs/DAGRunApi.md
+++ b/docs/DAGRunApi.md
@@ -108,7 +108,7 @@
Delete Dag Run
-Delete a DAG Run entry.
+Delete a Dag Run entry.
### Example
@@ -274,13 +274,22 @@
[[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 @@
# 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 @@
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 @@
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 @@
**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 @@
Get List Dag Runs Batch
-Get a list of DAG Runs.
+Get a list of Dag Runs.
### Example
@@ -612,7 +633,7 @@
Patch Dag Run
-Modify a DAG Run.
+Modify a Dag Run.
### Example
@@ -705,7 +726,7 @@
Trigger Dag Run
-Trigger a DAG.
+Trigger a Dag.
### Example
@@ -795,7 +816,7 @@
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 485ec58..c43cb46 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 @@
------------ | ------------- | ------------- | -------------
**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 03e7ae9..9a4c9cb 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 5527ac4..8230a66 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 d6f059c..74de607 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 00ef7cc..458cf4d 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 217af31..52111c8 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 c806e90..28bad04 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 362da02..f768629 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 e204d6f..720bd9f 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 5ff1623..5acc2bf 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 c16e979..c2c5121 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 40e2356..cb602af 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 71de5e9..98a7aec 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 a061c1e..1c7684f 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 95b94b2..60a329a 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 a416294..52ba851 100644
--- a/docs/DagVersionApi.md
+++ b/docs/DagVersionApi.md
@@ -100,9 +100,9 @@
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 e2ef2df..09e5aa5 100644
--- a/docs/DagWarningApi.md
+++ b/docs/DagWarningApi.md
@@ -12,7 +12,7 @@
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 782e8e6..53c3154 100644
--- a/docs/EventLogApi.md
+++ b/docs/EventLogApi.md
@@ -92,7 +92,7 @@
[[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 @@
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 @@
**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 940b81e..fb0bc9c 100644
--- a/docs/ExperimentalApi.md
+++ b/docs/ExperimentalApi.md
@@ -12,7 +12,7 @@
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 94acdca..f793b62 100644
--- a/docs/ExtraLinksApi.md
+++ b/docs/ExtraLinksApi.md
@@ -8,7 +8,7 @@
# **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 @@
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 @@
**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 936d049..d2cac04 100644
--- a/docs/ImportErrorApi.md
+++ b/docs/ImportErrorApi.md
@@ -94,7 +94,7 @@
[[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 @@
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 @@
**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 0000000..0b791bb
--- /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 2579552..6c883ec 100644
--- a/docs/PoolApi.md
+++ b/docs/PoolApi.md
@@ -266,7 +266,7 @@
[[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 @@
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 @@
**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 d51c77c..3fd7f4d 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 c1247b7..3eaa41a 100644
--- a/docs/TaskApi.md
+++ b/docs/TaskApi.md
@@ -101,7 +101,7 @@
Get Tasks
-Get tasks for DAG.
+Get tasks for Dag.
### Example
diff --git a/docs/TaskInstanceApi.md b/docs/TaskInstanceApi.md
index 1ac25cf..267a2b0 100644
--- a/docs/TaskInstanceApi.md
+++ b/docs/TaskInstanceApi.md
@@ -305,7 +305,7 @@
[[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 @@
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 @@
**dag_run_id** | **str**| |
**task_id** | **str**| |
**map_index** | **int**| | [optional] [default to -1]
+ **try_number** | **int**| | [optional]
### Return type
@@ -580,7 +582,7 @@
[[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 @@
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 @@
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 @@
**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 @@
[[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 @@
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 @@
**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 @@
[[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 @@
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 @@
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 @@
------------- | ------------- | ------------- | -------------
**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 @@
**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 daca357..e95e26c 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 0000000..5d60a97
--- /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 1ff157e..03cde0a 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 6354be5..075a9db 100644
--- a/docs/VariableApi.md
+++ b/docs/VariableApi.md
@@ -265,7 +265,7 @@
[[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 @@
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 @@
**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 52154df..3602070 100644
--- a/docs/XComApi.md
+++ b/docs/XComApi.md
@@ -196,13 +196,13 @@
[[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 @@
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 @@
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 @@
**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 @@
**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 ed91dbb..449bf80 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 d4fe7bd..198a6c6 100644
--- a/spec/v2.yaml
+++ b/spec/v2.yaml
@@ -271,8 +271,7 @@
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 @@
- 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 @@
title: CreateAssetEventsBody
type: object
DAGCollectionResponse:
- description: DAG Collection serializer for responses.
+ description: Dag Collection serializer for responses.
properties:
dags:
items:
@@ -1102,7 +1120,7 @@
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 @@
title: DAGPatchBody
type: object
DAGResponse:
- description: DAG serializer for responses.
+ description: Dag serializer for responses.
properties:
allowed_run_types:
items:
@@ -1424,7 +1442,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
- 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 @@
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 @@
- 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 @@
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 @@
- 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 @@
- DagWarning
/api/v2/dags:
get:
- description: Get all DAGs.
+ description: Get all Dags.
operationId: get_dags
parameters:
- in: query
@@ -6056,22 +6235,56 @@
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 @@
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 @@
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 @@
- 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 @@
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 @@
tags:
- DAG
patch:
- description: Patch the specific DAG.
+ description: Patch the specific Dag.
operationId: patch_dag
parameters:
- in: path
@@ -6603,7 +6842,7 @@
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 @@
- 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 @@
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 @@
- 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 @@
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 @@
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: "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."
+ - 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_pattern
+ 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. \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 @@
tags:
- DagRun
post:
- description: Trigger a DAG.
+ description: Trigger a Dag.
operationId: trigger_dag_run
parameters:
- in: path
@@ -7218,7 +7560,7 @@
- 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 @@
- 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 @@
tags:
- DagRun
patch:
- description: Modify a DAG Run.
+ description: Modify a Dag Run.
operationId: patch_dag_run
parameters:
- in: path
@@ -7480,7 +7822,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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
- and DAG runs.'
+ 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.'
operationId: get_task_instances
parameters:
- in: path
@@ -7727,6 +8126,15 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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: "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."
+ - 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_pattern
+ 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. \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 @@
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 @@
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 @@
- 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 @@
- 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 @@
- 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 @@
- 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 @@
- 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
- 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 @@
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 @@
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 0000000..1524b95
--- /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 669df41..8f29905 100644
--- a/test/test_dag_run_clear_body.py
+++ b/test/test_dag_run_clear_body.py
@@ -37,6 +37,7 @@
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 4779258..49807e4 100644
--- a/test/test_dag_run_collection_response.py
+++ b/test/test_dag_run_collection_response.py
@@ -69,6 +69,8 @@
triggered_by = null,
triggering_user_name = '', )
],
+ next_cursor = '',
+ previous_cursor = '',
total_entries = 56
)
else:
@@ -107,7 +109,6 @@
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 0000000..6f6f2b0
--- /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 92a4362..73be45d 100644
--- a/test/test_response_clear_dag_run.py
+++ b/test/test_response_clear_dag_run.py
@@ -36,41 +36,7 @@
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 @@
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 0bb10b8..20ef44a 100644
--- a/test/test_task_instance_collection_response.py
+++ b/test/test_task_instance_collection_response.py
@@ -35,6 +35,8 @@
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 @@
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 0000000..a9d16d3
--- /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 e4604e3..be94e6f 100644
--- a/version.txt
+++ b/version.txt
@@ -1 +1 @@
-3.2.1
+3.2.2
