apache-airflow-providers-standard 1.2.0__py3-none-any.whl → 1.3.0rc1__py3-none-any.whl

airflow/providers/standard/example_dags/example_sensors.py

@@ -0,0 +1,135 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from __future__ import annotations
+
+import datetime
+
+import pendulum
+
+from airflow.providers.standard.operators.bash import BashOperator
+from airflow.providers.standard.sensors.bash import BashSensor
+from airflow.providers.standard.sensors.filesystem import FileSensor
+from airflow.providers.standard.sensors.python import PythonSensor
+from airflow.providers.standard.sensors.time import TimeSensor
+from airflow.providers.standard.sensors.time_delta import TimeDeltaSensor
+from airflow.providers.standard.sensors.weekday import DayOfWeekSensor
+from airflow.providers.standard.utils.weekday import WeekDay
+from airflow.sdk import DAG
+from airflow.utils.trigger_rule import TriggerRule
+
+
+# [START example_callables]
+def success_callable():
+    return True
+
+
+def failure_callable():
+    return False
+
+
+# [END example_callables]
+
+
+with DAG(
+    dag_id="example_sensors",
+    schedule=None,
+    start_date=pendulum.datetime(2021, 1, 1, tz="UTC"),
+    catchup=False,
+    tags=["example"],
+) as dag:
+    # [START example_time_delta_sensor]
+    t0 = TimeDeltaSensor(task_id="wait_some_seconds", delta=datetime.timedelta(seconds=2))
+    # [END example_time_delta_sensor]
+
+    # [START example_time_delta_sensor_async]
+    t0a = TimeDeltaSensor(
+        task_id="wait_some_seconds_async", delta=datetime.timedelta(seconds=2), deferrable=True
+    )
+    # [END example_time_delta_sensor_async]
+
+    # [START example_time_sensors]
+    t1 = TimeSensor(
+        task_id="fire_immediately", target_time=datetime.datetime.now(tz=datetime.timezone.utc).time()
+    )
+
+    t2 = TimeSensor(
+        task_id="timeout_after_second_date_in_the_future",
+        timeout=1,
+        soft_fail=True,
+        target_time=(datetime.datetime.now(tz=datetime.timezone.utc) + datetime.timedelta(hours=1)).time(),
+    )
+
+    t1a = TimeSensor(
+        task_id="fire_immediately_async",
+        target_time=datetime.datetime.now(tz=datetime.timezone.utc).time(),
+        deferrable=True,
+    )
+
+    t2a = TimeSensor(
+        task_id="timeout_after_second_date_in_the_future_async",
+        timeout=1,
+        soft_fail=True,
+        target_time=(datetime.datetime.now(tz=datetime.timezone.utc) + datetime.timedelta(hours=1)).time(),
+        deferrable=True,
+    )
+    # [END example_time_sensors]
+
+    # [START example_bash_sensors]
+    t3 = BashSensor(task_id="Sensor_succeeds", bash_command="exit 0")
+
+    t4 = BashSensor(task_id="Sensor_fails_after_3_seconds", timeout=3, soft_fail=True, bash_command="exit 1")
+    # [END example_bash_sensors]
+
+    t5 = BashOperator(task_id="remove_file", bash_command="rm -rf /tmp/temporary_file_for_testing")
+
+    # [START example_file_sensor]
+    t6 = FileSensor(task_id="wait_for_file", filepath="/tmp/temporary_file_for_testing")
+    # [END example_file_sensor]
+
+    # [START example_file_sensor_async]
+    t7 = FileSensor(
+        task_id="wait_for_file_async", filepath="/tmp/temporary_file_for_testing", deferrable=True
+    )
+    # [END example_file_sensor_async]
+
+    t8 = BashOperator(
+        task_id="create_file_after_3_seconds", bash_command="sleep 3; touch /tmp/temporary_file_for_testing"
+    )
+
+    # [START example_python_sensors]
+    t9 = PythonSensor(task_id="success_sensor_python", python_callable=success_callable)
+
+    t10 = PythonSensor(
+        task_id="failure_timeout_sensor_python", timeout=3, soft_fail=True, python_callable=failure_callable
+    )
+    # [END example_python_sensors]
+
+    # [START example_day_of_week_sensor]
+    t11 = DayOfWeekSensor(
+        task_id="week_day_sensor_failing_on_timeout", timeout=3, soft_fail=True, week_day=WeekDay.MONDAY
+    )
+    # [END example_day_of_week_sensor]
+
+    tx = BashOperator(task_id="print_date_in_bash", bash_command="date")
+
+    tx.trigger_rule = TriggerRule.NONE_FAILED
+    [t0, t0a, t1, t1a, t2, t2a, t3, t4] >> tx
+    t5 >> t6 >> t7 >> tx
+    t8 >> tx
+    [t9, t10] >> tx
+    t11 >> tx

