synapse 2.220.0__py311-none-any.whl → 2.222.0__py311-none-any.whl

synapse/cortex.py

@@ -624,7 +624,8 @@ class CoreApi(s_cell.CellApi):
         Returns:
             AsyncIterator[Tuple(buid, valu)]
         '''
-        self.user.confirm(('layer', 'lift', layriden))
+        if not self.user.allowed(('layer', 'lift', layriden)):
+            self.user.confirm(('layer', 'read', layriden))
         async for item in self.cell.iterFormRows(layriden, form, stortype=stortype, startvalu=startvalu):
             yield item
 
@@ -642,7 +643,8 @@ class CoreApi(s_cell.CellApi):
         Returns:
             AsyncIterator[Tuple(buid, valu)]
         '''
-        self.user.confirm(('layer', 'lift', layriden))
+        if not self.user.allowed(('layer', 'lift', layriden)):
+            self.user.confirm(('layer', 'read', layriden))
         async for item in self.cell.iterPropRows(layriden, form, prop, stortype=stortype, startvalu=startvalu):
             yield item
 
@@ -659,7 +661,8 @@ class CoreApi(s_cell.CellApi):
         Returns:
             AsyncIterator[Tuple(buid, valu)]
         '''
-        self.user.confirm(('layer', 'lift', layriden))
+        if not self.user.allowed(('layer', 'lift', layriden)):
+            self.user.confirm(('layer', 'read', layriden))
         async for item in self.cell.iterUnivRows(layriden, prop, stortype=stortype, startvalu=startvalu):
             yield item
 
@@ -680,7 +683,8 @@ class CoreApi(s_cell.CellApi):
             This yields (buid, (tagvalu, form)) instead of just buid, valu in order to allow resuming an interrupted
             call by feeding the last value retrieved into starttupl
         '''
-        self.user.confirm(('layer', 'lift', layriden))
+        if not self.user.allowed(('layer', 'lift', layriden)):
+            self.user.confirm(('layer', 'read', layriden))
         async for item in self.cell.iterTagRows(layriden, tag, form=form, starttupl=starttupl):
             yield item
 
