sarapy 1.3.1__py3-none-any.whl → 2.1.0__py3-none-any.whl

sarapy/stats/stats.py

@@ -0,0 +1,258 @@
+import numpy as np
+from scipy.stats import skew, kurtosis, gaussian_kde
+import pandas as pd
+import logging
+
+logging.basicConfig(level=logging.DEBUG)
+
+def getMA(data, window_size=104, mode='same'):
+    """
+    Función para calcular la media móvil de una serie temporal.
+    data: numpy array con los datos de la serie temporal
+    window_size: tamaño de la ventana para calcular la media móvil
+    """
+    return np.convolve(data, np.ones(window_size)/window_size, mode=mode)
+
+def probabilidadEmpirica(data:np.ndarray, umbral):
+    """
+    Función para calcular la probabilidad empírica de un valor en una serie temporal.
+    data: numpy array con los datos de la serie temporal
+    umbral: valor umbral para calcular la probabilidad empírica
+    """
+    return data[data>umbral]/data.shape[0]
+
+def penalizacion(alpha, skewness, beta, kurtosis):
+    """
+    Función para calcular la penalización de una serie temporal.
+    alpha: valor de penalización
+    skewness: asimetría de la serie temporal
+    kurtosis: curtosis de la serie temporal
+    """
+    return np.exp(-alpha * np.abs(skewness)) * np.exp(-beta * np.abs(kurtosis))
+
+def probSaturacion(probEmpirica, penalizacion):
+    """
+    Función para calcular la probabilidad de saturación de una serie temporal.
+    probEmpirica: probabilidad empírica de la serie temporal
+    penalizacion: penalización de la serie temporal
+    """
+    return probEmpirica * penalizacion
+
+def estimarKDE(distorsion_data, method="scott"):
+    """
+    Recibe una serie o array de valores dstpt de un nodo.
+    Retorna una función de densidad KDE evaluable.
+    """
+    kde = gaussian_kde(distorsion_data, bw_method=method)
+    return kde
+
+def saturationProbability(distorsion_data, saturation_mode = "alto", umbrales = (1,14), alpha=0.5, beta=0.2):
+    """
+    Calcula la probabilidad de que una ventana esté saturada.
+    - distorsion_data: array de valores dstpt.
+    - saturation_mode: modo de saturación, puede ser "bajo", "alto" o "ambos".
+    - umbrales: tupla con los valores de umbral bajo y alto.
+    - kde: booleano, si se debe calcular la densidad de probabilidad.
+    - alpha, beta: coeficientes de penalización para skewness y curtosis.
+
+    Devuelve un diccionario con los componentes y la probabilidad final.
+    """
+    ##chequeo si saturation_mode es válido
+    if saturation_mode not in ["bajo", "alto", "ambos"]:
+        raise ValueError("saturation_mode debe ser 'bajo', 'alto' o 'ambos'.")
+    if distorsion_data.shape[0] == 0:
+        raise ValueError("La distorsion_data no puede estar vacía.")
+    if distorsion_data.shape[0] < 50:
+        logging.warning("La distorsion_data tiene menos de 50 elementos. Los resultados pueden no ser representativos.")
+    
+    ventana_filtered = distorsion_data.copy()
+    if saturation_mode == "bajo":
+        ventana_filtered = ventana_filtered[ventana_filtered < umbrales[0]]
+    elif saturation_mode == "alto":
+        ventana_filtered = ventana_filtered[ventana_filtered > umbrales[1]]
+    elif saturation_mode == "ambos":
+        ventana_filtered = ventana_filtered[(ventana_filtered < umbrales[0]) | (ventana_filtered > umbrales[1])]
+
+    ##chequeo si la ventana filtrada está vacía
+    if ventana_filtered.shape[0] == 0:
+        logging.warning("Ventana filtrada vacía. Se retornará 0.0.")
+        return 0.0
+
+    skew_val = skew(ventana_filtered)
+    kurt_val = kurtosis(ventana_filtered)
+
+    pena = penalizacion(alpha, skew_val, beta, kurt_val)
+    ##chequeo que pena no sea nan, sino reemplazo por 1
+    if np.isnan(pena):
+        logging.warning("La penalización es NaN. Se reemplazará por 1.")
+        pena = 1.0
+    # Probabilidad
+    proba_empirica = ventana_filtered.shape[0]/distorsion_data.shape[0]
+    prob_saturacion = proba_empirica * pena
+  
+    logging.debug(f"Ventana filtrada: {ventana_filtered.shape[0]}, {distorsion_data.shape[0]}, {proba_empirica}, {pena}")
+    return prob_saturacion
+
+def movingProbability(distorsion_data, window_size=104, **kwargs):
+    """
+    Calcula la probabilidad de saturación de una serie temporal de distorsión.
+    La ventana se mueve sin solapamiento (stride = window_size) y sin padding, 
+    pero incluye el remanente final si queda un bloque incompleto.
+    
+    Params:
+    - distorsion_data: array de valores dstpt.
+    - window_size: tamaño de la ventana.
+    - kwargs: parámetros adicionales para saturationProbability.
+    
+    Devuelve:
+    - probabilities: array de probabilidades por ventana (incluye parcial).
+    - probas_array: array de salida mismo tamaño que distorsion_data.
+    """
+    
+    total_length = len(distorsion_data)
+    n_windows = total_length // window_size
+    remainder = total_length % window_size
+    
+    total_blocks = n_windows + (1 if remainder > 0 else 0)
+    
+    probabilities = np.zeros(total_blocks)
+    probas_array = np.zeros_like(distorsion_data)   
+    
+    for i in range(n_windows):
+        start = i * window_size
+        end = start + window_size
+        ventana = distorsion_data[start:end]
+        probabilities[i] = saturationProbability(ventana, **kwargs)
+        probas_array[start:end] = probabilities[i]
+    
+    # Procesamos el bloque final (parcial) si existe
+    if remainder > 0:
+        start = n_windows * window_size
+        end = total_length
+        ventana = distorsion_data[start:end]
+        probabilities[-1] = saturationProbability(ventana, **kwargs)
+        probas_array[start:end] = probabilities[-1]
+    
+    return probabilities, probas_array
+
+def resumen_sensor(df, values_col = "dstpt", pctbajo_value = 1, pctalto_value = 14):
+    """
+    Función para obtener un resumen estadístico de los valores de un sensor.
+    valores: numpy array con los valores del sensor
+    Retorna un diccionario con la media, desviación estándar, asimetría, curtosis y porcentajes de valores bajos y altos.
+    """
+    
+    pctbajo = lambda x: np.mean(np.array(x) < pctbajo_value)
+    pctbajo.__name__ = "pct_bajo"
+    pctalto = lambda x: np.mean(np.array(x) > pctalto_value)
+    pctalto.__name__ = "pct_alto"
+    funciones = ["count","mean", "std", "min", "max", skew, kurtosis, pctbajo, pctalto]
+    table = df[[values_col,"nodo"]].pivot_table(index="nodo", values=values_col, aggfunc=funciones, fill_value=0).reset_index()
+    return table
+
+def detectar_secuencia_saturada(valores, umbral_bajo=1, umbral_alto=14, longitud_min=10):
+    """
+    Función para detectar si hay una secuencia de valores por debajo o por encima de los umbrales.
+    valores: numpy array con los valores del sensor
+    umbral_bajo: valor por debajo del cual se considera que el sensor está saturado
+    umbral_alto: valor por encima del cual se considera que el sensor está saturado
+    longitud_min: longitud mínima de la secuencia para considerarla saturada
+
+    Return
+    -------
+    bool: True si hay una secuencia de valores por debajo o por encima de los umbrales, False en caso contrario.
+    Esta función busca secuencias de valores por debajo del umbral bajo o por encima del umbral alto.
+    """
+    estado = (np.array(valores) < umbral_bajo) | (np.array(valores) > umbral_alto)
+    sec_actual = 0
+    for val in estado:
+        if val:
+            sec_actual += 1
+            if sec_actual >= longitud_min:
+                return True
+        else:
+            sec_actual = 0
+    return False
+
+if __name__ == "__main__":
+    #cargo archivo examples\volcado_17112023_NODE_processed.csv
+    from sarapy.utils.plotting import plotTemporalData, heatmapAlphavsBeta
+    import pandas as pd
+    import numpy as np
+    import os
+    import sarapy.utils.getRawOperations as getRawOperations
+    from sarapy.dataProcessing import OpsProcessor
+    from sarapy.preprocessing import TransformInputData
+    from sarapy.dataProcessing import TLMSensorDataProcessor
+
+    tlmsde = TLMSensorDataProcessor.TLMSensorDataProcessor()
+
+    nodo = "UPM025N"
+
+    data_path = os.path.join(os.getcwd(), f"examples\\2025-04-10\\{nodo}\\data.json")
+    historical_data_path = os.path.join(os.getcwd(), f"examples\\2025-04-10\\{nodo}\\historical-data.json")
+
+    raw_data = pd.read_json(data_path, orient="records").to_dict(orient="records")
+    raw_data2 = pd.read_json(historical_data_path, orient="records").to_dict(orient="records")
+
+    transform_input_data = TransformInputData.TransformInputData()
+
+    raw_ops = getRawOperations.getRawOperations(raw_data, raw_data2)
+    datum = transform_input_data.fit_transform(raw_ops)[:,2]
+    telemetria = tlmsde.fit_transform(datum)
+    mode = telemetria[:,tlmsde.dataPositions["MODEFlag"]]
+    dstpt = telemetria[:,tlmsde.dataPositions["DSTRPT"]]
+
+    op = OpsProcessor.OpsProcessor(classifier_file='modelos\\pipeline_rf.pkl', imputeDistances = False,
+                                   regresor_file='modelos\\regresor.pkl', poly_features_file='modelos\\poly_features.pkl')
+    op.operationsDict
+    data_processed = op.processOperations(raw_ops)
+
+    #paso la lista de operaciones a un dataframe
+    df = pd.DataFrame(data_processed)
+    df["mode"] = mode
+    df["dstpt"] = dstpt
+    df["nodo"] = nodo
+    df["dstpt_ma"] = getMA(df["dstpt"].values, window_size=104, mode='same')
+    ##me quedo con los datos donde mode==0
+    df = df[df["mode"] == 0]
+    
+    #calculo el resumen del sensor
+    resumen = resumen_sensor(df, values_col="dstpt_ma", pctbajo_value=1, pctalto_value=14.6)
+    print(resumen)
+    #calculo la probabilidad de saturación
+    ma = df["dstpt_ma"].values
+    prob_saturacion = saturationProbability(ma, saturation_mode="alto", umbrales=(1, 14),
+                                               alpha=0.2, beta=0.2)
+    
+    print(f"Probabilidad de saturación: {prob_saturacion}")
+
+    ventana = 104
+    probs, array_probs = movingProbability(ma[100:2500], window_size=ventana, saturation_mode="alto", alpha=0.05, beta=0.05, umbrales=(1, 14.9))
+
+    # heatmapAlphavsBeta(ma, saturationProbability)
+
+    import matplotlib.pyplot as plt
+    ##grafico ma[100:2500] y array_probs en una misma figura pero array_probs en el eje y derecho
+    fig, ax1 = plt.subplots(figsize=(15, 10))
+    ax1.plot(ma[100:2500], label='MA', color='blue')
+    ax1.set_xlabel("Operación")
+    ax1.set_ylabel("MA", color='blue')
+    # ax1.set_ylim(12, 15)
+    ax1.tick_params(axis='y', labelcolor='blue')
+    ax2 = ax1.twinx()
+    ax2.plot(array_probs, label='Probabilidad de saturación', color='grey')
+    3#agrego ahline con array_probs.mean()
+    ax2.axhline(y=array_probs.mean(), color='black', linestyle=':', label='Media de probabilidad',linewidth=3)
+    ax2.set_ylabel("Probabilidad de saturación", color='black')
+    ax2.tick_params(axis='y', labelcolor='black')
+    ax1.axhline(y=1, color='green', linestyle='--', label='Umbral bajo')
+    ax1.axhline(y=14, color='red', linestyle='--', label='Umbral alto')
+    ax1.set_title(f"Análisis de {nodo} - DSTPT")
+    ax1.legend(loc='lower left')
+    ax2.legend(loc='lower right')
+    plt.show()
+
+    colors = ["#e71616","#63d536"]
+    plotTemporalData(df, nodos = [nodo], columnas = ["dstpt_ma"], title = "DSTPT",sameFig = False, show = True,
+                    save = False, filename = "dstpt_plot.png", figsize=(15, 10), colors=colors)