airflow/providers/standard/example_dags/example_short_circuit_decorator.py

@@ -0,0 +1,60 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+"""Example DAG demonstrating the usage of the `@task.short_circuit()` TaskFlow decorator."""
+
+from __future__ import annotations
+
+import pendulum
+
+from airflow.providers.standard.operators.empty import EmptyOperator
+from airflow.sdk import chain, dag, task
+from airflow.utils.trigger_rule import TriggerRule
+
+
+@dag(schedule=None, start_date=pendulum.datetime(2021, 1, 1, tz="UTC"), catchup=False, tags=["example"])
+def example_short_circuit_decorator():
+    # [START howto_operator_short_circuit]
+    @task.short_circuit()
+    def check_condition(condition):
+        return condition
+
+    ds_true = [EmptyOperator(task_id=f"true_{i}") for i in [1, 2]]
+    ds_false = [EmptyOperator(task_id=f"false_{i}") for i in [1, 2]]
+
+    condition_is_true = check_condition.override(task_id="condition_is_true")(condition=True)
+    condition_is_false = check_condition.override(task_id="condition_is_false")(condition=False)
+
+    chain(condition_is_true, *ds_true)
+    chain(condition_is_false, *ds_false)
+    # [END howto_operator_short_circuit]
+
+    # [START howto_operator_short_circuit_trigger_rules]
+    [task_1, task_2, task_3, task_4, task_5, task_6] = [
+        EmptyOperator(task_id=f"task_{i}") for i in range(1, 7)
+    ]
+
+    task_7 = EmptyOperator(task_id="task_7", trigger_rule=TriggerRule.ALL_DONE)
+
+    short_circuit = check_condition.override(task_id="short_circuit", ignore_downstream_trigger_rules=False)(
+        condition=False
+    )
+
+    chain(task_1, [task_2, short_circuit], [task_3, task_4], [task_5, task_6], task_7)
+    # [END howto_operator_short_circuit_trigger_rules]
+
+
+example_dag = example_short_circuit_decorator()

airflow/providers/standard/example_dags/example_short_circuit_operator.py

@@ -0,0 +1,66 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+"""Example DAG demonstrating the usage of the ShortCircuitOperator."""
+
+from __future__ import annotations
+
+import pendulum
+
+from airflow.providers.standard.operators.empty import EmptyOperator
+from airflow.providers.standard.operators.python import ShortCircuitOperator
+from airflow.sdk import DAG, chain
+from airflow.utils.trigger_rule import TriggerRule
+
+with DAG(
+    dag_id="example_short_circuit_operator",
+    schedule=None,
+    start_date=pendulum.datetime(2021, 1, 1, tz="UTC"),
+    catchup=False,
+    tags=["example"],
+) as dag:
+    # [START howto_operator_short_circuit]
+    cond_true = ShortCircuitOperator(
+        task_id="condition_is_True",
+        python_callable=lambda: True,
+    )
+
+    cond_false = ShortCircuitOperator(
+        task_id="condition_is_False",
+        python_callable=lambda: False,
+    )
+
+    ds_true = [EmptyOperator(task_id=f"true_{i}") for i in [1, 2]]
+    ds_false = [EmptyOperator(task_id=f"false_{i}") for i in [1, 2]]
+
+    chain(cond_true, *ds_true)
+    chain(cond_false, *ds_false)
+    # [END howto_operator_short_circuit]
+
+    # [START howto_operator_short_circuit_trigger_rules]
+    [task_1, task_2, task_3, task_4, task_5, task_6] = [
+        EmptyOperator(task_id=f"task_{i}") for i in range(1, 7)
+    ]
+
+    task_7 = EmptyOperator(task_id="task_7", trigger_rule=TriggerRule.ALL_DONE)
+
+    short_circuit = ShortCircuitOperator(
+        task_id="short_circuit", ignore_downstream_trigger_rules=False, python_callable=lambda: False
+    )
+
+    chain(task_1, [task_2, short_circuit], [task_3, task_4], [task_5, task_6], task_7)
+    # [END howto_operator_short_circuit_trigger_rules]

