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

.circleci/config.yml

@@ -1,16 +1,16 @@
 version: 2.1
 
 orbs:
-  python: circleci/python@1.3.2
+  python: circleci/python@2.0.3
   codecov: codecov/codecov@3.2.2
 
 jobs:
   test:
     docker:
       - image: "cimg/python:<<parameters.tag>>"
-      - image: 'cimg/node:14.18'
+      - image: "cimg/node:16.15"
-      - image: 'circleci/redis:6'
+      - image: "cimg/redis:6.2"
-      - image: 'cimg/postgres:12.8'
+      - image: "cimg/postgres:14.2"
         environment:
           POSTGRES_DB: speckle2_test
           POSTGRES_PASSWORD: speckle
@@ -27,6 +27,7 @@ jobs:
           STRATEGY_LOCAL: "true"
           CANONICAL_URL: "http://localhost:3000"
           WAIT_HOSTS: localhost:5432, localhost:6379
+          DISABLE_FILE_UPLOADS: "true"
     parameters:
       tag:
         default: "3.8"
@@ -51,7 +52,7 @@ jobs:
 
   deploy:
     docker:
-      - image: "circleci/python:3.8"
+      - image: "cimg/python:3.8"
     steps:
       - checkout
       - run: python patch_version.py $CIRCLE_TAG
@@ -60,17 +61,17 @@ jobs:
 
 workflows:
   main:
-    jobs: 
+    jobs:
       - test:
           matrix:
             parameters:
-              tag: ["3.6", "3.7", "3.8", "3.9"]
+              tag: ["3.7", "3.8", "3.9", "3.10"]
           filters:
             tags:
               only: /.*/
       - deploy:
           requires:
-            - test 
+            - test
           filters:
             tags:
               only: /[0-9]+(\.[0-9]+)*/

.devcontainer/Dockerfile

@@ -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"
+ARG VARIANT="3.10"
-FROM mcr.microsoft.com/vscode/devcontainers/python:0-${VARIANT}
+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.

.devcontainer/devcontainer.json

@@ -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",

.devcontainer/docker-compose.yaml

@@ -1,21 +1,17 @@
 version: "3.3"  # optional since v1.27.0
 services:
   postgres:
-    image: circleci/postgres:12
+    image: cimg/postgres:14.2
     environment:
       POSTGRES_DB: speckle2_test
       POSTGRES_PASSWORD: speckle
       POSTGRES_USER: speckle
-      # ports:
-      #   - "5432:5432"
     network_mode: host
   redis:
-    image: circleci/redis:6
+    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"
@@ -27,8 +23,7 @@ services:
       STRATEGY_LOCAL: "true"
       CANONICAL_URL: "http://localhost:3000"
       WAIT_HOSTS: localhost:5432, localhost:6379
-    # ports:
+      DISABLE_FILE_UPLOADS: "true"
-    #   - "3000:3000"
     network_mode: host
 
   specklepy:

.vscode/launch.json

@@ -4,6 +4,7 @@
   // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
   "version": "0.2.0",
   "configurations": [
+    
     {
       "name": "Python: Current File",
       "type": "python",
@@ -13,10 +14,13 @@
       "justMyCode": false
     },
     {
-      "name": "Python: Test debug config",
+      "name": "Pytest",
       "type": "python",
-      "request": "test",
+      "request": "launch",
+      "program": "poetry",
+      "args": ["run", "pytest"],
       "console": "integratedTerminal",
+      "justMyCode": true
     }
   ]
 }

example/many_children.py

@@ -0,0 +1,63 @@
+from typing import List
+from specklepy.objects import Base
+from specklepy.api import operations
+from specklepy.transports.sqlite import SQLiteTransport
+import time
+from pathlib import Path
+import os
+import string
+import random
+
+
+class Sub(Base):
+    bar: List[str]
+
+
+def random_string():
+    letters = string.ascii_lowercase
+    return "".join(random.choice(letters) for _ in range(10))
+
+
+BASE_PATH = SQLiteTransport.get_base_path("Speckle")
+
+
+def clean_db():
+    os.remove(Path(BASE_PATH, "Objects.db"))
+
+
+def one_pass(clean: bool, randomize: bool, child_count: int):
+
+    foo = Base()
+    for i in range(child_count):
+        stuff = random_string() if randomize else "stuff"
+        foo[f"@child_{i}"] = Sub(bar=["asdf", "bar", i, stuff])
+
+    if clean:
+        clean_db()
+    transport = SQLiteTransport()
+    start = time.time()
+    hash = operations.send(base=foo, transports=[transport])
+    send_time = time.time() - start
+
+    receive_start = time.time()
+    operations.receive(hash, transport)
+    receive_time = time.time() - receive_start
+    return send_time, receive_time
+
+
+if __name__ == "__main__":
+    sample_size = 4
+
+    test_permutations = [
+        (True, True),
+        (False, False),
+        (False, True),
+        (True, False),
+    ]
+    for clean, randomize in test_permutations:
+        print(f"CLEAN: {clean}, RANDOMIZE: {randomize}")
+        for child_count in [10, 100, 1000, 10000]:
+            print(f"\tCHILD COUNT: {child_count}")
+            for _ in range(sample_size):
+                send_time, receive_time = one_pass(clean, randomize, child_count)
+                print(f"\t\tSend: {send_time} Receive: {receive_time}")

