def test_escape_text_value(self):
from influxdb_client.extras import pd
now = pd.Timestamp('2020-04-05 00:00+00:00')
an_hour_ago = now - timedelta(hours=1)
test = [{
'a': an_hour_ago,
'b': 'hello world',
'c': 1,
'd': 'foo bar'
}, {
'a': now,
'b': 'goodbye cruel world',
'c': 2,
'd': 'bar foo'
}]
data_frame = pd.DataFrame(test)
data_frame = data_frame.set_index('a')
points = data_frame_to_list_of_points(
data_frame=data_frame,
point_settings=PointSettings(),
data_frame_measurement_name='test',
data_frame_tag_columns=['d'])
self.assertEqual(2, len(points))
self.assertEqual(
"test,d=foo\\ bar b=\"hello world\",c=1i 1586041200000000000",
points[0])
self.assertEqual(
"test,d=bar\\ foo b=\"goodbye cruel world\",c=2i 1586044800000000000",
points[1])
def test_tag_escaping_key_and_value(self):
from influxdb_client.extras import pd, np
now = pd.Timestamp('2020-04-05 00:00+00:00')
data_frame = pd.DataFrame(
data=[
["carriage\nreturn", "new\nline", "t\tab",
np.int64(2)],
],
index=[
now + timedelta(hours=1),
],
columns=["carriage\rreturn", "new\nline", "t\tab", "l\ne\rv\tel"])
points = data_frame_to_list_of_points(
data_frame=data_frame,
point_settings=PointSettings(),
data_frame_measurement_name='h\n2\ro\t_data',
data_frame_tag_columns={"new\nline", "carriage\rreturn", "t\tab"})
self.assertEqual(1, len(points))
self.assertEqual(
"h\\n2\\ro\\t_data,carriage\\rreturn=carriage\\nreturn,new\\nline=new\\nline,t\\tab=t\\tab l\\ne\\rv\\tel=2i 1586048400000000000",
points[0])
def test_write_num_py(self):
from influxdb_client.extras import pd, np
bucket = self.create_test_bucket()
now = pd.Timestamp('2020-04-05 00:00+00:00')
data_frame = pd.DataFrame(
data=[["coyote_creek", np.int64(100.5)],
["coyote_creek", np.int64(200)]],
index=[now + timedelta(hours=1), now + timedelta(hours=2)],
columns=["location", "water_level"])
write_api = self.client.write_api(write_options=SYNCHRONOUS)
write_api.write(bucket.name,
record=data_frame,
data_frame_measurement_name='h2o_feet',
data_frame_tag_columns=['location'])
write_api.close()
result = self.query_api.query(
"from(bucket:\"" + bucket.name +
"\") |> range(start: 1970-01-01T00:00:00.000000001Z)",
self.my_organization.id)
self.assertEqual(1, len(result))
self.assertEqual(2, len(result[0].records))
self.assertEqual(result[0].records[0].get_value(), 100.0)
self.assertEqual(result[0].records[1].get_value(), 200.0)
pass
def test_write_tag_nan(self):
from influxdb_client.extras import pd, np
now = pd.Timestamp('2020-04-05 00:00+00:00')
data_frame = pd.DataFrame(
data=[["", 3.1955, 20.514305], ['', 5.7310, 23.328710],
[np.nan, 5.7310, 23.328710], ["tag", 3.138664, 20.755026]],
index=[
now, now + timedelta(minutes=30), now + timedelta(minutes=60),
now + timedelta(minutes=90)
],
columns=["tag", "actual_kw_price", "forecast_kw_price"])
points = data_frame_to_list_of_points(
data_frame=data_frame,
point_settings=PointSettings(),
data_frame_measurement_name='measurement',
data_frame_tag_columns={"tag"})
self.assertEqual(4, len(points))
self.assertEqual(
"measurement actual_kw_price=3.1955,forecast_kw_price=20.514305 1586044800000000000",
points[0])
self.assertEqual(
"measurement actual_kw_price=5.731,forecast_kw_price=23.32871 1586046600000000000",
points[1])
self.assertEqual(
"measurement actual_kw_price=5.731,forecast_kw_price=23.32871 1586048400000000000",
points[2])
self.assertEqual(
"measurement,tag=tag actual_kw_price=3.138664,forecast_kw_price=20.755026 1586050200000000000",
points[3])
def test_escaping_measurement(self):
from influxdb_client.extras import pd, np
now = pd.Timestamp('2020-04-05 00:00+00:00')
data_frame = pd.DataFrame(data=[
["coyote_creek", np.int64(100.5)],
["coyote_creek", np.int64(200)],
],
index=[now + timedelta(hours=1), now + timedelta(hours=2)],
columns=["location", "water_level"])
points = data_frame_to_list_of_points(data_frame=data_frame,
point_settings=PointSettings(),
data_frame_measurement_name='measu rement',
data_frame_tag_columns={"tag"})
self.assertEqual(2, len(points))
self.assertEqual("measu\\ rement location=\"coyote_creek\",water_level=100i 1586048400000000000",
points[0])
self.assertEqual("measu\\ rement location=\"coyote_creek\",water_level=200i 1586052000000000000",
points[1])
points = data_frame_to_list_of_points(data_frame=data_frame,
point_settings=PointSettings(),
data_frame_measurement_name='measu\nrement2',
data_frame_tag_columns={"tag"})
self.assertEqual(2, len(points))
self.assertEqual("measu\\nrement2 location=\"coyote_creek\",water_level=100i 1586048400000000000",
points[0])
self.assertEqual("measu\\nrement2 location=\"coyote_creek\",water_level=200i 1586052000000000000",
points[1])
def test_write_nan(self):
from influxdb_client.extras import pd, np
now = pd.Timestamp('2020-04-05 00:00+00:00')
data_frame = pd.DataFrame(data=[
[3.1955, np.nan, 20.514305, np.nan],
[5.7310, np.nan, 23.328710, np.nan],
[np.nan, 3.138664, np.nan, 20.755026],
[5.7310, 5.139563, 23.328710, 19.791240],
[np.nan, np.nan, np.nan, np.nan],
],
index=[now, now + timedelta(minutes=30), now + timedelta(minutes=60),
now + timedelta(minutes=90), now + timedelta(minutes=120)],
columns=["actual_kw_price", "forecast_kw_price", "actual_general_use",
"forecast_general_use"])
points = data_frame_to_list_of_points(data_frame=data_frame, point_settings=PointSettings(),
data_frame_measurement_name='measurement')
self.assertEqual(4, len(points))
self.assertEqual("measurement actual_general_use=20.514305,actual_kw_price=3.1955 1586044800000000000",
points[0])
self.assertEqual("measurement actual_general_use=23.32871,actual_kw_price=5.731 1586046600000000000",
points[1])
self.assertEqual("measurement forecast_general_use=20.755026,forecast_kw_price=3.138664 1586048400000000000",
points[2])
self.assertEqual("measurement actual_general_use=23.32871,actual_kw_price=5.731,forecast_general_use=19.79124"
",forecast_kw_price=5.139563 1586050200000000000",
points[3])
def test_time_to_ast(self):
from influxdb_client.extras import pd
import dateutil.parser
literals = [
(pd.Timestamp('1996-02-25T21:20:00.001001231Z'),
'1996-02-25T21:20:00.001001231Z'),
(dateutil.parser.parse('1996-02-25T21:20:00.001001231Z'),
'1996-02-25T21:20:00.001001000Z'),
(dateutil.parser.parse('1996-02-25'),
'1996-02-25T00:00:00.000000000Z'),
(datetime.datetime(2021,
5,
24,
8,
40,
44,
785000,
tzinfo=timezone.utc),
'2021-05-24T08:40:44.785000000Z'),
]
for literal in literals:
ast = QueryApi._build_flux_ast({'date': literal[0]})
self.assertEqual('DateTimeLiteral',
ast.body[0].assignment.init.type)
self.assertEqual(literal[1], ast.body[0].assignment.init.value)
def test_with_default_tags(self):
from influxdb_client.extras import pd, np
now = pd.Timestamp('2020-04-05 00:00+00:00')
data_frame = pd.DataFrame(data={
'value': [1, 2],
't1': ['a1', 'a2'],
't3': ['c1', 'c2'],
},
index=[now + timedelta(hours=1), now + timedelta(hours=2)])
original_data = data_frame.copy()
points = data_frame_to_list_of_points(data_frame=data_frame,
point_settings=PointSettings(t2='every'),
data_frame_measurement_name='h2o',
data_frame_tag_columns={"t1", "t3"})
self.assertEqual(2, len(points))
self.assertEqual("h2o,t1=a1,t2=every,t3=c1 value=1i 1586048400000000000", points[0])
self.assertEqual("h2o,t1=a2,t2=every,t3=c2 value=2i 1586052000000000000", points[1])
# Check that the data frame hasn't been changed (an earlier version did change it)
self.assertEqual(True, (data_frame == original_data).all(axis = None), f'data changed; old:\n{original_data}\nnew:\n{data_frame}')
# Check that the default tags won't override actual column data.
# This is arguably incorrect behavior, but it's how it works currently.
points = data_frame_to_list_of_points(data_frame=data_frame,
point_settings=PointSettings(t1='every'),
data_frame_measurement_name='h2o',
data_frame_tag_columns={"t1", "t3"})
self.assertEqual(2, len(points))
self.assertEqual("h2o,t1=a1,t3=c1 value=1i 1586048400000000000", points[0])
self.assertEqual("h2o,t1=a2,t3=c2 value=2i 1586052000000000000", points[1])
self.assertEqual(True, (data_frame == original_data).all(axis = None), f'data changed; old:\n{original_data}\nnew:\n{data_frame}')
def test_write_data_frame(self):
from influxdb_client.extras import pd
bucket = self.create_test_bucket()
now = pd.Timestamp('1970-01-01 00:00+00:00')
data_frame = pd.DataFrame(data=[["coyote_creek", 1.0], ["coyote_creek", 2.0]],
index=[now + timedelta(hours=1), now + timedelta(hours=2)],
columns=["location", "water_level"])
self.write_client.write(bucket.name, record=data_frame, data_frame_measurement_name='h2o_feet',
data_frame_tag_columns=['location'])
result = self.query_api.query(
"from(bucket:\"" + bucket.name + "\") |> range(start: 1970-01-01T00:00:00.000000001Z)", self.org)
self.assertEqual(1, len(result))
self.assertEqual(2, len(result[0].records))
self.assertEqual(result[0].records[0].get_measurement(), "h2o_feet")
self.assertEqual(result[0].records[0].get_value(), 1.0)
self.assertEqual(result[0].records[0].values.get("location"), "coyote_creek")
self.assertEqual(result[0].records[0].get_field(), "water_level")
self.assertEqual(result[0].records[0].get_time(),
datetime.datetime(1970, 1, 1, 1, 0, tzinfo=datetime.timezone.utc))
self.assertEqual(result[0].records[1].get_measurement(), "h2o_feet")
self.assertEqual(result[0].records[1].get_value(), 2.0)
self.assertEqual(result[0].records[1].values.get("location"), "coyote_creek")
self.assertEqual(result[0].records[1].get_field(), "water_level")
self.assertEqual(result[0].records[1].get_time(),
datetime.datetime(1970, 1, 1, 2, 0, tzinfo=datetime.timezone.utc))
self.delete_test_bucket(bucket)
def test_specify_timezone_date_time_index(self):
from influxdb_client.extras import pd
data_frame = pd.DataFrame(data={
'value1': [10, 20],
'value2': [30, 40],
},
index=[
pd.Timestamp('2020-05-24 10:00'),
pd.Timestamp('2020-05-24 01:00')
])
points = data_frame_to_list_of_points(
data_frame=data_frame,
data_frame_measurement_name="test",
data_frame_timestamp_timezone="Europe/Berlin",
point_settings=PointSettings())
self.assertEqual(2, len(points))
self.assertEqual('test value1=10i,value2=30i 1590307200000000000',
points[0])
self.assertEqual('test value1=20i,value2=40i 1590274800000000000',
points[1])
def test_write_data_frame_without_measurement_name(self):
from influxdb_client.extras import pd
bucket = self.create_test_bucket()
now = pd.Timestamp('1970-01-01 00:00+00:00')
data_frame = pd.DataFrame(data=[["coyote_creek", 1.0], ["coyote_creek", 2.0]],
index=[now + timedelta(hours=1), now + timedelta(hours=2)],
columns=["location", "water_level"])
with self.assertRaises(TypeError) as cm:
self.write_client.write(bucket.name, record=data_frame)
exception = cm.exception
self.assertEqual('"data_frame_measurement_name" is a Required Argument', exception.__str__())
def test_with_period_index(self):
from influxdb_client.extras import pd, np
now = pd.Timestamp('2020-04-05 00:00+00:00')
data_frame = pd.DataFrame(data={
'value': [1, 2],
},
index=pd.period_range(start='2020-04-05 01:00+00:00', freq='H', periods=2))
points = data_frame_to_list_of_points(data_frame=data_frame,
point_settings=PointSettings(),
data_frame_measurement_name='h2o')
self.assertEqual(2, len(points))
self.assertEqual("h2o value=1i 1586048400000000000", points[0])
self.assertEqual("h2o value=2i 1586052000000000000", points[1])
def test_tags_order(self):
from influxdb_client.extras import pd, np
now = pd.Timestamp('2020-04-05 00:00+00:00')
data_frame = pd.DataFrame(data=[["c", "a", "b", np.int64(2)], ],
index=[now + timedelta(hours=1), ],
columns=["c", "a", "b", "level"])
points = data_frame_to_list_of_points(data_frame=data_frame,
point_settings=PointSettings(),
data_frame_measurement_name='h2o',
data_frame_tag_columns={"c", "a", "b"})
self.assertEqual(1, len(points))
self.assertEqual("h2o,a=a,b=b,c=c level=2i 1586048400000000000", points[0])
def test_write_num_py_floats(self):
from influxdb_client.extras import pd, np
now = pd.Timestamp('2020-04-05 00:00+00:00')
for np_float_type in [
np.float, np.float16, np.float32, np.float64, np.float128
]:
data_frame = pd.DataFrame([15.5], index=[now],
columns=['level']).astype(np_float_type)
points = data_frame_to_list_of_points(
data_frame=data_frame,
data_frame_measurement_name='h2o',
point_settings=PointSettings())
self.assertEqual(1, len(points))
self.assertEqual("h2o level=15.5 1586044800000000000",
points[0],
msg=f'Current type: {np_float_type}')
def test_write_precision(self):
from influxdb_client.extras import pd
now = pd.Timestamp('2020-04-05 00:00+00:00')
precisions = [(WritePrecision.NS, 1586044800000000000),
(WritePrecision.US, 1586044800000000),
(WritePrecision.MS, 1586044800000),
(WritePrecision.S, 1586044800),
(None, 1586044800000000000)]
for precision in precisions:
data_frame = pd.DataFrame([15], index=[now], columns=['level'])
points = data_frame_to_list_of_points(
data_frame=data_frame,
data_frame_measurement_name='h2o',
point_settings=PointSettings(),
precision=precision[0])
self.assertEqual(1, len(points))
self.assertEqual(f"h2o level=15i {precision[1]}", points[0])
def test_write_object_field_nan(self):
from influxdb_client.extras import pd, np
now = pd.Timestamp('2020-04-05 00:00+00:00')
data_frame = pd.DataFrame(data=[
["foo", 1],
[np.nan, 2],
],
index=[now, now + timedelta(minutes=30)],
columns=["obj", "val"])
points = data_frame_to_list_of_points(
data_frame=data_frame,
point_settings=PointSettings(),
data_frame_measurement_name='measurement')
self.assertEqual(2, len(points))
self.assertEqual("measurement obj=\"foo\",val=1i 1586044800000000000",
points[0])
self.assertEqual("measurement val=2i 1586046600000000000", points[1])
def test_write_field_bool(self):
from influxdb_client.extras import pd, np
now = pd.Timestamp('2020-04-05 00:00+00:00')
data_frame = pd.DataFrame(data=[
[True],
[False],
],
index=[now, now + timedelta(minutes=30)],
columns=["status"])
points = data_frame_to_list_of_points(data_frame=data_frame,
point_settings=PointSettings(),
data_frame_measurement_name='measurement')
self.assertEqual(2, len(points))
self.assertEqual("measurement status=True 1586044800000000000",
points[0])
self.assertEqual("measurement status=False 1586046600000000000",
points[1])
def test_use_default_tags_with_data_frame(self):
from influxdb_client.extras import pd
bucket = self.create_test_bucket()
now = pd.Timestamp('1970-01-01 00:00+00:00')
data_frame = pd.DataFrame(
data=[["coyote_creek", 1.0], ["coyote_creek", 2.0]],
index=[now + timedelta(hours=1), now + timedelta(hours=2)],
columns=["location", "water_level"])
async_result = self.write_client.write(
bucket.name,
record=data_frame,
data_frame_measurement_name='h2o_feet',
data_frame_tag_columns=['location'])
async_result.get()
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))
records = flux_result[0].records
self.assertEqual(2, len(records))
rec = records[0]
rec2 = records[1]
self.assertEqual(self.id_tag, rec["id"])
self.assertEqual(self.customer_tag, rec["customer"])
self.assertEqual("LA", rec[self.data_center_key])
self.assertEqual(self.id_tag, rec2["id"])
self.assertEqual(self.customer_tag, rec2["customer"])
self.assertEqual("LA", rec2[self.data_center_key])
self.delete_test_bucket(bucket)
