scikit-survival 0.25.0__cp313-cp313-macosx_11_0_arm64.whl → 0.27.0__cp313-cp313-macosx_11_0_arm64.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,35 +1,35 @@
-scikit_survival-0.25.0.dist-info/RECORD,,
-scikit_survival-0.25.0.dist-info/WHEEL,sha256=oqGJCpG61FZJmvyZ3C_0aCv-2mdfcY9e3fXvyUNmWfM,136
-scikit_survival-0.25.0.dist-info/top_level.txt,sha256=fPkcFA-XQGbwnD_ZXOvaOWmSd34Qezr26Mn99nYPvAg,7
-scikit_survival-0.25.0.dist-info/METADATA,sha256=gDfqAfi65Ozo4Ak5qArzmaEGnhAVbjoRFBEM8xtI0Ww,7187
-scikit_survival-0.25.0.dist-info/licenses/COPYING,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+scikit_survival-0.27.0.dist-info/RECORD,,
+scikit_survival-0.27.0.dist-info/WHEEL,sha256=6IL0WRXMJwUnm4EmfBfLXRzeRewZIa5V-Dek5EQDpZ4,137
+scikit_survival-0.27.0.dist-info/top_level.txt,sha256=fPkcFA-XQGbwnD_ZXOvaOWmSd34Qezr26Mn99nYPvAg,7
+scikit_survival-0.27.0.dist-info/METADATA,sha256=dPPT8BmqDfq_N5pEWc2GPDgGr16wgXY5cvTt-BcxZjE,6950
+scikit_survival-0.27.0.dist-info/licenses/COPYING,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
 sksurv/functions.py,sha256=e0jVqnEtyHoI7qjn18gHD2oRTCoOOA3i6p90tDgMWKs,3898
-sksurv/metrics.py,sha256=C8vWJEQ1CysbaG4KRnQA7cHOttDZsLGNAaL1DSVgccI,41241
-sksurv/nonparametric.py,sha256=XNATA2vYpspXqzflT8ckR3zuOqRwBI50zMcLwvs5JxY,31715
-sksurv/util.py,sha256=wbLvsOh5Ta3myMRVmlBazCTcMzV8G_nv1VF4Y1twY-I,15745
+sksurv/metrics.py,sha256=a75hixN4WZm8vlNmn61dksLdRVEQUEKg1htbDrIa7JU,41249
+sksurv/nonparametric.py,sha256=Bhvtr_j3gozbcnMcXJ_55BbfAEua-n4-hzTiVtBYt6M,31748
+sksurv/util.py,sha256=1zX5DcUCw-9oM2uwMPrC5C736g3VsmxgL_w5piTuBew,15809
 sksurv/__init__.py,sha256=eRitrwFtAUadhvZtcasgO443RRMaPTmJHCph3dWkHSg,5153
 sksurv/docstrings.py,sha256=PJTe7sts8j6x3Gck_18buulAr2HIMOF6GnWDtrLQtIw,3301
-sksurv/preprocessing.py,sha256=rCy0BOvniqfN14XAJqYGu0ihmumB3-gY14UUmO2lf38,6508
+sksurv/preprocessing.py,sha256=proeFKkPiyx4UDCwEnaOo0jLUTqA3jbnSP28R2izbPw,6974
 sksurv/exceptions.py,sha256=CRun7zrKzcZ9zinni5b2cMaV-pU-pw1UnXpRV2h3z_4,801
-sksurv/testing.py,sha256=2oeCsTzEiVRKDRb3iSJLKn03hBO2IrUq-2U5TfvOYK4,4295
-sksurv/compare.py,sha256=k610CG3y4OnUkuIhR4hnd_kaLUHNi1qsmL4EBYQ8rLc,4440
+sksurv/testing.py,sha256=qyhAvOz_Q3lQ6D7hMUuqy-CbpjpwkXwmb1l8mlpoCk4,6097
+sksurv/compare.py,sha256=RCfPU-EhM1C_8BMhNV5eb34ZrTZX6ODkB6KxTHQh-6E,4420
 sksurv/base.py,sha256=JGjekQGBRQdwS6AlI6uuNowT3KOpgBHCzxJGq6dsgew,4373
-sksurv/column.py,sha256=D52_WjVEvKPuA-pQdYtbh5hJagCrT8Dg8jaiFfJRHnU,6908
+sksurv/column.py,sha256=ptWBSh2llhSPeGOxxmoAYhlI2KXXRJjJEZO9K9-eZXQ,6869
 sksurv/tree/tree.py,sha256=uvCcwIGVqx2x39ycIsLtJSKWBhty37uDKr85zQOBR9U,31992
