def test_eq():
query = Query().value == 1
assert query({'value': 1})
assert not query({'value': 2})
assert hash(query)
query = Query().value == [0, 1]
assert query({'value': [0, 1]})
assert not query({'value': [0, 1, 2]})
assert hash(query)
def test_and():
query = (
(Query().val1 == 1) &
(Query().val2 == 2)
)
assert query({'val1': 1, 'val2': 2})
assert not query({'val1': 1})
assert not query({'val2': 2})
assert not query({'val1': '', 'val2': ''})
assert hash(query)
def test_not():
query = ~(Query().val1 == 1)
assert query({'val1': 5, 'val2': 2})
assert not query({'val1': 1, 'val2': 2})
query = ((~(Query().val1 == 1)) & (Query().val2 == 2))
assert query({'val1': '', 'val2': 2})
assert query({'val2': 2})
assert not query({'val1': 1, 'val2': 2})
assert not query({'val1': 1})
assert not query({'val1': '', 'val2': ''})
def test_ne():
query = Query().value != 1
assert query({'value': 0})
assert query({'value': 2})
assert not query({'value': 1})
assert hash(query)
query = Query().value != [0, 1]
assert query({'value': [0, 1, 2]})
assert not query({'value': [0, 1]})
assert hash(query)
def test_has():
query = Query().key1.key2.exists()
str(query) # This used to cause a bug...
assert query({'key1': {'key2': {'key3': 1}}})
assert query({'key1': {'key2': 1}})
assert not query({'key1': 3})
assert not query({'key1': {'key1': 1}})
assert not query({'key2': {'key1': 1}})
query = Query().key1.key2 == 1
assert query({'key1': {'key2': 1}})
assert not query({'key1': {'key2': 2}})
# Nested has: key exists
query = Query().key1.key2.key3.exists()
assert query({'key1': {'key2': {'key3': 1}}})
# Not a dict
assert not query({'key1': 1})
assert not query({'key1': {'key2': 1}})
# Wrong key
assert not query({'key1': {'key2': {'key0': 1}}})
assert not query({'key1': {'key0': {'key3': 1}}})
assert not query({'key0': {'key2': {'key3': 1}}})
# Nested has: check for value
query = Query().key1.key2.key3 == 1
assert query({'key1': {'key2': {'key3': 1}}})
assert not query({'key1': {'key2': {'key3': 0}}})
# Test special methods: regex matches
query = Query().key1.value.matches(r'\d+')
assert query({'key1': {'value': '123'}})
assert not query({'key2': {'value': '123'}})
assert not query({'key2': {'value': 'abc'}})
# Test special methods: regex contains
query = Query().key1.value.search(r'\d+')
assert query({'key1': {'value': 'a2c'}})
assert not query({'key2': {'value': 'a2c'}})
assert not query({'key2': {'value': 'abc'}})
# Test special methods: nested has and regex matches
query = Query().key1.x.y.matches(r'\d+')
assert query({'key1': {'x': {'y': '123'}}})
assert not query({'key1': {'x': {'y': 'abc'}}})
# Test special method: nested has and regex contains
query = Query().key1.x.y.search(r'\d+')
assert query({'key1': {'x': {'y': 'a2c'}}})
assert not query({'key1': {'x': {'y': 'abc'}}})
# Test special methods: custom test
query = Query().key1.int.test(lambda x: x == 3)
assert query({'key1': {'int': 3}})
def test_regex():
query = Query().val.matches(r'\d{2}\.')
assert query({'val': '42.'})
assert not query({'val': '44'})
assert not query({'val': 'ab.'})
assert not query({'': None})
query = Query().val.search(r'\d+')
assert query({'val': 'ab3'})
assert not query({'val': 'abc'})
assert not query({'val': ''})
assert not query({'': None})
def saveScore(self, chapter, score): ### saves highest score for the chapter test that is taken
student = Query() ## tinyDB construct query
if len(db.search(student.student_id == self.id)) == 0: ##searches database for the student by student id
self.saveToDB()
table.update({"scores" : [{"chapter" : chapter, "score" : score}]}, where('student_id') == self.id)
def readByMapHex(self, mapHex: str):
db = self.createObj()
rows = db.tbl.search(
Query().mapHex == mapHex
)
db.close()
return rows
def test_path_exists():
query = Query()['value'].exists()
assert query == where('value').exists()
assert query({'value': 1})
assert not query({'something': 1})
assert hash(query)
assert hash(query) != hash(where('asd'))
query = Query()['value']['val'].exists()
assert query == where('value')['val'].exists()
assert query({'value': {'val': 2}})
assert not query({'value': 1})
assert not query({'value': {'asd': 1}})
assert not query({'something': 1})
assert hash(query)
assert hash(query) != hash(where('asd'))
def create(self, mapHex, source, tokenType, x, y):
db = self.createObj()
num = db.tbl.count(Query().mapHex == mapHex)
db.close()
if num > 100:
raise TokenLimit('token limit has been reached for this map')
hex = ''
while True:
hex = mkHex()
if self.exists('hex', hex) == False:
break
row = {
'hex': hex,
'mapHex': mapHex,
'source': source,
'type': tokenType,
'x': x,
'y': y,
'ts': self.now_ts()
}
return super().create(row)
def updateByHex(self, hex: str, x: int, y: int):
db = self.createObj()
rows_updated = db.tbl.update(
{'x': x, 'y': y},
Query().hex == hex
)
db.close()
return rows_updated
def deleteByHex(self, hex: str):
db = self.createObj()
ids = db.tbl.remove(Query().hex == hex)
db.close()
if ids != []:
return True
return False
def test_orm_usage():
data = {'name': 'John', 'age': {'year': 2000}}
User = Query()
query1 = User.name == 'John'
query2 = User.age.year == 2000
assert query1(data)
assert query2(data)
def test_fragment():
query = Query().fragment({'a': 4, 'b': True})
assert query({'a': 4, 'b': True, 'c': 'yes'})
assert not query({'a': 4, 'c': 'yes'})
assert not query({'b': True, 'c': 'yes'})
assert not query({'a': 5, 'b': True, 'c': 'yes'})
assert not query({'a': 4, 'b': 'no', 'c': 'yes'})
def deleteByHex(self, hex: str):
if self.exists('hex', hex) == False:
return False
db = self.createObj()
db.tbl.remove(Query().hex == hex)
db.close()
return True
def test_custom_with_params():
def test(value, minimum, maximum):
return minimum <= value <= maximum
query = Query().val.test(test, 1, 10)
assert query({'val': 5})
assert not query({'val': 0})
assert not query({'val': 11})
assert not query({'': None})
def __plant_entry_sorter(plant: Plant,
plants_master_data_db: table.Table) -> int:
""" sorter function for plant entries list. Sort by doc_id"""
plant_query = Query()
plant_entry = plants_master_data_db.get(plant_query.id == plant.id)
plant_seq = plant_entry.doc_id
if not plant_seq is None:
return plant_seq
else:
return -1
def test_custom():
def test(value):
return value == 42
query = Query().val.test(test)
assert query({'val': 42})
assert not query({'val': 40})
assert not query({'val': '44'})
assert not query({'': None})
def read_messages(host):
if not db_client_queries.has(host):
client = Client(host)
db_client.insert(client)
if host is not None:
message: Query = Query()
return db_message.search(message.host == host)
return db_message.all()
def test_all():
query = Query().followers.all(Query().name == 'don')
assert query({'followers': [{'name': 'don'}]})
assert not query({'followers': [{'name': 'don'}, {'name': 'john'}]})
assert hash(query)
query = Query().followers.all(Query().num.matches('\\d+'))
assert query({'followers': [{'num': '123'}, {'num': '456'}]})
assert not query({'followers': [{'num': '123'}, {'num': 'abc'}]})
assert hash(query)
query = Query().followers.all(['don', 'john'])
assert query({'followers': ['don', 'john', 'greg']})
assert not query({'followers': ['don', 'greg']})
assert not query({})
assert hash(query)
query = Query().followers.all([{'name': 'jane'}, {'name': 'john'}])
assert query({'followers': [{'name': 'john'}, {'name': 'jane'}]})
assert query(
{'followers': [{
'name': 'john'
}, {
'name': 'jane'
}, {
'name': 'bob'
}]})
assert not query({'followers': [{'name': 'john'}, {'name': 'bob'}]})
assert hash(query)
def test_custom():
def test(value):
return value == 42
query = Query().val.test(test)
assert query({'val': 42})
assert not query({'val': 40})
assert not query({'val': '44'})
assert not query({'': None})
assert hash(query)
def in_list(value, l):
return value in l
query = Query().val.test(in_list, tuple([25, 35]))
assert not query({'val': 20})
assert query({'val': 25})
assert not query({'val': 30})
assert query({'val': 35})
assert not query({'val': 36})
assert hash(query)
def test_regex():
query = Query().val.matches(r'\d{2}\.')
assert query({'val': '42.'})
assert not query({'val': '44'})
assert not query({'val': 'ab.'})
assert not query({'': None})
assert hash(query)
query = Query().val.search(r'\d+')
assert query({'val': 'ab3'})
assert not query({'val': 'abc'})
assert not query({'val': ''})
assert not query({'': None})
assert hash(query)
query = Query().val.search(r'JOHN', flags=re.IGNORECASE)
assert query({'val': 'john'})
assert query({'val': 'xJohNx'})
assert not query({'val': 'JOH'})
assert not query({'': None})
assert hash(query)
def updateByHex(self, hex: str, title: str, map: str, sound: str,
width: int, fog: bool):
db = self.createObj()
db.tbl.update(
{
'title': title,
'map_source': map,
'map_soundtrack': sound,
'width': width,
'fog': fog
},
Query().hex == hex)
db.close()
return True
def cal_score(cui1, cui2):
q = Query()
res = score_db.search((q.cui1 == cui1) & (q.cui2 == cui2))
if len(res) == 1:
return float(res[0]['score'])
elif len(res) > 1:
print("有錯誤，多餘一個結果")
else: # < 1的話，再找一次
res = score_db.search((q.cui2 == cui1) & (q.cui1 == cui2))
if len(res) == 1:
return float(res[0]['score'])
else:
return 0
def execute(self, lf, input_table):
"""
Convert the logical form into procedural program calls and execute it
"""
buffer = tokenize(lf)
stack = []
denotation = []
db = input_table
User = Query()
result = None
try:
result = self.execute_table(buffer, stack, denotation, db, User)
except:
result = sys.exc_info()
#result = self.execute_table(buffer, stack, denotation, db, User)
return result
def clean_up_plant_history() -> None:
# history db connection
plant_db = DbAdapter().plant_db
sensor_history_db = plant_db.table(SENSOR_HISTORY_TABLE_NAME)
# master db connection
master_data_db = DbAdapter().master_data_db
plants_master_data_db = master_data_db.table(
SCHEDULED_JOBS_CONFIGURATION_TABLE_NAME)
max_months = plants_master_data_db.get(
doc_id=1)['max_plant_history_months']
min_date = datetime.now() - timedelta(weeks=max_months * 4)
sensor_entry = Query()
# delete all entries which are older than max_months
test_max_entry = lambda plant_history_entry_ts: datetime.fromisoformat(
plant_history_entry_ts) < min_date
sensor_history_db.remove(sensor_entry.ts.test(test_max_entry))
logger.info(
f'[-Clean up plant history-] Sucessfully cleared plant history entries older than: {min_date}'
)
def get_plant_history(
range_start_date: Optional[str] = FastAPIQuery(None, description="Note: start date is assumed to be in ISO format (YYYY-MM-DD)",regex="^([0-9]{4})(-)(1[0-2]|0[1-9])\\2(3[01]|0[1-9]|[12][0-9])$"),
range_end_date: Optional[str]= FastAPIQuery(None, description="Note: end date is assumed to be in ISO format (YYYY-MM-DD)", regex="^([0-9]{4})(-)(1[0-2]|0[1-9])\\2(3[01]|0[1-9]|[12][0-9])$")
):
"""
Get entries of plant sensor history db.
The query can be narrowed as follows by query params:
- **range_start_date** AND **range_end_date**: Gets all entries between range_start_date and range_end_date
- **range_start_date**: Gets all entries which are newer than range_start_date
- **range_end_date**: Gets all entries which are older than range_end_date
- **NO QUERY PARAM**: Gets all entries of sensor history db
"""
history_entry = Query()
if range_start_date and range_end_date:
return sensor_history.search(history_entry.ts.test(test_history_range, range_start_date, range_end_date))
elif range_start_date:
return sensor_history.search(history_entry.ts.test(test_history_range_start, range_start_date))
elif range_end_date:
return sensor_history.search(history_entry.ts.test(test_history_range_end, range_end_date))
else:
return sensor_history.all()
def test_any():
query = Query().followers.any(Query().name == 'don')
assert query({'followers': [{'name': 'don'}, {'name': 'john'}]})
assert not query({'followers': 1})
assert not query({})
query = Query().followers.any(Query().num.matches('\\d+'))
assert query({'followers': [{'num': '12'}, {'num': 'abc'}]})
assert not query({'followers': [{'num': 'abc'}]})
query = Query().followers.any(['don', 'jon'])
assert query({'followers': ['don', 'greg', 'bill']})
assert not query({'followers': ['greg', 'bill']})
assert not query({})
query = Query().followers.any([{'name': 'don'}, {'name': 'john'}])
assert query({'followers': [{'name': 'don'}, {'name': 'greg'}]})
assert not query({'followers': [{'name': 'greg'}]})
def updateBgByHex(self, hex: str, bg: str):
db = self.createObj()
db.tbl.update({'map_source': bg}, Query().hex == hex)
db.close()
return True
def readByHex(self, hex: str):
db = self.createObj()
row = db.tbl.get(Query().hex == hex)
db.close()
return row
