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

sarapy/mlProcessors/FertilizerTransformer.py

@@ -1,4 +1,5 @@
 import pickle
+import logging
 from sarapy.dataProcessing import TLMSensorDataProcessor
 
 class FertilizerTransformer:
@@ -13,22 +14,23 @@ class FertilizerTransformer:
             - regresor: Regresor que transforma los valores de distorsión a gramos.
             - poly_features: Grado del polinomio a utilizar en la transformación de los datos.        
         """
+        self.logger = logging.getLogger("FertilizerTransformer")
         ##cargo el regresor con pickle. Usamos try para capturar el error FileNotFoundError
         try:
             with open(regresor_file, 'rb') as file:
                 self._regresor = pickle.load(file)
-            print("Regresor cargado con éxito.")
+            self.logger.info("Regresor cargado con éxito.")
         except FileNotFoundError:
-            print("El archivo no se encuentra en el directorio actual.")
+            self.logger.error("El archivo no se encuentra en el directorio actual.")
 
         ##cargo las características polinómicas con pickle. Usamos try para capturar el error FileNotFoundError
         try:
             with open(poly_features_file, 'rb') as file:
                 self._poly_features = pickle.load(file)
-            print("Características polinómicas cargadas con éxito.")
+            self.logger.info("Características polinómicas cargadas con éxito.")
         except FileNotFoundError:
-            print("El archivo no se encuentra en el directorio actual.")
-            
+            self.logger.error("El archivo no se encuentra en el directorio actual.")
+
         self.fertilizer_grams = None ##cuando no se ha transformado ningún dato, se inicializa en None
 
 
@@ -46,23 +48,151 @@ class FertilizerTransformer:
         X_poly = self._poly_features.fit_transform(X.reshape(-1, 1))
         self.fertilizer_grams = self._regresor.predict(X_poly)
 
+        ##para valores de distorsión de 13+-0.3 y 15+-0.3, pongo los valores en 8 y 9 gramos, respectivamente
+        ##uso máscara booleana para encontrar los índices
+        mask_13 = (X >= 12.7) & (X <= 13.3)
+        mask_15 = (X >= 14.7) & (X <= 15.3)
+        self.fertilizer_grams[mask_13] = 8
+        self.fertilizer_grams[mask_15] = 9
+
         ##retorno con shape (n,)
         return self.fertilizer_grams.reshape(-1,)
     
 if __name__ == "__main__":
     import pandas as pd
+    import numpy as np
     import json
     from sarapy.preprocessing import TransformInputData
+    import matplotlib.pyplot as plt
+    from collections import Counter
+
+    fecha = "2025-08-09"
+    nodo_interes = "UPM095N"
 
-    historical_data_path = "examples/2025-06-21/UPM000N/historical-data.json"
+    historical_data_path = f"examples//{fecha}//{nodo_interes}//historical-data.json"
     with open(historical_data_path, 'r') as file:
         historical_data = json.load(file)
 
     ##cargo en un diccionario sarapy\preprocessing\telemetriaDataPosition.json
     data_positions = json.load(open("sarapy/preprocessing/telemetriaDataPosition.json", 'r'))
-    transform_input_data = TransformInputData.TransformInputData()
+    transform_input_data = TransformInputData()
     transformed_data = transform_input_data.transform(historical_data)
 
-    fertransformer = FertilizerTransformer(regresor_file='modelos\\regresor.pkl', poly_features_file='modelos\\poly_features.pkl')
+    fertransformer = FertilizerTransformer(regresor_file='modelos\\regresor_v2.pkl', poly_features_file='modelos\\poly_features_v2.pkl')
     gramos = fertransformer.transform(transformed_data)
-    print(gramos[:10])
+    print(gramos[:10])
+
+    df = pd.DataFrame(transformed_data)
+    score_ft = df["SC_FT"].values
+
+    print(score_ft.mean(), gramos.mean())
+    print(score_ft.max(), gramos.max())
+    print(score_ft.min(), gramos.min())
+
+    puntos = list(zip(score_ft, gramos))
+    conteos  = Counter(puntos)
+    xs, ys, sizes = zip(*[(x, y, c) for (x, y), c in conteos.items()])
+
+    np.array([s*10 for s in sizes]).shape
+
+    points = np.column_stack((score_ft, gramos))
+    unique_points, counts = np.unique(points, axis=0, return_counts=True)
+
+    sizes = np.log1p(counts) * 50
+
+    plt.figure(figsize=(10, 6))
+    handles, labels = plt.gca().get_legend_handles_labels()
+    order = [2, 0, 1]
+    plt.scatter(unique_points[:,0], unique_points[:,1], color="#5612af", label="Regresor 1 - Orden 12",zorder=1,
+                s=sizes)
+    plt.scatter(score_ft.mean(), gramos.mean(), color="#af121f", label="Punto promedio", marker='X',s=400)
+    plt.title(f'Predicciones Regresor 2 de orden 12 para NODO: {nodo_interes}')
+    plt.xlabel('Score de Fertilizante (SC_FT)')
+    plt.ylabel('Predicciones de Gramos de Fertilizante')
+    plt.grid(True)
+    plt.legend()
+    plt.savefig(f'predicciones_regresor2_orden12_{nodo_interes}.png')
+    plt.show()
+
+    nodos = ["UPM075N", "UPM076N", "UPM077N", "UPM078N", "UPM079N", "UPM080N", "UPM081N", "UPM082N", "UPM083N", "UPM084N",
+             "UPM085N", "UPM086N", "UPM087N", "UPM088N", "UPM089N", "UPM090N", "UPM091N", "UPM092N", "UPM093N", "UPM094N", "UPM095N",
+             "UPM096N", "UPM097N", "UPM098N", "UPM099N"]
+    
+    ##cargo datos históricos de ejemplo
+    
+    scores_ft_maximos = {}
+    scores_ft_minimos = {}
+    gramos_maximos = {}
+    gramos_minimos = {}
+    for nodo in nodos:
+        historical_data_path = f"examples//{fecha}//{nodo}//historical-data.json"
+        try:
+            with open(historical_data_path, 'r') as file:
+                historical_data = json.load(file)
+        except FileNotFoundError:
+            print(f"El archivo {historical_data_path} no se encuentra en el directorio actual.")
+            continue
+        transform_input_data = TransformInputData()
+        transformed_data = transform_input_data.transform(historical_data)
+        fertransformer = FertilizerTransformer(regresor_file='modelos\\regresor_v2.pkl', poly_features_file='modelos\\poly_features_v2.pkl')
+        gramos = fertransformer.transform(transformed_data)
+        gramos_maximos[nodo] = gramos.max()
+        gramos_minimos[nodo] = gramos.min()
+
+        df = pd.DataFrame(transformed_data)
+        score_ft = df["SC_FT"].values
+        scores_ft_maximos[nodo] = score_ft.max()
+        scores_ft_minimos[nodo] = score_ft.min()
+        
+    data = np.array([[gramos_maximos[nodo] for nodo in nodos],
+                       [scores_ft_maximos[nodo] for nodo in nodos],
+                        [gramos_minimos[nodo] for nodo in nodos],
+                          [scores_ft_minimos[nodo] for nodo in nodos]])  
+
+    data_df = pd.DataFrame(data=data.T, index=nodos, columns=['Gramos_Fertilizante', 'Score_Fertilizante', 'Gramos_Fertilizante_Min', 'Score_Fertilizante_Min'])
+
+    data_df['Gramos_Fertilizante'].plot.bar(figsize=(12, 6), color="#34a853", legend=False)
+    #add text labels on top of each bar with the height value
+    for i, v in enumerate(data_df['Gramos_Fertilizante']):
+        plt.text(i, v + 0.1, f"{v:.1f}", ha='center', va='bottom',color="#34a853")
+    plt.title('Máximos de gramos de fertilizante por nodo') 
+    plt.xlabel('Nodos')
+    plt.ylabel('Gramos de Fertilizante')
+    plt.grid(axis='y')
+    plt.savefig('maximos_gramos_fertilizante_por_nodo.png')
+    plt.show()
+
+    data_df['Gramos_Fertilizante_Min'].plot.bar(figsize=(12, 6), color="#34a853", legend=False)
+    #add text labels on top of each bar with the height value
+    for i, v in enumerate(data_df['Gramos_Fertilizante_Min']):
+        plt.text(i, v + 0.1, f"{v:.1f}", ha='center', va='bottom',color="#34a853")
+    plt.title('Mínimos de gramos de fertilizante por nodo') 
+    plt.xlabel('Nodos')
+    plt.ylabel('Gramos de Fertilizante')
+    plt.grid(axis='y')
+    plt.savefig('minimos_gramos_fertilizante_por_nodo.png')
+    plt.show()
+
+    data_df['Score_Fertilizante'].plot.bar(figsize=(12, 6), color="#3434a8", legend=False)
+    #add text labels on top of each bar with the height value
+    for i, v in enumerate(data_df['Score_Fertilizante']):
+        plt.text(i, v + 0.1, f"{v:.1f}", ha='center', va='bottom',color="#3434a8")
+    plt.title('Máximos de score de fertilizante por nodo') 
+    plt.xlabel('Nodos')
+    plt.ylabel('Score de Fertilizante')
+    plt.grid(axis='y')
+    plt.savefig('maximos_score_fertilizante_por_nodo.png')
+    plt.show()
+
+    data_df['Score_Fertilizante_Min'].plot.bar(figsize=(12, 6), color="#3434a8", legend=False)
+    #add text labels on top of each bar with the height value
+    for i, v in enumerate(data_df['Score_Fertilizante_Min']):
+        plt.text(i, v + 0.1, f"{v:.1f}", ha='center', va='bottom',color="#3434a8")
+    plt.title('Mínimos de score de fertilizante por nodo') 
+    plt.xlabel('Nodos')
+    plt.ylabel('Score de Fertilizante')
+    plt.grid(axis='y')
+    plt.savefig('minimos_score_fertilizante_por_nodo.png')
+    plt.show()
+
+    

sarapy/mlProcessors/PlantinClassifier.py

@@ -28,11 +28,13 @@ class PlantinClassifier(BaseEstimator, TransformerMixin):
             self.logger.info("Clasificador cargado con éxito.")
         except FileNotFoundError:
             self.logger.error("El archivo no se encuentra en el directorio actual.")
+            raise
 
-    def classify(self, feature_matrix, dst_pt, inest_pt, proba_threshold = 0.85,
+    def classify(self, feature_matrix, dst_pt, inest_pt,
+                 proba_threshold = 0.45, use_proba_ma = False, proba_ma_window = 10,
                 update_samePlace:bool = True, update_dstpt: bool = True,
-                umbral_proba_dstpt = 0.85, umbral_bajo_dstpt = 4,
-                use_ma = False, ma_window = 104,
+                umbral_proba_dstpt = 0.5, umbral_bajo_dstpt = 1.5,
+                use_ma = True, dstpt_ma_window = 62,
                 use_min_dstpt = False, factor = 0.1, **kwargs):
         """Genera la clasificación de las operaciones para plantines.
         