sarapy/utils/plotting.py

@@ -0,0 +1,96 @@
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+def plotTemporalData(df, columnas, nodos = None, title = "DSTPT", xlabel = "Operación", ylabel = "DSTPT",limit_lines=(1,14),
+                     sameFig = False, show = True, save = False, filename = "dstpt_plot.png", figsize=(15, 10), colors="blue"):
+    """
+    Grafica los datos de dstpt de los nodos temporalmente.
+    
+    Parámetros:
+    ---------
+    df : DataFrame
+        DataFrame con los datos a graficar. Los nodos deben estar en una columna llamada "nodo".
+    nodos : list, opcional
+        Lista de nodos a graficar. Si es None, se grafican todos los nodos.
+    columnas : list
+        Lista de columnas a graficar. Por defecto es ["dstpt"].
+    title : str, opcional
+        Título de la gráfica. Por defecto es "DSTPT".
+    xlabel : str, opcional
+        Etiqueta del eje x. Por defecto es "X-axis".
+    ylabel : str, opcional
+        Etiqueta del eje y. Por defecto es "Y-axis".
+    sameFig : bool, opcional
+        Si es True, se grafican todos los nodos en la misma figura. Por defecto es False.
+    """
+    if nodos is None:
+        nodos = df["nodo"].unique()
+
+    if len(nodos) == 1:
+        sameFig = True
+
+    if sameFig:
+        fig, ax = plt.subplots(figsize=figsize)
+        ##grafico todos los nodos en la misma figura
+        ##Grafico cada columna en la misma figura
+        for nodo in nodos:
+            for j, columna in enumerate(columnas):
+                data_nodo = df[df["nodo"]==nodo][columnas].values
+                ax.plot(data_nodo, label=nodo, color=colors[j])
+        ax.set_title(title)
+        ax.set_xlabel(xlabel)
+        ax.set_ylabel(ylabel)
+        #agrego lineas horizontales en los limites
+        ax.axhline(y=limit_lines[0], color='b', linestyle='--')
+        ax.axhline(y=limit_lines[1], color='b', linestyle='--')
+        ax.legend()
+        if save:
+            plt.savefig(filename)
+        if show:
+            plt.show()
+    else:
+        ##grafico cada nodo en un axis diferente
+        fig, axs = plt.subplots(len(nodos), 1, figsize=figsize)
+        ##grafico cada nodo en un mismo axis y cada columna con un color diferente
+        for i, nodo in enumerate(nodos):
+            for j, columna in enumerate(columnas):
+                data_nodo = df[df["nodo"]==nodo][columna].values
+                axs[i].plot(data_nodo, label=columna, color=colors[j])
+            axs[i].axhline(y=limit_lines[0], color='b', linestyle='--')
+            axs[i].axhline(y=limit_lines[1], color='b', linestyle='--')
+            axs[i].set_ylabel(ylabel)
+            axs[i].set_xticks([])
+            axs[i].text(len(data_nodo)*1.1, 0.9, f"{nodo}", ha='right', va='top', fontsize=10,
+                        bbox=dict(facecolor='#c1ddf7', alpha=1, edgecolor='black', boxstyle='round,pad=0.3'))
+            # axs[i].legend()
+        ##activo xticks en el último eje
+        axs[i].set_xlabel(xlabel)
+        if save:
+            plt.savefig(filename)
+        if show:
+            plt.show()
+
+def heatmapAlphavsBeta(data, saturationProbability):
+# Definimos grilla de alpha y beta
+    alpha_vals = np.linspace(0, 1, 20)
+    beta_vals = np.linspace(0, 1, 20)
+
+    # Creamos matriz de resultados
+    Psat_matrix = np.zeros((len(alpha_vals), len(beta_vals)))
+
+    for i, alpha in enumerate(alpha_vals):
+        for j, beta in enumerate(beta_vals):
+            Psat_matrix[i, j] = saturationProbability(data, saturation_mode="alto", umbrales=(1, 14),
+                                               alpha=alpha, beta=beta)
+
+    # Graficamos el heatmap
+    import matplotlib.pyplot as plt
+    import seaborn as sns
+
+    plt.figure(figsize=(10, 8))
+    sns.heatmap(Psat_matrix, xticklabels=np.round(beta_vals, 2), yticklabels=np.round(alpha_vals, 2), cmap="YlOrRd")
+    plt.title("Evolución de Psat en función de α (vertical) y β (horizontal)")
+    plt.xlabel(r"$\beta$ (peso de kurtosis)")
+    plt.ylabel(r"$\alpha$ (peso de skewness)")
+    plt.show()

