sarapy 2.1.1__py3-none-any.whl → 2.3.0__py3-none-any.whl

sarapy/dataProcessing/OpsProcessor.py

@@ -29,7 +29,12 @@ class OpsProcessor():
             - kwargs: Diccionario con los argumentos necesarios instanciar algunas clases.
         """
 
+        self.classifications_probas = None
         plclass_map = {"classifier_file"}
+        self._operationsDict = {} ##diccionario de operarios con sus operaciones
+        self._platin_classifiedOperations = np.array([]) ##array con las operaciones clasificadas para plantin
+        self._fertilizer_classifiedOperations = np.array([]) ##array con las operaciones clasificadas para plantin
+        self._last_row_db = 0 ##indicador de la última fila de los datos extraidos de la base de datos histórica
 
         kwargs_plclass = {}
         ##recorro kwargs y usando plclass_map creo un nuevo diccionario con los valores que se pasaron
@@ -45,8 +50,8 @@ class OpsProcessor():
             if key in fmcreator_map:
                 fmcreator_kargs[key] = value
         
-        self._plantin_classifier = PlantinClassifier.PlantinClassifier(**kwargs_plclass)
-        self.plantinFMCreator = PlantinFMCreator.PlantinFMCreator(**fmcreator_kargs)
+        self._plantin_classifier = PlantinClassifier(**kwargs_plclass)
+        self.plantinFMCreator = PlantinFMCreator(**fmcreator_kargs)
         
         ##mapa de argumentos para FertilizerTransformer
         ft_map = {"regresor_file", "poly_features_file"}
@@ -56,16 +61,11 @@ class OpsProcessor():
             if key in ft_map:
                 ft_kwargs[key] = value
 
-        self._ftfmcreator = FertilizerFMCreator.FertilizerFMCreator()
-        self._fertilizer_transformer = FertilizerTransformer.FertilizerTransformer(**ft_kwargs)
-        
-        self._operationsDict = {} ##diccionario de operarios con sus operaciones
-        self._platin_classifiedOperations = np.array([]) ##array con las operaciones clasificadas para plantin
-        self._fertilizer_classifiedOperations = np.array([]) ##array con las operaciones clasificadas para plantin
-        self._last_row_db = 0 ##indicador de la última fila de los datos extraidos de la base de datos histórica
-        self.transformInputData = TransformInputData.TransformInputData()
-        self.transformToOutputData = TransformToOutputData.TransformToOutputData()
-        
+        self._ftfmcreator = FertilizerFMCreator()
+        self._fertilizer_transformer = FertilizerTransformer(**ft_kwargs)
+        self.transformInputData = TransformInputData()
+        self.transformToOutputData = TransformToOutputData()
+
     def processOperations(self, data, **kwargs):
         """Método para procesar las operaciones de los operarios.
 
@@ -94,14 +94,14 @@ class OpsProcessor():
 
             #Si tenemos nuevas operaciones, actualizamos el diccionario de operaciones
             self.updateOperationsDict(newSample) #actualizamos diccionario interno de la clase
-            pl_clas = self.classifyForPlantin(**kwargs) #clasificamos las operaciones para plantín
+            pl_clas, self.classifications_probas = self.classifyForPlantin(**kwargs) #clasificamos las operaciones para plantín
 
             #estimamos los gramos de fertilizante
             ft_grams = self._fertilizer_transformer.transform(newSample)
             logging.debug(f"Fertilizer grams shape: {ft_grams.shape}")
             id_db_h_nums, id_db_dw_nums = self.getActualOperationsNumbers() #obtenemos los números de operaciones desde el diccionario de operaciones
             logging.debug(f"ID_DB_H shape: {id_db_h_nums.shape}, ID_DB_DW shape: {id_db_dw_nums.shape}")
