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

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/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/mlProcessors/PlantinFMCreator.py

@@ -4,9 +4,10 @@ from sklearn.base import BaseEstimator, TransformerMixin
 from sarapy.dataProcessing import TLMSensorDataProcessor, TimeSeriesProcessor, GeoProcessor
 
 class PlantinFMCreator(BaseEstimator, TransformerMixin):
-    """La clase FMCreator se encarga de crear la Feature Matrix (FM) a partir de los datos de telemetría. Se utilizan las clases TLMSensorDataExtractor, TimeSeriesProcessor y GeoProcessor para realizar las transformaciones necesarias.
+    """La clase FMCreator se encarga de crear la Feature Matrix (FM) a partir de los datos de telemetría.
+    Se utilizan las clases TLMSensorDataProcessor, TimeSeriesProcessor y GeoProcessor para realizar las transformaciones necesarias.
     
-    Versión 0.1.0
+    Versión 2.0.0
     
     En esta versión la matriz de características está formada por las siguientes variables
     
@@ -14,6 +15,7 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
     - deltaO: delta operación
     - ratio_dCdP: Ratio entre el delta de caminata y delta de pico abierto
     - distances: Distancias entre operaciones
+    - inest_pt: Inestabilidad del plantín
     """
     
     def __init__(self, imputeDistances = True, distanciaMedia:float = 1.8,
@@ -45,12 +47,7 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
         """Fittea el objeto
         
         Params:
-            - X: Es un array con los datos provenientes (strings) de la base de datos histórica. La forma de X es (n,5)Las columnas de X son,
-                - 0: tlm_spbb son los datos de telemetría.
-                - 1: date_oprc son los datos de fecha y hora de operación.
-                - 2: latitud de la operación
-                - 3: longitud de la operación
-                - 4: precision del GPS
+            - X: Es una lista de diccionarios (como un JSON) con los datos de telemetría.
         """
         self.is_fitted = True
         
@@ -58,12 +55,7 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
         """Transforma los datos de X en la matriz de características.
         
         Params:
-            - X: Es un array con los datos provenientes (strings) de la base de datos histórica. La forma de X es (n,5)Las columnas de X son,
-                - 0: tlm_spbb son los datos de telemetría.
-                - 1: date_oprc son los datos de fecha y hora de operación.
-                - 2: latitud de la operación
-                - 3: longitud de la operación
-                - 4: precision del GPS
+            - X: Es una lista de diccionarios (como un JSON) con los datos de telemetría.
                 
         Returns:
                 - 0: feature_matrix: (deltaO, ratio_dCdP, distances)
@@ -74,40 +66,35 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
         if not self.is_fitted:
             raise RuntimeError("El modelo no ha sido fitteado.")
         
-        ##instanciamos los objetos
-        tlmDataExtractor = TLMSensorDataProcessor.TLMSensorDataProcessor()
+        ##instanciamos los objetos a usar
+        self.tlmDataProcessor = TLMSensorDataProcessor.TLMSensorDataProcessor(X)
         timeProcessor = TimeSeriesProcessor.TimeSeriesProcessor()
+        tpDP = timeProcessor._dataPositions
         geoprocessor = GeoProcessor.GeoProcessor()
         
-        tlm_spbb = X[:,0] #datos de telemería
-        date_oprc = X[:,1].astype(int) #datos de fecha y hora de operación
-        lats = X[:,2].astype(float) #latitudes de las operaciones
-        longs = X[:,3].astype(float) #longitudes de las operaciones  
+
+        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
+        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 *****
-        ##obtengo las posiciones de los datos de tlmDataExtractor y timeProcessor
-        self._tlmdeDP = tlmDataExtractor.dataPositions #posiciones de los datos transformados de tlmDataExtractor
-        self._tpDP = timeProcessor.dataPositions #posiciones de los datos transformados de timeProcessor
-        
-        ##fitteamos tlmse con los datos de telemetría
-        self._tlmExtracted = tlmDataExtractor.fit_transform(tlm_spbb)
+        ##***** OBTENEMOS LOS DATOS PARA FITEAR LOS OBJETOS Y ASÍ PROCESAR LA FM *****
         
         ##fitteamos timeProcessor con los datos de fecha y hora de operación y los TIMEAC
-        timeData = np.hstack((date_oprc.reshape(-1,1),self._tlmExtracted[:,self._tlmdeDP["TIMEAC"]].reshape(-1, 1)))
+        timeData = np.hstack((date_oprc.reshape(-1,1),time_ac.reshape(-1, 1)))
+        
         self._timeDeltas = timeProcessor.fit_transform(timeData)
         
         ##fitteamos geoprocessor con las latitudes y longitudes
