sarapy 2.2.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

sarapy/utils/utils.py

@@ -0,0 +1,172 @@
+from typing import List, Tuple
+
+import numpy as np
+import pandas as pd
+from pathlib import Path
+from sarapy.analysis.FeaturesResume import FeaturesResume
+
+def dataMerging(historical_data, post_processing_data, raw_data, nodoName = None, newColumns = False, asDF = False):
+    """
+    Función para tomar historical_data y post_processing_data y formar una 
+    sóla lista de diccionarios (json)
+
+    Si newColumns es False la función reemplaza los valores de tag_seedling y tag_fertilizer de historical_data,
+    sino genera dos nuevos campos llamados tag_seedling_classified y tag_fertilizer_estimated en historical_data.
+
+    Args:
+        - historical_data (list): Lista de diccionarios con datos históricos (tipo json)
+        - post_processing_data (list): Lista de diccionarios con datos de post-procesamiento (tipo json)
+        - nodoName (str|None): Nombre del nodo al que pertenecen los datos. Por defecto es None
+        - newColumns (bool): Indica si se deben crear nuevas columnas en lugar de reemplazar las existentes.
+        - asDF (bool): Indica si se debe retornar como un dataframe o no
+    """
+    #chequeo que historical_data y post_processing_data sean del mismo tamaño, sino rais
+    if len(historical_data) != len(post_processing_data):
+        raise ValueError("Las listas de datos históricos y de post-procesamiento no son del mismo tamaño.")
+
+    final_data = pd.DataFrame(historical_data)
+    post_data = pd.DataFrame(post_processing_data)
+    raw_data = pd.DataFrame(raw_data)
+
+    final_data['raw_tag_seedling'] = raw_data['raw_tag_seedling']
+    final_data['raw_tag_fertilizer'] = raw_data['raw_tag_fertilizer']
+
+    if not newColumns:
+        final_data['tag_seedling'] = post_data['tag_seedling']
+        final_data['tag_fertilizer'] = post_data['tag_fertilizer']
+    else:
+        final_data['tag_seedling_classified'] = post_data['tag_seedling']
+        final_data['tag_fertilizer_estimated'] = post_data['tag_fertilizer']
+
+    if nodoName:
+        final_data['nodo'] = nodoName
+
+    #retorno como lista de diccionarios (json)
+    if not asDF:
+        return final_data.to_dict(orient='records')
+    else:
+        return final_data
+
+def getOutliersThresholds(data, q1 = 0.25, q3 = 0.75, k = 1.5):
+    """Cálculo de los límites para detectar outliers a partir del rango intercuartil
+    
+    data: array con los datos
+    q1: primer cuartil
+    q3: tercer cuartil
+    k: factor de escala
+    """
+    # Calculo del rango intercuartil
+    q1 = np.quantile(data, q1)
+    q3 = np.quantile(data, q3)
+    iqr = q3 - q1
+
+    # Cálculo de los límites
+    lower = q1 - k * iqr
+    upper = q3 + k * iqr
+
+    return lower, upper
+
+
+def countingZeros(array: List[int], minimos_seguidos: int = 3) -> List[Tuple[int, int]]:
+    """
+    Cuenta ceros consecutivos en un array binario (0s y 1s), retornando una lista de tuplas.
+    Cada tupla (n, k) indica que se encontraron 'n' secuencias de 'k' ceros consecutivos,
+    siempre que k >= minimos_seguidos.
+    
+    Parameters:
+        array (List[int]): Lista binaria de 0s y 1s.
+        minimos_seguidos (int): Mínimo de ceros consecutivos a considerar.
+        
+    Returns:
+        List[Tuple[int, int]]: Lista de tuplas (n, k), ordenadas por k.
+    """
+    contador = 0
+    resultados = {}
+    indexes = []
+    for i, val in enumerate(array):
+        if val == 0:
+            contador += 1
+            indexes.append(i)
+        else:
+            if contador >= minimos_seguidos:
+                if contador in resultados.keys():
+                    resultados[contador][0] += 1
+                    resultados[contador][1] += (indexes,)
+                    indexes = []
+                else:
+                    resultados[contador] = [1, (indexes,)]
+                    indexes = []
+            contador = 0
+
+    # Por si la secuencia termina en ceros
+    if contador >= minimos_seguidos:
+        if contador in resultados.keys():
+            resultados[contador][0] += 1
+            resultados[contador][1] += (indexes,)
+            indexes = []
+        else:
+            resultados[contador] = [1, (indexes,)]
+
+    # retorna [cantidad de ocurrencias, longitud de ceros, indices de ocurrencias]
+    return sorted([(v[0], k, v[1]) for k, v in resultados.items()])
+
+def get_lat_long_from_indices(df: pd.DataFrame, indices: List[List[int]]) -> Tuple[float, float]:
+    """
+    Obtiene la latitud y longitud a partir de una lista de índices en un DataFrame.
+    
+    Parameters:
+        df (pd.DataFrame): DataFrame que contiene las columnas 'latitude' y 'longitude'.
+        indices (List[int]): Lista de listas de índices para buscar las coordenadas.
+        
+    Returns:
+        Tuple[float, float]: Tupla con la latitud y longitud correspondientes.
+    """
+    latitudes = []
+    longitudes = []
+    nodos = []
+    for index_list in indices:
+        for index in index_list:
+            latitudes.append(df.iloc[index]["latitude"])
+            longitudes.append(df.iloc[index]["longitude"])
+            nodos.append(df.iloc[index]["nodo"])
+    return [nodos, latitudes, longitudes]
+
+
+def readingFolders(raiz: str | Path, ignorar_ocultas: bool = True, ordenar: bool = True) -> list[str]:
+    raiz = Path(raiz)
+    if not raiz.is_dir():
+        raise NotADirectoryError(f"La ruta no es una carpeta: {raiz}")
+
+    nombres = [p.name for p in raiz.iterdir() if p.is_dir()]
+    if ignorar_ocultas:
+        nombres = [n for n in nombres if not n.startswith(".")]
+    if ordenar:
+        nombres.sort()
+    return nombres
+
+def computar_resumenes_por_filtro(nodos_ok, merged_cache, filtro, outliers):
+        """
+        Función para computar resúmenes filtrados por un criterio específico.
+        """
+        conteos, resumenes, dstp_ptmas, delta_dcdp, time_ac = {}, {}, {}, {}, {}
+        for nodo in nodos_ok:
+            fr = FeaturesResume(merged_cache[nodo], info=nodo, filtrar=filtro)
+            fr.removeOutliers(outliers)
+            conteos[nodo] = fr.data["tag_seedling"].value_counts(normalize=True)
+            resumenes[nodo] = fr.getResume(to="all")
+            dstp_ptmas[nodo] = fr.getSensorMA()
+            delta_dcdp[nodo] = fr.data["ratio_dCdP"]
+            time_ac[nodo] = fr.data["time_ac"]
+        return conteos, resumenes
+
+def metricas_desde_resumenes(nodos_ok, resumenes, stats):
+    """Devuelve dict nombre_metrica -> vector numpy en el orden de nodos_ok."""
+    return {
+        "nodo": [n for n in nodos_ok],
+        "time_ac":   np.array([resumenes[n]["time_ac"][stats]   for n in nodos_ok]),
+        "deltaO":    np.array([resumenes[n]["deltaO"][stats]    for n in nodos_ok]),
+        "ratio_dCdP":np.array([resumenes[n]["ratio_dCdP"][stats]for n in nodos_ok]),
+        "precision": np.array([resumenes[n]["precision"][stats] for n in nodos_ok]),
+        "distances": np.array([resumenes[n]["distances"][stats] for n in nodos_ok]),
+        "dst_pt":    np.array([resumenes[n]["dst_pt"][stats]    for n in nodos_ok]),
+    }

