PyIAML 1.0.0__py3-none-any.whl

iaml/actionables/predictors/survival/act_random_survival_forest.py

@@ -0,0 +1,91 @@
+"""[STEP] Random Survival Forest"""
+import textwrap
+from typing import Any
+from sksurv.ensemble import RandomSurvivalForest
+
+from ....predictor import Predictor
+from ....candidate import Candidate
+from ....dataset import Dataset
+from ....decorators.all import is_step
+
+
+@is_step('predictor', 'tabular', 'survival')
+class ActRandomSurvivalForest(Predictor):
+    """[STEP] Random Survival Forest"""
+
+    name: str = "RandomSurvivalForest"
+    _usage: str = "Use when you want a flexible tree-ensemble survival model; choose over ActCox when PH is doubtful, or consider ActExtraSurvivalTrees for more randomness. Applicable to tabular time-to-event data with censoring. Avoid when data are tiny or effects are well modeled by linear PH."
+    _description: str = textwrap.dedent('''\
+        RandomSurvivalForest is a survival analysis algorithm
+        that uses an ensemble of decision trees to estimate the survival function
+        over time. It is a non-parametric model that handles complex relationships
+        and can model non-linear effects of covariates.''')
+    _description_long: str = textwrap.dedent('''\
+        RandomSurvivalForest is a flexible survival analysis
+        algorithm that uses an ensemble of decision trees to predict the time
+        until an event occurs. It extends the concept of random forests to survival
+        data, handling complex interactions and non-linear relationships between
+        input features (covariates). Unlike parametric models such as the Cox
+        Proportional Hazards model, RandomSurvivalForest makes fewer assumptions
+        about the underlying data, making it useful in cases where the assumptions
+        of proportional hazards do not hold. It also efficiently manages censored
+        data, where the event may not have occurred during the study period.''')
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2008,
+            'name': 'Random survival forests',
+            'authors': [
+                'H. Ishwaran',
+                'U. B. Kogalur',
+                'E. H. Blackstone',
+                'M. S. Lauer'
+            ],
+            'doi': 'https://doi.org/10.1214/08-AOAS169',
+            'publisher': 'The Annals of Applied Statistics, 2(3): page 841-860'
+        }
+    ]
+
+    def __init__(self):
+        self.configuration: dict = {
+            'n_estimators': {
+                'description': 'Number of trees in the forest.',
+                'default': 100,
+                'range': [1, 1000],
+                'passthrough': True
+            },
+            'min_samples_split': {
+                'description': 'The minimum number of samples required to split an internal node.',
+                'default': 2,
+                'range': [2, 20],
+                'passthrough': True
+            },
+            'min_samples_leaf': {
+                'description': 'The minimum number of samples required to be at a leaf node.',
+                'default': 1,
+                'range': [1, 20],
+                'passthrough': True
+            },
+            'max_depth': {
+                'description': textwrap.dedent('''\
+                    The maximum depth of the tree. If None, then nodes are
+                    expanded until all leaves are pure.'''),
+                'default': None,
+                'range': [1, None],
+                'passthrough': True
+            }
+        }
+        self.model: RandomSurvivalForest = None
+
+    def fit(self, dataset: Dataset):  # pylint: disable=unused-argument
+        self.model = RandomSurvivalForest(
+            **self.passthrough_parameters()
+        )
+        X, y = dataset.to_survival()
+        self.model.fit(X, y)
+        return self
+
+    def suitable(self, dataset: Dataset) -> bool:
+        return dataset.type_of_target == 'survival'
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        return 0.5  # neutral

iaml/actionables/predictors/survival/act_survival_component_wise_gboost.py