-sksurv/tree/_criterion.cpython-313-darwin.so,sha256=LxHEzFNv8X6dBsF0yyi3vIiBnl6_6SkylDgukVgkdxo,227584
+sksurv/tree/_criterion.cpython-313-darwin.so,sha256=bwiRuMxY7vayD_gKOoPHuMDiGT_gvatXn3TQbmnRICk,254176
 sksurv/tree/__init__.py,sha256=7RUjPZtGrVYiHY4roDXdEDM7RVBSsbY_CXWmyqZk2ts,64
 sksurv/ensemble/boosting.py,sha256=zLsJdjgPuEunYzPy-xlsmdNAI2U97YnX6aWN3ksFIrM,61572
 sksurv/ensemble/__init__.py,sha256=7kZAzxFpJGtgLQfhoOqZUyGUubIs_Kw3RgyUsAd1Fq0,191
-sksurv/ensemble/_coxph_loss.cpython-313-darwin.so,sha256=1iPNdygjlbSX6D8j8qLmn3zVxRNO0GQtm9eHQt5b-1Q,206464
+sksurv/ensemble/_coxph_loss.cpython-313-darwin.so,sha256=W8sw-AJbny_y1RawziGGEv2cyK_KBP_TUzCPKsQMv3g,225984
 sksurv/ensemble/survival_loss.py,sha256=mhIbuOqz7t-nuygswZD0d0are2R0EQ3d3yHMRdxOKIk,5942
 sksurv/ensemble/forest.py,sha256=zAo-Txbqc5GjnbfI5fJCUfUHG2NFdFS6dDQhADrBnuM,35268
-sksurv/kernels/_clinical_kernel.cpython-313-darwin.so,sha256=TRp_1pSu1uMuSpnmQnuKNRoaZILa5l1MtyupwCzLtFk,206968
-sksurv/kernels/clinical.py,sha256=uqwjrmo0ZHpqZQ7oWw_xWl4A47ZO19WsYJWe6zRzPrY,11439
+sksurv/kernels/_clinical_kernel.cpython-313-darwin.so,sha256=zsFMXU2Lbwss4GONW9ughZXJkDShdA41gNIE8-jVPCc,228168
+sksurv/kernels/clinical.py,sha256=oNIXgBIivmgjM927qNpspfI3HivC_ORqFvdsTb_NHTA,11452
 sksurv/kernels/__init__.py,sha256=_aZIFutv7kUTlkHJlP52zBDkpUXnKIlPPf3cikuAmCA,77
-sksurv/bintrees/_binarytrees.cpython-313-darwin.so,sha256=OEYfuVsBvUjQ65pLqweApss3IliBTeiFg1qvj6ZkxY0,112992
+sksurv/bintrees/_binarytrees.cpython-313-darwin.so,sha256=MDKQGWVi9FWiSIxNMUwZ970iuM8YwcK3wVxaksDbfzQ,118512
 sksurv/bintrees/__init__.py,sha256=l6Fe4PAMByrABpGzZ5W8KHieEYG-rh-DADo2QiEMLrU,727
 sksurv/datasets/__init__.py,sha256=EPzJ50wd-cZ6mWuHFPRRRMqgt14WzM32HGxDrlOp9Q4,361
-sksurv/datasets/base.py,sha256=q6xtOdE-y5WvevZsDidwE_imFtWozUQaWKbAhpPbw7Q,25611
+sksurv/datasets/base.py,sha256=C9fnZJXLBTw1mvzc7GqGB4LdS6_8pQqPIAzKBo5jDpM,25622
 sksurv/datasets/data/cgvhd.arff,sha256=0lxUqY74JaMpC_vWJC4RWJy6vTmQwCg1yrUxjX65VX8,5214
 sksurv/datasets/data/GBSG2.arff,sha256=jBuh302AIWtYaV1rvJ9RKEZkqzcSThAdVt8ImFFkWwQ,26204
 sksurv/datasets/data/actg320.arff,sha256=8GE2kIU8Nvx7m5Ns-uTJW6Rgtk3xmJzBzMEmtynq5FU,45446
