pacnpal/thrillwiki_django_no_react
1
1
Fork 0
mirror of https://github.com/pacnpal/thrillwiki_django_no_react.git synced 2025-12-22 09:51:09 -05:00
Code Issues Packages Projects Releases Wiki Activity

okay fine

Browse Source
This commit is contained in:
pacnpal
2024-11-03 17:47:26 +00:00
parent 387c4740e7
commit 27f3326e22
10020 changed files with 1935769 additions and 2364 deletions
Download Patch File Download Diff File Expand all files Collapse all files

81
.venv/lib/python3.12/site-packages/autobahn/wamp/__init__.py Normal file
View File

@@ -0,0 +1,81 @@
###############################################################################
#
# The MIT License (MIT)
#
# Copyright (c) typedef int GmbH
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
###############################################################################
from autobahn.wamp.types import \
ComponentConfig, \
SessionDetails, \
CloseDetails, \
RegisterOptions, \
CallOptions, \
CallDetails, \
CallResult, \
SubscribeOptions, \
PublishOptions, \
EventDetails
from autobahn.wamp.exception import \
Error, \
SessionNotReady, \
SerializationError, \
ProtocolError, \
TransportLost, \
ApplicationError, \
InvalidUri
from autobahn.wamp.interfaces import ISession
from autobahn.wamp.uri import \
error, \
register, \
subscribe
__all__ = (
'ComponentConfig',
'SessionDetails',
'CloseDetails',
'RegisterOptions',
'CallOptions',
'CallDetails',
'CallResult',
'SubscribeOptions',
'PublishOptions',
'EventDetails',
'Error',
'SessionNotReady',
'SerializationError',
'ProtocolError',
'TransportLost',
'ApplicationError',
'InvalidUri',
'ISession',
'error',
'register',
'subscribe',
)

694
.venv/lib/python3.12/site-packages/autobahn/wamp/auth.py Normal file
View File

@@ -0,0 +1,694 @@
###############################################################################
#
# The MIT License (MIT)
#
# Copyright (c) typedef int GmbH
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
###############################################################################
import os
import base64
import struct
import time
import binascii
import hmac
import hashlib
import random
from typing import Optional, Dict
from autobahn.util import public
from autobahn.util import xor as xor_array
from autobahn.wamp.interfaces import IAuthenticator
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.backends import default_backend
# if we don't have argon2/passlib (see "authentication" extra) then
# you don't get AuthScram and variants
try:
from argon2.low_level import hash_secret
from argon2 import Type
from passlib.utils import saslprep
HAS_ARGON = True
except ImportError:
HAS_ARGON = False
__all__ = (
'AuthAnonymous',
'AuthScram',
'AuthCryptoSign',
'AuthWampCra',
'AuthTicket',
'create_authenticator',
'pbkdf2',
'generate_totp_secret',
'compute_totp',
'check_totp',
'qrcode_from_totp',
'derive_key',
'generate_wcs',
'compute_wcs',
'derive_scram_credential',
)
def create_authenticator(name, **kwargs):
"""
Accepts various keys and values to configure an authenticator. The
valid keys depend on the kind of authenticator but all can
understand: `authextra`, `authid` and `authrole`
:return: an instance implementing IAuthenticator with the given
configuration.
"""
try:
klass = {
AuthScram.name: AuthScram,
AuthCryptoSign.name: AuthCryptoSign,
AuthCryptoSignProxy.name: AuthCryptoSignProxy,
AuthWampCra.name: AuthWampCra,
AuthAnonymous.name: AuthAnonymous,
AuthAnonymousProxy.name: AuthAnonymousProxy,
AuthTicket.name: AuthTicket,
}[name]
except KeyError:
raise ValueError(
"Unknown authenticator '{}'".format(name)
)
# this may raise further ValueErrors if the kwargs are wrong
authenticator = klass(**kwargs)
return authenticator
# experimental authentication API
class AuthAnonymous(object):
name = 'anonymous'
def __init__(self, **kw):
self._args = kw
@property
def authextra(self):
return self._args.get('authextra', dict())
def on_challenge(self, session, challenge):
raise RuntimeError(
"on_challenge called on anonymous authentication"
)
def on_welcome(self, msg, authextra):
return None
IAuthenticator.register(AuthAnonymous)
class AuthAnonymousProxy(AuthAnonymous):
name = 'anonymous-proxy'
IAuthenticator.register(AuthAnonymousProxy)
class AuthTicket(object):
name = 'ticket'
def __init__(self, **kw):
self._args = kw
try:
self._ticket = self._args.pop('ticket')
except KeyError:
raise ValueError(
"ticket authentication requires 'ticket=' kwarg"
)
@property
def authextra(self):
return self._args.get('authextra', dict())
def on_challenge(self, session, challenge):
assert challenge.method == "ticket"
return self._ticket
def on_welcome(self, msg, authextra):
return None
IAuthenticator.register(AuthTicket)
class AuthCryptoSign(object):
name = 'cryptosign'
def __init__(self, **kw):
# should put in checkconfig or similar
for key in kw.keys():
if key not in ['authextra', 'authid', 'authrole', 'privkey']:
raise ValueError(
"Unexpected key '{}' for {}".format(key, self.__class__.__name__)
)
for key in ['privkey']:
if key not in kw:
raise ValueError(
"Must provide '{}' for cryptosign".format(key)
)
from autobahn.wamp.cryptosign import CryptosignKey
self._privkey = CryptosignKey.from_bytes(
binascii.a2b_hex(kw['privkey'])
)
if 'pubkey' in kw.get('authextra', dict()):
pubkey = kw['authextra']['pubkey']
if pubkey != self._privkey.public_key():
raise ValueError(
"Public key doesn't correspond to private key"
)
else:
kw['authextra'] = kw.get('authextra', dict())
kw['authextra']['pubkey'] = self._privkey.public_key()
self._channel_binding = kw.get('authextra', dict()).get('channel_binding', None)
self._args = kw
@property
def authextra(self):
return self._args.get('authextra', dict())
def on_challenge(self, session, challenge):
channel_id = session._transport.transport_details.channel_id.get(self._channel_binding, None)
return self._privkey.sign_challenge(challenge,
channel_id=channel_id,
channel_id_type=self._channel_binding)
def on_welcome(self, msg, authextra):
return None
IAuthenticator.register(AuthCryptoSign)
class AuthCryptoSignProxy(AuthCryptoSign):
name = 'cryptosign-proxy'
IAuthenticator.register(AuthCryptoSignProxy)
def _hash_argon2id13_secret(password, salt, iterations, memory):
"""
Internal helper. Returns the salted/hashed password using the
argon2id-13 algorithm. The return value is base64-encoded.
"""
rawhash = hash_secret(
secret=password,
salt=base64.b64decode(salt),
time_cost=iterations,
memory_cost=memory,
parallelism=1, # hard-coded by WAMP-SCRAM spec
hash_len=32,
type=Type.ID,
version=0x13, # note this is decimal "19" which appears in places
)
# spits out stuff like:
# '$argon2i$v=19$m=512,t=2,p=2$5VtWOO3cGWYQHEMaYGbsfQ$AcmqasQgW/wI6wAHAMk4aQ'
_, tag, ver, options, salt_data, hash_data = rawhash.split(b'$')
return hash_data
def _hash_pbkdf2_secret(password, salt, iterations):
"""
Internal helper for SCRAM authentication
"""
return pbkdf2(password, salt, iterations, keylen=32)
class AuthScram(object):
"""
Implements "wamp-scram" authentication for components.
NOTE: This is a prototype of a draft spec; see
https://github.com/wamp-proto/wamp-proto/issues/135
"""
name = 'scram'
def __init__(self, **kw):
if not HAS_ARGON:
raise RuntimeError(
"Cannot support WAMP-SCRAM without argon2_cffi and "
"passlib libraries; install autobahn['scram']"
)
self._args = kw
self._client_nonce = None
@property
def authextra(self):
# is authextra() called exactly once per authentication?
if self._client_nonce is None:
self._client_nonce = base64.b64encode(os.urandom(16)).decode('ascii')
return {
"nonce": self._client_nonce,
}
def on_challenge(self, session, challenge):
assert challenge.method == "scram"
assert self._client_nonce is not None
required_args = ['nonce', 'kdf', 'salt', 'iterations']
optional_args = ['memory', 'channel_binding']
for k in required_args:
if k not in challenge.extra:
raise RuntimeError(
"WAMP-SCRAM challenge option '{}' is "
" required but not specified".format(k)
)
for k in challenge.extra:
if k not in optional_args + required_args:
raise RuntimeError(
"WAMP-SCRAM challenge has unknown attribute '{}'".format(k)
)
channel_binding = challenge.extra.get('channel_binding', '')
server_nonce = challenge.extra['nonce'] # base64
salt = challenge.extra['salt'] # base64
iterations = int(challenge.extra['iterations'])
memory = int(challenge.extra.get('memory', -1))
password = self._args['password'].encode('utf8') # supplied by user
authid = saslprep(self._args['authid'])
algorithm = challenge.extra['kdf']
client_nonce = self._client_nonce
self._auth_message = (
"{client_first_bare},{server_first},{client_final_no_proof}".format(
client_first_bare="n={},r={}".format(authid, client_nonce),
server_first="r={},s={},i={}".format(server_nonce, salt, iterations),
client_final_no_proof="c={},r={}".format(channel_binding, server_nonce),
)
).encode('ascii')
if algorithm == 'argon2id-13':
if memory == -1:
raise ValueError(
"WAMP-SCRAM 'argon2id-13' challenge requires 'memory' parameter"
)
self._salted_password = _hash_argon2id13_secret(password, salt, iterations, memory)
elif algorithm == 'pbkdf2':
self._salted_password = _hash_pbkdf2_secret(password, salt, iterations)
else:
raise RuntimeError(
"WAMP-SCRAM specified unknown KDF '{}'".format(algorithm)
)
client_key = hmac.new(self._salted_password, b"Client Key", hashlib.sha256).digest()
stored_key = hashlib.new('sha256', client_key).digest()
client_signature = hmac.new(stored_key, self._auth_message, hashlib.sha256).digest()
client_proof = xor_array(client_key, client_signature)
return base64.b64encode(client_proof)
def on_welcome(self, session, authextra):
"""
When the server is satisfied, it sends a 'WELCOME' message.
This hook allows us an opportunity to deny the session right
before it gets set up -- we check the server-signature thus
authorizing the server and if it fails we drop the connection.
"""
alleged_server_sig = base64.b64decode(authextra['scram_server_signature'])
server_key = hmac.new(self._salted_password, b"Server Key", hashlib.sha256).digest()
server_signature = hmac.new(server_key, self._auth_message, hashlib.sha256).digest()
if not hmac.compare_digest(server_signature, alleged_server_sig):
session.log.error("Verification of server SCRAM signature failed")
return "Verification of server SCRAM signature failed"
session.log.info(
"Verification of server SCRAM signature successful"
)
return None
IAuthenticator.register(AuthScram)
class AuthWampCra(object):
name = 'wampcra'
def __init__(self, **kw):
# should put in checkconfig or similar
for key in kw.keys():
if key not in ['authextra', 'authid', 'authrole', 'secret']:
raise ValueError(
"Unexpected key '{}' for {}".format(key, self.__class__.__name__)
)
for key in ['secret', 'authid']:
if key not in kw:
raise ValueError(
"Must provide '{}' for wampcra".format(key)
)
self._args = kw
self._secret = kw.pop('secret')
if not isinstance(self._secret, str):
self._secret = self._secret.decode('utf8')
@property
def authextra(self):
return self._args.get('authextra', dict())
def on_challenge(self, session, challenge):
key = self._secret.encode('utf8')
if 'salt' in challenge.extra:
key = derive_key(
key,
challenge.extra['salt'],
challenge.extra['iterations'],
challenge.extra['keylen']
)
signature = compute_wcs(
key,
challenge.extra['challenge'].encode('utf8')
)
return signature.decode('ascii')
def on_welcome(self, msg, authextra):
return None
IAuthenticator.register(AuthWampCra)
@public
def generate_totp_secret(length=10):
"""
Generates a new Base32 encoded, random secret.
.. seealso:: http://en.wikipedia.org/wiki/Base32
:param length: The length of the entropy used to generate the secret.
:type length: int
:returns: The generated secret in Base32 (letters ``A-Z`` and digits ``2-7``).
The length of the generated secret is ``length * 8 / 5`` octets.
:rtype: unicode
"""
assert(type(length) == int)
return base64.b32encode(os.urandom(length)).decode('ascii')
@public
def compute_totp(secret, offset=0):
"""
Computes the current TOTP code.
:param secret: Base32 encoded secret.
:type secret: unicode
:param offset: Time offset (in steps, use eg -1, 0, +1 for compliance with RFC6238)
for which to compute TOTP.
:type offset: int
:returns: TOTP for current time (+/- offset).
:rtype: unicode
"""
assert(type(secret) == str)
assert(type(offset) == int)
try:
key = base64.b32decode(secret)
except TypeError:
raise Exception('invalid secret')
interval = offset + int(time.time()) // 30
msg = struct.pack('>Q', interval)
digest = hmac.new(key, msg, hashlib.sha1).digest()
o = 15 & (digest[19])
token = (struct.unpack('>I', digest[o:o + 4])[0] & 0x7fffffff) % 1000000
return '{0:06d}'.format(token)
@public
def check_totp(secret, ticket):
"""
Check a TOTP value received from a principal trying to authenticate against
the expected value computed from the secret shared between the principal and
the authenticating entity.
The Internet can be slow, and clocks might not match exactly, so some
leniency is allowed. RFC6238 recommends looking an extra time step in either
direction, which essentially opens the window from 30 seconds to 90 seconds.
:param secret: The secret shared between the principal (eg a client) that
is authenticating, and the authenticating entity (eg a server).
:type secret: unicode
:param ticket: The TOTP value to be checked.
:type ticket: unicode
:returns: ``True`` if the TOTP value is correct, else ``False``.
:rtype: bool
"""
for offset in [0, 1, -1]:
if ticket == compute_totp(secret, offset):
return True
return False
@public
def qrcode_from_totp(secret, label, issuer):
if type(secret) != str:
raise Exception('secret must be of type unicode, not {}'.format(type(secret)))
if type(label) != str:
raise Exception('label must be of type unicode, not {}'.format(type(label)))
try:
import qrcode
import qrcode.image.svg
except ImportError:
raise Exception('qrcode not installed')
return qrcode.make(
'otpauth://totp/{}?secret={}&issuer={}'.format(label, secret, issuer),
box_size=3,
image_factory=qrcode.image.svg.SvgImage).to_string()
@public
def pbkdf2(data, salt, iterations=1000, keylen=32, hashfunc=None):
"""
Returns a binary digest for the PBKDF2 hash algorithm of ``data``
with the given ``salt``. It iterates ``iterations`` time and produces a
key of ``keylen`` bytes. By default SHA-256 is used as hash function,
a different hashlib ``hashfunc`` can be provided.
:param data: The data for which to compute the PBKDF2 derived key.
:type data: bytes
:param salt: The salt to use for deriving the key.
:type salt: bytes
:param iterations: The number of iterations to perform in PBKDF2.
:type iterations: int
:param keylen: The length of the cryptographic key to derive.
:type keylen: int
:param hashfunc: Name of the hash algorithm to use
:type hashfunc: str
:returns: The derived cryptographic key.
:rtype: bytes
"""
if not (type(data) == bytes) or \
not (type(salt) == bytes) or \
not (type(iterations) == int) or \
not (type(keylen) == int):
raise ValueError("Invalid argument types")
# justification: WAMP-CRA uses SHA256 and users shouldn't have any
# other reason to call this particular pbkdf2 function (arguably,
# it should be private maybe?)
if hashfunc is None:
hashfunc = 'sha256'
if hashfunc is callable:
# used to take stuff from hashlib; translate?
raise ValueError(
"pbkdf2 now takes the name of a hash algorithm for 'hashfunc='"
)
backend = default_backend()
# https://cryptography.io/en/latest/hazmat/primitives/key-derivation-functions/#pbkdf2
kdf = PBKDF2HMAC(
algorithm=getattr(hashes, hashfunc.upper())(),
length=keylen,
salt=salt,
iterations=iterations,
backend=backend,
)
return kdf.derive(data)
@public
def derive_key(secret, salt, iterations=1000, keylen=32):
"""
Computes a derived cryptographic key from a password according to PBKDF2.
.. seealso:: http://en.wikipedia.org/wiki/PBKDF2
:param secret: The secret.
:type secret: bytes or unicode
:param salt: The salt to be used.
:type salt: bytes or unicode
:param iterations: Number of iterations of derivation algorithm to run.
:type iterations: int
:param keylen: Length of the key to derive in bytes.
:type keylen: int
:return: The derived key in Base64 encoding.
:rtype: bytes
"""
if not (type(secret) in [str, bytes]):
raise ValueError("'secret' must be bytes")
if not (type(salt) in [str, bytes]):
raise ValueError("'salt' must be bytes")
if not (type(iterations) == int):
raise ValueError("'iterations' must be an integer")
if not (type(keylen) == int):
raise ValueError("'keylen' must be an integer")
if type(secret) == str:
secret = secret.encode('utf8')
if type(salt) == str:
salt = salt.encode('utf8')
key = pbkdf2(secret, salt, iterations, keylen)
return binascii.b2a_base64(key).strip()
WCS_SECRET_CHARSET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
"""
The characters from which :func:`autobahn.wamp.auth.generate_wcs` generates secrets.
"""
@public
def generate_wcs(length=14):
"""
Generates a new random secret for use with WAMP-CRA.
The secret generated is a random character sequence drawn from
- upper and lower case latin letters
- digits
-
:param length: The length of the secret to generate.
:type length: int
:return: The generated secret. The length of the generated is ``length`` octets.
:rtype: bytes
"""
assert(type(length) == int)
return "".join(random.choice(WCS_SECRET_CHARSET) for _ in range(length)).encode('ascii')
@public
def compute_wcs(key, challenge):
"""
Compute an WAMP-CRA authentication signature from an authentication
challenge and a (derived) key.
:param key: The key derived (via PBKDF2) from the secret.
:type key: bytes
:param challenge: The authentication challenge to sign.
:type challenge: bytes
:return: The authentication signature.
:rtype: bytes
"""
assert(type(key) in [str, bytes])
assert(type(challenge) in [str, bytes])
if type(key) == str:
key = key.encode('utf8')
if type(challenge) == str:
challenge = challenge.encode('utf8')
sig = hmac.new(key, challenge, hashlib.sha256).digest()
return binascii.b2a_base64(sig).strip()
def derive_scram_credential(email: str, password: str, salt: Optional[bytes] = None) -> Dict:
"""
Derive WAMP-SCRAM credentials from user email and password. The SCRAM parameters used
are the following (these are also contained in the returned credentials):
* kdf ``argon2id-13``
* time cost ``4096``
* memory cost ``512``
* parallelism ``1``
See `draft-irtf-cfrg-argon2 <https://datatracker.ietf.org/doc/draft-irtf-cfrg-argon2/>`__ and
`argon2-cffi <https://argon2-cffi.readthedocs.io/en/stable/>`__.
:param email: User email.
:param password: User password.
:param salt: Optional salt to use (must be 16 bytes long). If none is given, compute salt
from email as ``salt = SHA256(email)[:16]``.
:return: WAMP-SCRAM credentials. When serialized, the returned credentials can be copy-pasted
into the ``config.json`` node configuration for a Crossbar.io node.
"""
assert HAS_ARGON, 'missing dependency argon2'
from argon2.low_level import hash_secret
from argon2.low_level import Type
# derive salt from email
if not salt:
m = hashlib.sha256()
m.update(email.encode('utf8'))
salt = m.digest()[:16]
assert len(salt) == 16
hash_data = hash_secret(
secret=password.encode('utf8'),
salt=salt,
time_cost=4096,
memory_cost=512,
parallelism=1,
hash_len=32,
type=Type.ID,
version=19,
)
_, tag, v, params, _, salted_password = hash_data.decode('ascii').split('$')
assert tag == 'argon2id'
assert v == 'v=19' # argon's version 1.3 is represented as 0x13, which is 19 decimal...
params = {
k: v
for k, v in
[x.split('=') for x in params.split(',')]
}
salted_password = salted_password.encode('ascii')
client_key = hmac.new(salted_password, b"Client Key", hashlib.sha256).digest()
stored_key = hashlib.new('sha256', client_key).digest()
server_key = hmac.new(salted_password, b"Server Key", hashlib.sha256).digest()
credential = {
"kdf": "argon2id-13",
"memory": int(params['m']),
"iterations": int(params['t']),
"salt": binascii.b2a_hex(salt).decode('ascii'),
"stored-key": binascii.b2a_hex(stored_key).decode('ascii'),
"server-key": binascii.b2a_hex(server_key).decode('ascii'),
}
return credential

983
.venv/lib/python3.12/site-packages/autobahn/wamp/component.py Normal file
View File

