synapse 2.134.0__py310-none-any.whl → 2.136.0__py310-none-any.whl

synapse/lib/stormtypes.py

@@ -953,7 +953,6 @@ class LibTags(Lib):
             Normalize and prefix a list of syn:tag:part values so they can be applied.
 
             Examples:
-
                 Add tag prefixes and then use them to tag nodes::
 
                     $tags = $lib.tags.prefix($result.tags, vtx.visi)
@@ -1506,6 +1505,7 @@ class LibBase(Lib):
 
     @stormfunc(readonly=True)
     async def _min(self, *args):
+        args = await toprim(args)
         # allow passing in a list of ints
         vals = []
         for arg in args:
@@ -1519,6 +1519,7 @@ class LibBase(Lib):
 
     @stormfunc(readonly=True)
     async def _max(self, *args):
+        args = await toprim(args)
         # allow passing in a list of ints
         vals = []
         for arg in args:
@@ -1938,6 +1939,18 @@ class LibAxon(Lib):
                  'returns': {'type': 'dict', 'desc': 'A dictionary containing runtime data about the Axon.'}}},
     )
     _storm_lib_path = ('axon',)
+    _storm_lib_perms = (
+        {'perm': ('storm', 'lib', 'axon', 'del'), 'gate': 'cortex',
+            'desc': 'Controls the ability to remove a file from the Axon.'},
+        {'perm': ('storm', 'lib', 'axon', 'get'), 'gate': 'cortex',
+            'desc': 'Controls the ability to retrieve a file from the Axon.'},
+        {'perm': ('storm', 'lib', 'axon', 'has'), 'gate': 'cortex',
+            'desc': 'Controls the ability to check if the Axon contains a file.'},
+        {'perm': ('storm', 'lib', 'axon', 'wget'), 'gate': 'cortex',
+            'desc': 'Controls the ability to retrieve a file from URL and store it in the Axon.'},
+        {'perm': ('storm', 'lib', 'axon', 'wput'), 'gate': 'cortex',
+            'desc': 'Controls the ability to push a file from the Axon to a URL.'},
+    )
 
     def getObjLocals(self):
         return {
@@ -3442,6 +3455,12 @@ class LibTelepath(Lib):
                   'returns': {'type': 'storm:proxy', 'desc': 'A object representing a Telepath Proxy.', }}},
     )
     _storm_lib_path = ('telepath',)
