Merge pull request #109 from sdpython/fst

Use f strings in more places

Author: sdpython

_unittests/ut_timeseries/test_preprocessing_timeseries.py

@@ -26,6 +26,22 @@ def test_base_parameters_split0(self):
             self.assertEqualArray(nx, ppx)
             self.assertEqualArray(ny, ppy)
 
+    def test_base_parameters_split0_weight(self):
+        X = numpy.arange(20).reshape((10, 2))
+        y = numpy.arange(10) * 100
+        bs = BaseTimeSeries(past=2)
+        nx, ny, _ = build_ts_X_y(bs, X, y)
+        weights = numpy.ones((nx.shape[0], ), dtype=nx.dtype)
+        for d in range(0, 5):
+            proc = TimeSeriesDifference(d)
+            proc.fit(nx, ny, weights)
+            px, py = proc.transform(nx, ny)
+            self.assertEqualArray(px[-1, :], nx[-1, :])
+            rev = proc.get_fct_inv()
+            ppx, ppy = rev.transform(px, py)
+            self.assertEqualArray(nx, ppx)
+            self.assertEqualArray(ny, ppy)
+
 
 if __name__ == "__main__":
     unittest.main()

mlinsights/helpers/parameters.py

@@ -12,7 +12,7 @@ def format_value(v):
     @param      v           a string
     @return                 a string
     """
-    return ("'{0}'".format(v.replace("'", "\\'"))
+    return (v.replace("'", "\\'")
             if isinstance(v, str) else f"{v}")
 
 

mlinsights/helpers/pipeline.py

@@ -203,5 +203,6 @@ def decision_function(self, X, *args, **kwargs):
             try:
                 setattr(model, k, MethodType(new_methods[k], model))
             except AttributeError:  # pragma: no cover
-                warnings.warn("Unable to overwrite method '{}' for class "
-                              "{}.".format(k, type(model)))
+                warnings.warn(
+                    f"Unable to overwrite method {k!r} for class "
+                    f"{type(model)!r}.")

mlinsights/mlbatch/pipeline_cache.py

@@ -54,12 +54,12 @@ def _get_fit_params_steps(self, fit_params):
             if '__' not in pname:
                 if not isinstance(pval, dict):
                     raise ValueError(  # pragma: no cover
-                        "For scikit-learn < 0.23, "
-                        "Pipeline.fit does not accept the {} parameter. "
-                        "You can pass parameters to specific steps of your "
-                        "pipeline using the stepname__parameter format, e.g. "
-                        "`Pipeline.fit(X, y, logisticregression__sample_weight"
-                        "=sample_weight)`.".format(pname))
+                        f"For scikit-learn < 0.23, "
+                        f"Pipeline.fit does not accept the {pname} parameter. "
+                        f"You can pass parameters to specific steps of your "
+                        f"pipeline using the stepname__parameter format, e.g. "
+                        f"`Pipeline.fit(X, y, logisticregression__sample_weight"
+                        f"=sample_weight)`.")
                 else:
                     fit_params_steps[pname].update(pval)
             else:

mlinsights/mlmodel/_kmeans_022.py

@@ -63,8 +63,9 @@ def _assign_labels_csr(X, sample_weight, x_squared_norms, centers,
     if (distances is not None and
             distances.shape != (X.shape[0], )):
         raise ValueError(  # pragma: no cover
-            "Dimension mismatch for distance got {}, expecting {}."
-            "".format(distances.shape, (X.shape[0], centers.shape[0])))
+            f"Dimension mismatch for distance got "
+            f"{distances.shape}, expecting "
+            f"{(X.shape[0], centers.shape[0])}.")
     n_clusters = centers.shape[0]
     n_samples = X.shape[0]
     store_distances = 0

mlinsights/mlmodel/_kmeans_constraint_.py

@@ -550,9 +550,9 @@ def _constraint_kmeans_weights(X, labels, sample_weight, centers, inertia, it,
             X, centers, sw, weights, labels, total_inertia)
         if numpy.isnan(inertia):
             raise RuntimeError(  # pragma: no cover
-                "nanNobs={} Nclus={}\ninertia={}\nweights={}\ndiff={}\nlabels={}".format(
-                    X.shape[0], centers.shape[0], inertia, weights, diff,
-                    set(labels)))
+                f"nanNobs={X.shape[0]} Nclus={centers.shape[0]}\n"
+                f"inertia={inertia}\nweights={weights}\ndiff={diff}\n"
+                f"labels={set(labels)}")
 
         # best option so far?
         if best_inertia is None or inertia < best_inertia:

mlinsights/mlmodel/categories_to_integers.py

@@ -152,8 +152,8 @@ def transform(v, vec):
                         lv = lv[:20]
                         lv.append("...")
                     raise ValueError(  # pragma: no cover
-                        "Unable to find category value '{0}' type(v)={2} among\n{1}".format(
-                            v, "\n".join(lv), type(v)))
+                        "Unable to find category value %r type(v)=%r "
+                        "among\n%s" % (v, type(v), '\n'.join(lv)))
                 return numpy.nan
 
             sch, pos, new_vector = self._schema
@@ -184,8 +184,9 @@ def transform(v, vec):
                                 lv = lv[:20]
                                 lv.append("...")
                             raise ValueError(  # pragma: no cover
-                                "unable to find category value '{0}': '{1}' type(v)={3} among\n{2}".format(
-                                    k, v, "\n".join(lv), type(v)))
+                                "Unable to find category value %r: %r "
+                                "type(v)=%r among\n%s" % (
+                                    k, v, type(v), '\n'.join(lv)))
                     else:
                         p = pos[k] + vec[k][v]
                     res[i, p] = 1.0

mlinsights/mlmodel/decision_tree_logreg.py

@@ -189,8 +189,9 @@ def fit_improve(self, dtlr, total_N, X, y, sample_weight):
             # The classifier is not linear and cannot be improved.
             if dtlr.fit_improve_algo == 'intercept_sort_always':  # pragma: no cover
                 raise RuntimeError(
-                    "The model is not linear ({}), "
-                    "intercept cannot be improved.".format(self.estimator.__class__.__name__))
+                    f"The model is not linear "
+                    f"({self.estimator.__class__.__name__!r}), "
+                    f"intercept cannot be improved.")
             return prob
 
         above = prob[:, 1] > self.threshold
@@ -368,8 +369,8 @@ def __init__(self, estimator=None,
 
         if self.fit_improve_algo not in DecisionTreeLogisticRegression._fit_improve_algo_values:
             raise ValueError(
-                "fit_improve_algo='{}' not in {}".format(
-                    self.fit_improve_algo, DecisionTreeLogisticRegression._fit_improve_algo_values))
+                f"fit_improve_algo={self.fit_improve_algo!r} "
+                f"not in {DecisionTreeLogisticRegression._fit_improve_algo_values}.")
 
     def fit(self, X, y, sample_weight=None):
         """