sarapy/version.py

@@ -1,2 +1,2 @@
 ## Version of the package   
-__version__ = "1.3.1"
+__version__ = "2.1.0"

{sarapy-1.3.1.dist-info → sarapy-2.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sarapy
-Version: 1.3.1
+Version: 2.1.0
 Home-page: https://github.com/lucasbaldezzari/sarapy
 Author: Lucas Baldezzari
 Author-email: Lucas Baldezzari <lmbaldezzari@gmail.com>
@@ -19,6 +19,25 @@ Requires-Dist: geopy
 
 Library for processing SARAPICO project metadata of _AMG SA_.
 
+#### Version 2.1.0
+
+- Se modifica TransformInputdata para poder obtener el timestamp en newSample de OpsProcessor. Se modifica transformOutputData para entregar los datos en base a la solicitud de #43. Se modifica OpsProcessor para poder obtener los datos de salida según solicitud en #43. Close #43.
+
+#### Version 2.0.0
+
+- Se realizan cambios en TransformInputData para que convierta los datos de telemetría a la forma de lista de diccionarios, como un JSON, para que sea más fácil de usar y entender. Además, a futuro, se espera que los datos de la electrónica se puedan enviar en este formato.
+- Se realizan cambios en TLMSensorDataProcessor para que pueda recibir los datos de telemetría como una lista de diccionarios. La clase permite obtener los datos como un numpy array, o indexar por filas y columnas de forma similar a un DataFrame de pandas (de hecho se usa pandas para esto).
+- Se generan cambios en PlantinFMCreator para que pueda recibir los datos de telemetría como una lista de diccionarios, y se usa TLMSensorDataProcessor para procesar los datos y obtener la matriz de características, la cual es la misma que antes.
+- Se generan cambios en FertilizerTransformer para que pueda recibir los datos de telemetría como una lista de diccionarios, y se usa TLMSensorDataProcessor para procesar los datos y obtener la matriz de características, la cual es la misma que antes.
+- Se generan cambios en OpsProcessor para poder trabajar con el formato nuevo de datos.
+
+Los detalles de los cambios son comentados en el issue #37.
+
+#### Version 1.4.0b1
+
+- Se empieza a trabajar sobre librería estadística para poder detectar sensores saturados.
+- Se empieza a trabajar sobre actualización para trabajar con los datos en la nueva modalidad luego de la migración.
+
 #### Version 1.3.1
 
 - Se modifica PlantinClassifier para tomar el umbral máximo de dst_pt en 4 y no en 7.

sarapy-2.1.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+sarapy/__init__.py,sha256=aVoywqGSscYYDycLaYJnz08dlQabl9gH0h4Q5KtHM9o,74
+sarapy/version.py,sha256=Mggl7XGGseYHWRAVliZYoEOj2Nt43ALrs5sSYbS8DK4,51
+sarapy/dataProcessing/GeoProcessor.py,sha256=ARjgKTXDVdf_cFCXyFmzlnmmmay3HG3q-yeJ9QrAcQU,5919
+sarapy/dataProcessing/OpsProcessor.py,sha256=zu6AJ2wQD84-u-fxxTIqGbdw4NrRRye9gHZO3A8Z724,17269
+sarapy/dataProcessing/TLMSensorDataProcessor.py,sha256=RuITlryuSaIWvYyJwE5wxp85HVZ6mr5kUVALikfwS4g,3603
+sarapy/dataProcessing/TimeSeriesProcessor.py,sha256=aig3A3_SCa9FVSWxGWiapBUX7Lj9Wi1BVyZi-XXZZYQ,6414
+sarapy/dataProcessing/__init__.py,sha256=Kqs5sFtq6RMEa3KLJFbsGRoYsIxHL1UUGMuplyCyQFk,200
+sarapy/mlProcessors/FertilizerFMCreator.py,sha256=LNi86CI6eVuQ0_UBVJNd_-L79fcY2-zY2NCm9ypl6OM,2354
+sarapy/mlProcessors/FertilizerTransformer.py,sha256=PefMNrsvfqqjup0lcypzZB0IKzZbvTlTI03u4ITNuUo,3003
+sarapy/mlProcessors/PlantinClassifier.py,sha256=PoPvtrqTXCmr0cLaMNRdDzhvzUJNZhLtvZNeE0qd_0Q,7905
+sarapy/mlProcessors/PlantinFMCreator.py,sha256=meK8SH1rUlBOAfC4BPGUgpEIfgr-yXp9SwKdxVtmGo4,7035
+sarapy/mlProcessors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sarapy/preprocessing/DistancesImputer.py,sha256=NvbVAh5m0yFxVgDbEFnEX7RSG13qLjO7i2gqjDAWsf4,9106
+sarapy/preprocessing/FertilizerImputer.py,sha256=zK6ONAilwPHvj-bC7yxnQYOkDBCCkWh6__57vYK9anM,1490
+sarapy/preprocessing/TransformInputData.py,sha256=ZQ8k_4JFp78G5VqZEuzYmF8VCDcOxEnHKbd_4w7PPjY,8536
+sarapy/preprocessing/TransformToOutputData.py,sha256=xXFRTwpv-R2duG4ixOVBLojHc0z3FD_l5gRzinF4DQc,3143
+sarapy/preprocessing/__init__.py,sha256=Wg_Csy8Xiz8BN8A4-T7iPwcL_ol5ApEx6YtybItKB8M,100
+sarapy/stats/__init__.py,sha256=ZrLMSistwynmmx4HUcI-ePRzqQ4bjp85JT4fTmbzC-c,27
+sarapy/stats/stats.py,sha256=raQBnn2RRtwYOuKN4Mgk6Rhk4hajx1TVcGlYnT2TMmA,11412
+sarapy/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sarapy/utils/amg_decoder.py,sha256=JZ7cbu7DlCuatuq2F7aBfUr7S7U-K5poBgxw5nY6rNI,4319
+sarapy/utils/amg_ppk.py,sha256=c0GusnxdntU-E0JOezzbIfC7SWoJmKAbad_zYDCJ3-c,1060
+sarapy/utils/getRawOperations.py,sha256=8aA1fIkNCnUYgiWfnFggRT_U35z432gZBrZ7seGO5w4,817
+sarapy/utils/plotting.py,sha256=kX-eYw618urMcUBkNPviQZdBziDc_TR3GInTsO90kU4,4065
+sarapy-2.1.0.dist-info/LICENCE,sha256=N00sU3vSQ6F5c2vML9_qP4IFTkCPFFj0YGDB2CZP-uQ,840
+sarapy-2.1.0.dist-info/METADATA,sha256=SUxMaAystOQGL48pzY351JHV6JgnZkiw5yhNJEqZ1RY,5695
+sarapy-2.1.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+sarapy-2.1.0.dist-info/top_level.txt,sha256=4mUGZXfX2Fw47fpY6MQkaJeuOs_8tbjLkkNp34DJWiA,7
+sarapy-2.1.0.dist-info/RECORD,,

sarapy-1.3.1.dist-info/RECORD

@@ -1,26 +0,0 @@
-sarapy/__init__.py,sha256=aVoywqGSscYYDycLaYJnz08dlQabl9gH0h4Q5KtHM9o,74
-sarapy/version.py,sha256=1iLPpzVPQZ7V5v1UclFBnaF0jEl1KLqdxud9qvQDJVo,51
-sarapy/dataProcessing/GeoProcessor.py,sha256=ARjgKTXDVdf_cFCXyFmzlnmmmay3HG3q-yeJ9QrAcQU,5919
-sarapy/dataProcessing/OpsProcessor.py,sha256=XLCousbVeST-y4hjr27AKrg9-bOMTdkWl3fDJOgXFSM,18321
-sarapy/dataProcessing/TLMSensorDataProcessor.py,sha256=GfSIRYD_biFlOMTfSQSwW0HsUouZuUL3ScvL4uUHTPQ,23824
-sarapy/dataProcessing/TimeSeriesProcessor.py,sha256=-uic18Sut9yMCenbLO1-VabmKifKABt_FbCCP_fLcmE,5403
-sarapy/dataProcessing/__init__.py,sha256=Kqs5sFtq6RMEa3KLJFbsGRoYsIxHL1UUGMuplyCyQFk,200
-sarapy/mlProcessors/FertilizerFMCreator.py,sha256=LNi86CI6eVuQ0_UBVJNd_-L79fcY2-zY2NCm9ypl6OM,2354
-sarapy/mlProcessors/FertilizerTransformer.py,sha256=vdGNbvlmvtJZxr0oOE4Zb8Es-K-BKQh4oyhIGfDAcxQ,3571
-sarapy/mlProcessors/PlantinClassifier.py,sha256=PoPvtrqTXCmr0cLaMNRdDzhvzUJNZhLtvZNeE0qd_0Q,7905
-sarapy/mlProcessors/PlantinFMCreator.py,sha256=FeEz0MiorkMPodPgN9FtBDJ22WVLoLwK4g-CFI46DAk,8568
-sarapy/mlProcessors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sarapy/preprocessing/DistancesImputer.py,sha256=NvbVAh5m0yFxVgDbEFnEX7RSG13qLjO7i2gqjDAWsf4,9106
-sarapy/preprocessing/FertilizerImputer.py,sha256=zK6ONAilwPHvj-bC7yxnQYOkDBCCkWh6__57vYK9anM,1490
-sarapy/preprocessing/TransformInputData.py,sha256=wDwyg4U-jgTqvNUFngsmhSKwyhoIyVWlhezEhhPf2qE,4090
-sarapy/preprocessing/TransformToOutputData.py,sha256=rWAsZKWLxn1qtxUMV_cWeKs4dPkFcBEt6IqKL9A64js,3933
-sarapy/preprocessing/__init__.py,sha256=Wg_Csy8Xiz8BN8A4-T7iPwcL_ol5ApEx6YtybItKB8M,100
-sarapy/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sarapy/utils/amg_decoder.py,sha256=JZ7cbu7DlCuatuq2F7aBfUr7S7U-K5poBgxw5nY6rNI,4319
-sarapy/utils/amg_ppk.py,sha256=c0GusnxdntU-E0JOezzbIfC7SWoJmKAbad_zYDCJ3-c,1060
-sarapy/utils/getRawOperations.py,sha256=8aA1fIkNCnUYgiWfnFggRT_U35z432gZBrZ7seGO5w4,817
-sarapy-1.3.1.dist-info/LICENCE,sha256=N00sU3vSQ6F5c2vML9_qP4IFTkCPFFj0YGDB2CZP-uQ,840
-sarapy-1.3.1.dist-info/METADATA,sha256=DoZmWAvCW8LCVj1gjNAMG_5SR1WlMaokH4BTC0bps7E,3892
-sarapy-1.3.1.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-sarapy-1.3.1.dist-info/top_level.txt,sha256=4mUGZXfX2Fw47fpY6MQkaJeuOs_8tbjLkkNp34DJWiA,7
-sarapy-1.3.1.dist-info/RECORD,,