airflow/providers/standard/example_dags/example_trigger_controller_dag.py

@@ -0,0 +1,46 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+"""
+Example usage of the TriggerDagRunOperator. This example holds 2 DAGs:
+1. 1st DAG (example_trigger_controller_dag) holds a TriggerDagRunOperator, which will trigger the 2nd DAG
+2. 2nd DAG (example_trigger_target_dag) which will be triggered by the TriggerDagRunOperator in the 1st DAG
+"""
+
+from __future__ import annotations
+
+import pendulum
+
+from airflow.providers.standard.operators.trigger_dagrun import TriggerDagRunOperator
+from airflow.sdk import DAG
+
+with DAG(
+    dag_id="example_trigger_controller_dag",
+    start_date=pendulum.datetime(2021, 1, 1, tz="UTC"),
+    catchup=False,
+    schedule="@once",
+    tags=["example"],
+) as dag:
+    # [START howto_operator_trigger_dagrun]
+
+    trigger = TriggerDagRunOperator(
+        task_id="test_trigger_dagrun",
+        trigger_dag_id="example_trigger_target_dag",  # Ensure this equals the dag_id of the DAG to trigger
+        conf={"message": "Hello World"},
+    )
+
+    # [END howto_operator_trigger_dagrun]

airflow/providers/standard/example_dags/sql/__init__.py

@@ -0,0 +1,16 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.

airflow/providers/standard/example_dags/sql/sample.sql

@@ -0,0 +1,24 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements.  See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership.  The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License.  You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied.  See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+CREATE TABLE Orders (
+    order_id INT PRIMARY KEY,
+    name TEXT,
+    description TEXT
+)

airflow/providers/standard/operators/python.py

@@ -31,6 +31,7 @@ import warnings
 from abc import ABCMeta, abstractmethod
 from collections.abc import Collection, Container, Iterable, Mapping, Sequence
 from functools import cache
+from itertools import chain
 from pathlib import Path
 from tempfile import TemporaryDirectory
 from typing import TYPE_CHECKING, Any, Callable, NamedTuple, cast
@@ -494,9 +495,21 @@ class _BasePythonVirtualenvOperator(PythonOperator, metaclass=ABCMeta):
         return textwrap.dedent(inspect.getsource(self.python_callable))
 
     def _write_args(self, file: Path):
+        def resolve_proxies(obj):
+            """Recursively replaces lazy_object_proxy.Proxy instances with their resolved values."""
+            if isinstance(obj, lazy_object_proxy.Proxy):
+                return obj.__wrapped__  # force evaluation
+            if isinstance(obj, dict):
+                return {k: resolve_proxies(v) for k, v in obj.items()}
+            if isinstance(obj, list):
+                return [resolve_proxies(v) for v in obj]
+            return obj
+
         if self.op_args or self.op_kwargs:
             self.log.info("Use %r as serializer.", self.serializer)
-            file.write_bytes(self.pickling_library.dumps({"args": self.op_args, "kwargs": self.op_kwargs}))
+            file.write_bytes(
+                self.pickling_library.dumps({"args": self.op_args, "kwargs": resolve_proxies(self.op_kwargs)})
+            )
 
     def _write_string_args(self, file: Path):
         file.write_text("\n".join(map(str, self.string_args)))
@@ -859,14 +872,7 @@ class PythonVirtualenvOperator(_BasePythonVirtualenvOperator):
             # If we're using system packages, assume both are present
             found_airflow = found_pendulum = True
         else:
-            requirements_iterable = []
-            if isinstance(self.requirements, str):
-                requirements_iterable = self.requirements.splitlines()
-            else:
-                for item in self.requirements:
-                    requirements_iterable.extend(item.splitlines())
-
-            for raw_str in requirements_iterable:
+            for raw_str in chain.from_iterable(req.splitlines() for req in self.requirements):
                 line = raw_str.strip()
                 # Skip blank lines and full‐line comments
                 if not line or line.startswith("#"):

