synapse 2.179.0__py311-none-any.whl → 2.180.0__py311-none-any.whl

synapse/cortex.py

@@ -5730,7 +5730,7 @@ class Cortex(s_oauth.OAuthMixin, s_cell.Cell):  # type: ignore
 
         if (nexsoffs := opts.get('nexsoffs')) is not None:
             if not await self.waitNexsOffs(nexsoffs, timeout=opts.get('nexstimeout')):
-                raise s_exc.TimeOut(mesg=f'Timeout waiting for nexus offset {nexsoffs}.')
+                raise s_exc.TimeOut(mesg=f'Timeout waiting for nexus offset {nexsoffs} in count()')
 
         view = self._viewFromOpts(opts)
 
@@ -5794,7 +5794,7 @@ class Cortex(s_oauth.OAuthMixin, s_cell.Cell):  # type: ignore
 
         if (nexsoffs := opts.get('nexsoffs')) is not None:
             if not await self.waitNexsOffs(nexsoffs, timeout=opts.get('nexstimeout')):
-                raise s_exc.TimeOut(mesg=f'Timeout waiting for nexus offset {nexsoffs}.')
+                raise s_exc.TimeOut(mesg=f'Timeout waiting for nexus offset {nexsoffs} in storm().')
 
         view = self._viewFromOpts(opts)
         async for mesg in view.storm(text, opts=opts):
@@ -5821,7 +5821,7 @@ class Cortex(s_oauth.OAuthMixin, s_cell.Cell):  # type: ignore
 
         if (nexsoffs := opts.get('nexsoffs')) is not None:
             if not await self.waitNexsOffs(nexsoffs, timeout=opts.get('nexstimeout')):
-                raise s_exc.TimeOut(mesg=f'Timeout waiting for nexus offset {nexsoffs}.')
+                raise s_exc.TimeOut(mesg=f'Timeout waiting for nexus offset {nexsoffs} in callStorm().')
 
         view = self._viewFromOpts(opts)
         return await view.callStorm(text, opts=opts)
@@ -5849,7 +5849,7 @@ class Cortex(s_oauth.OAuthMixin, s_cell.Cell):  # type: ignore
 
         if (nexsoffs := opts.get('nexsoffs')) is not None:
             if not await self.waitNexsOffs(nexsoffs, timeout=opts.get('nexstimeout')):
-                raise s_exc.TimeOut(mesg=f'Timeout waiting for nexus offset {nexsoffs}.')
+                raise s_exc.TimeOut(mesg=f'Timeout waiting for nexus offset {nexsoffs} in exportStorm().')
 
         user = self._userFromOpts(opts)
         view = self._viewFromOpts(opts)

synapse/lib/ast.py

@@ -419,7 +419,8 @@ class SubGraph:
                     await asyncio.sleep(0)
                     continue
 
-                yield (pivonode, path.fork(pivonode), {'type': 'prop', 'prop': propname})
+                link = {'type': 'prop', 'prop': propname}
+                yield (pivonode, path.fork(pivonode, link), link)
 
             for iden in existing:
                 buid = s_common.uhex(iden)
@@ -1436,12 +1437,13 @@ class LiftOper(Oper):
 
             return
 
+        link = {'type': 'runtime'}
         async for node, path in genr:
 
             yield node, path
 
             async for subn in self.lift(runt, path):
-                yield subn, path.fork(subn)
+                yield subn, path.fork(subn, link)
 
     async def lift(self, runt, path):  # pragma: no cover
         raise NotImplementedError('Must define lift(runt, path)')
@@ -1913,8 +1915,9 @@ class PivotOut(PivotOper):
         # <syn:tag> -> * is "from tags to nodes with tags"
         if node.form.name == 'syn:tag':
 
+            link = {'type': 'tag', 'tag': node.ndef[1], 'reverse': True}
             async for pivo in runt.snap.nodesByTag(node.ndef[1]):
-                yield pivo, path.fork(pivo)
+                yield pivo, path.fork(pivo, link)
 
             return
 
@@ -1925,7 +1928,7 @@ class PivotOut(PivotOper):
                 logger.warning(f'Missing node corresponding to ndef {n2def} on edge')
                 return
 
-            yield pivo, path.fork(pivo)
+            yield pivo, path.fork(pivo, {'type': 'prop', 'prop': 'n2'})
             return
 
         for name, prop in node.form.props.items():
