sarapy 0.3.10__tar.gz → 0.4.1__tar.gz

sarapy-0.4.1/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.1
+Name: sarapy
+Version: 0.4.1
+Home-page: https://github.com/lucasbaldezzari/sarapy
+Author: Lucas Baldezzari
+Author-email: Lucas Baldezzari <lmbaldezzari@gmail.com>
+Maintainer-email: Lucas Baldezzari <lmbaldezzari@gmail.com>
+License: Your license text goes here
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: pandas
+Requires-Dist: scipy
+Requires-Dist: scikit-learn
+Requires-Dist: geopy
+
+# SARAPY
+
+Library for processing SARAPICO project metadata of _AMG_.
+
+#### Version 0.4.1 (working)
+
+- Se corrigen problemas de importaciones circulares.
+
+#### Version 0.4.0
+
+- Se implementa _OpsProcessor_.
+- Se implementa _PlanntinClassifier_.
+- Se corrige salida de _transform()_ y _fit_transform()_ de GeoProcessor.
+- Se mueve PlantinFMCreator a mlProcessors
+- Se cambia nombre de TLMSensorDataCreator a TLMSensorDataProcessor

sarapy-0.4.1/README.md

@@ -0,0 +1,15 @@
+# SARAPY
+
+Library for processing SARAPICO project metadata of _AMG_.
+
+#### Version 0.4.1 (working)
+
+- Se corrigen problemas de importaciones circulares.
+
+#### Version 0.4.0
+
+- Se implementa _OpsProcessor_.
+- Se implementa _PlanntinClassifier_.
+- Se corrige salida de _transform()_ y _fit_transform()_ de GeoProcessor.
+- Se mueve PlantinFMCreator a mlProcessors
+- Se cambia nombre de TLMSensorDataCreator a TLMSensorDataProcessor

{sarapy-0.3.10 → sarapy-0.4.1}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "sarapy"
 
