synapse 2.195.1__py311-none-any.whl → 2.197.0__py311-none-any.whl

synapse/tests/test_telepath.py

@@ -54,6 +54,9 @@ class Beep:
     def beep(self):
         return f'{self.path}: beep'
 
+    def genbeep(self):
+        yield self.beep()
+
 class Foo:
 
     def __init__(self):
@@ -138,6 +141,9 @@ class TeleApi:
     def getFooBar(self, x, y):
         return x - y
 
+    def genGetFooBar(self, x, y):
+        yield self.getFooBar(x, y)
+
     async def customshare(self):
         return await CustomShare.anit(self.link, 42)
 
@@ -160,6 +166,11 @@ class TeleAware(s_telepath.Aware):
 
         return self._initBeep(path[0])
 
+    async def getTeleFeats(self):
+        return {
+            'aware': 1,
+        }
+
 class TeleAuth(s_telepath.Aware):
 
     def getTeleApi(self, link, mesg, path):
@@ -632,7 +643,15 @@ class TeleTest(s_t_utils.SynTest):
                 self.len(1, snfo)
                 self.eq(snfo[0].get('items'), {None: 'synapse.tests.test_telepath.TeleApi'})
 
+                self.true(proxy._hasTeleFeat('aware'))
+                self.false(proxy._hasTeleFeat('aware', vers=2))
+                self.false(proxy._hasTeleFeat('newp'))
+
+                self.true(proxy._hasTeleMeth('getFooBar'))
+                self.false(proxy._hasTeleMeth('getBarBaz'))
+
                 self.eq(10, await proxy.getFooBar(20, 10))
+                self.eq([10], [m async for m in await proxy.genGetFooBar(20, 10)])
 
                 # check a custom share works
                 obj = await proxy.customshare()
@@ -674,7 +693,14 @@ class TeleTest(s_t_utils.SynTest):
 
             # check that a dynamic share works
             async with await self.getTestProxy(dmon, 'woke/up') as proxy:
+                self.isin('synapse.tests.test_telepath.Beep', proxy._getClasses())
+                self.notin('synapse.tests.test_telepath.TeleApi', proxy._getClasses())
                 self.eq('up: beep', await proxy.beep())
+                self.eq(['up: beep'], [m async for m in await proxy.genbeep()])
+                # Telepath features are a function of the base object, not the result of getTeleApi
+                self.true(proxy._hasTeleFeat('aware'))
+                self.false(proxy._hasTeleFeat('aware', vers=2))
+                self.false(proxy._hasTeleFeat('newp'))
 
     async def test_telepath_auth(self):
 

synapse/tests/test_tools_aha.py

@@ -3,14 +3,17 @@ import shutil
 
 from unittest import mock
 
+import synapse.exc as s_exc
 import synapse.common as s_common
 import synapse.lib.cell as s_cell
+import synapse.lib.version as s_version
 
 import synapse.tests.utils as s_t_utils
 
 import synapse.tools.aha.list as s_a_list
 import synapse.tools.aha.clone as s_a_clone
 import synapse.tools.aha.enroll as s_a_enroll
+import synapse.tools.aha.mirror as s_a_mirror
 import synapse.tools.aha.easycert as s_a_easycert
 import synapse.tools.aha.provision.user as s_a_provision_user
 
@@ -170,3 +173,192 @@ class AhaToolsTest(s_t_utils.SynTest):
 
                 teleyaml = s_common.yamlload(syndir, 'telepath.yaml')
                 self.eq(teleyaml.get('version'), 1)
