sarapy 1.3.0__tar.gz → 2.0.0__tar.gz

{sarapy-1.3.0/sarapy.egg-info → sarapy-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sarapy
-Version: 1.3.0
+Version: 2.0.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.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.
+
 #### Version 1.3.0
 
 - Se agrega funcionalidad para estimar la cantidad de gramos de fertilizante en base al nivel de distorsión de fertilizante arrojado por la electrónica. Se implementa mlProcessor.FertlizerFMCreator y mlProcessor.FertilizerTransformer. Además se modifican las clases OpsProcessor y TransformToOutputData para poder usar estas nuevas clases.

{sarapy-1.3.0 → sarapy-2.0.0}/README.md

@@ -2,6 +2,25 @@
 
 Library for processing SARAPICO project metadata of _AMG SA_.
 
+#### 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.
+
 #### Version 1.3.0
 
 - Se agrega funcionalidad para estimar la cantidad de gramos de fertilizante en base al nivel de distorsión de fertilizante arrojado por la electrónica. Se implementa mlProcessor.FertlizerFMCreator y mlProcessor.FertilizerTransformer. Además se modifican las clases OpsProcessor y TransformToOutputData para poder usar estas nuevas clases.

{sarapy-1.3.0 → sarapy-2.0.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "sarapy"
 
-version = "1.3.0"
+version = "2.0.0"
 authors = [
   {name = "Lucas Baldezzari", email = "lmbaldezzari@gmail.com"},]
 maintainers = [

{sarapy-1.3.0 → sarapy-2.0.0}/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
@@ -68,23 +74,7 @@ class OpsProcessor():
         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.
+            ¡¡¡¡¡¡¡DOCUMENTAR!!!!!!!!!!!!!!!
             
         Returns:
             Lista de diccionarios con las clasificaciones. Cada diccionario tiene la forma
@@ -93,21 +83,22 @@ class OpsProcessor():
         
         ##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]
+            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
+
             return self.transformToOutputData.fit_transform(np.column_stack((id_db_h_nums,
                                                                              id_db_dw_nums,
                                                                              pl_clas,
-                                                                             ft_grams,
-                                                                             date_oprc)))
+                                                                             ft_grams)))
         else:
             self.resetAllNewSamplesValues()
             return None
@@ -116,33 +107,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 +130,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 +171,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 +199,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 +214,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 +225,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 +246,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 +265,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 +281,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 +292,20 @@ 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[:100]
+    samples2 = samples[100:200]
+
+    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())
+    op.processOperations(samples[:2])
+    # op.processOperations(samples2)

sarapy-2.0.0/sarapy/dataProcessing/TLMSensorDataProcessor.py