@@ -699,7 +703,8 @@ class CoreApi(s_cell.CellApi):
         Returns:
             AsyncIterator[Tuple(buid, valu)]
         '''
-        self.user.confirm(('layer', 'lift', layriden))
+        if not self.user.allowed(('layer', 'lift', layriden)):
+            self.user.confirm(('layer', 'read', layriden))
         async for item in self.cell.iterTagPropRows(layriden, tag, prop, form=form, stortype=stortype,
                                                     startvalu=startvalu):
             yield item
@@ -1366,6 +1371,30 @@ class Cortex(s_oauth.OAuthMixin, s_cell.Cell):  # type: ignore
 
     def _initCorePerms(self):
         self._cortex_permdefs.extend((
+            {'perm': ('axon', 'upload'), 'gate': 'cortex',
+             'desc': 'Controls the ability to upload a file to the Axon.'},
+            {'perm': ('axon', 'get'), 'gate': 'cortex',
+             'desc': 'Controls the ability to retrieve a file from the Axon.'},
+            {'perm': ('axon', 'has'), 'gate': 'cortex',
+             'desc': 'Controls the ability to check if the Axon contains a file.'},
+            {'perm': ('axon', 'del'), 'gate': 'cortex',
+             'desc': 'Controls the ability to remove a file from the Axon.'},
+
+            {'perm': ('layer', 'add'), 'gate': 'cortex',
+             'desc': 'Controls the ability to add Layers to the cortex.'},
+            {'perm': ('layer', 'del'), 'gate': 'cortex',
+             'desc': 'Controls the ability to remove Layers from the cortex.'},
+            {'perm': ('layer', 'read'), 'gate': 'layer',
+             'desc': 'Controls the ability to read/lift from a Layer.'},
+            {'perm': ('layer', 'read', '<iden>'), 'gate': 'cortex',
+             'desc': 'Controls the ability to read/lift from a specific Layer.'},
+            {'perm': ('layer', 'set', '<name>'), 'gate': 'layer',
+             'desc': 'Controls the ability to configure properties of a Layer.'},
+            {'perm': ('layer', 'write'), 'gate': 'layer',
+             'desc': 'Controls the ability to write to a Layer.'},
+            {'perm': ('layer', 'write', '<iden>'), 'gate': 'cortex',
+             'desc': 'Controls the ability to write to a specific Layer.'},
+
             {'perm': ('model', 'form', 'add'), 'gate': 'cortex',
              'desc': 'Controls access to adding extended model forms.'},
             {'perm': ('model', 'form', 'add', '<form>'), 'gate': 'cortex',
@@ -1519,15 +1548,6 @@ class Cortex(s_oauth.OAuthMixin, s_cell.Cell):  # type: ignore
             {'perm': ('view', 'set', '<setting>'), 'gate': 'view',
              'desc': 'Controls access to change view settings.',
              'ex': 'view.set.name'},
-
-            {'perm': ('axon', 'upload'), 'gate': 'cortex',
-             'desc': 'Controls the ability to upload a file to the Axon.'},
-            {'perm': ('axon', 'get'), 'gate': 'cortex',
-             'desc': 'Controls the ability to retrieve a file from the Axon.'},
-            {'perm': ('axon', 'has'), 'gate': 'cortex',
-             'desc': 'Controls the ability to check if the Axon contains a file.'},
-            {'perm': ('axon', 'del'), 'gate': 'cortex',
-             'desc': 'Controls the ability to remove a file from the Axon.'},
         ))
         for pdef in self._cortex_permdefs:
             s_schemas.reqValidPermDef(pdef)

synapse/data/lark/storm.lark

@@ -238,10 +238,10 @@ liftreverse: _REVERSE "(" (liftformtag | liftpropby | liftprop | liftbyarray | l
 
 _DEREF.3:  /\*(?=\$)/
 
-liftformtag: ((PROPS | UNIVNAME | WILDPROPS) | _DEREF _varvalu) tagname [_cmpr _valu]
-liftpropby: ((PROPS | EMBEDPROPS | UNIVNAME) | _DEREF _varvalu) _cmpr _valu
-liftprop: ((PROPS | UNIVNAME | WILDPROPS) | _DEREF _varvalu)
-liftbyarray: ((PROPS | EMBEDPROPS | UNIVNAME) | _DEREF _varvalu) "*[" _safe_cmpr _valu "]"
+liftformtag: (PROPS | UNIVNAME | WILDPROPS | derefprops) tagname [_cmpr _valu]
+liftpropby: (PROPS | EMBEDPROPS | UNIVNAME | derefprops) _cmpr _valu
+liftprop: (PROPS | UNIVNAME | WILDPROPS | derefprops)
+liftbyarray: (PROPS | EMBEDPROPS | UNIVNAME | derefprops) "*[" _safe_cmpr _valu "]"
 lifttagtag: (_HASH | _HASHSPACE) tagname [_cmpr _valu]
 liftbytag: (tagname | tagnamewithspace) [_cmpr _valu]
 liftbytagprop: (tagprop | tagpropwithspace) [_cmpr _valu]
@@ -249,7 +249,7 @@ liftbyformtagprop: formtagprop [_cmpr _valu]
 
 tagprop: tagname _COLONNOSPACE (BASEPROP | _varvalu)
 tagpropwithspace: tagnamewithspace _COLONNOSPACE (BASEPROP | _varvalu) -> tagprop
-formtagprop: ((PROPS | UNIVNAME | WILDPROPS) | _DEREF _varvalu) tagname _COLONNOSPACE (BASEPROP | _varvalu)
+formtagprop: (PROPS | UNIVNAME | WILDPROPS | derefprops) tagname _COLONNOSPACE (BASEPROP | _varvalu)
 _COLONNOSPACE.2: /(?<!\s):/
 
 _funcarg: (VARTOKN [EQNOSPACE _valu])
@@ -484,7 +484,7 @@ EMBEDPROPS.2: /[a-z_][a-z0-9_]*(:[a-z0-9_]+)+((\:\:|\:|\.)[a-z0-9_]+)*(?![:.a-z0
 UNIVNAME.2: /(?<=^|[\s\|\{\(\[+=-])\.[a-z_][a-z0-9_]*([:.][a-z0-9_]+)*/
 univprop:  UNIVNAME | "." _varvalu
 // A full property or a universal property
-formname: PROPS | _DEREF _varvalu
+formname: PROPS | derefprops
 // A relative property
 relprop: RELNAME | _COLONDOLLAR _varvaluatom
 
@@ -494,6 +494,9 @@ RELNAME: /(?<!\w):\.?[a-z_][a-z0-9_]*(?:(\:\:|\:|\.)[a-z_][a-z0-9_]*)*/
 // Similar to PROPS but does not require a colon
 BASEPROP: /[a-z_][a-z0-9_]*(?:(\:\:|\:|\.)[a-z_][a-z0-9_]*)*/
 
+// Derefed variable for prop names
+derefprops: _DEREF _varvalu
+
 // The entry point for a $(...) expression.  The initial dollar sign is now optional
 _dollarexprs: "$"? dollaroper
 

synapse/lib/ast.py

@@ -2,7 +2,6 @@ import types
 import asyncio
 import decimal
 import fnmatch
-import hashlib
 import logging
 import binascii
 import itertools
@@ -1833,7 +1832,7 @@ class LiftProp(LiftOper):
 
         assert len(self.kids) == 1
 
-        name = await tostr(await self.kids[0].compute(runt, path))
+        name = await self.kids[0].compute(runt, path)
 
         prop = runt.model.props.get(name)
         if prop is not None:
@@ -4029,6 +4028,13 @@ class FormName(Value):
     async def compute(self, runt, path):
         return await self.kids[0].compute(runt, path)
 
+class DerefProps(Value):
+    async def compute(self, runt, path):
+        valu = await toprim(await self.kids[0].compute(runt, path))
+        if (exc := await s_stormtypes.typeerr(valu, str)) is not None:
+            raise self.kids[0].addExcInfo(exc)
+        return valu
+
 class RelProp(PropName):
     pass
 

synapse/lib/layer.py

@@ -119,6 +119,7 @@ class LayerApi(s_cell.CellApi):
 
         self.layr = layr
         self.liftperm = ('layer', 'lift', self.layr.iden)
+        self.readperm = ('layer', 'read', self.layr.iden)
         self.writeperm = ('layer', 'write', self.layr.iden)
 
     async def iterLayerNodeEdits(self):
@@ -126,7 +127,8 @@ class LayerApi(s_cell.CellApi):
         Scan the full layer and yield artificial nodeedit sets.
         '''
 