+
+    async def test_aha_mirror(self):
+
+        async with self.getTestAha() as aha:
+
+            base_svcinfo = {
+                'iden': 'test_iden',
+                'leader': 'leader',
+                'urlinfo': {
+                    'scheme': 'tcp',
+                    'host': '127.0.0.1',
+                    'port': 0,
+                    'hostname': 'test.host'
+                }
+            }
+
+            conf_no_iden = {'aha:provision': await aha.addAhaSvcProv('no.iden')}
+            async with self.getTestCell(s_cell.Cell, conf=conf_no_iden) as cell_no_iden:
+                svcinfo = {k: v for k, v in base_svcinfo.items() if k != 'iden'}
+                await aha.addAhaSvc('no.iden', svcinfo)
+
+                argv = ['--url', aha.getLocalUrl()]
+                retn, outp = await self.execToolMain(s_a_mirror.main, argv)
+                self.eq(retn, 0)
+                outp.expect('Service Mirror Groups:')
+                self.notin('no.iden', str(outp))
+
+            conf_no_host = {'aha:provision': await aha.addAhaSvcProv('no.host')}
+            async with self.getTestCell(s_cell.Cell, conf=conf_no_host) as cell_no_host:
+                svcinfo = dict(base_svcinfo)
+                svcinfo['urlinfo'] = {k: v for k, v in base_svcinfo['urlinfo'].items() if k != 'hostname'}
+                await aha.addAhaSvc('no.host', svcinfo)
+
+                argv = ['--url', aha.getLocalUrl()]
+                retn, outp = await self.execToolMain(s_a_mirror.main, argv)
+                self.eq(retn, 0)
+                outp.expect('Service Mirror Groups:')
+                self.notin('no.host', str(outp))
+
+            conf_no_leader = {'aha:provision': await aha.addAhaSvcProv('no.leader')}
+            async with self.getTestCell(s_cell.Cell, conf=conf_no_leader) as cell_no_leader:
+                svcinfo = {k: v for k, v in base_svcinfo.items() if k != 'leader'}
+                await aha.addAhaSvc('no.leader', svcinfo)
+
+                argv = ['--url', aha.getLocalUrl()]
+                retn, outp = await self.execToolMain(s_a_mirror.main, argv)
+                self.eq(retn, 0)
+                outp.expect('Service Mirror Groups:')
+                self.notin('no.leader', str(outp))
+
+            conf_no_primary = {'aha:provision': await aha.addAhaSvcProv('no.primary')}
+            async with self.getTestCell(s_cell.Cell, conf=conf_no_primary) as cell_no_primary:
+                svcinfo = dict(base_svcinfo)
+                svcinfo['urlinfo']['hostname'] = 'nonexistent.host'
+                await aha.addAhaSvc('no.primary', svcinfo)
+
+            async with aha.waiter(3, 'aha:svcadd', timeout=10):
+
+                conf = {'aha:provision': await aha.addAhaSvcProv('00.cell')}
+                cell00 = await aha.enter_context(self.getTestCell(conf=conf))
+
+                conf = {'aha:provision': await aha.addAhaSvcProv('01.cell', {'mirror': 'cell'})}
+                cell01 = await aha.enter_context(self.getTestCell(conf=conf))
+
+                await cell01.sync()
+
+            ahaurl = aha.getLocalUrl()
+
+            argv = ['--url', ahaurl]
+            retn, outp = await self.execToolMain(s_a_mirror.main, argv)
+            self.eq(retn, 0)
+            outp.expect('Service Mirror Groups:')
+            outp.expect('00.cell.synapse')
+            outp.expect('01.cell.synapse')
+            outp.expect('Group Status: In Sync')
+
+            argv = ['--url', ahaurl, '--timeout', '30']
+            retn, outp = await self.execToolMain(s_a_mirror.main, argv)
+            self.eq(retn, 0)
+
+            with mock.patch('synapse.telepath.Proxy._hasTeleFeat',
+                          return_value=False):
+                argv = ['--url', ahaurl]
+                retn, outp = await self.execToolMain(s_a_mirror.main, argv)
+                self.eq(retn, 1)
+                outp.expect(f'Service at {ahaurl} does not support the required callpeers feature.')
+
+            with mock.patch('synapse.telepath.Proxy._hasTeleFeat',
+                          side_effect=s_exc.NoSuchMeth(name='_hasTeleFeat')):
+                argv = ['--url', ahaurl]
+                retn, outp = await self.execToolMain(s_a_mirror.main, argv)
+                self.eq(retn, 1)
+                outp.expect(f'Service at {ahaurl} does not support the required callpeers feature.')
+
+            argv = ['--url', 'tcp://newp:1234/']
+            retn, outp = await self.execToolMain(s_a_mirror.main, argv)
+            self.eq(retn, 1)
+            outp.expect('ERROR:')
+
+            async def mockCellInfo():
+                return {
+                    'cell': {'ready': True, 'nexsindx': 10, 'uplink': None},
+                    'synapse': {'verstring': s_version.verstring},
+                }
+
+            async def mockOutOfSyncCellInfo():
+                return {
+                    'cell': {'ready': True, 'nexsindx': 5, 'uplink': cell00.iden},
+                    'synapse': {'verstring': s_version.verstring},
+                }
+
+            with mock.patch.object(cell00, 'getCellInfo', mockCellInfo):
+                with mock.patch.object(cell01, 'getCellInfo', mockOutOfSyncCellInfo):
+                    async def mock_call_aha(*args, **kwargs):
+                        todo = args[1]
+                        if todo[0] == 'waitNexsOffs':
+                            yield ('00.cell.synapse', (True, True))
+                            yield ('01.cell.synapse', (True, True))
+                        elif todo[0] == 'getCellInfo':
+                            if not hasattr(mock_call_aha, 'called'):
+                                mock_call_aha.called = True
+                                yield ('00.cell.synapse', (True, await mockCellInfo()))
+                                yield ('01.cell.synapse', (True, await mockOutOfSyncCellInfo()))
+                            else:
+                                yield ('00.cell.synapse', (True, await mockCellInfo()))
+                                yield ('01.cell.synapse', (True, await mockCellInfo()))
+
+                    with mock.patch.object(aha, 'callAhaPeerApi', mock_call_aha):
+                        argv = ['--url', ahaurl, '--wait']
+                        retn, outp = await self.execToolMain(s_a_mirror.main, argv)
+                        self.eq(retn, 0)
+                        outp.expect('Group Status: Out of Sync')
+                        outp.expect('Updated status:')
+                        outp.expect('Group Status: In Sync')
+
+            with mock.patch.object(cell00, 'getCellInfo', mockCellInfo):
+                with mock.patch.object(cell01, 'getCellInfo', mockOutOfSyncCellInfo):
+                    argv = ['--url', ahaurl, '--timeout', '1']
+                    retn, outp = await self.execToolMain(s_a_mirror.main, argv)
+                    self.eq(retn, 0)
+                    outp.expect('Group Status: Out of Sync')
+
+            async with self.getTestCore() as core:
+                curl = core.getLocalUrl()
+                argv = ['--url', curl]
+                with mock.patch('synapse.telepath.Proxy._hasTeleFeat',
+                          return_value=True):
+                    retn, outp = await self.execToolMain(s_a_mirror.main, argv)
+                    self.eq(1, retn)
+                    outp.expect(f'Service at {curl} is not an Aha server')
+
+            async with aha.waiter(1, 'aha:svcadd', timeout=10):
+
+                conf = {'aha:provision': await aha.addAhaSvcProv('02.cell', {'mirror': 'cell'})}
+                cell02 = await aha.enter_context(self.getTestCell(conf=conf))
+                await cell02.sync()
+
+            async def mock_failed_api(*args, **kwargs):
+                yield ('00.cell.synapse', (True, {'cell': {'ready': True, 'nexsindx': 10}}))
+                yield ('01.cell.synapse', (False, 'error'))
+                yield ('02.cell.synapse', (True, {'cell': {'ready': True, 'nexsindx': 12}}))
+
+            with mock.patch.object(aha, 'callAhaPeerApi', mock_failed_api):
+                argv = ['--url', ahaurl, '--timeout', '1']
+                retn, outp = await self.execToolMain(s_a_mirror.main, argv)
+                outp.expect('00.cell.synapse                          leader     True     True    127.0.0.1', whitespace=False)
+                outp.expect('nexsindx      10', whitespace=False)
+                outp.expect('02.cell.synapse                          leader     True     True    127.0.0.1', whitespace=False)
+                outp.expect('nexsindx      12', whitespace=False)
+                outp.expect('01.cell.synapse                          <unknown>  True     True', whitespace=False)
+                outp.expect('<unknown>    <unknown>', whitespace=False)
+
+        self.eq(s_a_mirror.timeout_type('30'), 30)
+        self.eq(s_a_mirror.timeout_type('0'), 0)
+
+        with self.raises(s_exc.BadArg) as cm:
+            s_a_mirror.timeout_type('-1')
+        self.isin('is not a valid non-negative integer', cm.exception.get('mesg'))
+
+        with self.raises(s_exc.BadArg) as cm:
+            s_a_mirror.timeout_type('foo')
+        self.isin('is not a valid non-negative integer', cm.exception.get('mesg'))
+
+        synerr = s_exc.SynErr(mesg='Oof')
+        with mock.patch('synapse.telepath.openurl', side_effect=synerr):
+            argv = ['--url', 'tcp://test:1234/']
+            retn, outp = await self.execToolMain(s_a_mirror.main, argv)
+            self.eq(retn, 1)
+            outp.expect('ERROR: Oof')

