Module redvox.tests.my_tests

import datetime
import timeit
import os.path
from typing import Optional, List

import numpy as np
import pickle
import pandas as pd
import tempfile
import matplotlib.pyplot as plt
import pyarrow as pa

import redvox.common.io as io
import redvox.common.file_statistics as fs
import redvox.api1000.wrapped_redvox_packet.wrapped_packet
from redvox.common.api_reader import ApiReader
from redvox.common.api_reader_dw import ApiReaderDw
from redvox.common.io import ReadFilter, Index, index_structured, index_unstructured
from redvox.common.data_window import DataWindow, DataWindowConfig
from redvox.common.data_window_configuration import DataWindowConfigFile
from redvox.common.sensor_data import SensorType
from redvox.common.station import Station
from redvox.common import sensor_reader_utils as sru
from redvox.common.offset_model import OffsetModel
from redvox.tests import TEST_DATA_DIR
import redvox.common.station_model as smdl
import redvox.common.date_time_utils as dt
from redvox.cloud.session_model_api import SessionModelsResp
from redvox.common.session_model import SessionModel
from redvox.api1000.wrapped_redvox_packet.station_information import (
    NetworkType,
    PowerState,
    CellServiceState,
    WifiWakeLock,
    ScreenState,
)
import redvox.common.session_model as stmdl

import redvox.settings as settings
import redvox.common.offset_model as ofm

settings.set_parallelism_enabled(False)


if __name__ == "__main__":
    # 7000f in 24.67s
    # 457f in 11.13s
    # 53f in .39s

    # ofm.set_min_valid_latency_micros(1000)
    # ofm.set_min_samples(0)
    # ofm.set_min_timesync_dur(15)

    # files_path = "/Volumes/Tonga_2/Tonga/RDVX/LW_MAMA_BABY/HI"
    files_path = "/Users/tyler/Documents/ml_export"

    rd_filter = ReadFilter(
        start_dt=dt.datetime_from_epoch_seconds_utc(1689718030), end_dt=dt.datetime_from_epoch_seconds_utc(1689718090)
    )

    s = timeit.default_timer()
    rdr = ApiReader(files_path, True, rd_filter)
    e = timeit.default_timer()

    print(f"time to make reader: {e-s}")

    stations = rdr.get_stations()
    for stn in stations:
        smdl.example_of_print_loc_and_timing_summary(stn)
        if rdr.session_models.cloud_models:
            for ss in rdr.session_models.cloud_models.sessions:
                if stn.get_key().as_cloud_key() == ss.session_key():
                    print(f"cloud: {ss.session_key()}")
                    print(f"timing:\nlatency: {ss.timing.mean_lat}\noffset: {ss.timing.mean_off}")
                    for sb in ss.sub:
                        ddyn = rdr.session_models.get_dynamic_session(f"{ss.session_key()}:{sb}")
                        for a, b in ddyn.location.items():
                            print(f"source: {a}\nnum_pts: {b.lat.welford.cnt}")
                            m, v, _ = b.lat.welford.finalize()
                            print(f"latitude:  {m, np.sqrt(v)}")
                            m, v, _ = b.lng.welford.finalize()
                            print(f"longitude: {m, np.sqrt(v)}")
                            m, v, _ = b.alt.welford.finalize()
                            print(f"altitude:  {m, np.sqrt(v)}")
                    break
        if rdr.session_models.local_models:
            for ss in rdr.session_models.local_models.sessions:
                if stn.get_key().as_cloud_key() == ss.cloud_session.session_key():
                    print(f"local: {ss.cloud_session.session_key()}")
                    print(
                        f"timing:\nlatency: {ss.cloud_session.timing.mean_lat}\n"
                        f"offset: {ss.cloud_session.timing.mean_off}"
                    )
                    for sb in ss.cloud_session.sub:
                        ddyn = rdr.session_models.get_dynamic_session(f"{ss.cloud_session.session_key()}:{sb}")
                        for a, b in ddyn.location.items():
                            print(f"source: {a}\nnum_pts: {b.lat.welford.cnt}")
                            m, v, _ = b.lat.welford.finalize()
                            print(f"latitude:  {m, np.sqrt(v)}")
                            m, v, _ = b.lng.welford.finalize()
                            print(f"longitude: {m, np.sqrt(v)}")
                            m, v, _ = b.alt.welford.finalize()
                            print(f"altitude:  {m, np.sqrt(v)}")
                    break

    # rdr = ApiReaderDw(files_path, True)

    # dwcfg = DataWindowConfig(files_path, True,
    #                          # station_ids=["1637621008"],
    #                          # start_datetime=dt.datetime_from_epoch_seconds_utc(1686787200),
    #                          # end_datetime=dt.datetime_from_epoch_seconds_utc(1686787230)
    #                          start_datetime=dt.datetime_from_epoch_seconds_utc(1661890300),
    #                          end_datetime=dt.datetime_from_epoch_seconds_utc(1661890330)
    #                          )
    #
    # s = timeit.default_timer()
    #
    # dwdw = DataWindow("test me", config=dwcfg)
    #
    # e = timeit.default_timer()
    #
    # del dwdw
    #
    # print(f"ran in {e - s}")

    exit(1)


def str_test():
    config = DataWindowConfig(
        "/Users/tyler/Documents/inlblast_2021_9_30",
        structured_layout=True,
        station_ids=["1637610036"],
        start_datetime=datetime.datetime(2021, 9, 30, 17, 0, 0),
        end_datetime=datetime.datetime(2021, 9, 30, 17, 5, 0),
    )
    dw = DataWindow("test_str_repr", config=config)
    print("string: ", dw)
    print("repr: ", repr(dw))
    print("dict: ", dw.as_dict())