-        await self._reqUserAllowed(self.liftperm)
+        if not self.allowed(self.liftperm):
+            await self._reqUserAllowed(self.readperm)
         async for item in self.layr.iterLayerNodeEdits():
             yield item
             await asyncio.sleep(0)
@@ -165,13 +167,15 @@ class LayerApi(s_cell.CellApi):
 
         Once caught up with storage, yield them in realtime.
         '''
-        await self._reqUserAllowed(self.liftperm)
+        if not self.allowed(self.liftperm):
+            await self._reqUserAllowed(self.readperm)
         async for item in self.layr.syncNodeEdits(offs, wait=wait, reverse=reverse):
             yield item
             await asyncio.sleep(0)
 
     async def syncNodeEdits2(self, offs, wait=True):
-        await self._reqUserAllowed(self.liftperm)
+        if not self.allowed(self.liftperm):
+            await self._reqUserAllowed(self.readperm)
         async for item in self.layr.syncNodeEdits2(offs, wait=wait):
             yield item
             await asyncio.sleep(0)
@@ -180,18 +184,21 @@ class LayerApi(s_cell.CellApi):
         '''
         Returns what will be the *next* nodeedit log index.
         '''
-        await self._reqUserAllowed(self.liftperm)
+        if not self.allowed(self.liftperm):
+            await self._reqUserAllowed(self.readperm)
         return await self.layr.getEditIndx()
 
     async def getEditSize(self):
         '''
         Return the total number of (edits, meta) pairs in the layer changelog.
         '''
-        await self._reqUserAllowed(self.liftperm)
+        if not self.allowed(self.liftperm):
+            await self._reqUserAllowed(self.readperm)
         return await self.layr.getEditSize()
 
     async def getIden(self):
-        await self._reqUserAllowed(self.liftperm)
+        if not self.allowed(self.liftperm):
+            await self._reqUserAllowed(self.readperm)
         return self.layr.iden
 
 BUID_CACHE_SIZE = 10000
@@ -3350,7 +3357,99 @@ class Layer(s_nexus.Pusher):
         nodeedits = [(buid, newp_formname, [set_edit])]
 
         _, changes = await self.saveNodeEdits(nodeedits, meta)
-        return bool(changes[0][2])
+        return any(c[2] for c in changes)
+
+    async def delStorNode(self, buid, meta):
+        '''
+        Delete all node information in this layer.
+
+        Deletes props, tagprops, tags, n1edges, n2edges, nodedata, and node valu.
+        '''
+        sode = self._getStorNode(buid)
+        if sode is None:
+            return False
+
+        formname = sode.get('form')
+
+        edits = []
+        nodeedits = []
+
+        for propname, propvalu in sode.get('props', {}).items():
+            edits.append(
+                (EDIT_PROP_DEL, (propname, *propvalu), ())
+            )
+
+        for tagname, tprops in sode.get('tagprops', {}).items():
+            for propname, propvalu in tprops.items():
+                edits.append(
+                    (EDIT_TAGPROP_DEL, (tagname, propname, *propvalu), ())
+                )
+
+        for tagname, tagvalu in sode.get('tags', {}).items():
+            edits.append(
+                (EDIT_TAG_DEL, (tagname, tagvalu), ())
+            )
+
+        # EDIT_NODE_DEL will delete all nodedata and n1 edges if there is a valu in the sode
+        if (valu := sode.get('valu')):
+            edits.append(
+                (EDIT_NODE_DEL, valu, ())
+            )
+        else:
+            async for item in self.iterNodeData(buid):
+                edits.append(
+                    (EDIT_NODEDATA_DEL, item, ())
+                )
+                await asyncio.sleep(0)
+
+            async for edge in self.iterNodeEdgesN1(buid):
+                edits.append(
+                    (EDIT_EDGE_DEL, edge, ())
+                )
+                await asyncio.sleep(0)
+
+        nodeedits.append((buid, formname, edits))
+
+        n2edges = {}
+        n1iden = s_common.ehex(buid)
+        async for verb, n2iden in self.iterNodeEdgesN2(buid):
+            n2edges.setdefault(n2iden, []).append((verb, n1iden))
+            await asyncio.sleep(0)
+
+        n2forms = {}
+        @s_cache.memoize()
+        def getN2Form(n2iden):
+            buid = s_common.uhex(n2iden)
+            if (form := n2forms.get(buid)) is not None: # pragma: no cover
+                return form
+
+            n2sode = self._getStorNode(buid)
+            form = n2sode.get('form')
+            n2forms[buid] = form
+            return form
+
+        changed = False
+
+        async def batchEdits(size=1000):
+            if len(nodeedits) < size:
+                return changed
+
+            _, changes = await self.saveNodeEdits(nodeedits, meta)
+
+            nodeedits.clear()
+
+            if changed: # pragma: no cover
+                return changed
+
+            return any(c[2] for c in changes)
+
+        for n2iden, edges in n2edges.items():
+            edits = [(EDIT_EDGE_DEL, edge, ()) for edge in edges]
+            nodeedits.append((s_common.uhex(n2iden), getN2Form(n2iden), edits))
+
+            changed = await batchEdits()
+
+        return await batchEdits(size=1)
 
     async def delStorNodeProp(self, buid, prop, meta):
         pprop = self.core.model.reqProp(prop)
@@ -3363,7 +3462,49 @@ class Layer(s_nexus.Pusher):
         nodeedits = [(buid, oldp_formname, [del_edit])]
 
         _, changes = await self.saveNodeEdits(nodeedits, meta)
-        return bool(changes[0][2])
+        return any(c[2] for c in changes)
+
+    async def delNodeData(self, buid, meta, name=None):
+        '''
+        Delete nodedata from a node in this layer. If name is not specified, delete all nodedata.
+        '''
+        sode = self._getStorNode(buid)
+        if sode is None: # pragma: no cover
+            return False
+
+        edits = []
+        if name is None:
+            async for item in self.iterNodeData(buid):
+                edits.append((EDIT_NODEDATA_DEL, item, ()))
+                await asyncio.sleep(0)
+
+        elif await self.hasNodeData(buid, name):
+            edits.append((EDIT_NODEDATA_DEL, (name, None), ()))
+
+        if not edits:
+            return False
+
+        nodeedits = [(buid, sode.get('form'), edits)]
+
+        _, changes = await self.saveNodeEdits(nodeedits, meta)
+        return any(c[2] for c in changes)
+
+    async def delEdge(self, n1buid, verb, n2buid, meta):
+        sode = self._getStorNode(n1buid)
+        if sode is None: # pragma: no cover
+            return False
+
+        if not await self.hasNodeEdge(n1buid, verb, n2buid): # pragma: no cover
+            return False
+
+        edits = [
+            (EDIT_EDGE_DEL, (verb, s_common.ehex(n2buid)), ())
+        ]
+
+        nodeedits = [(n1buid, sode.get('form'), edits)]
+
+        _, changes = await self.saveNodeEdits(nodeedits, meta)
+        return any(c[2] for c in changes)
 
     async def storNodeEdits(self, nodeedits, meta):
 

synapse/lib/parser.py

@@ -669,6 +669,7 @@ ruleClassMap = {
     'condsetoper': s_ast.CondSetOper,
     'condtrysetoper': lambda astinfo, kids: s_ast.CondSetOper(astinfo, kids, errok=True),
     'condsubq': s_ast.SubqCond,
+    'derefprops': s_ast.DerefProps,
     'dollarexpr': s_ast.DollarExpr,
     'edgeaddn1': s_ast.EditEdgeAdd,
     'edgedeln1': s_ast.EditEdgeDel,

synapse/lib/rstorm.py

@@ -1,8 +1,12 @@
 import os
+import sys
 import copy
+import shlex
 import pprint
 import logging
+import argparse
 import contextlib
+import subprocess
 import collections
 
 import vcr
@@ -25,7 +29,7 @@ import synapse.tools.storm as s_storm
 import synapse.tools.genpkg as s_genpkg
 
 
-re_directive = regex.compile(r'^\.\.\s(storm.*|[^:])::(?:\s(.*)$|$)')
+re_directive = regex.compile(r'^\.\.\s(shell.*|storm.*|[^:])::(?:\s(.*)$|$)')
 
 logger = logging.getLogger(__name__)
 
@@ -48,7 +52,6 @@ class OutPutRst(s_output.OutPutStr):
 
         return s_output.OutPutStr.printf(self, mesg, addnl)
 
-
 class StormOutput(s_cmds_cortex.StormCmd):
     '''
     Produce standard output from a stream of storm runtime messages.
