sarapy 1.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

sarapy/dataProcessing/OpsProcessor.py

@@ -4,7 +4,7 @@ import datetime
 from dateutil.tz import tzutc
 import numpy as np
 import pandas as pd
-# from sarapy.mlProcessors import PlantinFMCreator
+from sarapy.mlProcessors import PlantinFMCreator
 from sarapy.mlProcessors import PlantinClassifier
 from sarapy.preprocessing import TransformInputData, TransformToOutputData
 
@@ -22,20 +22,27 @@ class OpsProcessor():
         """Constructor de la clase OpsProcessor.
         
         Args:
-            - distanciaMedia: Distancia media entre operaciones.
+            - kwargs: Diccionario con los argumentos necesarios instanciar algunas clases.
         """
 
-        plclass_map = {"classifier_file","imputeDistances", "distanciaMedia",
-                       "umbral_precision"," dist_mismo_lugar", "max_dist",
-                       "umbral_ratio_dCdP", "deltaO_medio"}
+        plclass_map = {"classifier_file"}
 
         kwargs_plclass = {}
         ##recorro kwargs y usando plclass_map creo un nuevo diccionario con los valores que se pasaron
         for key, value in kwargs.items():
             if key in plclass_map:
                 kwargs_plclass[key] = value
+
+        fmcreator_map = {"imputeDistances", "distanciaMedia", "umbral_precision",
+                         "dist_mismo_lugar", "max_dist", "umbral_ratio_dCdP", "deltaO_medio"}
+        fmcreator_kargs = {}
+        ##recorro kwargs y usando fmcreator_map creo un nuevo diccionario con los valores que se pasaron
+        for key, value in kwargs.items():
+            if key in fmcreator_map:
+                fmcreator_kargs[key] = value
         
         self._plantin_classifier = PlantinClassifier.PlantinClassifier(**kwargs_plclass)
+        self.plantinFMCreator = PlantinFMCreator.PlantinFMCreator(**fmcreator_kargs)
         # self._fertilizerFMCreator = FertilizerFMCreator() ## PARA IMPLEMENTAR
         
         self._operationsDict = {} ##diccionario de operarios con sus operaciones
@@ -45,7 +52,7 @@ class OpsProcessor():
         self.transformInputData = TransformInputData.TransformInputData()
         self.transformToOutputData = TransformToOutputData.TransformToOutputData()
         
-    def processOperations(self, data):
+    def processOperations(self, data, **kwargs):
         """Método para procesar las operaciones de los operarios.
 
         Se toma una nueva muestra y se procesa la información para clasificar las operaciones considerando el
@@ -68,6 +75,8 @@ class OpsProcessor():
                 "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.
             
         Returns:
             Lista de diccionarios con las clasificaciones. Cada diccionario tiene la forma
@@ -79,7 +88,7 @@ class OpsProcessor():
             newSample = self.transformInputData.fit_transform(data)
             #Si tenemos nuevas operaciones, actualizamos el diccionario de operaciones
             self.updateOperationsDict(newSample) #actualizamos diccionario interno de la clase
-            pl_clas = self.classifyForPlantin() #clasificamos las operaciones para plantín
+            pl_clas = self.classifyForPlantin(**kwargs) #clasificamos las operaciones para plantín
             ft_clas = newSample[:,7].astype(int) #clasificamos las operaciones para fertilizante
             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]
@@ -148,14 +157,27 @@ class OpsProcessor():
         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
 
-    def classifyForPlantin(self):
+    def classifyForPlantin(self, **kwargs):
         """Método para clasificar las operaciones para plantín.
         Se recorre el diccionario de operaciones y se clasifican las operaciones para plantín.
 