@@ -0,0 +1,80 @@
+"""[STEP] Componentwise Gradient Boosting Survival Analysis"""
+import textwrap
+from typing import Any
+from sksurv.ensemble import ComponentwiseGradientBoostingSurvivalAnalysis
+
+from ....predictor import Predictor
+from ....candidate import Candidate
+from ....dataset import Dataset
+from ....decorators.all import is_step
+
+
+@is_step('predictor', 'tabular', 'survival', 'minimal_predictor')
+class ActComponentwiseGradientBoostingSurvivalAnalysis(Predictor):
+    """[STEP] Componentwise Gradient Boosting Survival Analysis"""
+
+    name: str = "ComponentwiseGradientBoostingSurvivalAnalysis"
+    _usage: str = "Use when you want stagewise boosting with feature selection for survival instead of ActGradientBoostingSurvivalAnalysis. Applicable to tabular censored survival data, especially with many features. Avoid when a linear model like ActCox or ActCoxnetSurvivalAnalysis is preferred."
+    _description: str = textwrap.dedent('''\
+        ComponentwiseGradientBoostingSurvivalAnalysis is a survival analysis
+        algorithm that uses gradient boosting with componentwise (stagewise) updates
+        to estimate the survival function over time. This variant of boosting allows
+        the model to fit individual components (features) in a stagewise manner,
+        making it a more interpretable approach for feature selection and model
+        refinement in survival analysis.''')
+    _description_long: str = textwrap.dedent('''\
+        ComponentwiseGradientBoostingSurvivalAnalysis extends
+        gradient boosting for survival analysis by applying updates one component
+        (feature) at a time. This approach improves the model's ability to handle
+        sparse datasets or datasets with high-dimensional features, where only
+        a few variables may have significant effects on survival outcomes.
+        It provides a more interpretable framework for survival analysis,
+        as each boosting iteration focuses on fitting individual covariates
+        rather than combining all features at once. This method is particularly
+        suited for feature selection and handling censored survival data.''')
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2006,
+            'name': 'Survival ensembles',
+            'authors': [
+                'T. Hothorn',
+                'P. B5hlmann',
+                'S. Dudoit',
+                'A. Molinaro',
+                'M. J. van der Laan'
+            ],
+            'doi': 'https://doi.org/10.1093/biostatistics/kxj011',
+            'publisher': 'Biostatistics, 7(3), 355-373'
+        }
+    ]
+
+    def __init__(self):
+        self.configuration: dict = {
+            'n_estimators': {
+                'description': 'Number of boosting stages to be run.',
+                'default': 100,
+                'range': [1, 1000],
+                'passthrough': True
+            },
+            'learning_rate': {
+                'description': 'Learning rate shrinks the contribution of each component.',
+                'default': 0.1,
+                'range': [0.01, 1.0],
+                'passthrough': True
+            }
+        }
+        self.model: ComponentwiseGradientBoostingSurvivalAnalysis = None
+
+    def fit(self, dataset: Dataset):  # pylint: disable=unused-argument
+        self.model = ComponentwiseGradientBoostingSurvivalAnalysis(
+            **self.passthrough_parameters()
+        )
+        X, y = dataset.to_survival()
+        self.model.fit(X, y)
+        return self
+
+    def suitable(self, dataset: Dataset) -> bool:
+        return dataset.type_of_target == 'survival'
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        return 0.5  # neutral

iaml/actionables/predictors/survival/act_survival_tree.py