sarapy/version.py

@@ -1,2 +1,2 @@
-## Version of the package   
-__version__ = "2.2.0"
+## Version of the package
+__version__ = "3.0.0"

{sarapy-2.2.0.dist-info → sarapy-3.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sarapy
-Version: 2.2.0
+Version: 3.0.0
 Home-page: https://github.com/lucasbaldezzari/sarapy
 Author: Lucas Baldezzari
 Author-email: Lucas Baldezzari <lmbaldezzari@gmail.com>
@@ -19,6 +19,44 @@ Requires-Dist: geopy
 
 Library for processing SARAPICO project metadata of _AMG SA_.
 
+#### Version 3.0.0
+- Se mejora la forma de obtener valores de media movil para todas las variables en las que se usa.
+- Se corrigen bugs debido a nodos con pocas operaciones.
+- Se corrigen errores a la hora de pasar parámetros a los métodos de algunas clases.
+- Se configuran parámetros de fmcreator y plantin_classifier para el reetiquetado, los mismos son:
+
+kwargs_fmcreator = {"imputeDistances":True, "distanciaMedia":1.8, "umbral_precision":0.3,
+                        "dist_mismo_lugar":0.2, "max_dist":100,
+                        "umbral_ratio_dCdP":2, "deltaO_medio":4,
+                        "impute_ratiodcdp": True, "umbral_impute_ratiodcdp": -0.5,
+                        "deltaO_ma": True, "deltaO_ma_window": 26}
+            
+            
+    ##argumentos del método PlantinClassifier.clasiffy()
+    kwargs_classifier = {"proba_threshold":0.4,
+                         "use_proba_ma":False,
+                         "proba_ma_window":10,
+                         "update_samePlace":True,
+                         "update_dstpt":True,
+                         "umbral_proba_dstpt":0.5,
+                         "umbral_bajo_dstpt":1.5,
+                         "use_ma":True,
+                         "dstpt_ma_window":62,
+                         "use_min_dstpt":False,
+                         "factor":0.1,
+                         
+                         "useRatioStats":False,
+                         "std_weight":1.,
+                         "useDistancesStats":False,
+                         "ratio_dcdp_umbral":0.1,
+                         "dist_umbral":0.5,
+                         }
+
+#### Version 2.3.0
+
+- Se agregan funcionalidades.
+- Se corrigen errores menores.
+
 #### Version 2.2.0
 
 - Se agrega baseDeltaP en PlantinFMCreator para poder dividir el timestamp de la electrónica por 10, ya que se envía en décimas de segundo.

sarapy-3.0.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+sarapy/__init__.py,sha256=aVoywqGSscYYDycLaYJnz08dlQabl9gH0h4Q5KtHM9o,74
+sarapy/version.py,sha256=FwfAbPJHI1L9iu0rJTFUu9Rw3s7BA7POU73XKvHfy0E,48
+sarapy/analysis/FeaturesResume.py,sha256=fqKpDy7Py3QHUMtrS8r-KE25ah4HjkJxBKoZtHdORAQ,31946
+sarapy/analysis/__init__.py,sha256=i6QGXmnuA-k6Gh6639TinluogMhLGIiL-tiR_S2i2Ok,74
+sarapy/dataProcessing/GeoProcessor.py,sha256=ARjgKTXDVdf_cFCXyFmzlnmmmay3HG3q-yeJ9QrAcQU,5919
+sarapy/dataProcessing/OpsProcessor.py,sha256=LaWKdVzPfSmFuuQsqalW5cySJ0kQf9wnfEniXUBYyr8,19306
+sarapy/dataProcessing/TLMSensorDataProcessor.py,sha256=NhRxMoA4SHwyhD61xn6m5UIp1ZrDhEnHaFfhveMJLRQ,3689
+sarapy/dataProcessing/TimeSeriesProcessor.py,sha256=aig3A3_SCa9FVSWxGWiapBUX7Lj9Wi1BVyZi-XXZZYQ,6414
+sarapy/dataProcessing/__init__.py,sha256=Kqs5sFtq6RMEa3KLJFbsGRoYsIxHL1UUGMuplyCyQFk,200
+sarapy/mlProcessors/FertilizerFMCreator.py,sha256=LNi86CI6eVuQ0_UBVJNd_-L79fcY2-zY2NCm9ypl6OM,2354
+sarapy/mlProcessors/FertilizerTransformer.py,sha256=0VkW1Kqnc0LMS1HgaVJvnsyg4MwAG-9ocw047_u7-U8,3119
+sarapy/mlProcessors/PlantinClassifier.py,sha256=yNck3R8wGfy6rjb8Q2mxVdu63NWJgJ6UmqUORa2qvbk,12491
+sarapy/mlProcessors/PlantinFMCreator.py,sha256=y8rdkUb-84-ONa4kJOY2R2zAfuOXtUJVBEhUPhDncyY,7852
+sarapy/mlProcessors/__init__.py,sha256=wHnqLn15KRCOYI9WWS8_ArraG_c4UEfDCi19muwjN14,335
+sarapy/preprocessing/DistancesImputer.py,sha256=NvbVAh5m0yFxVgDbEFnEX7RSG13qLjO7i2gqjDAWsf4,9106
+sarapy/preprocessing/FertilizerImputer.py,sha256=zK6ONAilwPHvj-bC7yxnQYOkDBCCkWh6__57vYK9anM,1490
+sarapy/preprocessing/TransformInputData.py,sha256=gT0S_ANSmSODPru4DVK7qpA7ZqnRoPwNyLkV-VJWvAU,8584
+sarapy/preprocessing/TransformToOutputData.py,sha256=2hSeFkrSt1OO_jiX4SQJtL3Dhm_9xLy7zCgkj8jo9OE,3137
+sarapy/preprocessing/__init__.py,sha256=2if1rcq8WCk8u4M3bHcE_tY2hLmZxwNG4qdLNJR1Ixg,331
+sarapy/stats/__init__.py,sha256=X4IZsG2TxZUtXYmONvVJymHInnLHMqiThmW6U2ZMd8U,258
+sarapy/stats/stats.py,sha256=eVmi6w9QcwvwuDK3yOr1Z8wQV-1oT3QJujDqWZFYzGc,11424
+sarapy/utils/__init__.py,sha256=TD_-dGgPQBD13hyf2OqDUET0XZOXTduJD1ht8tjZF_0,257
+sarapy/utils/plotting.py,sha256=kX-eYw618urMcUBkNPviQZdBziDc_TR3GInTsO90kU4,4065
+sarapy/utils/utils.py,sha256=NSSeZHeLnQWcFa6vfJ2nVkptX2dIyiCMlZPBmsgEvjo,7106
+sarapy-3.0.0.dist-info/LICENCE,sha256=N00sU3vSQ6F5c2vML9_qP4IFTkCPFFj0YGDB2CZP-uQ,840
+sarapy-3.0.0.dist-info/METADATA,sha256=mNSvlvzBpAm4_9fXTa5EALLidW7rfi6P7tR4bwzRRWc,7684
+sarapy-3.0.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+sarapy-3.0.0.dist-info/top_level.txt,sha256=4mUGZXfX2Fw47fpY6MQkaJeuOs_8tbjLkkNp34DJWiA,7
+sarapy-3.0.0.dist-info/RECORD,,

sarapy/utils/amg_decoder.py

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

sarapy/utils/amg_ppk.py

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

sarapy/utils/getRawOperations.py

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

sarapy-2.2.0.dist-info/RECORD

@@ -1,29 +0,0 @@
-sarapy/__init__.py,sha256=aVoywqGSscYYDycLaYJnz08dlQabl9gH0h4Q5KtHM9o,74
-sarapy/version.py,sha256=KOlO2hui0K8-Vgk9NSIA7DmWhS5E7jpA2nk5zqFERaE,51
-sarapy/dataProcessing/GeoProcessor.py,sha256=ARjgKTXDVdf_cFCXyFmzlnmmmay3HG3q-yeJ9QrAcQU,5919
-sarapy/dataProcessing/OpsProcessor.py,sha256=edoZBO-loAU-uVvjkNeFiRfUGFnaz2ImMsT25DMxDGM,17349
-sarapy/dataProcessing/TLMSensorDataProcessor.py,sha256=RuITlryuSaIWvYyJwE5wxp85HVZ6mr5kUVALikfwS4g,3603
-sarapy/dataProcessing/TimeSeriesProcessor.py,sha256=aig3A3_SCa9FVSWxGWiapBUX7Lj9Wi1BVyZi-XXZZYQ,6414
-sarapy/dataProcessing/__init__.py,sha256=Kqs5sFtq6RMEa3KLJFbsGRoYsIxHL1UUGMuplyCyQFk,200
-sarapy/mlProcessors/FertilizerFMCreator.py,sha256=LNi86CI6eVuQ0_UBVJNd_-L79fcY2-zY2NCm9ypl6OM,2354
-sarapy/mlProcessors/FertilizerTransformer.py,sha256=PefMNrsvfqqjup0lcypzZB0IKzZbvTlTI03u4ITNuUo,3003
-sarapy/mlProcessors/PlantinClassifier.py,sha256=PoPvtrqTXCmr0cLaMNRdDzhvzUJNZhLtvZNeE0qd_0Q,7905
-sarapy/mlProcessors/PlantinFMCreator.py,sha256=Rp6Mx_bhe0tvcktaG8vC8Dq8LPsBzKx4IjfVledvy6I,6926
-sarapy/mlProcessors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sarapy/preprocessing/DistancesImputer.py,sha256=NvbVAh5m0yFxVgDbEFnEX7RSG13qLjO7i2gqjDAWsf4,9106
-sarapy/preprocessing/FertilizerImputer.py,sha256=zK6ONAilwPHvj-bC7yxnQYOkDBCCkWh6__57vYK9anM,1490
-sarapy/preprocessing/TransformInputData.py,sha256=hp2P0Jry7ORUU_N3bMlAz1sCTvD5Qwfm376O8xqwPEo,8539
-sarapy/preprocessing/TransformToOutputData.py,sha256=2hSeFkrSt1OO_jiX4SQJtL3Dhm_9xLy7zCgkj8jo9OE,3137
-sarapy/preprocessing/__init__.py,sha256=Wg_Csy8Xiz8BN8A4-T7iPwcL_ol5ApEx6YtybItKB8M,100
-sarapy/stats/__init__.py,sha256=ZrLMSistwynmmx4HUcI-ePRzqQ4bjp85JT4fTmbzC-c,27
-sarapy/stats/stats.py,sha256=raQBnn2RRtwYOuKN4Mgk6Rhk4hajx1TVcGlYnT2TMmA,11412
-sarapy/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sarapy/utils/amg_decoder.py,sha256=JZ7cbu7DlCuatuq2F7aBfUr7S7U-K5poBgxw5nY6rNI,4319
-sarapy/utils/amg_ppk.py,sha256=c0GusnxdntU-E0JOezzbIfC7SWoJmKAbad_zYDCJ3-c,1060
-sarapy/utils/getRawOperations.py,sha256=8aA1fIkNCnUYgiWfnFggRT_U35z432gZBrZ7seGO5w4,817
-sarapy/utils/plotting.py,sha256=kX-eYw618urMcUBkNPviQZdBziDc_TR3GInTsO90kU4,4065
-sarapy-2.2.0.dist-info/LICENCE,sha256=N00sU3vSQ6F5c2vML9_qP4IFTkCPFFj0YGDB2CZP-uQ,840
-sarapy-2.2.0.dist-info/METADATA,sha256=4yYQOkyZXWyLc3UqIHtYbxMxpznXjRat6kGwHD60Jk0,5945
-sarapy-2.2.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-sarapy-2.2.0.dist-info/top_level.txt,sha256=4mUGZXfX2Fw47fpY6MQkaJeuOs_8tbjLkkNp34DJWiA,7
-sarapy-2.2.0.dist-info/RECORD,,