+        Args:
+            - kwargs: Diccionario con los argumentos necesarios para la clasificación. Se utiliza para pasar argumentos a los métodos de clasificación.
+
         Returns:
             - plantinClassifications: np.array con las clasificaciones de las operaciones para plantín.
         """
 
+        key_classify_map = {"feature_matrix", "update_samePlace",
+                            "useRatioStats", "std_weight", "useDistancesStats",
+                            "ratio_dcdp_umbral", "dist_umbral"}
+        
+        ##recorro kwargs y usando key_classify_map creo un nuevo diccionario con los valores que se pasaron
+        classify_kwargs = {}
+        for key, value in kwargs.items():
+            if key in key_classify_map:
+                classify_kwargs[key] = value
+
         ##creamos/reiniciamos el array con las clasificaciones de las operaciones para plantín
         plantinClassifications = None
         
@@ -165,7 +187,8 @@ class OpsProcessor():
         for ID_NPDP in ops_with_new_sample:#self.operationsDict.keys():
             ##clasificamos las operaciones para plantín
             operations = self.operationsDict[ID_NPDP]["sample_ops"]
-            classified_ops = self._plantin_classifier.classify(operations)
+            features, dst_pt, inest_pt = self.plantinFMCreator.fit_transform(operations)
+            classified_ops = self._plantin_classifier.classify(features, **classify_kwargs)
             
             ##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"]:
@@ -270,17 +293,26 @@ if __name__ == "__main__":
     import pandas as pd
     import numpy as np
     import os
-    from sarapy.utils.getRawOperations import getRawOperations
+    import sarapy.utils.getRawOperations as getRawOperations
+    from sarapy.dataProcessing import OpsProcessor
+
+    data_path = os.path.join(os.getcwd(), "examples\\2024-09-04\\UPM012N\\data.json")
+    historical_data_path = os.path.join(os.getcwd(), "examples\\2024-09-04\\UPM012N\\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")
 
-    data_df_raw = getRawOperations("examples\\2024-05-30\\UPM007N\\data.json", "examples\\2024-05-30\\UPM007N\\historical-data.json")
+    raw_ops = getRawOperations.getRawOperations(raw_data, raw_data2)
 
     import time
     start_time = time.time()
-    op = OpsProcessor(classifier_file="examples\\pip_lda_imp.pkl", imputeDistances = False)
-    classifcations = op.processOperations(data_df_raw)
+    op = OpsProcessor.OpsProcessor(classifier_file='modelos\\pipeline_rf.pkl', imputeDistances = False)
+    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")
     
-    print(len(classifcations))
-    classifcations[:10]
+    ##
+    df = pd.DataFrame(classifications)
+    tag_seedling = df["tag_seedling"].values
+    print(tag_seedling.mean())

sarapy/mlProcessors/PlantinClassifier.py

@@ -8,64 +8,138 @@ import pickle
 class PlantinClassifier(BaseEstimator, TransformerMixin):
     """Clase para implementar el pipeline de procesamiento de datos para la clasificación del tipo de operación para plantines."""
     
-    def __init__(self, classifier_file = "", **kwargs):
+    def __init__(self, classifier_file = ""):
         """Constructor de la clase PlantinClassifier.
         
         Args:
             - classifier_file: String con el nombre del archivo que contiene el clasificador entrenado. El archivo a cargar es un archivo .pkl.
         """
-        
-        plclass_map = {"imputeDistances", "distanciaMedia", "umbral_precision"," dist_mismo_lugar", "max_dist",
-                       "umbral_ratio_dCdP", "deltaO_medio"}
-        
-        kwargs_plfmc = {}
-        
-        ##recorro kwargs y usando plclass_map creo un nuevo diccionario con los valores que se pasaron
-        for key, value in kwargs.items():
-            if key in plclass_map:
-                kwargs_plfmc[key] = value
-        
-        self._plantinFMCreator = PlantinFMCreator.PlantinFMCreator(**kwargs_plfmc)
+
         #cargo el clasificador con pickle. Usamos try para capturar el error FileNotFoundError
         try:
             with open(classifier_file, 'rb') as file:
                 self._pipeline = pickle.load(file)
+            print("Clasificador cargado con éxito.")
         except FileNotFoundError:
             print("El archivo no se encuentra en el directorio actual.")
         
-    def classify(self, newData):
+    def classify(self, feature_matrix, update_samePlace:bool = True, **kwargs):
         """Genera la clasificación de las operaciones para plantines.
         
