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