@@ -0,0 +1,90 @@
+###Documentación en https://github.com/lucasbaldezzari/sarapy/blob/main/docs/Docs.md
+import numpy as np
+import pandas as pd
+
+class TLMSensorDataProcessor():
+    """- Autor: BALDEZZARI Lucas
+
+    Estar clase sirve para entegar los datos de telemetría como un array de numpy. La idea es
+    poder acceder a los datos a través de indexación, ejemplos:
+    tlm_data[["INST_PT","INST_FT"],:] en este caso se obtienen los datos de las columnas INST_PT e INST_FT
+    
+    """
+    
+    def __init__(self, data:list):
+        """Constructor de la clase MetadataManager
+        
+        Args:
+         - data: Es una lista de diccionarios (como un JSON) con los datos de telemetría.
+        """
+        #convierto a un DataFrame de pandas
+        self.data = pd.DataFrame(data)
+        self.keys = self.data.columns.tolist()
+
+    def getData(self):
+        """Devuelve los datos de telemetría como un numpy array.
+        
+        Los datos se retornan como un array de numpy, donde cada fila es una operación y cada columna es un sensor.
+        Es decir, los datos son de la forma (n_operaciones, n_columnas).
+        """
+        return self.data.values
+
+    def __getitem__(self, key):
+        """
+        Permite indexar el objeto como un array o DataFrame.
+
+        Ejemplos:
+            obj[["col1", "col2"], :]       -> columnas col1 y col2, todas las filas
+            obj[:, :100]                   -> todas las columnas, primeras 100 filas
+            obj[:]                         -> todo
+            obj[["col1"], :50]             -> columna col1, primeras 50 filas
+        """
+        if isinstance(key, tuple): ##reviso si es una tupla
+            ##se supone que key es una tupla de la forma (cols, rows)
+            if len(key) != 2:
+                raise ValueError("La clave debe ser una tupla de la forma (cols, rows)")
+            cols, rows = key
+
+            # Columnas
+            if isinstance(cols, list) or isinstance(cols, str):
+                selected_cols = cols
+            elif cols == slice(None):  # equivalente a ":"
+                selected_cols = self.data.columns
+            else:
+                raise TypeError(f"Tipo de indexado de columnas no soportado: {type(cols)}")
+
+            # Filas
+            if isinstance(rows, int) or isinstance(rows, slice):
+                #retornamos de la forma (n_operaciones, n_columnas)
+                return self.data.loc[rows, selected_cols].values
+            else:
+                raise TypeError(f"Tipo de indexado de filas no soportado: {type(rows)}")
+
+        elif isinstance(key, slice):
+            # Caso para todas las filas y columnas
+            # Retornamos de la forma (n_operaciones, n_columnas)
+            return self.data.iloc[key].values
+
+        else:
+            raise TypeError("La indexación debe ser una tupla (cols, rows) o un slice ':'")
+    
+if __name__ == "__main__":
+    import pandas as pd
+    import json
+    from sarapy.preprocessing import TransformInputData
+
+    historical_data_path = "examples/2025-06-21/UPM000N/historical-data.json"
+    with open(historical_data_path, 'r') as file:
+        historical_data = json.load(file)
+
+    inputData_transformer = TransformInputData.TransformInputData()
+    data = inputData_transformer.transform(historical_data)
+    
+    tlm_processor = TLMSensorDataProcessor(data=data)
+    print(tlm_processor.data.head())
+    tlm_processor[:, :10].shape
+
+    tlm_processor[["id_db_dw", "id_db_h"], :5]#.shape
+    tlm_processor.keys
+    tlm_processor["longitud",:]
+    

{sarapy-1.3.0 → sarapy-2.0.0}/sarapy/dataProcessing/TimeSeriesProcessor.py

@@ -54,7 +54,14 @@ class TimeSeriesProcessor(BaseEstimator, TransformerMixin):
     def transform(self, X: np.array):
         """Genera un array con los tiempos de operación, caminata, pico abierto y ratio_dCdP.
             Args:
-                - X es un array de strings de forma (n, 2) donde la primera columna es el tiempo y la segunda columna es el tiempo de pico abierto (en segundos).
+                - X es un array de strings de forma (n, 2) donde la primera columna es el tiempo
+                y la segunda columna es el tiempo de pico abierto (en segundos).
+
+        Returns:
+            - Un array de numpy de forma (n, 4) donde la primera columna es
+            el tiempo de operación, la segunda columna es el tiempo de caminata,
+            la tercera columna es el tiempo de pico abierto y la cuarta columna es
+            el ratio entre el tiempo de caminata y el tiempo de pico abierto.
         """
         
         if not self.is_fitted:
@@ -66,6 +73,17 @@ class TimeSeriesProcessor(BaseEstimator, TransformerMixin):
                           self._ratio_dCdP.reshape(-1,1))).round(2)
     
     def fit_transform(self, X: np.array, y=None):
+        """Genera un array con los tiempos de operación, caminata, pico abierto y ratio_dCdP.
+            Args:
+                - X es un array de strings de forma (n, 2) donde la primera columna es el tiempo
+                y la segunda columna es el tiempo de pico abierto (en segundos).
+
+        Returns:
+            - Un array de numpy de forma (n, 4) donde la primera columna es
+            el tiempo de operación, la segunda columna es el tiempo de caminata,
+            la tercera columna es el tiempo de pico abierto y la cuarta columna es
+            el ratio entre el tiempo de caminata y el tiempo de pico abierto.
+        """
         self.fit(X)
         return self.transform(X)
            

{sarapy-1.3.0 → sarapy-2.0.0}/sarapy/mlProcessors/FertilizerTransformer.py

@@ -1,4 +1,5 @@
 import pickle