-        newData: Es un array con los datos (strings) provenientes de la base de datos histórica. La forma de newData debe ser (n,4). Las columnas de newData deben ser,
-                - 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
+        feature_matrix: Es un array con los datos (strings) provenientes de la base de datos histórica.
+        La forma de newData debe ser (n,3). Las columnas de newData deben ser,
+                - 1: deltaO
+                - 2: ratio_dCdP
+                - 3: distancias
+
+        kwargs: Diccionario con los argumentos necesarios para la clasificación.
+
+        NOTA: Estas características son necesarias en base a la última versión del modelo de clasificación.
         """
-        feature_matrix = self._plantinFMCreator.fit_transform(newData)
-        return self._pipeline.predict(feature_matrix)
+
+        self.clasificaiones = self._pipeline.predict(feature_matrix)
+
+        if update_samePlace:
+            self.grouped_ops = self.groupOpsSamePlace(feature_matrix, **kwargs)
+            self.clasificaiones = self.updateLabelsSamePlace(self.clasificaiones, self.grouped_ops)
+
+        return self.clasificaiones
     
-if __name__ == "__main__":
-    from sarapy.dataProcessing import OpsProcessor
+    def groupOpsSamePlace(self, X, useRatioStats = True, std_weight=1, useDistancesStats = True,
+                          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.
+        Se entiende por operación en el mismo lugar aquellas operaciones que tengan distancias entre sí menores a 0.5.
+        La función tomará las operaciones que tengan distancias menores a 0.5 y la operación anterior, dado que se supone que la 
+        operación anterior se corresponde a un nuevo sitio de plantado.
 
-    #cargo archivo examples\volcado_17112023_NODE_processed.csv
-    import pandas as pd
+        Las operaciones de limpieza son aquellas que tienen un ratio_dCdP menor a 0.3
+
+        Args:
+        - X: Array con las features de operaciones. Las columnas son deltaO, ratio_dCdP y distances.
+        - useRatioStats: Booleano para usar o no las estadísticas. Por defecto es True.
+        - std_weight: Peso para la desviación estándar. Por defecto es 1.
+        - ratio_dcdp_umbral: Umbral para el ratio_dCdP. Por defecto es 0.1.
+        - dist_umbral: Umbral para la distancia (en metros). Por defecto es 0.5.
+        
+        Retorna:
+        - Una lista con los índices de las operaciones agrupadas.
+        """
+
+        if useRatioStats:
+            median_ratio_dcdp = np.median(X[:,1])
+            std_ratio_dcdp = np.std(X[:,1])
+            ratio_dcdp_umbral = median_ratio_dcdp - std_weight*std_ratio_dcdp
+
+        if useDistancesStats:
+            median_dist = np.median(X[:,2])
+            # std_dist = np.std(X[:,2])
+            dist_umbral = median_dist #- std_weight*std_dist
+
+        ##recorro las operaciones y comparo la actual con la siguiente. Si la distancia es menor a 0.5, la agrupo.
+        ##Si el ratio_dCdP es menor a 0.3, la agrupo.
+        grouped_ops = []
+        distancias = X[:,2]
+        ratio_dcdp = X[:,1]
+        flag_cleaning = True
+        for i in range(1,X.shape[0]):
+            if flag_cleaning:
+                sub_group = []
+            if distancias[i] < dist_umbral and ratio_dcdp[i] < ratio_dcdp_umbral:
+                flag_cleaning = False
+                sub_group.append(i-1)
+                sub_group.append(i)
+            else:
+                flag_cleaning = True
+                if len(sub_group) > 0:
+                    grouped_ops.append(sub_group)
+
+        ##recorro grouped_ops y elimino los elementos que se repiten dentro de cada subgrupo y ordeno los indices dentro de cada subgrupo
+        for i in range(len(grouped_ops)):
+            grouped_ops[i] = list(set(grouped_ops[i]))
+            grouped_ops[i].sort()
+
+        return grouped_ops
+
+    def updateLabelsSamePlace(self, labels, ops_grouped):
+        """
+        Función para actualizar las etiquetas de las operaciones agrupadas en el mismo lugar.
+
+        Args:
+        - labels: Array con las etiquetas de las operaciones.
+        - indexes: Array con los índices correspondientes a operaciones repetidas
+        """
+        new_labels = labels.copy()
+        for indexes in ops_grouped:
+            new_labels[indexes[0]] = 1
+            new_labels[indexes[1:]] = 0
+
+        return new_labels
+    
+if __name__ == "__main__":
     import os