synapse/tools/aha/mirror.py

@@ -0,0 +1,193 @@
+import sys
+import asyncio
+import argparse
+
+import synapse.exc as s_exc
+import synapse.common as s_common
+import synapse.telepath as s_telepath
+
+import synapse.lib.output as s_output
+import synapse.lib.version as s_version
+
+descr = '''
+Query the Aha server for the service cluster status of mirrors.
+
+Examples:
+
+    python -m synapse.tools.aha.mirror --timeout 30
+
+'''
+
+async def get_cell_infos(prox, iden, members, timeout):
+    cell_infos = {}
+    if iden is not None:
+        todo = s_common.todo('getCellInfo')
+        async for svcname, (ok, info) in prox.callAhaPeerApi(iden, todo, timeout=timeout):
+            if not ok:
+                continue
+            cell_infos[svcname] = info
+    return cell_infos
+
+def build_status_list(members, cell_infos):
+    group_status = []
+    for svc in members:
+        svcname = svc.get('name')
+        svcinfo = svc.get('svcinfo', {})
+        status = {
+            'name': svcname,
+            'role': '<unknown>',
+            'online': str('online' in svcinfo),
+            'ready': 'True',
+            'host': svcinfo.get('urlinfo', {}).get('host', ''),
+            'port': str(svcinfo.get('urlinfo', {}).get('port', '')),
+            'version': '<unknown>',
+            'nexs_indx': 0
+        }
+        if svcname in cell_infos:
+            info = cell_infos[svcname]
+            cell_info = info.get('cell', {})
+            status.update({
+                'nexs_indx': cell_info.get('nexsindx', 0),
+                'role': 'follower' if cell_info.get('uplink') else 'leader',
+                'version': str(info.get('synapse', {}).get('verstring', '')),
+                'online': 'True',
+                'ready': str(cell_info.get('ready', False))
+            })
+        group_status.append(status)
+    return group_status
+
+def output_status(outp, vname, group_status):
+    header = ' {:<40} {:<10} {:<8} {:<7} {:<16} {:<9} {:<12} {:<10}'.format(
+        'name', 'role', 'online', 'ready', 'host', 'port', 'version', 'nexus idx')
+    outp.printf(header)
+    outp.printf('#' * 120)
+    outp.printf(vname)
+    for status in group_status:
+        if status['nexs_indx'] == 0:
+            status['nexs_indx'] = '<unknown>'
+        line = ' {name:<40} {role:<10} {online:<8} {ready:<7} {host:<16} {port:<9} {version:<12} {nexs_indx:<10}'.format(**status)
+        outp.printf(line)
+
+def check_sync_status(group_status):
+    indices = {status['nexs_indx'] for status in group_status}
+    known_count = sum(1 for status in group_status)
+    return len(indices) == 1 and known_count == len(group_status)
+
+def timeout_type(valu):
+    try:
+        ivalu = int(valu)
+        if ivalu < 0:
+            raise ValueError
+    except ValueError:
+        raise s_exc.BadArg(mesg=f"{valu} is not a valid non-negative integer")
+    return ivalu
+
+async def main(argv, outp=s_output.stdout):
+
+    pars = argparse.ArgumentParser(prog='synapse.tools.aha.mirror', description=descr,
+                        formatter_class=argparse.RawDescriptionHelpFormatter)
+
+    pars.add_argument('--url', default='cell:///vertex/storage', help='The telepath URL to connect to the AHA service.')
+    pars.add_argument('--timeout', type=timeout_type, default=10, help='The timeout in seconds for individual service API calls')
+    pars.add_argument('--wait', action='store_true', help='Whether to wait for the mirrors to sync.')
+    opts = pars.parse_args(argv)
+
+    async with s_telepath.withTeleEnv():
+        try:
+            async with await s_telepath.openurl(opts.url) as prox:
+                try:
+                    if not prox._hasTeleFeat('callpeers', vers=1):
+                        outp.printf(f'Service at {opts.url} does not support the required callpeers feature.')
+                        return 1
+                except s_exc.NoSuchMeth:
+                    outp.printf(f'Service at {opts.url} does not support the required callpeers feature.')
+                    return 1
+                classes = prox._getClasses()
+                if 'synapse.lib.aha.AhaApi' not in classes:
+                    outp.printf(f'Service at {opts.url} is not an Aha server')
+                    return 1
+
+                virtual_services, member_servers = {}, {}
+                async for svc in prox.getAhaSvcs():
+                    name = svc.get('name', '')
+                    svcinfo = svc.get('svcinfo', {})
+                    urlinfo = svcinfo.get('urlinfo', {})
+                    hostname = urlinfo.get('hostname', '')
+
+                    if name != hostname:
+                        virtual_services[name] = svc
+                    else:
+                        member_servers[name] = svc
+
+                mirror_groups = {}
+                for vname, vsvc in virtual_services.items():
+                    vsvc_info = vsvc.get('svcinfo', {})
+                    vsvc_iden = vsvc_info.get('iden')
+                    vsvc_leader = vsvc_info.get('leader')
+                    vsvc_hostname = vsvc_info.get('urlinfo', {}).get('hostname', '')
+
+                    if not vsvc_iden or not vsvc_hostname or not vsvc_leader:
+                        continue
+
+                    primary_member = member_servers.get(vsvc_hostname)
+                    if not primary_member:
+                        continue
+
+                    members = [primary_member] + [
+                        msvc for mname, msvc in member_servers.items()
+                        if mname != vsvc_hostname and
+                        msvc.get('svcinfo', {}).get('iden') == vsvc_iden and
+                        msvc.get('svcinfo', {}).get('leader') == vsvc_leader
+                    ]
+
+                    if len(members) > 1:
+                        mirror_groups[vname] = members
+
+                outp.printf('Service Mirror Groups:')
+                for vname, members in mirror_groups.items():
+                    iden = members[0].get('svcinfo', {}).get('iden')
+
+                    cell_infos = await get_cell_infos(prox, iden, members, opts.timeout)
+                    group_status = build_status_list(members, cell_infos)
+                    output_status(outp, vname, group_status)
+
+                    if check_sync_status(group_status):
+                        outp.printf('Group Status: In Sync')
+                    else:
+                        outp.printf(f'Group Status: Out of Sync')
+                        if opts.wait:
+                            leader_nexs = None
+                            for status in group_status:
+                                if status['role'] == 'leader' and isinstance(status['nexs_indx'], int):
+                                    leader_nexs = status['nexs_indx']
+
+                            if leader_nexs is not None:
+                                while True:
+                                    responses = []
+                                    todo = s_common.todo('waitNexsOffs', leader_nexs - 1, timeout=opts.timeout)
+                                    async for svcname, (ok, info) in prox.callAhaPeerApi(iden, todo, timeout=opts.timeout):
+                                        if ok and info:
+                                            responses.append((svcname, info))
+
+                                    if len(responses) == len(members):
+                                        cell_infos = await get_cell_infos(prox, iden, members, opts.timeout)
+                                        group_status = build_status_list(members, cell_infos)
+
+                                        outp.printf('\nUpdated status:')
+                                        output_status(outp, vname, group_status)
+
+                                        if check_sync_status(group_status):
+                                            outp.printf('Group Status: In Sync')
+                                            break
+
+                return 0
+
+        except Exception as e:
+            mesg = repr(e)
+            if isinstance(e, s_exc.SynErr):
+                mesg = e.errinfo.get('mesg', repr(e))
+            outp.printf(f'ERROR: {mesg}')
+            return 1
+
+if __name__ == '__main__':  # pragma: no cover
+    sys.exit(asyncio.run(main(sys.argv[1:])))

