feat(client): stream invites (#202 )

* chore: update dev container * feat(client): add server version request * docs(client): enhanced server version docstring * test(client): sever version test * test(base): type check for union type * refactor(base): move _ attrs to `RegisteringBase` * refactor: some light cleanup * chore(container): add pylint line length * feat(metrics): add "Invite Action" * feat(client): pass server version to resources * feat(models): pending stream collaborator model * fix(client): do not parse if request res is null * feat(exceptions): add unsupported exception to distinguish for new invites as of server 2.6.4 * feat(client): add stream invite queries/mutations * test(client): test stream invites * feat(client): incorporate last invites changes
feat(serialization): cache bases on deserialize (#200 )
2022-07-26 17:58:46 +01:00 · 2022-07-20 18:02:25 +01:00 · 2022-07-15 16:38:55 +01:00 · 2022-07-11 12:19:22 +01:00 · 2022-07-11 10:31:19 +01:00 · 2022-06-30 16:16:05 +01:00
33 changed files with 1529 additions and 473 deletions
@@ -1,11 +1,11 @@
-# See here for image contents: https://github.com/microsoft/vscode-dev-containers/tree/v0.191.1/containers/python-3/.devcontainer/base.Dockerfile
+# See here for image contents: https://github.com/microsoft/vscode-dev-containers/blob/main/containers/python-3/.devcontainer/base.Dockerfile

 # [Choice] Python version: 3, 3.9, 3.8, 3.7, 3.6
-ARG VARIANT="3.9"
-FROM mcr.microsoft.com/vscode/devcontainers/python:0-${VARIANT}
+ARG VARIANT="3.10"
+FROM mcr.microsoft.com/vscode/devcontainers/python:${VARIANT}

 # [Choice] Node.js version: none, lts/*, 16, 14, 12, 10
-ARG NODE_VERSION="none"
+ARG NODE_VERSION="16"
 RUN if [ "${NODE_VERSION}" != "none" ]; then su vscode -c "umask 0002 && . /usr/local/share/nvm/nvm.sh && nvm install ${NODE_VERSION} 2>&1"; fi

 # [Optional] If your pip requirements rarely change, uncomment this section to add them to the image.
@@ -22,6 +22,9 @@
 		"python.languageServer": "Pylance",
 		"python.linting.enabled": true,
 		"python.linting.pylintEnabled": true,
+		"python.linting.pylintArgs": [
+			"--max-line-length=120"
+		],
 		"python.formatting.autopep8Path": "/usr/local/py-utils/bin/autopep8",
 		"python.formatting.blackPath": "/usr/local/py-utils/bin/black",
 		"python.formatting.yapfPath": "/usr/local/py-utils/bin/yapf",
@@ -6,16 +6,12 @@ services:
      POSTGRES_DB: speckle2_test
      POSTGRES_PASSWORD: speckle
      POSTGRES_USER: speckle
-      # ports:
-      #   - "5432:5432"
    network_mode: host
  redis:
    image: cimg/redis:6.2
-    # ports:
-    #   - "6379:6379"
    network_mode: host
  speckle-server:
-    image: speckle/speckle-server
+    image: speckle/speckle-server:latest
    command: ["bash", "-c", "/wait && node bin/www"]
    environment:
      POSTGRES_URL: "localhost"
@@ -28,8 +24,6 @@ services:
      CANONICAL_URL: "http://localhost:3000"
      WAIT_HOSTS: localhost:5432, localhost:6379
      DISABLE_FILE_UPLOADS: "true"
-    # ports:
-    #   - "3000:3000"
    network_mode: host

  specklepy:
@@ -6,6 +6,20 @@ category = "main"
 optional = false
 python-versions = "*"

+[[package]]
+name = "astroid"
+version = "2.11.7"
+description = "An abstract syntax tree for Python with inference support."
+category = "dev"
+optional = false
+python-versions = ">=3.6.2"
+
+[package.dependencies]
+lazy-object-proxy = ">=1.4.0"
+typed-ast = {version = ">=1.4.0,<2.0", markers = "implementation_name == \"cpython\" and python_version < \"3.8\""}
+typing-extensions = {version = ">=3.10", markers = "python_version < \"3.10\""}
+wrapt = ">=1.11,<2"
+
 [[package]]
 name = "asttokens"
 version = "2.0.5"
@@ -42,6 +56,14 @@ docs = ["furo", "sphinx", "zope.interface", "sphinx-notfound-page"]
 tests = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "six", "mypy", "pytest-mypy-plugins", "zope.interface", "cloudpickle"]
 tests_no_zope = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "six", "mypy", "pytest-mypy-plugins", "cloudpickle"]

+[[package]]
+name = "backoff"
+version = "2.1.2"
+description = "Function decoration for backoff and retry"
+category = "main"
+optional = false
+python-versions = ">=3.7,<4.0"
+
 [[package]]
 name = "black"
 version = "20.8b1"
@@ -105,7 +127,7 @@ python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"

 [[package]]
 name = "coverage"
-version = "6.4.1"
+version = "6.4.2"
 description = "Code coverage measurement for Python"
 category = "dev"
 optional = false
@@ -146,6 +168,17 @@ executing = ">=0.8.0,<1.0.0"
 [package.extras]
 pygments = ["Pygments (>=2.2.0)"]

+[[package]]
+name = "dill"
+version = "0.3.5.1"
+description = "serialize all of python"
+category = "dev"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*"
+
+[package.extras]
+graph = ["objgraph (>=1.7.2)"]
+
 [[package]]
 name = "executing"
 version = "0.8.3"
@@ -156,13 +189,14 @@ python-versions = "*"

 [[package]]
 name = "gql"
-version = "3.3.0"
+version = "3.4.0"
 description = "GraphQL client for Python"
 category = "main"
 optional = false
 python-versions = "*"

 [package.dependencies]
+backoff = ">=1.11.1,<3.0"
 graphql-core = ">=3.2,<3.3"
 requests = {version = ">=2.26,<3", optional = true, markers = "extra == \"requests\""}
 requests-toolbelt = {version = ">=0.9.1,<1", optional = true, markers = "extra == \"requests\""}
@@ -235,6 +269,22 @@ requirements_deprecated_finder = ["pipreqs", "pip-api"]
 colors = ["colorama (>=0.4.3,<0.5.0)"]
 plugins = ["setuptools"]

+[[package]]
+name = "lazy-object-proxy"
+version = "1.7.1"
+description = "A fast and thorough lazy object proxy."
+category = "dev"
+optional = false
+python-versions = ">=3.6"
+
+[[package]]
+name = "mccabe"
+version = "0.7.0"
+description = "McCabe checker, plugin for flake8"
+category = "dev"
+optional = false
+python-versions = ">=3.6"
+
 [[package]]
 name = "multidict"
 version = "6.0.2"
@@ -270,6 +320,18 @@ category = "dev"
 optional = false
 python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,>=2.7"

+[[package]]
+name = "platformdirs"
+version = "2.5.2"
+description = "A small Python module for determining appropriate platform-specific dirs, e.g. a \"user data dir\"."
+category = "dev"
+optional = false
+python-versions = ">=3.7"
+
+[package.extras]
+docs = ["furo (>=2021.7.5b38)", "proselint (>=0.10.2)", "sphinx-autodoc-typehints (>=1.12)", "sphinx (>=4)"]
+test = ["appdirs (==1.4.4)", "pytest-cov (>=2.7)", "pytest-mock (>=3.6)", "pytest (>=6)"]
+
 [[package]]
 name = "pluggy"
 version = "1.0.0"
@@ -308,6 +370,29 @@ typing-extensions = ">=3.7.4.3"
 dotenv = ["python-dotenv (>=0.10.4)"]
 email = ["email-validator (>=1.0.3)"]

+[[package]]
+name = "pylint"
+version = "2.14.4"
+description = "python code static checker"
+category = "dev"
+optional = false
+python-versions = ">=3.7.2"
+
+[package.dependencies]
+astroid = ">=2.11.6,<=2.12.0-dev0"
+colorama = {version = ">=0.4.5", markers = "sys_platform == \"win32\""}
+dill = ">=0.2"
+isort = ">=4.2.5,<6"
+mccabe = ">=0.6,<0.8"
+platformdirs = ">=2.2.0"
+tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""}
+tomlkit = ">=0.10.1"
+typing-extensions = {version = ">=3.10.0", markers = "python_version < \"3.10\""}
+
+[package.extras]
+spelling = ["pyenchant (>=3.2,<4.0)"]
+testutils = ["gitpython (>3)"]
+
 [[package]]
 name = "pyparsing"
 version = "3.0.9"
@@ -428,6 +513,14 @@ category = "dev"
 optional = false
 python-versions = ">=3.7"

+[[package]]
+name = "tomlkit"
+version = "0.11.1"
+description = "Style preserving TOML library"
+category = "dev"
+optional = false
+python-versions = ">=3.6,<4.0"
+
 [[package]]
 name = "typed-ast"
 version = "1.5.4"