-        ##genero un array de puntos de la forma (n,2)
         points = np.hstack((lats.reshape(-1,1),longs.reshape(-1,1)))
         self._distances = geoprocessor.fit_transform(points)
 
-        self.dst_pt = self._tlmExtracted[:,self._tlmdeDP["DSTRPT"]]
-        self.inest_pt = self._tlmExtracted[:,self._tlmdeDP["INESTPT"]]
-        
         ##armamos la feature matrix
-        self.featureMatrix = np.vstack((self._timeDeltas[:,self._tpDP["deltaO"]],
-                                        self._timeDeltas[:,self._tpDP["ratio_dCdP"]],
+        self.featureMatrix = np.vstack((self._timeDeltas[:,tpDP["deltaO"]],
+                                        self._timeDeltas[:,tpDP["ratio_dCdP"]],
                                         self._distances)).T
         
         return self.featureMatrix, self.dst_pt, self.inest_pt
@@ -116,12 +103,7 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
         """Fittea y transforma los datos de X en la matriz de características.
         
         Params:
-            - X: Es un array con los datos provenientes (strings) de la base de datos histórica. La forma de X es (n,5)Las columnas de X son,
-                - 0: tlm_spbb son los datos de telemetría.
-                - 1: date_oprc son los datos de fecha y hora de operación.
-                - 2: latitud de la operación
-                - 3: longitud de la operación
-                - 4: precision del GPS
+            - X: Es una lista de diccionarios (como un JSON) con los datos de telemetría.
                 
         Returns:
                 - 0: feature_matrix: (deltaO, ratio_dCdP, distances)
@@ -131,10 +113,10 @@ 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 tlmExtracted(self):
+    #     """Devuelve los datos de telemetría extraídos."""
+    #     return self.tlmExtracted
     
     @property
     def tlmdeDP(self):
@@ -158,23 +140,21 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
     
         
 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
-
-    fmcreator = PlantinFMCreator.PlantinFMCreator(imputeDistances=False)
-    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")
+    historical_data_path = "examples/2025-06-21/UPM000N/historical-data.json"
+    with open(historical_data_path, 'r') as file:
+        historical_data = json.load(file)
+    df = pd.DataFrame(historical_data)
 
-    raw_ops = np.array(getRawOperations.getRawOperations(raw_data, raw_data2))
-    X = tindata.fit_transform(raw_ops)
+    ##cargo en un diccionario sarapy\preprocessing\telemetriaDataPosition.json
+    data_positions = json.load(open("sarapy/preprocessing/telemetriaDataPosition.json", 'r'))
+    transform_input_data = TransformInputData.TransformInputData()
+    X = transform_input_data.transform(historical_data)
+    
+    fmcreator = PlantinFMCreator(imputeDistances=False)
 
-    fm, dst_pt, inest_pt = fmcreator.fit_transform(X[:,2:])  
+    fm, dst_pt, inest_pt = fmcreator.fit_transform(X) 
+    print(fm.shape)  # Debería ser (n_operaciones, 3)

sarapy/preprocessing/TransformInputData.py

@@ -10,101 +10,140 @@ class TransformInputData(BaseEstimator, TransformerMixin):
 
     def __init__(self):
         """
-        Constructor de la clase TransformInputData.
-        
-        Args:
-            - features_list: Lista con los nombres de las columnas a extraer de los datos recibidos de cada operación.
-        """
-        self.is_fitted = False
-        self.positions = {"id_db_h":0,
-                          "ID_NPDP":1,
-                          "TLM_NPDP":2,
-                          "date_oprc":3,
-                          "latitud":4,
-                          "longitud":5,
-                          "Precision":6,
-                          "FR":7,
-                          "id_db_dw":8}
+        Inicializa la clase TransformToJson.
 
-    def fit(self, X:np.array, y = None):
-        """
-        Fittea el objeto
+        Args:
+            data_positions (dict): Diccionario con las posiciones de los datos en el formato JSON. Se utiliza para identificar
+            la posición de cada dato en el JSON transformado. Diferentes transformadores pueden tener diferentes posiciones de datos.
         """
-        self.is_fitted = True  
+        # self.dataPositions = TransformInputData.data_positions  # Diccionario para almacenar las posiciones de los datos
+        self.data_positions = { "Date_oprc": 0, "Operacion": 1, "SC_PT": 2, "DATA_PT": 3, "INST_PT": 4, "RES_PT": 5,
+                               "CLMP_PT": 6, "SC_FT": 7, "DATA_FT": 8, "INST_FT": 9, "RES_FT": 10, "CLMP_FT": 11, "SC_GYRO_Z": 12,
+                               "SC_GYRO_Y": 13, "SC_GYRO_X": 14, "DATA_GYRO": 15, "INST_GYRO": 16, "CLMP_GYRO": 17, "SC_ACCEL_Z": 18,
+                               "SC_ACCEL_Y": 19, "SC_ACCEL_X": 20, "DATA_ACCEL": 21, "INST_ACCEL": 22, "CLMP_ACCEL": 23, "TIME_AC": 24,
+                               "OPEN_AC": 25, "Longitud_N": 26, "Latitud_N": 27, "Precision_N": 28, "N_FIX": 29, "N_SIV": 30, "N_PDOP": 31,
+                               "N_NBAT": 32, "N_SBAT": 33, "N_VBAT": 34, "N_CBAT": 35, "N_CHRG": 36, "ID_NPDP": 37, "N_MODE": 38, "N_RST": 39,
+                               "N_FLASH": 40, "N_CLK": 41, "N_EST_GNSS": 42, "N_EST_NFC": 43, "N_EST_RF": 44, "N_EST_IMU": 45, "N_EST_BMS": 46,
+                               "EST_CDC": 47, "N_ONLINE": 48, "N_RSSI": 49, "SEND_TRY": 50, "PMST": 51, "ID_OPRR": 52, "N_DATA_ID": 53,
+                               "ID_GPDP": 54, "G_MODE": 55, "G_RST": 56, "G_FLASH": 57, "G_CLK": 58, "G_EST_4G": 59, "G_EST_NFC": 60,
+                               "G_EST_IMU": 61,"G_EST_BMS": 62, "G_RSSI": 63, "G_NETWORK": 64, "G_ONLINE": 65, "G_SIGNAL": 66,
+                               "G_MONEY": 67, "ID_CDLL": 68,"G_DATA_ID": 69, "Longitud_G": 70, "Latitud_G": 71, "Precision_G": 72,
+                               "G_FIX": 73, "G_SIV": 74, "G_PDOP": 75, "G_NBAT": 76, "G_SBAT": 77, "G_VBAT": 78, "G_CBAT": 79, "G_CHRG": 80,
+                               "VUX1": 81, "VUX2": 82, "VUX3": 83, "VUX4": 84, "VUX5": 85, "VUX6": 86, "VUX7": 87, "VUX8": 88,
+                               "VUX9": 89, "VUX10": 90}
+        self.dataFloat = ["latitud","longitud","Longitud_N","Latitud_N","Longitud_G","Latitud_G","date_oprc","Date_oprc"]
+        self.dataString = ["timestamp"]
 
-        self.newSample = np.array([[d["id_db_h"],
-                                    d["ID_NPDP"],
-                                    ''.join([bin(byte)[2:].zfill(8) for byte in d["TLM_NPDP"]]),
-                                    int(d["date_oprc"].timestamp()),
-                                    d["Latitud"],
-                                    d["Longitud"],
-                                    d["Precision"],
-                                    d["FR"],
-                                    d["id_db_dw"]] for d in X])   
-              
-        return self
-    
-    def transform(self, X:np.array):
+    def transform(self, X):
         """
-        Transforma los datos de entrada a un formato utilizable para procesar las operaciones.
+        Método para transformar los datos en formato JSON.
         
         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
-            }
-            
-        NOTA: Los diccionarios de la lista tienen más datos, pero no se usan ahora.
+            X: 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}
+            ]
+
+        NOTA: Cada diccionario debe tener, sí o sí, los siguientes keys (además de los que ya tiene csv_datum)
+            - 0: id_db_h (sale de "id" dentro de los datos de entrada X)
+            - 1: ID_NPDP  (sale de csv_datum)
+            - 3: date_oprc (sale de csv_datum)
+            - 4: latitud (sale de csv_datum)
+            - 5: longitud (sale de csv_datum)
+            - 6: precision (sale de csv_datum)
+            - 7: FR
+            - 8: id_db_dw (sale de "Operacion" dentro de csv_datum)
         
         Returns:
-            Retorna un array de strings con la siguiente estructura
-            - 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
-    """
-        ##chequeamos si se ha llamado a fit(). Sino, se arroja un error
-        if not self.is_fitted:
-            raise ValueError("TransformInputData no ha sido fitteado. Llame a fit() previamente.")
+            Lista de diccionarios con los datos transformados. Básciamente se toma csv_datum y se agrega a cada uno de los diccionarios de la lista.
+            Para esto, se usa el diccionario `dataPositions` para identificar las posiciones y qué son cada uno de los valores dentro de `csv_datum`.
+            Los diccionarios dentro de la lista no tendrán csv_datum.
+        """
+        self.data_transformed = []
+        dict_structre = {"id_db_h":None, "id_db_dw":None, "ID_NPDP":None,
+                         "date_oprc":None, "latitud":None, "longitud":None,
+                         "precision":None, "FR":None, "timestamp": None}
         
-        return self.newSample
-    
-    def fit_transform(self, X:np.array, y=None):
-        self.fit(X)
-        return self.transform(X)
+        ##agrego los keys que están en dataPositions con valores None
+        for key in self.data_positions.keys():
+            dict_structre[key] = None
+
+        
+        for row in X:
+            # Crear un diccionario para almacenar los datos transformados
+            data_dict = dict_structre.copy()
+            # Asignar los valores de csv_datum a las posiciones correspondientes
+            csv_datum = row.get("csv_datum", "")
+            if csv_datum:
+                values = csv_datum.split(',')
+                for key, pos in self.data_positions.items():
+                    if pos < len(values):
+                        data_dict[key] = values[pos]
+                    else:
+                        data_dict[key] = None
+            
+            data_dict["id_db_h"] = row.get("id", None)
+            data_dict["id_db_dw"] = data_dict.get("Operacion", None)
+            data_dict["ID_NPDP"] = data_dict.get("ID_NPDP", None)
+            ##convierto Date_oprc a un objeto datetime y paso a timestamp
+            date_oprc = data_dict.get("Date_oprc", None)
+            if date_oprc:
+                try:
+                    from dateutil import parser
+                    data_dict["date_oprc"] = parser.isoparse(date_oprc).timestamp()
+                except Exception as e:
+                    print(f"Error parsing date_oprc: {e}")
+                    data_dict["date_oprc"] = None
+            else:
+                data_dict["date_oprc"] = None
+            data_dict["latitud"] = data_dict.get("Latitud_N", None)
+            data_dict["longitud"] = data_dict.get("Longitud_N", None)
+            data_dict["precision"] = data_dict.get("Precision_N", None)
+            data_dict["Date_oprc"] = data_dict.get("date_oprc", None)
+            data_dict["latitud"] = data_dict.get("Latitud_N", None)
+            data_dict["longitud"] = data_dict.get("Longitud_N", None)
+            data_dict["timestamp"] = row.get("timestamp", None)
+            # data_dict["FR"] = row.get("tag_fertilizer", None)
+            
+            # Agregar el diccionario transformado a la lista
+            self.data_transformed.append(data_dict)
+
+        ##convierto los datos de self.dataFloat a float y el resto a int
+        for data in self.data_transformed:
+            for key, value in data.items():
+                if key in self.dataFloat:
+                    try:
+                        data[key] = float(value) if value else None
+                    except ValueError:
+                        data[key] = None
+                elif key in self.dataString:
+                    try:
+                        data[key] = str(value) if value else None
+                    except ValueError:
+                        data[key] = None
+                else:
+                    try:
+                        data[key] = int(value) if value else None
+                    except ValueError:
+                        data[key] = None
+
+        return self.data_transformed
     
 if __name__ == "__main__":
     import pandas as pd
