sarapy 0.3.4__py3-none-any.whl → 0.3.6__py3-none-any.whl

sarapy/dataProcessing/TLMSensorDataExtractor.py

@@ -47,13 +47,22 @@ class TLMSensorDataExtractor(BaseEstimator, TransformerMixin):
         
         ##creamos un diccionario para saber la posición de cada dato dentro del array devuelto por transform()
         self._dataPositions = {
-            "RFFlag": 0, "GNSSFlag": 1, "RFIDFlag": 2, "FLASHFlag": 3, "RTCSFlag": 4, "MODEFlag": 5, "NBAT": 6, "TIMEAC": 7, "ESTAC": 8, "DSTRPT": 9, "INESTPT": 10, "OFFSPT": 11, "DSTRFT": 12, "INESTFT": 13, "OFFSFT": 14, "PMSTFlag": 15, "GYROX": 16, "GYROY": 17, "GYROZ": 18, "ACELX": 19, "ACELY": 20, "ACELZ": 21, "ESTMOFlag": 22, "ESTORFlag": 23, "SBAT": 24, "VBAT": 25, "CBAT": 26, "ESTBMSFlag": 27, "FIX": 28, "SIV": 29}
+            "RFFlag": 0, "GNSSFlag": 1, "RFIDFlag": 2, "FLASHFlag": 3, "RTCSFlag": 4,
+            "MODEFlag": 5, "NBAT": 6, "TIMEAC": 7, "ESTAC": 8, "DSTRPT": 9,
+            "INESTPT": 10, "OFFSPT": 11, "DSTRFT": 12, "INESTFT": 13, "OFFSFT": 14,
+            "PMSTFlag": 15, "GYROX": 16, "GYROY": 17, "GYROZ": 18, "ACELX": 19, "ACELY": 20,
+            "ACELZ": 21, "ESTMOFlag": 22, "ESTORFlag": 23, "SBAT": 24, "VBAT": 25, "CBAT": 26,
+            "ESTBMSFlag": 27, "FIX": 28, "SIV": 29}
         
         # self.kilometers = kwargs.pop('kilometers', 0)
         self.is_fitted = False
 
     def fit(self, X, y=None):
-        """Método para generar datos a partir de la metadata."""
+        """Método para generar datos a partir de la metadata.
+        
+        Args:
+         - X: Es un array con los datos provenientes (strings) de la base de datos histórica. La forma de X es (n,1) donde n es la cantidad de datos.
+        """
 
         ##chequeamos si todos los strings de X tienen la misma longitud, sino arrojamos un assert
         assert all(len(x) == len(X[0]) for x in X), "Todos los strings de X deben tener la misma longitud"
@@ -93,7 +102,11 @@ class TLMSensorDataExtractor(BaseEstimator, TransformerMixin):
 
 
     def transform(self, X, y=None):
-        """Transforma los datos de entrada en un array de numpy."""
+        """Transforma los datos de entrada en un array de numpy.
+
+        Args:
+         - X: Es un array con los datos provenientes (strings) de la base de datos histórica. La forma de X es (n,1) donde n es la cantidad de datos.
+        """
         
         ##chequeamos si se ha llamado a fit(). Sino, se arroja un error
         if not self.is_fitted:
@@ -131,7 +144,11 @@ class TLMSensorDataExtractor(BaseEstimator, TransformerMixin):
                             self._SIV]).T
 
     def fit_transform(self, X, y=None):
-        """Combinamos fit() y transform() en un solo método."""
+        """Combinamos fit() y transform() en un solo método.
+        
+        Args:
+         - X: Es un array con los datos provenientes (strings) de la base de datos histórica. La forma de X es (n,1) donde n es la cantidad de datos.
+        """
         self.fit(X)
         return self.transform(X)
 

sarapy/preprocessing/DistancesImputer.py