synapse/tools/changelog.py

@@ -886,34 +886,8 @@ async def format(opts: argparse.Namespace,
     modeldiff = False
     clean_vers_ref = opts.version.replace(".", "_")
     model_rst_ref = f'userguide_model_{clean_vers_ref}'
-    for key, header in s_schemas._changelogTypes.items():
-        dataz = entries.get(key)
-        if dataz:
-            text = text + f'\n{header}\n{"-" * len(header)}'
-            dataz.sort(key=lambda x: x.get('prs'))
-            for data in dataz:
-                desc = data.get('desc')  # type: str
-                desc_lines = desc.splitlines()
-                for i, chunk in enumerate(desc_lines):
-                    if i == 0:
-                        for line in textwrap.wrap(chunk, initial_indent='- ', subsequent_indent='  ', width=opts.width):
-                            text = f'{text}\n{line}'
-                    else:
-                        text = text + '\n'
-                        for line in textwrap.wrap(chunk, initial_indent='  ', subsequent_indent='  ', width=opts.width):
-                            text = f'{text}\n{line}'
-
-                if not opts.hide_prs:
-                    for pr in data.get('prs'):
-                        text = f'{text}\n  (`#{pr} <https://github.com/vertexproject/synapse/pull/{pr}>`_)'
-            if key == 'migration':
-                text = text + '\n- See :ref:`datamigration` for more information about automatic migrations.'
-            elif key == 'model':
-                text = text + f'\n- See :ref:`{model_rst_ref}` for more detailed model changes.'
-                modeldiff = True
-            text = text + '\n'
 
-    if modeldiff and opts.model_ref:
+    if opts.model_ref:
         # TODO find previous model file automatically?
         if opts.verbose:
             outp.printf(f'Getting reference model from {opts.model_ref}')
@@ -934,6 +908,8 @@ async def format(opts: argparse.Namespace,
         changes = differ.diffModl(outp)
         has_changes = sum([len(v) for v in changes.values()])
         if has_changes:
+            entries['model'].append({'prs': [], 'type': 'skip'})
+            modeldiff = True
             rst = _gen_model_rst(opts.version, model_rst_ref, changes, cur_modl, outp, width=opts.width)
             model_text = rst.getRstText()
             if opts.verbose:
@@ -955,6 +931,35 @@ async def format(opts: argparse.Namespace,
         else:
             outp.printf(f'No model changes detected.')
 
+    for key, header in s_schemas._changelogTypes.items():
+        dataz = entries.get(key)
+        if dataz:
+            text = text + f'\n{header}\n{"-" * len(header)}'
+            dataz.sort(key=lambda x: x.get('prs'))
+            for data in dataz:
+                desc = data.get('desc')  # type: str
+                if desc is None and data.get('type') == 'skip':
+                    continue
+                desc_lines = desc.splitlines()
+                for i, chunk in enumerate(desc_lines):
+                    if i == 0:
+                        for line in textwrap.wrap(chunk, initial_indent='- ', subsequent_indent='  ', width=opts.width):
+                            text = f'{text}\n{line}'
+                    else:
+                        text = text + '\n'
+                        for line in textwrap.wrap(chunk, initial_indent='  ', subsequent_indent='  ', width=opts.width):
+                            text = f'{text}\n{line}'
+
+                if not opts.hide_prs:
+                    for pr in data.get('prs'):
+                        text = f'{text}\n  (`#{pr} <https://github.com/vertexproject/synapse/pull/{pr}>`_)'
+            if key == 'migration':
+                text = text + '\n- See :ref:`datamigration` for more information about automatic migrations.'
+            elif key == 'model':
+                if modeldiff:
+                    text = text + f'\n- See :ref:`{model_rst_ref}` for more detailed model changes.'
+            text = text + '\n'
+
     if opts.rm:
         if opts.verbose:
             outp.printf('Staging file removals in git')

synapse/tools/genpkg.py

@@ -12,10 +12,10 @@ import synapse.exc as s_exc
 import synapse.common as s_common
 import synapse.telepath as s_telepath
 
-import synapse.lib.storm as s_storm
 import synapse.lib.output as s_output
 import synapse.lib.certdir as s_certdir
 import synapse.lib.dyndeps as s_dyndeps
+import synapse.lib.schemas as s_schemas
 
 logger = logging.getLogger(__name__)
 
@@ -221,7 +221,7 @@ def loadPkgProto(path, opticdir=None, no_docs=False, readonly=False):
         pkgdef['optic'].setdefault('files', {})
         loadOpticFiles(pkgdef, opticdir)
 
-    s_storm.reqValidPkgdef(pkgdef)
+    s_schemas.reqValidPkgdef(pkgdef)
 
     # Ensure the package is json safe and tuplify it.
     s_common.reqJsonSafeStrict(pkgdef)

{synapse-2.195.1.dist-info → synapse-2.197.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: synapse
-Version: 2.195.1
+Version: 2.197.0
 Summary: Synapse Intelligence Analysis Framework
 Author-email: The Vertex Project LLC <root@vertex.link>
 License: Apache License 2.0