@@ -0,0 +1,120 @@
+"""[STEP] SurvivalTree"""
+import textwrap
+from typing import Any
+from sksurv.tree import SurvivalTree
+
+from ....predictor import Predictor
+from ....candidate import Candidate
+from ....dataset import Dataset
+from ....decorators.all import is_step
+
+
+@is_step('predictor', 'tabular', 'survival', 'baseline_predictor')
+class ActSurvivalTree(Predictor):
+    """[STEP] SurvivalTree"""
+
+    name: str = "SurvivalTree"
+    _description: str = textwrap.dedent('''\
+        SurvivalTree is a decision tree algorithm tailored for survival analysis.
+        It constructs a tree structure based on the log-rank test, where each split
+        is designed to separate data by survival times. The method handles censored data
+        and outputs risk scores, cumulative hazard functions, and survival functions
+        based on the tree's terminal nodes.''')
+    _description_long: str = textwrap.dedent('''\
+        SurvivalTree builds a decision tree based on survival data, using the
+        log-rank splitting rule to determine the best splits. It is a non-parametric model that
+        is particularly suited for survival analysis with right-censored data. The model provides
+        both cumulative hazard and survival functions at each terminal node, making it useful for
+        clinical risk prediction and other applications where time-to-event outcomes are crucial.
+        ''')
+    _usage: str = "Use when you need an interpretable survival baseline; compare ActCox or ActExtraSurvivalTrees for linear or ensemble options. Applicable to tabular time-to-event data with right censoring. Avoid when higher accuracy is required or proportional-hazards structure is assumed."
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 1993,
+            'name': 'Survival Trees by Goodness of Split',
+            'authors': [
+                'M. Leblanc',
+                'J. Crowley'
+            ],
+            'doi': 'https://doi.org/10.1080/01621459.1993.10476296',
+            'publisher': 'Journal of the American Statistical Association, 88(422), 457-467'
+        }
+    ]
+
+    def __init__(self):
+        self.configuration: dict = {
+            'splitter': {
+                'description': textwrap.dedent('''\
+                    The strategy used to split at each node. Supported: "best",
+                    "random".'''),
+                'default': 'best',
+                'categorical': ['best', 'random'],
+                'passthrough': True
+            },
+            'max_depth': {
+                'description': 'The maximum depth of the tree.',
+                'default': None,
+                'range': [1, None],
+                'passthrough': True
+            },
+            'min_samples_split': {
+                'description': 'The minimum number of samples required to split an internal node.',
+                'default': 6,
+                'range': [2, 20],
+                'passthrough': True
+            },
+            'min_samples_leaf': {
+                'description': 'The minimum number of samples required to be at a leaf node.',
+                'default': 3,
+                'range': [1, 20],
+                'passthrough': True
+            },
+            'min_weight_fraction_leaf': {
+                'description': textwrap.dedent('''\
+                    The minimum weighted fraction of the input samples required
+                    to be at a leaf node.'''),
+                'default': 0.0,
+                'range': [0.0, 0.5],
+                'passthrough': True
+            },
+            'max_features': {
+                'description': textwrap.dedent('''\
+                    The number of features to consider when looking for the
+                    best split.'''),
+                'default': None,
+                'categorical': [None, 'sqrt', 'log2'],
+                'passthrough': True
+            },
+            'random_state': {
+                'description': 'Random seed (integer or None) for the estimator.',
+                'default': None,
+                'passthrough': True
+            },
+            'max_leaf_nodes': {
+                'description': 'Grow a tree with a maximum number of leaf nodes.',
+                'default': None,
+                'range': [None, 1000],
+                'passthrough': True
+            },
+            'low_memory': {
+                'description': 'Reduce memory usage but disable some prediction functions.',
+                'default': False,
+                'categorical': [True, False],
+                'passthrough': True
+            }
+        }
+        self.model: SurvivalTree = None
+
+    def fit(self, dataset: Dataset):  # pylint: disable=unused-argument
+        self.model = SurvivalTree(
+            **self.passthrough_parameters()
+        )
+        X, y = dataset.to_survival()
+        self.model.fit(X, y)
+        return self
+
+    def suitable(self, dataset: Dataset) -> bool:
+        return dataset.type_of_target == 'survival'
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        return 0.5  # neutral

iaml/actionables/predictors/survival/act_survival_xgboost.py

@@ -0,0 +1,9 @@
+"""Compatibility import for the former survival boosting module.
+
+The implementation lives in ``act_gradient_boosting_survival_analysis``.
+Re-export the same class so existing imports and pickles keep resolving without
+registering a second predictor. The backend is scikit-survival, not XGBoost.
+"""
+from .act_gradient_boosting_survival_analysis import ActGradientBoostingSurvivalAnalysis
+
+__all__ = ['ActGradientBoostingSurvivalAnalysis']

iaml/actionables/predictors/survival/act_weibull_aft.py

