formatting by save

.circleci/config.yml

@@ -1,15 +1,108 @@
 version: 2.1
 
-# Define the jobs we want to run for this project
-jobs:
-  build:
-    docker:
-      - image: cimg/base:2023.03
-    steps:
-      - run: echo "so long and thanks for all the fish"
+orbs:
+  codecov: codecov/codecov@3.3.0
+
+jobs:
+  pre-commit:
+    parameters:
+      config_file:
+        default: ./.pre-commit-config.yaml
+        description: Optional, path to pre-commit config file.
+        type: string
+      cache_prefix:
+        default: ''
+        description: |
+          Optional cache prefix to be used on CircleCI. Can be used for cache busting or to ensure multiple jobs use different caches.
+        type: string
+    docker:
+      - image: speckle/pre-commit-runner:latest
+    resource_class: medium
+    steps:
+      - checkout
+      - restore_cache:
+          keys:
+            - cache-pre-commit-<<parameters.cache_prefix>>-{{ checksum "<<parameters.config_file>>" }}
+      - run:
+          name: Install pre-commit hooks
+          command: pre-commit install-hooks --config <<parameters.config_file>>
+      - save_cache:
+          key: cache-pre-commit-<<parameters.cache_prefix>>-{{ checksum "<<parameters.config_file>>" }}
+          paths:
+            - ~/.cache/pre-commit
+      - run:
+          name: Run pre-commit
+          command: pre-commit run --all-files
+      - run:
+          command: git --no-pager diff
+          name: git diff
+          when: on_fail
+
+  test:
+    machine:
+      image: ubuntu-2204:2023.02.1
+      docker_layer_caching: false
+    resource_class: medium
+    parameters:
+      tag:
+        default: "3.11"
+        type: string
+    steps:
+      - checkout
+      - run:
+          name: Install python
+          command: |
+            pyenv install -s << parameters.tag >>
+            pyenv global << parameters.tag >>
+      - run:
+          name: Startup the Speckle Server
+          command: docker compose -f docker-compose.yml up -d
+      - run:
+          name: Install Poetry
+          command: |
+            pip install poetry
+      - run:
+          name: Install packages
+          command: poetry install
+      - run:
+          name: Run tests
+          command: poetry run pytest --cov --cov-report xml:reports/coverage.xml --junitxml=reports/test-results.xml
+      - store_test_results:
+          path: reports
+      - store_artifacts:
+          path: reports
+      - codecov/upload
+
+  deploy:
+    docker:
+      - image: "cimg/python:3.8"
+    steps:
+      - checkout
+      - run: python patch_version.py $CIRCLE_TAG
+      - run: poetry build
+      - run: poetry publish -u __token__ -p $PYPI_TOKEN
 
-# Orchestrate our job run sequence
 workflows:
-  build_and_test:
+  main:
     jobs:
-      - build
+      - pre-commit:
+          filters:
+            tags:
+              only: /.*/
+      - test:
+          matrix:
+            parameters:
+              tag: ["3.11"]
+          filters:
+            tags:
+              only: /.*/
+      - deploy:
+          context: pypi
+          requires:
+            - pre-commit
+            - test
+          filters:
+            tags:
+              only: /[0-9]+(\.[0-9]+)*/
+            branches:
+              ignore: /.*/ # For testing only! /ci\/.*/

.github/workflows/github-action.yml

@@ -1,56 +0,0 @@
-name: "Specklepy test and build"
-on:
-  # pull_request:
-  #   branches:
-  #     - 'v3-dev'
-  push:
-    branches:
-      - "gergo/uvSetup"
-jobs:
-  ci:
-    name: continuous-integration
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version:
-          - "3.10"
-          - "3.11"
-          - "3.12"
-          - "3.13"
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Install uv and set the python version
-        uses: astral-sh/setup-uv@v5
-        with:
-          python-version: ${{ matrix.python-version }}
-          enable-cache: true
-          cache-dependency-glob: "uv.lock"
-
-      - name: Install the project
-        run: uv sync --all-extras --dev
-
-      - uses: actions/cache@v3
-        with:
-          path: ~/.cache/pre-commit/
-          key: ${{ hashFiles('.pre-commit-config.yaml') }}
-
-      - name: Run pre-commit
-        run: uv run pre-commit run --all-files
-
-      # - name: Run Speckle Server
-      #   run: docker compose up -d
-
-      # - name: Run tests
-      #   run: uv run pytest --cov --cov-report xml:reports/coverage.xml --junitxml=reports/test-results.xml
-
-      # - uses: codecov/codecov-action@v5
-      #   if: matrix.python-version == 3.13
-      #   with:
-      #     fail_ci_if_error: true # optional (default = false)
-      #     files: ./reports/test-results.xml # optional
-      #     token: ${{ secrets.CODECOV_TOKEN }}
-
-      - name: Minimize uv cache
-        run: uv cache prune --ci

.github/workflows/publish.yml

@@ -1,36 +0,0 @@
-# Publish a release to PyPI.
-# name: 'Publish to PyPI'
-
-# on:
-  # push:
-  #   branches:
-  #     - 'gergo/uvSetup'
-
-# jobs:
-#   pypi-publish:
-#     name: Upload to PyPI
-#     runs-on: ubuntu-latest
-#     environment:
-#       name: release
-#     permissions:
-#       # For PyPI's trusted publishing.
-#       id-token: write
-#     steps:
-#       - name: 'Install uv'
-#         uses: astral-sh/setup-uv@v5
-#       - uses: actions/checkout@v4
-#         with:
-#           # This is necessary so that we have the tags.
-#           fetch-depth: 0
-#       - uses: mtkennerly/dunamai-action@v1
-#         with:
-#           env-var: MY_VERSION
-#           args: --style semver
-#       - run: echo $MY_VERSION
-#       - name: 'Build artifacts'
-#         run: uv build
-#       - name: Publish to PyPi
-#         run: uv publish --publish-url https://test.pypi.org/simple/
-
-#       - name: Test package install
-#         run: uv run --with specklepy --no-project -- python -c "import specklepy"

.pre-commit-config.yaml

@@ -1,31 +1,33 @@
 repos:
-  - repo: local
+  - repo: https://github.com/charliermarsh/ruff-pre-commit
     hooks:
-      # Run the linter.
       - id: ruff
-        name: ruff lint
-        entry: uv run ruff check --force-exclude
-        language: system
-        types_or: [python, pyi]
-      # Run the formatter.
-      - id: ruff-format
-        name: ruff format
-        entry: uv run ruff format --force-exclude
-        language: system
-        types_or: [python, pyi]
-
+    rev: v0.8.2
 
   - repo: https://github.com/commitizen-tools/commitizen
     hooks:
       - id: commitizen
       - id: commitizen-branch
         stages:
-          - pre-push
+          - push
     rev: v3.13.0
 
+  - repo: https://github.com/pycqa/isort
+    rev: 5.13.2
+    hooks:
+      - id: isort
 
+  - repo: https://github.com/psf/black
+    rev: 24.10.0
+    hooks:
+      - id: black
+        # It is recommended to specify the latest version of Python
+        # supported by your project here, or alternatively use
+        # pre-commit's default_language_version, see
+        # https://pre-commit.com/#top_level-default_language_version
+        # language_version: python3.11
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v5.0.0
+    rev: v4.5.0
     hooks:
       - id: end-of-file-fixer
       - id: trailing-whitespace

README.md

