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

synapse/models/base.py

@@ -195,8 +195,12 @@ class BaseModule(s_module.CoreModule):
 
                     ('created', ('time', {}), {
                         'doc': 'The time the note was created.'}),
+
                     ('updated', ('time', {}), {
                         'doc': 'The time the note was updated.'}),
+
+                    ('replyto', ('meta:note', {}), {
+                        'doc': 'The note is a reply to the specified note.'}),
                 )),
 
                 ('meta:timeline', {}, (
@@ -213,17 +217,26 @@ class BaseModule(s_module.CoreModule):
                 ('meta:timeline:taxonomy', {}, ()),
 
                 ('meta:event', {}, (
+
                     ('timeline', ('meta:timeline', {}), {
                         'doc': 'The timeline containing the event.'}),
+
                     ('title', ('str', {}), {
                         'doc': 'A title for the event.'}),
+
                     ('summary', ('str', {}), {
                         'disp': {'hint': 'text'},
                         'doc': 'A prose summary of the event.'}),
+
                     ('time', ('time', {}), {
                         'doc': 'The time that the event occurred.'}),
+
+                    ('index', ('int', {}), {
+                        'doc': 'The index of this event in a timeline without exact times.'}),
+
                     ('duration', ('duration', {}), {
                         'doc': 'The duration of the event.'}),
+
                     ('type', ('meta:event:taxonomy', {}), {
                         'doc': 'Type of event.'}),
                 )),

synapse/models/biz.py

@@ -175,22 +175,36 @@ class BizModule(s_module.CoreModule):
                     }),
                 )),
                 ('biz:listing', {}, (
+
                     ('seller', ('ps:contact', {}), {
                         'doc': 'The contact information for the seller.'}),
+
                     ('product', ('biz:product', {}), {
                         'doc': 'The product being offered.'}),
+
                     ('service', ('biz:service', {}), {
                         'doc': 'The service being offered.'}),
+
                     ('current', ('bool', {}), {
                         'doc': 'Set to true if the offer is still current.'}),
+
                     ('time', ('time', {}), {
                         'doc': 'The first known offering of this product/service by the organization for the asking price.'}),
+
                     ('expires', ('time', {}), {
                         'doc': 'Set if the offer has a known expiration date.'}),
+
                     ('price', ('econ:price', {}), {
                         'doc': 'The asking price of the product or service.'}),
+
                     ('currency', ('econ:currency', {}), {
                         'doc': 'The currency of the asking price.'}),
+
+                    ('count:total', ('int', {'min': 0}), {
+                        'doc': 'The number of instances for sale.'}),
+
+                    ('count:remaining', ('int', {'min': 0}), {
+                        'doc': 'The current remaining number of instances for sale.'}),
                 )),
                 ('biz:service', {}, (
                     ('provider', ('ps:contact', {}), {

synapse/models/economic.py

@@ -169,6 +169,9 @@ class EconModule(s_module.CoreModule):
 
                     ('currency', ('econ:currency', {}), {
                         'doc': 'The econ:price of the purchase'}),
+
+                    ('listing', ('biz:listing', {}), {
+                        'doc': 'The purchase was made based on the given listing.'}),
                 )),
 
                 ('econ:receipt:item', {}, (

synapse/models/inet.py

@@ -69,6 +69,22 @@ ipv6_multicast_scopes = {
 
 scopes_enum = 'reserved,interface-local,link-local,realm-local,admin-local,site-local,organization-local,global,unassigned'
 
+svcobjstatus = (
+    (10, 'draft'),
+    (30, 'available'),
+    (40, 'offline'),
+    (50, 'removed'),
+)
+
+svcaccesstypes = (
+    (10, 'create'),
+    (30, 'read'),
+    (40, 'update'),
+    (50, 'delete'),
+    (60, 'list'),
+    (70, 'execute'),
+)
+
 def getAddrScope(ipv6):
 
     if ipv6.is_loopback:
@@ -767,7 +783,7 @@ class IPv6Range(s_types.Range):
     def _normPyTuple(self, valu):
         if len(valu) != 2:
             raise s_exc.BadTypeValu(numitems=len(valu), name=self.name,
-                                    mesg=f'Must be a 2-tuple of type {self.subtype.name}: {repr(valu)[:256]}')
+                                    mesg=f'Must be a 2-tuple of type {self.subtype.name}: {s_common.trimText(repr(valu))}')
 
         minv = self.subtype.norm(valu[0])[0]
         maxv = self.subtype.norm(valu[1])[0]
@@ -1415,7 +1431,7 @@ class InetModule(s_module.CoreModule):
                         'doc': 'A channel within a web service or instance such as slack or discord.'
                     }),
 
-                    ('inet:web:hashtag', ('str', {'lower': True, 'regex': r'^#[\w]+$'}), {
+                    ('inet:web:hashtag', ('str', {'lower': True, 'regex': r'^#\w[\w·]*(?<!·)$'}), {
                         'doc': 'A hashtag used in a web post.',
                     }),
 
@@ -1493,6 +1509,88 @@ class InetModule(s_module.CoreModule):
                     ('inet:ssl:jarmsample', ('comp', {'fields': (('server', 'inet:server'), ('jarmhash', 'inet:ssl:jarmhash'))}), {
                         'doc': 'A JARM hash sample taken from a server.'}),
 
+                    ('inet:service:platform', ('guid', {}), {
+                        'doc': 'A network platform which provides services.'}),
+
+                    ('inet:service:instance', ('guid', {}), {
+                        'doc': 'An instance of the platform such as Slack or Discord instances.'}),
+
+                    ('inet:service:object:status', ('int', {'enums': svcobjstatus}), {
+                        'doc': 'An object status enumeration.'}),
+
+                    ('inet:service:account', ('guid', {}), {
+                        'doc': 'An account within a service platform. Accounts may be instance specific.'}),
+
+                    ('inet:service:permission:type:taxonomy', ('taxonomy', {}), {
+                        'interfaces': ('meta:taxonomy',),
+                        'doc': 'A permission type taxonomy.'}),
+
+                    ('inet:service:permission', ('guid', {}), {
+                        'interfaces': ('inet:service:object',),
+                        'doc': 'A permission which may be granted to a service account or role.'}),
+
+                    ('inet:service:rule', ('guid', {}), {
+                        'interfaces': ('inet:service:object',),
+                        'doc': 'A rule which grants or denies a permission to a service account or role.'}),
+
+                    ('inet:service:login', ('guid', {}), {
+                        'interfaces': ('inet:service:action',),
+                        'doc': 'A login event for a service account.'}),
+
+                    ('inet:service:login:method:taxonomy', ('taxonomy', {}), {
+                        'interfaces': ('meta:taxonomy',),
+                        'doc': 'A taxonomy of inet service login methods.'}),
+
+                    ('inet:service:session', ('guid', {}), {
+                        'interfaces': ('inet:service:object',),
+                        'doc': 'An authenticated session.'}),
+
+                    ('inet:service:group', ('guid', {}), {
+                        'interfaces': ('inet:service:object',),
+                        'doc': 'A group or role which contains member accounts.'}),
+
+                    ('inet:service:group:member', ('guid', {}), {
+                        'interfaces': ('inet:service:object',),
+                        'doc': 'Represents a service account being a member of a group.'}),
+
+                    ('inet:service:channel', ('guid', {}), {
+                        'interfaces': ('inet:service:object',),
+                        'doc': 'A channel used to distribute messages.'}),
+
+                    ('inet:service:channel:member', ('guid', {}), {
+                        'interfaces': ('inet:service:object',),
+                        'doc': 'Represents a service account being a member of a channel.'}),
+
+                    ('inet:service:message', ('guid', {}), {
+                        'interfaces': ('inet:service:action',),
+                        'doc': 'A message or post created by an account.'}),
+
+                    ('inet:service:message:link', ('guid', {}), {
+                        'doc': 'A URL link included within a message.'}),
+
+                    ('inet:service:message:attachment', ('guid', {}), {
+                        'doc': 'A file attachment included within a message.'}),
+
+                    ('inet:service:access', ('guid', {}), {
+                        'interfaces': ('inet:service:action',),
+                        'doc': 'Represents a user access request to a service resource.'}),
+
+                    ('inet:service:resource:type:taxonomy', ('taxonomy', {}), {
+                        'interfaces': ('meta:taxonomy',),
+                        'doc': 'A taxonomy of inet service resource types.'}),
+
+                    ('inet:service:resource', ('guid', {}), {
+                        'interfaces': ('inet:service:object',),
+                        'doc': 'A generic resource provided by the service architecture.'}),
+
+                    ('inet:service:bucket', ('guid', {}), {
+                        'interfaces': ('inet:service:object',),
+                        'doc': 'A file/blob storage object within a service architecture.'}),
+
+                    ('inet:service:bucket:item', ('guid', {}), {
+                        'interfaces': ('inet:service:object',),
+                        'doc': 'An individual file stored within a bucket.'}),
+
                     ('inet:tls:handshake', ('guid', {}), {
                         'doc': 'An instance of a TLS handshake between a server and client.'}),
 
@@ -1543,6 +1641,90 @@ class InetModule(s_module.CoreModule):
                                 'doc': 'The host that the request was sent to.'}),
                         ),
                     }),