@@ -0,0 +1,983 @@
###############################################################################
#
# The MIT License (MIT)
#
# Copyright (c) typedef int GmbH
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
###############################################################################
import itertools
import random
from functools import partial
import txaio
from autobahn.util import ObservableMixin
from autobahn.websocket.util import parse_url as parse_ws_url
from autobahn.rawsocket.util import parse_url as parse_rs_url
from autobahn.wamp.types import ComponentConfig, SubscribeOptions, RegisterOptions
from autobahn.wamp.exception import SessionNotReady, ApplicationError
from autobahn.wamp.auth import create_authenticator, IAuthenticator
from autobahn.wamp.serializer import SERID_TO_SER
__all__ = (
'Component'
)
def _validate_endpoint(endpoint, check_native_endpoint=None):
"""
Check a WAMP connecting endpoint configuration.
"""
if check_native_endpoint:
check_native_endpoint(endpoint)
elif not isinstance(endpoint, dict):
raise ValueError(
"'endpoint' must be a dict"
)
# note, we're falling through here -- check_native_endpoint can
# disallow or allow dict-based config as it likes, but if it
# *does* allow a dict through, we want to check "base options"
# here so that both Twisted and asyncio don't have to check these
# things as well.
if isinstance(endpoint, dict):
# XXX what about filling in anything missing from the URL? Or
# is that only for when *nothing* is provided for endpoint?
if 'type' not in endpoint:
# could maybe just make tcp the default?
raise ValueError("'type' required in endpoint configuration")
if endpoint['type'] not in ['tcp', 'unix']:
raise ValueError('invalid type "{}" in endpoint'.format(endpoint['type']))
for k in endpoint.keys():
if k not in ['type', 'host', 'port', 'path', 'tls', 'timeout', 'version']:
raise ValueError(
"Invalid key '{}' in endpoint configuration".format(k)
)
if endpoint['type'] == 'tcp':
for k in ['host', 'port']:
if k not in endpoint:
raise ValueError(
"'{}' required in 'tcp' endpoint config".format(k)
)
for k in ['path']:
if k in endpoint:
raise ValueError(
"'{}' not valid in 'tcp' endpoint config".format(k)
)
elif endpoint['type'] == 'unix':
for k in ['path']:
if k not in endpoint:
raise ValueError(
"'{}' required for 'unix' endpoint config".format(k)
)
for k in ['host', 'port', 'tls']:
if k in endpoint:
raise ValueError(
"'{}' not valid in 'unix' endpoint config".format(k)
)
else:
assert False, 'should not arrive here'
def _create_transport(index, transport, check_native_endpoint=None):
"""
Internal helper to insert defaults and create _Transport instances.
:param transport: a (possibly valid) transport configuration
:type transport: dict
:returns: a _Transport instance
:raises: ValueError on invalid configuration
"""
if type(transport) != dict:
raise ValueError('invalid type {} for transport configuration - must be a dict'.format(type(transport)))
valid_transport_keys = [
'type', 'url', 'endpoint', 'serializer', 'serializers', 'options',
'max_retries', 'max_retry_delay', 'initial_retry_delay',
'retry_delay_growth', 'retry_delay_jitter', 'proxy', 'headers'
]
for k in transport.keys():
if k not in valid_transport_keys:
raise ValueError(
"'{}' is not a valid configuration item".format(k)
)
kind = 'websocket'
if 'type' in transport:
if transport['type'] not in ['websocket', 'rawsocket']:
raise ValueError('Invalid transport type {}'.format(transport['type']))
kind = transport['type']
else:
transport['type'] = 'websocket'
if 'proxy' in transport and kind != 'websocket':
raise ValueError(
"proxy= only supported for type=websocket transports"
)
proxy = transport.get("proxy", None)
if proxy is not None:
for k in proxy.keys():
if k not in ['host', 'port']:
raise ValueError(
"Unknown key '{}' in proxy config".format(k)
)
for k in ['host', 'port']:
if k not in proxy:
raise ValueError(
"Proxy config requires '{}'".formaT(k)
)
options = dict()
if 'options' in transport:
options = transport['options']
if not isinstance(options, dict):
raise ValueError(
'options must be a dict, not {}'.format(type(options))
)
headers = transport.get("headers")
if kind == 'websocket':
for key in ['url']:
if key not in transport:
raise ValueError("Transport requires '{}' key".format(key))
# endpoint not required; we will deduce from URL if it's not provided
# XXX not in the branch I rebased; can this go away? (is it redundant??)
if 'endpoint' not in transport:
is_secure, host, port, resource, path, params = parse_ws_url(transport['url'])
endpoint_config = {
'type': 'tcp',
'host': host,
'port': port,
'tls': is_secure,
}
else:
# note: we're avoiding mutating the incoming "configuration"
# dict, so this should avoid that too...
endpoint_config = transport['endpoint']
_validate_endpoint(endpoint_config, check_native_endpoint)
if 'serializer' in transport:
raise ValueError("'serializer' is only for rawsocket; use 'serializers'")
if 'serializers' in transport:
if not isinstance(transport['serializers'], (list, tuple)):
raise ValueError("'serializers' must be a list of strings")
if not all([
isinstance(s, (str, str))
for s in transport['serializers']]):
raise ValueError("'serializers' must be a list of strings")
valid_serializers = SERID_TO_SER.keys()
for serial in transport['serializers']:
if serial not in valid_serializers:
raise ValueError(
"Invalid serializer '{}' (expected one of: {})".format(
serial,
', '.join([repr(s) for s in valid_serializers]),
)
)
serializer_config = transport.get('serializers', ['cbor', 'json'])
elif kind == 'rawsocket':
if 'endpoint' not in transport:
if transport['url'].startswith('rs'):
# # try to parse RawSocket URL ..
isSecure, host, port = parse_rs_url(transport['url'])
elif transport['url'].startswith('ws'):
# try to parse WebSocket URL ..
isSecure, host, port, resource, path, params = parse_ws_url(transport['url'])
else:
raise RuntimeError()
if host == 'unix':
# here, "port" is actually holding the path on the host, eg "/tmp/file.sock"
endpoint_config = {
'type': 'unix',
'path': port,
}
else:
endpoint_config = {
'type': 'tcp',
'host': host,
'port': port,
}
else:
endpoint_config = transport['endpoint']
if 'serializers' in transport:
raise ValueError("'serializers' is only for websocket; use 'serializer'")
if headers is not None:
raise ValueError("'headers' not supported for rawsocket transport")
# always a list; len == 1 for rawsocket
if 'serializer' in transport:
if not isinstance(transport['serializer'], (str, str)):
raise ValueError("'serializer' must be a string")
serializer_config = [transport['serializer']]
else:
serializer_config = ['cbor']
else:
assert False, 'should not arrive here'
kw = {}
for key in ['max_retries', 'max_retry_delay', 'initial_retry_delay',
'retry_delay_growth', 'retry_delay_jitter']:
if key in transport:
kw[key] = transport[key]
return _Transport(
index,
kind=kind,
url=transport.get('url', None),
endpoint=endpoint_config,
serializers=serializer_config,
proxy=proxy,
options=options,
headers=headers,
**kw
)
class _Transport(object):
"""
Thin-wrapper for WAMP transports used by a Connection.
"""
def __init__(self, idx, kind, url, endpoint, serializers,
max_retries=-1,
max_retry_delay=300,
initial_retry_delay=1.5,
retry_delay_growth=1.5,
retry_delay_jitter=0.1,
proxy=None,
options=None,
headers=None):
"""
"""
if options is None:
options = dict()
self.idx = idx
self.type = kind
self.url = url
self.endpoint = endpoint
self.options = options
self.headers = headers
self.serializers = serializers
if self.type == 'rawsocket' and len(serializers) != 1:
raise ValueError(
"'rawsocket' transport requires exactly one serializer"
)
self.max_retries = max_retries
self.max_retry_delay = max_retry_delay
self.initial_retry_delay = initial_retry_delay
self.retry_delay_growth = retry_delay_growth
self.retry_delay_jitter = retry_delay_jitter
self.proxy = proxy # this is a dict of proxy config
# used via can_reconnect() and failed() to record this
# transport is never going to work
self._permanent_failure = False
self.reset()
def reset(self):
"""
set connection failure rates and retry-delay to initial values
"""
self.connect_attempts = 0
self.connect_sucesses = 0
self.connect_failures = 0
self.retry_delay = self.initial_retry_delay
def failed(self):
"""
Mark this transport as failed, meaning we won't try to connect to
it any longer (that is: can_reconnect() will always return
False afer calling this).
"""
self._permanent_failure = True
def can_reconnect(self):
if self._permanent_failure:
return False
if self.max_retries == -1:
return True
return self.connect_attempts < self.max_retries + 1
def next_delay(self):
if self.connect_attempts == 0:
# if we never tried before, try immediately
return 0
elif self.max_retries != -1 and self.connect_attempts >= self.max_retries + 1:
raise RuntimeError('max reconnects reached')
else:
self.retry_delay = self.retry_delay * self.retry_delay_growth
self.retry_delay = random.normalvariate(self.retry_delay, self.retry_delay * self.retry_delay_jitter)
if self.retry_delay > self.max_retry_delay:
self.retry_delay = self.max_retry_delay
return self.retry_delay
def describe_endpoint(self):
"""
returns a human-readable description of the endpoint
"""
if isinstance(self.endpoint, dict):
return self.endpoint['type']
return repr(self.endpoint)
# this could probably implement twisted.application.service.IService
# if we wanted; or via an adapter...which just adds a startService()
# and stopService() [latter can be async]
class Component(ObservableMixin):
"""
A WAMP application component. A component holds configuration for
(and knows how to create) transports and sessions.
"""
session_factory = None
"""
The factory of the session we will instantiate.
"""
def subscribe(self, topic, options=None, check_types=False):
"""
A decorator as a shortcut for subscribing during on-join
For example::
@component.subscribe(
"some.topic",
options=SubscribeOptions(match='prefix'),
)
def topic(*args, **kw):
print("some.topic({}, {}): event received".format(args, kw))
"""
assert options is None or isinstance(options, SubscribeOptions)
def decorator(fn):
def do_subscription(session, details):
return session.subscribe(fn, topic=topic, options=options, check_types=check_types)
self.on('join', do_subscription)
return fn
return decorator
def register(self, uri, options=None, check_types=False):
"""
A decorator as a shortcut for registering during on-join
For example::
@component.register(
"com.example.add",
options=RegisterOptions(invoke='roundrobin'),
)
def add(*args, **kw):
print("add({}, {}): event received".format(args, kw))
"""
assert options is None or isinstance(options, RegisterOptions)
def decorator(fn):
def do_registration(session, details):
return session.register(fn, procedure=uri, options=options, check_types=check_types)
self.on('join', do_registration)
return fn
return decorator
def __init__(self, main=None, transports=None, config=None, realm='realm1', extra=None,
authentication=None, session_factory=None, is_fatal=None):
"""
:param main: After a transport has been connected and a session
has been established and joined to a realm, this (async)
procedure will be run until it finishes -- which signals that
the component has run to completion. In this case, it usually
doesn't make sense to use the ``on_*`` kwargs. If you do not
pass a main() procedure, the session will not be closed
(unless you arrange for .leave() to be called).
:type main: callable taking two args ``reactor`` and ``ISession``
:param transports: Transport configurations for creating
transports. Each transport can be a WAMP URL, or a dict
containing the following configuration keys:
- ``type`` (optional): ``websocket`` (default) or ``rawsocket``
- ``url``: the router URL
- ``endpoint`` (optional, derived from URL if not provided):
- ``type``: "tcp" or "unix"
- ``host``, ``port``: only for TCP
- ``path``: only for unix
- ``timeout``: in seconds
- ``tls``: ``True`` or (under Twisted) an
``twisted.internet.ssl.IOpenSSLClientComponentCreator``
instance (such as returned from
``twisted.internet.ssl.optionsForClientTLS``) or
``CertificateOptions`` instance.
- ``max_retries``: Maximum number of reconnection attempts. Unlimited if set to -1.
- ``initial_retry_delay``: Initial delay for reconnection attempt in seconds (Default: 1.0s).
- ``max_retry_delay``: Maximum delay for reconnection attempts in seconds (Default: 60s).
- ``retry_delay_growth``: The growth factor applied to the retry delay between reconnection attempts (Default 1.5).
- ``retry_delay_jitter``: A 0-argument callable that introduces nose into the delay. (Default random.random)
- ``serializer`` (only for raw socket): Specify an accepted serializer (e.g. 'json', 'msgpack', 'cbor', 'ubjson', 'flatbuffers')
- ``serializers``: Specify list of accepted serializers
- ``options``: tbd
- ``proxy``: tbd
:type transports: None or str or list
:param realm: the realm to join
:type realm: str
:param authentication: configuration of authenticators
:type authentication: dict
:param session_factory: if None, ``ApplicationSession`` is
used, otherwise a callable taking a single ``config`` argument
that is used to create a new `ApplicationSession` instance.
:param is_fatal: a callable taking a single argument, an
``Exception`` instance. The callable should return ``True`` if
this error is "fatal", meaning we should not try connecting to
the current transport again. The default behavior (on None) is
to always return ``False``
"""
self.set_valid_events(
[
'start', # fired by base class
'connect', # fired by ApplicationSession
'join', # fired by ApplicationSession
'ready', # fired by ApplicationSession
'leave', # fired by ApplicationSession
'disconnect', # fired by ApplicationSession
'connectfailure', # fired by base class
]
)
if is_fatal is not None and not callable(is_fatal):
raise ValueError('"is_fatal" must be a callable or None')
self._is_fatal = is_fatal
if main is not None and not callable(main):
raise ValueError('"main" must be a callable if given')
self._entry = main
# use WAMP-over-WebSocket to localhost when no transport is specified at all
if transports is None:
transports = 'ws://127.0.0.1:8080/ws'
# allows to provide a URL instead of a list of transports
if isinstance(transports, (str, str)):
url = transports
# 'endpoint' will get filled in by parsing the 'url'
transport = {
'type': 'websocket',
'url': url,
}
transports = [transport]
# allows single transport instead of a list (convenience)
elif isinstance(transports, dict):
transports = [transports]
# XXX do we want to be able to provide an infinite iterable of
# transports here? e.g. a generator that makes new transport
# to try?
# now check and save list of transports
self._transports = []
for idx, transport in enumerate(transports):
# allows to provide a URL instead of transport dict
if type(transport) == str:
_transport = {
'type': 'websocket',
'url': transport,
}
else:
_transport = transport
self._transports.append(
_create_transport(idx, _transport, self._check_native_endpoint)
)
# XXX should have some checkconfig support
self._authentication = authentication or {}
if session_factory:
self.session_factory = session_factory
self._realm = realm
self._extra = extra
self._delay_f = None
self._done_f = None
self._session = None
self._stopping = False
def _can_reconnect(self):
# check if any of our transport has any reconnect attempt left
for transport in self._transports:
if transport.can_reconnect():
return True
return False
def _start(self, loop=None):
"""
This starts the Component, which means it will start connecting
(and re-connecting) to its configured transports. A Component
runs until it is "done", which means one of:
- There was a "main" function defined, and it completed successfully;
- Something called ``.leave()`` on our session, and we left successfully;
- ``.stop()`` was called, and completed successfully;
- none of our transports were able to connect successfully (failure);
:returns: a Future/Deferred which will resolve (to ``None``) when we are
"done" or with an error if something went wrong.
"""
# we can only be "start()ed" once before we stop .. but that
# doesn't have to be an error we can give back another future
# that fires when our "real" _done_f is completed.
if self._done_f is not None:
d = txaio.create_future()
def _cb(arg):
txaio.resolve(d, arg)
txaio.add_callbacks(self._done_f, _cb, _cb)
return d
# this future will be returned, and thus has the semantics
# specified in the docstring.
self._done_f = txaio.create_future()
def _reset(arg):
"""
if the _done_f future is resolved (good or bad), we want to set it
to None in our class
"""
self._done_f = None
return arg
txaio.add_callbacks(self._done_f, _reset, _reset)
# Create a generator of transports that .can_reconnect()
transport_gen = itertools.cycle(self._transports)
# this is a 1-element list so we can set it from closures in
# this function
transport_candidate = [0]
def error(fail):
self._delay_f = None
if self._stopping:
# might be better to add framework-specific checks in
# subclasses to see if this is CancelledError (for
# Twisted) and whatever asyncio does .. but tracking
# if we're in the shutdown path is fine too
txaio.resolve(self._done_f, None)
else:
self.log.info("Internal error {msg}", msg=txaio.failure_message(fail))
self.log.debug("{tb}", tb=txaio.failure_format_traceback(fail))
txaio.reject(self._done_f, fail)
def attempt_connect(_):
self._delay_f = None
def handle_connect_error(fail):
# FIXME - make txaio friendly
# Can connect_f ever be in a cancelled state?
# if txaio.using_asyncio and isinstance(fail.value, asyncio.CancelledError):
# unrecoverable_error = True
self.log.debug('component failed: {error}', error=txaio.failure_message(fail))
self.log.debug('{tb}', tb=txaio.failure_format_traceback(fail))
# If this is a "fatal error" that will never work,
# we bail out now
if isinstance(fail.value, ApplicationError):
self.log.error("{msg}", msg=fail.value.error_message())
elif isinstance(fail.value, OSError):
# failed to connect entirely, like nobody
# listening etc.
self.log.info("Connection failed with OS error: {msg}", msg=txaio.failure_message(fail))
elif self._is_ssl_error(fail.value):
# Quoting pyOpenSSL docs: "Whenever
# [SSL.Error] is raised directly, it has a
# list of error messages from the OpenSSL
# error queue, where each item is a tuple
# (lib, function, reason). Here lib, function
# and reason are all strings, describing where
# and what the problem is. See err(3) for more
# information."
# (and 'args' is a 1-tuple containing the above
# 3-tuple...)
ssl_lib, ssl_func, ssl_reason = fail.value.args[0][0]
self.log.error("TLS failure: {reason}", reason=ssl_reason)
else:
self.log.error(
'Connection failed: {error}',
error=txaio.failure_message(fail),
)
if self._is_fatal is None:
is_fatal = False
else:
is_fatal = self._is_fatal(fail.value)
if is_fatal:
self.log.info("Error was fatal; failing transport")
transport_candidate[0].failed()
txaio.call_later(0, transport_check, None)
return
def notify_connect_error(fail):
chain_f = txaio.create_future()
# hmm, if connectfailure took a _Transport instead of
# (or in addition to?) self it could .failed() the
# transport and we could do away with the is_fatal
# listener?
handler_f = self.fire('connectfailure', self, fail.value)
txaio.add_callbacks(
handler_f,
lambda _: txaio.reject(chain_f, fail),
lambda _: txaio.reject(chain_f, fail)
)
return chain_f
def connect_error(fail):
notify_f = notify_connect_error(fail)
txaio.add_callbacks(notify_f, None, handle_connect_error)
def session_done(x):
txaio.resolve(self._done_f, None)
connect_f = txaio.as_future(
self._connect_once,
loop, transport_candidate[0],
)
txaio.add_callbacks(connect_f, session_done, connect_error)
def transport_check(_):
self.log.debug('Entering re-connect loop')
if not self._can_reconnect():
err_msg = "Component failed: Exhausted all transport connect attempts"
self.log.info(err_msg)
try:
raise RuntimeError(err_msg)
except RuntimeError as e:
txaio.reject(self._done_f, e)
return
while True:
transport = next(transport_gen)
if transport.can_reconnect():
transport_candidate[0] = transport
break
delay = transport.next_delay()
self.log.warn(
'trying transport {transport_idx} ("{transport_url}") using connect delay {transport_delay}',
transport_idx=transport.idx,
transport_url=transport.url,
transport_delay=delay,
)
self._delay_f = txaio.sleep(delay)
txaio.add_callbacks(self._delay_f, attempt_connect, error)
# issue our first event, then start reconnect loop
start_f = self.fire('start', loop, self)
txaio.add_callbacks(start_f, transport_check, error)
return self._done_f
def stop(self):
self._stopping = True
if self._session and self._session.is_attached():
return self._session.leave()
elif self._delay_f:
# This cancel request will actually call the "error" callback of
# the _delay_f future. Nothing to worry about.
return txaio.as_future(txaio.cancel, self._delay_f)
# if (for some reason -- should we log warning here to figure
# out if this can evern happen?) we've not fired _done_f, we
# do that now (causing our "main" to exit, and thus react() to
# quit)
if not txaio.is_called(self._done_f):
txaio.resolve(self._done_f, None)
return txaio.create_future_success(None)
def _connect_once(self, reactor, transport):
self.log.info(
'connecting once using transport type "{transport_type}" '
'over endpoint "{endpoint_desc}"',
transport_type=transport.type,
endpoint_desc=transport.describe_endpoint(),
)
done = txaio.create_future()
# factory for ISession objects
def create_session():
cfg = ComponentConfig(self._realm, self._extra)
try:
self._session = session = self.session_factory(cfg)
for auth_name, auth_config in self._authentication.items():
if isinstance(auth_config, IAuthenticator):
session.add_authenticator(auth_config)
else:
authenticator = create_authenticator(auth_name, **auth_config)
session.add_authenticator(authenticator)
except Exception as e:
# couldn't instantiate session calls, which is fatal.
# let the reconnection logic deal with that
f = txaio.create_failure(e)
txaio.reject(done, f)
raise
else:
# hook up the listener to the parent so we can bubble
# up events happning on the session onto the
# connection. This lets you do component.on('join',
# cb) which will work just as if you called
# session.on('join', cb) for every session created.
session._parent = self
# listen on leave events; if we get errors
# (e.g. no_such_realm), an on_leave can happen without
# an on_join before
def on_leave(session, details):
self.log.info(
"session leaving '{details.reason}'",
details=details,
)
if not txaio.is_called(done):
if details.reason in ["wamp.close.normal", "wamp.close.goodbye_and_out"]:
txaio.resolve(done, None)
else:
f = txaio.create_failure(
ApplicationError(details.reason, details.message)
)
txaio.reject(done, f)
session.on('leave', on_leave)
# if we were given a "main" procedure, we run through
# it completely (i.e. until its Deferred fires) and
# then disconnect this session
def on_join(session, details):
transport.reset()
transport.connect_sucesses += 1
self.log.debug("session on_join: {details}", details=details)
d = txaio.as_future(self._entry, reactor, session)
def main_success(_):
self.log.debug("main_success")
def leave():
try:
session.leave()
except SessionNotReady:
# someone may have already called
# leave()
pass
txaio.call_later(0, leave)
def main_error(err):
self.log.debug("main_error: {err}", err=err)
txaio.reject(done, err)
session.disconnect()
txaio.add_callbacks(d, main_success, main_error)
if self._entry is not None:
session.on('join', on_join)
# listen on disconnect events. Note that in case we
# had a "main" procedure, we could have already
# resolve()'d our "done" future
def on_disconnect(session, was_clean):
self.log.debug(
"session on_disconnect: was_clean={was_clean}",
was_clean=was_clean,
)
if not txaio.is_called(done):
if not was_clean:
self.log.warn(
"Session disconnected uncleanly"
)
else:
# eg the session has left the realm, and the transport was properly
# shut down. successfully finish the connection
txaio.resolve(done, None)
session.on('disconnect', on_disconnect)
# return the fresh session object
return session
transport.connect_attempts += 1
d = txaio.as_future(
self._connect_transport,
reactor, transport, create_session, done,
)
def on_error(err):
"""
this may seem redundant after looking at _connect_transport, but
it will handle a case where something goes wrong in
_connect_transport itself -- as the only connect our
caller has is the 'done' future
"""
transport.connect_failures += 1
# something bad has happened, and maybe didn't get caught
# upstream yet
if not txaio.is_called(done):
txaio.reject(done, err)
txaio.add_callbacks(d, None, on_error)
return done
def on_join(self, fn):
"""
A decorator as a shortcut for listening for 'join' events.
For example::
@component.on_join
def joined(session, details):
print("Session {} joined: {}".format(session, details))
"""
self.on('join', fn)
def on_leave(self, fn):
"""
A decorator as a shortcut for listening for 'leave' events.
"""
self.on('leave', fn)
def on_connect(self, fn):
"""
A decorator as a shortcut for listening for 'connect' events.
"""
self.on('connect', fn)
def on_disconnect(self, fn):
"""
A decorator as a shortcut for listening for 'disconnect' events.
"""
self.on('disconnect', fn)
def on_ready(self, fn):
"""
A decorator as a shortcut for listening for 'ready' events.
"""
self.on('ready', fn)
def on_connectfailure(self, fn):
"""
A decorator as a shortcut for listening for 'connectfailure' events.
"""
self.on('connectfailure', fn)
def _run(reactor, components, done_callback=None):
"""
Internal helper. Use "run" method from autobahn.twisted.wamp or
autobahn.asyncio.wamp
This is the generic parts of the run() method so that there's very
little code in the twisted/asyncio specific run() methods.
This is called by react() (or run_until_complete() so any errors
coming out of this should be handled properly. Logging will
already be started.
"""
# let user pass a single component to run, too
# XXX probably want IComponent? only demand it, here and below?
if isinstance(components, Component):
components = [components]
if type(components) != list:
raise ValueError(
'"components" must be a list of Component objects - encountered'
' {0}'.format(type(components))
)
for c in components:
if not isinstance(c, Component):
raise ValueError(
'"components" must be a list of Component objects - encountered'
'item of type {0}'.format(type(c))
)
# validation complete; proceed with startup
log = txaio.make_logger()
def component_success(comp, arg):
log.debug("Component '{c}' successfully completed: {arg}", c=comp, arg=arg)
return arg
def component_failure(comp, f):
log.error("Component '{c}' error: {msg}", c=comp, msg=txaio.failure_message(f))
log.debug("Component error: {tb}", tb=txaio.failure_format_traceback(f))
# double-check: is a component-failure still fatal to the
# startup process (because we passed consume_exception=False
# to gather() below?)
return None
def component_start(comp):
# the future from start() errbacks if we fail, or callbacks
# when the component is considered "done" (so maybe never)
d = txaio.as_future(comp.start, reactor)
txaio.add_callbacks(
d,
partial(component_success, comp),
partial(component_failure, comp),
)
return d
# note that these are started in parallel -- maybe we want to add
# a "connected" signal to components so we could start them in the
# order they're given to run() as "a" solution to dependencies.
dl = []
for comp in components:
d = component_start(comp)
dl.append(d)
done_d = txaio.gather(dl, consume_exceptions=False)
if done_callback:
def all_done(arg):
log.debug("All components ended; stopping reactor")
done_callback(reactor, arg)
txaio.add_callbacks(done_d, all_done, all_done)
return done_d

268
.venv/lib/python3.12/site-packages/autobahn/wamp/cryptobox.py Normal file
View File

@@ -0,0 +1,268 @@
###############################################################################
#
# The MIT License (MIT)
#
# Copyright (c) typedef int GmbH
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
###############################################################################
from autobahn.util import public
from autobahn.wamp.interfaces import IPayloadCodec
from autobahn.wamp.types import EncodedPayload
from autobahn.wamp.serializer import _dumps as _json_dumps
from autobahn.wamp.serializer import _loads as _json_loads
__all__ = [
'HAS_CRYPTOBOX',
'EncodedPayload'
]
try:
# try to import everything we need for WAMP-cryptobox
from nacl.encoding import Base64Encoder, RawEncoder, HexEncoder
from nacl.public import PrivateKey, PublicKey, Box
from nacl.utils import random
from pytrie import StringTrie
except ImportError:
HAS_CRYPTOBOX = False
else:
HAS_CRYPTOBOX = True
__all__.extend(['Key', 'KeyRing'])
if HAS_CRYPTOBOX:
@public
class Key(object):
"""
Holds originator and responder keys for an URI.
The originator is either a caller or a publisher. The responder is either a callee or subscriber.
"""
def __init__(self, originator_priv=None, originator_pub=None, responder_priv=None, responder_pub=None):
# the originator private and public keys, as available
if originator_priv:
self.originator_priv = PrivateKey(originator_priv, encoder=Base64Encoder)
else:
self.originator_priv = None
if self.originator_priv:
self.originator_pub = self.originator_priv.public_key
assert(originator_pub is None or originator_pub == self.originator_pub)
else:
self.originator_pub = PublicKey(originator_pub, encoder=Base64Encoder)
# the responder private and public keys, as available
if responder_priv:
self.responder_priv = PrivateKey(responder_priv, encoder=Base64Encoder)
else:
self.responder_priv = None
if self.responder_priv:
self.responder_pub = self.responder_priv.public_key
assert(responder_pub is None or responder_pub == self.responder_pub)
else:
self.responder_pub = PublicKey(responder_pub, encoder=Base64Encoder)
# this crypto box is for originators (callers, publishers):
#
# 1. _encrypting_ WAMP messages outgoing from originators: CALL*, PUBLISH*
# 2. _decrypting_ WAMP messages incoming to originators: RESULT*, ERROR
#
if self.originator_priv and self.responder_pub:
self.originator_box = Box(self.originator_priv, self.responder_pub)
else:
self.originator_box = None
# this crypto box is for responders (callees, subscribers):
#
# 1. _decrypting_ WAMP messages incoming to responders: INVOCATION*, EVENT*
# 2. _encrypting_ WAMP messages outgoing from responders: YIELD*, ERROR
#
if self.responder_priv and self.originator_pub:
self.responder_box = Box(self.responder_priv, self.originator_pub)
else:
self.responder_box = None
if not (self.originator_box or self.responder_box):
raise Exception("insufficient keys provided for at least originator or responder role")
@public
class SymKey(object):
"""
Holds a symmetric key for an URI.
"""
def __init__(self, raw=None):
pass
@public
class KeyRing(object):
"""
A keyring holds (cryptobox) public-private key pairs for use with WAMP-cryptobox payload
encryption. The keyring can be set on a WAMP session and then transparently will get used
for encrypting and decrypting WAMP message payloads.
"""
@public
def __init__(self, default_key=None):
"""
Create a new key ring to hold public and private keys mapped from an URI space.
"""
assert(default_key is None or isinstance(default_key, Key) or type(default_key == str))
self._uri_to_key = StringTrie()
if type(default_key) == str:
default_key = Key(originator_priv=default_key, responder_priv=default_key)
self._default_key = default_key
@public
def generate_key(self):
"""
Generate a new private key and return a pair with the base64 encodings
of (priv_key, pub_key).
"""
key = PrivateKey.generate()
priv_key = key.encode(encoder=Base64Encoder)
pub_key = key.public_key.encode(encoder=Base64Encoder)
return priv_key.decode('ascii'), pub_key.decode('ascii')
@public
def generate_key_hex(self):
"""
Generate a new private key and return a pair with the hex encodings
of (priv_key, pub_key).
"""
key = PrivateKey.generate()
priv_key = key.encode(encoder=HexEncoder)
pub_key = key.public_key.encode(encoder=HexEncoder)
return priv_key.decode('ascii'), pub_key.decode('ascii')
@public
def set_key(self, uri, key):
"""
Add a key set for a given URI.
"""
assert(type(uri) == str)
assert(key is None or isinstance(key, Key) or type(key) == str)
if type(key) == str:
key = Key(originator_priv=key, responder_priv=key)
if uri == '':
self._default_key = key
else:
if key is None:
if uri in self._uri_to_key:
del self._uri_to_key[uri]
else:
self._uri_to_key[uri] = key
@public
def rotate_key(self, uri):
assert(type(uri) == str)
if uri in self._uri_to_key:
self._uri_to_key[uri].rotate()
else:
self._uri_to_key[uri].rotate()
def _get_box(self, is_originating, uri, match_exact=False):
try:
if match_exact:
key = self._uri_to_key[uri]
else:
key = self._uri_to_key.longest_prefix_value(uri)
except KeyError:
if self._default_key:
key = self._default_key
else:
return None
if is_originating:
return key.originator_box
else:
return key.responder_box
@public
def encode(self, is_originating, uri, args=None, kwargs=None):
"""
Encrypt the given WAMP URI, args and kwargs into an EncodedPayload instance, or None
if the URI should not be encrypted.
"""
assert(type(is_originating) == bool)
assert(type(uri) == str)
assert(args is None or type(args) in (list, tuple))
assert(kwargs is None or type(kwargs) == dict)
box = self._get_box(is_originating, uri)
if not box:
# if we didn't find a crypto box, then return None, which
# signals that the payload travel unencrypted (normal)
return None
payload = {
'uri': uri,
'args': args,
'kwargs': kwargs
}
nonce = random(Box.NONCE_SIZE)
payload_ser = _json_dumps(payload).encode('utf8')
payload_encr = box.encrypt(payload_ser, nonce, encoder=RawEncoder)
# above returns an instance of http://pynacl.readthedocs.io/en/latest/utils/#nacl.utils.EncryptedMessage
# which is a bytes _subclass_! hence we apply bytes() to get at the underlying plain
# bytes "scalar", which is the concatenation of `payload_encr.nonce + payload_encr.ciphertext`
payload_bytes = bytes(payload_encr)
payload_key = None
return EncodedPayload(payload_bytes, 'cryptobox', 'json', enc_key=payload_key)
@public
def decode(self, is_originating, uri, encoded_payload):
"""
Decrypt the given WAMP URI and EncodedPayload into a tuple ``(uri, args, kwargs)``.
"""
assert(type(uri) == str)
assert(isinstance(encoded_payload, EncodedPayload))
assert(encoded_payload.enc_algo == 'cryptobox')
box = self._get_box(is_originating, uri)
if not box:
raise Exception("received encrypted payload, but can't find key!")
payload_ser = box.decrypt(encoded_payload.payload, encoder=RawEncoder)
if encoded_payload.enc_serializer != 'json':
raise Exception("received encrypted payload, but don't know how to process serializer '{}'".format(encoded_payload.enc_serializer))
payload = _json_loads(payload_ser.decode('utf8'))
uri = payload.get('uri', None)
args = payload.get('args', None)
kwargs = payload.get('kwargs', None)
return uri, args, kwargs
# A WAMP-cryptobox keyring can work as a codec for
# payload transparency
IPayloadCodec.register(KeyRing)

1022
.venv/lib/python3.12/site-packages/autobahn/wamp/cryptosign.py Normal file
View File

File diff suppressed because it is too large Load Diff

326
.venv/lib/python3.12/site-packages/autobahn/wamp/exception.py Normal file
View File

@@ -0,0 +1,326 @@
###############################################################################
#
# The MIT License (MIT)
#
# Copyright (c) typedef int GmbH
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
###############################################################################
from autobahn.util import public
from autobahn.wamp.uri import error
__all__ = (
'Error',
'SessionNotReady',
'SerializationError',
'InvalidUriError',
'ProtocolError',
'TransportLost',
'ApplicationError',
'NotAuthorized',
'InvalidUri',
'InvalidPayload',
'TypeCheckError',
)
@public
class Error(RuntimeError):
"""
Base class for all exceptions related to WAMP.
"""
@public
class SessionNotReady(Error):
"""
The application tried to perform a WAMP interaction, but the
session is not yet fully established.
"""
@public
class SerializationError(Error):
"""
Exception raised when the WAMP serializer could not serialize the
application payload (``args`` or ``kwargs`` for ``CALL``, ``PUBLISH``, etc).
"""
@public
class InvalidUriError(Error):
"""
Exception raised when an invalid WAMP URI was used.
"""
@public
class ProtocolError(Error):
"""
Exception raised when WAMP protocol was violated. Protocol errors
are fatal and are handled by the WAMP implementation. They are
not supposed to be handled at the application level.
"""
@public
class TransportLost(Error):
"""
Exception raised when the transport underlying the WAMP session
was lost or is not connected.
"""
@public
class ApplicationError(Error):
"""
Base class for all exceptions that can/may be handled
at the application level.
"""
INVALID_URI = "wamp.error.invalid_uri"
"""
Peer provided an incorrect URI for a URI-based attribute of a WAMP message
such as a realm, topic or procedure.
"""
INVALID_PAYLOAD = "wamp.error.invalid_payload"
"""
The application payload could not be serialized.
"""
PAYLOAD_SIZE_EXCEEDED = "wamp.error.payload_size_exceeded"
"""
The application payload could not be transported becuase the serialized/framed payload
exceeds the transport limits.
"""
NO_SUCH_PROCEDURE = "wamp.error.no_such_procedure"
"""
A Dealer could not perform a call, since not procedure is currently registered
under the given URI.
"""
PROCEDURE_ALREADY_EXISTS = "wamp.error.procedure_already_exists"
"""
A procedure could not be registered, since a procedure with the given URI is
already registered.
"""
PROCEDURE_EXISTS_INVOCATION_POLICY_CONFLICT = "wamp.error.procedure_exists_with_different_invocation_policy"
"""
A procedure could not be registered, since a procedure with the given URI is
already registered, and the registration has a conflicting invocation policy.
"""
NO_SUCH_REGISTRATION = "wamp.error.no_such_registration"
"""
A Dealer could not perform a unregister, since the given registration is not active.
"""
NO_SUCH_SUBSCRIPTION = "wamp.error.no_such_subscription"
"""
A Broker could not perform a unsubscribe, since the given subscription is not active.
"""
NO_SUCH_SESSION = "wamp.error.no_such_session"
"""
A router could not perform an operation, since a session ID specified was non-existant.
"""
INVALID_ARGUMENT = "wamp.error.invalid_argument"
"""
A call failed, since the given argument types or values are not acceptable to the
called procedure - in which case the *Callee* may throw this error. Or a Router
performing *payload validation* checked the payload (``args`` / ``kwargs``) of a call,
call result, call error or publish, and the payload did not conform.
"""
# FIXME: this currently isn't used neither in Autobahn nor Crossbar. Check!
SYSTEM_SHUTDOWN = "wamp.error.system_shutdown"
"""
The *Peer* is shutting down completely - used as a ``GOODBYE`` (or ``ABORT``) reason.
"""
# FIXME: this currently isn't used neither in Autobahn nor Crossbar. Check!
CLOSE_REALM = "wamp.error.close_realm"
"""
The *Peer* want to leave the realm - used as a ``GOODBYE`` reason.
"""
# FIXME: this currently isn't used neither in Autobahn nor Crossbar. Check!
GOODBYE_AND_OUT = "wamp.error.goodbye_and_out"
"""
A *Peer* acknowledges ending of a session - used as a ``GOOBYE`` reply reason.
"""
NOT_AUTHORIZED = "wamp.error.not_authorized"
"""
A call, register, publish or subscribe failed, since the session is not authorized
to perform the operation.
"""
AUTHORIZATION_FAILED = "wamp.error.authorization_failed"
"""
A Dealer or Broker could not determine if the *Peer* is authorized to perform
a join, call, register, publish or subscribe, since the authorization operation
*itself* failed. E.g. a custom authorizer did run into an error.
"""
AUTHENTICATION_FAILED = "wamp.error.authentication_failed"
"""
Something failed with the authentication itself, that is, authentication could
not run to end.
"""
NO_AUTH_METHOD = "wamp.error.no_auth_method"
"""
No authentication method the peer offered is available or active.
"""
NO_SUCH_REALM = "wamp.error.no_such_realm"
"""
Peer wanted to join a non-existing realm (and the *Router* did not allow to auto-create
the realm).
"""
NO_SUCH_ROLE = "wamp.error.no_such_role"
"""
A *Peer* was to be authenticated under a Role that does not (or no longer) exists on the Router.
For example, the *Peer* was successfully authenticated, but the Role configured does not
exists - hence there is some misconfiguration in the Router.
"""
NO_SUCH_PRINCIPAL = "wamp.error.no_such_principal"
"""
A *Peer* was authenticated for an authid that does not or longer exists.
"""
CANCELED = "wamp.error.canceled"
"""
A Dealer or Callee canceled a call previously issued (WAMP AP).
"""
TIMEOUT = "wamp.error.timeout"
"""
A pending (in-flight) call was timed out.
"""
# FIXME: this currently isn't used neither in Autobahn nor Crossbar. Check!
NO_ELIGIBLE_CALLEE = "wamp.error.no_eligible_callee"
"""
A *Dealer* could not perform a call, since a procedure with the given URI is registered,
but *Callee Black- and Whitelisting* and/or *Caller Exclusion* lead to the
exclusion of (any) *Callee* providing the procedure (WAMP AP).
"""
ENC_NO_PAYLOAD_CODEC = "wamp.error.no_payload_codec"
"""
WAMP message in payload transparency mode received, but no codec set
or codec did not decode the payload.
"""
ENC_TRUSTED_URI_MISMATCH = "wamp.error.encryption.trusted_uri_mismatch"
"""
WAMP-cryptobox application payload end-to-end encryption error.
"""
ENC_DECRYPT_ERROR = "wamp.error.encryption.decrypt_error"
"""
WAMP-cryptobox application payload end-to-end encryption error.
"""
TYPE_CHECK_ERROR = "wamp.error.type_check_error"
"""
WAMP procedure called with wrong argument types or subscription published
with wrong argument types.
"""
def __init__(self, error, *args, **kwargs):
"""
:param error: The URI of the error that occurred, e.g. ``wamp.error.not_authorized``.
:type error: str
"""
Exception.__init__(self, *args)
self.kwargs = kwargs
self.error = error
self.enc_algo = kwargs.pop('enc_algo', None)
self.callee = kwargs.pop('callee', None)
self.callee_authid = kwargs.pop('callee_authid', None)
self.callee_authrole = kwargs.pop('callee_authrole', None)
self.forward_for = kwargs.pop('forward_for', None)
@public
def error_message(self):
"""
Get the error message of this exception.
:returns: The error message.
:rtype: str
"""
return '{0}: {1}'.format(
self.error,
' '.join([str(a) for a in self.args]),
)
def __unicode__(self):
if self.kwargs and 'traceback' in self.kwargs:
tb = ':\n' + self.kwargs.pop('traceback') + '\n'
self.kwargs['traceback'] = '...'
else:
tb = ''
return "ApplicationError(error=<{0}>, args={1}, kwargs={2}, enc_algo={3}, callee={4}, callee_authid={5}, callee_authrole={6}, forward_for={7}){8}".format(
self.error, list(self.args), self.kwargs, self.enc_algo, self.callee, self.callee_authid, self.callee_authrole, self.forward_for, tb)
def __str__(self):
return self.__unicode__()
@error(ApplicationError.NOT_AUTHORIZED)
class NotAuthorized(Exception):
"""
Not authorized to perform the respective action.
"""
@error(ApplicationError.INVALID_URI)
class InvalidUri(Exception):
"""
The URI for a topic, procedure or error is not a valid WAMP URI.
"""
@error(ApplicationError.INVALID_PAYLOAD)
class InvalidPayload(Exception):
"""
The URI for a topic, procedure or error is not a valid WAMP URI.
"""
class TypeCheckError(ApplicationError):
"""
The URI for a topic published with invalid argument types or a
procedure called with invalid arguments types.
"""
def __init__(self, *args, **kwargs):
super().__init__(ApplicationError.TYPE_CHECK_ERROR, *args, **kwargs)