-    import numpy as np
-    import os
-    from sarapy.utils.getRawOperations import getRawOperations
-
-    # features=["id_db_h","ID_NPDP","TLM_NPDP","date_oprc","latitud","longitud","Precision","FR","id_db_dw",
-    #           "INESTPT","INESTFT"]
-    
-    transform_input_data = TransformInputData()
-
-    #cargo "examples\\2024-05-30\\UPM007N\\data.json"
-    data = pd.read_json("examples\\2024-05-30\\UPM007N\\data.json").to_dict(orient="records")
-    historical_data = pd.read_json("examples\\2024-05-30\\UPM007N\\historical-data.json").to_dict(orient="records")
+    import json
 
-    ppk_results = getRawOperations(data,historical_data)
+    historical_data_path = "examples/2025-06-21/UPM000N/historical-data.json"
+    with open(historical_data_path, 'r') as file:
+        historical_data = json.load(file)
+    df = pd.DataFrame(historical_data)
 
-    X = np.array(ppk_results)
-    print(transform_input_data.fit_transform(X))
+    ##cargo en un diccionario sarapy\preprocessing\telemetriaDataPosition.json
+    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])

sarapy/preprocessing/TransformToOutputData.py

@@ -10,14 +10,11 @@ class TransformToOutputData(BaseEstimator, TransformerMixin):
             - dataToTransform: array con los datos de las operaciones clasificadas.
             Actualmente el array de dataToTransform es de (n,5) con las columnas siguientes
             
