apache-airflow-task-sdk 1.4.0b1__tar.gz → 1.4.0b2__tar.gz

{apache_airflow_task_sdk-1.4.0b1 → apache_airflow_task_sdk-1.4.0b2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: apache-airflow-task-sdk
-Version: 1.4.0b1
+Version: 1.4.0b2
 Summary: Python Task SDK for Apache Airflow DAG Authors
 Project-URL: Bug Tracker, https://github.com/apache/airflow/issues
 Project-URL: Documentation, https://airflow.staged.apache.org/docs/
@@ -37,7 +37,7 @@ Requires-Dist: cadwyn>=6.1.1
 Requires-Dist: colorlog>=6.8.2
 Requires-Dist: fsspec>=2023.10.0
 Requires-Dist: greenback>=1.2.1
-Requires-Dist: httpx>=0.27.0
+Requires-Dist: httpx2>=2.0.0
 Requires-Dist: importlib-metadata>=6.5; python_version < '3.12'
 Requires-Dist: isoduration>=20.11.0
 Requires-Dist: jinja2>=3.1.5
@@ -56,6 +56,7 @@ Requires-Dist: python-dateutil>=2.7.0
 Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: structlog>=26.1.0
 Requires-Dist: tenacity>=8.3.0
+Requires-Dist: truststore>=0.10.0
 Requires-Dist: typing-extensions>=4.14.1
 Provides-Extra: all
 Requires-Dist: datadog>=0.50.0; extra == 'all'

{apache_airflow_task_sdk-1.4.0b1 → apache_airflow_task_sdk-1.4.0b2}/dev/generate_task_sdk_models.py

@@ -22,7 +22,7 @@ import sys
 from pathlib import Path
 from tomllib import load as load_tomllib
 
-import httpx
+import httpx2
 from datamodel_code_generator import (
     DataModelType,
     DatetimeClassType,
@@ -77,7 +77,7 @@ def generate_file():
     app = InProcessExecutionAPI()
 
     latest_version = app.app.versions.version_values[0]
-    client = httpx.Client(transport=app.transport)
+    client = httpx2.Client(transport=app.transport)
     openapi_schema = (
         client.get(f"http://localhost/openapi.json?version={latest_version}").raise_for_status().text
     )

{apache_airflow_task_sdk-1.4.0b1 → apache_airflow_task_sdk-1.4.0b2}/docs/airflow-metadata.schema.json

@@ -57,8 +57,7 @@
     },
     "dags": {
       "type": "object",
-      "description": "Mapping of dag_id to DAG entry. Every dag_id the bundle exposes must appear here.",
-      "minProperties": 1,
+      "description": "Mapping of dag_id to the tasks the bundle runs for a Python Dag with stub TaskHandler. May be empty, for example when the bundle only declares Dag definitions.",
       "additionalProperties": {
         "$ref": "#/$defs/dagEntry"
       }

{apache_airflow_task_sdk-1.4.0b1 → apache_airflow_task_sdk-1.4.0b2}/docs/api.rst

@@ -94,6 +94,8 @@ Bases
 
 .. autoapiclass:: airflow.sdk.BaseXCom
 
+.. autoapiclass:: airflow.sdk.bases.xcom.XComCoordinate
+
 .. autoapiclass:: airflow.sdk.BranchMixIn
 
 .. autoapiclass:: airflow.sdk.PokeReturnValue
@@ -130,6 +132,8 @@ Tasks & Operators
 -----------------
 .. autoapiclass:: airflow.sdk.TaskGroup
 
+.. autoapiclass:: airflow.sdk.LoopDecision
+
 .. autoclass:: airflow.sdk.TaskInstance
 
 .. autoapiclass:: airflow.sdk.XComArg

{apache_airflow_task_sdk-1.4.0b1 → apache_airflow_task_sdk-1.4.0b2}/docs/conf.py

@@ -57,7 +57,7 @@ extensions = [
     "sphinx.ext.intersphinx",
     "airflow_intersphinx",
     "exampleinclude",
-    "sphinxcontrib.mermaid",
+    "mermaid_svg",
     "airflow_spelling",
 ]
 

{apache_airflow_task_sdk-1.4.0b1 → apache_airflow_task_sdk-1.4.0b2}/docs/executable-bundle-spec.rst

@@ -262,9 +262,10 @@ Top-level keys:
     - ``sha256`` (string, required): the lower-case hexadecimal SHA-256 of the file's bytes.
 
 ``dags`` (mapping, required)
-    Mapping of ``dag_id`` to a *DAG entry*. Every ``dag_id`` the bundle
-    exposes MUST appear here. The scanner uses these keys to match a DAG
-    parsing or task-execution request to the bundle that owns it.
+    Mapping of ``dag_id`` to a *DAG entry*, for each Python Dag with stub TaskHandler whose tasks the
+    bundle runs. The scanner uses these keys to match a task-execution request to the bundle that
+    owns it. The mapping MAY be empty, for example when the bundle only declares Dag definitions,
+    because the Dag processor finds those by running the binary.
 
 DAG entry fields:
 

{apache_airflow_task_sdk-1.4.0b1 → apache_airflow_task_sdk-1.4.0b2}/docs/index.rst

@@ -100,6 +100,7 @@ Why use ``airflow.sdk``?
 - :class:`airflow.sdk.RetryPolicy`
 - :class:`airflow.sdk.RetryRule`
 - :class:`airflow.sdk.TaskGroup`
+- :class:`airflow.sdk.LoopDecision`
 - :class:`airflow.sdk.TaskInstanceState`
 - :class:`airflow.sdk.DagRunState`
 - :class:`airflow.sdk.WeightRule`

{apache_airflow_task_sdk-1.4.0b1 → apache_airflow_task_sdk-1.4.0b2}/docs/lang-sdk-spec.rst

@@ -105,11 +105,11 @@ Per-SDK spelling
      - an ``async`` function
    * - ``TaskHandler``
      - ``airflow.TaskHandler(dagId, taskId, fn)``
-     - ``@Builder.TaskHandler(dagId, taskId)``
+     - ``@Airflow.TaskHandler(dagId, taskId)``
      - ``new TaskHandler(dagId, taskId, fn)``
    * - ``Dag``
      - ``airflow.Dag(spec)``
-     - ``@Builder.Dag(id, ...)``, or ``new Dag(id)``
+     - ``@Airflow.Dag(id, ...)``, or ``new Dag(id)``
      - ``new Dag(id)``
    * - ``dag``
      - ``*airflow.DagRef``
@@ -117,7 +117,7 @@ Per-SDK spelling
      - ``Dag``
    * - ``dag.Task``
      - ``dag.Task(fn, opts...)``
-     - ``@Builder.Task(id)``, or ``dag.task(id, cls)``
+     - ``@Airflow.Task(id)``, or ``dag.task(id, cls)``
      - ``dag.task(id, fn)``
    * - data edge
      - ``airflow.Inputs(refs...)``

{apache_airflow_task_sdk-1.4.0b1 → apache_airflow_task_sdk-1.4.0b2}/pyproject.toml

@@ -55,7 +55,7 @@ dependencies = [
     "cadwyn>=6.1.1",
     "fsspec>=2023.10.0",
     "greenback>=1.2.1",
-    "httpx>=0.27.0",
+    "httpx2>=2.0.0",
     "jinja2>=3.1.5",
     "methodtools>=0.4.7",
     "msgspec>=0.19.0",
@@ -64,6 +64,7 @@ dependencies = [
     "pyyaml>=6.0.3",
     "structlog>=26.1.0",
     "tenacity>=8.3.0",
+    "truststore>=0.10.0",
     # Start of shared timezones dependencies
     "pendulum>=3.1.0",
     # End of shared timezones dependencies
@@ -127,8 +128,8 @@ requires = [
     "hatchling==1.32.4",
     "packaging==26.3",
     "pathspec==1.1.1",
-    "pluggy==1.6.0",
-    "tomlkit==0.15.1",
+    "pluggy==1.7.0",
+    "tomlkit==0.15.2",
     "trove-classifiers==2026.9.21.13",
 ]
 build-backend = "hatchling.build"
@@ -196,6 +197,9 @@ namespace-packages = ["src/airflow"]
 # Generated file, be less strict
 "src/airflow/sdk/*/_generated.py" = ["D"]
 
+[tool.ruff.lint.flake8-tidy-imports.extend-banned-api]
+"httpx".msg = "Use httpx2; httpx objects do not interoperate with the httpx2-based Task SDK client. See https://github.com/apache/airflow/issues/70522"
+
 [tool.coverage.run]
 branch = true
 relative_files = true

{apache_airflow_task_sdk-1.4.0b1 → apache_airflow_task_sdk-1.4.0b2}/src/airflow/sdk/__init__.py

@@ -63,6 +63,7 @@ __all__ = [
     "HourWindow",
     "IdentityMapper",
     "Label",
+    "LoopDecision",
     "Metadata",
     "MinimumCount",
     "MonthWindow",
@@ -122,7 +123,7 @@ __all__ = [
     "teardown",
 ]
 
-__version__ = "1.4.0b1"
+__version__ = "1.4.0b2"
 
 if TYPE_CHECKING:
     from airflow.sdk.api.datamodels._generated import DagRunState, TaskInstanceState, TriggerRule, WeightRule
@@ -165,6 +166,7 @@ if TYPE_CHECKING:
     from airflow.sdk.definitions.decorators import result, setup, task, teardown
     from airflow.sdk.definitions.decorators.task_group import task_group
     from airflow.sdk.definitions.edges import EdgeModifier, Label
+    from airflow.sdk.definitions.loop import LoopDecision
     from airflow.sdk.definitions.param import Param, ParamsDict
     from airflow.sdk.definitions.partition_mappers.allowed_key import AllowedKeyMapper
     from airflow.sdk.definitions.partition_mappers.base import (
@@ -279,6 +281,7 @@ __lazy_imports: dict[str, str] = {
     "HourWindow": ".definitions.partition_mappers.window",
     "IdentityMapper": ".definitions.partition_mappers.identity",
     "Label": ".definitions.edges",
+    "LoopDecision": ".definitions.loop",
     "Metadata": ".definitions.asset.metadata",
     "MinimumCount": ".definitions.partition_mappers.wait_policy",
     "MonthWindow": ".definitions.partition_mappers.window",

{apache_airflow_task_sdk-1.4.0b1 → apache_airflow_task_sdk-1.4.0b2}/src/airflow/sdk/__init__.pyi

@@ -70,6 +70,7 @@ from airflow.sdk.definitions.decorators import (
 )
 from airflow.sdk.definitions.decorators.task_group import task_group as task_group
 from airflow.sdk.definitions.edges import EdgeModifier as EdgeModifier, Label as Label
+from airflow.sdk.definitions.loop import LoopDecision as LoopDecision
 from airflow.sdk.definitions.param import Param as Param
 from airflow.sdk.definitions.partition_mappers.allowed_key import AllowedKeyMapper
 from airflow.sdk.definitions.partition_mappers.base import PartitionMapper, RollupMapper
@@ -182,6 +183,7 @@ __all__ = [
     "HourWindow",
     "IdentityMapper",
     "Label",
+    "LoopDecision",
     "Metadata",
     "MinimumCount",
     "MonthWindow",

{apache_airflow_task_sdk-1.4.0b1 → apache_airflow_task_sdk-1.4.0b2}/src/airflow/sdk/_shared/logging/remote.py

@@ -60,8 +60,12 @@ class RemoteLogIO(Protocol):
         """Upload the given log path to the remote storage."""
         ...
 
-    def read(self, relative_path: str, ti: RuntimeTI) -> LogResponse:
-        """Read logs from the given remote log path."""
+    def read(self, relative_path: str, ti: RuntimeTI | None) -> LogResponse:
+        """
+        Read logs from the given remote log path.
+
+        ``ti`` is None for logs not tied to a task instance, such as deadline callbacks.
+        """
         ...
 
 
@@ -69,8 +73,12 @@ class RemoteLogIO(Protocol):
 class RemoteLogStreamIO(RemoteLogIO, Protocol):
     """Interface for remote task loggers with stream-based read support."""
 
-    def stream(self, relative_path: str, ti: RuntimeTI) -> StreamingLogResponse:
-        """Stream-based read interface for reading logs from the given remote log path."""
+    def stream(self, relative_path: str, ti: RuntimeTI | None) -> StreamingLogResponse:
+        """
+        Stream-based read interface for reading logs from the given remote log path.
+
+        ``ti`` is None for logs not tied to a task instance, such as deadline callbacks.
+        """
         ...
 
 

{apache_airflow_task_sdk-1.4.0b1 → apache_airflow_task_sdk-1.4.0b2}/src/airflow/sdk/_shared/logging/structlog.py

@@ -420,22 +420,16 @@ def structlog_processors(
     # structlog to ignore.
 
     import contextlib
+    import importlib
 
     import click
 
     suppress: tuple[ModuleType, ...] = (click, contextlib)
-    try:
-        import httpcore
-
-        suppress = (*suppress, httpcore)
-    except ImportError:
-        pass
-    try:
-        import httpx
-
-        suppress = (*suppress, httpx)
-    except ImportError:
-        pass
+    # airflow-core is still on httpx while the Task SDK is on httpx2, so either (or both) may
+    # be installed; tracked at https://github.com/apache/airflow/issues/70522
+    for module_name in ("httpcore", "httpcore2", "httpx", "httpx2"):
+        with contextlib.suppress(ImportError):
+            suppress = (*suppress, importlib.import_module(module_name))
 
     if json_output:
         dict_exc_formatter = structlog.tracebacks.ExceptionDictTransformer(
@@ -690,6 +684,7 @@ def configure_logging(
             "airflow": {"level": log_level.upper()},
             # These ones are too chatty even at info
             "httpx": {"level": "WARN"},
+            "httpx2": {"level": "WARN"},
             "sqlalchemy.engine": {"level": "WARN"},
             "alembic.runtime.plugins": {"level": "WARN"},
         }

{apache_airflow_task_sdk-1.4.0b1 → apache_airflow_task_sdk-1.4.0b2}/src/airflow/sdk/_shared/observability/metrics/metrics_template.yaml

@@ -326,6 +326,12 @@ metrics:
     legacy_name: "-"
     name_variables: []
 
+  - name: "deadline_alerts.deadline_creation_failed"
+    description: "Number of deadline alerts skipped because their deadline could not be created"
+    type: "counter"
+    legacy_name: "-"
+    name_variables: []
+
   - name: "deadline_alerts.deadline_missed"
     description: "Number of deadline alerts that fired because a Dag run missed its deadline"
     type: "counter"

{apache_airflow_task_sdk-1.4.0b1 → apache_airflow_task_sdk-1.4.0b2}/src/airflow/sdk/_shared/secrets_masker/secrets_masker.py

@@ -79,6 +79,13 @@ DEFAULT_SENSITIVE_FIELDS = frozenset(
 SECRETS_TO_SKIP_MASKING = {"airflow"}
 """Common terms that should be excluded from masking in both production and tests"""
 
+# Word boundaries inside camelCase / PascalCase names: "privateKey" -> "private_Key",
+# "APIKey" -> "API_Key". Applied before lowercasing so multi-word sensitive field names
+# (``private_key``, ``connection_string``...) also match camelCase keys.
+_CAMEL_LOWER_UPPER_RE = re.compile(r"([a-z0-9])([A-Z])")
+_CAMEL_ACRONYM_RE = re.compile(r"([A-Z]+)([A-Z][a-z])")
+_NON_WORD_RE = re.compile(r"\W+")
+
 
 def should_hide_value_for_key(name):
     """
@@ -356,10 +363,12 @@ class SecretsMasker(logging.Filter):
         self, item: Redactable, name: str | None, depth: int, max_depth: int, replacement: str = "***"
     ) -> Redacted:
         try:
-            # Key-name-based redaction is unbounded by depth — sensitive keys
-            # must fail closed at any nesting level. The depth cutoff below is
-            # only used to bound the work of pattern-based string masking and
-            # to terminate recursion through self-referential iterables.
+            # Both key-name-based and pattern-based redaction apply at any
+            # nesting depth: a registered secret or a sensitive key must fail
+            # closed wherever it sits in the structure. ``max_depth`` only bounds
+            # the fail-closed walk of a value already known to be sensitive
+            # (``_redact_all``); self-referential structures are stopped by
+            # Python's recursion limit and the except clause below.
             if name and self.should_hide_value_for_key(name):
                 return self._redact_all(item, depth, max_depth, replacement=replacement)
             # Always walk dicts so deeper sensitive keys are still caught;
@@ -395,11 +404,6 @@ class SecretsMasker(logging.Filter):
                     )
                     for subval in item
                 ]
-            # The depth cutoff only bounds the work of pattern-based string
-            # masking below — key-name redaction (dicts and iterables above) is
-            # unbounded so sensitive keys fail closed at any depth.
-            if depth > max_depth:
-                return item
             if isinstance(item, Enum):
                 return self._redact(
                     item=item.value, name=name, depth=depth, max_depth=max_depth, replacement=replacement
@@ -588,9 +592,13 @@ class SecretsMasker(logging.Filter):
         Name might be a Variable name, or key in conn.extra_dejson, for example.
         """
         if isinstance(name, str) and self.hide_sensitive_var_conn_fields:
-            name = name.strip().lower()
-            normalized = re.sub(r"\W+", "_", name)
-            return any(s in normalized for s in self.sensitive_variables_fields)
+            name = name.strip()
+            normalized = _NON_WORD_RE.sub("_", name.lower())
+            split = _CAMEL_ACRONYM_RE.sub(r"\1_\2", _CAMEL_LOWER_UPPER_RE.sub(r"\1_\2", name))
+            split = _NON_WORD_RE.sub("_", split.lower())
+            # Check both forms so fields configured without separators (e.g. ``mysensitivekey``)
+            # keep matching camelCase keys such as ``mySensitiveKey``.
+            return any(s in normalized or s in split for s in self.sensitive_variables_fields)
         return False
 
     def add_mask(self, secret: JsonValue, name: str | None = None):

{apache_airflow_task_sdk-1.4.0b1 → apache_airflow_task_sdk-1.4.0b2}/src/airflow/sdk/api/client.py

@@ -27,10 +27,10 @@ from http import HTTPStatus
 from typing import TYPE_CHECKING, Any, TypeVar
 from urllib.parse import quote
 
-import certifi
-import httpx
+import httpx2
 import msgspec
 import structlog
+import truststore
 from opentelemetry import trace
 from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
 from pydantic import BaseModel, JsonValue
@@ -63,6 +63,7 @@ from airflow.sdk.api.datamodels._generated import (
     HITLDetailResponse,
     HITLUser,
     InactiveAssetsResponse,
+    LoopDecisionPayload,
     Note,
     PrevSuccessfulDagRunResponse,
     ResultMessage,
@@ -192,22 +193,22 @@ __all__ = [
 ]
 
 
-def get_json_error(response: httpx.Response):
+def get_json_error(response: httpx2.Response):
     """Raise a ServerResponseError if we can extract error info from the error."""
     err = ServerResponseError.from_response(response)
     if err:
         raise err
 
 
-def raise_on_4xx_5xx(response: httpx.Response):
+def raise_on_4xx_5xx(response: httpx2.Response):
     return get_json_error(response) or response.raise_for_status()
 
 
 # Py 3.11+ version
-def raise_on_4xx_5xx_with_note(response: httpx.Response):
+def raise_on_4xx_5xx_with_note(response: httpx2.Response):
     try:
         return get_json_error(response) or response.raise_for_status()
-    except httpx.HTTPStatusError as e:
+    except httpx2.HTTPStatusError as e:
         if TYPE_CHECKING:
             assert hasattr(e, "add_note")
         e.add_note(
@@ -227,11 +228,11 @@ if hasattr(BaseException, "add_note"):
     raise_on_4xx_5xx = raise_on_4xx_5xx_with_note
 
 
-def add_correlation_id(request: httpx.Request):
+def add_correlation_id(request: httpx2.Request):
     request.headers["correlation-id"] = str(uuid7())
 
 
-def inject_trace_context(request: httpx.Request) -> None:
+def inject_trace_context(request: httpx2.Request) -> None:
     _trace_propagator.inject(request.headers)
 
 
@@ -281,6 +282,7 @@ class TaskInstanceOperations:
         retry_reason: str | None = None,
         *,
         pid: int | None = None,
+        loop_decision: LoopDecisionPayload | None = None,
     ):
         """Report a terminal outcome or acknowledge server-requested termination."""
         if state == TaskInstanceState.SUCCESS:
@@ -291,6 +293,8 @@ class TaskInstanceOperations:
             rendered_map_index=rendered_map_index,
             retry_reason=retry_reason,
         )
+        if loop_decision is not None:
+            body.loop_decision = loop_decision
         if state == TerminalStateNonSuccess.SERVER_TERMINATED:
             body.hostname = get_hostname()
             body.pid = pid
@@ -313,13 +317,23 @@ class TaskInstanceOperations:
         )
         self.client.patch(f"task-instances/{id}/state", content=body.model_dump_json())
 
-    def succeed(self, id: uuid.UUID, when: datetime, task_outlets, outlet_events, rendered_map_index):
+    def succeed(
+        self,
+        id: uuid.UUID,
+        when: datetime,
+        task_outlets,
+        outlet_events,
+        rendered_map_index,
+        *,
+        loop_decision: LoopDecisionPayload | None = None,
+    ):
         """Tell the API server that this TI has succeeded."""
         body = TISuccessStatePayload(
             end_date=when,
             task_outlets=task_outlets,
             outlet_events=outlet_events,
             rendered_map_index=rendered_map_index,
+            loop_decision=loop_decision,
         )
         self.client.patch(f"task-instances/{id}/state", content=body.model_dump_json())
 
@@ -1168,11 +1182,11 @@ class CallbackOperations:
         self.client.patch(f"callbacks/{callback_id}/run")
 
 
-class BearerAuth(httpx.Auth):
+class BearerAuth(httpx2.Auth):
     def __init__(self, token: str):
         self.token: str = token
 
-    def auth_flow(self, request: httpx.Request):
+    def auth_flow(self, request: httpx2.Request):
         if self.token:
             request.headers["Authorization"] = "Bearer " + self.token
         yield request
@@ -1180,13 +1194,13 @@ class BearerAuth(httpx.Auth):
 
 # This exists as an aid for debugging or local running via the `dry_run` argument to Client. It doesn't make
 # sense for returning connections etc.
-def noop_handler(request: httpx.Request) -> httpx.Response:
+def noop_handler(request: httpx2.Request) -> httpx2.Response:
     path = request.url.path
     log.debug("Dry-run request", method=request.method, path=path)
 
     if path.startswith("/task-instances/") and path.endswith("/run"):
         # Return a fake context
-        return httpx.Response(
+        return httpx2.Response(
             200,
             json={
                 "dag_run": {
@@ -1202,7 +1216,7 @@ def noop_handler(request: httpx.Request) -> httpx.Response:
                 "should_retry": False,
             },
         )
-    return httpx.Response(200, json={"text": "Hello, world!"})
+    return httpx2.Response(200, json={"text": "Hello, world!"})
 
 
 # Note: Given defaults make attempts after 1, 3, 7, 15 and fails after 31seconds
@@ -1219,28 +1233,33 @@ API_CLIENT_USE_PUBLIC_CERTS = conf.getboolean("api", "client_use_public_certs",
 
 def _should_retry_api_request(exception: BaseException) -> bool:
     """Determine if an API request should be retried based on the exception type."""
-    if isinstance(exception, httpx.HTTPStatusError):
+    if isinstance(exception, httpx2.HTTPStatusError):
         return exception.response.status_code >= 500
 
-    return isinstance(exception, httpx.RequestError)
+    return isinstance(exception, httpx2.RequestError)
 
 
-class Client(httpx.Client):
+class Client(httpx2.Client):
     @lru_cache()
     @staticmethod
     def _get_ssl_context_cached(ca_file: str | None = None, ca_path: str | None = None) -> ssl.SSLContext:
         """
         Cache SSL context to prevent memory growth from repeated context creation.
 
-        If `client_use_public_certs` is enabled certifi.where() will be loaded into the context.
+        If `client_use_public_certs` is enabled, the system trust store is trusted alongside any
+        explicitly loaded CAs.
 
         :param ca_file: Certificate Authority, optional.
         :param ca_path: Certificate File, optional.
         """
-        ctx = ssl.create_default_context(cafile=ca_file)
+        ctx: ssl.SSLContext
         if API_CLIENT_USE_PUBLIC_CERTS:
-            log.info("Using Public CAs from certifi")
-            ctx.load_verify_locations(certifi.where())
+            log.info("Using public CAs from the system trust store")
+            ctx = truststore.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+            if ca_file:
+                ctx.load_verify_locations(ca_file)
+        else:
+            ctx = ssl.create_default_context(cafile=ca_file)
         if ca_path:
             ctx.load_verify_locations(ca_path)
         return ctx
@@ -1253,7 +1272,7 @@ class Client(httpx.Client):
         if dry_run:
             # If dry run is requested, install a no op handler so that simple tasks can "heartbeat" using a
             # real client, but just don't make any HTTP requests
-            kwargs.setdefault("transport", httpx.MockTransport(noop_handler))
+            kwargs.setdefault("transport", httpx2.MockTransport(noop_handler))
             kwargs.setdefault("base_url", "dry-run://server")
         else:
             kwargs["base_url"] = base_url
@@ -1283,14 +1302,14 @@ class Client(httpx.Client):
             **kwargs,
         )
 
-    def _update_auth(self, response: httpx.Response):
+    def _update_auth(self, response: httpx2.Response):
         if new_token := response.headers.get("Refreshed-API-Token"):
             log.debug("Execution API issued us a refreshed Task token")
             self.auth = BearerAuth(new_token)
 
     def request(self, *args, retry: bool = True, **kwargs):
         """
-        Make a request using our httpx.Client.request with a default retry policy.
+        Make a request using our httpx2.Client.request with a default retry policy.
 
         Pass ``retry=False`` to bypass the default retry policy.
         """
@@ -1408,18 +1427,19 @@ class _ErrorBody(BaseModel):
         return repr(self.detail)
 
 
-class ServerResponseError(httpx.HTTPStatusError):
-    def __init__(self, message: str, *, request: httpx.Request, response: httpx.Response):
+class ServerResponseError(httpx2.HTTPStatusError):
+    def __init__(self, message: str, *, request: httpx2.Request, response: httpx2.Response):
         super().__init__(message, request=request, response=response)
 
     detail: list[RemoteValidationError] | str | dict[str, Any] | None
 
     def __reduce__(self) -> tuple[Any, ...]:
-        # Needed because https://github.com/encode/httpx/pull/3108 isn't merged yet.
+        # Needed because https://github.com/encode/httpx/pull/3108 never landed, and httpx2
+        # forked from httpx 0.28.1 without it.
         return Exception.__new__, (type(self),) + self.args, self.__dict__
 
     @classmethod
-    def from_response(cls, response: httpx.Response) -> ServerResponseError | None:
+    def from_response(cls, response: httpx2.Response) -> ServerResponseError | None:
         if response.is_success:
             return None
         # 4xx or 5xx error?
@@ -1445,7 +1465,7 @@ class ServerResponseError(httpx.HTTPStatusError):
             try:
                 detail = msgspec.json.decode(response.content)
             except Exception:
-                # Fallback to a normal httpx error
+                # Fallback to a normal httpx2 error
                 return None
             msg = "Server returned error"
 

{apache_airflow_task_sdk-1.4.0b1 → apache_airflow_task_sdk-1.4.0b2}/src/airflow/sdk/api/datamodels/_generated.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
 #   filename:  http://0.0.0.0:8080/execution/openapi.json
-#   version:   0.82.0
+#   version:   0.85.0
 
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements.  See the NOTICE file
@@ -245,6 +245,18 @@ class LoopContext(BaseModel):
     terminal_is_mapped: Annotated[bool, Field(title="Terminal Is Mapped")]
 
 
+class LoopDecisionPayload(BaseModel):
+    """
+    A loop gate's evaluation of its ``until`` callable.
+    """
+
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+    stop: Annotated[bool, Field(title="Stop")]
+    reason: Annotated[str | None, Field(title="Reason")] = None
+
+
 class PrevSuccessfulDagRunResponse(BaseModel):
     """
     Schema for response with previous successful DagRun information for Task Template Context.
@@ -387,6 +399,7 @@ class TISuccessStatePayload(BaseModel):
     task_outlets: Annotated[list[AssetProfile] | None, Field(title="Task Outlets")] = None
     outlet_events: Annotated[list[dict[str, Any]] | None, Field(title="Outlet Events")] = None
     rendered_map_index: Annotated[str | None, Field(title="Rendered Map Index")] = None
+    loop_decision: LoopDecisionPayload | None = None
 
 
 class TITargetStatePayload(BaseModel):
@@ -759,6 +772,7 @@ class TITerminalStatePayload(BaseModel):
     retry_reason: Annotated[str | None, Field(title="Retry Reason")] = None
     hostname: Annotated[str | None, Field(title="Hostname")] = None
     pid: Annotated[int | None, Field(title="Pid")] = None
+    loop_decision: LoopDecisionPayload | None = None
 
 
 class XComArgBinding(BaseModel):