@@ -50,13 +52,25 @@ class PlantinClassifier(BaseEstimator, TransformerMixin):
         """
 
         if use_ma:
-            dst_pt = self.get_dstpt_MA(dst_pt, window_size=ma_window, mode='same')
+            if dst_pt.shape[0] < dstpt_ma_window:
+                self.logger.warning("El tamaño de la serie temporal es menor que la ventana de media móvil. No se aplicará media móvil.")
+                dst_pt = self.get_dstpt_MA(dst_pt, window_size=dst_pt.shape[0], mode='same')             
+            else:
+                dst_pt = self.get_dstpt_MA(dst_pt, window_size=dstpt_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 use_proba_ma:
+            if proba_ma_window >= self.classifications_probas.shape[0]:
+                self.logger.warning("El tamaño de la serie temporal es menor que la ventana de media móvil. No se aplicará media móvil a las probabilidades.")
+                probas_ma = self.get_probas_MA(self.classifications_probas, window_size=self.classifications_probas.shape[0], mode='same')
+            else:
+                probas_ma = self.get_probas_MA(self.classifications_probas, window_size=proba_ma_window, mode='same')
+            self.clasificaciones[probas_ma[:,1] < proba_threshold] = 0
+        else:
+            # self.clasificaciones = self._pipeline.classes_[np.argmax(self.classifications_probas, axis=1)]
+            self.clasificaciones[self.classifications_probas[:,1] < proba_threshold] = 0
 
         if update_samePlace:
             self.grouped_ops = self.groupOpsSamePlace(feature_matrix, **kwargs)
@@ -69,7 +83,7 @@ class PlantinClassifier(BaseEstimator, TransformerMixin):
 
         return self.clasificaciones, self.classifications_probas
 
-    def groupOpsSamePlace(self, X, useRatioStats = True, std_weight=1, useDistancesStats = True,
+    def groupOpsSamePlace(self, X, useRatioStats = False, std_weight=1, useDistancesStats = False,
                           ratio_dcdp_umbral=0.1, dist_umbral=0.5):
         """
         Función que agrupa las operaciones que se realizaron en el mismo lugar o que sean de limpieza.