@@ -1934,27 +1937,28 @@ class PivotOut(PivotOper):
             if valu is None:
                 continue
 
+            link = {'type': 'prop', 'prop': prop.name}
             # if the outbound prop is an ndef...
             if isinstance(prop.type, s_types.Ndef):
                 pivo = await runt.snap.getNodeByNdef(valu)
                 if pivo is None:
                     continue
 
-                yield pivo, path.fork(pivo)
+                yield pivo, path.fork(pivo, link)
                 continue
 
             if isinstance(prop.type, s_types.Array):
                 if isinstance(prop.type.arraytype, s_types.Ndef):
                     for item in valu:
                         if (pivo := await runt.snap.getNodeByNdef(item)) is not None:
-                            yield pivo, path.fork(pivo)
+                            yield pivo, path.fork(pivo, link)
                     continue
 
                 typename = prop.type.opts.get('type')
                 if runt.model.forms.get(typename) is not None:
                     for item in valu:
                         async for pivo in runt.snap.nodesByPropValu(typename, '=', item, norm=False):
-                            yield pivo, path.fork(pivo)
+                            yield pivo, path.fork(pivo, link)
 
             form = runt.model.forms.get(prop.type.name)
             if form is None:
@@ -1962,7 +1966,7 @@ class PivotOut(PivotOper):
 
             if prop.isrunt:
                 async for pivo in runt.snap.nodesByPropValu(form.name, '=', valu):
-                    yield pivo, path.fork(pivo)
+                    yield pivo, path.fork(pivo, link)
                 continue
 
             pivo = await runt.snap.getNodeByNdef((form.name, valu))
@@ -1973,7 +1977,7 @@ class PivotOut(PivotOper):
             if pivo.buid == node.buid:
                 continue
 
-            yield pivo, path.fork(pivo)
+            yield pivo, path.fork(pivo, link)
 
 class N1WalkNPivo(PivotOut):
 
@@ -1990,7 +1994,7 @@ class N1WalkNPivo(PivotOut):
             async for (verb, iden) in node.iterEdgesN1():
                 wnode = await runt.snap.getNodeByBuid(s_common.uhex(iden))
                 if wnode is not None:
-                    yield wnode, path.fork(wnode)
+                    yield wnode, path.fork(wnode, {'type': 'edge', 'verb': verb})
 
 class PivotToTags(PivotOper):
     '''
@@ -2057,7 +2061,7 @@ class PivotToTags(PivotOper):
                 if pivo is None:
                     continue
 
-                yield pivo, path.fork(pivo)
+                yield pivo, path.fork(pivo, {'type': 'tag', 'tag': name})
 
 class PivotIn(PivotOper):
     '''
@@ -2083,25 +2087,27 @@ class PivotIn(PivotOper):
 
             pivo = await runt.snap.getNodeByNdef(ndef)
             if pivo is not None:
-                yield pivo, path.fork(pivo)
+                yield pivo, path.fork(pivo, {'type': 'prop', 'prop': 'n1', 'reverse': True})
 
             return
 
         name, valu = node.ndef
 
         for prop in runt.model.getPropsByType(name):
+            link = {'type': 'prop', 'prop': prop.name, 'reverse': True}
             norm = node.form.typehash is not prop.typehash
             async for pivo in runt.snap.nodesByPropValu(prop.full, '=', valu, norm=norm):
-                yield pivo, path.fork(pivo)
+                yield pivo, path.fork(pivo, link)
 
         for prop in runt.model.getArrayPropsByType(name):
             norm = node.form.typehash is not prop.arraytypehash
+            link = {'type': 'prop', 'prop': prop.name, 'reverse': True}
             async for pivo in runt.snap.nodesByPropArray(prop.full, '=', valu, norm=norm):
-                yield pivo, path.fork(pivo)
+                yield pivo, path.fork(pivo, link)
 
-        async for refsbuid in runt.snap.getNdefRefs(node.buid):
+        async for refsbuid, prop in runt.snap.getNdefRefs(node.buid, props=True):
             pivo = await runt.snap.getNodeByBuid(refsbuid)
-            yield pivo, path.fork(pivo)
+            yield pivo, path.fork(pivo, {'type': 'prop', 'prop': prop, 'reverse': True})
 
 class N2WalkNPivo(PivotIn):
 