-version = "0.3.10"
+version = "0.4.1"
 authors = [
   {name = "Lucas Baldezzari", email = "lmbaldezzari@gmail.com"},]
 maintainers = [
@@ -17,4 +17,5 @@ dependencies = [
   "geopy",
 ]
 
-readme = "README.md"
+readme = "README.md"
+license = {text = "Your license text goes here"} 

{sarapy-0.3.10 → sarapy-0.4.1}/sarapy/dataProcessing/GeoProcessor.py

@@ -15,15 +15,16 @@ class GeoProcessor(BaseEstimator, TransformerMixin):
         self.is_fitted = False
 
     @staticmethod
-    def getDistance(point1: np.array, point2: np.array) ->float:
-        """Calcula la distancia elipsoidal (en metros) entre los puntos p1 y p2 donde cada punto está representado como un array con un valor de latitud y otro de longitud. 
+    def getDistance(point1: float, point2: float) ->float:
+        """Calcula la distancia elipsoidal (en metros) entre los puntos p1 y p2 donde cada punto
+        está representado como un array con un valor de latitud y otro de longitud. 
 
         Parametros
-            point1 (np.array): array con los valores de latitud y longitud del punto 1
-            point2 (np.array): array con los valores de latitud y longitud del punto 2
+            point1 (float): array con los valores de latitud y longitud del punto 1
+            point2 (float): array con los valores de latitud y longitud del punto 2
 
         Returns:
-            float: np.array con las distancias entre los dos puntos
+            float con las distancias entre los dos puntos
         """
         
         ##aplicamos la función geodesic
@@ -38,11 +39,12 @@ class GeoProcessor(BaseEstimator, TransformerMixin):
         assert isinstance(X, np.ndarray), "X debe ser un np.array"
         ##asserteamos que X tenga dos columnas
         assert X.ndim == 2, "X debe ser de la forma (n, 2)"
-        ##asserteamos que X no tenga valores nulos
-        assert not np.isnan(X).any(), "X no debe tener valores nulos"
+        # ##asserteamos que X no tenga valores nulos
+        # assert not np.isnan(X).any(), "X no debe tener valores nulos"
         ##chequeamos que X tenga una sola fila, si es así, enviamos un warning
         if X.shape[0] == 1:
-            warnings.warn("X tiene una sola fila, se recomienda utilizar fit_transform")
+            warnings.warn("En GeoProcesor.fit(): X tiene una sola fila, por lo tanto no se puede computar la distancia entre los puntos.\
+                          \n Se devolverá un array con un solo valor de 0.0.")
 
         self._points = X
         self.is_fitted = True
@@ -60,9 +62,9 @@ class GeoProcessor(BaseEstimator, TransformerMixin):
         
         if self._points.shape[0] >= 2:
             ##calculamos la distancia entre los puntos de latitud y longitud dentro de X
-            self._distances = np.array([self.getDistance(point1, point2) for point1, point2 in zip(self.points,self.points[1:])]).round(2)
-            #agrego un cero al final del array
-            self._distances = np.append(self._distances, 0)
+            self._distances = np.array([self.getDistance(point1, point2) for point1, point2 in zip(self.points[1:],self.points)]).round(2)
+            #agrego un cero al inicio de la lista de distancias ya que el primer punto no tiene una operación previo con la cual comparar
+            self._distances = np.insert(self._distances, 0, 0)
         
         elif self._points.shape[0] == 1:
             self._distances = np.array([0])
@@ -97,13 +99,17 @@ class GeoProcessor(BaseEstimator, TransformerMixin):
         
         
 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")
+    raw_data = pd.read_csv(path, sep=";", ).to_numpy()
+
     ga = GeoProcessor()
 
-    puntos = np.array([[-32.329910, -57.229061],
-              [	-32.329895, -57.229061],
-              [-32.329880, -57.229069],
-              [-32.329865, -57.229069]])
-    
+    puntos = raw_data[50:60, 4:6]
+
     ga.fit(puntos)
     print(ga.transform(puntos))
     print(ga.fit_transform(puntos))

sarapy-0.4.1/sarapy/dataProcessing/OpsProcessor.py

@@ -0,0 +1,288 @@
+###Documentación en https://github.com/lucasbaldezzari/sarapy/blob/main/docs/Docs.md
+import warnings
+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.
+    
+    La clase recibe una muestra desde la base de datos histórica y la procesa para obtener las
+    operaciones clasificadas para cada operario. Se clasifican las operaciones desde el punto de vista
+    del plantín y del fertilizante. La clasificación del tipo de operación respecto de plantín se hace
+    con el pipeline para plantín, idem para el fertilizante.
+    """
+    
+    def __init__(self, distanciaMedia = 1.8, umbral_precision = 0.3, dist_mismo_lugar = 0.0,
+                 max_dist = 100, umbral_ratio_dCdP = 0.5, deltaO_medio = 4,
+                 keepDimsPFMC = False, columnToImputePFMC = 0):
+        """Constructor de la clase OpsProcessor.
+        
+        Args:
+            - distanciaMedia: Distancia media entre operaciones.
+        """
+
+        # self._plantinFMCreator = PlantinFMCreator(distanciaMedia = distanciaMedia, umbral_precision = umbral_precision,
+        #                                           dist_mismo_lugar = dist_mismo_lugar, max_dist = max_dist,
+        #                                           umbral_ratio_dCdP = umbral_ratio_dCdP, deltaO_medio = deltaO_medio)
+        
+        self._plantin_classifier = PlantinClassifier.PlantinClassifier()
+        # self._fertilizerFMCreator = FertilizerFMCreator() ## PARA IMPLEMENTAR
+        
+        self._operationsDict = {} ##diccionario de operarios con sus operaciones
+        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):
+        """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
+        plantín y por otro lado el fertilizante.
+        Se retorna un array con las clasificaciones concatenadas, manteniendo el orden de las operaciones por operario.
+        
+        Args:
+            - 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,
+            
+                - 0: op_number
+                - 1: id_oprr
+                - 2: tlm_spbb
+                - 3: date_oprc
+                - 4: lat
+                - 5: lon
+                - 6: precision
+        """
+        
+        ##chqueo que newSample no esté vacío
+        if len(newSample) != 0:
+            #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
+            # ops_numbers = newSample[:,0]
+            ops_numbers = self.getActualOperationsNumbers() #obtenemos los números de operaciones desde el diccionario de operaciones
+            return plantinClassifications.round(2), ops_numbers
+        
+        else:
+            self.resetAllNewSamplesValues()
+            return None
+        
+    def updateOperationsDict(self, newSample):
+        """Actualiza 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
+                - 3: date_oprc
+                - 4: lat
+                - 5: lon
+                - 6: precision
+                
+        Returns:
+            - None
+            NOTA: PENSAR SI SE DEVUELVE ALGO COMO UN TRUE O FALSE PARA SABER SI SE ACTUALIZÓ O NO EL DICCIONARIO
+            DE MANERA CORRECTA O HUBO ALGÚN PROBLEMA Y ASÍ VER QUÉ HACER EN EL MAIN
+        """
+        
+        id_oprrs_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:
+                #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
+                #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,
+                                                 "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]
+            ##actualizo el diccionario
+            self._operationsDict[id_oprr]["sample_ops"] = sample_ops
+            self._operationsDict[id_oprr]["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"]
+            ###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.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
+
+    def classifyForPlantin(self):
+        """Método para clasificar las operaciones para plantín.
+        Se recorre el diccionario de operaciones y se clasifican las operaciones para plantín.
+
+        Returns:
+            - plantinClassifications: np.array con las clasificaciones de las operaciones para plantín.
+        """
+
+        ##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"]]
+
+        for id_oprr in ops_with_new_sample:#self.operationsDict.keys():
+            ##clasificamos las operaciones para plantín
+            operations = self.operationsDict[id_oprr]["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"]:
+                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
+
+        return plantinClassifications
+            
+    def updateLastOperations(self, id_oprrs_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
+                - 3: date_oprc
+                - 4: lat
+                - 5: lon
+                - 6: precision
+        """
+        
+        for id_oprr in id_oprrs_w_newOperations:
+            self._operationsDict[id_oprr]["last_oprc"] = self._operationsDict[id_oprr]["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.
+        """
+        id_oprrs_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())
+
+        return opsNumbersList
+    
+    def updateNewSamplesValues(self, id_oprrs_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.
+        """
+
+        ##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
+            else:
+                self._operationsDict[id_oprr]["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
+
+    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())
+
+        return opsNumbersList
+
+    def cleanSamplesOperations(self):
+        """Método para limpiar las operaciones de un operario 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
+                - 3: date_oprc
+                - 4: lat
+                - 5: lon
+                - 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
+    
+    @property
+    def operationsDict(self):
+        return self._operationsDict
+    
+    
+if __name__ == "__main__":
+    #cargo archivo examples\volcado_17112023_NODE_processed.csv
+    import pandas as pd
+    import numpy as np
+    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)
+
+    ##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
+    
+    # from sarapy.dataProcessing import OpsProcessor
+    op = OpsProcessor()
+
+    op.operationsDict
+
+    ##procesamos una muestra
+    print(op.processOperations(samples[0]))
+    print(op.processOperations(np.array([])))
+    print(op.processOperations(samples[1]))
+    # ##recorro los samsamples[0]ples y los proceso
+    # for sample in print(op.operationsDict[":
+    #     op.processOperations(sample)
+    data_df.loc[data_df["id_oprr"] == 1].head(15)

