X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=PLC%2FLeaseFilter.py;h=de340ea4333161ea822441834894fe305cee59dd;hb=1b1b5a911bb005644baabb87ecba60602228a070;hp=e192d435420be1f21e009306ab1fd1d99bd2e869;hpb=cab70ce8fccbe5c4fae1da42e09a1f3b0f9dd9be;p=plcapi.git diff --git a/PLC/LeaseFilter.py b/PLC/LeaseFilter.py index e192d43..de340ea 100644 --- a/PLC/LeaseFilter.py +++ b/PLC/LeaseFilter.py @@ -3,11 +3,12 @@ # # Utilities for filtering on leases +# w0622: we keep on using 'filter' as a variable name +# pylint: disable=c0111, c0103, w0622 + import time -import calendar -from types import StringTypes -from PLC.Faults import * +from PLC.Faults import * # pylint: disable=w0401, w0614 from PLC.Filter import Filter from PLC.Parameter import Parameter, Mixed from PLC.Timestamp import Timestamp @@ -15,55 +16,59 @@ from PLC.Timestamp import Timestamp # supersede the generic Filter class to support time intersection -class LeaseFilter (Filter): +class LeaseFilter(Filter): # general notes on input parameters # int_timestamp: number of seconds since the epoch # str_timestamp: see Timestamp.sql_validate - # timeslot: a tuple (from, until), each being either int_timestamp or + # timeslot: a list [from, until], each being either int_timestamp or # str_timestamp local_fields = { 'alive': Mixed( - Parameter( - int, "int_timestamp: leases alive at that time"), - Parameter( - str, "str_timestamp: leases alive at that time"), - Parameter( - tuple, "timeslot: the leases alive during this timeslot")), - 'clip': Mixed( - Parameter( - int, "int_timestamp: leases alive after that time"), - Parameter( - str, "str_timestamp: leases alive after at that time"), - Parameter( - tuple, "timeslot: the leases alive during this timeslot")), + Parameter(int, "int_timestamp: leases alive at that time"), + Parameter(str, "str_timestamp: leases alive at that time"), + Parameter(list, "timeslot: the leases alive during this timeslot"), + ), + 'clip': Mixed( + Parameter(int, "int_timestamp: leases alive after that time"), + Parameter(str, "str_timestamp: leases alive after that time"), + Parameter(list, "timeslot: the leases alive during this timeslot"), + ), ########## macros # {'day' : 0} : all leases from today and on # {'day' : 1} : all leases today (localtime at the myplc) # {'day' : 2} : all leases today and tomorrow (localtime at the myplc) # etc.. - 'day': Parameter(int, "clip on a number of days from today and on;" - " 0 means no limit in the future"), + 'day': Parameter( + int, + "clip on a number of days from today and on;" + " 0 means no limit in the future"), } - def __init__(self, fields={}, filter={}, + def __init__(self, fields=None, filter=None, doc="Lease filter -- adds the 'alive' and 'clip'" "capabilities for filtering on leases"): + if fields is None: + fields = {} + if filter is None: + filter = {} Filter.__init__(self, fields, filter, doc) self.fields.update(LeaseFilter.local_fields) # canonical type @staticmethod - def quote(timestamp): return Timestamp.cast_long(timestamp) + def quote(timestamp): + return Timestamp.cast_long(timestamp) # basic SQL utilities @staticmethod def sql_time_intersect(f1, u1, f2, u2): - # either f2 is in [f1,u1], or u2 is in [f1,u1], or f2<=f1<=u1<=u2 - return ("(({f1} <= {f2}) AND ({f2} <= {u1})) " + - "OR (({f1} <= {u2}) AND ({u2} <= {u1})) " + - "OR (({f2}<={f1}) AND ({u1}<={u2}))").format(**locals()) + # either f2 is in [f1,u1[, or u2 is in ]f1,u1], or f2<=f1= mark - return "({u1} >= {mark})".format(**locals()) + return f"({u1} >= {mark})" # hooks for the local fields def sql_alive(self, alive): - if isinstance(alive, int) or isinstance(alive, StringTypes): + if isinstance(alive, (int, str)): # the lease is alive at that time if from <= alive <= until alive = LeaseFilter.quote(alive) return LeaseFilter.sql_time_in_range(alive, 't_from', 't_until') - elif isinstance(alive, tuple): + elif isinstance(alive, (tuple, list)): (f, u) = alive f = LeaseFilter.quote(f) u = LeaseFilter.quote(u) return LeaseFilter.sql_time_intersect(f, u, 't_from', 't_until') else: - raise PLCInvalidArgument("LeaseFilter: alive field {}" - .format(alive)) + raise PLCInvalidArgument(f"LeaseFilter: alive field {alive}") def sql_clip(self, clip): - if isinstance(clip, int) or isinstance(clip, StringTypes): + if isinstance(clip, int) or isinstance(clip, str): start = LeaseFilter.quote(clip) return LeaseFilter.sql_timeslot_after('t_from', 't_until', start) - elif isinstance(clip, tuple): + elif isinstance(clip, (tuple, list)): (f, u) = clip f = LeaseFilter.quote(f) u = LeaseFilter.quote(u) return LeaseFilter.sql_time_intersect(f, u, 't_from', 't_until') else: - raise PLCInvalidArgument("LeaseFilter: clip field {}" - .format(clip)) + raise PLCInvalidArgument(f"LeaseFilter: clip field {clip}") - # the whole key to implementing day is to compute today's beginning + # the whole key to implementing day is to compute today's beginning def today_start(self): # a struct_time st = time.localtime() @@ -129,13 +131,13 @@ class LeaseFilter (Filter): else: self['clip'] = (today, today + nb_days * 24 * 3600) del self['day'] - + # preserve locally what belongs to us, hide it from the superclass # self.local is a dict local_key : user_value # self.negation is a dict local_key : string self.local = {} self.negation = {} - for (k, v) in LeaseFilter.local_fields.items(): + for (k, v) in list(LeaseFilter.local_fields.items()): if k in self: self.local[k] = self[k] del self[k] @@ -146,18 +148,18 @@ class LeaseFilter (Filter): self.negation[k] = "NOT " # run the generic filtering code (where_part, clip_part) = Filter.sql(self, api, join_with) - for (k, v) in self.local.items(): + for (k, v) in list(self.local.items()): try: # locate hook function associated with key method = LeaseFilter.__dict__['sql_' + k] - where_part += " {} {}({})"\ - .format(self.join_with, - self.negation[k], - method(self, self.local[k])) - except Exception, e: + where_part += ( + f" {self.join_with} {self.negation[k]}" + f"({method(self, self.local[k])})" + ) + except Exception as e: raise PLCInvalidArgument( - "LeaseFilter: something wrong with filter" - "key {}, val was {} -- {}".format(k, v, e)) + f"LeaseFilter: something wrong with filter " + f"key {k}, value was {v} -- {e}") return (where_part, clip_part) # xxx not sure where this belongs yet