synapse 2.170.0__py311-none-any.whl → 2.172.0__py311-none-any.whl

synapse/common.py

@@ -1183,6 +1183,26 @@ def httpcodereason(code):
     except ValueError:
         return f'Unknown HTTP status code {code}'
 
+def trimText(text: str, n: int = 256, placeholder: str = '...') -> str:
+    '''
+    Trim a text string larger than n characters and add a placeholder at the end.
+
+    Args:
+        text: String to trim.
+        n: Number of characters to allow.
+        placeholder: Placeholder text.
+
+    Returns:
+        The original string or the trimmed string.
+    '''
+    if len(text) <= n:
+        return text
+    plen = len(placeholder)
+    mlen = n - plen
+    assert plen > 0
+    assert n > plen
+    return f'{text[:mlen]}{placeholder}'
+
 # TODO:  Switch back to using asyncio.wait_for when we are using py 3.12+
 # This is a workaround for a race where asyncio.wait_for can end up
 # ignoring cancellation https://github.com/python/cpython/issues/86296

synapse/cortex.py

@@ -56,6 +56,7 @@ import synapse.lib.stormwhois as s_stormwhois  # NOQA
 import synapse.lib.stormtypes as s_stormtypes
 
 import synapse.lib.stormlib.aha as s_stormlib_aha  # NOQA
+import synapse.lib.stormlib.env as s_stormlib_env  # NOQA
 import synapse.lib.stormlib.gen as s_stormlib_gen  # NOQA
 import synapse.lib.stormlib.gis as s_stormlib_gis  # NOQA
 import synapse.lib.stormlib.hex as s_stormlib_hex  # NOQA
@@ -4548,7 +4549,11 @@ class Cortex(s_oauth.OAuthMixin, s_cell.Cell):  # type: ignore
                 continue
 
             view.layers = [lyr for lyr in view.layers if lyr.iden != layriden]
-            await view.info.set('layers', [lyr.iden for lyr in view.layers])
+            layridens = [lyr.iden for lyr in view.layers]
+            await view.info.set('layers', layridens)
+
+            mesg = {'iden': view.iden, 'layers': layridens}
+            await self.feedBeholder('view:setlayers', mesg, gates=[view.iden, layridens[0]])
 
             if view.parent.iden == viewiden:
                 if newparent is None:
@@ -4558,6 +4563,9 @@ class Cortex(s_oauth.OAuthMixin, s_cell.Cell):  # type: ignore
                     view.parent = newview
                     await view.info.set('parent', newparent)
 
+                mesg = {'iden': view.iden, 'name': 'parent', 'valu': newparent}
+                await self.feedBeholder('view:set', mesg, gates=[view.iden, layridens[0]])
+
         if not layrinuse and (layr := self.layers.get(layriden)) is not None:
             del self.layers[layriden]
 
@@ -4682,6 +4690,13 @@ class Cortex(s_oauth.OAuthMixin, s_cell.Cell):  # type: ignore
 
         return self.layers.get(iden)
 
+    def reqLayer(self, iden=None):
+        layr = self.getLayer(iden=iden)
+        if layr is None:
+            mesg = f'No layer found with iden: {iden}'
+            raise s_exc.NoSuchLayer(mesg=mesg, iden=iden)
+        return layr
+
     def listLayers(self):
         return self.layers.values()
 
@@ -5038,10 +5053,7 @@ class Cortex(s_oauth.OAuthMixin, s_cell.Cell):  # type: ignore
                 await self.setNexsIndx(maxindx)
 
     async def saveLayerNodeEdits(self, layriden, edits, meta):
-        layr = self.getLayer(layriden)
-        if layr is None:
-            mesg = f'No layer found with iden: {layriden}'
-            raise s_exc.NoSuchLayer(mesg=mesg, iden=layriden)
+        layr = self.reqLayer(layriden)
         return await layr.saveNodeEdits(edits, meta)
 
     async def cloneLayer(self, iden, ldef=None):