+    _storm_lib_perms = (
+        {'perm': ('storm', 'lib', 'telepath', 'open'), 'gate': 'cortex',
+         'desc': 'Controls the ability to open an arbitrary telepath URL. USE WITH CAUTION.'},
+        {'perm': ('storm', 'lib', 'telepath', 'open', '<scheme>'), 'gate': 'cortex',
+         'desc': 'Controls the ability to open a telepath URL with a specific URI scheme. USE WITH CAUTION.'},
+    )
 
     def getObjLocals(self):
         return {
@@ -3451,7 +3470,8 @@ class LibTelepath(Lib):
     async def _methTeleOpen(self, url):
         url = await tostr(url)
         scheme = url.split('://')[0]
-        self.runt.confirm(('lib', 'telepath', 'open', scheme))
+        if not self.runt.allowed(('lib', 'telepath', 'open', scheme)):
+            self.runt.confirm(('storm', 'lib', 'telepath', 'open', scheme))
         return Proxy(self.runt, await self.runt.getTeleProxy(url))
 
 @registry.registerType
@@ -4038,6 +4058,7 @@ class Bytes(Prim):
 
             Example:
                 Compress bytes with gzip::
+
                     $foo = $mybytez.gzip()''',
          'type': {'type': 'function', '_funcname': '_methGzip',
                   'returns': {'type': 'bytes', 'desc': 'The gzip compressed bytes.', }}},
@@ -4049,6 +4070,7 @@ class Bytes(Prim):
 
             Example:
                 Load bytes to a object::
+
                     $foo = $mybytez.json()''',
          'type': {'type': 'function', '_funcname': '_methJsonLoad',
                   'args': (
@@ -4082,8 +4104,9 @@ class Bytes(Prim):
             Unpack structures from bytes using python struct.unpack syntax.
 
             Examples:
-                # unpack 3 unsigned 16 bit integers in little endian format
-                ($x, $y, $z) = $byts.unpack("<HHH")
+                Unpack 3 unsigned 16 bit integers in little endian format::
+
+                    ($x, $y, $z) = $byts.unpack("<HHH")
             ''',
          'type': {'type': 'function', '_funcname': 'unpack',
                   'args': (
@@ -6317,7 +6340,7 @@ class Layer(Prim):
         formname = await tostr(formname, noneok=True)
 
         if formname is not None and self.runt.snap.core.model.form(formname) is None:
-            raise s_exc.NoSuchForm(formname)
+            raise s_exc.NoSuchForm.init(formname)
 
         iden = self.valu.get('iden')
         layr = self.runt.snap.core.getLayer(iden)
@@ -6379,7 +6402,8 @@ class Layer(Prim):
             raise s_exc.AuthDeny(mesg=mesg, user=self.runt.user.iden, username=self.runt.user.name)
 
         scheme = url.split('://')[0]
-        self.runt.confirm(('lib', 'telepath', 'open', scheme))
+        if not self.runt.allowed(('lib', 'telepath', 'open', scheme)):
+            self.runt.confirm(('storm', 'lib', 'telepath', 'open', scheme))
 
         async with await s_telepath.openurl(url):
             pass
@@ -6418,7 +6442,9 @@ class Layer(Prim):
             raise s_exc.AuthDeny(mesg=mesg, user=self.runt.user.iden, username=self.runt.user.name)
 
         scheme = url.split('://')[0]
-        self.runt.confirm(('lib', 'telepath', 'open', scheme))
+
+        if not self.runt.allowed(('lib', 'telepath', 'open', scheme)):
+            self.runt.confirm(('storm', 'lib', 'telepath', 'open', scheme))
 
         async with await s_telepath.openurl(url):
             pass
@@ -6540,10 +6566,11 @@ class Layer(Prim):
     async def _methLayerSet(self, name, valu):
         name = await tostr(name)
 
-        if name == 'name':
-            valu = await tostr(valu)
-        elif name == 'desc':
-            valu = await tostr(valu)
+        if name in ('name', 'desc'):
+            if valu is undef:
+                valu = None
+            else:
+                valu = await tostr(await toprim(valu), noneok=True)
         elif name == 'logedits':
             valu = await tobool(valu)
         else:
@@ -6899,12 +6926,12 @@ class View(Prim):
 
         name = await tostr(name)
 
-        if name == 'name':
-            valu = await tostr(valu)
-        elif name == 'desc':
-            valu = await tostr(valu)
-        elif name == 'parent':
-            valu = await tostr(valu)
+        if name in ('name', 'desc', 'parent'):
+            if valu is undef:
+                valu = None
+            else:
+                valu = await tostr(await toprim(valu), noneok=True)
+
         elif name == 'nomerge':
             valu = await tobool(valu)
         elif name == 'layers':
@@ -7396,8 +7423,8 @@ class LibUsers(Lib):
          'type': {'type': 'function', '_funcname': '_methUsersAdd',
                   'args': (
                       {'name': 'name', 'type': 'str', 'desc': 'The name of the user.', },
-                      {'name': 'passwd', 'type': 'str', 'desc': 'The users password.', 'default': None, },
-                      {'name': 'email', 'type': 'str', 'desc': 'The users email address.', 'default': None, },
+                      {'name': 'passwd', 'type': 'str', 'desc': "The user's password.", 'default': None, },
+                      {'name': 'email', 'type': 'str', 'desc': "The user's email address.", 'default': None, },
                       {'name': 'iden', 'type': 'str', 'desc': 'The iden to use to create the user.', 'default': None, }
                   ),
                   'returns': {'type': 'storm:auth:user',
@@ -7427,6 +7454,12 @@ class LibUsers(Lib):
                               'desc': 'The ``storm:auth:user`` object, or none if the user does not exist.', }}},
     )
     _storm_lib_path = ('auth', 'users')
+    _storm_lib_perms = (
+        {'perm': ('storm', 'lib', 'auth', 'users', 'add'), 'gate': 'cortex',
+         'desc': 'Controls the ability to add a user to the system. USE WITH CAUTION!'},
+        {'perm': ('storm', 'lib', 'auth', 'users', 'del'), 'gate': 'cortex',
+         'desc': 'Controls the ability to remove a user from the system. USE WITH CAUTION!'},
+    )
 
     def getObjLocals(self):
         return {
@@ -7454,7 +7487,8 @@ class LibUsers(Lib):
             return User(self.runt, udef['iden'])
 
     async def _methUsersAdd(self, name, passwd=None, email=None, iden=None):
-        self.runt.confirm(('auth', 'user', 'add'))
+        if not self.runt.allowed(('auth', 'user', 'add')):
+            self.runt.confirm(('storm', 'lib', 'auth', 'users', 'add'))
         name = await tostr(name)
         iden = await tostr(iden, True)
         email = await tostr(email, True)
@@ -7463,7 +7497,8 @@ class LibUsers(Lib):
         return User(self.runt, udef['iden'])
 
     async def _methUsersDel(self, iden):
-        self.runt.confirm(('auth', 'user', 'del'))
+        if not self.runt.allowed(('auth', 'user', 'del')):
+            self.runt.confirm(('storm', 'lib', 'auth', 'users', 'del'))
         await self.runt.snap.core.delUser(iden)
 
 @registry.registerLib
@@ -7503,6 +7538,12 @@ class LibRoles(Lib):
                               'desc': 'The role by name, or null if it does not exist.', }}},
     )
     _storm_lib_path = ('auth', 'roles')
+    _storm_lib_perms = (
+        {'perm': ('storm', 'lib', 'auth', 'roles', 'add'), 'gate': 'cortex',
+         'desc': 'Controls the ability to add a role to the system. USE WITH CAUTION!'},
+        {'perm': ('storm', 'lib', 'auth', 'roles', 'del'), 'gate': 'cortex',
+         'desc': 'Controls the ability to remove a role from the system. USE WITH CAUTION!'},
+    )
 
     def getObjLocals(self):
         return {
@@ -7530,12 +7571,14 @@ class LibRoles(Lib):
             return Role(self.runt, rdef['iden'])
 
     async def _methRolesAdd(self, name):
-        self.runt.confirm(('auth', 'role', 'add'))
+        if not self.runt.allowed(('auth', 'role', 'add')):
+            self.runt.confirm(('storm', 'lib', 'auth', 'roles', 'add'))
         rdef = await self.runt.snap.core.addRole(name)
         return Role(self.runt, rdef['iden'])
 
     async def _methRolesDel(self, iden):
-        self.runt.confirm(('auth', 'role', 'del'))
+        if not self.runt.allowed(('auth', 'role', 'del')):
+            self.runt.confirm(('storm', 'lib', 'auth', 'roles', 'del'))
         await self.runt.snap.core.delRole(iden)
 
 @registry.registerLib
@@ -8034,6 +8077,8 @@ class User(Prim):
          'type': {'type': 'function', '_funcname': '_methUserGrant',
                   'args': (
                       {'name': 'iden', 'type': 'str', 'desc': 'The iden of the Role.', },
+                      {'name': 'indx', 'type': 'int', 'desc': 'The position of the Role as a 0 based index.',
+                       'default': None, },
                   ),
                   'returns': {'type': 'null', }}},
         {'name': 'setRoles', 'desc': '''
@@ -8140,20 +8185,20 @@ class User(Prim):
                   'returns': {'type': 'list',
                               'desc': 'A list of ``storm:auth:gates`` that the user has rules for.', }}},
         {'name': 'name', 'desc': '''
-        A users name. This can also be used to set a users name.
+        A user's name. This can also be used to set a user's name.
 
         Example:
-                Change a users name::
+                Change a user's name::
 
                     $user=$lib.auth.users.byname(bob) $user.name=robert
         ''',
          'type': {'type': 'stor', '_storfunc': '_storUserName',
                   'returns': {'type': 'str', }}},
         {'name': 'email', 'desc': '''
-        A users email. This can also be used to set the users email.
+        A user's email. This can also be used to set the user's email.
 
         Example:
-                Change a users email address::
+                Change a user's email address::
 
                     $user=$lib.auth.users.byname(bob) $user.email="robert@bobcorp.net"
         ''',
@@ -8294,9 +8339,10 @@ class User(Prim):
         user = await self.runt.snap.core.auth.reqUser(self.valu)
         return user.getAllowedReason(perm, gateiden=gateiden, default=default)
 
-    async def _methUserGrant(self, iden):
+    async def _methUserGrant(self, iden, indx=None):
         self.runt.confirm(('auth', 'user', 'grant'))
-        await self.runt.snap.core.addUserRole(self.valu, iden)
+        indx = await toint(indx, noneok=True)
+        await self.runt.snap.core.addUserRole(self.valu, iden, indx=indx)
 
     async def _methUserSetRoles(self, idens):
         self.runt.confirm(('auth', 'user', 'grant'))
@@ -8447,10 +8493,10 @@ class Role(Prim):
                   ),
                   'returns': {'type': 'null', }}},
         {'name': 'name', 'desc': '''
-            A roles name. This can also be used to set the role name.
+            A role's name. This can also be used to set the role name.
 
             Example:
-                    Change a roles name::
+                    Change a role's name::
 
                         $role=$lib.auth.roles.byname(analyst) $role.name=superheroes
             ''',

synapse/lib/types.py

@@ -385,7 +385,7 @@ class Bool(Type):
         return int(bool(valu)), {}
 
     def repr(self, valu):
-        return repr(bool(valu))
+        return repr(bool(valu)).lower()
 
 class Array(Type):
 
@@ -1732,6 +1732,9 @@ class Taxonomy(Str):
     def _normPyStr(self, text):
         return self._normPyList(text.strip().strip('.').split('.'))
 
+    def repr(self, norm):
+        return norm.rstrip('.')
+
 class Tag(Str):
 
     def postTypeInit(self):

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, 134, 0)
+version = (2, 136, 0)
 verstring = '.'.join([str(x) for x in version])
