def json2snmi(json_str): snmi = json.loads(json_str) if not hasattr(snmi, '_snowevent'): setattr(snmi, '_snowevent', None) if not hasattr(snmi, '_snowroute'): setattr(snmi, '_snowroute', None) return snmi
def json2snrgi(json_str): """ convert json :type json_str: str :rtype: pyticas_ncrtes.itypes.SnowRouteGroupInfo """ return json.loads(json_str)
def json2snei(json_str): """ :type json_str: str :rtype: pyticas_ncrtes.itypes.SnowEventInfo """ return json.loads(json_str)
def json2ts(json_str): """ :param json_str: :type json_str: :return: :rtype: pyticas_ncrtes.itypes.TargetStationInfo """ return json.loads(json_str)
def _load(wb): info_ws = wb.sheet_by_name(const.INFO_SHEET_NAME) meta_data = [] for ridx in range(info_ws.nrows): value = str(info_ws.cell(ridx, 0).value).strip() if value: meta_data.append(value) r = json.loads(''.join(meta_data)) _read_lane_configs_from_sheet(wb, r.cfg, const.DATA_SHEET_NAME) return r
def json2ttri(json_str): """ convert json to `pyticas_tetres.types.TTRouteInfo` object from TICAS client :type json_str: str :rtype: TTRouteInfo """ tmp = json.loads(json_str) if not hasattr(tmp.route, 'cfg'): tmp.route.cfg = None route_setup(tmp.route) return tmp
def load_route(filepath): """ :type filepath: str :rtype: Route """ if not os.path.exists(filepath): return None r = json.loads(util.get_file_contents(filepath)) if isinstance(r, Route): return r else: return None
def _load_json(json_path): if not os.path.exists(json_path): return None nsr_data = None try: with open(json_path, 'r') as f: json_str = f.read() nsr_data = json.loads(json_str) except: pass return nsr_data
def to_info(self, model_data, data_info_type=None, **kwargs): """ change DB model type to info type :param model_data: retrieved data from DB :param data_info_type: info class defined in `pyticas_tetres.ttrms_types` :return: corresponding class instance to DB model """ route_attrs = data_info_type._route_attrs_ if data_info_type else self.route_attrs dt_attrs = data_info_type._dt_attrs_ if data_info_type else self.dt_attrs rel_attrs = data_info_type._rel_attrs_ if data_info_type else self.rel_attrs enum_attrs = data_info_type._enum_attrs_ if data_info_type else self.enum_attrs json_attrs = data_info_type._json_attrs_ if data_info_type else self.json_attrs info = data_info_type() if data_info_type else self.dataInfoType() none_route = kwargs.get('none_route', False) if not model_data: return None for key, value in model_data.__dict__.items(): if key.startswith('_'): continue if key in dt_attrs: # isinstance(value, datetime.datetime): valueToSet = value.strftime( '%Y-%m-%d %H:%M:%S') if value else None elif key in route_attrs: if not none_route: valueToSet = json2route(value) if not isinstance(valueToSet, Route): valueToSet = value else: valueToSet = None elif key in enum_attrs: enum_type = enum_attrs.get(key) valueToSet = enum_type.find_by_value(value) elif key in json_attrs: valueToSet = json.loads(value) else: valueToSet = value setattr(info, key, valueToSet) for attr_name, rel_info in rel_attrs.items(): if model_data and not attr_name.startswith('_'): valueToSet = self.to_info(getattr(model_data, attr_name), data_info_type=rel_info['info_cls'], **kwargs) else: valueToSet = None setattr(info, attr_name, valueToSet) return info
def load_weather(site_id, prd, sen_id=0): """ :type site_id: int :type prd: pyticas.ttypes.Period :type sen_id: int :rtype: list[pyticas_tetres.ttypes.WeatherInfo] """ conn = http.client.HTTPConnection(RWIS_ADDR, RWIS_PORT) params = urllib.parse.urlencode({'site_id': site_id, 'start_date': prd.start_date.strftime('%Y-%m-%d %H:%M:%S'), 'end_date': prd.end_date.strftime('%Y-%m-%d %H:%M:%S'), 'sen_id': sen_id}) headers = {"Content-type": "application/x-www-form-urlencoded", "Accept": "text/plain"} #conn.set_debuglevel(1) conn.request("POST", "/rwis/get", params, headers) response = conn.getresponse() j = json.loads(response.read().decode('utf-8')) wDA = WeatherDataAccess(prd.start_date.year) if j['code'] == 1: wd = j['obj'] else: return None results = [] wis = [] for idx, dtime in enumerate(prd.get_timeline(with_date=True)): row = wd.data[idx] if not row: wi = WeatherInfo(dtime=dtime) else: dt = dict(row.__dict__) dt['dtime'] = row.dtime.strftime('%Y-%m-%d %H:%M:%S') dt['pc_start_dtime'] = dt['pc_start_dtime'].strftime('%Y-%m-%d %H:%M:%S') if dt['pc_start_dtime'] else None dt['pc_end_dtime'] = dt['pc_end_dtime'].strftime('%Y-%m-%d %H:%M:%S') if dt['pc_end_dtime'] else None wi = WeatherInfo(**dt) results.append(wi) wm = wDA.da_base.to_model(wi) wis.append(wm) wDA.insert(wi) wDA.commit() wDA.close_session() return results
def cached(group_id, site_id, date, src_type=None): """ :type group_id: str :type site_id: str :type date: datetime.datetime :rtype: ScanWebData """ cache_path = _cache_path(_CACHE_RWIS, group_id, site_id, date, src_type) if os.path.exists(cache_path) == False: return None try: return json.loads(util.get_file_contents(cache_path)) except Exception: os.remove(cache_path) return None
def json2route(json_str): """ convert json to `Route` object from TICAS client :type json_str: str :rtype: Route """ tmp = json.loads(json_str) r = Route(tmp.name, tmp.desc) if not hasattr(tmp, 'cfg'): tmp.cfg = None if not hasattr(tmp, 'rnodes'): tmp.rnodes = [] r.cfg = tmp.cfg r.rnodes = tmp.rnodes route_setup(r) return r
def json2snri(json_str): """ convert json to `pyticas_tetres.types.SnowRouteInfo` object from TICAS client :type json_str: str :rtype: SnowRouteInfo """ info = json.loads(json_str) if info.route1 and not hasattr(info.route1, 'cfg'): info.route1.cfg = None route_setup(info.route1) route2 = route.opposite_route(info.route1) cfg2 = info.route1.cfg.clone() rc.route_config.reverse(cfg2) route2.cfg = cfg2 info.route2 = route2 info.route1.name = 'route1 - %s' % info.route1.rnodes[0].corridor.name info.route1.desc = '' info.route2.name = 'route2 - %s' % info.route2.rnodes[0].corridor.name info.route2.desc = '' return info
def tetres_syscfg_update(): cfginfo_json = request.form.get('cfg', None) if not cfginfo_json: return prot.response_invalid_request() cfginfo = json.loads(cfginfo_json, SystemConfigInfo) if not cfginfo or not isinstance(cfginfo, SystemConfigInfo): return prot.response_invalid_request() for k, v in cfginfo.__dict__.items(): if k.startswith('_'): continue if v is None: return prot.response_invalid_request() prev_syscfg = systemconfig.set_system_config_info(cfginfo) if not prev_syscfg: return prot.response_fail('fail to update configuration') put_task_to_actionlog(prev_syscfg) return prot.response_success()
def handle_route_wise_moe_parameters(config_json_string): import json config_json = json.loads(config_json_string) route_id = config_json.get("reference_tt_route_id") if route_id: rw_moe_critical_density = config_json.get("rw_moe_critical_density") rw_moe_lane_capacity = config_json.get("rw_moe_lane_capacity") rw_moe_congestion_threshold_speed = config_json.get("rw_moe_congestion_threshold_speed") rw_moe_start_date = config_json.get("rw_moe_start_date") rw_moe_end_date = config_json.get("rw_moe_end_date") rw_moe_param_info = create_rw_moe_param_object(route_id, rw_moe_critical_density, rw_moe_lane_capacity, rw_moe_congestion_threshold_speed, rw_moe_start_date, rw_moe_end_date) rw_moe_object_id = save_rw_param_object(rw_moe_param_info) if has_traffic_files(rw_moe_start_date, rw_moe_end_date): try: update_moe_values(config_json) update_rw_moe_status(rw_moe_object_id, status="Completed") except Exception as e: print(e) update_rw_moe_status(rw_moe_object_id, status="Failed", reason=str(e)) else: update_rw_moe_status(rw_moe_object_id, status="Failed", reason="Missing traffic files for the given time range.")
def json2sei(json_str): sei = json.loads(json_str) sei.set_years() return sei
def json2snei(json_str): return json.loads(json_str)
def traveltime_info(ttr_id, weather_type, depart_time, dbsession=None): """ :type ttr_id: int :type weather_type: int :type depart_time: datetime.datetime :rtype: list[dict], list[float] """ logger = getLogger(__name__) logger.debug( '# public travel time information is requested (route_id=%s, weather_type=%s, depart_time=%s)' % (ttr_id, weather_type, depart_time)) ttrda = TTRouteDataAccess(session=dbsession) ttri = ttrda.get_by_id(ttr_id) if weather_type: try: weather_type = int(weather_type) except: weather_type = None if not weather_type or weather_type not in [WC_NORMAL, WC_RAIN, WC_SNOW]: weather_type = _weather(depart_time, ttri.route) regime_type = _regime_type(weather_type, depart_time) logger.debug(' > regime type = %d (%s)' % (regime_type, REGIME_STRING[regime_type])) da = TODReliabilityDataAccess(session=ttrda.get_session()) tods = da.list_by_route(ttr_id, regime_type) res = [] dbg_from, dbg_to = 60, len(tods) - 12 for idx, tod in enumerate(tods): tod_res = json.loads(tod.result) if not tod_res: continue if idx >= dbg_from and idx < dbg_to: logger.debug( ' - time=%02d:%02d, avg_tt=%s, 95%%p_tt=%s, count=%s' % (tod.hour, tod.minute, tod_res['avg_tt'], tod_res['percentile_tts']['95'], tod_res['count'])) res.append({ 'hour': tod.hour, 'minute': tod.minute, 'avg_tt': _roundup(tod_res['avg_tt']), 'p95_tt': _roundup(tod_res['percentile_tts']['95']), 'p90_tt': _roundup(tod_res['percentile_tts']['90']), 'p85_tt': _roundup(tod_res['percentile_tts']['85']), 'p80_tt': _roundup(tod_res['percentile_tts']['80']), 'count': tod_res['count'] }) today_to = depart_time now = datetime.datetime.now() if today_to >= now: today_to = now # 5 minute interval delta = (today_to.minute - math.floor(today_to.minute / 5) * 5) * 60 + today_to.second today_to = today_to - datetime.timedelta(seconds=delta) try: today_from = datetime.datetime.combine(today_to.date(), datetime.time(0, 0, 0)) prd = period.Period(today_from, today_to, cfg.TT_DATA_INTERVAL) tts = moe.travel_time(ttri.route, prd) tts = moe.imputation(tts, imp_module=time_avg) traveltimes = _moving_average(tts[-1].data, 5) except Exception as ex: getLogger(__name__).warn('error to calculate travel times') traveltimes = [] traveltimes = _roundup(traveltimes) ttrda.close_session() return res[60:-12], traveltimes[60:]
def json2wzgi(json_str): return json.loads(json_str)
def json2route_wise_moe_parameters(json_str): return json.loads(json_str)