def test__one_by_one_import_all(): mock_measurement = Measurement() mock_measurement.save = MagicMock(return_value=1) measurements = [mock_measurement, mock_measurement] inserted_count = Importer._one_by_one_import_all(measurements) assert inserted_count == 2
def deleteMeasurement(): if not current_user.isAdmin(): flash(constants.NOT_ALLOWED, 'danger') else: measurementid = unicode(request.form['measurementid']) Measurement.delete(Measurement.get(measurementid)) flash(constants.MEASUREMENT_DELETE_SUCCESS, 'success') return redirect(url_for('manageMeasurements'))
def manageMeasurements(): if request.method == 'GET': measurements = Measurement.getAll() users = {} for user in User.getAll(): users[user.id] = user.username return render_template('measurements.html', measurements=measurements, users=users) elif request.method == 'POST': month = request.form['month'] day = request.form['day'] year = request.form['year'] hour = request.form['hour'] minute = request.form['minute'] second = request.form['second'] ampm = request.form['ampm'] if ampm == 'am' and hour == '12': hour = '00' elif ampm == 'pm' and hour != '12': hour = str(int(hour) + 12) try: t = datetime.strptime(' '.join([month, day, year, hour, minute, second]), '%m %d %Y %H %M %S') except ValueError: flash(constants.DATE_OUT_OF_RANGE, 'danger') return redirect(url_for('manageMeasurements')) # t = request.form['time'] # try: # t = datetime.strptime(t, '%Y-%m-%dT%H:%M:%S') # except ValueError: # try: # t = datetime.strptime(t, '%Y-%m-%dT%H:%M') # except ValueError: # flash(constants.INVALID_DATE, 'danger') # return redirect(url_for('manageMeasurements')) ph = float(request.form['ph']) do = float(request.form['do']) ec = float(request.form['ec']) temp = float(request.form['temp']) try: if not (0 <= ph <=14): raise ValueError(constants.INVALID_PH) if not (0 <= do <= 36): raise ValueError(constants.INVALID_DO) if not (0 <= ec): raise ValueError(constants.INVALID_EC) except ValueError as e: flash(e.args[0], 'danger') return redirect(url_for('manageMeasurements')) measurement = Measurement.get(t) if measurement: flash(constants.TIME_TAKEN, 'danger') else: Measurement.create(Measurement(current_user.id, t, ph, do, ec, temp)) flash(constants.MEASUREMENT_CREATE_SUCCESS, 'success') return redirect(url_for('manageMeasurements'))
def meas_add(): form = MeasForm(request.form, csrf_enabled=False) if request.method == 'POST' and form.validate(): meas = Measurement(sys=form.sys.data, dia=form.dia.data, pulse=form.pulse.data) meas.put() return redirect(url_for('meas_add')) return render_template('meas_form.html', form=form)
def processRows(reader, filename): badSyntax = [] timeTaken = [] date = os.path.splitext(filename)[0] try: datetime.strptime(date, '%m.%d.%y') except ValueError: flash(constants.INVALID_CSV_NAME, 'danger') return for row in reader: if len(row) == 5: t = date + ' ' + row[0] try: t = datetime.strptime(t, '%m.%d.%y %H:%M:%S') except ValueError: try: t = datetime.strptime(t, '%m.%d.%y %H:%M') except ValueError: badSyntax.append(reader.line_num) continue ph = row[1] do = row[2] ec = row[3] temp = row[4] try: ph = float(ph) do = float(do) ec = float(ec) temp = float(temp) if not (0 <= ph <= 14): raise ValueError(constants.INVALID_PH) if not (0 <= do <= 36): raise ValueError(constants.INVALID_DO) if not (0 <= ec): raise ValueError(constants.INVALID_EC) except ValueError: badSyntax.append(reader.line_num) continue measurement = Measurement.get(t) if measurement: timeTaken.append(reader.line_num) continue Measurement.create(Measurement(current_user.id, t, ph, do, ec, temp)) else: badSyntax.append(reader.line_num) flash(constants.CSV_UPLOAD_SUCCESS, 'success') if badSyntax: flash(constants.CSV_BAD_SYNTAX.format(json.dumps(badSyntax)), 'info') if timeTaken: flash(constants.CSV_TIME_TAKEN.format(json.dumps(timeTaken)), 'info')
def post(self): data = json.loads(self.request.body) if not (set(data.keys()) == {'timestamp', 'type', 'amount'}): raise ValueError() timestamp = datetime.fromtimestamp(data['timestamp']) measurement = Measurement(timestamp=timestamp, amount=float(data['amount']), type=data['type']) measurement.put()
def test_bulk_import_new_measurements_empyt_db(client): import_measurements = [ Measurement(timestamp=datetime.datetime( 2017, 1, 1, 0, tzinfo=pendulum.timezone("Europe/Berlin")), nodeId='test_node'), Measurement(timestamp=datetime.datetime( 2017, 1, 1, 2, tzinfo=pendulum.timezone("Europe/Berlin")), nodeId='test_node') ] insert_count = Importer._bulk_import_new_measurements(import_measurements) assert insert_count == 2 assert db.session.query(Measurement).count() == 2
def test_filters_old_measurements(client): # Arrange timestamp = datetime.now() Measurement(nodeId="node-1", isemsRevision="1", timestamp=timestamp - timedelta(days=45)).save() Measurement(nodeId="node-2", isemsRevision="1", timestamp=timestamp).save() # Act rv = client.get('/measurements/latest') # Assert assert rv.json == {'measurements': [{**base_measurement, 'id': 2, 'nodeId': 'node-2', 'timestamp': timestamp.isoformat()}]}
def consolidate_measurements(identifier, type_): # aggregate the individual measurements measurements = Measurement.all(identifier, type_).order(Measurement.timestamp).fetch(keys_only=True) logging.info('There are %d measurements' % (len(measurements),)) i = 0 if len(measurements) >= BLOCK_SIZE: measurements = ndb.get_multi(measurements) for blocknr in range(len(measurements) // BLOCK_SIZE): blockdata = [] to_delete = [] first, last = datetime.datetime(2999, 12, 31), datetime.datetime(1000, 1, 1) for mnr in range(BLOCK_SIZE): measurement = measurements[i] if not measurement: return "Odd stuff." i += 1 ts = measurement.timestamp blockdata.append((int(time.mktime(ts.timetuple())), measurement.value)) first = min(first, ts) last = max(last, ts) to_delete.append(measurement.key) # Full block, add it block = MeasurementBlock(identifier=identifier, type=type_, count=BLOCK_SIZE, first=first, last=last, values=json.dumps(blockdata)) block.put() ndb.delete_multi(to_delete) consolidate_blocks(identifier, type_, 1) consolidate_blocks(identifier, type_, 2) return "Ok."
def add_measurement_for_ingredient(ingredient, recipe_data): """ Add measurements for corresponding ingredients in a recipe to the db recipe_data (obj): recipe data from the Spoonacular API ingredient (obj): ingredient data Returns the recipe from the db """ try: recipe_id = recipe_data.get('id', None) ingredient_id = ingredient.get('id', None) amount = ingredient.get('amount', None) unit = ingredient.get('unit', None) new_measurement = Measurement(ingredient_id=ingredient_id, recipe_id=recipe_id, amount=amount, unit=unit) new_measurement = add_and_commit(new_measurement) except Exception as e: db.session.rollback() # import pdb # pdb.set_trace() print('***********************') print(str(e)) print('***********************') return recipe_data
def patch(self, id): try: measurement = Measurement.objects(id=id).first() if measurement is not None: if get_formatted_date( measurement.created) != get_formatted_date( get_today_date()): raise BadRequest( f'Cannot update a measurement for {get_formatted_date(measurement.created)}' ) data = self.reqparse.parse_args() data = normalize_data(data) measurement.update(**data) measurement.reload() return measurement.to_dict(), 200 abort(404, message=f'Measurement ID={id} was not found') except BadRequest as e: app.logger.error(e) raise e except NotFound as e: app.logger.error(e) raise e except Exception as e: app.logger.error(e) abort(500, message=str(e))
def process_data(data): # first decouple binary data barr = bytearray(data) proto = UnicornProto.from_buffer(barr) print proto.device for field in proto._fields_: print field[0], getattr(proto, field[0]) #get device station, _ = Station.get_or_create(device_id=proto.device, ) # store parsed data into DB measured = Measurement.create( station=station, timestamp=proto.timestamp, temperature=proto.temperature, humidity=proto.humidity, pressure=proto.pressure, CO2=proto.CO2, light=proto.light, snow=proto.snow_intensity, rain=proto.rain_intensity, battery=proto.battery, ) return measured
def image_update(): try: unit = request.args.get('consumer_unit') print(unit) image = request.files['file'] if unit is None or image is None: return _build_response({'error': 'No unit was specified'}, 400) costumer = Costumer.query.filter_by(consumer_unit=unit).first() if costumer is None: return _build_response({'error': 'Costumer not found'}, 404) timestamp = str(time.time()) path = image_path + unit + '_' + timestamp + '_' + secure_filename( image.filename) image.save(path) img = Image.open(image) # ABRE A IMG REFERIDA # TODO: Function to get the measurement value from the image value = ocr.image_to_string( img, lang='eng', config='--psm 10' ) # CONVERTE A IMG PARA STRING COM OS PARAMETROS DE LINGUA INGLESA E PSM 10 print(value) new_measurement = Measurement(value, path, costumer.id) db.session.add(new_measurement) db.session.commit() return _build_response({'success': True}, 200) except Exception as error: return _build_response({'error': str(error)}, 500)
def on_get(self, req, resp, name=None): try: if name: result = list( Measurement.select( Measurement.timestamp, Measurement.temperature, Measurement.pressure, Measurement.humidity, Measurement.light, Measurement.CO2, Measurement.rain, Measurement.snow, Measurement.battery, Station.name, Station.id, ).join(Station).where(Station.name == name).order_by( Measurement.timestamp.desc()).limit(100).dicts())[::-1] else: result = list( Measurement.select( Measurement.timestamp, Measurement.temperature, Measurement.pressure, Measurement.humidity, Measurement.light, Measurement.CO2, Measurement.rain, Measurement.snow, Measurement.battery, Station.name, Station.id, ).join(Station).order_by( Measurement.timestamp.desc()).limit(200).dicts())[::-1] except Exception as ex: self.logger.error(ex) print ex description = ('Aliens have attacked our base! We will ' 'be back as soon as we fight them off. ' 'We appreciate your patience.') raise falcon.HTTPServiceUnavailable('Service Outage', description, 30) resp.context['result'] = result resp.status = falcon.HTTP_200
def get(self, id): """ Returns a measurement given its ID """ measurement = Measurement.objects(id=id).first() if measurement is not None: return measurement.to_dict(), 200 self.abort_with_http_code_error(404, f'Measurement ID={id} was not found')
def test_some_data(client): # Arrange timestamp = datetime.now() Measurement(nodeId="node-1", isemsRevision="1", timestamp=timestamp).save() Measurement(nodeId="node-2", isemsRevision="1", timestamp=timestamp).save() # Act rv = client.get('/measurements/latest') # Assert assert rv.json == {'measurements': [{**base_measurement, 'id': 1, 'nodeId': 'node-1', 'timestamp': timestamp.isoformat()}, {**base_measurement, 'id': 2, 'nodeId': 'node-2', 'timestamp': timestamp.isoformat()}]}
def getTask(task_id): mariadb_connection = mariadb.connect(user='******', password='******', database='PlantHubDB') cursor = mariadb_connection.cursor() cursor.execute("SELECT * FROM Measurement WHERE ID={}".format(task_id)) entry = cursor.fetchall() data = Measurement(entry[0][0], entry[0][1], entry[0][2], entry[0][3], entry[0][4], entry[0][5]) closeConnection() return data.data
def get_reply(measured): # get last ts from DB last = Measurement.select().where( Measurement.station == measured.station, Measurement.timestamp < measured.timestamp).order_by( Measurement.timestamp.desc()).first() ts = int(time.time()) if last: ts = last.timestamp return ctypes.c_ulong(ts)
def test_new_measurement(): new_measurement = Measurement(1, '001100', 'a', 'manu12', 110, 111, 101.00) assert new_measurement.id == 1 assert new_measurement.meas_date == '001100' assert new_measurement.event_type == 'a' assert new_measurement.manufacturerID == 'manu12' assert new_measurement.gluc_value == 110 assert new_measurement.insulin_value == 111 assert new_measurement.carb == 101.00 assert not new_measurement.carb == 86753.29
def get(self, id): try: measurement = Measurement.objects(id=id).first() if measurement is not None: return measurement.to_dic(), 200 abort(404, message=f'Measurement ID={id} was not found') except NotFound as e: raise e except Exception as e: abort(500, message=str(e))
def getLatestTask(sensor_id): mariadb_connection = mariadb.connect(user='******', password='******', database='PlantHubDB') cursor = mariadb_connection.cursor() cursor.execute("SELECT * FROM Measurement WHERE Date=( SELECT MAX(Date) FROM Measurement WHERE SensorId={} )".format(sensor_id)) entry = cursor.fetchall() n = len(entry) - 1 data = Measurement(entry[n][0], entry[n][1], entry[n][2], entry[n][3], entry[n][4], entry[n][5]) closeConnection() return data.data
def create_measurement(Session): session = Session() measurement = Measurement() cpu_utilization(measurement) cpu_stats(measurement) memory_stats(measurement) swap_stats(measurement) disk_stats(measurement) processes(measurement) session.add(measurement) session.commit()
def measurement(): measurement = Measurement(request.form['sensor_id'], request.form['temprature'], request.form['humidity'], request.form['distance']) db.session.add(measurement) db.session.commit() return jsonify(Measurement.query.get(measurement.id).json())
def create_measurement(): request_data = request.get_json() auth = request.headers.get("X-Api-Key") # For creating measurements you need a valid API key if auth != app.config["API_KEY"]: return jsonify({"message": "ERROR: Unauthorized or missing API key"}), 401 measurement = Measurement( # "id" : _id, sensor=request_data["sensor"], timestamp=dt.datetime.strptime(request_data["timestamp"], "%Y-%m-%d %H:%M:%S"), value=request_data["value"], ) db.session.add(measurement) db.session.commit() return jsonify(measurement.serialize()), 201, { "Location": url_for('get_measurement', _id=measurement.id) }
def save_measurement(self, name, value): """Save the given measure.""" if not self.has_category(name): raise ValueError( "Unable to save because the category '{}' does not exist!". format(name)) category = self._session.query(Category).filter_by(name=name).first() measurement = Measurement(value=value, category=category, timestamp=datetime.now()) self._session.add(measurement) self._session.commit()
def getTasks(amount): mariadb_connection = mariadb.connect(user='******', password='******', database='PlantHubDB') cursor = mariadb_connection.cursor() all_data = [] cursor.execute("SELECT * FROM Measurement") all_entries = cursor.fetchall() for row in all_entries: entry = Measurement(row[0], row[1], row[2], row[3], row[4], row[5]) all_data.append(entry.data) closeConnection() return all_data
def parse_line(cls, line): parts = line.split(";") VALID_FIELD_COUNTS = [ 18, # without status 19 # with new status field ] field_count = len(parts) try: assert (field_count in VALID_FIELD_COUNTS) except AssertionError: print("Assertion failed for line: {}".format(line)) return None measurement = Measurement(nodeId=parts[0], isemsRevision=parts[1], timestamp=datetime.fromtimestamp( int(parts[2]), tz=pendulum.timezone("Europe/Berlin")), openMPPTFirmwareVersion=parts[3], timeToShutdown=parts[4], isPowerSaveMode=(parts[5] == "1"), openCircuitVoltage=parts[6], mppVoltage=parts[7], batteryVoltage=parts[8], batteryChargeEstimate=parts[9], batteryHealthEstimate=parts[10], batteryTemperature=parts[11], lowVoltageDisconnectVoltage=parts[12], temperatureCorrectedVoltage=parts[13], rateBatteryCapacity=parts[14], ratedSolarModuleCapacity=parts[15], latitude=float(parts[16]), longitude=float(parts[17])) if field_count == 19: measurement.status = int(parts[18], 16) return measurement
def _bulk_import_new_measurements(cls, measurements): max_timestamp = Measurement.get_latest_timestamp( measurements[0].nodeId) if max_timestamp: max_timestamp = max_timestamp.replace( tzinfo=pendulum.timezone("Europe/Berlin")) new_measurements = [ m for m in measurements if m.timestamp > max_timestamp ] else: new_measurements = measurements db.session.bulk_save_objects(new_measurements) db.session.commit() return len(new_measurements)
def setUp(self): self.h1 = [ '192.168.0.1', '192.168.0.36', '192.168.0.28', '192.168.0.34', '192.168.0.42', '192.168.0.3' ] self.h2 = [ '192.168.0.2', '192.168.0.136', '192.168.0.8', '192.168.0.16', '192.168.0.39', '192.168.0.146', '192.168.0.3' ] self.h3 = [ '192.168.0.1', '192.168.0.136', '192.168.0.8', '192.168.0.18' '192.168.0.16', '192.168.0.39', '192.168.0.146', '192.168.0.4' ] self.p1 = p.Path(hops=self.h1, id=1) self.p2 = p.Path(hops=self.h2, id=2) self.p3 = p.Path(hops=self.h3, id=3) self.p4 = p.Path(hops=self.h1, id=4) self.m1 = m.Measurement(66, 1476351846113) self.m2 = m.Measurement(69, 1476351876762) self.m3 = m.Measurement(62, 1476351898901) self.m4 = m.Measurement(66, 1476351846113)
def add_static_data(self): with app.app_context(): category1 = Category('Test Category 1') category2 = Category('Test Category 2') db.session.add(category1) db.session.add(category2) course1 = Course('Test Course 1') course2 = Course('Test Course 2') db.session.add(course1) db.session.add(course2) cuisine1 = Cuisine('Test Cuisine 1') cuisine2 = Cuisine('Test Cuisine 2') db.session.add(cuisine1) db.session.add(cuisine2) country1 = Country('Test Country 1') country2 = Country('Test Country 2') db.session.add(country1) db.session.add(country2) author_country1 = Country.query.filter_by( country_name='Test Country 1').first() author1 = Author('Test Author 1') author_country1.authors.append(author1) db.session.add(author_country1) author_country2 = Country.query.filter_by( country_name='Test Country 2').first() author2 = Author('Test Author 2') author_country2.authors.append(author2) db.session.add(author_country2) measurement1 = Measurement('Test Measurement 1') measurement2 = Measurement('Test Measurement 2') db.session.add(measurement1) db.session.add(measurement2) ingredient1 = Ingredient('Test Ingredient 1') ingredient2 = Ingredient('Test Ingredient 2') db.session.add(ingredient1) db.session.add(ingredient2) db.session.commit()
def measruements_batch(): try: json = request.get_json() userid = json['username'] for entry in json['measurements']: measurement = Measurement( int(userid), datetime.fromtimestamp(entry['timestamp']), int(entry['hr']), float(entry['gsr']), entry['state'], float(entry['level'])) db.session.add(measurement) db.session.commit() return jsonify(success=str(len(json['measurements'])) + " entries inserted.") except Exception, e: return jsonify(error=str(e)), 500
def post(self): """ Creates a measurement """ data = self.reqparse.parse_args() measurement = Measurement(**data) user = User.objects(email='*****@*****.**').first() measurement.user = user measurement.save() return measurement.to_dict(), 201
def fetch_measurements_for_parameter(con, param_name): cursorObj = con.cursor() table_name = param_name + "_parameter" print(table_name) cursorObj.execute('SELECT * FROM ' + table_name) rows = cursorObj.fetchall() print("Finish fetching all rows.") measurements = [] for row in rows: row_dict = dict(zip(col_headers, row)) row_dict['parameter'] = param_name measurement = Measurement(row_dict) measurements.append(measurement) print("Finish converting to measurement objects.") return measurements
def save_measurement(): data = request.get_json() # db query registered_user = User.query.filter_by(login=data['login']).first() if registered_user is None: return {"message": f"User {data['login']} not found."}, 400 else: measurement = Measurement(min=data['min'], max=data['max'], avg=data['avg'], gps_longitude=data['gps_longitude'], gps_latitude=data['gps_latitude'], user_login=data['login']) db_session.add(measurement) db_session.commit() return {"message": f"Saved successfully."}, 201
def get(self): datak = memcache.get('metrics') if datak is None: tdata = [] measurements = Measurement.query() for m in measurements: mdict = m.to_dict() mdict['timestamp'] = datetime.strftime(mdict['timestamp'], "%Y-%m-%d %H:%M:%S") if mdict['updated']: mdict['updated'] = datetime.strftime(mdict['updated'], "%Y-%m-%d %H:%M:%S") tdata.append(mdict) datak = self._to_blobstore(tdata) self.response.headers['Content-Type'] = 'application/zip' stamp = str(int(time.mktime(memcache.get('updated').timetuple()))) self.send_blob(datak, save_as='metrics-{}.zip'.format(stamp))
def get(self): # Generate lower bound for timestamp lower_bound = datetime.now() + timedelta(days=-7) dosables = Dosable.query(Dosable.timestamp > lower_bound).fetch() measurements = (Measurement.query(Measurement.timestamp > lower_bound) .fetch()) parallel_switches = (ParallelSwitch .query(ParallelSwitch.timestamp > lower_bound).fetch()) # Sort data in each category by type for data_group in [dosables, measurements, parallel_switches]: data_group.sort(key=lambda d: d.type) ret = { category: {type: [instance.to_json() for instance in instances] for type, instances in itertools.groupby(data_group, key=lambda x: x.type)} for category, data_group in [('dosables', dosables), ('measurements', measurements), ('parallel_switches', parallel_switches)] } self.out_json(ret)
def seed(): # Users user1 = User() user1.name = 'Daniel' user1.chest_pain = '' user1.eck_result = '' user1.blood_sugar = False user1.angina = False user1.age = 21 db.session.add(user1) user2 = User() user2.name = 'Bernd' user2.chest_pain = '' user2.eck_result = '' user2.blood_sugar = True user2.angina = False user2.age = 67 db.session.add(user2) # Plans plan1 = Plan() plan1.user = user1 db.session.add(plan1) plan2 = Plan() plan2.user = user2 db.session.add(plan2) # Plan entries for _ in range(10): entry1 = PlanEntry() entry1.timestamp = datetime.time(random.randint(0, 23), random.randint(0, 59)) entry1.mandatory = random.randint(0, 1) == 0 entry1.plan = plan1 db.session.add(entry1) entry2 = PlanEntry() entry2.timestamp = datetime.time(random.randint(0, 23), random.randint(0, 59)) entry2.mandatory = random.randint(0, 1) == 0 entry2.plan = plan2 db.session.add(entry1) # Measurements for _ in range(100): measurement = Measurement() measurement.user = user1 if random.randint(0, 1) == 0 else user2 measurement.pulse = random.randint(60, 120) measurement.systolic = random.randint(100, 130) measurement.diastolic = random.randint(60, 100) measurement.timestamp = datetime.datetime( 2016, 1, # Monat random.randint(1, 31), # Tag (vereinfacht) random.randint(0, 23), # Stunde random.randint(0, 59) # Minute ) db.session.add(measurement) # Frequency Measurements for _ in range(1000): measurement = FrequencyMeasurement() measurement.user = user1 if random.randint(0, 1) == 0 else user2 measurement.rate = random.randint(60, 120) measurement.timestamp = datetime.datetime( 2016, 1, # Monat random.randint(1, 31), # Tag (vereinfacht) random.randint(0, 23), # Stunde random.randint(0, 59) # Minute ) db.session.add(measurement) db.session.commit()
def _get_earliest(self): query = Measurement.query() return query.order(Measurement.timestamp).get().timestamp
def _get_count(self): query = Measurement.query() return query.count()
def show_meas(): user = users.get_current_user() meas_query = Measurement.gql("WHERE user = :curr_user", curr_user=user) meas_list = meas_query.fetch(10) return render_template('render_meas.html', meas_dict=[meas.to_dict() for meas in meas_list])