@@ -2,6 +2,26 @@ Changelog
 ==========
 
 
+14.7.3 (2026-08-03)
+-------------------
+
+* Initial release for DSS 14.7.3
+
+14.7.2 (2026-07-13)
+-------------------
+
+* Initial release for DSS 14.7.2
+
+14.7.1 (2026-07-13)
+-------------------
+
+* Initial release for DSS 14.7.1
+
+14.7.0 (2026-06-25)
+-------------------
+
+* Initial release for DSS 14.7.0
+
 14.6.2 (2026-06-15)
 -------------------
 
 
@@ -13,7 +13,13 @@ def __init__(self, parameters):
         self.thresholds = parameters["thresholds"]
 
     def process(self, X_numeric, X_non_numeric):
-        X_numeric[:, self.output_columns] = np.where(X_numeric[:, self.columns] > self.thresholds, 1.0, 0.0)
+        kept = [
+            (self.columns[index], self.output_columns[index], self.thresholds[index])
+            for index in X_numeric.existing_column_indices(self.output_columns)
+        ]
+        if len(kept) > 0:
+            columns, output_columns, thresholds = zip(*kept)
+            X_numeric[:, list(output_columns)] = np.where(X_numeric[:, list(columns)] > thresholds, 1.0, 0.0)
         return X_numeric, X_non_numeric
 
     def __repr__(self):
 
@@ -19,8 +19,10 @@ def process(self, X_numeric, X_non_numeric):
 
         for col1, col2, values in zip(self.column_1, self.column_2, self.values):
             for value_col1, value_col2 in values:
-                mask = (data[:, columns.index(col1)] == value_col1) * (data[:, columns.index(col2)] == value_col2)
-                X_numeric[:, "interaction:{}:{}:{}:{}".format(col1, col2, value_col1, value_col2)] = np.where(mask, 1, self.unrecorded_value)
+                output_name = "interaction:{}:{}:{}:{}".format(col1, col2, value_col1, value_col2)
+                if X_numeric.has_column(output_name):
+                    mask = (data[:, columns.index(col1)] == value_col1) * (data[:, columns.index(col2)] == value_col2)
+                    X_numeric[:, output_name] = np.where(mask, 1, self.unrecorded_value)
 
         return X_numeric, X_non_numeric
 
 
@@ -21,16 +21,21 @@ def __init__(self, parameters):
     def process(self, X_numeric, X_non_numeric):
         for column, level, output_names, defaults, encodings in zip(
                 self.columns, self.levels, self.output_names, self.defaults, self.encodings):
+            kept_output_names = X_numeric.existing_columns(output_names)
+            if len(kept_output_names) == 0:
+                continue
 
             mask_all = np.full((len(X_numeric),), False)
             for category, values in encodings.items():
                 mask = (X_non_numeric[:, column] == category)
                 for value, output_name in zip(values, output_names):
-                    X_numeric[mask, output_name] = value
+                    if X_numeric.has_column(output_name):
+                        X_numeric[mask, output_name] = value
                 mask_all += mask
 
             for default, output_name in zip(defaults, output_names):
-                X_numeric[~mask_all, output_name] = default
+                if X_numeric.has_column(output_name):
+                    X_numeric[~mask_all, output_name] = default
 
         return X_numeric, X_non_numeric
 
 
@@ -32,15 +32,21 @@ def truncate_datetime(self, period, date):
     def process(self, X_numeric, X_non_numeric):
         origin = datetime.datetime(1900, 1, 1, 0, 0, 0)
         for column, periods in self.mapping.items():
+            output_names_by_period = {}
+            for period in periods:
+                prefix = "datetime_cyclical:{}:{}:".format(column, period.lower())
+                output_names_by_period[period] = (prefix + "sin", prefix + "cos")
+
             timestamps = X_numeric[:, column] * 1000.0
             dates = [origin + datetime.timedelta(milliseconds=timestamp) for timestamp in timestamps]
-
             for period in periods:
+                sin_output_name, cos_output_name = output_names_by_period[period]
                 second_subperiods = np.array([(date - self.truncate_datetime(period, date)).total_seconds() for date in dates])
                 trigo_args = second_subperiods * 2 * 3.141592653589793 / PERIOD[period]
-                prefix = "datetime_cyclical:{}:{}:".format(column, period.lower())
-                X_numeric[:, prefix + "sin"] = np.sin(trigo_args)
-                X_numeric[:, prefix + "cos"] = np.cos(trigo_args)
+                if X_numeric.has_column(sin_output_name):
+                    X_numeric[:, sin_output_name] = np.sin(trigo_args)
+                if X_numeric.has_column(cos_output_name):
+                    X_numeric[:, cos_output_name] = np.cos(trigo_args)
 
         return X_numeric, X_non_numeric
 
 
@@ -28,9 +28,12 @@ def __init__(self, parameters):
     def process(self, X_numeric, X_non_numeric):
         for i, column in enumerate(self.columns):
             # Propagate NaN with default 0 * X_numeric[:, column]