-commit = 'cb63cc9ab251257464e815be7c525139fec7e047'
+commit = 'dba42be36057d465def6a8f17294aac3677a161e'

synapse/lib/view.py

@@ -617,7 +617,10 @@ class View(s_nexus.Pusher):  # type: ignore
             self.core._calcViewsByLayer()
 
         else:
-            await self.info.set(name, valu)
+            if valu is None:
+                await self.info.pop(name)
+            else:
+                await self.info.set(name, valu)
 
         await self.core.feedBeholder('view:set', {'iden': self.iden, 'name': name, 'valu': valu},
                                      gates=[self.iden, self.layers[0].iden])

synapse/tests/test_axon.py

@@ -330,9 +330,11 @@ Bob,Smith,Little House at the end of Main Street,Gomorra,CA,12345'''
 
         evt = asyncio.Event()
         origlink = s_axon.Axon._sha256ToLink
-        async def fakelink(self, sha256, link):
+        async def fakelink(self, sha256_, link):
             link.onfini(evt.set)
-            await origlink(self, sha256, link)
+            if sha256_ == pennhash:
+                sha256_ = b'newp'
+            await origlink(self, sha256_, link)
 
         newdata = '\n'.join([data for i in range(500)])
         size, sha256 = await axon.put(newdata.encode())
@@ -347,6 +349,10 @@ Bob,Smith,Little House at the end of Main Street,Gomorra,CA,12345'''
                 break
             self.true(await s_coro.event_wait(evt, 5))
 