-    path = os.path.join(os.getcwd(), "examples\\volcado_17112023_NODE_processed.csv")
-    data_df = pd.read_csv(path, sep=";", )
-    raw_data = data_df.to_numpy().astype(str)
-
-    ##tomo raw_data y obtengo muestras de entre 7 a 15 filas una detrás de la otra. El valor de entre 7 y 15 es aleatorio.
-    sample = []
-    index = 0
-    while True:
-        random_value = np.random.randint(8, 15)
-        if index + random_value < len(raw_data):
-            sample.append(raw_data[index:index+random_value])
-        else:
-            break
-        index += random_value
-
-    plantin_classifier = PlantinClassifier(classifier_file="examples\\pip_lda_imp.pkl",imputeDistances = False)
-    plantin_classifier.classify(sample[50][:,2:])
+    import pandas as pd
+    import numpy as np
+    from sarapy.preprocessing import TransformInputData
+    from sarapy.mlProcessors import PlantinFMCreator
+    import sarapy.utils.getRawOperations as getRawOperations
+    from sarapy.mlProcessors import PlantinClassifier
+
+    fmcreator = PlantinFMCreator.PlantinFMCreator(imputeDistances=False)
+    tindata = TransformInputData.TransformInputData()
+
+    data_path = os.path.join(os.getcwd(), "examples\\2024-09-04\\UPM011N\\data.json")
+    historical_data_path = os.path.join(os.getcwd(), "examples\\2024-09-04\\UPM011N\\historical-data.json")
+    raw_data = pd.read_json(data_path, orient="records").to_dict(orient="records")
+    raw_data2 = pd.read_json(historical_data_path, orient="records").to_dict(orient="records")
+
+    raw_ops = np.array(getRawOperations.getRawOperations(raw_data, raw_data2))
+    raw_X = tindata.fit_transform(raw_ops)[:,2:]
+
+    X, dst_pt, inest_pt = fmcreator.fit_transform(raw_X)
+
+    rf_clf_nu = PlantinClassifier.PlantinClassifier(classifier_file='modelos\\pipeline_rf.pkl') ##wu = no update
+    rf_clf_wu = PlantinClassifier.PlantinClassifier(classifier_file='modelos\\pipeline_rf.pkl') ##wu = with update
+
+    print(rf_clf_nu.classify(X, update_samePlace = False).mean())
+    print(rf_clf_wu.classify(X, update_samePlace=True, useRatioStats=True, useDistancesStats=True).mean())

sarapy/mlProcessors/PlantinFMCreator.py

@@ -88,7 +88,7 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
         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  
-        precitions = X[:,4].astype(float) #precision del GPS   
+        # 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
@@ -106,32 +106,16 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
         ##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)
-        
-        ####***** IMPUTAMOS DATOS SI ES LO REQUERIDO*****
-        if self.imputeDistances:
-            distanceimputer = DistancesImputer.DistancesImputer(distanciaMedia = self.distanciaMedia,
-                                                                umbral_precision = self.umbral_precision,
-                                                                dist_mismo_lugar = self.dist_mismo_lugar,
-                                                                max_dist = self.max_dist,
-                                                                umbral_ratio_dCdP = self.umbral_ratio_dCdP,
-                                                                deltaO_medio = self.deltaO_medio, keepDims = False, columnToImpute = 0)
-            
-            X_distance_imputation = np.hstack((self._distances.reshape(-1, 1),
-                                            precitions.reshape(-1, 1),
-                                            self._tlmExtracted[:,self._tlmdeDP["GNSSFlag"]].reshape(-1, 1),
-                                            self._tlmExtracted[:,self._tlmdeDP["FIX"]].reshape(-1, 1),
-                                            self._timeDeltas[:,self._tpDP["deltaO"]].reshape(-1, 1),
-                                            self._timeDeltas[:,self._tpDP["ratio_dCdP"]].reshape(-1, 1)))
-            
-            self._distances = distanceimputer.fit_transform(X_distance_imputation)   
+
+        self.dst_pt = self._tlmExtracted[:,self._tlmdeDP["DSTRPT"]]
+        self.inest_pt = self._tlmExtracted[:,self._tlmdeDP["INESTPT"]]
         
         ##armamos la feature matrix
-        featureMatrix = np.vstack((self._tlmExtracted[:,self._tlmdeDP["DSTRPT"]],
-                                   self._timeDeltas[:,self._tpDP["deltaO"]],
-                                   self._timeDeltas[:,self._tpDP["ratio_dCdP"]],
-                                   self._distances)).T
+        self.featureMatrix = np.vstack((self._timeDeltas[:,self._tpDP["deltaO"]],
+                                        self._timeDeltas[:,self._tpDP["ratio_dCdP"]],
+                                        self._distances)).T
         