@@ -6905,6 +6917,83 @@ class Cortex(s_oauth.OAuthMixin, s_cell.Cell):  # type: ignore
         self.slab.delete(name.encode(), db=self.vaultsbynamedb)
         self.slab.delete(bidn, db=self.vaultsdb)
 
+    def _propAllowedReason(self, user, perms, gateiden=None, default=None):
+        '''
+        Similar to allowed, but always prefer the default value specified by the caller.
+        Default values are still pulled from permdefs if there is a match there; but still prefer caller default.
+        This results in a ternary response that can be used to know if a rule had a positive/negative or no match.
+        The matching reason metadata is also returned.
+        '''
+        if default is None:
+            permdef = self.getPermDef(perms)
+            if permdef:
+                default = permdef.get('default', default)
+
+        return user.getAllowedReason(perms, gateiden=gateiden, default=default)
+
+    def confirmPropSet(self, user, prop, layriden):
+        meta0 = self._propAllowedReason(user, prop.setperms[0], gateiden=layriden)
+
+        if meta0.isadmin:
+            return
+
+        allowed0 = meta0.value
+
+        meta1 = self._propAllowedReason(user, prop.setperms[1], gateiden=layriden)
+        allowed1 = meta1.value
+
+        if allowed0:
+            if allowed1:
+                return
+            elif allowed1 is False:
+                # This is a allow-with-precedence case.
+                # Inspect meta to determine if the rule a0 is more specific than rule a1
+                if len(meta0.rule) >= len(meta1.rule):
+                    return
+                user.raisePermDeny(prop.setperms[0], gateiden=layriden)
+            return
+
+        if allowed1:
+            if allowed0 is None:
+                return
+            # allowed0 here is False. This is a deny-with-precedence case.
+            # Inspect meta to determine if the rule a1 is more specific than rule a0
+            if len(meta1.rule) > len(meta0.rule):
+                return
+
+        user.raisePermDeny(prop.setperms[0], gateiden=layriden)
+
+    def confirmPropDel(self, user, prop, layriden):
+        meta0 = self._propAllowedReason(user, prop.delperms[0], gateiden=layriden)
+
+        if meta0.isadmin:
+            return
+
+        allowed0 = meta0.value
+        meta1 = self._propAllowedReason(user, prop.delperms[1], gateiden=layriden)
+        allowed1 = meta1.value
+
+        if allowed0:
+            if allowed1:
+                return
+            elif allowed1 is False:
+                # This is a allow-with-precedence case.
+                # Inspect meta to determine if the rule a0 is more specific than rule a1
+                if len(meta0.rule) >= len(meta1.rule):
+                    return
+                user.raisePermDeny(prop.delperms[0], gateiden=layriden)
+            return
+
+        if allowed1:
+            if allowed0 is None:
+                return
+            # allowed0 here is False. This is a deny-with-precedence case.
+            # Inspect meta to determine if the rule a1 is more specific than rule a0
+            if len(meta1.rule) > len(meta0.rule):
+                return
+
+        user.raisePermDeny(prop.delperms[0], gateiden=layriden)
+
 @contextlib.asynccontextmanager
 async def getTempCortex(mods=None):
     '''
@@ -6922,7 +7011,10 @@ async def getTempCortex(mods=None):
     '''
     with s_common.getTempDir() as dirn:
         logger.debug(f'Creating temporary cortex as {dirn}')
-        async with await Cortex.anit(dirn) as core:
+        conf = {
+            'health:sysctl:checks': False,
+        }
+        async with await Cortex.anit(dirn, conf=conf) as core:
             if mods:
                 for mod in mods:
                     await core.loadCoreModule(mod)

synapse/lib/agenda.py

@@ -572,7 +572,8 @@ class Agenda(s_base.Base):
         self._next_indx += 1
 
         if iden in self.appts:
-            raise s_exc.DupIden()
+            mesg = f'Cron job already exists with iden: {iden}'
+            raise s_exc.DupIden(iden=iden, mesg=mesg)
 
         if not query:
             raise ValueError('"query" key of cdef parameter is not present or empty')
