tsadmetrics 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

tsadmetrics/metric_utils.py

@@ -1,241 +1,5 @@
 import numpy as np
-from ._tsadeval.metrics import Binary_anomalies, pointwise_to_full_series, segmentwise_to_full_series, DelayThresholdedPointAdjust
-def get_tp_tn_fp_fn_point_wise(y_true: np.array,y_pred: np.array):
-    TP,TN,FP,FN=0,0,0,0
-    for true,pred in zip(y_true,y_pred):
-        if true==pred:
-            if true==1:
-                TP+=1
-            else:
-                TN+=1
-        else:
-            if true==1:
-                FN+=1
-            else:
-                FP+=1
-    return TP,TN,FP,FN
-
-
-def get_events(y_true,anomaly=True):
-    events = []
-    start_idx = None
-    v = 0
-    if anomaly:
-        v = 1
-    else:
-        v = 0
-
-    for i, val in enumerate(y_true):
-        if val == v:  # Si encontramos el inicio de un evento
-            if start_idx is None:
-                start_idx = i  # Establecemos el inicio del evento
-        elif start_idx is not None:  # Si encontramos el final de un evento
-            events.append((start_idx, i - 1))  # Agregamos el evento a la lista de eventos
-            start_idx = None  # Restablecemos el inicio del evento
-
-    if start_idx is not None:  # Si al final de la secuencia aún estamos dentro de un evento
-        events.append((start_idx, len(y_true) - 1))  # Agregamos el evento final a la lista de eventos
-
-
-    return events
-
-def calculate_intersection(event1, event2):
-    start_intersection = max(event1[0], event2[0])
-    end_intersection = min(event1[1], event2[1])
-
-    # If there is an intersection, return the range of the intersection, otherwise return None
-    if start_intersection <= end_intersection:
-        return [start_intersection, end_intersection]
-    else:
-        return None
-
-def get_tp_tn_fp_fn_point_adjusted(y_true: np.array,y_pred: np.array):
-    TP, TN, FP, FN = get_tp_tn_fp_fn_point_wise(y_true, y_pred)
-    TP=0
-    FN=0
-    y_true_events = get_events(y_true,anomaly=True)
-    y_pred_events = get_events(y_pred,anomaly=True)
-
-    i_true = 0
-    i_pred = 0
-    while i_true<len(y_true_events):
-        detected = False
-        while i_pred<len(y_pred_events) and y_true_events[i_true][1]>y_pred_events[i_pred][0]:
-            if calculate_intersection(y_true_events[i_true],y_pred_events[i_pred]) is not None:
-                TP+= y_true_events[i_true][1]-y_true_events[i_true][0]+1
-                detected=True
-                break
-            elif y_true_events[i_true][0]>y_pred_events[i_pred][1]:
-                i_pred+=1
-        
-        if not detected:
-            FN+= y_true_events[i_true][1]-y_true_events[i_true][0]+1
-        i_true+=1
-    
-    return TP, TN, FP, FN
-
-def get_tp_tn_fp_fn_delay_th_point_adjusted(y_true: np.array,y_pred: np.array,k: int):
-    TP, TN, FP, FN = get_tp_tn_fp_fn_point_wise(y_true, y_pred)
-    TP=0
-    FN=0
-    y_true_events = get_events(y_true,anomaly=True)
-    y_pred_events = get_events(y_pred,anomaly=True)
-
-    i_true = 0
-    i_pred = 0
-    while i_true<len(y_true_events):
-        detected = False
-        while i_pred<len(y_pred_events) and y_true_events[i_true][1]>y_pred_events[i_pred][0]:
-            intersec = calculate_intersection(y_true_events[i_true],y_pred_events[i_pred])
-            if intersec is not None and intersec[0]-y_true_events[i_true][0]<k:
-                TP+= y_true_events[i_true][1]-y_true_events[i_true][0]+1
-                detected=True
-                break
-            else:
-                i_pred+=1
-        
-        if not detected:
-            FN+= y_true_events[i_true][1]-y_true_events[i_true][0]+1
-        i_true+=1
-    
-    return TP, TN, FP, FN
-
-def get_tp_tn_fp_fn_point_adjusted_at_k(y_true: np.array,y_pred: np.array, k: float):
-    TP, TN, FP, FN = get_tp_tn_fp_fn_point_wise(y_true, y_pred)
-    TP=0
-    FN=0
-    y_true_events = get_events(y_true,anomaly=True)
-    y_pred_events = get_events(y_pred,anomaly=True)
-
-    i_true = 0
-    i_pred = 0
-    while i_true<len(y_true_events):
-        detected = False
-        while i_pred<len(y_pred_events) and y_true_events[i_true][1]>y_pred_events[i_pred][0]:
-            intersec = calculate_intersection(y_true_events[i_true],y_pred_events[i_pred])
-            if intersec is not None:
-                event_size = y_true_events[i_true][1]-y_true_events[i_true][0]+1
-                intersec_size = intersec[1]-intersec[0]+1
-            if intersec is not None and intersec_size/event_size>=k:
-                
-                TP+= y_true_events[i_true][1]-y_true_events[i_true][0]+1
-                detected=True
-                break
-            else:
-                i_pred+=1
-        
-        if not detected:
-            FN+= y_true_events[i_true][1]-y_true_events[i_true][0]+1
-        i_true+=1
-    
-    return TP, TN, FP, FN
-
-
-def get_tp_tn_fp_fn_latency_sparsity_aw(y_true: np.array, y_pred: np.array, ni: int):
-    batched_shape = (int(np.ceil(y_pred.shape[0] / ni)), 1)
-    label_batch = np.zeros(batched_shape)
-    pred_batch = np.zeros(batched_shape)
-    actual = np.copy(y_true)
-    predict = np.copy(y_pred)
-    detect_state = False  # triggered when a True anomaly is detected by model
-    anomaly_batch_count = 0
-    i, i_ni = 0, 0
-    step = ni
-
-    while i < len(y_true) and step > 1:
-        j = min(i + step, len(y_true))  # end of ni (batch) starting at i
-
-        # Adjust step size if needed
-        if step > 2 and actual[i:j].sum() > 1:
-            if np.diff(np.where(actual[i:j])).max() > 1:  # if it finds an interruption in the true label continuity
-                step = min(int((j - i) / 2), 2)  # reduce step size
-                label_batch = np.append(label_batch, [[0]], axis=0)
-                pred_batch = np.append(pred_batch, [[0]], axis=0)  # increase size
-                j = i + step
-            else:
-                step = ni
-        else:
-            step = ni
-
-        # Start rolling window scoring
-        if actual[i:j].max():  # If label = T
-            if not actual[i]:  # if first value is normal
-                detect_state = False
-            s = actual[i:j].argmax()  # this is the index of the first occurrence
-            if detect_state:  # if anomaly was previously detected by model
-                anomaly_batch_count += 1
-                pred_batch[i_ni], label_batch[i_ni], predict[i + s:j] = 1, 1, 1
-            elif predict[i:j].max():  # if alert was detected with T
-                detect_state = True  # turn on detection state
-                anomaly_batch_count += 1
-                pred_batch[i_ni], label_batch[i_ni], predict[i + s:j] = 1, 1, 1
-            else:
-                detect_state = False
-                label_batch[i_ni] = 1
-        else:
-            detect_state = False
-            if predict[i:j].max():  # if False positive
-                pred_batch[i_ni] = 1
-        i += step
-        i_ni += 1
-
-    if ni == 1:
-        return get_tp_tn_fp_fn_point_wise(actual, predict)
-
-    return get_tp_tn_fp_fn_point_wise(label_batch.flatten().astype(int), pred_batch.flatten().astype(int))
-
-def get_tp_fp_fn_segment_wise(y_true: np.array,y_pred: np.array):
-    
-
-    y_true_anomaly_events = get_events(y_true)
-    pred_anomaly_events = get_events(y_pred)
-    y_true_normal_events = get_events(y_true,False)
-    pred_normal_events = get_events(y_pred,False)
-
-    TP = 0
-    FN = 0
-    FP = 0
-    #TP
-    i = 0
-    for e_p in pred_anomaly_events:
-        
-        c, d = e_p
-        while i<len(y_true_anomaly_events):
-            e_g = y_true_anomaly_events[i]
-            a, b = e_g
-            if a>d:
-              break
-
-            if b<c:
-                i+=1
-                continue
-
-            else:
-              if max(a, c) <= min(b, d):
-                  TP+=1
-            
-
-            i+=1
-
-    #FN
-    FN = len(y_true_anomaly_events) - TP
-    #FP
-    i = 0
-    for e_p in y_true_normal_events:
-        
-        c, d = e_p
-        while i<len(pred_anomaly_events):
-            e_g = pred_anomaly_events[i]
-            a, b = e_g
-            if a>d:
-                break
-            if b<c:
-                i+=1
-                continue
-            if calculate_intersection(e_g, e_p) is not None:
-                FP+=1
-            i+=1
-    return TP, FP, FN
+from ._tsadeval.metrics import pointwise_to_full_series, segmentwise_to_full_series
 
 def is_full_series(length: int, anomalies: np.array):
     # [1 0 1 1 0]
