sarapy 0.4.4__tar.gz → 0.4.6__tar.gz

{sarapy-0.4.4 → sarapy-0.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sarapy
-Version: 0.4.4
+Version: 0.4.6
 Home-page: https://github.com/lucasbaldezzari/sarapy
 Author: Lucas Baldezzari
 Author-email: Lucas Baldezzari <lmbaldezzari@gmail.com>
@@ -18,6 +18,15 @@ Requires-Dist: geopy
 
 Library for processing SARAPICO project metadata of _AMG_.
 
+#### Version 0.4.6
+
+- Se agrega función OpsProcessor.transformInputData() para convertir la lista de diccionarios entregadas por el decoder a un array de strings necesarios para procesar y clasificar los datos.
+
+#### Version 0.4.5
+
+- Se modifica clase PlantinClassifier para que ahora tome un clasificador y lo use para clasificar operaciones.
+- Se modifica OpsProcessor para poder obtener clasificaciones (y no matrices de características de plantin como se venía probando).
+
 #### Version 0.4.4
 
 - Se modifica fit() de PlantinFMCreator.

{sarapy-0.4.4 → sarapy-0.4.6}/README.md

@@ -2,6 +2,15 @@
 
 Library for processing SARAPICO project metadata of _AMG_.
 
+#### Version 0.4.6
+
+- Se agrega función OpsProcessor.transformInputData() para convertir la lista de diccionarios entregadas por el decoder a un array de strings necesarios para procesar y clasificar los datos.
+
+#### Version 0.4.5
+
+- Se modifica clase PlantinClassifier para que ahora tome un clasificador y lo use para clasificar operaciones.
+- Se modifica OpsProcessor para poder obtener clasificaciones (y no matrices de características de plantin como se venía probando).
+
 #### Version 0.4.4
 
 - Se modifica fit() de PlantinFMCreator.

{sarapy-0.4.4 → sarapy-0.4.6}/pyproject.toml

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

{sarapy-0.4.4 → sarapy-0.4.6}/sarapy/dataProcessing/OpsProcessor.py

@@ -4,7 +4,6 @@ import numpy as np
 # from sarapy.mlProcessors import PlantinFMCreator
 from sarapy.mlProcessors import PlantinClassifier
 
-
 class OpsProcessor():
     """Clase para procesar las operaciones de los operarios. La información se toma de la base de datos
     hostórica y se procesa para obtener un array con las operaciones clasificadas para cada operario.
@@ -22,8 +21,10 @@ class OpsProcessor():
             - distanciaMedia: Distancia media entre operaciones.
         """
 
-        plclass_map = {"imputeDistances", "distanciaMedia", "umbral_precision"," dist_mismo_lugar", "max_dist",
+        plclass_map = {"classifier_file","imputeDistances", "distanciaMedia",
+                       "umbral_precision"," dist_mismo_lugar", "max_dist",
                        "umbral_ratio_dCdP", "deltaO_medio"}
+
         kwargs_plclass = {}
         ##recorro kwargs y usando plclass_map creo un nuevo diccionario con los valores que se pasaron
         for key, value in kwargs.items():
@@ -37,7 +38,7 @@ class OpsProcessor():
         self._classifiedOperations = np.array([]) ##array con las operaciones clasificadas
         self._last_row_db = 0 ##indicador de la última fila de los datos extraidos de la base de datos histórica
         
-    def processOperations(self, newSample):
+    def processOperations(self, data):
         """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
@@ -45,20 +46,25 @@ class OpsProcessor():
         Se retorna un array con las clasificaciones concatenadas, manteniendo el orden de las operaciones por operario.
         
         Args:
-            - newSample: lista con los datos (numpy.array de strings) de una muestra de operaciones.
-            La forma de cada dato dentro de la lista newSample es (n,6). Las columnas de newSample son,
+            data: Es una lista de diccionario. Cada diccionario tiene los siguientes keys.
             
-                - 0: op_number
-                - 1: id_oprr
-                - 2: tlm_spbb
-                - 3: date_oprc
-                - 4: lat
-                - 5: lon
-                - 6: precision
+            id_db, ID_NPDB, TLM_SPBB, date_oprc, latitud, longitud, precision
+            
+            Ejemplo:
+            
+            {"id_db":"1", "ID_NPDB":"XXAA123",
+            "TLM_SPBB": "1010001000010010101100010110000111101101001100000000000000000000",
+            "date_oprc":"2024-02-17 12:33:20",
+            "Latitud":"-32.145564789", "Longitud":"-55.145564789", "Precision": "0.25"}
+            
+        Returns:
+            Lista de diccionarios con las clasificaciones. Cada diccionario tiene la forma
+            {"id_db": 10, "tag_seedling": 1, "tag_fertilizer": 1}
         """
         
         ##chqueo que newSample no esté vacío
-        if len(newSample) != 0:
+        if len(data) != 0:
+            newSample = self.transformInputData(data)
             #Si tenemos nuevas operaciones, actualizamos el diccionario de operaciones
             self.updateOperationsDict(newSample) #actualizamos diccionario interno de la clase
             plantinClassifications = self.classifyForPlantin() #clasificamos las operaciones para plantín
@@ -77,12 +83,12 @@ class OpsProcessor():
             - 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: op_number
-                - 1: id_oprr
-                - 2: tlm_spbb
+                - 0: id_db
+                - 1: ID_NPDP
+                - 2: TLM_SPBB
                 - 3: date_oprc
-                - 4: lat
-                - 5: lon
+                - 4: latitud
+                - 5: longitud
                 - 6: precision
                 
         Returns:
@@ -91,36 +97,36 @@ class OpsProcessor():
             DE MANERA CORRECTA O HUBO ALGÚN PROBLEMA Y ASÍ VER QUÉ HACER EN EL MAIN
         """
         
-        id_oprrs_w_newOperations = np.unique(newSample[:,1]) ##identificadores de operarios con nuevas operaciones en la muestra
+        ID_NPDPs_w_newOperations = np.unique(newSample[:,1]) ##identificadores de operarios con nuevas operaciones en la muestra
         
-        ##chqueo si estos id_oprrs ya están en el diccionario, sino los agrego
-        for id_oprr in id_oprrs_w_newOperations:
-            if id_oprr not in self._operationsDict:
+        ##chqueo si estos ID_NPDPs ya están en el diccionario, sino los agrego
+        for ID_NPDP in ID_NPDPs_w_newOperations:
+            if ID_NPDP not in self._operationsDict:
                 #El diccionario contiene la siguiente información:
-                #sample_ops: np.array con las columnas de tlm_spbb, date_oprc, lat, lon, precision
-                #last_oprc: np.array de la última operación con las columnas de tlm_spbb, date_oprc, lat, lon, precision
+                #sample_ops: np.array con las columnas de TLM_SPBB, date_oprc, lat, lon, precision
+                #last_oprc: np.array de la última operación con las columnas de TLM_SPBB, date_oprc, lat, lon, precision
                 #first_day_op_classified: booleano para saber si es la primera operación del día fue clasificada
-                self._operationsDict[id_oprr] = {"sample_ops": None,
+                self._operationsDict[ID_NPDP] = {"sample_ops": None,
                                                  "last_oprc": None, 
                                                  "first_day_op_classified": False,
                                                  "new_sample": False,
                                                  "ops_numbers": None} #inicio del diccionario anidado para el nuevo operario
                 
         ##actualizo el diccionario con las operaciones nuevas para aquellos operarios que correspondan
-        for id_oprr in id_oprrs_w_newOperations:
-            sample_ops = newSample[newSample[:,1] == id_oprr][:,2:] #me quedo con las columnas de tlm_spbb, date_oprc, lat, lon, precision
-            ops_numbers = newSample[newSample[:,1] == id_oprr][:,0]
+        for ID_NPDP in ID_NPDPs_w_newOperations:
+            sample_ops = newSample[newSample[:,1] == ID_NPDP][:,2:] #me quedo con las columnas de TLM_SPBB, date_oprc, lat, lon, precision
+            ops_numbers = newSample[newSample[:,1] == ID_NPDP][:,0]
             ##actualizo el diccionario
-            self._operationsDict[id_oprr]["sample_ops"] = sample_ops
-            self._operationsDict[id_oprr]["ops_numbers"] = ops_numbers
+            self._operationsDict[ID_NPDP]["sample_ops"] = sample_ops
+            self._operationsDict[ID_NPDP]["ops_numbers"] = ops_numbers
             ##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_oprr]["last_oprc"]
+            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_oprr]["sample_ops"] = np.vstack((last_op, sample_ops))
+                self._operationsDict[ID_NPDP]["sample_ops"] = np.vstack((last_op, sample_ops))
                 
-        self.updateNewSamplesValues(id_oprrs_w_newOperations) #actualizo el estado de 'new_sample' en el diccionario de operaciones
-        self.updateLastOperations(id_oprrs_w_newOperations) #actualizo la última operación de una muestra de operaciones en el diccionario de operaciones
+        self.updateNewSamplesValues(ID_NPDPs_w_newOperations) #actualizo el estado de 'new_sample' en el diccionario de operaciones
+        self.updateLastOperations(ID_NPDPs_w_newOperations) #actualizo la última operación de una muestra de operaciones en el diccionario de operaciones
 
     def classifyForPlantin(self):
         """Método para clasificar las operaciones para plantín.
@@ -133,90 +139,135 @@ class OpsProcessor():
         ##creamos/reiniciamos el array con las clasificaciones de las operaciones para plantín
         plantinClassifications = None
         
-        ##me quedo con los id_oprrs que tengan _operationsDict[id_oprr]["new_sample"] iguales a True
-        ops_with_new_sample = [id_oprr for id_oprr in self.operationsDict.keys() if self.operationsDict[id_oprr]["new_sample"]]
+        ##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"]]
 
-        for id_oprr in ops_with_new_sample:#self.operationsDict.keys():
+        for ID_NPDP in ops_with_new_sample:#self.operationsDict.keys():
             ##clasificamos las operaciones para plantín
-            operations = self.operationsDict[id_oprr]["sample_ops"]
+            operations = self.operationsDict[ID_NPDP]["sample_ops"]
             classified_ops = self._plantin_classifier.classify(operations)
             
             ##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_oprr]["first_day_op_classified"]:
+            if self.operationsDict[ID_NPDP]["first_day_op_classified"]:
                 classified_ops = classified_ops[1:]
                 
-            plantinClassifications = np.vstack((plantinClassifications, classified_ops)) if plantinClassifications is not None else classified_ops
-                
-            self.operationsDict[id_oprr]["first_day_op_classified"] = True
+            # 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
 
         return plantinClassifications
             
-    def updateLastOperations(self, id_oprrs_w_newOperations):
+    def updateLastOperations(self, ID_NPDPs_w_newOperations):
         """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: op_number
-                - 1: id_oprr
-                - 2: tlm_spbb
+                - 0: id_db
+                - 1: ID_NPDP
+                - 2: TLM_SPBB
                 - 3: date_oprc
-                - 4: lat
-                - 5: lon
+                - 4: latitud
+                - 5: longitud
                 - 6: precision
         """
         
-        for id_oprr in id_oprrs_w_newOperations:
-            self._operationsDict[id_oprr]["last_oprc"] = self._operationsDict[id_oprr]["sample_ops"][-1]
+        for ID_NPDP in ID_NPDPs_w_newOperations:
+            self._operationsDict[ID_NPDP]["last_oprc"] = self._operationsDict[ID_NPDP]["sample_ops"][-1]
 
     def updateOperationsNumbers(self, new_ops_numbers):
         """Método para actualizar los números de operaciones en el diccionario de operaciones.
 
         Args:
-            - new_ops_numbers: array de la forma (n,2) con los números de operaciones en la primer columna y los id_oprrs en la segunda.
+            - new_ops_numbers: array de la forma (n,2) con los números de operaciones en la primer columna y los ID_NPDPs en la segunda.
         """
-        id_oprrs_w_newOperations = np.unique(new_ops_numbers[:,1]) ##identificadores de operarios con nuevas operaciones en la muestra
+        ID_NPDPs_w_newOperations = np.unique(new_ops_numbers[:,1]) ##identificadores de operarios con nuevas operaciones en la muestra
         opsNumbersList = np.array([]) ##array con los números de operaciones
 
-        for id_oprr in id_oprrs_w_newOperations:
-            opsNumbersList = np.append(opsNumbersList, self.operationsDict[id_oprr]["ops_numbers"].flatten())
+        for ID_NPDP in ID_NPDPs_w_newOperations:
+            opsNumbersList = np.append(opsNumbersList, self.operationsDict[ID_NPDP]["ops_numbers"].flatten())
 
         return opsNumbersList
     
-    def updateNewSamplesValues(self, id_oprrs_w_newOperations):
+    def updateNewSamplesValues(self, ID_NPDPs_w_newOperations):
         """Método para actualizar el estado de 'new_sample' del diccionario de operaciones.
 
         Args:
-            - id_oprrs_w_newOperations: lista con los id_oprrs que tienen nuevas operaciones.
+            - ID_NPDPs_w_newOperations: lista con los ID_NPDPs que tienen nuevas operaciones.
         """
 
         ##recorro el diccionario de operaciones y actualizo el estado de 'new_sample' a
-        ##True para los id_oprrs que tienen nuevas operaciones y a False para los que no tienen nuevas operaciones
-        for id_oprr in self.operationsDict.keys():
-            if id_oprr in id_oprrs_w_newOperations:
-                self._operationsDict[id_oprr]["new_sample"] = True
+        ##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():
+            if ID_NPDP in ID_NPDPs_w_newOperations:
+                self._operationsDict[ID_NPDP]["new_sample"] = True
             else:
-                self._operationsDict[id_oprr]["new_sample"] = False
+                self._operationsDict[ID_NPDP]["new_sample"] = False
     
     def resetAllNewSamplesValues(self):
         """Método para resetar todos los valores de new_sample en el diccionario de operaciones.
         """
         
-        for id_oprr in self.operationsDict.keys():
-            self._operationsDict[id_oprr]["new_sample"] = False
+        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."""
 
         opsNumbersList = np.array([])
-        for id_oprr in self.operationsDict.keys():
-            if self.operationsDict[id_oprr]["new_sample"]:
-                opsNumbersList = np.append(opsNumbersList, self.operationsDict[id_oprr]["ops_numbers"].flatten())
+        for ID_NPDP in self.operationsDict.keys():
+            if self.operationsDict[ID_NPDP]["new_sample"]:
+                opsNumbersList = np.append(opsNumbersList, self.operationsDict[ID_NPDP]["ops_numbers"].flatten())
 
         return opsNumbersList
+    
+    def updateFirstDayOp(self):
+        """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():
+            self._operationsDict[ID_NPDP]["first_day_op_classified"] = False
+            
+    def transformInputData(self, data):
+        """Función para transformar los datos de entrada que llegan del decoder
+        
+        Args:
+            data: Es una lista de diccionario. Cada diccionario tiene los siguientes keys.
+            
+            id_db, ID_NPDB, TLM_SPBB, date_oprc, latitud, longitud, precision
+            
+            Ejemplo:
+            
+            {"id_db":"1", "ID_NPDB":"XXAA123",
+            "TLM_SPBB": "1010001000010010101100010110000111101101001100000000000000000000",
+            "date_oprc":"2024-02-17 12:33:20",
+            "Latitud":"-32.145564789", "Longitud":"-55.145564789", "Precision": "0.25"}
+        
+        Returns:
+            Retorna un array de strings con la siguiente estructura
+            - 0: id_db
+            - 1: ID_NPDP
+            - 2: TLM_SPBB
+            - 3: date_oprc
+            - 4: latitud
+            - 5: longitud
+            - 6: precision
+        """
+    
+        ##convierto list_of_dics a un array de strings
+        newSample = np.array([[d["id_db"],
+                            d["ID_NPDB"],
+                            d["TLM_SPBB"],
+                            d["date_oprc"],
+                            d["Latitud"],
+                            d["Longitud"],
+                            d["precision"]] for d in data])
+        
+        return newSample
+    
     def cleanSamplesOperations(self):
         """Método para limpiar las operaciones de un operario en el diccionario de operaciones.
 
@@ -224,25 +275,18 @@ class OpsProcessor():
             - 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: op_number
-                - 1: id_oprr
-                - 2: tlm_spbb
+                - 0: id_db
+                - 1: ID_NPDP
+                - 2: TLM_SPBB
                 - 3: date_oprc
-                - 4: lat
-                - 5: lon
+                - 4: latitud
+                - 5: longitud
                 - 6: precision
         """
 
-        for id_oprr in self.operationsDict.keys():
-            self._operationsDict[id_oprr]["sample_ops"] = None
-
-    def updateFirstDayOp(self):
-        """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_oprr in self.operationsDict.keys():
-            self._operationsDict[id_oprr]["first_day_op_classified"] = False
-    
+        for ID_NPDP in self.operationsDict.keys():
+            self._operationsDict[ID_NPDP]["sample_ops"] = None
+            
     @property
     def operationsDict(self):
         return self._operationsDict
@@ -253,35 +297,16 @@ if __name__ == "__main__":
     import pandas as pd
     import numpy as np
     import os
-    path = os.path.join(os.getcwd(), "examples\\volcado_17112023_NODE_processed.csv")
+    path = os.path.join(os.getcwd(), "examples\\volcado_17112023_NODE_processed_modified.csv")
     data_df = pd.read_csv(path, sep=";", )
     raw_data = data_df.to_numpy().astype(str)
-
-    ##seed de numpy en 42
-    np.random.seed(42)
-
-    size = data_df[data_df["id_oprr"] == 1].shape[0]
-    data_df.loc[data_df["id_oprr"] == 1, "id_dataBase"] = range(1,size+1)
-    size = data_df[data_df["id_oprr"] == 2].shape[0]
-    data_df.loc[data_df["id_oprr"] == 2, "id_dataBase"] = range(1,size+1)
-    ##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.
-    samples = []
-    index = 0
-    while True:
-        random_value = np.random.randint(8, 15)
-        if index + random_value < len(raw_data):
-            samples.append(raw_data[index:index+random_value])
-        else:
-            break
-        index += random_value
+    
+    ##tomo los valos de data_df y formo una lista de diccionarios por cada fila
+    samples = data_df.to_dict(orient="records")
     
     # from sarapy.dataProcessing import OpsProcessor
-    op = OpsProcessor(imputeDistances = False)
-
+    op = OpsProcessor(classifier_file="examples\\pip_lda_imp.pkl", imputeDistances = False)
     op.operationsDict
 
     ##procesamos una muestra
-    print(op.processOperations(samples[10]))    
-    print(op.processOperations(np.array([])))
-    print(op.processOperations(samples[11]))
-    # data_df.loc[data_df["id_oprr"] == 1].head(15)
+    print(op.processOperations(samples))

{sarapy-0.4.4 → sarapy-0.4.6}/sarapy/mlProcessors/PlantinClassifier.py

@@ -3,12 +3,17 @@ import numpy as np
 from sklearn.base import BaseEstimator, TransformerMixin
 from sklearn.pipeline import Pipeline
 from sarapy.mlProcessors import PlantinFMCreator
+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, **kwargs):
-        """Constructor de la clase PlantinClassifier."""
+    def __init__(self, classifier_file = "", **kwargs):
+        """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"}
@@ -21,10 +26,12 @@ class PlantinClassifier(BaseEstimator, TransformerMixin):
                 kwargs_plfmc[key] = value
         
         self._plantinFMCreator = PlantinFMCreator.PlantinFMCreator(**kwargs_plfmc)
-        
-        self._pipeline = Pipeline([
-            ("FMCreator", self._plantinFMCreator),
-        ])
+        #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)
+        except FileNotFoundError:
+            print("El archivo no se encuentra en el directorio actual.")
         
     def classify(self, newData):
         """Genera la clasificación de las operaciones para plantines.
@@ -36,8 +43,8 @@ class PlantinClassifier(BaseEstimator, TransformerMixin):
                 - 3: longitud de la operación
                 - 4: precision del GPS
         """
-        
-        return self._pipeline.fit_transform(newData).round(2)
+        feature_matrix = self._plantinFMCreator.fit_transform(newData)
+        return self._pipeline.predict(feature_matrix)
     
 if __name__ == "__main__":
     from sarapy.dataProcessing import OpsProcessor
@@ -60,9 +67,5 @@ if __name__ == "__main__":
             break
         index += random_value
 
-    op = OpsProcessor.OpsProcessor()
-    ##actualizo el diccionario de operaciones
-    op.updateOperationsDict(sample[12])
-    op.operationsDict
-    plantin_classifier = PlantinClassifier(imputeDistances = False)
-    plantin_classifier.classify(op.operationsDict["1"]["sample_ops"])    
+    plantin_classifier = PlantinClassifier(classifier_file="examples\\pip_lda_imp.pkl",imputeDistances = False)
+    plantin_classifier.classify(sample[50][:,2:])

{sarapy-0.4.4 → sarapy-0.4.6}/sarapy/version.py

@@ -1,2 +1,2 @@
 ## Version of the package   
-__version__ = "0.4.4"
+__version__ = "0.4.6"

{sarapy-0.4.4 → sarapy-0.4.6}/sarapy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sarapy
-Version: 0.4.4
+Version: 0.4.6
 Home-page: https://github.com/lucasbaldezzari/sarapy
 Author: Lucas Baldezzari
 Author-email: Lucas Baldezzari <lmbaldezzari@gmail.com>
@@ -18,6 +18,15 @@ Requires-Dist: geopy
 
 Library for processing SARAPICO project metadata of _AMG_.
 
+#### Version 0.4.6
+
+- Se agrega función OpsProcessor.transformInputData() para convertir la lista de diccionarios entregadas por el decoder a un array de strings necesarios para procesar y clasificar los datos.
+
+#### Version 0.4.5
+
+- Se modifica clase PlantinClassifier para que ahora tome un clasificador y lo use para clasificar operaciones.
+- Se modifica OpsProcessor para poder obtener clasificaciones (y no matrices de características de plantin como se venía probando).
+
 #### Version 0.4.4
 
 - Se modifica fit() de PlantinFMCreator.