sarapy 0.1.4__tar.gz → 0.2.1__tar.gz

{sarapy-0.1.4 → sarapy-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sarapy
-Version: 0.1.4
+Version: 0.2.1
 Summary: Library for Sarapico Metadata processing
 Home-page: https://github.com/lucasbaldezzari/sarapy
 Author: Lucas Baldezzari
@@ -24,6 +24,16 @@ Requires-Dist: geopy
 
 Library for processing SARAPICO project metadata of _AMG_.
 
+#### 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.

{sarapy-0.1.4 → sarapy-0.2.1}/README.md

@@ -2,6 +2,16 @@
 
 Library for processing SARAPICO project metadata of _AMG_.
 
+#### 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.

{sarapy-0.1.4 → sarapy-0.2.1}/pyproject.toml

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

sarapy-0.2.1/sarapy/dataProcessing/GeoAnalyzer.py

@@ -0,0 +1,116 @@
+###Documentación en https://github.com/lucasbaldezzari/sarapy/blob/main/docs/Readme.md
+
+import numpy as np
+from geopy.distance import geodesic
+from sklearn.base import BaseEstimator, TransformerMixin
+import warnings
+
+class GeoAnalyzer(BaseEstimator, TransformerMixin):
+    """La clase GeoAnalyzer se encarga de gestionar los datos de georreferenciación."""
+    
+    # _GeoPoint = Tuple[float, float]
+    
+    def __init__(self):
+        """Inicializa la clase GeoAnalyzer."""
+        
+        self._points = None #np.array de tuplas con las coordenadas de latitud y longitud
+        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. 
+
+        Parametros
+            p1 (tuple): np.array de tuplas con las coordenadas de latitud y longitud del punto 1
+            p2 (tuple): np.array de tuplas con las coordenadas de latitud y longitud del punto 2
+
+        Returns:
+            float: np.array con las distancias entre los dos puntos
+        """
+        
+        ##aplicamos la función geodesic
+        return geodesic(point1, point2).meters
+        
+    def fit(self, X: np.array, y=None)-> np.array:
+        """fittea el objeto
+        
+        - X: array con los puntos de latitud y longitud. Shape (n, 2)
+        """
+        ##asserteamos que X sea un np.array
+        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"
+        ##chequeamos que X tenga una sola fila, si es así, enviamos un warning y agregamos una fila copiando la única fila que tiene
+        if X.shape[0] == 1:
+            warnings.warn("X tiene una sola fila, se agregará una fila copiando la única fila que tiene")
+            X = np.vstack((X, X))
+
+        self._points = X
+        self.is_fitted = True
+        
+    def transform(self, X, y=None):
+        """Transforma los datos de X en distancias entre los puntos.
+        
+        - X: array con los puntos de latitud y longitud. Shape (n, 2)-
+        
+        Returns:
+            np.array: np.array con las distancias entre los dos puntos
+        """
+        if not self.is_fitted:
+            raise RuntimeError("El modelo no ha sido fitteado.")
+            
+        ##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)
+        
+        return self._distances
+
+    def fit_transform(self, X, y=None):
+        """Fit y transforma los datos de X en distancias entre los puntos.
+        
+        - X: datos de entrenamiento
+        
+        Returns:
+            np.array: np.array con las distancias entre los dos puntos
+        """
+        self.fit(X)
+        return self.transform(self.points)
+        
+    @property
+    def points(self):
+        """Devuelve los puntos de georreferenciación."""
+        return self._points
+    
+    @property
+    def distances(self):
+        """Devuelve las distancias entre los puntos."""
+        ##chqueamos que el modelo haya sido fitteado
+        if not self.is_fitted:
+            warnings.warn("El modelo no ha sido fitteado.")
+            return None
+        else:
+            return self._distances
+        
+        
+if __name__ == "__main__":
+    ga = GeoAnalyzer()
+
+    puntos = np.array([[-32.329910, -57.229061],
+              [	-32.329895, -57.229061],
+              [-32.329880, -57.229069],
+              [-32.329865, -57.229069]])
+    
+    ga.fit(puntos)
+    print(ga.transform(puntos))
+    print(ga.fit_transform(puntos))
+    print(ga.distances)
+    punto_referencia = puntos[0]
+    
+    sample = np.array([[-32.329910, -57.229061]])
+    
+    ga2 = GeoAnalyzer()
+    ga2.fit(sample)
+    ga2.points
+    print(ga2.fit_transform(sample))
+    print(ga2.distances)

{sarapy-0.1.4 → sarapy-0.2.1}/sarapy/dataProcessing/TLMSensorDataExtractor.py

@@ -1,44 +1,15 @@
-"""
-La clase MetadataManager se encarga de gestionar los metadatos obtenidos de la base de datos. Estos metadatos se corresponden con los datos registrados en los sarapicos.
+###Documentación en https://github.com/lucasbaldezzari/sarapy/blob/main/docs/Readme.md
 
-- Versión de metadatos utilizada: Revision 9
-- Apuntes de identificiación: https://docs.google.com/document/d/1E-TvkMWqeL9d57FOeRH7Zk_Fr5SdmknnmuQ7n7uwUVg/edit#heading=h.3dy6vkm
-- Apuntes de
-- Apuntes de Desarrollo: 
-
-- Autor: BALDEZZARI Lucas
-"""
-
-##importamos numpy
 import numpy as np
-# from geopy.distance import geodesic
-
 from sklearn.base import BaseEstimator, TransformerMixin
 
 class TLMSensorDataExtractor(BaseEstimator, TransformerMixin):
-    """
-    Clase que se encarga de procesar los metadatos obtenidos de la base de datos histórica.
-
-    - Versión de metadatos utilizada: Revision 9 
-    - Link documento metadato: https://trello.com/c/M6DWjpwr/70-definici%C3%B3n-metadatos-a-relevar
-    - Los metadatos de DATA_TLM en la Revisión 9 vienen en un string de 0 y 1. Estos valores indican, lo siguiente:
-    |RF(1bit)|GNSS(1bit)|RFID(1bit)|FLASH(1bit)|RTCS(1bit)|MODE(1bit)|NBAT(2bits)|TIMEAC(8bits)|ESTAC(1bit)|DSTR PT(4bits)|INEST PT(1bit)|OFFS PT(2bits)|X(1bit)|DSTR FT(4bits)|INEST FT(1bit)|OFFS FT(2bits)|X(1bit)|GYRO_X(3bits)|GYRO_Y(3bits)|GYRO_Z(2bits)|ACEL_X(2bits)|ACEL_Y(2bits)|ACEL_Z(2bits)|EST MO(1bit)|EST OR(1bit)|SBAT(2bits)|VBAT(3bits)|CBAT(2bits)|EST BMS(1bit)
-    
-    Los valores X indican bit sin uso.
-
-    - Versión 1.0.0.RevA
-    - Autor: BALDEZZARI Lucas
-    """
+    """- Autor: BALDEZZARI Lucas"""
     
     __metadataVersion = "Revision 9" #Versión de metadatos utilizada
 
     def __init__(self, *args, **kwargs):
-        """
-        Constructor de la clase MetadataManager.
-
-        :param metadata: Diccionario con los metadatos obtenidos de la base de datos.
-        :type metadata: strg
-        """
+        """Constructor de la clase MetadataManager."""
 
         ### Creamos constantes que sirven para buscar los datos en el string de telemetría
         ### Cada constante es una tupla con la posición del bit menos significativo y la posición del bit más significativo
@@ -75,113 +46,82 @@ class TLMSensorDataExtractor(BaseEstimator, TransformerMixin):
         self.is_fitted = False
 
     def fit(self, X, y=None):
-        """
-        Método para generar datos a partir de la metadata.
-
-        X es un array de strings. Cada string es un dato de la metadata.
-
-        Extraigo información de cada fila de X. Genero numpys array de cada dato extraido de la metadata.
-
-        Parametros
-        ----------
-            X: Array de strings.
-            y: None
-                No se utiliza.
-        """
+        """Método para generar datos a partir de la metadata."""
 
         ##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"
 
-        self.RFFlag = np.vectorize(self.getRFFlag)(X)
-        self.GNSSFlag = np.vectorize(self.getGNSSFlag)(X)
-        self.RFIDFlag = np.vectorize(self.getRFIDFlag)(X)
-        self.FLASHFlag = np.vectorize(self.getFLASHFlag)(X)
-        self.RTCSFlag = np.vectorize(self.getRTCSFlag)(X)
-        self.MODEFlag = np.vectorize(self.getMODEFlag)(X)
-        self.NBAT = np.vectorize(self.getNBAT)(X)
-        self.TIMEAC = np.vectorize(self.getTIMEAC)(X)
-        self.ESTAC = np.vectorize(self.getESTAC)(X)
-        self.DSTRPT = np.vectorize(self.getDSTRPT)(X)
-        self.INESTPT = np.vectorize(self.getINESTPTFlag)(X)
-        self.OFFSPT = np.vectorize(self.getOFFSPT)(X)
-        self.DSTRFT = np.vectorize(self.getDSTRFT)(X)
-        self.INESTFT = np.vectorize(self.getINESTFTFlag)(X)
-        self.OFFSFT = np.vectorize(self.getOFFSFT)(X)
-        self.PMSTFlag = np.vectorize(self.getPMSTFlag)(X)
-        self.GYROX = np.vectorize(self.getGYROX)(X)
-        self.GYROY = np.vectorize(self.getGYROY)(X)
-        self.GYROZ = np.vectorize(self.getGYROZ)(X)
-        self.ACELX = np.vectorize(self.getACELX)(X)
-        self.ACELY = np.vectorize(self.getACELY)(X)
-        self.ACELZ = np.vectorize(self.getACELZ)(X)
-        self.ESTMOFlag = np.vectorize(self.getESTMOFlag)(X)
-        self.ESTORFlag = np.vectorize(self.getESTORFlag)(X)
-        self.SBAT = np.vectorize(self.getSBAT)(X)
-        self.VBAT = np.vectorize(self.getVBAT)(X)
-        self.CBAT = np.vectorize(self.getCBAT)(X)
-        self.ESTBMSFlag = np.vectorize(self.getESTBMSFlag)(X)
+        self._RFFlag = np.vectorize(self.getRFFlag)(X)
+        self._GNSSFlag = np.vectorize(self.getGNSSFlag)(X)
+        self._RFIDFlag = np.vectorize(self.getRFIDFlag)(X)
+        self._FLASHFlag = np.vectorize(self.getFLASHFlag)(X)
+        self._RTCSFlag = np.vectorize(self.getRTCSFlag)(X)
+        self._MODEFlag = np.vectorize(self.getMODEFlag)(X)
+        self._NBAT = np.vectorize(self.getNBAT)(X)
+        self._TIMEAC = np.vectorize(self.getTIMEAC)(X)
+        self._ESTAC = np.vectorize(self.getESTAC)(X)
+        self._DSTRPT = np.vectorize(self.getDSTRPT)(X)
+        self._INESTPT = np.vectorize(self.getINESTPTFlag)(X)
+        self._OFFSPT = np.vectorize(self.getOFFSPT)(X)
+        self._DSTRFT = np.vectorize(self.getDSTRFT)(X)
+        self._INESTFT = np.vectorize(self.getINESTFTFlag)(X)
+        self._OFFSFT = np.vectorize(self.getOFFSFT)(X)
+        self._PMSTFlag = np.vectorize(self.getPMSTFlag)(X)
+        self._GYROX = np.vectorize(self.getGYROX)(X)
+        self._GYROY = np.vectorize(self.getGYROY)(X)
+        self._GYROZ = np.vectorize(self.getGYROZ)(X)
+        self._ACELX = np.vectorize(self.getACELX)(X)
+        self._ACELY = np.vectorize(self.getACELY)(X)
+        self._ACELZ = np.vectorize(self.getACELZ)(X)
+        self._ESTMOFlag = np.vectorize(self.getESTMOFlag)(X)
+        self._ESTORFlag = np.vectorize(self.getESTORFlag)(X)
+        self._SBAT = np.vectorize(self.getSBAT)(X)
+        self._VBAT = np.vectorize(self.getVBAT)(X)
+        self._CBAT = np.vectorize(self.getCBAT)(X)
+        self._ESTBMSFlag = np.vectorize(self.getESTBMSFlag)(X)
 
         self.is_fitted = True
-        
+
 
     def transform(self, X, y=None):
-        """Genera un array de numpy con los datos extraidos de la metadata.
-        
-        Forma una matriz de numpy.
-        
-        Parametros
-        ----------
-            X: X es un array de strings. Cada string es un dato de la metadata.
-            y: None
-                No se utiliza."""
+        """
+                """
         
         ##chequeamos si se ha llamado a fit(). Sino, se arroja un error
         if not self.is_fitted:
             raise ValueError("MetadataManager no ha sido fitteado. Llame a fit() previamente.")
         
-        return np.array([   self.RFFlag,
-                            self.GNSSFlag,
-                            self.RFIDFlag,
-                            self.FLASHFlag,
-                            self.RTCSFlag,
-                            self.MODEFlag,
-                            self.NBAT,
-                            self.TIMEAC,
-                            self.ESTAC,
-                            self.DSTRPT,
-                            self.INESTPT,
-                            self.OFFSPT,
-                            self.DSTRFT,
-                            self.INESTFT,
-                            self.OFFSFT,
-                            self.PMSTFlag,
-                            self.GYROX,
-                            self.GYROY,
-                            self.GYROZ,
-                            self.ACELX,
-                            self.ACELY,
-                            self.ACELZ,
-                            self.ESTMOFlag,
-                            self.ESTORFlag,
-                            self.SBAT,
-                            self.VBAT,
-                            self.CBAT,
-                            self.ESTBMSFlag]).T
+        return np.array([   self._RFFlag,
+                            self._GNSSFlag,
+                            self._RFIDFlag,
+                            self._FLASHFlag,
+                            self._RTCSFlag,
+                            self._MODEFlag,
+                            self._NBAT,
+                            self._TIMEAC,
+                            self._ESTAC,
+                            self._DSTRPT,
+                            self._INESTPT,
+                            self._OFFSPT,
+                            self._DSTRFT,
+                            self._INESTFT,
+                            self._OFFSFT,
+                            self._PMSTFlag,
+                            self._GYROX,
+                            self._GYROY,
+                            self._GYROZ,
+                            self._ACELX,
+                            self._ACELY,
+                            self._ACELZ,
+                            self._ESTMOFlag,
+                            self._ESTORFlag,
+                            self._SBAT,
+                            self._VBAT,
+                            self._CBAT,
+                            self._ESTBMSFlag]).T
 
     def fit_transform(self, X, y=None):
-        """Combinamos fit() y transform() en un solo método.
-        
-        Parametros
-        ----------
-            X: X es un array de strings. Cada string es un dato de la metadata.
-            y: None
-                No se utiliza.
-        
-        Return
-        ------
-            numpy array:
-                Array de numpy con los datos extraidos de la metadata.
-                """
+        """Combinamos fit() y transform() en un solo método."""
         self.fit(X)
         return self.transform(X)
 
@@ -638,6 +578,118 @@ class TLMSensorDataExtractor(BaseEstimator, TransformerMixin):
         return np.uint8(int(metadata[self.__ESTBMSflag_pos[0]:self.__ESTBMSflag_pos[1]+1],2))
     
             
+    @property
+    def RFFlag(self):
+        return self._RFFlag
+    
+    @property
+    def GNSSFlag(self):
+        return self._GNSSFlag
+    
+    @property
+    def RFIDFlag(self):
+        return self._RFIDFlag
+    
+    @property
+    def FLASHFlag(self):
+        return self._FLASHFlag
+    
+    @property
+    def RTCSFlag(self):
+        return self._RTCSFlag
+    
+    @property
+    def MODEFlag(self):
+        return self._MODEFlag
+    
+    @property
+    def NBAT(self):
+        return self._NBAT
+    
+    @property
+    def TIMEAC(self):
+        return self._TIMEAC
+    
+    @property
+    def ESTAC(self):
+        return self._ESTAC
+    
+    @property
+    def DSTRPT(self):
+        return self._DSTRPT
+    
+    @property
+    def INESTPT(self):
+        return self._INESTPT
+    
+    @property
+    def OFFSPT(self):
+        return self._OFFSPT
+    
+    @property
+    def DSTRFT(self):
+        return self._DSTRFT
+    
+    @property
+    def INESTFT(self):
+        return self._INESTFT
+    
+    @property
+    def OFFSFT(self):
+        return self._OFFSFT
+    
+    @property
+    def PMSTFlag(self):
+        return self._PMSTFlag
+    
+    @property
+    def GYROX(self):
+        return self._GYROX
+    
+    @property
+    def GYROY(self):
+        return self._GYROY
+    
+    @property
+    def GYROZ(self):
+        return self._GYROZ
+    
+    @property
+    def ACELX(self):
+        return self._ACELX
+    
+    @property
+    def ACELY(self):
+        return self._ACELY
+    
+    @property
+    def ACELZ(self):
+        return self._ACELZ
+    
+    @property
+    def ESTMOFlag(self):
+        return self._ESTMOFlag
+    
+    @property
+    def ESTORFlag(self):
+        return self._ESTORFlag
+    
+    @property
+    def SBAT(self):
+        return self._SBAT
+    
+    @property
+    def VBAT(self):
+        return self._VBAT
+    
+    @property
+    def CBAT(self):
+        return self._CBAT
+    
+    @property
+    def ESTBMSFlag(self):
+        return self._ESTBMSFlag
+    
     @classmethod
     def getMetadataRevisionNumber(cls):
         """
@@ -652,7 +704,7 @@ class TLMSensorDataExtractor(BaseEstimator, TransformerMixin):
     
 if __name__ == "__main__":
     tlmsde = TLMSensorDataExtractor()
-    print(tlmsde.getMetadataRevisionNumber())
+    print(tlmsde.getMetadataRevisionNumber())   
 
     sample = np.array(["1010001000010000110000001011000000000000000000001111011010001001",
               "1010001000010000110000001011000000000000000000001111011010001001"])
@@ -660,4 +712,6 @@ if __name__ == "__main__":
     tlmsde.getTIMEAC(sample[0])
 
     # tlmsde.fit(sample)
-    print(tlmsde.fit_transform(sample))
+    print(tlmsde.fit_transform(sample))
+    
+    print(tlmsde.TIMEAC)

sarapy-0.2.1/sarapy/dataProcessing/TimeSeriesProcessor.py

@@ -0,0 +1,105 @@
+###Documentación en https://github.com/lucasbaldezzari/sarapy/blob/main/docs/Readme.md
+
+import numpy as np
+from sklearn.base import BaseEstimator, TransformerMixin
+import warnings
+from datetime import datetime
+
+class TimeSeriesProcessor(BaseEstimator, TransformerMixin):
+    """"
+    - Autor: BALDEZZARI Lucas
+    - Creación: 8 de enero de 2024
+    """
+    
+    def __init__(self):
+        """Inicializa la clase TimeSeriesProcessor."""
+        
+        self.is_fitted = False
+        
+    def fit(self, X: np.array, y=None)-> np.array:
+        """Fittea el objeto"""
+
+        ##asserteamos que X sea un np.array
+        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"
+        ##chequeamos que X tenga una sola fila, si es así, enviamos un warning y agregamos una fila copiando la única fila que tiene
+        if X.shape[0] == 1:
+            warnings.warn("X tiene una sola fila, se agregará una fila copiando la única fila que tiene")
+            X = np.vstack((X, X))
+            
+        ##calculamos la diferencia entre los timestamps. La forma de calcular estos tiempos se enecuentra en los apuntes de identificación "Intervalos de tiempo" del siguiente link:
+        #https://drive.google.com/file/d/1I7a_AHsGI2n5gPBOBT_oRmsqm-xt9kI9/view?usp=sharing
+        
+        self._deltaO = np.diff(X[:,0]) #deltaO = Ttiempo operación siguiente - Ttiempo operación actual
+        ##agrego un 0 al principio de la serie
+        # self._deltaO = np.hstack((0, self._deltaO))
+        self._deltaP = X[:,1][1:]
+        self._deltaC = self._deltaO - self._deltaP
+        ##hago cero el primer vlaor de deltaC
+        
+        self.is_fitted = True
+    
+    def transform(self, X: np.array):
+        """Genera un array con los tiempos de operación, caminata y pico abierto."""
+        
+        if not self.is_fitted:
+            raise RuntimeError("El modelo no ha sido fitteado.")
+        
+        return np.hstack((self._deltaO.reshape(-1, 1), self._deltaC.reshape(-1, 1), self._deltaP.reshape(-1, 1))).round(2)
+    
+    def fit_transform(self, X: np.array, y=None):
+        self.fit(X)
+        return self.transform(X)
+    
+    @property
+    def deltaO(self):
+        """Devuelve el tiempo de operación."""
+        return self._deltaO
+    
+    @property
+    def deltaC(self):
+        """Devuelve el tiempo de caminata."""
+        return self._deltaC
+    
+    @property
+    def deltaP(self):
+        """Devuelve el tiempo de pico abierto."""
+        return self._deltaP
+    
+if __name__ == "__main__":
+    timestamps = np.array([1697724423, 1697724428, 1697724430, 1697724433])
+    tlm_data = np.array(["0010001000001100110000001100001000000000000000001111111000110000",
+                         "0010001000001100110000101100000000000000000000001111111000110000",
+                         "0010001000001100101100101100000000000000000000001111111000110000",
+                         "0010001000001100101100001100000000000000000000001111111000110000"])
+    
+    from sarapy.dataProcessing import TLMSensorDataExtractor
+    tlm_extractor = TLMSensorDataExtractor()
+    tlm_extractor.fit(tlm_data)
+    
+    deltaPicos = tlm_extractor.TIMEAC
+
+    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)
+    
+    ### PROBAMOS QUÉ SUCEDE SI TENEMOS UNA SOLA FILA
+    tlm_data2 = np.array(["0010001000001100110000001100001000000000000000001111111000110000"])
+    timestamps2 = np.array([1697724423])
+    
+    tmsp2 = TimeSeriesProcessor() 
+    tlm_extractor2 = TLMSensorDataExtractor()
+    
+    tlm_extractor2.fit(tlm_data2)
+    
+    X2 = np.hstack((timestamps2.reshape(-1, 1), tlm_extractor2.TIMEAC.reshape(-1, 1)))
+    
+    tmsp2.fit(X2)
+    tmsp2.transform(X2)