@@ -330,4 +94,5 @@ def position(i, anomaly_length,bias):
         else:
             return anomaly_length - i + 1
     else:
-        raise Exception("Error, wrong bias value.")
+        raise Exception("Error, wrong bias value.")
+    

tsadmetrics/non_binary_metrics.py

@@ -1,7 +1,8 @@
 import numpy as np
 from ._tsadeval.metrics import *
+from .validation import validate_non_binary_inputs
 from sklearn.metrics import auc
-from pate.PATE_metric import PATE
+from pate.PATE_metric import PATE 
 def precision_at_k(y_true : np.array, y_anomaly_scores:  np.array):
     """
     Calculate the precision at k score for anomaly detection in time series.
@@ -14,6 +15,8 @@ def precision_at_k(y_true : np.array, y_anomaly_scores:  np.array):
     The value of k is automatically set to the number of true anomalies present in 
     y_true. That is, k = sum(y_true).
 
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+
     Parameters:
         y_true (np.array):
             The ground truth binary labels for the time series data.
@@ -23,6 +26,8 @@ def precision_at_k(y_true : np.array, y_anomaly_scores:  np.array):
     Returns:
         float: The precision at k score.
     """
+    validate_non_binary_inputs(y_true, y_anomaly_scores)
+
     m = PatK_pw(y_true,y_anomaly_scores)
 
     return m.get_score()