0
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/__init__.py Normal file
View File

BIN
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/schema/auth.bfbs Normal file
View File

Binary file not shown.

BIN
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/schema/pubsub.bfbs Normal file
View File

Binary file not shown.

BIN
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/schema/roles.bfbs Normal file
View File

Binary file not shown.

BIN
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/schema/rpc.bfbs Normal file
View File

Binary file not shown.

BIN
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/schema/session.bfbs Normal file
View File

Binary file not shown.

BIN
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/schema/types.bfbs Normal file
View File

Binary file not shown.

BIN
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/schema/wamp.bfbs Normal file
View File

Binary file not shown.

52
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/Map.py Normal file
View File

@@ -0,0 +1,52 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: wamp
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Map(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Map()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsMap(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Map
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Map
def Key(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Map
def Value(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
def MapStart(builder): builder.StartObject(2)
def Start(builder):
return MapStart(builder)
def MapAddKey(builder, key): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(key), 0)
def AddKey(builder, key):
return MapAddKey(builder, key)
def MapAddValue(builder, value): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(value), 0)
def AddValue(builder, value):
return MapAddValue(builder, value)
def MapEnd(builder): return builder.EndObject()
def End(builder):
return MapEnd(builder)

32
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/Void.py Normal file
View File

@@ -0,0 +1,32 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: wamp
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Void(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Void()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsVoid(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Void
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
def VoidStart(builder): builder.StartObject(0)
def Start(builder):
return VoidStart(builder)
def VoidEnd(builder): return builder.EndObject()
def End(builder):
return VoidEnd(builder)

0
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/__init__.py Normal file
View File

62
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Abort.py Normal file
View File

@@ -0,0 +1,62 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Abort(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Abort()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsAbort(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Abort
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Abort
def Session(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Abort
def Reason(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Abort
def Message(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
def AbortStart(builder): builder.StartObject(3)
def Start(builder):
return AbortStart(builder)
def AbortAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
def AddSession(builder, session):
return AbortAddSession(builder, session)
def AbortAddReason(builder, reason): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(reason), 0)
def AddReason(builder, reason):
return AbortAddReason(builder, reason)
def AbortAddMessage(builder, message): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(message), 0)
def AddMessage(builder, message):
return AbortAddMessage(builder, message)
def AbortEnd(builder): return builder.EndObject()
def End(builder):
return AbortEnd(builder)

31
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AnyMessage.py Normal file
View File

@@ -0,0 +1,31 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
class AnyMessage(object):
NONE = 0
Hello = 1
Welcome = 2
Abort = 3
Challenge = 4
Authenticate = 5
Goodbye = 6
Error = 7
Publish = 8
Published = 9
Subscribe = 10
Subscribed = 11
Unsubscribe = 12
Unsubscribed = 13
Event = 14
EventReceived = 15
Call = 16
Cancel = 17
Result = 18
Register = 19
Registered = 20
Unregister = 21
Unregistered = 22
Invocation = 23
Interrupt = 24
Yield = 25

72
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthCraChallenge.py Normal file
View File

@@ -0,0 +1,72 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class AuthCraChallenge(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = AuthCraChallenge()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsAuthCraChallenge(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# AuthCraChallenge
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# AuthCraChallenge
def Challenge(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# AuthCraChallenge
def Salt(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# AuthCraChallenge
def Iterations(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 1000
# AuthCraChallenge
def Keylen(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 32
def AuthCraChallengeStart(builder): builder.StartObject(4)
def Start(builder):
return AuthCraChallengeStart(builder)
def AuthCraChallengeAddChallenge(builder, challenge): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(challenge), 0)
def AddChallenge(builder, challenge):
return AuthCraChallengeAddChallenge(builder, challenge)
def AuthCraChallengeAddSalt(builder, salt): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(salt), 0)
def AddSalt(builder, salt):
return AuthCraChallengeAddSalt(builder, salt)
def AuthCraChallengeAddIterations(builder, iterations): builder.PrependUint32Slot(2, iterations, 1000)
def AddIterations(builder, iterations):
return AuthCraChallengeAddIterations(builder, iterations)
def AuthCraChallengeAddKeylen(builder, keylen): builder.PrependUint8Slot(3, keylen, 32)
def AddKeylen(builder, keylen):
return AuthCraChallengeAddKeylen(builder, keylen)
def AuthCraChallengeEnd(builder): return builder.EndObject()
def End(builder):
return AuthCraChallengeEnd(builder)

32
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthCraRequest.py Normal file
View File

@@ -0,0 +1,32 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class AuthCraRequest(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = AuthCraRequest()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsAuthCraRequest(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# AuthCraRequest
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
def AuthCraRequestStart(builder): builder.StartObject(0)
def Start(builder):
return AuthCraRequestStart(builder)
def AuthCraRequestEnd(builder): return builder.EndObject()
def End(builder):
return AuthCraRequestEnd(builder)

32
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthCraWelcome.py Normal file
View File

@@ -0,0 +1,32 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class AuthCraWelcome(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = AuthCraWelcome()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsAuthCraWelcome(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# AuthCraWelcome
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
def AuthCraWelcomeStart(builder): builder.StartObject(0)
def Start(builder):
return AuthCraWelcomeStart(builder)
def AuthCraWelcomeEnd(builder): return builder.EndObject()
def End(builder):
return AuthCraWelcomeEnd(builder)

42
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthCryptosignChallenge.py Normal file
View File

@@ -0,0 +1,42 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class AuthCryptosignChallenge(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = AuthCryptosignChallenge()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsAuthCryptosignChallenge(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# AuthCryptosignChallenge
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# AuthCryptosignChallenge
def ChannelBinding(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
def AuthCryptosignChallengeStart(builder): builder.StartObject(1)
def Start(builder):
return AuthCryptosignChallengeStart(builder)
def AuthCryptosignChallengeAddChannelBinding(builder, channelBinding): builder.PrependUint8Slot(0, channelBinding, 0)
def AddChannelBinding(builder, channelBinding):
return AuthCryptosignChallengeAddChannelBinding(builder, channelBinding)
def AuthCryptosignChallengeEnd(builder): return builder.EndObject()
def End(builder):
return AuthCryptosignChallengeEnd(builder)

52
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthCryptosignRequest.py Normal file
View File

@@ -0,0 +1,52 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class AuthCryptosignRequest(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = AuthCryptosignRequest()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsAuthCryptosignRequest(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# AuthCryptosignRequest
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# AuthCryptosignRequest
def Pubkey(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# AuthCryptosignRequest
def ChannelBinding(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
def AuthCryptosignRequestStart(builder): builder.StartObject(2)
def Start(builder):
return AuthCryptosignRequestStart(builder)
def AuthCryptosignRequestAddPubkey(builder, pubkey): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pubkey), 0)
def AddPubkey(builder, pubkey):
return AuthCryptosignRequestAddPubkey(builder, pubkey)
def AuthCryptosignRequestAddChannelBinding(builder, channelBinding): builder.PrependUint8Slot(1, channelBinding, 0)
def AddChannelBinding(builder, channelBinding):
return AuthCryptosignRequestAddChannelBinding(builder, channelBinding)
def AuthCryptosignRequestEnd(builder): return builder.EndObject()
def End(builder):
return AuthCryptosignRequestEnd(builder)

32
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthCryptosignWelcome.py Normal file
View File

@@ -0,0 +1,32 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class AuthCryptosignWelcome(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = AuthCryptosignWelcome()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsAuthCryptosignWelcome(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# AuthCryptosignWelcome
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
def AuthCryptosignWelcomeStart(builder): builder.StartObject(0)
def Start(builder):
return AuthCryptosignWelcomeStart(builder)
def AuthCryptosignWelcomeEnd(builder): return builder.EndObject()
def End(builder):
return AuthCryptosignWelcomeEnd(builder)

10
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthFactor.py Normal file
View File

@@ -0,0 +1,10 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
class AuthFactor(object):
NONE = 0
AuthTicketRequest = 1
AuthCraRequest = 2
AuthScramRequest = 3
AuthCryptosignRequest = 4

12
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthMethod.py Normal file
View File

@@ -0,0 +1,12 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
class AuthMethod(object):
ANONYMOUS = 0
COOKIE = 1
TLS = 2
TICKET = 3
CRA = 4
SCRAM = 5
CRYPTOSIGN = 6

7
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthMode.py Normal file
View File

@@ -0,0 +1,7 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
class AuthMode(object):
FIRST = 0
MULTIFACTOR = 1

92
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthScramChallenge.py Normal file
View File

@@ -0,0 +1,92 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class AuthScramChallenge(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = AuthScramChallenge()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsAuthScramChallenge(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# AuthScramChallenge
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# AuthScramChallenge
def Nonce(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# AuthScramChallenge
def Salt(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# AuthScramChallenge
def Kdf(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 2
# AuthScramChallenge
def Iterations(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# AuthScramChallenge
def Memory(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# AuthScramChallenge
def ChannelBinding(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
def AuthScramChallengeStart(builder): builder.StartObject(6)
def Start(builder):
return AuthScramChallengeStart(builder)
def AuthScramChallengeAddNonce(builder, nonce): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(nonce), 0)
def AddNonce(builder, nonce):
return AuthScramChallengeAddNonce(builder, nonce)
def AuthScramChallengeAddSalt(builder, salt): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(salt), 0)
def AddSalt(builder, salt):
return AuthScramChallengeAddSalt(builder, salt)
def AuthScramChallengeAddKdf(builder, kdf): builder.PrependUint8Slot(2, kdf, 2)
def AddKdf(builder, kdf):
return AuthScramChallengeAddKdf(builder, kdf)
def AuthScramChallengeAddIterations(builder, iterations): builder.PrependUint32Slot(3, iterations, 0)
def AddIterations(builder, iterations):
return AuthScramChallengeAddIterations(builder, iterations)
def AuthScramChallengeAddMemory(builder, memory): builder.PrependUint32Slot(4, memory, 0)
def AddMemory(builder, memory):
return AuthScramChallengeAddMemory(builder, memory)
def AuthScramChallengeAddChannelBinding(builder, channelBinding): builder.PrependUint8Slot(5, channelBinding, 0)
def AddChannelBinding(builder, channelBinding):
return AuthScramChallengeAddChannelBinding(builder, channelBinding)
def AuthScramChallengeEnd(builder): return builder.EndObject()
def End(builder):
return AuthScramChallengeEnd(builder)

52
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthScramRequest.py Normal file
View File

@@ -0,0 +1,52 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class AuthScramRequest(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = AuthScramRequest()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsAuthScramRequest(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# AuthScramRequest
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# AuthScramRequest
def Nonce(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# AuthScramRequest
def ChannelBinding(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
def AuthScramRequestStart(builder): builder.StartObject(2)
def Start(builder):
return AuthScramRequestStart(builder)
def AuthScramRequestAddNonce(builder, nonce): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(nonce), 0)
def AddNonce(builder, nonce):
return AuthScramRequestAddNonce(builder, nonce)
def AuthScramRequestAddChannelBinding(builder, channelBinding): builder.PrependUint8Slot(1, channelBinding, 0)
def AddChannelBinding(builder, channelBinding):
return AuthScramRequestAddChannelBinding(builder, channelBinding)
def AuthScramRequestEnd(builder): return builder.EndObject()
def End(builder):
return AuthScramRequestEnd(builder)

42
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthScramWelcome.py Normal file
View File

@@ -0,0 +1,42 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class AuthScramWelcome(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = AuthScramWelcome()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsAuthScramWelcome(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# AuthScramWelcome
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# AuthScramWelcome
def Verifier(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
def AuthScramWelcomeStart(builder): builder.StartObject(1)
def Start(builder):
return AuthScramWelcomeStart(builder)
def AuthScramWelcomeAddVerifier(builder, verifier): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(verifier), 0)
def AddVerifier(builder, verifier):
return AuthScramWelcomeAddVerifier(builder, verifier)
def AuthScramWelcomeEnd(builder): return builder.EndObject()
def End(builder):
return AuthScramWelcomeEnd(builder)

32
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthTicketChallenge.py Normal file
View File

@@ -0,0 +1,32 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class AuthTicketChallenge(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = AuthTicketChallenge()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsAuthTicketChallenge(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# AuthTicketChallenge
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
def AuthTicketChallengeStart(builder): builder.StartObject(0)
def Start(builder):
return AuthTicketChallengeStart(builder)
def AuthTicketChallengeEnd(builder): return builder.EndObject()
def End(builder):
return AuthTicketChallengeEnd(builder)

32
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthTicketRequest.py Normal file
View File

@@ -0,0 +1,32 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class AuthTicketRequest(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = AuthTicketRequest()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsAuthTicketRequest(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# AuthTicketRequest
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
def AuthTicketRequestStart(builder): builder.StartObject(0)
def Start(builder):
return AuthTicketRequestStart(builder)
def AuthTicketRequestEnd(builder): return builder.EndObject()
def End(builder):
return AuthTicketRequestEnd(builder)

32
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthTicketWelcome.py Normal file
View File

@@ -0,0 +1,32 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class AuthTicketWelcome(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = AuthTicketWelcome()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsAuthTicketWelcome(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# AuthTicketWelcome
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
def AuthTicketWelcomeStart(builder): builder.StartObject(0)
def Start(builder):
return AuthTicketWelcomeStart(builder)
def AuthTicketWelcomeEnd(builder): return builder.EndObject()
def End(builder):
return AuthTicketWelcomeEnd(builder)

66
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Authenticate.py Normal file
View File

@@ -0,0 +1,66 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Authenticate(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Authenticate()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsAuthenticate(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Authenticate
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Authenticate
def Session(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Authenticate
def Signature(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Authenticate
def Extra(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from wamp.Map import Map
obj = Map()
obj.Init(self._tab.Bytes, x)
return obj
return None
def AuthenticateStart(builder): builder.StartObject(3)
def Start(builder):
return AuthenticateStart(builder)
def AuthenticateAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
def AddSession(builder, session):
return AuthenticateAddSession(builder, session)
def AuthenticateAddSignature(builder, signature): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(signature), 0)
def AddSignature(builder, signature):
return AuthenticateAddSignature(builder, signature)
def AuthenticateAddExtra(builder, extra): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(extra), 0)
def AddExtra(builder, extra):
return AuthenticateAddExtra(builder, extra)
def AuthenticateEnd(builder): return builder.EndObject()
def End(builder):
return AuthenticateEnd(builder)

172
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/BrokerFeatures.py Normal file
View File

@@ -0,0 +1,172 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class BrokerFeatures(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = BrokerFeatures()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsBrokerFeatures(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# BrokerFeatures
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# BrokerFeatures
def PublisherIdentification(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# BrokerFeatures
def PublisherExclusion(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# BrokerFeatures
def SubscriberBlackwhiteListing(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# BrokerFeatures
def PatternBasedSubscription(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# BrokerFeatures
def PublicationTrustlevels(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# BrokerFeatures
def SubscriptionRevocation(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# BrokerFeatures
def SessionMetaApi(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# BrokerFeatures
def SubscriptionMetaApi(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# BrokerFeatures
def EventRetention(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# BrokerFeatures
def EventHistory(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# BrokerFeatures
def AcknowledgeEventReceived(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# BrokerFeatures
def AcknowledgeSubscriberReceived(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# BrokerFeatures
def PayloadTransparency(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# BrokerFeatures
def PayloadEncryptionCryptobox(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
def BrokerFeaturesStart(builder): builder.StartObject(14)
def Start(builder):
return BrokerFeaturesStart(builder)
def BrokerFeaturesAddPublisherIdentification(builder, publisherIdentification): builder.PrependBoolSlot(0, publisherIdentification, 0)
def AddPublisherIdentification(builder, publisherIdentification):
return BrokerFeaturesAddPublisherIdentification(builder, publisherIdentification)
def BrokerFeaturesAddPublisherExclusion(builder, publisherExclusion): builder.PrependBoolSlot(1, publisherExclusion, 0)
def AddPublisherExclusion(builder, publisherExclusion):
return BrokerFeaturesAddPublisherExclusion(builder, publisherExclusion)
def BrokerFeaturesAddSubscriberBlackwhiteListing(builder, subscriberBlackwhiteListing): builder.PrependBoolSlot(2, subscriberBlackwhiteListing, 0)
def AddSubscriberBlackwhiteListing(builder, subscriberBlackwhiteListing):
return BrokerFeaturesAddSubscriberBlackwhiteListing(builder, subscriberBlackwhiteListing)
def BrokerFeaturesAddPatternBasedSubscription(builder, patternBasedSubscription): builder.PrependBoolSlot(3, patternBasedSubscription, 0)
def AddPatternBasedSubscription(builder, patternBasedSubscription):
return BrokerFeaturesAddPatternBasedSubscription(builder, patternBasedSubscription)
def BrokerFeaturesAddPublicationTrustlevels(builder, publicationTrustlevels): builder.PrependBoolSlot(4, publicationTrustlevels, 0)
def AddPublicationTrustlevels(builder, publicationTrustlevels):
return BrokerFeaturesAddPublicationTrustlevels(builder, publicationTrustlevels)
def BrokerFeaturesAddSubscriptionRevocation(builder, subscriptionRevocation): builder.PrependBoolSlot(5, subscriptionRevocation, 0)
def AddSubscriptionRevocation(builder, subscriptionRevocation):
return BrokerFeaturesAddSubscriptionRevocation(builder, subscriptionRevocation)
def BrokerFeaturesAddSessionMetaApi(builder, sessionMetaApi): builder.PrependBoolSlot(6, sessionMetaApi, 0)
def AddSessionMetaApi(builder, sessionMetaApi):
return BrokerFeaturesAddSessionMetaApi(builder, sessionMetaApi)
def BrokerFeaturesAddSubscriptionMetaApi(builder, subscriptionMetaApi): builder.PrependBoolSlot(7, subscriptionMetaApi, 0)
def AddSubscriptionMetaApi(builder, subscriptionMetaApi):
return BrokerFeaturesAddSubscriptionMetaApi(builder, subscriptionMetaApi)
def BrokerFeaturesAddEventRetention(builder, eventRetention): builder.PrependBoolSlot(8, eventRetention, 0)
def AddEventRetention(builder, eventRetention):
return BrokerFeaturesAddEventRetention(builder, eventRetention)
def BrokerFeaturesAddEventHistory(builder, eventHistory): builder.PrependBoolSlot(9, eventHistory, 0)
def AddEventHistory(builder, eventHistory):
return BrokerFeaturesAddEventHistory(builder, eventHistory)
def BrokerFeaturesAddAcknowledgeEventReceived(builder, acknowledgeEventReceived): builder.PrependBoolSlot(10, acknowledgeEventReceived, 0)
def AddAcknowledgeEventReceived(builder, acknowledgeEventReceived):
return BrokerFeaturesAddAcknowledgeEventReceived(builder, acknowledgeEventReceived)
def BrokerFeaturesAddAcknowledgeSubscriberReceived(builder, acknowledgeSubscriberReceived): builder.PrependBoolSlot(11, acknowledgeSubscriberReceived, 0)
def AddAcknowledgeSubscriberReceived(builder, acknowledgeSubscriberReceived):
return BrokerFeaturesAddAcknowledgeSubscriberReceived(builder, acknowledgeSubscriberReceived)
def BrokerFeaturesAddPayloadTransparency(builder, payloadTransparency): builder.PrependBoolSlot(12, payloadTransparency, 0)
def AddPayloadTransparency(builder, payloadTransparency):
return BrokerFeaturesAddPayloadTransparency(builder, payloadTransparency)
def BrokerFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox): builder.PrependBoolSlot(13, payloadEncryptionCryptobox, 0)
def AddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox):
return BrokerFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox)
def BrokerFeaturesEnd(builder): return builder.EndObject()
def End(builder):
return BrokerFeaturesEnd(builder)

238
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Call.py Normal file
View File

@@ -0,0 +1,238 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Call(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Call()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsCall(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Call
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Call
def Session(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Call
def Request(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Call
def Procedure(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Call
def Payload(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
a = self._tab.Vector(o)
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
return 0
# Call
def PayloadAsNumpy(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
return 0
# Call
def PayloadLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Call
def PayloadIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
return o == 0
# Call
def EncAlgo(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# Call
def EncSerializer(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# Call
def EncKey(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
if o != 0:
a = self._tab.Vector(o)
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
return 0
# Call
def EncKeyAsNumpy(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
if o != 0:
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
return 0
# Call
def EncKeyLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Call
def EncKeyIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
return o == 0
# Call
def Timeout(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# Call
def ReceiveProgress(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# Call
def TransactionHash(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Call
def Caller(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Call
def CallerAuthid(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Call
def CallerAuthrole(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Call
def ForwardFor(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
if o != 0:
x = self._tab.Vector(o)
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
from wamp.proto.Principal import Principal
obj = Principal()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Call
def ForwardForLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Call
def ForwardForIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
return o == 0
def CallStart(builder): builder.StartObject(14)
def Start(builder):
return CallStart(builder)
def CallAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
def AddSession(builder, session):
return CallAddSession(builder, session)
def CallAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
def AddRequest(builder, request):
return CallAddRequest(builder, request)
def CallAddProcedure(builder, procedure): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(procedure), 0)
def AddProcedure(builder, procedure):
return CallAddProcedure(builder, procedure)
def CallAddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0)
def AddPayload(builder, payload):
return CallAddPayload(builder, payload)
def CallStartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartPayloadVector(builder, numElems):
return CallStartPayloadVector(builder, numElems)
def CallAddEncAlgo(builder, encAlgo): builder.PrependUint8Slot(4, encAlgo, 0)
def AddEncAlgo(builder, encAlgo):
return CallAddEncAlgo(builder, encAlgo)
def CallAddEncSerializer(builder, encSerializer): builder.PrependUint8Slot(5, encSerializer, 0)
def AddEncSerializer(builder, encSerializer):
return CallAddEncSerializer(builder, encSerializer)
def CallAddEncKey(builder, encKey): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(encKey), 0)
def AddEncKey(builder, encKey):
return CallAddEncKey(builder, encKey)
def CallStartEncKeyVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartEncKeyVector(builder, numElems):
return CallStartEncKeyVector(builder, numElems)
def CallAddTimeout(builder, timeout): builder.PrependUint32Slot(7, timeout, 0)
def AddTimeout(builder, timeout):
return CallAddTimeout(builder, timeout)
def CallAddReceiveProgress(builder, receiveProgress): builder.PrependBoolSlot(8, receiveProgress, 0)
def AddReceiveProgress(builder, receiveProgress):
return CallAddReceiveProgress(builder, receiveProgress)
def CallAddTransactionHash(builder, transactionHash): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(transactionHash), 0)
def AddTransactionHash(builder, transactionHash):
return CallAddTransactionHash(builder, transactionHash)
def CallAddCaller(builder, caller): builder.PrependUint64Slot(10, caller, 0)
def AddCaller(builder, caller):
return CallAddCaller(builder, caller)
def CallAddCallerAuthid(builder, callerAuthid): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(callerAuthid), 0)
def AddCallerAuthid(builder, callerAuthid):
return CallAddCallerAuthid(builder, callerAuthid)
def CallAddCallerAuthrole(builder, callerAuthrole): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(callerAuthrole), 0)
def AddCallerAuthrole(builder, callerAuthrole):
return CallAddCallerAuthrole(builder, callerAuthrole)
def CallAddForwardFor(builder, forwardFor): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(forwardFor), 0)
def AddForwardFor(builder, forwardFor):
return CallAddForwardFor(builder, forwardFor)
def CallStartForwardForVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def StartForwardForVector(builder, numElems):
return CallStartForwardForVector(builder, numElems)
def CallEnd(builder): return builder.EndObject()
def End(builder):
return CallEnd(builder)

132
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/CalleeFeatures.py Normal file
View File

@@ -0,0 +1,132 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class CalleeFeatures(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = CalleeFeatures()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsCalleeFeatures(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# CalleeFeatures
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# CalleeFeatures
def CallerIdentification(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# CalleeFeatures
def CallTrustlevels(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# CalleeFeatures
def CallTimeout(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# CalleeFeatures
def CallCanceling(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# CalleeFeatures
def ProgressiveCallResults(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# CalleeFeatures
def RegistrationRevocation(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# CalleeFeatures
def PatternBasedRegistration(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# CalleeFeatures
def SharedRegistration(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# CalleeFeatures
def PayloadTransparency(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# CalleeFeatures
def PayloadEncryptionCryptobox(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
def CalleeFeaturesStart(builder): builder.StartObject(10)
def Start(builder):
return CalleeFeaturesStart(builder)
def CalleeFeaturesAddCallerIdentification(builder, callerIdentification): builder.PrependBoolSlot(0, callerIdentification, 0)
def AddCallerIdentification(builder, callerIdentification):
return CalleeFeaturesAddCallerIdentification(builder, callerIdentification)
def CalleeFeaturesAddCallTrustlevels(builder, callTrustlevels): builder.PrependBoolSlot(1, callTrustlevels, 0)
def AddCallTrustlevels(builder, callTrustlevels):
return CalleeFeaturesAddCallTrustlevels(builder, callTrustlevels)
def CalleeFeaturesAddCallTimeout(builder, callTimeout): builder.PrependBoolSlot(2, callTimeout, 0)
def AddCallTimeout(builder, callTimeout):
return CalleeFeaturesAddCallTimeout(builder, callTimeout)
def CalleeFeaturesAddCallCanceling(builder, callCanceling): builder.PrependBoolSlot(3, callCanceling, 0)
def AddCallCanceling(builder, callCanceling):
return CalleeFeaturesAddCallCanceling(builder, callCanceling)
def CalleeFeaturesAddProgressiveCallResults(builder, progressiveCallResults): builder.PrependBoolSlot(4, progressiveCallResults, 0)
def AddProgressiveCallResults(builder, progressiveCallResults):
return CalleeFeaturesAddProgressiveCallResults(builder, progressiveCallResults)
def CalleeFeaturesAddRegistrationRevocation(builder, registrationRevocation): builder.PrependBoolSlot(5, registrationRevocation, 0)
def AddRegistrationRevocation(builder, registrationRevocation):
return CalleeFeaturesAddRegistrationRevocation(builder, registrationRevocation)
def CalleeFeaturesAddPatternBasedRegistration(builder, patternBasedRegistration): builder.PrependBoolSlot(6, patternBasedRegistration, 0)
def AddPatternBasedRegistration(builder, patternBasedRegistration):
return CalleeFeaturesAddPatternBasedRegistration(builder, patternBasedRegistration)
def CalleeFeaturesAddSharedRegistration(builder, sharedRegistration): builder.PrependBoolSlot(7, sharedRegistration, 0)
def AddSharedRegistration(builder, sharedRegistration):
return CalleeFeaturesAddSharedRegistration(builder, sharedRegistration)
def CalleeFeaturesAddPayloadTransparency(builder, payloadTransparency): builder.PrependBoolSlot(8, payloadTransparency, 0)
def AddPayloadTransparency(builder, payloadTransparency):
return CalleeFeaturesAddPayloadTransparency(builder, payloadTransparency)
def CalleeFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox): builder.PrependBoolSlot(9, payloadEncryptionCryptobox, 0)
def AddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox):
return CalleeFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox)
def CalleeFeaturesEnd(builder): return builder.EndObject()
def End(builder):
return CalleeFeaturesEnd(builder)

92
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/CallerFeatures.py Normal file
View File

@@ -0,0 +1,92 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class CallerFeatures(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = CallerFeatures()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsCallerFeatures(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# CallerFeatures
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# CallerFeatures
def CallerIdentification(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# CallerFeatures
def CallTimeout(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# CallerFeatures
def CallCanceling(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# CallerFeatures
def ProgressiveCallResults(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# CallerFeatures
def PayloadTransparency(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# CallerFeatures
def PayloadEncryptionCryptobox(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
def CallerFeaturesStart(builder): builder.StartObject(6)
def Start(builder):
return CallerFeaturesStart(builder)
def CallerFeaturesAddCallerIdentification(builder, callerIdentification): builder.PrependBoolSlot(0, callerIdentification, 0)
def AddCallerIdentification(builder, callerIdentification):
return CallerFeaturesAddCallerIdentification(builder, callerIdentification)
def CallerFeaturesAddCallTimeout(builder, callTimeout): builder.PrependBoolSlot(1, callTimeout, 0)
def AddCallTimeout(builder, callTimeout):
return CallerFeaturesAddCallTimeout(builder, callTimeout)
def CallerFeaturesAddCallCanceling(builder, callCanceling): builder.PrependBoolSlot(2, callCanceling, 0)
def AddCallCanceling(builder, callCanceling):
return CallerFeaturesAddCallCanceling(builder, callCanceling)
def CallerFeaturesAddProgressiveCallResults(builder, progressiveCallResults): builder.PrependBoolSlot(3, progressiveCallResults, 0)
def AddProgressiveCallResults(builder, progressiveCallResults):
return CallerFeaturesAddProgressiveCallResults(builder, progressiveCallResults)
def CallerFeaturesAddPayloadTransparency(builder, payloadTransparency): builder.PrependBoolSlot(4, payloadTransparency, 0)
def AddPayloadTransparency(builder, payloadTransparency):
return CallerFeaturesAddPayloadTransparency(builder, payloadTransparency)
def CallerFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox): builder.PrependBoolSlot(5, payloadEncryptionCryptobox, 0)
def AddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox):
return CallerFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox)
def CallerFeaturesEnd(builder): return builder.EndObject()
def End(builder):
return CallerFeaturesEnd(builder)

92
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Cancel.py Normal file
View File

@@ -0,0 +1,92 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Cancel(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Cancel()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsCancel(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Cancel
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Cancel
def Session(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Cancel
def Request(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Cancel
def Mode(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# Cancel
def ForwardFor(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
x = self._tab.Vector(o)
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
from wamp.proto.Principal import Principal
obj = Principal()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Cancel
def ForwardForLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Cancel
def ForwardForIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
return o == 0
def CancelStart(builder): builder.StartObject(4)
def Start(builder):
return CancelStart(builder)
def CancelAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
def AddSession(builder, session):
return CancelAddSession(builder, session)
def CancelAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
def AddRequest(builder, request):
return CancelAddRequest(builder, request)
def CancelAddMode(builder, mode): builder.PrependUint8Slot(2, mode, 0)
def AddMode(builder, mode):
return CancelAddMode(builder, mode)
def CancelAddForwardFor(builder, forwardFor): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(forwardFor), 0)
def AddForwardFor(builder, forwardFor):
return CancelAddForwardFor(builder, forwardFor)
def CancelStartForwardForVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def StartForwardForVector(builder, numElems):
return CancelStartForwardForVector(builder, numElems)
def CancelEnd(builder): return builder.EndObject()
def End(builder):
return CancelEnd(builder)

8
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/CancelMode.py Normal file
View File

@@ -0,0 +1,8 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
class CancelMode(object):
SKIP = 0
ABORT = 1
KILL = 2

66
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Challenge.py Normal file
View File

@@ -0,0 +1,66 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Challenge(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Challenge()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsChallenge(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Challenge
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Challenge
def Session(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Challenge
def Method(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# Challenge
def Extra(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from wamp.Map import Map
obj = Map()
obj.Init(self._tab.Bytes, x)
return obj
return None
def ChallengeStart(builder): builder.StartObject(3)
def Start(builder):
return ChallengeStart(builder)
def ChallengeAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
def AddSession(builder, session):
return ChallengeAddSession(builder, session)
def ChallengeAddMethod(builder, method): builder.PrependUint8Slot(1, method, 0)
def AddMethod(builder, method):
return ChallengeAddMethod(builder, method)
def ChallengeAddExtra(builder, extra): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(extra), 0)
def AddExtra(builder, extra):
return ChallengeAddExtra(builder, extra)
def ChallengeEnd(builder): return builder.EndObject()
def End(builder):
return ChallengeEnd(builder)

7
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/ChannelBinding.py Normal file
View File

@@ -0,0 +1,7 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
class ChannelBinding(object):
NONE = 0
TLS_UNIQUE = 1

88
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/ClientRoles.py Normal file
View File

@@ -0,0 +1,88 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class ClientRoles(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = ClientRoles()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsClientRoles(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# ClientRoles
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# ClientRoles
def Publisher(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from wamp.proto.PublisherFeatures import PublisherFeatures
obj = PublisherFeatures()
obj.Init(self._tab.Bytes, x)
return obj
return None
# ClientRoles
def Subscriber(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from wamp.proto.SubscriberFeatures import SubscriberFeatures
obj = SubscriberFeatures()
obj.Init(self._tab.Bytes, x)
return obj
return None
# ClientRoles
def Caller(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from wamp.proto.CallerFeatures import CallerFeatures
obj = CallerFeatures()
obj.Init(self._tab.Bytes, x)
return obj
return None
# ClientRoles
def Callee(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from wamp.proto.CalleeFeatures import CalleeFeatures
obj = CalleeFeatures()
obj.Init(self._tab.Bytes, x)
return obj
return None
def ClientRolesStart(builder): builder.StartObject(4)
def Start(builder):
return ClientRolesStart(builder)
def ClientRolesAddPublisher(builder, publisher): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(publisher), 0)
def AddPublisher(builder, publisher):
return ClientRolesAddPublisher(builder, publisher)
def ClientRolesAddSubscriber(builder, subscriber): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(subscriber), 0)
def AddSubscriber(builder, subscriber):
return ClientRolesAddSubscriber(builder, subscriber)
def ClientRolesAddCaller(builder, caller): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(caller), 0)
def AddCaller(builder, caller):
return ClientRolesAddCaller(builder, caller)
def ClientRolesAddCallee(builder, callee): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(callee), 0)
def AddCallee(builder, callee):
return ClientRolesAddCallee(builder, callee)
def ClientRolesEnd(builder): return builder.EndObject()
def End(builder):
return ClientRolesEnd(builder)

162
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/DealerFeatures.py Normal file
View File

@@ -0,0 +1,162 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class DealerFeatures(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = DealerFeatures()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsDealerFeatures(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# DealerFeatures
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# DealerFeatures
def CallerIdentification(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# DealerFeatures
def CallTrustlevels(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# DealerFeatures
def CallTimeout(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# DealerFeatures
def CallCanceling(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# DealerFeatures
def ProgressiveCallResults(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# DealerFeatures
def RegistrationRevocation(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# DealerFeatures
def PatternBasedRegistration(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# DealerFeatures
def SharedRegistration(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# DealerFeatures
def SessionMetaApi(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# DealerFeatures
def RegistrationMetaApi(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# DealerFeatures
def TestamentMetaApi(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# DealerFeatures
def PayloadTransparency(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# DealerFeatures
def PayloadEncryptionCryptobox(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
def DealerFeaturesStart(builder): builder.StartObject(13)
def Start(builder):
return DealerFeaturesStart(builder)
def DealerFeaturesAddCallerIdentification(builder, callerIdentification): builder.PrependBoolSlot(0, callerIdentification, 0)
def AddCallerIdentification(builder, callerIdentification):
return DealerFeaturesAddCallerIdentification(builder, callerIdentification)
def DealerFeaturesAddCallTrustlevels(builder, callTrustlevels): builder.PrependBoolSlot(1, callTrustlevels, 0)
def AddCallTrustlevels(builder, callTrustlevels):
return DealerFeaturesAddCallTrustlevels(builder, callTrustlevels)
def DealerFeaturesAddCallTimeout(builder, callTimeout): builder.PrependBoolSlot(2, callTimeout, 0)
def AddCallTimeout(builder, callTimeout):
return DealerFeaturesAddCallTimeout(builder, callTimeout)
def DealerFeaturesAddCallCanceling(builder, callCanceling): builder.PrependBoolSlot(3, callCanceling, 0)
def AddCallCanceling(builder, callCanceling):
return DealerFeaturesAddCallCanceling(builder, callCanceling)
def DealerFeaturesAddProgressiveCallResults(builder, progressiveCallResults): builder.PrependBoolSlot(4, progressiveCallResults, 0)
def AddProgressiveCallResults(builder, progressiveCallResults):
return DealerFeaturesAddProgressiveCallResults(builder, progressiveCallResults)
def DealerFeaturesAddRegistrationRevocation(builder, registrationRevocation): builder.PrependBoolSlot(5, registrationRevocation, 0)
def AddRegistrationRevocation(builder, registrationRevocation):
return DealerFeaturesAddRegistrationRevocation(builder, registrationRevocation)
def DealerFeaturesAddPatternBasedRegistration(builder, patternBasedRegistration): builder.PrependBoolSlot(6, patternBasedRegistration, 0)
def AddPatternBasedRegistration(builder, patternBasedRegistration):
return DealerFeaturesAddPatternBasedRegistration(builder, patternBasedRegistration)
def DealerFeaturesAddSharedRegistration(builder, sharedRegistration): builder.PrependBoolSlot(7, sharedRegistration, 0)
def AddSharedRegistration(builder, sharedRegistration):
return DealerFeaturesAddSharedRegistration(builder, sharedRegistration)
def DealerFeaturesAddSessionMetaApi(builder, sessionMetaApi): builder.PrependBoolSlot(8, sessionMetaApi, 0)
def AddSessionMetaApi(builder, sessionMetaApi):
return DealerFeaturesAddSessionMetaApi(builder, sessionMetaApi)
def DealerFeaturesAddRegistrationMetaApi(builder, registrationMetaApi): builder.PrependBoolSlot(9, registrationMetaApi, 0)
def AddRegistrationMetaApi(builder, registrationMetaApi):
return DealerFeaturesAddRegistrationMetaApi(builder, registrationMetaApi)
def DealerFeaturesAddTestamentMetaApi(builder, testamentMetaApi): builder.PrependBoolSlot(10, testamentMetaApi, 0)
def AddTestamentMetaApi(builder, testamentMetaApi):
return DealerFeaturesAddTestamentMetaApi(builder, testamentMetaApi)
def DealerFeaturesAddPayloadTransparency(builder, payloadTransparency): builder.PrependBoolSlot(11, payloadTransparency, 0)
def AddPayloadTransparency(builder, payloadTransparency):
return DealerFeaturesAddPayloadTransparency(builder, payloadTransparency)
def DealerFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox): builder.PrependBoolSlot(12, payloadEncryptionCryptobox, 0)
def AddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox):
return DealerFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox)
def DealerFeaturesEnd(builder): return builder.EndObject()
def End(builder):
return DealerFeaturesEnd(builder)

158
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Error.py Normal file
View File

@@ -0,0 +1,158 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Error(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Error()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsError(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Error
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Error
def Session(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Error
def RequestType(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
return 0
# Error
def Request(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Error
def Error(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Error
def Payload(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
a = self._tab.Vector(o)
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
return 0
# Error
def PayloadAsNumpy(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
return 0
# Error
def PayloadLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Error
def PayloadIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
return o == 0
# Error
def EncAlgo(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# Error
def EncSerializer(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# Error
def EncKey(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
if o != 0:
a = self._tab.Vector(o)
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
return 0
# Error
def EncKeyAsNumpy(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
if o != 0:
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
return 0
# Error
def EncKeyLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Error
def EncKeyIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
return o == 0
def ErrorStart(builder): builder.StartObject(8)
def Start(builder):
return ErrorStart(builder)
def ErrorAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
def AddSession(builder, session):
return ErrorAddSession(builder, session)
def ErrorAddRequestType(builder, requestType): builder.PrependUint16Slot(1, requestType, 0)
def AddRequestType(builder, requestType):
return ErrorAddRequestType(builder, requestType)
def ErrorAddRequest(builder, request): builder.PrependUint64Slot(2, request, 0)
def AddRequest(builder, request):
return ErrorAddRequest(builder, request)
def ErrorAddError(builder, error): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(error), 0)
def AddError(builder, error):
return ErrorAddError(builder, error)
def ErrorAddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0)
def AddPayload(builder, payload):
return ErrorAddPayload(builder, payload)
def ErrorStartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartPayloadVector(builder, numElems):
return ErrorStartPayloadVector(builder, numElems)
def ErrorAddEncAlgo(builder, encAlgo): builder.PrependUint8Slot(5, encAlgo, 0)
def AddEncAlgo(builder, encAlgo):
return ErrorAddEncAlgo(builder, encAlgo)
def ErrorAddEncSerializer(builder, encSerializer): builder.PrependUint8Slot(6, encSerializer, 0)
def AddEncSerializer(builder, encSerializer):
return ErrorAddEncSerializer(builder, encSerializer)
def ErrorAddEncKey(builder, encKey): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(encKey), 0)
def AddEncKey(builder, encKey):
return ErrorAddEncKey(builder, encKey)
def ErrorStartEncKeyVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartEncKeyVector(builder, numElems):
return ErrorStartEncKeyVector(builder, numElems)
def ErrorEnd(builder): return builder.EndObject()
def End(builder):
return ErrorEnd(builder)

317
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Event.py Normal file
View File

@@ -0,0 +1,317 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Event(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Event()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsEvent(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Event
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Event
def Session(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Event
def Subscription(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Event
def Publication(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Positional values for application-defined event payload.
# Event
def Args(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
a = self._tab.Vector(o)
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
return 0
# Event
def ArgsAsNumpy(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
return 0
# Event
def ArgsLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Event
def ArgsIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
return o == 0
# Keyword values for application-defined event payload.
# Event
def Kwargs(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
a = self._tab.Vector(o)
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
return 0
# Event
def KwargsAsNumpy(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
return 0
# Event
def KwargsLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Event
def KwargsIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
return o == 0
# Alternative, transparent payload. If given, ``args`` and ``kwargs`` must be left unset.
# Event
def Payload(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
a = self._tab.Vector(o)
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
return 0
# Event
def PayloadAsNumpy(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
return 0
# Event
def PayloadLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Event
def PayloadIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
return o == 0
# Event
def EncAlgo(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# Event
def EncSerializer(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# Event
def EncKey(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
if o != 0:
a = self._tab.Vector(o)
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
return 0
# Event
def EncKeyAsNumpy(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
if o != 0:
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
return 0
# Event
def EncKeyLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Event
def EncKeyIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
return o == 0
# Event
def Publisher(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Event
def PublisherAuthid(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Event
def PublisherAuthrole(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Event
def Topic(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Event
def Retained(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# Event
def TransactionHash(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Event
def Acknowledge(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# Event
def ForwardFor(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
if o != 0:
x = self._tab.Vector(o)
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
from wamp.proto.Principal import Principal
obj = Principal()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Event
def ForwardForLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Event
def ForwardForIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
return o == 0
def EventStart(builder): builder.StartObject(17)
def Start(builder):
return EventStart(builder)
def EventAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
def AddSession(builder, session):
return EventAddSession(builder, session)
def EventAddSubscription(builder, subscription): builder.PrependUint64Slot(1, subscription, 0)
def AddSubscription(builder, subscription):
return EventAddSubscription(builder, subscription)
def EventAddPublication(builder, publication): builder.PrependUint64Slot(2, publication, 0)
def AddPublication(builder, publication):
return EventAddPublication(builder, publication)
def EventAddArgs(builder, args): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(args), 0)
def AddArgs(builder, args):
return EventAddArgs(builder, args)
def EventStartArgsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartArgsVector(builder, numElems):
return EventStartArgsVector(builder, numElems)
def EventAddKwargs(builder, kwargs): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(kwargs), 0)
def AddKwargs(builder, kwargs):
return EventAddKwargs(builder, kwargs)
def EventStartKwargsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartKwargsVector(builder, numElems):
return EventStartKwargsVector(builder, numElems)
def EventAddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0)
def AddPayload(builder, payload):
return EventAddPayload(builder, payload)
def EventStartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartPayloadVector(builder, numElems):
return EventStartPayloadVector(builder, numElems)
def EventAddEncAlgo(builder, encAlgo): builder.PrependUint8Slot(6, encAlgo, 0)
def AddEncAlgo(builder, encAlgo):
return EventAddEncAlgo(builder, encAlgo)
def EventAddEncSerializer(builder, encSerializer): builder.PrependUint8Slot(7, encSerializer, 0)
def AddEncSerializer(builder, encSerializer):
return EventAddEncSerializer(builder, encSerializer)
def EventAddEncKey(builder, encKey): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(encKey), 0)
def AddEncKey(builder, encKey):
return EventAddEncKey(builder, encKey)
def EventStartEncKeyVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartEncKeyVector(builder, numElems):
return EventStartEncKeyVector(builder, numElems)
def EventAddPublisher(builder, publisher): builder.PrependUint64Slot(9, publisher, 0)
def AddPublisher(builder, publisher):
return EventAddPublisher(builder, publisher)
def EventAddPublisherAuthid(builder, publisherAuthid): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(publisherAuthid), 0)
def AddPublisherAuthid(builder, publisherAuthid):
return EventAddPublisherAuthid(builder, publisherAuthid)
def EventAddPublisherAuthrole(builder, publisherAuthrole): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(publisherAuthrole), 0)
def AddPublisherAuthrole(builder, publisherAuthrole):
return EventAddPublisherAuthrole(builder, publisherAuthrole)
def EventAddTopic(builder, topic): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(topic), 0)
def AddTopic(builder, topic):
return EventAddTopic(builder, topic)
def EventAddRetained(builder, retained): builder.PrependBoolSlot(13, retained, 0)
def AddRetained(builder, retained):
return EventAddRetained(builder, retained)
def EventAddTransactionHash(builder, transactionHash): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(transactionHash), 0)
def AddTransactionHash(builder, transactionHash):
return EventAddTransactionHash(builder, transactionHash)
def EventAddAcknowledge(builder, acknowledge): builder.PrependBoolSlot(15, acknowledge, 0)
def AddAcknowledge(builder, acknowledge):
return EventAddAcknowledge(builder, acknowledge)
def EventAddForwardFor(builder, forwardFor): builder.PrependUOffsetTRelativeSlot(16, flatbuffers.number_types.UOffsetTFlags.py_type(forwardFor), 0)
def AddForwardFor(builder, forwardFor):
return EventAddForwardFor(builder, forwardFor)
def EventStartForwardForVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def StartForwardForVector(builder, numElems):
return EventStartForwardForVector(builder, numElems)
def EventEnd(builder): return builder.EndObject()
def End(builder):
return EventEnd(builder)

138
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/EventReceived.py Normal file
View File

@@ -0,0 +1,138 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class EventReceived(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = EventReceived()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsEventReceived(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# EventReceived
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# EventReceived
def Session(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# EventReceived
def Publication(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# EventReceived
def Payload(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
a = self._tab.Vector(o)
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
return 0
# EventReceived
def PayloadAsNumpy(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
return 0
# EventReceived
def PayloadLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.VectorLen(o)
return 0
# EventReceived
def PayloadIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
return o == 0
# EventReceived
def EncAlgo(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# EventReceived
def EncSerializer(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# EventReceived
def EncKey(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
a = self._tab.Vector(o)
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
return 0
# EventReceived
def EncKeyAsNumpy(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
return 0
# EventReceived
def EncKeyLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return self._tab.VectorLen(o)
return 0
# EventReceived
def EncKeyIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
return o == 0
def EventReceivedStart(builder): builder.StartObject(6)
def Start(builder):
return EventReceivedStart(builder)
def EventReceivedAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
def AddSession(builder, session):
return EventReceivedAddSession(builder, session)
def EventReceivedAddPublication(builder, publication): builder.PrependUint64Slot(1, publication, 0)
def AddPublication(builder, publication):
return EventReceivedAddPublication(builder, publication)
def EventReceivedAddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0)
def AddPayload(builder, payload):
return EventReceivedAddPayload(builder, payload)
def EventReceivedStartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartPayloadVector(builder, numElems):
return EventReceivedStartPayloadVector(builder, numElems)
def EventReceivedAddEncAlgo(builder, encAlgo): builder.PrependUint8Slot(3, encAlgo, 0)
def AddEncAlgo(builder, encAlgo):
return EventReceivedAddEncAlgo(builder, encAlgo)
def EventReceivedAddEncSerializer(builder, encSerializer): builder.PrependUint8Slot(4, encSerializer, 0)
def AddEncSerializer(builder, encSerializer):
return EventReceivedAddEncSerializer(builder, encSerializer)
def EventReceivedAddEncKey(builder, encKey): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(encKey), 0)
def AddEncKey(builder, encKey):
return EventReceivedAddEncKey(builder, encKey)
def EventReceivedStartEncKeyVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartEncKeyVector(builder, numElems):
return EventReceivedStartEncKeyVector(builder, numElems)
def EventReceivedEnd(builder): return builder.EndObject()
def End(builder):
return EventReceivedEnd(builder)

72
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Goodbye.py Normal file
View File

@@ -0,0 +1,72 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Goodbye(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Goodbye()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsGoodbye(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Goodbye
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Goodbye
def Session(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Goodbye
def Reason(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Goodbye
def Message(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Goodbye
def Resumable(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
def GoodbyeStart(builder): builder.StartObject(4)
def Start(builder):
return GoodbyeStart(builder)
def GoodbyeAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
def AddSession(builder, session):
return GoodbyeAddSession(builder, session)
def GoodbyeAddReason(builder, reason): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(reason), 0)
def AddReason(builder, reason):
return GoodbyeAddReason(builder, reason)
def GoodbyeAddMessage(builder, message): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(message), 0)
def AddMessage(builder, message):
return GoodbyeAddMessage(builder, message)
def GoodbyeAddResumable(builder, resumable): builder.PrependBoolSlot(3, resumable, 0)
def AddResumable(builder, resumable):
return GoodbyeAddResumable(builder, resumable)
def GoodbyeEnd(builder): return builder.EndObject()
def End(builder):
return GoodbyeEnd(builder)

163
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Hello.py Normal file
View File

@@ -0,0 +1,163 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Hello(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Hello()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsHello(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Hello
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Hello
def Session(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Hello
def Roles(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from wamp.proto.ClientRoles import ClientRoles
obj = ClientRoles()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Hello
def Realm(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Hello
def Authmethods(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
a = self._tab.Vector(o)
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
return 0
# Hello
def AuthmethodsAsNumpy(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
return 0
# Hello
def AuthmethodsLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Hello
def AuthmethodsIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
return o == 0
# Hello
def Authid(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Hello
def Authrole(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Hello
def Authextra(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from wamp.Map import Map
obj = Map()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Hello
def Resumable(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# Hello
def ResumeSession(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Hello
def ResumeToken(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
def HelloStart(builder): builder.StartObject(10)
def Start(builder):
return HelloStart(builder)
def HelloAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
def AddSession(builder, session):
return HelloAddSession(builder, session)
def HelloAddRoles(builder, roles): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(roles), 0)
def AddRoles(builder, roles):
return HelloAddRoles(builder, roles)
def HelloAddRealm(builder, realm): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(realm), 0)
def AddRealm(builder, realm):
return HelloAddRealm(builder, realm)
def HelloAddAuthmethods(builder, authmethods): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(authmethods), 0)
def AddAuthmethods(builder, authmethods):
return HelloAddAuthmethods(builder, authmethods)
def HelloStartAuthmethodsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartAuthmethodsVector(builder, numElems):
return HelloStartAuthmethodsVector(builder, numElems)
def HelloAddAuthid(builder, authid): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(authid), 0)
def AddAuthid(builder, authid):
return HelloAddAuthid(builder, authid)
def HelloAddAuthrole(builder, authrole): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(authrole), 0)
def AddAuthrole(builder, authrole):
return HelloAddAuthrole(builder, authrole)
def HelloAddAuthextra(builder, authextra): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(authextra), 0)
def AddAuthextra(builder, authextra):
return HelloAddAuthextra(builder, authextra)
def HelloAddResumable(builder, resumable): builder.PrependBoolSlot(7, resumable, 0)
def AddResumable(builder, resumable):
return HelloAddResumable(builder, resumable)
def HelloAddResumeSession(builder, resumeSession): builder.PrependUint64Slot(8, resumeSession, 0)
def AddResumeSession(builder, resumeSession):
return HelloAddResumeSession(builder, resumeSession)
def HelloAddResumeToken(builder, resumeToken): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(resumeToken), 0)
def AddResumeToken(builder, resumeToken):
return HelloAddResumeToken(builder, resumeToken)
def HelloEnd(builder): return builder.EndObject()
def End(builder):
return HelloEnd(builder)

185
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/HelloNew.py Normal file
View File

@@ -0,0 +1,185 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class HelloNew(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = HelloNew()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsHelloNew(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# HelloNew
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# HelloNew
def Roles(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from wamp.proto.ClientRoles import ClientRoles
obj = ClientRoles()
obj.Init(self._tab.Bytes, x)
return obj
return None
# HelloNew
def Realm(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# HelloNew
def Authid(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# HelloNew
def Authrole(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# HelloNew
def Authmode(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# HelloNew
def Authfactor1Type(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# HelloNew
def Authfactor1(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
if o != 0:
from flatbuffers.table import Table
obj = Table(bytearray(), 0)
self._tab.Union(obj, o)
return obj
return None
# HelloNew
def Authfactor2Type(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# HelloNew
def Authfactor2(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
if o != 0:
from flatbuffers.table import Table
obj = Table(bytearray(), 0)
self._tab.Union(obj, o)
return obj
return None
# HelloNew
def Authfactor3Type(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# HelloNew
def Authfactor3(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
if o != 0:
from flatbuffers.table import Table
obj = Table(bytearray(), 0)
self._tab.Union(obj, o)
return obj
return None
# HelloNew
def Resumable(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# HelloNew
def ResumeSession(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# HelloNew
def ResumeToken(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
def HelloNewStart(builder): builder.StartObject(14)
def Start(builder):
return HelloNewStart(builder)
def HelloNewAddRoles(builder, roles): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(roles), 0)
def AddRoles(builder, roles):
return HelloNewAddRoles(builder, roles)
def HelloNewAddRealm(builder, realm): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(realm), 0)
def AddRealm(builder, realm):
return HelloNewAddRealm(builder, realm)
def HelloNewAddAuthid(builder, authid): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(authid), 0)
def AddAuthid(builder, authid):
return HelloNewAddAuthid(builder, authid)
def HelloNewAddAuthrole(builder, authrole): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(authrole), 0)
def AddAuthrole(builder, authrole):
return HelloNewAddAuthrole(builder, authrole)
def HelloNewAddAuthmode(builder, authmode): builder.PrependUint8Slot(4, authmode, 0)
def AddAuthmode(builder, authmode):
return HelloNewAddAuthmode(builder, authmode)
def HelloNewAddAuthfactor1Type(builder, authfactor1Type): builder.PrependUint8Slot(5, authfactor1Type, 0)
def AddAuthfactor1Type(builder, authfactor1Type):
return HelloNewAddAuthfactor1Type(builder, authfactor1Type)
def HelloNewAddAuthfactor1(builder, authfactor1): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(authfactor1), 0)
def AddAuthfactor1(builder, authfactor1):
return HelloNewAddAuthfactor1(builder, authfactor1)
def HelloNewAddAuthfactor2Type(builder, authfactor2Type): builder.PrependUint8Slot(7, authfactor2Type, 0)
def AddAuthfactor2Type(builder, authfactor2Type):
return HelloNewAddAuthfactor2Type(builder, authfactor2Type)
def HelloNewAddAuthfactor2(builder, authfactor2): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(authfactor2), 0)
def AddAuthfactor2(builder, authfactor2):
return HelloNewAddAuthfactor2(builder, authfactor2)
def HelloNewAddAuthfactor3Type(builder, authfactor3Type): builder.PrependUint8Slot(9, authfactor3Type, 0)
def AddAuthfactor3Type(builder, authfactor3Type):
return HelloNewAddAuthfactor3Type(builder, authfactor3Type)
def HelloNewAddAuthfactor3(builder, authfactor3): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(authfactor3), 0)
def AddAuthfactor3(builder, authfactor3):
return HelloNewAddAuthfactor3(builder, authfactor3)
def HelloNewAddResumable(builder, resumable): builder.PrependBoolSlot(11, resumable, 0)
def AddResumable(builder, resumable):
return HelloNewAddResumable(builder, resumable)
def HelloNewAddResumeSession(builder, resumeSession): builder.PrependUint64Slot(12, resumeSession, 0)
def AddResumeSession(builder, resumeSession):
return HelloNewAddResumeSession(builder, resumeSession)
def HelloNewAddResumeToken(builder, resumeToken): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(resumeToken), 0)
def AddResumeToken(builder, resumeToken):
return HelloNewAddResumeToken(builder, resumeToken)
def HelloNewEnd(builder): return builder.EndObject()
def End(builder):
return HelloNewEnd(builder)

102
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Interrupt.py Normal file
View File

@@ -0,0 +1,102 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Interrupt(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Interrupt()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsInterrupt(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Interrupt
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Interrupt
def Session(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Interrupt
def Request(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Interrupt
def Mode(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 1
# Interrupt
def Reason(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Interrupt
def ForwardFor(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
x = self._tab.Vector(o)
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
from wamp.proto.Principal import Principal
obj = Principal()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Interrupt
def ForwardForLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Interrupt
def ForwardForIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
return o == 0
def InterruptStart(builder): builder.StartObject(5)
def Start(builder):
return InterruptStart(builder)
def InterruptAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
def AddSession(builder, session):
return InterruptAddSession(builder, session)
def InterruptAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
def AddRequest(builder, request):
return InterruptAddRequest(builder, request)
def InterruptAddMode(builder, mode): builder.PrependUint8Slot(2, mode, 1)
def AddMode(builder, mode):
return InterruptAddMode(builder, mode)
def InterruptAddReason(builder, reason): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(reason), 0)
def AddReason(builder, reason):
return InterruptAddReason(builder, reason)
def InterruptAddForwardFor(builder, forwardFor): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(forwardFor), 0)
def AddForwardFor(builder, forwardFor):
return InterruptAddForwardFor(builder, forwardFor)
def InterruptStartForwardForVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def StartForwardForVector(builder, numElems):
return InterruptStartForwardForVector(builder, numElems)
def InterruptEnd(builder): return builder.EndObject()
def End(builder):
return InterruptEnd(builder)

248
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Invocation.py Normal file
View File

@@ -0,0 +1,248 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Invocation(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Invocation()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsInvocation(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Invocation
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Invocation
def Session(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Invocation
def Request(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Invocation
def Registration(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Invocation
def Payload(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
a = self._tab.Vector(o)
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
return 0
# Invocation
def PayloadAsNumpy(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
return 0
# Invocation
def PayloadLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Invocation
def PayloadIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
return o == 0
# Invocation
def EncAlgo(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# Invocation
def EncSerializer(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# Invocation
def EncKey(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
if o != 0:
a = self._tab.Vector(o)
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
return 0
# Invocation
def EncKeyAsNumpy(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
if o != 0:
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
return 0
# Invocation
def EncKeyLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Invocation
def EncKeyIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
return o == 0
# Invocation
def Procedure(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Invocation
def Timeout(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
# Invocation
def ReceiveProgress(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# Invocation
def TransactionHash(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Invocation
def Caller(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Invocation
def CallerAuthid(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Invocation
def CallerAuthrole(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Invocation
def ForwardFor(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
if o != 0:
x = self._tab.Vector(o)
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
from wamp.proto.Principal import Principal
obj = Principal()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Invocation
def ForwardForLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Invocation
def ForwardForIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
return o == 0
def InvocationStart(builder): builder.StartObject(15)
def Start(builder):
return InvocationStart(builder)
def InvocationAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
def AddSession(builder, session):
return InvocationAddSession(builder, session)
def InvocationAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
def AddRequest(builder, request):
return InvocationAddRequest(builder, request)
def InvocationAddRegistration(builder, registration): builder.PrependUint64Slot(2, registration, 0)
def AddRegistration(builder, registration):
return InvocationAddRegistration(builder, registration)
def InvocationAddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0)
def AddPayload(builder, payload):
return InvocationAddPayload(builder, payload)
def InvocationStartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartPayloadVector(builder, numElems):
return InvocationStartPayloadVector(builder, numElems)
def InvocationAddEncAlgo(builder, encAlgo): builder.PrependUint8Slot(4, encAlgo, 0)
def AddEncAlgo(builder, encAlgo):
return InvocationAddEncAlgo(builder, encAlgo)
def InvocationAddEncSerializer(builder, encSerializer): builder.PrependUint8Slot(5, encSerializer, 0)
def AddEncSerializer(builder, encSerializer):
return InvocationAddEncSerializer(builder, encSerializer)
def InvocationAddEncKey(builder, encKey): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(encKey), 0)
def AddEncKey(builder, encKey):
return InvocationAddEncKey(builder, encKey)
def InvocationStartEncKeyVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartEncKeyVector(builder, numElems):
return InvocationStartEncKeyVector(builder, numElems)
def InvocationAddProcedure(builder, procedure): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(procedure), 0)
def AddProcedure(builder, procedure):
return InvocationAddProcedure(builder, procedure)
def InvocationAddTimeout(builder, timeout): builder.PrependUint32Slot(8, timeout, 0)
def AddTimeout(builder, timeout):
return InvocationAddTimeout(builder, timeout)
def InvocationAddReceiveProgress(builder, receiveProgress): builder.PrependBoolSlot(9, receiveProgress, 0)
def AddReceiveProgress(builder, receiveProgress):
return InvocationAddReceiveProgress(builder, receiveProgress)
def InvocationAddTransactionHash(builder, transactionHash): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(transactionHash), 0)
def AddTransactionHash(builder, transactionHash):
return InvocationAddTransactionHash(builder, transactionHash)
def InvocationAddCaller(builder, caller): builder.PrependUint64Slot(11, caller, 0)
def AddCaller(builder, caller):
return InvocationAddCaller(builder, caller)
def InvocationAddCallerAuthid(builder, callerAuthid): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(callerAuthid), 0)
def AddCallerAuthid(builder, callerAuthid):
return InvocationAddCallerAuthid(builder, callerAuthid)
def InvocationAddCallerAuthrole(builder, callerAuthrole): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(callerAuthrole), 0)
def AddCallerAuthrole(builder, callerAuthrole):
return InvocationAddCallerAuthrole(builder, callerAuthrole)
def InvocationAddForwardFor(builder, forwardFor): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(forwardFor), 0)
def AddForwardFor(builder, forwardFor):
return InvocationAddForwardFor(builder, forwardFor)
def InvocationStartForwardForVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def StartForwardForVector(builder, numElems):
return InvocationStartForwardForVector(builder, numElems)
def InvocationEnd(builder): return builder.EndObject()
def End(builder):
return InvocationEnd(builder)

10
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/InvocationPolicy.py Normal file
View File

@@ -0,0 +1,10 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
class InvocationPolicy(object):
SINGLE = 0
FIRST = 1
LAST = 2
ROUNDROBIN = 3
RANDOM = 4

8
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Kdf.py Normal file
View File

@@ -0,0 +1,8 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
class Kdf(object):
NONE = 0
PBKDF2 = 1
ARGON2 = 2

8
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Match.py Normal file
View File

@@ -0,0 +1,8 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
class Match(object):
EXACT = 0
PREFIX = 1
WILDCARD = 2

55
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Message.py Normal file
View File

@@ -0,0 +1,55 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Message(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Message()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsMessage(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Message
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Message
def MsgType(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# Message
def Msg(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
from flatbuffers.table import Table
obj = Table(bytearray(), 0)
self._tab.Union(obj, o)
return obj
return None
def MessageStart(builder): builder.StartObject(2)
def Start(builder):
return MessageStart(builder)
def MessageAddMsgType(builder, msgType): builder.PrependUint8Slot(0, msgType, 0)
def AddMsgType(builder, msgType):
return MessageAddMsgType(builder, msgType)
def MessageAddMsg(builder, msg): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(msg), 0)
def AddMsg(builder, msg):
return MessageAddMsg(builder, msg)
def MessageEnd(builder): return builder.EndObject()
def End(builder):
return MessageEnd(builder)

31
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/MessageType.py Normal file
View File

@@ -0,0 +1,31 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
class MessageType(object):
NULL = 0
HELLO = 1
WELCOME = 2
ABORT = 3
CHALLENGE = 4
AUTHENTICATE = 5
GOODBYE = 6
ERROR = 8
PUBLISH = 16
PUBLISHED = 17
SUBSCRIBE = 32
SUBSCRIBED = 33
UNSUBSCRIBE = 34
UNSUBSCRIBED = 35
EVENT = 36
EVENT_RECEIVED = 37
CALL = 48
CANCEL = 49
RESULT = 50
REGISTER = 64
REGISTERED = 65
UNREGISTER = 66
UNREGISTERED = 67
INVOCATION = 68
INTERRUPT = 69
YIELD = 70

8
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Payload.py Normal file
View File

@@ -0,0 +1,8 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
class Payload(object):
PLAIN = 0
CRYPTOBOX = 1
OPAQUE = 2

26
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Principal.py Normal file
View File

@@ -0,0 +1,26 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Principal(object):
__slots__ = ['_tab']
@classmethod
def SizeOf(cls):
return 8
# Principal
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Principal
def Session(self): return self._tab.Get(flatbuffers.number_types.Uint64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0))
def CreatePrincipal(builder, session):
builder.Prep(8, 8)
builder.PrependUint64(session)
return builder.Offset()

457
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Publish.py Normal file
View File

@@ -0,0 +1,457 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Publish(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Publish()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsPublish(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Publish
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Publish
def Session(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Publish
def Request(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Publish
def Topic(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Positional values for application-defined event payload.
# Publish
def Args(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
a = self._tab.Vector(o)
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
return 0
# Publish
def ArgsAsNumpy(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
return 0
# Publish
def ArgsLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Publish
def ArgsIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
return o == 0
# Keyword values for application-defined event payload.
# Publish
def Kwargs(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
a = self._tab.Vector(o)
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
return 0
# Publish
def KwargsAsNumpy(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
return 0
# Publish
def KwargsLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Publish
def KwargsIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
return o == 0
# Alternative, transparent payload. If given, ``args`` and ``kwargs`` must be left unset.
# Publish
def Payload(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
a = self._tab.Vector(o)
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
return 0
# Publish
def PayloadAsNumpy(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
return 0
# Publish
def PayloadLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Publish
def PayloadIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
return o == 0
# Publish
def EncAlgo(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# Publish
def EncSerializer(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# Publish
def EncKey(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
if o != 0:
a = self._tab.Vector(o)
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
return 0
# Publish
def EncKeyAsNumpy(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
if o != 0:
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
return 0
# Publish
def EncKeyLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Publish
def EncKeyIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
return o == 0
# Publish
def Acknowledge(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# Publish
def ExcludeMe(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return True
# Publish
def Exclude(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
if o != 0:
a = self._tab.Vector(o)
return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
return 0
# Publish
def ExcludeAsNumpy(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
if o != 0:
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
return 0
# Publish
def ExcludeLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Publish
def ExcludeIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
return o == 0
# Publish
def ExcludeAuthid(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
if o != 0:
a = self._tab.Vector(o)
return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
return ""
# Publish
def ExcludeAuthidLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Publish
def ExcludeAuthidIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
return o == 0
# Publish
def ExcludeAuthrole(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
if o != 0:
a = self._tab.Vector(o)
return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
return ""
# Publish
def ExcludeAuthroleLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Publish
def ExcludeAuthroleIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
return o == 0
# Publish
def Eligible(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
if o != 0:
a = self._tab.Vector(o)
return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
return 0
# Publish
def EligibleAsNumpy(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
if o != 0:
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
return 0
# Publish
def EligibleLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Publish
def EligibleIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
return o == 0
# Publish
def EligibleAuthid(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
if o != 0:
a = self._tab.Vector(o)
return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
return ""
# Publish
def EligibleAuthidLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Publish
def EligibleAuthidIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
return o == 0
# Publish
def EligibleAuthrole(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
if o != 0:
a = self._tab.Vector(o)
return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
return ""
# Publish
def EligibleAuthroleLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Publish
def EligibleAuthroleIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
return o == 0
# Publish
def Retain(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# Publish
def TransactionHash(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Publish
def ForwardFor(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
if o != 0:
x = self._tab.Vector(o)
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
from wamp.proto.Principal import Principal
obj = Principal()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Publish
def ForwardForLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Publish
def ForwardForIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
return o == 0
def PublishStart(builder): builder.StartObject(20)
def Start(builder):
return PublishStart(builder)
def PublishAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
def AddSession(builder, session):
return PublishAddSession(builder, session)
def PublishAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
def AddRequest(builder, request):
return PublishAddRequest(builder, request)
def PublishAddTopic(builder, topic): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(topic), 0)
def AddTopic(builder, topic):
return PublishAddTopic(builder, topic)
def PublishAddArgs(builder, args): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(args), 0)
def AddArgs(builder, args):
return PublishAddArgs(builder, args)
def PublishStartArgsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartArgsVector(builder, numElems):
return PublishStartArgsVector(builder, numElems)
def PublishAddKwargs(builder, kwargs): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(kwargs), 0)
def AddKwargs(builder, kwargs):
return PublishAddKwargs(builder, kwargs)
def PublishStartKwargsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartKwargsVector(builder, numElems):
return PublishStartKwargsVector(builder, numElems)
def PublishAddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0)
def AddPayload(builder, payload):
return PublishAddPayload(builder, payload)
def PublishStartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartPayloadVector(builder, numElems):
return PublishStartPayloadVector(builder, numElems)
def PublishAddEncAlgo(builder, encAlgo): builder.PrependUint8Slot(6, encAlgo, 0)
def AddEncAlgo(builder, encAlgo):
return PublishAddEncAlgo(builder, encAlgo)
def PublishAddEncSerializer(builder, encSerializer): builder.PrependUint8Slot(7, encSerializer, 0)
def AddEncSerializer(builder, encSerializer):
return PublishAddEncSerializer(builder, encSerializer)
def PublishAddEncKey(builder, encKey): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(encKey), 0)
def AddEncKey(builder, encKey):
return PublishAddEncKey(builder, encKey)
def PublishStartEncKeyVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartEncKeyVector(builder, numElems):
return PublishStartEncKeyVector(builder, numElems)
def PublishAddAcknowledge(builder, acknowledge): builder.PrependBoolSlot(9, acknowledge, 0)
def AddAcknowledge(builder, acknowledge):
return PublishAddAcknowledge(builder, acknowledge)
def PublishAddExcludeMe(builder, excludeMe): builder.PrependBoolSlot(10, excludeMe, 1)
def AddExcludeMe(builder, excludeMe):
return PublishAddExcludeMe(builder, excludeMe)
def PublishAddExclude(builder, exclude): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(exclude), 0)
def AddExclude(builder, exclude):
return PublishAddExclude(builder, exclude)
def PublishStartExcludeVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def StartExcludeVector(builder, numElems):
return PublishStartExcludeVector(builder, numElems)
def PublishAddExcludeAuthid(builder, excludeAuthid): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(excludeAuthid), 0)
def AddExcludeAuthid(builder, excludeAuthid):
return PublishAddExcludeAuthid(builder, excludeAuthid)
def PublishStartExcludeAuthidVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def StartExcludeAuthidVector(builder, numElems):
return PublishStartExcludeAuthidVector(builder, numElems)
def PublishAddExcludeAuthrole(builder, excludeAuthrole): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(excludeAuthrole), 0)
def AddExcludeAuthrole(builder, excludeAuthrole):
return PublishAddExcludeAuthrole(builder, excludeAuthrole)
def PublishStartExcludeAuthroleVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def StartExcludeAuthroleVector(builder, numElems):
return PublishStartExcludeAuthroleVector(builder, numElems)
def PublishAddEligible(builder, eligible): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(eligible), 0)
def AddEligible(builder, eligible):
return PublishAddEligible(builder, eligible)
def PublishStartEligibleVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def StartEligibleVector(builder, numElems):
return PublishStartEligibleVector(builder, numElems)
def PublishAddEligibleAuthid(builder, eligibleAuthid): builder.PrependUOffsetTRelativeSlot(15, flatbuffers.number_types.UOffsetTFlags.py_type(eligibleAuthid), 0)
def AddEligibleAuthid(builder, eligibleAuthid):
return PublishAddEligibleAuthid(builder, eligibleAuthid)
def PublishStartEligibleAuthidVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def StartEligibleAuthidVector(builder, numElems):
return PublishStartEligibleAuthidVector(builder, numElems)
def PublishAddEligibleAuthrole(builder, eligibleAuthrole): builder.PrependUOffsetTRelativeSlot(16, flatbuffers.number_types.UOffsetTFlags.py_type(eligibleAuthrole), 0)
def AddEligibleAuthrole(builder, eligibleAuthrole):
return PublishAddEligibleAuthrole(builder, eligibleAuthrole)
def PublishStartEligibleAuthroleVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def StartEligibleAuthroleVector(builder, numElems):
return PublishStartEligibleAuthroleVector(builder, numElems)
def PublishAddRetain(builder, retain): builder.PrependBoolSlot(17, retain, 0)
def AddRetain(builder, retain):
return PublishAddRetain(builder, retain)
def PublishAddTransactionHash(builder, transactionHash): builder.PrependUOffsetTRelativeSlot(18, flatbuffers.number_types.UOffsetTFlags.py_type(transactionHash), 0)
def AddTransactionHash(builder, transactionHash):
return PublishAddTransactionHash(builder, transactionHash)
def PublishAddForwardFor(builder, forwardFor): builder.PrependUOffsetTRelativeSlot(19, flatbuffers.number_types.UOffsetTFlags.py_type(forwardFor), 0)
def AddForwardFor(builder, forwardFor):
return PublishAddForwardFor(builder, forwardFor)
def PublishStartForwardForVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def StartForwardForVector(builder, numElems):
return PublishStartForwardForVector(builder, numElems)
def PublishEnd(builder): return builder.EndObject()
def End(builder):
return PublishEnd(builder)

62
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Published.py Normal file
View File

@@ -0,0 +1,62 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Published(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Published()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsPublished(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Published
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Published
def Session(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Published
def Request(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Published
def Publication(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def PublishedStart(builder): builder.StartObject(3)
def Start(builder):
return PublishedStart(builder)
def PublishedAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
def AddSession(builder, session):
return PublishedAddSession(builder, session)
def PublishedAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
def AddRequest(builder, request):
return PublishedAddRequest(builder, request)
def PublishedAddPublication(builder, publication): builder.PrependUint64Slot(2, publication, 0)
def AddPublication(builder, publication):
return PublishedAddPublication(builder, publication)
def PublishedEnd(builder): return builder.EndObject()
def End(builder):
return PublishedEnd(builder)

92
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/PublisherFeatures.py Normal file
View File

@@ -0,0 +1,92 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class PublisherFeatures(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = PublisherFeatures()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsPublisherFeatures(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# PublisherFeatures
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# PublisherFeatures
def PublisherIdentification(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# PublisherFeatures
def PublisherExclusion(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# PublisherFeatures
def SubscriberBlackwhiteListing(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# PublisherFeatures
def AcknowledgeEventReceived(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# PublisherFeatures
def PayloadTransparency(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# PublisherFeatures
def PayloadEncryptionCryptobox(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
def PublisherFeaturesStart(builder): builder.StartObject(6)
def Start(builder):
return PublisherFeaturesStart(builder)
def PublisherFeaturesAddPublisherIdentification(builder, publisherIdentification): builder.PrependBoolSlot(0, publisherIdentification, 0)
def AddPublisherIdentification(builder, publisherIdentification):
return PublisherFeaturesAddPublisherIdentification(builder, publisherIdentification)
def PublisherFeaturesAddPublisherExclusion(builder, publisherExclusion): builder.PrependBoolSlot(1, publisherExclusion, 0)
def AddPublisherExclusion(builder, publisherExclusion):
return PublisherFeaturesAddPublisherExclusion(builder, publisherExclusion)
def PublisherFeaturesAddSubscriberBlackwhiteListing(builder, subscriberBlackwhiteListing): builder.PrependBoolSlot(2, subscriberBlackwhiteListing, 0)
def AddSubscriberBlackwhiteListing(builder, subscriberBlackwhiteListing):
return PublisherFeaturesAddSubscriberBlackwhiteListing(builder, subscriberBlackwhiteListing)
def PublisherFeaturesAddAcknowledgeEventReceived(builder, acknowledgeEventReceived): builder.PrependBoolSlot(3, acknowledgeEventReceived, 0)
def AddAcknowledgeEventReceived(builder, acknowledgeEventReceived):
return PublisherFeaturesAddAcknowledgeEventReceived(builder, acknowledgeEventReceived)
def PublisherFeaturesAddPayloadTransparency(builder, payloadTransparency): builder.PrependBoolSlot(4, payloadTransparency, 0)
def AddPayloadTransparency(builder, payloadTransparency):
return PublisherFeaturesAddPayloadTransparency(builder, payloadTransparency)
def PublisherFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox): builder.PrependBoolSlot(5, payloadEncryptionCryptobox, 0)
def AddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox):
return PublisherFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox)
def PublisherFeaturesEnd(builder): return builder.EndObject()
def End(builder):
return PublisherFeaturesEnd(builder)

102
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Register.py Normal file
View File

@@ -0,0 +1,102 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Register(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Register()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsRegister(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Register
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Register
def Session(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Register
def Request(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Register
def Procedure(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Register
def Match(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# Register
def Invoke(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# Register
def Concurrency(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
return 0
# Register
def ForceReregister(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
def RegisterStart(builder): builder.StartObject(7)
def Start(builder):
return RegisterStart(builder)
def RegisterAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
def AddSession(builder, session):
return RegisterAddSession(builder, session)
def RegisterAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
def AddRequest(builder, request):
return RegisterAddRequest(builder, request)
def RegisterAddProcedure(builder, procedure): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(procedure), 0)
def AddProcedure(builder, procedure):
return RegisterAddProcedure(builder, procedure)
def RegisterAddMatch(builder, match): builder.PrependUint8Slot(3, match, 0)
def AddMatch(builder, match):
return RegisterAddMatch(builder, match)
def RegisterAddInvoke(builder, invoke): builder.PrependUint8Slot(4, invoke, 0)
def AddInvoke(builder, invoke):
return RegisterAddInvoke(builder, invoke)
def RegisterAddConcurrency(builder, concurrency): builder.PrependUint16Slot(5, concurrency, 0)
def AddConcurrency(builder, concurrency):
return RegisterAddConcurrency(builder, concurrency)
def RegisterAddForceReregister(builder, forceReregister): builder.PrependBoolSlot(6, forceReregister, 0)
def AddForceReregister(builder, forceReregister):
return RegisterAddForceReregister(builder, forceReregister)
def RegisterEnd(builder): return builder.EndObject()
def End(builder):
return RegisterEnd(builder)

62
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Registered.py Normal file
View File

@@ -0,0 +1,62 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Registered(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Registered()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsRegistered(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Registered
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Registered
def Session(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Registered
def Request(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Registered
def Registration(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def RegisteredStart(builder): builder.StartObject(3)
def Start(builder):
return RegisteredStart(builder)
def RegisteredAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
def AddSession(builder, session):
return RegisteredAddSession(builder, session)
def RegisteredAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
def AddRequest(builder, request):
return RegisteredAddRequest(builder, request)
def RegisteredAddRegistration(builder, registration): builder.PrependUint64Slot(2, registration, 0)
def AddRegistration(builder, registration):
return RegisteredAddRegistration(builder, registration)
def RegisteredEnd(builder): return builder.EndObject()
def End(builder):
return RegisteredEnd(builder)

208
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Result.py Normal file
View File

@@ -0,0 +1,208 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Result(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Result()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsResult(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Result
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Result
def Session(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Result
def Request(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Result
def Payload(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
a = self._tab.Vector(o)
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
return 0
# Result
def PayloadAsNumpy(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
return 0
# Result
def PayloadLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Result
def PayloadIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
return o == 0
# Result
def EncAlgo(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# Result
def EncSerializer(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# Result
def EncKey(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
a = self._tab.Vector(o)
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
return 0
# Result
def EncKeyAsNumpy(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
return 0
# Result
def EncKeyLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Result
def EncKeyIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
return o == 0
# Result
def Progress(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# Result
def Callee(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Result
def CalleeAuthid(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Result
def CalleeAuthrole(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Result
def ForwardFor(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
if o != 0:
x = self._tab.Vector(o)
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
from wamp.proto.Principal import Principal
obj = Principal()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Result
def ForwardForLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Result
def ForwardForIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
return o == 0
def ResultStart(builder): builder.StartObject(11)
def Start(builder):
return ResultStart(builder)
def ResultAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
def AddSession(builder, session):
return ResultAddSession(builder, session)
def ResultAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
def AddRequest(builder, request):
return ResultAddRequest(builder, request)
def ResultAddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0)
def AddPayload(builder, payload):
return ResultAddPayload(builder, payload)
def ResultStartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartPayloadVector(builder, numElems):
return ResultStartPayloadVector(builder, numElems)
def ResultAddEncAlgo(builder, encAlgo): builder.PrependUint8Slot(3, encAlgo, 0)
def AddEncAlgo(builder, encAlgo):
return ResultAddEncAlgo(builder, encAlgo)
def ResultAddEncSerializer(builder, encSerializer): builder.PrependUint8Slot(4, encSerializer, 0)
def AddEncSerializer(builder, encSerializer):
return ResultAddEncSerializer(builder, encSerializer)
def ResultAddEncKey(builder, encKey): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(encKey), 0)
def AddEncKey(builder, encKey):
return ResultAddEncKey(builder, encKey)
def ResultStartEncKeyVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartEncKeyVector(builder, numElems):
return ResultStartEncKeyVector(builder, numElems)
def ResultAddProgress(builder, progress): builder.PrependBoolSlot(6, progress, 0)
def AddProgress(builder, progress):
return ResultAddProgress(builder, progress)
def ResultAddCallee(builder, callee): builder.PrependUint64Slot(7, callee, 0)
def AddCallee(builder, callee):
return ResultAddCallee(builder, callee)
def ResultAddCalleeAuthid(builder, calleeAuthid): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(calleeAuthid), 0)
def AddCalleeAuthid(builder, calleeAuthid):
return ResultAddCalleeAuthid(builder, calleeAuthid)
def ResultAddCalleeAuthrole(builder, calleeAuthrole): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(calleeAuthrole), 0)
def AddCalleeAuthrole(builder, calleeAuthrole):
return ResultAddCalleeAuthrole(builder, calleeAuthrole)
def ResultAddForwardFor(builder, forwardFor): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(forwardFor), 0)
def AddForwardFor(builder, forwardFor):
return ResultAddForwardFor(builder, forwardFor)
def ResultStartForwardForVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def StartForwardForVector(builder, numElems):
return ResultStartForwardForVector(builder, numElems)
def ResultEnd(builder): return builder.EndObject()
def End(builder):
return ResultEnd(builder)

60
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/RouterRoles.py Normal file
View File

@@ -0,0 +1,60 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class RouterRoles(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = RouterRoles()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsRouterRoles(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# RouterRoles
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# RouterRoles
def Broker(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from wamp.proto.BrokerFeatures import BrokerFeatures
obj = BrokerFeatures()
obj.Init(self._tab.Bytes, x)
return obj
return None
# RouterRoles
def Dealer(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from wamp.proto.DealerFeatures import DealerFeatures
obj = DealerFeatures()
obj.Init(self._tab.Bytes, x)
return obj
return None
def RouterRolesStart(builder): builder.StartObject(2)
def Start(builder):
return RouterRolesStart(builder)
def RouterRolesAddBroker(builder, broker): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(broker), 0)
def AddBroker(builder, broker):
return RouterRolesAddBroker(builder, broker)
def RouterRolesAddDealer(builder, dealer): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(dealer), 0)
def AddDealer(builder, dealer):
return RouterRolesAddDealer(builder, dealer)
def RouterRolesEnd(builder): return builder.EndObject()
def End(builder):
return RouterRolesEnd(builder)

13
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Serializer.py Normal file
View File

@@ -0,0 +1,13 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
class Serializer(object):
TRANSPORT = 0
JSON = 1
MSGPACK = 2
CBOR = 3
UBJSON = 4
OPAQUE = 5
FLATBUFFERS = 6
FLEXBUFFERS = 7

82
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Subscribe.py Normal file
View File

@@ -0,0 +1,82 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Subscribe(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Subscribe()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsSubscribe(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Subscribe
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Subscribe
def Session(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Subscribe
def Request(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Subscribe
def Topic(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Subscribe
def Match(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# Subscribe
def GetRetained(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
def SubscribeStart(builder): builder.StartObject(5)
def Start(builder):
return SubscribeStart(builder)
def SubscribeAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
def AddSession(builder, session):
return SubscribeAddSession(builder, session)
def SubscribeAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
def AddRequest(builder, request):
return SubscribeAddRequest(builder, request)
def SubscribeAddTopic(builder, topic): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(topic), 0)
def AddTopic(builder, topic):
return SubscribeAddTopic(builder, topic)
def SubscribeAddMatch(builder, match): builder.PrependUint8Slot(3, match, 0)
def AddMatch(builder, match):
return SubscribeAddMatch(builder, match)
def SubscribeAddGetRetained(builder, getRetained): builder.PrependBoolSlot(4, getRetained, 0)
def AddGetRetained(builder, getRetained):
return SubscribeAddGetRetained(builder, getRetained)
def SubscribeEnd(builder): return builder.EndObject()
def End(builder):
return SubscribeEnd(builder)

62
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Subscribed.py Normal file
View File

@@ -0,0 +1,62 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Subscribed(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Subscribed()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsSubscribed(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Subscribed
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Subscribed
def Session(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Subscribed
def Request(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Subscribed
def Subscription(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def SubscribedStart(builder): builder.StartObject(3)
def Start(builder):
return SubscribedStart(builder)
def SubscribedAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
def AddSession(builder, session):
return SubscribedAddSession(builder, session)
def SubscribedAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
def AddRequest(builder, request):
return SubscribedAddRequest(builder, request)
def SubscribedAddSubscription(builder, subscription): builder.PrependUint64Slot(2, subscription, 0)
def AddSubscription(builder, subscription):
return SubscribedAddSubscription(builder, subscription)
def SubscribedEnd(builder): return builder.EndObject()
def End(builder):
return SubscribedEnd(builder)

112
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/SubscriberFeatures.py Normal file
View File

@@ -0,0 +1,112 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class SubscriberFeatures(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = SubscriberFeatures()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsSubscriberFeatures(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# SubscriberFeatures
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# SubscriberFeatures
def PublisherIdentification(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# SubscriberFeatures
def PatternBasedSubscription(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# SubscriberFeatures
def PublicationTrustlevels(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# SubscriberFeatures
def SubscriptionRevocation(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# SubscriberFeatures
def EventHistory(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# SubscriberFeatures
def AcknowledgeSubscriberReceived(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# SubscriberFeatures
def PayloadTransparency(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# SubscriberFeatures
def PayloadEncryptionCryptobox(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
def SubscriberFeaturesStart(builder): builder.StartObject(8)
def Start(builder):
return SubscriberFeaturesStart(builder)
def SubscriberFeaturesAddPublisherIdentification(builder, publisherIdentification): builder.PrependBoolSlot(0, publisherIdentification, 0)
def AddPublisherIdentification(builder, publisherIdentification):
return SubscriberFeaturesAddPublisherIdentification(builder, publisherIdentification)
def SubscriberFeaturesAddPatternBasedSubscription(builder, patternBasedSubscription): builder.PrependBoolSlot(1, patternBasedSubscription, 0)
def AddPatternBasedSubscription(builder, patternBasedSubscription):
return SubscriberFeaturesAddPatternBasedSubscription(builder, patternBasedSubscription)
def SubscriberFeaturesAddPublicationTrustlevels(builder, publicationTrustlevels): builder.PrependBoolSlot(2, publicationTrustlevels, 0)
def AddPublicationTrustlevels(builder, publicationTrustlevels):
return SubscriberFeaturesAddPublicationTrustlevels(builder, publicationTrustlevels)
def SubscriberFeaturesAddSubscriptionRevocation(builder, subscriptionRevocation): builder.PrependBoolSlot(3, subscriptionRevocation, 0)
def AddSubscriptionRevocation(builder, subscriptionRevocation):
return SubscriberFeaturesAddSubscriptionRevocation(builder, subscriptionRevocation)
def SubscriberFeaturesAddEventHistory(builder, eventHistory): builder.PrependBoolSlot(4, eventHistory, 0)
def AddEventHistory(builder, eventHistory):
return SubscriberFeaturesAddEventHistory(builder, eventHistory)
def SubscriberFeaturesAddAcknowledgeSubscriberReceived(builder, acknowledgeSubscriberReceived): builder.PrependBoolSlot(5, acknowledgeSubscriberReceived, 0)
def AddAcknowledgeSubscriberReceived(builder, acknowledgeSubscriberReceived):
return SubscriberFeaturesAddAcknowledgeSubscriberReceived(builder, acknowledgeSubscriberReceived)
def SubscriberFeaturesAddPayloadTransparency(builder, payloadTransparency): builder.PrependBoolSlot(6, payloadTransparency, 0)
def AddPayloadTransparency(builder, payloadTransparency):
return SubscriberFeaturesAddPayloadTransparency(builder, payloadTransparency)
def SubscriberFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox): builder.PrependBoolSlot(7, payloadEncryptionCryptobox, 0)
def AddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox):
return SubscriberFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox)
def SubscriberFeaturesEnd(builder): return builder.EndObject()
def End(builder):
return SubscriberFeaturesEnd(builder)

158
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/SubscriberReceived.py Normal file
View File

@@ -0,0 +1,158 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class SubscriberReceived(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = SubscriberReceived()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsSubscriberReceived(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# SubscriberReceived
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# SubscriberReceived
def Publication(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# SubscriberReceived
def Subscriber(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# SubscriberReceived
def SubscriberAuthid(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# SubscriberReceived
def SubscriberAuthrole(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# SubscriberReceived
def Payload(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
a = self._tab.Vector(o)
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
return 0
# SubscriberReceived
def PayloadAsNumpy(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
return 0
# SubscriberReceived
def PayloadLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return self._tab.VectorLen(o)
return 0
# SubscriberReceived
def PayloadIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
return o == 0
# SubscriberReceived
def EncAlgo(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# SubscriberReceived
def EncSerializer(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# SubscriberReceived
def EncKey(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
if o != 0:
a = self._tab.Vector(o)
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
return 0
# SubscriberReceived
def EncKeyAsNumpy(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
if o != 0:
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
return 0
# SubscriberReceived
def EncKeyLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
if o != 0:
return self._tab.VectorLen(o)
return 0
# SubscriberReceived
def EncKeyIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
return o == 0
def SubscriberReceivedStart(builder): builder.StartObject(8)
def Start(builder):
return SubscriberReceivedStart(builder)
def SubscriberReceivedAddPublication(builder, publication): builder.PrependUint64Slot(0, publication, 0)
def AddPublication(builder, publication):
return SubscriberReceivedAddPublication(builder, publication)
def SubscriberReceivedAddSubscriber(builder, subscriber): builder.PrependUint64Slot(1, subscriber, 0)
def AddSubscriber(builder, subscriber):
return SubscriberReceivedAddSubscriber(builder, subscriber)
def SubscriberReceivedAddSubscriberAuthid(builder, subscriberAuthid): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(subscriberAuthid), 0)
def AddSubscriberAuthid(builder, subscriberAuthid):
return SubscriberReceivedAddSubscriberAuthid(builder, subscriberAuthid)
def SubscriberReceivedAddSubscriberAuthrole(builder, subscriberAuthrole): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(subscriberAuthrole), 0)
def AddSubscriberAuthrole(builder, subscriberAuthrole):
return SubscriberReceivedAddSubscriberAuthrole(builder, subscriberAuthrole)
def SubscriberReceivedAddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0)
def AddPayload(builder, payload):
return SubscriberReceivedAddPayload(builder, payload)
def SubscriberReceivedStartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartPayloadVector(builder, numElems):
return SubscriberReceivedStartPayloadVector(builder, numElems)
def SubscriberReceivedAddEncAlgo(builder, encAlgo): builder.PrependUint8Slot(5, encAlgo, 0)
def AddEncAlgo(builder, encAlgo):
return SubscriberReceivedAddEncAlgo(builder, encAlgo)
def SubscriberReceivedAddEncSerializer(builder, encSerializer): builder.PrependUint8Slot(6, encSerializer, 0)
def AddEncSerializer(builder, encSerializer):
return SubscriberReceivedAddEncSerializer(builder, encSerializer)
def SubscriberReceivedAddEncKey(builder, encKey): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(encKey), 0)
def AddEncKey(builder, encKey):
return SubscriberReceivedAddEncKey(builder, encKey)
def SubscriberReceivedStartEncKeyVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartEncKeyVector(builder, numElems):
return SubscriberReceivedStartEncKeyVector(builder, numElems)
def SubscriberReceivedEnd(builder): return builder.EndObject()
def End(builder):
return SubscriberReceivedEnd(builder)

62
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Unregister.py Normal file
View File

@@ -0,0 +1,62 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Unregister(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Unregister()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsUnregister(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Unregister
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Unregister
def Session(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Unregister
def Request(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Unregister
def Registration(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def UnregisterStart(builder): builder.StartObject(3)
def Start(builder):
return UnregisterStart(builder)
def UnregisterAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
def AddSession(builder, session):
return UnregisterAddSession(builder, session)
def UnregisterAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
def AddRequest(builder, request):
return UnregisterAddRequest(builder, request)
def UnregisterAddRegistration(builder, registration): builder.PrependUint64Slot(2, registration, 0)
def AddRegistration(builder, registration):
return UnregisterAddRegistration(builder, registration)
def UnregisterEnd(builder): return builder.EndObject()
def End(builder):
return UnregisterEnd(builder)

72
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Unregistered.py Normal file
View File

@@ -0,0 +1,72 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Unregistered(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Unregistered()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsUnregistered(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Unregistered
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Unregistered
def Session(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Unregistered
def Request(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Unregistered
def Registration(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Unregistered
def Reason(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
def UnregisteredStart(builder): builder.StartObject(4)
def Start(builder):
return UnregisteredStart(builder)
def UnregisteredAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
def AddSession(builder, session):
return UnregisteredAddSession(builder, session)
def UnregisteredAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
def AddRequest(builder, request):
return UnregisteredAddRequest(builder, request)
def UnregisteredAddRegistration(builder, registration): builder.PrependUint64Slot(2, registration, 0)
def AddRegistration(builder, registration):
return UnregisteredAddRegistration(builder, registration)
def UnregisteredAddReason(builder, reason): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(reason), 0)
def AddReason(builder, reason):
return UnregisteredAddReason(builder, reason)
def UnregisteredEnd(builder): return builder.EndObject()
def End(builder):
return UnregisteredEnd(builder)

62
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Unsubscribe.py Normal file
View File

@@ -0,0 +1,62 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Unsubscribe(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Unsubscribe()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsUnsubscribe(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Unsubscribe
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Unsubscribe
def Session(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Unsubscribe
def Request(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Unsubscribe
def Subscription(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
def UnsubscribeStart(builder): builder.StartObject(3)
def Start(builder):
return UnsubscribeStart(builder)
def UnsubscribeAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
def AddSession(builder, session):
return UnsubscribeAddSession(builder, session)
def UnsubscribeAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
def AddRequest(builder, request):
return UnsubscribeAddRequest(builder, request)
def UnsubscribeAddSubscription(builder, subscription): builder.PrependUint64Slot(2, subscription, 0)
def AddSubscription(builder, subscription):
return UnsubscribeAddSubscription(builder, subscription)
def UnsubscribeEnd(builder): return builder.EndObject()
def End(builder):
return UnsubscribeEnd(builder)

72
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Unsubscribed.py Normal file
View File

@@ -0,0 +1,72 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Unsubscribed(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Unsubscribed()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsUnsubscribed(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Unsubscribed
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Unsubscribed
def Session(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Unsubscribed
def Request(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Unsubscribed
def Subscription(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Unsubscribed
def Reason(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
def UnsubscribedStart(builder): builder.StartObject(4)
def Start(builder):
return UnsubscribedStart(builder)
def UnsubscribedAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
def AddSession(builder, session):
return UnsubscribedAddSession(builder, session)
def UnsubscribedAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
def AddRequest(builder, request):
return UnsubscribedAddRequest(builder, request)
def UnsubscribedAddSubscription(builder, subscription): builder.PrependUint64Slot(2, subscription, 0)
def AddSubscription(builder, subscription):
return UnsubscribedAddSubscription(builder, subscription)
def UnsubscribedAddReason(builder, reason): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(reason), 0)
def AddReason(builder, reason):
return UnsubscribedAddReason(builder, reason)
def UnsubscribedEnd(builder): return builder.EndObject()
def End(builder):
return UnsubscribedEnd(builder)

150
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Welcome.py Normal file
View File

@@ -0,0 +1,150 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Welcome(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Welcome()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsWelcome(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Welcome
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Welcome
def Session(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Welcome
def Roles(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from wamp.proto.RouterRoles import RouterRoles
obj = RouterRoles()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Welcome
def Realm(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Welcome
def Authid(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Welcome
def Authrole(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Welcome
def Authmethod(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# Welcome
def Authprovider(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Welcome
def Authextra(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from wamp.Map import Map
obj = Map()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Welcome
def Resumed(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# Welcome
def Resumable(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# Welcome
def ResumeToken(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
def WelcomeStart(builder): builder.StartObject(11)
def Start(builder):
return WelcomeStart(builder)
def WelcomeAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
def AddSession(builder, session):
return WelcomeAddSession(builder, session)
def WelcomeAddRoles(builder, roles): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(roles), 0)
def AddRoles(builder, roles):
return WelcomeAddRoles(builder, roles)
def WelcomeAddRealm(builder, realm): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(realm), 0)
def AddRealm(builder, realm):
return WelcomeAddRealm(builder, realm)
def WelcomeAddAuthid(builder, authid): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(authid), 0)
def AddAuthid(builder, authid):
return WelcomeAddAuthid(builder, authid)
def WelcomeAddAuthrole(builder, authrole): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(authrole), 0)
def AddAuthrole(builder, authrole):
return WelcomeAddAuthrole(builder, authrole)
def WelcomeAddAuthmethod(builder, authmethod): builder.PrependUint8Slot(5, authmethod, 0)
def AddAuthmethod(builder, authmethod):
return WelcomeAddAuthmethod(builder, authmethod)
def WelcomeAddAuthprovider(builder, authprovider): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(authprovider), 0)
def AddAuthprovider(builder, authprovider):
return WelcomeAddAuthprovider(builder, authprovider)
def WelcomeAddAuthextra(builder, authextra): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(authextra), 0)
def AddAuthextra(builder, authextra):
return WelcomeAddAuthextra(builder, authextra)
def WelcomeAddResumed(builder, resumed): builder.PrependBoolSlot(8, resumed, 0)
def AddResumed(builder, resumed):
return WelcomeAddResumed(builder, resumed)
def WelcomeAddResumable(builder, resumable): builder.PrependBoolSlot(9, resumable, 0)
def AddResumable(builder, resumable):
return WelcomeAddResumable(builder, resumable)
def WelcomeAddResumeToken(builder, resumeToken): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(resumeToken), 0)
def AddResumeToken(builder, resumeToken):
return WelcomeAddResumeToken(builder, resumeToken)
def WelcomeEnd(builder): return builder.EndObject()
def End(builder):
return WelcomeEnd(builder)

208
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Yield.py Normal file
View File

@@ -0,0 +1,208 @@
# automatically generated by the FlatBuffers compiler, do not modify
# namespace: proto
import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()
class Yield(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Yield()
x.Init(buf, n + offset)
return x
@classmethod
def GetRootAsYield(cls, buf, offset=0):
"""This method is deprecated. Please switch to GetRootAs."""
return cls.GetRootAs(buf, offset)
# Yield
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Yield
def Session(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Yield
def Request(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Yield
def Payload(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
a = self._tab.Vector(o)
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
return 0
# Yield
def PayloadAsNumpy(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
return 0
# Yield
def PayloadLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Yield
def PayloadIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
return o == 0
# Yield
def EncAlgo(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# Yield
def EncSerializer(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 0
# Yield
def EncKey(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
a = self._tab.Vector(o)
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
return 0
# Yield
def EncKeyAsNumpy(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
return 0
# Yield
def EncKeyLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Yield
def EncKeyIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
return o == 0
# Yield
def Progress(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
if o != 0:
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
return False
# Yield
def Callee(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
# Yield
def CalleeAuthid(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Yield
def CalleeAuthrole(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
if o != 0:
return self._tab.String(o + self._tab.Pos)
return None
# Yield
def ForwardFor(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
if o != 0:
x = self._tab.Vector(o)
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
from wamp.proto.Principal import Principal
obj = Principal()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Yield
def ForwardForLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Yield
def ForwardForIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
return o == 0
def YieldStart(builder): builder.StartObject(11)
def Start(builder):
return YieldStart(builder)
def YieldAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
def AddSession(builder, session):
return YieldAddSession(builder, session)
def YieldAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
def AddRequest(builder, request):
return YieldAddRequest(builder, request)
def YieldAddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0)
def AddPayload(builder, payload):
return YieldAddPayload(builder, payload)
def YieldStartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartPayloadVector(builder, numElems):
return YieldStartPayloadVector(builder, numElems)
def YieldAddEncAlgo(builder, encAlgo): builder.PrependUint8Slot(3, encAlgo, 0)
def AddEncAlgo(builder, encAlgo):
return YieldAddEncAlgo(builder, encAlgo)
def YieldAddEncSerializer(builder, encSerializer): builder.PrependUint8Slot(4, encSerializer, 0)
def AddEncSerializer(builder, encSerializer):
return YieldAddEncSerializer(builder, encSerializer)
def YieldAddEncKey(builder, encKey): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(encKey), 0)
def AddEncKey(builder, encKey):
return YieldAddEncKey(builder, encKey)
def YieldStartEncKeyVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartEncKeyVector(builder, numElems):
return YieldStartEncKeyVector(builder, numElems)
def YieldAddProgress(builder, progress): builder.PrependBoolSlot(6, progress, 0)
def AddProgress(builder, progress):
return YieldAddProgress(builder, progress)
def YieldAddCallee(builder, callee): builder.PrependUint64Slot(7, callee, 0)
def AddCallee(builder, callee):
return YieldAddCallee(builder, callee)
def YieldAddCalleeAuthid(builder, calleeAuthid): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(calleeAuthid), 0)
def AddCalleeAuthid(builder, calleeAuthid):
return YieldAddCalleeAuthid(builder, calleeAuthid)
def YieldAddCalleeAuthrole(builder, calleeAuthrole): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(calleeAuthrole), 0)
def AddCalleeAuthrole(builder, calleeAuthrole):
return YieldAddCalleeAuthrole(builder, calleeAuthrole)
def YieldAddForwardFor(builder, forwardFor): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(forwardFor), 0)
def AddForwardFor(builder, forwardFor):
return YieldAddForwardFor(builder, forwardFor)
def YieldStartForwardForVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def StartForwardForVector(builder, numElems):
return YieldStartForwardForVector(builder, numElems)
def YieldEnd(builder): return builder.EndObject()
def End(builder):
return YieldEnd(builder)

0
.venv/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/__init__.py Normal file
View File

1128
.venv/lib/python3.12/site-packages/autobahn/wamp/interfaces.py Normal file
View File

File diff suppressed because it is too large Load Diff

6000
.venv/lib/python3.12/site-packages/autobahn/wamp/message.py Normal file
View File

File diff suppressed because it is too large Load Diff

129
.venv/lib/python3.12/site-packages/autobahn/wamp/message_fbs.py Normal file
View File

@@ -0,0 +1,129 @@
###############################################################################
#
# The MIT License (MIT)
#
# Copyright (c) typedef int GmbH
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
###############################################################################
import flatbuffers
from autobahn.wamp.gen.wamp.proto import Event as EventGen
from autobahn.wamp.gen.wamp.proto import Publish as PublishGen
from autobahn.wamp.gen.wamp.proto import Message
from autobahn.wamp.gen.wamp.proto.MessageType import MessageType
__all__ = (
'Event',
'Message',
'MessageType',
)
class Event(EventGen.Event):
@classmethod
def GetRootAsEvent(cls, buf, offset):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Event()
x.Init(buf, n + offset)
return x
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
def ArgsAsBytes(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
_off = self._tab.Vector(o)
_len = self._tab.VectorLen(o)
return memoryview(self._tab.Bytes)[_off:_off+_len]
return None
def KwargsAsBytes(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
_off = self._tab.Vector(o)
_len = self._tab.VectorLen(o)
return memoryview(self._tab.Bytes)[_off:_off+_len]
return None
def PayloadAsBytes(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
_off = self._tab.Vector(o)
_len = self._tab.VectorLen(o)
return memoryview(self._tab.Bytes)[_off:_off+_len]
return None
def EncKeyAsBytes(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
if o != 0:
_off = self._tab.Vector(o)
_len = self._tab.VectorLen(o)
return memoryview(self._tab.Bytes)[_off:_off+_len]
return None
class Publish(PublishGen.Publish):
@classmethod
def GetRootAsEvent(cls, buf, offset):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Event()
x.Init(buf, n + offset)
return x
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
def ArgsAsBytes(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
if o != 0:
_off = self._tab.Vector(o)
_len = self._tab.VectorLen(o)
return memoryview(self._tab.Bytes)[_off:_off+_len]
return None
def KwargsAsBytes(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
if o != 0:
_off = self._tab.Vector(o)
_len = self._tab.VectorLen(o)
return memoryview(self._tab.Bytes)[_off:_off+_len]
return None
def PayloadAsBytes(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
if o != 0:
_off = self._tab.Vector(o)
_len = self._tab.VectorLen(o)
return memoryview(self._tab.Bytes)[_off:_off+_len]
return None
def EncKeyAsBytes(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
if o != 0:
_off = self._tab.Vector(o)
_len = self._tab.VectorLen(o)
return memoryview(self._tab.Bytes)[_off:_off+_len]
return None

2047
.venv/lib/python3.12/site-packages/autobahn/wamp/protocol.py Normal file
View File

File diff suppressed because it is too large Load Diff

338
.venv/lib/python3.12/site-packages/autobahn/wamp/request.py Normal file
View File

@@ -0,0 +1,338 @@
###############################################################################
#
# The MIT License (MIT)
#
# Copyright (c) typedef int GmbH
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
###############################################################################
__all__ = (
'Publication',
'Subscription',
'Handler',
'Registration',
'Endpoint',
'PublishRequest',
'SubscribeRequest',
'UnsubscribeRequest',
'CallRequest',
'InvocationRequest',
'RegisterRequest',
'UnregisterRequest',
)
class Publication(object):
"""
Object representing a publication (feedback from publishing an event when doing
an acknowledged publish).
"""
__slots__ = ('id', 'was_encrypted')
def __init__(self, publication_id, was_encrypted):
"""
:param publication_id: The publication ID of the published event.
:type publication_id: int
:param was_encrypted: Flag indicating whether the app payload was encrypted.
:type was_encrypted: bool
"""
self.id = publication_id
self.was_encrypted = was_encrypted
def __str__(self):
return "Publication(id={0}, was_encrypted={1})".format(self.id, self.was_encrypted)
class Subscription(object):
"""
Object representing a handler subscription.
"""
__slots__ = ('id', 'topic', 'active', 'session', 'handler')
def __init__(self, subscription_id, topic, session, handler):
"""
:param subscription_id: The subscription ID.
:type subscription_id: int
:param topic: The subscription URI or URI pattern.
:type topic: str
:param session: The ApplicationSession this subscription is living on.
:type session: instance of ApplicationSession
:param handler: The user event callback.
:type handler: callable
"""
self.id = subscription_id
self.topic = topic
self.active = True
self.session = session
self.handler = handler
def unsubscribe(self):
"""
Unsubscribe this subscription.
"""
if self.active:
return self.session._unsubscribe(self)
else:
raise Exception("subscription no longer active")
def __str__(self):
return "Subscription(id={0}, is_active={1})".format(self.id, self.active)
class Handler(object):
"""
Object representing an event handler attached to a subscription.
"""
__slots__ = ('fn', 'obj', 'details_arg')
def __init__(self, fn, obj=None, details_arg=None):
"""
:param fn: The event handler function to be called.
:type fn: callable
:param obj: The (optional) object upon which to call the function.
:type obj: obj or None
:param details_arg: The keyword argument under which event details should be provided.
:type details_arg: str or None
"""
self.fn = fn
self.obj = obj
self.details_arg = details_arg
class Registration(object):
"""
Object representing a registration.
"""
__slots__ = ('id', 'active', 'session', 'procedure', 'endpoint')
def __init__(self, session, registration_id, procedure, endpoint):
"""
:param id: The registration ID.
:type id: int
:param active: Flag indicating whether this registration is active.
:type active: bool
:param procedure: The procedure URI or URI pattern.
:type procedure: callable
:param endpoint: The user callback.
:type endpoint: callable
"""
self.id = registration_id
self.active = True
self.session = session
self.procedure = procedure
self.endpoint = endpoint
def unregister(self):
"""
"""
if self.active:
return self.session._unregister(self)
else:
raise Exception("registration no longer active")
def __str__(self):
return 'Registration(id={0}, is_active={1}, procedure="{2}")'.format(self.id, self.active, self.procedure)
class Endpoint(object):
"""
Object representing an procedure endpoint attached to a registration.
"""
__slots__ = ('fn', 'obj', 'details_arg')
def __init__(self, fn, obj=None, details_arg=None):
"""
:param fn: The endpoint procedure to be called.
:type fn: callable
:param obj: The (optional) object upon which to call the function.
:type obj: obj or None
:param details_arg: The keyword argument under which call details should be provided.
:type details_arg: str or None
"""
self.fn = fn
self.obj = obj
self.details_arg = details_arg
class Request(object):
"""
Object representing an outstanding request, such as for subscribe/unsubscribe,
register/unregister or call/publish.
"""
__slots__ = ('request_id', 'on_reply')
def __init__(self, request_id, on_reply):
"""
:param request_id: The WAMP request ID.
:type request_id: int
:param on_reply: The Deferred/Future to be fired when the request returns.
:type on_reply: Deferred/Future
"""
self.request_id = request_id
self.on_reply = on_reply
class PublishRequest(Request):
"""
Object representing an outstanding request to publish (acknowledged) an event.
"""
__slots__ = ('was_encrypted')
def __init__(self, request_id, on_reply, was_encrypted):
"""
:param request_id: The WAMP request ID.
:type request_id: int
:param on_reply: The Deferred/Future to be fired when the request returns.
:type on_reply: Deferred/Future
:param was_encrypted: Flag indicating whether the app payload was encrypted.
:type was_encrypted: bool
"""
Request.__init__(self, request_id, on_reply)
self.was_encrypted = was_encrypted
class SubscribeRequest(Request):
"""
Object representing an outstanding request to subscribe to a topic.
"""
__slots__ = ('handler', 'topic')
def __init__(self, request_id, topic, on_reply, handler):
"""
:param request_id: The WAMP request ID.
:type request_id: int
:param topic: The topic URI being subscribed to.
:type topic: unicode
:param on_reply: The Deferred/Future to be fired when the request returns.
:type on_reply: Deferred/Future
:param handler: WAMP call options that are in use for this call.
:type handler: callable
"""
Request.__init__(self, request_id, on_reply)
self.topic = topic
self.handler = handler
class UnsubscribeRequest(Request):
"""
Object representing an outstanding request to unsubscribe a subscription.
"""
__slots__ = ('subscription_id',)
def __init__(self, request_id, on_reply, subscription_id):
"""
"""
Request.__init__(self, request_id, on_reply)
self.subscription_id = subscription_id
class CallRequest(Request):
"""
Object representing an outstanding request to call a procedure.
"""
__slots__ = ('procedure', 'options',)
def __init__(self, request_id, procedure, on_reply, options):
"""
:param request_id: The WAMP request ID.
:type request_id: int
:param on_reply: The Deferred/Future to be fired when the request returns.
:type on_reply: Deferred/Future
:param options: WAMP call options that are in use for this call.
:type options: dict
"""
Request.__init__(self, request_id, on_reply)
self.procedure = procedure
self.options = options
class InvocationRequest(Request):
"""
Object representing an outstanding request to invoke an endpoint.
"""
class RegisterRequest(Request):
"""
Object representing an outstanding request to register a procedure.
"""
__slots__ = ('procedure', 'endpoint',)
def __init__(self, request_id, on_reply, procedure, endpoint):
"""
"""
Request.__init__(self, request_id, on_reply)
self.procedure = procedure
self.endpoint = endpoint
class UnregisterRequest(Request):
"""
Object representing an outstanding request to unregister a registration.
"""
__slots__ = ('registration_id',)
def __init__(self, request_id, on_reply, registration_id):
"""
"""
Request.__init__(self, request_id, on_reply)
self.registration_id = registration_id

305
.venv/lib/python3.12/site-packages/autobahn/wamp/role.py Normal file
View File

@@ -0,0 +1,305 @@
###############################################################################
#
# The MIT License (MIT)
#
# Copyright (c) typedef int GmbH
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
###############################################################################
import json
from autobahn import util
from autobahn.wamp.exception import ProtocolError
__all__ = (
'RoleFeatures',
'RoleBrokerFeatures',
'RoleSubscriberFeatures',
'RolePublisherFeatures',
'RoleDealerFeatures',
'RoleCallerFeatures',
'RoleCalleeFeatures',
'ROLE_NAME_TO_CLASS',
'DEFAULT_CLIENT_ROLES',
)
class RoleFeatures(util.EqualityMixin):
"""
Base class for WAMP role features.
"""
ROLE = None
def __str__(self):
return json.dumps(self.__dict__)
def __repr__(self):
configured_options = {}
for k, v in self.__dict__.items():
if v is not None:
configured_options[k] = v
return "{0}({1})".format(self.ROLE, ", ".join([k + '=' + str(v)
for k, v in configured_options.items()]))
def _check_all_bool(self):
# check feature attributes
for k in self.__dict__:
if not k.startswith('_') and k != 'ROLE':
if getattr(self, k) is not None and type(getattr(self, k)) != bool:
raise ProtocolError("invalid type {0} for feature '{1}' for role '{2}'".format(getattr(self, k), k, self.ROLE))
class RoleBrokerFeatures(RoleFeatures):
"""
WAMP broker role features.
"""
ROLE = 'broker'
def __init__(self,
publisher_identification=None,
publication_trustlevels=None,
pattern_based_subscription=None,
session_meta_api=None,
subscription_meta_api=None,
subscriber_blackwhite_listing=None,
publisher_exclusion=None,
subscription_revocation=None,
event_history=None,
payload_transparency=None,
x_acknowledged_event_delivery=None,
payload_encryption_cryptobox=None,
event_retention=None,
**kwargs):
self.publisher_identification = publisher_identification
self.publication_trustlevels = publication_trustlevels
self.pattern_based_subscription = pattern_based_subscription
self.session_meta_api = session_meta_api
self.subscription_meta_api = subscription_meta_api
self.subscriber_blackwhite_listing = subscriber_blackwhite_listing
self.publisher_exclusion = publisher_exclusion
self.subscription_revocation = subscription_revocation
self.event_history = event_history
self.payload_transparency = payload_transparency
self.x_acknowledged_event_delivery = x_acknowledged_event_delivery
self.payload_encryption_cryptobox = payload_encryption_cryptobox
self.event_retention = event_retention
self._check_all_bool()
class RoleSubscriberFeatures(RoleFeatures):
"""
WAMP subscriber role features.
"""
ROLE = 'subscriber'
def __init__(self,
publisher_identification=None,
publication_trustlevels=None,
pattern_based_subscription=None,
subscription_revocation=None,
event_history=None,
payload_transparency=None,
payload_encryption_cryptobox=None,
**kwargs):
self.publisher_identification = publisher_identification
self.publication_trustlevels = publication_trustlevels
self.pattern_based_subscription = pattern_based_subscription
self.subscription_revocation = subscription_revocation
self.event_history = event_history
self.payload_transparency = payload_transparency
self.payload_encryption_cryptobox = payload_encryption_cryptobox
self._check_all_bool()
class RolePublisherFeatures(RoleFeatures):
"""
WAMP publisher role features.
"""
ROLE = 'publisher'
def __init__(self,
publisher_identification=None,
subscriber_blackwhite_listing=None,
publisher_exclusion=None,
payload_transparency=None,
x_acknowledged_event_delivery=None,
payload_encryption_cryptobox=None,
**kwargs):
self.publisher_identification = publisher_identification
self.subscriber_blackwhite_listing = subscriber_blackwhite_listing
self.publisher_exclusion = publisher_exclusion
self.payload_transparency = payload_transparency
self.x_acknowledged_event_delivery = x_acknowledged_event_delivery
self.payload_encryption_cryptobox = payload_encryption_cryptobox
self._check_all_bool()
class RoleDealerFeatures(RoleFeatures):
"""
WAMP dealer role features.
"""
ROLE = 'dealer'
def __init__(self,
caller_identification=None,
call_trustlevels=None,
pattern_based_registration=None,
session_meta_api=None,
registration_meta_api=None,
shared_registration=None,
call_timeout=None,
call_canceling=None,
progressive_call_results=None,
registration_revocation=None,
payload_transparency=None,
testament_meta_api=None,
payload_encryption_cryptobox=None,
**kwargs):
self.caller_identification = caller_identification
self.call_trustlevels = call_trustlevels
self.pattern_based_registration = pattern_based_registration
self.session_meta_api = session_meta_api
self.registration_meta_api = registration_meta_api
self.shared_registration = shared_registration
self.call_timeout = call_timeout
self.call_canceling = call_canceling
self.progressive_call_results = progressive_call_results
self.registration_revocation = registration_revocation
self.payload_transparency = payload_transparency
self.testament_meta_api = testament_meta_api
self.payload_encryption_cryptobox = payload_encryption_cryptobox
self._check_all_bool()
class RoleCallerFeatures(RoleFeatures):
"""
WAMP caller role features.
"""
ROLE = 'caller'
def __init__(self,
caller_identification=None,
call_timeout=None,
call_canceling=None,
progressive_call_results=None,
payload_transparency=None,
payload_encryption_cryptobox=None,
**kwargs):
self.caller_identification = caller_identification
self.call_timeout = call_timeout
self.call_canceling = call_canceling
self.progressive_call_results = progressive_call_results
self.payload_transparency = payload_transparency
self.payload_encryption_cryptobox = payload_encryption_cryptobox
self._check_all_bool()
class RoleCalleeFeatures(RoleFeatures):
"""
WAMP callee role features.
"""
ROLE = 'callee'
def __init__(self,
caller_identification=None,
call_trustlevels=None,
pattern_based_registration=None,
shared_registration=None,
call_timeout=None,
call_canceling=None,
progressive_call_results=None,
registration_revocation=None,
payload_transparency=None,
payload_encryption_cryptobox=None,
**kwargs):
self.caller_identification = caller_identification
self.call_trustlevels = call_trustlevels
self.pattern_based_registration = pattern_based_registration
self.shared_registration = shared_registration
self.call_timeout = call_timeout
self.call_canceling = call_canceling
self.progressive_call_results = progressive_call_results
self.registration_revocation = registration_revocation
self.payload_transparency = payload_transparency
self.payload_encryption_cryptobox = payload_encryption_cryptobox
self._check_all_bool()
# map of role names to role class
ROLE_NAME_TO_CLASS = {
'broker': RoleBrokerFeatures,
'subscriber': RoleSubscriberFeatures,
'publisher': RolePublisherFeatures,
'dealer': RoleDealerFeatures,
'caller': RoleCallerFeatures,
'callee': RoleCalleeFeatures,
}
# default role features for client roles supported
DEFAULT_CLIENT_ROLES = {
'subscriber': RoleSubscriberFeatures(
publisher_identification=True,
pattern_based_subscription=True,
subscription_revocation=True,
payload_transparency=True,
payload_encryption_cryptobox=True,
),
'publisher': RolePublisherFeatures(
publisher_identification=True,
subscriber_blackwhite_listing=True,
publisher_exclusion=True,
payload_transparency=True,
x_acknowledged_event_delivery=True,
payload_encryption_cryptobox=True,
),
'caller': RoleCallerFeatures(
caller_identification=True,
progressive_call_results=True,
payload_transparency=True,
payload_encryption_cryptobox=True,
call_canceling=True,
),
'callee': RoleCalleeFeatures(
caller_identification=True,
pattern_based_registration=True,
shared_registration=True,
progressive_call_results=True,
registration_revocation=True,
payload_transparency=True,
payload_encryption_cryptobox=True,
call_canceling=True,
),
}

1052
.venv/lib/python3.12/site-packages/autobahn/wamp/serializer.py Normal file
View File

File diff suppressed because it is too large Load Diff

0
.venv/lib/python3.12/site-packages/autobahn/wamp/test/__init__.py Normal file
View File

238
.venv/lib/python3.12/site-packages/autobahn/wamp/test/test_wamp_auth.py Normal file
View File

@@ -0,0 +1,238 @@
###############################################################################
#
# The MIT License (MIT)
#
# Copyright (c) typedef int GmbH
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
###############################################################################
import unittest
from unittest.mock import Mock
import platform
import re
import json
import binascii
from autobahn.wamp import auth
from autobahn.wamp import types
# these test vectors are all for HMAC-SHA1
PBKDF2_TEST_VECTORS = [
# From RFC 6070
(b'password', b'salt', 1, 20, '0c60c80f961f0e71f3a9b524af6012062fe037a6'),
(b'password', b'salt', 2, 20, 'ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957'),
# From Crypt-PBKDF2
(b'password', b'ATHENA.MIT.EDUraeburn', 1, 16, 'cdedb5281bb2f801565a1122b2563515'),
(b'password', b'ATHENA.MIT.EDUraeburn', 1, 32, 'cdedb5281bb2f801565a1122b25635150ad1f7a04bb9f3a333ecc0e2e1f70837'),
(b'password', b'ATHENA.MIT.EDUraeburn', 2, 16, '01dbee7f4a9e243e988b62c73cda935d'),
(b'password', b'ATHENA.MIT.EDUraeburn', 2, 32, '01dbee7f4a9e243e988b62c73cda935da05378b93244ec8f48a99e61ad799d86'),
(b'password', b'ATHENA.MIT.EDUraeburn', 1200, 32, '5c08eb61fdf71e4e4ec3cf6ba1f5512ba7e52ddbc5e5142f708a31e2e62b1e13'),
(b'X' * 64, b'pass phrase equals block size', 1200, 32, '139c30c0966bc32ba55fdbf212530ac9c5ec59f1a452f5cc9ad940fea0598ed1'),
(b'X' * 65, b'pass phrase exceeds block size', 1200, 32, '9ccad6d468770cd51b10e6a68721be611a8b4d282601db3b36be9246915ec82a'),
]
if platform.python_implementation() != 'PyPy':
# the following fails on PyPy: "RuntimeError: maximum recursion depth exceeded"
PBKDF2_TEST_VECTORS.extend(
[
# From RFC 6070
(b'password', b'salt', 4096, 20, '4b007901b765489abead49d926f721d065a429c1'),
(b'passwordPASSWORDpassword', b'saltSALTsaltSALTsaltSALTsaltSALTsalt', 4096, 25, '3d2eec4fe41c849b80c8d83662c0e44a8b291a964cf2f07038'),
(b'pass\x00word', b'sa\x00lt', 4096, 16, '56fa6aa75548099dcc37d7f03425e0c3'),
# This one is from the RFC but it just takes for ages
# (b'password', b'salt', 16777216, 20, 'eefe3d61cd4da4e4e9945b3d6ba2158c2634e984'),
]
)
class TestWampAuthHelpers(unittest.TestCase):
def test_pbkdf2(self):
for tv in PBKDF2_TEST_VECTORS:
result = auth.pbkdf2(tv[0], tv[1], tv[2], tv[3], 'sha1')
self.assertEqual(type(result), bytes)
self.assertEqual(binascii.hexlify(result).decode('ascii'), tv[4])
def test_generate_totp_secret_default(self):
secret = auth.generate_totp_secret()
self.assertEqual(type(secret), str)
self.assertEqual(len(secret), 10 * 8 / 5)
def test_generate_totp_secret_length(self):
for length in [5, 10, 20, 30, 40, 50]:
secret = auth.generate_totp_secret(length)
self.assertEqual(type(secret), str)
self.assertEqual(len(secret), length * 8 / 5)
def test_compute_totp(self):
pat = re.compile(r"\d\d\d\d\d\d")
secret = "MFRGGZDFMZTWQ2LK"
signature = auth.compute_totp(secret)
self.assertEqual(type(signature), str)
self.assertTrue(pat.match(signature) is not None)
def test_compute_totp_offset(self):
pat = re.compile(r"\d\d\d\d\d\d")
secret = "MFRGGZDFMZTWQ2LK"
for offset in range(-10, 10):
signature = auth.compute_totp(secret, offset)
self.assertEqual(type(signature), str)
self.assertTrue(pat.match(signature) is not None)
def test_derive_key(self):
secret = 'L3L1YUE8Txlw'
salt = 'salt123'
key = auth.derive_key(secret.encode('utf8'), salt.encode('utf8'))
self.assertEqual(type(key), bytes)
self.assertEqual(key, b"qzcdsr9uu/L5hnss3kjNTRe490ETgA70ZBaB5rvnJ5Y=")
def test_generate_wcs_default(self):
secret = auth.generate_wcs()
self.assertEqual(type(secret), bytes)
self.assertEqual(len(secret), 14)
def test_generate_wcs_length(self):
for length in [5, 10, 20, 30, 40, 50]:
secret = auth.generate_wcs(length)
self.assertEqual(type(secret), bytes)
self.assertEqual(len(secret), length)
def test_compute_wcs(self):
secret = 'L3L1YUE8Txlw'
challenge = json.dumps([1, 2, 3], ensure_ascii=False).encode('utf8')
signature = auth.compute_wcs(secret.encode('utf8'), challenge)
self.assertEqual(type(signature), bytes)
self.assertEqual(signature, b"1njQtmmeYO41N5EWEzD2kAjjEKRZ5kPZt/TzpYXOzR0=")
@unittest.skipIf(not auth.HAS_ARGON, 'no Argon2 library')
class TestScram(unittest.TestCase):
def test_argon2id_static(self):
# re-generate from the official argon2 tools:
# echo -n "p4ssw0rd" | argon2 '1234567890abcdef' -id -t 32 -m 9 -p 1 -l 32
expected = binascii.unhexlify('ee4a8acf9d5958354fb79a95ae20692d05e42591ba49fae85eb6700e8b0ed293')
raw_hash = auth._hash_argon2id13_secret(
b'p4ssw0rd',
binascii.b2a_base64(b'1234567890abcdef'), # ours takes base64-encoded salt
32, # this is WAY TOO SMALL; for production, use 4096 or higher
512, # note that the argon2 utility takes a "power of 2", so "-m 9" above == 512
)
decoded_hash = binascii.a2b_base64(raw_hash + b'==\n')
self.assertEqual(expected, decoded_hash)
def test_pbkdf2_static(self):
expected = binascii.unhexlify('f6991a28c75f43751e0d75499fd7b8649f659118ddc1d61cee5883af547d15f5')
# 8 iterations is WAY TOO FEW for production; this is a test
raw_hash = auth._hash_pbkdf2_secret(b'p4ssw0rd', b'1234567890abcdef', 8)
self.assertEqual(raw_hash, expected)
def test_basic(self):
scram = auth.AuthScram(
nonce='1234567890abcdef',
kdf='argon2id13',
salt=binascii.b2a_hex(b'1234567890abcdef').decode('ascii'),
iterations=32, # far too few; use 4096 or more for production
memory=512,
password='p4ssw0rd',
authid='username',
)
# thought: if we could import crossbar code here, we could
# test the "other side" of this with fewer mocks
# (i.e. hard-coding the client nonce)
scram._client_nonce = binascii.b2a_hex(b'1234567890abcdef').decode('ascii')
self.assertEqual(
{'nonce': '31323334353637383930616263646566'},
scram.authextra,
)
challenge = types.Challenge('scram', {
'nonce': '1234567890abcdeffedcba0987654321',
'kdf': 'argon2id-13',
'salt': binascii.b2a_hex(b'1234567890abcdef').decode('ascii'),
'iterations': 32,
'memory': 512,
})
reply = scram.on_challenge(Mock(), challenge)
self.assertEqual(
b'f5r3loERzGVSuimE+lvO0bWna2zyswBo0HrZkaaEy38=',
reply,
)
authextra = dict(
scram_server_signature=b'f5r3loERzGVSuimE+lvO0bWna2zyswBo0HrZkaaEy38=',
)
scram.on_welcome(Mock(), authextra)
def test_no_memory_arg(self):
scram = auth.AuthScram(
nonce='1234567890abcdef',
kdf='argon2id13',
salt=binascii.b2a_hex(b'1234567890abcdef').decode('ascii'),
iterations=4096,
memory=512,
password='p4ssw0rd',
authid='username',
)
scram.authextra
with self.assertRaises(ValueError) as ctx:
challenge = types.Challenge('scram', {
'nonce': '1234567890abcdeffedcba0987654321',
'kdf': 'argon2id-13',
'salt': binascii.b2a_hex(b'1234567890abcdef'),
'iterations': 4096,
# no 'memory' key
})
scram.on_challenge(Mock(), challenge)
self.assertIn(
"requires 'memory' parameter",
str(ctx.exception)
)
def test_unknown_arg(self):
scram = auth.AuthScram(
nonce='1234567890abcdef',
kdf='argon2id13',
salt=binascii.b2a_hex(b'1234567890abcdef'),
iterations=4096,
memory=512,
password='p4ssw0rd',
authid='username',
)
scram.authextra
with self.assertRaises(RuntimeError) as ctx:
challenge = types.Challenge('scram', {
'nonce': '1234567890abcdeffedcba0987654321',
'kdf': 'argon2id-13',
'salt': binascii.b2a_hex(b'1234567890abcdef'),
'iterations': 4096,
'memory': 512,
'an_invalid_key': None
})
scram.on_challenge(Mock(), challenge)
self.assertIn("an_invalid_key", str(ctx.exception))

219
.venv/lib/python3.12/site-packages/autobahn/wamp/test/test_wamp_component.py Normal file
View File

@@ -0,0 +1,219 @@
###############################################################################
#
# The MIT License (MIT)
#
# Copyright (c) typedef int GmbH
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
###############################################################################
import os
if os.environ.get('USE_TWISTED', False):
from autobahn.twisted.util import sleep
from autobahn.twisted import wamp
from twisted.trial import unittest
from twisted.internet import defer
from twisted.application import service
class CaseComponent(wamp.ApplicationSession):
"""
Application code goes here. This is an example component that calls
a remote procedure on a WAMP peer, subscribes to a topic to receive
events, and then stops the world after some events.
"""
def __init__(self, config):
wamp.ApplicationSession.__init__(self, config)
self.test = config.extra['test']
self.stop = False
self._logline = 1
self.finished = False
def log(self, *args):
if len(args) > 1:
sargs = ", ".join(str(s) for s in args)
elif len(args) == 1:
sargs = args[0]
else:
sargs = "-"
msg = '= : {0:>3} : {1:<20} : {2}'.format(self._logline, self.__class__.__name__, sargs)
self._logline += 1
print(msg)
def finish(self):
if not self.finished:
self.test.deferred.callback(None)
self.finished = True
else:
print("already finished")
class Case1_Backend(CaseComponent):
@defer.inlineCallbacks
def onJoin(self, details):
self.log("joined")
def add2(x, y):
self.log("add2 invoked: {0}, {1}".format(x, y))
return x + y
yield self.register(add2, 'com.mathservice.add2')
self.log("add2 registered")
self.finish()
class Case1_Frontend(CaseComponent):
@defer.inlineCallbacks
def onJoin(self, details):
self.log("joined")
try:
res = yield self.call('com.mathservice.add2', 2, 3)
except Exception as e:
self.log("call error: {0}".format(e))
else:
self.log("call result: {0}".format(res))
self.finish()
class Case2_Backend(CaseComponent):
@defer.inlineCallbacks
def onJoin(self, details):
self.log("joined")
def ping():
self.log("ping() is invoked")
return
def add2(a, b):
self.log("add2() is invoked", a, b)
return a + b
def stars(nick="somebody", stars=0):
self.log("stars() is invoked", nick, stars)
return "{0} starred {1}x".format(nick, stars)
def orders(product, limit=5):
self.log("orders() is invoked", product, limit)
return ["Product {0}".format(i) for i in range(50)][:limit]
def arglen(*args, **kwargs):
self.log("arglen() is invoked", args, kwargs)
return [len(args), len(kwargs)]
yield self.register(ping, 'com.arguments.ping')
yield self.register(add2, 'com.arguments.add2')
yield self.register(stars, 'com.arguments.stars')
yield self.register(orders, 'com.arguments.orders')
yield self.register(arglen, 'com.arguments.arglen')
self.log("procedures registered")
class Case2_Frontend(CaseComponent):
@defer.inlineCallbacks
def onJoin(self, details):
self.log("joined")
yield sleep(1)
yield self.call('com.arguments.ping')
self.log("Pinged!")
res = yield self.call('com.arguments.add2', 2, 3)
self.log("Add2: {0}".format(res))
starred = yield self.call('com.arguments.stars')
self.log("Starred 1: {0}".format(starred))
starred = yield self.call('com.arguments.stars', nick='Homer')
self.log("Starred 2: {0}".format(starred))
starred = yield self.call('com.arguments.stars', stars=5)
self.log("Starred 3: {0}".format(starred))
starred = yield self.call('com.arguments.stars', nick='Homer', stars=5)
self.log("Starred 4: {0}".format(starred))
orders = yield self.call('com.arguments.orders', 'coffee')
self.log("Orders 1: {0}".format(orders))
orders = yield self.call('com.arguments.orders', 'coffee', limit=10)
self.log("Orders 2: {0}".format(orders))
arglengths = yield self.call('com.arguments.arglen')
self.log("Arglen 1: {0}".format(arglengths))
arglengths = yield self.call('com.arguments.arglen', 1, 2, 3)
self.log("Arglen 1: {0}".format(arglengths))
arglengths = yield self.call('com.arguments.arglen', a=1, b=2, c=3)
self.log("Arglen 2: {0}".format(arglengths))
arglengths = yield self.call('com.arguments.arglen', 1, 2, 3, a=1, b=2, c=3)
self.log("Arglen 3: {0}".format(arglengths))
self.log("finishing")
self.finish()
class TestRpc(unittest.TestCase):
if os.environ.get("WAMP_ROUTER_URL") is None:
skip = ("Please provide WAMP_ROUTER_URL environment with url to "
"WAMP router to run WAMP integration tests")
def setUp(self):
self.url = os.environ.get("WAMP_ROUTER_URL")
self.realm = "realm1"
@defer.inlineCallbacks
def runOneTest(self, components):
self.deferred = defer.Deferred()
app = service.MultiService()
for component in components:
c = wamp.Service(
url=self.url,
extra=dict(test=self),
realm=self.realm,
make=component,
)
c.setServiceParent(app)
app.startService()
yield self.deferred
app.stopService()
@defer.inlineCallbacks
def test_case1(self):
yield self.runOneTest([Case1_Backend, Case1_Frontend])
@defer.inlineCallbacks
def test_case2(self):
yield self.runOneTest([Case2_Backend, Case2_Frontend])

154
.venv/lib/python3.12/site-packages/autobahn/wamp/test/test_wamp_component_aio.py Normal file
View File

@@ -0,0 +1,154 @@
###############################################################################
#
# The MIT License (MIT)
#
# Copyright (c) typedef int GmbH
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
###############################################################################
import os
import sys
import unittest.mock as mock
import pytest
import txaio
if os.environ.get('USE_ASYNCIO', False):
from autobahn.asyncio.component import Component
@pytest.mark.skipif(sys.version_info < (3, 5), reason="requires Python 3.5+")
@pytest.mark.asyncio(forbid_global_loop=True)
async def test_asyncio_component(event_loop):
orig_loop = txaio.config.loop
txaio.config.loop = event_loop
comp = Component(
transports=[
{
"url": "ws://localhost:12/bogus",
"max_retries": 1,
"max_retry_delay": 0.1,
}
]
)
# if having trouble, try starting some logging (and use
# "py.test -s" to get real-time output)
# txaio.start_logging(level="debug")
f = comp.start(loop=event_loop)
txaio.config.loop = event_loop
finished = txaio.create_future()
def fail():
finished.set_exception(AssertionError("timed out"))
txaio.config.loop = orig_loop
txaio.call_later(4.0, fail)
def done(f):
try:
f.result()
finished.set_exception(AssertionError("should get an error"))
except RuntimeError as e:
if 'Exhausted all transport connect attempts' not in str(e):
finished.set_exception(AssertionError("wrong exception caught"))
finished.set_result(None)
txaio.config.loop = orig_loop
assert comp._done_f is None
f.add_done_callback(done)
await finished
@pytest.mark.skipif(sys.version_info < (3, 5), reason="requires Python 3.5+")
@pytest.mark.asyncio(forbid_global_loop=True)
async def test_asyncio_component_404(event_loop):
"""
If something connects but then gets aborted, it should still try
to re-connect (in real cases this could be e.g. wrong path,
TLS failure, WebSocket handshake failure, etc)
"""
orig_loop = txaio.config.loop
txaio.config.loop = event_loop
class FakeTransport(object):
def close(self):
pass
def write(self, data):
pass
fake_transport = FakeTransport()
actual_protocol = [None] # set in a closure below
def create_connection(protocol_factory=None, server_hostname=None, host=None, port=None, ssl=False):
if actual_protocol[0] is None:
protocol = protocol_factory()
actual_protocol[0] = protocol
protocol.connection_made(fake_transport)
return txaio.create_future_success((fake_transport, protocol))
else:
return txaio.create_future_error(RuntimeError("second connection fails completely"))
with mock.patch.object(event_loop, 'create_connection', create_connection):
event_loop.create_connection = create_connection
comp = Component(
transports=[
{
"url": "ws://localhost:12/bogus",
"max_retries": 1,
"max_retry_delay": 0.1,
}
]
)
# if having trouble, try starting some logging (and use
# "py.test -s" to get real-time output)
# txaio.start_logging(level="debug")
f = comp.start(loop=event_loop)
txaio.config.loop = event_loop
# now that we've started connecting, we *should* be able
# to connetion_lost our transport .. but we do a
# call-later to ensure we're after the setup stuff in the
# event-loop (because asyncio doesn't synchronously
# process already-completed Futures like Twisted does)
def nuke_transport():
if actual_protocol[0] is not None:
actual_protocol[0].connection_lost(None) # asyncio can call this with None
txaio.call_later(0.1, nuke_transport)
finished = txaio.create_future()
def fail():
finished.set_exception(AssertionError("timed out"))
txaio.config.loop = orig_loop
txaio.call_later(1.0, fail)
def done(f):
try:
f.result()
finished.set_exception(AssertionError("should get an error"))
except RuntimeError as e:
if 'Exhausted all transport connect attempts' not in str(e):
finished.set_exception(AssertionError("wrong exception caught"))
finished.set_result(None)
txaio.config.loop = orig_loop
f.add_done_callback(done)
await finished

37
.venv/lib/python3.12/site-packages/autobahn/wamp/test/test_wamp_cryptobox.py Normal file
View File

@@ -0,0 +1,37 @@
###############################################################################
#
# The MIT License (MIT)
#
# Copyright (c) typedef int GmbH
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
###############################################################################
from autobahn.wamp import cryptobox
import unittest
@unittest.skipIf(not cryptobox.HAS_CRYPTOBOX, 'no cryptobox support present')
class TestCryptoBox(unittest.TestCase):
def test_create_keyring(self):
kr = cryptobox.KeyRing()
assert kr

295
.venv/lib/python3.12/site-packages/autobahn/wamp/test/test_wamp_cryptosign.py Normal file
View File

@@ -0,0 +1,295 @@
###############################################################################
#
# The MIT License (MIT)
#
# Copyright (c) typedef int GmbH
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
###############################################################################
import os
import hashlib
import binascii
import unittest
from unittest.mock import Mock
import txaio
if os.environ.get('USE_TWISTED', None):
txaio.use_twisted()
elif os.environ.get('USE_ASYNCIO', None):
txaio.use_asyncio()
else:
raise RuntimeError('need either USE_TWISTED=1 or USE_ASYNCIO=1')
from autobahn.wamp import types
from autobahn.wamp.auth import create_authenticator
from autobahn.wamp.cryptosign import _makepad, HAS_CRYPTOSIGN, CryptosignAuthextra
if HAS_CRYPTOSIGN:
from autobahn.wamp.cryptosign import CryptosignKey
from nacl.encoding import HexEncoder
import tempfile
keybody = '''-----BEGIN OPENSSH PRIVATE KEY-----
b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gtZW
QyNTUxOQAAACAa38i/4dNWFuZN/72QAJbyOwZvkUyML/u2b2B1uW4RbQAAAJj4FLyB+BS8
gQAAAAtzc2gtZWQyNTUxOQAAACAa38i/4dNWFuZN/72QAJbyOwZvkUyML/u2b2B1uW4RbQ
AAAEBNV9l6aPVVaWYgpthJwM5YJWhRjXKet1PcfHMt4oBFEBrfyL/h01YW5k3/vZAAlvI7
Bm+RTIwv+7ZvYHW5bhFtAAAAFXNvbWV1c2VyQGZ1bmt0aGF0LmNvbQ==
-----END OPENSSH PRIVATE KEY-----'''
pubkey = '''ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJVp3hjHwIQyEladzd8mFcf0YSXcmyKS3qMLB7VqTQKm someuser@example.com
'''
# valid test vectors for WAMP-cryptosign signature testing
test_vectors_1 = [
# _WITHOUT_ channel_id
{
'channel_id': None,
'private_key': '4d57d97a68f555696620a6d849c0ce582568518d729eb753dc7c732de2804510',
'challenge': 'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
'signature': 'b32675b221f08593213737bef8240e7c15228b07028e19595294678c90d11c0cae80a357331bfc5cc9fb71081464e6e75013517c2cf067ad566a6b7b728e5d03ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'
},
{
'channel_id': None,
'private_key': 'd511fe78e23934b3dadb52fcd022974b80bd92bccc7c5cf404e46cc0a8a2f5cd',
'challenge': 'b26c1f87c13fc1da14997f1b5a71995dff8fbe0a62fae8473c7bdbd05bfb607d',
'signature': 'd4209ad10d5aff6bfbc009d7e924795de138a63515efc7afc6b01b7fe5201372190374886a70207b042294af5bd64ce725cd8dceb344e6d11c09d1aaaf4d660fb26c1f87c13fc1da14997f1b5a71995dff8fbe0a62fae8473c7bdbd05bfb607d'
},
{
'channel_id': None,
'private_key': '6e1fde9cf9e2359a87420b65a87dc0c66136e66945196ba2475990d8a0c3a25b',
'challenge': 'b05e6b8ad4d69abf74aa3be3c0ee40ae07d66e1895b9ab09285a2f1192d562d2',
'signature': '7beb282184baadd08f166f16dd683b39cab53816ed81e6955def951cb2ddad1ec184e206746fd82bda075af03711d3d5658fc84a76196b0fa8d1ebc92ef9f30bb05e6b8ad4d69abf74aa3be3c0ee40ae07d66e1895b9ab09285a2f1192d562d2'
},
# _WITH_ channel_id
{
'channel_id': '62e935ae755f3d48f80d4d59f6121358c435722a67e859cc0caa8b539027f2ff',
'private_key': '4d57d97a68f555696620a6d849c0ce582568518d729eb753dc7c732de2804510',
'challenge': 'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
'signature': '9b6f41540c9b95b4b7b281c3042fa9c54cef43c842d62ea3fd6030fcb66e70b3e80d49d44c29d1635da9348d02ec93f3ed1ef227dfb59a07b580095c2b82f80f9d16ca518aa0c2b707f2b2a609edeca73bca8dd59817a633f35574ac6fd80d00'
},
{
'channel_id': '62e935ae755f3d48f80d4d59f6121358c435722a67e859cc0caa8b539027f2ff',
'private_key': 'd511fe78e23934b3dadb52fcd022974b80bd92bccc7c5cf404e46cc0a8a2f5cd',
'challenge': 'b26c1f87c13fc1da14997f1b5a71995dff8fbe0a62fae8473c7bdbd05bfb607d',
'signature': '305aaa3ac25e98f651427688b3fc43fe7d8a68a7ec1d7d61c61517c519bd4a427c3015599d83ca28b4c652333920223844ef0725eb5dc2febfd6af7677b73f01d0852a29b460fc92ec943242ac638a053bbacc200512b18b30d15083cbdc9282'
},
{
'channel_id': '62e935ae755f3d48f80d4d59f6121358c435722a67e859cc0caa8b539027f2ff',
'private_key': '6e1fde9cf9e2359a87420b65a87dc0c66136e66945196ba2475990d8a0c3a25b',
'challenge': 'b05e6b8ad4d69abf74aa3be3c0ee40ae07d66e1895b9ab09285a2f1192d562d2',
'signature': 'ee3c7644fd8070532bc1fde3d70d742267da545d8c8f03e63bda63f1ad4214f4d2c4bfdb4eb9526def42deeb7e31602a6ff99eba893e0a4ad4d45892ca75e608d2b75e24a189a7f78ca776ba36fc53f6c3e31c32f251f2c524f0a44202f2902d'
},
]
class TestSigVectors(unittest.TestCase):
def test_vectors(self):
session = Mock()
for testvec in test_vectors_1:
# setup fake transport details including fake channel_id
if testvec['channel_id']:
channel_id = binascii.a2b_hex(testvec['channel_id'])
channel_id_type = 'tls-unique'
session._transport.transport_details = types.TransportDetails(channel_id={'tls-unique': channel_id})
else:
channel_id = None
channel_id_type = None
session._transport.transport_details = types.TransportDetails(channel_id=None)
# private signing key (the seed for it)
private_key = CryptosignKey.from_bytes(binascii.a2b_hex(testvec['private_key']))
# the fake challenge we've received
challenge = types.Challenge("cryptosign", dict(challenge=testvec['challenge']))
# ok, now sign the challenge
f_signed = private_key.sign_challenge(challenge,
channel_id=channel_id,
channel_id_type=channel_id_type)
def success(signed):
# the signature returned is a Hex encoded string
self.assertTrue(type(signed) == str)
# we return the concatenation of the signature and the message signed (96 bytes)
self.assertEqual(
192,
len(signed),
)
# must match the expected value in our test vector
self.assertEqual(
testvec['signature'],
signed,
)
def failed(err):
self.fail(str(err))
txaio.add_callbacks(f_signed, success, failed)
class TestAuth(unittest.TestCase):
def setUp(self):
self.key = CryptosignKey.from_ssh_bytes(keybody)
self.privkey_hex = self.key._key.encode(encoder=HexEncoder)
# all tests here fake the use of channel_id_type='tls-unique' with the following channel_id
m = hashlib.sha256()
m.update("some TLS message".encode())
# 62e935ae755f3d48f80d4d59f6121358c435722a67e859cc0caa8b539027f2ff
channel_id = m.digest()
self.transport_details = types.TransportDetails(channel_id={'tls-unique': channel_id})
def test_public_key(self):
self.assertEqual(self.key.public_key(binary=False), '1adfc8bfe1d35616e64dffbd900096f23b066f914c8c2ffbb66f6075b96e116d')
def test_valid(self):
session = Mock()
session._transport.transport_details = self.transport_details
challenge = types.Challenge("cryptosign", dict(challenge="ff" * 32))
f_signed = self.key.sign_challenge(challenge,
channel_id=self.transport_details.channel_id['tls-unique'],
channel_id_type='tls-unique')
def success(signed):
self.assertEqual(
192,
len(signed),
)
self.assertEqual(
'9b6f41540c9b95b4b7b281c3042fa9c54cef43c842d62ea3fd6030fcb66e70b3e80d49d44c29d1635da9348d02ec93f3ed1ef227dfb59a07b580095c2b82f80f9d16ca518aa0c2b707f2b2a609edeca73bca8dd59817a633f35574ac6fd80d00',
signed,
)
def failed(err):
self.fail(str(err))
txaio.add_callbacks(f_signed, success, failed)
def test_authenticator(self):
authenticator = create_authenticator(
"cryptosign",
authid="someone",
authextra={'channel_binding': 'tls-unique'},
privkey=self.privkey_hex,
)
session = Mock()
session._transport.transport_details = self.transport_details
challenge = types.Challenge("cryptosign", dict(challenge="ff" * 32))
f_reply = authenticator.on_challenge(session, challenge)
def success(reply):
self.assertEqual(
reply,
'9b6f41540c9b95b4b7b281c3042fa9c54cef43c842d62ea3fd6030fcb66e70b3e80d49d44c29d1635da9348d02ec93f3ed1ef227dfb59a07b580095c2b82f80f9d16ca518aa0c2b707f2b2a609edeca73bca8dd59817a633f35574ac6fd80d00',
)
def failed(err):
self.fail(str(err))
txaio.add_callbacks(f_reply, success, failed)
class TestKey(unittest.TestCase):
def test_pad(self):
self.assertEqual(_makepad(0), b'')
self.assertEqual(_makepad(2), b'\x01\x02')
self.assertEqual(_makepad(3), b'\x01\x02\x03')
self.assertEqual(_makepad(30), b'\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e')
self.assertEqual(binascii.b2a_hex(_makepad(30)).decode(), '0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e')
def test_key(self):
with tempfile.NamedTemporaryFile('w+t') as fp:
fp.write(keybody)
fp.seek(0)
key = CryptosignKey.from_ssh_file(fp.name)
self.assertEqual(key.public_key(), '1adfc8bfe1d35616e64dffbd900096f23b066f914c8c2ffbb66f6075b96e116d')
def test_pubkey(self):
with tempfile.NamedTemporaryFile('w+t') as fp:
fp.write(pubkey)
fp.seek(0)
key = CryptosignKey.from_ssh_file(fp.name)
self.assertEqual(key.public_key(binary=False), '9569de18c7c0843212569dcddf2615c7f46125dc9b2292dea30b07b56a4d02a6')
self.assertEqual(key.comment, 'someuser@example.com')
class TestAuthExtra(unittest.TestCase):
def test_default_ctor(self):
ae = CryptosignAuthextra()
self.assertEqual(ae.marshal(), {})
def test_ctor(self):
ae1 = CryptosignAuthextra(pubkey=b'\xff' * 32)
self.assertEqual(ae1.marshal(), {
'pubkey': 'ff' * 32
})
ae1 = CryptosignAuthextra(pubkey=b'\xff' * 32, bandwidth=200)
self.assertEqual(ae1.marshal(), {
'pubkey': 'ff' * 32,
'reservation': {
'bandwidth': 200
}
})
def test_parse(self):
data_original = {
'pubkey': '9019a424b040859c108edee02e64c1dcb32b253686d7b5db56c306e9bdb2fe7e',
'challenge': 'fe81c84e94a75a357c259d6b37361e43966a45f57dff181bb61b2f91a0f4ac88',
'channel_binding': 'tls-unique',
'channel_id': '2e642bf991f48ece9133a0a32d15550921dda12bfebfbc941571d4b2960540bc',
'trustroot': '0xe78ea2fE1533D4beD9A10d91934e109A130D0ad8',
'reservation': {
'chain_id': 999,
'block_no': 123456789,
'realm': '0x163D58cE482560B7826b4612f40aa2A7d53310C4',
'delegate': '0x72b3486d38E9f49215b487CeAaDF27D6acf22115',
'seeder': '0x52d66f36A7927cF9612e1b40bD6549d08E0513Ff',
'bandwidth': 200
},
'signature': '747763c69394270603f64af5be3f8256a14b41ff51027e583ee81db9f1f15a01cc8e55218a76139f26dbaaa78d8a537d80d248b3fc6245ecf4602cc5fbb0f6452e',
}
ae1 = CryptosignAuthextra.parse(data_original)
data_marshalled = ae1.marshal()
# FIXME: marshal check-summed eth addresses
data_original['trustroot'] = data_original['trustroot'].lower()
for k in ['realm', 'delegate', 'seeder']:
data_original['reservation'][k] = data_original['reservation'][k].lower()
self.assertEqual(data_marshalled, data_original)

50
.venv/lib/python3.12/site-packages/autobahn/wamp/test/test_wamp_exception.py Normal file
View File

@@ -0,0 +1,50 @@
###############################################################################
#
# The MIT License (MIT)
#
# Copyright (c) typedef int GmbH
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
###############################################################################
from unittest import TestCase
from autobahn.wamp.exception import ApplicationError
class ApplicationErrorTestCase(TestCase):
def test_unicode_str(self):
"""
Unicode arguments in ApplicationError will not raise an exception when
str()'d.
"""
error = ApplicationError("some.url", "\u2603")
self.assertIn("\u2603", str(error))
def test_unicode_errormessage(self):
"""
Unicode arguments in ApplicationError will not raise an exception when
the error_message method is called.
"""
error = ApplicationError("some.url", "\u2603")
# on py27-tw189: exceptions.UnicodeEncodeError: 'ascii' codec can't encode character '\u2603' in position 10: ordinal not in
print(error.error_message())
self.assertIn("\u2603", error.error_message())

98
.venv/lib/python3.12/site-packages/autobahn/wamp/test/test_wamp_identifiers.py Normal file
View File

@@ -0,0 +1,98 @@
###############################################################################
#
# The MIT License (MIT)
#
# Copyright (c) typedef int GmbH
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
###############################################################################
from autobahn.wamp.message import check_or_raise_realm_name, identify_realm_name_category
from autobahn.wamp.exception import InvalidUriError
import unittest
class TestWampIdentifiers(unittest.TestCase):
def test_valid_realm_names(self):
for name in [
'realm1',
'com.example.myapp1',
'myapp1.example.com',
'eth.wamp-proto',
'wamp-proto.eth',
'eth.wamp-proto.myapp1',
'myapp1.wamp-proto.eth',
'aaa',
'Abc',
'a00',
'A00',
'0x0000000000000000000000000000000000000000',
'0xe59C7418403CF1D973485B36660728a5f4A8fF9c',
]:
self.assertEqual(name, check_or_raise_realm_name(name))
def test_invalid_realm_names(self):
for name in [
None,
23,
{},
'',
'.realm1',
'123realm',
'0x' + '00' * 64,
'0x' + '00' * 32,
'0x' + 'zz' * 40,
'rlm$test',
'a' * 256,
]:
self.assertRaises(InvalidUriError, check_or_raise_realm_name, name)
def test_realm_name_categories(self):
for name, category in [
# valid
('realm1', 'standalone'),
('com.example.myapp1', 'standalone'),
('myapp1.example.com', 'standalone'),
('eth.wamp-proto', 'reverse_ens'),
('wamp-proto.eth', 'ens'),
('eth.wamp-proto.myapp1', 'reverse_ens'),
('myapp1.wamp-proto.eth', 'ens'),
('aaa', 'standalone'),
('Abc', 'standalone'),
('a00', 'standalone'),
('A00', 'standalone'),
('0x0000000000000000000000000000000000000000', 'eth'),
('0xe59C7418403CF1D973485B36660728a5f4A8fF9c', 'eth'),
# invalid
(None, None),
(23, None),
({}, None),
('', None),
('.realm1', None),
('123realm', None),
('0x' + '00' * 64, None),
('0x' + '00' * 32, None),
('0x' + 'zz' * 40, None),
('rlm$test', None),
('a' * 256, None),
]:
self.assertEqual(category, identify_realm_name_category(name))

1151
.venv/lib/python3.12/site-packages/autobahn/wamp/test/test_wamp_message.py Normal file
View File

File diff suppressed because it is too large Load Diff

1088
.venv/lib/python3.12/site-packages/autobahn/wamp/test/test_wamp_protocol.py Normal file
View File

File diff suppressed because it is too large Load Diff

104
.venv/lib/python3.12/site-packages/autobahn/wamp/test/test_wamp_protocol_peer.py Normal file
View File

@@ -0,0 +1,104 @@
###############################################################################
#
# The MIT License (MIT)
#
# Copyright (c) typedef int GmbH
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
###############################################################################
# we need to select a txaio subsystem because we're importing the base
# protocol classes here for testing purposes. "normally" yo'd import
# from autobahn.twisted.wamp or autobahn.asyncio.wamp explicitly.
from autobahn import wamp
from autobahn.wamp import message
from autobahn.wamp import exception
from autobahn.wamp import protocol
import unittest
class TestPeerExceptions(unittest.TestCase):
def test_exception_from_message(self):
session = protocol.BaseSession()
@wamp.error("com.myapp.error1")
class AppError1(Exception):
pass
@wamp.error("com.myapp.error2")
class AppError2(Exception):
pass
session.define(AppError1)
session.define(AppError2)
# map defined errors to user exceptions
emsg = message.Error(message.Call.MESSAGE_TYPE, 123456, 'com.myapp.error1')
exc = session._exception_from_message(emsg)
self.assertIsInstance(exc, AppError1)
self.assertEqual(exc.args, ())
emsg = message.Error(message.Call.MESSAGE_TYPE, 123456, 'com.myapp.error2')
exc = session._exception_from_message(emsg)
self.assertIsInstance(exc, AppError2)
self.assertEqual(exc.args, ())
# map undefined error to (generic) exception
emsg = message.Error(message.Call.MESSAGE_TYPE, 123456, 'com.myapp.error3')
exc = session._exception_from_message(emsg)
self.assertIsInstance(exc, exception.ApplicationError)
self.assertEqual(exc.error, 'com.myapp.error3')
self.assertEqual(exc.args, ())
self.assertEqual(exc.kwargs, {})
emsg = message.Error(message.Call.MESSAGE_TYPE, 123456, 'com.myapp.error3', args=[1, 2, 'hello'])
exc = session._exception_from_message(emsg)
self.assertIsInstance(exc, exception.ApplicationError)
self.assertEqual(exc.error, 'com.myapp.error3')
self.assertEqual(exc.args, (1, 2, 'hello'))
self.assertEqual(exc.kwargs, {})
emsg = message.Error(message.Call.MESSAGE_TYPE, 123456, 'com.myapp.error3', args=[1, 2, 'hello'], kwargs={'foo': 23, 'bar': 'baz'})
exc = session._exception_from_message(emsg)
self.assertIsInstance(exc, exception.ApplicationError)
self.assertEqual(exc.error, 'com.myapp.error3')
self.assertEqual(exc.args, (1, 2, 'hello'))
self.assertEqual(exc.kwargs, {'foo': 23, 'bar': 'baz'})
def test_message_from_exception(self):
session = protocol.BaseSession()
@wamp.error("com.myapp.error1")
class AppError1(Exception):
pass
@wamp.error("com.myapp.error2")
class AppError2(Exception):
pass
session.define(AppError1)
session.define(AppError2)
exc = AppError1()
msg = session._message_from_exception(message.Call.MESSAGE_TYPE, 123456, exc)
self.assertEqual(msg.marshal(), [message.Error.MESSAGE_TYPE, message.Call.MESSAGE_TYPE, 123456, {}, "com.myapp.error1"])

72
.venv/lib/python3.12/site-packages/autobahn/wamp/test/test_wamp_scram.py Normal file
View File

@@ -0,0 +1,72 @@
###############################################################################
#
# The MIT License (MIT)
#
# Copyright (c) typedef int GmbH
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
###############################################################################
import unittest
from binascii import a2b_hex
from autobahn.wamp.auth import derive_scram_credential
TEST_VECTORS = [
{
'email': 'foobar@example.com',
'password': 'secret123',
'salt': None,
'expected': {
'iterations': 4096,
'kdf': 'argon2id-13',
'memory': 512,
'salt': '3bc3ca01dd1d501ca1c22e1c5d7d16fe',
'server-key': '8de7864c316f3c2356fd76cfdab696db55bc70e680fe5180e2f731e2345acca2',
'stored-key': 'e796c2f0a51770303ee4616bc630a66774d51a55003154aff2a54ec7c4ac0e38'
}
},
{
'email': 'foobar@example.com',
'password': 'secret123',
'salt': a2b_hex('ae1f0d2f422757809077785e660b62c6'),
'expected': {
'iterations': 4096,
'kdf': 'argon2id-13',
'memory': 512,
'salt': 'ae1f0d2f422757809077785e660b62c6',
'server-key': '0d8e7e9222a7c0e54c9e979aa342115699ff5696c45dc379b5ee241338a5861d',
'stored-key': '5f19358ff6f38e267b6ef1ea1d862514ec4e8745a84682259fd3894be09febb5'
}
},
]
class TestKey(unittest.TestCase):
def test_derive_scram_credential(self):
for tv in TEST_VECTORS:
email = tv['email']
password = tv['password']
salt = tv['salt']
expected = tv['expected']
credential = derive_scram_credential(email, password, salt)
self.assertEqual(credential, expected)

546
.venv/lib/python3.12/site-packages/autobahn/wamp/test/test_wamp_serializer.py Normal file
View File

@@ -0,0 +1,546 @@
###############################################################################
#
# The MIT License (MIT)
#
# Copyright (c) typedef int GmbH
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
###############################################################################
import os
import unittest
import random
import decimal
from decimal import Decimal
from autobahn.wamp import message
from autobahn.wamp import role
from autobahn.wamp import serializer
def generate_test_messages():
"""
List of WAMP test message used for serializers. Expand this if you add more
options or messages.
This list of WAMP message does not contain any binary app payloads!
"""
some_bytes = os.urandom(32)
some_unicode = '\u3053\u3093\u306b\u3061\u306f\u4e16\u754c'
some_uri = 'com.myapp.foobar'
some_unicode_uri = 'com.myapp.\u4f60\u597d\u4e16\u754c.baz'
some_args = [1, 2, 3, 'hello', some_bytes, some_unicode, {'foo': 23, 'bar': 'hello', 'baz': some_bytes, 'moo': some_unicode}]
some_kwargs = {'foo': 23, 'bar': 'hello', 'baz': some_bytes, 'moo': some_unicode, 'arr': some_args}
msgs = [
message.Hello("realm1", {'subscriber': role.RoleSubscriberFeatures()}),
message.Hello("realm1", {'publisher': role.RolePublisherFeatures()}),
message.Hello("realm1", {'caller': role.RoleCallerFeatures()}),
message.Hello("realm1", {'callee': role.RoleCalleeFeatures()}),
message.Hello("realm1", {
'subscriber': role.RoleSubscriberFeatures(),
'publisher': role.RolePublisherFeatures(),
'caller': role.RoleCallerFeatures(),
'callee': role.RoleCalleeFeatures(),
}),
message.Goodbye(),
message.Yield(123456),
message.Yield(123456, args=some_args),
message.Yield(123456, args=[], kwargs=some_kwargs),
message.Yield(123456, args=some_args, kwargs=some_kwargs),
message.Yield(123456, progress=True),
message.Interrupt(123456),
message.Interrupt(123456, mode=message.Interrupt.KILL),
message.Invocation(123456, 789123),
message.Invocation(123456, 789123, args=some_args),
message.Invocation(123456, 789123, args=[], kwargs=some_kwargs),
message.Invocation(123456, 789123, args=some_args, kwargs=some_kwargs),
message.Invocation(123456, 789123, timeout=10000),
message.Result(123456),
message.Result(123456, args=some_args),
message.Result(123456, args=[], kwargs=some_kwargs),
message.Result(123456, args=some_args, kwargs=some_kwargs),
message.Result(123456, progress=True),
message.Cancel(123456),
message.Cancel(123456, mode=message.Cancel.KILL),
message.Call(123456, some_uri),
message.Call(123456, some_uri, args=some_args),
message.Call(123456, some_uri, args=[], kwargs=some_kwargs),
message.Call(123456, some_uri, args=some_args, kwargs=some_kwargs),
message.Call(123456, some_uri, timeout=10000),
message.Call(123456, some_unicode_uri),
message.Call(123456, some_unicode_uri, args=some_args),
message.Call(123456, some_unicode_uri, args=[], kwargs=some_kwargs),
message.Call(123456, some_unicode_uri, args=some_args, kwargs=some_kwargs),
message.Call(123456, some_unicode_uri, timeout=10000),
message.Unregistered(123456),
message.Unregister(123456, 789123),
message.Registered(123456, 789123),
message.Register(123456, some_uri),
message.Register(123456, some_uri, match='prefix'),
message.Register(123456, some_uri, invoke='roundrobin'),
message.Register(123456, some_unicode_uri),
message.Register(123456, some_unicode_uri, match='prefix'),
message.Register(123456, some_unicode_uri, invoke='roundrobin'),
message.Event(123456, 789123),
message.Event(123456, 789123, args=some_args),
message.Event(123456, 789123, args=[], kwargs=some_kwargs),
message.Event(123456, 789123, args=some_args, kwargs=some_kwargs),
message.Event(123456, 789123, publisher=300),
message.Published(123456, 789123),
message.Publish(123456, some_uri),
message.Publish(123456, some_uri, args=some_args),
message.Publish(123456, some_uri, args=[], kwargs=some_kwargs),
message.Publish(123456, some_uri, args=some_args, kwargs=some_kwargs),
message.Publish(123456, some_uri, exclude_me=False, exclude=[300], eligible=[100, 200, 300]),
message.Publish(123456, some_unicode_uri),
message.Publish(123456, some_unicode_uri, args=some_args),
message.Publish(123456, some_unicode_uri, args=[], kwargs=some_kwargs),
message.Publish(123456, some_unicode_uri, args=some_args, kwargs=some_kwargs),
message.Publish(123456, some_unicode_uri, exclude_me=False, exclude=[300], eligible=[100, 200, 300]),
message.Unsubscribed(123456),
message.Unsubscribe(123456, 789123),
message.Subscribed(123456, 789123),
message.Subscribe(123456, some_uri),
message.Subscribe(123456, some_uri, match=message.Subscribe.MATCH_PREFIX),
message.Subscribe(123456, some_unicode_uri),
message.Subscribe(123456, some_unicode_uri, match=message.Subscribe.MATCH_PREFIX),
message.Error(message.Call.MESSAGE_TYPE, 123456, some_uri),
message.Error(message.Call.MESSAGE_TYPE, 123456, some_uri, args=some_args),
message.Error(message.Call.MESSAGE_TYPE, 123456, some_uri, args=[], kwargs=some_kwargs),
message.Error(message.Call.MESSAGE_TYPE, 123456, some_uri, args=some_args, kwargs=some_kwargs),
message.Error(message.Call.MESSAGE_TYPE, 123456, some_unicode_uri),
message.Error(message.Call.MESSAGE_TYPE, 123456, some_unicode_uri, args=some_args),
message.Error(message.Call.MESSAGE_TYPE, 123456, some_unicode_uri, args=[], kwargs=some_kwargs),
message.Error(message.Call.MESSAGE_TYPE, 123456, some_unicode_uri, args=some_args, kwargs=some_kwargs),
message.Result(123456),
message.Result(123456, args=some_args),
message.Result(123456, args=some_args, kwargs=some_kwargs),
]
return [(False, msg) for msg in msgs]
def generate_test_messages_binary():
"""
Generate WAMP test messages which contain binary app payloads.
With the JSON serializer, this currently only works on Python 3 (both CPython3 and PyPy3),
because even on Python 3, we need to patch the stdlib JSON, and on Python 2, the patching
would be even hackier.
"""
msgs = []
for binary in [b'',
b'\x00',
b'\30',
os.urandom(4),
os.urandom(16),
os.urandom(128),
os.urandom(256),
os.urandom(512),
os.urandom(1024)]:
msgs.append(message.Event(123456, 789123, args=[binary]))
msgs.append(message.Event(123456, 789123, args=[binary], kwargs={'foo': binary}))
return [(True, msg) for msg in msgs]
def create_serializers(decimal_support=False):
_serializers = []
_serializers.append(serializer.JsonSerializer(use_decimal_from_str=decimal_support))
_serializers.append(serializer.JsonSerializer(batched=True, use_decimal_from_str=decimal_support))
_serializers.append(serializer.CBORSerializer())
_serializers.append(serializer.CBORSerializer(batched=True))
if not decimal_support:
# builtins.OverflowError: Integer value out of range
_serializers.append(serializer.MsgPackSerializer())
_serializers.append(serializer.MsgPackSerializer(batched=True))
# roundtrip error
_serializers.append(serializer.UBJSONSerializer())
_serializers.append(serializer.UBJSONSerializer(batched=True))
# FIXME: implement full FlatBuffers serializer for WAMP
# WAMP-FlatBuffers currently only supports Python 3
# _serializers.append(serializer.FlatBuffersSerializer())
# _serializers.append(serializer.FlatBuffersSerializer(batched=True))
return _serializers
class TestFlatBuffersSerializer(unittest.TestCase):
def test_basic(self):
messages = [
message.Event(123456,
789123,
args=[1, 2, 3],
kwargs={'foo': 23, 'bar': 'hello'},
publisher=666,
retained=True),
message.Publish(123456,
'com.example.topic1',
args=[1, 2, 3],
kwargs={'foo': 23, 'bar': 'hello'},
retain=True)
]
ser = serializer.FlatBuffersSerializer()
# from pprint import pprint
for msg in messages:
# serialize message
payload, binary = ser.serialize(msg)
# unserialize message again
msg2 = ser.unserialize(payload, binary)[0]
# pprint(msg.marshal())
# pprint(msg2.marshal())
# must be equal: message roundtrips via the serializer
self.assertEqual(msg, msg2)
# self.assertEqual(msg.subscription, msg2.subscription)
# self.assertEqual(msg.publication, msg2.publication)
class TestDecimalSerializer(unittest.TestCase):
"""
binary fixed-point
binary floating-point: float (float32), double (float64)
decimal floating-point: decimal128, decimal256
decimal fixed-point: NUMERIC(precision, scale)
decimal arbitrary precision: NUMERIC, decimal.Decimal
https://developer.nvidia.com/blog/implementing-high-precision-decimal-arithmetic-with-cuda-int128/
https://github.com/johnmcfarlane/cnl
"""
def setUp(self) -> None:
self._test_serializers = create_serializers(decimal_support=True)
# enough for decimal256 precision arithmetic (76 significand decimal digits)
decimal.getcontext().prec = 76
self._test_messages_no_dec = [
(True,
{
'a': random.random(),
'b': random.randint(0, 2 ** 53),
'c': random.randint(0, 2 ** 64),
'd': random.randint(0, 2 ** 128),
'e': random.randint(0, 2 ** 256),
# float64: 52 binary digits, precision of 15-17 significant decimal digits
'f': 0.12345678901234567,
'g': 0.8765432109876545,
'y': os.urandom(8),
'z': [
-1,
0,
1,
True,
None,
0.12345678901234567,
0.8765432109876545,
os.urandom(8)
]
})
]
self._test_messages_dec = [
(True,
{
'a': random.random(),
'b': random.randint(0, 2 ** 53),
'c': random.randint(0, 2 ** 64),
'd': random.randint(0, 2 ** 128),
'e': random.randint(0, 2 ** 256),
# float64: 52 binary digits, precision of 15-17 significant decimal digits
'f': 0.12345678901234567,
'g': 0.8765432109876545,
# decimal128: precision of 38 significant decimal digits
'h': Decimal('0.1234567890123456789012345678901234567'),
'i': Decimal('0.8765432109876543210987654321098765434'),
# decimal256: precision of 76 significant decimal digits
'j': Decimal('0.123456789012345678901234567890123456701234567890123456789012345678901234567'),
'k': Decimal('0.876543210987654321098765432109876543298765432109876543210987654321098765434'),
'y': os.urandom(8),
'z': [
-1,
0,
1,
True,
None,
0.12345678901234567,
0.8765432109876545,
Decimal('0.1234567890123456789012345678901234567'),
Decimal('0.8765432109876543210987654321098765434'),
Decimal('0.123456789012345678901234567890123456701234567890123456789012345678901234567'),
Decimal('0.876543210987654321098765432109876543298765432109876543210987654321098765434'),
os.urandom(8)
]
})
]
def test_json_no_decimal(self):
"""
Test without ``use_decimal_from_str`` feature of JSON object serializer.
"""
ser = serializer.JsonObjectSerializer(use_decimal_from_str=False)
for contains_binary, obj in self._test_messages_no_dec:
_obj = ser.unserialize(ser.serialize(obj))[0]
self.assertEqual(obj, _obj)
self.assertEqual(1.0000000000000002, _obj['f'] + _obj['g'])
def test_json_decimal(self):
"""
Test ``use_decimal_from_str`` feature of JSON object serializer.
"""
ser = serializer.JsonObjectSerializer(use_decimal_from_str=True)
for contains_binary, obj in self._test_messages_dec:
_obj = ser.unserialize(ser.serialize(obj))[0]
self.assertEqual(obj, _obj)
self.assertEqual(1.0000000000000002, _obj['f'] + _obj['g'])
self.assertEqual(Decimal('1.0000000000000000000000000000000000001'), _obj['h'] + _obj['i'])
self.assertEqual(Decimal('1.000000000000000000000000000000000000000000000000000000000000000000000000001'), _obj['j'] + _obj['k'])
def test_roundtrip_msg(self):
for wamp_ser in self._test_serializers:
ser = wamp_ser._serializer
for contains_binary, msg in self._test_messages_no_dec + self._test_messages_dec:
payload = ser.serialize(msg)
msg2 = ser.unserialize(payload)
self.assertEqual(msg, msg2[0])
def test_crosstrip_msg(self):
for wamp_ser1 in self._test_serializers:
ser1 = wamp_ser1._serializer
for contains_binary, msg in self._test_messages_no_dec + self._test_messages_dec:
payload1 = ser1.serialize(msg)
msg1 = ser1.unserialize(payload1)
msg1 = msg1[0]
for wamp_ser2 in self._test_serializers:
ser2 = wamp_ser2._serializer
payload2 = ser2.serialize(msg1)
msg2 = ser2.unserialize(payload2)
msg2 = msg2[0]
self.assertEqual(msg, msg2)
# print(ser1, len(payload1), ser2, len(payload2))
class TestSerializer(unittest.TestCase):
def setUp(self):
self._test_messages = generate_test_messages() + generate_test_messages_binary()
self._test_serializers = create_serializers()
# print('Testing WAMP serializers {} with {} WAMP test messages'.format([ser.SERIALIZER_ID for ser in self._test_serializers], len(self._test_messages)))
def test_deep_equal_msg(self):
"""
Test deep object equality assert (because I am paranoid).
"""
v = os.urandom(10)
o1 = [1, 2, {'foo': 'bar', 'bar': v, 'baz': [9, 3, 2], 'goo': {'moo': [1, 2, 3]}}, v]
o2 = [1, 2, {'goo': {'moo': [1, 2, 3]}, 'bar': v, 'baz': [9, 3, 2], 'foo': 'bar'}, v]
self.assertEqual(o1, o2)
def test_roundtrip_msg(self):
"""
Test round-tripping over each serializer.
"""
for ser in self._test_serializers:
for contains_binary, msg in self._test_messages:
# serialize message
payload, binary = ser.serialize(msg)
# unserialize message again
msg2 = ser.unserialize(payload, binary)
# must be equal: message roundtrips via the serializer
self.assertEqual([msg], msg2)
def test_crosstrip_msg(self):
"""
Test cross-tripping over 2 serializers (as is done by WAMP routers).
"""
for ser1 in self._test_serializers:
for contains_binary, msg in self._test_messages:
# serialize message
payload, binary = ser1.serialize(msg)
# unserialize message again
msg1 = ser1.unserialize(payload, binary)
msg1 = msg1[0]
for ser2 in self._test_serializers:
# serialize message
payload, binary = ser2.serialize(msg1)
# unserialize message again
msg2 = ser2.unserialize(payload, binary)
# must be equal: message crosstrips via
# the serializers ser1 -> ser2
self.assertEqual([msg], msg2)
def test_cache_msg(self):
"""
Test message serialization caching.
"""
for contains_binary, msg in self._test_messages:
# message serialization cache is initially empty
self.assertEqual(msg._serialized, {})
for ser in self._test_serializers:
# verify message serialization is not yet cached
self.assertFalse(ser._serializer in msg._serialized)
payload, binary = ser.serialize(msg)
# now the message serialization must be cached
self.assertTrue(ser._serializer in msg._serialized)
self.assertEqual(msg._serialized[ser._serializer], payload)
# and after resetting the serialization cache, message
# serialization is gone
msg.uncache()
self.assertFalse(ser._serializer in msg._serialized)
def test_initial_stats(self):
"""
Test initial serializer stats are indeed empty.
"""
for ser in self._test_serializers:
stats = ser.stats(details=True)
self.assertEqual(stats['serialized']['bytes'], 0)
self.assertEqual(stats['serialized']['messages'], 0)
self.assertEqual(stats['serialized']['rated_messages'], 0)
self.assertEqual(stats['unserialized']['bytes'], 0)
self.assertEqual(stats['unserialized']['messages'], 0)
self.assertEqual(stats['unserialized']['rated_messages'], 0)
def test_serialize_stats(self):
"""
Test serializer stats are non-empty after serializing/unserializing messages.
"""
for ser in self._test_serializers:
for contains_binary, msg in self._test_messages:
# serialize message
payload, binary = ser.serialize(msg)
# unserialize message again
ser.unserialize(payload, binary)
stats = ser.stats(details=False)
self.assertTrue(stats['bytes'] > 0)
self.assertTrue(stats['messages'] > 0)
self.assertTrue(stats['rated_messages'] > 0)
def test_serialize_stats_with_details(self):
"""
Test serializer stats - with details - are non-empty after serializing/unserializing messages.
"""
for ser in self._test_serializers:
for contains_binary, msg in self._test_messages:
# serialize message
payload, binary = ser.serialize(msg)
# unserialize message again
ser.unserialize(payload, binary)
stats = ser.stats(details=True)
# {'serialized': {'bytes': 7923, 'messages': 59, 'rated_messages': 69}, 'unserialized': {'bytes': 7923, 'messages': 59, 'rated_messages': 69}}
# print(stats)
self.assertTrue(stats['serialized']['bytes'] > 0)
self.assertTrue(stats['serialized']['messages'] > 0)
self.assertTrue(stats['serialized']['rated_messages'] > 0)
self.assertTrue(stats['unserialized']['bytes'] > 0)
self.assertTrue(stats['unserialized']['messages'] > 0)
self.assertTrue(stats['unserialized']['rated_messages'] > 0)
self.assertEqual(stats['serialized']['bytes'], stats['unserialized']['bytes'])
self.assertEqual(stats['serialized']['messages'], stats['unserialized']['messages'])
self.assertEqual(stats['serialized']['rated_messages'], stats['unserialized']['rated_messages'])
def test_reset_stats(self):
"""
Test serializer stats are reset after fetching stats - depending on option.
"""
for ser in self._test_serializers:
for contains_binary, msg in self._test_messages:
# serialize message
payload, binary = ser.serialize(msg)
# unserialize message again
ser.unserialize(payload, binary)
ser.stats()
stats = ser.stats(details=True)
self.assertEqual(stats['serialized']['bytes'], 0)
self.assertEqual(stats['serialized']['messages'], 0)
self.assertEqual(stats['serialized']['rated_messages'], 0)
self.assertEqual(stats['unserialized']['bytes'], 0)
self.assertEqual(stats['unserialized']['messages'], 0)
self.assertEqual(stats['unserialized']['rated_messages'], 0)
def test_auto_stats(self):
"""
Test serializer stats are non-empty after serializing/unserializing messages.
"""
for ser in self._test_serializers:
def on_stats(stats):
self.assertTrue(stats['bytes'] > 0)
self.assertTrue(stats['messages'] > 0)
self.assertTrue(stats['rated_messages'] > 0)
ser.set_stats_autoreset(10, 0, on_stats)
for contains_binary, msg in self._test_messages:
# serialize message
payload, binary = ser.serialize(msg)
# unserialize message again
ser.unserialize(payload, binary)

88
.venv/lib/python3.12/site-packages/autobahn/wamp/test/test_wamp_session_details.py Normal file
View File

@@ -0,0 +1,88 @@
###############################################################################
#
# The MIT License (MIT)
#
# Copyright (c) typedef int GmbH
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
###############################################################################
from autobahn.wamp.types import TransportDetails, SessionDetails
import unittest
# from .test_wamp_transport_details import TRANSPORT_DETAILS_1
from autobahn.wamp.test.test_wamp_transport_details import TRANSPORT_DETAILS_1
class TestSessionDetails(unittest.TestCase):
def test_empty(self):
sd1 = SessionDetails()
data = sd1.marshal()
self.assertEqual(data, {
'realm': None,
'session': None,
'authid': None,
'authrole': None,
'authmethod': None,
'authprovider': None,
'authextra': None,
'serializer': None,
'transport': None,
'resumed': None,
'resumable': None,
'resume_token': None,
})
sd2 = SessionDetails.parse(data)
self.assertEqual(sd2, sd1)
def test_attributes(self):
sd1 = SessionDetails()
td1 = TransportDetails.parse(TRANSPORT_DETAILS_1)
sd1.realm = 'realm1'
sd1.session = 666
sd1.authid = 'homer'
sd1.authrole = 'user'
sd1.authmethod = 'wampcra'
sd1.authprovider = 'static'
sd1.authextra = {'foo': 'bar', 'baz': [1, 2, 3]}
sd1.serializer = 'json'
sd1.transport = td1
sd1.resumed = False
sd1.resumable = True
sd1.resume_token = '8713e25a-d4f5-48b7-9d6d-eda66603a1ab'
data = sd1.marshal()
self.assertEqual(data, {
'realm': sd1.realm,
'session': sd1.session,
'authid': sd1.authid,
'authrole': sd1.authrole,
'authmethod': sd1.authmethod,
'authprovider': sd1.authprovider,
'authextra': sd1.authextra,
'serializer': sd1.serializer,
'transport': sd1.transport.marshal(),
'resumed': sd1.resumed,
'resumable': sd1.resumable,
'resume_token': sd1.resume_token,
})
sd2 = SessionDetails.parse(data)
self.assertEqual(sd2, sd1)

Some files were not shown because too many files have changed in this diff Show More