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

sarapy/dataProcessing/OpsProcessor.py

@@ -5,6 +5,12 @@ from sarapy.mlProcessors import PlantinFMCreator
 from sarapy.mlProcessors import PlantinClassifier
 from sarapy.preprocessing import TransformInputData, TransformToOutputData
 from sarapy.mlProcessors import FertilizerFMCreator, FertilizerTransformer
+import logging
+
+##nivel de logging en warning para evitar mensajes de advertencia de sklearn
+logging.basicConfig(level=logging.WARNING,
+                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+                    datefmt='%Y-%m-%d %H:%M:%S')
 
 class OpsProcessor():
     """Clase para procesar las operaciones de los operarios. La información se toma de la base de datos
@@ -66,48 +72,41 @@ class OpsProcessor():
         Se toma una nueva muestra y se procesa la información para clasificar las operaciones considerando el
         plantín y por otro lado el fertilizante.
         Se retorna un array con las clasificaciones concatenadas, manteniendo el orden de las operaciones por operario.
-        
-        Args:
-            data: Es una lista de diccionario. Cada diccionario tiene los siguientes keys.
-            
-            Ejemplo:
-            
-            {
-                "id_db_h":1, #int
-                "ID_NPDP":"XXAA123", #string
-                "FR": 1, #int
-                "TLM_NPDP": b'\xfc\x01\t\t\x00\x00\x00\x98', #bytes
-                "date_oprc":datetime.datetime(2024, 2, 16, 21, 2, 2, tzinfo=tzutc()),#datetime
-                "Latitud":-32.145564789, #float
-                "Longitud":-55.145564789, #float
-                "Precision": 1000,
-                "id_db_dw": 1 #int
-            }
 
-            - kwargs: Diccionario con los argumentos necesarios para la clasificación. Se utiliza para pasar argumentos a los métodos de clasificación.
+        Args:
+            - data: Lista de diccionario. Cada diccionario tiene la forma.
+            Ejemplo (NOTA: El salto de línea es agregado para mejorar la legibilidad):
+            [
+            {"id": 6, "receiver_timestamp": "2025-06-21T15:51:36.527825+00:00", "timestamp": "2025-06-21T15:51:01.000002+00:00", "datum": null,
+            "csv_datum": "2025-06-21T15:51:01.000002+00:00,2,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-58.0321,-33.2471,
+            1,0,0,0,0,0,0,0,0,0,1,1,1,0,1,1,0,0,0,0,1,0,0,1,1,0,3,0,0,0,0,3,0,0,0,0,0,1,0,0,0,0,0.0000,0.0000,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0", 
+            "longitude": null, "latitude": null, "accuracy": null, "tag_seedling": null, "tag_fertilizer": null}
+            ]
             
         Returns:
             Lista de diccionarios con las clasificaciones. Cada diccionario tiene la forma
-            {"id_db_h": 10, "id_db_dw": 10, "tag_seedling": 1, "tag_fertilizer": gramos (float)}
+            [{"timestamp": "2025-05-27T21:42:38.000002+00:00", "tag_seedling": 1, "tag_fertilizer": gramos (float)},...]
         """
         
         ##chqueo que newSample no esté vacío
         if len(data) != 0:
-            newSample = self.transformInputData.fit_transform(data)
+            newSample = self.transformInputData.transform(data)
+
             #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
 
             #estimamos los gramos de fertilizante
-            dst_ft = self._ftfmcreator.transform(newSample[:,2]).astype(int)
-            ft_grams = self._fertilizer_transformer.transform(dst_ft.reshape(-1,1))
+            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
-            date_oprc = newSample[:,3]
-            return self.transformToOutputData.fit_transform(np.column_stack((id_db_h_nums,
-                                                                             id_db_dw_nums,
+            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
+            timestamps = pd.DataFrame(newSample)["timestamp"].values.reshape(-1, 1) ##extraigo los timestamps de la muestra
+            
+            return self.transformToOutputData.fit_transform(np.column_stack((timestamps,
                                                                              pl_clas,
-                                                                             ft_grams,
-                                                                             date_oprc)))
+                                                                             ft_grams)))
         else:
             self.resetAllNewSamplesValues()
             return None