sarapy-0.2.1/sarapy/dataProcessing/__init__.py

@@ -0,0 +1,3 @@
+from .TLMSensorDataExtractor import TLMSensorDataExtractor
+from .GeoAnalyzer import GeoAnalyzer
+from .TimeSeriesProcessor import TimeSeriesProcessor

{sarapy-0.1.4 → sarapy-0.2.1}/sarapy/version.py

@@ -1,2 +1,2 @@
 ## Version of the package   
-__version__ = "0.1.4"
+__version__ = "0.2.1"

{sarapy-0.1.4 → sarapy-0.2.1}/sarapy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sarapy
-Version: 0.1.4
+Version: 0.2.1
 Summary: Library for Sarapico Metadata processing
 Home-page: https://github.com/lucasbaldezzari/sarapy
 Author: Lucas Baldezzari
@@ -24,6 +24,16 @@ Requires-Dist: geopy
 
 Library for processing SARAPICO project metadata of _AMG_.
 
+#### 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.

{sarapy-0.1.4 → sarapy-0.2.1}/sarapy.egg-info/SOURCES.txt

@@ -8,5 +8,7 @@ sarapy.egg-info/SOURCES.txt
 sarapy.egg-info/dependency_links.txt
 sarapy.egg-info/requires.txt
 sarapy.egg-info/top_level.txt
+sarapy/dataProcessing/GeoAnalyzer.py
 sarapy/dataProcessing/TLMSensorDataExtractor.py
+sarapy/dataProcessing/TimeSeriesProcessor.py
 sarapy/dataProcessing/__init__.py

sarapy-0.1.4/sarapy/dataProcessing/__init__.py

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