def getGRCPoints(self, bucket): points = [] dt = datetime.now(tz=pytz.timezone('US/Pacific')).isoformat() mag = self.explainMagnitude() mining = self.getMiningInfo() for prj in mag.magnitude: point = Point(measurement_name='magnitude') point.time(time=dt) point.tag('project_name', prj.project) point.field('rac', prj.rac) point.field('magnitude', prj.magnitude) points.append({"bucket": bucket, "point": point}) mining_point = Point(measurement_name='mining') mining_point.time(time=dt) mining_point.tag('CPID', mining.CPID) mining_point.field('blocks', mining.blocks) mining_point.field('magnitude', mining.current_magnitude) mining_point.field('current_difficulty', mining.difficulty.current) mining_point.field('pending_reward', mining.BoincRewardPending) mining_point.field('stake_weight', mining.stakeweight.valuesum) mining_point.field('time_to_stake', mining.time_to_stake_days) mining_point.field('staking_efficiency', mining.staking_efficiency) points.append({"bucket": bucket, "point": mining_point}) return points
def test_write_point_different_precision(self): bucket = self.create_test_bucket() _point1 = Point("h2o_feet").tag("location", "coyote_creek").field("level water_level", 5.0).time(5, WritePrecision.S) _point2 = Point("h2o_feet").tag("location", "coyote_creek").field("level water_level", 6.0).time(6, WritePrecision.US) _point_list = [_point1, _point2] async_results = self.write_client.write(bucket.name, self.org, _point_list) self.assertEqual(2, len(async_results)) for async_result in async_results: async_result.get() query = f'from(bucket:"{bucket.name}") |> range(start: 1970-01-01T00:00:00.000000001Z) '\ '|> sort(columns: [\"_time\"], desc: false)' flux_result = self.client.query_api().query(query) self.assertEqual(1, len(flux_result)) records = flux_result[0].records self.assertEqual(2, len(records)) self.assertEqual(records[0].get_time(), datetime.datetime(1970, 1, 1, 0, 0, 0, 6, tzinfo=datetime.timezone.utc)) self.assertEqual(records[1].get_time(), datetime.datetime(1970, 1, 1, 0, 0, 5, tzinfo=datetime.timezone.utc))
async def main(): """ Configure Retries - for more info see https://github.com/inyutin/aiohttp_retry """ retry_options = ExponentialRetry(attempts=3) async with InfluxDBClientAsync( url="http://localhost:8086", token="my-token", org="my-org", client_session_type=RetryClient, client_session_kwargs={"retry_options": retry_options}) as client: """ Write data: """ print(f"\n------- Written data: -------\n") write_api = client.write_api() _point1 = Point("async_m").tag("location", "Prague").field("temperature", 25.3) _point2 = Point("async_m").tag("location", "New York").field("temperature", 24.3) successfully = await write_api.write(bucket="my-bucket", record=[_point1, _point2]) print(f" > successfully: {successfully}") """ Query: Stream of FluxRecords """ print(f"\n------- Query: Stream of FluxRecords -------\n") query_api = client.query_api() records = await query_api.query_stream( 'from(bucket:"my-bucket") ' '|> range(start: -10m) ' '|> filter(fn: (r) => r["_measurement"] == "async_m")') async for record in records: print(record)
def waterMessage(self, time, reading, nodeSettings ): payload = emonSuite.PayloadWater() if( emonSuite.EmonSerial.ParseWaterPayload(reading,payload) ): try: for sensor in range(payload.numFlowSensors): p = Point("water").tag("sensor",f"water/flowCount/{payload.subnode}/{sensor}")\ .tag("sensorGroup",nodeSettings[payload.subnode]["name"])\ .tag("sensorName",nodeSettings[payload.subnode][f"f{sensor}"])\ .field("value", payload.flowCount[sensor]*nodeSettings[payload.subnode][f"f{sensor}_litresPerPulse"]).time(time) self.write_api.write(bucket=self.bucket, record=p) for sensor in range(payload.numHeightSensors): p = Point("tank").tag("sensor", f"water/height/{payload.subnode}/{sensor}")\ .tag("sensorGroup",nodeSettings[payload.subnode]["name"])\ .tag("sensorName",nodeSettings[payload.subnode][f"h{sensor}"])\ .field("value", payload.waterHeight[sensor]/1).time(time) self.write_api.write(bucket=self.bucket, record=p) p = Point("supplyV").tag("sensor", f"supplyV/water/{payload.subnode}")\ .tag("sensorGroup",nodeSettings[payload.subnode]["name"])\ .tag("sensorName",nodeSettings[payload.subnode]["name"])\ .field("value", payload.supplyV/1000).time(time) self.write_api.write(bucket=self.bucket, record=p) if(':' in reading): self.publishRSSI( time, nodeSettings[payload.subnode]['name'], reading ) except Exception as ex: self.printException("waterException", reading, ex)
def data_convert_printer(data): converted_data = [] state_data = data.get("state") temperature_data = data.get("temperature") printer_state_point = Point("printer_state").tag("X-API-KEY", X_API_KEY)\ .field("flags_cancelling", state_data.get("flags").get("cancelling"))\ .field("flags_closedOrError", state_data.get("flags").get("error"))\ .field("flags_finishing", state_data.get("flags").get("finishing"))\ .field("flags_operational", state_data.get("flags").get("operational"))\ .field("flags_paused", state_data.get("flags").get("paused"))\ .field("flags_pausing", state_data.get("flags").get("pausing"))\ .field("flags_printing", state_data.get("flags").get("printing"))\ .field("flags_ready", state_data.get("flags").get("ready"))\ .field("flags_resuming", state_data.get("flags").get("resuming"))\ .field("flags_sdReady", state_data.get("flags").get("sdReady"))\ .field("text", state_data.get("text")) converted_data.append(printer_state_point) printer_temperature_point = Point("printer_temperature").tag("X-API-KEY", X_API_KEY)\ .field("bed_actual", temperature_data.get("bed").get("actual") if temperature_data.get("bed").get("actual") is not None else 0.0)\ .field("bed_offset", temperature_data.get("bed").get("offset") if temperature_data.get("bed").get("offset") is not None else 0.0)\ .field("bed_target", temperature_data.get("bed").get("target") if temperature_data.get("bed").get("target") is not None else 0.0)\ .field("tool0_actual", temperature_data.get("tool0").get("actual") if temperature_data.get("tool0").get("actual") is not None else 0.0)\ .field("tool0_offset", temperature_data.get("tool0").get("offset") if temperature_data.get("tool0").get("offset") is not None else 0.0)\ .field("tool0_target", temperature_data.get("tool0").get("target") if temperature_data.get("tool0").get("target") is not None else 0.0) converted_data.append(printer_temperature_point) return converted_data
async def _prepare_data(self, measurement: str): _point1 = Point(measurement).tag("location", "Prague").field("temperature", 25.3) _point2 = Point(measurement).tag("location", "New York").field( "temperature", 24.3) await self.client.write_api().write(bucket="my-bucket", record=[_point1, _point2])
def test_write_point_different_precision(self): bucket = self.create_test_bucket() point1 = Point('test_precision') \ .field('power', 10) \ .tag('powerFlow', 'low') \ .time(datetime.datetime(2020, 4, 20, 6, 30, tzinfo=datetime.timezone.utc), WritePrecision.S) point2 = Point('test_precision') \ .field('power', 20) \ .tag('powerFlow', 'high') \ .time(datetime.datetime(2020, 4, 20, 5, 30, tzinfo=datetime.timezone.utc), WritePrecision.MS) writer = self.client.write_api(write_options=SYNCHRONOUS) writer.write(bucket.name, self.org, [point1, point2]) result = self.query_api.query( f"from(bucket:\"{bucket.name}\") |> range(start: 1970-01-01T00:00:00.000000001Z) |> last() " "|> sort(columns: [\"_time\"], desc: false)", self.org) self.assertEqual(len(result), 2) self.assertEqual(len(result[0].records), 1) self.assertEqual(len(result[1].records), 1) self.assertEqual( result[0].records[0].get_time(), datetime.datetime(2020, 4, 20, 5, 30, tzinfo=datetime.timezone.utc)) self.assertEqual( result[1].records[0].get_time(), datetime.datetime(2020, 4, 20, 6, 30, tzinfo=datetime.timezone.utc))
def influxDB(influxdbip, token, measurement, cycle): print("influxDB写入") a = 1 bucket = "test" token = "HTvG6oIApfABybjjYd_6Jehf8AEWkLStYw0qftanx9ijF05-UsLZ9pVqI604PwuRlhv8IkuIZshYaqVFTC0DXA==" client = InfluxDBClient(url=influxdbip, token=token, org="su") write_api = client.write_api(write_options=SYNCHRONOUS) # query_api = client.query_api() cycle = (int(cycle) / 1000) #单位ms # cycle=(cycle) flash("开始写入influxDB", "influx") while 1: try: ss = 1 xx = 2 p = Point(measurement).tag("location", "108厂房").field("温度", ss) q = Point(measurement).tag("location", "beijing").field("2", xx) write_api.write(bucket=bucket, org="su", record=[p, q]) # print("2222") time.sleep(cycle) except a == 0: pass # Stop writing except Exception as e: print(e) break
def send_data(data_table, lake_prefix, bucket="lakeinfo/autogen", lake_temp=None): """Writes data to influxdb client in env properties.""" client = InfluxDBClient.from_env_properties() # client = InfluxDBClient(url=getenv("INFLUXDB_V2_URL"), org=getenv( # "INFLUXDB_V2_ORG"), token=getenv("INFLUXDB_V2_TOKEN")) write_api = client.write_api(write_options=SYNCHRONOUS) last_point = data_table[-1] print(last_point) points = [ Point("{}_level".format(lake_prefix)).tag("units", "ft").field("value", last_point['lake_level']).field( "valueNum", float(last_point['lake_level'])), # .time(last_point['timestamp']), Point("{}_turbine_release".format(lake_prefix)).tag("units", "cfps").field( "valueNum", last_point['turbine_release_cfs']).field("value", float(last_point['turbine_release_cfs'])), # .time(last_point['timestamp']), Point("{}_spillway_release".format(lake_prefix)).tag("units", "cfps").field( "valueNum", last_point['spillway_release_cfs']).field("value", float(last_point['spillway_release_cfs'])), # .time(last_point['timestamp']), Point("{}_total_release".format(lake_prefix)).tag("units", "cfps").field( "valueNum", last_point['total_release_cfs']).field("value", float(last_point['total_release_cfs'])) # .time(last_point['timestamp']), ] if lake_temp: points.append(Point("{}_temperature".format(lake_prefix)).tag("units", "ºF").field( "valueNum", lake_temp).field("value", lake_temp)) for i in points: write_api.write(bucket, 'patrickjmcd', i) print("Wrote {}".format(i._name))
def write_data(alias, name, value): url, token, org, bucket = get_config("influx") # print(url, token, org) client = InfluxDBClient(url=url, token=token) write_api = client.write_api(write_options=SYNCHRONOUS) if alias == "temp": p = Point("event").tag("hostname", name).field("temperature", value) elif alias == "humidity": p = Point("event").tag("hostname", name).field("humidity", value) write_api.write(bucket=bucket, org=org, record=p) print(name, value, bucket)
def collect_influx(self, influx: InfluxDB) -> None: ''' Pushes the current data to influx. ''' ts = datetime.now(timezone.utc) wpres = InfluxWritePrecision.S overview_fields: Dict[str, float] = dict() if self.readings.battery_voltage is not None: overview_fields['voltage'] = self.readings.battery_voltage if self.readings.battery_power is not None: overview_fields['power'] = self.readings.battery_power if self.readings.battery_state is not None: overview_fields['state'] = self.readings.battery_state if self.readings.soc_min is not None: overview_fields['soc_min'] = self.readings.soc_min if self.readings.soc_target is not None: overview_fields['soc_target'] = self.readings.soc_target if self.readings.soc is not None: overview_fields['soc'] = self.readings.soc if self.readings.soh is not None: overview_fields['soh'] = self.readings.soh if self.readings.temperature is not None: overview_fields['temperature'] = self.readings.temperature if self.readings.bat_status is not None: overview_fields['status'] = self.readings.bat_status if self.readings.impedance_fine is not None: overview_fields['impedance_fine'] = self.readings.impedance_fine if self.readings.discharged_amp_hours is not None: overview_fields['discharged_amp_hours'] = self.readings.discharged_amp_hours if self.readings.stored_energy is not None: overview_fields['stored_energy'] = self.readings.stored_energy if len(overview_fields) > 0: overview = Point('battery_overview').tag('inverter', self.parent.name).time(ts, write_precision=wpres) for ov_name, ov_value in overview_fields.items(): overview = overview.field(ov_name, ov_value) influx.add_points(overview) if len(self.batteries) > 0: modules: Dict[int, Point] = dict() for battery in self.batteries.values(): if battery: if battery.cycle_count is not None and battery.num not in modules: # add not none checks for all! modules[battery.num] = Point('battery_module').tag('inverter', self.parent.name) \ .tag('module', battery.num) if battery.cycle_count is not None: modules[battery.num] = modules[battery.num].field('cycles', battery.cycle_count) influx.add_points(modules.values())
def push_to_influx(measurement=None): assert measurement if not influx_config.enabled: return points = [ Point("power").field("usage", measurement.power_usage).time( measurement.timestamp), Point("power").field("delivery", measurement.power_delivery).time( measurement.timestamp), ] influx_write_api.write(influx_config.BUCKET, influx_config.ORG, points)
def refreshLatencyGraphs(secondsToRun): startTime = datetime.now() with open('statsByParentNode.json', 'r') as j: parentNodes = json.loads(j.read()) with open('statsByDevice.json', 'r') as j: devices = json.loads(j.read()) print("Retrieving device statistics") devices = getLatencies(devices, secondsToRun) print("Computing parent node statistics") parentNodes = getParentNodeStats(parentNodes, devices) print("Writing data to InfluxDB") bucket = influxDBBucket org = influxDBOrg token = influxDBtoken url="http://localhost:8086" client = InfluxDBClient( url=url, token=token, org=org ) write_api = client.write_api(write_options=SYNCHRONOUS) queriesToSend = [] for device in devices: if device['tcpLatency'] != None: p = Point('Latency').tag("Device", device['hostname']).tag("ParentNode", device['ParentNode']).tag("Type", "Device").field("TCP Latency", device['tcpLatency']) queriesToSend.append(p) for parentNode in parentNodes: if parentNode['tcpLatency'] != None: p = Point('Latency').tag("Device", parentNode['parentNodeName']).tag("ParentNode", parentNode['parentNodeName']).tag("Type", "Parent Node").field("TCP Latency", parentNode['tcpLatency']) queriesToSend.append(p) write_api.write(bucket=bucket, record=queriesToSend) print("Added " + str(len(queriesToSend)) + " points to InfluxDB.") client.close() #with open('statsByParentNode.json', 'w') as infile: # json.dump(parentNodes, infile) #with open('statsByDevice.json', 'w') as infile: # json.dump(devices, infile) endTime = datetime.now() durationSeconds = round((endTime - startTime).total_seconds()) print("Graphs updated within " + str(durationSeconds) + " seconds.")
def read_and_write_data(): client = TimeseriesClient.from_env_properties() # write single points _start_points = datetime.now(UTC) _point1 = (Point("test_single_point").tag("location", "Prague").field( "temperature", 25.3).time(_start_points)) _point2 = (Point("test_single_point").tag("location", "New York").field( "temperature", 24.3).time(_start_points)) client.write_points(project=PROJECT, points=[_point1, _point2]) # write a dataframe _start_dataframe = datetime.now(UTC) _dataframe = pd.DataFrame( data=[["coyote_creek", 1.0], ["coyote_creek", 2.0]], index=[_start_dataframe, _start_dataframe + timedelta(hours=1)], columns=["location", "water_level"], ) client.write_a_dataframe( project=PROJECT, measurement_name="test_dataframe", dataframe=_dataframe, tag_columns=["location"], ) # read single points points = client.get_points( project=PROJECT, fields={"_measurement": "test_single_point"}, start_time=_start_points, ) logger.info("Request Points:") results = [] for table in points: for record in table.records: results.append((record.get_value(), record.get_field())) print(results) # read a dataframe dataframe = client.get_dataframe( project=PROJECT, fields={ "_measurement": "test_dataframe", "_field": "water_level" }, start_time=_start_dataframe, ) logger.info("Requested Dataframe:") logger.info(dataframe)
def _write_point(self): self.write_client = self.client.write_api(write_options=SYNCHRONOUS) bucket = self.create_test_bucket() measurement = "h2o_feet" field_name = "water_level" val = "1.0" tag = "location" tag_value = "creek level" p = Point(measurement) p.field(field_name, val) p.tag(tag, tag_value) record_list = [p] self.write_client.write(bucket.name, self.org, record_list) query = 'from(bucket:"' + bucket.name + '") |> range(start: 1970-01-01T00:00:00.000000001Z)' flux_result = self.client.query_api().query(query) self.assertEqual(1, len(flux_result)) rec = flux_result[0].records[0] self.assertEqual(self.id_tag, rec["id"]) self.assertEqual(self.customer_tag, rec["customer"]) self.assertEqual("LA", rec[self.data_center_key]) self.delete_test_bucket(bucket)
def test_write_points_unicode(self): bucket = self.create_test_bucket() measurement = "h2o_feet_ěščřĚŠČŘ" field_name = "field_ěščř" utf8_val = "Přerov 🍺" tag = "tag_ěščř" tag_value = "tag_value_ěščř" p = Point(measurement) p.field(field_name, utf8_val) p.tag(tag, tag_value) record_list = [p] self.write_client.write(bucket.name, self.org, record_list) query = 'from(bucket:"' + bucket.name + '") |> range(start: 1970-01-01T00:00:00.000000001Z)' flux_result = self.client.query_api().query(query) self.assertEqual(1, len(flux_result)) rec = flux_result[0].records[0] self.assertEqual(self.id_tag, rec["id"]) self.assertEqual(self.customer_tag, rec["customer"]) self.assertEqual("LA", rec[self.data_center_key]) self.assertEqual(measurement, rec.get_measurement()) self.assertEqual(utf8_val, rec.get_value()) self.assertEqual(field_name, rec.get_field())
def parse_row(row: OrderedDict): """Parse row of CSV file into Point with structure: taxi-trip-data,DOLocationID=152,PULocationID=79,dispatching_base_num=B02510 dropoff_datetime="2019-01-01 01:27:24" 1546304267000000000 CSV format: dispatching_base_num,pickup_datetime,dropoff_datetime,PULocationID,DOLocationID,SR_Flag B00001,2019-01-01 00:30:00,2019-01-01 02:51:55,,, B00001,2019-01-01 00:45:00,2019-01-01 00:54:49,,, B00001,2019-01-01 00:15:00,2019-01-01 00:54:52,,, B00008,2019-01-01 00:19:00,2019-01-01 00:39:00,,, B00008,2019-01-01 00:27:00,2019-01-01 00:37:00,,, B00008,2019-01-01 00:48:00,2019-01-01 01:02:00,,, B00008,2019-01-01 00:50:00,2019-01-01 00:59:00,,, B00008,2019-01-01 00:51:00,2019-01-01 00:56:00,,, B00009,2019-01-01 00:44:00,2019-01-01 00:58:00,,, B00009,2019-01-01 00:19:00,2019-01-01 00:36:00,,, B00009,2019-01-01 00:36:00,2019-01-01 00:49:00,,, B00009,2019-01-01 00:26:00,2019-01-01 00:32:00,,, ... :param row: the row of CSV file :return: Parsed csv row to [Point] """ return Point("taxi-trip-data") \ .tag("dispatching_base_num", row['dispatching_base_num']) \ .tag("PULocationID", row['PULocationID']) \ .tag("DOLocationID", row['DOLocationID']) \ .tag("SR_Flag", row['SR_Flag']) \ .field("dropoff_datetime", row['dropoff_datetime']) \ .time(row['pickup_datetime']) \ .to_line_protocol()
def notify(self, notifyevent, control, settings, pelletdb, in_data, grill_platform): if time.time() - self.last_updated < 1: return from influxdb_client import Point name = settings['globals']['grill_name'] if len(name) == 0: name = 'Smoker' def get_or_default(data, k, default): if data is not None and k in data: return data[k] return default p = Point(name).time(time=datetime.utcnow()) \ .field("GrillTemp", float(get_or_default(in_data, 'GrillTemp', 0.0))) \ .field('GrillSetPoint', float(get_or_default(in_data, 'GrillSetPoint', 0.0))) \ .field('Probe1Temp', float(get_or_default(in_data, 'Probe1Temp', 0.0))) \ .field('Probe1SetPoint', float(get_or_default(in_data, 'Probe1SetPoint', 0.0))) \ .field('Probe2Temp', float(get_or_default(in_data, 'Probe2Temp', 0))) \ .field('Probe2SetPoint', float(get_or_default(in_data, 'Probe2SetPoint', 0.0))) \ .field("Mode", str(get_or_default(control, "mode", 'unknown'))) \ .field('PelletLevel', int(get_or_default(get_or_default(pelletdb, 'current', {}), 'hopper_level', 100))) if grill_platform is not None: outputs = grill_platform.GetOutputStatus() for key in outputs: p = p.field(key, int(outputs[key])) if notifyevent and 'GRILL_STATE' != notifyevent: p = p.field('Event', str(notifyevent)) self.queue.append(p) self.last_updated = time.time()
def ProcessLogin(): with opentracing.tracer.start_span('Enter /users') as span: span.set_tag('step_1', '1') try: tracer.close() except: z = 1 point = Point("endpoint_request").tag("endpoint", "/users").field( "value", 1).time(datetime.utcnow(), WritePrecision.NS) write_api.write(bucket, org, point) if request.method == 'GET': opt_name = request.args.get("name") opt_pass = request.args.get("pass") if opt_name is None or opt_pass is None: return "badz" else: if opt_name == "johnd" and opt_pass == "foo": return "good" else: return "bad" else: return "bad"
def main(): if len(sys.argv) != 4: usage() sp3_path, start_time, end_time = sys.argv[1:] print('Loading SP3 files...') for sp3 in pathlib.Path(sp3_path).glob('*.sp3'): load_sp3(str(sp3)) client = InfluxDBClient.from_config_file('influxdb.ini') query_api = client.query_api() write_api = client.write_api(write_options = ASYNCHRONOUS) query = f"""from (bucket:"hesperides") |> range(start: {start_time}, stop: {end_time}) |> aggregateWindow(every: 1m, fn: first) |> filter(fn: (r) => r._measurement == "position" and r.ship == "hesperides" and (r._field == "lat" or r._field == "lon")) |> pivot(rowKey: ["_time"], columnKey: ["_field"], valueColumn: "_value")""" print('Querying InfluxDB for positions...') records = query_api.query_stream(query) for record in records: print('Computing azels for', record.get_time()) for satellite in satellites: azel = compute_azel(satellite, record) azel_record = Point('azel').time(record.get_time()).tag('svn', satellite).tag('ship', 'hesperides').field('az', azel[0]).field('el', azel[1]) write_api.write(bucket = 'gnss', record = azel_record)
def send_data(what, value): """ this function sends the data as json, and checks if it was succesfull """ client = InfluxDBClient(url=influx_cloud_url, token=influx_cloud_token) try: point = Point("measurement").field(what, value).time(time=datetime.utcnow()) # if data is incorrect, don't send anything if point is None: return -1 """ Write data by Point structure """ print(f'Writing to InfluxDB cloud: {point.to_line_protocol()} ...') write_api = client.write_api(write_options=SYNCHRONOUS) write_api.write(bucket=bucket, org=org, record=point) print() print('success') print() print() except Exception as e: print(e) finally: client.close()
def main(gpio, room, org, bucket): while True: client = InfluxDBClient.from_env_properties() write_api = client.write_api(write_options=SYNCHRONOUS) hum, temp = Adafruit_DHT.read_retry(SENSOR, gpio) if temp is not None: p = Point("temp").tag("room", room).field("degrees_c", temp).time(datetime.utcnow()) logging.info("Writing %s", p.to_line_protocol()) write_api.write(bucket, org, p) if hum is not None: p = Point("humid").tag("room", room).field("perc_rh", hum).time(datetime.utcnow()) logging.info("Writing %s", p.to_line_protocol()) write_api.write(bucket, org, p) write_api.close() time.sleep(INTERVAL)
async def process_message(message: dict) -> None: """ Parse user request and answer :param message: user message to be processed """ # start with simple parser text = message.get("text", "").lower().strip() user_id = message.get("user", "") channel = message.get("channel", "") INFLUX_API_WRITE( Point("digestbot").field("overall_requests", 1).time(datetime.utcnow())) if text.startswith("help"): await helper.process_message(channel, text) elif text == "top": await top.send_initial_message(user_id, channel) elif text == "timers": await timer.send_initial_message(user_id, channel) elif text == "presets": await preset.send_initial_message(user_id, channel) elif text == "ignore": await ignore.send_initial_message(user_id, channel) elif text == "qna" and QNA_PRESENTED: # only if QnA provided await qna.send_initial_message(user_id, channel, message.get('trigger_id', "")) else: template = container.jinja_env.get_template("syntax_response.json") result = template.render(qna_presented=QNA_PRESENTED) await container.slacker.post_to_channel(channel_id=channel, blocks=result, ephemeral=True, user_id=user_id)
def getSensePoints(self, imperial_or_metric, bucket): dt = datetime.now(tz=pytz.timezone('US/Pacific')).isoformat() point = Point(measurement_name="sense") point.time(time=dt) # % relative point.field("humidity", self.sense.get_humidity()) if imperial_or_metric == "imperial": point.field( "temperature_from_humidity", convertCToF(self.sense.get_temperature_from_humidity())) point.field( "temperature_from_pressure", convertCToF(self.sense.get_temperature_from_pressure())) point.field("pressure", convertmbToPSI(self.sense.get_pressure())) else: point.field("temperature_from_humidity", self.sense.get_temperature_from_humidity()) point.field("temperature_from_pressure", self.sense.get_temperature_from_pressure()) point.field("pressure", self.sense.get_pressure()) point.field("orientation_radians", self.sense.get_orientation_radians()) point.field("orientation_degress", self.sense.get_orientation_degrees()) # magnetic intensity in microteslas point.field("compass_raw", self.sense.get_compass_raw()) # rotational intensity in radians per second point.field("gyroscope_raw", self.sense.get_gyroscope_raw()) # acceleration intensity in Gs point.field("accelerometer_raw", self.sense.get_accelerometer_raw()) return [{"bucket": bucket, "point": point}]
def ReAnWr_Data(DB_info, Sensor_info, start, end, step): logger = SetupLogger().getLogger(__name__) try: from influxdb_client import InfluxDBClient, Point, WritePrecision from influxdb_client.client.write_api import SYNCHRONOUS except : logger.error("influxdb_client module was not installed! Abort!") sys.exit() if start == "0" and end == "0": logger.info("Read and Write data on and on!") while True: humidity, temperature = ReadSensor(Sensor_info['sensor'],Sensor_info['pin']) point = Point(DB_info['measurement']).field("temperature", float (temperature)).field("humidity", float(humidity)).time(datetime.datetime.utcnow(), WritePrecision.NS) logger.info('Time={2} Temp={0:0.1f}*C Humidity={1:0.1f}%'.format(temperature, humidity, datetime.datetime.now())) DB_info['write_api'].write(DB_info['bucket'], DB_info['org'], point) time.sleep(int(step)) else: logger.error("Not a supported start and end time yet! Abort!") sys.exit()
def test_basic_write(self): """Basically from docs""" _point1 = Point("test_measure").tag("sometag", "sometagvalue") \ .field("somefield", 25.3) \ .time(datetime.utcnow(), write_precision=WritePrecision.S) # This is also a pretty good test for "Did I get timezones right" self.InfluxClient.api.write(bucket=self.bucket, record=[_point1]) query_string = f'from(bucket:"{self.bucket}")\ |> range(start: -10m)\ |> filter(fn:(r) => r._measurement == "test_measure")\ |> filter(fn: (r) => r.sometag == "sometagvalue")\ |> filter(fn:(r) => r._field == "somefield" )' query_api = self.InfluxClient.client.query_api() start_time = time() query_result = list while time() - start_time < 10: sleep(1) query_result = query_api.query(query=query_string, org=INFLUX_CI_CONFIG['o']) if len(query_result) != 0: break self.assertEqual(len(query_result), 1) self.assertEqual(query_result[0].records[0].values['_value'], 25.3)
def parse_row(row: OrderedDict): """Parse row of CSV file into Point with structure: CSV format: date,symbol,open,close,low,high,volume 2016-01-05,WLTW,123.43,125.839996,122.309998,126.25,2163600.0 2016-01-06,WLTW,125.239998,119.980003,119.940002,125.540001,2386400.0 2016-01-07,WLTW,116.379997,114.949997,114.93,119.739998,2489500.0 2016-01-08,WLTW,115.480003,116.620003,113.5,117.440002,2006300.0 2016-01-11,WLTW,117.010002,114.970001,114.089996,117.330002,1408600.0 2016-01-12,WLTW,115.510002,115.550003,114.5,116.059998,1098000.0 2016-01-13,WLTW,116.459999,112.849998,112.589996,117.07,949600.0 ... :param row: the row of CSV file :return: Parsed csv row to [Point] """ global _progress _progress += 1 if _progress % 1000 == 0: print(_progress) return Point("financial-analysis") \ .tag("symbol", row["symbol"]) \ .field("open", float(row['open'])) \ .field("high", float(row['high'])) \ .field("low", float(row['low'])) \ .field("close", float(row['close'])) \ .time(datetime.strptime(row['date'], '%Y-%m-%d'))
def hr2point(time, val): return Point("health") \ .field("heart_rate", val) \ .time( datetime.fromtimestamp(time / 1000, timezone.utc), WritePrecision.S )
def stress2point(time, val): return Point("health") \ .field("stress", max(val, 0)) \ .time( datetime.fromtimestamp(time / 1000, timezone.utc), WritePrecision.S )
def test_write_query_data_nanoseconds(self): from influxdb_client.client.util.date_utils_pandas import PandasDateTimeHelper import influxdb_client.client.util.date_utils as date_utils date_utils.date_helper = PandasDateTimeHelper() bucket = self.create_test_bucket() point = Point("h2o_feet") \ .field("water_level", 155) \ .tag("location", "creek level")\ .time('1996-02-25T21:20:00.001001231Z') self.write_client.write(bucket.name, self.org, [point]) flux_result = self.client.query_api().query( f'from(bucket:"{bucket.name}") |> range(start: 1970-01-01T00:00:00.000000001Z)') self.assertEqual(1, len(flux_result)) record = flux_result[0].records[0] self.assertEqual(self.id_tag, record["id"]) self.assertEqual(record["_value"], 155) self.assertEqual(record["location"], "creek level") self.assertEqual(record["_time"].year, 1996) self.assertEqual(record["_time"].month, 2) self.assertEqual(record["_time"].day, 25) self.assertEqual(record["_time"].hour, 21) self.assertEqual(record["_time"].minute, 20) self.assertEqual(record["_time"].second, 00) self.assertEqual(record["_time"].microsecond, 1001) self.assertEqual(record["_time"].nanosecond, 231) date_utils.date_helper = None