@@ -116,33 +115,20 @@ class OpsProcessor():
         """Actualiza el diccionario de operaciones.
         
         Args:
-            - newSample: lista con los datos (numpy.array de strings) de las operaciones.
-            
-            - 0: id_db_h
-            - 1: ID_NPDP
-            - 2: TLM_NPDP
-            - 3: date_oprc
-            - 4: latitud
-            - 5: longitud
-            - 6: Precision
-            - 7: FR
-            - 8: id_db_dw
-                
-        Returns:
-            - None
-            NOTA: PENSAR SI SE DEVUELVE ALGO COMO UN TRUE O FALSE PARA SABER SI SE ACTUALIZÓ O NO EL DICCIONARIO
-            DE MANERA CORRECTA O HUBO ALGÚN PROBLEMA Y ASÍ VER QUÉ HACER EN EL MAIN
+            - newSample: lista de diccionarios con los datos de  las operaciones.
+
         """
-        
-        ID_NPDPs_newOperations = np.unique(newSample[:,1]) ##identificadores de operarios con nuevas operaciones en la muestra
-        
+        nodos_recibidos = np.array([row["ID_NPDP"] for row in newSample]) ##nodos recibidos en la muestra
+        ID_NPDPs_newOperations = np.unique(nodos_recibidos) ##identificadores de operarios con nuevas operaciones en la muestra
+        logging.debug(f"Received nodes: {ID_NPDPs_newOperations}")
+
         ##chqueo si estos ID_NPDPs ya están en el diccionario, sino los agrego
         for ID_NPDP in ID_NPDPs_newOperations:
             if ID_NPDP not in self._operationsDict:
                 #El diccionario contiene la siguiente información:
-                #sample_ops: np.array con las columnas de TLM_NPDP, date_oprc, lat, lon, precision
-                #last_oprc: np.array de la última operación con las columnas de TLM_NPDP, date_oprc, lat, lon, precision
-                #first_day_op_classified: booleano para saber si es la primera operación del día fue clasificada
+                #sample_ops: lista de diccionarios con los datos de las operaciones.
+                #last_oprc: diccionario con la última operación registrada.
+                #first_day_op_classified: booleano para saber si es la primera operación del día que fue clasificada
                 self._operationsDict[ID_NPDP] = {"sample_ops": None,
                                                  "last_oprc": None, 
                                                  "first_day_op_classified": False,
@@ -152,18 +138,18 @@ class OpsProcessor():
                 
         ##actualizo el diccionario con las operaciones nuevas para aquellos operarios que correspondan
         for ID_NPDP in ID_NPDPs_newOperations:
-            sample_ops = newSample[newSample[:,1] == ID_NPDP][:,2:] #me quedo con las columnas de TLM_NPDP, date_oprc, lat, lon, precision
-            id_db_h = newSample[newSample[:,1] == ID_NPDP][:,0]
-            id_db_dw = newSample[newSample[:,1] == ID_NPDP][:,8]
+            sample_ops = newSample
+            id_db_h = np.array([row["id_db_h"] for row in newSample]) ##extraigo los id_db_h de la muestra
+            id_db_dw = np.array([row["id_db_dw"] for row in newSample])
             ##actualizo el diccionario
             self._operationsDict[ID_NPDP]["sample_ops"] = sample_ops
-            self._operationsDict[ID_NPDP]["id_db_h"] = id_db_h
-            self._operationsDict[ID_NPDP]["id_db_dw"] = id_db_dw
+            self._operationsDict[ID_NPDP]["id_db_h"] = np.astype(id_db_h, str) ##convierto a int
+            self._operationsDict[ID_NPDP]["id_db_dw"] = np.astype(id_db_dw, str) ##convierto a int
             ##chequeo si tenemos última operación, si es así, asignamos dicha operación en la primera fila de sample_ops
             last_op = self._operationsDict[ID_NPDP]["last_oprc"]
             ###si last_op es not None y last_op no está vacía, entonces concatenamos last_op con sample_ops
-            if last_op is not None and last_op.size != 0:
-                self._operationsDict[ID_NPDP]["sample_ops"] = np.vstack((last_op, sample_ops))
+            if last_op is not None and len(last_op) != 0:
+                self._operationsDict[ID_NPDP]["sample_ops"] += last_op ##concatenamos la última operación con las nuevas operaciones
                 
         self.updateNewSamplesValues(ID_NPDPs_newOperations) #actualizo el estado de 'new_sample' en el diccionario de operaciones
         self.updateLastOperations(ID_NPDPs_newOperations) #actualizo la última operación de una muestra de operaciones en el diccionario de operaciones
@@ -193,25 +179,27 @@ class OpsProcessor():
         plantinClassifications = None
         
         ##me quedo con los ID_NPDPs que tengan _operationsDict[ID_NPDP]["new_sample"] iguales a True
-        ops_with_new_sample = [ID_NPDP for ID_NPDP in self.operationsDict.keys() if self.operationsDict[ID_NPDP]["new_sample"]]
+        ops_with_new_sample = [ID_NPDP for ID_NPDP in self._operationsDict.keys() if self.operationsDict[ID_NPDP]["new_sample"]]
 
         for ID_NPDP in ops_with_new_sample:#self.operationsDict.keys():
             ##clasificamos las operaciones para plantín
-            operations = self.operationsDict[ID_NPDP]["sample_ops"]
+            operations = self._operationsDict[ID_NPDP]["sample_ops"]
+            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)
+            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
-            if self.operationsDict[ID_NPDP]["first_day_op_classified"]:
+            if self._operationsDict[ID_NPDP]["first_day_op_classified"]:
                 classified_ops = classified_ops[1:]
 
             ##actualizo las operaciones que hayan sido hardcodeadas luego de despertar y/o reiniciar la electrónica