@@ -2118,7 +2124,7 @@ class N2WalkNPivo(PivotIn):
             async for (verb, iden) in node.iterEdgesN2():
                 wnode = await runt.snap.getNodeByBuid(s_common.uhex(iden))
                 if wnode is not None:
-                    yield wnode, path.fork(wnode)
+                    yield wnode, path.fork(wnode, {'type': 'edge', 'verb': verb, 'reverse': True})
 
 class PivotInFrom(PivotOper):
     '''
@@ -2137,18 +2143,19 @@ class PivotInFrom(PivotOper):
         if isinstance(form.type, s_types.Edge):
 
             full = form.name + ':n2'
-
+            link = {'type': 'prop', 'prop': 'n2', 'reverse': True}
             async for node, path in genr:
 
                 if self.isjoin:
                     yield node, path
 
                 async for pivo in runt.snap.nodesByPropValu(full, '=', node.ndef, norm=False):
-                    yield pivo, path.fork(pivo)
+                    yield pivo, path.fork(pivo, link)
 
             return
 
         # edge <- form
+        link = {'type': 'prop', 'prop': 'n1', 'reverse': True}
         async for node, path in genr:
 
             if self.isjoin:
@@ -2168,7 +2175,7 @@ class PivotInFrom(PivotOper):
             if pivo is None:
                 continue
 
-            yield pivo, path.fork(pivo)
+            yield pivo, path.fork(pivo, link)
 
 class FormPivot(PivotOper):
     '''
@@ -2181,8 +2188,9 @@ class FormPivot(PivotOper):
         if isinstance(prop.type, s_types.Ndef):
 
             async def pgenr(node, strict=True):
+                link = {'type': 'prop', 'prop': prop.name, 'reverse': True}
                 async for pivo in runt.snap.nodesByPropValu(prop.full, '=', node.ndef, norm=False):
-                    yield pivo
+                    yield pivo, link
 
         elif not prop.isform:
 
@@ -2200,8 +2208,9 @@ class FormPivot(PivotOper):
                     norm = prop.typehash is not node.form.typehash
                     ngenr = runt.snap.nodesByPropValu(prop.full, '=', node.ndef[1], norm=norm)
 
+                link = {'type': 'prop', 'prop': prop.name, 'reverse': True}
                 async for pivo in ngenr:
-                    yield pivo
+                    yield pivo, link
 
         # if dest form is a subtype of a graph "edge", use N1 automatically
         elif isinstance(prop.type, s_types.Edge):
@@ -2209,8 +2218,9 @@ class FormPivot(PivotOper):
             full = prop.name + ':n1'
 
             async def pgenr(node, strict=True):
+                link = {'type': 'prop', 'prop': 'n1', 'reverse': True}
                 async for pivo in runt.snap.nodesByPropValu(full, '=', node.ndef, norm=False):
-                    yield pivo
+                    yield pivo, link
 
         else:
             # form -> form pivot is nonsensical. Lets help out...
@@ -2222,8 +2232,9 @@ class FormPivot(PivotOper):
 
                 # <syn:tag> -> <form> is "from tags to nodes" pivot
                 if node.form.name == 'syn:tag' and prop.isform:
+                    link = {'type': 'tag', 'tag': node.ndef[1], 'reverse': True}
                     async for pivo in runt.snap.nodesByTag(node.ndef[1], form=prop.name):
-                        yield pivo
+                        yield pivo, link
 
                     return
 
@@ -2236,7 +2247,7 @@ class FormPivot(PivotOper):
 
                     pivo = await runt.snap.getNodeByNdef(node.get('n2'))
                     if pivo:
-                        yield pivo
+                        yield pivo, {'type': 'prop', 'prop': 'n2'}
 
                     return
 
@@ -2254,8 +2265,9 @@ class FormPivot(PivotOper):
 
                     refsvalu = node.get(refsname)
                     if refsvalu is not None:
+                        link = {'type': 'prop', 'prop': refsname}
                         async for pivo in runt.snap.nodesByPropValu(refsform, '=', refsvalu, norm=False):
-                            yield pivo
+                            yield pivo, link
 
                 for refsname, refsform in refs.get('array'):
 
@@ -2266,9 +2278,10 @@ class FormPivot(PivotOper):
 
                     refsvalu = node.get(refsname)
                     if refsvalu is not None:
+                        link = {'type': 'prop', 'prop': refsname}
                         for refselem in refsvalu:
                             async for pivo in runt.snap.nodesByPropValu(destform.name, '=', refselem, norm=False):
-                                yield pivo
+                                yield pivo, link
 
                 for refsname in refs.get('ndef'):
 
@@ -2278,17 +2291,18 @@ class FormPivot(PivotOper):
                     if refsvalu is not None and refsvalu[0] == destform.name:
                         pivo = await runt.snap.getNodeByNdef(refsvalu)
                         if pivo is not None:
-                            yield pivo
+                            yield pivo, {'type': 'prop', 'prop': refsname}
 
                 for refsname in refs.get('ndefarray'):
 
                     found = True
 
                     if (refsvalu := node.get(refsname)) is not None:
+                        link = {'type': 'prop', 'prop': refsname}
                         for aval in refsvalu:
                             if aval[0] == destform.name:
                                 if (pivo := await runt.snap.getNodeByNdef(aval)) is not None:
-                                    yield pivo
+                                    yield pivo, link
 
                 #########################################################################
                 # reverse "-> form" pivots (ie inet:fqdn -> inet:dns:a)
@@ -2303,8 +2317,9 @@ class FormPivot(PivotOper):
                     found = True
 
                     refsprop = destform.props.get(refsname)
+                    link = {'type': 'prop', 'prop': refsname, 'reverse': True}
                     async for pivo in runt.snap.nodesByPropValu(refsprop.full, '=', node.ndef[1], norm=False):
-                        yield pivo
+                        yield pivo, link
 
                 # "reverse" array references...
                 for refsname, refsform in refs.get('array'):
@@ -2315,8 +2330,9 @@ class FormPivot(PivotOper):
                     found = True
 
                     destprop = destform.props.get(refsname)
+                    link = {'type': 'prop', 'prop': refsname, 'reverse': True}
                     async for pivo in runt.snap.nodesByPropArray(destprop.full, '=', node.ndef[1], norm=False):
-                        yield pivo
+                        yield pivo, link
 
                 # "reverse" ndef references...
                 for refsname in refs.get('ndef'):
@@ -2324,16 +2340,18 @@ class FormPivot(PivotOper):
                     found = True
 
                     refsprop = destform.props.get(refsname)
+                    link = {'type': 'prop', 'prop': refsname, 'reverse': True}
                     async for pivo in runt.snap.nodesByPropValu(refsprop.full, '=', node.ndef, norm=False):
-                        yield pivo
+                        yield pivo, link
 
                 for refsname in refs.get('ndefarray'):
 
                     found = True
 
                     refsprop = destform.props.get(refsname)
+                    link = {'type': 'prop', 'prop': refsname, 'reverse': True}
                     async for pivo in runt.snap.nodesByPropArray(refsprop.full, '=', node.ndef, norm=False):
-                        yield pivo
+                        yield pivo, link
 
                 if strict and not found:
                     mesg = f'No pivot found for {node.form.name} -> {destform.name}.'
@@ -2361,8 +2379,8 @@ class FormPivot(PivotOper):
 
             async def listpivot(node):
                 for pgenr in pgenrs:
-                    async for pivo in pgenr(node, strict=False):
-                        yield pivo
+                    async for pivo, valu in pgenr(node, strict=False):
+                        yield pivo, valu
 
             return listpivot
 
@@ -2383,8 +2401,8 @@ class FormPivot(PivotOper):
                 yield node, path
 
             try:
-                async for pivo in pgenr(node):
-                    yield pivo, path.fork(pivo)
+                async for pivo, link in pgenr(node):
+                    yield pivo, path.fork(pivo, link)
             except (s_exc.BadTypeValu, s_exc.BadLiftValu) as e:
                 if not warned:
                     logger.warning(f'Caught error during pivot: {e.items()}')
@@ -2420,11 +2438,12 @@ class PropPivotOut(PivotOper):
                 await asyncio.sleep(0)
                 continue
 
+            link = {'type': 'prop', 'prop': prop.name}
             if prop.type.isarray:
                 if isinstance(prop.type.arraytype, s_types.Ndef):
                     for item in valu:
                         if (pivo := await runt.snap.getNodeByNdef(item)) is not None:
-                            yield pivo, path.fork(pivo)
+                            yield pivo, path.fork(pivo, link)
                     continue
 
                 fname = prop.type.arraytype.name
