async def add_connection(from_type: ObjectTypeEnum, from_name: str, to_type: ObjectTypeEnum, to_name: str, connection_type: RelationTypeEnum = Query( RelationTypeEnum.default), session_id=Depends(get_session_id)): connection_type = connection_type if connection_type != 'default' else '' fo = SessionManager.get_model_object_instance(test_user, session_id, from_type, from_name) to = SessionManager.get_model_object_instance(test_user, session_id, to_type, to_name) fo.connect(connection_type=connection_type)[to_type][to_name].add()
async def add_connections(connections: List[Connection], session_id=Depends(get_session_id)): for connection in connections: fo_type, fo_name = connection.from_object.object_type, connection.from_object.object_name to_type, to_name = connection.to_object.object_type, connection.to_object.object_name relation_type = connection.relation_type if connection.relation_type != 'default' else '' fo = SessionManager.get_model_object_instance( test_user, session_id, fo_type, fo_name) to = SessionManager.get_model_object_instance( test_user, session_id, to_type, to_name) fo.connect(connection_type=relation_type)[to_type][to_name].add()
def check_that_time_resolution_is_set( session_id: int = Depends(get_session_id)): is_set = SessionManager.get_user_session( test_user).shop_sessions_time_resolution_is_set[session_id] if is_set == False: raise HTTPException( 400, 'First you must set the time_resolution of the session')
async def get_connections(session_id=Depends(get_session_id)): connections = [] for object_type in shop_session(test_user, session_id).model._all_types: generator = SessionManager.get_model_object_generator( test_user, session_id, object_type) for object_name in generator.get_object_names(): from_object = generator[object_name] for relation_direction in RelationDirectionEnum: for relation_type in RelationTypeEnum: for r in from_object.get_relations( direction=relation_direction, relation_type=relation_type): to_object = serialize_model_object_instance(r) connections += [ Connection( from_object=serialize_model_object_instance( from_object), to_object=to_object, relation_type=relation_type, relation_direction=relation_direction, ) ] return connections
async def set_time_resolution(time_resolution: TimeResolution = Body( ..., example={ "start_time": "2021-05-02T00:00:00.00Z", "end_time": "2021-05-03T00:00:00.00Z", "time_unit": "hour" }), session_id=Depends(get_session_id)): # validate start = pd.Timestamp(time_resolution.start_time) end = pd.Timestamp(time_resolution.end_time) if (end <= start): raise HTTPException( 400, 'end_time must be strictly greater than start_time') shop_session(test_user, session_id).set_time_resolution( starttime=time_resolution.start_time, endtime=time_resolution.end_time, timeunit=time_resolution. time_unit # TODO: also use time_resolution series ) # store the fact that time_resolution has been set us = SessionManager.get_user_session(test_user) us.shop_sessions_time_resolution_is_set[session_id] = True return None
async def get_session(session_id: int = Query(1)): if session_id in SessionManager.get_shop_sessions(test_user): s = shop_session(test_user, session_id) return Session(session_id=s._id, session_name=s._name) else: raise HTTPException(404, f'Session with id {{{session_id}}} not found')
async def get_model_object_instance( object_type: ObjectTypeEnum, object_name: str = Query('example_reservoir'), attribute_filter: str = Query( '*', description='filter attributes by regex'), session_id=Depends(get_session_id)): if attribute_filter != '*': raise HTTPException( 500, 'setting attribute_filter != * is not support yet') o = SessionManager.get_model_object_instance(test_user, session_id, object_type, object_name) return serialize_model_object_instance(o)
async def create_or_modify_existing_model_object_instance( object_type: ObjectTypeEnum, object_name: str = Query('example_reservoir'), object_instance: ObjectInstance = Body( None, example={ 'attributes': { 'vol_head': { 'x_values': [10.0, 20.0, 30.0], 'y_values': [42.0, 43.0, 45.0] }, 'water_value_input': { '0.0': { 'x_values': [10.0, 9.0, 8.0], 'y_values': [42.0, 20.0, 10.0] } }, 'inflow': { #'values': {'2020-01-01T00:00:00': [ 42.0 ] } 'timestamps': ['2020-01-01T00:00:00', '2020-01-01T05:00:00'], 'values': [[42.0, 50.0]] } } }), session_id=Depends(get_session_id)): session = shop_session(test_user, session_id) try: object_generator = session.model[object_type] except Exception as e: raise HTTPException( 500, f'model does not implement object_type {{{object_type}}}') if object_name not in object_generator.get_object_names(): try: object_generator.add_object(object_name) except Exception as e: raise HTTPException( 500, f'object_name {{{object_name}}} is in conflict with existing instance' ) model_object = session.model[object_type][object_name] if object_instance and object_instance.attributes: for (k, v) in object_instance.attributes.items(): try: datatype = model_object[k].info()['datatype'] except Exception as e: http_raise_internal( f'unknown object_attribute {k} for object_type {object_type}', e) if datatype == 'txy': # convert scalar values to TimeSeries if type(v) == float or type(v) == int: start_time = shop_session( test_user, session_id).get_time_resolution()['starttime'] v = TimeSeries(timestamps=[start_time], values=[[v]]) try: time_series: TimeSeries = v # index, values = zip(*time_series.values.items()) index, values = time_series.timestamps, np.transpose( time_series.values) df = pd.DataFrame(index=index, data=values) model_object[k].set(df) except Exception as e: http_raise_internal(f'trouble setting {{{datatype}}} ', e) elif datatype == 'xy': try: curve: Curve = v ser = pd.Series(index=curve.x_values, data=curve.y_values) model_object[k].set(ser) except Exception as e: http_raise_internal(f'trouble setting {{{datatype}}} ', e) elif datatype in ['xy_array', 'xyn']: try: curves: OrderedDict[float, Curve] = v ser_list = [] for ref, curve in curves.items(): ser_list += [ pd.Series(index=curve.x_values, data=curve.y_values, name=ref) ] model_object[k].set(ser_list) except Exception as e: http_raise_internal(f'trouble setting {{{datatype}}} ', e) elif datatype == 'xyt': try: curves: OrderedDict[datetime, Curve] = v ser_list = [] for ref, curve in curves.items(): ser_list += [ pd.Series(index=curve.x_values, data=curve.y_values, name=ref) ] model_object[k].set(ser_list) except Exception as e: http_raise_internal(f'trouble setting {{{datatype}}} ', e) elif datatype == 'double': model_object[k].set(float(v)) elif datatype == 'int': model_object[k].set(int(v)) else: try: model_object[k].set(v) except Exception as e: http_raise_internal(f'trouble setting {{{datatype}}} ', e) o = SessionManager.get_model_object_instance(test_user, session_id, object_type, object_name) return serialize_model_object_instance(o)
async def get_model_object_type_information( object_type: ObjectTypeEnum, attribute_filter: str = Query( '*', description='filter attributes by regex'), verbose: bool = Query( False, description= 'toggles additional attribute information, e.g is_input, is_output, etc ...' ), session_id=Depends(get_session_id)): if attribute_filter != '*': raise HTTPException( 500, 'setting attribute_filter != * is not support yet') ot = SessionManager.get_model_object_generator(test_user, session_id, object_type) instances = list(ot.get_object_names()) sess = shop_session(test_user, session_id) attribute_names: List[str] = list( sess.shop_api.GetObjectTypeAttributeNames(object_type)) attribute_types: List[str] = list( sess.shop_api.GetObjectTypeAttributeDatatypes(object_type)) if not verbose: attributes = { n: new_attribute_type_name_from_old(t) for n, t in zip(attribute_names, attribute_types) } else: # TODO: Create this kind of dictionary once at startup, since this might be expensive? attr_info = { attr_name: { info_key: sess.shop_api.GetAttributeInfo(object_type, attr_name, info_key) for info_key in sess.shop_api.GetValidAttributeInfoKeys() } for attr_name in attribute_names } attributes = { n: ObjectAttribute( attribute_name=n, attribute_type=new_attribute_type_name_from_old(t), is_input=attr_info[n]['isInput'], is_output=attr_info[n]['isOutput'], legacy_datatype=attr_info[n]['datatype'], x_unit=attr_info[n]['xUnit'], y_unit=attr_info[n]['yUnit'], license_name=attr_info[n]['licenseName'], full_name=attr_info[n]['fullName'], data_func_name=attr_info[n]['dataFuncName'], description=attr_info[n]['description'], documentation_url=attr_info[n]['documentationUrl'], example_url_prefix=attr_info[n]['exampleUrlPrefix'], example=attr_info[n]['example']) for n, t in zip(attribute_names, attribute_types) } return ObjectType( object_type=object_type, instances=instances, attributes=attributes, )
def shop_session(user_name: str, session_id: str): return SessionManager.get_shop_session(user_name, session_id)
async def get_sessions(): return [ Session(session_id=s._id, session_name=s._name) for _, s in SessionManager.get_shop_sessions(test_user).items() ]
async def create_session(s: Session = Body(Session(session_name='unnamed'), example={'name': 'unnamed'})): s = SessionManager.add_shop_session(test_user, session_name=s.session_name) return Session(session_id=s._id, session_name=s._name)
def http_raise_internal(msg: str, e: Exception): raise HTTPException(500, f'{msg} -- Internal Exception: {e}') def get_session_id(session_id: int = Header(1)) -> int: return session_id def check_that_time_resolution_is_set( session_id: int = Depends(get_session_id)): is_set = SessionManager.get_user_session( test_user).shop_sessions_time_resolution_is_set[session_id] if is_set == False: raise HTTPException( 400, 'First you must set the time_resolution of the session') test_user = '******' SessionManager.add_user_session('test_user', None) SessionManager.add_shop_session(test_user, 'default_session') pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto") oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token") def verify_password(plain_password, hashed_password): return pwd_context.verify(plain_password, hashed_password) def get_password_hash(password): return pwd_context.hash(password) def get_user(db, username: str): if username in db: user_dict = db[username]