@@ -38,21 +38,21 @@ sksurv/datasets/data/breast_cancer_GSE7390-metastasis.arff,sha256=Iz9MHAay7imf_8
 sksurv/datasets/data/flchain.arff,sha256=vyYA7EN90ZBx9zva2C3mgXgEV9EUHsNu1VGwAm5uV3M,343058
 sksurv/datasets/data/whas500.arff,sha256=9kBAyROYh1E3gi7KMGqScgjfaJaAjNl2SvcGVyL6U9Y,27772
 sksurv/datasets/data/veteran.arff,sha256=cdvJ4jXzzC7RCzolTjn5hcCSNG0chFc27SGxP74mNFY,5260
-sksurv/io/arffwrite.py,sha256=fRJJ6h8Q4z5h9PNgzQgjLStYbVw1L38J2Qc3OKXFoWY,5431
+sksurv/io/arffwrite.py,sha256=klmpbAaksrOOPu0Ftl6cVwgEhQNTsv_Okxkjn9J2Wc0,5430
 sksurv/io/__init__.py,sha256=LacpKG9UKO_RefPXc6umPaGFGPOGzA-FZra_MCRWCxk,92
-sksurv/io/arffread.py,sha256=Tz7D7BgsEcsC-7NRJjFziXyOO-jwVoj-QNRMmQkORPM,2638
+sksurv/io/arffread.py,sha256=zc18B_CWVPr5_6Q_8IjohSmHL6rdTwTOsMqygyM945Y,2750
 sksurv/meta/__init__.py,sha256=VLA0VhLxZhF3z35md5Z4-nhw6BSSCfR6L7YOBGk1w1A,216
 sksurv/meta/stacking.py,sha256=7dROmB9H-qfwWeCf9ueu9IEEsxDQOTNPK82nmH-EFlg,13164
 sksurv/meta/ensemble_selection.py,sha256=cy4szNkw6KABLE7QjVkb6nMKV8YEWAunalM8SK0aSu8,26568
 sksurv/meta/base.py,sha256=mV6653v4txKKHJqcJXVT-J-ARNN9rDfzIq02xoEy93I,1437
 sksurv/linear_model/coxph.py,sha256=KFzVDP1TrNr9Hv08bCGsacTX0w_aE2jwsgMpCHe3R8A,22189
-sksurv/linear_model/_coxnet.cpython-313-darwin.so,sha256=KBXVjuQntRLnBq02jgq6tBrUc2rkOjgJqU6YDCHsIr0,131712
+sksurv/linear_model/_coxnet.cpython-313-darwin.so,sha256=dQNVtKIwLT65ArbcM3xas4iQLHf4Ok3euwB9ighwYMs,134496
 sksurv/linear_model/__init__.py,sha256=58Lt5Tj3xGqRS4uZfVR5avKQNZubHD6RSknVDyzLTso,152
 sksurv/linear_model/coxnet.py,sha256=RgIomES97BcaM-RWmxmrP6AE3vkDaBsy4of727VsVfQ,22556
 sksurv/linear_model/aft.py,sha256=1Vn_V-e5ffQhbIed34MZzZBt4RzvAcLaxI1VTOZrBEY,7558
 sksurv/svm/naive_survival_svm.py,sha256=hx1C__lOT8hSV0g-YBI5reEgp9v4qQXOnvUlbVlHPwc,9319
-sksurv/svm/_minlip.cpython-313-darwin.so,sha256=Wl1ZyIVbl4E2sKlYxygzVU9gXyPTGeZomgnbrzBLh7g,206912
-sksurv/svm/_prsvm.cpython-313-darwin.so,sha256=ONCcBf9zFSuSaOmjpnl5cxAt_75s9gJe_GNcOaPv85I,206832
+sksurv/svm/_minlip.cpython-313-darwin.so,sha256=r7WUbkQb3zgFUQZR9_OKzHLiZfo2KZe9jdNXcSyKjVA,228576
+sksurv/svm/_prsvm.cpython-313-darwin.so,sha256=taYwEV4XFgj4p_GOcE_DlRhrBHfTD_CHDuegCVxzR8U,225008
 sksurv/svm/__init__.py,sha256=7BRFkatw9wbtsY-aes9cnz31VPpIjZ-383LuDmucDsw,328
 sksurv/svm/survival_svm.py,sha256=JGgUSft8p999DvZ0e617Ui2IEopt8kG3xspAJHt8CbU,44986
-sksurv/svm/minlip.py,sha256=Hnx6t2jV1s-p1puebvsHImRCUuv5HpJ0u-5bC4Sh6A0,24771
+sksurv/svm/minlip.py,sha256=B6nfOSxxWdXAB_Ym4AXxileEkyffVpRAnr34Yqvh9C8,24976

{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: cp313-cp313-macosx_11_0_arm64
 Generator: delocate 0.13.0

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