@@ -35,6 +40,8 @@ def auc_roc_pw(y_true : np.array, y_anomaly_scores:  np.array):
     computed in a point-wise manner. That is, each point in the time series is treated
     independently when calculating true positives, false positives, and false negatives.
 
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+
     Parameters:
         y_true (np.array):
             Ground-truth binary labels for the time series (0 = normal, 1 = anomaly).
@@ -44,6 +51,7 @@ def auc_roc_pw(y_true : np.array, y_anomaly_scores:  np.array):
     Returns:
         float: AUC-ROC score.
     """
+    validate_non_binary_inputs(y_true, y_anomaly_scores)
     
     m = AUC_ROC(y_true,y_anomaly_scores)
 
@@ -58,6 +66,8 @@ def auc_pr_pw(y_true : np.array ,y_anomaly_scores:  np.array):
     computed in a point-wise manner. That is, each point in the time series is treated
     independently when calculating precision and recall.
 
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+
     Parameters:
         y_true (np.array):
             Ground-truth binary labels for the time series (0 = normal, 1 = anomaly).
@@ -67,6 +77,8 @@ def auc_pr_pw(y_true : np.array ,y_anomaly_scores:  np.array):
     Returns:
         float: AUC-PR score.
     """
+    validate_non_binary_inputs(y_true, y_anomaly_scores)
+
     m = AUC_PR_pw(y_true,y_anomaly_scores)
 
     return m.get_score()
@@ -84,6 +96,8 @@ def auc_pr_pa(y_true: np.array, y_anomaly_scores: np.array):
     to the ground-truth labels to compute true positives, false positives, and false negatives,
     which are used to construct the PR curve.
 
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+
     Parameters:
         y_true (np.array):
             Ground-truth binary labels for the time series (0 = normal, 1 = anomaly).