@@ -0,0 +1,183 @@
+###Documentación en https://github.com/lucasbaldezzari/sarapy/blob/main/docs/Docs.md
+
+import numpy as np
+from sklearn.base import BaseEstimator, TransformerMixin
+from sarapy.dataProcessing import TLMSensorDataExtractor, TimeSeriesProcessor, GeoProcessor
+
+class DistancesImputer(BaseEstimator, TransformerMixin):
+    """La clase PlantinDataImuter 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.
+    """
+    
+    def __init__(self, distanciaMedia:float = 1.8, umbral_mismo_lugar:float = 0.3, umbral_ratio_dCdP:float = 0.5, deltaO_medio = 4, keepDims = False, columnToImpute = 0):
+        """Constructor de la clase PlantinDataImputer.
+        
+        Args:
+            - distanciaMedia: Distancia media entre operaciones.
+            - umbral_mismo_lugar: Umbral para considerar que dos operaciones son el mismo lugar.
+            - umbral_ratio_dCdP: Umbral para el ratio entre el delta de caminata y el delta de pico abierto.
+            - deltaO_medio: delta de operación medio entre operaciones.
+            - 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.is_fitted = False
+        self._distanciaMedia = distanciaMedia
+        self._umbral_mismo_lugar = umbral_mismo_lugar
+        self._umbral_ratio_dCdP = umbral_ratio_dCdP
+        self._deltaO_medio = deltaO_medio
+        self._keepDims = keepDims
+        self._columnToImpute = columnToImpute
+        self._dataPositions = {"distancias":0} #posición de los datos en el array devuelto por transform()
+        
+    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,6)Las columnas de X son,
+                - 0: distancia entre operaciones
+                - 1: presición del GPS
+                - 2: GNSSflag. Nandera para saber si hay dato GPS, donde 0 es que hay dato y 1 que no hay dato
+                - 3: FIX bandera para tipo de fijación GNSS (ver valores enhttps://trello.com/c/M6DWjpwr/70-definici%C3%B3n-metadatos-a-relevar)
+                - 4: deltaO
+                - 5: ratio_dCdP
+                
+        NOTA: En versiones futuras se considerarán los datos de la posición (vertical, horizontal, etc) del sarapico
+        """
+        
+        ##agregar asserts y warnings
+        
+        self._distancias = X[:,0] #distancias
+        self._precision = X[:,1]
+        self._GNSSflag = X[:,2]
+        self._FIX = X[:,3]
+        self._deltaO = X[:,4]
+        self._ratio_dCdP = X[:,5]
+        
+    def transform(self, X:np.array, y = None):
+        """Aplica las imputaciones para transformar el objeto y retorna el array transformado.
+        
+        Args:
+            - X: Es un array con los datos provenientes (strings) de la base de datos histórica. La forma de X es (n,6)Las columnas de X son,
+            
+        Returns:
+            - updatedDistances: Array con las distancias imputadas.
+        """
+        
+        
+        self._updatedDistances = self._imputeDistance()
+        ##si keepDims es True, devolvemos x con las mismas dimensiones que el array de entrada. Los valores de self._updatedDistances se colocan en self._columnToImpute
+        if not self._keepDims:
+            return self._updatedDistances
+
+        else:
+            X[:,self._columnToImpute] = self._updatedDistances
+            return X
+        
+    def fit_transform(self, X:np.array, y = None):
+        """Fitea y aplica las imputaciones para transformar el objeto. Retorna el array transformado.
+        
+        Args:
+            - X: Es un array con los datos provenientes (strings) de la base de datos histórica. La forma de X es (n,6)Las columnas de X son,
+            
+        Returns:
+            - updatedDistances: Array con las distancias imputadas.
+        """
+        self.fit(X)
+        return self.transform(X)
+    
+    def _imputeDistance(self):
+        """Imputa la distancia entre operaciones.
+        
+        Si GNSSflag = 0, hay dato GPS, si GNSSflag = 1, no hay dato GPS.
+        Si la precisión es menor al umbral del mismo lugar entonces se considera que la precision es buena.
+
+        Luego, 
+
+        Caso 0: GNSSflag = 0 y precision < umbral_mismo_lugar -> la distancia no cambia
+        Caso 1: GNSSflag = 0 y precision > umbral_mismo_lugar -> la distancia se reemplazará por la distancia media si el ratio_dCdP es mayor al umbral_ratio_dCdP, sino por la distancia umbral_mismo_lugar
+        """
+        
+        caso1_indexes = np.where((self._GNSSflag == 0) & (self._precision > self._umbral_mismo_lugar))
+        
+        #copiamos self._distances en updatedDistances
+        updatedDistances = self._distancias
+        
+        if len(caso1_indexes[0]) > 0:
+            updatedDistances[caso1_indexes] = np.vectorize(lambda x: self._umbral_mismo_lugar
+                                                        if x < self._umbral_ratio_dCdP
+                                                        else self._distanciaMedia)(self.ratio_dCdP[caso1_indexes])
+        
+        return updatedDistances
+
+    def _checkDeltaTimes(self, ratio_dCdP):
+        """Chqequea que el ratio_dCdP"""
+
+        return self._umbral_mismo_lugar if ratio_dCdP < self._umbral_ratio_dCdP else self._distanciaMedia
+    
+    @property
+    def distancias(self):
+        return self._distancias
+    
+    @property
+    def precision(self):
+        return self._precision
+    
+    @property
+    def GNSSflag(self):
+        return self._GNSSflag
+    
+    @property
+    def FIX(self):
+        return self._FIX
+    
+    @property
+    def deltaO(self):
+        return self._deltaO
+    
+    @property
+    def ratio_dCdP(self):
+        return self._ratio_dCdP
+    
+    @property
+    def updatedDistances(self):
+        return self._updatedDistances
+    
+
+if __name__ == "__main__":
+    tlmda = TLMSensorDataExtractor()
+    tsa = TimeSeriesProcessor()
+    gpa = GeoProcessor()
+
+    ##datos de ejemplo
+    tlmsbp_sample = np.array(['0010001000010010110000011000000111111101001000000000000000000000',
+                              '0010001000010100110000011000000111111101001000000000000000000000',
+                              '0010001000010000110000011000000111111101001000000000000000000000',
+                              '0010001000011010110000011000110111111101001000000000000000000000'])
+    
+    date_oprc = np.array([35235, 35240, 35244, 35248])
+    lats = np.array(["-32.331093", "-32.331116", "-32.331131", "-32.331146"]).astype(float)
+    lons = np.array(["-57.229733", "-57.229733", "-57.229733", "-57.22974"]).astype(float)
+
+    precisiones = np.array([1, 0.1, 0.1, 1])
+
+    tlmda_data = tlmda.fit_transform(tlmsbp_sample)
+    timesAC = tlmda.ESTAC
+
+    time_data = np.hstack((date_oprc.reshape(-1, 1), timesAC.reshape(-1, 1)))
+    tsa_data = tsa.fit_transform(time_data)
+
+    ##genero puntos donde la primer columna es latitud y la segunda longitud
+    puntos = np.hstack((lats.reshape(-1, 1), lons.reshape(-1, 1)))
+    distancias = gpa.fit_transform(puntos)
+
+    X = np.hstack((distancias.reshape(-1, 1),
+                   precisiones.reshape(-1, 1),
+                   tlmda.GNSSFlag.reshape(-1,1),
+                   tlmda.FIX.reshape(-1,1), tsa.deltaO.reshape(-1,1),
+                   tsa.ratio_dCdP.reshape(-1,1)))
+    
+    distanceimputer = DistancesImputer()
+    distanceimputer.fit(X)
+
+    print(distanceimputer.transform(X))
+    print(distanceimputer.fit_transform(X))