sarapy-0.3.10/sarapy/dataProcessing/TLMSensorDataExtractor.py → sarapy-0.4.1/sarapy/dataProcessing/TLMSensorDataProcessor.py

@@ -3,7 +3,7 @@
 import numpy as np
 from sklearn.base import BaseEstimator, TransformerMixin
 
-class TLMSensorDataExtractor(BaseEstimator, TransformerMixin):
+class TLMSensorDataProcessor(BaseEstimator, TransformerMixin):
     """- Autor: BALDEZZARI Lucas
     
     Metadata utilizada: Versión 9
@@ -764,7 +764,7 @@ class TLMSensorDataExtractor(BaseEstimator, TransformerMixin):
         return self._dataPositions
     
 if __name__ == "__main__":
-    tlmsde = TLMSensorDataExtractor()
+    tlmsde = TLMSensorDataProcessor()
 
     sample = np.array(["1010001000010000110000001011000000000000000000001111011010001001",
               "1010001000010000110000001011000000000000000000001111011010001001"])

{sarapy-0.3.10 → sarapy-0.4.1}/sarapy/dataProcessing/TimeSeriesProcessor.py

@@ -3,7 +3,6 @@
 import numpy as np
 from sklearn.base import BaseEstimator, TransformerMixin
 import warnings
-from datetime import datetime
 
 class TimeSeriesProcessor(BaseEstimator, TransformerMixin):
     """"
@@ -22,7 +21,11 @@ class TimeSeriesProcessor(BaseEstimator, TransformerMixin):
             "deltaP": 2, "ratio_dCdP": 3}
         
     def fit(self, X: np.array, y=None)-> np.array:
-        """Fittea el objeto"""
+        """Fittea el objeto
+        
+            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).
+        """
 
         ##asserteamos que X sea un np.array
         assert isinstance(X, np.ndarray), "X debe ser un np.array"
@@ -54,7 +57,10 @@ class TimeSeriesProcessor(BaseEstimator, TransformerMixin):
         self.is_fitted = True
     
     def transform(self, X: np.array):
-        """Genera un array con los tiempos de operación, caminata y pico abierto."""
+        """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).
+        """
         
         if not self.is_fitted:
             raise RuntimeError("El modelo no ha sido fitteado.")
@@ -100,27 +106,26 @@ class TimeSeriesProcessor(BaseEstimator, TransformerMixin):
         return self._dataPositions
     
 if __name__ == "__main__":
-    timestamps = np.array([1697724423, 1697724428, 1697724430, 1697724433])
-    tlm_data = np.array(["0010001000001100110000001100001000000000000000001111111000110000",
-                         "0010001000001100110000101100000000000000000000001111111000110000",
-                         "0010001000001100101100101100000000000000000000001111111000110000",
-                         "0010001000001100101100001100000000000000000000001111111000110000"])
-    
-    ## pasamos los timestamps a fecha usando datetime
-    import datetime
-    fechas = np.array([datetime.datetime.fromtimestamp(ts) for ts in timestamps])
-    print(fechas)
-    
-    from sarapy.dataProcessing import TLMSensorDataExtractor
-    tlm_extractor = TLMSensorDataExtractor()
+    
+    import pandas as pd
+    import numpy as np
+    import os
+    path = os.path.join(os.getcwd(), "examples\\volcado_17112023_NODE_processed.csv")
+    raw_data = pd.read_csv(path, sep=";", ).to_numpy()
+    timestamps = raw_data[50:60,3].astype(float)
+    tlm_data = raw_data[50:60,2]
+       
+    from sarapy.dataProcessing import TLMSensorDataProcessor
+    tlm_extractor = TLMSensorDataProcessor.TLMSensorDataProcessor()
     tlm_extractor.fit(tlm_data)
     
-    deltaPicos = tlm_extractor.TIMEAC
+    deltaPicos = tlm_extractor.TIMEAC.astype(float)
 
     tmsp = TimeSeriesProcessor()
     
     #creamos un array con los timestamps y los tiempos de pico abierto de la forma (n, 2)
     X = np.hstack((timestamps.reshape(-1, 1), deltaPicos.reshape(-1, 1)))
+
     tmsp.fit(X)
     tmsp.transform(X)
     tmsp.fit_transform(X)
@@ -131,7 +136,7 @@ if __name__ == "__main__":
     timestamps2 = np.array([1697724423])
     
     tmsp2 = TimeSeriesProcessor() 
-    tlm_extractor2 = TLMSensorDataExtractor()
+    tlm_extractor2 = TLMSensorDataProcessor.TLMSensorDataProcessor()
     
     tlm_extractor2.fit(tlm_data2)
     

sarapy-0.4.1/sarapy/dataProcessing/__init__.py

@@ -0,0 +1,4 @@
+# from .TLMSensorDataProcessor import TLMSensorDataProcessor
+# from .GeoProcessor import GeoProcessor
+# from .TimeSeriesProcessor import TimeSeriesProcessor
+# from .OpsProcessor import OpsProcessor