@@ -93,7 +107,7 @@ def auc_pr_pa(y_true: np.array, y_anomaly_scores: np.array):
     Returns:
         float: AUC-PR score (with point-adjusted evaluation).
     """
-        
+    validate_non_binary_inputs(y_true, y_anomaly_scores)
     
     precisions = [1]
     recalls = [0]
@@ -176,6 +190,8 @@ def auc_pr_sw(y_true: np.array, y_anomaly_scores: np.array):
     that does not overlap with any ground-truth anomaly. These adjusted counts are then used 
     to compute precision and recall for constructing the PR curve.
 
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+
     Parameters:
         y_true (np.array):
             Ground-truth binary labels for the time series (0 = normal, 1 = anomaly).
@@ -185,6 +201,7 @@ def auc_pr_sw(y_true: np.array, y_anomaly_scores: np.array):
     Returns:
         float: AUC-PR score (with segment-wise evaluation).
     """
+    validate_non_binary_inputs(y_true, y_anomaly_scores)
 
     precisions = [1]
     recalls = [0]
@@ -284,6 +301,8 @@ def vus_roc(y_true : np.array ,y_anomaly_scores:  np.array, window=4):
     the ROC-AUC over different values of the tolerance parameter, from 0 to `window`, thus producing
     a volume under the ROC surface.
 
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+
     For more information, see the original paper:
     https://dl.acm.org/doi/10.14778/3551793.3551830
 
@@ -300,6 +319,8 @@ def vus_roc(y_true : np.array ,y_anomaly_scores:  np.array, window=4):
 
     
     """
+    validate_non_binary_inputs(y_true, y_anomaly_scores)
+
     m = VUS_ROC(y_true,y_anomaly_scores,max_window=window)
 
     return m.get_score()
@@ -314,6 +335,8 @@ def vus_pr(y_true : np.array ,y_anomaly_scores:  np.array,  window=4):
     anomalies that are temporally close to the true events. The final metric integrates the PR-AUC
     over several levels of temporal tolerance (from 0 to `window`), yielding a volume under the PR surface.
 
+    Implementation of https://link.springer.com/article/10.1007/s10618-023-00988-8
+    
     For more information, see the original paper:
     https://dl.acm.org/doi/10.14778/3551793.3551830
 
@@ -330,6 +353,8 @@ def vus_pr(y_true : np.array ,y_anomaly_scores:  np.array,  window=4):
 
     
     """
+    validate_non_binary_inputs(y_true, y_anomaly_scores)
+
     m = VUS_PR(y_true,y_anomaly_scores,max_window=window)
 
     return m.get_score()