@@ -622,20 +623,22 @@ class Agenda(s_base.Base):
         if appt is not None:
             return appt
 
-        mesg = f'No cron job with id: {iden}'
+        mesg = f'No cron job with iden {iden}'
         raise s_exc.NoSuchIden(iden=iden, mesg=mesg)
 
     async def enable(self, iden):
         appt = self.appts.get(iden)
         if appt is None:
-            raise s_exc.NoSuchIden()
+            mesg = f'No cron job with iden: {iden}'
+            raise s_exc.NoSuchIden(iden=iden, mesg=mesg)
 
         await self.mod(iden, appt.query)
 
     async def disable(self, iden):
         appt = self.appts.get(iden)
         if appt is None:
-            raise s_exc.NoSuchIden()
+            mesg = f'No cron job with iden: {iden}'
+            raise s_exc.NoSuchIden(iden=iden, mesg=mesg)
 
         appt.enabled = False
         await appt.save()
@@ -646,7 +649,8 @@ class Agenda(s_base.Base):
         '''
         appt = self.appts.get(iden)
         if appt is None:
-            raise s_exc.NoSuchIden()
+            mesg = f'No cron job with iden: {iden}'
+            raise s_exc.NoSuchIden(iden=iden, mesg=mesg)
 
         if not query:
             raise ValueError('empty query')
@@ -664,7 +668,8 @@ class Agenda(s_base.Base):
         '''
         appt = self.appts.get(croniden)
         if appt is None:
-            raise s_exc.NoSuchIden()
+            mesg = f'No cron job with iden: {croniden}'
+            raise s_exc.NoSuchIden(iden=croniden, mesg=mesg)
 
         appt.view = viewiden
 