-            classified_ops = self.updateBedoreAwake(classified_ops)
+            classified_ops = self.updateAfterAwake(classified_ops)
                 
-            # plantinClassifications = np.vstack((plantinClassifications, classified_ops)) if plantinClassifications is not None else classified_ops
             plantinClassifications = np.concatenate((plantinClassifications, classified_ops)) if plantinClassifications is not None else classified_ops
             
-            self.operationsDict[ID_NPDP]["first_day_op_classified"] = True
+            self._operationsDict[ID_NPDP]["first_day_op_classified"] = True
 
         return plantinClassifications
             
@@ -219,18 +207,7 @@ class OpsProcessor():
         """Método para actualizar la última operación de una muestra de operaciones en el diccionario de operaciones
 
         Args:
-            - newSample: lista con los datos (numpy.array de strings) de las operaciones.
-            La forma de cada dato dentro de la lista newSample es (n,6). Las columnas de newSample son,
-            
-                - 0: id_db_h
-                - 1: ID_NPDP
-                - 2: TLM_NPDP
-                - 3: date_oprc
-                - 4: latitud
-                - 5: longitud
-                - 6: Precision
-                - 7: FR
-                - 8: id_db_dw
+            - newSample: lista de diccionarios con los datos de  las operaciones.
         """
         
         for ID_NPDP in ID_NPDPs_newOperations:
@@ -245,8 +222,9 @@ class OpsProcessor():
 
         ##recorro el diccionario de operaciones y actualizo el estado de 'new_sample' a
         ##True para los ID_NPDPs que tienen nuevas operaciones y a False para los que no tienen nuevas operaciones
-        for ID_NPDP in self.operationsDict.keys():
+        for ID_NPDP in self._operationsDict.keys():
             if ID_NPDP in ID_NPDPs_newOperations:
+                logging.debug(f"Actualizando 'new_sample' para nodo: {ID_NPDP}")
                 self._operationsDict[ID_NPDP]["new_sample"] = True
             else:
                 self._operationsDict[ID_NPDP]["new_sample"] = False
@@ -255,19 +233,20 @@ class OpsProcessor():
         """Método para resetar todos los valores de new_sample en el diccionario de operaciones.
         """
         
-        for ID_NPDP in self.operationsDict.keys():
+        for ID_NPDP in self._operationsDict.keys():
             self._operationsDict[ID_NPDP]["new_sample"] = False
 
     def getActualOperationsNumbers(self):
         """Método para obtener los números de operaciones desde el diccionario de operaciones para aquellos operarios que
         tienen nuevas operaciones en la muestra."""
-
+        
         id_db_h_list = np.array([])
         id_db_dw_list = np.array([])
