class PizzaToppings(Flags): """ Some pizza toppings, with obviously meaningful bitwise values. """ # Note 1<<1 < 1<<4 > 1<<2, so we are ensuring here that the definition # order is different from the order of the values, which lets us test that # we're not somehow ordering by value and happen the get the same results. mozzarella = FlagConstant(1 << 1) pesto = FlagConstant(1 << 4) pepperoni = FlagConstant(1 << 2)
class Switches(Flags): r = FlagConstant() g = FlagConstant() b = FlagConstant() r.description = u"red" g.description = u"green" b.description = u"blue" black = FlagConstant()
class FXF(Flags): # Implicitly assign three flag values based on definition order READ = FlagConstant() WRITE = FlagConstant() APPEND = FlagConstant() # Explicitly assign one flag value by passing it in EXCLUSIVE = FlagConstant(0x20) # Implicitly assign another flag value, following the previously # specified explicit value. TEXT = FlagConstant()
def _setMatchFunctions(flags): """ Compute a predicate and normalize functions for the given match expression flags. @param flags: Match expression flags. @type flags: L{MatchFlags} @return: Predicate and normalize functions. @rtype: L{tuple} of callables. """ predicate = lambda x: x normalize = lambda x: x def caseInsensitivify(x): # Case insensitive only makes sense conceptually for text # Note we are intentionally not treating bytes as text if isinstance(x, unicode): return x.lower() else: return x if flags is None: flags = FlagConstant() else: for flag in flags: if flag == MatchFlags.NOT: predicate = lambda x: not x elif flag == MatchFlags.caseInsensitive: normalize = caseInsensitivify else: raise NotImplementedError( "Unknown query flag: {0}".format(describe(flag)) ) flags._predicate = predicate flags._normalize = normalize return flags
class CONTROLS(Flags): """ Control frame specifiers. """ CONTINUE = FlagConstant(0) TEXT = FlagConstant(1) BINARY = FlagConstant(2) CLOSE = FlagConstant(8) PING = FlagConstant(9) PONG = FlagConstant(10)
class Authorization(Flags): """ Authorizations """ imsAdmin = FlagConstant() readPersonnel = FlagConstant() readIncidents = FlagConstant() writeIncidents = FlagConstant() readIncidentReports = FlagConstant() writeIncidentReports = FlagConstant()
class TunnelFlags(Flags): """ L{TunnelFlags} defines more flags which are used to configure the behavior of a tunnel device. @cvar IFF_TUN: This indicates a I{tun}-type device. This type of tunnel carries IP datagrams. This flag is mutually exclusive with C{IFF_TAP}. @cvar IFF_TAP: This indicates a I{tap}-type device. This type of tunnel carries ethernet frames. This flag is mutually exclusive with C{IFF_TUN}. @cvar IFF_NO_PI: This indicates the I{protocol information} header will B{not} be included in data read from the tunnel. @see: U{https://www.kernel.org/doc/Documentation/networking/tuntap.txt} """ IFF_TUN = FlagConstant(0x0001) IFF_TAP = FlagConstant(0x0002) TUN_FASYNC = FlagConstant(0x0010) TUN_NOCHECKSUM = FlagConstant(0x0020) TUN_NO_PI = FlagConstant(0x0040) TUN_ONE_QUEUE = FlagConstant(0x0080) TUN_PERSIST = FlagConstant(0x0100) TUN_VNET_HDR = FlagConstant(0x0200) IFF_NO_PI = FlagConstant(0x1000) IFF_ONE_QUEUE = FlagConstant(0x2000) IFF_VNET_HDR = FlagConstant(0x4000) IFF_TUN_EXCL = FlagConstant(0x8000)
class TIMEX(Flags): # (timex.mode) ADJ_OFFSET = FlagConstant(0x0001) # time offset # xntp 3.4 compatibility names MOD_OFFSET = FlagConstant(0x0001)
class MatchFlags(Flags): """ Match expression flags. """ NOT = FlagConstant() NOT.description = u"not" caseInsensitive = FlagConstant() caseInsensitive.description = u"case insensitive" none = None @staticmethod def _setMatchFunctions(flags): """ Compute a predicate and normalize functions for the given match expression flags. @param flags: Match expression flags. @type flags: L{MatchFlags} @return: Predicate and normalize functions. @rtype: L{tuple} of callables. """ predicate = lambda x: x normalize = lambda x: x def caseInsensitivify(x): # Case insensitive only makes sense conceptually for text # Note we are intentionally not treating bytes as text if isinstance(x, unicode): return x.lower() else: return x if flags is None: flags = FlagConstant() else: for flag in flags: if flag == MatchFlags.NOT: predicate = lambda x: not x elif flag == MatchFlags.caseInsensitive: normalize = caseInsensitivify else: raise NotImplementedError("Unknown query flag: {0}".format( describe(flag))) flags._predicate = predicate flags._normalize = normalize return flags @staticmethod def predicator(flags): """ Determine a predicate function for the given flags. @param flags: Match expression flags. @type flags: L{MatchFlags} @return: a L{callable} that accepts an L{object} argument and returns a L{object} that has the opposite or same truth value as the argument, depending on whether L{MatchFlags.NOT} is or is not in C{flags}. @rtype: callable """ if not hasattr(flags, "_predicate"): flags = MatchFlags._setMatchFunctions(flags) return flags._predicate @staticmethod def normalizer(flags): """ Determine a normalize function for the given flags. @param flags: Match expression flags. @type flags: L{MatchFlags} @return: a L{callable} that accepts a L{unicode} and returns the same L{unicode} or a normalized L{unicode} that can be compared with other normalized L{unicode}s in a case-insensitive fashion, depending on whether L{MatchFlags.caseInsensitive} is not or is in C{flags}. @rtype: callable """ if not hasattr(flags, "_normalize"): flags = MatchFlags._setMatchFunctions(flags) return flags._normalize
class OtherAccess(Flags): """ More access types. """ delete = FlagConstant()
class Access(Flags): """ Some access types. """ read = FlagConstant() write = FlagConstant()