+from sarapy.dataProcessing import TLMSensorDataProcessor
 
 class FertilizerTransformer:
     """
@@ -31,51 +32,37 @@ class FertilizerTransformer:
         self.fertilizer_grams = None ##cuando no se ha transformado ningún dato, se inicializa en None
 
 
-    def transform(self, X):
+    def transform(self, data):
         """Transforma los datos de distorsión de fertilizante a gramos.
 
         Params:
-            - X: Es un array con los datos de distorsión de fertilizante. La forma de X es (n,1)
-
-            Ejemplo: [12.  1. 12.  0.  0.  0.  0.  0.  0. 12.]
+            - data: Es una lista de diccionarios (como un JSON) con los datos de telemetría.
 
         Returns:
             - 0: Array con los valores de distorsión de fertilizante transformados a gramos.
         """
-
-        X_poly = self._poly_features.fit_transform(X)
+        tlmDataProcessor = TLMSensorDataProcessor.TLMSensorDataProcessor(data)
+        X = tlmDataProcessor["SC_FT",:]
+        X_poly = self._poly_features.fit_transform(X.reshape(-1, 1))
         self.fertilizer_grams = self._regresor.predict(X_poly)
 
         ##retorno con shape (n,)
         return self.fertilizer_grams.reshape(-1,)
     
 if __name__ == "__main__":
-    import os
     import pandas as pd
-    import numpy as np
+    import json
     from sarapy.preprocessing import TransformInputData
-    from sarapy.mlProcessors import PlantinFMCreator
-    import sarapy.utils.getRawOperations as getRawOperations
-    tindata = TransformInputData.TransformInputData()
-
-    ##cargo los archivos examples\2024-09-04\UPM001N\data.json y examples\2024-09-04\UPM001N\historical-data.json
-    data_path = os.path.join(os.getcwd(), "examples\\2024-09-04\\UPM001N\\data.json")
-    historical_data_path = os.path.join(os.getcwd(), "examples\\2024-09-04\\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 = np.array(getRawOperations.getRawOperations(raw_data, raw_data2))
-    X = tindata.fit_transform(raw_ops) #transforma los datos de operaciones a un array de numpy
-    
-    from sarapy.mlProcessors import FertilizerFMCreator
 
-    ftfmcreator = FertilizerFMCreator.FertilizerFMCreator()
-    dst_ft = ftfmcreator.transform(X[:,2])
-    ##convierto a int dst_ft
-    dst_ft = dst_ft.astype(int)
+    historical_data_path = "examples/2025-06-21/UPM000N/historical-data.json"
+    with open(historical_data_path, 'r') as file:
+        historical_data = json.load(file)
 
-    from sarapy.mlProcessors import FertilizerTransformer
+    ##cargo en un diccionario sarapy\preprocessing\telemetriaDataPosition.json
+    data_positions = json.load(open("sarapy/preprocessing/telemetriaDataPosition.json", 'r'))
+    transform_input_data = TransformInputData.TransformInputData()
+    transformed_data = transform_input_data.transform(historical_data)
 
-    fertransformer = FertilizerTransformer.FertilizerTransformer(regresor_file='modelos\\regresor.pkl', poly_features_file='modelos\\poly_features.pkl')
-    gramos = fertransformer.transform(dst_ft.reshape(-1,1))
+    fertransformer = FertilizerTransformer(regresor_file='modelos\\regresor.pkl', poly_features_file='modelos\\poly_features.pkl')
+    gramos = fertransformer.transform(transformed_data)
     print(gramos[:10])

{sarapy-1.3.0 → sarapy-2.0.0}/sarapy/mlProcessors/PlantinClassifier.py

@@ -129,12 +129,12 @@ class PlantinClassifier(BaseEstimator, TransformerMixin):
         Función para actualizar las etiquetas de las operaciones que tengan distorsiones de plantín.
         """
         new_labels = labels.copy()
+        
         ##filtro si dst_pt es menor a 7 y si inest_pt es 0
-        new_labels[(dst_pt < 7) & (inest_pt == 0)] = 0
+        new_labels[(dst_pt < 4) & (inest_pt == 0)] = 0
 
-        ##si inest_pt es y umbral_proba es menor a umbra_proba, entonces la operación es 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
-        # new_labels[(inest_pt == 1) & (self.probas[:,1] >= umbral_proba)] = 1
 
         return new_labels