sarapy-0.4.1/sarapy/mlProcessors/PlantinClassifier.py

@@ -0,0 +1,58 @@
+###Documentación en https://github.com/lucasbaldezzari/sarapy/blob/main/docs/Docs.md
+import numpy as np
+from sklearn.base import BaseEstimator, TransformerMixin
+from sklearn.pipeline import Pipeline
+from sarapy.mlProcessors import PlantinFMCreator
+
+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):
+        """Constructor de la clase PlantinClassifier."""
+        
+        self._plantinFMCreator = PlantinFMCreator.PlantinFMCreator()
+        
+        self._pipeline = Pipeline([
+            ("FMCreator", self._plantinFMCreator),
+        ])
+        
+    def classify(self, newData):
+        """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
+        """
+        
+        return self._pipeline.fit_transform(newData).round(2)
+    
+if __name__ == "__main__":
+    from sarapy.dataProcessing import OpsProcessor
+
+    #cargo archivo examples\volcado_17112023_NODE_processed.csv
+    import pandas as pd
+    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
+
+    op = OpsProcessor.OpsProcessor()
+    ##actualizo el diccionario de operaciones
+    op.updateOperationsDict(sample[12])
+    op.operationsDict
+    plantin_classifier = PlantinClassifier()
+    plantin_classifier.classify(op.operationsDict["1"]["sample_ops"])    

{sarapy-0.3.10/sarapy/dataProcessing → sarapy-0.4.1/sarapy/mlProcessors}/PlantinFMCreator.py

@@ -1,9 +1,9 @@
 ###Documentación en https://github.com/lucasbaldezzari/sarapy/blob/main/docs/Docs.md
 
+import warnings
 import numpy as np
 from sklearn.base import BaseEstimator, TransformerMixin
-import warnings
-from sarapy.dataProcessing import TLMSensorDataExtractor, TimeSeriesProcessor, GeoProcessor
+from sarapy.dataProcessing import TLMSensorDataProcessor, TimeSeriesProcessor, GeoProcessor
 from sarapy.preprocessing import DistancesImputer
 
 class PlantinFMCreator(BaseEstimator, TransformerMixin):
@@ -48,7 +48,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,4)Las columnas de X son,
+            - 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
@@ -65,9 +65,9 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
         precitions = X[:,4].astype(float) #precision del GPS      
         
         ##instanciamos los objetos
-        tlmDataExtractor = TLMSensorDataExtractor()
-        timeProcessor = TimeSeriesProcessor()
-        geoprocessor = GeoProcessor()
+        tlmDataExtractor = TLMSensorDataProcessor.TLMSensorDataProcessor()
+        timeProcessor = TimeSeriesProcessor.TimeSeriesProcessor()
+        geoprocessor = GeoProcessor.GeoProcessor()
         
         ##***** OBTENEMOS LOS DATOS PARA FITEAR LOS OBJETOS Y ASÍ PROCESAR LA FM *****
         ##obtengo las posiciones de los datos de tlmDataExtractor y timeProcessor
@@ -88,11 +88,12 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
         
         ####***** IMPUTAMOS DATOS SI ES LO REQUERIDO*****
         if self.imputeDistances:
-            distanceimputer = 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)
+            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),
@@ -109,18 +110,19 @@ 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,4)Las columnas de X son,
+            - 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
                 
         Returns:
             - featureMatrix: Es un array con la matriz de características. La forma de featureMatrix es (n,5). Las columnas de featureMatrix son,
                 - 0: DST_PT: Distorsión de plantín
-                - 2: deltaO: delta operación
-                - 3: ratio_dCdP: Ratio entre el delta de caminata y delta de pico abierto
-                - 4: distances: Distancias entre operaciones
+                - 1: deltaO: delta operación
+                - 2: ratio_dCdP: Ratio entre el delta de caminata y delta de pico abierto
+                - 3: distances: Distancias entre operaciones
         """
         
         if not self.is_fitted:
@@ -138,18 +140,19 @@ 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,4)Las columnas de X son,
+            - 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
+                
         Returns:
             - featureMatrix: Es un array con la matriz de características. La forma de featureMatrix es (n,5). Las columnas de featureMatrix son,
                 - 0: DST_PT: Distorsión de plantín
-                - 2: deltaO: delta operación
-                - 3: ratio_dCdP: Ratio entre el delta de caminata y delta de pico abierto
-                - 4: distances: Distancias entre operaciones
+                - 1: deltaO: delta operación
+                - 2: ratio_dCdP: Ratio entre el delta de caminata y delta de pico abierto
+                - 3: distances: Distancias entre operaciones
         """
         self.fit(X)
         return self.transform(X)
@@ -177,23 +180,13 @@ class PlantinFMCreator(BaseEstimator, TransformerMixin):
         
 if __name__ == "__main__":
     ##genero objeto FMCreator
-    fmcreator = PlantinFMCreator(imputeDistances=True)
-    
-    ##datos de ejemplo
-    tlmsbp_sample = np.array(['0010001000010010110000011000000111111101001000000000000000000000',
-                              '0010001000010100110000011000000111111101001000000000000000000000',
-                              '0010001000010000110000011000000111111101001000000000000000000000',
-                              '0010001000011010110000011000110111111101001000000000000000000000'])
-    
-    date_oprc = ["35235", "35240", "35244", "35248"]
-    lats = ["-32.331093", "-32.331116", "-32.331131", "-32.331146"]
-    lons = ["-57.229733", "-57.229733", "-57.229733", "-57.22974"]
-    precitions = ["1", "0.12", "0.1", "1"]
-    
-    ##generamos matriz de datos X
-    ##generamos matriz de datos X de tal forma que cada columna tenga los datos de tlmsbp_sample, date_oprc, lats y lons
-    X = np.vstack((tlmsbp_sample, date_oprc, lats, lons,precitions)).T
-    X = X.astype(str)
+    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()
+
+    X = raw_data[50:60,2:]
     fmcreator.fit(X)
     fm = fmcreator.fit_transform(X)
     print(fm)