@@ -676,7 +681,8 @@ class Agenda(s_base.Base):
         '''
         appt = self.appts.get(iden)
         if appt is None:
-            raise s_exc.NoSuchIden()
+            mesg = f'No cron job with iden: {iden}'
+            raise s_exc.NoSuchIden(iden=iden, mesg=mesg)
 
         try:
             heappos = self.apptheap.index(appt)

synapse/lib/ast.py

@@ -733,8 +733,9 @@ class SubQuery(Oper):
                 retn.append(valunode.ndef[1])
 
                 if len(retn) > limit:
-                    mesg = f'Subquery used as a value yielded too many (>{limit}) nodes'
-                    raise self.addExcInfo(s_exc.BadTypeValu(mesg=mesg))
+                    query = self.kids[0].text
+                    mesg = f'Subquery used as a value yielded too many (>{limit}) nodes. {s_common.trimText(query)}'
+                    raise self.addExcInfo(s_exc.BadTypeValu(mesg=mesg, text=query))
 
         return retn
 
@@ -987,12 +988,12 @@ class ForLoop(Oper):
                         try:
                             numitems = len(item)
                         except TypeError:
-                            mesg = f'Number of items to unpack does not match the number of variables: {repr(item)[:256]}'
+                            mesg = f'Number of items to unpack does not match the number of variables: {s_common.trimText(repr(item))}'
                             exc = s_exc.StormVarListError(mesg=mesg, names=name)
                             raise self.kids[1].addExcInfo(exc)
 
                         if len(name) != numitems:
-                            mesg = f'Number of items to unpack does not match the number of variables: {repr(item)[:256]}'
+                            mesg = f'Number of items to unpack does not match the number of variables: {s_common.trimText(repr(item))}'
                             exc = s_exc.StormVarListError(mesg=mesg, names=name, numitems=numitems)
                             raise self.kids[1].addExcInfo(exc)
 
@@ -1053,12 +1054,12 @@ class ForLoop(Oper):
                         try:
                             numitems = len(item)
                         except TypeError:
-                            mesg = f'Number of items to unpack does not match the number of variables: {repr(item)[:256]}'
+                            mesg = f'Number of items to unpack does not match the number of variables: {s_common.trimText(repr(item))}'
                             exc = s_exc.StormVarListError(mesg=mesg, names=name)
                             raise self.kids[1].addExcInfo(exc)
 
                         if len(name) != numitems:
-                            mesg = f'Number of items to unpack does not match the number of variables: {repr(item)[:256]}'
+                            mesg = f'Number of items to unpack does not match the number of variables: {s_common.trimText(repr(item))}'
                             exc = s_exc.StormVarListError(mesg=mesg, names=name, numitems=numitems)
                             raise self.kids[1].addExcInfo(exc)
 
@@ -1306,7 +1307,7 @@ class VarListSetOper(Oper):
             item = [i async for i in s_stormtypes.toiter(item)]
 
             if len(item) < len(names):
-                mesg = f'Attempting to assign more items than we have variables to assign to: {repr(item)[:256]}'
+                mesg = f'Attempting to assign more items than we have variables to assign to: {s_common.trimText(repr(item))}'
                 exc = s_exc.StormVarListError(mesg=mesg, names=names, numitems=len(item))
                 raise self.kids[0].addExcInfo(exc)
 
@@ -1322,7 +1323,7 @@ class VarListSetOper(Oper):
             item = [i async for i in s_stormtypes.toiter(item)]
 
             if len(item) < len(names):
-                mesg = f'Attempting to assign more items than we have variables to assign to: {repr(item)[:256]}'
+                mesg = f'Attempting to assign more items than we have variables to assign to: {s_common.trimText(repr(item))}'
                 exc = s_exc.StormVarListError(mesg=mesg, names=names, numitems=len(item))
                 raise self.kids[0].addExcInfo(exc)
 

synapse/lib/cache.py

@@ -66,7 +66,7 @@ class FixedCache:
 
     def get(self, key):
         if self.iscorocall:
-            raise s_exc.BadArg('cache was initialized with coroutine.  Must use aget')
+            raise s_exc.BadArg(mesg='cache was initialized with coroutine.  Must use aget')
 
         valu = self.cache.get(key, s_common.novalu)
         if valu is not s_common.novalu:
@@ -81,7 +81,7 @@ class FixedCache:
 
     async def aget(self, key):
         if not self.iscorocall:
-            raise s_exc.BadOperArg('cache was initialized with non coroutine.  Must use get')
+            raise s_exc.BadOperArg(mesg='cache was initialized with non coroutine.  Must use get')
 
         valu = self.cache.get(key, s_common.novalu)
         if valu is not s_common.novalu:

synapse/lib/cell.py

@@ -55,7 +55,6 @@ import synapse.lib.lmdbslab as s_lmdbslab
 import synapse.lib.thisplat as s_thisplat
 
 import synapse.lib.crypto.passwd as s_passwd
-import synapse.lib.platforms.linux as s_linux
 
 import synapse.tools.backup as s_t_backup
 
@@ -1465,7 +1464,7 @@ class Cell(s_nexus.Pusher, s_telepath.Aware):
     async def _runSysctlLoop(self):
         while not self.isfini:
             fixvals = []
-            sysctls = s_linux.getSysctls()
+            sysctls = s_thisplat.getSysctls()
 
             for name, valu in self.SYSCTL_VALS.items():
                 if (sysval := sysctls.get(name)) != valu:
@@ -1484,7 +1483,7 @@ class Cell(s_nexus.Pusher, s_telepath.Aware):
             extra = await self.getLogExtra(sysctls=fixvals)
             logger.warning(mesg, extra=extra)
 
-            await asyncio.sleep(self.SYSCTL_CHECK_FREQ)
+            await self.waitfini(self.SYSCTL_CHECK_FREQ)
 
     def _getAhaAdmin(self):
         name = self.conf.get('aha:admin')
@@ -4143,6 +4142,11 @@ class Cell(s_nexus.Pusher, s_telepath.Aware):
         async with await s_spooled.Set.anit(dirn=self.dirn, cell=self) as sset:
             yield sset
 
+    @contextlib.asynccontextmanager
+    async def getSpooledDict(self):
+        async with await s_spooled.Dict.anit(dirn=self.dirn, cell=self) as sdict:
+            yield sdict
+
     async def addSignalHandlers(self):
         await s_base.Base.addSignalHandlers(self)
 

synapse/lib/coro.py

@@ -39,6 +39,18 @@ async def agen(item):
     for x in item:
         yield x
 
+async def pause(genr, iterations=10):
+    idx = 0
+
+    async for out in agen(genr):
+        yield out
+        idx += 1
+
+        if idx % iterations == 0:
+            await asyncio.sleep(0)
+
+    return
+
 def executor(func, *args, **kwargs):
     '''
     Execute a non-coroutine function in the ioloop executor pool.