@@ -2437,7 +2456,7 @@ class PropPivotOut(PivotOper):
 
                 for item in valu:
                     async for pivo in runt.snap.nodesByPropValu(fname, '=', item, norm=False):
-                        yield pivo, path.fork(pivo)
+                        yield pivo, path.fork(pivo, link)
 
                 continue
 
@@ -2448,7 +2467,7 @@ class PropPivotOut(PivotOper):
                 if pivo is None:
                     logger.warning(f'Missing node corresponding to ndef {valu}')
                     continue
-                yield pivo, path.fork(pivo)
+                yield pivo, path.fork(pivo, link)
                 continue
 
             # :prop -> *
@@ -2465,7 +2484,7 @@ class PropPivotOut(PivotOper):
             # A node explicitly deleted in the graph or missing from a underlying layer
             # could cause this lift to return None.
             if pivo:
-                yield pivo, path.fork(pivo)
+                yield pivo, path.fork(pivo, link)
 
 
 class PropPivot(PivotOper):
@@ -2477,6 +2496,9 @@ class PropPivot(PivotOper):
 
         async def pgenr(node, srcprop, valu, strict=True):
 
+            link = {'type': 'prop', 'prop': srcprop.name}
+            if not prop.isform:
+                link['dest'] = prop.full
             # pivoting from an array prop to a non-array prop needs an extra loop
             if srcprop.type.isarray and not prop.type.isarray:
                 if isinstance(srcprop.type.arraytype, s_types.Ndef) and prop.isform:
@@ -2485,13 +2507,13 @@ class PropPivot(PivotOper):
                             continue
 
                         if (pivo := await runt.snap.getNodeByNdef(aval)) is not None:
-                            yield pivo
+                            yield pivo, link
                     return
 
                 norm = srcprop.arraytypehash is not prop.typehash
                 for arrayval in valu:
                     async for pivo in runt.snap.nodesByPropValu(prop.full, '=', arrayval, norm=norm):
-                        yield pivo
+                        yield pivo, link
 
                 return
 
@@ -2503,7 +2525,7 @@ class PropPivot(PivotOper):
                 if pivo is None:
                     await runt.snap.warn(f'Missing node corresponding to ndef {valu}', log=False, ndef=valu)
                     return
-                yield pivo
+                yield pivo, link
 
                 return
 
@@ -2515,7 +2537,7 @@ class PropPivot(PivotOper):
                 genr = runt.snap.nodesByPropValu(prop.full, '=', valu, norm=norm)
 
             async for pivo in genr:
-                yield pivo
+                yield pivo, link
 
         return pgenr
 
@@ -2569,8 +2591,8 @@ class PropPivot(PivotOper):
                 continue
 
             try:
-                async for pivo in pgenr(node, srcprop, valu):
-                    yield pivo, path.fork(pivo)
+                async for pivo, link in pgenr(node, srcprop, valu):
+                    yield pivo, path.fork(pivo, link)
 
             except (s_exc.BadTypeValu, s_exc.BadLiftValu) as e:
                 if not warned:
@@ -4218,19 +4240,20 @@ class EditUnivDel(Edit):
 
 class N1Walk(Oper):
 
-    def __init__(self, astinfo, kids=(), isjoin=False):
+    def __init__(self, astinfo, kids=(), isjoin=False, reverse=False):
         Oper.__init__(self, astinfo, kids=kids)
         self.isjoin = isjoin
+        self.reverse = reverse
 
     def repr(self):
         return f'{self.__class__.__name__}: {self.kids}, isjoin={self.isjoin}'
 
     async def walkNodeEdges(self, runt, node, verb=None):
-        async for _, iden in node.iterEdgesN1(verb=verb):
+        async for verb, iden in node.iterEdgesN1(verb=verb):
             buid = s_common.uhex(iden)
             walknode = await runt.snap.getNodeByBuid(buid)
             if walknode is not None:
-                yield walknode
+                yield verb, walknode
 
     def buildfilter(self, runt, destforms, cmpr):
 
@@ -4330,21 +4353,28 @@ class N1Walk(Oper):
                 if verb == '*':
                     verb = None
 
-                async for walknode in self.walkNodeEdges(runt, node, verb=verb):
+                async for verbname, walknode in self.walkNodeEdges(runt, node, verb=verb):
 
                     if destfilt and not await destfilt(walknode, path, cmprvalu):
                         continue
 