@@ -0,0 +1,230 @@
+"""[STEP] Weibull AFT"""
+import inspect
+import textwrap
+from typing import Any
+
+import numpy as np
+
+try:
+    from sksurv.linear_model import WeibullAFT
+except Exception:  # pragma: no cover - optional dependency
+    try:
+        from sksurv.parametric import WeibullAFT
+    except Exception:  # pragma: no cover - optional dependency
+        WeibullAFT = None
+
+try:
+    from lifelines import WeibullAFTFitter
+except Exception:  # pragma: no cover - optional dependency
+    WeibullAFTFitter = None
+
+from ....predictor import Predictor
+from ....candidate import Candidate
+from ....dataset import Dataset
+from ....data_type import DataType
+from ....decorators.all import is_step
+
+
+@is_step('predictor', 'tabular', 'survival')
+class ActWeibullAFT(Predictor):
+    """[STEP] Weibull AFT"""
+
+    name: str = "WeibullAFT"
+    _usage: str = "Use when you want a parametric Weibull AFT model with time ratios, rather than ActCox. Applicable to tabular right-censored survival data with numeric features. Avoid when Weibull fit is implausible or you need flexible nonparametric models like ActExtraSurvivalTrees."
+    _description: str = textwrap.dedent('''\
+        WeibullAFT is a parametric accelerated failure time model
+        that assumes survival times follow a Weibull distribution and
+        models how covariates speed up or slow down the event time.
+        Uses scikit-survival when available and falls back to lifelines.''')
+    _description_long: str = textwrap.dedent('''\
+        WeibullAFT fits an accelerated failure time model where the log of
+        survival time is a linear function of the input features and the
+        baseline survival follows a Weibull distribution. The model provides
+        parametric survival and hazard estimates, supports right-censored data,
+        and yields interpretable covariate effects on time-to-event outcomes.
+        This step uses scikit-survival when available and falls back to
+        lifelines when needed.''')
+
+    def __init__(self):
+        self.configuration: dict = {
+            'alpha': {
+                'description': textwrap.dedent('''\
+                    Regularization strength for scikit-survival. Higher values
+                    enforce stronger regularization.'''),
+                'default': 0.05,
+                'range': [1e-04, 10.0]
+            },
+            'penalizer': {
+                'description': textwrap.dedent('''\
+                    L2 penalizer strength for lifelines models.'''),
+                'default': 0.0,
+                'range': [0.0, 10.0]
+            },
+            'l1_ratio': {
+                'description': textwrap.dedent('''\
+                    Mixing parameter between L1 and L2 penalties.'''),
+                'default': 0.0,
+                'range': [0.0, 1.0]
+            },
+            'fit_intercept': {
+                'description': 'Whether to fit the intercept term.',
+                'default': True,
+                'categorical': [True, False]
+            },
+            'max_iter': {
+                'description': 'Maximum number of iterations for the optimizer.',
+                'default': 1000,
+                'range': [10, 100000]
+            },
+            'tol': {
+                'description': 'Stopping tolerance.',
+                'default': 1e-07,
+                'range': [1e-09, 1e-03]
+            }
+        }
+        self.model: Any = None
+        self.columns: list[str] = []
+        self.backend: str | None = None
+        self._lifelines_event_col: str | None = None
+        self._lifelines_time_col: str | None = None
+
+    def _select_features(self, X):
+        if self.columns and hasattr(X, 'columns'):
+            return X[self.columns]
+        return X
+
+    def _resolve_backend(self) -> tuple[str | None, Any | None]:
+        if WeibullAFT is not None:
+            return 'sksurv', WeibullAFT
+        if WeibullAFTFitter is not None:
+            return 'lifelines', WeibullAFTFitter
+        return None, None
+
+    def _model_parameters(self, model_cls: Any, backend: str) -> dict[str, Any]:
+        params = self.passthrough_parameters()
+        if backend == 'lifelines':
+            params.pop('alpha', None)
+
+        if model_cls is None:
+            return params
+
+        try:
+            sig_params = inspect.signature(model_cls).parameters
+        except (TypeError, ValueError):
+            return params
+
+        return {key: value for key, value in params.items() if key in sig_params}
+
+    @staticmethod
+    def _split_survival_target(y) -> tuple[np.ndarray, np.ndarray]:
+        samples = Dataset.normalize_survival_target(y)
+        if not samples:
+            return np.array([], dtype=bool), np.array([], dtype=float)
+        events, times = zip(*samples)
+        return np.asarray(events, dtype=bool), np.asarray(times, dtype=float)
+
+    @staticmethod
+    def _unique_column_name(base: str, columns) -> str:
+        name = base
+        while name in columns:
+            name = f"_{name}"
+        return name
+
+    def _prepare_lifelines_frame(self, X, y) -> tuple[Any, str, str]:
+        X_selected = self._select_features(X).copy()
+        event_col = self._unique_column_name("_event", X_selected.columns)
+        time_col = self._unique_column_name("_time", X_selected.columns)
+        events, times = self._split_survival_target(y)
+        X_selected[event_col] = events
+        X_selected[time_col] = times
+        return X_selected, time_col, event_col
+
+    def fit(self, dataset: Dataset):  # pylint: disable=unused-argument
+        self.columns = dataset.get_columns_names_by_type(DataType.NUMERIC)
+        if not self.columns:
+            self.columns = dataset.features
+
+        backend, model_cls = self._resolve_backend()
+        if model_cls is None:
+            raise ImportError(
+                "WeibullAFT requires scikit-survival or lifelines to be installed."
+            )
+
+        self.backend = backend
+        self.model = model_cls(**self._model_parameters(model_cls, backend))
+
+        if backend == 'sksurv':
+            X, y = dataset.to_survival()
+            self.model.fit(self._select_features(X), y)
+        else:
+            X, time_col, event_col = self._prepare_lifelines_frame(dataset.X, dataset.y)
+            self.model.fit(X, duration_col=time_col, event_col=event_col)
+            self._lifelines_time_col = time_col
+            self._lifelines_event_col = event_col
+
+        return self
+
+    def predict(self, X):
+        X_selected = self._select_features(X)
+        if self.model and hasattr(self.model, 'predict'):
+            return super().predict(X_selected)
+        if self.model and hasattr(self.model, 'predict_median'):
+            return self.model.predict_median(X_selected)
+        if self.model and hasattr(self.model, 'predict_expectation'):
+            return self.model.predict_expectation(X_selected)
+        return None
+
+    def predict_survival_function(self, X):
+        X_selected = self._select_features(X)
+        if self.model and hasattr(self.model, 'predict_survival_function'):
+            return self.model.predict_survival_function(X_selected)
+        raise AttributeError("Unable to predict survival function with this model")
+
+    def predict_cumulative_hazard_function(self, X):
+        X_selected = self._select_features(X)
+        if self.model and hasattr(self.model, 'predict_cumulative_hazard_function'):
+            return self.model.predict_cumulative_hazard_function(X_selected)
+        if self.model and hasattr(self.model, 'predict_cumulative_hazard'):
+            return self.model.predict_cumulative_hazard(X_selected)
+        raise AttributeError("Unable to predict cumulative hazard function with this model")
+
+    def score(self, X, y=None, *args, **kwargs):
+        if self.backend == 'lifelines':
+            if y is None:
+                if (
+                    self._lifelines_event_col is None
+                    or self._lifelines_time_col is None
+                    or not hasattr(X, 'columns')
+                    or self._lifelines_event_col not in X.columns
+                    or self._lifelines_time_col not in X.columns
+                ):
+                    raise ValueError(
+                        "lifelines score requires y or a DataFrame containing the "
+                        "duration/event columns from fit."
+                    )
+                X_frame = self._select_features(X).copy()
+                X_frame[self._lifelines_event_col] = X[self._lifelines_event_col]
+                X_frame[self._lifelines_time_col] = X[self._lifelines_time_col]
+                return self.model.score(X_frame, *args, **kwargs)
+            X_frame = self._select_features(X).copy()
+            events, times = self._split_survival_target(y)
+            if self._lifelines_event_col is None or self._lifelines_time_col is None:
+                self._lifelines_event_col = self._unique_column_name(
+                    "_event", X_frame.columns
+                )
+                self._lifelines_time_col = self._unique_column_name(
+                    "_time", X_frame.columns
+                )
+            X_frame[self._lifelines_event_col] = events
+            X_frame[self._lifelines_time_col] = times
+            return self.model.score(X_frame, *args, **kwargs)
+        return self.model.score(self._select_features(X), y, *args, **kwargs)
+
+    def suitable(self, dataset: Dataset) -> bool:
+        backend_available = WeibullAFT is not None or WeibullAFTFitter is not None
+        return dataset.type_of_target == 'survival' \
+            and bool(dataset.get_columns_names_by_type(DataType.NUMERIC)) \
+            and backend_available
+
+    def priorize(self, candidate: Candidate = None) -> float:
+        return 0.5  # neutral