@@ -141,7 +155,7 @@ class PlantinClassifier(BaseEstimator, TransformerMixin):
         return new_labels
 
     def updateLabelsFromDSTPT(self, labels, dst_pt, inest_pt,
-                              umbral_bajo_dstpt = 4, umbral_proba_dstpt = 0.85,
+                              umbral_bajo_dstpt = 4, umbral_proba_dstpt = 0.5,
                               use_min_dstpt = False, factor = 0.1):
         """
         Función para actualizar las etiquetas de las operaciones que tengan distorsiones de plantín.
@@ -164,7 +178,25 @@ class PlantinClassifier(BaseEstimator, TransformerMixin):
         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)
+        # return np.convolve(dst_pt, np.ones(window_size)/window_size, mode=mode)
+        padding_start = dst_pt[0:window_size]
+        padding_end = dst_pt[-window_size:]
+        padded_data = np.concatenate([padding_start, dst_pt, padding_end])
+        ma_full = np.convolve(padded_data, np.ones(window_size)/window_size, mode='same')
+        return ma_full[window_size: -window_size]
+    
+    def get_probas_MA(self, probas, 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)
+        padding_start = probas[0:window_size, :]
+        padding_end = probas[-window_size:, :]
+        padded_data = np.vstack([padding_start, probas, padding_end])
+        ma_full = np.apply_along_axis(lambda m: np.convolve(m, np.ones(window_size)/window_size, mode='same'), axis=0, arr=padded_data)
+        return ma_full[window_size: -window_size, :]
     
 if __name__ == "__main__":
     import os
@@ -176,22 +208,35 @@ if __name__ == "__main__":
     import json
 
 
-    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,
+    ## argumentos de PlantinFMCreator
+    kwargs_fmcreator = {"imputeDistances":True, "distanciaMedia":1.8, "umbral_precision":0.3,
+                        "dist_mismo_lugar":0.2, "max_dist":100,
+                        "umbral_ratio_dCdP":2, "deltaO_medio":4,
+                        "impute_ratiodcdp": True, "umbral_impute_ratiodcdp": -0.5,
+                        "deltaO_ma": True, "deltaO_ma_window": 26}
+            
+            
+    ##argumentos del método PlantinClassifier.clasiffy()
+    kwargs_classifier = {"proba_threshold":0.45,
+                         "use_proba_ma":False,
+                         "proba_ma_window":10,
+                         "update_samePlace":True,
+                         "update_dstpt":True,
+                         "umbral_proba_dstpt":0.5,
+                         "umbral_bajo_dstpt":1.5,
+                         "use_ma":True,
+                         "dstpt_ma_window":62,
+                         "use_min_dstpt":False,
+                         "factor":0.1,
+                         
                          "useRatioStats":False,
                          "std_weight":1.,
                          "useDistancesStats":False,
-                         "ratio_dcdp_umbral":0.3,
+                         "ratio_dcdp_umbral":0.1,
                          "dist_umbral":0.5,
-                         "umbral_bajo_dstpt":4,
-                         "umbral_proba_dstpt":0.85}
+                         }
 
-    historical_data_path = "examples\\2025-09-04\\UPM039N\\historical-data.json"
+    historical_data_path = "examples\\2025-09-04\\UPM042N\\historical-data.json"
     with open(historical_data_path, 'r') as file:
         samples = json.load(file)
 
@@ -210,6 +255,3 @@ if __name__ == "__main__":
     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))
-

sarapy/mlProcessors/PlantinFMCreator.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 sarapy.dataProcessing import TLMSensorDataProcessor, TimeSeriesProcessor, GeoProcessor
@@ -20,7 +21,9 @@ 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, baseDeltaP = 10):
+                 umbral_ratio_dCdP:float = 0.5, deltaO_medio = 4, baseDeltaP = 10,
+                 impute_ratiodcdp = False, umbral_impute_ratiodcdp = -0.8,
+                 deltaO_ma = False, deltaO_ma_window = 26):
         """Inicializa la clase FMCreator.
         
         Args:
@@ -30,6 +33,7 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
             - umbral_ratio_dCdP: Umbral para el ratio entre el delta de caminata y el delta de pico abierto.
             - deltaO_medio: delta de operación medio entre operaciones.
         """
+        self.logger = logging.getLogger("PlantinFMCreator")
         
         self.is_fitted = False
         self.imputeDistances = imputeDistances
@@ -40,9 +44,10 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
         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}
+        self.impute_ratiodcdp = impute_ratiodcdp
+        self.umbral_impute_ratiodcdp = umbral_impute_ratiodcdp
+        self.deltaO_ma = deltaO_ma
+        self.deltaO_ma_window = deltaO_ma_window
         
     def fit(self, X: np.array, y=None)-> np.array:
         """Fittea el objeto
@@ -73,7 +78,6 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
         tpDP = timeProcessor._dataPositions
         geoprocessor = GeoProcessor.GeoProcessor()
         
-
         date_oprc = self.tlmDataProcessor["date_oprc",:] #datos de fecha y hora de operación
         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
@@ -88,7 +92,6 @@ 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)))
@@ -98,6 +101,22 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
         self.featureMatrix = np.vstack((self._timeDeltas[:,tpDP["deltaO"]],
                                         self._timeDeltas[:,tpDP["ratio_dCdP"]],
                                         self._distances)).T