synapse/lib/layer.py

@@ -75,6 +75,7 @@ import synapse.telepath as s_telepath
 
 import synapse.lib.gis as s_gis
 import synapse.lib.cell as s_cell
+import synapse.lib.coro as s_coro
 import synapse.lib.cache as s_cache
 import synapse.lib.nexus as s_nexus
 import synapse.lib.queue as s_queue
@@ -157,14 +158,14 @@ class LayerApi(s_cell.CellApi):
 
         await self.layr.storNodeEditsNoLift(nodeedits, meta)
 
-    async def syncNodeEdits(self, offs, wait=True):
+    async def syncNodeEdits(self, offs, wait=True, reverse=False):
         '''
         Yield (offs, nodeedits) tuples from the nodeedit log starting from the given offset.
 
         Once caught up with storage, yield them in realtime.
         '''
         await self._reqUserAllowed(self.liftperm)
-        async for item in self.layr.syncNodeEdits(offs, wait=wait):
+        async for item in self.layr.syncNodeEdits(offs, wait=wait, reverse=reverse):
             yield item
             await asyncio.sleep(0)
 
@@ -3816,7 +3817,7 @@ class Layer(s_nexus.Pusher):
 
     async def getEdgeVerbs(self):
 
-        for lkey in self.layrslab.scanKeys(db=self.byverb):
+        for lkey in self.layrslab.scanKeys(db=self.byverb, nodup=True):
             yield lkey.decode()
 
     async def getEdges(self, verb=None):
@@ -4088,11 +4089,126 @@ class Layer(s_nexus.Pusher):
         '''
         Return a generator of all a buid's node data keys
         '''
-        for lkey in self.dataslab.scanKeysByPref(buid, db=self.nodedata):
+        for lkey in self.dataslab.scanKeysByPref(buid, db=self.nodedata, nodup=True):
             abrv = lkey[32:]
             prop = self.getAbrvProp(abrv)
             yield prop[0]
 