example/using_speckle_base.py

@@ -50,10 +50,10 @@ if __name__ == "__main__":
     )
     # support for dynamic attributes
     custom_sub.extra_extra = "what is this?"
-    debug(custom_sub.json())
+    debug(custom_sub)
 
     serialized = operations.serialize(custom_sub)
     deserialized = operations.deserialize(serialized)
     # the only difference should be between the two data is that the deserialized
     # instance id attribute is not None.
-    debug(deserialized.json())
+    debug(deserialized)

pyproject.toml

@@ -11,11 +11,11 @@ homepage = "https://speckle.systems/"
 
 
 [tool.poetry.dependencies]
-python = "^3.6.5"
+python = ">=3.7.2, <4.0"
 pydantic = "^1.8.2"
 appdirs = "^1.4.4"
-gql = {version = ">=3.0.0b1", extras = ["all"], allow-prereleases = true}
+gql = {extras = ["requests", "websockets"], version = "^3.3.0"}
-ujson = "^4.3.0"
+ujson = "^5.3.0"
 Deprecated = "^1.2.13"
 
 [tool.poetry.dev-dependencies]
@@ -24,6 +24,8 @@ isort = "^5.7.0"
 pytest = "^6.2.2"
 pytest-ordering = "^0.6"
 pytest-cov = "^3.0.0"
+devtools = "^0.8.0"
+pylint = "^2.14.4"
 
 
 [tool.black]
@@ -43,7 +45,7 @@ exclude = '''
 '''
 include = '\.pyi?$'
 line-length = 88
-target-version = ["py36", "py37", "py38"]
+target-version = ["py37", "py38", "py39", "py310"]
 
 
 [build-system]

specklepy/api/client.py

@@ -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,

specklepy/api/credentials.py

@@ -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
+    token: Optional[str] = None
-    refreshToken: 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(

specklepy/api/models.py

@@ -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__()

specklepy/api/operations.py

@@ -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 = []
@@ -40,13 +43,8 @@ def send(
 
     serializer = BaseObjectSerializer(write_transports=transports)
 
-    for t in transports:
-        t.begin_write()
     obj_hash, _ = serializer.write_json(base=base)
 
-    for t in transports:
-        t.end_write()
-
     return obj_hash
 
 

specklepy/api/resource.py

@@ -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.server_version = server_version
-        self.schema = None
+        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:
+        except Exception as ex:
-            if isinstance(e, TransportQueryError):
+            if isinstance(ex, TransportQueryError):
                 return GraphQLException(
-                    message=f"Failed to execute the GraphQL {self.name} request. Errors: {e.errors}",
+                    message=f"Failed to execute the GraphQL {self.name} request. Errors: {ex.errors}",
-                    errors=e.errors,
+                    errors=ex.errors,
-                    data=e.data,
+                    data=ex.data,
                 )
             else:
                 return SpeckleException(
-                    message=f"Failed to execute the GraphQL {self.name} request. Inner exception: {e}",
+                    message=f"Failed to execute the GraphQL {self.name} request. Inner exception: {ex}",
-                    exception=e,
+                    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."
+            ),
+        )

specklepy/api/resources/__init__.py

@@ -1,6 +1,5 @@
 from pathlib import Path
 import sys
-import inspect
 import pkgutil
 from importlib import import_module
 

specklepy/api/resources/branch.py

@@ -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
 

specklepy/api/resources/commit.py

@@ -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
 

specklepy/api/resources/object.py

@@ -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
 
@@ -52,7 +50,9 @@ class Resource(ResourceBase):
         params = {"stream_id": stream_id, "object_id": object_id}
 
         return self.make_request(
-            query=query, params=params, return_type=["stream", "object", "data"]
+            query=query,
+            params=params,
+            return_type=["stream", "object", "data"],
         )
 
     def create(self, stream_id: str, objects: List[Dict]) -> str:

specklepy/api/resources/server.py

@@ -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
 

specklepy/api/resources/stream.py

@@ -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
 

specklepy/api/resources/subscriptions.py

@@ -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)

specklepy/api/resources/user.py

@@ -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,
+        )

specklepy/logging/exceptions.py

@@ -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:
+    def __init__(self, message: str, obj: Any, exception: Exception = None) -> None:
-        super().__init__(message=message)
+        super().__init__(message=message, exception=exception)
-        self.object = object
+        self.obj = obj
-        self.unhandled_type = type(object)
+        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)

specklepy/logging/metrics.py

@@ -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,8 +105,7 @@ class Singleton(type):
 class MetricsTracker(metaclass=Singleton):
     analytics_url = "https://analytics.speckle.systems/track?ip=1"
     analytics_token = "acd87c5a50b56df91a795e999812a3a4"