+
+        if self.impute_ratiodcdp:
+            ratio_dcdp_median = np.median(self.featureMatrix[:, 1])
+            self.featureMatrix[:, 1] = np.where(self.featureMatrix[:, 1] < self.umbral_impute_ratiodcdp, ratio_dcdp_median, self.featureMatrix[:, 1])
+
+        if self.deltaO_ma:
+            data = self.featureMatrix[:, 0]
+            if self.deltaO_ma_window >= len(data):
+                self.logger.warning("El tamaño de la serie temporal es menor que la ventana de media móvil. No se aplicará media móvil a deltaO.")
+                self.deltaO_ma_window = len(data)
+            
+            padding_start = data[0:self.deltaO_ma_window]
+            padding_end = data[-self.deltaO_ma_window:]
+            padded_data = np.concatenate([padding_start, data, padding_end])
+            ma_full = np.convolve(padded_data, np.ones(self.deltaO_ma_window)/self.deltaO_ma_window, mode='same')
+            self.featureMatrix[:, 0] = ma_full[self.deltaO_ma_window: - self.deltaO_ma_window]
         
         return self.featureMatrix, self.dst_pt, self.inest_pt
 
@@ -130,12 +149,6 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
         """Devuelve las distancias entre operaciones."""
         return self._distances
     
