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)