-            date_oprc = pd.DataFrame(newSample)["date_oprc"].values.reshape(-1, 1) ##extraigo las fechas de operación de la muestra
+            # date_oprc = pd.DataFrame(newSample)["date_oprc"].values.reshape(-1, 1) ##extraigo las fechas de operación de la muestra
             timestamps = pd.DataFrame(newSample)["timestamp"].values.reshape(-1, 1) ##extraigo los timestamps de la muestra
             
             return self.transformToOutputData.fit_transform(np.column_stack((timestamps,
@@ -167,7 +167,8 @@ class OpsProcessor():
 
         key_classify_map = {"feature_matrix", "update_samePlace",
                             "useRatioStats", "std_weight", "useDistancesStats",
-                            "ratio_dcdp_umbral", "dist_umbral"}
+                            "ratio_dcdp_umbral", "dist_umbral",
+                            "umbral_bajo_dstpt", "umbral_proba_dstpt"}
         
         ##recorro kwargs y usando key_classify_map creo un nuevo diccionario con los valores que se pasaron
         classify_kwargs = {}
@@ -187,7 +188,7 @@ class OpsProcessor():
             logging.debug(f"Número de operaciones para el nodo {ID_NPDP}: {len(operations)}")
             features, dst_pt, inest_pt = self.plantinFMCreator.fit_transform(operations)
             logging.debug(f"Features shape for {ID_NPDP}: {features.shape}")
-            classified_ops = self._plantin_classifier.classify(features, dst_pt, inest_pt, **classify_kwargs)
+            classified_ops, classifications_probas = self._plantin_classifier.classify(features, dst_pt, inest_pt, **classify_kwargs)
             logging.debug(f"Classified operations shape for {ID_NPDP}: {classified_ops.shape}")
             
             ##chequeo si first_day_op_classified es True, si es así, no se considera la primera fila de las classified_ops
@@ -201,7 +202,7 @@ class OpsProcessor():
             
             self._operationsDict[ID_NPDP]["first_day_op_classified"] = True
 
-        return plantinClassifications
+        return plantinClassifications, classifications_probas
             
     def updateLastOperations(self, ID_NPDPs_newOperations):
         """Método para actualizar la última operación de una muestra de operaciones en el diccionario de operaciones
@@ -303,16 +304,39 @@ if __name__ == "__main__":
     import pandas as pd
     import json
     import logging
-    
 
-    historical_data_path = "examples/2025-06-21/UPM000N/historical-data.json"
+    ## argumentos de PlantinFMCreator
+    kwargs_constructor = {"imputeDistances":False, "distanciaMedia":1.8, "umbral_precision":0.3,
+                          "dist_mismo_lugar":0.0, "max_dist":100,
+                          "umbral_ratio_dCdP":0.5, "deltaO_medio":4,}
+            
+            
+            ##argumentos del método PlantinClassifier.clasiffy()
+    kwargs_classifier = {"proba_threshold":0.85,
+                         "update_samePlace":False,
+                         "update_dstpt":False,
+                         "useRatioStats":False,
+                         "std_weight":1.,
+                         "useDistancesStats":False,
+                         "ratio_dcdp_umbral":0.3,
+                         "dist_umbral":0.5,
+                         "umbral_bajo_dstpt":4,
+                         "umbral_proba_dstpt":0.85}
+
+    
+    historical_data_path = "examples\\2025-09-04\\UPM039N\\historical-data.json"
     with open(historical_data_path, 'r') as file:
         samples = json.load(file)
 
-    samples1 = samples
+    op = OpsProcessor(classifier_file='modelos\\pipeline_rf.pkl',
+                      regresor_file='modelos\\regresor.pkl', poly_features_file='modelos\\poly_features.pkl',
+                      **kwargs_constructor)
+
+    ops_clasificadas = op.processOperations(samples, **kwargs_classifier)
+    probas = op.classifications_probas
+    print(probas[:3])
+    print(ops_clasificadas[:3])
+    df_ops_clasificadas = pd.DataFrame(ops_clasificadas)
+
+    print(df_ops_clasificadas.describe())
 
-    op = OpsProcessor(classifier_file='modelos\\pipeline_rf.pkl', imputeDistances = False,
-                      regresor_file='modelos\\regresor.pkl', poly_features_file='modelos\\poly_features.pkl')
-    
-    print(op.processOperations(samples[:20]))
-    # op.processOperations(samples2)

sarapy/mlProcessors/PlantinClassifier.py

@@ -1,4 +1,5 @@
 ###Documentación en https://github.com/lucasbaldezzari/sarapy/blob/main/docs/Docs.md
+import logging
 import numpy as np
 from sklearn.base import BaseEstimator, TransformerMixin
 from sklearn.pipeline import Pipeline
@@ -15,17 +16,24 @@ class PlantinClassifier(BaseEstimator, TransformerMixin):
             - classifier_file: String con el nombre del archivo que contiene el clasificador entrenado. El archivo a cargar es un archivo .pkl.
         """
 
+        self.logger = logging.getLogger("PlantinClassifier")
+
+        self.classifications_probas = None
+        self.clasificaciones = None
+
         #cargo el clasificador con pickle. Usamos try para capturar el error FileNotFoundError
         try:
             with open(classifier_file, 'rb') as file:
                 self._pipeline = pickle.load(file)
-            print("Clasificador cargado con éxito.")
+            self.logger.info("Clasificador cargado con éxito.")
         except FileNotFoundError:
-            print("El archivo no se encuentra en el directorio actual.")
-        
-    def classify(self, feature_matrix, dst_pt, inest_pt,
+            self.logger.error("El archivo no se encuentra en el directorio actual.")
+
+    def classify(self, feature_matrix, dst_pt, inest_pt, proba_threshold = 0.85,
                 update_samePlace:bool = True, update_dstpt: bool = True,
-                umbral_proba = 0.85, **kwargs):
+                umbral_proba_dstpt = 0.85, umbral_bajo_dstpt = 4,
+                use_ma = False, ma_window = 104,
+                use_min_dstpt = False, factor = 0.1, **kwargs):
         """Genera la clasificación de las operaciones para plantines.
         
         - feature_matrix: Es un array con los datos (strings) provenientes de la base de datos histórica.
@@ -41,18 +49,26 @@ class PlantinClassifier(BaseEstimator, TransformerMixin):
         NOTA: Estas características son necesarias en base a la última versión del modelo de clasificación.
         """
 
-        self.clasificaiones = self._pipeline.predict(feature_matrix)
-        self.probas = self._pipeline.predict_proba(feature_matrix)
+        if use_ma:
+            dst_pt = self.get_dstpt_MA(dst_pt, window_size=ma_window, mode='same')
+
+        self.clasificaciones = self._pipeline.predict(feature_matrix)
+        self.classifications_probas = self._pipeline.predict_proba(feature_matrix)
+
+        # Si la probabilidad de ser plantín es menor al umbral, entonces la clasificación es 0 (no plantín)
+        self.clasificaciones[self.classifications_probas[:,1] < proba_threshold] = 0
 
         if update_samePlace:
             self.grouped_ops = self.groupOpsSamePlace(feature_matrix, **kwargs)
-            self.clasificaiones = self.updateLabelsSamePlace(self.clasificaiones, self.grouped_ops)
+            self.clasificaciones = self.updateLabelsSamePlace(self.clasificaciones, self.grouped_ops)
 
         if update_dstpt:
-            self.clasificaiones = self.updateLabelsFromDSTPT(self.clasificaiones, dst_pt, inest_pt, umbral_proba)
+            self.clasificaciones = self.updateLabelsFromDSTPT(self.clasificaciones, dst_pt, inest_pt,
+                                                             umbral_bajo_dstpt, umbral_proba_dstpt,
+                                                             use_min_dstpt, factor)
+
+        return self.clasificaciones, self.classifications_probas
 
-        return self.clasificaiones
-    
     def groupOpsSamePlace(self, X, useRatioStats = True, std_weight=1, useDistancesStats = True,
                           ratio_dcdp_umbral=0.1, dist_umbral=0.5):
         """
@@ -123,20 +139,32 @@ class PlantinClassifier(BaseEstimator, TransformerMixin):
             new_labels[indexes[1:]] = 0
 
         return new_labels
-    
-    def updateLabelsFromDSTPT(self, labels, dst_pt, inest_pt, umbral_proba = 0.85):
+
+    def updateLabelsFromDSTPT(self, labels, dst_pt, inest_pt,
+                              umbral_bajo_dstpt = 4, umbral_proba_dstpt = 0.85,
+                              use_min_dstpt = False, factor = 0.1):
         """
         Función para actualizar las etiquetas de las operaciones que tengan distorsiones de plantín.
         """
         new_labels = labels.copy()
+
+        umbral_bajo_dstpt = min(dst_pt)*(1+factor) if use_min_dstpt else umbral_bajo_dstpt
         
-        ##filtro si dst_pt es menor a 7 y si inest_pt es 0
-        new_labels[(dst_pt < 4) & (inest_pt == 0)] = 0
+        ##filtro
+        new_labels[(dst_pt < umbral_bajo_dstpt) & (inest_pt == 0)] = 0
 
-        ##si inest_pt 1 es y umbral_proba es menor a umbra_proba, entonces la operación es 0
-        new_labels[(inest_pt == 1) & (self.probas[:,1] < umbral_proba)] = 0
+        ##si inest_pt 1 es y las probs son menores a umbral_proba_dstpt, entonces la operación es 0
+        new_labels[(inest_pt == 1) & (self.classifications_probas[:,1] < umbral_proba_dstpt)] = 0
 
         return new_labels
+
+    def get_dstpt_MA(self, dst_pt, 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(dst_pt, np.ones(window_size)/window_size, mode=mode)
     
 if __name__ == "__main__":
     import os
@@ -144,25 +172,44 @@ if __name__ == "__main__":
     import numpy as np
     from sarapy.preprocessing import TransformInputData
     from sarapy.mlProcessors import PlantinFMCreator
-    import sarapy.utils.getRawOperations as getRawOperations
     from sarapy.mlProcessors import PlantinClassifier
+    import json
 
-    fmcreator = PlantinFMCreator.PlantinFMCreator(imputeDistances=False)
-    tindata = TransformInputData.TransformInputData()
 
-    data_path = os.path.join(os.getcwd(), "examples\\2024-10-15\\UPM015N\\data.json")
-    historical_data_path = os.path.join(os.getcwd(), "examples\\2024-10-15\\UPM015N\\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")
-
-    raw_ops = np.array(getRawOperations.getRawOperations(raw_data, raw_data2))
-    raw_X = tindata.fit_transform(raw_ops)[:,2:]
+    kwargs_fmcreator = {"imputeDistances":False, "distanciaMedia":1.8, "umbral_precision":0.3,
+                          "dist_mismo_lugar":0.0, "max_dist":100,
+                          "umbral_ratio_dCdP":2, "deltaO_medio":4,}
+    
+    kwargs_classifier = {"proba_threshold":0.85,
+                         "update_samePlace":False,
+                         "update_dstpt":False,
+                         "useRatioStats":False,
+                         "std_weight":1.,
+                         "useDistancesStats":False,
+                         "ratio_dcdp_umbral":0.3,
+                         "dist_umbral":0.5,
+                         "umbral_bajo_dstpt":4,
+                         "umbral_proba_dstpt":0.85}
+
+    historical_data_path = "examples\\2025-09-04\\UPM039N\\historical-data.json"
+    with open(historical_data_path, 'r') as file:
+        samples = json.load(file)
+
+    fmcreator = PlantinFMCreator(**kwargs_fmcreator)
+    tindata = TransformInputData()
+    raw_X = tindata.transform(samples)
 
     X, dst_pt, inest_pt = fmcreator.fit_transform(raw_X)
 
-    rf_clf_nu = PlantinClassifier.PlantinClassifier(classifier_file='modelos\\pipeline_rf.pkl') ##wu = no update
-    rf_clf_wu = PlantinClassifier.PlantinClassifier(classifier_file='modelos\\pipeline_rf.pkl') ##wu = with update
+    rf_clf_wu = PlantinClassifier(classifier_file='modelos\\pipeline_rf.pkl')
+
+    clasificaciones, probas = rf_clf_wu.classify(X, dst_pt, inest_pt, **kwargs_classifier)
+    print("media de clasificaciones", clasificaciones.mean())
+    print("media de probabilidades", probas.mean(axis=0), probas.std(axis=0), np.median(probas, axis=0))
+    print("primeras clasificaciones", clasificaciones[100:105])
+    print("primeras probabilidades", probas[100:105])
+    print("primeras distorsiones", dst_pt[100:105])
+    print("primeras inestabilidades", inest_pt[100:105])
+
+    # print(rf_clf_wu.classify(X, dst_pt, inest_pt, **kwargs_classifier))
 
-    print(rf_clf_nu.classify(X, dst_pt, inest_pt, update_samePlace = False, update_dstpt=False).mean())
-    print(rf_clf_wu.classify(X, dst_pt, inest_pt, update_samePlace=True, update_dstpt=True,
-    useRatioStats=True, useDistancesStats=True,umbral_proba=0.8).mean()) 

sarapy/mlProcessors/PlantinFMCreator.py

@@ -20,7 +20,7 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
     
     def __init__(self, imputeDistances = True, distanciaMedia:float = 1.8,
                  umbral_precision:float = 0.3, dist_mismo_lugar = 0.0, max_dist = 100,
-                 umbral_ratio_dCdP:float = 0.5, deltaO_medio = 4):
+                 umbral_ratio_dCdP:float = 0.5, deltaO_medio = 4, baseDeltaP = 10):
         """Inicializa la clase FMCreator.
         
         Args:
@@ -39,6 +39,7 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
         self.max_dist = max_dist
         self.umbral_ratio_dCdP = umbral_ratio_dCdP
         self.deltaO_medio = deltaO_medio
+        self.baseDeltaP = baseDeltaP
         
         ##creamos un diccionario para saber la posición de cada dato dentro del array devuelto por transform()
         self._dataPositions = {"DST_PT": 0, "deltaO": 2, "ratio_dCdP": 3, "distances": 4}
@@ -74,12 +75,12 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
         
 
         date_oprc = self.tlmDataProcessor["date_oprc",:] #datos de fecha y hora de operación
-        time_ac = self.tlmDataProcessor["TIME_AC",:] #datos de fecha y hora de operación en formato timestamp
+        time_ac = self.tlmDataProcessor["TIME_AC",:]/self.baseDeltaP #datos de fecha y hora de operación en formato timestamp
         lats = self.tlmDataProcessor["latitud",:] #latitudes de las operaciones
         longs = self.tlmDataProcessor["longitud",:] #longitudes de las operaciones 
         self.dst_pt = self.tlmDataProcessor["SC_PT",:] #distorsión del plantín
         self.inest_pt = self.tlmDataProcessor["INST_PT",:] #inest 
-        # precitions = X[:,4].astype(float) #precision del GPS   
+
         
         ##***** OBTENEMOS LOS DATOS PARA FITEAR LOS OBJETOS Y ASÍ PROCESAR LA FM *****
         
@@ -87,7 +88,8 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
         timeData = np.hstack((date_oprc.reshape(-1,1),time_ac.reshape(-1, 1)))
         
         self._timeDeltas = timeProcessor.fit_transform(timeData)
-        
+        # print(np.median(self._timeDeltas[:,tpDP["ratio_dCdP"]]))
+
         ##fitteamos geoprocessor con las latitudes y longitudes
         points = np.hstack((lats.reshape(-1,1),longs.reshape(-1,1)))
         self._distances = geoprocessor.fit_transform(points)
@@ -113,11 +115,6 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
         self.fit(X)
         return self.transform(X)
     
-    # @property
-    # def tlmExtracted(self):
-    #     """Devuelve los datos de telemetría extraídos."""
-    #     return self.tlmExtracted
-    
     @property
     def tlmdeDP(self):
         """Devuelve el diccionario con la posición de los datos dentro del array devuelto por transform()."""
@@ -144,7 +141,7 @@ if __name__ == "__main__":
     import json
     from sarapy.preprocessing import TransformInputData
 
-    historical_data_path = "examples/2025-06-21/UPM000N/historical-data.json"
+    historical_data_path = "examples\\2025-08-04\\UPM003N\\historical-data.json"
     with open(historical_data_path, 'r') as file:
         historical_data = json.load(file)
     df = pd.DataFrame(historical_data)
@@ -157,4 +154,4 @@ if __name__ == "__main__":
     fmcreator = PlantinFMCreator(imputeDistances=False)
 
     fm, dst_pt, inest_pt = fmcreator.fit_transform(X) 
-    print(fm.shape)  # Debería ser (n_operaciones, 3)
+    print(np.median(fm,axis=0))

sarapy/mlProcessors/__init__.py

@@ -0,0 +1,11 @@
+from .FertilizerFMCreator import FertilizerFMCreator
+from .FertilizerTransformer import FertilizerTransformer
+from .PlantinClassifier import PlantinClassifier
+from .PlantinFMCreator import PlantinFMCreator
+
+__all__ = [
+    "FertilizerFMCreator",
+    "FertilizerTransformer",
+    "PlantinClassifier",
+    "PlantinFMCreator",
+]

sarapy/preprocessing/TransformInputData.py

@@ -137,7 +137,7 @@ if __name__ == "__main__":
     import pandas as pd
     import json
 
-    historical_data_path = "examples/2025-06-21/UPM000N/historical-data.json"
+    historical_data_path = "examples\\2025-08-04\\UPM006N\\historical-data.json"
     with open(historical_data_path, 'r') as file:
         historical_data = json.load(file)
     df = pd.DataFrame(historical_data)
@@ -146,4 +146,4 @@ if __name__ == "__main__":
     data_positions = json.load(open("sarapy/preprocessing/telemetriaDataPosition.json", 'r'))
     transform_input_data = TransformInputData()
     transformed_data = transform_input_data.transform(historical_data)
-    print(transformed_data[-1])
+    print(transformed_data[:2])

sarapy/preprocessing/__init__.py

@@ -1,2 +1,11 @@
-# from .DistancesImputer import DistancesImputer
-# from .FertilizerImputer import FertilizerImputer
+from .DistancesImputer import DistancesImputer
+from .FertilizerImputer import FertilizerImputer
+from .TransformInputData import TransformInputData
+from .TransformToOutputData import TransformToOutputData
+
+__all__ = [
+    "DistancesImputer",
+    "FertilizerImputer",
+    "TransformInputData",
+    "TransformToOutputData"
+]

sarapy/stats/__init__.py

@@ -1 +1,13 @@
-# from stats.stats import *
+from .stats import *
+
+__all__ = [
+    "getMA",
+    "probabilidadEmpirica",
+    "penalizacion",
+    "probSaturacion",
+    "estimarKDE",
+    "saturationProbability",
+    "movingProbability",
+    "resumen_sensor",
+    "detectar_secuencia_saturada"
+]

sarapy/stats/stats.py

@@ -2,8 +2,7 @@ import numpy as np
 from scipy.stats import skew, kurtosis, gaussian_kde
 import pandas as pd
 import logging
-
-logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)  # ← "sarapy.stats"
 
 def getMA(data, window_size=104, mode='same'):
     """
@@ -63,7 +62,7 @@ def saturationProbability(distorsion_data, saturation_mode = "alto", umbrales =
     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.")
+        logger.warning("La distorsion_data tiene menos de 50 elementos. Los resultados pueden no ser representativos.")
     
     ventana_filtered = distorsion_data.copy()
     if saturation_mode == "bajo":
@@ -75,7 +74,7 @@ def saturationProbability(distorsion_data, saturation_mode = "alto", umbrales =
 
     ##chequeo si la ventana filtrada está vacía
     if ventana_filtered.shape[0] == 0:
-        logging.warning("Ventana filtrada vacía. Se retornará 0.0.")
+        logger.warning("Ventana filtrada vacía. Se retornará 0.0.")
         return 0.0
 
     skew_val = skew(ventana_filtered)
@@ -84,13 +83,13 @@ def saturationProbability(distorsion_data, saturation_mode = "alto", umbrales =
     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.")
+        logger.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}")
+    logger.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):

sarapy/utils/__init__.py

@@ -0,0 +1,3 @@
+from .utils import *   # <- importa la FUNCIÓN (o clase), no el módulo
+__all__ = ["dataMerging", "getOutliersThresholds", "countingZeros", "get_lat_long_from_indices","readingFolders",
+           "filter_raw_by_time_window", "to_time_obj", "time_to_td"]

sarapy/utils/utils.py

@@ -0,0 +1,172 @@
+from typing import List, Tuple
+
+import numpy as np
+import pandas as pd
+from pathlib import Path
+from sarapy.analysis.FeaturesResume import FeaturesResume
+
+def dataMerging(historical_data, post_processing_data, raw_data, nodoName = None, newColumns = False, asDF = False):
+    """
+    Función para tomar historical_data y post_processing_data y formar una 
+    sóla lista de diccionarios (json)
+
+    Si newColumns es False la función reemplaza los valores de tag_seedling y tag_fertilizer de historical_data,
+    sino genera dos nuevos campos llamados tag_seedling_classified y tag_fertilizer_estimated en historical_data.
+
+    Args:
+        - historical_data (list): Lista de diccionarios con datos históricos (tipo json)
+        - post_processing_data (list): Lista de diccionarios con datos de post-procesamiento (tipo json)
+        - nodoName (str|None): Nombre del nodo al que pertenecen los datos. Por defecto es None
+        - newColumns (bool): Indica si se deben crear nuevas columnas en lugar de reemplazar las existentes.
+        - asDF (bool): Indica si se debe retornar como un dataframe o no
+    """
+    #chequeo que historical_data y post_processing_data sean del mismo tamaño, sino rais
+    if len(historical_data) != len(post_processing_data):
+        raise ValueError("Las listas de datos históricos y de post-procesamiento no son del mismo tamaño.")
+
+    final_data = pd.DataFrame(historical_data)
+    post_data = pd.DataFrame(post_processing_data)
+    raw_data = pd.DataFrame(raw_data)
+
+    final_data['raw_tag_seedling'] = raw_data['raw_tag_seedling']
+    final_data['raw_tag_fertilizer'] = raw_data['raw_tag_fertilizer']
+
+    if not newColumns:
+        final_data['tag_seedling'] = post_data['tag_seedling']
+        final_data['tag_fertilizer'] = post_data['tag_fertilizer']
+    else:
+        final_data['tag_seedling_classified'] = post_data['tag_seedling']
+        final_data['tag_fertilizer_estimated'] = post_data['tag_fertilizer']
+
+    if nodoName:
+        final_data['nodo'] = nodoName
+
+    #retorno como lista de diccionarios (json)
+    if not asDF:
+        return final_data.to_dict(orient='records')
+    else:
+        return final_data
+
+def getOutliersThresholds(data, q1 = 0.25, q3 = 0.75, k = 1.5):
+    """Cálculo de los límites para detectar outliers a partir del rango intercuartil
+    
+    data: array con los datos
+    q1: primer cuartil
+    q3: tercer cuartil
+    k: factor de escala
+    """
+    # Calculo del rango intercuartil
+    q1 = np.quantile(data, q1)
+    q3 = np.quantile(data, q3)
+    iqr = q3 - q1
+
+    # Cálculo de los límites
+    lower = q1 - k * iqr
+    upper = q3 + k * iqr
+
+    return lower, upper
+
+
+def countingZeros(array: List[int], minimos_seguidos: int = 3) -> List[Tuple[int, int]]:
+    """
+    Cuenta ceros consecutivos en un array binario (0s y 1s), retornando una lista de tuplas.
+    Cada tupla (n, k) indica que se encontraron 'n' secuencias de 'k' ceros consecutivos,
+    siempre que k >= minimos_seguidos.
+    
+    Parameters:
+        array (List[int]): Lista binaria de 0s y 1s.
+        minimos_seguidos (int): Mínimo de ceros consecutivos a considerar.
+        
+    Returns:
+        List[Tuple[int, int]]: Lista de tuplas (n, k), ordenadas por k.
+    """
+    contador = 0
+    resultados = {}
+    indexes = []
+    for i, val in enumerate(array):
+        if val == 0:
+            contador += 1
+            indexes.append(i)
+        else:
+            if contador >= minimos_seguidos:
+                if contador in resultados.keys():
+                    resultados[contador][0] += 1
+                    resultados[contador][1] += (indexes,)
+                    indexes = []
+                else:
+                    resultados[contador] = [1, (indexes,)]
+                    indexes = []
+            contador = 0
+
+    # Por si la secuencia termina en ceros
+    if contador >= minimos_seguidos:
+        if contador in resultados.keys():
+            resultados[contador][0] += 1
+            resultados[contador][1] += (indexes,)
+            indexes = []
+        else:
+            resultados[contador] = [1, (indexes,)]
+
+    # retorna [cantidad de ocurrencias, longitud de ceros, indices de ocurrencias]
+    return sorted([(v[0], k, v[1]) for k, v in resultados.items()])
+
+def get_lat_long_from_indices(df: pd.DataFrame, indices: List[List[int]]) -> Tuple[float, float]:
+    """
+    Obtiene la latitud y longitud a partir de una lista de índices en un DataFrame.
+    
+    Parameters:
+        df (pd.DataFrame): DataFrame que contiene las columnas 'latitude' y 'longitude'.
+        indices (List[int]): Lista de listas de índices para buscar las coordenadas.
+        
+    Returns:
+        Tuple[float, float]: Tupla con la latitud y longitud correspondientes.
+    """
+    latitudes = []
+    longitudes = []
+    nodos = []
+    for index_list in indices:
+        for index in index_list:
+            latitudes.append(df.iloc[index]["latitude"])
+            longitudes.append(df.iloc[index]["longitude"])
+            nodos.append(df.iloc[index]["nodo"])
+    return [nodos, latitudes, longitudes]
+
+
+def readingFolders(raiz: str | Path, ignorar_ocultas: bool = True, ordenar: bool = True) -> list[str]:
+    raiz = Path(raiz)
+    if not raiz.is_dir():
+        raise NotADirectoryError(f"La ruta no es una carpeta: {raiz}")
+
+    nombres = [p.name for p in raiz.iterdir() if p.is_dir()]
+    if ignorar_ocultas:
+        nombres = [n for n in nombres if not n.startswith(".")]
+    if ordenar:
+        nombres.sort()
+    return nombres
+
+def computar_resumenes_por_filtro(nodos_ok, merged_cache, filtro, outliers):
+        """
+        Función para computar resúmenes filtrados por un criterio específico.
+        """
+        conteos, resumenes, dstp_ptmas, delta_dcdp, time_ac = {}, {}, {}, {}, {}
+        for nodo in nodos_ok:
+            fr = FeaturesResume(merged_cache[nodo], info=nodo, filtrar=filtro)
+            fr.removeOutliers(outliers)
+            conteos[nodo] = fr.data["tag_seedling"].value_counts(normalize=True)
+            resumenes[nodo] = fr.getResume(to="all")
+            dstp_ptmas[nodo] = fr.getSensorMA()
+            delta_dcdp[nodo] = fr.data["ratio_dCdP"]
+            time_ac[nodo] = fr.data["time_ac"]
+        return conteos, resumenes
+
+def metricas_desde_resumenes(nodos_ok, resumenes, stats):
+    """Devuelve dict nombre_metrica -> vector numpy en el orden de nodos_ok."""
+    return {
+        "nodo": [n for n in nodos_ok],
+        "time_ac":   np.array([resumenes[n]["time_ac"][stats]   for n in nodos_ok]),
+        "deltaO":    np.array([resumenes[n]["deltaO"][stats]    for n in nodos_ok]),
+        "ratio_dCdP":np.array([resumenes[n]["ratio_dCdP"][stats]for n in nodos_ok]),
+        "precision": np.array([resumenes[n]["precision"][stats] for n in nodos_ok]),
+        "distances": np.array([resumenes[n]["distances"][stats] for n in nodos_ok]),
+        "dst_pt":    np.array([resumenes[n]["dst_pt"][stats]    for n in nodos_ok]),
+    }

sarapy/version.py

@@ -1,2 +1,2 @@
-## Version of the package   
-__version__ = "2.1.1"
+## Version of the package
+__version__ = "2.3.0"