-    @property
-    def dataPositions(self):
-        """Devuelve el diccionario con la posición de los datos dentro del array devuelto por transform()."""
-        return self._dataPositions
-    
-        
 if __name__ == "__main__":
     import pandas as pd
     import json

sarapy/preprocessing/TransformInputData.py

@@ -137,7 +137,7 @@ if __name__ == "__main__":
     import pandas as pd
     import json
 
-    historical_data_path = "examples\\2025-08-04\\UPM006N\\historical-data.json"
+    historical_data_path = "examples\\2025-09-04\\UPM042N\\historical-data.json"
     with open(historical_data_path, 'r') as file:
         historical_data = json.load(file)
     df = pd.DataFrame(historical_data)
@@ -146,4 +146,5 @@ 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[:2])
+    print(transformed_data[:2])
+    print(transformed_data[0]["date_oprc"])

sarapy/version.py

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

{sarapy-2.3.0.dist-info → sarapy-3.1.0.dist-info}/METADATA

@@ -1,24 +1,76 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: sarapy
-Version: 2.3.0
-Home-page: https://github.com/lucasbaldezzari/sarapy
-Author: Lucas Baldezzari
+Version: 3.1.0
+Summary: Library for Sarapico Metadata processing
 Author-email: Lucas Baldezzari <lmbaldezzari@gmail.com>
-Maintainer-email: Lucas Baldezzari <lmbaldezzari@gmail.com>
-License: For private use only. Owner AMG Servicios profesionales (Mercedes, Uruguay)
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Microsoft :: Windows :: Windows 10
+Classifier: Operating System :: Microsoft :: Windows :: Windows 11
+Classifier: Operating System :: Unix
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENCE
-Requires-Dist: numpy
-Requires-Dist: matplotlib
-Requires-Dist: pandas
-Requires-Dist: scipy
-Requires-Dist: scikit-learn
-Requires-Dist: geopy
+Requires-Dist: numpy>=1.23
+Requires-Dist: pandas>=1.5
+Requires-Dist: scipy>=1.9
+Requires-Dist: scikit-learn>=1.2
+Requires-Dist: matplotlib>=3.6
+Requires-Dist: seaborn>=0.12
+Requires-Dist: requests>=2.28
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: geopy>=2.3
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Dynamic: license-file
 
 # SARAPY
 
 Library for processing SARAPICO project metadata of _AMG SA_.
 
+#### Version 3.1.0
+
+- Se actualiza regresor para estimar fertilizante.
+- Actualización de archivos para instalar la libería.
+
+
+#### Version 3.0.0
+- Se mejora la forma de obtener valores de media movil para todas las variables en las que se usa.
+- Se corrigen bugs debido a nodos con pocas operaciones.
+- Se corrigen errores a la hora de pasar parámetros a los métodos de algunas clases.
+- Se configuran parámetros de fmcreator y plantin_classifier para el reetiquetado, los mismos son:
+
+kwargs_fmcreator = {"imputeDistances":True, "distanciaMedia":1.8, "umbral_precision":0.3,
+                        "dist_mismo_lugar":0.2, "max_dist":100,
+                        "umbral_ratio_dCdP":2, "deltaO_medio":4,
+                        "impute_ratiodcdp": True, "umbral_impute_ratiodcdp": -0.5,
+                        "deltaO_ma": True, "deltaO_ma_window": 26}
+            
+            
+    ##argumentos del método PlantinClassifier.clasiffy()
+    kwargs_classifier = {"proba_threshold":0.4,
+                         "use_proba_ma":False,
+                         "proba_ma_window":10,
+                         "update_samePlace":True,
+                         "update_dstpt":True,
+                         "umbral_proba_dstpt":0.5,
+                         "umbral_bajo_dstpt":1.5,
+                         "use_ma":True,
+                         "dstpt_ma_window":62,
+                         "use_min_dstpt":False,
+                         "factor":0.1,
+                         
+                         "useRatioStats":False,
+                         "std_weight":1.,
+                         "useDistancesStats":False,
+                         "ratio_dcdp_umbral":0.1,
+                         "dist_umbral":0.5,
+                         }
+
 #### Version 2.3.0
 
 - Se agregan funcionalidades.