@@ -350,6 +375,8 @@ def real_pate(y_true: np.array, y_anomaly_scores: np.array, early: int, delay: i
     The final PATE score aggregates these weighted contributions across all time steps, yielding 
     a smooth performance measure that is sensitive to both the timing and confidence of the predictions.
 
+    Implementation of https://arxiv.org/abs/2405.12096
+    
     For more information, see the original paper:
     https://arxiv.org/abs/2405.12096
 
@@ -366,4 +393,6 @@ def real_pate(y_true: np.array, y_anomaly_scores: np.array, early: int, delay: i
     Returns:
         float: The real-valued PATE score.
     """
+    validate_non_binary_inputs(y_true, y_anomaly_scores)
+
     return PATE(y_true, y_anomaly_scores, early, delay, binary_scores=False)

tsadmetrics/scripts/compute_metrics.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+import argparse
+from tsadmetrics.utils import compute_metrics_from_file
+
+
+def main():
+    
+    parser = argparse.ArgumentParser(
+        description='Compute metrics from anomaly detection results and configuration files.'
+    )
+    
+    
+    parser.add_argument(
+        '--res_file', 
+        type=str, 
+        required=True,
+        help='Path to the results CSV file (e.g., results.csv)'
+    )
+    parser.add_argument(
+        '--conf_file', 
+        type=str, 
+        required=True,
+        help='Path to the configuration JSON file (e.g., conf.json)'
+    )
+    parser.add_argument(
+        '--output_dir', 
+        type=str, 
+        required=True,
+        help='Directory where output files will be saved (e.g., ./output_dir)'
+    )
+    
+    args = parser.parse_args()
+    
+    
+    compute_metrics_from_file(
+        results_file=args.res_file,
+        conf_file=args.conf_file,
+        output_dir=args.output_dir
+    )
+
+if __name__ == '__main__':
+    main()

tsadmetrics/utils.py

@@ -1,7 +1,8 @@
 import numpy as np
 import pandas as pd
 import time
-
+import sys
+import tsadmetrics
 def compute_metrics(y_true: np.array,y_pred: np.array, metrics: list, metrics_params: dict, is_anomaly_score = False, verbose = False):
     """
     Computes the specified metrics for the given true and predicted values.
@@ -52,4 +53,70 @@ def compute_metrics(y_true: np.array,y_pred: np.array, metrics: list, metrics_pa
     metrics_df['metric_name'] = results.keys()
     metrics_df['metric_value'] = results.values()
     
-    return metrics_df
+    return metrics_df
+
+
+def compute_metrics_from_file(results_file: str, conf_file: str, output_dir: str = '.'):
+    """
+    Computes metrics based on prediction results from a CSV file and configuration from a JSON file.
+
+    Parameters:
+        results_file (str): Path to CSV file containing y_true and y_pred columns.
+        conf_file (str): Path to JSON configuration file with metrics and parameters.
+
+    Returns:
+        pd.DataFrame: DataFrame with computed metrics.
+    """
+    # Read results data
+    res = pd.read_csv(results_file)
+    y_true = res['y_true'].values
+    y_pred = res['y_pred'].values
+    
+    # Determine if predictions are binary or scores
+    is_anomaly_score = False
+    unique_values = np.unique(y_pred)
+    if not (np.array_equal(unique_values, [0, 1]) or 
+            np.array_equal(unique_values, [0]) or 
+            np.array_equal(unique_values, [1])):
+        is_anomaly_score = True
+        if not np.all((y_pred >= 0) & (y_pred <= 1)):
+            raise ValueError("y_pred must be either binary (0/1) or anomaly scores in range [0, 1]")
+
+    # Read configuration from JSON using pandas
+    try:
+        config_df = pd.read_json(conf_file, orient='records')
+    except ValueError as e:
+        raise ValueError(f"Invalid JSON format in configuration file: {str(e)}")
+
+    # Convert pandas DataFrame to format expected by compute_metrics
+    metrics = []
+    metrics_params = {}
+    
+    for _, row in config_df.iterrows():
+        metric_name = row['name']
+        try:
+            metric_func = getattr(tsadmetrics, metric_name)
+        except AttributeError:
+            raise ValueError(f"Metric function '{metric_name}' not found in tsadmetrics module")
+        
+        metrics.append((metric_name, metric_func))
+        
+        # Handle params (convert from pandas Series to dict if needed)
+        params = row.get('params', {})
+        if pd.notna(params) and params:  # Check for non-empty params
+            if isinstance(params, pd.Series):
+                metrics_params[metric_name] = params.to_dict()
+            else:
+                metrics_params[metric_name] = params
+
+    # Compute metrics
+    metrics_df = compute_metrics(
+        y_true=y_true,
+        y_pred=y_pred,
+        metrics=metrics,
+        metrics_params=metrics_params,
+        is_anomaly_score=is_anomaly_score,
+        verbose=False
+    )
+    metrics_df.to_csv(output_dir+'/computed_metrics.csv', index=False)
+

tsadmetrics/validation.py

@@ -0,0 +1,35 @@
+import numpy as np
+
+def check_gt_binary_array(arr):
+    if len(arr.shape) != 1:
+        raise ValueError("Ground truth input must be a 1D binary array.")
+    if not np.all(np.isin(arr, [0, 1])):
+        raise ValueError("Ground truth input array must contain only binary values (0 or 1).")
+    return True
+
+def check_pred_binary_array(arr):
+    if len(arr.shape) != 1:
+        raise ValueError("Prediction input must be a 1D binary array.")
+    if not np.all(np.isin(arr, [0, 1])):
+        raise ValueError("Prediction input array must contain only binary values (0 or 1).")
+    return True
+def check_same_length(arr1, arr2):
+    if len(arr1) != len(arr2):
+        raise ValueError("Ground truth and prediction arrays must have the same length.")
+    return True
+
+def check_pred_continuous_array(arr):
+    if len(arr.shape) != 1:
+        raise ValueError("Prediction input must be a 1D continuous array.")
+    if not np.all((arr >= 0) & (arr <= 1)):
+        raise ValueError("All values in the array must be in the range [0, 1].")
+    return True
+
+def validate_binary_inputs(y_true, y_pred):
+    check_gt_binary_array(y_true)
+    check_pred_binary_array(y_pred)
+    check_same_length(y_true, y_pred)
+
+def validate_non_binary_inputs(y_true, y_anomaly_scores):
+    check_gt_binary_array(y_true)
+    check_same_length(y_true, y_anomaly_scores)

{tsadmetrics-0.1.14.dist-info → tsadmetrics-0.1.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tsadmetrics
-Version: 0.1.14
+Version: 0.1.16
 Summary: =?unknown-8bit?q?Librer=C3=ADa_para_evaluaci=C3=B3n_de_detecci=C3=B3n_de_anomal=C3=ADas?= en series temporales
 Home-page: https://github.com/pathsko/TSADmetrics
 Author: Pedro Rafael Velasco Priego

{tsadmetrics-0.1.14.dist-info → tsadmetrics-0.1.16.dist-info}/RECORD

@@ -1,4 +1,4 @@
-docs/conf.py,sha256=skVqctOiByesc7wNDW5DpjyTxUCP0wxlpWA1fsJYZhk,1384
+docs/conf.py,sha256=UvAyr0jPk75vQyREMEG3TIs96Pk-hslOgLQUpySp2tw,1645
 entorno/bin/activate_this.py,sha256=45dnJsdtOWIt5LtVSBmBfB8E7AlKcnhnZe9e3WGclak,1199
 entorno/bin/rst2html.py,sha256=h4RydG-iAectsUra0lNFGwB4_1mngxrtPPgQrxUWQ3A,643
 entorno/bin/rst2html4.py,sha256=Xiv3Zb1gk4jT7DYFVlf5w4LJtI5ZI3pW3b1KLxyPS5A,765
@@ -13,14 +13,16 @@ entorno/bin/rst2xetex.py,sha256=spisB81JgqAmMAkjdTaP8awFQS_Zuob9HIcbMi1kOS8,922
 entorno/bin/rst2xml.py,sha256=uoIfpn3prnir2tzqdycsAjOg-OWw663XOK47IeHCZdY,651
 entorno/bin/rstpep2html.py,sha256=sthYQHEgYfj4JqwG45URwVbRAs-HYuwKget7SUwp9fc,719
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/test_binary.py,sha256=dj9BsKBo5rpWw4JGiKKoVkg4rIW4YylTie2VxH2DAGo,29787
-tests/test_non_binary.py,sha256=syANlwm0DKsL6geGeq6nQI6ZVe6T_YXWTyk2-Hmck4s,11308
-tsadmetrics/__init__.py,sha256=MTWOa43fgOdkMNo5NglCReRnB8hoF0ob2PIvDziCNHw,1575
-tsadmetrics/binary_metrics.py,sha256=6GxE3HSiAC9OeDOpP6QFgPwbp-Q37-F3cUdyYcpRrxE,62841
-tsadmetrics/metric_utils.py,sha256=fm8v0X37_AlqWpkcUT9r3680QsjLljrHe2YuXkRLAZ4,10873
-tsadmetrics/non_binary_metrics.py,sha256=O6AqceHrjCVV1kJPBzXQIgtiu6afzoiJz2biNsxf3_4,13389
+tests/test_binary.py,sha256=Qt14fP-F-TW6KlPz6X-2DhtFpaHNrODiMA2DI39JrBI,39311
+tests/test_non_binary.py,sha256=NLXnSvzu5hqsCSlPhNE2IJdE-r-YZv4I7iCCBiYrrsc,13962
+tests/test_utils.py,sha256=8Favmlyix1YaAm03XuzMfEjLnq_Ud0YV_6aFwsIMpl8,2192
+tsadmetrics/__init__.py,sha256=Qg5AvsmzqC3vhNC2WmRpHx4MYrmNBjnXjou9V-WfwE4,1603
+tsadmetrics/binary_metrics.py,sha256=PiecIZ2z2B3-uCx1H3KXfLXdSIu8vxY5sUsIb2vmobk,69729
+tsadmetrics/metric_utils.py,sha256=1nuHQp5fc7whPMfJTfWmKb6XmSngoe6p7fdsoP0Vz-I,2876
+tsadmetrics/non_binary_metrics.py,sha256=oCpRQhHmbauXoYMWD3cuI1eycoTOwyfoOKA2D-UQHeM,14545
 tsadmetrics/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tsadmetrics/utils.py,sha256=BqsG4DyP3AffuMFQCJ-Qy4YaDu4IkFudZWYCvyTGvvY,2444
+tsadmetrics/utils.py,sha256=TiOFwPNBgWWFCIwOO0BPFr5alRABhj597jsmevUjx54,4889
+tsadmetrics/validation.py,sha256=fseGfpGhN-3zAMo2WZLxahcOAsOOyBb2RAFRDKB1KI8,1340
 tsadmetrics/_tsadeval/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tsadmetrics/_tsadeval/auc_roc_pr_plot.py,sha256=PHqJUXq2qI248XV9o04D8SsUJgowetaKq0Cu5bYrIAE,12689
 tsadmetrics/_tsadeval/discontinuity_graph.py,sha256=Ci65l_DPi6HTtb8NvQJe1najgGrRuEpOMWvSyi2AeR0,4088
@@ -53,7 +55,10 @@ tsadmetrics/_tsadeval/prts/time_series_metrics/fscore.py,sha256=pJz4iuPyVGNvwsaR
 tsadmetrics/_tsadeval/prts/time_series_metrics/precision.py,sha256=jLkcMg7UNl25SHtZUBGkP-RV8HsvaZCtjakryl7PFWU,3204
 tsadmetrics/_tsadeval/prts/time_series_metrics/precision_recall.py,sha256=OhUJSm_I7VZ_gX_SSg8AYUq3_NW9rMIy7lAVsnOFw4Q,417
 tsadmetrics/_tsadeval/prts/time_series_metrics/recall.py,sha256=LL-0pPer3ymovVRlktaHo5XDzpgiDhWOVfdPOzKR6og,3152
-tsadmetrics-0.1.14.dist-info/METADATA,sha256=TCFL9Dpv6zwwM_5n2HeCxKgFP-KB4AHYrvCe3rMZMOI,831
-tsadmetrics-0.1.14.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-tsadmetrics-0.1.14.dist-info/top_level.txt,sha256=s2VIr_ePl-WZbYt9FsYbsDGM7J-Qc5cgpwEOeQ3FVpM,31
-tsadmetrics-0.1.14.dist-info/RECORD,,
+tsadmetrics/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tsadmetrics/scripts/compute_metrics.py,sha256=PwtH6XmpKEWwdY62pMfZGrgIBTIms0z3qVpw5LjnuwE,991
+tsadmetrics-0.1.16.dist-info/METADATA,sha256=inUh6ZZm5fg0cpluGAHUR1ULoN4WP480ZjZ9MNuWxAo,831
+tsadmetrics-0.1.16.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+tsadmetrics-0.1.16.dist-info/entry_points.txt,sha256=fnsO232FxrQC6pmeZnyZ4UaiXyvN1rKxksLKQO9n7q8,81
+tsadmetrics-0.1.16.dist-info/top_level.txt,sha256=s2VIr_ePl-WZbYt9FsYbsDGM7J-Qc5cgpwEOeQ3FVpM,31
+tsadmetrics-0.1.16.dist-info/RECORD,,

tsadmetrics-0.1.16.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tsadmetrics-compute = tsadmetrics.scripts.compute_metrics:main