@@ -401,8 +402,8 @@ def fit(self, X, y, sample_weight=None):
         self.classes_ = numpy.array(sorted(set(y)))
         if len(self.classes_) != 2:
             raise RuntimeError(
-                "The model only supports binary classification but labels are "
-                "{}.".format(self.classes_))
+                f"The model only supports binary classification but labels are "
+                f"{self.classes_}.")
 
         if self.strategy == 'parallel':
             return self._fit_parallel(X, y, sample_weight)

mlinsights/mlmodel/kmeans_l1.py

@@ -617,9 +617,10 @@ def _fit_l1(self, X, y=None, sample_weight=None):
         distinct_clusters = len(set(best_labels))
         if distinct_clusters < self.n_clusters:
             warnings.warn(  # pragma no cover
-                "Number of distinct clusters ({}) found smaller than "
-                "n_clusters ({}). Possibly due to duplicate points "
-                "in X.".format(distinct_clusters, self.n_clusters),
+                f"Number of distinct clusters ({distinct_clusters}) "
+                f"found smaller than "
+                f"n_clusters ({self.n_clusters}). Possibly "
+                f"due to duplicate points in X.",
                 ConvergenceWarning, stacklevel=2)
 
         self.cluster_centers_ = best_centers

mlinsights/mlmodel/ml_featurizer.py

@@ -43,8 +43,8 @@ def model_featurizer(model, **params):
         return model_featurizer_torch(model, **params)
     tried.append("torch")
     raise FeaturizerTypeError(  # pragma no cover
-        "Unable to process type '{0}', allowed:\n{1}".format(
-            type(model), "\n".join(sorted(str(_) for _ in tried))))
+        "Unable to process type %r, allowed:\n%s" % (
+            type(model), '\n'.join(sorted(str(_) for _ in tried))))
 
 
 def is_vector(X):