-        for ID_NPDP in self.operationsDict.keys():
-            if self.operationsDict[ID_NPDP]["new_sample"]:
-                id_db_h_list = np.append(id_db_h_list, self.operationsDict[ID_NPDP]["id_db_h"].flatten())
-                id_db_dw_list = np.append(id_db_dw_list, self.operationsDict[ID_NPDP]["id_db_dw"].flatten())
+        for ID_NPDP in self._operationsDict.keys():
+            if self._operationsDict[ID_NPDP]["new_sample"]:
+                logging.debug(f"Obteniendo números de operaciones para el ID_NPDP: {ID_NPDP}")
+                id_db_h_list = np.append(id_db_h_list, self._operationsDict[ID_NPDP]["id_db_h"].flatten())
+                id_db_dw_list = np.append(id_db_dw_list, self._operationsDict[ID_NPDP]["id_db_dw"].flatten())
 
         return id_db_h_list.astype(int), id_db_dw_list.astype(int)
     
@@ -275,7 +254,7 @@ class OpsProcessor():
         """Método para actualizar el indicador de si es la primera operación del día para cada operario en el diccionario de operaciones.
         """
 
-        for ID_NPDP in self.operationsDict.keys():
+        for ID_NPDP in self._operationsDict.keys():
             self._operationsDict[ID_NPDP]["first_day_op_classified"] = False
     
     def cleanSamplesOperations(self):
@@ -294,10 +273,10 @@ class OpsProcessor():
                 - 6: Precision
         """
 
-        for ID_NPDP in self.operationsDict.keys():
+        for ID_NPDP in self._operationsDict.keys():
             self._operationsDict[ID_NPDP]["sample_ops"] = None
 
-    def updateBedoreAwake(self, classified_ops):
+    def updateAfterAwake(self, classified_ops):
         """
         Función para actualizar las operaciones que hayan sido hardcodeadas luego de despertar y/o reiniciar la electrónica.
 
@@ -310,8 +289,8 @@ class OpsProcessor():
         - classified_ops: np.array con las operaciones clasificadas.
         """
 
-        ##me quedo con los índices donde MODEFlag es igual a 1
-        mask = self.plantinFMCreator.tlmExtracted[:,self.plantinFMCreator.tlmdeDP["MODEFlag"]]==1
+        ##me quedo con los índices donde N_MODE es igual a 1
+        mask = self.plantinFMCreator.tlmDataProcessor["N_MODE",:]==1
         classified_ops[mask] = 0 ##hardcodeo las operaciones que hayan sido clasificadas como 1
         return classified_ops
             
@@ -321,37 +300,19 @@ class OpsProcessor():
     
 
 if __name__ == "__main__":
-    #cargo archivo examples\volcado_17112023_NODE_processed.csv
     import pandas as pd
-    import numpy as np
-    import os
-    import sarapy.utils.getRawOperations as getRawOperations
-    from sarapy.dataProcessing import OpsProcessor
-
-    data_path = os.path.join(os.getcwd(), "examples\\2024-09-16\\UPM001N\\data.json")
-    historical_data_path = os.path.join(os.getcwd(), "examples\\2024-09-16\\UPM001N\\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 = getRawOperations.getRawOperations(raw_data, raw_data2)
-
-    import time
-    start_time = time.time()
-    op = OpsProcessor.OpsProcessor(classifier_file='modelos\\pipeline_rf.pkl', imputeDistances = False,
-                                   regresor_file='modelos\\regresor.pkl', poly_features_file='modelos\\poly_features.pkl')
-    classifications = op.processOperations(raw_ops, update_samePlace=True, useRatioStats=True)
-    end_time = time.time()
-    execution_time = end_time - start_time
-    print("Execution time:", execution_time, "seconds")
+    import json
+    import logging
+    
+
+    historical_data_path = "examples/2025-06-21/UPM000N/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', imputeDistances = False,
+                      regresor_file='modelos\\regresor.pkl', poly_features_file='modelos\\poly_features.pkl')
     
-    ##
-    df = pd.DataFrame(classifications)
-    tag_seedling = df["tag_seedling"].values
-    print(tag_seedling.mean())
-    print(df["tag_seedling"].shape)
-
-    ##datos de fertilizante
-    tag_fertilizer = df["tag_fertilizer"].values
-    print(tag_fertilizer[1500:1560])
-    print(tag_fertilizer.mean())
+    print(op.processOperations(samples[:20]))
+    # op.processOperations(samples2)