fix(metrics): streamline async scoring methods and apply nest_asyncio

- Replaced event loop checks with a unified async wrapper for scoring.
- Simplified error handling and callback management.
- Ensured compatibility with Jupyter environments by applying nest_asyncio directly.

Author: alex-graber-pmi

ragas/src/ragas/metrics/base.py

@@ -12,7 +12,7 @@
 from tqdm import tqdm
 
 from ragas._analytics import EvaluationEvent, _analytics_batcher
-from ragas.async_utils import is_event_loop_running
+from ragas.async_utils import apply_nest_asyncio, run
 from ragas.callbacks import ChainType, new_group
 from ragas.dataset_schema import MetricAnnotation, MultiTurnSample, SingleTurnSample
 from ragas.losses import BinaryMetricLoss, MSELoss
@@ -143,26 +143,22 @@ def score(self, row: t.Dict, callbacks: Callbacks = None) -> float:
             callbacks=callbacks,
             metadata={"type": ChainType.METRIC},
         )
-        try:
-            if is_event_loop_running():
-                try:
-                    import nest_asyncio
 
-                    nest_asyncio.apply()
-                except ImportError:
-                    raise ImportError(
-                        "It seems like your running this in a jupyter-like environment. Please install nest_asyncio with `pip install nest_asyncio` to make it work."
-                    )
-            loop = asyncio.get_event_loop()
-            score = loop.run_until_complete(self._ascore(row=row, callbacks=group_cm))
-        except Exception as e:
-            if not group_cm.ended:
-                rm.on_chain_error(e)
-            raise e
-        else:
-            if not group_cm.ended:
-                rm.on_chain_end({"output": score})
-        return score
+        async def _async_wrapper():
+            try:
+                result = await self._ascore(row=row, callbacks=group_cm)
+            except Exception as e:
+                if not group_cm.ended:
+                    rm.on_chain_error(e)
+                raise e
+            else:
+                if not group_cm.ended:
+                    rm.on_chain_end({"output": result})
+                return result
+
+        # Apply nest_asyncio logic to ensure compatibility in notebook/Jupyter environments.
+        apply_nest_asyncio()
+        return run(_async_wrapper)
 
     @deprecated("0.2", removal="0.3", alternative="single_turn_ascore")
     async def ascore(
@@ -477,27 +473,23 @@ def single_turn_score(
             callbacks=callbacks,
             metadata={"type": ChainType.METRIC},
         )
-        try:
-            if is_event_loop_running():
-                try:
-                    import nest_asyncio
 
-                    nest_asyncio.apply()
-                except ImportError:
-                    raise ImportError(
-                        "It seems like your running this in a jupyter-like environment. Please install nest_asyncio with `pip install nest_asyncio` to make it work."
-                    )
-            loop = asyncio.get_event_loop()
-            score = loop.run_until_complete(
-                self._single_turn_ascore(sample=sample, callbacks=group_cm)
-            )
-        except Exception as e:
-            if not group_cm.ended:
-                rm.on_chain_error(e)
-            raise e
-        else:
-            if not group_cm.ended:
-                rm.on_chain_end({"output": score})
+        async def _async_wrapper():
+            try:
+                result = await self._single_turn_ascore(
+                    sample=sample, callbacks=group_cm
+                )
+            except Exception as e:
+                if not group_cm.ended:
+                    rm.on_chain_error(e)
+                raise e
+            else:
+                if not group_cm.ended:
+                    rm.on_chain_end({"output": result})
+                return result
+
+        apply_nest_asyncio()
+        score = run(_async_wrapper)
 
         # track the evaluation event
         _analytics_batcher.add_evaluation(
@@ -605,27 +597,23 @@ def multi_turn_score(
             callbacks=callbacks,
             metadata={"type": ChainType.METRIC},
         )
-        try:
-            if is_event_loop_running():
-                try:
-                    import nest_asyncio
 
-                    nest_asyncio.apply()
-                except ImportError:
-                    raise ImportError(
-                        "It seems like your running this in a jupyter-like environment. Please install nest_asyncio with `pip install nest_asyncio` to make it work."
-                    )
-            loop = asyncio.get_event_loop()
-            score = loop.run_until_complete(
-                self._multi_turn_ascore(sample=sample, callbacks=group_cm)
-            )
-        except Exception as e:
-            if not group_cm.ended:
-                rm.on_chain_error(e)
-            raise e
-        else:
-            if not group_cm.ended:
-                rm.on_chain_end({"output": score})
+        async def _async_wrapper():
+            try:
+                result = await self._multi_turn_ascore(
+                    sample=sample, callbacks=group_cm
+                )
+            except Exception as e:
+                if not group_cm.ended:
+                    rm.on_chain_error(e)
+                raise e
+            else:
+                if not group_cm.ended:
+                    rm.on_chain_end({"output": result})
+                return result
+
+        apply_nest_asyncio()
+        score = run(_async_wrapper)
 
         # track the evaluation event
         _analytics_batcher.add_evaluation(