@@ -508,14 +601,15 @@ testing = ["pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-flake8", "pytest-

 [metadata]
 lock-version = "1.1"
-python-versions = ">=3.7.0, <4.0"
-content-hash = "027e0ce91c7e3dfbee0a5c1eea4204267ba3d5ec7df98df81ae3828691c36d7d"
+python-versions = ">=3.7.2, <4.0"
+content-hash = "a5b670e88908a75e6b410d426ab43cc0034023712b27cf83a966502d3ab52f8e"

 [metadata.files]
 appdirs = [
    {file = "appdirs-1.4.4-py2.py3-none-any.whl", hash = "sha256:a841dacd6b99318a741b166adb07e19ee71a274450e68237b4650ca1055ab128"},
    {file = "appdirs-1.4.4.tar.gz", hash = "sha256:7d5d0167b2b1ba821647616af46a749d1c653740dd0d2415100fe26e27afdf41"},
 ]
+astroid = []
 asttokens = [
    {file = "asttokens-2.0.5-py2.py3-none-any.whl", hash = "sha256:0844691e88552595a6f4a4281a9f7f79b8dd45ca4ccea82e5e05b4bbdb76705c"},
    {file = "asttokens-2.0.5.tar.gz", hash = "sha256:9a54c114f02c7a9480d56550932546a3f1fe71d8a02f1bc7ccd0ee3ee35cf4d5"},
@@ -528,6 +622,7 @@ attrs = [
    {file = "attrs-21.4.0-py2.py3-none-any.whl", hash = "sha256:2d27e3784d7a565d36ab851fe94887c5eccd6a463168875832a1be79c82828b4"},
    {file = "attrs-21.4.0.tar.gz", hash = "sha256:626ba8234211db98e869df76230a137c4c40a12d72445c45d5f5b716f076e2fd"},
 ]
+backoff = []
 black = [
    {file = "black-20.8b1.tar.gz", hash = "sha256:1c02557aa099101b9d21496f8a914e9ed2222ef70336404eeeac8edba836fbea"},
 ]
@@ -547,49 +642,7 @@ colorama = [
    {file = "colorama-0.4.5-py2.py3-none-any.whl", hash = "sha256:854bf444933e37f5824ae7bfc1e98d5bce2ebe4160d46b5edf346a89358e99da"},
    {file = "colorama-0.4.5.tar.gz", hash = "sha256:e6c6b4334fc50988a639d9b98aa429a0b57da6e17b9a44f0451f930b6967b7a4"},
 ]
-coverage = [
-    {file = "coverage-6.4.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:f1d5aa2703e1dab4ae6cf416eb0095304f49d004c39e9db1d86f57924f43006b"},
-    {file = "coverage-6.4.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4ce1b258493cbf8aec43e9b50d89982346b98e9ffdfaae8ae5793bc112fb0068"},
-    {file = "coverage-6.4.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:83c4e737f60c6936460c5be330d296dd5b48b3963f48634c53b3f7deb0f34ec4"},
-    {file = "coverage-6.4.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:84e65ef149028516c6d64461b95a8dbcfce95cfd5b9eb634320596173332ea84"},
-    {file = "coverage-6.4.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f69718750eaae75efe506406c490d6fc5a6161d047206cc63ce25527e8a3adad"},
-    {file = "coverage-6.4.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:e57816f8ffe46b1df8f12e1b348f06d164fd5219beba7d9433ba79608ef011cc"},
-    {file = "coverage-6.4.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:01c5615d13f3dd3aa8543afc069e5319cfa0c7d712f6e04b920431e5c564a749"},
-    {file = "coverage-6.4.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:75ab269400706fab15981fd4bd5080c56bd5cc07c3bccb86aab5e1d5a88dc8f4"},
-    {file = "coverage-6.4.1-cp310-cp310-win32.whl", hash = "sha256:a7f3049243783df2e6cc6deafc49ea123522b59f464831476d3d1448e30d72df"},
-    {file = "coverage-6.4.1-cp310-cp310-win_amd64.whl", hash = "sha256:ee2ddcac99b2d2aec413e36d7a429ae9ebcadf912946b13ffa88e7d4c9b712d6"},
-    {file = "coverage-6.4.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:fb73e0011b8793c053bfa85e53129ba5f0250fdc0392c1591fd35d915ec75c46"},
-    {file = "coverage-6.4.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:106c16dfe494de3193ec55cac9640dd039b66e196e4641fa8ac396181578b982"},
-    {file = "coverage-6.4.1-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:87f4f3df85aa39da00fd3ec4b5abeb7407e82b68c7c5ad181308b0e2526da5d4"},
-    {file = "coverage-6.4.1-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:961e2fb0680b4f5ad63234e0bf55dfb90d302740ae9c7ed0120677a94a1590cb"},
-    {file = "coverage-6.4.1-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:cec3a0f75c8f1031825e19cd86ee787e87cf03e4fd2865c79c057092e69e3a3b"},
-    {file = "coverage-6.4.1-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:129cd05ba6f0d08a766d942a9ed4b29283aff7b2cccf5b7ce279d50796860bb3"},
-    {file = "coverage-6.4.1-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:bf5601c33213d3cb19d17a796f8a14a9eaa5e87629a53979a5981e3e3ae166f6"},
-    {file = "coverage-6.4.1-cp37-cp37m-win32.whl", hash = "sha256:269eaa2c20a13a5bf17558d4dc91a8d078c4fa1872f25303dddcbba3a813085e"},
-    {file = "coverage-6.4.1-cp37-cp37m-win_amd64.whl", hash = "sha256:f02cbbf8119db68455b9d763f2f8737bb7db7e43720afa07d8eb1604e5c5ae28"},
-    {file = "coverage-6.4.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:ffa9297c3a453fba4717d06df579af42ab9a28022444cae7fa605af4df612d54"},
-    {file = "coverage-6.4.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:145f296d00441ca703a659e8f3eb48ae39fb083baba2d7ce4482fb2723e050d9"},
-    {file = "coverage-6.4.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d67d44996140af8b84284e5e7d398e589574b376fb4de8ccd28d82ad8e3bea13"},
-    {file = "coverage-6.4.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2bd9a6fc18aab8d2e18f89b7ff91c0f34ff4d5e0ba0b33e989b3cd4194c81fd9"},
-    {file = "coverage-6.4.1-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3384f2a3652cef289e38100f2d037956194a837221edd520a7ee5b42d00cc605"},
-    {file = "coverage-6.4.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:9b3e07152b4563722be523e8cd0b209e0d1a373022cfbde395ebb6575bf6790d"},
-    {file = "coverage-6.4.1-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:1480ff858b4113db2718848d7b2d1b75bc79895a9c22e76a221b9d8d62496428"},
-    {file = "coverage-6.4.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:865d69ae811a392f4d06bde506d531f6a28a00af36f5c8649684a9e5e4a85c83"},
-    {file = "coverage-6.4.1-cp38-cp38-win32.whl", hash = "sha256:664a47ce62fe4bef9e2d2c430306e1428ecea207ffd68649e3b942fa8ea83b0b"},
-    {file = "coverage-6.4.1-cp38-cp38-win_amd64.whl", hash = "sha256:26dff09fb0d82693ba9e6231248641d60ba606150d02ed45110f9ec26404ed1c"},
-    {file = "coverage-6.4.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:d9c80df769f5ec05ad21ea34be7458d1dc51ff1fb4b2219e77fe24edf462d6df"},
-    {file = "coverage-6.4.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:39ee53946bf009788108b4dd2894bf1349b4e0ca18c2016ffa7d26ce46b8f10d"},
-    {file = "coverage-6.4.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f5b66caa62922531059bc5ac04f836860412f7f88d38a476eda0a6f11d4724f4"},
-    {file = "coverage-6.4.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fd180ed867e289964404051a958f7cccabdeed423f91a899829264bb7974d3d3"},
-    {file = "coverage-6.4.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:84631e81dd053e8a0d4967cedab6db94345f1c36107c71698f746cb2636c63e3"},
-    {file = "coverage-6.4.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:8c08da0bd238f2970230c2a0d28ff0e99961598cb2e810245d7fc5afcf1254e8"},
-    {file = "coverage-6.4.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:d42c549a8f41dc103a8004b9f0c433e2086add8a719da00e246e17cbe4056f72"},
-    {file = "coverage-6.4.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:309ce4a522ed5fca432af4ebe0f32b21d6d7ccbb0f5fcc99290e71feba67c264"},
-    {file = "coverage-6.4.1-cp39-cp39-win32.whl", hash = "sha256:fdb6f7bd51c2d1714cea40718f6149ad9be6a2ee7d93b19e9f00934c0f2a74d9"},
-    {file = "coverage-6.4.1-cp39-cp39-win_amd64.whl", hash = "sha256:342d4aefd1c3e7f620a13f4fe563154d808b69cccef415415aece4c786665397"},
-    {file = "coverage-6.4.1-pp36.pp37.pp38-none-any.whl", hash = "sha256:4803e7ccf93230accb928f3a68f00ffa80a88213af98ed338a57ad021ef06815"},
-    {file = "coverage-6.4.1.tar.gz", hash = "sha256:4321f075095a096e70aff1d002030ee612b65a205a0a0f5b815280d5dc58100c"},
-]
+coverage = []
 deprecated = [
    {file = "Deprecated-1.2.13-py2.py3-none-any.whl", hash = "sha256:64756e3e14c8c5eea9795d93c524551432a0be75629f8f29e67ab8caf076c76d"},
    {file = "Deprecated-1.2.13.tar.gz", hash = "sha256:43ac5335da90c31c24ba028af536a91d41d53f9e6901ddb021bcc572ce44e38d"},
@@ -598,14 +651,15 @@ devtools = [
    {file = "devtools-0.8.0-py3-none-any.whl", hash = "sha256:00717ef184223cf36c65bbd17c6eb412f8a7564f47957f9e8b2b7610661b17fb"},
    {file = "devtools-0.8.0.tar.gz", hash = "sha256:6162a2f61c70242479dff3163e7837e6a9bf32451661af1347bfa3115602af16"},
 ]
+dill = [
+    {file = "dill-0.3.5.1-py2.py3-none-any.whl", hash = "sha256:33501d03270bbe410c72639b350e941882a8b0fd55357580fbc873fba0c59302"},
+    {file = "dill-0.3.5.1.tar.gz", hash = "sha256:d75e41f3eff1eee599d738e76ba8f4ad98ea229db8b085318aa2b3333a208c86"},
+]
 executing = [
    {file = "executing-0.8.3-py2.py3-none-any.whl", hash = "sha256:d1eef132db1b83649a3905ca6dd8897f71ac6f8cac79a7e58a1a09cf137546c9"},
    {file = "executing-0.8.3.tar.gz", hash = "sha256:c6554e21c6b060590a6d3be4b82fb78f8f0194d809de5ea7df1c093763311501"},
 ]
-gql = [
-    {file = "gql-3.3.0-py2.py3-none-any.whl", hash = "sha256:77fbc0a47c2df4edb8a98afa8c9c23aead5e0b4ab26d424e2dcfeb3fa2a2319d"},
-    {file = "gql-3.3.0.tar.gz", hash = "sha256:efa405aebe0e7b2fe342b43cfc70fd57e2e385fcae04f79c509366ad48a64381"},
-]
+gql = []
 graphql-core = [
    {file = "graphql-core-3.2.1.tar.gz", hash = "sha256:9d1bf141427b7d54be944587c8349df791ce60ade2e3cccaf9c56368c133c201"},
    {file = "graphql_core-3.2.1-py3-none-any.whl", hash = "sha256:f83c658e4968998eed1923a2e3e3eddd347e005ac0315fbb7ca4d70ea9156323"},
@@ -626,6 +680,49 @@ isort = [
    {file = "isort-5.10.1-py3-none-any.whl", hash = "sha256:6f62d78e2f89b4500b080fe3a81690850cd254227f27f75c3a0c491a1f351ba7"},
    {file = "isort-5.10.1.tar.gz", hash = "sha256:e8443a5e7a020e9d7f97f1d7d9cd17c88bcb3bc7e218bf9cf5095fe550be2951"},
 ]
+lazy-object-proxy = [
+    {file = "lazy-object-proxy-1.7.1.tar.gz", hash = "sha256:d609c75b986def706743cdebe5e47553f4a5a1da9c5ff66d76013ef396b5a8a4"},
+    {file = "lazy_object_proxy-1.7.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:bb8c5fd1684d60a9902c60ebe276da1f2281a318ca16c1d0a96db28f62e9166b"},
+    {file = "lazy_object_proxy-1.7.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a57d51ed2997e97f3b8e3500c984db50a554bb5db56c50b5dab1b41339b37e36"},
+    {file = "lazy_object_proxy-1.7.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd45683c3caddf83abbb1249b653a266e7069a09f486daa8863fb0e7496a9fdb"},
+    {file = "lazy_object_proxy-1.7.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:8561da8b3dd22d696244d6d0d5330618c993a215070f473b699e00cf1f3f6443"},
+    {file = "lazy_object_proxy-1.7.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fccdf7c2c5821a8cbd0a9440a456f5050492f2270bd54e94360cac663398739b"},
+    {file = "lazy_object_proxy-1.7.1-cp310-cp310-win32.whl", hash = "sha256:898322f8d078f2654d275124a8dd19b079080ae977033b713f677afcfc88e2b9"},
+    {file = "lazy_object_proxy-1.7.1-cp310-cp310-win_amd64.whl", hash = "sha256:85b232e791f2229a4f55840ed54706110c80c0a210d076eee093f2b2e33e1bfd"},
+    {file = "lazy_object_proxy-1.7.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:46ff647e76f106bb444b4533bb4153c7370cdf52efc62ccfc1a28bdb3cc95442"},
+    {file = "lazy_object_proxy-1.7.1-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:12f3bb77efe1367b2515f8cb4790a11cffae889148ad33adad07b9b55e0ab22c"},
+    {file = "lazy_object_proxy-1.7.1-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c19814163728941bb871240d45c4c30d33b8a2e85972c44d4e63dd7107faba44"},
+    {file = "lazy_object_proxy-1.7.1-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:e40f2013d96d30217a51eeb1db28c9ac41e9d0ee915ef9d00da639c5b63f01a1"},
+    {file = "lazy_object_proxy-1.7.1-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:2052837718516a94940867e16b1bb10edb069ab475c3ad84fd1e1a6dd2c0fcfc"},
+    {file = "lazy_object_proxy-1.7.1-cp36-cp36m-win32.whl", hash = "sha256:6a24357267aa976abab660b1d47a34aaf07259a0c3859a34e536f1ee6e76b5bb"},
+    {file = "lazy_object_proxy-1.7.1-cp36-cp36m-win_amd64.whl", hash = "sha256:6aff3fe5de0831867092e017cf67e2750c6a1c7d88d84d2481bd84a2e019ec35"},
+    {file = "lazy_object_proxy-1.7.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:6a6e94c7b02641d1311228a102607ecd576f70734dc3d5e22610111aeacba8a0"},
+    {file = "lazy_object_proxy-1.7.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c4ce15276a1a14549d7e81c243b887293904ad2d94ad767f42df91e75fd7b5b6"},
+    {file = "lazy_object_proxy-1.7.1-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e368b7f7eac182a59ff1f81d5f3802161932a41dc1b1cc45c1f757dc876b5d2c"},
+    {file = "lazy_object_proxy-1.7.1-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:6ecbb350991d6434e1388bee761ece3260e5228952b1f0c46ffc800eb313ff42"},
+    {file = "lazy_object_proxy-1.7.1-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:553b0f0d8dbf21890dd66edd771f9b1b5f51bd912fa5f26de4449bfc5af5e029"},
+    {file = "lazy_object_proxy-1.7.1-cp37-cp37m-win32.whl", hash = "sha256:c7a683c37a8a24f6428c28c561c80d5f4fd316ddcf0c7cab999b15ab3f5c5c69"},
+    {file = "lazy_object_proxy-1.7.1-cp37-cp37m-win_amd64.whl", hash = "sha256:df2631f9d67259dc9620d831384ed7732a198eb434eadf69aea95ad18c587a28"},
+    {file = "lazy_object_proxy-1.7.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:07fa44286cda977bd4803b656ffc1c9b7e3bc7dff7d34263446aec8f8c96f88a"},
+    {file = "lazy_object_proxy-1.7.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4dca6244e4121c74cc20542c2ca39e5c4a5027c81d112bfb893cf0790f96f57e"},
+    {file = "lazy_object_proxy-1.7.1-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:91ba172fc5b03978764d1df5144b4ba4ab13290d7bab7a50f12d8117f8630c38"},
+    {file = "lazy_object_proxy-1.7.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:043651b6cb706eee4f91854da4a089816a6606c1428fd391573ef8cb642ae4f7"},
+    {file = "lazy_object_proxy-1.7.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:b9e89b87c707dd769c4ea91f7a31538888aad05c116a59820f28d59b3ebfe25a"},
+    {file = "lazy_object_proxy-1.7.1-cp38-cp38-win32.whl", hash = "sha256:9d166602b525bf54ac994cf833c385bfcc341b364e3ee71e3bf5a1336e677b55"},
+    {file = "lazy_object_proxy-1.7.1-cp38-cp38-win_amd64.whl", hash = "sha256:8f3953eb575b45480db6568306893f0bd9d8dfeeebd46812aa09ca9579595148"},
+    {file = "lazy_object_proxy-1.7.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:dd7ed7429dbb6c494aa9bc4e09d94b778a3579be699f9d67da7e6804c422d3de"},
+    {file = "lazy_object_proxy-1.7.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:70ed0c2b380eb6248abdef3cd425fc52f0abd92d2b07ce26359fcbc399f636ad"},
+    {file = "lazy_object_proxy-1.7.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7096a5e0c1115ec82641afbdd70451a144558ea5cf564a896294e346eb611be1"},
+    {file = "lazy_object_proxy-1.7.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:f769457a639403073968d118bc70110e7dce294688009f5c24ab78800ae56dc8"},
+    {file = "lazy_object_proxy-1.7.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:39b0e26725c5023757fc1ab2a89ef9d7ab23b84f9251e28f9cc114d5b59c1b09"},
+    {file = "lazy_object_proxy-1.7.1-cp39-cp39-win32.whl", hash = "sha256:2130db8ed69a48a3440103d4a520b89d8a9405f1b06e2cc81640509e8bf6548f"},
+    {file = "lazy_object_proxy-1.7.1-cp39-cp39-win_amd64.whl", hash = "sha256:677ea950bef409b47e51e733283544ac3d660b709cfce7b187f5ace137960d61"},
+    {file = "lazy_object_proxy-1.7.1-pp37.pp38-none-any.whl", hash = "sha256:d66906d5785da8e0be7360912e99c9188b70f52c422f9fc18223347235691a84"},
+]
+mccabe = [
+    {file = "mccabe-0.7.0-py2.py3-none-any.whl", hash = "sha256:6c2d30ab6be0e4a46919781807b4f0d834ebdd6c6e3dca0bda5a15f863427b6e"},
+    {file = "mccabe-0.7.0.tar.gz", hash = "sha256:348e0240c33b60bbdf4e523192ef919f28cb2c3d7d5c7794f74009290f236325"},
+]
 multidict = [
    {file = "multidict-6.0.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:0b9e95a740109c6047602f4db4da9949e6c5945cefbad34a1299775ddc9a62e2"},
    {file = "multidict-6.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ac0e27844758d7177989ce406acc6a83c16ed4524ebc363c1f748cba184d89d3"},
@@ -699,6 +796,10 @@ pathspec = [
    {file = "pathspec-0.9.0-py2.py3-none-any.whl", hash = "sha256:7d15c4ddb0b5c802d161efc417ec1a2558ea2653c2e8ad9c19098201dc1c993a"},
    {file = "pathspec-0.9.0.tar.gz", hash = "sha256:e564499435a2673d586f6b2130bb5b95f04a3ba06f81b8f895b651a3c76aabb1"},
 ]
+platformdirs = [
+    {file = "platformdirs-2.5.2-py3-none-any.whl", hash = "sha256:027d8e83a2d7de06bbac4e5ef7e023c02b863d7ea5d079477e722bb41ab25788"},
+    {file = "platformdirs-2.5.2.tar.gz", hash = "sha256:58c8abb07dcb441e6ee4b11d8df0ac856038f944ab98b7be6b27b2a3c7feef19"},
+]
 pluggy = [
    {file = "pluggy-1.0.0-py2.py3-none-any.whl", hash = "sha256:74134bbf457f031a36d68416e1509f34bd5ccc019f0bcc952c7b909d06b37bd3"},
    {file = "pluggy-1.0.0.tar.gz", hash = "sha256:4224373bacce55f955a878bf9cfa763c1e360858e330072059e10bad68531159"},
@@ -744,6 +845,7 @@ pydantic = [
    {file = "pydantic-1.9.1-py3-none-any.whl", hash = "sha256:4988c0f13c42bfa9ddd2fe2f569c9d54646ce84adc5de84228cfe83396f3bd58"},
    {file = "pydantic-1.9.1.tar.gz", hash = "sha256:1ed987c3ff29fff7fd8c3ea3a3ea877ad310aae2ef9889a119e22d3f2db0691a"},
 ]
+pylint = []
 pyparsing = [
    {file = "pyparsing-3.0.9-py3-none-any.whl", hash = "sha256:5026bae9a10eeaefb61dab2f09052b9f4307d44aee4eda64b309723d8d206bbc"},
    {file = "pyparsing-3.0.9.tar.gz", hash = "sha256:2b020ecf7d21b687f219b71ecad3631f644a47f01403fa1d1036b0c6416d70fb"},
@@ -857,6 +959,7 @@ tomli = [
    {file = "tomli-2.0.1-py3-none-any.whl", hash = "sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc"},
    {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"},
 ]
+tomlkit = []
 typed-ast = [
    {file = "typed_ast-1.5.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:669dd0c4167f6f2cd9f57041e03c3c2ebf9063d0757dc89f79ba1daa2bfca9d4"},
    {file = "typed_ast-1.5.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:211260621ab1cd7324e0798d6be953d00b74e0428382991adfddb352252f1d62"},
@@ -11,7 +11,7 @@ homepage = "https://speckle.systems/"


 [tool.poetry.dependencies]
-python = ">=3.7.0, <4.0"
+python = ">=3.7.2, <4.0"
 pydantic = "^1.8.2"
 appdirs = "^1.4.4"
 gql = {extras = ["requests", "websockets"], version = "^3.3.0"}
@@ -25,6 +25,7 @@ pytest = "^6.2.2"
 pytest-ordering = "^0.6"
 pytest-cov = "^3.0.0"
 devtools = "^0.8.0"
+pylint = "^2.14.4"


 [tool.black]
@@ -44,7 +45,7 @@ exclude = '''
 '''
 include = '\.pyi?$'
 line-length = 88
-target-version = ["py36", "py37", "py38"]
+target-version = ["py37", "py38", "py39", "py310"]


 [build-system]
@@ -160,9 +160,26 @@ class SpeckleClient:
        return self.httpclient.execute(query)

    def _init_resources(self) -> None:
-        self.stream = stream.Resource(
+        self.server = server.Resource(
            account=self.account, basepath=self.url, client=self.httpclient
        )
+        server_version = None
+        try:
+            server_version = self.server.version()
+        except:
+            pass
+        self.user = user.Resource(
+            account=self.account,
+            basepath=self.url,
+            client=self.httpclient,
+            server_version=server_version,
+        )
+        self.stream = stream.Resource(
+            account=self.account,
+            basepath=self.url,
+            client=self.httpclient,
+            server_version=server_version,
+        )
        self.commit = commit.Resource(
            account=self.account, basepath=self.url, client=self.httpclient
        )
@@ -172,12 +189,6 @@ class SpeckleClient:
        self.object = object.Resource(
            account=self.account, basepath=self.url, client=self.httpclient
        )
-        self.server = server.Resource(
-            account=self.account, basepath=self.url, client=self.httpclient
-        )
-        self.user = user.Resource(
-            account=self.account, basepath=self.url, client=self.httpclient
-        )
        self.subscribe = subscriptions.Resource(
            account=self.account,
            basepath=self.ws_url,
@@ -1,5 +1,5 @@
 import os
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field  # pylint: disable=no-name-in-module
 from typing import List, Optional
 from specklepy.logging import metrics
 from specklepy.api.models import ServerInfo
@@ -16,11 +16,11 @@ class UserInfo(BaseModel):

 class Account(BaseModel):
    isDefault: bool = False
-    token: str = None
-    refreshToken: str = None
+    token: Optional[str] = None
+    refreshToken: Optional[str] = None
    serverInfo: ServerInfo = Field(default_factory=ServerInfo)
    userInfo: UserInfo = Field(default_factory=UserInfo)
-    id: str = None
+    id: Optional[str] = None

    def __repr__(self) -> str:
        return f"Account(email: {self.userInfo.email}, server: {self.serverInfo.url}, isDefault: {self.isDefault})"
@@ -45,12 +45,15 @@ def get_local_accounts(base_path: str = None) -> List[Account]:
        List[Account] -- list of all local accounts or an empty list if no accounts were found
    """
    account_storage = SQLiteTransport(scope="Accounts", base_path=base_path)
+    # pylint: disable=protected-access
    json_path = os.path.join(account_storage._base_path, "Accounts")
    os.makedirs(json_path, exist_ok=True)
    json_acct_files = [file for file in os.listdir(json_path) if file.endswith(".json")]

-    accounts = []
+    accounts: List[Account] = []
    res = account_storage.get_all_objects()
+    account_storage.close()
+
    if res:
        accounts.extend(Account.parse_raw(r[1]) for r in res)
    if json_acct_files:
@@ -63,7 +66,8 @@ def get_local_accounts(base_path: str = None) -> List[Account]:
            raise SpeckleException(
                "Invalid json accounts could not be read. Please fix or remove them.",
                ex,
-            )
+            ) from ex
+
    metrics.track(
        metrics.ACCOUNTS,
        next(
@@ -3,10 +3,10 @@
 #   timestamp: 2020-11-17T14:33:13+00:00

 from datetime import datetime
-from typing import Any, Dict, List, Optional
+from typing import List, Optional


-from pydantic import BaseModel
+from pydantic import BaseModel  # pylint: disable=no-name-in-module


 class Collaborator(BaseModel):
@@ -110,6 +110,24 @@ class User(BaseModel):
        return self.__repr__()


+class PendingStreamCollaborator(BaseModel):
+    id: Optional[str]
+    inviteId: Optional[str]
+    streamId: Optional[str]
+    streamName: Optional[str]
+    title: Optional[str]
+    role: Optional[str]
+    invitedBy: Optional[User]
+    user: Optional[User]
+    token: Optional[str]
+
+    def __repr__(self):
+        return f"PendingStreamCollaborator( inviteId: {self.inviteId}, streamId: {self.streamId}, role: {self.role}, title: {self.title}, invitedBy: {self.user.name if self.user else None})"
+
+    def __str__(self) -> str:
+        return self.__repr__()
+
+
 class Activity(BaseModel):
    actionType: Optional[str]
    info: Optional[dict]
@@ -133,7 +151,7 @@ class ActivityCollection(BaseModel):
    cursor: Optional[datetime]

    def __repr__(self) -> str:
-        return f"ActivityCollection( totalCount: {self.totalCount}, items: {len(self.items) if self.items else 0}, cursor: {self.cursor.isoformat()} )"
+        return f"ActivityCollection( totalCount: {self.totalCount}, items: {len(self.items) if self.items else 0}, cursor: {self.cursor.isoformat() if self.cursor else None} )"

    def __str__(self) -> str:
        return self.__repr__()
@@ -29,6 +29,9 @@ def send(
            message="You need to provide at least one transport: cannot send with an empty transport list and no default cache"
        )

+    if isinstance(transports, AbstractTransport):
+        transports = [transports]
+
    if transports is None:
        metrics.track(metrics.SEND)
        transports = []
@@ -1,10 +1,14 @@
+from graphql import DocumentNode
 from specklepy.api.credentials import Account
 from specklepy.transports.sqlite import SQLiteTransport
-from typing import Dict, List
+from typing import Any, Dict, List, Optional, Tuple, Type, Union
 from gql.client import Client
-from gql.gql import gql
 from gql.transport.exceptions import TransportQueryError
-from specklepy.logging.exceptions import GraphQLException, SpeckleException
+from specklepy.logging.exceptions import (
+    GraphQLException,
+    SpeckleException,
+    UnsupportedException,
+)
 from specklepy.serialization.base_object_serializer import BaseObjectSerializer


@@ -15,28 +19,30 @@ class ResourceBase(object):
        basepath: str,
        client: Client,
        name: str,
-        methods: list,
+        server_version: Optional[Tuple[Any, ...]] = None,
    ) -> None:
        self.account = account
        self.basepath = basepath
        self.client = client
        self.name = name
-        self.methods = methods
-        self.schema = None
+        self.server_version = server_version
+        self.schema: Optional[Type] = None

-    def _step_into_response(self, response: dict, return_type: str or List):
+    def _step_into_response(self, response: dict, return_type: Union[str, List, None]):
        """Step into the dict to get the relevant data"""
        if return_type is None:
            return response
-        elif isinstance(return_type, str):
+        if isinstance(return_type, str):
            return response[return_type]
-        elif isinstance(return_type, List):
+        if isinstance(return_type, List):
            for key in return_type:
                response = response[key]
            return response

-    def _parse_response(self, response: dict or list, schema=None):
+    def _parse_response(self, response: Union[dict, list, None], schema=None):
        """Try to create a class instance from the response"""
+        if response is None:
+            return None
        if isinstance(response, list):
            return [self._parse_response(response=r, schema=schema) for r in response]
        if schema:
@@ -52,26 +58,26 @@ class ResourceBase(object):

    def make_request(
        self,
-        query: gql,
+        query: DocumentNode,
        params: Dict = None,
-        return_type: str or List = None,
+        return_type: Union[str, List, None] = None,
        schema=None,
        parse_response: bool = True,
-    ) -> Dict or GraphQLException:
+    ) -> Any:
        """Executes the GraphQL query"""
        try:
            response = self.client.execute(query, variable_values=params)
-        except Exception as e:
-            if isinstance(e, TransportQueryError):
+        except Exception as ex:
+            if isinstance(ex, TransportQueryError):
                return GraphQLException(
-                    message=f"Failed to execute the GraphQL {self.name} request. Errors: {e.errors}",
-                    errors=e.errors,
-                    data=e.data,
+                    message=f"Failed to execute the GraphQL {self.name} request. Errors: {ex.errors}",
+                    errors=ex.errors,
+                    data=ex.data,
                )
            else:
                return SpeckleException(
-                    message=f"Failed to execute the GraphQL {self.name} request. Inner exception: {e}",
-                    exception=e,
+                    message=f"Failed to execute the GraphQL {self.name} request. Inner exception: {ex}",
+                    exception=ex,
                )

        response = self._step_into_response(response=response, return_type=return_type)
@@ -80,3 +86,29 @@ class ResourceBase(object):
            return self._parse_response(response=response, schema=schema)
        else:
            return response
+
+    def _check_server_version_at_least(
+        self, target_version: Tuple[Any, ...], unsupported_message: str = None
+    ):
+        """Use this check to guard against making unsupported requests on older servers.
+
+        Arguments:
+            target_version {tuple} -- the minimum server version in the format (major, minor, patch, (tag, build))
+                                      eg (2, 6, 3) for a stable build and (2, 6, 4, 'alpha', 4711) for alpha
+        """
+        if not unsupported_message:
+            unsupported_message = f"The client method used is not supported on Speckle Server versios prior to v{'.'.join(target_version)}"
+        if self.server_version and self.server_version < target_version:
+            raise UnsupportedException(unsupported_message)
+
+    def _check_invites_supported(self):
+        """Invites are only supported for Speckle Server >= 2.6.4.
+        Use this check to guard against making unsupported requests on older servers.
+        """
+        self._check_server_version_at_least(
+            (2, 6, 4),
+            (
+                "Stream invites are only supported as of Speckle Server v2.6.4. "
+                "Please update your Speckle Server to use this method or use the `grant_permission` flow instead."
+            ),
+        )
@@ -1,6 +1,5 @@
 from pathlib import Path
 import sys
-import inspect
 import pkgutil
 from importlib import import_module

@@ -4,7 +4,6 @@ from specklepy.api.models import Branch
 from specklepy.logging import metrics

 NAME = "branch"
-METHODS = ["create"]


 class Resource(ResourceBase):
@@ -16,7 +15,6 @@ class Resource(ResourceBase):
            basepath=basepath,
            client=client,
            name=NAME,
-            methods=METHODS,
        )
        self.schema = Branch

@@ -6,7 +6,6 @@ from specklepy.logging import metrics


 NAME = "commit"
-METHODS = []


 class Resource(ResourceBase):
@@ -18,7 +17,6 @@ class Resource(ResourceBase):
            basepath=basepath,
            client=client,
            name=NAME,
-            methods=METHODS,
        )
        self.schema = Commit

@@ -4,7 +4,6 @@ from specklepy.api.resource import ResourceBase
 from specklepy.objects.base import Base

 NAME = "object"
-METHODS = []


 class Resource(ResourceBase):
@@ -16,7 +15,6 @@ class Resource(ResourceBase):
            basepath=basepath,
            client=client,
            name=NAME,
-            methods=METHODS,
        )
        self.schema = Base

@@ -1,12 +1,13 @@
-from typing import Dict, List
+import re
+from typing import Any, Dict, List, Tuple
 from gql import gql
 from specklepy.api.models import ServerInfo
 from specklepy.api.resource import ResourceBase
 from specklepy.logging import metrics
+from specklepy.logging.exceptions import GraphQLException


 NAME = "server"
-METHODS = ["get", "apps"]


 class Resource(ResourceBase):
@@ -18,7 +19,6 @@ class Resource(ResourceBase):
            basepath=basepath,
            client=client,
            name=NAME,
-            methods=METHODS,
        )

    def get(self) -> ServerInfo:
@@ -61,6 +61,39 @@ class Resource(ResourceBase):
            query=query, return_type="serverInfo", schema=ServerInfo
        )

+    def version(self) -> Tuple[Any, ...]:
+        """Get the server version
+
+        Returns:
+            tuple -- the server version in the format (major, minor, patch, (tag, build))
+                     eg (2, 6, 3) for a stable build and (2, 6, 4, 'alpha', 4711) for alpha
+        """
+        # not tracking as it will be called along with other mutations / queries as a check
+        query = gql(
+            """
+            query Server {
+                serverInfo {
+                    version
+                }
+            }
+            """
+        )
+        ver = self.make_request(
+            query=query, return_type=["serverInfo", "version"], parse_response=False
+        )
+        if isinstance(ver, Exception):
+            raise GraphQLException(
+                f"Could not get server version for {self.basepath}", [ver]
+            )
+
+        # pylint: disable=consider-using-generator; (list comp is faster)
+        return tuple(
+            [
+                int(segment) if segment.isdigit() else segment
+                for segment in re.split(r"\.|-", ver)
+            ]
+        )
+
    def apps(self) -> Dict:
        """Get the apps registered on the server

@@ -1,26 +1,26 @@
 from datetime import datetime, timezone
+from typing import List, Optional
+from deprecated import deprecated
 from gql import gql
-from typing import List
 from specklepy.logging import metrics
-from specklepy.api.models import ActivityCollection, Stream
+from specklepy.api.models import ActivityCollection, PendingStreamCollaborator, Stream
 from specklepy.api.resource import ResourceBase
-from specklepy.logging.exceptions import SpeckleException
+from specklepy.logging.exceptions import UnsupportedException, SpeckleException


 NAME = "stream"
-METHODS = ["list", "create", "get", "update", "delete", "search", "activity"]


 class Resource(ResourceBase):
    """API Access class for streams"""

-    def __init__(self, account, basepath, client) -> None:
+    def __init__(self, account, basepath, client, server_version) -> None:
        super().__init__(
            account=account,
            basepath=basepath,
            client=client,
            name=NAME,
-            methods=METHODS,
+            server_version=server_version,
        )

        self.schema = Stream
@@ -342,9 +342,18 @@ class Resource(ResourceBase):
            query=query, params=params, return_type=["streamFavorite"]
        )

+    @deprecated(
+        version="2.6.4",
+        reason=(
+            "As of Speckle Server v2.6.4, this method is deprecated. "
+            "Users need to be invited and accept the invite before being added to a stream"
+        ),
+    )
    def grant_permission(self, stream_id: str, user_id: str, role: str):
        """Grant permissions to a user on a given stream

+        Valid for Speckle Server version < 2.6.4
+
        Arguments:
            stream_id {str} -- the id of the stream to grant permissions to
            user_id {str} -- the id of the user to grant permissions for
@@ -354,6 +363,15 @@ class Resource(ResourceBase):
            bool -- True if the operation was successful
        """
        metrics.track(metrics.PERMISSION, self.account, {"name": "add", "role": role})
+        if self.server_version and self.server_version >= (2, 6, 4):
+            raise UnsupportedException(
+                (
+                    "Server mutation `grant_permission` is no longer supported as of Speckle Server v2.6.4. "
+                    "Please use the new `update_permission` method to change an existing user's permission "
+                    "or use the `invite` method to invite a user to a stream."
+                )
+            )
+
        query = gql(
            """
            mutation StreamGrantPermission($permission_params: StreamGrantPermissionInput !) {
@@ -377,6 +395,282 @@ class Resource(ResourceBase):
            parse_response=False,
        )

+    def get_all_pending_invites(
+        self, stream_id: str
+    ) -> List[PendingStreamCollaborator]:
+        """Get all of the pending invites on a stream.
+        You must be a `stream:owner` to query this.
+
+        Requires Speckle Server version >= 2.6.4
+
+        Arguments:
+            stream_id {str} -- the stream id from which to get the pending invites
+
+        Returns:
+            List[PendingStreamCollaborator] -- a list of pending invites for the specified stream
+        """
+        metrics.track(metrics.INVITE, self.account, {"name": "get"})
+        self._check_invites_supported()
+
+        query = gql(
+            """
+            query StreamInvites($streamId: String!) {
+                stream(id: $streamId){
+                    pendingCollaborators {
+                        id
+                        token
+                        inviteId
+                        streamId
+                        streamName
+                        title
+                        role
+                        invitedBy{
+                            id
+                            name
+                            company
+                            avatar
+                        }
+                        user {
+                            id
+                            name
+                            company
+                            avatar
+                        }
+                    }
+                }
+            }
+            """
+        )
+        params = {"streamId": stream_id}
+
+        return self.make_request(
+            query=query,
+            params=params,
+            return_type=["stream", "pendingCollaborators"],
+            schema=PendingStreamCollaborator,
+        )
+
+    def invite(
+        self,
+        stream_id: str,
+        email: str = None,
+        user_id: str = None,
+        role: str = "stream:contributor",  # should default be reviewer?
+        message: str = None,
+    ):
+        """Invite someone to a stream using either their email or user id
+
+        Requires Speckle Server version >= 2.6.4
+
+        Arguments:
+            stream_id {str} -- the id of the stream to invite the user to
+            email {str} -- the email of the user to invite (use this OR `user_id`)
+            user_id {str} -- the id of the user to invite (use this OR `email`)
+            role {str} -- the role to assing to the user (defaults to `stream:contributor`)
+            message {str} -- a message to send along with this invite to the specified user
+
+        Returns:
+            bool -- True if the operation was successful
+        """
+        metrics.track(metrics.INVITE, self.account, {"name": "create"})
+        self._check_invites_supported()
+
+        if email is None and user_id is None:
+            raise SpeckleException(
+                "You must provide either an email or a user id to use the `stream.invite` method"
+            )
+
+        query = gql(
+            """
+            mutation StreamInviteCreate($input: StreamInviteCreateInput!) {
+                streamInviteCreate(input: $input)
+            }
+            """
+        )
+
+        params = {
+            "email": email,
+            "userId": user_id,
+            "streamId": stream_id,
+            "message": message,
+            "role": role,
+        }
+        params = {"input": {k: v for k, v in params.items() if v is not None}}
+
+        return self.make_request(
+            query=query,
+            params=params,
+            return_type="streamInviteCreate",
+            parse_response=False,
+        )
+
+    def invite_batch(
+        self,
+        stream_id: str,
+        emails: List[str] = None,
+        user_ids: List[None] = None,
+        message: str = None,
+    ) -> bool:
+        """Invite a batch of users to a specified stream.
+
+        Requires Speckle Server version >= 2.6.4
+
+        Arguments:
+            stream_id {str} -- the id of the stream to invite the user to
+            emails {List[str]} -- the email of the user to invite (use this and/or `user_ids`)
+            user_id {List[str]} -- the id of the user to invite (use this and/or `emails`)
+            message {str} -- a message to send along with this invite to the specified user
+
+        Returns:
+            bool -- True if the operation was successful
+        """
+        metrics.track(metrics.INVITE, self.account, {"name": "batch create"})
+        self._check_invites_supported()
+        if emails is None and user_ids is None:
+            raise SpeckleException(
+                "You must provide either an email or a user id to use the `stream.invite` method"
+            )
+
+        query = gql(
+            """
+            mutation StreamInviteBatchCreate($input: [StreamInviteCreateInput!]!) {
+                streamInviteBatchCreate(input: $input)
+            }
+            """
+        )
+
+        email_invites = [
+            {"streamId": stream_id, "message": message, "email": email}
+            for email in emails
+            if emails is not None
+        ]
+
+        user_invites = [
+            {"streamId": stream_id, "message": message, "userId": user_id}
+            for user_id in user_ids
+            if user_ids is not None
+        ]
+
+        params = {"input": [*email_invites, *user_invites]}
+
+        return self.make_request(
+            query=query,
+            params=params,
+            return_type="streamInviteBatchCreate",
+            parse_response=False,
+        )
+
+    def invite_cancel(self, stream_id: str, invite_id: str) -> bool:
+        """Cancel an existing stream invite
+
+        Requires Speckle Server version >= 2.6.4
+
+        Arguments:
+            stream_id {str} -- the id of the stream invite
+            invite_id {str} -- the id of the invite to use
+
+        Returns:
+            bool -- true if the operation was successful
+        """
+        metrics.track(metrics.INVITE, self.account, {"name": "cancel"})
+        self._check_invites_supported()
+
+        query = gql(
+            """
+            mutation StreamInviteCancel($streamId: String!, $inviteId: String!) {
+                streamInviteCancel(streamId: $streamId, inviteId: $inviteId)
+            }
+            """
+        )
+
+        params = {"streamId": stream_id, "inviteId": invite_id}
+
+        return self.make_request(
+            query=query,
+            params=params,
+            return_type="streamInviteCancel",
+            parse_response=False,
+        )
+
+    def invite_use(self, stream_id: str, token: str, accept: bool = True) -> bool:
+        """Accept or decline a stream invite
+
+        Requires Speckle Server version >= 2.6.4
+
+        Arguments:
+            stream_id {str} -- the id of the stream for which the user has a pending invite
+            token {str} -- the token of the invite to use
+            accept {bool} -- whether or not to accept the invite (defaults to True)
+
+        Returns:
+            bool -- true if the operation was successful
+        """
+        metrics.track(metrics.INVITE, self.account, {"name": "use"})
+        self._check_invites_supported()
+
+        query = gql(
+            """
+            mutation StreamInviteUse($accept: Boolean!, $streamId: String!, $token: String!) {
+                streamInviteUse(accept: $accept, streamId: $streamId, token: $token)
+            }
+            """
+        )
+
+        params = {"streamId": stream_id, "token": token, "accept": accept}
+
+        return self.make_request(
+            query=query,
+            params=params,
+            return_type="streamInviteUse",
+            parse_response=False,
+        )
+
+    def update_permission(self, stream_id: str, user_id: str, role: str):
+        """Updates permissions for a user on a given stream
+
+        Valid for Speckle Server >=2.6.4
+
+        Arguments:
+            stream_id {str} -- the id of the stream to grant permissions to
+            user_id {str} -- the id of the user to grant permissions for
+            role {str} -- the role to grant the user
+
+        Returns:
+            bool -- True if the operation was successful
+        """
+        metrics.track(
+            metrics.PERMISSION, self.account, {"name": "update", "role": role}
+        )
+        if self.server_version and self.server_version < (2, 6, 4):
+            raise UnsupportedException(
+                (
+                    "Server mutation `update_permission` is only supported as of Speckle Server v2.6.4. "
+                    "Please update your Speckle Server to use this method or use the `grant_permission` method instead."
+                )
+            )
+        query = gql(
+            """
+            mutation StreamUpdatePermission($permission_params: StreamUpdatePermissionInput !) {
+                streamUpdatePermission(permissionParams: $permission_params)
+            }
+            """
+        )
+
+        params = {
+            "permission_params": {
+                "streamId": stream_id,
+                "userId": user_id,
+                "role": role,
+            }
+        }
+
+        return self.make_request(
+            query=query,
+            params=params,
+            return_type="streamUpdatePermission",
+            parse_response=False,
+        )
+
    def revoke_permission(self, stream_id: str, user_id: str):
        """Revoke permissions from a user on a given stream

@@ -1,16 +1,12 @@
-from typing import Callable, Dict, List
+from typing import Callable, Dict, List, Union
 from functools import wraps
 from gql import gql
+from graphql import DocumentNode
 from specklepy.api.resource import ResourceBase
 from specklepy.api.resources.stream import Stream
 from specklepy.logging.exceptions import SpeckleException

 NAME = "subscribe"
-METHODS = [
-    "stream_added",
-    "stream_updated",
-    "stream_removed",
-]


 def check_wsclient(function):
@@ -35,7 +31,6 @@ class Resource(ResourceBase):
            basepath=basepath,
            client=client,
            name=NAME,
-            methods=METHODS,
        )

    @check_wsclient
@@ -109,15 +104,15 @@ class Resource(ResourceBase):
    @check_wsclient
    async def subscribe(
        self,
-        query: gql,
+        query: DocumentNode,
        params: Dict = None,
        callback: Callable = None,
-        return_type: str or List = None,
+        return_type: Union[str, List] = None,
        schema=None,
        parse_response: bool = True,
    ):
        # if self.client.transport.websocket is None:
-        #     TODO: add multiple subs to the same ws connection
+        # TODO: add multiple subs to the same ws connection
        async with self.client as session:
            async for res in session.subscribe(query, variable_values=params):
                res = self._step_into_response(response=res, return_type=return_type)
@@ -1,25 +1,24 @@
+from typing import List, Optional, Union
 from datetime import datetime, timezone
+from gql import gql
 from specklepy.logging import metrics
 from specklepy.logging.exceptions import SpeckleException
-from typing import List
-from gql import gql
 from specklepy.api.resource import ResourceBase
-from specklepy.api.models import ActivityCollection, User
+from specklepy.api.models import ActivityCollection, PendingStreamCollaborator, User

 NAME = "user"
-METHODS = ["get", "search", "update", "activity"]


 class Resource(ResourceBase):
    """API Access class for users"""

-    def __init__(self, account, basepath, client) -> None:
+    def __init__(self, account, basepath, client, server_version) -> None:
        super().__init__(
            account=account,
            basepath=basepath,
            client=client,
            name=NAME,
-            methods=METHODS,
+            server_version=server_version,
        )
        self.schema = User

@@ -55,7 +54,9 @@ class Resource(ResourceBase):

        return self.make_request(query=query, params=params, return_type="user")

-    def search(self, search_query: str, limit: int = 25) -> List[User]:
+    def search(
+        self, search_query: str, limit: int = 25
+    ) -> Union[List[User], SpeckleException]:
        """Searches for user by name or email. The search query must be at least 3 characters long

        Arguments:
@@ -188,3 +189,92 @@ class Resource(ResourceBase):
            return_type=["user", "activity"],
            schema=ActivityCollection,
        )
+
+    def get_all_pending_invites(self) -> List[PendingStreamCollaborator]:
+        """Get all of the active user's pending stream invites
+
+        Requires Speckle Server version >= 2.6.4
+
+        Returns:
+            List[PendingStreamCollaborator] -- a list of pending invites for the current user
+        """
+        metrics.track(metrics.INVITE, self.account, {"name": "get"})
+        self._check_invites_supported()
+
+        query = gql(
+            """
+            query StreamInvites {
+                streamInvites{
+                    id
+                    token
+                    inviteId
+                    streamId
+                    streamName
+                    title
+                    role
+                    invitedBy {
+                        id
+                        name
+                        company
+                        avatar
+                    }
+                }
+            }
+            """
+        )
+
+        return self.make_request(
+            query=query,
+            return_type="streamInvites",
+            schema=PendingStreamCollaborator,
+        )
+
+    def get_pending_invite(
+        self, stream_id: str, token: str = None
+    ) -> Optional[PendingStreamCollaborator]:
+        """Get a particular pending invite for the active user on a given stream.
+        If no invite_id is provided, any valid invite will be returned.
+
+        Requires Speckle Server version >= 2.6.4
+
+        Arguments:
+            stream_id {str} -- the id of the stream to look for invites on
+            token {str} -- the token of the invite to look for (optional)
+
+        Returns:
+            PendingStreamCollaborator -- the invite for the given stream (or None if it isn't found)
+        """
+        metrics.track(metrics.INVITE, self.account, {"name": "get"})
+        self._check_invites_supported()
+
+        query = gql(
+            """
+            query StreamInvite($streamId: String!, $token: String) {
+                streamInvite(streamId: $streamId, token: $token) {
+                    id
+                    token
+                    streamId
+                    streamName
+                    title
+                    role
+                    invitedBy {
+                        id
+                        name
+                        company
+                        avatar
+                    }
+                }
+            }
+            """
+        )
+
+        params = {"streamId": stream_id}
+        if token:
+            params["token"] = token
+
+        return self.make_request(
+            query=query,
+            params=params,
+            return_type="streamInvite",
+            schema=PendingStreamCollaborator,
+        )
@@ -1,8 +1,9 @@
-from typing import Any, List
+from typing import Any, List, Optional


 class SpeckleException(Exception):
    def __init__(self, message: str, exception: Exception = None) -> None:
+        super().__init__()
        self.message = message
        self.exception = exception

@@ -11,17 +12,19 @@ class SpeckleException(Exception):


 class SerializationException(SpeckleException):
-    def __init__(self, message: str, object: Any, exception: Exception = None) -> None:
-        super().__init__(message=message)
-        self.object = object
-        self.unhandled_type = type(object)
+    def __init__(self, message: str, obj: Any, exception: Exception = None) -> None:
+        super().__init__(message=message, exception=exception)
+        self.obj = obj
+        self.unhandled_type = type(obj)

    def __str__(self) -> str:
        return f"SpeckleException: Could not serialize object of type {self.unhandled_type}"


 class GraphQLException(SpeckleException):
-    def __init__(self, message: str, errors: List, data=None) -> None:
+    def __init__(
+        self, message: str, errors: Optional[List[Any]] = None, data=None
+    ) -> None:
        super().__init__(message=message)
        self.errors = errors
        self.data = data
@@ -30,6 +33,14 @@ class GraphQLException(SpeckleException):
        return f"GraphQLException: {self.message}"


+class UnsupportedException(SpeckleException):
+    def __init__(self, message: str) -> None:
+        super().__init__(message=message)
+
+    def __str__(self) -> str:
+        return f"UnsupportedException: {self.message}"
+
+
 class SpeckleWarning(Warning):
    def __init__(self, *args: object) -> None:
        super().__init__(*args)
@@ -1,10 +1,13 @@
-import socket
 import sys
 import queue
 import hashlib
+import getpass
 import logging
 import requests
 import threading
+import platform
+import contextlib
+

 """
 Anonymous telemetry to help us understand how to make a better Speckle.
@@ -12,7 +15,7 @@ This really helps us to deliver a better open source project and product!
 """
 TRACK = True
 HOST_APP = "python"
-HOST_APP_VERSION = f"python {'.'.join(map(str, sys.version_info[:3]))}"
+HOST_APP_VERSION = f"python {'.'.join(map(str, sys.version_info[:2]))}"
 PLATFORMS = {"win32": "Windows", "cygwin": "Windows", "darwin": "Mac OS X"}

 LOG = logging.getLogger(__name__)
@@ -23,6 +26,7 @@ RECEIVE = "Receive"
 SEND = "Send"
 STREAM = "Stream Action"
 PERMISSION = "Permission Action"
+INVITE = "Invite Action"
 COMMIT = "Commit Action"
 BRANCH = "Branch Action"
 USER = "User Action"
@@ -75,7 +79,7 @@ def track(action: str, account: "Account" = None, custom_props: dict = None):
        METRICS_TRACKER.queue.put_nowait(event_params)
    except Exception as ex:
        # wrapping this whole thing in a try except as we never want a failure here to annoy users!
-        LOG.error("Error queueing metrics request: " + str(ex))
+        LOG.error(f"Error queueing metrics request: {str(ex)}")


 def initialise_tracker(account: "Account" = None):
@@ -101,7 +105,7 @@ class Singleton(type):
 class MetricsTracker(metaclass=Singleton):
    analytics_url = "https://analytics.speckle.systems/track?ip=1"
    analytics_token = "acd87c5a50b56df91a795e999812a3a4"
-    last_user = None
+    last_user = ""
    last_server = None
    platform = None
    sending_thread = None
@@ -113,11 +117,15 @@ class MetricsTracker(metaclass=Singleton):
        )
        self.platform = PLATFORMS.get(sys.platform, "linux")
        self.sending_thread.start()
+        with contextlib.suppress(Exception):
+            node, user = platform.node(), getpass.getuser()
+            if node and user:
+                self.last_user = f"@{self.hash(f'{node}-{user}')}"

    def set_last_user(self, email: str):
        if not email:
            return
-        self.last_user = "@" + self.hash(email)
+        self.last_user = f"@{self.hash(email)}"

    def set_last_server(self, server: str):
        if not server:
@@ -135,6 +143,6 @@ class MetricsTracker(metaclass=Singleton):
            try:
                session.post(self.analytics_url, json=event_params)
            except Exception as ex:
-                LOG.error("Error sending metrics request: " + str(ex))
+                LOG.error(f"Error sending metrics request: {str(ex)}")

            self.queue.task_done()
@@ -92,12 +92,19 @@ class _RegisteringBase:
    speckle_type: ClassVar[str]
    _type_registry: ClassVar[Dict[str, "Base"]] = {}
    _attr_types: ClassVar[Dict[str, Type]] = {}
+    # dict of chunkable props and their max chunk size
+    _chunkable: Dict[str, int] = {}
+    _chunk_size_default: int = 1000
+    _detachable: Set[str] = set()  # list of defined detachable props
+    _serialize_ignore: Set[str] = set()

    class Config:
        validate_assignment = True

    @classmethod
-    def get_registered_type(cls, speckle_type: str) -> Optional[Type["Base"]]:
+    def get_registered_type(
+        cls, speckle_type: str
+    ) -> Union["Base", Type["Base"], None]:
        """Get the registered type from the protected mapping via the `speckle_type`"""
        return cls._type_registry.get(speckle_type, None)

@@ -142,12 +149,7 @@ class Base(_RegisteringBase):
    id: Optional[str] = None
    totalChildrenCount: Optional[int] = None
    applicationId: Optional[str] = None
-    _units: str = None
-    # dict of chunkable props and their max chunk size
-    _chunkable: Dict[str, int] = {}
-    _chunk_size_default: int = 1000
-    _detachable: Set[str] = set()  # list of defined detachable props
-    _serialize_ignore: Set[str] = set()
+    _units: Union[str, None] = None

    def __init__(self, **kwargs) -> None:
        super().__init__()
@@ -331,7 +333,7 @@ class Base(_RegisteringBase):

    def get_serializable_attributes(self) -> List[str]:
        """Get the attributes that should be serialized"""
-        return list(set(self.get_member_names()) - self._serialize_ignore)
+        return sorted(list(set(self.get_member_names()) - self._serialize_ignore))

    def get_typed_member_names(self) -> List[str]:
        """Get all of the names of the defined (typed) properties of this object"""
@@ -378,6 +380,7 @@ class Base(_RegisteringBase):
        )

    def _handle_object_count(self, obj: Any, parsed: List) -> int:
+        # pylint: disable=isinstance-second-argument-not-valid-type
        count = 0
        if obj is None:
            return count
@@ -406,7 +409,7 @@ Base.update_forward_refs()


 class DataChunk(Base, speckle_type="Speckle.Core.Models.DataChunk"):
-    data: List[Any] = None
+    data: Union[List[Any], None] = None

    def __init__(self) -> None:
        super().__init__()
@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import Any, Callable, List, Type
+from typing import Any, Callable, List, Type, Dict

 from specklepy.logging.exceptions import SpeckleException
 from specklepy.objects.base import Base
@@ -43,8 +43,8 @@ def curve_from_list(args: List[float]):


 class ObjectArray:
-    def __init__(self) -> None:
-        self.data = []
+    def __init__(self, data: list = None) -> None:
+        self.data = data or []

    @classmethod
    def from_objects(cls, objects: List[Base]) -> "ObjectArray":
@@ -60,18 +60,17 @@ class ObjectArray:
                    "All objects in chunk should have the same speckle_type. "
                    f"Found {speckle_type} and {obj.speckle_type}"
                )
-            data_list.encode_object(object=obj)
+            data_list.encode_object(obj=obj)

        return data_list

    @staticmethod
    def decode_data(
-        data: List[Any], decoder: Callable[[List[Any]], Base]
+        data: List[Any], decoder: Callable[[List[Any]], Base], **kwargs: Dict[str, Any]
    ) -> List[Base]:
        bases = []
        if not data:
            return bases
-
        index = 0
        while index < len(data):
            item_length = int(data[index])
@@ -79,19 +78,16 @@ class ObjectArray:
            item_end = item_start + item_length
            item_data = data[item_start:item_end]
            index = item_end
-            # TODO: investigate what's going on w this fail
-            try:
-                decoded_data = decoder(item_data)
-                bases.append(decoded_data)
-            except ValueError:
-                continue
+            decoded_data = decoder(item_data, **kwargs)
+            bases.append(decoded_data)
+
        return bases

-    def decode(self, decoder: Callable[[List[Any]], Any]):
-        return self.decode_data(data=self.data, decoder=decoder)
+    def decode(self, decoder: Callable[[List[Any]], Any], **kwargs: Dict[str, Any]):
+        return self.decode_data(data=self.data, decoder=decoder, **kwargs)

-    def encode_object(self, object: Base):
-        encoded = object.to_list()
+    def encode_object(self, obj: Base):
+        encoded = obj.to_list()
        encoded.insert(0, len(encoded))
        self.data.extend(encoded)

@@ -128,8 +124,7 @@ class CurveArray(ObjectArray):

    @classmethod
    def _curve_decoder(cls, data: List[float]) -> Base:
-        crv_array = cls()
-        crv_array.data = data
+        crv_array = cls(data)
        return crv_array.to_curve()

    def to_curves(self) -> List[Base]:
@@ -64,19 +64,21 @@ class Plane(Base, speckle_type=GEOMETRY + "Plane"):
    @classmethod
    def from_list(cls, args: List[Any]) -> "Plane":
        return cls(
-            origin=Point.from_list(args[0:3]),
+            origin=Point.from_list(args[:3]),
            normal=Vector.from_list(args[3:6]),
            xdir=Vector.from_list(args[6:9]),
            ydir=Vector.from_list(args[9:12]),
+            units=get_units_from_encoding(args[-1]),
        )

    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.extend(self.origin.to_list())
-        encoded.extend(self.normal.to_list())
-        encoded.extend(self.xdir.to_list())
-        encoded.extend(self.ydir.to_list())
-        return encoded
+        return [
+            *self.origin.to_list(),
+            *self.normal.to_list(),
+            *self.xdir.to_list(),
+            *self.ydir.to_list(),
+            get_encoding_from_units(self.units),
+        ]


 class Box(Base, speckle_type=GEOMETRY + "Box"):
@@ -98,17 +100,21 @@ class Line(Base, speckle_type=GEOMETRY + "Line"):
    @classmethod
    def from_list(cls, args: List[Any]) -> "Line":
        return cls(
-            start=Point.from_list(args[0:3]),
-            end=Point.from_list(args[3:6]),
-            domain=Interval.from_list(args[6:9]),
+            start=Point.from_list(args[1:4]),
+            end=Point.from_list(args[4:7]),
+            domain=Interval.from_list(args[7:10]),
+            units=get_units_from_encoding(args[-1]),
        )

    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.extend(self.start.to_list())
-        encoded.extend(self.end.to_list())
-        encoded.extend(self.domain.to_list())
-        return encoded
+        domain = self.domain.to_list() if self.domain else [0, 1]
+        return [
+            CurveTypeEncoding.Line.value,
+            *self.start.to_list(),
+            *self.end.to_list(),
+            *domain,
+            get_encoding_from_units(self.units),
+        ]


 class Arc(Base, speckle_type=GEOMETRY + "Arc"):
@@ -134,20 +140,26 @@ class Arc(Base, speckle_type=GEOMETRY + "Arc"):
            angleRadians=args[4],
            domain=Interval.from_list(args[5:7]),
            plane=Plane.from_list(args[7:20]),
+            startPoint=Point.from_list(args[20:23]),
+            midPoint=Point.from_list(args[23:26]),
+            endPoint=Point.from_list(args[26:29]),
            units=get_units_from_encoding(args[-1]),
        )

    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.append(CurveTypeEncoding.Arc.value)
-        encoded.append(self.radius)
-        encoded.append(self.startAngle)
-        encoded.append(self.endAngle)
-        encoded.append(self.angleRadians)
-        encoded.extend(self.domain.to_list())
-        encoded.extend(self.plane.to_list())
-        encoded.append(get_encoding_from_units(self.units))
-        return encoded
+        return [
+            CurveTypeEncoding.Arc.value,
+            self.radius,
+            self.startAngle,
+            self.endAngle,
+            self.angleRadians,
+            *self.domain.to_list(),
+            *self.plane.to_list(),
+            *self.startPoint.to_list(),
+            *self.midPoint.to_list(),
+            *self.endPoint.to_list(),
+            get_encoding_from_units(self.units),
+        ]


 class Circle(Base, speckle_type=GEOMETRY + "Circle"):
@@ -168,13 +180,13 @@ class Circle(Base, speckle_type=GEOMETRY + "Circle"):
        )

    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.append(CurveTypeEncoding.Circle.value)
-        encoded.append(self.radius),
-        encoded.extend(self.domain.to_list())
-        encoded.extend(self.plane.to_list())
-        encoded.append(get_encoding_from_units(self.units))
-        return encoded
+        return [
+            CurveTypeEncoding.Circle.value,
+            self.radius,
+            *self.domain.to_list(),
+            *self.plane.to_list(),
+            get_encoding_from_units(self.units),
+        ]


 class Ellipse(Base, speckle_type=GEOMETRY + "Ellipse"):
@@ -198,14 +210,14 @@ class Ellipse(Base, speckle_type=GEOMETRY + "Ellipse"):
        )

    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.append(CurveTypeEncoding.Ellipse.value)
-        encoded.append(self.firstRadius)
-        encoded.append(self.secondRadius)
-        encoded.extend(self.domain.to_list())
-        encoded.extend(self.plane.to_list())
-        encoded.append(get_encoding_from_units(self.units))
-        return encoded
+        return [
+            CurveTypeEncoding.Ellipse.value,
+            self.firstRadius,
+            self.secondRadius,
+            *self.domain.to_list(),
+            *self.plane.to_list(),
+            get_encoding_from_units(self.units),
+        ]


 class Polyline(Base, speckle_type=GEOMETRY + "Polyline", chunkable={"value": 20000}):
@@ -237,14 +249,14 @@ class Polyline(Base, speckle_type=GEOMETRY + "Polyline", chunkable={"value": 200
        )

    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.append(CurveTypeEncoding.Polyline.value)
-        encoded.append(int(self.closed))
-        encoded.extend(self.domain.to_list())
-        encoded.append(len(self.value))
-        encoded.extend(self.value)
-        encoded.append(get_encoding_from_units(self.units))
-        return encoded
+        return [
+            CurveTypeEncoding.Polyline.value,
+            int(self.closed),
+            *self.domain.to_list(),
+            len(self.value),
+            *self.value,
+            get_encoding_from_units(self.units),
+        ]

    def as_points(self) -> List[Point]:
        """Converts the `value` attribute to a list of Points"""
@@ -315,21 +327,21 @@ class Curve(
        )

    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.append(CurveTypeEncoding.Curve.value)
-        encoded.append(self.degree)
-        encoded.append(int(self.periodic))
-        encoded.append(int(self.rational))
-        encoded.append(int(self.closed))
-        encoded.extend(self.domain.to_list())
-        encoded.append(len(self.points))
-        encoded.append(len(self.weights))
-        encoded.append(len(self.knots))
-        encoded.extend(self.points)
-        encoded.extend(self.weights)
-        encoded.extend(self.knots)
-        encoded.append(get_encoding_from_units(self.units))
-        return encoded
+        return [
+            CurveTypeEncoding.Curve.value,
+            self.degree,
+            int(self.periodic),
+            int(self.rational),
+            int(self.closed),
+            *self.domain.to_list(),
+            len(self.points),
+            len(self.weights),
+            len(self.knots),
+            *self.points,
+            *self.weights,
+            *self.knots,
+            get_encoding_from_units(self.units),
+        ]


 class Polycurve(Base, speckle_type=GEOMETRY + "Polycurve"):
@@ -342,8 +354,7 @@ class Polycurve(Base, speckle_type=GEOMETRY + "Polycurve"):

    @classmethod
    def from_list(cls, args: List[Any]) -> "Polycurve":
-        curve_arrays = CurveArray()
-        curve_arrays.data = args[4:-1]
+        curve_arrays = CurveArray(args[5:-1])
        return cls(
            closed=bool(args[1]),
            domain=Interval.from_list(args[2:4]),
@@ -352,14 +363,15 @@ class Polycurve(Base, speckle_type=GEOMETRY + "Polycurve"):
        )

    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.append(CurveTypeEncoding.Polycurve.value)
-        encoded.append(int(self.closed))
-        encoded.extend(self.domain.to_list())
-        curve_array = CurveArray.from_curves(self.segments)
-        encoded.extend(curve_array.data)
-        encoded.append(get_encoding_from_units(self.units))
-        return encoded
+        curve_array = CurveArray.from_curves(self.segments).data
+        return [
+            CurveTypeEncoding.Polycurve.value,
+            int(self.closed),
+            *self.domain.to_list(),
+            len(curve_array),
+            *curve_array,
+            get_encoding_from_units(self.units),
+        ]


 class Extrusion(Base, speckle_type=GEOMETRY + "Extrusion"):
@@ -460,46 +472,65 @@ class Surface(Base, speckle_type=GEOMETRY + "Surface"):
        )

    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.append(self.degreeU)
-        encoded.append(self.degreeV)
-        encoded.append(self.countU)
-        encoded.append(self.countV)
-        encoded.append(int(self.rational))
-        encoded.append(int(self.closedU))
-        encoded.append(int(self.closedV))
-        encoded.extend(self.domainU.to_list())
-        encoded.extend(self.domainV.to_list())
-        encoded.append(len(self.pointData))
-        encoded.append(len(self.knotsU))
-        encoded.append(len(self.knotsV))
-        encoded.extend(self.pointData)
-        encoded.extend(self.knotsU)
-        encoded.extend(self.knotsV)
-        encoded.append(get_encoding_from_units(self.units))
-        return encoded
+        return [
+            self.degreeU,
+            self.degreeV,
+            self.countU,
+            self.countV,
+            int(self.rational),
+            int(self.closedU),
+            int(self.closedV),
+            *self.domainU.to_list(),
+            *self.domainV.to_list(),
+            len(self.pointData),
+            len(self.knotsU),
+            len(self.knotsV),
+            *self.pointData,
+            *self.knotsU,
+            *self.knotsV,
+            get_encoding_from_units(self.units),
+        ]


 class BrepFace(Base, speckle_type=GEOMETRY + "BrepFace"):
    _Brep: "Brep" = None
    SurfaceIndex: int = None
-    LoopIndices: List[int] = None
    OuterLoopIndex: int = None
    OrientationReversed: bool = None
+    LoopIndices: List[int] = None

    @property
    def _outer_loop(self):
-        return self._Brep.Loops[self.OuterLoopIndex]
+        return self._Brep.Loops[self.OuterLoopIndex]  # pylint: disable=no-member

    @property
    def _surface(self):
-        return self._Brep.Surfaces[self.SurfaceIndex]
+        return self._Brep.Surfaces[self.SurfaceIndex]  # pylint: disable=no-member

    @property
    def _loops(self):
        if self.LoopIndices:
+            # pylint: disable=not-an-iterable, no-member
            return [self._Brep.Loops[i] for i in self.LoopIndices]

+    @classmethod
+    def from_list(cls, args: List[Any], brep: "Brep" = None) -> "BrepFace":
+        return cls(
+            _Brep=brep,
+            SurfaceIndex=args[0],
+            OuterLoopIndex=args[1],
+            OrientationReversed=bool(args[2]),
+            LoopIndices=args[3:],
+        )
+
+    def to_list(self) -> List[Any]:
+        return [
+            self.SurfaceIndex,
+            self.OuterLoopIndex,
+            int(self.OrientationReversed),
+            *self.LoopIndices,
+        ]
+

 class BrepEdge(Base, speckle_type=GEOMETRY + "BrepEdge"):
    _Brep: "Brep" = None
@@ -521,18 +552,59 @@ class BrepEdge(Base, speckle_type=GEOMETRY + "BrepEdge"):
    @property
    def _trims(self):
        if self.TrimIndices:
+            # pylint: disable=not-an-iterable
            return [self._Brep.Trims[i] for i in self.TrimIndices]

    @property
    def _curve(self):
        return self._Brep.Curve3D[self.Curve3dIndex]

+    @classmethod
+    def from_list(cls, args: List[Any], brep: "Brep" = None) -> "BrepEdge":
+        domain_start = args[4]
+        domain_end = args[5]
+        domain = (
+            Interval(start=domain_start, end=domain_end)
+            if None not in (domain_start, domain_end)
+            else None
+        )
+        return cls(
+            _Brep=brep,
+            Curve3dIndex=int(args[0]),
+            TrimIndices=[int(t) for t in args[6:]],
+            StartIndex=int(args[1]),
+            EndIndex=int(args[2]),
+            ProxyCurveIsReversed=bool(args[3]),
+            Domain=domain,
+        )
+
+    def to_list(self) -> List[Any]:
+        return [
+            self.Curve3dIndex,
+            self.StartIndex,
+            self.EndIndex,
+            int(self.ProxyCurveIsReversed),
+            self.Domain.start,
+            self.Domain.end,
+            *self.TrimIndices,
+        ]
+
+
+
+class BrepLoopType(int, Enum):
+    Unknown = 0
+    Outer = 1
+    Inner = 2
+    Slit = 3
+    CurveOnSurface = 4
+    PointOnSurface = 5
+

 class BrepLoop(Base, speckle_type=GEOMETRY + "BrepLoop"):
    _Brep: "Brep" = None
    FaceIndex: int = None
    TrimIndices: List[int] = None
-    Type: str = None
+    Type: BrepLoopType = None

    @property
    def _face(self):
@@ -541,10 +613,27 @@ class BrepLoop(Base, speckle_type=GEOMETRY + "BrepLoop"):
    @property
    def _trims(self):
        if self.TrimIndices:
+            # pylint: disable=not-an-iterable
            return [self._Brep.Trims[i] for i in self.TrimIndices]

+    @classmethod
+    def from_list(cls, args: List[any], brep: "Brep" = None):
+        return cls(
+            _Brep=brep,
+            FaceIndex=args[0],
+            Type=BrepLoopType(args[1]),
+            TrimIndices=args[2:],
+        )

-class BrepTrimTypeEnum(int, Enum):
+    def to_list(self) -> List[int]:
+        return [
+            self.FaceIndex,
+            self.Type.value,
+            *self.TrimIndices,
+        ]
+
+
+class BrepTrimType(int, Enum):
    Unknown = 0
    Boundary = 1
    Mated = 2
@@ -564,29 +653,35 @@ class BrepTrim(Base, speckle_type=GEOMETRY + "BrepTrim"):
    LoopIndex: int = None
    CurveIndex: int = None
    IsoStatus: int = None
-    TrimType: str = None
+    TrimType: BrepTrimType = None
    IsReversed: bool = None
    Domain: Interval = None

    @property
    def _face(self):
-        return self._Brep.Faces[self.FaceIndex]
+        if self._Brep:
+            return self._Brep.Faces[self.FaceIndex]  # pylint: disable=no-member

    @property
    def _loop(self):
-        return self._Brep.Loops[self.LoopIndex]
+        if self._Brep:
+            return self._Brep.Loops[self.LoopIndex]  # pylint: disable=no-member

    @property
    def _edge(self):
-        return self._Brep.Edges[self.EdgeIndex] if self.EdgeIndex != -1 else None
+        if self._Brep:
+            # pylint: disable=no-member
+            return self._Brep.Edges[self.EdgeIndex] if self.EdgeIndex != -1 else None

    @property
    def _curve_2d(self):
-        return self._Brep.Curve2D[self.CurveIndex]
+        if self._Brep:
+            return self._Brep.Curve2D[self.CurveIndex]  # pylint: disable=no-member

    @classmethod
-    def from_list(cls, args: List[Any]) -> "BrepTrim":
+    def from_list(cls, args: List[Any], brep: "Brep" = None) -> "BrepTrim":
        return cls(
+            _Brep=brep,
            EdgeIndex=args[0],
            StartIndex=args[1],
            EndIndex=args[2],
@@ -594,39 +689,48 @@ class BrepTrim(Base, speckle_type=GEOMETRY + "BrepTrim"):
            LoopIndex=args[4],
            CurveIndex=args[5],
            IsoStatus=args[6],
-            TrimType=BrepTrimTypeEnum(args[7]).name,
+            TrimType=BrepTrimType(args[7]),
            IsReversed=bool(args[8]),
        )

    def to_list(self) -> List[Any]:
-        encoded = []
-        encoded.append(self.EdgeIndex)
-        encoded.append(self.StartIndex)
-        encoded.append(self.EndIndex)
-        encoded.append(self.FaceIndex)
-        encoded.append(self.LoopIndex)
-        encoded.append(self.CurveIndex)
-        encoded.append(self.IsoStatus)
-        encoded.append(getattr(BrepTrimTypeEnum, self.TrimType).value)
-        encoded.append(self.IsReversed)
-        return encoded
+        return [
+            self.EdgeIndex,
+            self.StartIndex,
+            self.EndIndex,
+            self.FaceIndex,
+            self.LoopIndex,
+            self.CurveIndex,
+            self.IsoStatus,
+            self.TrimType.value,
+            int(self.IsReversed),
+        ]


 class Brep(
    Base,
    speckle_type=GEOMETRY + "Brep",
    chunkable={
-        "SurfacesValue": 200,
-        "Curve3DValues": 200,
-        "Curve2DValues": 200,
-        "VerticesValue": 5000,
-        "Edges": 5000,
-        "Loops": 5000,
-        "TrimsValue": 5000,
-        "Faces": 5000,
+        "SurfacesValue": 31250,
+        "Curve3DValues": 31250,
+        "Curve2DValues": 31250,
+        "VerticesValue": 31250,
+        "EdgesValue": 62500,
+        "LoopsValue": 62500,
+        "FacesValue": 62500,
+        "TrimsValue": 62500,
    },
    detachable={"displayValue"},
-    serialize_ignore={"Surfaces", "Curve3D", "Curve2D", "Vertices", "Trims"},
+    serialize_ignore={
+        "Surfaces",
+        "Curve3D",
+        "Curve2D",
+        "Vertices",
+        "Trims",
+        "Edges",
+        "Loops",
+        "Faces",
+    },
 ):
    provenance: str = None
    bbox: Box = None
@@ -637,6 +741,10 @@ class Brep(
    Curve3D: List[Base] = None
    Curve2D: List[Base] = None
    Vertices: List[Point] = None
+    Edges: List[BrepEdge] = None
+    Loops: List[BrepLoop] = None
+    Faces: List[BrepFace] = None
+    Trims: List[BrepTrim] = None
    IsClosed: bool = None
    Orientation: int = None

@@ -645,7 +753,7 @@ class Brep(
            return children

        for child in children:
-            child._Brep = self
+            child._Brep = self  # pylint: disable=protected-access
        return children

    # set as prop for now for backwards compatibility
@@ -661,61 +769,73 @@ class Brep(
            self._displayValue = value

    @property
-    def Edges(self) -> List[BrepEdge]:
-        return self._inject_self_into_children(self._Edges)
+    def EdgesValue(self) -> List[BrepEdge]:
+        return None if self.Edges is None else ObjectArray.from_objects(self.Edges).data

-    @Edges.setter
-    def Edges(self, value: List[BrepEdge]):
-        self._Edges = value
+    @EdgesValue.setter
+    def EdgesValue(self, value: List[float]):
+        if not value:
+            return
+
+        self.Edges = ObjectArray.decode_data(value, BrepEdge.from_list, brep=self)

    @property
-    def Loops(self) -> List[BrepLoop]:
-        return self._inject_self_into_children(self._Loops)
+    def LoopsValue(self) -> List[BrepLoop]:
+        return None if self.Loops is None else ObjectArray.from_objects(self.Loops).data

-    @Loops.setter
-    def Loops(self, value: List[BrepLoop]):
-        self._Loops = value
+    @LoopsValue.setter
+    def LoopsValue(self, value: List[int]):
+        if not value:
+            return
+
+        self.Loops = ObjectArray.decode_data(value, BrepLoop.from_list, brep=self)

    @property
-    def Faces(self) -> List[BrepFace]:
-        return self._inject_self_into_children(self._Faces)
+    def FacesValue(self) -> List[int]:
+        return None if self.Faces is None else ObjectArray.from_objects(self.Faces).data

-    @Faces.setter
-    def Faces(self, value: List[BrepFace]):
-        self._Faces = value
+    @FacesValue.setter
+    def FacesValue(self, value: List[int]):
+        if not value:
+            return
+
+        self.Faces = ObjectArray.decode_data(value, BrepFace.from_list, brep=self)

    @property
    def SurfacesValue(self) -> List[float]:
-        if self.Surfaces is None:
-            return None
-        return ObjectArray.from_objects(self.Surfaces).data
+        return (
+            None
+            if self.Surfaces is None
+            else ObjectArray.from_objects(self.Surfaces).data
+        )

    @SurfacesValue.setter
    def SurfacesValue(self, value: List[float]):
+        if not value:
+            return
+
        self.Surfaces = ObjectArray.decode_data(value, Surface.from_list)

    @property
    def Curve3DValues(self) -> List[float]:
-        if self.Curve3D is None:
-            return None
-        return CurveArray.from_curves(self.Curve3D).data
+        return (
+            None if self.Curve3D is None else CurveArray.from_curves(self.Curve3D).data
+        )

    @Curve3DValues.setter
    def Curve3DValues(self, value: List[float]):
-        crv_array = CurveArray()
-        crv_array.data = value
+        crv_array = CurveArray(value)
        self.Curve3D = crv_array.to_curves()

    @property
    def Curve2DValues(self) -> List[Base]:
-        if self.Curve2D is None:
-            return None
-        return CurveArray.from_curves(self.Curve2D).data
+        return (
+            None if self.Curve2D is None else CurveArray.from_curves(self.Curve2D).data
+        )

    @Curve2DValues.setter
    def Curve2DValues(self, value: List[float]):
-        crv_array = CurveArray()
-        crv_array.data = value
+        crv_array = CurveArray(value)
        self.Curve2D = crv_array.to_curves()

    @property
@@ -742,27 +862,25 @@ class Brep(

        self.Vertices = vertices

-    @property
-    def Trims(self) -> List[BrepTrim]:
-        return self._inject_self_into_children(self._Trims)
-
-    @Trims.setter
-    def Trims(self, value: List[BrepTrim]):
-        self._Trims = value
-
+    # TODO: can this be consistent with loops, edges, faces, curves, etc and prepend with the chunk list? needs to happen in sharp first
    @property
    def TrimsValue(self) -> List[float]:
-        if self.Trims is None:
-            return None
-        values = []
+        # return None if self.Trims is None else ObjectArray.from_objects(self.Trims).data
+        if not self.Trims:
+            return
+        value = []
        for trim in self.Trims:
-            values.extend(trim.to_list())
-        return values
+            value.extend(trim.to_list())
+        return value

    @TrimsValue.setter
    def TrimsValue(self, value: List[float]):
+        if not value:
+            return
+
+        # self.Trims = ObjectArray.decode_data(value, BrepTrim.from_list, brep=self)
        self.Trims = [
-            BrepTrim.from_list(value[i : i + 9]) for i in range(0, len(value), 9)
+            BrepTrim.from_list(value[i : i + 9], self) for i in range(0, len(value), 9)
        ]


@@ -16,8 +16,8 @@ UNITS_STRINGS = {
 }

 UNITS_ENCODINGS = {
-    None: 0,
    "none": 0,
+    None: 0,
    "mm": 1,
    "cm": 2,
    "m": 3,
@@ -40,16 +40,20 @@ def safe_json_loads(obj: str, obj_id=None) -> Any:
 class BaseObjectSerializer:
    read_transport: AbstractTransport
    write_transports: List[AbstractTransport]
-    detach_lineage: List[bool] = []  # tracks depth and whether or not to detach
-    lineage: List[str] = []  # keeps track of hash chain through the object tree
-    family_tree: Dict[str, Dict[str, int]] = {}
-    closure_table: Dict[str, Dict[str, int]] = {}
+    detach_lineage: List[bool]  # tracks depth and whether or not to detach
+    lineage: List[str]  # keeps track of hash chain through the object tree
+    family_tree: Dict[str, Dict[str, int]]
+    closure_table: Dict[str, Dict[str, int]]
+    deserialized: Dict[str, Base]   # holds deserialized objects so objects with same id return the same instance

-    def __init__(
-        self, write_transports: List[AbstractTransport] = [], read_transport=None
-    ) -> None:
-        self.write_transports = write_transports
+    def __init__(self, write_transports: List[AbstractTransport] = None, read_transport=None) -> None:
+        self.write_transports = write_transports or []
        self.read_transport = read_transport
+        self.detach_lineage = []
+        self.lineage = []
+        self.family_tree = {}
+        self.closure_table = {}
+        self.deserialized = {}

    def write_json(self, base: Base):
        """Serializes a given base object into a json string
@@ -57,12 +61,12 @@ class BaseObjectSerializer:
            base {Base} -- the base object to be decomposed and serialized

        Returns:
-            (str, str) -- a tuple containing the hash (id) of the base object and the serialized object string
+            (str, str) -- a tuple containing the object id of the base object and the serialized object string
        """

-        hash, obj = self.traverse_base(base)
+        obj_id, obj = self.traverse_base(base)

-        return hash, ujson.dumps(obj)
+        return obj_id, ujson.dumps(obj)

    def traverse_base(self, base: Base) -> Tuple[str, Dict]:
        """Decomposes the given base object and builds a serializable dictionary
@@ -71,7 +75,7 @@ class BaseObjectSerializer:
            base {Base} -- the base object to be decomposed and serialized

        Returns:
-            (str, dict) -- a tuple containing the hash (id) of the base object and the constructed serializable dictionary
+            (str, dict) -- a tuple containing the object id of the base object and the constructed serializable dictionary
        """
        self.__reset_writer()

@@ -79,13 +83,13 @@ class BaseObjectSerializer:
            for wt in self.write_transports:
                wt.begin_write()

-        hash, obj = self._traverse_base(base)
+        obj_id, obj = self._traverse_base(base)

        if self.write_transports:
            for wt in self.write_transports:
                wt.end_write()

-        return hash, obj
+        return obj_id, obj

    def _traverse_base(self, base: Base) -> Tuple[str, Dict]:
        if not self.detach_lineage:
@@ -110,11 +114,6 @@ class BaseObjectSerializer:
            if prop == "id":
                continue

-            # allow serialisation of nulls
-            if value is None:
-                object_builder[prop] = value
-                continue
-
            # only bother with chunking and detaching if there is a write transport
            if self.write_transports:
                dynamic_chunk_match = prop.startswith("@") and re.match(
@@ -131,8 +130,8 @@ class BaseObjectSerializer:
                    prop.startswith("@") or prop in base._detachable or chunkable
                )

-            # 1. handle primitives (ints, floats, strings, and bools)
-            if isinstance(value, PRIMITIVES):
+            # 1. handle None and primitives (ints, floats, strings, and bools)
+            if value is None or isinstance(value, PRIMITIVES):
                object_builder[prop] = value
                continue

@@ -145,8 +144,8 @@ class BaseObjectSerializer:
            elif isinstance(value, Base):
                child_obj = self.traverse_value(value, detach=detach)
                if detach and self.write_transports:
-                    ref_hash = child_obj["id"]
-                    object_builder[prop] = self.detach_helper(ref_hash=ref_hash)
+                    ref_id = child_obj["id"]
+                    object_builder[prop] = self.detach_helper(ref_id=ref_id)
                else:
                    object_builder[prop] = child_obj

@@ -165,8 +164,8 @@ class BaseObjectSerializer:
                chunk_refs = []
                for c in chunks:
                    self.detach_lineage.append(detach)
-                    ref_hash, _ = self._traverse_base(c)
-                    ref_obj = self.detach_helper(ref_hash=ref_hash)
+                    ref_id, _ = self._traverse_base(c)
+                    ref_obj = self.detach_helper(ref_id=ref_id)
                    chunk_refs.append(ref_obj)
                object_builder[prop] = chunk_refs

@@ -185,20 +184,20 @@ class BaseObjectSerializer:
            }
        object_builder["totalChildrenCount"] = len(closure)

-        hash = hash_obj(object_builder)
+        obj_id = hash_obj(object_builder)

-        object_builder["id"] = hash
+        object_builder["id"] = obj_id
        if closure:
-            object_builder["__closure"] = self.closure_table[hash] = closure
+            object_builder["__closure"] = self.closure_table[obj_id] = closure

        # write detached or root objects to transports
        if detached and self.write_transports:
            for t in self.write_transports:
-                t.save_object(id=hash, serialized_object=ujson.dumps(object_builder))
+                t.save_object(id=obj_id, serialized_object=ujson.dumps(object_builder))

        del self.lineage[-1]

-        return hash, object_builder
+        return obj_id, object_builder

    def traverse_value(self, obj: Any, detach: bool = False) -> Any:
        """Decomposes a given object and constructs a serializable object or dictionary
@@ -224,8 +223,8 @@ class BaseObjectSerializer:
            for o in obj:
                if isinstance(o, Base):
                    self.detach_lineage.append(detach)
-                    hash, _ = self._traverse_base(o)
-                    detached_list.append(self.detach_helper(ref_hash=hash))
+                    ref_id, _ = self._traverse_base(o)
+                    detached_list.append(self.detach_helper(ref_id=ref_id))
                else:
                    detached_list.append(self.traverse_value(o, detach))
            return detached_list
@@ -254,11 +253,11 @@ class BaseObjectSerializer:

                return str(obj)

-    def detach_helper(self, ref_hash: str) -> Dict[str, str]:
+    def detach_helper(self, ref_id: str) -> Dict[str, str]:
        """Helper to keep track of detached objects and their depth in the family tree and create reference objects to place in the parent object

        Arguments:
-            ref_hash {str} -- the hash of the fully traversed object
+            ref_id {str} -- the id of the fully traversed object

        Returns:
            dict -- a reference object to be inserted into the given object's parent
@@ -267,13 +266,13 @@ class BaseObjectSerializer:
        for parent in self.lineage:
            if parent not in self.family_tree:
                self.family_tree[parent] = {}
-            if ref_hash not in self.family_tree[parent] or self.family_tree[parent][
-                ref_hash
+            if ref_id not in self.family_tree[parent] or self.family_tree[parent][
+                ref_id
            ] > len(self.detach_lineage):
-                self.family_tree[parent][ref_hash] = len(self.detach_lineage)
+                self.family_tree[parent][ref_id] = len(self.detach_lineage)

        return {
-            "referencedId": ref_hash,
+            "referencedId": ref_id,
            "speckle_type": "reference",
        }

@@ -295,6 +294,8 @@ class BaseObjectSerializer:
        """
        if not obj_string:
            return None
+        
+        self.deserialized = {}
        obj = safe_json_loads(obj_string)
        return self.recompose_base(obj=obj)

@@ -313,6 +314,9 @@ class BaseObjectSerializer:
        if isinstance(obj, str):
            obj = safe_json_loads(obj)

+        if "id" in obj and obj["id"] in self.deserialized:
+            return self.deserialized[obj["id"]]
+
        if "speckle_type" in obj and obj["speckle_type"] == "reference":
            obj = self.get_child(obj=obj)

@@ -343,14 +347,14 @@ class BaseObjectSerializer:

            # 2. handle referenced child objects
            elif "referencedId" in value:
-                ref_hash = value["referencedId"]
-                ref_obj_str = self.read_transport.get_object(id=ref_hash)
+                ref_id = value["referencedId"]
+                ref_obj_str = self.read_transport.get_object(id=ref_id)
                if ref_obj_str:
-                    ref_obj = safe_json_loads(ref_obj_str, ref_hash)
+                    ref_obj = safe_json_loads(ref_obj_str, ref_id)
                    base.__setattr__(prop, self.recompose_base(obj=ref_obj))
                else:
                    warnings.warn(
-                        f"Could not find the referenced child object of id `{ref_hash}` in the given read transport: {self.read_transport.name}",
+                        f"Could not find the referenced child object of id `{ref_id}` in the given read transport: {self.read_transport.name}",
                        SpeckleWarning,
                    )
                    base.__setattr__(prop, self.handle_value(value))
@@ -359,6 +363,9 @@ class BaseObjectSerializer:
            else:
                base.__setattr__(prop, self.handle_value(value))

+        if "id" in obj:
+            self.deserialized[obj["id"]] = base
+
        return base

    def handle_value(self, obj: Any):
@@ -404,13 +411,13 @@ class BaseObjectSerializer:
            return obj

    def get_child(self, obj: Dict):
-        ref_hash = obj["referencedId"]
-        ref_obj_str = self.read_transport.get_object(id=ref_hash)
+        ref_id = obj["referencedId"]
+        ref_obj_str = self.read_transport.get_object(id=ref_id)
        if not ref_obj_str:
            warnings.warn(
-                f"Could not find the referenced child object of id `{ref_hash}` in the given read transport: {self.read_transport.name}",
+                f"Could not find the referenced child object of id `{ref_id}` in the given read transport: {self.read_transport.name}",
                SpeckleWarning,
            )
            return obj

-        return safe_json_loads(ref_obj_str, ref_hash)
+        return safe_json_loads(ref_obj_str, ref_id)
@@ -156,29 +156,13 @@ class ServerTransport(AbstractTransport):
        lines = r.iter_lines(decode_unicode=True)

        # iter through returned objects saving them as we go
+        target_transport.begin_write()
        for line in lines:
            if line:
                hash, obj = line.split("\t")
                target_transport.save_object(hash, obj)

        target_transport.save_object(id, root_obj_serialized)
+        target_transport.end_write()

        return root_obj_serialized
-
-    # async def stream_res(self, endpoint: str) -> str:
-    #     data = b""
-    #     async with aiohttp.ClientSession() as session:
-    #         session.headers.update(
-    #             {
-    #                 "Authorization": f"{self.session.headers['Authorization']}",
-    #                 "Accept": "text/plain",
-    #             }
-    #         )
-    #         async with session.get(endpoint) as res:
-    #             while True:
-    #                 chunk = await res.content.read(self.chunk_size)
-    #                 if not chunk:
-    #                     break
-    #                 data += chunk
-
-    #     return data.decode("utf-8")
@@ -188,4 +188,4 @@ class SQLiteTransport(AbstractTransport):
            self.__connection = sqlite3.connect(self._root_path)

    def __del__(self):
-        self.__connection.close()
+        self.close()
@@ -65,6 +65,13 @@ def client(host, user_dict):
    return client


+@pytest.fixture(scope="session")
+def second_client(host, second_user_dict):
+    client = SpeckleClient(host=host, use_ssl=False)
+    client.authenticate_with_token(second_user_dict["token"])
+    return client
+
+
@pytest.fixture(scope="session")
 def sample_stream(client):
    stream = Stream(
@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Union
 from contextlib import ExitStack as does_not_raise

 import pytest
@@ -111,6 +111,7 @@ class FrozenYoghurt(Base):
    add_ons: Optional[Dict[str, float]]  # dict item types won't be checked
    price: float = 0.0
    dietary: DietaryRestrictions
+    tag: Union[int, str]


 def test_type_checking() -> None:
@@ -120,6 +121,8 @@ def test_type_checking() -> None:
    order.price = "7"  # will get converted
    order.customer = "izzy"
    order.dietary = DietaryRestrictions.VEGAN
+    order.tag = "preorder"
+    order.tag = 4411

    with pytest.raises(SpeckleException):
        order.flavours = "not a list"
@@ -129,8 +132,26 @@ def test_type_checking() -> None:
        order.add_ons = ["sprinkles"]
    with pytest.raises(SpeckleException):
        order.dietary = "no nuts plz"
+    with pytest.raises(SpeckleException):
+        order.tag = ["tag01", "tag02"]

    order.add_ons = {"sprinkles": 0.2, "chocolate": 1.0}
    order.flavours = ["strawberry", "lychee", "peach", "pineapple"]

    assert order.price == 7.0
+
+
+def test_cached_deserialization() -> None:
+    material = Base(color="blue", opacity=0.5)
+
+    a = Base(name="a")
+    a["@material"] = material
+    b = Base(name="b")
+    b["@material"] = material
+
+    root = Base(a=a, b=b)
+
+    serialized = operations.serialize(root)
+    deserialized = operations.deserialize(serialized)
+
+    assert deserialized["a"]["@material"] is deserialized["b"]["@material"]
@@ -1,5 +1,5 @@
+# pylint: disable=redefined-outer-name
 import json
-from typing import Callable

 import pytest
 from specklepy.api import operations
@@ -13,8 +13,9 @@ from specklepy.objects.geometry import (
    BrepEdge,
    BrepFace,
    BrepLoop,
+    BrepLoopType,
    BrepTrim,
-    BrepTrimTypeEnum,
+    BrepTrimType,
    Circle,
    Curve,
    Ellipse,
@@ -48,12 +49,7 @@ def vector():

@pytest.fixture()
 def plane(point, vector):
-    return Plane(
-        origin=point,
-        normal=vector,
-        xdir=vector,
-        ydir=vector,
-    )
+    return Plane(origin=point, normal=vector, xdir=vector, ydir=vector, units="m")


@pytest.fixture()
@@ -74,6 +70,7 @@ def line(point, interval):
        start=point,
        end=point,
        domain=interval,
+        units="none"
        # These attributes are not handled in C#
        # bbox=None,
        # length=None
@@ -81,7 +78,7 @@ def line(point, interval):


@pytest.fixture()
-def arc(plane, interval):
+def arc(plane, interval, point):
    return Arc(
        radius=2.3,
        startAngle=22.1,
@@ -90,13 +87,13 @@ def arc(plane, interval):
        plane=plane,
        domain=interval,
        units="m",
+        startPoint=point,
+        midPoint=point,
+        endPoint=point,
        # These attributes are not handled in C#
        # bbox=None,
        # area=None,
        # length=None,
-        # startPoint=None,
-        # midPoint=None,
-        # endPoint=None,
    )


@@ -236,7 +233,7 @@ def brep_edge(interval):

@pytest.fixture()
 def brep_loop():
-    return BrepLoop(FaceIndex=5, TrimIndices=[3, 4, 5], Type="unknown")
+    return BrepLoop(FaceIndex=5, TrimIndices=[3, 4, 5], Type=BrepLoopType.Unknown)


@pytest.fixture()
@@ -249,7 +246,7 @@ def brep_trim():
        LoopIndex=4,
        CurveIndex=7,
        IsoStatus=6,
-        TrimType="Mated",
+        TrimType=BrepTrimType.Mated,
        IsReversed=False,
        # These attributes are not handled in C#
        # Domain=None,
@@ -338,22 +335,22 @@ def geometry_objects_dict(
    ],
 )
 def test_to_and_from_list(object_name: str, geometry_objects_dict):
-    object = geometry_objects_dict[object_name]
-    assert hasattr(object, "to_list")
-    assert hasattr(object, "from_list")
+    obj = geometry_objects_dict[object_name]
+    assert hasattr(obj, "to_list")
+    assert hasattr(obj, "from_list")

-    chunks = object.to_list()
+    chunks = obj.to_list()
    assert isinstance(chunks, list)

-    object_class = object.__class__
+    object_class = obj.__class__
    decoded_object: Base = object_class.from_list(chunks)
-    assert decoded_object.get_id() == object.get_id()
+    assert decoded_object.get_id() == obj.get_id()


 def test_brep_surfaces_value_serialization(surface):
    brep = Brep()
-    assert brep.Surfaces == None
-    assert brep.SurfacesValue == None
+    assert brep.Surfaces is None
+    assert brep.SurfacesValue is None
    brep.Surfaces = [surface, surface]
    assert brep.SurfacesValue == ObjectArray.from_objects([surface, surface]).data

@@ -364,8 +361,8 @@ def test_brep_surfaces_value_serialization(surface):

 def test_brep_curve2d_values_serialization(curve, polyline, circle):
    brep = Brep()
-    assert brep.Curve2D == None
-    assert brep.Curve2DValues == None
+    assert brep.Curve2D is None
+    assert brep.Curve2DValues is None
    brep.Curve2D = [curve, polyline]
    assert brep.Curve2DValues == CurveArray.from_curves([curve, polyline]).data

@@ -376,8 +373,8 @@ def test_brep_curve2d_values_serialization(curve, polyline, circle):

 def test_brep_curve3d_values_serialization(curve, polyline, circle):
    brep = Brep()
-    assert brep.Curve3D == None
-    assert brep.Curve3DValues == None
+    assert brep.Curve3D is None
+    assert brep.Curve3DValues is None
    brep.Curve3D = [curve, polyline]
    assert brep.Curve3DValues == CurveArray.from_curves([curve, polyline]).data

@@ -389,9 +386,9 @@ def test_brep_curve3d_values_serialization(curve, polyline, circle):
 def test_brep_vertices_values_serialization():
    brep = Brep()
    brep.VerticesValue = [1, 1, 1, 1, 2, 2, 2, 3, 3, 3]
-    brep.Vertices[0].get_id() == Point(x=1, y=1, z=1, _units="mm").get_id()
-    brep.Vertices[1].get_id() == Point(x=2, y=2, z=2, _units="mm").get_id()
-    brep.Vertices[2].get_id() == Point(x=3, y=3, z=3, _units="mm").get_id()
+    assert brep.Vertices[0].get_id() == Point(x=1, y=1, z=1, _units="mm").get_id()
+    assert brep.Vertices[1].get_id() == Point(x=2, y=2, z=2, _units="mm").get_id()
+    assert brep.Vertices[2].get_id() == Point(x=3, y=3, z=3, _units="mm").get_id()


 def test_trims_value_serialization():
@@ -405,7 +402,7 @@ def test_trims_value_serialization():
        0,
        1,
        1,
-        1,
+        0,
        1,
        0,
        0,
@@ -414,32 +411,82 @@ def test_trims_value_serialization():
        1,
        2,
        1,
-        0,
+        1,
    ]

-    brep.Trims[0].get_id() == BrepTrim(
-        EdgeIndex=0,
-        StartIndex=0,
-        EndIndex=0,
-        FaceIndex=0,
-        LoopIndex=0,
-        CurveIndex=0,
-        IsoStatus=1,
-        TrimType=BrepTrimTypeEnum.Boundary,
-        IsReversed=False,
-    ).get_id()
+    assert (
+        brep.Trims[0].get_id()
+        == BrepTrim(
+            EdgeIndex=0,
+            StartIndex=0,
+            EndIndex=0,
+            FaceIndex=0,
+            LoopIndex=0,
+            CurveIndex=0,
+            IsoStatus=1,
+            TrimType=BrepTrimType.Boundary,
+            IsReversed=False,
+        ).get_id()
+    )

-    brep.Trims[1].get_id() == BrepTrim(
-        EdgeIndex=1,
-        StartIndex=0,
-        EndIndex=0,
-        FaceIndex=0,
-        LoopIndex=0,
-        CurveIndex=1,
-        IsoStatus=2,
-        TrimType=BrepTrimTypeEnum.Boundary,
-        IsReversed=True,
-    ).get_id()
+    assert (
+        brep.Trims[1].get_id()
+        == BrepTrim(
+            EdgeIndex=1,
+            StartIndex=0,
+            EndIndex=0,
+            FaceIndex=0,
+            LoopIndex=0,
+            CurveIndex=1,
+            IsoStatus=2,
+            TrimType=BrepTrimType.Boundary,
+            IsReversed=True,
+        ).get_id()
+    )
+
+
+def test_loops_value_serialization():
+    brep = Brep()
+    brep.LoopsValue = [6, 0, 1, 0, 1, 2, 3]
+
+    assert brep == brep.Loops[0]._Brep  # pylint: disable=protected-access
+    assert (
+        brep.Loops[0].get_id()
+        == BrepLoop(
+            FaceIndex=0, Type=BrepLoopType(1), TrimIndices=[0, 1, 2, 3]
+        ).get_id()
+    )
+
+
+def test_edges_value_serialization():
+    brep = Brep()
+    brep.EdgesValue = [8, 0, 0, 1, 0, -8.13345756858629, 8.13345756858629, 1, 3]
+
+    assert brep == brep.Edges[0]._Brep  # pylint: disable=protected-access
+    assert (
+        brep.Edges[0].get_id()
+        == BrepEdge(
+            Curve3dIndex=0,
+            StartIndex=0,
+            EndIndex=1,
+            ProxyCurveIsReversed=False,
+            Domain=Interval(start=-8.13345756858629, end=8.13345756858629),
+            TrimIndices=[1, 3],
+        ).get_id()
+    )
+
+
+def test_faces_value_serialization():
+    brep = Brep()
+    brep.FacesValue = [4, 0, 0, 1, 0]
+
+    assert brep == brep.Faces[0]._Brep  # pylint: disable=protected-access
+    assert (
+        brep.Faces[0].get_id()
+        == BrepFace(
+            SurfaceIndex=0, OuterLoopIndex=0, OrientationReversed=True, LoopIndices=[0]
+        ).get_id()
+    )


 def test_serialized_brep_attributes(brep: Brep):
@@ -447,7 +494,16 @@ def test_serialized_brep_attributes(brep: Brep):
    serialized = operations.serialize(brep, [transport])
    serialized_dict = json.loads(serialized)

-    removed_keys = ["Surfaces", "Curve3D", "Curve2D", "Vertices", "Trims"]
+    removed_keys = [
+        "Surfaces",
+        "Curve3D",
+        "Curve2D",
+        "Vertices",
+        "Trims",
+        "Loops",
+        "Edges",
+        "Faces",
+    ]

    for k in removed_keys:
        assert k not in serialized_dict.keys()
@@ -459,6 +515,7 @@ def test_mesh_create():
    mesh = Mesh.create(vertices, faces)

    with pytest.raises(SpeckleException):
+        # pylint: disable=unused-variable
        bad_mesh = Mesh.create(vertices=7, faces=faces)

    assert mesh.vertices == vertices
@@ -1,5 +1,6 @@
 import pytest
 from specklepy.api.models import ServerInfo
+from specklepy.api.client import SpeckleClient


 class TestServer:
@@ -12,12 +13,19 @@ class TestServer:
            "lifespan": 9001,
        }

-    def test_server_get(self, client):
+    def test_server_get(self, client: SpeckleClient):
        server = client.server.get()

        assert isinstance(server, ServerInfo)

-    def test_server_apps(self, client):
+    def test_server_version(self, client: SpeckleClient):
+        version = client.server.version()
+
+        assert isinstance(version, tuple)
+        assert isinstance(version[0], int)
+        assert len(version) >= 3
+
+    def test_server_apps(self, client: SpeckleClient):
        apps = client.server.apps()

        assert isinstance(apps, list)
@@ -1,8 +1,18 @@
 import pytest
 from datetime import datetime
-from specklepy.api.models import ActivityCollection, Activity, Stream
+from specklepy.api.models import (
+    ActivityCollection,
+    Activity,
+    PendingStreamCollaborator,
+    Stream,
+    User,
+)
 from specklepy.api.client import SpeckleClient
-from specklepy.logging.exceptions import GraphQLException
+from specklepy.logging.exceptions import (
+    GraphQLException,
+    SpeckleException,
+    UnsupportedException,
+)


@pytest.mark.run(order=2)
@@ -25,6 +35,10 @@ class TestStream:
            isPublic=False,
        )

+    @pytest.fixture(scope="module")
+    def second_user(self, second_client: SpeckleClient):
+        return second_client.user.get()
+
    def test_stream_create(self, client, stream, updated_stream):
        stream.id = updated_stream.id = client.stream.create(
            name=stream.name,
@@ -79,22 +93,67 @@ class TestStream:
        assert isinstance(favorited, Stream)
        assert unfavorited.favoritedDate is None

-    def test_stream_grant_permission(self, client, stream, second_user_dict):
-        granted = client.stream.grant_permission(
+    def test_stream_grant_permission(self, client, stream, second_user):
+        # deprecated as of Speckle Server 2.6.4
+        with pytest.raises(UnsupportedException):
+            client.stream.grant_permission(
+                stream_id=stream.id,
+                user_id=second_user.id,
+                role="stream:contributor",
+            )
+
+    def test_stream_invite(
+        self, client: SpeckleClient, stream: Stream, second_user_dict: dict
+    ):
+        invited = client.stream.invite(
            stream_id=stream.id,
-            user_id=second_user_dict["id"],
-            role="stream:contributor",
+            email=second_user_dict["email"],
+            role="stream:reviewer",
+            message="welcome to my stream!",
        )

-        fetched_stream = client.stream.get(stream.id)
+        assert invited is True

-        assert granted is True
-        assert len(fetched_stream.collaborators) == 2
-        assert fetched_stream.collaborators[0].name == second_user_dict["name"]
+        # fail if no email or id
+        with pytest.raises(SpeckleException):
+            client.stream.invite(stream_id=stream.id)

-    def test_stream_revoke_permission(self, client, stream, second_user_dict):
+    def test_stream_invite_get_all_for_user(
+        self, second_client: SpeckleClient, stream: Stream
+    ):
+        # NOTE: these are user queries, but testing here to contain the flow
+        invites = second_client.user.get_all_pending_invites()
+
+        assert isinstance(invites, list)
+        assert isinstance(invites[0], PendingStreamCollaborator)
+        assert len(invites) == 1
+
+        invite = second_client.user.get_pending_invite(stream_id=stream.id)
+        assert isinstance(invite, PendingStreamCollaborator)
+
+    def test_stream_invite_use(self, second_client: SpeckleClient, stream: Stream):
+        invite: PendingStreamCollaborator = (
+            second_client.user.get_all_pending_invites()[0]
+        )
+
+        accepted = second_client.stream.invite_use(
+            stream_id=stream.id, token=invite.token
+        )
+
+        assert accepted is True
+
+    def test_stream_update_permission(
+        self, client: SpeckleClient, stream: Stream, second_user: User
+    ):
+        updated = client.stream.update_permission(
+            stream_id=stream.id, user_id=second_user.id, role="stream:contributor"
+        )
+
+        assert updated is True
+
+    def test_stream_revoke_permission(self, client, stream, second_user):
        revoked = client.stream.revoke_permission(
-            stream_id=stream.id, user_id=second_user_dict["id"]
+            stream_id=stream.id, user_id=second_user.id
        )

        fetched_stream = client.stream.get(stream.id)
@@ -102,6 +161,52 @@ class TestStream:
        assert revoked is True
        assert len(fetched_stream.collaborators) == 1

+    def test_stream_invite_cancel(
+        self,
+        client: SpeckleClient,
+        stream: Stream,
+        second_user: User,
+    ):
+        invited = client.stream.invite(
+            stream_id=stream.id,
+            user_id=second_user.id,
+            message="welcome to my stream!",
+        )
+        assert invited is True
+
+        invites = client.stream.get_all_pending_invites(stream_id=stream.id)
+
+        cancelled = client.stream.invite_cancel(
+            invite_id=invites[0].inviteId, stream_id=stream.id
+        )
+
+        assert cancelled is True
+
+    def test_stream_invite_batch(
+        self, client: SpeckleClient, stream: Stream, second_user: User
+    ):
+        # NOTE: only works for server admins
+        # invited = client.stream.invite_batch(
+        #     stream_id=stream.id,
+        #     emails=["userA@speckle.xyz", "userB@speckle.xyz"],
+        #     user_ids=[second_user.id],
+        #     message="yeehaw 🤠",
+        # )
+
+        # assert invited is True
+
+        # invited_only_email = client.stream.invite_batch(
+        #     stream_id=stream.id,
+        #     emails=["userC@speckle.xyz"],
+        #     message="yeehaw 🤠",
+        # )
+
+        # assert invited_only_email is True
+
+        # fail if no emails or user ids
+        with pytest.raises(SpeckleException):
+            client.stream.invite_batch(stream_id=stream.id)
+
    def test_stream_activity(self, client: SpeckleClient, stream: Stream):
        activity = client.stream.activity(stream.id)

@@ -0,0 +1,158 @@
+import json
+from typing import Callable
+
+import pytest
+from specklepy.api import operations
+from specklepy.logging.exceptions import SpeckleException
+from specklepy.objects.base import Base
+from specklepy.objects.encoding import CurveArray, ObjectArray
+from specklepy.objects.geometry import (
+    Line,
+    Mesh,
+    Point,
+    Vector,
+)
+from specklepy.transports.memory import MemoryTransport
+from specklepy.objects.structural.geometry import (
+    Node,
+    Element1D,
+    Element2D,
+    Restraint,
+    ElementType1D,
+    ElementType2D,
+)
+from specklepy.objects.structural.properties import (
+    Property1D,
+    Property2D,
+    SectionProfile,
+    MemberType,
+    ShapeType,
+)
+from specklepy.objects.structural.material import (
+    Material,
+)
+from specklepy.objects.structural.analysis import Model
+
+from specklepy.objects.structural.loading import LoadGravity
+
+
+@pytest.fixture()
+def point():
+    return Point(x=1, y=10, z=0)
+
+
+@pytest.fixture()
+def vector():
+    return Vector(x=0, y=0, z=-1)
+
+
+@pytest.fixture()
+def line(point, interval):
+    return Line(
+        start=point,
+        end=point,
+        domain=interval,
+        # These attributes are not handled in C#
+        # bbox=None,
+        # length=None
+    )
+
+
+@pytest.fixture()
+def mesh(box):
+    return Mesh(
+        vertices=[2, 1, 2, 4, 77.3, 5, 33, 4, 2],
+        faces=[1, 2, 3, 4, 5, 6, 7],
+        colors=[111, 222, 333, 444, 555, 666, 777],
+        bbox=box,
+        area=233,
+        volume=232.2,
+    )
+
+
+@pytest.fixture()
+def restraint():
+    return Restraint(code="FFFFFF")
+
+
+@pytest.fixture()
+def node(restraint, point):
+    return Node(basePoint=point, restraint=restraint, name="node1")
+
+
+@pytest.fixture()
+def material():
+    return Material(name="TestMaterial")
+
+
+@pytest.fixture()
+def memberType():
+    return MemberType(0)
+
+
+@pytest.fixture()
+def shapeType():
+    return ShapeType(8)
+
+
+@pytest.fixture()
+def sectionProfile(shapeType):
+    return SectionProfile(name="Test", shapeType=shapeType)
+
+
+@pytest.fixture()
+def property1D(memberType, sectionProfile, material):
+    return Property1D(
+        Material=material,
+        SectionProfile=sectionProfile,
+        memberType=memberType,
+    )
+
+
+@pytest.fixture()
+def elementType1D():
+    return ElementType1D(0)
+
+
+@pytest.fixture()
+def element1D(line, restraint, elementType1D, property1D):
+    return Element1D(
+        baseLine=line,
+        end1Releases=restraint,
+        end2Releases=restraint,
+        type=elementType1D,
+        property=property1D,
+    )
+
+
+@pytest.fixture()
+def property2D(material):
+    return Property2D(Material=material)
+
+
+@pytest.fixture()
+def elementType2D():
+    return ElementType2D(0)
+
+
+@pytest.fixture()
+def element2D(point, elementType2D):
+    return Element2D(
+        topology=[point],
+        type=elementType2D,
+    )
+
+
+@pytest.fixture()
+def loadGravity(element1D, element2D, vector):
+    return LoadGravity(elements=[element1D, element2D], gravityFactors=vector)
+
+
+@pytest.fixture()
+def model(loadGravity, element1D, element2D, material, property1D, property2D):
+    return Model(
+        loads=[loadGravity],
+        elements=[element1D, element2D],
+        materials=[material],
+        properties=[property1D, property2D],
+    )
Author	SHA1	Message	Date
izzy lyseggen	9fa6b661eb	feat(client): stream invites (#202 ) * chore: update dev container * feat(client): add server version request * docs(client): enhanced server version docstring * test(client): sever version test * test(base): type check for union type * refactor(base): move _ attrs to `RegisteringBase` * refactor: some light cleanup * chore(container): add pylint line length * feat(metrics): add "Invite Action" * feat(client): pass server version to resources * feat(models): pending stream collaborator model * fix(client): do not parse if request res is null * feat(exceptions): add unsupported exception to distinguish for new invites as of server 2.6.4 * feat(client): add stream invite queries/mutations * test(client): test stream invites * feat(client): incorporate last invites changes	2022-07-26 17:58:46 +01:00
izzy lyseggen	d1adccba00	feat(serialization): cache bases on deserialize (#200 ) * feat(serialization): cache bases on deserialize allows the deserializer to return the same instance when encountering objects with the same id closes #191 * feat(serialization): cache bases on deserialize allows the deserializer to return the same instance when encountering objects with the same id closes #191 * fix(serialization): check before accessing id obj may not be detached and therefore might not have an id * feat(serializer): cache w id from obj not base * chore: update deps * feat(operations): lil send helper on send, if `transports` is just a transport, add it to a list. i see this error a lot so just a friendly lil fix! * feat(objects): breps omg! * test(geometry): updates for breps * test(geometry): more brep serialization tests * refactor(test): formatting * style: formatting * test(geometry): clean up test file * fix(test): brep trims test fix * refactor(geometry): clean up encoding outputs * feat(objects): allow kwargs in encoding * feat(objects): align curve encodings w sharp * test(geometry): new curve encodings * feat(client): update stream permission mutation guess this changed some time recently and i wasn't made aware of it * fix(objects): brep face and edge encoding * fix(geometry): breps units 'none' fix * test(objects): fix 'none' units issue * revert(`486ea99`): use `streamGrantPermission` to be updated for next server release	2022-07-20 18:02:25 +01:00
Reynold Chan	9e30250446	Create test_structural.py (#180 )	2022-07-15 16:38:55 +01:00
Morten Engen	3e7d657e2e	feat(base): sort serializable attributes (#198 ) Sorts the serializable attributes before they are returned from .get_serializable_attributes(). Prevents the object id to change if the order of the member names from .get_member_names() changes.	2022-07-11 12:19:22 +01:00
izzy lyseggen	7484d8441b	fix(credentials): clean up sqlite transport directly after getting accts (#199 ) * fix(sqlite): use `self.close()` on del * fix(credentials): close sqlite directly after use * refactor(serializer): consolidate var name for ids	2022-07-11 10:31:19 +01:00
izzy lyseggen	682afce05f	fix(transport): call begin/end write in server (#195 ) * fix(transport): call begin/end write in server * style: remove unused code	2022-06-30 16:16:05 +01:00
izzy lyseggen	21b27e2f3b	feat(metrics): add ids for unknown users (#194 ) * feat(metrics): add `merge_ids` helper method * fix(metrics): use alias ids instead * fix(metrics): final cleanup for aliasing * fix(metrics): lol jk scratch the aliasing	2022-06-28 12:23:19 +01:00