iaml/cache.py

@@ -0,0 +1,61 @@
+# cache_singleton.py
+from typing import Any
+import pickle
+import pandas as pd
+
+from .meta_singleton import MetaSingleton
+from .cache_keys import hash_df
+from .dataset import Dataset
+from .logger import Logger
+
+
+def _data_fingerprint(dataset: Dataset | pd.DataFrame | str) -> str:
+    """Accept complete datasets, frozen keys, and legacy feature-only inputs."""
+    if isinstance(dataset, str):
+        return dataset
+    if isinstance(dataset, Dataset):
+        return dataset.fingerprint()
+    return hash_df(dataset)
+
+
+class Cache(metaclass=MetaSingleton):
+    """Façade singleton vers un cache partagé."""
+    def __init__(self) -> None:
+        self._backend = None
+
+    def configure(self, backend) -> None:
+        """Brancher le proxy partagé (à faire dans le parent ET dans chaque worker)."""
+        self._backend = backend
+
+    def disable(self) -> None:
+        if self._backend: self._backend.disable()
+
+    def enable(self) -> None:
+        if self._backend: self._backend.enable()
+
+    def from_cache(self, fingerprint: str, dataset: Dataset | pd.DataFrame | str) -> Any | None:
+        """Look up an operation using all dataset inputs or a precomputed key.
+
+        DataFrame inputs remain supported for feature-only operations. Supervised
+        operations must pass a Dataset, or its fingerprint captured before mutation.
+        """
+        if not self._backend:
+            return None
+        try:
+            return self._backend.get(fingerprint, _data_fingerprint(dataset))
+        except (EOFError, OSError) as exc:
+            Logger().warning(f"Shared cache disabled after get failure: {exc!r}")
+            self._backend = None
+            return None
+
+    def add_to_cache(
+        self, fingerprint: str, dataset: Dataset | pd.DataFrame | str, output: Any
+    ) -> None:
+        """Store an operation result under the same input key used for lookup."""
+        if not self._backend:
+            return
+        try:
+            self._backend.put(fingerprint, _data_fingerprint(dataset), output)
+        except (EOFError, OSError, pickle.PicklingError, TypeError) as exc:
+            Logger().warning(f"Shared cache disabled after put failure: {exc!r}")
+            self._backend = None

