synapse 2.184.0__py311-none-any.whl → 2.185.0__py311-none-any.whl

synapse/lib/stormtypes.py

@@ -1328,6 +1328,22 @@ class LibBase(Lib):
                   ),
                   'returns': {'type': 'list',
                               'desc': 'A list of (<bool>, <prim>) for status and normalized value.', }}},
+        {'name': 'repr', 'desc': '''
+            Attempt to convert a system mode value to a display mode string.
+
+            Examples:
+                Print the Synapse user name for an iden::
+
+                    $lib.print($lib.repr(syn:user, $iden))
+
+         ''',
+         'type': {'type': 'function', '_funcname': '_repr',
+                  'args': (
+                      {'name': 'name', 'type': 'str', 'desc': 'The name of the model type.'},
+                      {'name': 'valu', 'type': 'any', 'desc': 'The value to convert.'},
+                  ),
+                  'returns': {'type': 'str', 'desc': 'A display mode representation of the value.'}}},
+
         {'name': 'debug', 'desc': '''
             True if the current runtime has debugging enabled.
 
@@ -1400,6 +1416,7 @@ class LibBase(Lib):
             'false': False,
             'text': self._text,
             'cast': self._cast,
+            'repr': self._repr,
             'warn': self._warn,
             'print': self._print,
             'raise': self._raise,
@@ -1489,22 +1506,26 @@ class LibBase(Lib):
             mesg = 'Nested type does not support being copied!'
             raise s_exc.BadArg(mesg=mesg) from None
 
+    def _reqTypeByName(self, name):
+        typeitem = self.runt.snap.core.model.type(name)
+        if typeitem is not None:
+            return typeitem
+
+        # If a type cannot be found for the form, see if name is a property
+        # that has a type we can use
+        propitem = self.runt.snap.core.model.prop(name)
+        if propitem is not None:
+            return propitem.type
+
+        mesg = f'No type or prop found for name {name}.'
+        raise s_exc.NoSuchType(mesg=mesg)
+
     @stormfunc(readonly=True)
     async def _cast(self, name, valu):
         name = await toprim(name)
         valu = await toprim(valu)
 
-        typeitem = self.runt.snap.core.model.type(name)
-        if typeitem is None:
-            # If a type cannot be found for the form, see if name is a property
-            # that has a type we can use
-            propitem = self.runt.snap.core.model.prop(name)
-            if propitem is None:
-                mesg = f'No type or prop found for name {name}.'
-                raise s_exc.NoSuchType(mesg=mesg)
-
-            typeitem = propitem.type
-
+        typeitem = self._reqTypeByName(name)
         # TODO an eventual mapping between model types and storm prims
 
         norm, info = typeitem.norm(valu)
@@ -1515,16 +1536,7 @@ class LibBase(Lib):
         name = await toprim(name)
         valu = await toprim(valu)
 
-        typeitem = self.runt.snap.core.model.type(name)
-        if typeitem is None:
-            # If a type cannot be found for the form, see if name is a property
-            # that has a type we can use
-            propitem = self.runt.snap.core.model.prop(name)
-            if propitem is None:
-                mesg = f'No type or prop found for name {name}.'
-                raise s_exc.NoSuchType(mesg=mesg)
-
-            typeitem = propitem.type
+        typeitem = self._reqTypeByName(name)
 
         try:
             norm, info = typeitem.norm(valu)
@@ -1532,6 +1544,13 @@ class LibBase(Lib):
         except s_exc.BadTypeValu:
             return (False, None)
 
+    @stormfunc(readonly=True)
+    async def _repr(self, name, valu):
+        name = await toprim(name)
+        valu = await toprim(valu)
+
+        return self._reqTypeByName(name).repr(valu)
+
     @stormfunc(readonly=True)
     async def _exit(self, mesg=None, **kwargs):
         if mesg:
@@ -1720,7 +1739,7 @@ class LibDict(Lib):
          'type': {'type': 'function', '_funcname': '_has',
                   'args': (
                       {'name': 'valu', 'type': 'dict', 'desc': 'The dictionary being checked.'},
-                      {'name': 'name', 'type': 'str', 'desc': 'The key name to check.'},
+                      {'name': 'key', 'type': 'any', 'desc': 'The key to check.'},
                   ),
                   'returns': {'type': 'boolean', 'desc': 'True if the key is present, false if the key is not present.'}}},
         {'name': 'keys', 'desc': 'Retrieve a list of keys in the specified dictionary.',
@@ -1733,7 +1752,7 @@ class LibDict(Lib):
          'type': {'type': 'function', '_funcname': '_pop',
                   'args': (
                       {'name': 'valu', 'type': 'dict', 'desc': 'The dictionary to operate on.'},
-                      {'name': 'key', 'type': 'str', 'desc': 'The key name of the value to pop.'},
+                      {'name': 'key', 'type': 'any', 'desc': 'The key to pop.'},
                       {'name': 'default', 'type': 'any', 'default': '$lib.undef',
                        'desc': 'Optional default value to return if the key does not exist in the dictionary.'},
                   ),
@@ -1776,10 +1795,11 @@ class LibDict(Lib):
         raise s_exc.BadArg(mesg=mesg)
 
     @stormfunc(readonly=True)
-    async def _has(self, valu, name):
+    async def _has(self, valu, key):
         await self._check_type(valu)
+        key = await toprim(key)
         valu = await toprim(valu)
-        return name in valu
+        return key in valu
 
     @stormfunc(readonly=True)
     async def _keys(self, valu):
@@ -1791,8 +1811,8 @@ class LibDict(Lib):
     async def _pop(self, valu, key, default=undef):
         await self._check_type(valu)
 
+        key = await toprim(key)
         real = await toprim(valu)
-        key = await tostr(key)
 
         if key not in real:
             if default == undef:
@@ -4808,8 +4828,8 @@ class Dict(Prim):
         name = await toprim(name)
         return self.valu.get(name)
 
-    async def value(self):
-        return {await toprim(k): await toprim(v) for (k, v) in self.valu.items()}
+    async def value(self, use_list=False):
+        return {await toprim(k): await toprim(v, use_list=use_list) for (k, v) in self.valu.items()}
 
     async def stormrepr(self):
         reprs = ["{}: {}".format(await torepr(k), await torepr(v)) for (k, v) in list(self.valu.items())]
@@ -4845,9 +4865,9 @@ class CmdOpts(Dict):
         name = await tostr(name)
         return getattr(self.valu.opts, name, None)
 
-    async def value(self):
+    async def value(self, use_list=False):
         valu = vars(self.valu.opts)
-        return {await toprim(k): await toprim(v) for (k, v) in valu.items()}
+        return {await toprim(k): await toprim(v, use_list=use_list) for (k, v) in valu.items()}
 
     async def iter(self):
         valu = vars(self.valu.opts)
@@ -5193,8 +5213,10 @@ class List(Prim):
         async for item in toiter(valu):
             self.valu.append(item)
 
-    async def value(self):
-        return tuple([await toprim(v) for v in self.valu])
+    async def value(self, use_list=False):
+        if use_list:
+            return [await toprim(v, use_list=use_list) for v in self.valu]
+        return tuple([await toprim(v, use_list=use_list) for v in self.valu])
 
     async def iter(self):
         for item in self.valu:
@@ -9476,7 +9498,7 @@ class CronJob(Prim):
         return job
 
 # These will go away once we have value objects in storm runtime
-async def toprim(valu, path=None):
+async def toprim(valu, path=None, use_list=False):
 
     if isinstance(valu, (str, int, bool, float, bytes, types.AsyncGeneratorType, types.GeneratorType)) or valu is None:
         return valu
@@ -9485,16 +9507,19 @@ async def toprim(valu, path=None):
         retn = []
         for v in valu:
             try:
-                retn.append(await toprim(v))
+                retn.append(await toprim(v, use_list=use_list))
             except s_exc.NoSuchType:
                 pass
-        return tuple(retn)
+
+        if not use_list:
+            return tuple(retn)
+        return retn
 
     if isinstance(valu, dict):
         retn = {}
         for k, v in valu.items():
             try:
-                retn[k] = await toprim(v)
+                retn[k] = await toprim(v, use_list=use_list)
             except s_exc.NoSuchType:
                 pass
         return retn
@@ -9502,6 +9527,9 @@ async def toprim(valu, path=None):
     if isinstance(valu, Number):
         return float(valu.value())
 
+    if isinstance(valu, (Dict, List)):
+        return await valu.value(use_list=use_list)
+
     if isinstance(valu, Prim):
         return await s_coro.ornot(valu.value)
 

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, 184, 0)
+version = (2, 185, 0)
 verstring = '.'.join([str(x) for x in version])
-commit = '05940dce070d26f83bb7e4070f1d44d051804e3b'
+commit = 'c2ef0eded02f8ac5f34704a117947f44095f41f4'

synapse/models/doc.py

@@ -0,0 +1,93 @@
+import synapse.exc as s_exc
+import synapse.lib.module as s_module
+
+class DocModule(s_module.CoreModule):
+
+    def getModelDefs(self):
+        return (('doc', {
+            'interfaces': (
+                ('doc:document', {
+
+                    'doc': 'A common interface for documents.',
+
+                    'template': {
+                        'type': 'NEWP',
+                        'document': 'document',
+                        'documents': 'documents'},
+
+                    'props': (
+
+                        ('id', ('str', {'strip': True}), {
+                            'doc': 'The {document} ID.'}),
+
+                        ('name', ('str', {'lower': True, 'onespace': True}), {
+                            'doc': 'The {document} name.'}),
+
+                        ('type', ('{type}', {}), {
+                            'doc': 'The type of {document}.'}),
+
+                        ('text', ('str', {}), {
+                            'doc': 'The text of the {document}.'}),
+
+                        ('file', ('file:bytes', {}), {
+                            'doc': 'The file which contains the {document}.'}),
+
+                        ('created', ('time', {}), {
+                            'doc': 'The time that the {document} was created.'}),
+
+                        ('updated', ('time', {}), {
+                            'doc': 'The time that the {document} was last updated.'}),
+
+                        ('author', ('ps:contact', {}), {
+                            'doc': 'The contact information of the primary author.'}),
+
+                        ('contributors', ('array', {'type': 'ps:contact', 'sorted': True, 'uniq': True}), {
+                            'doc': 'An array of contacts which contributed to the {document}.'}),
+
+                        ('version', ('it:semver', {}), {
+                            'doc': 'The version of the {document}.'}),
+
+                        ('supersedes', ('array', {'type': '$self', 'sorted': True, 'uniq': True}), {
+                            'doc': 'An array of {documents} which are superseded by this {document}.'}),
+                    ),
+                }),
+            ),
+            'types': (
+
+                ('doc:policy:type:taxonomy', ('taxonomy', {}), {
+                    'interfaces': ('meta:taxonomy',),
+                    'doc': 'A taxonomy of policy types.'}),
+
+                ('doc:policy', ('guid', {}), {
+                    'interfaces': ('doc:document',),
+                    'template': {
+                        'document': 'policy',
+                        'documents': 'policies',
+                        'type': 'doc:policy:type:taxonomy'},
+                    'doc': 'Guiding principles used to reach a set of goals.'}),
+
+                ('doc:standard:type:taxonomy', ('taxonomy', {}), {
+                    'interfaces': ('meta:taxonomy',),
+                    'doc': 'A taxonomy of standard types.'}),
+
+                ('doc:standard', ('guid', {}), {
+                    'interfaces': ('doc:document',),
+                    'template': {
+                        'document': 'standard',
+                        'documents': 'standards',
+                        'type': 'doc:standard:type:taxonomy'},
+                    'doc': 'A group of requirements which define how to implement a policy or goal.'}),
+            ),
+            'forms': (
+
+                ('doc:policy:type:taxonomy', {}, ()),
+                ('doc:policy', {}, ()),
+
+                ('doc:standard:type:taxonomy', {}, ()),
+                ('doc:standard', {}, (
+                    ('policy', ('doc:policy', {}), {
+                        'doc': 'The policy which was used to derive the standard.'}),
+                )),
+            ),
+            'edges': (),
+        }),)

synapse/models/infotech.py

@@ -1882,7 +1882,8 @@ class ItModule(s_module.CoreModule):
                         'disp': {'hint': 'text'},
                         'doc': 'The commit message describing the changes in the commit.'}),
 
-                    ('id', ('str', {}), {
+                    # we mirror the interface type options...
+                    ('id', ('str', {'strip': True}), {
                         'doc': 'The version control system specific commit identifier.'}),
 
                     ('created', ('time', {}), {

synapse/models/media.py

@@ -38,7 +38,6 @@ class MediaModule(s_module.CoreModule):
                 ('publisher', ('ou:org', {}), {
                     'doc': 'The organization which published the news.'}),
 
-
                 ('publisher:name', ('ou:name', {}), {
                     'doc': 'The name of the publishing org used to publish the news.'}),
 

synapse/models/orgs.py

@@ -262,13 +262,25 @@ class OuModule(s_module.CoreModule):
                     'interfaces': ('meta:taxonomy',),
                 }),
                 ('ou:jobtitle', ('str', {'lower': True, 'onespace': True}), {
-                    'doc': 'A title for a position within an org.',
-                }),
+                    'doc': 'A title for a position within an org.'}),
+
+                ('ou:enacted:status:taxonomy', ('taxonomy', {}), {
+                    'interfaces': ('meta:taxonomy',),
+                    'doc': 'A taxonomy of enacted statuses.'}),
+
+                ('ou:enacted', ('guid', {}), {
+                    'interfaces': ('proj:task',),
+                    'template': {
+                        'task': 'adoption task'},
+                    'doc': 'An organization enacting a document.'}),
+
                 ('ou:requirement:type:taxonomy', ('taxonomy', {}), {
                     'interfaces': ('meta:taxonomy',),
                     'doc': 'A taxonomy of requirement types.'}),
+
                 ('ou:requirement', ('guid', {}), {
                     'doc': 'A specific requirement.'}),
+
             ),
             'edges': (
                 (('ou:campaign', 'uses', 'ou:technique'), {
@@ -1281,8 +1293,19 @@ class OuModule(s_module.CoreModule):
                     ('url', ('inet:url', {}), {
                         'doc': 'The contest result website URL.',
                     }),
-                    # TODO duration ('duration'
                 )),
+                ('ou:enacted:status:taxonomy', {}, ()),
+                ('ou:enacted', {}, (
+                    ('org', ('ou:org', {}), {
+                        'doc': 'The organization which is enacting the document.'}),
+
+                    ('doc', ('ndef', {'forms': ('doc:policy', 'doc:standard')}), {
+                        'doc': 'The document enacted by the organization.'}),
+
+                    ('scope', ('ndef', {}), {
+                        'doc': 'The scope of responsbility for the assignee to enact the document.'}),
+                )),
+
                 ('ou:requirement:type:taxonomy', {}, ()),
                 ('ou:requirement', {}, (
 

synapse/models/proj.py

@@ -1,14 +1,5 @@
 import synapse.lib.module as s_module
 
-prioenums = (
-    (0, 'none'),
-    (10, 'lowest'),
-    (20, 'low'),
-    (30, 'medium'),
-    (40, 'high'),
-    (50, 'highest'),
-)
-
 statusenums = (
     (0, 'new'),
     (10, 'in validation'),
@@ -47,11 +38,63 @@ class ProjectModule(s_module.CoreModule):
 
             ('proj', {
 
+                'interfaces': (
+                    ('proj:task', {
+
+                        'doc': 'A common interface for tasks.',
+
+                        'template': {
+                            'task': 'task'},
+
+                        'props': (
+
+                            ('id', ('str', {'strip': True}), {
+                                'doc': 'The ID of the {task}.'}),
+
+                            ('project', ('proj:project', {}), {
+                                'doc': 'The project containing the {task}.'}),
+
+                            ('status', ('int', {}), {
+                                # TODO: make runtime setable int enum typeopts
+                                'doc': 'The status of the {task}.'}),
+
+                            ('priority', ('meta:priority', {}), {
+                                'doc': 'The priority of the {task}.'}),
+
+                            ('created', ('time', {}), {
+                                'doc': 'The time the {task} was created.'}),
+
+                            ('updated', ('time', {}), {
+                                'doc': 'The time the {task} was last updated.'}),
+
+                            ('due', ('time', {}), {
+                                'doc': 'The time the {task} must be complete.'}),
+
+                            ('completed', ('time', {}), {
+                                'doc': 'The time the {task} was completed.'}),
+
+                            ('creator', ('syn:user', {}), {
+                                'doc': 'The user which created the {task}.'}),
+
+                            ('assignee', ('syn:user', {}), {
+                                'doc': 'The user assigned to complete the {task}.'}),
+
+                            ('ext:creator', ('ps:contact', {}), {
+                                'doc': 'The contact information of the creator from an external system.'}),
+
+                            ('ext:assignee', ('ps:contact', {}), {
+                                'doc': 'The contact information of the assignee from an external system.'}),
+                        ),
+                    }),
+                ),
                 'types': (
                     ('proj:epic', ('guid', {}), {
-                        'doc': 'A collection of tickets related to a topic.',
-                    }),
+                        'doc': 'A collection of tickets related to a topic.'}),
+
                     ('proj:ticket', ('guid', {}), {
+                        'interfaces': ('proj:task',),
+                        'template': {
+                            'task': 'ticket'},
                         'doc': 'A ticket in a ticketing system.'}),
 
                     ('proj:project:type:taxonomy', ('taxonomy', {}), {
@@ -180,30 +223,16 @@ class ProjectModule(s_module.CoreModule):
 
                     ('proj:ticket', {}, (
 
-                        ('project', ('proj:project', {}), {
-                            'doc': 'The project containing the ticket.'}),
-
                         ('ext:id', ('str', {'strip': True}), {
-                            'doc': 'A ticket ID from an external system.'}),
+                            'deprecated': True,
+                            'doc': 'Deprecated. Please use :id.'}),
 
                         ('ext:url', ('inet:url', {}), {
                             'doc': 'A URL to the ticket in an external system.'}),
 
-                        ('ext:creator', ('ps:contact', {}), {
-                            'doc': 'Ticket creator contact information from an external system.'}),
-
-                        ('ext:assignee', ('ps:contact', {}), {
-                            'doc': 'Ticket assignee contact information from an external system.'}),
-
                         ('epic', ('proj:epic', {}), {
                             'doc': 'The epic that includes the ticket.'}),
 
-                        ('created', ('time', {}), {
-                            'doc': 'The time the ticket was created.'}),
-
-                        ('updated', ('time', {'ismax': True}), {
-                            'doc': 'The last time the ticket was updated.'}),
-
                         ('name', ('str', {'onespace': True}), {
                             'doc': 'The name of the ticket.'}),
 
@@ -219,17 +248,8 @@ class ProjectModule(s_module.CoreModule):
                         ('sprint', ('proj:sprint', {}), {
                             'doc': 'The sprint that contains the ticket.'}),
 
-                        ('priority', ('int', {'enums': prioenums}), {
-                            'doc': 'The priority of the ticket.'}),
-
                         ('type', ('str', {'lower': True, 'strip': True}), {
                             'doc': 'The type of ticket. (eg story / bug)'}),
-
-                        ('creator', ('syn:user', {}), {
-                            'doc': 'The synapse user who created the ticket.'}),
-
-                        ('assignee', ('syn:user', {}), {
-                            'doc': 'The synapse user who the ticket is assigned to.'}),
                     )),
                 ),
             }),

synapse/models/syn.py

@@ -2,10 +2,67 @@ import logging
 
 import synapse.exc as s_exc
 
+import synapse.lib.types as s_types
 import synapse.lib.module as s_module
 
 logger = logging.getLogger(__name__)
 
+class SynUser(s_types.Guid):
+
+    def _normPyStr(self, text):
+
+        core = self.modl.core
+        if core is not None:
+
+            # direct use of an iden takes precedence...
+            user = core.auth.user(text)
+            if user is not None:
+                return user.iden, {}
+
+            user = core.auth._getUserByName(text)
+            if user is not None:
+                return user.iden, {}
+
+        return s_types.Guid._normPyStr(self, text)
+
+    def repr(self, iden):
+
+        core = self.modl.core
+        if core is not None:
+            user = core.auth.user(iden)
+            if user is not None:
+                return user.name
+
+        return iden
+
+class SynRole(s_types.Guid):
+
+    def _normPyStr(self, text):
+
+        core = self.modl.core
+        if core is not None:
+
+            # direct use of an iden takes precedence...
+            role = core.auth.role(text)
+            if role is not None:
+                return role.iden, {}
+
+            role = core.auth._getRoleByName(text)
+            if role is not None:
+                return role.iden, {}
+
+        return s_types.Guid._normPyStr(self, text)
+
+    def repr(self, iden):
+
+        core = self.modl.core
+        if core is not None:
+            role = core.auth.role(iden)
+            if role is not None:
+                return role.name
+
+        return iden
+
 class SynModule(s_module.CoreModule):
 
     def initCoreModule(self):
@@ -105,6 +162,13 @@ class SynModule(s_module.CoreModule):
 
         return (('syn', {
 
+            'ctors': (
+                ('syn:user', 'synapse.models.syn.SynUser', {}, {
+                    'doc': 'A Synapse user.'}),
+
+                ('syn:role', 'synapse.models.syn.SynRole', {}, {
+                    'doc': 'A Synapse role.'}),
+            ),
             'types': (
                 ('syn:type', ('str', {'strip': True}), {
                     'doc': 'A Synapse type used for normalizing nodes and properties.',
@@ -130,12 +194,6 @@ class SynModule(s_module.CoreModule):
                 ('syn:nodedata', ('comp', {'fields': (('key', 'str'), ('form', 'syn:form'))}), {
                     'doc': 'A nodedata key and the form it may be present on.',
                 }),
-                ('syn:user', ('guid', {'strip': True}), {
-                    'doc': 'A Synapse user GUID.'
-                }),
-                ('syn:role', ('guid', {'strip': True}), {
-                    'doc': 'A Synapse role GUID.'
-                }),
             ),
 
             'forms': (