@@ -25,25 +25,25 @@ Head to the [**📚 specklepy docs**](https://speckle.guide/dev/python.html) for
 
 ### Installation
 
-This project uses uv for dependency management, make sure you follow the official [docs](https://docs.astral.sh/uv/) to get it.
+This project uses python-poetry for dependency management, make sure you follow the official [docs](https://python-poetry.org/docs/#installation) to get poetry.
 
-To create a new virtual environment with uv run `$ uv venv` and follow the instructions on the screen to activate the virtual environment.
-To bootstrap the project environment run `$ uv sync`. This will install both the package and dev dependencies.
+To bootstrap the project environment run `$ poetry install`. This will create a new virtual-env for the project and install both the package and dev dependencies.
 
-To execute any python script run `$ uv run python my_script.py`
+If this is your first time using poetry and you're used to creating your venvs within the project directory, run `poetry config virtualenvs.in-project true` to configure poetry to do the same.
 
-> Alternatively you may roll your own virtual-env with either venv, virtualenv, pyenv-virtualenv etc. Uv will play along an recognize if it is invoked from inside a virtual environment.
+To execute any python script run `$ poetry run python my_script.py`
+
+> Alternatively you may roll your own virtual-env with either venv, virtualenv, pyenv-virtualenv etc. Poetry will play along an recognize if it is invoked from inside a virtual environment.
 
 ### Style guide
 
-All our repo wide styling linting and other rules are checked and enforced by `pre-commit`, which is included in the dev dependencies.
+All our repo  wide styling linting and other rules are checked and enforced by `pre-commit`, which is included in the dev dependencies.
 It is recommended to set up `pre-commit` after installing the dependencies by running `$ pre-commit install`.
 Commiting code that doesn't adhere to the given rules, will fail the checks in our CI system.
 
 ### Local Data Paths
 
 It may be helpful to know where the local accounts and object cache dbs are stored. Depending on on your OS, you can find the dbs at:
-
 - Windows: `APPDATA` or `<USER>\AppData\Roaming\Speckle`
 - Linux: `$XDG_DATA_HOME` or by default `~/.local/share/Speckle`
 - Mac: `~/.config/Speckle`

docker-compose.yml

@@ -6,7 +6,7 @@ services:
   # Speckle Server dependencies
   #######
   postgres:
-    image: "postgres:16-alpine"
+    image: "postgres:14.5-alpine"
     restart: always
     environment:
       POSTGRES_DB: speckle
@@ -53,6 +53,12 @@ services:
   # Speckle Server
   #######
 
+  speckle-frontend:
+    image: speckle/speckle-frontend-2:latest
+    restart: always
+    ports:
+      - "0.0.0.0:8080:8080"
+
   speckle-server:
     image: speckle/speckle-server:latest
     restart: always

example/units_none.py

@@ -1,8 +1,8 @@
 from devtools import debug
 
 from specklepy.api import operations
-from specklepy.objects_v2.geometry import Base
-from specklepy.objects_v2.units import Units
+from specklepy.objects.geometry import Base
+from specklepy.objects.units import Units
 
 dct = {
     "id": "1234abcd",

patch_version.py

@@ -0,0 +1,31 @@
+import re
+import sys
+
+
+def patch(tag):
+    print(f"Patching version: {tag}")
+
+    with open("pyproject.toml", "r") as f:
+        lines = f.readlines()
+
+        if "version" not in lines[2]:
+            raise Exception("Invalid pyproject.toml. Could not patch version.")
+
+        lines[2] = f'version = "{tag}"\n'
+        with open("pyproject.toml", "w") as file:
+            file.writelines(lines)
+
+
+def main():
+    if len(sys.argv) < 2:
+        return
+
+    tag = sys.argv[1]
+    if not re.match(r"[0-9]+(\.[0-9]+)*$", tag):
+        raise ValueError(f"Invalid tag provided: {tag}")
+
+    patch(tag)
+
+
+if __name__ == "__main__":
+    main()

pyproject.toml

@@ -1,70 +1,75 @@
-[project]
-dynamic = ["version"]
+[tool.poetry]
 name = "specklepy"
+version = "2.17.14"
 description = "The Python SDK for Speckle 2.0"
 readme = "README.md"
-authors = [{ name = "Speckle Systems", email = "devops@speckle.systems" }]
-license = { text = "Apache-2.0" }
-requires-python = ">=3.10.0, <4.0"
-dependencies = [
-  "appdirs>=1.4.4",
-  "attrs>=24.3.0",
-  "deprecated>=1.2.15",
-  "gql[requests,websockets]>=3.5.0",
-  "httpx>=0.28.1",
-  "pydantic>=2.10.5",
-  "pydantic-settings>=2.7.1",
-  "stringcase>=1.2.0",
-  "ujson>=5.10.0",
-]
-
-[dependency-groups]
-dev = [
-  "commitizen>=4.1.0",
-  "devtools>=0.12.2",
-  "pre-commit>=4.0.1",
-  "pytest>=8.3.4",
-  "pytest-asyncio>=0.25.2",
-  "pytest-cov>=6.0.0",
-  "pytest-ordering>=0.6",
-  "ruff>=0.9.2",
-  "types-deprecated>=1.2.15.20241117",
-  "types-requests>=2.32.0.20241016",
-  "types-ujson>=5.10.0.20240515",
-]
-
-[project.urls]
-repository = "https://github.com/specklesystems/specklepy"
+authors = ["Speckle Systems <devops@speckle.systems>"]
+license = "Apache-2.0"
+repository = "https://github.com/specklesystems/speckle-py"
 documentation = "https://speckle.guide/dev/py-examples.html"
 homepage = "https://speckle.systems/"
+packages = [
+  { include = "specklepy", from = "src" },
+  { include = "speckle_automate", from = "src" },
+]
 
-[build-system]
-requires = ["setuptools>=64", "setuptools-scm>=8"]
-build-backend = "setuptools.build_meta"
 
-[tool.setuptools_scm]
+[tool.poetry.dependencies]
+python = ">=3.10.0, <4.0"
+pydantic = "^2.5"
+appdirs = "^1.4.4"
+gql = { extras = ["requests", "websockets"], version = "^3.3.0" }
+ujson = "^5.3.0"
+Deprecated = "^1.2.13"
+stringcase = "^1.2.0"
+attrs = "^23.1.0"
+httpx = "^0.25.0"
+pydantic-settings = "^2.6.1"
+
+[tool.poetry.group.dev.dependencies]
+black = "24.10.0"
+isort = "^5.13.2"
+pytest = "^7.1.3"
+pytest-asyncio = "^0.23.0"
+pytest-ordering = "^0.6"
+pytest-cov = "^3.0.0"
+devtools = "^0.8.0"
+pylint = "^3.3.2"
+pydantic-settings = "^2.3.0"
+mypy = "^0.982"
+pre-commit = "^2.20.0"
+commitizen = "^3.13.0"
+ruff = "^0.8.2"
+types-deprecated = "^1.2.9"
+types-ujson = "^5.6.0.0"
+types-requests = "^2.28.11.5"
+
+[tool.black]
+exclude = '''
+/(
+    \.eggs
+  | \.git
+  | \.hg
+  | \.mypy_cache
+  | \.tox
+  | \.venv
+  | _build
+  | buck-out
+  | build
+  | dist
+)/
+'''
+include = '\.pyi?$'
+line-length = 88
+target-version = ["py39", "py310", "py311", "py312", "py313"]
 
 [tool.commitizen]
 name = "cz_conventional_commits"
 version = "2.9.2"
 tag_format = "$version"
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
 
-[tool.ruff]
-exclude = [".venv", "**/*.yml"]
-
-[tool.ruff.lint]
-select = [
-  # pycodestyle
-  "E",
-  # Pyflakes
-  "F",
-  # pyupgrade
-  "UP",
-  # flake8-bugbear
-  "B",
-  # flake8-simplify
-  "SIM",
-  # isort
-  "I",
-]
-ignore = ["UP006", "UP007", "UP035"]
+[tool.isort]
+profile = "black"

src/speckle_automate/automation_context.py

@@ -96,23 +96,13 @@ class AutomationContext:
 
     def receive_version(self) -> Base:
         """Receive the Speckle project version that triggered this automation run."""
-        # TODO: this is a quick hack to keep implementation consistency.
-        # Move to proper receive many versions
+        # TODO: this is a quick hack to keep implementation consistency. Move to proper receive many versions
         version_id = self.automation_run_data.triggers[0].payload.version_id
         commit = self.speckle_client.commit.get(
             self.automation_run_data.project_id, version_id
         )
-        if not commit or not commit.referencedObject:
-            raise ValueError(
-                f"""\
-                             Could not receive specified version.
-                             {"The commit has no referencedObject." if not commit.referencedObject else ""}
-                             Is your environment configured correctly?
-                             project_id: {self.automation_run_data.project_id}
-                             model_id: {self.automation_run_data.triggers[0].payload.model_id}
-                             version_id: {self.automation_run_data.triggers[0].payload.version_id}
-                             """
-            )
+        if not commit.referencedObject:
+            raise ValueError("The commit has no referencedObject, cannot receive it.")
         base = operations.receive(
             commit.referencedObject, self._server_transport, self._memory_transport
         )
@@ -274,8 +264,7 @@ class AutomationContext:
 
         if not path_obj.exists():
             raise ValueError("The given file path doesn't exist")
-
-        files = {path_obj.name: path_obj.open("rb")}
+        files = {path_obj.name: open(str(path_obj), "rb")}
 
         url = (
             f"{self.automation_run_data.speckle_server_url}api/stream/"

src/speckle_automate/runner.py

@@ -128,8 +128,7 @@ def execute_automate_function(
                 automate_function,  # type: ignore
             )
 
-        # if we've gotten this far,
-        # the execution should technically be completed as expected
+        # if we've gotten this far, the execution should technically be completed as expected
         # thus exiting with 0 is the schemantically correct thing to do
         exit_code = (
             1 if automation_context.run_status == AutomationStatus.EXCEPTION else 0
@@ -191,4 +190,4 @@ def run_function(
         if not automation_context.context_view:
             automation_context.set_context_view()
         automation_context.report_run_status()
-    return automation_context
+        return automation_context

src/specklepy/api/client.py

@@ -1,5 +1,3 @@
-import contextlib
-
 from deprecated import deprecated
 
 from specklepy.api.credentials import Account
@@ -42,8 +40,7 @@ class SpeckleClient(CoreSpeckleClient):
     client = SpeckleClient(host="app.speckle.systems") # or whatever your host is
     # client = SpeckleClient(host="localhost:3000", use_ssl=False) or use local server
 
-    # authenticate the client with an account
-    # (account has been added in Speckle Manager)
+    # authenticate the client with an account (account has been added in Speckle Manager)
     account = get_default_account()
     client.authenticate_with_account(account)
 
@@ -77,9 +74,10 @@ class SpeckleClient(CoreSpeckleClient):
         )
 
         server_version = None
-
-        with contextlib.suppress(Exception):
+        try:
             server_version = self.server.version()
+        except Exception:
+            pass
 
         self.other_user = OtherUserResource(
             account=self.account,

src/specklepy/api/credentials.py

@@ -2,11 +2,8 @@ from typing import List, Optional
 
 # following imports seem to be unnecessary, but they need to stay
 # to not break the scripts using these functions as non-core
-from specklepy.core.api.credentials import (  # noqa: F401
-    Account,
-    StreamWrapper,  # noqa: F401
-    UserInfo,
-)
+from specklepy.core.api.credentials import StreamWrapper  # noqa: F401
+from specklepy.core.api.credentials import Account, UserInfo  # noqa: F401
 from specklepy.core.api.credentials import (
     get_account_from_token as core_get_account_from_token,
 )

src/specklepy/api/operations.py

@@ -53,9 +53,7 @@ def receive(
     return _untracked_receive(obj_id, remote_transport, local_transport)
 
 
-def serialize(
-    base: Base, write_transports: List[AbstractTransport] | None = None
-) -> str:
+def serialize(base: Base, write_transports: List[AbstractTransport] = []) -> str:
     """
     Serialize a base object. If no write transports are provided,
     the object will be serialized
@@ -69,8 +67,6 @@ def serialize(
     Returns:
         str -- the serialized object
     """
-    if not write_transports:
-        write_transports = []
     metrics.track(metrics.SDK, custom_props={"name": "Serialize"})
     return core_serialize(base, write_transports)
 

src/specklepy/api/resources/current/active_user_resource.py

@@ -138,8 +138,7 @@ class ActiveUserResource(CoreResource):
             token (Optional[str]): The token of the invite to look for (optional).
 
         Returns:
-            Optional[PendingStreamCollaborator]: The invite for the given stream,
-            or None if not found.
+            Optional[PendingStreamCollaborator]: The invite for the given stream, or None if not found.
         """
         metrics.track(metrics.SDK, self.account, {"name": "User Active Invite Get"})
         return super().get_pending_invite(stream_id, token)

src/specklepy/api/resources/current/other_user_resource.py

@@ -20,10 +20,8 @@ from specklepy.logging.exceptions import SpeckleException
 class OtherUserResource(CoreResource):
     """
     Provides API access to other users' profiles and activities on the platform.
-    This class enables fetching limited information about users,
-    searching for users by name or email,
-    and accessing user activity logs with appropriate privacy
-    and access control measures in place.
+    This class enables fetching limited information about users, searching for users by name or email,
+    and accessing user activity logs with appropriate privacy and access control measures in place.
     """
 
     def __init__(self, account, basepath, client, server_version) -> None:
@@ -66,8 +64,7 @@ class OtherUserResource(CoreResource):
             limit (int): Maximum number of search results to return.
 
         Returns:
-            Union[List[LimitedUser], SpeckleException]:
-                A list of users matching the search
+            Union[List[LimitedUser], SpeckleException]: A list of users matching the search
                 query or an exception if the query is too short.
         """
         if len(search_query) < 3:
@@ -89,8 +86,8 @@ class OtherUserResource(CoreResource):
         cursor: Optional[datetime] = None,
     ) -> ActivityCollection:
         """
-        Retrieves a collection of activities for a specified user,
-        with optional filters for activity type, time frame, and pagination.
+        Retrieves a collection of activities for a specified user, with optional filters for activity type,
+        time frame, and pagination.
 
         Args:
             user_id (str): The ID of the user whose activities are being requested.
@@ -101,8 +98,7 @@ class OtherUserResource(CoreResource):
             cursor (Optional[datetime]): Timestamp for pagination cursor.
 
         Returns:
-            ActivityCollection: A collection of user activities filtered
-            according to specified criteria.
+            ActivityCollection: A collection of user activities filtered according to specified criteria.
         """
         metrics.track(metrics.SDK, self.account, {"name": "Other User Activity"})
         return super().activity(user_id, limit, action_type, before, after, cursor)

src/specklepy/api/resources/current/server_resource.py

@@ -31,8 +31,7 @@ class ServerResource(CoreResource):
             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
+        # not tracking as it will be called along with other mutations / queries as a check
         return super().version()
 
     def apps(self) -> Dict:

src/specklepy/core/api/client.py

@@ -1,4 +1,3 @@
-import contextlib
 import re
 from typing import Dict
 from warnings import warn
@@ -50,8 +49,7 @@ class SpeckleClient:
     client = SpeckleClient(host="app.speckle.systems") # or whatever your host is
     # client = SpeckleClient(host="localhost:3000", use_ssl=False) or use local server
 
-    # authenticate the client with an account
-    # (account has been added in Speckle Manager)
+    # authenticate the client with an account (account has been added in Speckle Manager)
     account = get_default_account()
     client.authenticate_with_account(account)
 
@@ -104,8 +102,7 @@ class SpeckleClient:
 
         self._init_resources()
 
-        # ? Check compatibility with the server
-        # - i think we can skip this at this point? save a request
+        # ? Check compatibility with the server - i think we can skip this at this point? save a request
         # try:
         #     server_info = self.server.get()
         #     if isinstance(server_info, Exception):
@@ -190,10 +187,9 @@ class SpeckleClient:
                 if ex.exception.code == 403:
                     warn(
                         SpeckleWarning(
-                            "Possibly invalid token - could not authenticate "
-                            f"Speckle Client for server {self.url}"
-                        ),
-                        stacklevel=2,
+                            "Possibly invalid token - could not authenticate Speckle Client"
+                            f" for server {self.url}"
+                        )
                     )
                 else:
                     raise ex
@@ -207,8 +203,10 @@ class SpeckleClient:
         )
 
         server_version = None
-        with contextlib.suppress(Exception):
+        try:
             server_version = self.server.version()
+        except Exception:
+            pass
 
         self.other_user = OtherUserResource(
             account=self.account,
@@ -285,7 +283,7 @@ class SpeckleClient:
             return attr.Resource(
                 account=self.account, basepath=self.url, client=self.httpclient
             )
-        except AttributeError as ex:
+        except AttributeError:
             raise SpeckleException(
                 f"Method {name} is not supported by the SpeckleClient class"
-            ) from ex
+            )

src/specklepy/core/api/models/current.py

@@ -55,8 +55,7 @@ class ServerConfiguration(BaseModel):
     objectSizeLimitBytes: int
 
 
-# Keeping this one all Optionals at the minute,
-#  because its used both as a deserialization model for GQL and Account Management
+# Keeping this one all Optionals at the minute, because its used both as a deserialization model for GQL and Account Management
 class ServerInfo(BaseModel):
     name: Optional[str] = None
     company: Optional[str] = None
@@ -127,7 +126,7 @@ class Version(BaseModel):
 
 
 class Model(BaseModel):
-    author: Optional[LimitedUser]
+    author: LimitedUser
     createdAt: datetime
     description: Optional[str]
     displayName: str

src/specklepy/core/api/models/deprecated.py

@@ -4,10 +4,7 @@ from typing import List, Optional
 from deprecated import deprecated
 from pydantic import BaseModel, Field
 
-FE1_DEPRECATION_REASON = (
-    "Stream/Branch/Commit API is now deprecated, "
-    "Use the new Project/Model/Version API functions in Client"
-)
+FE1_DEPRECATION_REASON = "Stream/Branch/Commit API is now deprecated, Use the new Project/Model/Version API functions in Client}"
 FE1_DEPRECATION_VERSION = "2.20"
 
 

src/specklepy/core/api/operations.py

@@ -70,8 +70,7 @@ def receive(
 
     serializer = BaseObjectSerializer(read_transport=local_transport)
 
-    # try local transport first. if the parent is there, we assume all the children
-    # are there and continue with deserialization using the local transport
+    # try local transport first. if the parent is there, we assume all the children are there and continue with deserialization using the local transport
     obj_string = local_transport.get_object(obj_id)
     if obj_string:
         return serializer.read_json(obj_string=obj_string)
@@ -91,9 +90,7 @@ def receive(
     return serializer.read_json(obj_string=obj_string)
 
 
-def serialize(
-    base: Base, write_transports: List[AbstractTransport] | None = None
-) -> str:
+def serialize(base: Base, write_transports: List[AbstractTransport] = []) -> str:
     """
     Serialize a base object. If no write transports are provided,
     the object will be serialized
@@ -107,8 +104,6 @@ def serialize(
     Returns:
         str -- the serialized object
     """
-    if not write_transports:
-        write_transports = []
     serializer = BaseObjectSerializer(write_transports=write_transports)
 
     return serializer.write_json(base)[1]

src/specklepy/core/api/resource.py

@@ -18,7 +18,7 @@ from specklepy.transports.sqlite import SQLiteTransport
 T = TypeVar("T", bound=BaseModel)
 
 
-class ResourceBase:
+class ResourceBase(object):
     def __init__(
         self,
         account: Account,
@@ -101,8 +101,7 @@ class ResourceBase:
         parse_response: bool = True,
     ) -> Any:
         """Executes the GraphQL query"""
-        # This method has quite complex and ambiguous typing,
-        # and counter-intuitive error handling
+        # This method has quite complex and ambiguous typing, and counter-intuitive error handling
         # We are going to phase it out in favour of `make_request_and_parse_response`
         try:
             with self.__lock:

src/specklepy/core/api/resources/current/active_user_resource.py

@@ -37,12 +37,10 @@ class ActiveUserResource(ResourceBase):
         self.schema = User
 
     def get(self) -> Optional[User]:
-        """Gets the currently active user profile
-        (as extracted from the authorization header)
+        """Gets the currently active user profile (as extracted from the authorization header)
 
         Returns:
-            User -- the requested user, or none if no authentication token
-            is provided to the Client
+            User -- the requested user, or none if no authentication token is provided to the Client
         """
         QUERY = gql(
             """

src/specklepy/core/api/resources/current/model_resource.py

@@ -76,24 +76,14 @@ class ModelResource(ResourceBase):
     ) -> ModelWithVersions:
         QUERY = gql(
             """
-            query ModelGetWithVersions(
-              $modelId: String!,
-              $projectId: String!,
-              $versionsLimit: Int!,
-              $versionsCursor: String,
-              $versionsFilter: ModelVersionsFilter
-              ) {
+            query ModelGetWithVersions($modelId: String!, $projectId: String!, $versionsLimit: Int!, $versionsCursor: String, $versionsFilter: ModelVersionsFilter) {
               data:project(id: $projectId) {
                 data:model(id: $modelId) {
                   id
                   name
                   previewUrl
                   updatedAt
-                  versions(
-                    limit: $versionsLimit,
-                    cursor: $versionsCursor,
-                    filter: $versionsFilter
-                    ) {
+                  versions(limit: $versionsLimit, cursor: $versionsCursor, filter: $versionsFilter) {
                     items {
                       id
                       referencedObject
@@ -158,18 +148,9 @@ class ModelResource(ResourceBase):
     ) -> ResourceCollection[Model]:
         QUERY = gql(
             """
-            query ProjectGetWithModels(
-              $projectId: String!,
-              $modelsLimit: Int!,
-              $modelsCursor: String,
-              $modelsFilter: ProjectModelsFilter
-              ) {
+            query ProjectGetWithModels($projectId: String!, $modelsLimit: Int!, $modelsCursor: String, $modelsFilter: ProjectModelsFilter) {
               data:project(id: $projectId) {
-                data:models(
-                  limit: $modelsLimit,
-                  cursor: $modelsCursor,
-                  filter: $modelsFilter
-                  ) {
+                data:models(limit: $modelsLimit, cursor: $modelsCursor, filter: $modelsFilter) {
                   items {
                     id
                     name

src/specklepy/core/api/resources/current/other_user_resource.py

@@ -74,9 +74,7 @@ class OtherUserResource(ResourceBase):
         archived: bool = False,
         emailOnly: bool = False,
     ) -> UserSearchResultCollection:
-        """
-        Searches for a user on the server, by name or email.
-        The search query must be at least
+        """Searches for a user on the server, by name or email. The search query must be at least
         3 characters long
 
         Arguments:
@@ -91,20 +89,8 @@ class OtherUserResource(ResourceBase):
 
         QUERY = gql(
             """
-            query UserSearch(
-                $query: String!,
-                $limit: Int!,
-                $cursor: String,
-                $archived: Boolean,
-                $emailOnly: Boolean
-            ) {
-              data:userSearch(
-                query: $query,
-                limit: $limit,
-                cursor: $cursor,
-                archived: $archived,
-                emailOnly: $emailOnly
-                ) {
+            query UserSearch($query: String!, $limit: Int!, $cursor: String, $archived: Boolean, $emailOnly: Boolean) {
+              data:userSearch(query: $query, limit: $limit, cursor: $cursor, archived: $archived, emailOnly: $emailOnly) {
                 cursor
                 items {
                  id

src/specklepy/core/api/resources/current/project_invite_resource.py

@@ -37,10 +37,7 @@ class ProjectInviteResource(ResourceBase):
     ) -> ProjectWithTeam:
         QUERY = gql(
             """
-            mutation ProjectInviteCreate(
-              $projectId: ID!,
-              $input: ProjectInviteCreateInput!
-              ) {
+            mutation ProjectInviteCreate($projectId: ID!, $input: ProjectInviteCreateInput!) {
               data:projectMutations {
                 data:invites {
                   data:create(projectId: $projectId, input: $input) {

src/specklepy/core/api/resources/current/project_resource.py

@@ -65,12 +65,7 @@ class ProjectResource(ResourceBase):
     ) -> ProjectWithModels:
         QUERY = gql(
             """
-            query ProjectGetWithModels(
-              $projectId: String!,
-              $modelsLimit: Int!,
-              $modelsCursor: String,
-              $modelsFilter: ProjectModelsFilter
-              ) {
+            query ProjectGetWithModels($projectId: String!, $modelsLimit: Int!, $modelsCursor: String, $modelsFilter: ProjectModelsFilter) {
               data:project(id: $projectId) {
                 id
                 name
@@ -82,11 +77,7 @@ class ProjectResource(ResourceBase):
                 updatedAt
                 sourceApps
                 workspaceId
-                models(
-                  limit: $modelsLimit,
-                  cursor: $modelsCursor,
-                  filter: $modelsFilter
-                  ) {
+                models(limit: $modelsLimit, cursor: $modelsCursor, filter: $modelsFilter) {
                   items {
                     id
                     name

src/specklepy/core/api/resources/current/server_resource.py

@@ -80,8 +80,7 @@ class ServerResource(ResourceBase):
             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
+        # not tracking as it will be called along with other mutations / queries as a check
         query = gql(
             """
             query Server {

src/specklepy/core/api/resources/current/version_resource.py

@@ -76,13 +76,7 @@ class VersionResource(ResourceBase):
     ) -> ResourceCollection[Version]:
         QUERY = gql(
             """
-            query VersionGetVersions(
-              $projectId: String!,
-              $modelId: String!,
-              $limit: Int!,
-              $cursor: String,
-              $filter: ModelVersionsFilter
-              ) {
+            query VersionGetVersions($projectId: String!, $modelId: String!, $limit: Int!, $cursor: String, $filter: ModelVersionsFilter) {
               data:project(id: $projectId) {
                 data:model(id: $modelId) {
                   data:versions(limit: $limit, cursor: $cursor, filter: $filter) {

src/specklepy/core/api/wrapper.py

@@ -159,12 +159,11 @@ class StreamWrapper:
             try:
                 self.branch_name = project["project"]["model"]["name"]
             except KeyError as ke:
-                raise SpeckleException("Project model name is not found", ke) from ke
+                raise SpeckleException("Project model name is not found", ke)
 
         if not self.stream_id:
             raise SpeckleException(
-                f"Cannot parse {url} into a stream wrapper class - no {key_stream} ",
-                "id found.",
+                f"Cannot parse {url} into a stream wrapper class - no {key_stream} id found."
             )
 
     @property
@@ -214,11 +213,7 @@ class StreamWrapper:
             self._client = SpeckleClient(host=self.host, use_ssl=self.use_ssl)
 
         if self._account.token is None and token is None:
-            warn(
-                f"No local account found for server {self.host}",
-                SpeckleWarning,
-                stacklevel=2,
-            )
+            warn(f"No local account found for server {self.host}", SpeckleWarning)
             return self._client
 
         if self._account.token:
@@ -271,20 +266,14 @@ class StreamWrapper:
         if use_fe2 is False or (use_fe2 is True and not self.model_id):
             base_url = f"{self.server_url}{key_streams}{self.stream_id}"
         else:  # fe2 is True and model_id available
-            base_url = (
-                f"{self.server_url}{key_streams}"
-                f"{self.stream_id}{key_branches}{value_branch}"
-            )
+            base_url = f"{self.server_url}{key_streams}{self.stream_id}{key_branches}{value_branch}"
 
         if wrapper_type == "object":
             return f"{base_url}{key_objects}{self.object_id}"
         elif wrapper_type == "commit":
             return f"{base_url}{key_commits}{self.commit_id}"
         elif wrapper_type == "branch":
-            return (
-                f"{self.server_url}{key_streams}{self.stream_id}"
-                f"{key_branches}{value_branch}"
-            )
+            return f"{self.server_url}{key_streams}{self.stream_id}{key_branches}{value_branch}"
         elif wrapper_type == "stream":
             return f"{self.server_url}{key_streams}{self.stream_id}"
         else:

src/specklepy/core/helpers/speckle_path_provider.py

@@ -99,7 +99,7 @@ def user_application_data_path() -> Path:
     except Exception as ex:
         raise SpeckleException(
             message="Failed to initialize user application data path.", exception=ex
-        ) from ex
+        )
 
 
 def user_speckle_folder_path() -> Path:

src/specklepy/logging/metrics.py

@@ -86,8 +86,7 @@ def track(
 
         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!
+        # wrapping this whole thing in a try except as we never want a failure here to annoy users!
         LOG.debug(f"Error queueing metrics request: {str(ex)}")
 
 
@@ -107,7 +106,7 @@ class Singleton(type):
 
     def __call__(cls, *args, **kwargs):
         if cls not in cls._instances:
-            cls._instances[cls] = super().__call__(*args, **kwargs)
+            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
         return cls._instances[cls]
 
 

src/specklepy/objects/__init__.py

@@ -1,6 +0,0 @@
-from .data_objects import DataObject, QgisObject
-
-__all__ = [
-    "DataObject",
-    "QgisObject",
-]

src/specklepy/objects/base.py

@@ -224,7 +224,7 @@ def _validate_type(t: Optional[type], value: Any) -> Tuple[bool, Any]:
         if isinstance(t, ForwardRef):
             return True, value
 
-        origin = t.__origin__
+        origin = getattr(t, "__origin__")
         # below is what in nicer for >= py38
         # origin = get_origin(t)
 
@@ -289,7 +289,7 @@ def _validate_type(t: Optional[type], value: Any) -> Tuple[bool, Any]:
             if len(args) != len(value):
                 return False, value
             values = []
-            for t_item, v_item in zip(args, value, strict=True):
+            for t_item, v_item in zip(args, value):
                 item_valid, item_value = _validate_type(t_item, v_item)
                 if not item_valid:
                     return False, value
@@ -372,8 +372,7 @@ class Base(_RegisteringBase, speckle_type="Base"):
         if name == "speckle_type":
             # not sure if we should raise an exception here??
             # raise SpeckleException(
-            #     "Cannot override the `speckle_type`."
-            #     "This is set manually by the class or on deserialisation"
+            #     "Cannot override the `speckle_type`. This is set manually by the class or on deserialisation"
             # )
             return
         # if value is not None:
@@ -401,10 +400,7 @@ class Base(_RegisteringBase, speckle_type="Base"):
         try:
             cls._attr_types = get_type_hints(cls)
         except Exception as e:
-            warn(
-                f"Could not update forward refs for class {cls.__name__}: {e}",
-                stacklevel=2,
-            )
+            warn(f"Could not update forward refs for class {cls.__name__}: {e}")
 
     @classmethod
     def validate_prop_name(cls, name: str) -> None:
@@ -469,8 +465,7 @@ class Base(_RegisteringBase, speckle_type="Base"):
 
     # @units.setter
     # def units(self, value: Union[str, Units, None]):
-    #     """While this property accepts any string value,
-    #        geometry expects units to be specific strings (see Units enum)"""
+    #     """While this property accepts any string value, geometry expects units to be specific strings (see Units enum)"""
     #     if isinstance(value, str) or value is None:
     #         self._units = value
     #     elif isinstance(value, Units):

src/specklepy/objects/data_objects.py

@@ -1,81 +0,0 @@
-from dataclasses import dataclass, field
-from typing import Dict, List
-from specklepy.objects.base import Base
-from specklepy.objects.interfaces import IDataObject, IGisObject, IHasUnits
-from specklepy.logging.exceptions import SpeckleException
-
-
-@dataclass(kw_only=True)
-class DataObject(
-    Base,
-    IDataObject,
-    speckle_type="Objects.Data.DataObject",
-    detachable={"displayValue"},
-):
-
-    name: str
-    properties: Dict[str, object]
-    displayValue: List[Base]
-    _name: str = field(repr=False, init=False)
-    _properties: Dict[str, object] = field(repr=False, init=False)
-    _displayValue: List[Base] = field(repr=False, init=False)
-
-    @property
-    def name(self) -> str:
-        return self._name
-
-    @property
-    def properties(self) -> Dict[str, object]:
-        return self._properties
-
-    @property
-    def displayValue(self) -> List[Base]:
-        return self._displayValue
-
-    @name.setter
-    def name(self, value: str):
-        if isinstance(value, str):
-            self._name = value
-        else:
-            raise SpeckleException(
-                f"'name' value should be string, received {type(value)}"
-            )
-
-    @properties.setter
-    def properties(self, value: dict):
-        if isinstance(value, dict):
-            self._properties = value
-        else:
-            raise SpeckleException(
-                f"'properties' value should be Dict, received {type(value)}"
-            )
-
-    @displayValue.setter
-    def displayValue(self, value: list):
-        if isinstance(value, list):
-            self._displayValue = value
-        else:
-            raise SpeckleException(
-                f"'displayValue' value should be List, received {type(value)}"
-            )
-
-
-@dataclass(kw_only=True)
-class QgisObject(
-    DataObject, IGisObject, IHasUnits, speckle_type="Objects.Data.QgisObject"
-):
-    type: str
-    _type: str = field(repr=False, init=False)
-
-    @property
-    def type(self) -> str:
-        return self._type
-
-    @type.setter
-    def type(self, value: str):
-        if isinstance(value, str):
-            self._type = value
-        else:
-            raise SpeckleException(
-                f"'type' value should be string, received {type(value)}"
-            )

src/specklepy/objects/geometry.py

@@ -0,0 +1,272 @@
+from dataclasses import dataclass, field
+from typing import List, Tuple
+
+from specklepy.objects.base import Base
+from specklepy.objects.interfaces import ICurve, IHasArea, IHasUnits, IHasVolume
+from specklepy.objects.models.units import Units
+from specklepy.objects.primitive import Interval
+
+
+@dataclass(kw_only=True)
+class Point(Base, IHasUnits, speckle_type="Objects.Geometry.Point"):
+    """
+    a 3-dimensional point
+    """
+
+    x: float
+    y: float
+    z: float
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(x: {self.x}, y: {self.y}, z: {self.z}, units: {self.units})"
+
+    def to_list(self) -> List[float]:
+        return [self.x, self.y, self.z]
+
+    @classmethod
+    def from_list(cls, coords: List[float], units: str | Units) -> "Point":
+        return cls(x=coords[0], y=coords[1], z=coords[2], units=units)
+
+    @classmethod
+    def from_coords(cls, x: float, y: float, z: float, units: str | Units) -> "Point":
+        return cls(x=x, y=y, z=z, units=units)
+
+    def distance_to(self, other: "Point") -> float:
+        """
+        calculates the distance between this point and another given point
+        """
+        dx = other.x - self.x
+        dy = other.y - self.y
+        dz = other.z - self.z
+        return (dx * dx + dy * dy + dz * dz) ** 0.5
+
+
+@dataclass(kw_only=True)
+class Line(Base, IHasUnits, ICurve, speckle_type="Objects.Geometry.Line"):
+    """
+    a line defined by two points in 3D space
+    """
+
+    start: Point
+    end: Point
+    domain: Interval = field(default_factory=Interval.unit_interval)
+
+    @property
+    def length(self) -> float:
+        """
+        calculate the length of the line using Point's distance_to method
+        """
+        return self.start.distance_to(self.end)
+
+    @property
+    def _domain(self) -> Interval:
+        return self.domain
+
+    def to_list(self) -> List[float]:
+        result = []
+        result.extend(self.start.to_list())
+        result.extend(self.end.to_list())
+        result.extend([self.domain.start, self.domain.end])
+        return result
+
+    @classmethod
+    def from_list(cls, coords: List[float], units: str) -> "Line":
+        if len(coords) < 6:
+            raise ValueError("Line from coordinate array requires 6 coordinates.")
+
+        start = Point(x=coords[0], y=coords[1], z=coords[2], units=units)
+        end = Point(x=coords[3], y=coords[4], z=coords[5], units=units)
+
+        return cls(start=start, end=end, units=units)
+
+    @classmethod
+    def from_coords(
+        cls,
+        start_x: float,
+        start_y: float,
+        start_z: float,
+        end_x: float,
+        end_y: float,
+        end_z: float,
+        units: str,
+    ) -> "Line":
+        start = Point(x=start_x, y=start_y, z=start_z, units=units)
+        end = Point(x=end_x, y=end_y, z=end_z, units=units)
+        return cls(start=start, end=end, units=units)
+
+
+@dataclass(kw_only=True)
+class Polyline(Base, IHasUnits, ICurve, speckle_type="Objects.Geometry.Polyline"):
+    """
+    a polyline curve, defined by a set of vertices.
+    """
+
+    value: List[float] = field(default_factory=list)
+    closed: bool = False
+    domain: Interval = field(default_factory=Interval.unit_interval)
+
+    @property
+    def length(self) -> float:
+        points = self.get_points()
+        total_length = 0.0
+        for i in range(len(points) - 1):
+            total_length += points[i].distance_to(points[i + 1])
+        if self.closed and points:
+            total_length += points[-1].distance_to(points[0])
+        return total_length
+
+    @property
+    def _domain(self) -> Interval:
+        """
+        internal domain property for ICurve interface
+        """
+        return self.domain
+
+    def get_points(self) -> List[Point]:
+        """
+        converts the raw coordinate list into Point objects
+        """
+        if len(self.value) % 3 != 0:
+            raise ValueError(
+                "Polyline value list is malformed: expected length to be multiple of 3"
+            )
+
+        points = []
+        for i in range(0, len(self.value), 3):
+            points.append(
+                Point(
+                    x=self.value[i],
+                    y=self.value[i + 1],
+                    z=self.value[i + 2],
+                    units=self.units,
+                )
+            )
+        return points
+
+    def to_list(self) -> List[float]:
+        """
+        returns the values of this Polyline as a list of numbers
+        """
+        result = []
+        result.append(len(self.value) + 6)  # total list length
+        # type indicator for polyline ?? not sure about this
+        result.append("Objects.Geometry.Polyline")
+        result.append(1 if self.closed else 0)
+        result.append(self.domain.start)
+        result.append(self.domain.end)
+        result.append(len(self.value))
+        result.extend(self.value)
+        result.append(Units.get_encoding_from_unit(self.units))
+        return result
+
+    @classmethod
+    def from_list(cls, coords: List[float], units: str | Units) -> "Polyline":
+        """
+        creates a new Polyline based on a list of coordinates
+        """
+        point_count = int(coords[5])
+        return cls(
+            closed=(int(coords[2]) == 1),
+            domain=Interval(start=coords[3], end=coords[4]),
+            value=coords[6 : 6 + point_count],
+            units=units,
+        )
+
+
+@dataclass(kw_only=True)
+class Mesh(
+    Base,
+    IHasArea,
+    IHasVolume,
+    IHasUnits,
+    speckle_type="Objects.Geometry.Mesh",
+    detachable={"vertices", "faces", "colors", "textureCoordinates"},
+    chunkable={
+        "vertices": 31250,
+        "faces": 62500,
+        "colors": 62500,
+        "textureCoordinates": 31250,
+    },
+):
+    vertices: List[float] = field(default_factory=list)
+    faces: List[int] = field(default_factory=list)
+    colors: List[int] = field(default_factory=list)
+    textureCoordinates: List[float] = field(default_factory=list)
+
+    @property
+    def vertices_count(self) -> int:
+        return len(self.vertices) // 3
+
+    @property
+    def texture_coordinates_count(self) -> int:
+        return len(self.textureCoordinates) // 2
+
+    def get_point(self, index: int) -> Point:
+        index *= 3
+        return Point(
+            x=self.vertices[index],
+            y=self.vertices[index + 1],
+            z=self.vertices[index + 2],
+            units=self.units,
+        )
+
+    def get_points(self) -> List[Point]:
+        if len(self.vertices) % 3 != 0:
+            raise ValueError(
+                "Mesh vertices list is malformed: expected length to be multiple of 3"
+            )
+
+        points = []
+        for i in range(0, len(self.vertices), 3):
+            points.append(
+                Point(
+                    x=self.vertices[i],
+                    y=self.vertices[i + 1],
+                    z=self.vertices[i + 2],
+                    units=self.units,
+                )
+            )
+        return points
+
+    def get_texture_coordinate(self, index: int) -> Tuple[float, float]:
+        index *= 2
+        return (self.textureCoordinates[index], self.textureCoordinates[index + 1])
+
+    def align_vertices_with_texcoords_by_index(self) -> None:
+        if not self.textureCoordinates:
+            return
+
+        if self.texture_coordinates_count == self.vertices_count:
+            return
+
+        faces_unique = []
+        vertices_unique = []
+        has_colors = len(self.colors) > 0
+        colors_unique = [] if has_colors else None
+
+        n_index = 0
+        while n_index < len(self.faces):
+            n = self.faces[n_index]
+            if n < 3:
+                n += 3
+
+            if n_index + n >= len(self.faces):
+                break
+
+            faces_unique.append(n)
+            for i in range(1, n + 1):
+                vert_index = self.faces[n_index + i]
+                new_vert_index = len(vertices_unique) // 3
+
+                point = self.get_point(vert_index)
+                vertices_unique.extend([point.x, point.y, point.z])
+
+                if colors_unique is not None:
+                    colors_unique.append(self.colors[vert_index])
+                faces_unique.append(new_vert_index)
+
+            n_index += n + 1
+
+        self.vertices = vertices_unique
+        self.colors = colors_unique if colors_unique is not None else self.colors
+        self.faces = faces_unique

src/specklepy/objects/geometry/__init__.py

@@ -1,18 +0,0 @@
-from specklepy.objects.geometry.arc import Arc
-from specklepy.objects.geometry.line import Line
-from specklepy.objects.geometry.mesh import Mesh
-from specklepy.objects.geometry.plane import Plane
-from specklepy.objects.geometry.point import Point
-from specklepy.objects.geometry.polyline import Polyline
-from specklepy.objects.geometry.vector import Vector
-
-# re-export them at the geometry package level
-__all__ = [
-    "Arc",
-    "Line",
-    "Mesh",
-    "Plane",
-    "Point",
-    "Polyline",
-    "Vector"
-]

src/specklepy/objects/geometry/arc.py

@@ -1,36 +0,0 @@
-import math
-from dataclasses import dataclass
-
-from specklepy.objects.base import Base
-from specklepy.objects.geometry.plane import Plane
-from specklepy.objects.geometry.point import Point
-from specklepy.objects.interfaces import ICurve, IHasUnits
-
-
-@dataclass(kw_only=True)
-class Arc(Base, IHasUnits, ICurve, speckle_type="Objects.Geometry.Arc"):
-    plane: Plane
-    startPoint: Point
-    midPoint: Point
-    endPoint: Point
-
-    @property
-    def radius(self) -> float:
-        return self.startPoint.distance_to(self.plane.origin)
-
-    @property
-    def length(self) -> float:
-        start_to_mid = self.startPoint.distance_to(self.midPoint)
-        mid_to_end = self.midPoint.distance_to(self.endPoint)
-        r = self.radius
-        angle = (2 * math.asin(start_to_mid / (2 * r))) + \
-            (2 * math.asin(mid_to_end / (2 * r)))
-        return r * angle
-
-    @property
-    def measure(self) -> float:
-        start_to_mid = self.startPoint.distance_to(self.midPoint)
-        mid_to_end = self.midPoint.distance_to(self.endPoint)
-        r = self.radius
-        return (2 * math.asin(start_to_mid / (2 * r))) + \
-            (2 * math.asin(mid_to_end / (2 * r)))

src/specklepy/objects/geometry/line.py

@@ -1,20 +0,0 @@
-from dataclasses import dataclass
-
-from specklepy.objects.base import Base
-from specklepy.objects.geometry.point import Point
-from specklepy.objects.interfaces import ICurve, IHasUnits
-
-
-@dataclass(kw_only=True)
-class Line(
-    Base,
-    IHasUnits,
-    ICurve,
-    speckle_type="Objects.Geometry.Line"
-):
-    start: Point
-    end: Point
-
-    @property
-    def length(self) -> float:
-        return self.start.distance_to(self.end)

src/specklepy/objects/geometry/mesh.py

@@ -1,211 +0,0 @@
-from dataclasses import dataclass, field
-from typing import List, Tuple
-
-from specklepy.objects.base import Base
-from specklepy.objects.geometry.point import Point
-from specklepy.objects.interfaces import IHasArea, IHasUnits, IHasVolume
-
-
-@dataclass(kw_only=True)
-class Mesh(
-    Base,
-    IHasArea,
-    IHasVolume,
-    IHasUnits,
-    speckle_type="Objects.Geometry.Mesh",
-    detachable={"vertices", "faces", "colors", "textureCoordinates"},
-    chunkable={
-        "vertices": 31250,
-        "faces": 62500,
-        "colors": 62500,
-        "textureCoordinates": 31250,
-    },
-    serialize_ignore={"vertices_count", "texture_coordinates_count"},
-):
-    """
-    a 3D mesh consisting of vertices and faces with optional colors and texture coordinates
-    """
-    vertices: List[float]
-    faces: List[int]
-    colors: List[int] = field(default_factory=list)
-    textureCoordinates: List[float] = field(default_factory=list)
-
-    def __repr__(self) -> str:
-        return (
-            f"{self.__class__.__name__}("
-            f"vertices: {self.vertices_count}, "
-            f"faces: {self.faces_count}, "
-            f"units: {self.units}, "
-            f"has_colors: {len(self.colors) > 0}, "
-            f"has_texture_coords: {len(self.textureCoordinates) > 0})"
-        )
-
-    @property
-    def vertices_count(self) -> int:
-        """
-        get the number of vertices in the mesh
-        """
-
-        if len(self.vertices) % 3 != 0:
-            raise ValueError(
-                f"Invalid vertices list: length ({len(
-                    self.vertices)}) must be a multiple of 3"
-            )
-        return len(self.vertices) // 3
-
-    @property
-    def texture_coordinates_count(self) -> int:
-        """
-        get the number of texture coordinates in the mesh
-        """
-        return len(self.textureCoordinates) // 2
-
-    @property
-    def area(self) -> float:
-        return self.__dict__.get('_area', 0.0)
-
-    @area.setter
-    def area(self, value: float) -> None:
-        self.__dict__['_area'] = value
-
-    @property
-    def volume(self) -> float:
-        return self.__dict__.get('_volume', 0.0)
-
-    @volume.setter
-    def volume(self, value: float) -> None:
-        self.__dict__['_volume'] = value
-
-    def calculate_area(self) -> float:
-        """
-        calculate total surface area of the mesh
-        """
-        total_area = 0.0
-        face_index = 0
-        i = 0
-
-        while i < len(self.faces):
-            vertex_count = self.faces[i]
-            if vertex_count >= 3:
-                face_vertices = self.get_face_vertices(face_index)
-                for j in range(1, vertex_count - 1):
-                    v0 = face_vertices[0]
-                    v1 = face_vertices[j]
-                    v2 = face_vertices[j + 1]
-                    a = [v1.x - v0.x, v1.y - v0.y, v1.z - v0.z]
-                    b = [v2.x - v0.x, v2.y - v0.y, v2.z - v0.z]
-                    cx = a[1] * b[2] - a[2] * b[1]
-                    cy = a[2] * b[0] - a[0] * b[2]
-                    cz = a[0] * b[1] - a[1] * b[0]
-                    area = 0.5 * (cx * cx + cy * cy + cz * cz) ** 0.5
-                    total_area += area
-            i += vertex_count + 1
-            face_index += 1
-
-        return total_area
-
-    def calculate_volume(self) -> float:
-        """
-        calculate volume of the mesh if it is closed
-        """
-        if not self.is_closed():
-            return 0.0
-
-        total_volume = 0.0
-        face_index = 0
-        i = 0
-        while i < len(self.faces):
-            vertex_count = self.faces[i]
-            if vertex_count >= 3:
-                face_vertices = self.get_face_vertices(face_index)
-                v0 = face_vertices[0]
-                for j in range(1, vertex_count - 1):
-                    v1 = face_vertices[j]
-                    v2 = face_vertices[j + 1]
-                    a = [v0.x, v0.y, v0.z]
-                    b = [v1.x - v0.x, v1.y - v0.y, v1.z - v0.z]
-                    c = [v2.x - v0.x, v2.y - v0.y, v2.z - v0.z]
-                    cx = b[1] * c[2] - b[2] * c[1]
-                    cy = b[2] * c[0] - b[0] * c[2]
-                    cz = b[0] * c[1] - b[1] * c[0]
-                    v = (a[0] * cx + a[1] * cy + a[2] * cz) / 6.0
-                    total_volume += v
-            i += vertex_count + 1
-            face_index += 1
-
-        return abs(total_volume)
-
-    def get_point(self, index: int) -> Point:
-        """
-        get vertex at index as a Point object
-        """
-        if index < 0 or index >= self.vertices_count:
-            raise IndexError(f"Vertex index {index} out of range")
-
-        index *= 3
-        return Point(
-            x=self.vertices[index],
-            y=self.vertices[index + 1],
-            z=self.vertices[index + 2],
-            units=self.units,
-        )
-
-    def get_points(self) -> List[Point]:
-        """
-        get all vertices as Point objects
-        """
-        return [self.get_point(i) for i in range(self.vertices_count)]
-
-    def get_texture_coordinate(self, index: int) -> Tuple[float, float]:
-        """
-        get texture coordinate at index
-        """
-        if index < 0 or index >= self.texture_coordinates_count:
-            raise IndexError(f"Texture coordinate index {index} out of range")
-
-        index *= 2
-        return (self.textureCoordinates[index], self.textureCoordinates[index + 1])
-
-    def get_face_vertices(self, face_index: int) -> List[Point]:
-        """
-        get the vertices of a specific face
-        """
-        i = 0
-        current_face = 0
-
-        while i < len(self.faces):
-            if current_face == face_index:
-                vertex_count = self.faces[i]
-                vertices = []
-                for j in range(vertex_count):
-                    vertex_index = self.faces[i + j + 1]
-                    if vertex_index >= self.vertices_count:
-                        raise IndexError(
-                            f"Vertex index {vertex_index} out of range")
-                    vertices.append(self.get_point(vertex_index))
-                return vertices
-
-            vertex_count = self.faces[i]
-            i += vertex_count + 1
-            current_face += 1
-
-        raise IndexError(f"Face index {face_index} out of range")
-
-    def is_closed(self) -> bool:
-        """
-        check if the mesh is closed (verifying each edge appears twice)
-        """
-        edge_counts = {}
-
-        i = 0
-        while i < len(self.faces):
-            vertex_count = self.faces[i]
-            for j in range(vertex_count):
-                v1 = self.faces[i + 1 + j]
-                v2 = self.faces[i + 1 + ((j + 1) % vertex_count)]
-                edge = tuple(sorted([v1, v2]))
-                edge_counts[edge] = edge_counts.get(edge, 0) + 1
-
-            i += vertex_count + 1
-
-        return all(count == 2 for count in edge_counts.values())

src/specklepy/objects/geometry/plane.py

@@ -1,28 +0,0 @@
-from dataclasses import dataclass
-
-from specklepy.objects.base import Base
-from specklepy.objects.geometry.point import Point
-from specklepy.objects.geometry.vector import Vector
-from specklepy.objects.interfaces import IHasUnits
-
-
-@dataclass(kw_only=True)
-class Plane(Base, IHasUnits, speckle_type="Objects.Geometry.Plane"):
-    """
-    a plane consisting of an origin Point, and 3 Vectors as its X, Y and Z axis.
-    """
-
-    origin: Point
-    normal: Vector
-    xdir: Vector
-    ydir: Vector
-
-    def __repr__(self) -> str:
-        return (
-            f"{self.__class__.__name__}("
-            f"origin: {self.origin}, "
-            f"normal: {self.normal}, "
-            f"xdir: {self.xdir}, "
-            f"ydir: {self.ydir}, "
-            f"units: {self.units})"
-        )

src/specklepy/objects/geometry/point.py

@@ -1,33 +0,0 @@
-from dataclasses import dataclass
-
-from specklepy.objects.base import Base
-from specklepy.objects.interfaces import IHasUnits
-
-
-@dataclass(kw_only=True)
-class Point(Base, IHasUnits, speckle_type="Objects.Geometry.Point"):
-    """
-    a 3-dimensional point
-    """
-
-    x: float
-    y: float
-    z: float
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(x: {self.x}, y: {self.y}, z: {self.z}, units: {self.units})"
-
-    def distance_to(self, other: "Point") -> float:
-        """
-        calculates the distance between this point and another given point.
-        """
-        if not isinstance(other, Point):
-            raise TypeError(f"Expected Point object, got {type(other)}")
-
-        # we assume that host application units are the same for both points
-        # unit conversion could be expensive, so we avoid it here
-        dx = other.x - self.x
-        dy = other.y - self.y
-        dz = other.z - self.z
-
-        return (dx * dx + dy * dy + dz * dz) ** 0.5

src/specklepy/objects/geometry/polyline.py

@@ -1,76 +0,0 @@
-from dataclasses import dataclass
-from typing import List
-
-from specklepy.objects.base import Base
-from specklepy.objects.geometry.point import Point
-from specklepy.objects.interfaces import ICurve, IHasUnits
-
-
-@dataclass(kw_only=True)
-class Polyline(Base, IHasUnits, ICurve, speckle_type="Objects.Geometry.Polyline"):
-    """
-    a polyline curve, defined by a set of vertices.
-    """
-    value: List[float]
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(value: {self.value}, units: {self.units})"
-
-    def is_closed(self, tolerance: float = 1e-6) -> bool:
-        """
-        check if the polyline is closed (start point equals end point within tolerance)
-        """
-        if len(self.value) < 6:  # need at least 2 points to be closed
-            return False
-
-        # compare first and last points
-        start = Point(
-            x=self.value[0],
-            y=self.value[1],
-            z=self.value[2],
-            units=self.units
-        )
-        end = Point(
-            x=self.value[-3],
-            y=self.value[-2],
-            z=self.value[-1],
-            units=self.units
-        )
-        return start.distance_to(end) <= tolerance
-
-    @property
-    def length(self) -> float:
-        return self.__dict__.get('_length', 0.0)
-
-    @length.setter
-    def length(self, value: float) -> None:
-        self.__dict__['_length'] = value
-
-    def calculate_length(self) -> float:
-        points = self.get_points()
-        total_length = 0.0
-        for i in range(len(points) - 1):
-            total_length += points[i].distance_to(points[i + 1])
-        if self.is_closed() and points:
-            total_length += points[-1].distance_to(points[0])
-        return total_length
-
-    def get_points(self) -> List[Point]:
-        """
-        converts the raw coordinate list into Point objects
-        """
-        if len(self.value) % 3 != 0:
-            raise ValueError(
-                "Polyline value list is malformed: expected length to be multiple of 3"
-            )
-
-        points = []
-        for i in range(0, len(self.value), 3):
-            point = Point(
-                x=self.value[i],
-                y=self.value[i + 1],
-                z=self.value[i + 2],
-                units=self.units
-            )
-            points.append(point)
-        return points

src/specklepy/objects/geometry/vector.py

@@ -1,22 +0,0 @@
-from dataclasses import dataclass
-
-from specklepy.objects.base import Base
-from specklepy.objects.interfaces import IHasUnits
-
-
-@dataclass(kw_only=True)
-class Vector(Base, IHasUnits, speckle_type="Objects.Geometry.Vector", serialize_ignore = {"length"}):
-    """
-    a 3-dimensional vector
-    """
-
-    x: float
-    y: float
-    z: float
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(x: {self.x}, y: {self.y}, z: {self.z}, units: {self.units})"
-
-    @property
-    def length(self) -> float:
-        return (self.x ** 2 + self.y ** 2 + self.z ** 2) ** 0.5

src/specklepy/objects/graph_traversal/default_traversal.py

@@ -1,29 +0,0 @@
-from specklepy.objects.base import Base
-from specklepy.objects.graph_traversal.traversal import GraphTraversal, TraversalRule
-
-DISPLAY_VALUE_PROPERTY_ALIASES = {"displayValue", "@displayValue"}
-ELEMENTS_PROPERTY_ALIASES = {"elements", "@elements"}
-
-
-def has_display_value(x: Base):
-    return any(hasattr(x, alias) for alias in DISPLAY_VALUE_PROPERTY_ALIASES)
-
-
-def create_default_traversal_function() -> GraphTraversal:
-    """
-    Traversal func for traversing the root object of a Speckle Model
-    """
-
-    convertible_rule = TraversalRule(
-        [lambda b: b.speckle_type != "Base", has_display_value],
-        lambda _: ELEMENTS_PROPERTY_ALIASES,
-    )
-
-    default_rule = TraversalRule(
-        [lambda _: True],
-        # NOTE: Unlike the C# implementation, this does not ignore Obsolete members
-        lambda o: o.get_member_names(),
-        False,
-    )
-
-    return GraphTraversal([convertible_rule, default_rule])

src/specklepy/objects/interfaces.py

@@ -1,6 +1,6 @@
 from abc import ABCMeta, abstractmethod
 from dataclasses import dataclass, field
-from typing import Dict, Generic, List, TypeVar
+from typing import Generic, List, TypeVar
 
 from specklepy.logging.exceptions import SpeckleInvalidUnitException
 from specklepy.objects.base import Base
@@ -11,37 +11,32 @@ T = TypeVar("T")  # define type variable for generic type
 
 
 # generic interfaces
-@dataclass(kw_only=True)
 class ICurve(metaclass=ABCMeta):
-    _domain: Interval = field(default_factory=Interval.unit_interval, init=False)
-
     @property
     @abstractmethod
     def length(self) -> float:
         pass
 
     @property
-    def domain(self) -> Interval:
-        return self._domain
+    @abstractmethod
+    def _domain(self) -> Interval:
+        pass
 
-    @domain.setter
-    def domain(self, value: Interval) -> None:
-        if not isinstance(value, Interval):
-            raise TypeError(f"Domain must be an Interval, got {type(value)}")
-        self._domain = value
+    @property
+    @abstractmethod
+    def units(self) -> str:
+        pass
 
 
 class IDisplayValue(Generic[T], metaclass=ABCMeta):
     @property
     @abstractmethod
-    def displayValue(self) -> T:
+    def display_value(self) -> T:
         pass
 
 
-# field interfaces
 @dataclass(kw_only=True)
 class IHasUnits(metaclass=ABCMeta):
-
     units: str | Units
     _units: str = field(repr=False, init=False)
 
@@ -63,7 +58,7 @@ class IHasUnits(metaclass=ABCMeta):
 
 @dataclass(kw_only=True)
 class IHasArea(metaclass=ABCMeta):
-
+    area: float
     _area: float = field(init=False, repr=False)
 
     @property
@@ -79,7 +74,7 @@ class IHasArea(metaclass=ABCMeta):
 
 @dataclass(kw_only=True)
 class IHasVolume(metaclass=ABCMeta):
-
+    volume: float
     _volume: float = field(init=False, repr=False)
 
     @property
@@ -97,7 +92,7 @@ class IHasVolume(metaclass=ABCMeta):
 class IProperties(metaclass=ABCMeta):
     @property
     @abstractmethod
-    def properties(self) -> Dict[str, object]:
+    def properties(self) -> dict[str, object]:
         pass
 
 
@@ -113,10 +108,3 @@ class IBlenderObject(IDataObject, metaclass=ABCMeta):
     @abstractmethod
     def type(self) -> str:
         pass
-
-
-class IGisObject(IDataObject, metaclass=ABCMeta):
-    @property
-    @abstractmethod
-    def type(self) -> str:
-        pass

src/specklepy/objects/models/collections/collection.py

@@ -12,26 +12,24 @@ class Collection(
     detachable={"elements"},
 ):
     """
-    A simple container for organising objects within a model
-    and preserving object hierarchy.
+    A simple container for organising objects within a model and preserving object hierarchy.
 
-    A container is defined by a human-readable name a unique applicationId and
-    its list of contained elements.
-    The elements can include an unrestricted number of Base objects including
-    additional nested Collections.
+    A container is defined by a human-readable name a unique applicationId and its list of contained elements.
+    The elements can include an unrestricted number of Base objects including additional nested Collections.
 
     Note:
-        A Collection can be for example a Layer in Rhino/AutoCad,
-        a collection in Blender, or a Category in Revit.
-        The location of each collection in the hierarchy of collections in a commit
-        will be retrieved through commit traversal.
+        A Collection can be for example a Layer in Rhino/AutoCad, a collection in Blender, or a Category in Revit.
+        The location of each collection in the hierarchy of collections in a commit will be retrieved through commit traversal.
 
     Attributes:
-        name: The human-readable name of the Collection. This name is not necessarily
-        unique within a commit. Set the applicationId for a unique identifier.
-        elements: The elements contained in this Collection.
-        This may include additional nested Collections
+        name: The human-readable name of the Collection. This name is not necessarily unique within a commit. Set the applicationId for a unique identifier.
+        elements: The elements contained in this Collection. This may include additional nested Collections
     """
 
     name: str
     elements: List[Base] = field(default_factory=list)
+
+
+if __name__ == "__main__":
+    c = Collection(name="asfd")
+    print(c)

src/specklepy/objects/primitive.py

@@ -1,21 +1,28 @@
 from dataclasses import dataclass
+from typing import List
 
 from specklepy.objects.base import Base
 
 
 @dataclass(kw_only=True)
-class Interval(Base, speckle_type="Objects.Primitive.Interval", serialize_ignore={"length"}):
-    start: float = 0.0
-    end: float = 0.0
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(start: {self.start}, end: {self.end})"
+class Interval(Base, speckle_type="Objects.Primitive.Interval"):
+    start: float = 0.0  # Added default
+    end: float = 0.0  # Added default
 
     @property
     def length(self) -> float:
-        abs(self.end - self.start)
+        return abs(self.end - self.start)
+
+    def __str__(self) -> str:
+        return f"{super().__str__()}[{self.start}, {self.end}]"
 
     @classmethod
     def unit_interval(cls) -> "Interval":
-        interval = cls(start=0, end=1)
-        return interval
+        return cls(start=0, end=1)
+
+    def to_list(self) -> List[float]:
+        return [self.start, self.end]
+
+    @classmethod
+    def from_list(cls, args: List[float]) -> "Interval":
+        return cls(start=args[0], end=args[1])

src/specklepy/objects/proxies.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import List, Optional
 
 from specklepy.objects.base import Base
@@ -11,9 +11,9 @@ class ColorProxy(
     speckle_type="Models.Proxies.ColorProxy",
     detachable={"objects"},
 ):
-    objects: List[str]
+    objects: List[str] = field(default_factory=list)
     value: int
-    name: Optional[str]
+    name: Optional[str] = None
 
 
 @dataclass(kw_only=True)
@@ -22,8 +22,8 @@ class GroupProxy(
     speckle_type="Models.Proxies.GroupProxy",
     detachable={"objects"},
 ):
-    objects: List[str]
-    name: str
+    objects: List[str] = field(default_factory=list)
+    name: str = field(default="Unnamed Group")
 
 
 @dataclass(kw_only=True)
@@ -33,8 +33,8 @@ class InstanceProxy(
     speckle_type="Models.Proxies.InstanceProxy",
 ):
     definition_id: str
-    transform: List[float]
-    max_depth: int
+    transform: List[float] = field(default_factory=list)
+    max_depth: int = 50
 
 
 @dataclass(kw_only=True)
@@ -43,6 +43,6 @@ class InstanceDefinitionProxy(
     speckle_type="Models.Proxies.InstanceDefinitionProxy",
     detachable={"objects"},
 ):
-    objects: List[str]
-    max_depth: int
-    name: str
+    objects: List[str] = field(default_factory=list)
+    max_depth: int = 50
+    name: str = field(default="Unnamed Instance")

src/specklepy/objects/tests/asdasd.py

@@ -1,9 +0,0 @@
-from specklepy.objects.geometry import Point, Line
-from specklepy.objects.models.units import Units
-
-p_1 = Point(x=0, y=0, z=0, units=Units.m)
-p_2 = Point(x=3, y=0, z=0, units=Units.m)
-
-line = Line(start=p_1, end=p_2, units=Units.m)
-line.length = line.calculate_length()
-print(line.length)

src/specklepy/objects/tests/line_test.py

@@ -0,0 +1,26 @@
+from devtools import debug
+
+from specklepy.api.operations import deserialize, serialize
+from specklepy.objects.geometry import Line, Point
+from specklepy.objects.models.units import Units
+from specklepy.objects.primitive import Interval
+
+# points
+p1 = Point(x=1.0, y=2.0, z=3.0, units=Units.m)
+p2 = Point(x=4.0, y=6.0, z=8.0, units=Units.m, applicationId="asdf")
+
+
+# test Line
+line = Line(start=p1, end=p2, units=Units.m, domain=Interval(start=0.0, end=1.0))
+
+print(f"\nLine length: {line.length}")
+
+ser_line = serialize(line)
+line_again = deserialize(ser_line)
+
+print("\nOriginal line:")
+debug(line)
+print("\nSerialized line:")
+debug(ser_line)
+print("\nDeserialized line:")
+debug(line_again)

src/specklepy/objects/tests/mesh_test.py

@@ -0,0 +1,182 @@
+from devtools import debug
+
+from specklepy.api.operations import deserialize, serialize
+from specklepy.objects.geometry import Mesh
+
+# create a speckle cube mesh (but more colorful)
+vertices = [
+    0.0,
+    0.0,
+    0.0,
+    1.0,
+    0.0,
+    0.0,
+    1.0,
+    1.0,
+    0.0,
+    0.0,
+    1.0,
+    0.0,
+    0.0,
+    0.0,
+    1.0,
+    1.0,
+    0.0,
+    1.0,
+    1.0,
+    1.0,
+    1.0,
+    0.0,
+    1.0,
+    1.0,
+]
+
+# define faces (triangles)
+faces = [
+    3,
+    0,
+    1,
+    2,
+    3,
+    0,
+    2,
+    3,
+    3,
+    4,
+    5,
+    6,
+    3,
+    4,
+    6,
+    7,
+    3,
+    0,
+    4,
+    7,
+    3,
+    0,
+    7,
+    3,
+    3,
+    1,
+    5,
+    6,
+    3,
+    1,
+    6,
+    2,
+    3,
+    3,
+    2,
+    6,
+    3,
+    3,
+    6,
+    7,
+    3,
+    0,
+    1,
+    5,
+    3,
+    0,
+    5,
+    4,
+]
+
+# create colors (one per vertex)
+colors = [
+    255,
+    0,
+    0,
+    255,
+    0,
+    255,
+    0,
+    255,
+    0,
+    0,
+    255,
+    255,
+    255,
+    255,
+    0,
+    255,
+    255,
+    0,
+    255,
+    255,
+    0,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    0,
+    0,
+    0,
+    255,
+]
+
+texture_coordinates = [
+    0.0,
+    0.0,
+    1.0,
+    0.0,
+    1.0,
+    1.0,
+    0.0,
+    1.0,
+    0.0,
+    0.0,
+    1.0,
+    0.0,
+    1.0,
+    1.0,
+    0.0,
+    1.0,
+]
+
+# create the mesh
+cube_mesh = Mesh(
+    vertices=vertices,
+    faces=faces,
+    colors=colors,
+    textureCoordinates=texture_coordinates,
+    units="mm",
+    area=0.0,
+    volume=0.0,
+)
+
+print("\nMesh Details:")
+print(f"Number of vertices: {cube_mesh.vertices_count}")
+print(f"Number of texture coordinates: {cube_mesh.texture_coordinates_count}")
+
+print("\nSome vertex points:")
+for i in range(4):
+    point = cube_mesh.get_point(i)
+    print(f"Vertex {i}: ({point.x}, {point.y}, {point.z})")
+
+print("\nSome texture coordinates:")
+for i in range(4):
+    u, v = cube_mesh.get_texture_coordinate(i)
+    print(f"Texture coordinate {i}: ({u}, {v})")
+
+print("\nTesting serialization...")
+ser_mesh = serialize(cube_mesh)
+mesh_again = deserialize(ser_mesh)
+
+print("\nOriginal mesh:")
+debug(cube_mesh)
+print("\nDeserialized mesh:")
+debug(mesh_again)
+
+print("\nTesting vertex-texture coordinate alignment...")
+cube_mesh.align_vertices_with_texcoords_by_index()
+print("Alignment complete.")
+
+print(f"Vertices count after alignment: {cube_mesh.vertices_count}")
+print(
+    f"Texture coordinates count after alignment: {cube_mesh.texture_coordinates_count}"
+)

src/specklepy/objects/tests/point_test.py

@@ -0,0 +1,21 @@
+from devtools import debug
+
+from specklepy.api.operations import deserialize, serialize
+from specklepy.objects.geometry import Point
+from specklepy.objects.models.units import Units
+
+# test points
+p1 = Point(x=1.0, y=2.0, z=3.0, units=Units.m)
+p2 = Point(x=4.0, y=6.0, z=8.0, units=Units.m, applicationId="asdf")
+
+print("Distance between points:", p1.distance_to(p2))
+
+ser_p1 = serialize(p1)
+p1_again = deserialize(ser_p1)
+
+print("\nOriginal point:")
+debug(p1)
+print("\nSerialized point:")
+debug(ser_p1)
+print("\nDeserialized point:")
+debug(p1_again)

src/specklepy/objects/tests/polyline_test.py

@@ -0,0 +1,51 @@
+from devtools import debug
+
+from specklepy.api.operations import deserialize, serialize
+from specklepy.objects.geometry import Polyline
+from specklepy.objects.models.units import Units
+from specklepy.objects.primitive import Interval
+
+# create points for first polyline - not closed, in meters
+points1_coords = [1.0, 1.0, 0.0, 2.0, 1.0, 0.0, 2.0, 2.0, 0.0, 1.0, 2.0, 0.0]
+
+# Create points for second polyline - closed, in ft
+points2_coords = [0.0, 0.0, 0.0, 3.0, 0.0, 0.0, 3.0, 3.0, 0.0, 0.0, 3.0, 0.0]
+
+# create polylines
+polyline1 = Polyline(
+    value=points1_coords,
+    closed=False,
+    units=Units.m,
+    domain=Interval(start=0.0, end=1.0),
+)
+
+polyline2 = Polyline(
+    value=points2_coords,
+    closed=True,
+    units=Units.feet,
+    domain=Interval(start=0.0, end=1.0),
+    applicationId="polyllllineeee",
+)
+
+print("Polyline 1 length (meters):", polyline1.length)
+print("Polyline 2 length (feet):", polyline2.length)
+
+ser_poly1 = serialize(polyline1)
+poly1_again = deserialize(ser_poly1)
+
+print("\nOriginal polyline 1:")
+debug(polyline1)
+print("\nSerialized polyline 1:")
+debug(ser_poly1)
+print("\nDeserialized polyline 1:")
+debug(poly1_again)
+
+ser_poly2 = serialize(polyline2)
+poly2_again = deserialize(ser_poly2)
+
+print("\nOriginal polyline 2:")
+debug(polyline2)
+print("\nSerialized polyline 2:")
+debug(ser_poly2)
+print("\nDeserialized polyline 2:")
+debug(poly2_again)

src/specklepy/objects/tests/test_arc.py

@@ -1,159 +0,0 @@
-import math
-
-import pytest
-
-from specklepy.core.api.operations import deserialize, serialize
-from specklepy.objects.geometry import Arc, Plane, Point, Vector
-from specklepy.objects.models.units import Units
-from specklepy.objects.primitive import Interval
-
-
-@pytest.fixture
-def sample_points():
-    start = Point(x=1.0, y=0.0, z=0.0, units=Units.m)
-    mid = Point(x=0.0, y=1.0, z=0.0, units=Units.m)
-    end = Point(x=-1.0, y=0.0, z=0.0, units=Units.m)
-
-    return start, mid, end
-
-
-@pytest.fixture
-def sample_plane():
-    origin = Point(x=0.0, y=0.0, z=0.0, units=Units.m)
-
-    normal = Vector(x=0.0, y=0.0, z=1.0, units=Units.m)
-
-    xdir = Vector(x=1.0, y=0.0, z=0.0, units=Units.m)
-
-    ydir = Vector(x=0.0, y=1.0, z=0.0, units=Units.m)
-
-    plane = Plane(origin=origin, normal=normal,
-                  xdir=xdir, ydir=ydir, units=Units.m)
-
-    return plane
-
-
-@pytest.fixture
-def sample_arc(sample_points, sample_plane):
-    start, mid, end = sample_points
-    arc = Arc(
-        plane=sample_plane,
-        startPoint=start,
-        midPoint=mid,
-        endPoint=end,
-        units=Units.m
-    )
-
-    return arc
-
-
-def test_arc_creation(sample_points, sample_plane):
-    start, mid, end = sample_points
-    arc = Arc(
-        plane=sample_plane,
-        startPoint=start,
-        midPoint=mid,
-        endPoint=end,
-        units=Units.m
-    )
-
-    assert arc.startPoint == start
-    assert arc.midPoint == mid
-    assert arc.endPoint == end
-    assert arc.plane == sample_plane
-    assert arc.units == Units.m.value
-
-
-def test_arc_domain(sample_arc):
-    assert isinstance(sample_arc.domain, Interval)
-    assert sample_arc.domain.start == 0.0
-    assert sample_arc.domain.end == 1.0
-
-
-def test_arc_radius(sample_arc):
-
-    assert sample_arc.radius == pytest.approx(1.0)
-
-
-def test_arc_length(sample_arc):
-
-    assert sample_arc.length == pytest.approx(math.pi)
-
-
-def test_arc_units(sample_points, sample_plane):
-    start, mid, end = sample_points
-    arc = Arc(
-        plane=sample_plane,
-        startPoint=start,
-        midPoint=mid,
-        endPoint=end,
-        units=Units.m
-    )
-
-    assert arc.units == Units.m.value
-
-    arc.units = "mm"
-    assert arc.units == "mm"
-
-
-def test_arc_invalid_construction(sample_points, sample_plane):
-    start, mid, end = sample_points
-
-    with pytest.raises(Exception):
-        Arc(
-            plane="not a plane",
-            startPoint=start,
-            midPoint=mid,
-            endPoint=end,
-            units=Units.m
-        )
-
-    with pytest.raises(Exception):
-        Arc(
-            plane=sample_plane,
-            startPoint="not a point",
-            midPoint=mid,
-            endPoint=end,
-            units=Units.m
-        )
-
-    with pytest.raises(Exception):
-        Arc(
-            plane=sample_plane,
-            startPoint=start,
-            midPoint="not a point",
-            endPoint=end,
-            units=Units.m
-        )
-
-    with pytest.raises(Exception):
-        Arc(
-            plane=sample_plane,
-            startPoint=start,
-            midPoint=mid,
-            endPoint="not a point",
-            units=Units.m
-        )
-
-
-def test_arc_serialization(sample_arc):
-    serialized = serialize(sample_arc)
-    deserialized = deserialize(serialized)
-
-    assert deserialized.startPoint.x == sample_arc.startPoint.x
-    assert deserialized.startPoint.y == sample_arc.startPoint.y
-    assert deserialized.startPoint.z == sample_arc.startPoint.z
-
-    assert deserialized.midPoint.x == sample_arc.midPoint.x
-    assert deserialized.midPoint.y == sample_arc.midPoint.y
-    assert deserialized.midPoint.z == sample_arc.midPoint.z
-
-    assert deserialized.endPoint.x == sample_arc.endPoint.x
-    assert deserialized.endPoint.y == sample_arc.endPoint.y
-    assert deserialized.endPoint.z == sample_arc.endPoint.z
-
-    assert deserialized.plane.origin.x == sample_arc.plane.origin.x
-    assert deserialized.plane.origin.y == sample_arc.plane.origin.y
-    assert deserialized.plane.origin.z == sample_arc.plane.origin.z
-
-    assert deserialized.units == sample_arc.units

src/specklepy/objects/tests/test_line.py

@@ -1,86 +0,0 @@
-import pytest
-
-from specklepy.core.api.operations import deserialize, serialize
-from specklepy.objects.geometry import Line, Point
-from specklepy.objects.models.units import Units
-from specklepy.objects.primitive import Interval
-
-
-@pytest.fixture
-def sample_points():
-
-    p1 = Point(x=0.0, y=0.0, z=0.0, units=Units.m)
-    p2 = Point(x=3.0, y=4.0, z=0.0, units=Units.m)
-    return p1, p2
-
-
-@pytest.fixture
-def sample_line(sample_points):
-
-    start, end = sample_points
-    line = Line(start=start, end=end, units=Units.m)
-    return line
-
-
-def test_line_creation(sample_points):
-
-    start, end = sample_points
-    line = Line(start=start, end=end, units=Units.m)
-
-    assert line.start == start
-    assert line.end == end
-    assert line.units == Units.m.value
-
-
-def test_line_domain(sample_line):
-
-    # Domain should be automatically initialized to unit interval by ICurve
-    assert isinstance(sample_line.domain, Interval)
-    assert sample_line.domain.start == 0.0
-    assert sample_line.domain.end == 1.0
-
-
-def test_line_length(sample_line):
-
-    assert sample_line.length == 5.0
-
-
-def test_line_units(sample_points):
-
-    start, end = sample_points
-    line = Line(start=start, end=end, units=Units.m)
-
-    assert line.units == Units.m.value
-
-    # Test setting units with string
-    line.units = "mm"
-    assert line.units == "mm"
-
-
-def test_line_serialization(sample_line):
-
-    serialized = serialize(sample_line)
-    deserialized = deserialize(serialized)
-
-    assert deserialized.start.x == sample_line.start.x
-    assert deserialized.start.y == sample_line.start.y
-    assert deserialized.start.z == sample_line.start.z
-    assert deserialized.end.x == sample_line.end.x
-    assert deserialized.end.y == sample_line.end.y
-    assert deserialized.end.z == sample_line.end.z
-    assert deserialized.units == sample_line.units
-    assert deserialized.domain.start == sample_line.domain.start
-    assert deserialized.domain.end == sample_line.domain.end
-
-
-def test_line_invalid_construction():
-    """Test error cases"""
-    p1 = Point(x=0.0, y=0.0, z=0.0, units=Units.m)
-
-    # Test with invalid start point
-    with pytest.raises(Exception):
-        Line(start="not a point", end=p1)
-
-    # Test with invalid end point
-    with pytest.raises(Exception):
-        Line(start=p1, end="not a point")

src/specklepy/objects/tests/test_mesh.py

@@ -1,185 +0,0 @@
-import pytest
-
-from specklepy.core.api.operations import deserialize, serialize
-from specklepy.objects.geometry.mesh import Mesh
-from specklepy.objects.geometry.point import Point
-from specklepy.objects.models.units import Units
-
-
-@pytest.fixture
-def cube_vertices():
-
-    return [
-        -0.5, -0.5, -0.5,
-        0.5, -0.5, -0.5,
-        0.5, 0.5, -0.5,
-        -0.5, 0.5, -0.5,
-        -0.5, -0.5, 0.5,
-        0.5, -0.5, 0.5,
-        0.5, 0.5, 0.5,
-        -0.5, 0.5, 0.5
-    ]
-
-
-@pytest.fixture
-def cube_faces():
-
-    return [
-        4, 0, 3, 2, 1,    # bottom (-z)
-        4, 4, 5, 6, 7,    # top (+z)
-        4, 0, 1, 5, 4,    # front (-y)
-        4, 3, 7, 6, 2,    # back (+y)
-        4, 0, 4, 7, 3,    # left (-x)
-        4, 1, 2, 6, 5     # right (+x)
-    ]
-
-
-@pytest.fixture
-def cube_colors():
-
-    return [
-        255, 0, 0, 255,    # red
-        0, 255, 0, 255,    # green
-        0, 0, 255, 255,    # blue
-        255, 255, 0, 255,  # yellow
-        255, 0, 255, 255,  # magenta
-        0, 255, 255, 255,  # cyan
-        255, 255, 255, 255,  # white
-        0, 0, 0, 255       # black
-    ]
-
-
-@pytest.fixture
-def cube_texture_coords():
-
-    return [
-        0.0, 0.0,
-        1.0, 0.0,
-        1.0, 1.0,
-        0.0, 1.0,
-        0.0, 0.0,
-        1.0, 0.0,
-        1.0, 1.0,
-        0.0, 1.0
-    ]
-
-
-@pytest.fixture
-def sample_mesh(cube_vertices, cube_faces):
-
-    return Mesh(vertices=cube_vertices, faces=cube_faces, units=Units.m)
-
-
-@pytest.fixture
-def full_mesh(cube_vertices, cube_faces, cube_colors, cube_texture_coords):
-
-    return Mesh(
-        vertices=cube_vertices,
-        faces=cube_faces,
-        colors=cube_colors,
-        textureCoordinates=cube_texture_coords,
-        units=Units.m
-    )
-
-
-def test_mesh_creation(cube_vertices, cube_faces):
-    mesh = Mesh(vertices=cube_vertices, faces=cube_faces, units=Units.m)
-
-    assert mesh.vertices == cube_vertices
-    assert mesh.faces == cube_faces
-    assert mesh.colors == []
-    assert mesh.textureCoordinates == []
-    assert mesh.units == Units.m.value
-
-
-def test_mesh_vertex_count(sample_mesh):
-    assert sample_mesh.vertices_count == 8  # cube has 8 vertices
-
-
-def test_mesh_texture_coordinates_count(full_mesh):
-    assert full_mesh.texture_coordinates_count == 8  # one UV per vertex
-
-
-def test_mesh_get_point(sample_mesh):
-
-    point = sample_mesh.get_point(0)
-    assert isinstance(point, Point)
-    assert point.x == -0.5
-    assert point.y == -0.5
-    assert point.z == -0.5
-    assert point.units == sample_mesh.units
-
-    with pytest.raises(IndexError):
-        sample_mesh.get_point(8)  # Beyond vertex count
-
-
-def test_mesh_get_points(sample_mesh):
-    points = sample_mesh.get_points()
-    assert len(points) == 8
-    assert all(isinstance(p, Point) for p in points)
-    assert all(p.units == sample_mesh.units for p in points)
-
-
-def test_mesh_get_texture_coordinate(full_mesh):
-    uv = full_mesh.get_texture_coordinate(0)
-    assert uv == (0.0, 0.0)
-
-    with pytest.raises(IndexError):
-        full_mesh.get_texture_coordinate(8)  # beyond UV count
-
-
-def test_mesh_get_face_vertices(sample_mesh):
-    face_vertices = sample_mesh.get_face_vertices(0)
-    assert len(face_vertices) == 4
-    assert all(isinstance(v, Point) for v in face_vertices)
-
-    with pytest.raises(IndexError):
-        sample_mesh.get_face_vertices(6)  # beyond face count
-
-
-def test_mesh_is_closed(sample_mesh):
-    assert sample_mesh.is_closed()  # cube is a closed mesh
-
-
-def test_mesh_area(sample_mesh):
-
-    calculated_area = sample_mesh.calculate_area()
-    sample_mesh.area = calculated_area
-    assert sample_mesh.area == pytest.approx(6.0)
-
-
-def test_mesh_volume(sample_mesh):
-
-    calculated_volume = sample_mesh.calculate_volume()
-    sample_mesh.volume = calculated_volume
-
-    # Verify volume is set correctly
-    assert sample_mesh.volume == pytest.approx(1.0)
-
-
-def test_mesh_invalid_vertices():
-
-    mesh = Mesh(vertices=[0.0, 0.0], faces=[3, 0, 1, 2], units=Units.m)
-
-    with pytest.raises(ValueError):
-        mesh.vertices_count
-
-
-def test_mesh_invalid_faces():
-
-    vertices = [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0]
-    with pytest.raises(IndexError):
-        # Face references vertex index out of range
-        mesh = Mesh(vertices=vertices, faces=[3, 0, 1, 5], units=Units.m)
-        mesh.get_face_vertices(0)
-
-
-def test_mesh_serialization(full_mesh):
-    serialized = serialize(full_mesh)
-    deserialized = deserialize(serialized)
-
-    assert deserialized.vertices == full_mesh.vertices
-    assert deserialized.faces == full_mesh.faces
-    assert deserialized.colors == full_mesh.colors
-    assert deserialized.textureCoordinates == full_mesh.textureCoordinates
-    assert deserialized.units == full_mesh.units

src/specklepy/objects/tests/test_plane.py

@@ -1,117 +0,0 @@
-import pytest
-
-from specklepy.core.api.operations import deserialize, serialize
-from specklepy.objects.geometry import Plane, Point, Vector
-from specklepy.objects.models.units import Units
-
-
-@pytest.fixture
-def sample_point():
-
-    point = Point(x=1.0, y=2.0, z=3.0, units=Units.m)
-    return point
-
-
-@pytest.fixture
-def sample_vectors():
-
-    normal = Vector(x=0.0, y=0.0, z=1.0, units=Units.m)
-    xdir = Vector(x=1.0, y=0.0, z=0.0, units=Units.m)
-    ydir = Vector(x=0.0, y=1.0, z=0.0, units=Units.m)
-
-    return normal, xdir, ydir
-
-
-@pytest.fixture
-def sample_plane(sample_point, sample_vectors):
-
-    normal, xdir, ydir = sample_vectors
-    plane = Plane(
-        origin=sample_point,
-        normal=normal,
-        xdir=xdir,
-        ydir=ydir,
-        units=Units.m
-    )
-    return plane
-
-
-def test_plane_creation(sample_point, sample_vectors):
-
-    normal, xdir, ydir = sample_vectors
-    plane = Plane(
-        origin=sample_point,
-        normal=normal,
-        xdir=xdir,
-        ydir=ydir,
-        units=Units.m
-    )
-
-    assert plane.origin == sample_point
-    assert plane.normal == normal
-    assert plane.xdir == xdir
-    assert plane.ydir == ydir
-    assert plane.units == Units.m.value
-
-
-def test_plane_units(sample_point, sample_vectors):
-
-    normal, xdir, ydir = sample_vectors
-    plane = Plane(
-        origin=sample_point,
-        normal=normal,
-        xdir=xdir,
-        ydir=ydir,
-        units=Units.m
-    )
-
-    assert plane.units == Units.m.value
-
-    plane.units = "mm"
-    assert plane.units == "mm"
-
-
-def test_plane_invalid_construction():
-
-    point = Point(x=1.0, y=2.0, z=3.0, units=Units.m)
-    normal = Vector(x=0.0, y=0.0, z=1.0, units=Units.m)
-    xdir = Vector(x=1.0, y=0.0, z=0.0, units=Units.m)
-    ydir = Vector(x=0.0, y=1.0, z=0.0, units=Units.m)
-
-    with pytest.raises(Exception):
-        Plane(origin="not a point", normal=normal, xdir=xdir, ydir=ydir)
-
-    with pytest.raises(Exception):
-        Plane(origin=point, normal="not a vector", xdir=xdir, ydir=ydir)
-
-    with pytest.raises(Exception):
-        Plane(origin=point, normal=normal, xdir="not a vector", ydir=ydir)
-
-    # Test with invalid ydir vector
-    with pytest.raises(Exception):
-        Plane(origin=point, normal=normal, xdir=xdir, ydir="not a vector")
-
-
-def test_plane_serialization(sample_plane):
-
-    serialized = serialize(sample_plane)
-    deserialized = deserialize(serialized)
-
-    # Check all properties are preserved
-    assert deserialized.origin.x == sample_plane.origin.x
-    assert deserialized.origin.y == sample_plane.origin.y
-    assert deserialized.origin.z == sample_plane.origin.z
-
-    assert deserialized.normal.x == sample_plane.normal.x
-    assert deserialized.normal.y == sample_plane.normal.y
-    assert deserialized.normal.z == sample_plane.normal.z
-
-    assert deserialized.xdir.x == sample_plane.xdir.x
-    assert deserialized.xdir.y == sample_plane.xdir.y
-    assert deserialized.xdir.z == sample_plane.xdir.z
-
-    assert deserialized.ydir.x == sample_plane.ydir.x
-    assert deserialized.ydir.y == sample_plane.ydir.y
-    assert deserialized.ydir.z == sample_plane.ydir.z
-
-    assert deserialized.units == sample_plane.units

src/specklepy/objects/tests/test_point.py

@@ -1,36 +0,0 @@
-import pytest
-
-from specklepy.core.api.operations import deserialize, serialize
-from specklepy.objects.geometry import Point
-from specklepy.objects.models.units import Units
-
-
-def test_point_creation():
-    p1 = Point(x=1.0, y=2.0, z=3.0, units=Units.m)
-    assert p1.x == 1.0
-    assert p1.y == 2.0
-    assert p1.z == 3.0
-    assert p1.units == Units.m.value
-
-
-def test_point_distance_calculation():
-    p1 = Point(x=1.0, y=2.0, z=3.0, units=Units.m)
-    p2 = Point(x=4.0, y=6.0, z=8.0, units=Units.m)
-
-    distance = p1.distance_to(p2)
-    expected = ((3.0**2 + 4.0**2 + 5.0**2) ** 0.5)
-    assert distance == pytest.approx(expected)
-
-    with pytest.raises(TypeError):
-        p1.distance_to("not a point")
-
-
-def test_point_serialization():
-    p1 = Point(x=1.0, y=2.0, z=3.0, units=Units.mm)
-    serialized = serialize(p1)
-    deserialized = deserialize(serialized)
-
-    assert deserialized.x == p1.x
-    assert deserialized.y == p1.y
-    assert deserialized.z == p1.z
-    assert deserialized.units == p1.units

src/specklepy/objects/tests/test_polyline.py

@@ -1,123 +0,0 @@
-import pytest
-
-from specklepy.core.api.operations import deserialize, serialize
-from specklepy.objects.geometry import Point, Polyline
-from specklepy.objects.models.units import Units
-from specklepy.objects.primitive import Interval
-
-
-@pytest.fixture
-def open_square_coords():
-
-    return [
-        0.0, 0.0, 0.0,  # point 1
-        1.0, 0.0, 0.0,  # point 2
-        1.0, 1.0, 0.0,  # point 3
-        0.0, 1.0, 0.0   # point 4
-    ]
-
-
-@pytest.fixture
-def closed_square_coords():
-
-    return [
-        0.0, 0.0, 0.0,  # point 1
-        1.0, 0.0, 0.0,  # point 2
-        1.0, 1.0, 0.0,  # point 3
-        0.0, 1.0, 0.0,  # point 4
-        0.0, 0.0, 0.0   # point 5 (same as point 1)
-    ]
-
-
-@pytest.fixture
-def sample_polyline(open_square_coords):
-    return Polyline(value=open_square_coords, units=Units.m)
-
-
-def test_polyline_creation(open_square_coords):
-    polyline = Polyline(value=open_square_coords, units=Units.m)
-    assert polyline.value == open_square_coords
-    assert polyline.units == Units.m.value
-
-
-def test_polyline_domain(sample_polyline):
-    assert isinstance(sample_polyline.domain, Interval)
-    assert sample_polyline.domain.start == 0.0
-    assert sample_polyline.domain.end == 1.0
-
-
-def test_polyline_is_closed(open_square_coords, closed_square_coords):
-    open_poly = Polyline(value=open_square_coords, units=Units.m)
-    closed_poly = Polyline(value=closed_square_coords, units=Units.m)
-
-    assert not open_poly.is_closed()
-    assert closed_poly.is_closed()
-
-
-def test_polyline_is_closed_with_tolerance(open_square_coords):
-
-    almost_closed = open_square_coords + \
-        [0.0, 0.0, 0.001]  # last point slightly above start
-    poly = Polyline(value=almost_closed, units=Units.m)
-
-    assert not poly.is_closed(tolerance=1e-6)
-    assert poly.is_closed(tolerance=0.01)
-
-
-def test_polyline_length_open(sample_polyline):
-    sample_polyline.length = sample_polyline.calculate_length()
-    assert sample_polyline.length == 3.0
-
-
-def test_polyline_length_closed(closed_square_coords):
-    polyline = Polyline(value=closed_square_coords, units=Units.m)
-    polyline.length = polyline.calculate_length()
-    assert polyline.length == 4.0
-
-
-def test_polyline_get_points(sample_polyline):
-    points = sample_polyline.get_points()
-
-    assert len(points) == 4
-    assert all(isinstance(p, Point) for p in points)
-    assert all(p.units == Units.m.value for p in points)
-
-    # Create expected points
-    expected_points = [
-        Point(x=0.0, y=0.0, z=0.0, units=Units.m),
-        Point(x=1.0, y=0.0, z=0.0, units=Units.m),
-        Point(x=1.0, y=1.0, z=0.0, units=Units.m),
-        Point(x=0.0, y=1.0, z=0.0, units=Units.m)
-    ]
-
-    # Check coordinates match
-    for actual, expected in zip(points, expected_points, strict=False):
-        assert actual.x == expected.x
-        assert actual.y == expected.y
-        assert actual.z == expected.z
-
-
-def test_polyline_invalid_coordinates():
-
-    invalid_coords = [0.0, 0.0, 0.0, 1.0, 1.0]  # missing one coordinate
-    with pytest.raises(ValueError):
-        polyline = Polyline(value=invalid_coords, units=Units.m)
-        polyline.get_points()
-
-
-def test_polyline_units(open_square_coords):
-    polyline = Polyline(value=open_square_coords, units=Units.m)
-    assert polyline.units == Units.m.value
-
-    polyline.units = "mm"
-    assert polyline.units == "mm"
-
-
-def test_polyline_serialization(sample_polyline):
-    serialized = serialize(sample_polyline)
-    deserialized = deserialize(serialized)
-
-    assert deserialized.value == sample_polyline.value
-    assert deserialized.units == sample_polyline.units
-    assert deserialized.domain.start == sample_polyline.domain.start
-    assert deserialized.domain.end == sample_polyline.domain.end

src/specklepy/objects/tests/test_vector.py

@@ -1,42 +0,0 @@
-import pytest
-
-from specklepy.core.api.operations import deserialize, serialize
-from specklepy.objects.geometry import Vector
-from specklepy.objects.models.units import Units
-
-
-def test_vector_creation():
-    v = Vector(x=1.0, y=2.0, z=3.0, units=Units.m)
-    assert v.x == 1.0
-    assert v.y == 2.0
-    assert v.z == 3.0
-    assert v.units == Units.m.value
-
-
-def test_vector_length():
-    v = Vector(x=3.0, y=4.0, z=0.0, units=Units.m)
-    assert v.length == pytest.approx(5.0)  # 3-4-5 triangle
-
-
-def test_vector_units():
-    v = Vector(x=1.0, y=2.0, z=3.0, units=Units.m)
-    assert v.units == Units.m.value
-
-    v.units = "mm"
-    assert v.units == "mm"
-
-
-def test_vector_invalid_construction():
-    with pytest.raises(TypeError):
-        Vector(x=1.0, y=2.0)  # missing z and units
-
-
-def test_vector_serialization():
-    v = Vector(x=1.0, y=2.0, z=3.0, units=Units.m)
-    serialized = serialize(v)
-    deserialized = deserialize(serialized)
-
-    assert deserialized.x == v.x
-    assert deserialized.y == v.y
-    assert deserialized.z == v.z
-    assert deserialized.units == v.units

src/specklepy/objects_v2/GIS/CRS.py

@@ -0,0 +1,15 @@
+from typing import Optional
+
+from specklepy.objects.base import Base
+
+
+class CRS(Base, speckle_type="Objects.GIS.CRS"):
+    """A Coordinate Reference System stored in wkt format"""
+
+    name: Optional[str] = None
+    authority_id: Optional[str] = None
+    wkt: Optional[str] = None
+    units_native: Optional[str] = None
+    offset_x: Optional[float] = None
+    offset_y: Optional[float] = None
+    rotation: Optional[float] = None

src/specklepy/objects_v2/GIS/__init__.py

@@ -0,0 +1,24 @@
+"""Builtin Speckle object kit."""
+
+from specklepy.objects.GIS.CRS import CRS
+from specklepy.objects.GIS.geometry import (
+    GisLineElement,
+    GisPointElement,
+    GisPolygonElement,
+    GisPolygonGeometry,
+    GisRasterElement,
+    PolygonGeometry,
+)
+from specklepy.objects.GIS.layers import RasterLayer, VectorLayer
+
+__all__ = [
+    "VectorLayer",
+    "RasterLayer",
+    "GisPolygonGeometry",
+    "PolygonGeometry",
+    "GisPolygonElement",
+    "GisLineElement",
+    "GisPointElement",
+    "GisRasterElement",
+    "CRS",
+]

src/specklepy/objects_v2/GIS/geometry.py

@@ -0,0 +1,74 @@
+from typing import List, Optional, Union
+
+from specklepy.objects.base import Base
+from specklepy.objects.geometry import (
+    Arc,
+    Circle,
+    Line,
+    Mesh,
+    Point,
+    Polycurve,
+    Polyline,
+)
+
+
+class PolygonGeometry(Base, speckle_type="Objects.GIS.PolygonGeometry"):
+    """GIS Polygon Geometry"""
+
+    boundary: Optional[Polyline]
+    voids: Optional[List[Polyline]]
+
+
+GisPolygonGeometry = PolygonGeometry
+
+
+class GisPolygonElement(Base, speckle_type="Objects.GIS.PolygonElement"):
+    """GIS Polygon element"""
+
+    geometry: Optional[List[GisPolygonGeometry]] = None
+    attributes: Optional[Base] = None
+
+
+class GisLineElement(Base, speckle_type="Objects.GIS.LineElement"):
+    """GIS Polyline element"""
+
+    geometry: Optional[List[Union[Polyline, Arc, Line, Circle, Polycurve]]] = None
+    attributes: Optional[Base] = None
+
+
+class GisPointElement(Base, speckle_type="Objects.GIS.PointElement"):
+    """GIS Point element"""
+
+    geometry: Optional[List[Point]] = None
+    attributes: Optional[Base] = None
+
+
+class GisRasterElement(
+    Base, speckle_type="Objects.GIS.RasterElement", detachable={"displayValue"}
+):
+    """GIS Raster element"""
+
+    band_count: Optional[int] = None
+    band_names: Optional[List[str]] = None
+    x_origin: Optional[float] = None
+    y_origin: Optional[float] = None
+    x_size: Optional[int] = None
+    y_size: Optional[int] = None
+    x_resolution: Optional[float] = None
+    y_resolution: Optional[float] = None
+    noDataValue: Optional[List[float]] = None
+    displayValue: Optional[List[Mesh]] = None
+
+
+class GisTopography(
+    GisRasterElement,
+    speckle_type="Objects.GIS.GisTopography",
+    detachable={"displayValue"},
+):
+    """GIS Raster element with 3d Topography representation"""
+
+
+class GisNonGeometryElement(Base, speckle_type="Objects.GIS.NonGeometryElement"):
+    """GIS Table feature"""
+
+    attributes: Optional[Base] = None

src/specklepy/objects_v2/GIS/layers.py

@@ -0,0 +1,142 @@
+from typing import Any, Dict, List, Optional, Union
+
+from deprecated import deprecated
+
+from specklepy.objects.base import Base
+from specklepy.objects.GIS.CRS import CRS
+from specklepy.objects.other import Collection
+
+
+@deprecated(version="2.15", reason="Use VectorLayer or RasterLayer instead")
+class Layer(Base, detachable={"features"}):
+    """A GIS Layer"""
+
+    def __init__(
+        self,
+        name: Optional[str] = None,
+        crs: Optional[CRS] = None,
+        units: str = "m",
+        features: Optional[List[Base]] = None,
+        layerType: str = "None",
+        geomType: str = "None",
+        renderer: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.name = name
+        self.crs = crs
+        self.units = units
+        self.type = layerType
+        self.features = features or []
+        self.geomType = geomType
+        self.renderer = renderer or {}
+
+
+@deprecated(version="2.16", reason="Use VectorLayer or RasterLayer instead")
+class VectorLayer(
+    Collection,
+    detachable={"elements"},
+    speckle_type="VectorLayer",
+    serialize_ignore={"features"},
+):
+    """GIS Vector Layer"""
+
+    name: Optional[str] = None
+    crs: Optional[Union[CRS, Base]] = None
+    units: Optional[str] = None
+    elements: Optional[List[Base]] = None
+    attributes: Optional[Base] = None
+    geomType: Optional[str] = "None"
+    renderer: Optional[Dict[str, Any]] = None
+    collectionType = "VectorLayer"
+
+    @property
+    @deprecated(version="2.14", reason="Use elements")
+    def features(self) -> Optional[List[Base]]:
+        return self.elements
+
+    @features.setter
+    def features(self, value: Optional[List[Base]]) -> None:
+        self.elements = value
+
+
+@deprecated(version="2.16", reason="Use VectorLayer or RasterLayer instead")
+class RasterLayer(
+    Collection,
+    detachable={"elements"},
+    speckle_type="RasterLayer",
+    serialize_ignore={"features"},
+):
+    """GIS Raster Layer"""
+
+    name: Optional[str] = None
+    crs: Optional[Union[CRS, Base]] = None
+    units: Optional[str] = None
+    rasterCrs: Optional[Union[CRS, Base]] = None
+    elements: Optional[List[Base]] = None
+    geomType: Optional[str] = "None"
+    renderer: Optional[Dict[str, Any]] = None
+    collectionType = "RasterLayer"
+
+    @property
+    @deprecated(version="2.14", reason="Use elements")
+    def features(self) -> Optional[List[Base]]:
+        return self.elements
+
+    @features.setter
+    def features(self, value: Optional[List[Base]]) -> None:
+        self.elements = value
+
+
+class VectorLayer(  # noqa: F811
+    Collection,
+    detachable={"elements"},
+    speckle_type="Objects.GIS.VectorLayer",
+    serialize_ignore={"features"},
+):
+    """GIS Vector Layer"""
+
+    name: Optional[str] = None
+    crs: Optional[Union[CRS, Base]] = None
+    units: Optional[str] = None
+    elements: Optional[List[Base]] = None
+    attributes: Optional[Base] = None
+    geomType: Optional[str] = "None"
+    renderer: Optional[Dict[str, Any]] = None
+    collectionType = "VectorLayer"
+
+    @property
+    @deprecated(version="2.14", reason="Use elements")
+    def features(self) -> Optional[List[Base]]:
+        return self.elements
+
+    @features.setter
+    def features(self, value: Optional[List[Base]]) -> None:
+        self.elements = value
+
+
+class RasterLayer(  # noqa: F811
+    Collection,
+    detachable={"elements"},
+    speckle_type="Objects.GIS.RasterLayer",
+    serialize_ignore={"features"},
+):
+    """GIS Raster Layer"""
+
+    name: Optional[str] = None
+    crs: Optional[Union[CRS, Base]] = None
+    units: Optional[str] = None
+    rasterCrs: Optional[Union[CRS, Base]] = None
+    elements: Optional[List[Base]] = None
+    geomType: Optional[str] = "None"
+    renderer: Optional[Dict[str, Any]] = None
+    collectionType = "RasterLayer"
+
+    @property
+    @deprecated(version="2.14", reason="Use elements")
+    def features(self) -> Optional[List[Base]]:
+        return self.elements
+
+    @features.setter
+    def features(self, value: Optional[List[Base]]) -> None:
+        self.elements = value

src/specklepy/objects_v2/__init__.py

@@ -0,0 +1,23 @@
+"""Builtin Speckle object kit."""
+
+# from specklepy.objects import (
+#     GIS,
+#     encoding,
+#     geometry,
+#     other,
+#     primitive,
+#     structural,
+#     units,
+# )
+from specklepy.objects.base import Base
+
+__all__ = [
+    "Base",
+    # "encoding",
+    # "geometry",
+    # "other",
+    # "units",
+    # "structural",
+    # "primitive",
+    # "GIS",
+]

src/specklepy/objects_v2/base.py

@@ -0,0 +1,588 @@
+import contextlib
+from enum import Enum
+from inspect import isclass
+from typing import (
+    Any,
+    ClassVar,
+    Dict,
+    ForwardRef,
+    List,
+    Optional,
+    Set,
+    Tuple,
+    Type,
+    Union,
+    get_type_hints,
+)
+from warnings import warn
+
+from stringcase import pascalcase
+
+from specklepy.logging.exceptions import SpeckleException, SpeckleInvalidUnitException
+from specklepy.objects.units import Units
+from specklepy.transports.memory import MemoryTransport
+
+PRIMITIVES = (int, float, str, bool)
+
+# to remove from dir() when calling get_member_names()
+REMOVE_FROM_DIR = {
+    "Config",
+    "_Base__dict_helper",
+    "__annotations__",
+    "__class__",
+    "__delattr__",
+    "__dict__",
+    "__dir__",
+    "__doc__",
+    "__eq__",
+    "__format__",
+    "__ge__",
+    "__getattribute__",
+    "__getitem__",
+    "__gt__",
+    "__hash__",
+    "__init__",
+    "__init_subclass__",
+    "__le__",
+    "__lt__",
+    "__module__",
+    "__ne__",
+    "__new__",
+    "__reduce__",
+    "__reduce_ex__",
+    "__repr__",
+    "__setattr__",
+    "__setitem__",
+    "__sizeof__",
+    "__str__",
+    "__subclasshook__",
+    "__weakref__",
+    "_chunk_size_default",
+    "_chunkable",
+    "_count_descendants",
+    "_attr_types",
+    "_detachable",
+    "_handle_object_count",
+    "_type_check",
+    "_type_registry",
+    "_units",
+    "add_chunkable_attrs",
+    "add_detachable_attrs",
+    "get_children_count",
+    "get_dynamic_member_names",
+    "get_id",
+    "get_member_names",
+    "get_registered_type",
+    "get_typed_member_names",
+    "to_dict",
+    "update_forward_refs",
+    "validate_prop_name",
+    "from_list",
+    "to_list",
+}
+
+
+class _RegisteringBase:
+    """
+    Private Base model for Speckle types.
+
+    This is an implementation detail, please do not use this outside this module.
+
+    This class provides automatic registration of `speckle_type` into a global,
+    (class level) registry for each subclassing type.
+    The type registry is a base for accurate type based (de)serialization.
+    """
+
+    speckle_type: ClassVar[str]
+    _speckle_type_override: ClassVar[Optional[str]] = None
+    _speckle_namespace: ClassVar[Optional[str]] = None
+    _type_registry: ClassVar[Dict[str, Type["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()
+
+    @classmethod
+    def get_registered_type(cls, speckle_type: str) -> Optional[Type["Base"]]:
+        """Get the registered type from the protected mapping via the `speckle_type`"""
+        for full_name in reversed(speckle_type.split(":")):
+            maybe_type = cls._type_registry.get(full_name, None)
+            if maybe_type:
+                return maybe_type
+        return None
+
+    @classmethod
+    def _determine_speckle_type(cls) -> str:
+        """
+        This method brings the speckle_type construction in par with Speckle-sharp/Core.
+
+        The implementation differs, because in Core the basis of the speckle_type if
+        type.FullName, which includes the dotnet namespace name too.
+        Copying that behavior is hard in python, where the concept of namespaces
+        means something entirely different.
+
+        So we enabled a speckle_type override mechanism, that enables
+        """
+        base_name = "Base"
+        if cls.__name__ == base_name:
+            return base_name
+
+        bases = [
+            b._full_name()
+            for b in reversed(cls.mro())
+            if issubclass(b, Base) and b.__name__ != base_name
+        ]
+        return ":".join(bases)
+
+    @classmethod
+    def _full_name(cls) -> str:
+        base_name = "Base"
+        if cls.__name__ == base_name:
+            return base_name
+
+        if cls._speckle_type_override:
+            return cls._speckle_type_override
+
+        # convert the module names to PascalCase to match c# namespace naming convention
+        # also drop specklepy from the beginning
+        namespace = ".".join(
+            pascalcase(m)
+            for m in filter(lambda name: name != "specklepy", cls.__module__.split("."))
+        )
+        return f"{namespace}.{cls.__name__}"
+
+    def __init_subclass__(
+        cls,
+        speckle_type: Optional[str] = None,
+        chunkable: Optional[Dict[str, int]] = None,
+        detachable: Optional[Set[str]] = None,
+        serialize_ignore: Optional[Set[str]] = None,
+        **kwargs: Dict[str, Any],
+    ):
+        """
+        Hook into subclass type creation.
+
+        This is provides a mechanism to hook into the event of the subclass type object
+        initialization. This is reused to register each subclassing type into a class
+        level dictionary.
+        """
+        # if not speckle_type:
+        #     raise Exception("no type")
+        cls._speckle_type_override = speckle_type
+        cls.speckle_type = cls._determine_speckle_type()
+        # cls.speckle_type = speckle_type
+        if cls._full_name() in cls._type_registry:
+            raise ValueError(
+                f"The speckle_type: {speckle_type} is already registered for type: "
+                f"{cls._type_registry[cls._full_name()].__name__}. "
+                "Please choose a different type name."
+            )
+        cls._type_registry[cls._full_name()] = cls  # type: ignore
+        try:
+            cls._attr_types = get_type_hints(cls)
+        except Exception:
+            cls._attr_types = getattr(cls, "__annotations__", {})
+        if chunkable:
+            chunkable = {k: v for k, v in chunkable.items() if isinstance(v, int)}
+            cls._chunkable = dict(cls._chunkable, **chunkable)
+        if detachable:
+            cls._detachable = cls._detachable.union(detachable)
+        if serialize_ignore:
+            cls._serialize_ignore = cls._serialize_ignore.union(serialize_ignore)
+        # we know, that the super here is object, that takes no args on init subclass
+        return super().__init_subclass__()
+
+
+# T = TypeVar("T")
+
+# how i wish the code below would be correct, but we're also parsing into floats
+# and converting into strings if the original type is string, but the value isn't
+# def _validate_type(t: type, value: T) -> Tuple[bool, T]:
+
+
+def _validate_type(t: Optional[type], value: Any) -> Tuple[bool, Any]:
+    # this should be reworked. Its only ok to return null for Optionals...
+    # if t is None and value is None:
+    if value is None:
+        return True, value
+
+    # after fixing the None t above, this should be
+    # if t is Any:
+    # if t is None:
+
+    if t is None or t is Any:
+        return True, value
+
+    if isclass(t) and issubclass(t, Enum):
+        if isinstance(value, t):
+            return True, value
+        if value in t._value2member_map_:
+            return True, t(value)
+
+    if getattr(t, "__module__", None) == "typing":
+        if isinstance(t, ForwardRef):
+            return True, value
+
+        origin = getattr(t, "__origin__")
+        # below is what in nicer for >= py38
+        # origin = get_origin(t)
+
+        # recursive validation for Unions on both types preferring the fist type
+        if origin is Union:
+            # below is what in nicer for >= py38
+            # t_1, t_2 = get_args(t)
+            args = t.__args__  # type: ignore
+            for arg_t in args:
+                t_success, t_value = _validate_type(arg_t, value)
+                if t_success:
+                    return True, t_value
+            return False, value
+        if origin is dict:
+            if not isinstance(value, dict):
+                return False, value
+            if value == {}:
+                return True, value
+            if not getattr(t, "__args__", None):
+                return True, value
+            t_key, t_value = t.__args__  # type: ignore
+
+            if (
+                getattr(t_key, "__name__", None),
+                getattr(t_value, "__name__", None),
+            ) == ("KT", "VT"):
+                return True, value
+            # we're only checking the first item, but the for loop and return after
+            # evaluating the first item is the fastest way
+            for dict_key, dict_value in value.items():
+                valid_key, _ = _validate_type(t_key, dict_key)
+                valid_value, _ = _validate_type(t_value, dict_value)
+
+                if valid_key and valid_value:
+                    return True, value
+                return False, value
+
+        if origin is list:
+            if not isinstance(value, list):
+                return False, value
+            if value == []:
+                return True, value
+            if not hasattr(t, "__args__"):
+                return True, value
+            t_items = t.__args__[0]  # type: ignore
+            if getattr(t_items, "__name__", None) == "T":
+                return True, value
+            first_item_valid, _ = _validate_type(t_items, value[0])
+            if first_item_valid:
+                return True, value
+            return False, value
+
+        if origin is tuple:
+            if not isinstance(value, tuple):
+                return False, value
+            if not hasattr(t, "__args__"):
+                return True, value
+            args = t.__args__  # type: ignore
+            if args == tuple():
+                return True, value
+            # we're not checking for empty tuple, cause tuple lengths must match
+            if len(args) != len(value):
+                return False, value
+            values = []
+            for t_item, v_item in zip(args, value):
+                item_valid, item_value = _validate_type(t_item, v_item)
+                if not item_valid:
+                    return False, value
+                values.append(item_value)
+            return True, tuple(values)
+
+        if origin is set:
+            if not isinstance(value, set):
+                return False, value
+            if not hasattr(t, "__args__"):
+                return True, value
+            t_items = t.__args__[0]  # type: ignore
+            first_item_valid, _ = _validate_type(t_items, next(iter(value)))
+            if first_item_valid:
+                return True, value
+            return False, value
+
+    if isinstance(value, t):
+        return True, value
+
+    with contextlib.suppress(ValueError, TypeError):
+        if t is float and value is not None:
+            return True, float(value)
+        # TODO: dafuq, i had to add this not list check
+        # but it would also fail for objects and other complex values
+        if t is str and value and not isinstance(value, list):
+            return True, str(value)
+
+    return False, value
+
+
+class Base(_RegisteringBase, speckle_type="Base"):
+    # id: Union[str, None] = None
+    # totalChildrenCount: Union[int, None] = None
+    # applicationId: Union[str, None] = None
+    _units: Union[None, str] = None
+
+    def __init__(
+        self,
+        id: str | None = None,
+        # totalChildrenCount: Union[int, None] = None,
+        applicationId: str | None = None,
+        **kwargs,
+    ) -> None:
+        self.id = id
+        # self.totalChildrenCount = totalChildrenCount
+        self.applicationId = applicationId
+        super().__init__()
+        for k, v in kwargs.items():
+            self.__setattr__(k, v)
+
+    def __repr__(self) -> str:
+        return (
+            f"{self.__class__.__name__}(id: {self.id}, "
+            f"speckle_type: {self.speckle_type}, "
+            # f"totalChildrenCount: {self.totalChildrenCount})"
+        )
+
+    def __str__(self) -> str:
+        return self.__repr__()
+
+    @classmethod
+    def of_type(cls, speckle_type: str, **kwargs) -> "Base":
+        """
+        Get a plain Base object with a specified speckle_type.
+
+        The speckle_type is protected and cannot be overwritten on a class instance.
+        This is to prevent problems with receiving in other platforms or connectors.
+        However, if you really need a base with a different type, here is a helper
+        to do that for you.
+
+        This is used in the deserialisation of unknown types so their speckle_type
+        can be preserved.
+        """
+        b = cls(**kwargs)
+        b.__dict__.update(speckle_type=speckle_type)
+        return b
+
+    def __setitem__(self, name: str, value: Any) -> None:
+        self.validate_prop_name(name)
+        self.__dict__[name] = value
+
+    def __getitem__(self, name: str) -> Any:
+        return self.__dict__[name]
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        """
+        Type checking, guard attribute, and property set mechanism.
+
+        The `speckle_type` is a protected class attribute it must not be overridden.
+
+        This also performs a type check if the attribute is type hinted.
+        """
+        if name == "speckle_type":
+            # not sure if we should raise an exception here??
+            # raise SpeckleException(
+            #     "Cannot override the `speckle_type`. This is set manually by the class or on deserialisation"
+            # )
+            return
+        # if value is not None:
+        value = self._type_check(name, value)
+        attr = getattr(self.__class__, name, None)
+        if isinstance(attr, property):
+            try:
+                attr.__set__(self, value)
+            except AttributeError:
+                return  # the prop probably doesn't have a setter
+        super().__setattr__(name, value)
+
+    @classmethod
+    def update_forward_refs(cls) -> None:
+        """
+        Attempts to populate the internal defined types dict for type checking
+        sometime after defining the class.
+        This is already done when defining the class, but can be called
+        again if references to undefined types were
+        included.
+
+        See `objects.geometry` for an example of how this is used with
+        the Brep class definitions.
+        """
+        try:
+            cls._attr_types = get_type_hints(cls)
+        except Exception as e:
+            warn(f"Could not update forward refs for class {cls.__name__}: {e}")
+
+    @classmethod
+    def validate_prop_name(cls, name: str) -> None:
+        """Validator for dynamic attribute names."""
+        if name in {"", "@"}:
+            raise ValueError("Invalid Name: Base member names cannot be empty strings")
+        if name.startswith("@@"):
+            raise ValueError(
+                "Invalid Name: Base member names cannot start with more than one '@'",
+            )
+        if "." in name or "/" in name:
+            raise ValueError(
+                "Invalid Name: Base member names cannot contain characters '.' or '/'",
+            )
+
+    def _type_check(self, name: str, value: Any) -> Any:
+        """
+        Lightweight type checking of values before setting them
+
+        NOTE: Does not check subscripted types within generics as the performance hit
+        of checking each item within a given collection isn't worth it.
+        Eg if you have a type Dict[str, float],
+        we will only check if the value you're trying to set is a dict.
+        """
+        types = getattr(self, "_attr_types", {})
+        t = types.get(name, None)
+
+        valid, checked_value = _validate_type(t, value)
+
+        if valid:
+            return checked_value
+
+        raise SpeckleException(
+            f"Cannot set '{self.__class__.__name__}.{name}':"
+            f"it expects type '{str(t)}',"
+            f"but received type '{type(value).__name__}'"
+        )
+
+    def add_chunkable_attrs(self, **kwargs: int) -> None:
+        """
+        Mark defined attributes as chunkable for serialisation
+
+        Arguments:
+            kwargs {int} -- the name of the attribute as the keyword
+            and the chunk size as the arg
+        """
+        chunkable = {k: v for k, v in kwargs.items() if isinstance(v, int)}
+        self._chunkable = dict(self._chunkable, **chunkable)
+
+    def add_detachable_attrs(self, names: Set[str]) -> None:
+        """
+        Mark defined attributes as detachable for serialisation
+
+        Arguments:
+            names {Set[str]} -- the names of the attributes to detach as a set of string
+        """
+        self._detachable = self._detachable.union(names)
+
+    @property
+    def units(self) -> Union[str, None]:
+        return self._units
+
+    @units.setter
+    def units(self, value: Union[str, Units, None]):
+        """While this property accepts any string value, geometry expects units to be specific strings (see Units enum)"""
+        if isinstance(value, str) or value is None:
+            self._units = value
+        elif isinstance(value, Units):
+            self._units = value.value
+        else:
+            raise SpeckleInvalidUnitException(
+                f"Unknown type {type(value)} received for units"
+            )
+
+    def get_member_names(self) -> List[str]:
+        """Get all of the property names on this object, dynamic or not"""
+        attr_dir = list(set(dir(self)) - REMOVE_FROM_DIR)
+        return [
+            name
+            for name in attr_dir
+            if not name.startswith("_") and not callable(getattr(self, name))
+        ]
+
+    def get_serializable_attributes(self) -> List[str]:
+        """Get the attributes that should be serialized"""
+        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"""
+        return list(self._attr_types.keys())
+
+    def get_dynamic_member_names(self) -> List[str]:
+        """Get all of the names of the dynamic properties of this object"""
+        return list(set(self.__dict__.keys()) - set(self._attr_types.keys()))
+
+    def get_children_count(self) -> int:
+        """Get the total count of children Base objects"""
+        parsed = []
+        return 1 + self._count_descendants(self, parsed)
+
+    def get_id(self, decompose: bool = False) -> str:
+        """
+        Gets the id (a unique hash) of this object.
+        ⚠️ This method fully serializes the object which,
+        in the case of large objects (with many sub-objects), has a tangible cost.
+        Avoid using it!
+
+        Note: the hash of a decomposed object differs from that of a
+        non-decomposed object
+
+        Arguments:
+            decompose {bool} -- if True, will decompose the object in
+            the process of hashing it
+
+        Returns:
+            str -- the hash (id) of the fully serialized object
+        """
+        from specklepy.serialization.base_object_serializer import BaseObjectSerializer
+
+        serializer = BaseObjectSerializer()
+        if decompose:
+            serializer.write_transports = [MemoryTransport()]
+        return serializer.traverse_base(self)[0]
+
+    def _count_descendants(self, base: "Base", parsed: List) -> int:
+        if base in parsed:
+            return 0
+        parsed.append(base)
+
+        return sum(
+            self._handle_object_count(value, parsed)
+            for name, value in base.get_member_names()
+            if not name.startswith("@")
+        )
+
+    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
+        if isinstance(obj, "Base"):
+            count += 1
+            count += self._count_descendants(obj, parsed)
+            return count
+        elif isinstance(obj, list):
+            for item in obj:
+                if isinstance(item, "Base"):
+                    count += 1
+                    count += self._count_descendants(item, parsed)
+                else:
+                    count += self._handle_object_count(item, parsed)
+        elif isinstance(obj, dict):
+            for _, value in obj.items():
+                if isinstance(value, "Base"):
+                    count += 1
+                    count += self._count_descendants(value, parsed)
+                else:
+                    count += self._handle_object_count(value, parsed)
+        return count
+
+
+Base.update_forward_refs()
+
+
+class DataChunk(Base, speckle_type="Speckle.Core.Models.DataChunk"):
+    data: Union[List[Any], None] = None
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.data = []

src/specklepy/objects_v2/encoding.py

@@ -0,0 +1,131 @@
+from enum import Enum
+from typing import Any, Callable, Dict, List, Optional, Type
+
+from specklepy.logging.exceptions import SpeckleException
+from specklepy.objects.base import Base
+
+
+class CurveTypeEncoding(int, Enum):
+    Arc = 0
+    Circle = 1
+    Curve = 2
+    Ellipse = 3
+    Line = 4
+    Polyline = 5
+    Polycurve = 6
+
+    @property
+    def object_class(self) -> Type:
+        from . import geometry
+
+        if self == self.Arc:
+            return geometry.Arc
+        elif self == self.Circle:
+            return geometry.Circle
+        elif self == self.Curve:
+            return geometry.Curve
+        elif self == self.Ellipse:
+            return geometry.Ellipse
+        elif self == self.Line:
+            return geometry.Line
+        elif self == self.Polyline:
+            return geometry.Polyline
+        elif self == self.Polycurve:
+            return geometry.Polycurve
+        raise SpeckleException(
+            f"No corresponding object class for CurveTypeEncoding: {self}"
+        )
+
+
+def curve_from_list(args: List[float]):
+    curve_type = CurveTypeEncoding(args[0])
+    return curve_type.object_class.from_list(args)
+
+
+class ObjectArray:
+    def __init__(self, data: Optional[list] = None) -> None:
+        self.data = data or []
+
+    @classmethod
+    def from_objects(cls, objects: List[Base]) -> "ObjectArray":
+        data_list = cls()
+        if not objects:
+            return data_list
+
+        speckle_type = objects[0].speckle_type
+
+        for obj in objects:
+            if speckle_type != obj.speckle_type:
+                raise SpeckleException(
+                    "All objects in chunk should have the same speckle_type. "
+                    f"Found {speckle_type} and {obj.speckle_type}"
+                )
+            data_list.encode_object(obj=obj)
+
+        return data_list
+
+    @staticmethod
+    def decode_data(
+        data: List[Any], decoder: Callable[[List[Any]], Base], **kwargs: Dict[str, Any]
+    ) -> List[Base]:
+        bases: List[Base] = []
+        if not data:
+            return bases
+        index = 0
+        while index < len(data):
+            item_length = int(data[index])
+            item_start = index + 1
+            item_end = item_start + item_length
+            item_data = data[item_start:item_end]
+            index = item_end
+            decoded_data = decoder(item_data, **kwargs)
+            bases.append(decoded_data)
+
+        return bases
+
+    def decode(self, decoder: Callable[[List[Any]], Any], **kwargs: Dict[str, Any]):
+        return self.decode_data(data=self.data, decoder=decoder, **kwargs)
+
+    def encode_object(self, obj: Base):
+        encoded = obj.to_list()
+        encoded.insert(0, len(encoded))
+        self.data.extend(encoded)
+
+
+class CurveArray(ObjectArray):
+    @classmethod
+    def from_curve(cls, curve: Base) -> "CurveArray":
+        crv_array = cls()
+        crv_array.data = curve.to_list()
+        return crv_array
+
+    @classmethod
+    def from_curves(cls, curves: List[Base]) -> "CurveArray":
+        data = []
+        for curve in curves:
+            curve_list = curve.to_list()
+            curve_list.insert(0, len(curve_list))
+            data.extend(curve_list)
+        crv_array = cls()
+        crv_array.data = data
+        return crv_array
+
+    @staticmethod
+    def curve_from_list(args: List[float]) -> Base:
+        curve_type = CurveTypeEncoding(args[0])
+        return curve_type.object_class.from_list(args)
+
+    @property
+    def type(self) -> CurveTypeEncoding:
+        return CurveTypeEncoding(self.data[0])
+
+    def to_curve(self) -> Base:
+        return self.type.object_class.from_list(self.data)
+
+    @classmethod
+    def _curve_decoder(cls, data: List[float]) -> Base:
+        crv_array = cls(data)
+        return crv_array.to_curve()
+
+    def to_curves(self) -> List[Base]:
+        return self.decode(decoder=self._curve_decoder)

src/specklepy/objects_v2/fakemesh.py

@@ -3,7 +3,7 @@ from typing import List, Optional
 
 from specklepy.objects.geometry import Point
 
-from specklepy.objects.base import Base
+from .base import Base
 
 CHUNKABLE_PROPS = {
     "vertices": 100,

src/specklepy/objects_v2/geometry.py

@@ -0,0 +1,946 @@
+from enum import Enum
+from typing import Any, List, Optional
+
+from specklepy.objects.base import Base
+from specklepy.objects.encoding import CurveArray, CurveTypeEncoding, ObjectArray
+from specklepy.objects.primitive import Interval
+from specklepy.objects.units import get_encoding_from_units, get_units_from_encoding
+
+GEOMETRY = "Objects.Geometry."
+
+
+class Point(Base, speckle_type=GEOMETRY + "Point"):
+    x: float = 0.0
+    y: float = 0.0
+    z: float = 0.0
+
+    def __repr__(self) -> str:
+        return (
+            f"{self.__class__.__name__}(x: {self.x}, y: {self.y}, z: {self.z}, id:"
+            f" {self.id}, speckle_type: {self.speckle_type})"
+        )
+
+    @classmethod
+    def from_list(cls, args: List[float]) -> "Point":
+        """
+        Create a new Point from a list of three floats
+        representing the x, y, and z coordinates
+        """
+        return cls(x=args[0], y=args[1], z=args[2])
+
+    def to_list(self) -> List[Any]:
+        return [self.x, self.y, self.z]
+
+    @classmethod
+    def from_coords(cls, x: float = 0.0, y: float = 0.0, z: float = 0.0):
+        """Create a new Point from x, y, and z values"""
+        pt = Point()
+        pt.x, pt.y, pt.z = x, y, z
+        return pt
+
+
+class Pointcloud(
+    Base,
+    speckle_type=GEOMETRY + "Pointcloud",
+    chunkable={"points": 31250, "colors": 62500, "sizes": 62500},
+):
+    points: Optional[List[float]] = None
+    colors: Optional[List[int]] = None
+    sizes: Optional[List[float]] = None
+    bbox: Optional["Box"] = None
+
+
+class Vector(Base, speckle_type=GEOMETRY + "Vector"):
+    x: float = 0.0
+    y: float = 0.0
+    z: float = 0.0
+    applicationId: Optional[str] = None
+
+    def __repr__(self) -> str:
+        return (
+            f"{self.__class__.__name__} "
+            "(x: {self.x}, y: {self.y}, z: {self.z}, id: {self.id}, "
+            "speckle_type: {self.speckle_type})"
+        )
+
+    @classmethod
+    def from_list(cls, args: List[float]) -> "Vector":
+        """
+        Create from a list of three floats representing the x, y, and z coordinates.
+        """
+        return cls(x=args[0], y=args[1], z=args[2])
+
+    def to_list(self) -> List[float]:
+        return [self.x, self.y, self.z]
+
+    @classmethod
+    def from_coords(cls, x: float = 0.0, y: float = 0.0, z: float = 0.0) -> "Vector":
+        """Create a new Point from x, y, and z values"""
+        v = Vector()
+        v.x, v.y, v.z = x, y, z
+        return v
+
+
+class ControlPoint(Point, speckle_type=GEOMETRY + "ControlPoint"):
+    weight: Optional[float] = None
+
+
+class Plane(Base, speckle_type=GEOMETRY + "Plane"):
+    origin: Point = Point()
+    normal: Vector = Vector()
+    xdir: Vector = Vector()
+    ydir: Vector = Vector()
+
+    @classmethod
+    def from_list(cls, args: List[Any]) -> "Plane":
+        return cls(
+            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]:
+        return [
+            *self.origin.to_list(),
+            *self.normal.to_list(),
+            *self.xdir.to_list(),
+            *self.ydir.to_list(),
+            get_encoding_from_units(self._units),
+        ]
+
+
+class Box(Base, speckle_type=GEOMETRY + "Box"):
+    basePlane: Plane = Plane()
+    xSize: Interval = Interval()
+    ySize: Interval = Interval()
+    zSize: Interval = Interval()
+    area: Optional[float] = None
+    volume: Optional[float] = None
+
+
+class Line(Base, speckle_type=GEOMETRY + "Line"):
+    start: Point = Point()
+    end: Optional[Point] = None
+    domain: Optional[Interval] = None
+    bbox: Optional[Box] = None
+    length: Optional[float] = None
+
+    @classmethod
+    def from_list(cls, args: List[Any]) -> "Line":
+        return cls(
+            start=Point.from_list(args[1:4]),
+            end=Point.from_list(args[4:7]),
+            domain=Interval.from_list(args[7:10]),
+            units=get_units_from_encoding(args[-1]),
+        )
+
+    def to_list(self) -> List[Any]:
+        domain = self.domain.to_list() if self.domain else [0, 1]
+        return [
+            CurveTypeEncoding.Line.value,
+            *self.start.to_list(),
+            *self.end.to_list(),
+            *domain,
+            get_encoding_from_units(self._units),
+        ]
+
+
+class Arc(Base, speckle_type=GEOMETRY + "Arc"):
+    radius: Optional[float] = None
+    startAngle: Optional[float] = None
+    endAngle: Optional[float] = None
+    angleRadians: Optional[float] = None
+    plane: Optional[Plane] = None
+    domain: Optional[Interval] = None
+    startPoint: Optional[Point] = None
+    midPoint: Optional[Point] = None
+    endPoint: Optional[Point] = None
+    bbox: Optional[Box] = None
+    area: Optional[float] = None
+    length: Optional[float] = None
+
+    @classmethod
+    def from_list(cls, args: List[Any]) -> "Arc":
+        return cls(
+            radius=args[1],
+            startAngle=args[2],
+            endAngle=args[3],
+            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]:
+        return [
+            CurveTypeEncoding.Arc.value,
+            self.radius,
+            self.startAngle,
+            self.endAngle,
+            self.angleRadians,
+            *self.domain.to_list(),
+            *self.plane.to_list(),
+            *self.startPoint.to_list(),
+            *self.midPoint.to_list(),
+            *self.endPoint.to_list(),
+            get_encoding_from_units(self._units),
+        ]
+
+
+class Circle(Base, speckle_type=GEOMETRY + "Circle"):
+    radius: Optional[float] = None
+    plane: Optional[Plane] = None
+    domain: Optional[Interval] = None
+    bbox: Optional[Box] = None
+    area: Optional[float] = None
+    length: Optional[float] = None
+
+    @classmethod
+    def from_list(cls, args: List[Any]) -> "Circle":
+        return cls(
+            radius=args[1],
+            domain=Interval.from_list(args[2:4]),
+            plane=Plane.from_list(args[4:17]),
+            units=get_units_from_encoding(args[-1]),
+        )
+
+    def to_list(self) -> List[Any]:
+        return [
+            CurveTypeEncoding.Circle.value,
+            self.radius,
+            *self.domain.to_list(),
+            *self.plane.to_list(),
+            get_encoding_from_units(self._units),
+        ]
+
+
+class Ellipse(Base, speckle_type=GEOMETRY + "Ellipse"):
+    firstRadius: Optional[float] = None
+    secondRadius: Optional[float] = None
+    plane: Optional[Plane] = None
+    domain: Optional[Interval] = None
+    trimDomain: Optional[Interval] = None
+    bbox: Optional[Box] = None
+    area: Optional[float] = None
+    length: Optional[float] = None
+
+    @classmethod
+    def from_list(cls, args: List[Any]) -> "Ellipse":
+        return cls(
+            firstRadius=args[1],
+            secondRadius=args[2],
+            domain=Interval.from_list(args[3:5]),
+            plane=Plane.from_list(args[5:18]),
+            units=get_units_from_encoding(args[-1]),
+        )
+
+    def to_list(self) -> List[Any]:
+        return [
+            CurveTypeEncoding.Ellipse.value,
+            self.firstRadius,
+            self.secondRadius,
+            *self.domain.to_list(),
+            *self.plane.to_list(),
+            get_encoding_from_units(self._units),
+        ]
+
+
+class Polyline(Base, speckle_type=GEOMETRY + "Polyline", chunkable={"value": 20000}):
+    value: Optional[List[float]] = None
+    closed: Optional[bool] = None
+    domain: Optional[Interval] = None
+    bbox: Optional[Box] = None
+    area: Optional[float] = None
+    length: Optional[float] = None
+
+    @classmethod
+    def from_points(cls, points: List[Point]):
+        """Create a new Polyline from a list of Points"""
+        polyline = cls()
+        polyline.units = points[0].units
+        polyline.value = []
+        for point in points:
+            polyline.value.extend([point.x, point.y, point.z])
+        return polyline
+
+    @classmethod
+    def from_list(cls, args: List[Any]) -> "Polyline":
+        point_count = args[4]
+        return cls(
+            closed=bool(args[1]),
+            domain=Interval.from_list(args[2:4]),
+            value=args[5 : 5 + point_count],
+            units=get_units_from_encoding(args[-1]),
+        )
+
+    def to_list(self) -> List[Any]:
+        return [
+            CurveTypeEncoding.Polyline.value,
+            int(self.closed),
+            *self.domain.to_list(),
+            len(self.value),
+            *self.value,
+            get_encoding_from_units(self._units),
+        ]
+
+    def as_points(self) -> List[Point]:
+        """Converts the `value` attribute to a list of Points"""
+        if not self.value:
+            return
+
+        if len(self.value) % 3:
+            raise ValueError("Points array malformed: length%3 != 0.")
+
+        values = iter(self.value)
+        return [
+            Point(x=v, y=next(values), z=next(values), units=self.units) for v in values
+        ]
+
+
+class SpiralType(Enum):
+    Biquadratic = 0
+    BiquadraticParabola = 1
+    Bloss = 2
+    Clothoid = 3
+    Cosine = 4
+    Cubic = 5
+    CubicParabola = 6
+    Radioid = 7
+    Sinusoid = 8
+    Unknown = 9
+
+
+class Spiral(Base, speckle_type=GEOMETRY + "Spiral", detachable={"displayValue"}):
+    startPoint: Optional[Point] = None
+    endPoint: Optional[Point]
+    plane: Optional[Plane]
+    turns: Optional[float]
+    pitchAxis: Optional[Vector] = Vector()
+    pitch: float = 0
+    spiralType: Optional[SpiralType] = None
+    displayValue: Optional[Polyline] = None
+    bbox: Optional[Box] = None
+    length: Optional[float] = None
+    domain: Optional[Interval] = None
+
+
+class Curve(
+    Base,
+    speckle_type=GEOMETRY + "Curve",
+    chunkable={"points": 20000, "weights": 20000, "knots": 20000},
+):
+    degree: Optional[int] = None
+    periodic: Optional[bool] = None
+    rational: Optional[bool] = None
+    points: Optional[List[float]] = None
+    weights: Optional[List[float]] = None
+    knots: Optional[List[float]] = None
+    domain: Optional[Interval] = None
+    displayValue: Optional[Polyline] = None
+    closed: Optional[bool] = None
+    bbox: Optional[Box] = None
+    area: Optional[float] = None
+    length: Optional[float] = None
+
+    def as_points(self) -> List[Point]:
+        """Converts the `value` attribute to a list of Points"""
+        if not self.points:
+            return
+
+        if len(self.points) % 3:
+            raise ValueError("Points array malformed: length%3 != 0.")
+
+        values = iter(self.points)
+        return [
+            Point(x=v, y=next(values), z=next(values), units=self.units) for v in values
+        ]
+
+    @classmethod
+    def from_list(cls, args: List[Any]) -> "Curve":
+        point_count = int(args[7])
+        weights_count = int(args[8])
+        knots_count = int(args[9])
+
+        points_start = 10
+        weights_start = 10 + point_count
+        knots_start = weights_start + weights_count
+        knots_end = knots_start + knots_count
+
+        return cls(
+            degree=int(args[1]),
+            periodic=bool(args[2]),
+            rational=bool(args[3]),
+            closed=bool(args[4]),
+            domain=Interval.from_list(args[5:7]),
+            points=args[points_start:weights_start],
+            weights=args[weights_start:knots_start],
+            knots=args[knots_start:knots_end],
+            units=get_units_from_encoding(args[-1]),
+        )
+
+    def to_list(self) -> List[Any]:
+        return [
+            CurveTypeEncoding.Curve.value,
+            self.degree,
+            int(self.periodic),
+            int(self.rational),
+            int(self.closed),
+            *self.domain.to_list(),
+            len(self.points),
+            len(self.weights),
+            len(self.knots),
+            *self.points,
+            *self.weights,
+            *self.knots,
+            get_encoding_from_units(self._units),
+        ]
+
+
+class Polycurve(Base, speckle_type=GEOMETRY + "Polycurve"):
+    segments: Optional[List[Base]] = None
+    domain: Optional[Interval] = None
+    closed: Optional[bool] = None
+    bbox: Optional[Box] = None
+    area: Optional[float] = None
+    length: Optional[float] = None
+
+    @classmethod
+    def from_list(cls, args: List[Any]) -> "Polycurve":
+        curve_arrays = CurveArray(args[5:-1])
+        return cls(
+            closed=bool(args[1]),
+            domain=Interval.from_list(args[2:4]),
+            segments=curve_arrays.to_curves(),
+            units=get_units_from_encoding(args[-1]),
+        )
+
+    def to_list(self) -> List[Any]:
+        curve_array = CurveArray.from_curves(self.segments).data
+        return [
+            CurveTypeEncoding.Polycurve.value,
+            int(self.closed),
+            *self.domain.to_list(),
+            len(curve_array),
+            *curve_array,
+            get_encoding_from_units(self._units),
+        ]
+
+
+class Extrusion(Base, speckle_type=GEOMETRY + "Extrusion"):
+    capped: Optional[bool] = None
+    profile: Optional[Base] = None
+    pathStart: Optional[Point] = None
+    pathEnd: Optional[Point] = None
+    pathCurve: Optional[Base] = None
+    pathTangent: Optional[Base] = None
+    profiles: Optional[List[Base]] = None
+    length: Optional[float] = None
+    area: Optional[float] = None
+    volume: Optional[float] = None
+    bbox: Optional[Box] = None
+
+
+class Mesh(
+    Base,
+    speckle_type=GEOMETRY + "Mesh",
+    chunkable={
+        "vertices": 2000,
+        "faces": 2000,
+        "colors": 2000,
+        "textureCoordinates": 2000,
+    },
+):
+    vertices: Optional[List[float]] = None
+    faces: Optional[List[int]] = None
+    colors: Optional[List[int]] = None
+    textureCoordinates: Optional[List[float]] = None
+    bbox: Optional[Box] = None
+    area: Optional[float] = None
+    volume: Optional[float] = None
+
+    @classmethod
+    def create(
+        cls,
+        vertices: List[float],
+        faces: List[int],
+        colors: Optional[List[int]] = None,
+        texture_coordinates: Optional[List[float]] = None,
+    ) -> "Mesh":
+        """
+        Create a new Mesh from lists representing its vertices, faces,
+        colors (optional), and texture coordinates (optional).
+
+        This will initialise empty lists for colors and texture coordinates
+        if you do not provide any.
+        """
+        return cls(
+            vertices=vertices,
+            faces=faces,
+            colors=colors or [],
+            textureCoordinates=texture_coordinates or [],
+        )
+
+
+class Surface(Base, speckle_type=GEOMETRY + "Surface"):
+    degreeU: Optional[int] = None
+    degreeV: Optional[int] = None
+    rational: Optional[bool] = None
+    area: Optional[float] = None
+    pointData: Optional[List[float]] = None
+    countU: Optional[int] = None
+    countV: Optional[int] = None
+    bbox: Optional[Box] = None
+    closedU: Optional[bool] = None
+    closedV: Optional[bool] = None
+    domainU: Optional[Interval] = None
+    domainV: Optional[Interval] = None
+    knotsU: Optional[List[float]] = None
+    knotsV: Optional[List[float]] = None
+
+    @classmethod
+    def from_list(cls, args: List[Any]) -> "Surface":
+        point_count = int(args[11])
+        knots_u_count = int(args[12])
+        knots_v_count = int(args[13])
+
+        start_point_data = 14
+        start_knots_u = start_point_data + point_count
+        start_knots_v = start_knots_u + knots_u_count
+
+        return cls(
+            degreeU=int(args[0]),
+            degreeV=int(args[1]),
+            countU=int(args[2]),
+            countV=int(args[3]),
+            rational=bool(args[4]),
+            closedU=bool(args[5]),
+            closedV=bool(args[6]),
+            domainU=Interval(start=args[7], end=args[8]),
+            domainV=Interval(start=args[9], end=args[10]),
+            pointData=args[start_point_data:start_knots_u],
+            knotsU=args[start_knots_u:start_knots_v],
+            knotsV=args[start_knots_v : start_knots_v + knots_v_count],
+            units=get_units_from_encoding(args[-1]),
+        )
+
+    def to_list(self) -> List[Any]:
+        return [
+            self.degreeU,
+            self.degreeV,
+            self.countU,
+            self.countV,
+            int(self.rational),
+            int(self.closedU),
+            int(self.closedV),
+            *self.domainU.to_list(),
+            *self.domainV.to_list(),
+            len(self.pointData),
+            len(self.knotsU),
+            len(self.knotsV),
+            *self.pointData,
+            *self.knotsU,
+            *self.knotsV,
+            get_encoding_from_units(self._units),
+        ]
+
+
+class BrepFace(Base, speckle_type=GEOMETRY + "BrepFace"):
+    _Brep: Optional["Brep"] = None
+    SurfaceIndex: Optional[int] = None
+    OuterLoopIndex: Optional[int] = None
+    OrientationReversed: Optional[bool] = None
+    LoopIndices: Optional[List[int]] = None
+
+    @property
+    def _outer_loop(self):
+        return self._Brep.Loops[self.OuterLoopIndex]  # pylint: disable=no-member
+
+    @property
+    def _surface(self):
+        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: Optional["Brep"] = None
+    Curve3dIndex: Optional[int] = None
+    TrimIndices: Optional[List[int]] = None
+    StartIndex: Optional[int] = None
+    EndIndex: Optional[int] = None
+    ProxyCurveIsReversed: Optional[bool] = None
+    Domain: Optional[Interval] = None
+
+    @property
+    def _start_vertex(self):
+        return self._Brep.Vertices[self.StartIndex]
+
+    @property
+    def _end_vertex(self):
+        return self._Brep.Vertices[self.EndIndex]
+
+    @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: Optional["Brep"] = None
+    FaceIndex: Optional[Optional[int]] = None
+    TrimIndices: Optional[List[int]] = None
+    Type: Optional[BrepLoopType] = None
+
+    @property
+    def _face(self):
+        return self._Brep.Faces[self.FaceIndex]
+
+    @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:],
+        )
+
+    def to_list(self) -> List[int]:
+        return [
+            self.FaceIndex,
+            self.Type.value,
+            *self.TrimIndices,
+        ]
+
+
+class BrepTrimType(int, Enum):
+    Unknown = 0
+    Boundary = 1
+    Mated = 2
+    Seam = 3
+    Singular = 4
+    CurveOnSurface = 5
+    PointOnSurface = 6
+    Slit = 7
+
+
+class BrepTrim(Base, speckle_type=GEOMETRY + "BrepTrim"):
+    _Brep: Optional["Brep"] = None
+    EdgeIndex: Optional[int] = None
+    StartIndex: Optional[int] = None
+    EndIndex: Optional[int] = None
+    FaceIndex: Optional[int] = None
+    LoopIndex: Optional[int] = None
+    CurveIndex: Optional[int] = None
+    IsoStatus: Optional[int] = None
+    TrimType: Optional[BrepTrimType] = None
+    IsReversed: Optional[bool] = None
+    Domain: Optional[Interval] = None
+
+    @property
+    def _face(self):
+        if self._Brep:
+            return self._Brep.Faces[self.FaceIndex]  # pylint: disable=no-member
+
+    @property
+    def _loop(self):
+        if self._Brep:
+            return self._Brep.Loops[self.LoopIndex]  # pylint: disable=no-member
+
+    @property
+    def _edge(self):
+        if self._Brep:
+            # pylint: disable=no-member
+            return self._Brep.Edges[self.EdgeIndex] if self.EdgeIndex != -1 else None
+
+    @property
+    def _curve_2d(self):
+        if self._Brep:
+            return self._Brep.Curve2D[self.CurveIndex]  # pylint: disable=no-member
+
+    @classmethod
+    def from_list(cls, args: List[Any], brep: "Brep" = None) -> "BrepTrim":
+        return cls(
+            _Brep=brep,
+            EdgeIndex=args[0],
+            StartIndex=args[1],
+            EndIndex=args[2],
+            FaceIndex=args[3],
+            LoopIndex=args[4],
+            CurveIndex=args[5],
+            IsoStatus=args[6],
+            TrimType=BrepTrimType(args[7]),
+            IsReversed=bool(args[8]),
+        )
+
+    def to_list(self) -> List[Any]:
+        return [
+            self.EdgeIndex,
+            self.StartIndex,
+            self.EndIndex,
+            self.FaceIndex,
+            self.LoopIndex,
+            self.CurveIndex,
+            self.IsoStatus,
+            self.TrimType.value,
+            int(self.IsReversed),
+        ]
+
+
+class Brep(
+    Base,
+    speckle_type=GEOMETRY + "Brep",
+    chunkable={
+        "SurfacesValue": 31250,
+        "Curve3DValues": 31250,
+        "Curve2DValues": 31250,
+        "VerticesValue": 31250,
+        "EdgesValue": 62500,
+        "LoopsValue": 62500,
+        "FacesValue": 62500,
+        "TrimsValue": 62500,
+    },
+    detachable={"displayValue"},
+    serialize_ignore={
+        "Surfaces",
+        "Curve3D",
+        "Curve2D",
+        "Vertices",
+        "Trims",
+        "Edges",
+        "Loops",
+        "Faces",
+    },
+):
+    provenance: Optional[str] = None
+    bbox: Optional[Box] = None
+    area: Optional[float] = None
+    volume: Optional[float] = None
+    _displayValue: Optional[List[Mesh]] = None
+    Surfaces: Optional[List[Surface]] = None
+    Curve3D: Optional[List[Base]] = None
+    Curve2D: Optional[List[Base]] = None
+    Vertices: Optional[List[Point]] = None
+    Edges: Optional[List[BrepEdge]] = None
+    Loops: Optional[List[BrepLoop]] = None
+    Faces: Optional[List[BrepFace]] = None
+    Trims: Optional[List[BrepTrim]] = None
+    IsClosed: Optional[bool] = None
+    Orientation: Optional[int] = None
+
+    def _inject_self_into_children(self, children: Optional[List[Base]]) -> List[Base]:
+        if children is None:
+            return children
+
+        for child in children:
+            child._Brep = self  # pylint: disable=protected-access
+        return children
+
+    # set as prop for now for backwards compatibility
+    @property
+    def displayValue(self) -> List[Mesh]:
+        return self._displayValue
+
+    @displayValue.setter
+    def displayValue(self, value):
+        if isinstance(value, Mesh):
+            self._displayValue = [value]
+        elif isinstance(value, list):
+            self._displayValue = value
+
+    @property
+    def EdgesValue(self) -> List[BrepEdge]:
+        return None if self.Edges is None else ObjectArray.from_objects(self.Edges).data
+
+    @EdgesValue.setter
+    def EdgesValue(self, value: List[float]):
+        if not value:
+            return
+
+        self.Edges = ObjectArray.decode_data(value, BrepEdge.from_list, brep=self)
+
+    @property
+    def LoopsValue(self) -> List[BrepLoop]:
+        return None if self.Loops is None else ObjectArray.from_objects(self.Loops).data
+
+    @LoopsValue.setter
+    def LoopsValue(self, value: List[int]):
+        if not value:
+            return
+
+        self.Loops = ObjectArray.decode_data(value, BrepLoop.from_list, brep=self)
+
+    @property
+    def FacesValue(self) -> List[int]:
+        return None if self.Faces is None else ObjectArray.from_objects(self.Faces).data
+
+    @FacesValue.setter
+    def FacesValue(self, value: List[int]):
+        if not value:
+            return
+
+        self.Faces = ObjectArray.decode_data(value, BrepFace.from_list, brep=self)
+
+    @property
+    def SurfacesValue(self) -> List[float]:
+        return (
+            None
+            if self.Surfaces is None
+            else ObjectArray.from_objects(self.Surfaces).data
+        )
+
+    @SurfacesValue.setter
+    def SurfacesValue(self, value: List[float]):
+        if not value:
+            return
+
+        self.Surfaces = ObjectArray.decode_data(value, Surface.from_list)
+
+    @property
+    def Curve3DValues(self) -> List[float]:
+        return (
+            None if self.Curve3D is None else CurveArray.from_curves(self.Curve3D).data
+        )
+
+    @Curve3DValues.setter
+    def Curve3DValues(self, value: List[float]):
+        crv_array = CurveArray(value)
+        self.Curve3D = crv_array.to_curves()
+
+    @property
+    def Curve2DValues(self) -> List[Base]:
+        return (
+            None if self.Curve2D is None else CurveArray.from_curves(self.Curve2D).data
+        )
+
+    @Curve2DValues.setter
+    def Curve2DValues(self, value: List[float]):
+        crv_array = CurveArray(value)
+        self.Curve2D = crv_array.to_curves()
+
+    @property
+    def VerticesValue(self) -> List[Point]:
+        if self.Vertices is None:
+            return None
+        encoded_unit = get_encoding_from_units(self.Vertices[0].units)
+        values = [encoded_unit]
+        for vertex in self.Vertices:
+            values.extend(vertex.to_list())
+        return values
+
+    @VerticesValue.setter
+    def VerticesValue(self, value: List[float]):
+        value = value.copy()
+        units = get_units_from_encoding(value.pop(0))
+
+        vertices = []
+
+        for i in range(0, len(value), 3):
+            vertex = Point.from_list(value[i : i + 3])
+            vertex.units = units
+            vertices.append(vertex)
+
+        self.Vertices = vertices
+
+    # TODO: can this be consistent with loops, edges, faces, curves, etc and prepend with the chunk list? needs to happen in sharp first
+    @property
+    def TrimsValue(self) -> List[float]:
+        # return None if self.Trims is None else ObjectArray.from_objects(self.Trims).data
+        if not self.Trims:
+            return
+        value = []
+        for trim in self.Trims:
+            value.extend(trim.to_list())
+        return value
+
+    @TrimsValue.setter
+    def TrimsValue(self, value: List[float]):
+        if not value:
+            return
+
+        # self.Trims = ObjectArray.decode_data(value, BrepTrim.from_list, brep=self)
+        self.Trims = [
+            BrepTrim.from_list(value[i : i + 9], self) for i in range(0, len(value), 9)
+        ]
+
+
+BrepEdge.update_forward_refs()
+BrepLoop.update_forward_refs()
+BrepTrim.update_forward_refs()
+BrepFace.update_forward_refs()

src/specklepy/objects_v2/graph_traversal/commit_object_builder.py

@@ -58,7 +58,9 @@ class CommitObjectBuilder(ABC, Generic[T]):
             if parent_id == ROOT:
                 parent = root_commit_object
             else:
-                parent = self.converted.get(parent_id, None)
+                parent = (
+                    self.converted[parent_id] if parent_id in self.converted else None
+                )
 
             if not parent:
                 continue
@@ -72,15 +74,13 @@ class CommitObjectBuilder(ABC, Generic[T]):
                 elements.append(current)
                 return
             except Exception as ex:
-                # A parent was found, but it was invalid
-                # (Likely because of a type mismatch on a `elements` property)
+                # A parent was found, but it was invalid (Likely because of a type mismatch on a `elements` property)
                 print(
                     f"Failed to add object {type(current)} to a converted parent; {ex}"
                 )
 
             raise Exception(
-                f"Could not find a valid parent for object of type {type(current)}."
-                f"Checked {len(parents)} potential parent, and non were converted!"
+                f"Could not find a valid parent for object of type {type(current)}. Checked {len(parents)} potential parent, and non were converted!"
             )
 
 

src/specklepy/objects_v2/graph_traversal/traversal.py

@@ -7,10 +7,6 @@ from specklepy.objects.base import Base
 
 
 class ITraversalRule(Protocol):
-    @property
-    def should_return(self) -> bool:
-        pass
-
     def get_members_to_traverse(self, o: Base) -> Set[str]:
         """Get the members to traverse."""
         pass
@@ -54,27 +50,20 @@ class GraphTraversal:
 
         while len(stack) > 0:
             head = stack.pop()
+            yield head
 
             current = head.current
             active_rule = self._get_active_rule_or_default_rule(current)
-
-            if active_rule.should_return:
-                yield head
-
             members_to_traverse = active_rule.get_members_to_traverse(current)
             for child_prop in members_to_traverse:
                 try:
                     if child_prop in {"speckle_type", "units", "applicationId"}:
-                        # debug: to avoid noisy exceptions,
-                        # explicitly avoid checking ones we know will fail,
-                        # this is not exhaustive
-                        continue
+                        continue  # debug: to avoid noisy exceptions, explicitly avoid checking ones we know will fail, this is not exhaustive
                     if getattr(current, child_prop, None):
                         value = current[child_prop]
                         self._traverse_member_to_stack(stack, value, child_prop, head)
                 except KeyError:
-                    # Unset application ids, and class variables like SpeckleType will
-                    #  throw when __getitem__ is called
+                    # Unset application ids, and class variables like SpeckleType will throw when __getitem__ is called
                     pass
 
     @staticmethod
@@ -125,14 +114,12 @@ class GraphTraversal:
 class TraversalRule:
     _conditions: Collection[Callable[[Base], bool]]
     _members_to_traverse: Callable[[Base], Iterable[str]]
-    _should_return_to_output: bool = True
-
-    @property
-    def should_return(self) -> bool:
-        return self._should_return_to_output
 
     def get_members_to_traverse(self, o: Base) -> Set[str]:
         return set(self._members_to_traverse(o))
 
     def does_rule_hold(self, o: Base) -> bool:
-        return any(condition(o) for condition in self._conditions)
+        for condition in self._conditions:
+            if condition(o):
+                return True
+        return False

src/specklepy/objects_v2/other.py

@@ -0,0 +1,311 @@
+from typing import Any, List, Optional
+
+from deprecated import deprecated
+
+from specklepy.objects.geometry import Plane, Point, Polyline, Vector
+
+from .base import Base
+
+OTHER = "Objects.Other."
+OTHER_REVIT = OTHER + "Revit."
+
+IDENTITY_TRANSFORM = [
+    1.0,
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    1.0,
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    1.0,
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    1.0,
+]
+
+
+class Material(Base, speckle_type=OTHER + "Material"):
+    """Generic class for materials containing generic parameters."""
+
+    name: Optional[str] = None
+
+
+class RevitMaterial(Material, speckle_type="Objects.Other.Revit." + "RevitMaterial"):
+    materialCategory: Optional[str] = None
+    materialClass: Optional[str] = None
+    shininess: Optional[int] = None
+    smoothness: Optional[int] = None
+    transparency: Optional[int] = None
+    parameters: Optional[Base] = None
+
+
+class RenderMaterial(Base, speckle_type=OTHER + "RenderMaterial"):
+    name: Optional[str] = None
+    opacity: float = 1
+    metalness: float = 0
+    roughness: float = 1
+    diffuse: int = -2894893  # light gray arbg
+    emissive: int = -16777216  # black arbg
+
+
+class MaterialQuantity(Base, speckle_type=OTHER + "MaterialQuantity"):
+    material: Optional[Material] = None
+    volume: Optional[float] = None
+    area: Optional[float] = None
+
+
+class DisplayStyle(Base, speckle_type=OTHER + "DisplayStyle"):
+    """
+    Minimal display style class.
+    Developed primarily for display styles in Rhino and AutoCAD.
+    Rhino object attributes uses OpenNURBS definition for linetypes and lineweights.
+    """
+
+    name: Optional[str] = None
+    color: int = -2894893  # light gray arbg
+    linetype: Optional[str] = None
+    lineweight: float = 0
+
+
+class Text(Base, speckle_type=OTHER + "Text"):
+    """
+    Text object to render it on viewer.
+    """
+
+    plane: Plane
+    value: str
+    height: float
+    rotation: float
+    displayValue: Optional[List[Polyline]] = None
+    richText: Optional[str] = None
+
+
+class Transform(
+    Base,
+    speckle_type=OTHER + "Transform",
+    serialize_ignore={"translation", "scaling", "is_identity", "value"},
+):
+    """The 4x4 transformation matrix
+
+    The 3x3 sub-matrix determines scaling.
+    The 4th column defines translation,
+    where the last value is a divisor (usually equal to 1).
+    """
+
+    _value: Optional[List[float]] = None
+
+    @property
+    @deprecated(version="2.12", reason="Use matrix")
+    def value(self) -> List[float]:
+        return self._value
+
+    @value.setter
+    def value(self, value: List[float]) -> None:
+        self.matrix = value
+
+    @property
+    def matrix(self) -> List[float]:
+        """The transform matrix represented as a flat list of 16 floats"""
+        return self._value
+
+    @matrix.setter
+    def matrix(self, value: List[float]) -> None:
+        try:
+            value = [float(x) for x in value]
+        except (ValueError, TypeError) as error:
+            raise ValueError(
+                "Could not create a Transform object with the requested value. Input"
+                f" must be a 16 element list of numbers. Value provided: {value}"
+            ) from error
+
+        if len(value) != 16:
+            raise ValueError(
+                "Could not create a Transform object: input list should be 16 floats"
+                f" long, but was {len(value)} long"
+            )
+
+        self._value = value
+
+    @property
+    def translation(self) -> List[float]:
+        """The final column of the matrix which defines the translation"""
+        return [self._value[i] for i in (3, 7, 11, 15)]
+
+    @property
+    def scaling(self) -> List[float]:
+        """The 3x3 scaling sub-matrix"""
+        return [self._value[i] for i in (0, 1, 2, 4, 5, 6, 8, 9, 10)]
+
+    @property
+    def is_identity(self) -> bool:
+        return self._value == IDENTITY_TRANSFORM
+
+    def apply_to_point(self, point: Point) -> Point:
+        """Transform a single speckle Point
+
+        Arguments:
+            point {Point} -- the speckle Point to transform
+
+        Returns:
+            Point -- a new transformed point
+        """
+        coords = self.apply_to_point_value([point.x, point.y, point.z])
+        return Point(x=coords[0], y=coords[1], z=coords[2], units=point.units)
+
+    def apply_to_point_value(self, point_value: List[float]) -> List[float]:
+        """Transform a list of three floats representing a point
+
+        Arguments:
+            point_value {List[float]} -- a list of 3 floats
+
+        Returns:
+            List[float] -- the list with the transform applied
+        """
+        transformed = [
+            point_value[0] * self._value[i]
+            + point_value[1] * self._value[i + 1]
+            + point_value[2] * self._value[i + 2]
+            + self._value[i + 3]
+            for i in range(0, 15, 4)
+        ]
+
+        return [transformed[i] / transformed[3] for i in range(3)]
+
+    def apply_to_points(self, points: List[Point]) -> List[Point]:
+        """Transform a list of speckle Points
+
+        Arguments:
+            points {List[Point]} -- the list of speckle Points to transform
+
+        Returns:
+            List[Point] -- a new list of transformed points
+        """
+        return [self.apply_to_point(point) for point in points]
+
+    def apply_to_points_values(self, points_value: List[float]) -> List[float]:
+        """Transform a list of speckle Points
+
+        Arguments:
+            points {List[float]}
+            -- a flat list of floats representing points to transform
+
+        Returns:
+            List[float] -- a new transformed list
+        """
+        if len(points_value) % 3 != 0:
+            raise ValueError(
+                "Cannot apply transform as the points list is malformed: expected"
+                " length to be multiple of 3"
+            )
+        transformed = []
+        for i in range(0, len(points_value), 3):
+            transformed.extend(self.apply_to_point_value(points_value[i : i + 3]))
+
+        return transformed
+
+    def apply_to_vector(self, vector: Vector) -> Vector:
+        """Transform a single speckle Vector
+
+        Arguments:
+            point {Vector} -- the speckle Vector to transform
+
+        Returns:
+            Vector -- a new transformed point
+        """
+        coords = self.apply_to_vector_value([vector.x, vector.y, vector.z])
+        return Vector(x=coords[0], y=coords[1], z=coords[2], units=vector.units)
+
+    def apply_to_vector_value(self, vector_value: List[float]) -> List[float]:
+        """Transform a list of three floats representing a vector
+
+        Arguments:
+            vector_value {List[float]} -- a list of 3 floats
+
+        Returns:
+            List[float] -- the list with the transform applied
+        """
+        return [
+            vector_value[0] * self._value[i]
+            + vector_value[1] * self._value[i + 1]
+            + vector_value[2] * self._value[i + 2]
+            for i in range(0, 15, 4)
+        ][:3]
+
+    @classmethod
+    def from_list(cls, value: Optional[List[float]] = None) -> "Transform":
+        """Returns a Transform object from a list of 16 numbers.
+        If no value is provided, an identity transform will be returned.
+
+        Arguments:
+            value {List[float]} -- the matrix as a flat list of 16 numbers
+            (defaults to the identity transform)
+
+        Returns:
+            Transform -- a complete transform object
+        """
+        if not value:
+            value = IDENTITY_TRANSFORM
+        return cls(value=value)
+
+
+class BlockDefinition(
+    Base, speckle_type=OTHER + "BlockDefinition", detachable={"geometry"}
+):
+    name: Optional[str] = None
+    basePoint: Optional[Point] = None
+    geometry: Optional[List[Base]] = None
+
+
+class Instance(Base, speckle_type=OTHER + "Instance", detachable={"definition"}):
+    transform: Optional[Transform] = None
+    definition: Optional[Base] = None
+
+
+class BlockInstance(
+    Instance, speckle_type=OTHER + "BlockInstance", serialize_ignore={"blockDefinition"}
+):
+    @property
+    @deprecated(version="2.13", reason="Use definition")
+    def blockDefinition(self) -> Optional[BlockDefinition]:
+        if isinstance(self.definition, BlockDefinition):
+            return self.definition
+        return None
+
+    @blockDefinition.setter
+    def blockDefinition(self, value: Optional[BlockDefinition]) -> None:
+        self.definition = value
+
+
+class RevitInstance(Instance, speckle_type=OTHER_REVIT + "RevitInstance"):
+    level: Optional[Base] = None
+    facingFlipped: bool
+    handFlipped: bool
+    parameters: Optional[Base] = None
+    elementId: Optional[str]
+
+
+# TODO: prob move this into a built elements module, but just trialling this for now
+class RevitParameter(Base, speckle_type="Objects.BuiltElements.Revit.Parameter"):
+    name: Optional[str] = None
+    value: Any = None
+    applicationUnitType: Optional[str] = None  # eg UnitType UT_Length
+    applicationUnit: Optional[str] = None  # DisplayUnitType eg DUT_MILLIMITERS
+    applicationInternalName: Optional[str] = (
+        None  # BuiltInParameterName or GUID for shared parameter
+    )
+    isShared: bool = False
+    isReadOnly: bool = False
+    isTypeParameter: bool = False
+
+
+class Collection(
+    Base, speckle_type="Speckle.Core.Models.Collection", detachable={"elements"}
+):
+    name: Optional[str] = None
+    collectionType: Optional[str] = None
+    elements: Optional[List[Base]] = None

src/specklepy/objects_v2/primitive.py

@@ -0,0 +1,25 @@
+from typing import Any, List
+
+from specklepy.objects.base import Base
+
+NAMESPACE = "Objects.Primitive"
+
+
+class Interval(Base, speckle_type=f"{NAMESPACE}.Interval"):
+    start: float = 0.0
+    end: float = 0.0
+
+    def length(self):
+        return abs(self.start - self.end)
+
+    @classmethod
+    def from_list(cls, args: List[Any]) -> "Interval":
+        return cls(start=args[0], end=args[1])
+
+    def to_list(self) -> List[Any]:
+        return [self.start, self.end]
+
+
+class Interval2d(Base, speckle_type=f"{NAMESPACE}.Interval2d"):
+    u: Interval
+    v: Interval

src/specklepy/objects_v2/structural/__init__.py

@@ -0,0 +1,142 @@
+"""Builtin Speckle object kit."""
+
+from specklepy.objects.structural.analysis import (
+    Model,
+    ModelInfo,
+    ModelSettings,
+    ModelUnits,
+)
+from specklepy.objects.structural.axis import Axis, AxisType
+from specklepy.objects.structural.geometry import (
+    Element1D,
+    Element2D,
+    Element3D,
+    ElementType1D,
+    ElementType2D,
+    ElementType3D,
+    Node,
+    Restraint,
+)
+from specklepy.objects.structural.loading import (
+    ActionType,
+    BeamLoadType,
+    CombinationType,
+    FaceLoadType,
+    Load,
+    LoadAxisType,
+    LoadBeam,
+    LoadCase,
+    LoadCombinations,
+    LoadDirection,
+    LoadDirection2D,
+    LoadFace,
+    LoadGravity,
+    LoadNode,
+    LoadType,
+)
+from specklepy.objects.structural.materials import (
+    Concrete,
+    MaterialType,
+    Steel,
+    StructuralMaterial,
+    Timber,
+)
+from specklepy.objects.structural.properties import (
+    BaseReferencePoint,
+    MemberType,
+    Property,
+    Property1D,
+    Property2D,
+    Property3D,
+    PropertyDamper,
+    PropertyMass,
+    PropertySpring,
+    PropertyType2D,
+    PropertyType3D,
+    PropertyTypeDamper,
+    PropertyTypeSpring,
+    ReferenceSurface,
+    ReferenceSurfaceEnum,
+    SectionProfile,
+    ShapeType,
+    shapeType,
+)
+from specklepy.objects.structural.results import (
+    Result,
+    Result1D,
+    Result2D,
+    Result3D,
+    ResultGlobal,
+    ResultNode,
+    ResultSet1D,
+    ResultSet2D,
+    ResultSet3D,
+    ResultSetAll,
+    ResultSetNode,
+)
+
+__all__ = [
+    "Element1D",
+    "Element2D",
+    "Element3D",
+    "ElementType1D",
+    "ElementType2D",
+    "ElementType3D",
+    "AxisType",
+    "Axis",
+    "Node",
+    "Restraint",
+    "Load",
+    "LoadType",
+    "ActionType",
+    "BeamLoadType",
+    "FaceLoadType",
+    "LoadDirection",
+    "LoadDirection2D",
+    "LoadAxisType",
+    "CombinationType",
+    "LoadBeam",
+    "LoadCase",
+    "LoadCombinations",
+    "LoadFace",
+    "LoadGravity",
+    "LoadNode",
+    "Model",
+    "ModelInfo",
+    "ModelSettings",
+    "ModelUnits",
+    "MaterialType",
+    "Concrete",
+    "StructuralMaterial",
+    "Steel",
+    "Timber",
+    "Property",
+    "Property1D",
+    "Property2D",
+    "Property3D",
+    "PropertyDamper",
+    "PropertyMass",
+    "PropertySpring",
+    "SectionProfile",
+    "MemberType",
+    "BaseReferencePoint",
+    "ReferenceSurface",
+    "PropertyType2D",
+    "PropertyType3D",
+    "ShapeType",
+    "PropertyTypeSpring",
+    "PropertyTypeDamper",
+    "ReferenceSurfaceEnum",
+    "shapeType",
+    "Result",
+    "Result1D",
+    "ResultSet1D",
+    "Result2D",
+    "ResultSet2D",
+    "Result3D",
+    "ResultSet3D",
+    "ResultGlobal",
+    "ResultSetNode",
+    "ResultNode",
+    "ResultSetAll",
+]

src/specklepy/objects_v2/structural/analysis.py

@@ -0,0 +1,49 @@
+from typing import List, Optional
+
+from specklepy.objects.base import Base
+
+STRUCTURAL_ANALYSIS = "Objects.Structural.Analysis."
+
+
+class ModelUnits(Base, speckle_type=STRUCTURAL_ANALYSIS + "ModelUnits"):
+    length: Optional[str] = None
+    sections: Optional[str] = None
+    displacements: Optional[str] = None
+    stress: Optional[str] = None
+    force: Optional[str] = None
+    mass: Optional[str] = None
+    time: Optional[str] = None
+    temperature: Optional[str] = None
+    velocity: Optional[str] = None
+    acceleration: Optional[str] = None
+    energy: Optional[str] = None
+    angle: Optional[str] = None
+    strain: Optional[str] = None
+
+
+class ModelSettings(Base, speckle_type=STRUCTURAL_ANALYSIS + "ModelSettings"):
+    modelUnits: Optional[ModelUnits] = None
+    steelCode: Optional[str] = None
+    concreteCode: Optional[str] = None
+    coincidenceTolerance: float = 0.0
+
+
+class ModelInfo(Base, speckle_type=STRUCTURAL_ANALYSIS + "ModelInfo"):
+    name: Optional[str] = None
+    description: Optional[str] = None
+    projectNumber: Optional[str] = None
+    projectName: Optional[str] = None
+    settings: Optional[ModelSettings] = None
+    initials: Optional[str] = None
+    application: Optional[str] = None
+
+
+class Model(Base, speckle_type=STRUCTURAL_ANALYSIS + "Model"):
+    specs: Optional[ModelInfo] = None
+    nodes: Optional[List] = None
+    elements: Optional[List] = None
+    loads: Optional[List] = None
+    restraints: Optional[List] = None
+    properties: Optional[List] = None
+    materials: Optional[List] = None
+    layerDescription: Optional[str] = None

src/specklepy/objects_v2/structural/axis.py

@@ -0,0 +1,17 @@
+from enum import Enum
+from typing import Optional
+
+from specklepy.objects.base import Base
+from specklepy.objects.geometry import Plane
+
+
+class AxisType(int, Enum):
+    Cartesian = 0
+    Cylindrical = 1
+    Spherical = 2
+
+
+class Axis(Base, speckle_type="Objects.Structural.Geometry.Axis"):
+    name: Optional[str] = None
+    axisType: Optional[AxisType] = None
+    plane: Optional[Plane] = None

src/specklepy/objects_v2/structural/geometry.py

@@ -0,0 +1,110 @@
+from enum import Enum
+from typing import List, Optional
+
+from specklepy.objects.base import Base
+from specklepy.objects.geometry import Line, Mesh, Plane, Point, Vector
+from specklepy.objects.structural.axis import Axis
+from specklepy.objects.structural.properties import (
+    Property1D,
+    Property2D,
+    Property3D,
+    PropertyDamper,
+    PropertyMass,
+    PropertySpring,
+)
+
+STRUCTURAL_GEOMETRY = "Objects.Structural.Geometry"
+
+
+class ElementType1D(int, Enum):
+    Beam = 0
+    Brace = 1
+    Bar = 2
+    Column = 3
+    Rod = 4
+    Spring = 5
+    Tie = 6
+    Strut = 7
+    Link = 8
+    Damper = 9
+    Cable = 10
+    Spacer = 11
+    Other = 12
+    Null = 13
+
+
+class ElementType2D(int, Enum):
+    Quad4 = 0
+    Quad8 = 1
+    Triangle3 = 2
+    Triangle6 = 3
+
+
+class ElementType3D(int, Enum):
+    Brick8 = 0
+    Wedge6 = 1
+    Pyramid5 = 2
+    Tetra4 = 3
+
+
+class Restraint(Base, speckle_type=STRUCTURAL_GEOMETRY + ".Restraint"):
+    code: Optional[str] = None
+    stiffnessX: float = 0.0
+    stiffnessY: float = 0.0
+    stiffnessZ: float = 0.0
+    stiffnessXX: float = 0.0
+    stiffnessYY: float = 0.0
+    stiffnessZZ: float = 0.0
+
+
+class Node(Base, speckle_type=STRUCTURAL_GEOMETRY + ".Node"):
+    name: Optional[str] = None
+    basePoint: Optional[Point] = None
+    constraintAxis: Optional[Axis] = None
+    restraint: Optional[Restraint] = None
+    springProperty: Optional[PropertySpring] = None
+    massProperty: Optional[PropertyMass] = None
+    damperProperty: Optional[PropertyDamper] = None
+
+
+class Element1D(Base, speckle_type=STRUCTURAL_GEOMETRY + ".Element1D"):
+    name: Optional[str] = None
+    baseLine: Optional[Line] = None
+    property: Optional[Property1D] = None
+    type: Optional[ElementType1D] = None
+    end1Releases: Optional[Restraint] = None
+    end2Releases: Optional[Restraint] = None
+    end1Offset: Optional[Vector] = None
+    end2Offset: Optional[Vector] = None
+    orientationNode: Optional[Node] = None
+    orinetationAngle: float = 0.0
+    localAxis: Optional[Plane] = None
+    parent: Optional[Base] = None
+    end1Node: Optional[Node] = None
+    end2Node: Optional[Node] = None
+    topology: Optional[List] = None
+    displayMesh: Optional[Mesh] = None
+
+
+class Element2D(Base, speckle_type=STRUCTURAL_GEOMETRY + ".Element2D"):
+    name: Optional[str] = None
+    property: Optional[Property2D] = None
+    type: Optional[ElementType2D] = None
+    offset: float = 0.0
+    orientationAngle: float = 0.0
+    parent: Optional[Base] = None
+    topology: Optional[List] = None
+    displayMesh: Optional[Mesh] = None
+
+
+class Element3D(Base, speckle_type=STRUCTURAL_GEOMETRY + ".Element3D"):
+    name: Optional[str] = None
+    baseMesh: Optional[Mesh] = None
+    property: Optional[Property3D] = None
+    type: Optional[ElementType3D] = None
+    orientationAngle: float = 0.0
+    parent: Optional[Base] = None
+    topology: List
+
+
+# class Storey needs ependency on built elements first

src/specklepy/objects_v2/structural/loading.py

@@ -0,0 +1,137 @@
+from enum import Enum
+from typing import List, Optional
+
+from specklepy.objects.base import Base
+from specklepy.objects.geometry import Vector
+from specklepy.objects.structural.axis import Axis
+
+STRUCTURAL_LOADING = "Objects.Structural.Loading."
+
+
+class LoadType(int, Enum):
+    none = 0
+    Dead = 1
+    SuperDead = 2
+    Soil = 3
+    Live = 4
+    LiveRoof = 5
+    ReducibleLive = 6
+    Wind = 7
+    Snow = 8
+    Rain = 9
+    Thermal = 10
+    Notional = 11
+    Prestress = 12
+    Equivalent = 13
+    Accidental = 14
+    SeismicRSA = 15
+    SeismicAccTorsion = 16
+    SeismicStatic = 17
+    Other = 18
+
+
+class ActionType(int, Enum):
+    none = 0
+    Permanent = 1
+    Variable = 2
+    Accidental = 3
+
+
+class BeamLoadType(int, Enum):
+    Point = 0
+    Uniform = 1
+    Linear = 2
+    Patch = 3
+    TriLinear = 4
+
+
+class FaceLoadType(int, Enum):
+    Constant = 0
+    Variable = 1
+    Point = 2
+
+
+class LoadDirection2D(int, Enum):
+    X = 0
+    Y = 1
+    Z = 2
+
+
+class LoadDirection(int, Enum):
+    X = 0
+    Y = 1
+    Z = 2
+    XX = 3
+    YY = 4
+    ZZ = 5
+
+
+class LoadAxisType(int, Enum):
+    Global = 0
+    Local = 1  # local element axes
+    DeformedLocal = (
+        2  # element local axis that is embedded in the element as it deforms
+    )
+
+
+class CombinationType(int, Enum):
+    LinearAdd = 0
+    Envelope = 1
+    AbsoluteAdd = 2
+    SRSS = 3
+    RangeAdd = 4
+
+
+class LoadCase(Base, speckle_type=STRUCTURAL_LOADING + "LoadCase"):
+    name: Optional[str] = None
+    loadType: Optional[LoadType] = None
+    group: Optional[str] = None
+    actionType: Optional[ActionType] = None
+    description: Optional[str] = None
+
+
+class Load(Base, speckle_type=STRUCTURAL_LOADING + "Load"):
+    name: Optional[str] = None
+    loadCase: Optional[LoadCase] = None
+
+
+class LoadBeam(Load, speckle_type=STRUCTURAL_LOADING + "LoadBeam"):
+    elements: Optional[List] = None
+    loadType: Optional[BeamLoadType] = None
+    direction: Optional[LoadDirection] = None
+    loadAxis: Optional[Axis] = None
+    loadAxisType: Optional[LoadAxisType] = None
+    isProjected: Optional[bool] = None
+    values: Optional[List] = None
+    positions: Optional[List] = None
+
+
+class LoadCombinations(Base, speckle_type=STRUCTURAL_LOADING + "LoadCombination"):
+    name: Optional[str] = None
+    loadCases: List
+    loadFactors: List
+    combinationType: CombinationType
+
+
+class LoadFace(Load, speckle_type=STRUCTURAL_LOADING + "LoadFace"):
+    elements: Optional[List] = None
+    loadType: Optional[FaceLoadType] = None
+    direction: Optional[LoadDirection2D] = None
+    loadAxis: Optional[Axis] = None
+    loadAxisType: Optional[LoadAxisType] = None
+    isProjected: Optional[bool] = None
+    values: Optional[List] = None
+    positions: Optional[List] = None
+
+
+class LoadGravity(Load, speckle_type=STRUCTURAL_LOADING + "LoadGravity"):
+    elements: Optional[List] = None
+    nodes: Optional[List] = None
+    gravityFactors: Optional[Vector] = None
+
+
+class LoadNode(Load, speckle_type=STRUCTURAL_LOADING + "LoadNode"):
+    nodes: Optional[List] = None
+    loadAxis: Optional[Axis] = None
+    direction: Optional[LoadDirection] = None
+    value: float = 0.0

src/specklepy/objects_v2/structural/materials.py

@@ -0,0 +1,61 @@
+from enum import Enum
+from typing import Optional
+
+from specklepy.objects.base import Base
+
+STRUCTURAL_MATERIALS = "Objects.Structural.Materials"
+
+
+class MaterialType(int, Enum):
+    Concrete = 0
+    Steel = 1
+    Timber = 2
+    Aluminium = 3
+    Masonry = 4
+    FRP = 5
+    Glass = 6
+    Fabric = 7
+    Rebar = 8
+    Tendon = 9
+    ColdFormed = 10
+    Other = 11
+
+
+class StructuralMaterial(
+    Base, speckle_type=STRUCTURAL_MATERIALS + ".StructuralMaterial"
+):
+    name: Optional[str] = None
+    grade: Optional[str] = None
+    materialType: Optional[MaterialType] = None
+    designCode: Optional[str] = None
+    codeYear: Optional[str] = None
+    strength: float = 0.0
+    elasticModulus: float = 0.0
+    poissonsRatio: float = 0.0
+    shearModulus: float = 0.0
+    density: float = 0.0
+    thermalExpansivity: float = 0.0
+    dampingRatio: float = 0.0
+    cost: float = 0.0
+    materialSafetyFactor: float = 0.0
+
+
+class Concrete(StructuralMaterial):
+    compressiveStrength: float = 0.0
+    tensileStrength: float = 0.0
+    flexuralStrength: float = 0.0
+    maxCompressiveStrain: float = 0.0
+    maxTensileStrain: float = 0.0
+    maxAggregateSize: float = 0.0
+    lightweight: Optional[bool] = None
+
+
+class Steel(StructuralMaterial, speckle_type=STRUCTURAL_MATERIALS + ".Steel"):
+    yieldStrength: float = 0.0
+    ultimateStrength: float = 0.0
+    maxStrain: float = 0.0
+    strainHardeningModulus: float = 0.0
+
+
+class Timber(StructuralMaterial, speckle_type=STRUCTURAL_MATERIALS + ".Timber"):
+    species: Optional[str] = None

src/specklepy/objects_v2/structural/properties.py

@@ -0,0 +1,212 @@
+from enum import Enum
+from typing import Optional
+
+from specklepy.objects.base import Base
+from specklepy.objects.structural.axis import Axis
+from specklepy.objects.structural.materials import StructuralMaterial
+
+STRUCTURAL_PROPERTY = "Objects.Structural.Properties"
+
+
+class MemberType(int, Enum):
+    Beam = 0
+    Column = 1
+    Generic1D = 2
+    Slab = 3
+    Wall = 4
+    Generic2D = 5
+    VoidCutter1D = 6
+    VoidCutter2D = 7
+
+
+class BaseReferencePoint(int, Enum):
+    Centroid = 0
+    TopLeft = 1
+    TopCentre = 2
+    TopRight = 3
+    MidLeft = 4
+    MidRight = 5
+    BotLeft = 6
+    BotCentre = 7
+    BotRight = 8
+
+
+class ReferenceSurface(int, Enum):
+    Top = 0
+    Middle = 1
+    Bottom = 2
+
+
+class PropertyType2D(int, Enum):
+    Stress = 0
+    Fabric = 1
+    Plate = 2
+    Shell = 3
+    Curved = 4
+    Wall = 5
+    Strain = 6
+    Axi = 7
+    Load = 8
+
+
+class PropertyType3D(int, Enum):
+    Solid = 0
+    Infinite = 1
+
+
+class ShapeType(int, Enum):
+    Rectangular = 0
+    Circular = 1
+    I = 2  # noqa: E741
+    Tee = 3
+    Angle = 4
+    Channel = 5
+    Perimeter = 6
+    Box = 7
+    Catalogue = 8
+    Explicit = 9
+    Undefined = 10
+
+
+class PropertyTypeSpring(int, Enum):
+    Axial = 0
+    Torsional = 1
+    General = 2
+    Matrix = 3
+    TensionOnly = 4
+    CompressionOnly = 5
+    Connector = 6
+    LockUp = 7
+    Gap = 8
+    Friction = 9
+
+
+class PropertyTypeDamper(int, Enum):
+    Axial = 0
+    Torsional = 1
+    General = 2
+
+
+class Property(Base, speckle_type=STRUCTURAL_PROPERTY):
+    name: Optional[str] = None
+
+
+class SectionProfile(
+    Base, speckle_type=STRUCTURAL_PROPERTY + ".Profiles.SectionProfile"
+):
+    name: Optional[str] = None
+    shapeType: Optional[ShapeType] = None
+    area: float = 0.0
+    Iyy: float = 0.0
+    Izz: float = 0.0
+    J: float = 0.0
+    Ky: float = 0.0
+    weight: float = 0.0
+
+
+class Property1D(Property, speckle_type=STRUCTURAL_PROPERTY + ".Property1D"):
+    memberType: Optional[MemberType] = None
+    material: Optional[StructuralMaterial] = None
+    profile: Optional[SectionProfile] = None
+    referencePoint: Optional[BaseReferencePoint] = None
+    offsetY: float = 0.0
+    offsetZ: float = 0.0
+
+
+class Property2D(Property, speckle_type=STRUCTURAL_PROPERTY + ".Property2D"):
+    type: Optional[PropertyType2D] = None
+    thickness: float = 0.0
+    material: Optional[StructuralMaterial] = None
+    orientationAxis: Optional[Axis] = None
+    refSurface: Optional[ReferenceSurface] = None
+    zOffset: float = 0.0
+    modifierInPlane: float = 0.0
+    modifierBending: float = 0.0
+    modifierShear: float = 0.0
+    modifierVolume: float = 0.0
+
+
+class Property3D(Property, speckle_type=STRUCTURAL_PROPERTY + ".Property3D"):
+    type: Optional[PropertyType3D] = None
+    material: Optional[StructuralMaterial] = None
+    orientationAxis: Optional[Axis] = None
+
+
+class PropertyDamper(Property, speckle_type=STRUCTURAL_PROPERTY + ".PropertyDamper"):
+    damperType: Optional[PropertyTypeDamper] = None
+    dampingX: float = 0.0
+    dampingY: float = 0.0
+    dampingZ: float = 0.0
+    dampingXX: float = 0.0
+    dampingYY: float = 0.0
+    dampingZZ: float = 0.0
+
+
+class PropertyMass(Property, speckle_type=STRUCTURAL_PROPERTY + ".PropertyMass"):
+    mass: float = 0.0
+    inertiaXX: float = 0.0
+    inertiaYY: float = 0.0
+    inertiaZZ: float = 0.0
+    inertiaXY: float = 0.0
+    inertiaYZ: float = 0.0
+    inertiaZX: float = 0.0
+    massModified: Optional[bool] = None
+    massModifierX: float = 0.0
+    massModifierY: float = 0.0
+    massModifierZ: float = 0.0
+
+
+class PropertySpring(Property, speckle_type=STRUCTURAL_PROPERTY + ".PropertySpring"):
+    springType: Optional[PropertyTypeSpring] = None
+    springCurveX: float = 0.0
+    stiffnessX: float = 0.0
+    springCurveY: float = 0.0
+    stiffnessY: float = 0.0
+    springCurveZ: float = 0.0
+    stiffnessZ: float = 0.0
+    springCurveXX: float = 0.0
+    stiffnessXX: float = 0.0
+    springCurveYY: float = 0.0
+    stiffnessYY: float = 0.0
+    springCurveZZ: float = 0.0
+    stiffnessZZ: float = 0.0
+    dampingRatio: float = 0.0
+    dampingX: float = 0.0
+    dampingY: float = 0.0
+    dampingZ: float = 0.0
+    dampingXX: float = 0.0
+    dampingYY: float = 0.0
+    dampingZZ: float = 0.0
+    matrix: float = 0.0
+    postiveLockup: float = 0.0
+    frictionCoefficient: float = 0.0
+
+
+class ReferenceSurfaceEnum(int, Enum):
+    Concrete = 0
+    Steel = 1
+    Timber = 2
+    Aluminium = 3
+    Masonry = 4
+    FRP = 5
+    Glass = 6
+    Fabric = 7
+    Rebar = 8
+    Tendon = 9
+    ColdFormed = 10
+    Other = 11
+
+
+class shapeType(int, Enum):
+    Concrete = 0
+    Steel = 1
+    Timber = 2
+    Aluminium = 3
+    Masonry = 4
+    FRP = 5
+    Glass = 6
+    Fabric = 7
+    Rebar = 8
+    Tendon = 9
+    ColdFormed = 10
+    Other = 11

src/specklepy/objects_v2/structural/results.py

@@ -0,0 +1,172 @@
+from typing import List, Optional
+
+from specklepy.objects.base import Base
+from specklepy.objects.structural.analysis import Model
+from specklepy.objects.structural.geometry import Element1D, Element2D, Element3D, Node
+
+STRUCTURAL_RESULTS = "Objects.Structural.Results."
+
+
+class Result(Base, speckle_type=STRUCTURAL_RESULTS + "Result"):
+    resultCase: Optional[Base] = None
+    permutation: Optional[str] = None
+    description: Optional[str] = None
+
+
+class ResultSet1D(Result, speckle_type=STRUCTURAL_RESULTS + "ResultSet1D"):
+    results1D: List
+
+
+class Result1D(Result, speckle_type=STRUCTURAL_RESULTS + "Result1D"):
+    element: Optional[Element1D] = None
+    position: Optional[float] = None
+    dispX: Optional[float] = None
+    dispY: Optional[float] = None
+    dispZ: Optional[float] = None
+    rotXX: Optional[float] = None
+    rotYY: Optional[float] = None
+    rotZZ: Optional[float] = None
+    forceX: Optional[float] = None
+    forceY: Optional[float] = None
+    forceZ: Optional[float] = None
+    momentXX: Optional[float] = None
+    momentYY: Optional[float] = None
+    momentZZ: Optional[float] = None
+    axialStress: Optional[float] = None
+    shearStressY: Optional[float] = None
+    shearStressZ: Optional[float] = None
+    bendingStressYPos: Optional[float] = None
+    bendingStressYNeg: Optional[float] = None
+    bendingStressZPos: Optional[float] = None
+    bendingStressZNeg: Optional[float] = None
+    combinedStressMax: Optional[float] = None
+    combinedStressMin: Optional[float] = None
+
+
+class ResultSet2D(Result, speckle_type=STRUCTURAL_RESULTS + "ResultSet2D"):
+    results2D: List
+
+
+class Result2D(Result, speckle_type=STRUCTURAL_RESULTS + "Result2D"):
+    element: Optional[Element2D] = None
+    position: List
+    dispX: Optional[float] = None
+    dispY: Optional[float] = None
+    dispZ: Optional[float] = None
+    forceXX: Optional[float] = None
+    forceYY: Optional[float] = None
+    forceXY: Optional[float] = None
+    momentXX: Optional[float] = None
+    momentYY: Optional[float] = None
+    momentXY: Optional[float] = None
+    shearX: Optional[float] = None
+    shearY: Optional[float] = None
+    stressTopXX: Optional[float] = None
+    stressTopYY: Optional[float] = None
+    stressTopZZ: Optional[float] = None
+    stressTopXY: Optional[float] = None
+    stressTopYZ: Optional[float] = None
+    stressTopZX: Optional[float] = None
+    stressMidXX: Optional[float] = None
+    stressMidYY: Optional[float] = None
+    stressMidZZ: Optional[float] = None
+    stressMidXY: Optional[float] = None
+    stressMidYZ: Optional[float] = None
+    stressMidZX: Optional[float] = None
+    stressBotXX: Optional[float] = None
+    stressBotYY: Optional[float] = None
+    stressBotZZ: Optional[float] = None
+    stressBotXY: Optional[float] = None
+    stressBotYZ: Optional[float] = None
+    stressBotZX: Optional[float] = None
+
+
+class ResultSet3D(Result, speckle_type=STRUCTURAL_RESULTS + "ResultSet3D"):
+    results3D: List
+
+
+class Result3D(Result, speckle_type=STRUCTURAL_RESULTS + "Result3D"):
+    element: Optional[Element3D] = None
+    position: List
+    dispX: Optional[float] = None
+    dispY: Optional[float] = None
+    dispZ: Optional[float] = None
+    stressXX: Optional[float] = None
+    stressYY: Optional[float] = None
+    stressZZ: Optional[float] = None
+    stressXY: Optional[float] = None
+    stressYZ: Optional[float] = None
+    stressZX: Optional[float] = None
+
+
+class ResultGlobal(Result, speckle_type=STRUCTURAL_RESULTS + "ResultGlobal"):
+    model: Optional[Model] = None
+    loadX: Optional[float] = None
+    loadY: Optional[float] = None
+    loadZ: Optional[float] = None
+    loadXX: Optional[float] = None
+    loadYY: Optional[float] = None
+    loadZZ: Optional[float] = None
+    reactionX: Optional[float] = None
+    reactionY: Optional[float] = None
+    reactionZ: Optional[float] = None
+    reactionXX: Optional[float] = None
+    reactionYY: Optional[float] = None
+    reactionZZ: Optional[float] = None
+    mode: Optional[float] = None
+    frequency: Optional[float] = None
+    loadFactor: Optional[float] = None
+    modalStiffness: Optional[float] = None
+    modalGeoStiffness: Optional[float] = None
+    effMassX: Optional[float] = None
+    effMassY: Optional[float] = None
+    effMassZ: Optional[float] = None
+    effMassXX: Optional[float] = None
+    effMassYY: Optional[float] = None
+    effMassZZ: Optional[float] = None
+
+
+class ResultSetNode(Result, speckle_type=STRUCTURAL_RESULTS + "ResultSetNode"):
+    resultsNode: List
+
+
+class ResultNode(Result, speckle_type=STRUCTURAL_RESULTS + " ResultNode"):
+    node: Optional[Node] = None
+    dispX: Optional[float] = None
+    dispY: Optional[float] = None
+    dispZ: Optional[float] = None
+    rotXX: Optional[float] = None
+    rotYY: Optional[float] = None
+    rotZZ: Optional[float] = None
+    reactionX: Optional[float] = None
+    reactionY: Optional[float] = None
+    reactionZ: Optional[float] = None
+    reactionXX: Optional[float] = None
+    reactionYY: Optional[float] = None
+    reactionZZ: Optional[float] = None
+    constraintX: Optional[float] = None
+    constraintY: Optional[float] = None
+    constraintZ: Optional[float] = None
+    constraintXX: Optional[float] = None
+    constraintYY: Optional[float] = None
+    constraintZZ: Optional[float] = None
+    velX: Optional[float] = None
+    velY: Optional[float] = None
+    velZ: Optional[float] = None
+    velXX: Optional[float] = None
+    velYY: Optional[float] = None
+    velZZ: Optional[float] = None
+    accX: Optional[float] = None
+    accY: Optional[float] = None
+    accZ: Optional[float] = None
+    accXX: Optional[float] = None
+    accYY: Optional[float] = None
+    accZZ: Optional[float] = None
+
+
+class ResultSetAll(Base, speckle_type=None):
+    resultSet1D: Optional[ResultSet1D] = None
+    resultSet2D: Optional[ResultSet2D] = None
+    resultSet3D: Optional[ResultSet3D] = None
+    resultsGlobal: Optional[ResultGlobal] = None
+    resultsNode: Optional[ResultSetNode] = None

src/specklepy/objects_v2/units.py

@@ -0,0 +1,124 @@
+from enum import Enum
+from typing import Union
+
+from specklepy.logging.exceptions import SpeckleException, SpeckleInvalidUnitException
+
+__all__ = [
+    "Units",
+    "get_encoding_from_units",
+    "get_units_from_encoding",
+    "get_units_from_string",
+]
+
+
+class Units(Enum):
+    mm = "mm"
+    cm = "cm"
+    m = "m"
+    km = "km"
+    inches = "in"
+    feet = "ft"
+    yards = "yd"
+    miles = "mi"
+    none = "none"
+
+
+UNITS_STRINGS = {
+    Units.mm: ["mm", "mil", "millimeters", "millimetres"],
+    Units.cm: ["cm", "centimetre", "centimeter", "centimetres", "centimeters"],
+    Units.m: ["m", "meter", "meters", "metre", "metres"],
+    Units.km: ["km", "kilometer", "kilometre", "kilometers", "kilometres"],
+    Units.inches: ["in", "inch", "inches"],
+    Units.feet: ["ft", "foot", "feet"],
+    Units.yards: ["yd", "yard", "yards"],
+    Units.miles: ["mi", "mile", "miles"],
+    Units.none: ["none", "null"],
+}
+
+
+UNITS_ENCODINGS = {
+    Units.none: 0,
+    None: 0,
+    Units.mm: 1,
+    Units.cm: 2,
+    Units.m: 3,
+    Units.km: 4,
+    Units.inches: 5,
+    Units.feet: 6,
+    Units.yards: 7,
+    Units.miles: 8,
+}
+
+
+UNIT_SCALE = {
+    Units.none: 1,
+    Units.mm: 0.001,
+    Units.cm: 0.01,
+    Units.m: 1.0,
+    Units.km: 1000.0,
+    Units.inches: 0.0254,
+    Units.feet: 0.3048,
+    Units.yards: 0.9144,
+    Units.miles: 1609.340,
+}
+"""Unit scaling factor to meters"""
+
+
+def get_units_from_string(unit: str) -> Units:
+    if not isinstance(unit, str):
+        raise SpeckleInvalidUnitException(unit)
+    unit = str.lower(unit)
+    for name, alternates in UNITS_STRINGS.items():
+        if unit in alternates:
+            return name
+    raise SpeckleInvalidUnitException(unit)
+
+
+def get_units_from_encoding(unit: int) -> Units:
+    for name, encoding in UNITS_ENCODINGS.items():
+        if unit == encoding:
+            return name or Units.none
+
+    raise SpeckleException(
+        message=(
+            f"Could not understand what unit {unit} is referring to."
+            f"Please enter a valid unit encoding (eg {UNITS_ENCODINGS})."
+        )
+    )
+
+
+def get_encoding_from_units(unit: Union[Units, str, None]):
+    maybe_sanitized_unit = unit
+    if isinstance(unit, str):
+        for unit_enum, aliases in UNITS_STRINGS.items():
+            if unit in aliases:
+                maybe_sanitized_unit = unit_enum
+    try:
+        return UNITS_ENCODINGS[maybe_sanitized_unit]
+    except KeyError as e:
+        raise SpeckleException(
+            message=(
+                f"No encoding exists for unit {maybe_sanitized_unit}."
+                f"Please enter a valid unit to encode (eg {UNITS_ENCODINGS})."
+            )
+        ) from e
+
+
+def get_scale_factor_from_string(fromUnits: str, toUnits: str) -> float:
+    """Returns a scalar to convert distance values from one unit system to another"""
+    return get_scale_factor(
+        get_units_from_string(fromUnits), get_units_from_string(toUnits)
+    )
+
+
+def get_scale_factor(fromUnits: Units, toUnits: Units) -> float:
+    """Returns a scalar to convert distance values from one unit system to another"""
+    return get_scale_factor_to_meters(fromUnits) / get_scale_factor_to_meters(toUnits)
+
+
+def get_scale_factor_to_meters(fromUnits: Units) -> float:
+    """Returns a scalar to convert distance values from one unit system to meters"""
+    if fromUnits not in UNIT_SCALE:
+        raise ValueError(f"Invalid units provided: {fromUnits}")
+
+    return UNIT_SCALE[fromUnits]

src/specklepy/serialization/base_object_serializer.py

@@ -30,7 +30,6 @@ def safe_json_loads(obj: str, obj_id=None) -> Any:
             f"Failed to deserialise object (id: {obj_id}). This is likely a ujson big"
             f" int error - falling back to json. \nError: {err}",
             SpeckleWarning,
-            stacklevel=2,
         )
         return json.loads(obj)
 
@@ -141,8 +140,7 @@ class BaseObjectSerializer:
                 object_builder[prop] = value
                 continue
 
-            # NOTE: for dynamic props, this won't be re-serialised
-            # as an enum but as an int
+            # NOTE: for dynamic props, this won't be re-serialised as an enum but as an int
             if isinstance(value, Enum):
                 object_builder[prop] = value.value
                 continue
@@ -224,7 +222,7 @@ class BaseObjectSerializer:
         if isinstance(obj, Enum):
             return obj.value
 
-        elif isinstance(obj, list | tuple | set):
+        elif isinstance(obj, (list, tuple, set)):
             if not detach:
                 return [self.traverse_value(o) for o in obj]
 
@@ -259,7 +257,6 @@ class BaseObjectSerializer:
                     f"Failed to handle {type(obj)} in"
                     " `BaseObjectSerializer.traverse_value`",
                     SpeckleWarning,
-                    stacklevel=2,
                 )
 
                 return str(obj)
@@ -377,7 +374,6 @@ class BaseObjectSerializer:
                         f"Could not find the referenced child object of id `{ref_id}`"
                         f" in the given read transport: {self.read_transport.name}",
                         SpeckleWarning,
-                        stacklevel=2,
                     )
                     base.__setattr__(prop, self.handle_value(value))
 
@@ -441,7 +437,6 @@ class BaseObjectSerializer:
                 f"Could not find the referenced child object of id `{ref_id}` in the"
                 f" given read transport: {self.read_transport.name}",
                 SpeckleWarning,
-                stacklevel=2,
             )
             return obj
 

src/specklepy/transports/memory.py

@@ -27,8 +27,8 @@ class MemoryTransport(AbstractTransport):
     ) -> None:
         raise NotImplementedError
 
-    def get_object(self, id: str) -> str | None:
-        return self.objects.get(id, None)
+    def get_object(self, id: str) -> str or None:
+        return self.objects[id] if id in self.objects else None
 
     def has_objects(self, id_list: List[str]) -> Dict[str, bool]:
         return {id: (id in self.objects) for id in id_list}

src/specklepy/transports/server/batch_sender.py

@@ -11,7 +11,7 @@ from specklepy.logging.exceptions import SpeckleException
 LOG = logging.getLogger(__name__)
 
 
-class BatchSender:
+class BatchSender(object):
     def __init__(
         self,
         server_url,
@@ -123,14 +123,8 @@ class BatchSender:
         upload_data = "[" + ",".join(new_objects) + "]"
         upload_data_gzip = gzip.compress(upload_data.encode())
         LOG.info(
-            "Uploading batch of {batch_size} objects {new_object_count}: ",
-            "(size: {upload_size}, compressed size: {upload_data_size})",
-            {
-                "batch_size": len(batch),
-                "new_object_count": len(new_objects),
-                "upload_size": len(upload_data),
-                "upload_data_size": len(upload_data_gzip),
-            },
+            "Uploading batch of %s objects (%s new): (size: %s, compressed size: %s)"
+            % (len(batch), len(new_objects), len(upload_data), len(upload_data_gzip))
         )
 
         try:

src/specklepy/transports/server/server.py

@@ -74,8 +74,7 @@ class ServerTransport(AbstractTransport):
                     SpeckleWarning(
                         "Unauthenticated Speckle Client provided to Server Transport"
                         f" for {url}. Receiving from private streams will fail."
-                    ),
-                    stacklevel=2,
+                    )
                 )
             else:
                 self.account = client.account

src/specklepy/transports/sqlite.py

@@ -39,7 +39,8 @@ class SQLiteTransport(AbstractTransport):
                 f"SQLiteTransport could not initialise {self.scope}.db at"
                 f" {self._base_path}. Either provide a different `base_path` or use an"
                 " alternative transport.",
-            ) from ex
+                ex,
+            )
 
     def __repr__(self) -> str:
         return f"SQLiteTransport(app: '{self.app_name}', scope: '{self.scope}')"
@@ -104,9 +105,10 @@ class SQLiteTransport(AbstractTransport):
             raise SpeckleException(
                 "Could not save the batch of objects to the local db. Inner exception:"
                 f" {ex}",
-            ) from ex
+                ex,
+            )
 
-    def get_object(self, id: str) -> str | None:
+    def get_object(self, id: str) -> str or None:
         self.__check_connection()
         with closing(self.__connection.cursor()) as c:
             row = c.execute(

tests/integration/client/current/test_active_user_resource.py

@@ -45,8 +45,7 @@ class TestActiveUserResource:
 
     def test_active_user_get_projects_with_filter(self, client: SpeckleClient):
         # Since the client may be reused for other tests,
-        # this test does rely on no other test creating a project
-        # with "Search for me" in its name
+        # this test does rely on no other test creating a project with "Search for me" in its name
         p1 = client.project.create(
             ProjectCreateInput(name="Search for me!", description=None, visibility=None)
         )

tests/integration/client/deprecated/test_objects.py

@@ -0,0 +1,47 @@
+import pytest
+
+from specklepy.api.models import Stream
+from specklepy.objects import Base
+from specklepy.objects.encoding import ObjectArray
+from specklepy.serialization.base_object_serializer import BaseObjectSerializer
+from specklepy.transports.sqlite import SQLiteTransport
+
+
+class TestObject:
+    @pytest.fixture(scope="module")
+    def stream(self, client):
+        stream = Stream(
+            name="a sample stream for testing",
+            description="a stream created for testing",
+            isPublic=True,
+        )
+        stream.id = client.stream.create(
+            stream.name, stream.description, stream.isPublic
+        )
+        return stream
+
+    def test_object_create(self, client, stream, base):
+        transport = SQLiteTransport()
+        s = BaseObjectSerializer(write_transports=[transport], read_transport=transport)
+        _, base_dict = s.traverse_base(base)
+        obj_id = client.object.create(stream_id=stream.id, objects=[base_dict])[0]
+
+        assert isinstance(obj_id, str)
+        assert base_dict["@detach"]["speckle_type"] == "reference"
+        assert obj_id == base.get_id(True)
+
+    def test_object_get(self, client, stream, base):
+        fetched_base = client.object.get(
+            stream_id=stream.id, object_id=base.get_id(True)
+        )
+
+        assert isinstance(fetched_base, Base)
+        assert fetched_base.name == base.name
+        assert isinstance(fetched_base.vertices, list)
+        # assert fetched_base["@detach"]["speckle_type"] == "reference"
+
+    def test_object_array_decoder(self):
+        array = ObjectArray()
+        array.data = [5, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 3, 1, 1, 1, 2, 1, 1, 1, 1]
+
+        assert array.decode(decoder=sum) == [5, 4, 3, 2, 1]

tests/integration/client/deprecated/test_other_user.py

@@ -33,8 +33,8 @@ class TestOtherUser:
         assert isinstance(fetched_user, LimitedUser)
         assert fetched_user.name == second_user_dict["name"]
         # changed in the server, now you cannot get emails of other users
-        # not checking this, since the first user could or could not be an admin
-        # on the server, admins can get emails of others, regular users can't
+        # not checking this, since the first user could or could not be an admin on the server
+        # admins can get emails of others, regular users can't
         # assert fetched_user.email == None
 
         second_user_dict["id"] = fetched_user.id

tests/integration/client/deprecated/test_user.py

@@ -36,8 +36,8 @@ class TestUser:
             assert isinstance(fetched_user, User)
             assert fetched_user.name == second_user_dict["name"]
             # changed in the server, now you cannot get emails of other users
-            # not checking this, since the first user could or could not be an admin
-            # on the server, admins can get emails of others, regular users can't
+            # not checking this, since the first user could or could not be an admin on the server
+            # admins can get emails of others, regular users can't
             # assert fetched_user.email == None
 
             second_user_dict["id"] = fetched_user.id

tests/integration/conftest.py

@@ -12,7 +12,7 @@ from specklepy.core.api.inputs.version_inputs import CreateVersionInput
 from specklepy.core.api.models import Stream, Version
 from specklepy.logging import metrics
 from specklepy.objects.base import Base
-from .fakemesh import FakeMesh, FakeDirection
+from specklepy.objects.fakemesh import FakeDirection, FakeMesh
 from specklepy.objects.geometry import Point
 from specklepy.transports.server.server import ServerTransport
 
@@ -44,8 +44,7 @@ def seed_user(host: str) -> Dict[str, str]:
     if not r.ok:
         raise Exception(f"Cannot seed user: {r.reason}")
     redirect_url = urlparse(r.headers.get("location"))
-    access_code = parse_qs(redirect_url.query)[
-        "access_code"][0]  # type: ignore
+    access_code = parse_qs(redirect_url.query)["access_code"][0]  # type: ignore
 
     r_tokens = requests.post(
         url=f"http://{host}/auth/token",
@@ -114,8 +113,7 @@ def sample_stream(client: SpeckleClient) -> Stream:
         description="a stream created for testing",
         isPublic=True,
     )
-    stream.id = client.stream.create(
-        stream.name, stream.description, stream.isPublic)
+    stream.id = client.stream.create(stream.name, stream.description, stream.isPublic)
     return stream
 
 

tests/integration/test_serialization.py

@@ -3,8 +3,8 @@ import json
 import pytest
 
 from specklepy.api import operations
-from specklepy.objects.base import Base
-from .fakemesh import FakeMesh
+from specklepy.objects import Base
+from specklepy.objects.fakemesh import FakeMesh
 from specklepy.objects.geometry import Point
 from specklepy.transports.memory import MemoryTransport
 from specklepy.transports.server import ServerTransport

tests/integration/test_wrapper.py

@@ -1,4 +1,3 @@
-import contextlib
 import json
 import tempfile
 from pathlib import Path
@@ -17,11 +16,14 @@ def user_path() -> Iterable[Path]:
     speckle_path_provider.override_application_data_path(tempfile.gettempdir())
     path = speckle_path_provider.accounts_folder_path().joinpath("test_acc.json")
     # hey, py37 doesn't support the missing_ok argument
-    with contextlib.suppress(Exception):
+    try:
         path.unlink()
-
-    with contextlib.suppress(Exception):
+    except Exception:
+        pass
+    try:
         path.unlink(missing_ok=True)
+    except Exception:
+        pass
     path.parent.absolute().mkdir(exist_ok=True)
     yield path
     if path.exists():
@@ -32,7 +34,7 @@ def user_path() -> Iterable[Path]:
 def test_parse_empty():
     try:
         StreamWrapper("https://testing.speckle.dev/streams")
-        raise AssertionError()
+        assert False
     except SpeckleException:
         assert True
 
@@ -40,7 +42,7 @@ def test_parse_empty():
 def test_parse_empty_fe2():
     try:
         StreamWrapper("https://latest.speckle.systems/projects")
-        raise AssertionError()
+        assert False
     except SpeckleException:
         assert True
 
@@ -167,7 +169,7 @@ def test_parse_model():
 def test_parse_federated_model():
     try:
         StreamWrapper("https://latest.speckle.systems/projects/843d07eb10/models/$main")
-        raise AssertionError()
+        assert False
     except SpeckleException:
         assert True
 
@@ -177,7 +179,7 @@ def test_parse_multi_model():
         StreamWrapper(
             "https://latest.speckle.systems/projects/2099ac4b5f/models/1870f279e3,a9cfdddc79"
         )
-        raise AssertionError()
+        assert False
     except SpeckleException:
         assert True
 

tests/unit/test_base.py

@@ -7,7 +7,7 @@ import pytest
 from specklepy.api import operations
 from specklepy.logging.exceptions import SpeckleException, SpeckleInvalidUnitException
 from specklepy.objects.base import Base
-from specklepy.objects.models.units import Units
+from specklepy.objects.units import Units
 
 
 @pytest.mark.parametrize(

tests/unit/test_geometry.py

@@ -0,0 +1,523 @@
+# pylint: disable=redefined-outer-name
+import json
+
+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 (
+    Arc,
+    Box,
+    Brep,
+    BrepEdge,
+    BrepFace,
+    BrepLoop,
+    BrepLoopType,
+    BrepTrim,
+    BrepTrimType,
+    Circle,
+    Curve,
+    Ellipse,
+    Interval,
+    Line,
+    Mesh,
+    Plane,
+    Point,
+    Polycurve,
+    Polyline,
+    Surface,
+    Vector,
+)
+from specklepy.objects.units import Units
+from specklepy.transports.memory import MemoryTransport
+
+
+@pytest.fixture()
+def interval():
+    return Interval(start=0, end=5)
+
+
+@pytest.fixture()
+def point():
+    return Point(x=1, y=10, z=0)
+
+
+@pytest.fixture()
+def vector():
+    return Vector(x=1, y=32, z=10)
+
+
+@pytest.fixture()
+def plane(point, vector):
+    return Plane(origin=point, normal=vector, xdir=vector, ydir=vector, units="m")
+
+
+@pytest.fixture()
+def box(plane, interval):
+    return Box(
+        basePlane=plane,
+        ySize=interval,
+        zSize=interval,
+        xSize=interval,
+        area=20.4,
+        volume=44.2,
+    )
+
+
+@pytest.fixture()
+def line(point, interval):
+    return Line(
+        start=point,
+        end=point,
+        domain=interval,
+        units="none",
+        # These attributes are not handled in C#
+        # bbox=None,
+        # length=None
+    )
+
+
+@pytest.fixture()
+def arc(plane, interval, point):
+    return Arc(
+        radius=2.3,
+        startAngle=22.1,
+        endAngle=44.5,
+        angleRadians=33,
+        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,
+    )
+
+
+@pytest.fixture()
+def circle(plane, interval):
+    return Circle(
+        radius=22,
+        plane=plane,
+        domain=interval,
+        units="m",
+        # These attributes are not handled in C#
+        # bbox=None,
+        # area=None,
+        # length=None,
+    )
+
+
+@pytest.fixture()
+def ellipse(plane, interval):
+    return Ellipse(
+        firstRadius=34,
+        secondRadius=22,
+        plane=plane,
+        domain=interval,
+        units="m",
+        # These attributes are not handled in C#
+        # trimDomain=None,
+        # bbox=None,
+        # area=None,
+        # length=None,
+    )
+
+
+@pytest.fixture()
+def polyline(interval):
+    return Polyline(
+        value=[22, 44, 54.3, 99, 232, 21],
+        closed=True,
+        domain=interval,
+        units="m",
+        # These attributes are not handled in C#
+        # bbox=None,
+        # area=None,
+        # length=None,
+    )
+
+
+@pytest.fixture()
+def curve(interval):
+    return Curve(
+        degree=90,
+        periodic=True,
+        rational=False,
+        closed=True,
+        domain=interval,
+        points=[23, 21, 44, 43, 56, 76, 1, 3, 2],
+        weights=[23, 11, 23],
+        knots=[22, 45, 76, 11],
+        units="m",
+        # These attributes are not handled in C#
+        # displayValue=None,
+        # bbox=None,
+        # area=None,
+        # length=None,
+    )
+
+
+@pytest.fixture()
+def polycurve(interval, curve, polyline):
+    return Polycurve(
+        segments=[curve, polyline],
+        domain=interval,
+        closed=True,
+        units="m",
+        # These attributes are not handled in C#
+        # bbox=None,
+        # area=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 surface(interval):
+    return Surface(
+        degreeU=33,
+        degreeV=44,
+        rational=True,
+        pointData=[1, 2.2, 3, 4, 5, 6, 7, 8, 9],
+        countU=3,
+        countV=4,
+        closedU=True,
+        closedV=False,
+        domainU=interval,
+        domainV=interval,
+        knotsU=[1.1, 2.2, 3.3, 4.4],
+        knotsV=[9, 8, 7, 6, 5, 4.4],
+        units="m",
+        # These attributes are not handled in C#
+        # bbox=None,
+        # area=None,
+    )
+
+
+@pytest.fixture()
+def brep_face():
+    return BrepFace(
+        SurfaceIndex=3,
+        LoopIndices=[1, 2, 3, 4],
+        OuterLoopIndex=2,
+        OrientationReversed=False,
+    )
+
+
+@pytest.fixture()
+def brep_edge(interval):
+    return BrepEdge(
+        Curve3dIndex=2,
+        TrimIndices=[4, 5, 6, 7],
+        StartIndex=2,
+        EndIndex=6,
+        ProxyCurveIsReversed=True,
+        Domain=interval,
+    )
+
+
+@pytest.fixture()
+def brep_loop():
+    return BrepLoop(FaceIndex=5, TrimIndices=[3, 4, 5], Type=BrepLoopType.Unknown)
+
+
+@pytest.fixture()
+def brep_trim():
+    return BrepTrim(
+        EdgeIndex=3,
+        StartIndex=4,
+        EndIndex=6,
+        FaceIndex=1,
+        LoopIndex=4,
+        CurveIndex=7,
+        IsoStatus=6,
+        TrimType=BrepTrimType.Mated,
+        IsReversed=False,
+        # These attributes are not handled in C#
+        # Domain=None,
+    )
+
+
+@pytest.fixture
+def brep(
+    mesh,
+    box,
+    surface,
+    curve,
+    polyline,
+    circle,
+    point,
+    brep_edge,
+    brep_loop,
+    brep_trim,
+    brep_face,
+):
+    return Brep(
+        provenance="pytest",
+        bbox=box,
+        area=32,
+        volume=54,
+        displayValue=mesh,
+        Surfaces=[surface, surface, surface],
+        Curve3D=[curve, polyline],
+        Curve2D=[circle],
+        Vertices=[point, point, point, point],
+        Edges=[brep_edge],
+        Loops=[brep_loop, brep_loop],
+        Trims=[brep_trim],
+        Faces=[brep_face, brep_face],
+        IsClosed=False,
+        Orientation=3,
+    )
+
+
+@pytest.fixture
+def geometry_objects_dict(
+    point,
+    vector,
+    plane,
+    line,
+    arc,
+    circle,
+    ellipse,
+    polyline,
+    curve,
+    polycurve,
+    surface,
+    brep_trim,
+):
+    return {
+        "point": point,
+        "vector": vector,
+        "plane": plane,
+        "line": line,
+        "arc": arc,
+        "circle": circle,
+        "ellipse": ellipse,
+        "polyline": polyline,
+        "curve": curve,
+        "polycurve": polycurve,
+        "surface": surface,
+        "brep_trim": brep_trim,
+    }
+
+
+@pytest.mark.parametrize(
+    "object_name",
+    [
+        "point",
+        "vector",
+        "plane",
+        "line",
+        "arc",
+        "circle",
+        "ellipse",
+        "polyline",
+        "curve",
+        "polycurve",
+        "surface",
+        "brep_trim",
+    ],
+)
+def test_to_and_from_list(object_name: str, geometry_objects_dict):
+    obj = geometry_objects_dict[object_name]
+    assert hasattr(obj, "to_list")
+    assert hasattr(obj, "from_list")
+
+    chunks = obj.to_list()
+    assert isinstance(chunks, list)
+
+    object_class = obj.__class__
+    decoded_object: Base = object_class.from_list(chunks)
+    assert decoded_object.get_id() == obj.get_id()
+
+
+def test_brep_surfaces_value_serialization(surface):
+    brep = Brep()
+    assert brep.Surfaces is None
+    assert brep.SurfacesValue is None
+    brep.Surfaces = [surface, surface]
+    assert brep.SurfacesValue == ObjectArray.from_objects([surface, surface]).data
+
+    brep.SurfacesValue = ObjectArray.from_objects([surface]).data
+    assert len(brep.Surfaces) == 1
+    assert brep.Surfaces[0].get_id() == surface.get_id()
+
+
+def test_brep_curve2d_values_serialization(curve, polyline, circle):
+    brep = Brep()
+    assert brep.Curve2D is None
+    assert brep.Curve2DValues is None
+    brep.Curve2D = [curve, polyline]
+    assert brep.Curve2DValues == CurveArray.from_curves([curve, polyline]).data
+
+    brep.Curve2DValues = CurveArray.from_curves([circle]).data
+    assert len(brep.Curve2D) == 1
+    assert brep.Curve2D[0].get_id() == circle.get_id()
+
+
+def test_brep_curve3d_values_serialization(curve, polyline, circle):
+    brep = Brep()
+    assert brep.Curve3D is None
+    assert brep.Curve3DValues is None
+    brep.Curve3D = [curve, polyline]
+    assert brep.Curve3DValues == CurveArray.from_curves([curve, polyline]).data
+
+    brep.Curve3DValues = CurveArray.from_curves([circle]).data
+    assert len(brep.Curve3D) == 1
+    assert brep.Curve3D[0].get_id() == circle.get_id()
+
+
+def test_brep_vertices_values_serialization():
+    brep = Brep()
+    brep.VerticesValue = [1, 1, 1, 1, 2, 2, 2, 3, 3, 3]
+    assert brep.Vertices[0].get_id() == Point(x=1, y=1, z=1, units=Units.mm).get_id()
+    assert brep.Vertices[1].get_id() == Point(x=2, y=2, z=2, units=Units.mm).get_id()
+    assert brep.Vertices[2].get_id() == Point(x=3, y=3, z=3, units=Units.mm).get_id()
+
+
+def test_trims_value_serialization():
+    brep = Brep()
+    brep.TrimsValue = [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        1,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        1,
+        2,
+        1,
+        1,
+    ]
+
+    assert (
+        brep.Trims[0].get_id()
+        == BrepTrim(
+            EdgeIndex=0,
+            StartIndex=0,
+            EndIndex=0,
+            FaceIndex=0,
+            LoopIndex=0,
+            CurveIndex=0,
+            IsoStatus=1,
+            TrimType=BrepTrimType.Boundary,
+            IsReversed=False,
+        ).get_id()
+    )
+
+    assert (
+        brep.Trims[1].get_id()
+        == BrepTrim(
+            EdgeIndex=1,
+            StartIndex=0,
+            EndIndex=0,
+            FaceIndex=0,
+            LoopIndex=0,
+            CurveIndex=1,
+            IsoStatus=2,
+            TrimType=BrepTrimType.Boundary,
+            IsReversed=True,
+        ).get_id()
+    )
+
+
+def test_loops_value_serialization():
+    brep = Brep()
+    brep.LoopsValue = [6, 0, 1, 0, 1, 2, 3]
+
+    assert brep == brep.Loops[0]._Brep  # pylint: disable=protected-access
+    assert (
+        brep.Loops[0].get_id()
+        == BrepLoop(
+            FaceIndex=0, Type=BrepLoopType(1), TrimIndices=[0, 1, 2, 3]
+        ).get_id()
+    )
+
+
+def test_edges_value_serialization():
+    brep = Brep()
+    brep.EdgesValue = [8, 0, 0, 1, 0, -8.13345756858629, 8.13345756858629, 1, 3]
+
+    assert brep == brep.Edges[0]._Brep  # pylint: disable=protected-access
+    assert (
+        brep.Edges[0].get_id()
+        == BrepEdge(
+            Curve3dIndex=0,
+            StartIndex=0,
+            EndIndex=1,
+            ProxyCurveIsReversed=False,
+            Domain=Interval(start=-8.13345756858629, end=8.13345756858629),
+            TrimIndices=[1, 3],
+        ).get_id()
+    )
+
+
+def test_faces_value_serialization():
+    brep = Brep()
+    brep.FacesValue = [4, 0, 0, 1, 0]
+
+    assert brep == brep.Faces[0]._Brep  # pylint: disable=protected-access
+    assert (
+        brep.Faces[0].get_id()
+        == BrepFace(
+            SurfaceIndex=0, OuterLoopIndex=0, OrientationReversed=True, LoopIndices=[0]
+        ).get_id()
+    )
+
+
+def test_serialized_brep_attributes(brep: Brep):
+    transport = MemoryTransport()
+    serialized = operations.serialize(brep, [transport])
+    serialized_dict = json.loads(serialized)
+
+    removed_keys = [
+        "Surfaces",
+        "Curve3D",
+        "Curve2D",
+        "Vertices",
+        "Trims",
+        "Loops",
+        "Edges",
+        "Faces",
+    ]
+
+    for k in removed_keys:
+        assert k not in serialized_dict.keys()
+
+
+def test_mesh_create():
+    vertices = [2, 1, 2, 4, 77.3, 5, 33, 4, 2]
+    faces = [1, 2, 3, 4, 5, 6, 7]
+    mesh = Mesh.create(vertices, faces)
+
+    with pytest.raises(SpeckleException):
+        bad_mesh = Mesh.create(vertices=7, faces=faces)  # noqa: F841
+
+    assert mesh.vertices == vertices
+    assert mesh.textureCoordinates == []

tests/unit/test_graph_traversal.py

@@ -2,7 +2,7 @@ from dataclasses import dataclass
 from typing import Dict, List, Optional
 from unittest import TestCase
 
-from specklepy.objects.base import Base
+from specklepy.objects import Base
 from specklepy.objects.graph_traversal.traversal import GraphTraversal, TraversalRule
 
 
@@ -100,7 +100,6 @@ class GraphTraversalTests(TestCase):
             for context in GraphTraversal([traverse_lists_rule]).traverse(test_case)
         ]
 
-        self.assertCountEqual(
-            ret, [test_case, expected_traverse, expected_traverse])
+        self.assertCountEqual(ret, [test_case, expected_traverse, expected_traverse])
         self.assertNotIn(expected_ignore, ret)
         self.assertEqual(len(ret), 3)

tests/unit/test_registering_base.py

@@ -3,6 +3,7 @@ from typing import Type
 import pytest
 
 from specklepy.objects.base import Base
+from specklepy.objects.structural import Concrete
 
 
 class Foo(Base):
@@ -27,6 +28,10 @@ class Baz(Bar):
             Baz,
             "Tests.Unit.TestRegisteringBase.Foo:Custom.Bar:Tests.Unit.TestRegisteringBase.Baz",
         ),
+        (
+            Concrete,
+            "Objects.Structural.Materials.StructuralMaterial:Objects.Structural.Materials.Concrete",
+        ),
     ],
 )
 def test_determine_speckle_type(klass: Type[Base], speckle_type: str):
@@ -38,6 +43,7 @@ def test_determine_speckle_type(klass: Type[Base], speckle_type: str):
     [
         (Base, "Base"),
         (Foo, "Tests.Unit.TestRegisteringBase.Foo"),
+        (Concrete, "Objects.Structural.Materials.Concrete"),
     ],
 )
 def test_full_name(klass: Type[Base], fully_qualified_name: str):