+            # make sure exceptions within sha256tolink get re-raised
+            await self.asyncraises(s_exc.NoSuchFile, s_t_utils.alist(axon.csvrows(pennhash)))
+            await self.asyncraises(s_exc.NoSuchFile, s_t_utils.alist(axon.readlines(s_common.ehex(pennhash))))
+
         # CSV with alternative delimiter
         data = '''foo|bar|baz
 words|word|wrd'''

synapse/tests/test_cortex.py

@@ -1196,6 +1196,10 @@ class CortexTest(s_t_utils.SynTest):
                 self.len(1, await core.nodes('test:int +#foo.bar:score<=30'))
                 self.len(1, await core.nodes('test:int +#foo.bar:score>=10'))
                 self.len(1, await core.nodes('test:int +#foo.bar:score*range=(10, 30)'))
+                self.len(1, await core.nodes('test:int +#*:score'))
+                self.len(1, await core.nodes('test:int +#foo.*:score'))
+                self.len(1, await core.nodes('$tag=* test:int +#*:score'))
+                self.len(1, await core.nodes('$tag=foo.* test:int +#foo.*:score'))
 
                 self.len(0, await core.nodes('test:int -#foo.bar'))
                 self.len(0, await core.nodes('test:int -#foo.bar:score'))
@@ -1317,6 +1321,24 @@ class CortexTest(s_t_utils.SynTest):
                 with self.raises(s_exc.NoSuchType):
                     await core.addTagProp('derp', ('derp', {}), {})
 