{sarapy-2.3.0.dist-info → sarapy-3.1.0.dist-info}/RECORD

@@ -1,20 +1,20 @@
 sarapy/__init__.py,sha256=aVoywqGSscYYDycLaYJnz08dlQabl9gH0h4Q5KtHM9o,74
-sarapy/version.py,sha256=EbFE7GAQLZCwSMMCgzxS5N2hemqkABZuHK40NP2gaZk,48
-sarapy/analysis/FeaturesResume.py,sha256=rJUFZ7hQ6iQN_G_h7FTOOSRM1T6ATcZTzO7xw7cHSFc,26373
+sarapy/version.py,sha256=cXLYU3050O7pgJLDnRyZy-RRSpT1wyHNfQXLgIuYsaU,48
+sarapy/analysis/FeaturesResume.py,sha256=fqKpDy7Py3QHUMtrS8r-KE25ah4HjkJxBKoZtHdORAQ,31946
 sarapy/analysis/__init__.py,sha256=i6QGXmnuA-k6Gh6639TinluogMhLGIiL-tiR_S2i2Ok,74
 sarapy/dataProcessing/GeoProcessor.py,sha256=ARjgKTXDVdf_cFCXyFmzlnmmmay3HG3q-yeJ9QrAcQU,5919
-sarapy/dataProcessing/OpsProcessor.py,sha256=Q5fWdoV9kdYozlfu0ue65qsyoHBfaVDuHwLcjpnFuJs,18379
-sarapy/dataProcessing/TLMSensorDataProcessor.py,sha256=RuITlryuSaIWvYyJwE5wxp85HVZ6mr5kUVALikfwS4g,3603
+sarapy/dataProcessing/OpsProcessor.py,sha256=HT9TvldVwoLKTLjtmtwA78KetoxUjuzw5Lce2WqM6CU,19432
+sarapy/dataProcessing/TLMSensorDataProcessor.py,sha256=NhRxMoA4SHwyhD61xn6m5UIp1ZrDhEnHaFfhveMJLRQ,3689
 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=0_xGKzkzOIjdK1Kwa4gY8DeJpW2dYCusOgXoJGDWuuU,9867
-sarapy/mlProcessors/PlantinFMCreator.py,sha256=Rp6Mx_bhe0tvcktaG8vC8Dq8LPsBzKx4IjfVledvy6I,6926
+sarapy/mlProcessors/FertilizerTransformer.py,sha256=MTsuplwuRdDMVzycRRYZa98ZOEgRhBcjaDWQg6kyph4,8933
+sarapy/mlProcessors/PlantinClassifier.py,sha256=yNck3R8wGfy6rjb8Q2mxVdu63NWJgJ6UmqUORa2qvbk,12491
+sarapy/mlProcessors/PlantinFMCreator.py,sha256=y8rdkUb-84-ONa4kJOY2R2zAfuOXtUJVBEhUPhDncyY,7852
 sarapy/mlProcessors/__init__.py,sha256=wHnqLn15KRCOYI9WWS8_ArraG_c4UEfDCi19muwjN14,335
 sarapy/preprocessing/DistancesImputer.py,sha256=NvbVAh5m0yFxVgDbEFnEX7RSG13qLjO7i2gqjDAWsf4,9106
 sarapy/preprocessing/FertilizerImputer.py,sha256=zK6ONAilwPHvj-bC7yxnQYOkDBCCkWh6__57vYK9anM,1490
