def __init__(self, *args, vav_nums=1, **kwargs): super(VavDevice, self).__init__(*args, **kwargs) for _ in range(0, vav_nums): vav_id = ':vav-{0}'.format(gen_uuid()) zone_id = ':zone-{0}'.format(gen_uuid()) self._register_vav_objs(vav_id, zone_id) self.add_capability(SemanticQueryServices)
def test_db_output_create(self, init_models, init_sites, init_buildings): output_db = OutputDB() # check that database is empty result = output_db.get_all() assert list(result) == [] #get service and model id models = list(ModelDB().get_all()) model_id, service_id = models[0].id, models[0].service_id # create an item output = OutputEvent(service_id, model_id, id=str(gen_uuid())) new_output_id_evt = output_db.create(output) assert new_output_id_evt is not None # check that database is not empty now result = output_db.get_all() outputs = list(result) assert len(outputs) == 1 assert outputs[0].module_id == service_id assert outputs[0].model_id == model_id #test with time series output = OutputTimeSeries(service_id, model_id, init_buildings[0], ValuesDescription('Temperature', 'DegreeCelsius', 20), id=str(gen_uuid())) new_output_id_ts = output_db.create(output) assert new_output_id_ts is not None result = output_db.get_all() outputs = list(result) assert len(outputs) == 2 output_event = outputs[0] if isinstance( outputs[0], OutputTimeSeries) else outputs[1] assert output_event.module_id == service_id assert output_event.model_id == model_id assert output_event.localization == output.localization assert output_event.values_desc.unit == output.values_desc.unit assert output_event.values_desc.kind == output.values_desc.kind assert output_event.values_desc.sampling == output.values_desc.sampling #test relation between service and output model = ModelDB().get_by_id(model_id) assert set(model.event_output_ids) == {new_output_id_evt} assert set(model.timeseries_output_ids) == {new_output_id_ts}
def predict_dep(self, target_srcids=[]): pred_g = self.new_graph(empty=True) occs = self.get_occs() for occ in occs: if self.target_building == 'ebu3b': srcid = occ.split('#')[-1] qstr = """ select ?point where {{ ?occ bf:srcid "{0}" . ?occ bf:isPointOf ?something . ?point bf:isPointOf ?something . ?point a/rdfs:subClassOf* brick:point . }} """.format(srcid) else: qstr = """ select ?point where {{ {0} bf:isPointOf ?something . ?point bf:isPointOf ?something . ?point a/rdfs:subClassOf* brick:point . }} """.format(occ.n3()) res = query_sparql(self.true_g, qstr) points = [row['point'] for row in res] random_obj = create_uri(str(gen_uuid())) # This would be a VAV. for point in points: insert_triple(pred_g, (point, BF['isPointOf'], random_obj)) insert_triple(pred_g, (random_obj, RDF['type'], BRICK['VAV'])) pred_g.serialize('test.ttl', format='turtle') self.pred_g = pred_g print('Quiver done') return pred_g
def predict_raw(self, target_srcids=[]): pred_g = self.new_graph(empty=True) if self.target_building == 'ebu3b': qstr = """ select ?occ ?occ_srcid ?point ?point_srcid where { ?occ a brick:occupied_command. ?occ bf:srcid ?occ_srcid . ?occ bf:isPointOf ?something . ?point bf:isPointOf ?something . ?point bf:srcid ?point_srcid . ?occ bf:isPointOf ?something . } """ else: raise Exception('qstr should be rewritten for {0}'.format( self.target_building)) # TODO: Add confidences (==1) res = query_sparql(self.true_g, qstr) vav_dict = {} #for # random_obj = create_uri(str(gen_uuid())) # This would be a VAV. for row in res: occ_srcid = str(row['occ_srcid']) if occ_srcid not in vav_dict: vav_dict[occ_srcid] = create_uri(str( gen_uuid())) # This would be a VAV. vav = vav_dict[occ_srcid] occ = create_uri(occ_srcid) point = create_uri(str(row['point_srcid'])) insert_triple(pred_g, (point, BF['isPointOf'], vav)) insert_triple(pred_g, (occ, BF['isPointOf'], vav)) insert_triple(pred_g, (vav, RDF['type'], BRICK['vav'])) self.pred_g = pred_g return pred_g
def __init__(self, sparql_url, brick_version, base_ns='', load_schema=True): BRICK_VERSION = brick_version self.sparql_url = sparql_url self.sparql = SPARQLWrapper(endpoint=self.sparql_url, updateEndpoint=self.sparql_url + '-auth') self.sparql.queryType = SELECT self.sparql.setCredentials('dba', 'dba') self.sparql.setHTTPAuth(DIGEST) if not base_ns: base_ns = 'http://example.com/' self.base_graph = 'urn:' + str(gen_uuid()) self.sparql.addDefaultGraph(self.base_graph) self.namespaces = { '': BASE, 'brick': BRICK, 'bf': BF, 'rdfs': RDFS, 'rdf': RDF, 'owl': OWL, 'foaf': FOAF } sparql_prefix = '' #for prefix, ns in self.namespaces.items(): # ns_n3 = ns.uri.n3() # sparql_prefix += 'prefix {0}: {1}\n'.format(prefix, ns_n3) #sparql_prefix += '\n' self._init_brick_constants() if load_schema: self.load_schema()
def __init__(self, uuid=None): # Set the type to the name of the class. self.__dict__['type'] = self.__class__.__name__.lower() # If there is a uuid, instantiate it. if uuid: self.get(uuid) # Otherwise, generate a uuid - our ojbect is new. else: self._id = gen_uuid().__str__()
def _get_verbosity(kwargs): """Private static helper method to get the verbosity settings from **kwargs.""" verbose = kwargs.get('verbose', False) verbose_period = kwargs.get('verbose_period', 1) log = kwargs.get('log', None) if log == 'unique': uuid = gen_uuid().hex[:12] log = logger.easy_setup(uuid, console_output=True, filename="log_{}.txt".format(uuid)) if log is None: log = LOCAL_LOG return verbose, verbose_period, log
def test_db_output_update(self, init_models, init_buildings): building_ids, _ = init_buildings models = list(ModelDB().get_all()) model_id, service_id = models[0].id, models[0].service_id output_db = OutputDB() output = OutputTimeSeries( service_id, model_id, building_ids[0], ValuesDescription('Temperature', 'DegreeCelsius', 20), id=str(gen_uuid())) new_output_id_ts = output_db.create(output) # get all items result = output_db.get_all() outputs = list(result) assert len(outputs) == 1 assert [item.id for item in outputs] == [new_output_id_ts] # get an item by its ID! # for a output, the ID to be used is the URL output = output_db.get_by_id(outputs[0].id) # update item data new_sampling = 400 new_model_id = models[1].id new_kind = 'Energy' new_unit = 'Joule' output.sampling = new_sampling output.model_id = new_model_id output.values_desc.kind = new_kind output.values_desc.unit = new_unit output_db.update(output.id, output) # check that item has really been updated in database updated_output = output_db.get_by_id(output.id) assert updated_output.id == output.id assert updated_output.model_id == new_model_id assert updated_output.module_id == output.module_id assert updated_output.localization == output.localization assert updated_output.values_desc.unit == new_unit assert updated_output.values_desc.kind == new_kind assert updated_output.values_desc.sampling == ( output.values_desc.sampling) # delete an item by its ID output_db.remove(output.id) # get an item by its ID with pytest.raises(ItemNotFoundError): # it has been removed... output_db.get_by_id(output.id)
async def post(self, request: Request, create_entities: CreateEntitiesRequest = Body(..., description='A dictionary to describe entities to create. Keys are Brick Classes and values are the number of instances to create for the Class'), graph: str = Query(configs['brick']['base_graph'], description=graph_desc), token: HTTPAuthorizationCredentials = jwt_security_scheme, ) -> EntitiesCreateResponse: resp = defaultdict(list) for brick_type, entities_num in create_entities.items(): for _ in range(entities_num): uri = UUID[str(gen_uuid())] await self.brick_db.add_triple(uri, RDF.type, URIRef(brick_type)) # TODO: Check the brick_type based on the parameter in the future resp[brick_type].append(str(uri)) return dict(resp)
def add_entities_json(self, entities): for entity in entities: entity_type = entity['type'] entity_id = entity.get('entity_id', None) if not entity_id: entity_id = str(gen_uuid()) entity['entity_id'] = entity_id self.db.add_brick_instance(entity_id, entity_type) for prop, obj in entity['relationships']: self.db.add_triple(':' + entity_id, prop, ':' + obj) name = entity.get('name', None) if name: self.db.add_triple(':' + entity_id, 'bf:hasName', name) return entities
def add_to_db_and_exec(code, svars): uuid = str(gen_uuid()) path = CodeExec.add_to_db(uuid, svars) try: with open(path, "w") as f: f.write(code) except IOError: return "Something went wrong" RamsimRunner.handle_request(uuid) return uuid
def add_reminder(self, hour: int, minute: int, weekday: int, concept: int) -> Union[str, NoReturn]: log("ReminderData: Adding reminder...") if 0 < hour < 25 and -1 < minute < 61 and 0 < weekday < 8: str_time = str(hour) + ":" + str(minute) + ":00" r_time = datetime.strptime(str_time, '%H:%M:%S').time() r_id = str(gen_uuid()) reminder = (r_time, weekday, concept, r_id) log("ReminderData: Created reminder " + r_id) self._reminders.append(reminder) log(self._reminders) self._db_reminders[r_id] = reminder self._sort() log("ReminderData: Executing add callbacks") for f in self._add_callbacks.values(): f(r_id) return r_id
async def add_entities_json_deprecated(self, entities): #TODO: IMplement this: raise HTTPException(status_code=501) for entity in entities: entity_type = entity['type'] entity_id = entity.get('entity_id', None) if not entity_id: entity_id = str(gen_uuid()) entity['entity_id'] = entity_id entity_id = URIRef(entity_id) self.brick_db.add_brick_instance(entity_id, entity_type) for prop, obj in entity['relationships']: obj = URIRef(obj) self.brick_db.add_triple(entity_id, prop, obj) name = entity.get('name', None) if name: self.brick_db.add_triple(entity_id, 'bf:hasName', name) return entities
async def _bulk_upsert_data(self, data, col_name): temp_table = '_temp_{0}'.format(gen_uuid().hex) async with self.pool.acquire() as conn: await conn.execute(""" CREATE TEMPORARY TABLE {temp_table} ( uuid TEXT, time TIMESTAMP, {col_name} {data_type}) """.format(col_name=col_name, temp_table=temp_table, data_type=self.column_type_map[col_name])) await conn.copy_records_to_table(temp_table, records=data) res = await conn.execute(""" INSERT INTO {target_table} (uuid, time, {col_name}) SELECT * FROM {temp_table} ON CONFLICT (time, uuid) DO UPDATE SET {col_name}=EXCLUDED.{col_name} WHERE {target_table}.{col_name} <> EXCLUDED.{col_name}; DROP TABLE {temp_table}; """.format(target_table=self.TABLE_NAME, temp_table=temp_table, col_name=col_name))
def create_entity(self, entity_type): return str(gen_uuid())
def process_file(file_path, base_sandbox_path, final_path, id): filename = os.path.basename(file_path) status = {"error":False, "state":"started", "result":None, "file_to_remove":file_path, \ "exception":None, "sandbox_id":id, "filename":filename, "file_to_mail":None, \ "file_list":[], "file_info_str":None, "json_failed":False} try: filename = os.path.basename(file_path) if not filename.endswith(".zip"): logging.warning( "Random shit received: {}, ignoring!".format(filename)) status["state"] = "finished" status["error"] = True status["result"] = "random_nonzip_shit" os.remove(file_path) status["file_to_remove"] = None raise ValueError("Got random shit") status["state"] = "processing_magic" logging.info("{}: processing {}".format(id, filename)) with open(file_path) as f: type = magic.from_buffer(f.read(1024)) logging.info("{}: '{}' file".format(id, type)) status["state"] = "checking_magic" if not type.startswith("Zip archive") or not is_zipfile(file_path): logging.warning( "Random .zip-imitating shit received: {}, ignoring!".format( filename)) status["state"] = "finished" status["error"] = True status["result"] = "random_fakezip_shit" os.remove(file_path) status["file_to_remove"] = None raise ValueError("Got random shit pretending to be ZIP") #TODO: check file size status["state"] = "moving_into_sandbox_base" os.rename(file_path, os.path.join(base_sandbox_path, filename)) status["file_to_remove"] = os.path.join(base_sandbox_path, filename) logging.info("{}: Moved file to the base sandbox folder".format(id)) sandbox_dir = os.path.join(base_sandbox_path, str(id)) logging.info("Cleaning sandbox dir: {}".format(sandbox_dir)) status["state"] = "cleaning_sandbox_base" clean_dir(sandbox_dir) sandbox_base_path = os.path.join(base_sandbox_path, filename) sandboxed_file_path = os.path.join(sandbox_dir, filename) status["state"] = "moving_into_sandbox" shutil.move(sandbox_base_path, sandboxed_file_path) status["file_to_remove"] = sandboxed_file_path logging.info("{}: Moved the file into the sandbox".format(id)) status["state"] = "extracting_into_sandbox" with ZipFile(sandboxed_file_path, 'r') as zf: status["file_list"] = list(zf.namelist()) status["file_info_to_str"] = dump_zipinfos_to_str(zf.infolist()) zf.extractall(sandbox_dir) status["state"] = "removing_original" logging.info("{}: Removing original file: {}".format( id, sandboxed_file_path)) os.remove(sandboxed_file_path) status["file_to_remove"] = None status["state"] = "generating_dest_filename" # filename, maybe extension fme = filename.rsplit('.', 1) if len(fme) == 1: logging.warning("lol wtf {} has no extension?".format(filename)) result_path = os.path.join(final_path, "{}-{}".format(filename, gen_uuid())) elif len(fme) == 2: # Expected result result_path = os.path.join( final_path, "{}-{}.{}".format(fme[0], gen_uuid(), fme[-1])) else: logging.warning( "lol wtf len({}.rsplit('.', 1)) != 2 ?".format(filename)) result_path = os.path.join(final_path, "{}-{}".format(filename, gen_uuid())) status["state"] = "packing_files" with ZipFile(result_path, 'w', ZIP_DEFLATED) as zf: for fn in status["file_list"]: zf.write(os.path.join(sandbox_dir, fn), fn) status["file_to_mail"] = result_path status["state"] = "success" except Exception as e: logging.exception("Failure during archive processing!") status["error"] = True status["exception"] = [ traceback.format_exc(), {k: str(v) for k, v in inspect.trace()[-1][0].f_locals.items()} ] if status["file_to_remove"]: try: os.remove(status["file_to_remove"]) except: logging.exception("Failure during file removal!") status["exception"].append([traceback.format_exc()]) heading = "ZeroPhone bugreport upload fail" if status.get( "error", False) else "ZeroPhone bugreport uploaded" files = [status["file_to_mail"]] if status.get("file_to_mail", None) else [] for key in status.keys(): if status[key] is None: status[key] = "None" logging.info(status) try: text = json.dumps(status) except: logging.exception("Status-to-JSON conversion failed!") status["json_failed"] = True text = str(status) try: sendMail(config["mail_destination"], 'ZeroPhone bugreport <*****@*****.**>', \ heading, text, files, server=config.get('mail_server', None)) except Exception as e: try: status["exception"].append([traceback.format_exc()]) status["exception"].append([{ k: str(v) for k, v in inspect.trace()[-1][0].f_locals.items() }]) logging.exception(status) except: logging.exception("wtf") return id
def uuid4(): """ Method to generate uuid as primary key for student and student_class :return: string as uuid """ return str(gen_uuid())
def register_remove_callback(self, f: callable) -> str: log("ReminderData: Registering new remove callback") identifier = str(gen_uuid()) self._remove_callbacks[identifier] = f log("ReminderData: Registered " + identifier) return identifier
if isinstance(val, float): if np.isnan(val): continue if tag in h_tags: if val == 'M': val = 'm:' datum[tag] = val data.append(datum) # Read rows to intantiate Brick g = Graph() # init graph entity_dict = defaultdict(list) # To validate if all entities are intantiated. for row in data: entity_h_tags = set() identifier = gen_uuid() raw_ref_dict = [] for (tag, value) in row.items(): if tag == 'id': identifier = quote_plus(value) elif value in ['Marker' , 'm:']: entity_h_tags.add(tag) elif 'Ref' in tag: ref_type = tag[:-3] ref_id = quote_plus(value[1:]) # remove '@' entity_dict[ref_type].append(ref_id) raw_ref_dict.append((ref_type, ref_id)) # Determine is-a relationship from the tag set. if identifier == '%401d552c40-54c9904c+%22AHU+03+Supply+Air+Pressure+Filter+DP%22': pdb.set_trace()
def generate_uuid(): uuid = str(gen_uuid()) config["uuid"] = uuid save_config(config) PrettyPrinter("Generated new UUID!", i, o, 3)
def uuid4(): return str(gen_uuid())