scikit-survival 0.25.0__cp311-cp311-win_amd64.whl → 0.27.0__cp311-cp311-win_amd64.whl

{scikit_survival-0.25.0.dist-info → scikit_survival-0.27.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scikit-survival
-Version: 0.25.0
+Version: 0.27.0
 Summary: Survival analysis built on top of scikit-learn
 Author-email: Sebastian Pölsterl <sebp@k-d-w.org>
 License-Expression: GPL-3.0-or-later
@@ -19,28 +19,28 @@ Classifier: Programming Language :: C++
 Classifier: Programming Language :: Cython
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development
 Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: COPYING
 Requires-Dist: ecos
 Requires-Dist: joblib
 Requires-Dist: numexpr
-Requires-Dist: numpy
-Requires-Dist: osqp<1.0.0,>=0.6.3
-Requires-Dist: pandas>=1.4.0
-Requires-Dist: scipy>=1.3.2
-Requires-Dist: scikit-learn<1.8,>=1.6.1
+Requires-Dist: numpy>=2.0.0
+Requires-Dist: osqp>=1.0.2
+Requires-Dist: pandas>=2.2.0
+Requires-Dist: scipy>=1.13.0
+Requires-Dist: scikit-learn<1.9,>=1.8.0
 Dynamic: license-file
 
 |License| |Docs| |DOI|
 
-|build-tests| |build-windows| |Codecov| |Codacy|
+|build-tests| |Codecov| |Codacy|
 
 ***************
 scikit-survival
@@ -72,14 +72,14 @@ this unique characteristic of such a dataset into account.
 Requirements
 ============
 
-- Python 3.10 or later
+- Python 3.11 or later
 - ecos
 - joblib
 - numexpr
-- numpy
+- numpy 2.0.0 or later
 - osqp
-- pandas 1.4.0 or later
-- scikit-learn 1.6 or 1.7
+- pandas 2.2.0 or later
+- scikit-learn 1.8
 - scipy
 - C/C++ compiler
 
@@ -178,8 +178,4 @@ Please cite the following paper if you are using **scikit-survival**.
   :target: https://github.com/sebp/scikit-survival/actions?query=workflow%3Atests+branch%3Amaster
   :alt: GitHub Actions Tests Status
 
-.. |build-windows| image:: https://ci.appveyor.com/api/projects/status/github/sebp/scikit-survival?branch=master&svg=true
-   :target: https://ci.appveyor.com/project/sebp/scikit-survival
-   :alt: Windows Build Status on AppVeyor
-
 .. _survival analysis: https://en.wikipedia.org/wiki/Survival_analysis

{scikit_survival-0.25.0.dist-info → scikit_survival-0.27.0.dist-info}/RECORD

@@ -1,20 +1,20 @@
-scikit_survival-0.25.0.dist-info/licenses/COPYING,sha256=Czg9WmPaZE9ijZnDOXbqZIftiaqlnwsyV5kt6sEXHms,35821
+scikit_survival-0.27.0.dist-info/licenses/COPYING,sha256=Czg9WmPaZE9ijZnDOXbqZIftiaqlnwsyV5kt6sEXHms,35821
 sksurv/__init__.py,sha256=y_H9kC05lnKq8z8qPnZJZVt79ILJhMH4bkCsohCbvV8,5336
 sksurv/base.py,sha256=FqiHfSFH6fdRzi49Eu3HT08hYxd9yrbdvX0-wSse9qc,4488
-sksurv/column.py,sha256=a5mnNWodyqNAOjsD1yqtFUhSRXYWlBnyLw8wQ0O2x0o,7113
-sksurv/compare.py,sha256=Nmh-YlH1X7OOVdRA_-KBj54mRxTHZUUz22IMLhFi01k,4563
+sksurv/column.py,sha256=Kuh1P2mQhHsZgohl2V1iLEGyjIZ3809QqIZa6XDZU7M,7073
+sksurv/compare.py,sha256=XmVNu-cnXk8M9rwm-qgWnxO_pgzDIH4lcZWkd7sVHJM,4543
 sksurv/docstrings.py,sha256=FGFChjoUjOMWxBz1_mZ2ffgond4e-cGMq8NfOM8S7oc,3400
 sksurv/exceptions.py,sha256=WopRsYNia5MQTvvVXL3U_nf418t29pplfBz6HFtmt1M,819
 sksurv/functions.py,sha256=lOquoM6P6B8WCSBWZFyT0uuKBRXl7zSRkzWwQuHsxTU,4012
-sksurv/metrics.py,sha256=HavsO3Ekh_ZZUlJbvzA_LPZA8ViI49pBJQSnDEHcHOI,42269
-sksurv/nonparametric.py,sha256=GWL6VSIMVBVqHhj9SuDRxSYvNFyZzHFHn9W2IngnvzY,32626
-sksurv/preprocessing.py,sha256=mWPkkwN0svTHYlSziaRZtqr4URofrEEtITx7S9cs8cw,6691
-sksurv/testing.py,sha256=9qoUAeRfp3tb4Zg7oCHkBS0DJXkIuxdflRLoV7NEfek,4403
-sksurv/util.py,sha256=1qpk4iZ0k83v_phg7F4B5n1E_yeAB6Q5V9OPxeoAuNQ,16160
+sksurv/metrics.py,sha256=RZBRQaMBSYxSNdcfPrrxWnlQgBssjEj-3lKT7ul4gOU,42277
+sksurv/nonparametric.py,sha256=bxig1gErSkrhvY1HUP99C5wzPS6JapVYBvOc5b7yUFw,32659
+sksurv/preprocessing.py,sha256=zjvxrpxZxBgA8QOP5yBc_dAE5QWLRSMerbKJBE5So2o,7169
+sksurv/testing.py,sha256=wxHys1bjqzZKrZ5-rp2sXKjlcTNh-fHmSks-fT_sPjs,6257
+sksurv/util.py,sha256=Ml7t7u7qONmohFTEAPMQI6IClv3IpJa6MIs_bL5FoME,16225
 sksurv/bintrees/__init__.py,sha256=z0GwaTPCzww2H2aXF28ubppw0Oc4umNTAlFAKu1VBJc,742
-sksurv/bintrees/_binarytrees.cp311-win_amd64.pyd,sha256=anMNbbgY9mLH4lT0w3oQ4i4yoY8-cG40EyQS52wxsrU,65536
+sksurv/bintrees/_binarytrees.cp311-win_amd64.pyd,sha256=gWmNLCajX18I5YuNdori_qWhL0RAyOBy163Ql3Xr_A0,64000
 sksurv/datasets/__init__.py,sha256=lDHdxi0FcMHWKyWTovynHnV5B3B5Y4qh8pNRk9to9nE,373
-sksurv/datasets/base.py,sha256=ntDzYWzM54YD3Kmo7dV4WGhTGUvFIjQv40iL0LOuCNg,26225
+sksurv/datasets/base.py,sha256=TKMgBrhD0bB0pldgzVgaW58eEa1WSfIq4vId3o2XlQI,26236
 sksurv/datasets/data/GBSG2.arff,sha256=oX_UM7Qy841xBOArXBkUPLzIxNTvdtIJqpxXsqGGw9Q,26904
 sksurv/datasets/data/actg320.arff,sha256=BwIq5q_i_75G2rPFQ6TjO0bsiR8MwA6wPouG-SX7TUo,46615
 sksurv/datasets/data/bmt.arff,sha256=3cF6Vrjkc5891_0fsCJ4d_4aMXJlZ6VmFygfMmOOmYM,555
@@ -24,18 +24,18 @@ sksurv/datasets/data/flchain.arff,sha256=4LVUyEe-45ozaWPy0VkN-1js_MNsKw1gs2E-JRy
 sksurv/datasets/data/veteran.arff,sha256=LxZtbmq4I82rcB24JeJTYRtlgwPc3vM2OX5hg-q7xTw,5408
 sksurv/datasets/data/whas500.arff,sha256=dvqRzx-nwgSVJZxNVE2zelnt7l3xgzFtMucB7Wux574,28292
 sksurv/ensemble/__init__.py,sha256=aBjRTFm8UE5sTew292-qcplLUCc6owAfY6osWlj-VSM,193
-sksurv/ensemble/_coxph_loss.cp311-win_amd64.pyd,sha256=XdALka9IzGICfpAK2yWN2fvzOUPETkNX6OhRiFc0znk,142848
+sksurv/ensemble/_coxph_loss.cp311-win_amd64.pyd,sha256=OIwWQh6SbrAfwcSieB71mqGsDJfP8dLBqouYn64VRtk,137728
 sksurv/ensemble/boosting.py,sha256=PierryBGYz_RBHuhBpwImQpxiLCsuZm73FrSPTTBgUg,63136
 sksurv/ensemble/forest.py,sha256=esiN6cUajfzdw-eMiXmwm9Eljs59Z0y1hmf83s2xx5Q,36170
 sksurv/ensemble/survival_loss.py,sha256=v3tSou5t1YY6lBydAZYZ66DLqAirvRhErqW1dZYrTWE,6093
 sksurv/io/__init__.py,sha256=dalzZGTrvekCM8wwsB636rg1dwDkQtDWaBOw7TpHr5U,94
-sksurv/io/arffread.py,sha256=-vGD3BhzfyqecsBU47SH1IUc1xZtrC0IzRwSPe5u-bk,2727
-sksurv/io/arffwrite.py,sha256=8XIY2sZgp71p5LAwCKDtF23VIu2PrMxeReKlR4cerZQ,5612
+sksurv/io/arffread.py,sha256=qg76GNSN0OwMTsjsjoIxAVORyn3QKx6St-h4kinQOGM,2841
+sksurv/io/arffwrite.py,sha256=1s2XoXRaTkVj7XyJ8FDHz2uCg2oqmC9V0PMW3_AkJ6A,5611
 sksurv/kernels/__init__.py,sha256=R1if2sVd_0_f6LniIGUR0tipIfzRKpzgGYnvrVZZvHM,78
-sksurv/kernels/_clinical_kernel.cp311-win_amd64.pyd,sha256=9iYtg22oQmo6biPWYgrmLZYs6xmXlNgl64ccROrKkDA,149504
-sksurv/kernels/clinical.py,sha256=rzFYj31rDHGCRDP3_oDCijSAjLwQENQQJa70fRp3BAE,11787
+sksurv/kernels/_clinical_kernel.cp311-win_amd64.pyd,sha256=aA6LrZMPHL92ELbcYbCHcs_ulU6Z4q5zIFGVzIVJwWE,144896
+sksurv/kernels/clinical.py,sha256=8FzyMVLdj68YXdEjj_e1IA9_fR2-9yOabfEbPv4VdJk,11800
 sksurv/linear_model/__init__.py,sha256=dO6Mr3wXk6Q-KQEuhpdgMeY3ji8ZVdgC-SeSRnrJdmw,155
-sksurv/linear_model/_coxnet.cp311-win_amd64.pyd,sha256=_pZJZnXvCoIN6vHqW2m1SqNNZ3KxikPFSBIzJ-f9z38,93696
+sksurv/linear_model/_coxnet.cp311-win_amd64.pyd,sha256=r6goQA8ZCiZUn3uwi5Pgqm3gmS2jou_-iBbMBUu-hdw,93184
 sksurv/linear_model/aft.py,sha256=z3GhH6YztcF25v3A2CJAqIK19XEfqUPV-nI0bKgb6h0,7766
 sksurv/linear_model/coxnet.py,sha256=M5IMDA73LHjqxM8jzA4cya7dIKUsOa6FlonLlnFKdDU,23148
 sksurv/linear_model/coxph.py,sha256=ckZSYTl6e_NIBzGi0WvbF9AyfZyvZ30x1VX-HpHdzbU,22826
@@ -44,15 +44,15 @@ sksurv/meta/base.py,sha256=AdhIkZi9PvucZ3B2lhhFQpQbwp8EUCDUVOiaev_UsX8,1472
 sksurv/meta/ensemble_selection.py,sha256=MBFTcvO9FKJMJkr5Ys6MHp-BQPSq0T9RcrteZjZRHWA,27292
 sksurv/meta/stacking.py,sha256=t5tDtSDKEHURJqdLpo1-L7cQZv6d5N9fbMi87xMj_Dw,13534
 sksurv/svm/__init__.py,sha256=CSceYEcBPGKRcJZ4R0u7DzwictGln_weLIsbt2i5xeU,339
-sksurv/svm/_minlip.cp311-win_amd64.pyd,sha256=eHlyXncMgkDPNYd5BkNwxuTdyRg9ujX4xR6ENkXzWws,147456
-sksurv/svm/_prsvm.cp311-win_amd64.pyd,sha256=QSZEOChCzEw1jMuOZLJXy5fL23W9zyHC7P6-lyghep8,145920
-sksurv/svm/minlip.py,sha256=nveno6rwf_c7XUXfpjP6NlyOAQRU9eES-FK2YR8rPFA,25461
+sksurv/svm/_minlip.cp311-win_amd64.pyd,sha256=sqN9QAIyWj1mcg0OH857FU7XVpAgEeuSlmKqaNm1XFs,143360
+sksurv/svm/_prsvm.cp311-win_amd64.pyd,sha256=QsAxnNLL1aY4LlejE76abe4sziImh5WrzeVh8d1bjRo,141312
+sksurv/svm/minlip.py,sha256=ZgUP_Zx5oduh1VhC-OhYjlJ28J1VhPUHReFirHnEcJw,25671
 sksurv/svm/naive_survival_svm.py,sha256=B7NHFE_BNpyzQKJjUmLZBqmw6sbqlHrGS_6iQLKu2yA,9568
 sksurv/svm/survival_svm.py,sha256=fgF1lSbt_jTy9Ykigg4fEWrsmqae_NyO401KTNG2Kpo,46222
 sksurv/tree/__init__.py,sha256=ozb0fhURX-lpiSiHZd0DMnjkqhC0XOC2CTZq0hEZLPw,65
-sksurv/tree/_criterion.cp311-win_amd64.pyd,sha256=lOuB4jKFYizn__GXfct6_Dvf7T15dF-YFYm9J3ztzts,164352
+sksurv/tree/_criterion.cp311-win_amd64.pyd,sha256=6IHsFXblpIEy1AohNoFgUeZybWVHmYKqW0-zyuyUgTY,162816
 sksurv/tree/tree.py,sha256=4FMKf862hGaZnObIytz_XiLL2fPD11Z0w5zUO2zp7cM,32782
-scikit_survival-0.25.0.dist-info/METADATA,sha256=VQTQ6_WZO5lTHvAso805ojRtYBzXagMjGJ40MUlMVgQ,7372
-scikit_survival-0.25.0.dist-info/WHEEL,sha256=JLOMsP7F5qtkAkINx5UnzbFguf8CqZeraV8o04b0I8I,101
-scikit_survival-0.25.0.dist-info/top_level.txt,sha256=fPkcFA-XQGbwnD_ZXOvaOWmSd34Qezr26Mn99nYPvAg,7
-scikit_survival-0.25.0.dist-info/RECORD,,
+scikit_survival-0.27.0.dist-info/METADATA,sha256=xaC_67dBglseZ5obMIN9AOyYtlMJSwf7dMHNUrUBQS8,7131
+scikit_survival-0.27.0.dist-info/WHEEL,sha256=bVDps4tOb0nHmbMU4uK7h9NZsZJmyTqcRbrvK3TZLY4,102
+scikit_survival-0.27.0.dist-info/top_level.txt,sha256=fPkcFA-XQGbwnD_ZXOvaOWmSd34Qezr26Mn99nYPvAg,7
+scikit_survival-0.27.0.dist-info/RECORD,,

{scikit_survival-0.25.0.dist-info → scikit_survival-0.27.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: false
 Tag: cp311-cp311-win_amd64
 

sksurv/column.py

@@ -14,7 +14,7 @@ import logging
 
 import numpy as np
 import pandas as pd
-from pandas.api.types import CategoricalDtype, is_object_dtype
+from pandas.api.types import CategoricalDtype, is_string_dtype
 
 __all__ = ["categorical_to_numeric", "encode_categorical", "standardize"]
 
@@ -118,12 +118,12 @@ def encode_categorical(table, columns=None, **kwargs):
         Numeric columns in the input table remain unchanged.
     """
     if isinstance(table, pd.Series):
-        if not isinstance(table.dtype, CategoricalDtype) and not is_object_dtype(table.dtype):
+        if not isinstance(table.dtype, CategoricalDtype) and not is_string_dtype(table.dtype):
             raise TypeError(f"series must be of categorical dtype, but was {table.dtype}")
         return _encode_categorical_series(table, **kwargs)
 
     def _is_categorical_or_object(series):
-        return isinstance(series.dtype, CategoricalDtype) or is_object_dtype(series.dtype)
+        return isinstance(series.dtype, CategoricalDtype) or is_string_dtype(series.dtype)
 
     if columns is None:
         # for columns containing categories
@@ -187,13 +187,12 @@ def categorical_to_numeric(table):
     def transform(column):
         if isinstance(column.dtype, CategoricalDtype):
             return column.cat.codes
-        if is_object_dtype(column.dtype):
+        if is_string_dtype(column.dtype):
             try:
                 nc = column.astype(np.int64)
             except ValueError:
                 classes = column.dropna().unique()
-                classes.sort(kind="mergesort")
-                nc = column.map(dict(zip(classes, range(classes.shape[0]))))
+                nc = column.map(dict(zip(sorted(classes), range(classes.shape[0]))))
             return nc
         if column.dtype == bool:
             return column.astype(np.int64)

sksurv/compare.py

@@ -117,7 +117,7 @@ def compare_survival(y, group_indicator, return_stats=False):
         table["expected"] = expected
         table["statistic"] = observed - expected
         table = pd.DataFrame.from_dict(table)
-        table.index = pd.Index(groups, name="group", dtype=groups.dtype)
+        table.index = pd.Index(groups, name="group")
         return chisq, pval, table, covar
 
     return chisq, pval

sksurv/datasets/base.py

@@ -36,10 +36,10 @@ def _get_x_y_survival(dataset, col_event, col_time, val_outcome, competing_risks
         event_type = np.int64 if competing_risks else bool
         y = np.empty(dtype=[(col_event, event_type), (col_time, np.float64)], shape=dataset.shape[0])
         if competing_risks:
-            y[col_event] = dataset[col_event].values
+            y[col_event] = dataset[col_event].to_numpy()
         else:
-            y[col_event] = (dataset[col_event] == val_outcome).values
-        y[col_time] = dataset[col_time].values
+            y[col_event] = (dataset[col_event] == val_outcome).to_numpy()
+        y[col_time] = dataset[col_time].to_numpy()
 
         x_frame = dataset.drop([col_event, col_time], axis=1)
 
@@ -116,7 +116,7 @@ def _loadarff_with_index(filename):
         if isinstance(dataset["index"].dtype, CategoricalDtype):
             # concatenating categorical index may raise TypeError
             # see https://github.com/pandas-dev/pandas/issues/14586
-            dataset["index"] = dataset["index"].astype(object)
+            dataset = dataset.astype({"index": "str"})
         dataset.set_index("index", inplace=True)
     return dataset
 
@@ -512,7 +512,7 @@ def load_bmt():
     """
     full_path = _get_data_path("bmt.arff")
     data = loadarff(full_path)
-    data["ftime"] = data["ftime"].astype(int)
+    data = data.astype({"ftime": int})
     return get_x_y(data, attr_labels=["status", "ftime"], competing_risks=True)
 
 
@@ -603,8 +603,8 @@ def load_cgvhd():
     """
     full_path = _get_data_path("cgvhd.arff")
     data = loadarff(full_path)
-    data["ftime"] = data[["survtime", "reltime", "cgvhtime"]].min(axis=1)
-    data["status"] = (
+    data.loc[:, "ftime"] = data[["survtime", "reltime", "cgvhtime"]].min(axis=1)
+    data.loc[:, "status"] = (
         ((data["ftime"] == data["cgvhtime"]) & (data["cgvh"] == "1")).astype(int)
         + 2 * ((data["ftime"] == data["reltime"]) & (data["rcens"] == "1")).astype(int)
         + 3 * ((data["ftime"] == data["survtime"]) & (data["stat"] == "1")).astype(int)

sksurv/io/arffread.py

@@ -12,6 +12,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 import numpy as np
 import pandas as pd
+from pandas.api.types import is_string_dtype
 from scipy.io.arff import loadarff as scipy_loadarff
 
 __all__ = ["loadarff"]
@@ -34,7 +35,8 @@ def _to_pandas(data, meta):
             data_dict[name] = pd.Categorical(raw, categories=attr_format, ordered=False)
         else:
             arr = data[name]
-            p = pd.Series(arr, dtype=arr.dtype)
+            dtype = "str" if is_string_dtype(arr.dtype) else arr.dtype
+            p = pd.Series(arr, dtype=dtype)
             data_dict[name] = p
 
     # currently, this step converts all pandas.Categorial columns back to pandas.Series

sksurv/io/arffwrite.py

@@ -15,7 +15,7 @@ import re
 
 import numpy as np
 import pandas as pd
-from pandas.api.types import CategoricalDtype, is_object_dtype
+from pandas.api.types import CategoricalDtype, is_string_dtype
 
 _ILLEGAL_CHARACTER_PAT = re.compile(r"[^-_=\w\d\(\)<>\.]")
 
@@ -106,7 +106,7 @@ def _write_header(data, fp, relation_name, index):
         name = attribute_names[column]
         fp.write(f"@attribute {name}\t")
 
-        if isinstance(series.dtype, CategoricalDtype) or is_object_dtype(series):
+        if isinstance(series.dtype, CategoricalDtype) or is_string_dtype(series.dtype):
             _write_attribute_categorical(series, fp)
         elif np.issubdtype(series.dtype, np.floating):
             fp.write("real")
@@ -168,11 +168,11 @@ def _write_data(data, fp):
     fp.write("@data\n")
 
     def to_str(x):
-        if pd.isnull(x):
+        if pd.isna(x):
             return "?"
         return str(x)
 
-    data = data.applymap(to_str)
+    data = data.map(to_str)
     n_rows = data.shape[0]
     for i in range(n_rows):
         str_values = list(data.iloc[i, :].apply(_check_str_array))

sksurv/kernels/clinical.py

@@ -41,7 +41,7 @@ def _get_continuous_and_ordinal_array(x):
     ordinal_columns = pd.Index([v for v in nominal_columns if x[v].cat.ordered])
     continuous_columns = x.select_dtypes(include=[np.number]).columns
 
-    x_num = x.loc[:, continuous_columns].astype(np.float64).values
+    x_num = x.loc[:, continuous_columns].to_numpy(dtype=np.float64)
     if len(ordinal_columns) > 0:
         x = _ordinal_as_numeric(x, ordinal_columns)
 
@@ -123,7 +123,7 @@ def clinical_kernel(x, y=None):
         y_numeric = x_numeric
 
     continuous_ordinal_kernel(x_numeric, y_numeric, mat)
-    _nominal_kernel(x.loc[:, nominal_columns].values, y.loc[:, nominal_columns].values, mat)
+    _nominal_kernel(x.loc[:, nominal_columns].to_numpy(), y.loc[:, nominal_columns].to_numpy(), mat)
     mat /= x.shape[1]
     return mat
 
@@ -210,7 +210,7 @@ class ClinicalKernelTransform(BaseEstimator, TransformerMixin):
             else:
                 raise TypeError(f"unsupported dtype: {dt!r}")
 
-            fit_data[:, i] = col.values
+            fit_data[:, i] = col.to_numpy()
 
         self._numeric_columns = np.asarray(numeric_columns)
         self._nominal_columns = np.asarray(nominal_columns)

sksurv/metrics.py

@@ -510,7 +510,7 @@ def cumulative_dynamic_auc(survival_train, survival_test, estimate, times, tied_
             # to make sure that the curve starts at (0, 0)
             tp_no_ties = np.r_[0, tp_no_ties]
             fp_no_ties = np.r_[0, fp_no_ties]
-            scores[i] = np.trapz(tp_no_ties, fp_no_ties)
+            scores[i] = np.trapezoid(tp_no_ties, fp_no_ties)
 
     if n_times == 1:
         mean_auc = scores[0]
@@ -780,7 +780,7 @@ def integrated_brier_score(survival_train, survival_test, estimate, times):
         raise ValueError("At least two time points must be given")
 
     # Computing the IBS
-    ibs_value = np.trapz(brier_scores, times) / (times[-1] - times[0])
+    ibs_value = np.trapezoid(brier_scores, times) / (times[-1] - times[0])
 
     return ibs_value
 

sksurv/nonparametric.py

@@ -321,7 +321,7 @@ def kaplan_meier_estimator(
         >>> plt.step(time, prob_surv, where="post")
         [...]
         >>> plt.fill_between(time, conf_int[0], conf_int[1], alpha=0.25, step="post")
-        <matplotlib.collections.PolyCollection object at 0x...>
+        <matplotlib.collections.FillBetweenPolyCollection object at 0x...>
         >>> plt.ylim(0, 1)
         (0.0, 1.0)
         >>> plt.show()  # doctest: +SKIP
@@ -757,12 +757,12 @@ def cumulative_incidence_competing_risks(
         >>> plt.step(x, y[0], where="post", label="Total risk")
         [...]
         >>> plt.fill_between(x, conf_int[0, 0], conf_int[0, 1], alpha=0.25, step="post")
-        <matplotlib.collections.PolyCollection object at 0x...>
+        <matplotlib.collections.FillBetweenPolyCollection object at 0x...>
         >>> for i in range(1, n_risks + 1):
         ...     plt.step(x, y[i], where="post", label=f"{i}-risk")
         ...     plt.fill_between(x, conf_int[i, 0], conf_int[i, 1], alpha=0.25, step="post")
         [...]
-        <matplotlib.collections.PolyCollection object at 0x...>
+        <matplotlib.collections.FillBetweenPolyCollection object at 0x...>
         >>> plt.ylim(0, 1)
         (0.0, 1.0)
         >>> plt.legend()

sksurv/preprocessing.py

@@ -10,6 +10,8 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
+import pandas as pd
+from pandas.api.types import CategoricalDtype, is_string_dtype
 from sklearn.base import BaseEstimator, TransformerMixin
 from sklearn.utils.validation import _check_feature_names, _check_feature_names_in, _check_n_features, check_is_fitted
 
@@ -127,12 +129,24 @@ class OneHotEncoder(BaseEstimator, TransformerMixin):
         """
         _check_feature_names(self, X, reset=True)
         _check_n_features(self, X, reset=True)
-        columns_to_encode = X.select_dtypes(include=["object", "category"]).columns
+
+        def is_string_or_categorical_dtype(dtype):
+            return is_string_dtype(dtype) or isinstance(dtype, CategoricalDtype)
+
+        columns_to_encode = pd.Index(
+            [name for name, dtype in X.dtypes.items() if is_string_or_categorical_dtype(dtype)]
+        )
         x_dummy = self._encode(X, columns_to_encode)
 
         self.feature_names_ = columns_to_encode
-        self.categories_ = {k: X[k].cat.categories for k in columns_to_encode}
-        self.encoded_columns_ = x_dummy.columns
+        cat_cols = {}
+        for col_name in columns_to_encode:
+            col = X[col_name]
+            if not isinstance(col.dtype, CategoricalDtype):
+                col = col.astype("category")
+            cat_cols[col_name] = col.cat.categories
+        self.categories_ = cat_cols
+        self.encoded_columns_ = x_dummy.columns.copy()
         return x_dummy
 
     def transform(self, X):
@@ -152,9 +166,7 @@ class OneHotEncoder(BaseEstimator, TransformerMixin):
         _check_n_features(self, X, reset=False)
         check_columns_exist(X.columns, self.feature_names_)
 
-        Xt = X.copy()
-        for col, cat in self.categories_.items():
-            Xt[col] = Xt[col].cat.set_categories(cat)
+        Xt = X.astype({col: CategoricalDtype(cat) for col, cat in self.categories_.items()})
 
         new_data = self._encode(Xt, self.feature_names_)
         return new_data.loc[:, self.encoded_columns_]
@@ -180,4 +192,4 @@ class OneHotEncoder(BaseEstimator, TransformerMixin):
         check_is_fitted(self, "encoded_columns_")
         input_features = _check_feature_names_in(self, input_features)
 
-        return self.encoded_columns_.values.copy()
+        return self.encoded_columns_.to_numpy(copy=True)

sksurv/svm/minlip.py

@@ -81,17 +81,22 @@ class OsqpSolver(QPSolver):
 
         solver_opts = self._get_options()
         m = osqp.OSQP()
-        m.setup(P=sparse.csc_matrix(P), q=q, A=G, u=h, **solver_opts)  # noqa: E741
-        results = m.solve()
+        m.setup(P=sparse.csc_matrix(P), q=q, A=G, l=None, u=h, **solver_opts)  # noqa: E741
+        results = m.solve(raise_error=False)
 
-        if results.info.status_val == -2:  # max iter reached
+        solved_codes = (
+            osqp.SolverStatus.OSQP_SOLVED,
+            osqp.SolverStatus.OSQP_SOLVED_INACCURATE,
+        )
+
+        if results.info.status_val == osqp.SolverStatus.OSQP_MAX_ITER_REACHED:  # max iter reached
             warnings.warn(
                 (f"OSQP solver did not converge: {results.info.status}"),
                 category=ConvergenceWarning,
                 stacklevel=2,
             )
-        elif results.info.status_val not in (1, 2):  # pragma: no cover
-            # non of solved, solved inaccurate
+        elif results.info.status_val not in solved_codes:  # pragma: no cover
+            # none of SOLVED, SOLVED_INACCURATE
             raise RuntimeError(f"OSQP solver failed: {results.info.status}")
 
         n_iter = results.info.iter
@@ -103,7 +108,7 @@ class OsqpSolver(QPSolver):
             "eps_abs": 1e-5,
             "eps_rel": 1e-5,
             "max_iter": self.max_iter or 4000,
-            "polish": True,
+            "polishing": True,
             "verbose": self.verbose,
         }
         return solver_opts

sksurv/testing.py

@@ -10,13 +10,17 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
+from contextlib import nullcontext
 from importlib import import_module
+from importlib.metadata import PackageNotFoundError, version
 import inspect
 from pathlib import Path
 import pkgutil
 
 import numpy as np
 from numpy.testing import assert_almost_equal, assert_array_equal
+from packaging.version import parse
+import pandas as pd
 import pytest
 from sklearn.base import BaseEstimator, TransformerMixin
 
@@ -106,3 +110,51 @@ class FixtureParameterFactory:
                 values = func()
                 cases.append(pytest.param(*values, id=name))
         return cases
+
+    def get_cases_func(self):
+        cases = []
+        for name, func in inspect.getmembers(self):
+            if name.startswith("data_"):
+                cases.append(pytest.param(func, id=name))
+        return cases
+
+
+def check_module_minimum_version(module, min_version_str, max_version_str=None):
+    """
+    Check whether a module of a specified minimum version is available.
+
+    Parameters
+    ----------
+    module : str
+        Name of the module.
+    min_version_str : str
+        Minimum version of the module.
+    max_version_str : str, optional
+        Maximum version of the module (excluding).
+
+    Returns
+    -------
+    available : bool
+        True if the module is available and its version is >= `version_str`.
+    """
+    try:
+        module_version = parse(version(module))
+        required_min_version = parse(min_version_str)
+        if max_version_str is None:
+            return module_version >= required_min_version
+        required_max_version = parse(max_version_str)
+        return required_min_version <= module_version < required_max_version
+    except PackageNotFoundError:  # pragma: no cover
+        return False
+
+
+def get_pandas_infer_string_context():
+    if check_module_minimum_version("pandas", "2.3.0", "3.0.0"):
+        return (
+            pytest.param(pd.option_context("future.infer_string", False), id="infer_string=False"),
+            pytest.param(pd.option_context("future.infer_string", True), id="infer_string=True"),
+        )
+    return (
+        pytest.param(nullcontext(), id="pandas default options"),
+        pytest.param(nullcontext(), marks=pytest.mark.skip("no pandas 2.3.0")),
+    )

sksurv/util.py

@@ -142,7 +142,7 @@ class Surv:
             raise TypeError(f"expected pandas.DataFrame, but got {type(data)!r}")
 
         return Surv.from_arrays(
-            data.loc[:, event].values, data.loc[:, time].values, name_event=str(event), name_time=str(time)
+            data.loc[:, event].to_numpy(), data.loc[:, time].to_numpy(), name_event=str(event), name_time=str(time)
         )
 
 
@@ -337,6 +337,7 @@ def safe_concat(objs, *args, **kwargs):
                 categories[df.name] = {"categories": df.cat.categories, "ordered": df.cat.ordered}
         else:
             dfc = df.select_dtypes(include=["category"])
+            new_dtypes = {}
             for name, s in dfc.items():
                 if name in categories:
                     if axis == 1:
@@ -345,12 +346,12 @@ def safe_concat(objs, *args, **kwargs):
                         raise ValueError(f"categories for column {name} do not match")
                 else:
                     categories[name] = {"categories": s.cat.categories, "ordered": s.cat.ordered}
-                df[name] = df[name].astype(object)
+                new_dtypes[name] = "str"
+            df = df.astype(new_dtypes)
 
     concatenated = pd.concat(objs, *args, axis=axis, **kwargs)
 
-    for name, params in categories.items():
-        concatenated[name] = pd.Categorical(concatenated[name], **params)
+    concatenated = concatenated.astype({name: pd.CategoricalDtype(**params) for name, params in categories.items()})
 
     return concatenated