-                - 0: id_db_h
-                - 1: id_db_dw
-                - 2: tag_seedling
-                - 3: tag_fertilizer      
-                - 4: date_oprc          
+                - 0: timestamps
+                - 1: tag_seedling
+                - 2: tag_fertilizer           
         Returns:
             Retorna una lista de diccionarios con la siguiente estructura
-            [{"id_db_h", },]
         """
 
     def __init__(self):
@@ -28,11 +25,6 @@ class TransformToOutputData(BaseEstimator, TransformerMixin):
             - features_list: Lista con los nombres de las columnas a extraer de los datos recibidos de cada operación.
         """
         self.is_fitted = False
-        self.positions = {"id_db_h":0,
-                          "id_db_dw":1,
-                          "tag_seedling":2,
-                          "tag_fertilizer":3,
-                          "date_oprc":4}
         
     def fit(self, X:np.array, y = None):
         """
@@ -40,21 +32,16 @@ class TransformToOutputData(BaseEstimator, TransformerMixin):
             - X: array con los datos de las operaciones clasificadas.
             Actualmente el array de dataToTransform es de (n,5) con las columnas siguientes
             
-                - 0: id_db_h
-                - 1: id_db_dw
-                - 2: tag_seedling
-                - 3: tag_fertilizer      
-                - 4: date_oprc          
+                - 0: timestamps
+                - 1: tag_seedling
+                - 2: tag_fertilizer       
         """
         self.is_fitted = True
-        keys = ["id_db_h", "id_db_dw", "tag_seedling", "tag_fertilizer", "date_oprc"]        
+        keys = ["timestamps","tag_seedling", "tag_fertilizer"]        
         self.temp_df = pd.DataFrame(X, columns = keys)
-        
-        date_data = X[:,4].astype(int)
-        date_oprc = np.array([datetime.datetime.fromtimestamp(date, datetime.timezone.utc) for date in date_data])
-        self.temp_df.loc[:,"date_oprc"] = date_oprc.flatten()
-        ##convierto las columnas "id_db_h", "id_db_dw", "tag_seedling" a int
-        for col in ["id_db_h", "id_db_dw", "tag_seedling"]:
+
+        ##convierto las columnas "timestamps", "tag_seedling" a int
+        for col in ["tag_seedling"]:
             self.temp_df[col] = self.temp_df[col].astype(float).astype(int)
         ##convierto la columna "tag_fertilizer" a float de y redondeo a 3 decimales
         self.temp_df["tag_fertilizer"] = self.temp_df["tag_fertilizer"].astype(float).round(3)
@@ -67,11 +54,9 @@ class TransformToOutputData(BaseEstimator, TransformerMixin):
             - X: array con los datos de las operaciones clasificadas.
             Actualmente el array de dataToTransform es de (n,5) con las columnas siguientes
             
-                - 0: id_db_h
-                - 1: id_db_dw
-                - 2: tag_seedling
-                - 3: tag_fertilizer      
-                - 4: date_oprc          
+                - 0: timestamps
+                - 1: tag_seedling
+                - 2: tag_fertilizer              
         Returns:
             Retorna una lista de diccionarios donde cada diccionario contiene los datos de una operación para los campos mencionados anteriormente.
         """
@@ -84,11 +69,9 @@ class TransformToOutputData(BaseEstimator, TransformerMixin):
             - X: array con los datos de las operaciones clasificadas.
             Actualmente el array de dataToTransform es de (n,5) con las columnas siguientes
             
-                - 0: id_db_h
-                - 1: id_db_dw
-                - 2: tag_seedling
-                - 3: tag_fertilizer      
-                - 4: date_oprc          
+                - 0: timestamps
+                - 1: tag_seedling
+                - 2: tag_fertilizer         
         Returns:
             Retorna una lista de diccionarios donde cada diccionario contiene los datos de una operación para los campos mencionados anteriormente.
         """

sarapy/stats/__init__.py

@@ -0,0 +1 @@
+# from stats.stats import *