-sarapy/preprocessing/TransformInputData.py,sha256=hp2P0Jry7ORUU_N3bMlAz1sCTvD5Qwfm376O8xqwPEo,8539
+sarapy/preprocessing/TransformInputData.py,sha256=gT0S_ANSmSODPru4DVK7qpA7ZqnRoPwNyLkV-VJWvAU,8584
 sarapy/preprocessing/TransformToOutputData.py,sha256=2hSeFkrSt1OO_jiX4SQJtL3Dhm_9xLy7zCgkj8jo9OE,3137
 sarapy/preprocessing/__init__.py,sha256=2if1rcq8WCk8u4M3bHcE_tY2hLmZxwNG4qdLNJR1Ixg,331
 sarapy/stats/__init__.py,sha256=X4IZsG2TxZUtXYmONvVJymHInnLHMqiThmW6U2ZMd8U,258
@@ -22,8 +22,11 @@ sarapy/stats/stats.py,sha256=eVmi6w9QcwvwuDK3yOr1Z8wQV-1oT3QJujDqWZFYzGc,11424
 sarapy/utils/__init__.py,sha256=TD_-dGgPQBD13hyf2OqDUET0XZOXTduJD1ht8tjZF_0,257
 sarapy/utils/plotting.py,sha256=kX-eYw618urMcUBkNPviQZdBziDc_TR3GInTsO90kU4,4065
 sarapy/utils/utils.py,sha256=NSSeZHeLnQWcFa6vfJ2nVkptX2dIyiCMlZPBmsgEvjo,7106
-sarapy-2.3.0.dist-info/LICENCE,sha256=N00sU3vSQ6F5c2vML9_qP4IFTkCPFFj0YGDB2CZP-uQ,840
-sarapy-2.3.0.dist-info/METADATA,sha256=26MojjAmKIPrQGgbgLXCi6F9WLG_4S2NGZK5vMoGx4Q,6032
-sarapy-2.3.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-sarapy-2.3.0.dist-info/top_level.txt,sha256=4mUGZXfX2Fw47fpY6MQkaJeuOs_8tbjLkkNp34DJWiA,7
-sarapy-2.3.0.dist-info/RECORD,,
+sarapy-3.1.0.dist-info/licenses/LICENCE,sha256=N00sU3vSQ6F5c2vML9_qP4IFTkCPFFj0YGDB2CZP-uQ,840
+test/checking_regresor.py,sha256=F9JwCHdg18dC_flNold_Jc9Gkuib9RDo5jeB-xgReqo,5932
+test/probabilidades_test.py,sha256=4mGwuYNQGQd-LurL63pBpaaw5QHIN1PymBPhzRQB9Hc,3254
+test/test_import.py,sha256=qYBVkwb3ACzGyYj4cVBNmrPAWw-cuITHgWP4oJYdrto,56
+sarapy-3.1.0.dist-info/METADATA,sha256=KvC1CO3uzNDPh--GUX0-3wippO0ThjttyoUGVk8m2Tg,8278
+sarapy-3.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+sarapy-3.1.0.dist-info/top_level.txt,sha256=gsDJg1lRhlnLTvKqH039RW-fsHlHgX6ZTxaM6GheziQ,34
+sarapy-3.1.0.dist-info/RECORD,,

{sarapy-2.3.0.dist-info → sarapy-3.1.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (72.1.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

sarapy-3.1.0.dist-info/top_level.txt

@@ -0,0 +1,5 @@
+docs
+examples
+modelos
+sarapy
+test