-    user_ip = None
+    last_user = ""
-    last_user = None
     last_server = None
     platform = None
     sending_thread = None
@@ -114,12 +117,15 @@ class MetricsTracker(metaclass=Singleton):
         )
         self.platform = PLATFORMS.get(sys.platform, "linux")
         self.sending_thread.start()
-        self.user_ip = socket.gethostbyname(socket.gethostname())
+        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:
@@ -137,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()

specklepy/objects/base.py

@@ -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 = "m"
+    _units: Union[str, None] = 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()
 
     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__()

specklepy/objects/encoding.py

@@ -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:
+    def __init__(self, data: list = None) -> None:
-        self.data = []
+        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
+            decoded_data = decoder(item_data, **kwargs)
-            try:
+            bases.append(decoded_data)
-                decoded_data = decoder(item_data)
+
-                bases.append(decoded_data)
-            except ValueError:
-                continue
         return bases
 
-    def decode(self, decoder: Callable[[List[Any]], Any]):
+    def decode(self, decoder: Callable[[List[Any]], Any], **kwargs: Dict[str, Any]):
-        return self.decode_data(data=self.data, decoder=decoder)
+        return self.decode_data(data=self.data, decoder=decoder, **kwargs)
 
-    def encode_object(self, object: Base):
+    def encode_object(self, obj: Base):
-        encoded = object.to_list()
+        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 = cls(data)
-        crv_array.data = data
         return crv_array.to_curve()
 
     def to_curves(self) -> List[Base]:

specklepy/objects/geometry.py

@@ -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 = []
+        return [
-        encoded.extend(self.origin.to_list())
+            *self.origin.to_list(),
-        encoded.extend(self.normal.to_list())
+            *self.normal.to_list(),
-        encoded.extend(self.xdir.to_list())
+            *self.xdir.to_list(),
-        encoded.extend(self.ydir.to_list())
+            *self.ydir.to_list(),
-        return encoded
+            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]),
+            start=Point.from_list(args[1:4]),
-            end=Point.from_list(args[3:6]),
+            end=Point.from_list(args[4:7]),
-            domain=Interval.from_list(args[6:9]),
+            domain=Interval.from_list(args[7:10]),
+            units=get_units_from_encoding(args[-1]),
         )
 
     def to_list(self) -> List[Any]:
-        encoded = []
+        domain = self.domain.to_list() if self.domain else [0, 1]
-        encoded.extend(self.start.to_list())
+        return [
-        encoded.extend(self.end.to_list())
+            CurveTypeEncoding.Line.value,
-        encoded.extend(self.domain.to_list())
+            *self.start.to_list(),
-        return encoded
+            *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 = []
+        return [
-        encoded.append(CurveTypeEncoding.Arc.value)
+            CurveTypeEncoding.Arc.value,
-        encoded.append(self.radius)
+            self.radius,
-        encoded.append(self.startAngle)
+            self.startAngle,
-        encoded.append(self.endAngle)
+            self.endAngle,
-        encoded.append(self.angleRadians)
+            self.angleRadians,
-        encoded.extend(self.domain.to_list())
+            *self.domain.to_list(),
-        encoded.extend(self.plane.to_list())
+            *self.plane.to_list(),
-        encoded.append(get_encoding_from_units(self.units))
+            *self.startPoint.to_list(),
-        return encoded
+            *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 = []
+        return [
-        encoded.append(CurveTypeEncoding.Circle.value)
+            CurveTypeEncoding.Circle.value,
-        encoded.append(self.radius),
+            self.radius,
-        encoded.extend(self.domain.to_list())
+            *self.domain.to_list(),
-        encoded.extend(self.plane.to_list())
+            *self.plane.to_list(),
-        encoded.append(get_encoding_from_units(self.units))
+            get_encoding_from_units(self.units),
-        return encoded
+        ]
 
 
 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 = []
+        return [
-        encoded.append(CurveTypeEncoding.Ellipse.value)
+            CurveTypeEncoding.Ellipse.value,
-        encoded.append(self.firstRadius)
+            self.firstRadius,
-        encoded.append(self.secondRadius)
+            self.secondRadius,
-        encoded.extend(self.domain.to_list())
+            *self.domain.to_list(),
-        encoded.extend(self.plane.to_list())
+            *self.plane.to_list(),
-        encoded.append(get_encoding_from_units(self.units))
+            get_encoding_from_units(self.units),
-        return encoded
+        ]
 
 
 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 = []
+        return [
-        encoded.append(CurveTypeEncoding.Polyline.value)
+            CurveTypeEncoding.Polyline.value,
-        encoded.append(int(self.closed))
+            int(self.closed),
-        encoded.extend(self.domain.to_list())
+            *self.domain.to_list(),
-        encoded.append(len(self.value))
+            len(self.value),
-        encoded.extend(self.value)
+            *self.value,
-        encoded.append(get_encoding_from_units(self.units))
+            get_encoding_from_units(self.units),
-        return encoded
+        ]
 
     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 = []
+        return [
-        encoded.append(CurveTypeEncoding.Curve.value)
+            CurveTypeEncoding.Curve.value,
-        encoded.append(self.degree)
+            self.degree,
-        encoded.append(int(self.periodic))
+            int(self.periodic),
-        encoded.append(int(self.rational))
+            int(self.rational),
-        encoded.append(int(self.closed))
+            int(self.closed),
-        encoded.extend(self.domain.to_list())
+            *self.domain.to_list(),
-        encoded.append(len(self.points))
+            len(self.points),
-        encoded.append(len(self.weights))
+            len(self.weights),
-        encoded.append(len(self.knots))
+            len(self.knots),
-        encoded.extend(self.points)
+            *self.points,
-        encoded.extend(self.weights)
+            *self.weights,
-        encoded.extend(self.knots)
+            *self.knots,
-        encoded.append(get_encoding_from_units(self.units))
+            get_encoding_from_units(self.units),
-        return encoded
+        ]
 
 
 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 = CurveArray(args[5:-1])
-        curve_arrays.data = args[4:-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 = []
+        curve_array = CurveArray.from_curves(self.segments).data
-        encoded.append(CurveTypeEncoding.Polycurve.value)
+        return [
-        encoded.append(int(self.closed))
+            CurveTypeEncoding.Polycurve.value,
-        encoded.extend(self.domain.to_list())
+            int(self.closed),
-        curve_array = CurveArray.from_curves(self.segments)
+            *self.domain.to_list(),
-        encoded.extend(curve_array.data)
+            len(curve_array),
-        encoded.append(get_encoding_from_units(self.units))
+            *curve_array,
-        return encoded
+            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 = []
+        return [
-        encoded.append(self.degreeU)
+            self.degreeU,
-        encoded.append(self.degreeV)
+            self.degreeV,
-        encoded.append(self.countU)
+            self.countU,
-        encoded.append(self.countV)
+            self.countV,
-        encoded.append(int(self.rational))
+            int(self.rational),
-        encoded.append(int(self.closedU))
+            int(self.closedU),
-        encoded.append(int(self.closedV))
+            int(self.closedV),
-        encoded.extend(self.domainU.to_list())
+            *self.domainU.to_list(),
-        encoded.extend(self.domainV.to_list())
+            *self.domainV.to_list(),
-        encoded.append(len(self.pointData))
+            len(self.pointData),
-        encoded.append(len(self.knotsU))
+            len(self.knotsU),
-        encoded.append(len(self.knotsV))
+            len(self.knotsV),
-        encoded.extend(self.pointData)
+            *self.pointData,
-        encoded.extend(self.knotsU)
+            *self.knotsU,
-        encoded.extend(self.knotsV)
+            *self.knotsV,
-        encoded.append(get_encoding_from_units(self.units))
+            get_encoding_from_units(self.units),
-        return encoded
+        ]
 
 
 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 = []
+        return [
-        encoded.append(self.EdgeIndex)
+            self.EdgeIndex,
-        encoded.append(self.StartIndex)
+            self.StartIndex,
-        encoded.append(self.EndIndex)
+            self.EndIndex,
-        encoded.append(self.FaceIndex)
+            self.FaceIndex,
-        encoded.append(self.LoopIndex)
+            self.LoopIndex,
-        encoded.append(self.CurveIndex)
+            self.CurveIndex,
-        encoded.append(self.IsoStatus)
+            self.IsoStatus,
-        encoded.append(getattr(BrepTrimTypeEnum, self.TrimType).value)
+            self.TrimType.value,
-        encoded.append(self.IsReversed)
+            int(self.IsReversed),
-        return encoded
+        ]
 
 
 class Brep(
     Base,
     speckle_type=GEOMETRY + "Brep",
     chunkable={
-        "SurfacesValue": 200,
+        "SurfacesValue": 31250,
-        "Curve3DValues": 200,
+        "Curve3DValues": 31250,
-        "Curve2DValues": 200,
+        "Curve2DValues": 31250,
-        "VerticesValue": 5000,
+        "VerticesValue": 31250,
-        "Edges": 5000,
+        "EdgesValue": 62500,
-        "Loops": 5000,
+        "LoopsValue": 62500,
-        "TrimsValue": 5000,
+        "FacesValue": 62500,
-        "Faces": 5000,
+        "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]:
+    def EdgesValue(self) -> List[BrepEdge]:
-        return self._inject_self_into_children(self._Edges)
+        return None if self.Edges is None else ObjectArray.from_objects(self.Edges).data
 
-    @Edges.setter
+    @EdgesValue.setter
-    def Edges(self, value: List[BrepEdge]):
+    def EdgesValue(self, value: List[float]):
-        self._Edges = value
+        if not value:
+            return
+
+        self.Edges = ObjectArray.decode_data(value, BrepEdge.from_list, brep=self)
 
     @property
-    def Loops(self) -> List[BrepLoop]:
+    def LoopsValue(self) -> List[BrepLoop]:
-        return self._inject_self_into_children(self._Loops)
+        return None if self.Loops is None else ObjectArray.from_objects(self.Loops).data
 
-    @Loops.setter
+    @LoopsValue.setter
-    def Loops(self, value: List[BrepLoop]):
+    def LoopsValue(self, value: List[int]):
-        self._Loops = value
+        if not value:
+            return
+
+        self.Loops = ObjectArray.decode_data(value, BrepLoop.from_list, brep=self)
 
     @property
-    def Faces(self) -> List[BrepFace]:
+    def FacesValue(self) -> List[int]:
-        return self._inject_self_into_children(self._Faces)
+        return None if self.Faces is None else ObjectArray.from_objects(self.Faces).data
 
-    @Faces.setter
+    @FacesValue.setter
-    def Faces(self, value: List[BrepFace]):
+    def FacesValue(self, value: List[int]):
-        self._Faces = value
+        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 (
-            return None
+            None
-        return ObjectArray.from_objects(self.Surfaces).data
+            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 (
-            return None
+            None if self.Curve3D is None else CurveArray.from_curves(self.Curve3D).data
-        return CurveArray.from_curves(self.Curve3D).data
+        )
 
     @Curve3DValues.setter
     def Curve3DValues(self, value: List[float]):
-        crv_array = CurveArray()
+        crv_array = CurveArray(value)
-        crv_array.data = value
         self.Curve3D = crv_array.to_curves()
 
     @property
     def Curve2DValues(self) -> List[Base]:
-        if self.Curve2D is None:
+        return (
-            return None
+            None if self.Curve2D is None else CurveArray.from_curves(self.Curve2D).data
-        return CurveArray.from_curves(self.Curve2D).data
+        )
 
     @Curve2DValues.setter
     def Curve2DValues(self, value: List[float]):
-        crv_array = CurveArray()
+        crv_array = CurveArray(value)
-        crv_array.data = value
         self.Curve2D = crv_array.to_curves()
 
     @property
@@ -742,27 +862,25 @@ class Brep(
 
         self.Vertices = vertices
 
-    @property
+    # TODO: can this be consistent with loops, edges, faces, curves, etc and prepend with the chunk list? needs to happen in sharp first
-    def Trims(self) -> List[BrepTrim]:
-        return self._inject_self_into_children(self._Trims)
-
-    @Trims.setter
-    def Trims(self, value: List[BrepTrim]):
-        self._Trims = value
-
     @property
     def TrimsValue(self) -> List[float]:
-        if self.Trims is None:
+        # return None if self.Trims is None else ObjectArray.from_objects(self.Trims).data
-            return None
+        if not self.Trims:
-        values = []
+            return
+        value = []
         for trim in self.Trims:
-            values.extend(trim.to_list())
+            value.extend(trim.to_list())
-        return values
+        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)
         ]
 
 

specklepy/objects/units.py

@@ -17,6 +17,7 @@ UNITS_STRINGS = {
 
 UNITS_ENCODINGS = {
     "none": 0,
+    None: 0,
     "mm": 1,
     "cm": 2,
     "m": 3,
@@ -58,7 +59,5 @@ def get_units_from_encoding(unit: int):
 def get_encoding_from_units(unit: str):
     try:
         return UNITS_ENCODINGS[unit]
-    except KeyError:
+    except KeyError as e:
-        raise SpeckleException(
+        raise SpeckleException(message=f"No encoding exists for unit {unit}. Please enter a valid unit to encode (eg {UNITS_ENCODINGS}).") from e
-            message=f"No encoding exists for unit {unit}. Please enter a valid unit to encode (eg {UNITS_ENCODINGS})."
-        )

specklepy/serialization/base_object_serializer.py

@@ -1,17 +1,19 @@
+import re
 import ujson
 import hashlib
-import re
+import warnings
 from uuid import uuid4
 from enum import Enum
 from warnings import warn
 from typing import Any, Dict, List, Tuple
 from specklepy.objects.base import Base, DataChunk
 from specklepy.logging.exceptions import (
-    SerializationException,
     SpeckleException,
     SpeckleWarning,
 )
 from specklepy.transports.abstract_transport import AbstractTransport
+
+# import for serialization
 import specklepy.objects.geometry
 import specklepy.objects.other
 
@@ -38,22 +40,33 @@ 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
+    detach_lineage: List[bool]  # tracks depth and whether or not to detach
-    lineage: List[str] = []  # keeps track of hash chain through the object tree
+    lineage: List[str]  # keeps track of hash chain through the object tree
-    family_tree: Dict[str, Dict[str, int]] = {}
+    family_tree: Dict[str, Dict[str, int]]
-    closure_table: 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__(
+    def __init__(self, write_transports: List[AbstractTransport] = None, read_transport=None) -> None:
-        self, write_transports: List[AbstractTransport] = [], read_transport=None
+        self.write_transports = write_transports or []
-    ) -> None:
-        self.write_transports = write_transports
         self.read_transport = read_transport
+        self.detach_lineage = []
+        self.lineage = []
+        self.family_tree = {}
+        self.closure_table = {}
+        self.deserialized = {}
 
     def write_json(self, base: Base):
-        self.__reset_writer()
+        """Serializes a given base object into a json string
-        self.detach_lineage = [True]
+        Arguments:
-        hash, obj = self.traverse_base(base)
+            base {Base} -- the base object to be decomposed and serialized
-        return hash, ujson.dumps(obj)
+
+        Returns:
+            (str, str) -- a tuple containing the object id of the base object and the serialized object string
+        """
+
+        obj_id, obj = self.traverse_base(base)
+
+        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
@@ -62,8 +75,23 @@ 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()
+
+        if self.write_transports:
+            for wt in self.write_transports:
+                wt.begin_write()
+
+        obj_id, obj = self._traverse_base(base)
+
+        if self.write_transports:
+            for wt in self.write_transports:
+                wt.end_write()
+
+        return obj_id, obj
+
+    def _traverse_base(self, base: Base) -> Tuple[str, Dict]:
         if not self.detach_lineage:
             self.detach_lineage = [True]
 
@@ -86,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(
@@ -107,8 +130,8 @@ class BaseObjectSerializer:
                     prop.startswith("@") or prop in base._detachable or chunkable
                 )
 
-            # 1. handle primitives (ints, floats, strings, and bools)
+            # 1. handle None and primitives (ints, floats, strings, and bools)
-            if isinstance(value, PRIMITIVES):
+            if value is None or isinstance(value, PRIMITIVES):
                 object_builder[prop] = value
                 continue
 
@@ -121,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"]
+                    ref_id = child_obj["id"]
-                    object_builder[prop] = self.detach_helper(ref_hash=ref_hash)
+                    object_builder[prop] = self.detach_helper(ref_id=ref_id)
                 else:
                     object_builder[prop] = child_obj
 
@@ -141,8 +164,8 @@ class BaseObjectSerializer:
                 chunk_refs = []
                 for c in chunks:
                     self.detach_lineage.append(detach)
-                    ref_hash, _ = self.traverse_base(c)
+                    ref_id, _ = self._traverse_base(c)
-                    ref_obj = self.detach_helper(ref_hash=ref_hash)
+                    ref_obj = self.detach_helper(ref_id=ref_id)
                     chunk_refs.append(ref_obj)
                 object_builder[prop] = chunk_refs
 
@@ -161,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
@@ -200,8 +223,8 @@ class BaseObjectSerializer:
             for o in obj:
                 if isinstance(o, Base):
                     self.detach_lineage.append(detach)
-                    hash, _ = self.traverse_base(o)
+                    ref_id, _ = self._traverse_base(o)
-                    detached_list.append(self.detach_helper(ref_hash=hash))
+                    detached_list.append(self.detach_helper(ref_id=ref_id))
                 else:
                     detached_list.append(self.traverse_value(o, detach))
             return detached_list
@@ -216,7 +239,7 @@ class BaseObjectSerializer:
 
         elif isinstance(obj, Base):
             self.detach_lineage.append(detach)
-            _, base_obj = self.traverse_base(obj)
+            _, base_obj = self._traverse_base(obj)
             return base_obj
 
         else:
@@ -230,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
@@ -243,19 +266,19 @@ 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][
+            if ref_id not in self.family_tree[parent] or self.family_tree[parent][
-                ref_hash
+                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",
         }
 
     def __reset_writer(self) -> None:
         """Reinitializes the lineage, and other variables that get used during the json writing process"""
-        self.detach_lineage = []
+        self.detach_lineage = [True]
         self.lineage = []
         self.family_tree = {}
         self.closure_table = {}
@@ -271,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)
 
@@ -289,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)
 
@@ -319,19 +347,25 @@ class BaseObjectSerializer:
 
             # 2. handle referenced child objects
             elif "referencedId" in value:
-                ref_hash = value["referencedId"]
+                ref_id = value["referencedId"]
-                ref_obj_str = self.read_transport.get_object(id=ref_hash)
+                ref_obj_str = self.read_transport.get_object(id=ref_id)
-                if not ref_obj_str:
+                if ref_obj_str:
-                    raise SpeckleException(
+                    ref_obj = safe_json_loads(ref_obj_str, ref_id)
-                        f"Could not find the referenced child object of id `{ref_hash}` in the given read transport: {self.read_transport.name}"
+                    base.__setattr__(prop, self.recompose_base(obj=ref_obj))
+                else:
+                    warnings.warn(
+                        f"Could not find the referenced child object of id `{ref_id}` in the given read transport: {self.read_transport.name}",
+                        SpeckleWarning,
                     )
-                ref_obj = safe_json_loads(ref_obj_str, ref_hash)
+                    base.__setattr__(prop, self.handle_value(value))
-                base.__setattr__(prop, self.recompose_base(obj=ref_obj))
 
             # 3. handle all other cases (base objects, lists, and dicts)
             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):
@@ -377,11 +411,13 @@ class BaseObjectSerializer:
             return obj
 
     def get_child(self, obj: Dict):
-        ref_hash = obj["referencedId"]
+        ref_id = obj["referencedId"]
-        ref_obj_str = self.read_transport.get_object(id=ref_hash)
+        ref_obj_str = self.read_transport.get_object(id=ref_id)
         if not ref_obj_str:
-            raise SpeckleException(
+            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)

specklepy/transports/server/server.py

@@ -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")

specklepy/transports/sqlite.py

@@ -3,7 +3,7 @@ import sys
 import time
 import sched
 import sqlite3
-from typing import Any, List, Dict
+from typing import Any, List, Dict, Tuple
 from appdirs import user_data_dir
 from contextlib import closing
 from specklepy.transports.abstract_transport import AbstractTransport
@@ -14,25 +14,29 @@ class SQLiteTransport(AbstractTransport):
     _name = "SQLite"
     _base_path: str = None
     _root_path: str = None
-    _is_writing: bool = False
-    _scheduler = sched.scheduler(time.time, time.sleep)
-    _polling_interval = 0.5  # seconds
     __connection: sqlite3.Connection = None
     app_name: str = ""
     scope: str = ""
     saved_obj_count: int = 0
+    max_size: int = None
+    _current_batch: List[Tuple[str, str]] = None
+    _current_batch_size: int = None
 
     def __init__(
         self,
         base_path: str = None,
         app_name: str = None,
         scope: str = None,
+        max_batch_size_mb: float = 10.0,
         **data: Any,
     ) -> None:
         super().__init__(**data)
         self.app_name = app_name or "Speckle"
         self.scope = scope or "Objects"
         self._base_path = base_path or self.get_base_path(self.app_name)
+        self.max_size = int(max_batch_size_mb * 1000 * 1000)
+        self._current_batch = []
+        self._current_batch_size = 0
 
         try:
             os.makedirs(self._base_path, exist_ok=True)
@@ -50,12 +54,6 @@ class SQLiteTransport(AbstractTransport):
     def __repr__(self) -> str:
         return f"SQLiteTransport(app: '{self.app_name}', scope: '{self.scope}')"
 
-    # def __write_timer_elapsed(self):
-    #     print("WRITE TIMER ELAPSED")
-    #     proc = Process(target=_run_queue, args=(self.__queue, self._root_path))
-    #     proc.start()
-    #     proc.join()
-
     @staticmethod
     def get_base_path(app_name):
         # from appdirs https://github.com/ActiveState/appdirs/blob/master/appdirs.py
@@ -74,36 +72,6 @@ class SQLiteTransport(AbstractTransport):
         path = os.path.expanduser("~/.config/")
         return os.path.join(path, app_name)
 
-    # def __consume_queue(self):
-    #     if self._is_writing or self.__queue.empty():
-    #         return
-    #     print("CONSUME QUEUE")
-    #     self._is_writing = True
-    #     while not self.__queue.empty():
-    #         data = self.__queue.get()
-    #         self.save_object(data[0], data[1])
-    #     self._is_writing = False
-
-    #     self._scheduler.enter(
-    #         delay=self._polling_interval, priority=1, action=self.__consume_queue
-    #     )
-    #     self._scheduler.run(blocking=True)
-
-    # def save_object(self, id: str, serialized_object: str) -> None:
-    #     """Adds an object to the queue and schedules it to be saved.
-
-    #     Arguments:
-    #         id {str} -- the object id
-    #         serialized_object {str} -- the full string representation of the object
-    #     """
-    #     print("SAVE OBJECT")
-    #     self.__queue.put((id, serialized_object))
-
-    #     self._scheduler.enter(
-    #         delay=self._polling_interval, priority=1, action=self.__consume_queue
-    #     )
-    #     self._scheduler.run(blocking=True)
-
     def save_object_from_transport(
         self, id: str, source_transport: AbstractTransport
     ) -> None:
@@ -117,23 +85,41 @@ class SQLiteTransport(AbstractTransport):
         self.save_object(id, serialized_object)
 
     def save_object(self, id: str, serialized_object: str) -> None:
-        """Directly saves an object into the database.
+        """
+        Adds an object to the current batch to be written to the db. If the current batch is full,
+        the batch is written to the db and the current batch is reset.
 
         Arguments:
             id {str} -- the object id
             serialized_object {str} -- the full string representation of the object
         """
+        obj_size = len(serialized_object)
+        if (
+            not self._current_batch
+            or self._current_batch_size + obj_size < self.max_size
+        ):
+            self._current_batch.append((id, serialized_object))
+            self._current_batch_size += obj_size
+            return
+
+        self.save_current_batch()
+        self._current_batch = [(id, serialized_object)]
+        self._current_batch_size = obj_size
+
+    def save_current_batch(self) -> None:
+        """Save the current batch of objects to the local db"""
         self.__check_connection()
         try:
             with closing(self.__connection.cursor()) as c:
-                c.execute(
+                c.executemany(
                     "INSERT OR IGNORE INTO objects(hash, content) VALUES(?,?)",
-                    (id, serialized_object),
+                    self._current_batch,
                 )
                 self.__connection.commit()
         except Exception as ex:
             raise SpeckleException(
-                f"Could not save the object to the local db. Inner exception: {ex}", ex
+                f"Could not save the batch of objects to the local db. Inner exception: {ex}",
+                ex,
             )
 
     def get_object(self, id: str) -> str or None:
@@ -156,10 +142,14 @@ class SQLiteTransport(AbstractTransport):
         return ret
 
     def begin_write(self):
+        self._object_cache = []
         self.saved_obj_count = 0
 
     def end_write(self):
-        pass
+        if self._current_batch:
+            self.save_current_batch()
+        self._current_batch = []
+        self._current_batch_size = 0
 
     def copy_object_and_children(
         self, id: str, target_transport: AbstractTransport
@@ -198,20 +188,4 @@ class SQLiteTransport(AbstractTransport):
             self.__connection = sqlite3.connect(self._root_path)
 
     def __del__(self):
-        self.__connection.close()
+        self.close()
-
-
-# def _run_queue(queue: Queue, root_path: str):
-#     if queue.empty():
-#         return
-#     print("RUN QUEUE")
-#     conn = sqlite3.connect(root_path)
-#     while not queue.empty():
-#         data = queue.get()
-#         with closing(conn.cursor()) as c:
-#             c.execute(
-#                 "INSERT OR IGNORE INTO objects(hash, content) VALUES(?,?)",
-#                 (data[0], data[1]),
-#             )
-#             conn.commit()
-#     conn.close()

tests/conftest.py

@@ -61,7 +61,14 @@ def second_user_dict(host):
 @pytest.fixture(scope="session")
 def client(host, user_dict):
     client = SpeckleClient(host=host, use_ssl=False)
-    client.authenticate(user_dict["token"])
+    client.authenticate_with_token(user_dict["token"])
+    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
 
 

tests/test_base.py

@@ -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"]

tests/test_geometry.py

@@ -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(
+    return Plane(origin=point, normal=vector, xdir=vector, ydir=vector, units="m")
-        origin=point,
-        normal=vector,
-        xdir=vector,
-        ydir=vector,
-    )
 
 
 @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]
+    obj = geometry_objects_dict[object_name]
-    assert hasattr(object, "to_list")
+    assert hasattr(obj, "to_list")
-    assert hasattr(object, "from_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.Surfaces is None
-    assert brep.SurfacesValue == 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.Curve2D is None
-    assert brep.Curve2DValues == 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.Curve3D is None
-    assert brep.Curve3DValues == 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()
+    assert 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()
+    assert 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[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(
+    assert (
-        EdgeIndex=0,
+        brep.Trims[0].get_id()
-        StartIndex=0,
+        == BrepTrim(
-        EndIndex=0,
+            EdgeIndex=0,
-        FaceIndex=0,
+            StartIndex=0,
-        LoopIndex=0,
+            EndIndex=0,
-        CurveIndex=0,
+            FaceIndex=0,
-        IsoStatus=1,
+            LoopIndex=0,
-        TrimType=BrepTrimTypeEnum.Boundary,
+            CurveIndex=0,
-        IsReversed=False,
+            IsoStatus=1,
-    ).get_id()
+            TrimType=BrepTrimType.Boundary,
+            IsReversed=False,
+        ).get_id()
+    )
 
-    brep.Trims[1].get_id() == BrepTrim(
+    assert (
-        EdgeIndex=1,
+        brep.Trims[1].get_id()
-        StartIndex=0,
+        == BrepTrim(
-        EndIndex=0,
+            EdgeIndex=1,
-        FaceIndex=0,
+            StartIndex=0,
-        LoopIndex=0,
+            EndIndex=0,
-        CurveIndex=1,
+            FaceIndex=0,
-        IsoStatus=2,
+            LoopIndex=0,
-        TrimType=BrepTrimTypeEnum.Boundary,
+            CurveIndex=1,
-        IsReversed=True,
+            IsoStatus=2,
-    ).get_id()
+            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

tests/test_server.py

@@ -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)

tests/test_stream.py

@@ -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):
+    def test_stream_grant_permission(self, client, stream, second_user):
-        granted = client.stream.grant_permission(
+        # 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"],
+            email=second_user_dict["email"],
-            role="stream:contributor",
+            role="stream:reviewer",
+            message="welcome to my stream!",
         )
 
-        fetched_stream = client.stream.get(stream.id)
+        assert invited is True
 
-        assert granted is True
+        # fail if no email or id
-        assert len(fetched_stream.collaborators) == 2
+        with pytest.raises(SpeckleException):
-        assert fetched_stream.collaborators[0].name == second_user_dict["name"]
+            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)
 

tests/test_structural.py

@@ -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],
+    )