+    async def confirmLayerEditPerms(self, user, gateiden, delete=False):
+        if user.allowed(('node',), gateiden=gateiden):
+            return
+
+        if delete:
+            perm_forms = ('node', 'del')
+            perm_props = ('node', 'prop', 'del')
+            perm_tags = ('node', 'tag', 'del')
+            perm_ndata = ('node', 'data', 'pop')
+            perm_edges = ('node', 'edge', 'del')
+        else:
+            perm_forms = ('node', 'add')
+            perm_props = ('node', 'prop', 'set')
+            perm_tags = ('node', 'tag', 'add')
+            perm_ndata = ('node', 'data', 'set')
+            perm_edges = ('node', 'edge', 'add')
+
+        allow_forms = user.allowed(perm_forms, gateiden=gateiden)
+        allow_props = user.allowed(perm_props, gateiden=gateiden)
+        allow_tags = user.allowed(perm_tags, gateiden=gateiden)
+        allow_ndata = user.allowed(perm_ndata, gateiden=gateiden)
+        allow_edges = user.allowed(perm_edges, gateiden=gateiden)
+
+        if all((allow_forms, allow_props, allow_tags, allow_ndata, allow_edges)):
+            return
+
+        # nodes & props
+        if not allow_forms or not allow_props:
+            async for byts, abrv in s_coro.pause(self.propabrv.slab.scanByFull(db=self.propabrv.name2abrv)):
+                form, prop = s_msgpack.un(byts)
+                if form is None: # pragma: no cover
+                    continue
+
+                if self.layrslab.prefexists(abrv, db=self.byprop):
+                    if prop and not allow_props:
+                        realform = self.core.model.form(form)
+                        if not realform: # pragma: no cover
+                            mesg = f'Invalid form: {form}'
+                            raise s_exc.NoSuchForm(mesg=mesg, form=form)
+
+                        realprop = realform.prop(prop)
+                        if not realprop: # pragma: no cover
+                            mesg = f'Invalid prop: {form}:{prop}'
+                            raise s_exc.NoSuchProp(mesg=mesg, form=form, prop=prop)
+
+                        if delete:
+                            self.core.confirmPropDel(user, realprop, gateiden)
+                        else:
+                            self.core.confirmPropSet(user, realprop, gateiden)
+
+                    elif not prop and not allow_forms:
+                        user.confirm(perm_forms + (form,), gateiden=gateiden)
+
+        # tagprops
+        if not allow_tags:
+            async for byts, abrv in s_coro.pause(self.tagpropabrv.slab.scanByFull(db=self.tagpropabrv.name2abrv)):
+                info = s_msgpack.un(byts)
+                if None in info or len(info) != 3:
+                    continue
+
+                if self.layrslab.prefexists(abrv, db=self.bytagprop):
+                    perm = perm_tags + tuple(info[1].split('.'))
+                    user.confirm(perm, gateiden=gateiden)
+
+        # nodedata
+        if not allow_ndata:
+            async for abrv in s_coro.pause(self.dataslab.scanKeys(db=self.dataname, nodup=True)):
+                name, _ = self.getAbrvProp(abrv)
+                perm = perm_ndata + (name,)
+                user.confirm(perm, gateiden=gateiden)
+
+        # edges
+        if not allow_edges:
+            async for verb in s_coro.pause(self.layrslab.scanKeys(db=self.byverb, nodup=True)):
+                perm = perm_edges + (verb.decode(),)
+                user.confirm(perm, gateiden=gateiden)
+
+        # tags
+        # NB: tag perms should be yielded for every leaf on every node in the layer
+        if not allow_tags:
+            async with self.core.getSpooledDict() as tags:
+
+                # Collect all tag abrvs for all nodes in the layer
+                async for lkey, buid in s_coro.pause(self.layrslab.scanByFull(db=self.bytag)):
+                    abrv = lkey[:8]
+                    abrvs = list(tags.get(buid, []))
+                    abrvs.append(abrv)
+                    await tags.set(buid, abrvs)
+
+                # Iterate over each node and it's tags
+                async for buid, abrvs in s_coro.pause(tags.items()):
+                    seen = {}
+
+                    if len(abrvs) == 1:
+                        # Easy optimization: If there's only one tag abrv, then it's a
+                        # leaf by default
+                        name = self.tagabrv.abrvToName(abrv)
+                        key = tuple(name.split('.'))
+                        perm = perm_tags + key
+                        user.confirm(perm, gateiden=gateiden)
+
+                    else:
+                        for abrv in abrvs:
+                            name = self.tagabrv.abrvToName(abrv)
+                            parts = tuple(name.split('.'))
+                            for idx in range(1, len(parts) + 1):
+                                key = tuple(parts[:idx])
+                                seen.setdefault(key, 0)
+                                seen[key] += 1
+
+                        for key, count in seen.items():
+                            if count == 1:
+                                perm = perm_tags + key
+                                user.confirm(perm, gateiden=gateiden)
+
     async def iterLayerNodeEdits(self):
         '''
         Scan the full layer and yield artificial sets of nodeedits.
@@ -4291,7 +4407,7 @@ class Layer(s_nexus.Pusher):
         for offs, (edits, meta) in self.nodeeditlog.iterBack(offs):
             yield (offs, edits, meta)
 
-    async def syncNodeEdits2(self, offs, wait=True):
+    async def syncNodeEdits2(self, offs, wait=True, reverse=False):
         '''
         Once caught up with storage, yield them in realtime.
 