{sarapy-0.3.10 → sarapy-0.4.1}/sarapy/preprocessing/DistancesImputer.py

@@ -2,7 +2,6 @@
 
 import numpy as np
 from sklearn.base import BaseEstimator, TransformerMixin
-from sarapy.dataProcessing import TLMSensorDataExtractor, TimeSeriesProcessor, GeoProcessor
 
 class DistancesImputer(BaseEstimator, TransformerMixin):
     """La clase DistancesImputer se encarga de imputar/modificar los datos de telemetría entregados por el sistema. Se utilizan las clases TLMSensorDataExtractor, TimeSeriesProcessor y GeoProcessor para realizar las transformaciones necesarias y luego aplicar las modificaciones necesarias en base a las reglas definidas luego del análisis estadístico.
@@ -153,9 +152,11 @@ class DistancesImputer(BaseEstimator, TransformerMixin):
     
 
 if __name__ == "__main__":
-    tlmda = TLMSensorDataExtractor()
-    tsa = TimeSeriesProcessor()
-    gpa = GeoProcessor()
+    from sarapy.dataProcessing import TimeSeriesProcessor, GeoProcessor
+    from sarapy.dataProcessing import TLMSensorDataProcessor
+    tlmda = TLMSensorDataProcessor.TLMSensorDataProcessor()
+    tsa = TimeSeriesProcessor.TimeSeriesProcessor()
+    gpa = GeoProcessor.GeoProcessor()
 
     ##datos de ejemplo
     tlmsbp_sample = np.array(['0010001000010010110000011000000111111101001000000000000000000000',

sarapy-0.4.1/sarapy/preprocessing/FertilizerImputer.py

@@ -0,0 +1,34 @@
+###Documentación en https://github.com/lucasbaldezzari/sarapy/blob/main/docs/Docs.md
+
+import numpy as np
+from sklearn.base import BaseEstimator, TransformerMixin
+
+class FertilizerImputer(BaseEstimator, TransformerMixin):
+    """Clase para imputar los datos de fertilizante.
+    
+    La idea principal es poder relevar la presencia o no de Fertilizante en la operación."""
+
+    def __init__(self, n_next_ops, min_dist_level = 3, keepDims = False, columnToImpute = 0):
+        """Constructor de la clase FertilizerImputer.
+        
+        Args:
+            - n_prev_ops: Número de operaciones siguientes a considerar.
+            - min_dist_level: Nivel mínimo de distorsión para considerar que hay fertilizante.
+            - columnToImpute: Columna a imputar.
+            - keepDims: Si es True, se mantienen las dimensiones del array de entrada. Si es False, se devuelve un array de una dimensión.
+        """
+        self.n_next_ops = n_next_ops
+        self.min_dist_level = min_dist_level
+        self._keepDims = keepDims
+        self._columnToImpute = columnToImpute
+        self.is_fitted = False
+        self._dataPositions = {"fertilizante":0}
+
+    def fit(self, X:np.array, y = None):
+        """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,1)
+                - 0: Fertilizante
+        """
+        self._fertilizante = X[:,0]

sarapy-0.4.1/sarapy/preprocessing/__init__.py

@@ -0,0 +1,2 @@
+# from .DistancesImputer import DistancesImputer
+# from .FertilizerImputer import FertilizerImputer

{sarapy-0.3.10 → sarapy-0.4.1}/sarapy/version.py

@@ -1,2 +1,2 @@
 ## Version of the package   
-__version__ = "0.3.10"
+__version__ = "0.4.1"

sarapy-0.4.1/sarapy.egg-info/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.1
+Name: sarapy
+Version: 0.4.1
+Home-page: https://github.com/lucasbaldezzari/sarapy
+Author: Lucas Baldezzari
+Author-email: Lucas Baldezzari <lmbaldezzari@gmail.com>
+Maintainer-email: Lucas Baldezzari <lmbaldezzari@gmail.com>
+License: Your license text goes here
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: pandas
+Requires-Dist: scipy
+Requires-Dist: scikit-learn
+Requires-Dist: geopy
+
+# SARAPY
+
+Library for processing SARAPICO project metadata of _AMG_.
+
+#### Version 0.4.1 (working)
+
+- Se corrigen problemas de importaciones circulares.
+
+#### Version 0.4.0
+
+- Se implementa _OpsProcessor_.
+- Se implementa _PlanntinClassifier_.
+- Se corrige salida de _transform()_ y _fit_transform()_ de GeoProcessor.
+- Se mueve PlantinFMCreator a mlProcessors
+- Se cambia nombre de TLMSensorDataCreator a TLMSensorDataProcessor

{sarapy-0.3.10 → sarapy-0.4.1}/sarapy.egg-info/SOURCES.txt

@@ -9,9 +9,13 @@ sarapy.egg-info/dependency_links.txt
 sarapy.egg-info/requires.txt
 sarapy.egg-info/top_level.txt
 sarapy/dataProcessing/GeoProcessor.py
-sarapy/dataProcessing/PlantinFMCreator.py
-sarapy/dataProcessing/TLMSensorDataExtractor.py
+sarapy/dataProcessing/OpsProcessor.py
+sarapy/dataProcessing/TLMSensorDataProcessor.py
 sarapy/dataProcessing/TimeSeriesProcessor.py
 sarapy/dataProcessing/__init__.py
+sarapy/mlProcessors/PlantinClassifier.py
+sarapy/mlProcessors/PlantinFMCreator.py
+sarapy/mlProcessors/__init__.py
 sarapy/preprocessing/DistancesImputer.py
+sarapy/preprocessing/FertilizerImputer.py
 sarapy/preprocessing/__init__.py

{sarapy-0.3.10 → sarapy-0.4.1}/setup.py

@@ -1,5 +1,5 @@
 from setuptools import setup, find_packages
-import os, toml
+import toml
 
 def getRequirements():
     with open('requirements.txt', 'r') as f:

sarapy-0.3.10/PKG-INFO

@@ -1,124 +0,0 @@
-Metadata-Version: 2.1
-Name: sarapy
-Version: 0.3.10
-Summary: Library for Sarapico Metadata processing
-Home-page: https://github.com/lucasbaldezzari/sarapy
-Author: Lucas Baldezzari
-Author-email: Lucas Baldezzari <lmbaldezzari@gmail.com>
-Maintainer-email: Lucas Baldezzari <lmbaldezzari@gmail.com>
-License: MIT
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: Microsoft :: Windows :: Windows 10
-Classifier: Operating System :: Microsoft :: Windows :: Windows 11
-Classifier: Operating System :: Unix
-Description-Content-Type: text/markdown
-Requires-Dist: numpy
-Requires-Dist: matplotlib
-Requires-Dist: pandas
-Requires-Dist: scipy
-Requires-Dist: scikit-learn
-Requires-Dist: geopy
-
-# SARAPY
-
-Library for processing SARAPICO project metadata of _AMG_.
-
-#### Version 0.3.10
-
-- Se corrige línea en DistancesImputer.
-
-#### Version 0.3.9
-
-- Se corrige nombre de argumento en el constructor de PlantinFMCreator
-
-#### Version 0.3.8
-
-- Se agregan condiciones para mejorar la imputación de distancias en _DistancesImputer_.
-
-#### Version 0.3.7
-
-- Se implementa la imputación de distancias con _DistancesImputer_ dentro de PlantinFMCreator.
-- Se agregan argumentos al constructor de _PlantinFMCreator_ necesarios para poder imputar con _DistancesImputer_.
-- Se agrega argumento dist*mismo_lugar en \_DistancesImputer* para usar dicho valor en las imputaciones que correspondan a operaciones en el mismo lugar.
-
-#### Version 0.3.6
-
-- Se agregan argumentos al constructor de _DistancesImputer_ para que Transform y fit_transform puedan entregar un array de shape (n,1) o bien de (n,6) eligiendo la columna a imputar.
-
-#### Version 0.3.5
-
-- Se implementa clase _DistancesImputer_.
-
-#### Version 0.3.4
-
-- Se actializa _dataPositions_ de PlantinFMCreator.
-
-#### Version 0.3.3
-
-- Se cambia el nombre de la clase FMCreator a PlantinFMCreator. Se modifica la matriz transformada quitando el dato de distorsión de Fertilizante.
-
-#### Version 0.3.2
-
-- Se agrega property en FMCreator para acceder a \_dataPosition. Se cambia la forma de los diccionarios de _dataPosition_ de FMCreator, TimeSeriesProcesor y TLMSensorDataExtractor. Además, ahora este atributo se crea en init().
-- Se corrige bug por división por cero en el cálculo de _ratio_dCdP_ de TimeSeriesProcessor.
-
-#### Version 0.3.1
-
-- Se corrige forma de acceder a los datos de X en FMCreator.fit().
-
-#### Version 0.3.0
-
-- Se implementa clase FMCreator.
-- Se quita método TLMSensorDataExtractor.getMetadataRevisionNumber().
-- Se agrega cálculo de ratio_dCdP en TimeSeriesProcessor
-- Se cambia nombre de clase _GeoAnalyzer_ por _GeoProcessor_
-- Se agrega atritubo dataPositions en _TLMSensorDataExtractor_ para poder saber qué representa cada columna dentro del array devuelto por tranform.
-- Se agrega dataPositions a TimeSeriesProcessor
-
-#### Version 0.2.6
-
-- Se cambia la forma de computar los deltaO de TimeSeriesProcessor. Ahora se hace deltaO*i = T_i - T*(i-1)
-
-#### Version 0.2.5
-
-- Se corrige GeoAnalyzer.transform() para que entregue el array con un cero adicional al final ya que estaba entregando _(n-1,2)_ datos cuando X es de shape (n,2).
-
-#### Version 0.2.4
-
-- Se corrige nombre de atributos de TLMSensorDataExtractor
-
-#### Version 0.2.3
-
-- Se modifican métodos _TLMSensorDataExtractor.fit()_ y _TLMSensorDataExtractor.transofmr()_ ya que no se habían considerado los datos de FIX y SIV de la metadata.
-
-#### Version 0.2.2
-
-- Se quita el chequeo de valores nulos en TimeSeriesProcessor.fit()
-- Si la cantidad de filas de X que se pasa a TimeSeriesProcessor.fit() es igual a uno, los tiempos de operación y de caminata se hacen cero. El método transform devolverá un array de (1,3) donde el único valor diferente de cero será el deltaC.
-
-#### Version 0.2.1
-
-- Se corrige _init.py_ de dataProcessing.
-
-#### Version 0.2.0
-
-- Transforming some attributs to private attributes. Adding @property for getters.
-- Created GNSSDataProcessor class.
-- Created TimeSeriesProcessor class.
-
-#### Version 0.1.4
-
-Setting an **init**.py file for TLMSensorDataExtractor module.
-
-#### Version 0.1.3
-
-Setting version.py file.
-
-#### Version 0.1.1 and Version 0.1.0
-
-Just for testing.
-
-### Docs
-
-Documentation [here](https://github.com/lucasbaldezzari/sarapy/blob/main/docs/Docs.md).

sarapy-0.3.10/README.md

@@ -1,102 +0,0 @@
-# SARAPY
-
-Library for processing SARAPICO project metadata of _AMG_.
-
-#### Version 0.3.10
-
-- Se corrige línea en DistancesImputer.
-
-#### Version 0.3.9
-
-- Se corrige nombre de argumento en el constructor de PlantinFMCreator
-
-#### Version 0.3.8
-
-- Se agregan condiciones para mejorar la imputación de distancias en _DistancesImputer_.
-
-#### Version 0.3.7
-
-- Se implementa la imputación de distancias con _DistancesImputer_ dentro de PlantinFMCreator.
-- Se agregan argumentos al constructor de _PlantinFMCreator_ necesarios para poder imputar con _DistancesImputer_.
-- Se agrega argumento dist*mismo_lugar en \_DistancesImputer* para usar dicho valor en las imputaciones que correspondan a operaciones en el mismo lugar.
-
-#### Version 0.3.6
-
-- Se agregan argumentos al constructor de _DistancesImputer_ para que Transform y fit_transform puedan entregar un array de shape (n,1) o bien de (n,6) eligiendo la columna a imputar.
-
-#### Version 0.3.5
-
-- Se implementa clase _DistancesImputer_.
-
-#### Version 0.3.4
-
-- Se actializa _dataPositions_ de PlantinFMCreator.
-
-#### Version 0.3.3
-
-- Se cambia el nombre de la clase FMCreator a PlantinFMCreator. Se modifica la matriz transformada quitando el dato de distorsión de Fertilizante.
-
-#### Version 0.3.2
-
-- Se agrega property en FMCreator para acceder a \_dataPosition. Se cambia la forma de los diccionarios de _dataPosition_ de FMCreator, TimeSeriesProcesor y TLMSensorDataExtractor. Además, ahora este atributo se crea en init().
-- Se corrige bug por división por cero en el cálculo de _ratio_dCdP_ de TimeSeriesProcessor.
-
-#### Version 0.3.1
-
-- Se corrige forma de acceder a los datos de X en FMCreator.fit().
-
-#### Version 0.3.0
-
-- Se implementa clase FMCreator.
-- Se quita método TLMSensorDataExtractor.getMetadataRevisionNumber().
-- Se agrega cálculo de ratio_dCdP en TimeSeriesProcessor
-- Se cambia nombre de clase _GeoAnalyzer_ por _GeoProcessor_
-- Se agrega atritubo dataPositions en _TLMSensorDataExtractor_ para poder saber qué representa cada columna dentro del array devuelto por tranform.
-- Se agrega dataPositions a TimeSeriesProcessor
-
-#### Version 0.2.6
-
-- Se cambia la forma de computar los deltaO de TimeSeriesProcessor. Ahora se hace deltaO*i = T_i - T*(i-1)
-
-#### Version 0.2.5
-
-- Se corrige GeoAnalyzer.transform() para que entregue el array con un cero adicional al final ya que estaba entregando _(n-1,2)_ datos cuando X es de shape (n,2).
-
-#### Version 0.2.4
-
-- Se corrige nombre de atributos de TLMSensorDataExtractor
-
-#### Version 0.2.3
-
-- Se modifican métodos _TLMSensorDataExtractor.fit()_ y _TLMSensorDataExtractor.transofmr()_ ya que no se habían considerado los datos de FIX y SIV de la metadata.
-
-#### Version 0.2.2
-
-- Se quita el chequeo de valores nulos en TimeSeriesProcessor.fit()
-- Si la cantidad de filas de X que se pasa a TimeSeriesProcessor.fit() es igual a uno, los tiempos de operación y de caminata se hacen cero. El método transform devolverá un array de (1,3) donde el único valor diferente de cero será el deltaC.
-
-#### Version 0.2.1
-
-- Se corrige _init.py_ de dataProcessing.
-
-#### Version 0.2.0
-
-- Transforming some attributs to private attributes. Adding @property for getters.
-- Created GNSSDataProcessor class.
-- Created TimeSeriesProcessor class.
-
-#### Version 0.1.4
-
-Setting an **init**.py file for TLMSensorDataExtractor module.
-
-#### Version 0.1.3
-
-Setting version.py file.
-
-#### Version 0.1.1 and Version 0.1.0
-
-Just for testing.
-
-### Docs
-
-Documentation [here](https://github.com/lucasbaldezzari/sarapy/blob/main/docs/Docs.md).

sarapy-0.3.10/sarapy/dataProcessing/__init__.py

@@ -1,4 +0,0 @@
-from .TLMSensorDataExtractor import TLMSensorDataExtractor
-from .GeoProcessor import GeoProcessor
-from .TimeSeriesProcessor import TimeSeriesProcessor
-from .PlantinFMCreator import PlantinFMCreator

sarapy-0.3.10/sarapy/preprocessing/__init__.py

@@ -1 +0,0 @@
-from .DistancesImputer import DistancesImputer

sarapy-0.3.10/sarapy.egg-info/PKG-INFO

@@ -1,124 +0,0 @@
-Metadata-Version: 2.1
-Name: sarapy
-Version: 0.3.10
-Summary: Library for Sarapico Metadata processing
-Home-page: https://github.com/lucasbaldezzari/sarapy
-Author: Lucas Baldezzari
-Author-email: Lucas Baldezzari <lmbaldezzari@gmail.com>
-Maintainer-email: Lucas Baldezzari <lmbaldezzari@gmail.com>
-License: MIT
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: Microsoft :: Windows :: Windows 10
-Classifier: Operating System :: Microsoft :: Windows :: Windows 11
-Classifier: Operating System :: Unix
-Description-Content-Type: text/markdown
-Requires-Dist: numpy
-Requires-Dist: matplotlib
-Requires-Dist: pandas
-Requires-Dist: scipy
-Requires-Dist: scikit-learn
-Requires-Dist: geopy
-
-# SARAPY
-
-Library for processing SARAPICO project metadata of _AMG_.
-
-#### Version 0.3.10
-
-- Se corrige línea en DistancesImputer.
-
-#### Version 0.3.9
-
-- Se corrige nombre de argumento en el constructor de PlantinFMCreator
-
-#### Version 0.3.8
-
-- Se agregan condiciones para mejorar la imputación de distancias en _DistancesImputer_.
-
-#### Version 0.3.7
-
-- Se implementa la imputación de distancias con _DistancesImputer_ dentro de PlantinFMCreator.
-- Se agregan argumentos al constructor de _PlantinFMCreator_ necesarios para poder imputar con _DistancesImputer_.
-- Se agrega argumento dist*mismo_lugar en \_DistancesImputer* para usar dicho valor en las imputaciones que correspondan a operaciones en el mismo lugar.
-
-#### Version 0.3.6
-
-- Se agregan argumentos al constructor de _DistancesImputer_ para que Transform y fit_transform puedan entregar un array de shape (n,1) o bien de (n,6) eligiendo la columna a imputar.
-
-#### Version 0.3.5
-
-- Se implementa clase _DistancesImputer_.
-
-#### Version 0.3.4
-
-- Se actializa _dataPositions_ de PlantinFMCreator.
-
-#### Version 0.3.3
-
-- Se cambia el nombre de la clase FMCreator a PlantinFMCreator. Se modifica la matriz transformada quitando el dato de distorsión de Fertilizante.
-
-#### Version 0.3.2
-
-- Se agrega property en FMCreator para acceder a \_dataPosition. Se cambia la forma de los diccionarios de _dataPosition_ de FMCreator, TimeSeriesProcesor y TLMSensorDataExtractor. Además, ahora este atributo se crea en init().
-- Se corrige bug por división por cero en el cálculo de _ratio_dCdP_ de TimeSeriesProcessor.
-
-#### Version 0.3.1
-
-- Se corrige forma de acceder a los datos de X en FMCreator.fit().
-
-#### Version 0.3.0
-
-- Se implementa clase FMCreator.
-- Se quita método TLMSensorDataExtractor.getMetadataRevisionNumber().
-- Se agrega cálculo de ratio_dCdP en TimeSeriesProcessor
-- Se cambia nombre de clase _GeoAnalyzer_ por _GeoProcessor_
-- Se agrega atritubo dataPositions en _TLMSensorDataExtractor_ para poder saber qué representa cada columna dentro del array devuelto por tranform.
-- Se agrega dataPositions a TimeSeriesProcessor
-
-#### Version 0.2.6
-
-- Se cambia la forma de computar los deltaO de TimeSeriesProcessor. Ahora se hace deltaO*i = T_i - T*(i-1)
-
-#### Version 0.2.5
-
-- Se corrige GeoAnalyzer.transform() para que entregue el array con un cero adicional al final ya que estaba entregando _(n-1,2)_ datos cuando X es de shape (n,2).
-
-#### Version 0.2.4
-
-- Se corrige nombre de atributos de TLMSensorDataExtractor
-
-#### Version 0.2.3
-
-- Se modifican métodos _TLMSensorDataExtractor.fit()_ y _TLMSensorDataExtractor.transofmr()_ ya que no se habían considerado los datos de FIX y SIV de la metadata.
-
-#### Version 0.2.2
-
-- Se quita el chequeo de valores nulos en TimeSeriesProcessor.fit()
-- Si la cantidad de filas de X que se pasa a TimeSeriesProcessor.fit() es igual a uno, los tiempos de operación y de caminata se hacen cero. El método transform devolverá un array de (1,3) donde el único valor diferente de cero será el deltaC.
-
-#### Version 0.2.1
-
-- Se corrige _init.py_ de dataProcessing.
-
-#### Version 0.2.0
-
-- Transforming some attributs to private attributes. Adding @property for getters.
-- Created GNSSDataProcessor class.
-- Created TimeSeriesProcessor class.
-
-#### Version 0.1.4
-
-Setting an **init**.py file for TLMSensorDataExtractor module.
-
-#### Version 0.1.3
-
-Setting version.py file.
-
-#### Version 0.1.1 and Version 0.1.0
-
-Just for testing.
-
-### Docs
-
-Documentation [here](https://github.com/lucasbaldezzari/sarapy/blob/main/docs/Docs.md).