@@ -329,6 +332,8 @@ class StormRst(s_base.Base):
         self.core = None
 
         self.handlers = {
+            'shell': self._handleShell,
+            'shell-env': self._handleShellEnv,
             'storm': self._handleStorm,
             'storm-cli': self._handleStormCli,
             'storm-pkg': self._handleStormPkg,
@@ -339,6 +344,7 @@ class StormRst(s_base.Base):
             'storm-cortex': self._handleStormCortex,
             'storm-envvar': self._handleStormEnvVar,
             'storm-expect': self._handleStormExpect,
+            'storm-python-path': self._handlePythonPath,
             'storm-multiline': self._handleStormMultiline,
             'storm-mock-http': self._handleStormMockHttp,
             'storm-vcr-opts': self._handleStormVcrOpts,
@@ -369,6 +375,22 @@ class StormRst(s_base.Base):
             raise s_exc.NoSuchName(mesg=f'The {directive} directive is not supported', directive=directive)
         return handler
 
+    async def _handlePythonPath(self, text):
+        '''
+        Add the text to sys.path.
+
+        Args:
+            text: The path to add.
+        '''
+        if not os.path.isdir(text):
+            raise s_exc.NoSuchDir(mesg=f'The path {text} is not a directory', path=text)
+        if text not in sys.path:
+            logger.debug(f'Inserting {text} into sys.path')
+            sys.path.insert(0, text)
+            def onfini():
+                sys.path.remove(text)
+            self.onfini(onfini)
+
     async def _handleStorm(self, text):
         '''
         Run a Storm command and generate text from the output.
@@ -596,6 +618,65 @@ class StormRst(s_base.Base):
             raise s_exc.NoSuchCtor(mesg=f'Failed to get callback "{text}"', ctor=text)
         self.context['storm-vcr-callback'] = cb
 
+    async def _handleShell(self, text):
+        '''
+        Execute shell with the supplied arguments.
+        '''
+        parser = argparse.ArgumentParser(add_help=False)
+        parser.add_argument('--include-stderr', action='store_true', help='Include stderr in output.')
+        parser.add_argument('--hide-query', action='store_true', help='Do not include the command in the output.')
+        parser.add_argument('--fail-ok', action='store_true', help='Non-zero return values are non-fatal.')
+        opts, args = parser.parse_known_args(shlex.split(text))
+
+        # Remove any command line arguments
+        query = text
+        query = query.replace('--include-stderr', '')
+        query = query.replace('--hide-query', '')
+        query = query.replace('--fail-ok', '')
+        query = query.strip()
+
+        env = dict(os.environ)
+        env.update(self.context.get('shell-env', {}))
+
+        stderr = None
+        if opts.include_stderr:
+            stderr = subprocess.STDOUT
+
+        proc = subprocess.run(args, stdout=subprocess.PIPE, stderr=stderr, env=env, text=True)
+        if proc.returncode != 0 and not opts.fail_ok:
+            mesg = f'Error when executing shell directive: {text} (rv: {proc.returncode})'
+            raise s_exc.SynErr(mesg=mesg)
+
+        self._printf('::\n\n')
+
+        if not opts.hide_query:
+            self._printf(f'  {query}\n\n')
+
+        for line in proc.stdout.splitlines():
+            self._printf(f'  {line}\n')
+
+        self._printf('\n\n')
+
+    async def _handleShellEnv(self, text):
+        '''
+        Env to use in subsequent shell queries.
+
+        Args:
+            text (str): [KEY=VALUE ...]
+                Note: No arguments will reset the shell environment.
+        '''
+        text = text.strip()
+        if not text:
+            return self.context.pop('shell-env')
+
+        env = {}
+
+        for item in text.split(' '):
+            key, val = item.split('=')
+            env[key] = val
+
+        self.context['shell-env'] = env
+
     async def _readline(self, line):
 
         match = re_directive.match(line)

synapse/lib/schemas.py

@@ -816,6 +816,10 @@ _reqValidPkgdefSchema = {
                     'items': {'type': 'array',
                         'items': {'type': 'string'}},
                 },
+                'asroot:ondeny:import': {
+                    'type': 'string',
+                    'enum': ['allow', 'warn', 'deny'],
+                },
             },
             'additionalProperties': True,
             'required': ['name', 'storm']

synapse/lib/snap.py

@@ -1123,22 +1123,30 @@ class Snap(s_base.Base):
             mesg = f'No property named "{full}".'
             raise s_exc.NoSuchProp(mesg=mesg)
 
-        if isinstance(valu, dict) and isinstance(prop.type, s_types.Guid) and cmpr == '=':
-            if prop.isform:
-                if (node := await self._getGuidNodeByDict(prop, valu)) is not None:
-                    yield node
-                return
+        if isinstance(valu, dict) and isinstance(prop.type, s_types.Guid) and cmpr in ('=', '?='):
+            excignore = ()
+            if cmpr == '?=':
+                excignore = (s_exc.BadTypeValu,)
 
-            fname = prop.type.name
-            if (form := prop.modl.form(fname)) is None:
-                mesg = f'The property "{full}" type "{fname}" is not a form and cannot be lifted using a dictionary.'
-                raise s_exc.BadTypeValu(mesg=mesg)
+            try:
+                if prop.isform:
+                    if (node := await self._getGuidNodeByDict(prop, valu)) is not None:
+                        yield node
+                    return
 
-            if (node := await self._getGuidNodeByDict(form, valu)) is None:
-                return
+                fname = prop.type.name
+                if (form := prop.modl.form(fname)) is None:
+                    mesg = f'The property "{full}" type "{fname}" is not a form and cannot be lifted using a dictionary.'
+                    raise s_exc.BadTypeValu(mesg=mesg)
 
-            norm = False
-            valu = node.ndef[1]
+                if (node := await self._getGuidNodeByDict(form, valu)) is None:
+                    return
+
+                norm = False
+                valu = node.ndef[1]
+
+            except excignore:
+                return
 
         if norm:
             cmprvals = prop.type.getStorCmprs(cmpr, valu)

synapse/lib/stormhttp.py

@@ -90,7 +90,7 @@ class LibHttp(s_stormtypes.Lib):
     For APIs that accept an ssl_opts argument, the dictionary may contain the following values::
 
         ({
-            'verify': <bool> - Perform SSL/TLS verification. Is overridden by the ssl_verify argument.
+            'verify': <boolean> - Perform SSL/TLS verification. Is overridden by the ssl_verify argument.
             'client_cert': <str> - PEM encoded full chain certificate for use in mTLS.
             'client_key': <str> - PEM encoded key for use in mTLS. Alternatively, can be included in client_cert.
             'ca_cert': <str> - A PEM encoded full chain CA certificate for use when verifying the request.
@@ -116,9 +116,9 @@ class LibHttp(s_stormtypes.Lib):
                        'default': None},
                       {'name': 'timeout', 'type': 'int', 'desc': 'Total timeout for the request in seconds.',
                        'default': 300},
-                      {'name': 'allow_redirects', 'type': 'bool', 'desc': 'If set to false, do not follow redirects.',
+                      {'name': 'allow_redirects', 'type': 'boolean', 'desc': 'If set to false, do not follow redirects.',
                        'default': True},
-                      {'name': 'proxy', 'type': ['bool', 'str'],
+                      {'name': 'proxy', 'type': ['boolean', 'str'],
                        'desc': 'Configure proxy usage. See $lib.inet.http help for additional details.', 'default': True},
                       {'name': 'ssl_opts', 'type': 'dict',
                        'desc': 'Optional SSL/TLS options. See $lib.inet.http help for additional details.',
@@ -141,7 +141,7 @@ class LibHttp(s_stormtypes.Lib):
                        'default': None},
                       {'name': 'timeout', 'type': 'int', 'desc': 'Total timeout for the request in seconds.',
                        'default': 300},
-                      {'name': 'allow_redirects', 'type': 'bool', 'desc': 'If set to false, do not follow redirects.',
+                      {'name': 'allow_redirects', 'type': 'boolean', 'desc': 'If set to false, do not follow redirects.',
                        'default': True},
                       {'name': 'fields', 'type': 'list',
                        'desc': 'A list of info dictionaries containing the name, value or sha256, '
@@ -150,7 +150,7 @@ class LibHttp(s_stormtypes.Lib):
                                'and the corresponding file will be uploaded as the value for '
                                'the field.',
                        'default': None},
-                      {'name': 'proxy', 'type': ['bool', 'str'],
+                      {'name': 'proxy', 'type': ['boolean', 'str'],
                        'desc': 'Configure proxy usage. See $lib.inet.http help for additional details.', 'default': True},
                       {'name': 'ssl_opts', 'type': 'dict',
                        'desc': 'Optional SSL/TLS options. See $lib.inet.http help for additional details.',
@@ -170,9 +170,9 @@ class LibHttp(s_stormtypes.Lib):
                        'default': None},
                       {'name': 'timeout', 'type': 'int', 'desc': 'Total timeout for the request in seconds.',
                        'default': 300, },
-                      {'name': 'allow_redirects', 'type': 'bool', 'desc': 'If set to true, follow redirects.',
+                      {'name': 'allow_redirects', 'type': 'boolean', 'desc': 'If set to true, follow redirects.',
                        'default': False},
-                      {'name': 'proxy', 'type': ['bool', 'str'],
+                      {'name': 'proxy', 'type': ['boolean', 'str'],
                        'desc': 'Configure proxy usage. See $lib.inet.http help for additional details.', 'default': True},
                       {'name': 'ssl_opts', 'type': 'dict',
                        'desc': 'Optional SSL/TLS options. See $lib.inet.http help for additional details.',
@@ -196,7 +196,7 @@ class LibHttp(s_stormtypes.Lib):
                        'default': None},
                       {'name': 'timeout', 'type': 'int', 'desc': 'Total timeout for the request in seconds.',
                        'default': 300},
-                      {'name': 'allow_redirects', 'type': 'bool', 'desc': 'If set to false, do not follow redirects.',
+                      {'name': 'allow_redirects', 'type': 'boolean', 'desc': 'If set to false, do not follow redirects.',
                        'default': True},
                       {'name': 'fields', 'type': 'list',
                        'desc': 'A list of info dictionaries containing the name, value or sha256, '
@@ -205,7 +205,7 @@ class LibHttp(s_stormtypes.Lib):
                                'and the corresponding file will be uploaded as the value for '
                                'the field.',
                        'default': None},
-                      {'name': 'proxy', 'type': ['bool', 'str'],
+                      {'name': 'proxy', 'type': ['boolean', 'str'],
                        'desc': 'Configure proxy usage. See $lib.inet.http help for additional details.', 'default': True},
                       {'name': 'ssl_opts', 'type': 'dict',
                        'desc': 'Optional SSL/TLS options. See $lib.inet.http help for additional details.',
@@ -226,7 +226,7 @@ class LibHttp(s_stormtypes.Lib):
                        'default': 300},
                       {'name': 'params', 'type': 'dict', 'desc': 'Optional parameters which may be passed to the connection request.',
                        'default': None},
-                      {'name': 'proxy', 'type': ['bool', 'str'],
+                      {'name': 'proxy', 'type': ['boolean', 'str'],
                        'desc': 'Configure proxy usage. See $lib.inet.http help for additional details.', 'default': True},
                       {'name': 'ssl_opts', 'type': 'dict',
                        'desc': 'Optional SSL/TLS options. See $lib.inet.http help for additional details.',