@@ -4301,7 +4417,7 @@ class Layer(s_nexus.Pusher):
         if not self.logedits:
             return
 
-        for offi, (nodeedits, meta) in self.nodeeditlog.iter(offs):
+        for offi, (nodeedits, meta) in self.nodeeditlog.iter(offs, reverse=reverse):
             yield (offi, nodeedits, meta)
 
         if wait:
@@ -4309,11 +4425,11 @@ class Layer(s_nexus.Pusher):
                 async for item in wind:
                     yield item
 
-    async def syncNodeEdits(self, offs, wait=True):
+    async def syncNodeEdits(self, offs, wait=True, reverse=False):
         '''
         Identical to syncNodeEdits2, but doesn't yield meta
         '''
-        async for offi, nodeedits, _meta in self.syncNodeEdits2(offs, wait=wait):
+        async for offi, nodeedits, _meta in self.syncNodeEdits2(offs, wait=wait, reverse=reverse):
             yield (offi, nodeedits)
 
     async def syncIndexEvents(self, offs, matchdef, wait=True):
@@ -4450,79 +4566,3 @@ def getFlatEdits(nodeedits):
         addedits(buid, form, edits)
 
     return [(k[0], k[1], v) for (k, v) in editsbynode.items()]
-
-def getNodeEditPerms(nodeedits):
-    '''
-    Yields (offs, perm) tuples that can be used in user.allowed()
-    '''
-    tags = []
-    tagadds = []
-
-    for nodeoffs, (buid, form, edits) in enumerate(nodeedits):
-
-        tags.clear()
-        tagadds.clear()
-
-        for editoffs, (edit, info, _) in enumerate(edits):
-
-            permoffs = (nodeoffs, editoffs)
-
-            if edit == EDIT_NODE_ADD:
-                yield (permoffs, ('node', 'add', form))
-                continue
-
-            if edit == EDIT_NODE_DEL:
-                yield (permoffs, ('node', 'del', form))
-                continue
-
-            if edit == EDIT_PROP_SET:
-                yield (permoffs, ('node', 'prop', 'set', f'{form}:{info[0]}'))
-                continue
-
-            if edit == EDIT_PROP_DEL:
-                yield (permoffs, ('node', 'prop', 'del', f'{form}:{info[0]}'))
-                continue
-
-            if edit == EDIT_TAG_SET:
-                if info[1] != (None, None):
-                    tagadds.append(info[0])
-                    yield (permoffs, ('node', 'tag', 'add', *info[0].split('.')))
-                else:
-                    tags.append((len(info[0]), editoffs, info[0]))
-                continue
-
-            if edit == EDIT_TAG_DEL:
-                yield (permoffs, ('node', 'tag', 'del', *info[0].split('.')))
-                continue
-
-            if edit == EDIT_TAGPROP_SET:
-                yield (permoffs, ('node', 'tag', 'add', *info[0].split('.')))
-                continue
-
-            if edit == EDIT_TAGPROP_DEL:
-                yield (permoffs, ('node', 'tag', 'del', *info[0].split('.')))
-                continue
-
-            if edit == EDIT_NODEDATA_SET:
-                yield (permoffs, ('node', 'data', 'set', info[0]))
-                continue
-
-            if edit == EDIT_NODEDATA_DEL:
-                yield (permoffs, ('node', 'data', 'pop', info[0]))
-                continue
-
-            if edit == EDIT_EDGE_ADD:
-                yield (permoffs, ('node', 'edge', 'add', info[0]))
-                continue
-
-            if edit == EDIT_EDGE_DEL:
-                yield (permoffs, ('node', 'edge', 'del', info[0]))
-                continue
-
-        for _, editoffs, tag in sorted(tags, reverse=True):
-            look = tag + '.'
-            if any([tagadd.startswith(look) for tagadd in tagadds]):
-                continue
-
-            yield ((nodeoffs, editoffs), ('node', 'tag', 'add', *tag.split('.')))
-            tagadds.append(tag)