-        return featureMatrix
+        return self.featureMatrix, self.dst_pt, self.inest_pt
 
     def fit_transform(self, X: np.array, y=None):
         """Fittea y transforma los datos de X en la matriz de características.
@@ -176,18 +160,23 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
     
         
 if __name__ == "__main__":
-    ##genero objeto FMCreator
-    fmcreator = PlantinFMCreator(imputeDistances=False)
-    import pandas as pd
     import os
-    path = os.path.join(os.getcwd(), "examples\\volcado_17112023_NODE_processed.csv")
-    raw_data = pd.read_csv(path, sep=";", ).to_numpy()
+    import pandas as pd
+    import numpy as np
+    from sarapy.preprocessing import TransformInputData
+    from sarapy.mlProcessors import PlantinFMCreator
+    import sarapy.utils.getRawOperations as getRawOperations
 
-    X = raw_data[50:60,2:]
-    fmcreator.fit(X)
-    fm = fmcreator.fit_transform(X)
-    print(fm)
-    print(fm.shape)
-    
-    X2 = raw_data[60:81,2:]
-    fmcreator.transform(X2).shape
+    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")
+
+    raw_ops = np.array(getRawOperations.getRawOperations(raw_data, raw_data2))
+    X = tindata.fit_transform(raw_ops)
+
+    fm, dst_pt, inest_pt = fmcreator.fit_transform(X[:,2:])  

sarapy/preprocessing/TransformInputData.py

@@ -100,7 +100,11 @@ if __name__ == "__main__":
     
     transform_input_data = TransformInputData()
 
-    ppk_results = getRawOperations("examples\\2024-05-30\\UPM007N\\data.json", "examples\\2024-05-30\\UPM007N\\historical-data.json")
+    #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")
+
+    ppk_results = getRawOperations(data,historical_data)
 
     X = np.array(ppk_results)
     print(transform_input_data.fit_transform(X))

sarapy/preprocessing/TransformToOutputData.py

@@ -8,7 +8,7 @@ class TransformToOutputData(BaseEstimator, TransformerMixin):
         
         Args:
             - dataToTransform: array con los datos de las operaciones clasificadas.
-            Actualmente el array de dataToTransform es de (n,4) con las columnas siguientes
+            Actualmente el array de dataToTransform es de (n,5) con las columnas siguientes
             
                 - 0: id_db_h
                 - 1: id_db_dw
@@ -36,6 +36,15 @@ class TransformToOutputData(BaseEstimator, TransformerMixin):
         
     def fit(self, X:np.array, y = None):
         """
+        Args:
+            - 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          
         """
         self.is_fitted = True
         keys = ["id_db_h", "id_db_dw", "tag_seedling", "tag_fertilizer", "date_oprc"]        
@@ -45,19 +54,41 @@ class TransformToOutputData(BaseEstimator, TransformerMixin):
         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", "tag_fertilizer" a int
-        self.temp_df.loc[:,["id_db_h", "id_db_dw", "tag_seedling", "tag_fertilizer"]] = self.temp_df.loc[:,["id_db_h", "id_db_dw", "tag_seedling", "tag_fertilizer"]].astype(int)
-        
+        for col in ["id_db_h", "id_db_dw", "tag_seedling", "tag_fertilizer"]:
+            self.temp_df[col] = self.temp_df[col].astype(float).astype(int)
+
         return self
     
     def transform(self, X:np.array):
         """
-        Retorna los datos de entrada a un formato utilizable para procesar las operaciones.
+        Args:
+            - 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          
+        Returns:
+            Retorna una lista de diccionarios donde cada diccionario contiene los datos de una operación para los campos mencionados anteriormente.
         """
 
         return self.temp_df.to_dict(orient = "records")
     
     def fit_transform(self, X:np.array, y = None):
         """
