dara-core 1.20.1a1__py3-none-any.whl → 1.20.1a3__py3-none-any.whl

dara/core/internal/encoder_registry.py

@@ -14,13 +14,13 @@ 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.
 """
-# pylint: disable=unnecessary-lambda
+
+from collections.abc import MutableMapping
 from inspect import Parameter, isclass
 from typing import (
     Any,
     Callable,
     Dict,
-    MutableMapping,
     Optional,
     Type,
     Union,
@@ -99,11 +99,11 @@ def _tuple_key_deserialize(d):
         if isinstance(key, str) and key.startswith('__tuple__'):
             key_list = []
             for each in key[10:-1].split(', '):
-                if (each.startswith("'") and each.endswith(("'"))) or (each.startswith('"') and each.endswith(('"'))):
+                if (each.startswith("'") and each.endswith("'")) or (each.startswith('"') and each.endswith('"')):
                     key_list.append(each[1:-1])
                 else:
                     key_list.append(each)
-            encoded_key = encoded_key = tuple(key_list)
+            encoded_key = tuple(key_list)
         else:
             encoded_key = key
 
@@ -112,7 +112,7 @@ def _tuple_key_deserialize(d):
     return encoded_dict
 
 
-def _df_deserialize(x):  # pylint: disable=inconsistent-return-statements
+def _df_deserialize(x):
     """
     A function to deserialize data into a DataFrame
 
@@ -240,14 +240,14 @@ def deserialize(value: Any, typ: Optional[Type]):
         return value
 
     # Already matches type
-    if type(value) == typ:
+    if type(value) is typ:
         return value
 
     # Handle Optional[foo] / Union[foo, None] -> call deserialize(value, foo)
     if get_origin(typ) == Union:
         args = get_args(typ)
         if len(args) == 2 and type(None) in args:
-            not_none_arg = args[0] if args[0] != type(None) else args[1]
+            not_none_arg = args[0] if args[0] is not type(None) else args[1]
             return deserialize(value, not_none_arg)
 
     try:

dara/core/internal/execute_action.py

@@ -14,11 +14,13 @@ 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 asyncio
+from collections.abc import Mapping
 from contextvars import ContextVar
-from typing import Any, Callable, Mapping, Optional, Union
+from typing import Any, Callable, Optional, Union
 
 import anyio
 
@@ -30,11 +32,7 @@ from dara.core.interactivity.actions import (
     ActionImpl,
 )
 from dara.core.internal.cache_store import CacheStore
-from dara.core.internal.dependency_resolution import (
-    is_resolved_derived_data_variable,
-    is_resolved_derived_variable,
-    resolve_dependency,
-)
+from dara.core.internal.dependency_resolution import resolve_dependency
 from dara.core.internal.encoder_registry import deserialize
 from dara.core.internal.tasks import MetaTask, TaskManager
 from dara.core.internal.utils import run_user_handler