iaml/cache_keys.py

@@ -0,0 +1,57 @@
+import hashlib
+import pickle
+from typing import Any
+
+import numpy as np
+import pandas as pd
+
+def hash_df(df: pd.DataFrame) -> str:
+    h = hashlib.sha256()
+
+    vals = pd.util.hash_pandas_object(df, index=False, categorize=True).values.tobytes()
+    h.update(vals)
+
+    h.update(pd.util.hash_pandas_object(df.index, categorize=True).values.tobytes())
+
+    h.update(pd.util.hash_pandas_object(df.columns, categorize=True).values.tobytes())
+
+    dtype_idx = pd.Index([getattr(dt, "name", str(dt)) for dt in df.dtypes])
+    h.update(pd.util.hash_pandas_object(dtype_idx).values.tobytes())
+
+    return h.hexdigest()
+
+
+def hash_dataset(
+    X: pd.DataFrame,
+    y: Any,
+    groups: pd.DataFrame | None = None,
+    columns_types: dict | None = None,
+    target_type: str | None = None,
+) -> str:
+    """Hash all inputs that can affect a supervised step or evaluation.
+
+    Targets are positional, as in Dataset, so their pandas index is not used.
+    Serialization preserves their shape and dtype, including structured survival
+    targets. This only serializes local inputs; no pickle is loaded here.
+    """
+    payload = (
+        "iaml-dataset-v2",
+        hash_df(X),
+        np.asarray(y),
+        hash_df(groups) if groups is not None else None,
+        columns_types,
+        target_type,
+    )
+    return hashlib.sha256(pickle.dumps(payload, protocol=5)).hexdigest()
+
+
+def hash_evaluation_context(*values: Any) -> str | None:
+    """Identify serializable evaluation settings, or decline to cache them.
+
+    Partial splitters include their arguments. Local functions and lambdas that
+    cannot be serialized are evaluated without partition or score caching.
+    """
+    try:
+        return hashlib.sha256(pickle.dumps(values, protocol=5)).hexdigest()
+    except (pickle.PicklingError, TypeError, AttributeError, ValueError):
+        return None