+        Args:
+            - 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          
+        Returns:
+            Retorna una lista de diccionarios donde cada diccionario contiene los datos de una operación para los campos mencionados anteriormente.
         """
         self.fit(X)
         return self.transform(X)

sarapy/utils/amg_decoder.py

@@ -0,0 +1,125 @@
+from dateutil import parser
+
+
+"""
+En 'estructura_datos' se registra cuantos bits se ocupan para cada dato.
+Por ejemplo, los primeros 6 bits para anio, los siguientes 4 para mes y asi.
+"""
+
+estructura_datos = {
+    "anio": 6,
+    "mes": 4,
+    "dia": 5,
+    "hora": 5,
+    "minutos": 6,
+    "segundos": 6,
+    "operacion": 16,
+    "PT": 2,
+    "FR": 2,
+    "OR": 2,
+    "MO": 2,
+    "TLM_NPDP": 64,
+    "TLM_GPDP": 16,
+    "ID_NPDP": -1,
+    "ID_OPRR": -1,
+    "ID_GPDP": -1,
+    "ID_CDLL": -1,
+    "size_GNSS": 16,
+    "Latitud": 32,
+    "Longitud": 32,
+    "Precision": 32,  
+}  # Agregar mas campos segun sea necesario
+
+
+def extraer_bits(trama, inicio, n_bits):
+    try:
+        byte_index = inicio // 8
+        bit_offset = inicio % 8
+
+        valor = 0
+        bits_procesados = 0
+        while bits_procesados < n_bits:
+            byte_actual = trama[byte_index]
+            bits_restantes = n_bits - bits_procesados
+            bits_a_extraer = min(bits_restantes, 8 - bit_offset)
+
+            mascara = (1 << bits_a_extraer) - 1
+            bits_extraidos = (byte_actual >> (8 - bit_offset - bits_a_extraer)) & mascara
+
+            valor = (valor << bits_a_extraer) | bits_extraidos
+
+            bits_procesados += bits_a_extraer
+            byte_index += 1
+            bit_offset = 0
+
+        return valor
+    except IndexError as ex:
+        raise ex
+    except Exception as ex:
+        print(f"Error inesperado en extraer_bits: {ex}")
+        raise ex
+
+
+def process_dynamic_id(trama, inicio):
+    # Lee el primer byte para determinar la longitud del ID
+    longitud_id_bytes = extraer_bits(trama, inicio, 8)  # 8 bits = 1 byte
+    inicio += 8  # Avanza el indice de inicio 8 bits para pasar al contenido del ID
+
+    # Ahora, extrae el ID basandose en la longitud obtenida
+    id_value = extraer_bits(trama, inicio, longitud_id_bytes * 8)  # Convierte la longitud a bits
+    inicio += longitud_id_bytes * 8  # Avanza el indice de inicio para pasar al final del ID
+
+    return id_value, inicio
+
+
+def process_data(trama):
+    
+    if not isinstance(trama, bytes):
+        raise ValueError("La trama debe ser un bytearray")
+    
+    inicio = 0
+    resultado = {}
+    for campo, n_bits in estructura_datos.items():
+        try:
+            if n_bits == -1:  # Verifica si el campo es dinamico
+                resultado[campo], inicio = process_dynamic_id(trama, inicio)
+            else:
+                if campo == "TLM_NPDP" or campo == "TLM_GPDP":
+                    resultado[campo] = trama[inicio // 8: (inicio + n_bits) // 8]
+                else:
+                    resultado[campo] = extraer_bits(trama, inicio, n_bits)  
+                inicio += n_bits
+            if campo == "Precision":
+                # Suponiendo que size_GNSS sigue inmediatamente despues de Precision
+                raw = trama[inicio // 8: (inicio // 8 ) + resultado["size_GNSS"] - 12]
+                resultado["RAW"] = raw
+        except IndexError as ex:
+            print(f"Error al procesar campo {campo}: {ex}. Posiblemente la trama es mas corta de lo esperado.")
+            break  # Salir del bucle en caso de un error de indice
+        except Exception as ex:
+            print(f"Error inesperado al procesar campo {campo}: {ex}")
+            break  # Salir del bucle en caso de errores inesperados
+    
+    if len(set(estructura_datos.keys()) - set(resultado.keys())) == 0:
+    
+        anio = 2020 + resultado["anio"]
+        mes = str(resultado["mes"]).zfill(2)
+        dia = str(resultado["dia"]).zfill(2)
+        hora = str(resultado["hora"]).zfill(2)
+        minutos = str(resultado["minutos"]).zfill(2)
+        segundos = str(resultado["segundos"]).zfill(2)
+        resultado["date_oprc"] = parser.parse(f"{anio}-{mes}-{dia}T{hora}:{minutos}:{segundos}+00:00")
+        
+        resultado["Latitud"] = (resultado["Latitud"] - 2 ** 32) / 10 ** 7
+        resultado["Longitud"] = (resultado["Longitud"] - 2 ** 32) / 10 ** 7
+        
+        del resultado["anio"]
+        del resultado["mes"]
+        del resultado["dia"]
+        del resultado["hora"]
+        del resultado["minutos"]
+        del resultado["segundos"]
+        del resultado["size_GNSS"]
+        
+        return resultado
+

sarapy/utils/amg_ppk.py

@@ -0,0 +1,38 @@
+from base64 import b64decode
+
+from sarapy.utils import amg_decoder
+
+
+def main(hash_table, ppk_data):
+
+    ppk_results = []
+
+    for hash_table_entry_values in hash_table.values():
+
+        try:
+
+            serialized_datum = hash_table_entry_values["serialized_datum"]
+            raw_datum = bytes(b64decode(serialized_datum.encode("utf-8")))  # 'trama'
+            datum = amg_decoder.process_data(raw_datum)
+
+            if datum:
+
+                longitude, latitude, accuracy = "", "", 0  # ToDo: PPK (Fernando)
+
+                if longitude:
+                    datum["Longitud"] = longitude
+                if latitude:
+                    datum["Latitud"] = latitude
+                if accuracy != 0:
+                    datum["Precision"] = accuracy
+
+                ppk_results.append({
+                    "id_db_dw": hash_table_entry_values["id_db_dw"],
+                    "id_db_h": hash_table_entry_values["id_db_h"],
+                    **datum
+                })
+
+        except Exception as ex:
+            print(ex)
+
+    return ppk_results

sarapy/utils/getRawOperations.py

@@ -0,0 +1,20 @@
+import pandas as pd
+from sarapy.utils import amg_ppk
+import os
+def getRawOperations(data, historical_data):
+    """
+    Args:
+        data_file: Lista de diccionarios con la data
+        historical_data_file: Lista de diccionarios con historical_data
+
+    Returns the raw operations from the database.
+    """
+    hash_table = {}
+    for datum in data:
+        hash_table[datum["timestamp"]] = {"id_db_dw": datum["id"], "id_db_h": 0, "serialized_datum": ""}
+    for historical_datum in historical_data:
+        if historical_datum["timestamp"] in hash_table:
+            hash_table[historical_datum["timestamp"]].update({"id_db_h": historical_datum["id"], "serialized_datum": historical_datum["datum"]})
+    ppk_results = amg_ppk.main(hash_table, [])  # ToDo: PPK (Fernando)
+
+    return ppk_results

sarapy/version.py

@@ -1,2 +1,2 @@
 ## Version of the package   
-__version__ = "1.0.0"
+__version__ = "1.1.0"

{sarapy-1.0.0.dist-info → sarapy-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sarapy
-Version: 1.0.0
+Version: 1.1.0
 Home-page: https://github.com/lucasbaldezzari/sarapy
 Author: Lucas Baldezzari
 Author-email: Lucas Baldezzari <lmbaldezzari@gmail.com>
@@ -19,6 +19,17 @@ Requires-Dist: geopy
 
 Library for processing SARAPICO project metadata of _AMG_.
 
+#### Version 1.1.0
+
+Versión 1.1 estable para trabajarse en servidor.
+
+- Se implementa nueva estrategia para la clasificación de plantines.
+
+
+#### Version 1.0.1
+
+- Se agrega *__init.py__* dentro del mpdulo _utils_.
+
 #### Version 1.0.0
 
 - Se crean clases TransformInputData y TransformToOuputData dentro del módulo proprocessing. Se crean utils.

sarapy-1.1.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+sarapy/__init__.py,sha256=aVoywqGSscYYDycLaYJnz08dlQabl9gH0h4Q5KtHM9o,74
+sarapy/version.py,sha256=s61q4qMKCUuPCPfTUqwvvIijwHBDiVMOFSU6VmU1ArI,51
+sarapy/dataProcessing/GeoProcessor.py,sha256=YeNFHZ5sArnSLDxz009SJzgdWuMPgvJPkqtwcivk87A,4654
+sarapy/dataProcessing/OpsProcessor.py,sha256=-mxZPA7V6r7xkkQBICmNBiT7FJGVs3C3D-DaPN34yHE,16433
+sarapy/dataProcessing/TLMSensorDataProcessor.py,sha256=GfSIRYD_biFlOMTfSQSwW0HsUouZuUL3ScvL4uUHTPQ,23824
+sarapy/dataProcessing/TimeSeriesProcessor.py,sha256=QPvg9vyPSWjVl020zbebqvlM9JnL1uEAuACRsfZweAg,5497
+sarapy/dataProcessing/__init__.py,sha256=Kqs5sFtq6RMEa3KLJFbsGRoYsIxHL1UUGMuplyCyQFk,200
+sarapy/dataProcessing/amg_decoder.py,sha256=JZ7cbu7DlCuatuq2F7aBfUr7S7U-K5poBgxw5nY6rNI,4319
+sarapy/mlProcessors/PlantinClassifier.py,sha256=ahoDIgxfKiq0sMm4dR1M4rLO-J6SxDMrASjlmswj3QI,6781
+sarapy/mlProcessors/PlantinFMCreator.py,sha256=PiDFCW7LQ00OTT0lqHwv03yVfqylHYz-7fPCxWnx5yk,8999
+sarapy/mlProcessors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sarapy/preprocessing/DistancesImputer.py,sha256=NvbVAh5m0yFxVgDbEFnEX7RSG13qLjO7i2gqjDAWsf4,9106
+sarapy/preprocessing/FertilizerImputer.py,sha256=zK6ONAilwPHvj-bC7yxnQYOkDBCCkWh6__57vYK9anM,1490
+sarapy/preprocessing/TransformInputData.py,sha256=wDwyg4U-jgTqvNUFngsmhSKwyhoIyVWlhezEhhPf2qE,4090
+sarapy/preprocessing/TransformToOutputData.py,sha256=REQX1d57bCqS3l9dh1m7ybJ-WSX1BGFzweojWMHar8A,3788
+sarapy/preprocessing/__init__.py,sha256=Wg_Csy8Xiz8BN8A4-T7iPwcL_ol5ApEx6YtybItKB8M,100
+sarapy/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sarapy/utils/amg_decoder.py,sha256=JZ7cbu7DlCuatuq2F7aBfUr7S7U-K5poBgxw5nY6rNI,4319
+sarapy/utils/amg_ppk.py,sha256=c0GusnxdntU-E0JOezzbIfC7SWoJmKAbad_zYDCJ3-c,1060
+sarapy/utils/getRawOperations.py,sha256=8aA1fIkNCnUYgiWfnFggRT_U35z432gZBrZ7seGO5w4,817
+sarapy-1.1.0.dist-info/LICENCE,sha256=N00sU3vSQ6F5c2vML9_qP4IFTkCPFFj0YGDB2CZP-uQ,840
+sarapy-1.1.0.dist-info/METADATA,sha256=oIu6w2r9Yj0EH0aiYLIPmTLarsGTK9ZpqKBXYbGDHWw,2568
+sarapy-1.1.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+sarapy-1.1.0.dist-info/top_level.txt,sha256=4mUGZXfX2Fw47fpY6MQkaJeuOs_8tbjLkkNp34DJWiA,7
+sarapy-1.1.0.dist-info/RECORD,,

sarapy-1.0.0.dist-info/RECORD

@@ -1,21 +0,0 @@
-sarapy/__init__.py,sha256=aVoywqGSscYYDycLaYJnz08dlQabl9gH0h4Q5KtHM9o,74
-sarapy/version.py,sha256=BwwbbQmaXV3f3NFM7cC4RWEuaju9GRSv_mfol3KcUwg,51
-sarapy/dataProcessing/GeoProcessor.py,sha256=YeNFHZ5sArnSLDxz009SJzgdWuMPgvJPkqtwcivk87A,4654
-sarapy/dataProcessing/OpsProcessor.py,sha256=NNEI2F6TtaxU8sHAr3yjo7nfsZ4hlGx8umb6VDnrPa4,14607
-sarapy/dataProcessing/TLMSensorDataProcessor.py,sha256=GfSIRYD_biFlOMTfSQSwW0HsUouZuUL3ScvL4uUHTPQ,23824
-sarapy/dataProcessing/TimeSeriesProcessor.py,sha256=QPvg9vyPSWjVl020zbebqvlM9JnL1uEAuACRsfZweAg,5497
-sarapy/dataProcessing/__init__.py,sha256=Kqs5sFtq6RMEa3KLJFbsGRoYsIxHL1UUGMuplyCyQFk,200
-sarapy/dataProcessing/amg_decoder.py,sha256=JZ7cbu7DlCuatuq2F7aBfUr7S7U-K5poBgxw5nY6rNI,4319
-sarapy/mlProcessors/PlantinClassifier.py,sha256=KI8xqBTsJb1dwNgqM5Z8w1kgU74ahwJSJ5CHbYfIlG8,3289
-sarapy/mlProcessors/PlantinFMCreator.py,sha256=5E3ueTdluGsBfDiDVilQCbxnDH6Y9OxQIbFokB83fy0,9751
-sarapy/mlProcessors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sarapy/preprocessing/DistancesImputer.py,sha256=NvbVAh5m0yFxVgDbEFnEX7RSG13qLjO7i2gqjDAWsf4,9106
-sarapy/preprocessing/FertilizerImputer.py,sha256=zK6ONAilwPHvj-bC7yxnQYOkDBCCkWh6__57vYK9anM,1490
-sarapy/preprocessing/TransformInputData.py,sha256=UPdb9vQpMBLQNZX_4tP2bl3s-nQ5y3oDgQ8kYr0rzlA,3898
-sarapy/preprocessing/TransformToOutputData.py,sha256=h4QsIFYde4w-8UxdQvNYpb5VTFeCz1oRwgxK3Rs44nI,2454
-sarapy/preprocessing/__init__.py,sha256=Wg_Csy8Xiz8BN8A4-T7iPwcL_ol5ApEx6YtybItKB8M,100
-sarapy-1.0.0.dist-info/LICENCE,sha256=N00sU3vSQ6F5c2vML9_qP4IFTkCPFFj0YGDB2CZP-uQ,840
-sarapy-1.0.0.dist-info/METADATA,sha256=umG5dvUMzbpgf2spOAxO4Z2o_5xAzjniecOZpOT4ayQ,2340
-sarapy-1.0.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-sarapy-1.0.0.dist-info/top_level.txt,sha256=4mUGZXfX2Fw47fpY6MQkaJeuOs_8tbjLkkNp34DJWiA,7
-sarapy-1.0.0.dist-info/RECORD,,