-                    yield walknode, path.fork(walknode)
+                    link = {'type': 'edge', 'verb': verbname}
+                    if self.reverse:
+                        link['reverse'] = True
+
+                    yield walknode, path.fork(walknode, link)
 
 class N2Walk(N1Walk):
 
+    def __init__(self, astinfo, kids=(), isjoin=False):
+        N1Walk.__init__(self, astinfo, kids=kids, isjoin=isjoin, reverse=True)
+
     async def walkNodeEdges(self, runt, node, verb=None):
-        async for _, iden in node.iterEdgesN2(verb=verb):
+        async for verb, iden in node.iterEdgesN2(verb=verb):
             buid = s_common.uhex(iden)
             walknode = await runt.snap.getNodeByBuid(buid)
             if walknode is not None:
-                yield walknode
+                yield verb, walknode
 
 class EditEdgeAdd(Edit):
 

synapse/lib/layer.py

@@ -2723,7 +2723,7 @@ class Layer(s_nexus.Pusher):
     async def _initLayerStorage(self):
 
         slabopts = {
-            'readahead': True,
+            'readahead': s_common.envbool('SYNDEV_CORTEX_LAYER_READAHEAD', 'true'),
             'lockmemory': self.lockmemory,
         }
 

synapse/lib/lmdbslab.py

@@ -834,6 +834,7 @@ class Slab(s_base.Base):
                 'xactops': len(slab.xactops),
                 'mapsize': slab.mapsize,
                 'readonly': slab.readonly,
+                'readahead': slab.readahead,
                 'lockmemory': slab.lockmemory,
                 'recovering': slab.recovering,
                 'maxsize': slab.maxsize,
@@ -889,6 +890,7 @@ class Slab(s_base.Base):
         self.growsize = opts.pop('growsize', self.DEFAULT_GROWSIZE)
 
         self.readonly = opts.get('readonly', False)
+        self.readahead = opts.get('readahead', True)
         self.lockmemory = opts.pop('lockmemory', False)
 
         if self.lockmemory:

synapse/lib/modelrev.py

@@ -8,7 +8,7 @@ import synapse.lib.layer as s_layer
 
 logger = logging.getLogger(__name__)
 
-maxvers = (0, 2, 26)
+maxvers = (0, 2, 27)
 
 class ModelRev:
 
@@ -40,6 +40,7 @@ class ModelRev:
             ((0, 2, 24), self.revModel_0_2_24),
             ((0, 2, 25), self.revModel_0_2_25),
             ((0, 2, 26), self.revModel_0_2_26),
+            ((0, 2, 27), self.revModel_0_2_27),
         )
 
     async def _uniqSortArray(self, todoprops, layers):
@@ -783,6 +784,9 @@ class ModelRev:
                 logger.info(f'Updating ndef indexing for {name}')
                 await self._updatePropStortype(layers, prop.full)
 
+    async def revModel_0_2_27(self, layers):
+        await self._normPropValu(layers, 'it:dev:repo:commit:id')
+
     async def runStorm(self, text, opts=None):
         '''
         Run storm code in a schedcoro and log the output messages.

synapse/lib/node.py

@@ -708,11 +708,16 @@ class Path:
     '''
     A path context tracked through the storm runtime.
     '''
-    def __init__(self, vars, nodes):
+    def __init__(self, vars, nodes, links=None):
 
         self.node = None
         self.nodes = nodes
 
+        if links is not None:
+            self.links = links
+        else:
+            self.links = []
+
         if len(nodes):
             self.node = nodes[-1]
 
@@ -765,19 +770,24 @@ class Path:
         info = await s_stormtypes.toprim(dict(self.metadata))
         if path:
             info['nodes'] = [node.iden() for node in self.nodes]
+
         return info
 
-    def fork(self, node):
+    def fork(self, node, link):
+
+        links = list(self.links)
+        if self.node is not None and link is not None:
+            links.append((self.node.iden(), link))
 
         nodes = list(self.nodes)
         nodes.append(node)
 
-        path = Path(self.vars.copy(), nodes)
+        path = Path(self.vars.copy(), nodes, links=links)
 
         return path
 
     def clone(self):
-        path = Path(copy.copy(self.vars), copy.copy(self.nodes))
+        path = Path(copy.copy(self.vars), copy.copy(self.nodes), copy.copy(self.links))
         path.frames = [v.copy() for v in self.frames]
         return path