+                with self.raises(s_exc.BadTypeValu):
+                    await core.nodes("$tag=(foo, bar) test:int#$tag:prop")
+
+                with self.raises(s_exc.BadTypeValu):
+                    await core.nodes("$tag=(foo, bar) test:int +#$tag:prop")
+
+                with self.raises(s_exc.BadTypeValu):
+                    await core.nodes("$tag=(foo, bar) test:int +#$tag:prop=5")
+
+                with self.raises(s_exc.BadTypeValu):
+                    await core.nodes("test:int $tag=(foo, bar) $lib.print(#$tag:prop)")
+
+                with self.raises(s_exc.BadTypeValu):
+                    await core.nodes("test:int $tag=(foo, bar) [ +#$tag:prop=foo ]")
+
+                with self.raises(s_exc.BadTypeValu):
+                    await core.nodes("test:int $tag=(foo, bar) [ -#$tag:prop ]")
+
             # Ensure that the tagprops persist
             async with self.getTestCore(dirn=dirn) as core:
                 # Ensure we can still work with a tagprop, after restart, that was
@@ -1496,7 +1518,7 @@ class CortexTest(s_t_utils.SynTest):
             self.eq(set(nodes[0].tags.keys()), {'foo', 'foo.v'})
 
             # Cannot norm a list of tag parts directly when making tags on a node
-            with self.raises(AttributeError):
+            with self.raises(s_exc.BadTypeValu):
                 await wcore.nodes("$foo=(('foo', 'bar.baz'),) [test:int=2 +#$foo]")
 
             # Can set a list of tags directly
@@ -1508,8 +1530,20 @@ class CortexTest(s_t_utils.SynTest):
             self.len(1, nodes)
             self.eq(set(nodes[0].tags.keys()), {'foo', 'bar', 'bar.baz'})
 
-            with self.raises(TypeError):
-                await wcore.nodes('$foo=$lib.set("foo", "bar") [test:int=5 +#$foo]')
+            nodes = await wcore.nodes('$foo=$lib.set("foo", "bar") [test:int=5 +#$foo]')
+            self.len(1, nodes)
+            self.eq(set(nodes[0].tags.keys()), {'foo', 'bar'})
+
+            await self.asyncraises(s_exc.BadTypeValu, wcore.nodes("$tag='' #$tag"))
+            await self.asyncraises(s_exc.BadTypeValu, wcore.nodes("$tag='' #$tag=2020"))
+            await self.asyncraises(s_exc.BadTypeValu, wcore.nodes("$tag=$lib.null #foo.$tag"))
+            await self.asyncraises(s_exc.BadTypeValu, wcore.nodes("$tag=(foo, bar) #$tag"))
+            await self.asyncraises(s_exc.BadTypeValu, wcore.nodes("$tag=(foo, bar) ##$tag"))
+            await self.asyncraises(s_exc.BadTypeValu, wcore.nodes("$tag=(foo, bar) inet:fqdn#$tag"))
+            await self.asyncraises(s_exc.BadTypeValu, wcore.nodes("test:int $tag=$lib.null +#foo.$tag"))
+            await self.asyncraises(s_exc.BadTypeValu, wcore.nodes("test:int $tag=(foo, bar) $lib.print(#$tag)"))
+            await self.asyncraises(s_exc.BadTypeValu, wcore.nodes("test:int $tag=(foo, bar) +#$tag"))
+            await self.asyncraises(s_exc.BadTypeValu, wcore.nodes("test:int $tag=(foo, bar) +#$tag=2020"))
 
     async def test_base_types1(self):
 
@@ -4907,7 +4941,7 @@ class CortexBasicTest(s_t_utils.SynTest):
             pode = podes[0]
             self.true(s_node.tagged(pode, '#foo'))
 
-            mesgs = await core.stormlist('$var="" test:str=foo [+?#$var=2019] $lib.print(#$var)')
+            mesgs = await core.stormlist('$var="" test:str=foo [+?#$var=2019]')
             podes = [m[1] for m in mesgs if m[0] == 'node']
             self.len(1, podes)
             pode = podes[0]