@@ -145,15 +143,15 @@ async def execute_action(
     if values is not None:
         annotations = action.__annotations__
 
-        for key, value in values.items():
-            # Override `force` property to be false
-            if is_resolved_derived_variable(value) or is_resolved_derived_data_variable(value):
-                value['force'] = False
-
+        async def _resolve_kwarg(val: Any, key: str):
             typ = annotations.get(key)
-            val = await resolve_dependency(value, store, task_mgr)
+            val = await resolve_dependency(val, store, task_mgr)
             resolved_kwargs[key] = deserialize(val, typ)
 
+        async with anyio.create_task_group() as tg:
+            for key, value in values.items():
+                tg.start_soon(_resolve_kwarg, value, key)
+
     # Merge resolved dynamic kwargs with static kwargs received
     resolved_kwargs = {**resolved_kwargs, **static_kwargs}
 
@@ -177,9 +175,11 @@ async def execute_action(
 
         # Note: no associated registry entry, the result are not persisted in cache
         # Return a metatask which, when all dependencies are ready, will stream the action results to the frontend
-        return MetaTask(
+        meta_task = MetaTask(
             process_result=_stream_action, args=[action, ctx], kwargs=resolved_kwargs, notify_channels=notify_channels
         )
+        task_mgr.register_task(meta_task)
+        return meta_task
 
     # No tasks - run directly as an asyncio task and return the execution id
     # Originally used to use FastAPI BackgroundTasks, but these ended up causing a blocking behavior that blocked some

dara/core/internal/hashing.py

@@ -31,8 +31,6 @@ def hash_object(obj: Union[BaseModel, dict, None]):
     if isinstance(obj, BaseModel):
         obj = obj.model_dump()
 
-    filter_hash = hashlib.sha1(
-        usedforsecurity=False
-    )   # nosec B303 # we don't use this for security purposes just as a cache key
+    filter_hash = hashlib.sha1(usedforsecurity=False)  # nosec B303 # we don't use this for security purposes just as a cache key
     filter_hash.update(json.dumps(obj or {}, sort_keys=True).encode())
     return filter_hash.hexdigest()

dara/core/internal/import_discovery.py

@@ -93,10 +93,9 @@ def run_discovery(
     # If module root is passed through, use it
     if 'module_root' in kwargs:
         root = kwargs.get('module_root')
-    else:
-        # Try to infer from module_name
-        if module_name is not None:
-            root = module_name.split('.')[0]
+    # Try to infer from module_name
+    elif module_name is not None:
+        root = module_name.split('.')[0]
 
     for k, v in global_symbols.items():
         # Ignore already encountered functions

dara/core/internal/multi_resource_lock.py

@@ -0,0 +1,70 @@
+from collections import Counter
+from contextlib import asynccontextmanager
+
+import anyio
+
+
+class MultiResourceLock:
+    """
+    A class that manages multiple named locks for concurrent access to shared resources.
+
+    This class allows for acquiring and releasing locks on named resources, ensuring
+    that only one task can access a specific resource at a time. It automatically
+    creates locks for new resources and cleans them up when they're no longer in use.
+
+    :reentrant:
+        If True a task can acquire the same resource more than once; every
+        subsequent acquire of an already-held lock is a no-op.  If False the
+        second attempt raises ``RuntimeError``.
+    """
+
+    def __init__(self):
+        self._locks: dict[str, anyio.Lock] = {}
+        self._waiters = Counter[str]()
+        self._cleanup_lock = anyio.Lock()
+
+    def is_locked(self, resource_name: str) -> bool:
+        """
+        Check if a lock for the specified resource is currently held.
+
+        :param resource_name (str): The name of the resource to check.
+        :return: True if the lock is held, False otherwise.
+        """
+        return resource_name in self._locks and self._locks[resource_name].locked()
+
+    @asynccontextmanager
+    async def acquire(self, resource_name: str):
+        """
+        Acquire a lock for the specified resource.
+
+        This method is an async context manager that acquires a lock for the given
+        resource name. If the lock doesn't exist, it creates one. It also keeps
+        track of waiters to ensure proper cleanup when the resource is no longer in use.
+
+        :param resource_name (str): The name of the resource to lock.
+
+        Usage:
+        ```python
+        async with multi_lock.acquire_lock("resource_a"):
+            # Critical section for "resource_a"
+            ...
+        ```
+
+        Note:
+            The lock is automatically released when exiting the context manager.
+        """
+
+        async with self._cleanup_lock:
+            if resource_name not in self._locks:
+                self._locks[resource_name] = anyio.Lock()
+            self._waiters[resource_name] += 1
+
+        try:
+            async with self._locks[resource_name]:
+                yield
+        finally:
+            async with self._cleanup_lock:
+                self._waiters[resource_name] -= 1
+                if self._waiters[resource_name] <= 0:
+                    del self._waiters[resource_name]
+                    del self._locks[resource_name]

dara/core/internal/normalization.py

@@ -15,11 +15,11 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
+from collections.abc import Mapping
 from typing import (
     Any,
     Generic,
     List,
-    Mapping,
     Optional,
     Tuple,
     TypeVar,
@@ -31,7 +31,6 @@ from typing import (
 from typing_extensions import TypedDict, TypeGuard
 
 from dara.core.base_definitions import DaraBaseModel as BaseModel
-from dara.core.internal.hashing import hash_object
 
 JsonLike = Union[Mapping, List]
 
@@ -48,7 +47,7 @@ class Placeholder(TypedDict):
     Placeholder object 'Referrable' objects are replaced with
     """
 
-    __ref: str   # pylint: disable=unused-private-member
+    __ref: str
 
 
 class Referrable(TypedDict):
@@ -56,7 +55,7 @@ class Referrable(TypedDict):
     Describes an object which can be replaced by a Placeholder.
     """
 
-    __typename: str   # pylint: disable=unused-private-member
+    __typename: str
     uid: str
 
 
@@ -81,10 +80,6 @@ def _get_identifier(obj: Referrable) -> str:
         nested = ','.join(cast(List[str], obj['nested']))
         identifier = f'{identifier}:{nested}'
 
-    if _is_referrable_with_filters(obj):
-        filter_hash = hash_object(obj['filters'])
-        identifier = f'{identifier}:{filter_hash}'
-
     return identifier
 
 
@@ -133,13 +128,11 @@ def _loop(iterable: JsonLike):
 
 
 @overload
-def normalize(obj: Mapping, check_root: bool = True) -> Tuple[Mapping, Mapping]:
-    ...
+def normalize(obj: Mapping, check_root: bool = True) -> Tuple[Mapping, Mapping]: ...
 
 
 @overload
-def normalize(obj: List, check_root: bool = True) -> Tuple[List, Mapping]:
-    ...
+def normalize(obj: List, check_root: bool = True) -> Tuple[List, Mapping]: ...
 
 
 def normalize(obj: JsonLike, check_root: bool = True) -> Tuple[JsonLike, Mapping]:
@@ -169,7 +162,7 @@ def normalize(obj: JsonLike, check_root: bool = True) -> Tuple[JsonLike, Mapping
         for key, value in _loop(obj):
             # For iterables, recursively call normalize
             if isinstance(value, (dict, list)):
-                _normalized, _lookup = normalize(value)   # type: ignore
+                _normalized, _lookup = normalize(value)  # type: ignore
                 output[key] = _normalized  # type: ignore
                 lookup.update(_lookup)
             else:
@@ -180,13 +173,11 @@ def normalize(obj: JsonLike, check_root: bool = True) -> Tuple[JsonLike, Mapping
 
 
 @overload
-def denormalize(normalized_obj: Mapping, lookup: Mapping) -> Mapping:
-    ...
+def denormalize(normalized_obj: Mapping, lookup: Mapping) -> Mapping: ...
 
 
 @overload
-def denormalize(normalized_obj: List, lookup: Mapping) -> List:
-    ...
+def denormalize(normalized_obj: List, lookup: Mapping) -> List: ...
 
 
 def denormalize(normalized_obj: JsonLike, lookup: Mapping) -> Optional[JsonLike]:
@@ -206,7 +197,7 @@ def denormalize(normalized_obj: JsonLike, lookup: Mapping) -> Optional[JsonLike]
     # Whole object is a placeholder
     if _is_placeholder(normalized_obj):
         ref = normalized_obj['__ref']
-        referrable = lookup[ref] if ref in lookup else None
+        referrable = lookup.get(ref, None)
 
         if isinstance(referrable, (list, dict)):
             return denormalize(referrable, lookup)

dara/core/internal/pandas_utils.py

@@ -15,13 +15,24 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-from typing import Optional, TypeVar
+import json
+import uuid
+from typing import Any, Literal, Optional, TypeVar, Union, cast, overload
 
-from pandas import DataFrame, MultiIndex
+from pandas import DataFrame, MultiIndex, Series
+from typing_extensions import TypedDict, TypeGuard
 
 INDEX = '__index__'
 
 
+@overload
+def append_index(df: DataFrame) -> DataFrame: ...
+
+
+@overload
+def append_index(df: None) -> None: ...
+
+
 def append_index(df: Optional[DataFrame]) -> Optional[DataFrame]:
     """
     Add a numerical index column to the dataframe
@@ -31,7 +42,7 @@ def append_index(df: Optional[DataFrame]) -> Optional[DataFrame]:
 
     if INDEX not in df.columns:
         new_df = df.copy()
-        new_df.insert(0, INDEX, range(0, len(df.index)))
+        new_df.insert(0, INDEX, range(0, len(df.index)))  # type: ignore
         return new_df
 
     return df
@@ -47,7 +58,7 @@ def remove_index(value: value_type) -> value_type:
     Otherwise return same value untouched.
     """
     if isinstance(value, DataFrame):
-        return value.drop(columns=['__index__'], inplace=False, errors='ignore')
+        return cast(value_type, value.drop(columns=['__index__'], inplace=False, errors='ignore'))
 
     return value
 
@@ -65,6 +76,12 @@ def df_convert_to_internal(original_df: DataFrame) -> DataFrame:
     if any(isinstance(c, str) and c.startswith('__col__') for c in df.columns):
         return df
 
+    # Apply display transformations to the DataFrame
+    format_for_display(df)
+
+    # Append index to match the way we process the original DataFrame
+    df = cast(DataFrame, append_index(df))
+
     # Handle hierarchical columns: [(A, B), (A, C)] -> ['A_B', 'A_C']
     if isinstance(df.columns, MultiIndex):
         df.columns = ['_'.join(col).strip() if col[0] != INDEX else INDEX for col in df.columns.values]
@@ -90,4 +107,89 @@ def df_convert_to_internal(original_df: DataFrame) -> DataFrame:
 
 
 def df_to_json(df: DataFrame) -> str:
-    return df_convert_to_internal(df).to_json(orient='records') or ''
+    return df_convert_to_internal(df).to_json(orient='records', date_unit='ns') or ''
+
+
+def format_for_display(df: DataFrame) -> None:
+    """
+    Apply transformations to a DataFrame to make it suitable for display.
+    Not: this does NOT make a copy of the DataFrame
+    """
+    for col in df.columns:
+        column_data = df[col]
+        if isinstance(column_data, DataFrame):
+            # Handle duplicate column names - format each column in the sub-DataFrame
+            for sub_col in column_data.columns:
+                if isinstance(column_data[sub_col], Series) and column_data[sub_col].dtype == 'object':
+                    column_data.loc[:, sub_col] = column_data[sub_col].apply(str)
+        elif column_data.dtype == 'object':
+            # We need to convert all values to string to avoid issues with
+            # displaying data in the Table component, for example when
+            # displaying datetime and number objects in the same column
+            df.loc[:, col] = column_data.apply(str)
+
+
+class FieldType(TypedDict):
+    name: Union[str, tuple[str, ...]]
+    type: Literal['integer', 'number', 'boolean', 'datetime', 'duration', 'any', 'str']
+
+
+class DataFrameSchema(TypedDict):
+    fields: list[FieldType]
+    primaryKey: list[str]
+
+
+class DataResponse(TypedDict):
+    data: Optional[DataFrame]
+    count: int
+    schema: Optional[DataFrameSchema]
+
+
+def is_data_response(response: Any) -> TypeGuard[DataResponse]:
+    has_shape = isinstance(response, dict) and 'data' in response and 'count' in response
+    if not has_shape:
+        return False
+    return response['data'] is None or isinstance(response['data'], DataFrame)
+
+
+def data_response_to_json(response: DataResponse) -> str:
+    """
+    Serialize a DataResponse to JSON.
+
+    json.dumps() custom serializers only accept value->value mappings, whereas `to_json` on pandas returns a string directly.
+    To avoid double serialization, we first insert a placeholder string and then replace it with the actual serialized JSON.
+    """
+    placeholder = str(uuid.uuid4())
+
+    def _custom_serializer(obj: Any) -> Any:
+        if isinstance(obj, DataFrame):
+            return placeholder
+        raise TypeError(f'Object of type {type(obj)} is not JSON serializable')
+
+    result = json.dumps(response, default=_custom_serializer)
+    result = result.replace(
+        f'"{placeholder}"', df_to_json(response['data']) if response['data'] is not None else 'null'
+    )
+    return result
+
+
+def build_data_response(data: DataFrame, count: int) -> DataResponse:
+    data_internal = df_convert_to_internal(data)
+    schema = get_schema(data_internal)
+
+    return DataResponse(data=data, count=count, schema=schema)
+
+
+def get_schema(df: DataFrame):
+    from pandas.io.json._table_schema import build_table_schema
+
+    raw_schema = build_table_schema(df)
+
+    for field_data in cast(list, raw_schema['fields']):
+        if field_data.get('type') == 'datetime':
+            # for datetime fields we need to know the resolution, so we get the actual e.g. `datetime64[ns]` string
+            column_name = field_data.get('name')
+            dtype_str = str(df[column_name].dtype)
+            field_data['type'] = dtype_str
+
+    return cast(DataFrameSchema, raw_schema)

dara/core/internal/pool/definitions.py

@@ -95,7 +95,7 @@ class TaskDefinition:
     def __await__(self):
         """Await the underlying event, then return or raise the result"""
         yield from self.event.wait().__await__()
-        if isinstance(self.result, Exception):
+        if isinstance(self.result, BaseException):
             raise self.result
         return self.result
 

dara/core/internal/pool/task_pool.py

@@ -16,10 +16,11 @@ limitations under the License.
 """
 
 import atexit
+from collections.abc import Coroutine
 from contextlib import contextmanager
 from datetime import datetime
 from multiprocessing import active_children
-from typing import Any, Callable, Coroutine, Dict, Optional, cast
+from typing import Any, Callable, Dict, Optional, Union, cast
 
 import anyio
 from anyio.abc import TaskGroup
@@ -102,16 +103,18 @@ class TaskPool:
             try:
                 await wait_while(
                     lambda: self.status != PoolStatus.RUNNING
-                    or not len(self.workers) == self.desired_workers
+                    or len(self.workers) != self.desired_workers
                     or not all(w.status == WorkerStatus.IDLE for w in self.workers.values()),
                     timeout=timeout,
                 )
-            except TimeoutError:
-                raise RuntimeError('Failed to start pool')
+            except TimeoutError as e:
+                raise RuntimeError('Failed to start pool') from e
         else:
             raise RuntimeError('Pool already started')
 
-    def submit(self, task_uid: str, function_name: str, args: tuple = (), kwargs: dict = {}) -> TaskDefinition:
+    def submit(
+        self, task_uid: str, function_name: str, args: Union[tuple, None] = None, kwargs: Union[dict, None] = None
+    ) -> TaskDefinition:
         """
         Submit a new task to the pool
 
@@ -120,6 +123,10 @@ class TaskPool:
         :param args: list of arguments to pass to the function
         :param kwargs: dict of kwargs to pass to the function
         """
+        if args is None:
+            args = ()
+        if kwargs is None:
+            kwargs = {}
         self._check_pool_state()
 
         # Create a task definition to keep track of its progress
@@ -151,7 +158,7 @@ class TaskPool:
 
         task = self.tasks.pop(task_uid)
         if not task.event.is_set():
-            task.result = Exception('Task cancelled')
+            task.result = anyio.get_cancelled_exc_class()()
             task.event.set()
 
         # Task in progress, stop the worker
@@ -463,9 +470,8 @@ class TaskPool:
                 )
         elif is_log(worker_msg):
             dev_logger.info(f'Task: {worker_msg["task_uid"]}', {'logs': worker_msg['log']})
-        elif is_progress(worker_msg):
-            if worker_msg['task_uid'] in self._progress_subscribers:
-                await self._progress_subscribers[worker_msg['task_uid']](worker_msg['progress'], worker_msg['message'])
+        elif is_progress(worker_msg) and worker_msg['task_uid'] in self._progress_subscribers:
+            await self._progress_subscribers[worker_msg['task_uid']](worker_msg['progress'], worker_msg['message'])
 
     async def _wait_queue_depletion(self, timeout: Optional[float] = None):
         """
@@ -478,8 +484,8 @@ class TaskPool:
                 condition=lambda: self.status in (PoolStatus.CLOSED, PoolStatus.RUNNING) and len(self.tasks) > 0,
                 timeout=timeout,
             )
-        except TimeoutError:
-            raise TimeoutError('Tasks are still being executed')
+        except TimeoutError as e:
+            raise TimeoutError('Tasks are still being executed') from e
 
     async def _core_loop(self):
         """
@@ -493,11 +499,14 @@ class TaskPool:
             while self.status not in (PoolStatus.ERROR, PoolStatus.STOPPED):
                 await anyio.sleep(0.1)
 
-                self._handle_excess_workers()
-                self._handle_orphaned_workers()
-                self._handle_dead_workers()
-                self._create_workers()
-                await self._process_next_worker_message()
+                try:
+                    self._handle_excess_workers()
+                    self._handle_orphaned_workers()
+                    self._handle_dead_workers()
+                    self._create_workers()
+                    await self._process_next_worker_message()
+                except Exception as e:
+                    dev_logger.error('Error in task pool', e)
         finally:
             self.loop_stopped.set()
 

dara/core/internal/pool/utils.py

@@ -27,6 +27,8 @@ from typing import Any, Callable, Optional, Tuple
 import anyio
 from tblib import Traceback
 
+from dara.core.logging import dev_logger
+
 
 class SubprocessException:
     """
@@ -89,9 +91,7 @@ def read_from_shared_memory(pointer: SharedMemoryPointer) -> Any:
         data = shared_mem.buf[:data_size]
 
         # Unpickle and deepcopy
-        decoded_payload_shared = pickle.loads(
-            shared_mem.buf
-        )   # nosec B301 # we trust the shared memory pointer passed by the pool
+        decoded_payload_shared = pickle.loads(shared_mem.buf)  # nosec B301 # we trust the shared memory pointer passed by the pool
         decoded_payload = copy.deepcopy(decoded_payload_shared)
 
         # Cleanup
@@ -133,20 +133,23 @@ async def stop_process_async(process: BaseProcess, timeout: float = 3):
     # Terminate and wait for it to shutdown
     process.terminate()
 
-    # mimic process.join() in an async way to not block
-    await wait_while(process.is_alive, timeout)
-
-    # If it's still alive
-    if process.is_alive():
-        try:
-            os.kill(process.pid, signal.SIGKILL)
-            await wait_while(process.is_alive, timeout)
-        except OSError:
+    try:
+        # mimic process.join() in an async way to not block
+        await wait_while(process.is_alive, timeout)
+
+        # If it's still alive
+        if process.is_alive():
+            try:
+                os.kill(process.pid, signal.SIGKILL)
+                await wait_while(process.is_alive, timeout)
+            except OSError as e:
+                raise RuntimeError(f'Unable to terminate subprocess with PID {process.pid}') from e
+
+        # If it's still alive raise an exception
+        if process.is_alive():
             raise RuntimeError(f'Unable to terminate subprocess with PID {process.pid}')
-
-    # If it's still alive raise an exception
-    if process.is_alive():
-        raise RuntimeError(f'Unable to terminate subprocess with PID {process.pid}')
+    except Exception as e:
+        dev_logger.error('Error stopping process', e)
 
 
 def stop_process(process: BaseProcess, timeout: float = 3):
@@ -171,8 +174,8 @@ def stop_process(process: BaseProcess, timeout: float = 3):
         try:
             os.kill(process.pid, signal.SIGKILL)
             process.join(timeout)
-        except OSError:
-            raise RuntimeError(f'Unable to terminate subprocess with PID {process.pid}')
+        except OSError as e:
+            raise RuntimeError(f'Unable to terminate subprocess with PID {process.pid}') from e
 
     # If it's still alive raise an exception
     if process.is_alive():

dara/core/internal/pool/worker.py

@@ -57,7 +57,8 @@ class StdoutLogger:
             self.channel.worker_api.log(self.task_uid, msg)
 
     def flush(self):
-        sys.__stdout__.flush()
+        if sys.__stdout__:
+            sys.__stdout__.flush()
 
 
 def execute_function(func: Callable, args: tuple, kwargs: dict):
@@ -164,7 +165,7 @@ def worker_loop(worker_params: WorkerParameters, channel: Channel):
 
         # Redirect logs via the channel
         stdout_logger = StdoutLogger(task_uid, channel)
-        sys.stdout = stdout_logger   # type: ignore
+        sys.stdout = stdout_logger  # type: ignore
 
         try:
             payload_pointer = task['payload']

dara/core/internal/port_utils.py

@@ -27,7 +27,7 @@ def is_available(host: str, port: int) -> bool:
     """
     try:
         with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
-            sock.settimeout(2.0)   # timeout in case port is blocked
+            sock.settimeout(2.0)  # timeout in case port is blocked
             return sock.connect_ex((host, port)) != 0
     except BaseException:
         return False