airflow/providers/standard/sensors/date_time.py

@@ -25,6 +25,7 @@ from typing import TYPE_CHECKING, Any, NoReturn
 from airflow.providers.standard.triggers.temporal import DateTimeTrigger
 from airflow.providers.standard.version_compat import AIRFLOW_V_3_0_PLUS
 from airflow.sensors.base import BaseSensorOperator
+from airflow.utils import timezone
 
 try:
     from airflow.triggers.base import StartTriggerArgs
@@ -41,8 +42,6 @@ except ImportError:
         timeout: datetime.timedelta | None = None
 
 
-from airflow.utils import timezone
-
 if TYPE_CHECKING:
     try:
         from airflow.sdk.definitions.context import Context
@@ -99,6 +98,13 @@ class DateTimeSensor(BaseSensorOperator):
         self.log.info("Checking if the time (%s) has come", self.target_time)
         return timezone.utcnow() > timezone.parse(self.target_time)
 
+    @property
+    def _moment(self) -> datetime.datetime:
+        if isinstance(self.target_time, datetime.datetime):
+            return self.target_time
+
+        return timezone.parse(self.target_time)
+
 
 class DateTimeSensorAsync(DateTimeSensor):
     """
@@ -145,11 +151,11 @@ class DateTimeSensorAsync(DateTimeSensor):
         self.defer(
             method_name="execute_complete",
             trigger=DateTimeTrigger(
-                moment=timezone.parse(self.target_time),
+                moment=self._moment,
                 end_from_trigger=self.end_from_trigger,
             )
             if AIRFLOW_V_3_0_PLUS
-            else DateTimeTrigger(moment=timezone.parse(self.target_time)),
+            else DateTimeTrigger(moment=self._moment),
         )
 
     def execute_complete(self, context: Context, event: Any = None) -> None:

airflow/providers/standard/sensors/external_task.py

@@ -260,12 +260,13 @@ class ExternalTaskSensor(BaseSensorOperator):
 
     def _get_dttm_filter(self, context):
         logical_date = context.get("logical_date")
-        if logical_date is None:
-            dag_run = context.get("dag_run")
-            if TYPE_CHECKING:
-                assert dag_run
+        if AIRFLOW_V_3_0_PLUS:
+            if logical_date is None:
+                dag_run = context.get("dag_run")
+                if TYPE_CHECKING:
+                    assert dag_run
 
-            logical_date = dag_run.run_after
+                logical_date = dag_run.run_after
         if self.execution_delta:
             dttm = logical_date - self.execution_delta
         elif self.execution_date_fn:
@@ -428,7 +429,7 @@ class ExternalTaskSensor(BaseSensorOperator):
         else:
             dttm_filter = self._get_dttm_filter(context)
             logical_or_execution_dates = (
-                {"logical_dates": dttm_filter} if AIRFLOW_V_3_0_PLUS else {"execution_date": dttm_filter}
+                {"logical_dates": dttm_filter} if AIRFLOW_V_3_0_PLUS else {"execution_dates": dttm_filter}
             )
             self.defer(
                 timeout=self.execution_timeout,

airflow/providers/standard/sensors/time.py

@@ -18,9 +18,12 @@
 from __future__ import annotations
 
 import datetime
+import warnings
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, NoReturn
+from typing import TYPE_CHECKING, Any
 
+from airflow.configuration import conf
+from airflow.exceptions import AirflowProviderDeprecationWarning
 from airflow.providers.standard.triggers.temporal import DateTimeTrigger
 from airflow.sensors.base import BaseSensorOperator
 
@@ -54,6 +57,7 @@ class TimeSensor(BaseSensorOperator):
     Waits until the specified time of the day.
 
     :param target_time: time after which the job succeeds
+    :param deferrable: whether to defer execution
 
     .. seealso::
         For more information on how to use this sensor, take a look at the guide:
@@ -61,32 +65,6 @@ class TimeSensor(BaseSensorOperator):
 
     """
 