+
+                    ('inet:service:base', {
+                        'doc': 'Properties common to most forms within a service platform.',
+                        'props': (
+
+                            ('id', ('str', {'strip': True}), {
+                                'doc': 'A platform specific ID.'}),
+
+                            ('platform', ('inet:service:platform', {}), {
+                                'doc': 'The platform which defines the node.'}),
+
+                            ('instance', ('inet:service:instance', {}), {
+                                'doc': 'The platform instance which defines the node.'}),
+                        ),
+                    }),
+
+                    ('inet:service:object', {
+
+                        'doc': 'Properties common to objects within a service platform.',
+                        'interfaces': ('inet:service:base',),
+                        'props': (
+
+                            ('status', ('inet:service:object:status', {}), {
+                                'doc': 'The status of this object.'}),
+
+                            ('period', ('ival', {}), {
+                                'doc': 'The period when the object existed.'}),
+
+                            ('creator', ('inet:service:account', {}), {
+                                'doc': 'The service account which created the object.'}),
+
+                            ('remover', ('inet:service:account', {}), {
+                                'doc': 'The service account which removed or decommissioned the object.'}),
+
+                        ),
+                    }),
+
+                    ('inet:service:action', {
+
+                        'doc': 'Properties common to events within a service platform.',
+                        'interfaces': ('inet:service:base',),
+                        'props': (
+
+                            ('time', ('time', {}), {
+                                'doc': 'The time that the account initiated the action.'}),
+
+                            ('account', ('inet:service:account', {}), {
+                                'doc': 'The account which initiated the action.'}),
+
+                            ('success', ('bool', {}), {
+                                'doc': 'Set to true if the action was successful.'}),
+
+                            ('rule', ('inet:service:rule', {}), {
+                                'doc': 'The rule which allowed or denied the action.'}),
+
+                            ('error:code', ('str', {'strip': True}), {
+                                'doc': 'The platform specific error code if the action was unsuccessful.'}),
+
+                            ('error:reason', ('str', {'strip': True}), {
+                                'doc': 'The platform specific friendly error reason if the action was unsuccessful.'}),
+
+                            ('platform', ('inet:service:platform', {}), {
+                                'doc': 'The platform where the action was initiated.'}),
+
+                            ('instance', ('inet:service:instance', {}), {
+                                'doc': 'The platform instance where the action was initiated.'}),
+
+                            ('session', ('inet:service:session', {}), {
+                                'doc': 'The session which initiated the action.'}),
+
+                            ('client', ('inet:client', {}), {
+                                'doc': 'The network address of the client which initiated the action.'}),
+
+                            ('client:host', ('it:host', {}), {
+                                'doc': 'The client host which initiated the action.'}),
+
+                            ('server', ('inet:server', {}), {
+                                'doc': 'The network address of the server which handled the action.'}),
+
+                            ('server:host', ('it:host', {}), {
+                                'doc': 'The server host which handled the action.'}),
+
+                        ),
+                    }),
                 ),
 
                 'forms': (
@@ -1931,6 +2113,9 @@ class InetModule(s_module.CoreModule):
                         ('host', ('it:host', {}), {
                             'doc': 'The host that used the network egress.'}),
 
+                        ('account', ('inet:service:account', {}), {
+                            'doc': 'The service account which used the client address to egress.'}),
+
                         ('client', ('inet:client', {}), {
                             'doc': 'The client address the host used as a network egress.'}),
 
@@ -2046,8 +2231,12 @@ class InetModule(s_module.CoreModule):
 
                     ('inet:iface', {}, (
                         ('host', ('it:host', {}), {
-                            'doc': 'The guid of the host the interface is associated with.'
-                        }),
+                            'doc': 'The guid of the host the interface is associated with.'}),
+
+                        ('name', ('str', {'strip': True}), {
+                            'ex': 'eth0',
+                            'doc': 'The interface name.'}),
+
                         ('network', ('it:network', {}), {
                             'doc': 'The guid of the it:network the interface connected to.'
                         }),
@@ -3310,6 +3499,287 @@ class InetModule(s_module.CoreModule):
                             'ro': True,
                             'doc': 'The x509 certificate sent by the client.'})
                     )),