sarapy/preprocessing/__init__.py

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

sarapy/version.py

@@ -1,2 +1,2 @@
 ## Version of the package   
-__version__ = "0.3.4"
+__version__ = "0.3.6"

{sarapy-0.3.4.dist-info → sarapy-0.3.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sarapy
-Version: 0.3.4
+Version: 0.3.6
 Summary: Library for Sarapico Metadata processing
 Home-page: https://github.com/lucasbaldezzari/sarapy
 Author: Lucas Baldezzari
@@ -24,6 +24,14 @@ Requires-Dist: geopy
 
 Library for processing SARAPICO project metadata of _AMG_.
 
+#### Version 0.3.6
+
+- Se agregan argumentos al constructor de _DistanceImputer_ 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 _DistanceImputer_.
+
 #### Version 0.3.4
 
 - Se actializa _dataPositions_ de PlantinFMCreator.

sarapy-0.3.6.dist-info/RECORD

@@ -0,0 +1,13 @@
+sarapy/__init__.py,sha256=aVoywqGSscYYDycLaYJnz08dlQabl9gH0h4Q5KtHM9o,74
+sarapy/version.py,sha256=hlwLRq9vgi9nmtXJZ2kG4AVJO9XRlrbyBz0GyHts1rA,51
+sarapy/dataProcessing/GeoProcessor.py,sha256=E9cZesfgTGk0fqENr9aO-ywRIqUCu3e5TjZ_CR5FyX4,4371
+sarapy/dataProcessing/PlantinFMCreator.py,sha256=CmaQUk7sLGTaSRwXVoamFbuHcG2nythow69i8pBKN18,7516
+sarapy/dataProcessing/TLMSensorDataExtractor.py,sha256=VPpAi2nZ6nQ7m5l3c78ElrqUztZlXH8ThZRPuz0_0xg,23817
+sarapy/dataProcessing/TimeSeriesProcessor.py,sha256=dAFahvctu7MWej2oliNMHuGAIsb6dhvzT1NWgMZfjOo,5398
+sarapy/dataProcessing/__init__.py,sha256=hloD9T6eugfTCiNmuaqO--Qaqnh4gJ7O2szR5fFU9M0,200
+sarapy/preprocessing/DistancesImputer.py,sha256=kPSEkncO5QQL1weC_HUoihmVO4Rbt8tNQV-ltofG4j0,8034
+sarapy/preprocessing/__init__.py,sha256=Eo1KwtWQC_45D8dIG82R8PmvfF2ljEaDNAW1yv9VRfo,46
+sarapy-0.3.6.dist-info/METADATA,sha256=KYfEMX6RNYqGav2F4Wwddbt5efVMNquaaqH1FtmnKTg,3757
+sarapy-0.3.6.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+sarapy-0.3.6.dist-info/top_level.txt,sha256=4mUGZXfX2Fw47fpY6MQkaJeuOs_8tbjLkkNp34DJWiA,7
+sarapy-0.3.6.dist-info/RECORD,,

sarapy-0.3.4.dist-info/RECORD

@@ -1,11 +0,0 @@
-sarapy/__init__.py,sha256=aVoywqGSscYYDycLaYJnz08dlQabl9gH0h4Q5KtHM9o,74
-sarapy/version.py,sha256=-B7EJFpS9DSYr1EAJCBw-EhvAaq7JnIVI26mlxWP71M,51
-sarapy/dataProcessing/GeoProcessor.py,sha256=E9cZesfgTGk0fqENr9aO-ywRIqUCu3e5TjZ_CR5FyX4,4371
-sarapy/dataProcessing/PlantinFMCreator.py,sha256=CmaQUk7sLGTaSRwXVoamFbuHcG2nythow69i8pBKN18,7516
-sarapy/dataProcessing/TLMSensorDataExtractor.py,sha256=0WR0TIioZFFsaYUbOXwqEcvf226Y1K9I5jmpR2iXW_Q,23199
-sarapy/dataProcessing/TimeSeriesProcessor.py,sha256=dAFahvctu7MWej2oliNMHuGAIsb6dhvzT1NWgMZfjOo,5398
-sarapy/dataProcessing/__init__.py,sha256=hloD9T6eugfTCiNmuaqO--Qaqnh4gJ7O2szR5fFU9M0,200
-sarapy-0.3.4.dist-info/METADATA,sha256=gax5t7Q1Ij_DFL6IxMH4nealBivsCEPFB-_HNtCcqhk,3483
-sarapy-0.3.4.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-sarapy-0.3.4.dist-info/top_level.txt,sha256=4mUGZXfX2Fw47fpY6MQkaJeuOs_8tbjLkkNp34DJWiA,7
-sarapy-0.3.4.dist-info/RECORD,,