-    def __init__(self, *, target_time: datetime.time, **kwargs) -> None:
-        super().__init__(**kwargs)
-        self.target_time = target_time
-
-    def poke(self, context: Context) -> bool:
-        self.log.info("Checking if the time (%s) has come", self.target_time)
-        return timezone.make_naive(timezone.utcnow(), self.dag.timezone).time() > self.target_time
-
-
-class TimeSensorAsync(BaseSensorOperator):
-    """
-    Waits until the specified time of the day.
-
-    This frees up a worker slot while it is waiting.
-
-    :param target_time: time after which the job succeeds
-    :param start_from_trigger: Start the task directly from the triggerer without going into the worker.
-    :param end_from_trigger: End the task directly from the triggerer without going into the worker.
-    :param trigger_kwargs: The keyword arguments passed to the trigger when start_from_trigger is set to True
-        during dynamic task mapping. This argument is not used in standard usage.
-
-    .. seealso::
-        For more information on how to use this sensor, take a look at the guide:
-        :ref:`howto/operator:TimeSensorAsync`
-    """
-
     start_trigger_args = StartTriggerArgs(
         trigger_cls="airflow.providers.standard.triggers.temporal.DateTimeTrigger",
         trigger_kwargs={"moment": "", "end_from_trigger": False},
@@ -100,32 +78,66 @@ class TimeSensorAsync(BaseSensorOperator):
         self,
         *,
         target_time: datetime.time,
+        deferrable: bool = conf.getboolean("operators", "default_deferrable", fallback=False),
         start_from_trigger: bool = False,
-        trigger_kwargs: dict[str, Any] | None = None,
         end_from_trigger: bool = False,
+        trigger_kwargs: dict[str, Any] | None = None,
         **kwargs,
     ) -> None:
         super().__init__(**kwargs)
-        self.start_from_trigger = start_from_trigger
-        self.end_from_trigger = end_from_trigger
-        self.target_time = target_time
 
+        # Create a "date-aware" timestamp that will be used as the "target_datetime". This is a requirement
+        # of the DateTimeTrigger
+
+        # Get date considering dag.timezone
         aware_time = timezone.coerce_datetime(
-            datetime.datetime.combine(datetime.datetime.today(), self.target_time, self.dag.timezone)
+            datetime.datetime.combine(
+                datetime.datetime.now(self.dag.timezone), target_time, self.dag.timezone
+            )
         )
 
+        # Now that the dag's timezone has made the datetime timezone aware, we need to convert to UTC
         self.target_datetime = timezone.convert_to_utc(aware_time)
+        self.deferrable = deferrable
+        self.start_from_trigger = start_from_trigger
+        self.end_from_trigger = end_from_trigger
+
         if self.start_from_trigger:
             self.start_trigger_args.trigger_kwargs = dict(
                 moment=self.target_datetime, end_from_trigger=self.end_from_trigger
             )
 
-    def execute(self, context: Context) -> NoReturn:
-        self.defer(
-            trigger=DateTimeTrigger(moment=self.target_datetime, end_from_trigger=self.end_from_trigger),
-            method_name="execute_complete",
-        )
+    def execute(self, context: Context) -> None:
+        if self.deferrable:
+            self.defer(
+                trigger=DateTimeTrigger(
+                    moment=self.target_datetime,  # This needs to be an aware timestamp
+                    end_from_trigger=self.end_from_trigger,
+                ),
+                method_name="execute_complete",
+            )
+
+    def execute_complete(self, context: Context) -> None:
+        return
 
-    def execute_complete(self, context: Context, event: Any = None) -> None:
-        """Handle the event when the trigger fires and return immediately."""
-        return None
+    def poke(self, context: Context) -> bool:
+        self.log.info("Checking if the time (%s) has come", self.target_datetime)
+
+        # self.target_date has been converted to UTC, so we do not need to convert timezone
+        return timezone.utcnow() > self.target_datetime
+
+
+class TimeSensorAsync(TimeSensor):
+    """
+    Deprecated. Use TimeSensor with deferrable=True instead.
+
+    :sphinx-autoapi-skip:
+    """
+
+    def __init__(self, **kwargs) -> None:
+        warnings.warn(
+            "TimeSensorAsync is deprecated and will be removed in a future version. Use `TimeSensor` with deferrable=True instead.",
+            AirflowProviderDeprecationWarning,
+            stacklevel=2,
+        )
+        super().__init__(deferrable=True, **kwargs)