synapse 2.154.1__py311-none-any.whl → 2.156.0__py311-none-any.whl

synapse/lib/stormtypes.py

@@ -6317,6 +6317,29 @@ class Layer(Prim):
                       {'name': 'propname', 'type': 'str', 'desc': 'The property or form name to look up.', },
                       {'name': 'maxsize', 'type': 'int', 'desc': 'The maximum number of rows to look up.',
                        'default': None, },
+                      {'name': 'valu', 'type': 'any', 'default': '$lib.undef',
+                       'desc': 'A specific value of the property to look up.', },
+                  ),
+                  'returns': {'type': 'int', 'desc': 'The count of rows.', }}},
+        {'name': 'getPropArrayCount',
+         'desc': 'Get the number of individual value rows in the layer for the given array property name.',
+         'type': {'type': 'function', '_funcname': '_methGetPropArrayCount',
+                  'args': (
+                      {'name': 'propname', 'type': 'str', 'desc': 'The property name to look up.', },
+                      {'name': 'valu', 'type': 'any', 'default': '$lib.undef',
+                       'desc': 'A specific value in the array property to look up.', },
+                  ),
+                  'returns': {'type': 'int', 'desc': 'The count of rows.', }}},
+        {'name': 'getTagPropCount',
+         'desc': 'Get the number of rows in the layer for the given tag property.',
+         'type': {'type': 'function', '_funcname': '_methGetTagPropCount',
+                  'args': (
+                      {'name': 'tag', 'type': 'str', 'desc': 'The tag to look up.', },
+                      {'name': 'propname', 'type': 'str', 'desc': 'The property name to look up.', },
+                      {'name': 'form', 'type': 'str', 'default': None,
+                       'desc': 'The optional form to look up.', },
+                      {'name': 'valu', 'type': 'any', 'default': '$lib.undef',
+                       'desc': 'A specific value of the property to look up.', },
                   ),
                   'returns': {'type': 'int', 'desc': 'The count of rows.', }}},
         {'name': 'getFormCounts', 'desc': '''
@@ -6514,6 +6537,8 @@ class Layer(Prim):
             'liftByProp': self.liftByProp,
             'getTagCount': self._methGetTagCount,
             'getPropCount': self._methGetPropCount,
+            'getTagPropCount': self._methGetTagPropCount,
+            'getPropArrayCount': self._methGetPropArrayCount,
             'getFormCounts': self._methGetFormcount,
             'getStorNode': self.getStorNode,
             'getStorNodes': self.getStorNodes,
@@ -6678,7 +6703,7 @@ class Layer(Prim):
         return await layr.getTagCount(tagname, formname=formname)
 
     @stormfunc(readonly=True)
-    async def _methGetPropCount(self, propname, maxsize=None):
+    async def _methGetPropCount(self, propname, maxsize=None, valu=undef):
         propname = await tostr(propname)
         maxsize = await toint(maxsize, noneok=True)
 
@@ -6691,13 +6716,86 @@ class Layer(Prim):
         await self.runt.reqUserCanReadLayer(layriden)
         layr = self.runt.snap.core.getLayer(layriden)
 
+        if valu is undef:
+            if prop.isform:
+                return await layr.getPropCount(prop.name, None, maxsize=maxsize)
+
+            if prop.isuniv:
+                return await layr.getPropCount(None, prop.name, maxsize=maxsize)
+
+            return await layr.getPropCount(prop.form.name, prop.name, maxsize=maxsize)
+
+        valu = await toprim(valu)
+        norm, info = prop.type.norm(valu)
+
+        if prop.isform:
+            return layr.getPropValuCount(prop.name, None, prop.type.stortype, norm)
+
+        if prop.isuniv:
+            return layr.getPropValuCount(None, prop.name, prop.type.stortype, norm)
+
+        return layr.getPropValuCount(prop.form.name, prop.name, prop.type.stortype, norm)
+
+    @stormfunc(readonly=True)
+    async def _methGetPropArrayCount(self, propname, valu=undef):
+        propname = await tostr(propname)
+
+        prop = self.runt.snap.core.model.prop(propname)
+        if prop is None:
+            mesg = f'No property named {propname}'
+            raise s_exc.NoSuchProp(mesg=mesg)
+
+        if not prop.type.isarray:
+            mesg = f'Property is not an array type: {prop.type.name}.'
+            raise s_exc.BadTypeValu(mesg=mesg)
+
+        layriden = self.valu.get('iden')
+        await self.runt.reqUserCanReadLayer(layriden)
+        layr = self.runt.snap.core.getLayer(layriden)
+
+        if valu is undef:
+            if prop.isform:
+                return await layr.getPropArrayCount(prop.name, None)
+
+            if prop.isuniv:
+                return await layr.getPropArrayCount(None, prop.name)
+
+            return await layr.getPropArrayCount(prop.form.name, prop.name)
+
+        valu = await toprim(valu)
+        atyp = prop.type.arraytype
+        norm, info = atyp.norm(valu)
+
         if prop.isform:
-            return await layr.getPropCount(prop.name, None, maxsize=maxsize)
+            return layr.getPropArrayValuCount(prop.name, None, atyp.stortype, norm)
 
         if prop.isuniv:
-            return await layr.getUnivPropCount(prop.name, maxsize=maxsize)
+            return layr.getPropArrayValuCount(None, prop.name, atyp.stortype, norm)
+
+        return layr.getPropArrayValuCount(prop.form.name, prop.name, atyp.stortype, norm)
+
+    @stormfunc(readonly=True)
+    async def _methGetTagPropCount(self, tag, propname, form=None, valu=undef):
+        tag = await tostr(tag)
+        propname = await tostr(propname)
+        form = await tostr(form, noneok=True)
+
+        prop = self.runt.snap.core.model.getTagProp(propname)
+        if prop is None:
+            mesg = f'No tag property named {propname}'
+            raise s_exc.NoSuchTagProp(name=propname, mesg=mesg)
+
+        layriden = self.valu.get('iden')
+        await self.runt.reqUserCanReadLayer(layriden)
+        layr = self.runt.snap.core.getLayer(layriden)
+
+        if valu is undef:
+            return await layr.getTagPropCount(form, tag, prop.name)
+
+        valu = await toprim(valu)
+        norm, info = prop.type.norm(valu)
 
-        return await layr.getPropCount(prop.form.name, prop.name, maxsize=maxsize)
+        return layr.getTagPropValuCount(form, tag, prop.name, prop.type.stortype, norm)
 
     @stormfunc(readonly=True)
     async def _methLayerEdits(self, offs=0, wait=True, size=None):
@@ -7021,6 +7119,68 @@ class View(Prim):
                   'returns':
                       {'type': 'dict',
                        'desc': "Dictionary containing form names and the count of the nodes in the View's Layers.", }}},
+
+        {'name': 'getPropCount',
+         'desc': '''
+            Get the number of nodes in the View with a specific property and optional value.
+
+            Notes:
+               This is a fast approximate count calculated by summing the number of
+               nodes with the property value in each layer of the view. Property values
+               which are overwritten by different values in higher layers will still
+               be included in the count.
+            ''',
+         'type': {'type': 'function', '_funcname': '_methGetPropCount',
+                  'args': (
+                      {'name': 'propname', 'type': 'str', 'desc': 'The property name to look up.', },
+                      {'name': 'valu', 'type': 'any', 'default': '$lib.undef',
+                       'desc': 'The value of the property to look up.', },
+                  ),
+                  'returns': {'type': 'int', 'desc': 'The count of nodes.', }}},
+
+        {'name': 'getPropArrayCount',
+         'desc': '''
+            Get the number of invidivual array property values in the View for the given array property name.
+
+            Notes:
+               This is a fast approximate count calculated by summing the number of
+               array property values in each layer of the view. Property values
+               which are overwritten by different values in higher layers will
+               still be included in the count.
+            ''',
+         'type': {'type': 'function', '_funcname': '_methGetPropArrayCount',
+                  'args': (
+                      {'name': 'propname', 'type': 'str', 'desc': 'The property name to look up.', },
+                      {'name': 'valu', 'type': 'any', 'default': '$lib.undef',
+                       'desc': 'The value in the array property to look up.', },
+                  ),
+                  'returns': {'type': 'int', 'desc': 'The count of nodes.', }}},
+
+        {'name': 'getTagPropCount',
+         'desc': '''
+            Get the number of nodes in the View with the given tag property and optional value.
+
+            Notes:
+               This is a fast approximate count calculated by summing the number of
+               nodes with the tag property value in each layer of the view.
+               Values which are overwritten by different values in higher layers
+               will still be included in the count.
+            ''',
+         'type': {'type': 'function', '_funcname': '_methGetTagPropCount',
+                  'args': (
+                      {'name': 'tag', 'type': 'str', 'desc': 'The tag to look up.', },
+                      {'name': 'propname', 'type': 'str', 'desc': 'The property name to look up.', },
+                      {'name': 'form', 'type': 'str', 'default': None,
+                       'desc': 'The optional form to look up.', },
+                      {'name': 'valu', 'type': 'any', 'default': '$lib.undef',
+                       'desc': 'The value of the property to look up.', },
+                  ),
+                  'returns': {'type': 'int', 'desc': 'The count of nodes.', }}},
+
+        {'name': 'detach', 'desc': 'Detach the view from its parent. WARNING: This cannot be reversed.',
+         'type': {'type': 'function', '_funcname': 'detach',
+                  'args': (),
+                  'returns': {'type': 'null', }}},
     )
     _storm_typename = 'view'
     _ismutable = False
@@ -7047,12 +7207,16 @@ class View(Prim):
             'pack': self._methViewPack,
             'repr': self._methViewRepr,
             'merge': self._methViewMerge,
+            'detach': self.detach,
             'addNode': self.addNode,
             'getEdges': self._methGetEdges,
             'wipeLayer': self._methWipeLayer,
             'addNodeEdits': self._methAddNodeEdits,
             'getEdgeVerbs': self._methGetEdgeVerbs,
             'getFormCounts': self._methGetFormcount,
+            'getPropCount': self._methGetPropCount,
+            'getTagPropCount': self._methGetTagPropCount,
+            'getPropArrayCount': self._methGetPropArrayCount,
         }
 
     async def addNode(self, form, valu, props=None):
@@ -7080,6 +7244,15 @@ class View(Prim):
         else:
             await view.addNode(form, valu, props=props, user=self.runt.user)
 
+    async def detach(self):
+
+        view = self._reqView()
+        if not self.runt.isAdmin(gateiden=view.iden):
+            mesg = 'You must be an admin of the view to detach.'
+            raise s_exc.AuthDeny(mesg=mesg, user=self.runt.user.iden, username=self.runt.user.name)
+
+        await view.detach()
+
     async def _methAddNodeEdits(self, edits):
         useriden = self.runt.user.iden
         viewiden = self.valu.get('iden')
@@ -7097,6 +7270,53 @@ class View(Prim):
         todo = s_common.todo('getFormCounts')
         return await self.viewDynCall(todo, ('view', 'read'))
 
+    @stormfunc(readonly=True)
+    async def _methGetPropCount(self, propname, valu=undef):
+        propname = await tostr(propname)
+
+        if valu is undef:
+            valu = s_common.novalu
+        else:
+            valu = await toprim(valu)
+
+        viewiden = self.valu.get('iden')
+        self.runt.confirm(('view', 'read'), gateiden=viewiden)
+        view = self.runt.snap.core.getView(viewiden)
+
+        return await view.getPropCount(propname, valu=valu)
+
+    @stormfunc(readonly=True)
+    async def _methGetTagPropCount(self, tag, propname, form=None, valu=undef):
+        tag = await tostr(tag)
+        propname = await tostr(propname)
+        form = await tostr(form, noneok=True)
+
+        if valu is undef:
+            valu = s_common.novalu
+        else:
+            valu = await toprim(valu)
+
+        viewiden = self.valu.get('iden')
+        self.runt.confirm(('view', 'read'), gateiden=viewiden)
+        view = self.runt.snap.core.getView(viewiden)
+
+        return await view.getTagPropCount(form, tag, propname, valu=valu)
+
+    @stormfunc(readonly=True)
+    async def _methGetPropArrayCount(self, propname, valu=undef):
+        propname = await tostr(propname)
+
+        if valu is undef:
+            valu = s_common.novalu
+        else:
+            valu = await toprim(valu)
+
+        viewiden = self.valu.get('iden')
+        self.runt.confirm(('view', 'read'), gateiden=viewiden)
+        view = self.runt.snap.core.getView(viewiden)
+
+        return await view.getPropArrayCount(propname, valu=valu)
+
     @stormfunc(readonly=True)
     async def _methGetEdges(self, verb=None):
         verb = await toprim(verb)
@@ -7127,6 +7347,9 @@ class View(Prim):
     async def _methViewGet(self, name, defv=None):
         return self.valu.get(name, defv)
 
+    def _reqView(self):
+        return self.runt.snap.core.reqView(self.valu.get('iden'))
+
     async def _methViewSet(self, name, valu):
 
         name = await tostr(name)
@@ -7137,14 +7360,17 @@ class View(Prim):
             else:
                 valu = await tostr(await toprim(valu), noneok=True)
 
+            if name == 'parent' and valu is not None:
+                self.runt.snap.core.reqView(valu, mesg='The parent view must already exist.')
+                self.runt.confirm(('view', 'read'), gateiden=valu)
+                self.runt.confirm(('view', 'fork'), gateiden=valu)
+
         elif name == 'nomerge':
             valu = await tobool(valu)
+
         elif name == 'layers':
 
-            view = self.runt.snap.core.getView(self.valu.get('iden'))
-            if view is None: # pragma: no cover
-                mesg = f'No view with iden: {self.valu.get("iden")}'
-                raise s_exc.NoSuchView(mesg=mesg, iden=self.valu.get('iden'))
+            view = self._reqView()
 
             layers = await toprim(valu)
             layers = tuple(str(x) for x in layers)
@@ -7170,8 +7396,11 @@ class View(Prim):
             mesg = f'View does not support setting: {name}'
             raise s_exc.BadOptValu(mesg=mesg)
 
-        todo = s_common.todo('setViewInfo', name, valu)
-        valu = await self.viewDynCall(todo, ('view', 'set', name))
+        view = self.runt.snap.core.reqView(self.valu.get('iden'))
+
+        self.runt.confirm(('view', 'set', name), gateiden=view.iden)
+        await view.setViewInfo(name, valu)
+
         self.valu[name] = valu
 
     @stormfunc(readonly=True)
@@ -7202,10 +7431,9 @@ class View(Prim):
         useriden = self.runt.user.iden
         viewiden = self.valu.get('iden')
 
-        gatekeys = (
-            (useriden, ('view', 'add'), None),
-            (useriden, ('view', 'read'), viewiden),
-        )
+        self.runt.confirm(('view', 'add'))
+        self.runt.confirm(('view', 'read'), gateiden=viewiden)
+        self.runt.confirm(('view', 'fork'), gateiden=viewiden)
 
         ldef = {'creator': self.runt.user.iden}
         vdef = {'creator': self.runt.user.iden}
@@ -7213,9 +7441,9 @@ class View(Prim):
         if name is not None:
             vdef['name'] = name
 
-        todo = s_common.todo('fork', ldef=ldef, vdef=vdef)
+        view = self.runt.snap.core.reqView(viewiden)
 
-        newv = await self.runt.dyncall(viewiden, todo, gatekeys=gatekeys)
+        newv = await view.fork(ldef=ldef, vdef=vdef)
 
         return View(self.runt, newv, path=self.path)
 

synapse/lib/types.py

@@ -929,6 +929,7 @@ class Int(IntBase):
     _opt_defs = (
         ('size', 8),  # type: ignore # Set the storage size of the integer type in bytes.
         ('signed', True),
+        ('enums:strict', True),
 
         # Note: currently unused
         ('fmt', '%d'),  # Set to an integer compatible format string to control repr.
@@ -952,6 +953,8 @@ class Int(IntBase):
         self.enumnorm = {}
         self.enumrepr = {}
 
+        self.enumstrict = self.opts.get('enums:strict')
+
         enums = self.opts.get('enums')
         if enums is not None:
             self.enumrepr.update(dict(enums))
@@ -1031,7 +1034,7 @@ class Int(IntBase):
             mesg = f'value is above max={self.maxval}'
             raise s_exc.BadTypeValu(valu=repr(valu), name=self.name, mesg=mesg)
 
-        if self.enumrepr and valu not in self.enumrepr:
+        if self.enumrepr and self.enumstrict and valu not in self.enumrepr:
             mesg = 'Value is not a valid enum value.'
             raise s_exc.BadTypeValu(valu=valu, name=self.name, mesg=mesg)
 
@@ -1761,8 +1764,19 @@ class Taxonomy(Str):
         self.setNormFunc(tuple, self._normPyList)
         self.taxon = self.modl.type('taxon')
 
+    def _ctorCmprPref(self, valu):
+        norm = self._normForLift(valu)
+
+        def cmpr(valu):
+            return valu.startswith(norm)
+
+        return cmpr
+
     def _normForLift(self, valu):
-        return self.norm(valu)[0]
+        norm = self.norm(valu)[0]
+        if isinstance(valu, str) and not valu.strip().endswith('.'):
+            return norm.rstrip('.')
+        return norm
 
     def _normPyList(self, valu):
 

synapse/lib/version.py

@@ -223,6 +223,6 @@ def reqVersion(valu, reqver,
 ##############################################################################
 # The following are touched during the release process by bumpversion.
 # Do not modify these directly.
-version = (2, 154, 1)
+version = (2, 156, 0)
 verstring = '.'.join([str(x) for x in version])
-commit = '596a72e1ce5102e18f289394f292c81bc65a3ff7'
+commit = '918a46d769574c99d1510654c1c2aaa13c3fda2c'

synapse/lib/view.py

@@ -144,6 +144,22 @@ class View(s_nexus.Pusher):  # type: ignore
         self.trigtask = None
         await self.initTrigTask()
 
+    @s_nexus.Pusher.onPushAuto('view:detach')
+    async def detach(self):
+        '''
+        Detach the view from its parent but do not change the layers.
+        ( this is not reversible! )
+        '''
+        if not self.parent:
+            mesg = 'A view with no parent is already detached.'
+            raise s_exc.BadArg(mesg=mesg)
+
+        self.parent = None
+        await self.info.pop('parent')
+
+        await self.core.feedBeholder('view:set', {'iden': self.iden, 'name': 'parent', 'valu': None},
+                                     gates=[self.iden, self.layers[0].iden])
+
     async def mergeStormIface(self, name, todo):
         '''
         Allow an interface which specifies a generator use case to yield
@@ -382,6 +398,95 @@ class View(s_nexus.Pusher):  # type: ignore
                 counts[name] += valu
         return counts
 
+    async def getPropCount(self, propname, valu=s_common.novalu):
+        prop = self.core.model.prop(propname)
+        if prop is None:
+            mesg = f'No property named {propname}'
+            raise s_exc.NoSuchProp(mesg=mesg)
+
+        count = 0
+        formname = None
+        propname = None
+
+        if prop.isform:
+            formname = prop.name
+        else:
+            propname = prop.name
+            if not prop.isuniv:
+                formname = prop.form.name
+
+        if valu is s_common.novalu:
+            for layr in self.layers:
+                await asyncio.sleep(0)
+                count += await layr.getPropCount(formname, propname)
+            return count
+
+        norm, info = prop.type.norm(valu)
+
+        for layr in self.layers:
+            await asyncio.sleep(0)
+            count += layr.getPropValuCount(formname, propname, prop.type.stortype, norm)
+
+        return count
+
+    async def getTagPropCount(self, form, tag, propname, valu=s_common.novalu):
+        prop = self.core.model.getTagProp(propname)
+        if prop is None:
+            mesg = f'No tag property named {propname}'
+            raise s_exc.NoSuchTagProp(name=propname, mesg=mesg)
+
+        count = 0
+
+        if valu is s_common.novalu:
+            for layr in self.layers:
+                await asyncio.sleep(0)
+                count += await layr.getTagPropCount(form, tag, prop.name)
+            return count
+
+        norm, info = prop.type.norm(valu)
+
+        for layr in self.layers:
+            await asyncio.sleep(0)
+            count += layr.getTagPropValuCount(form, tag, prop.name, prop.type.stortype, norm)
+
+        return count
+
+    async def getPropArrayCount(self, propname, valu=s_common.novalu):
+        prop = self.core.model.prop(propname)
+        if prop is None:
+            mesg = f'No property named {propname}'
+            raise s_exc.NoSuchProp(mesg=mesg)
+
+        if not prop.type.isarray:
+            mesg = f'Property is not an array type: {prop.type.name}.'
+            raise s_exc.BadTypeValu(mesg=mesg)
+
+        count = 0
+        formname = None
+        propname = None
+
+        if prop.isform:
+            formname = prop.name
+        else:
+            propname = prop.name
+            if not prop.isuniv:
+                formname = prop.form.name
+
+        if valu is s_common.novalu:
+            for layr in self.layers:
+                await asyncio.sleep(0)
+                count += await layr.getPropArrayCount(formname, propname)
+            return count
+
+        atyp = prop.type.arraytype
+        norm, info = atyp.norm(valu)
+
+        for layr in self.layers:
+            await asyncio.sleep(0)
+            count += layr.getPropArrayValuCount(formname, propname, atyp.stortype, norm)
+
+        return count
+
     async def getEdgeVerbs(self):
 
         async with await s_spooled.Set.anit(dirn=self.core.dirn, cell=self.core) as vset:
@@ -515,22 +620,20 @@ class View(s_nexus.Pusher):  # type: ignore
 
         mode = opts.get('mode', 'storm')
         editformat = opts.get('editformat', 'nodeedits')
-        if editformat not in ('nodeedits', 'splices', 'count', 'none'):
-            raise s_exc.BadConfValu(mesg='editformat')
-
-        if editformat == 'splices':
-            s_common.deprdate('storm option editformat=splices', s_common._splicedepr)
+        if editformat not in ('nodeedits', 'count', 'none'):
+            raise s_exc.BadConfValu(mesg=f'invalid edit format, got {editformat}', name='editformat', valu=editformat)
 
         texthash = hashlib.md5(text.encode(errors='surrogatepass'), usedforsecurity=False).hexdigest()
 
         async def runStorm():
             cancelled = False
             tick = s_common.now()
+            abstick = s_common.mononow()
             count = 0
             try:
 
                 # Always start with an init message.
-                await chan.put(('init', {'tick': tick, 'text': text,
+                await chan.put(('init', {'tick': tick, 'text': text, 'abstick': abstick,
                                          'hash': texthash, 'task': synt.iden}))
 
                 # Try text parsing. If this fails, we won't be able to get a storm
@@ -582,9 +685,10 @@ class View(s_nexus.Pusher):  # type: ignore
 
             finally:
                 if not cancelled:
-                    tock = s_common.now()
-                    took = tock - tick
-                    await chan.put(('fini', {'tock': tock, 'took': took, 'count': count}))
+                    abstock = s_common.mononow()
+                    abstook = abstock - abstick
+                    tock = tick + abstook
+                    await chan.put(('fini', {'tock': tock, 'abstock': abstock, 'took': abstook, 'count': count, }))
 
         await synt.worker(runStorm(), name='runstorm')
 
@@ -611,18 +715,11 @@ class View(s_nexus.Pusher):  # type: ignore
                 if editformat == 'none':
                     continue
 
-                if editformat == 'count':
-                    count = sum(len(edit[2]) for edit in mesg[1].get('edits', ()))
-                    mesg = ('node:edits:count', {'count': count})
-                    yield mesg
-                    continue
-
-                assert editformat == 'splices'
+                assert editformat == 'count'
 
-                nodeedits = mesg[1].get('edits', [()])
-                async for _, splice in self.layers[0].makeSplices(0, nodeedits, None):
-                    if not show or splice[0] in show:
-                        yield splice
+                count = sum(len(edit[2]) for edit in mesg[1].get('edits', ()))
+                mesg = ('node:edits:count', {'count': count})
+                yield mesg
                 continue
 
             if kind == 'fini':
@@ -672,11 +769,7 @@ class View(s_nexus.Pusher):  # type: ignore
 
         if name == 'parent':
 
-            parent = self.core.getView(valu)
-            if parent is None:
-                mesg = 'The parent view must already exist.'
-                raise s_exc.NoSuchView(mesg=mesg)
-
+            parent = self.core.reqView(valu, mesg='The parent view must already exist.')
             if parent.iden == self.iden:
                 mesg = 'A view may not have parent set to itself.'
                 raise s_exc.BadArg(mesg=mesg)

synapse/models/base.py

@@ -87,10 +87,10 @@ class BaseModule(s_module.CoreModule):
                 ('graph:timeedge', ('timeedge', {}), {
                     'doc': 'A generic digraph time edge to show relationships outside the model.'}),
 
-                ('meta:priority', ('int', {'enums': prioenums}), {
+                ('meta:priority', ('int', {'enums': prioenums, 'enums:strict': False}), {
                     'doc': 'A generic priority enumeration.'}),
 
-                ('meta:severity', ('int', {'enums': prioenums}), {
+                ('meta:severity', ('int', {'enums': prioenums, 'enums:strict': False}), {
                     'doc': 'A generic severity enumeration.'}),
 
                 ('meta:sophistication', ('int', {'enums': sophenums}), {