-            X_numeric[:, self.log_names[i]] = np.where(X_numeric[:, column] > 0, np.log(X_numeric[:, column] + 0.00000001), 0 * X_numeric[:, column])
-            X_numeric[:, self.sqrt_names[i]] = np.where(X_numeric[:, column] > 0, np.sqrt(X_numeric[:, column]), 0 * X_numeric[:, column])
-            X_numeric[:, self.square_names[i]] = X_numeric[:, column] ** 2
+            if X_numeric.has_column(self.log_names[i]):
+                X_numeric[:, self.log_names[i]] = np.where(X_numeric[:, column] > 0, np.log(X_numeric[:, column] + 0.00000001), 0 * X_numeric[:, column])
+            if X_numeric.has_column(self.sqrt_names[i]):
+                X_numeric[:, self.sqrt_names[i]] = np.where(X_numeric[:, column] > 0, np.sqrt(X_numeric[:, column]), 0 * X_numeric[:, column])
+            if X_numeric.has_column(self.square_names[i]):
+                X_numeric[:, self.square_names[i]] = X_numeric[:, column] ** 2
 
         return X_numeric, X_non_numeric
 
 
@@ -16,7 +16,7 @@ def compute_valid_mask(self, X_numeric, X_non_numeric):
         for column in self.columns:
             # important to check in non numeric first because dates can be in both
             #  but are not normalized yet
-            if column in X_non_numeric.column_index:
+            if X_non_numeric.has_column(column):
                 rows_to_compute *= np.where(X_non_numeric[:, column] == None, False, True)
             else:
                 rows_to_compute *= np.where(np.isnan(X_numeric[:, column]), False, True)
 
@@ -17,17 +17,23 @@ def process(self, X_numeric, X_non_numeric):
             mask_in_levels = np.full((len(X_numeric,)), False)
             for value in parameters["levels"]:
                 mask = X_non_numeric[:, column] == value
-                X_numeric[:, "dummy:{}:{}".format(column, value)] = np.where(mask, 1, self.unrecorded_value)
+                output_name = "dummy:{}:{}".format(column, value)
+                if X_numeric.has_column(output_name):
+                    X_numeric[:, output_name] = np.where(mask, 1, self.unrecorded_value)
                 mask_in_levels += mask
 
             # Missing values
             mask_none = X_non_numeric[:, column] == None
-            X_numeric[:, "dummy:{}:N/A".format(column)] = np.where(mask_none, 1, self.unrecorded_value)
+            output_name = "dummy:{}:N/A".format(column)
+            if X_numeric.has_column(output_name):
+                X_numeric[:, output_name] = np.where(mask_none, 1, self.unrecorded_value)
 
             # Values unseen during training
             if parameters["with_others"]:
                 mask_others = ~(mask_none + mask_in_levels)
-                X_numeric[:, "dummy:{}:{}".format(column, "__Others__")] = np.where(mask_others, 1, self.unrecorded_value)
+                output_name = "dummy:{}:{}".format(column, "__Others__")
+                if X_numeric.has_column(output_name):
+                    X_numeric[:, output_name] = np.where(mask_others, 1, self.unrecorded_value)
         return X_numeric, X_non_numeric
 
     def __repr__(self):
 
@@ -14,11 +14,15 @@ def __init__(self, parameters):
         self.unrecorded_value = parameters["unrecorded_value"]
 
     def process(self, X_numeric, X_non_numeric):
-        for (column, output_name) in zip(self.columns, self.output_names):
-            if column in X_numeric.column_index:
-                X_numeric[:, output_name] = np.where(np.isnan(X_numeric[:, column]), self.unrecorded_value, 1)
+        for input_column, output_feature_name in zip(self.columns, self.output_names):
+            if not X_numeric.has_column(output_feature_name):
+                # Feature reduction may drop this generated output feature, so there is no allocated column to write.
+                continue
+            if X_numeric.has_column(input_column):
+                X_numeric[:, output_feature_name] = np.where(np.isnan(X_numeric[:, input_column]), self.unrecorded_value, 1)
             else:
-                X_numeric[:, output_name] = np.where(X_non_numeric[:, column] == None, self.unrecorded_value, 1)
+                # Non-numeric input columns live in X_non_numeric; their generated flag output is numeric.
+                X_numeric[:, output_feature_name] = np.where(X_non_numeric[:, input_column] == None, self.unrecorded_value, 1)
 
         return X_numeric, X_non_numeric
 
 
@@ -18,7 +18,7 @@ def __init__(self, parameters):
     def process(self, X_numeric, X_non_numeric):
         for column, impute_value in self.impute_values.items():
             # Important to check on non numeric first since it can be in both (and not encoded at this step)
-            if column in X_non_numeric.column_index:
+            if X_non_numeric.has_column(column):
                 X_non_numeric[:, column] = np.where(X_non_numeric[:, column] == None, impute_value, X_non_numeric[:, column])
             else:
                 X_numeric[:, column] = np.where(np.isnan(X_numeric[:, column]), impute_value, X_numeric[:, column])