def gen_loaded(tbl): """ Variant 1. Generate regular intervals (may be with overlap) :param tbl: :return: """ cfg['in']['table'] = tbl # To obtain ``t_intervals_start`` used in query inside gen_data_on_intervals(cfg_out, cfg) # we copy its content here: t_prev_interval_start, t_intervals_start = intervals_from_period( **cfg['in'], period=cfg_out['split_period']) if cfg['proc']['overlap']: dt_shifts = np.arange(0, 1, (1 - cfg['proc']['overlap'])) * pd_period_to_timedelta( cfg_out['split_period']) t_intervals_start = ( t_intervals_start.to_numpy(dtype="datetime64[ns]")[np.newaxis].T + dt_shifts).flatten() if cfg['in']['max_date']: idel = t_intervals_start.searchsorted( np.datetime64(cfg['in']['max_date'] - pd_period_to_timedelta(cfg_out['split_period']))) t_intervals_start = t_intervals_start[:idel] cfg['in']['time_intervals_start'] = t_intervals_start # to save queried time - see main() cfg_filter = None cfg_in_columns_saved = cfg['in']['columns'] for start_end in h5q_starts2coord( cfg['in']['db_path'], cfg['in']['table'], t_intervals_start, dt_interval=cfg['proc']['dt_interval'] ): a = h5_load_range_by_coord(**cfg['in'], range_coordinates=start_end) if cfg_filter is None: # only 1 time # corrects columns if they are not exact mutch to faster h5_load_range_by_coord() next time cfg['in']['columns'] = a.columns # temporary # and exclude absent fields to not filter warning of no such column in filt_data_dd() detect_filt = f"m(ax|in)_({'|'.join(cfg['in']['columns'])})" cfg_filter = {k: v for k, v in cfg['filter'].items() if re.match(detect_filt, k)} d, i_burst = filt_data_dd(a, cfg['in']['dt_between_bursts'], cfg['in']['dt_hole_warning'], cfg_filter) n_bursts = len(i_burst) if n_bursts > 1: # 1st is always 0 l.info('gaps found: (%s)! at %s', n_bursts - 1, i_burst[1:] - 1) df0 = d.compute() if not len(df0): continue start_end = df0.index[[0, -1]].values yield df0, start_end cfg['in']['columns'] = cfg_in_columns_saved # recover to not affect next file
# path_db = path_cruise / (re.match('(^[\d_]*).*', path_cruise.name).groups()[0].strip('_') + 'incl.h5') path_db = Path( r'd:\workData\BalticSea\190713_ABP45\inclinometer\190721incl.h5') dir_incl = '' if 'inclinometer' in path_db.parent.parts else 'inclinometer/' probes = [ 5, 12 ] # [1, 4, 5, 7, 11, 12] #sorted(dt_from_utc_for_probe.keys()) # [1, 4, 5, 7, 11, 12, 14] #[21, 23] #range(1, 40) # [25,26] #, [17, 18] start = 2 go = True # Draw in Veusz if start <= 2 and go: # False: # dt_custom_s = None # 60 * 5 #None # allow not adjacent intervals with this length, s t_interval_start, t_intervals_end = intervals_from_period( datetime_range=np.array(['2019-07-21T20:00:00', '2019-08-18T01:45:00'], 'datetime64[s]'), period='1D') # t_interval_start = t_intervals_end[0] - np.timedelta64('5', 'm') for i, probe in enumerate(probes): probe_name = f'incl{probe:02}' print('processing {} intervals...'.format(len(t_intervals_end))) # for i_interval, (t_interval_start, t_interval_end) in enumerate(zip(pd.DatetimeIndex([t_interval_start]).append(t_intervals_end[:-1]), t_intervals_end), start=1): for i_interval, (t_interval_end_prev, t_interval_end) in list( enumerate(zip( pd.DatetimeIndex([t_interval_start ]).append(t_intervals_end[:-1]), pd.DatetimeIndex(t_intervals_end)), start=1))[::-1]: # if i_interval < 23: #<= 0: # TEMPORARY! Skip this number of intervals
def main(new_arg=None, **kwargs): """ :param new_arg: list of strings, command line arguments :kwargs: dicts of dictcts (for each ini section): specified values overwrites ini values """ # global l cfg = cfg_from_args(my_argparser(), new_arg, **kwargs) if not cfg['program']: return # usually error of unrecognized arguments displayed cfg['in']['db_coefs'] = Path(cfg['in']['db_coefs']) for path_field in ['db_coefs', 'path_cruise']: if not cfg['in'][path_field].is_absolute(): cfg['in'][path_field] = ( cfg['in']['cfgFile'].parent / cfg['in'][path_field] ).resolve().absolute() # cfg['in']['cfgFile'].parent / def constant_factory(val): def default_val(): return val return default_val for lim in ('min_date', 'max_date'): # convert keys to int because they must be comparable to probes_int_list (for command line arguments keys are allways strings, in yaml you can set string or int) _ = {int(k): v for k, v in cfg['filter'][lim].items()} cfg['filter'][lim] = defaultdict(constant_factory(_.get(0)), _) l = init_logging(logging, None, None, 'INFO') #l = init_logging(logging, None, cfg['program']['log'], cfg['program']['verbose']) if True: # False. Experimental speedup but takes memory from dask.cache import Cache cache = Cache(2e9) # Leverage two gigabytes of memory cache.register() # Turn cache on globally #if __debug__: # # because there was errors on debug when default scheduler used # cfg['program']['dask_scheduler'] = 'synchronous' if cfg['program']['dask_scheduler']: if cfg['program']['dask_scheduler'] == 'distributed': from dask.distributed import Client # cluster = dask.distributed.LocalCluster(n_workers=2, threads_per_worker=1, memory_limit="5.5Gb") client = Client(processes=False) # navigate to http://localhost:8787/status to see the diagnostic dashboard if you have Bokeh installed # processes=False: avoide inter-worker communication for computations releases the GIL (numpy, da.array) # without is error else: if cfg['program']['dask_scheduler'] == 'synchronous': l.warning('using "synchronous" scheduler for debugging') import dask dask.config.set(scheduler=cfg['program']['dask_scheduler']) # Run steps : st.start = cfg['program']['step_start'] st.end = cfg['program']['step_end'] st.go = True if not cfg['out'][ 'db_name']: # set name by 'path_cruise' name or parent if it has digits at start. priority for name is "*inclinometer*" for p in (lambda p: [p, p.parent])(cfg['in']['path_cruise']): m = re.match('(^[\d_]*).*', p.name) if m: break cfg['out']['db_name'] = f"{m.group(1).strip('_')}incl.h5" dir_incl = next((d for d in cfg['in']['path_cruise'].glob('*inclinometer*') if d.is_dir()), cfg['in']['path_cruise']) db_path = dir_incl / '_raw' / cfg['out']['db_name'] # --------------------------------------------------------------------------------------------- # def fs(probe, name): # if 'w' in name.lower(): # Baranov's wavegauge electronic # return 10 # 5 # return 5 # if probe < 20 or probe in [23, 29, 30, 32, 33]: # 30 [4, 11, 5, 12] + [1, 7, 13, 30] # return 5 # if probe in [21, 25, 26] + list(range(28, 35)): # return 8.2 # return 4.8 def datetime64_str(time_str: Optional[str] = None) -> np.ndarray: """ Reformat time_str to ISO 8601 or to 'NaT'. Used here for input in funcs that converts str to numpy.datetime64 :param time_str: May be 'NaT' :return: ndarray of strings (tested for 1 element only) formatted by numpy. """ return np.datetime_as_string(np.datetime64(time_str, 's')) probes = cfg['in']['probes'] or range( 1, 41) # sets default range, specify your values before line --- raw_root, probe_is_incl = re.subn('INCL_?', 'INKL_', cfg['in']['probes_prefix'].upper()) # some parameters that depends of probe type (indicated by probes_prefix) p_type = defaultdict( # baranov's format constant_factory({ 'correct_fun': partial(correct_txt, mod_file_name=mod_incl_name, sub_str_list=[ b'^\r?(?P<use>20\d{2}(\t\d{1,2}){5}(\t\d{5}){8}).*', b'^.+' ]), 'fs': 10, 'format': 'Baranov', }), { (lambda x: x if x.startswith('incl') else 'incl')(cfg['in']['probes_prefix']): { 'correct_fun': partial( correct_txt, mod_file_name=mod_incl_name, sub_str_list=[ b'^(?P<use>20\d{2}(,\d{1,2}){5}(,\-?\d{1,6}){6}(,\d{1,2}\.\d{2})(,\-?\d{1,3}\.\d{2})).*', b'^.+' ]), 'fs': 5, 'format': 'Kondrashov', }, 'voln': { 'correct_fun': partial( correct_txt, mod_file_name=mod_incl_name, sub_str_list=[ b'^(?P<use>20\d{2}(,\d{1,2}){5}(,\-?\d{1,8})(,\-?\d{1,2}\.\d{2}){2}).*', b'^.+' ]), 'fs': 5, #'tbl_prefix': 'w', 'format': 'Kondrashov', } }) if st(1, 'Save inclinometer or wavegage data from ASCII to HDF5'): # Note: Can not find additional not corrected files for same probe if already have any corrected in search path (move them out if need) i_proc_probe = 0 # counter of processed probes i_proc_file = 0 # counter of processed files # patten to identify only _probe_'s raw data files that need to correct '*INKL*{:0>2}*.[tT][xX][tT]': raw_parent = dir_incl / '_raw' # raw_parent /= if cfg['in']['raw_subdir'] is None: cfg['in']['raw_subdir'] = '' dir_out = raw_parent / re.sub(r'[.\\/ *?]', '_', cfg['in']['raw_subdir']) # sub replaces multilevel subdirs to 1 level that correct_fun() can only make def dt_from_utc_2000(probe): """ Correct time of probes started without time setting. Raw date must start from 2000-01-01T00:00""" return ( datetime(year=2000, month=1, day=1) - cfg['in']['time_start_utc'][probe] ) if cfg['in']['time_start_utc'].get(probe) else timedelta(0) # convert cfg['in']['dt_from_utc'] keys to int cfg['in']['dt_from_utc'] = { int(p): v for p, v in cfg['in']['dt_from_utc'].items() } # convert cfg['in']['t_start_utc'] to cfg['in']['dt_from_utc'] and keys to int cfg['in']['dt_from_utc'].update( # overwriting the 'time_start_utc' where already exist {int(p): dt_from_utc_2000(p) for p, v in cfg['in']['time_start_utc'].items()} ) # make cfg['in']['dt_from_utc'][0] be default value cfg['in']['dt_from_utc'] = defaultdict( constant_factory(cfg['in']['dt_from_utc'].pop(0, timedelta(0))), cfg['in']['dt_from_utc']) for probe in probes: raw_found = [] raw_pattern_file = str( Path(glob.escape(cfg['in']['raw_subdir'])) / cfg['in']['raw_pattern'].format(prefix=raw_root, number=probe)) correct_fun = p_type[cfg['in']['probes_prefix']]['correct_fun'] # if not archive: if (not re.match(r'.*(\.zip|\.rar)$', cfg['in']['raw_subdir'], re.IGNORECASE)) and raw_parent.is_dir(): raw_found = list(raw_parent.glob(raw_pattern_file)) if not raw_found: # Check if already have corrected files for probe generated by correct_txt(). If so then just use them raw_found = list( dir_out.glob( f"{cfg['in']['probes_prefix']}{probe:0>2}.txt")) if raw_found: print('corrected csv file', [r.name for r in raw_found], 'found') correct_fun = lambda x, dir_out: x elif not cfg['in']['raw_subdir']: continue for file_in in (raw_found or open_csv_or_archive_of_them( raw_parent, binary_mode=False, pattern=raw_pattern_file)): file_in = correct_fun(file_in, dir_out=dir_out) if not file_in: continue tbl = file_in.stem # f"{cfg['in']['probes_prefix']}{probe:0>2}" # tbl = re.sub('^((?P<i>inkl)|w)_0', lambda m: 'incl' if m.group('i') else 'w', # correct name # re.sub('^[\d_]*|\*', '', file_in.stem).lower()), # remove date-prefix if in name csv2h5( [ str( Path(__file__).parent / 'ini' / f"csv_{'inclin' if probe_is_incl else 'wavegage'}_{p_type[cfg['in']['probes_prefix']]['format']}.ini" ), '--path', str(file_in), '--blocksize_int', '50_000_000', # 50Mbt '--table', tbl, '--db_path', str(db_path), # '--log', str(scripts_path / 'log/csv2h5_inclin_Kondrashov.log'), # '--b_raise_on_err', '0', # ? '--b_interact', '0', '--fs_float', str(p_type[cfg['in']['probes_prefix']] ['fs']), #f'{fs(probe, file_in.stem)}', '--dt_from_utc_seconds', str(cfg['in']['dt_from_utc'][probe].total_seconds()), '--b_del_temp_db', '1', ] + (['--csv_specific_param_dict', 'invert_magnitometr: True'] if probe_is_incl else []), **{ 'filter': { 'min_date': cfg['filter']['min_date'].get( probe, np.datetime64(0, 'ns')), 'max_date': cfg['filter']['max_date'].get( probe, np.datetime64('now', 'ns') ), # simple 'now' works in sinchronious mode } }) # Get coefs: l.info( f"Adding coefficients to {db_path}/{tbl} from {cfg['in']['db_coefs']}" ) try: h5copy_coef(cfg['in']['db_coefs'], db_path, tbl) except KeyError as e: # Unable to open object (component not found) l.warning( 'No coefs to copy?' ) # write some dummy coefficients to can load Veusz patterns: h5copy_coef(None, db_path, tbl, dict_matrices=dict_matrices_for_h5(tbl=tbl)) except OSError as e: l.warning( 'Not found DB with coefs?' ) # write some dummy coefficients to can load Veusz patterns: h5copy_coef(None, db_path, tbl, dict_matrices=dict_matrices_for_h5(tbl=tbl)) i_proc_file += 1 else: print('no', raw_pattern_file, end=', ') i_proc_probe += 1 print('Ok:', i_proc_probe, 'probes,', i_proc_file, 'files processed.') if st(2, 'Calculate physical parameters and average'): kwarg = { 'in': { 'min_date': cfg['filter']['min_date'][0], 'max_date': cfg['filter']['max_date'][0], 'time_range_zeroing': cfg['in']['time_range_zeroing'] }, 'proc': {} } # if aggregate_period_s is None then not average and write to *_proc_noAvg.h5 else loading from that h5 and writing to _proc.h5 if not cfg['out']['aggregate_period_s']: cfg['out']['aggregate_period_s'] = [ None, 2, 600, 7200 if probe_is_incl else 3600 ] if cfg['in']['azimuth_add']: if 'Lat' in cfg['in']['azimuth_add']: # add magnetic declination,° for used coordinates # todo: get time kwarg['proc']['azimuth_add'] = mag_dec( cfg['in']['azimuth_add']['Lat'], cfg['in']['azimuth_add']['Lon'], datetime(2020, 9, 10), depth=-1) else: kwarg['proc']['azimuth_add'] = 0 if 'constant' in cfg['in']['azimuth_add']: # and add constant. For example, subtruct declination at the calibration place if it was applied kwarg['proc']['azimuth_add'] += cfg['in']['azimuth_add'][ 'constant'] # add -6.656 to account for calibration in Kaliningrad (mag deg = 6.656°) for aggregate_period_s in cfg['out']['aggregate_period_s']: if aggregate_period_s is None: db_path_in = db_path db_path_out = dir_incl / f'{db_path.stem}_proc_noAvg.h5' else: db_path_in = dir_incl / f'{db_path.stem}_proc_noAvg.h5' db_path_out = dir_incl / f'{db_path.stem}_proc.h5' # or separately: '_proc{aggregate_period_s}.h5' # 'incl.*|w\d*' inclinometers or wavegauges w\d\d # 'incl09': tables_list_regex = f"{cfg['in']['probes_prefix'].replace('voln', 'w')}.*" if cfg['in']['probes']: tables_list_regex += "(?:{})".format('|'.join( '{:0>2}'.format(p) for p in cfg['in']['probes'])) args = [ '../../empty.yml', # all settings are here, so to not print 'using default configuration' we use some existed empty file '--db_path', str(db_path_in), '--tables_list', tables_list_regex, '--aggregate_period', f'{aggregate_period_s}S' if aggregate_period_s else '', '--out.db_path', str(db_path_out), '--table', f'V_incl_bin{aggregate_period_s}' if aggregate_period_s else 'V_incl', '--verbose', 'INFO', #'DEBUG' get many numba messages '--b_del_temp_db', '1', # '--calc_version', 'polynom(force)', # depreshiated # '--chunksize', '20000', # '--not_joined_h5_path', f'{db_path.stem}_proc.h5', ] if aggregate_period_s is None: # proc. parameters (if we have saved proc. data then when aggregating we are not processing) # Note: for Baranov's prog 4096 is not suited: args += ([ '--max_dict', 'M[xyz]:4096', # '--time_range_zeroing_dict', "incl19: '2019-11-10T13:00:00', '2019-11-10T14:00:00'\n," # not works - use kwarg # '--time_range_zeroing_list', '2019-08-26T04:00:00, 2019-08-26T05:00:00' '--split_period', '1D' ] if probe_is_incl else [ '--bad_p_at_bursts_starts_peroiod', '1H', ]) # csv splitted by 1day (default for no avg) else csv is monolith if aggregate_period_s not in cfg['out'][ 'aggregate_period_s_not_to_text']: # , 300, 600]: args += ['--text_path', str(dir_incl / 'text_output')] # If need all data to be combined one after one: # set_field_if_no(kwarg, 'in', {}) # kwarg['in'].update({ # # 'tables': [f'incl{i:0>2}' for i in min_date.keys() if i!=0], # 'dates_min': min_date.values(), # in table list order # 'dates_max': max_date.values(), # # }) # set_field_if_no(kwarg, 'out', {}) # kwarg['out'].update({'b_all_to_one_col': 'True'}) incl_h5clc.main(args, **kwarg) if st(3, 'Calculate spectrograms'): # Can be done at any time after step 1 min_Pressure = 7 # add dict dates_min like {probe: parameter} of incl_clc to can specify param to each probe def raise_ni(): raise NotImplementedError( 'Can not proc probes having different fs in one run: you need to do it separately' ) args = [ Path(incl_h5clc.__file__).with_name( f'incl_h5spectrum{db_path.stem}.yaml'), # if no such file all settings are here '--db_path', str(dir_incl / f'{db_path.stem}_proc_noAvg.h5'), '--tables_list', f"{cfg['in']['probes_prefix']}.*", # inclinometers or wavegauges w\d\d ## 'w02', 'incl.*', # '--aggregate_period', f'{aggregate_period_s}S' if aggregate_period_s else '', '--min_date', datetime64_str(cfg['filter']['min_date'][0]), '--max_date', datetime64_str(cfg['filter']['max_date'] [0]), # '2019-09-09T16:31:00', #17:00:00 '--min_Pressure', f'{min_Pressure}', # '--max_dict', 'M[xyz]:4096', # use if db_path is not ends with _proc_noAvg.h5 i.e. need calc velocity '--out.db_path', f"{db_path.stem.replace('incl', cfg['in']['probes_prefix'])}_proc_psd.h5", # '--table', f'psd{aggregate_period_s}' if aggregate_period_s else 'psd', '--fs_float', str(p_type[cfg['in']['probes_prefix']] ['fs']), # f"{fs(probes[0], cfg['in']['probes_prefix'])}", # (lambda x: x == x[0])(np.vectorize(fs)(probes, prefix))).all() else raise_ni() # # '--time_range_zeroing_list', '2019-08-26T04:00:00, 2019-08-26T05:00:00' # '--verbose', 'DEBUG', # '--chunksize', '20000', '--b_interact', '0', ] if probe_is_incl: args += [ '--split_period', '2H', '--fmin', '0.0004', #0.0004 '--fmax', '1.05' ] else: args += [ '--split_period', '1H', '--dt_interval_minutes', '15', # set this if burst mode to the burst interval '--fmin', '0.0001', '--fmax', '4', #'--min_Pressure', '-1e15', # to not load NaNs ] incl_h5spectrum.main(args) if st(4, 'Draw in Veusz'): pattern_path = dir_incl / r'processed_h5,vsz/201202-210326incl_proc#28.vsz' # r'\201202_1445incl_proc#03_pattern.vsz' #' # db_path.parent / r'vsz_5min\191119_0000_5m_incl19.vsz' # r'vsz_5min\191126_0000_5m_w02.vsz' b_images_only = False # importing in vsz index slices replacing: pattern_str_slice_old = None # Length of not adjacent intervals, s (set None to not allow) # pandas interval in string or tuple representation '1D' of period between intervals and interval to draw period_str = '0s' # '1D' # dt dt_str = '0s' # '5m' file_intervals = None period = to_offset(period_str).delta dt = to_offset(dt_str).delta # timedelta(0) # 60 * 5 if file_intervals and period and dt: # Load starts and assign ends t_intervals_start = pd.read_csv( cfg['in']['path_cruise'] / r'vsz+h5_proc\intervals_selected.txt', converters={ 'time_start': lambda x: np.datetime64(x, 'ns') }, index_col=0).index edges = (pd.DatetimeIndex(t_intervals_start), pd.DatetimeIndex(t_intervals_start + dt_custom_s) ) # np.zeros_like() elif period and dt: # Generate periodic intervals t_interval_start, t_intervals_end = intervals_from_period( datetime_range=np.array( [ cfg['filter']['min_date']['0'], cfg['filter']['max_date']['0'] ], # ['2018-08-11T18:00:00', '2018-09-06T00:00:00'], # ['2019-02-11T13:05:00', '2019-03-07T11:30:00'], # ['2018-11-16T15:19', '2018-12-14T14:35'], # ['2018-10-22T12:30', '2018-10-27T06:30:00'], 'datetime64[s]'), period=period) edges = (pd.DatetimeIndex([t_interval_start ]).append(t_intervals_end[:-1]), pd.DatetimeIndex(t_intervals_end)) else: # [min, max] edges for each probe edges_dict = { pr: [cfg['filter']['min_date'][pr], cfg['filter']['max_date'][pr]] for pr in probes } cfg_vp = {'veusze': None} for i, probe in enumerate(probes): # cfg_vp = {'veusze': None} if edges_dict: # custom edges for each probe edges = [pd.DatetimeIndex([t]) for t in edges_dict[probe]] # substr in file to rerplace probe_name_in_pattern (see below). probe_name = f"_{cfg['in']['probes_prefix'].replace('incl', 'i')}{probe:02}" tbl = None # f"/{cfg['in']['probes_prefix']}{probe:02}" # to check probe data exist in db else will not check l.info('Draw %s in Veusz: %d intervals...', probe_name, edges[0].size) # for i_interval, (t_interval_start, t_interval_end) in enumerate(zip(pd.DatetimeIndex([t_interval_start]).append(t_intervals_end[:-1]), t_intervals_end), start=1): for i_interval, (t_interval_start, t_interval_end) in enumerate(zip(*edges), start=1): # if i_interval < 23: #<= 0: # TEMPORARY Skip this number of intervals # continue if period and period != dt: t_interval_start = t_interval_end - pd.Timedelta( dt_custom_s, 's') if tbl: try: # skipping absent probes start_end = h5q_interval2coord( db_path=str(db_path), table=tbl, t_interval=(t_interval_start, t_interval_end)) if not len(start_end): break # no data except KeyError: break # device name not in specified range, go to next name pattern_path_new = pattern_path.with_name(''.join([ f'{t_interval_start:%y%m%d_%H%M}', f'_{dt_str}' if dt else '', f'{probe_name}.vsz' ])) # Modify pattern file if not b_images_only: pattern_type, pattern_number = re.match( r'.*(incl|w)_proc?#?(\d*).*', pattern_path.name).groups() probe_name_in_pattern = f"_{pattern_type.replace('incl', 'i')}{pattern_number}" def f_replace(line): """ Replace in file 1. probe name 2. slice """ # if i_interval == 1: line, ok = re.subn(probe_name_in_pattern, probe_name, line) if ok and pattern_str_slice_old: # can be only in same line str_slice = '(({:d}, {:d}, None),)'.format( *(start_end + np.int32([-1, 1]))) # bytes(, 'ascii') line = re.sub(pattern_str_slice_old, str_slice, line) return line if not rep_in_file(pattern_path, pattern_path_new, f_replace=f_replace, binary_mode=False): l.warning('Veusz pattern not changed!' ) # may be ok if we need draw pattern # break elif cfg_vp['veusze']: cfg_vp['veusze'].Load(str(pattern_path_new)) elif cfg_vp['veusze']: cfg_vp['veusze'].Load(str(pattern_path_new)) txt_time_range = \ """ "[['{:%Y-%m-%dT%H:%M}', '{:%Y-%m-%dT%H:%M}']]" \ """.format(t_interval_start, t_interval_end) print(f'{i_interval}. {txt_time_range}', end=' ') cfg_vp = veuszPropagate.main( [ Path(veuszPropagate.__file__).parent.with_name( 'veuszPropagate.ini'), # '--data_yield_prefix', '-', # '--path', str(db_path), # if custom loading from db and some source is required '--tables_list', '', # switches to search vsz-files only # f'/{probe_name}', # 181022inclinometers/ \d* '--pattern_path', str(pattern_path_new), # fr'd:\workData\BalticSea\190801inclinometer_Schuka\{probe_name}_190807_1D.vsz', # str(dir_incl / f'{probe_name}_190211.vsz'), #warning: create file with small name # '--before_next', 'restore_config', # '--add_to_filename', f"_{t_interval_start:%y%m%d_%H%M}_{dt}", '--filename_fun', f'lambda tbl: "{pattern_path_new.name}"', '--add_custom_list', f'USEtime__', # f'USEtime{probe_name}', nAveragePrefer', '--add_custom_expressions_list', txt_time_range, # + """ # ", 5" # """, '--b_update_existed', 'True', '--export_pages_int_list', '0', # 0 for all '6, 7, 8', #'1, 2, 3' # '--export_dpi_int', '200', '--export_format', 'jpg', #'emf', '--b_interact', '0', '--b_images_only', f'{b_images_only}', '--return', '<embedded_object>', # reuse to not bloat memory '--b_execute_vsz', 'True', '--before_next', 'Close()' # Close() need if b_execute_vsz many files ], veusze=cfg_vp['veusze']) if st(40, f'Draw in Veusz by loader-drawer.vsz method'): # save all vsz files that uses separate code from os import chdir as os_chdir dt_s = 300 cfg['in'][ 'pattern_path'] = db_path.parent / f'vsz_{dt_s:d}s' / '~pattern~.vsz' time_starts = pd.read_csv( db_path.parent / r'processed_h5,vsz' / 'intervals_selected.txt', index_col=0, parse_dates=True, date_parser=lambda x: pd.to_datetime(x, format='%Y-%m-%dT%H:%M:%S' )).index pattern_code = cfg['in']['pattern_path'].read_bytes( ) # encoding='utf-8' path_vsz_all = [] for i, probe in enumerate(probes): probe_name = f"{cfg['in']['probes_prefix']}{probe:02}" # table name in db l.info('Draw %s in Veusz: %d intervals...', probe_name, time_starts.size) for i_interval, time_start in enumerate(time_starts, start=1): path_vsz = cfg['in']['pattern_path'].with_name( f"{time_start:%y%m%d_%H%M}_{probe_name.replace('incl','i')}.vsz" ) # copy file to path_vsz path_vsz.write_bytes(pattern_code) # replaces 1st row path_vsz_all.append(path_vsz) os_chdir(cfg['in']['pattern_path'].parent) veuszPropagate.main( [ 'ini/veuszPropagate.ini', '--path', str(cfg['in']['pattern_path'].with_name( '??????_????_*.vsz')), # db_path), '--pattern_path', f"{cfg['in']['pattern_path']}_", # here used to auto get export dir only. may not be _not existed file path_ if ['out']['paths'] is provided # '--table_log', f'/{device}/logRuns', # '--add_custom_list', f'{device_veusz_prefix}USE_time_search_runs', # 'i3_USE_timeRange', # '--add_custom_expressions', # """'[["{log_row[Index]:%Y-%m-%dT%H:%M:%S}", "{log_row[DateEnd]:%Y-%m-%dT%H:%M:%S}"]]'""", # '--export_pages_int_list', '1', #'--b_images_only', 'True' '--b_interact', '0', '--b_update_existed', 'True', # todo: delete_overlapped '--b_images_only', 'True', '--load_timeout_s_float', str(cfg['program']['load_timeout_s']) # '--min_time', '2020-07-08T03:35:00', ], **{'out': { 'paths': path_vsz_all }}) if st(50, 'Export from existed Veusz files in dir'): pattern_parent = db_path.parent # r'vsz_5min\191126_0000_5m_w02.vsz'' pattern_path = str(pattern_parent / r'processed_h5,vsz' / '??????incl_proc#[1-9][0-9].vsz') # [0-2,6-9] veuszPropagate.main([ 'ini/veuszPropagate.ini', '--path', pattern_path, '--pattern_path', pattern_path, # '--export_pages_int_list', '1', #'--b_images_only', 'True' '--b_interact', '0', '--b_update_existed', 'True', # todo: delete_overlapped '--b_images_only', 'True', '--load_timeout_s_float', str(cfg['program']['load_timeout_s']), '--b_execute_vsz', 'True', '--before_next', 'Close()' # Close() need if b_execute_vsz many files ])
except KeyError as e: # Unable to open object (component not found) pass else: print('Coef is not copied!') # todo write some dummy coefficients to can load Veusz patterns i_proc += 1 print(f'Ok! ({i_proc} probes processed)') # Draw in Veusz if start == 2: # Not adjacent intervals with this length, s (set None to not allow) dt_custom_s = None # 60 * 5 # None # Periodic intervals t_interval_start, t_intervals_end = intervals_from_period( datetime_range=np.array( ['2019-08-11T18:00:00', '2019-09-06T00:00:00'], # ['2019-07-28T00:00:00', '2019-09-11T00:00:00'], #08-14 07-28T00:00:00 'datetime64[s]'), period='1D') # t_interval_start = t_intervals_end[0] - np.timedelta64('5', 'm') for i, probe in enumerate(probes): probe_name = f'incl{probe:02}' print('processing {} intervals...'.format(len(t_intervals_end))) # for i_interval, (t_interval_start, t_interval_end) in enumerate(zip(pd.DatetimeIndex([t_interval_start]).append(t_intervals_end[:-1]), t_intervals_end), start=1): cfg_vp = {'veusze': None} for i_interval, (t_interval_end_prev, t_interval_end) in enumerate(zip( pd.DatetimeIndex([t_interval_start ]).append(t_intervals_end[:-1]), pd.DatetimeIndex(t_intervals_end)), start=1): # list()[::-1]
from utils_time import intervals_from_period path_cruise = drive_d.joinpath('workData/BalticSea/190210/') dir_probe = 'ADV_Nortek-Vector/' start = 1 go = True # --------------------------------------------------------------------------------------------- if start <= 1 and go: # False: # dt_custom_s = None # 60 * 5 # allow not adjacent intervals with this length, s t_interval_start, t_intervals_end = intervals_from_period( datetime_range=np.array( ['2019-02-13T00:00:00', '2019-02-25T00:00:00'], # ['2018-11-16T15:19', '2018-12-14T14:35'], # ['2018-10-22T12:30', '2018-10-27T06:30:00'], 'datetime64[s]'), period='1D') # t_intervals_end = pd.DatetimeIndex(['2018-11-19T00:00', '2018-11-30T00:00', '2018-12-05T00:00']) # t_interval_start = t_intervals_end[0] # t_intervals_end = t_intervals_end[1:] # '2018-12-09T03:10', '2018-12-06T21:30', '2018-12-11T11:40', # t_intervals_end = pd.DatetimeIndex(['2018-10-22T12:30', '2018-10-27T06:30:00']) probe_name = 'Vector' file_pattern = f'1D_{probe_name}_190212.vsz' * 70 print('processing {} intervals...'.format(len(t_intervals_end))) for i_interval, (t_interval_start, t_interval_end) in enumerate(zip( pd.DatetimeIndex([t_interval_start]).append(t_intervals_end[:-1]),