+                    ('inet:service:platform', {}, (
+
+                        ('url', ('inet:url', {}), {
+                            'ex': 'https://twitter.com',
+                            'doc': 'The primary URL of the platform.'}),
+
+                        ('name', ('str', {'onespace': True, 'lower': True}), {
+                            'ex': 'twitter',
+                            'doc': 'A friendly name for the platform.'}),
+
+                        ('desc', ('str', {}), {
+                            'disp': {'hint': 'text'},
+                            'doc': 'A description of the service platform.'}),
+
+                        ('provider', ('ou:org', {}), {
+                            'doc': 'The organization which operates the platform.'}),
+
+                        ('provider:name', ('ou:name', {}), {
+                            'doc': 'The name of the organization which operates the platform.'}),
+                    )),
+
+                    ('inet:service:instance', {}, (
+
+                        ('id', ('str', {'strip': True}), {
+                            'ex': 'B8ZS2',
+                            'doc': 'A platform specific ID to identify the service instance.'}),
+
+                        ('platform', ('inet:service:platform', {}), {
+                            'doc': 'The platform which defines the service instance.'}),
+
+                        ('url', ('inet:url', {}), {
+                            'ex': 'https://v.vtx.lk/slack',
+                            'doc': 'The primary URL which identifies the service instance.'}),
+
+                        ('name', ('str', {'lower': True, 'onespace': True}), {
+                            'ex': 'synapse users slack',
+                            'doc': 'The name of the service instance.'}),
+
+                        ('desc', ('str', {}), {
+                            'disp': {'hint': 'text'},
+                            'doc': 'A description of the service instance.'}),
+
+                        ('period', ('ival', {}), {
+                            'doc': 'The time period where the instance existed.'}),
+
+                        ('status', ('inet:service:object:status', {}), {
+                            'doc': 'The status of this instance.'}),
+
+                        ('creator', ('inet:service:account', {}), {
+                            'doc': 'The service account which created the instance.'}),
+
+                        ('owner', ('inet:service:account', {}), {
+                            'doc': 'The service account which owns the instance.'}),
+                    )),
+
+                    ('inet:service:account', {}, (
+
+                        ('id', ('str', {'strip': True}), {
+                            'doc': 'A platform specific ID used to identify the account.'}),
+
+                        ('user', ('inet:user', {}), {
+                            'doc': 'The current user name of the account.'}),
+
+                        ('email', ('inet:email', {}), {
+                            'doc': 'The current email address associated with the account.'}),
+
+                        ('profile', ('ps:contact', {}), {
+                            'doc': 'Current profile details associated with the account.'}),
+                    )),
+
+                    ('inet:service:group', {}, ( # inet:service:object
+
+                        ('id', ('str', {'strip': True}), {
+                            'doc': 'A platform specific ID used to identify the group.'}),
+
+                        ('name', ('inet:group', {}), {
+                            'doc': 'The name of the group on this platform.'}),
+
+                        ('profile', ('ps:contact', {}), {
+                            'doc': 'Current detailed contact information for this group.'}),
+                    )),
+
+                    ('inet:service:group:member', {}, (
+
+                        ('account', ('inet:service:account', {}), {
+                            'doc': 'The account that is a member of the group.'}),
+
+                        ('group', ('inet:service:group', {}), {
+                            'doc': 'The group that the account is a member of.'}),
+
+                        ('period', ('ival', {}), {
+                            'doc': 'The time period when the account was a member of the group.'}),
+                    )),
+
+                    ('inet:service:permission:type:taxonomy', {}, ()),
+
+                    ('inet:service:permission', {}, (
+
+                        ('name', ('str', {'onespace': True, 'lower': True}), {
+                            'doc': 'The name of the permission.'}),
+
+                        ('type', ('inet:service:permission:type:taxonomy', {}), {
+                            'doc': 'The type of permission.'}),
+
+                    )),
+
+                    ('inet:service:rule', {}, (
+
+                        ('permission', ('inet:service:permission', {}), {
+                            'doc': 'The permission which is granted.'}),
+
+                        ('denied', ('bool', {}), {
+                            'doc': 'Set to (true) to denote that the rule is an explicit deny.'}),
+
+                        ('object', ('ndef', {'interface': 'inet:service:object'}), {
+                            'doc': 'The object that the permission controls access to.'}),
+
+                        ('grantee', ('ndef', {'forms': ('inet:service:account', 'inet:service:group')}), {
+                            'doc': 'The user or role which is granted the permission.'}),
+                    )),
+
+                    ('inet:service:session', {}, (
+
+                        ('id', ('str', {'strip': True}), {
+                            'doc': 'The service specific session id.'}),
+
+                        ('creator', ('inet:service:account', {}), {
+                            'doc': 'The account which authenticated to create the session.'}),
+
+                        ('period', ('ival', {}), {
+                            'doc': 'The period where the session was valid.'}),
+                    )),
+
+                    ('inet:service:login', {}, (
+
+                        ('method', ('inet:service:login:method:taxonomy', {}), {
+                            'doc': 'The type of authentication used for the login. For example "password" or "multifactor.sms".'}),
+
+                        # TODO ndef based auth proto details
+                    )),
+
+                    ('inet:service:message', {}, (
+
+                        ('account', ('inet:service:account', {}), {
+                            'doc': 'The account which sent the message.'}),
+
+                        ('to', ('inet:service:account', {}), {
+                            'doc': 'The destination account. Used for direct messages.'}),
+
+                        ('url', ('inet:url', {}), {
+                            'doc': 'The URL where the message may be viewed.'}),
+
+                        ('group', ('inet:service:group', {}), {
+                            'doc': 'The group that the message was sent to.'}),
+
+                        ('channel', ('inet:service:channel', {}), {
+                            'doc': 'The channel that the message was sent to.'}),
+
+                        ('public', ('bool', {}), {
+                            'doc': 'Set to true if the message is publicly visible.'}),
+
+                        ('text', ('str', {}), {
+                            'disp': {'hint': 'text'},
+                            'doc': 'The text body of the message.'}),
+
+                        ('status', ('inet:service:object:status', {}), {
+                            'doc': 'The message status.'}),
+
+                        ('replyto', ('inet:service:message', {}), {
+                            'doc': 'The message that this message was sent in reply to. Used for message threading.'}),
+
+                        ('links', ('array', {'type': 'inet:service:message:link', 'uniq': True, 'sorted': True}), {
+                            'doc': 'An array of links contained within the message.'}),
+
+                        ('attachments', ('array', {'type': 'inet:service:message:attachment', 'uniq': True, 'sorted': True}), {
+                            'doc': 'An array of files attached to the message.'}),
+
+                        ('place', ('geo:place', {}), {
+                            'doc': 'The place that the message was sent from.'}),
+
+                        ('place:name', ('geo:name', {}), {
+                            'doc': 'The name of the place that the message was sent from.'}),
+
+                        ('client:address', ('inet:client', {}), {
+                            'doc': 'The client address that the message was sent from.'}),
+
+                        ('client:software', ('it:prod:softver', {}), {
+                            'doc': 'The client software version used to send the message.'}),
+
+                        ('client:software:name', ('it:prod:softname', {}), {
+                            'doc': 'The name of the client software used to send the message.'}),
+
+                        ('file', ('file:bytes', {}), {
+                            'doc': 'The raw file that the message was extracted from.'}),
+                    )),
+
+                    ('inet:service:message:link', {}, (
+
+                        ('title', ('str', {'strip': True}), {
+                            'doc': 'The title text for the link.'}),
+
+                        ('url', ('inet:url', {}), {
+                            'doc': 'The URL which was attached to the message.'}),
+                    )),
+
+                    ('inet:service:message:attachment', {}, (
+
+                        ('name', ('file:path', {}), {
+                            'doc': 'The name of the attached file.'}),
+
+                        ('text', ('str', {}), {
+                            'doc': 'Any text associated with the file such as alt-text for images.'}),
+
+                        ('file', ('file:bytes', {}), {
+                            'doc': 'The file which was attached to the message.'}),
+                    )),
+
+                    ('inet:service:channel', {}, (
+
+                        ('name', ('str', {'onespace': True, 'lower': True}), {
+                            'doc': 'The name of the channel.'}),
+
+                        ('period', ('ival', {}), {
+                            'doc': 'The time period where the channel was available.'}),
+                    )),
+
+                    ('inet:service:channel:member', {}, (
+
+                        ('channel', ('inet:service:channel', {}), {
+                            'doc': 'The channel that the account was a member of.'}),
+
+                        ('account', ('inet:service:account', {}), {
+                            'doc': 'The account that was a member of the channel.'}),
+
+                        ('period', ('ival', {}), {
+                            'doc': 'The time period where the account was a member of the channel.'}),
+                    )),
+
+                    ('inet:service:resource:type:taxonomy', {}, {}),
+                    ('inet:service:resource', {}, (
+
+                        ('name', ('str', {'onespace': True, 'lower': True}), {
+                            'doc': 'The name of the service resource.'}),
+
+                        ('desc', ('str', {}), {
+                            'disp': {'hint': 'text'},
+                            'doc': 'A description of the service resource.'}),
+
+                        ('url', ('inet:url', {}), {
+                            'doc': 'The primary URL where the resource is available from the service.'}),
+
+                        ('type', ('inet:service:resource:type:taxonomy', {}), {
+                            'doc': 'The resource type. For example "rpc.endpoint".'}),
+                    )),
+
+                    ('inet:service:bucket', {}, (
+
+                        ('name', ('str', {'onespace': True, 'lower': True}), {
+                            'doc': 'The name of the service resource.'}),
+                    )),
+
+                    ('inet:service:bucket:item', {}, (
+
+                        ('bucket', ('inet:service:bucket', {}), {
+                            'doc': 'The bucket which contains the item.'}),
+
+                        ('file', ('file:bytes', {}), {
+                            'doc': 'The bytes stored within the bucket item.'}),
+
+                        ('file:name', ('file:path', {}), {
+                            'doc': 'The name of the file stored in the bucket item.'}),
+                    )),
+
+                    ('inet:service:access', {}, (
+
+                        ('resource', ('inet:service:resource', {}), {
+                            'doc': 'The resource which the account attempted to access.'}),
+
+                        ('type', ('int', {'enums': svcaccesstypes}), {
+                            'doc': 'The type of access requested.'}),
+                    )),
                 ),
             }),
         )