final touches (hopefully)

early return ifc quantities
function call elimination
2025-08-19 20:20:15 +03:00 · 2025-08-19 20:16:45 +03:00 · 2025-08-19 20:12:22 +03:00 · 2025-08-19 20:08:22 +03:00 · 2025-08-19 19:33:25 +03:00 · 2025-08-18 22:30:49 +03:00
81 changed files with 4610 additions and 1299 deletions
@@ -1,27 +0,0 @@
-# See here for image contents: https://github.com/microsoft/vscode-dev-containers/blob/main/containers/python-3/.devcontainer/base.Dockerfile
-
-# [Choice] Python version: 3, 3.9, 3.8, 3.7, 3.6
-ARG VARIANT="3.10"
-FROM mcr.microsoft.com/vscode/devcontainers/python:${VARIANT}
-
-# [Choice] Node.js version: none, lts/*, 16, 14, 12, 10
-ARG NODE_VERSION="16"
-RUN if [ "${NODE_VERSION}" != "none" ]; then su vscode -c "umask 0002 && . /usr/local/share/nvm/nvm.sh && nvm install ${NODE_VERSION} 2>&1"; fi
-
-# [Optional] If your pip requirements rarely change, uncomment this section to add them to the image.
-# COPY requirements.txt /tmp/pip-tmp/
-# RUN pip3 --disable-pip-version-check --no-cache-dir install -r /tmp/pip-tmp/requirements.txt \
-#    && rm -rf /tmp/pip-tmp
-
-# [Optional] Uncomment this section to install additional OS packages.
-# RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
-#     && apt-get -y install --no-install-recommends <your-package-list-here>
-
-# [Optional] Uncomment this line to install global node packages.
-# RUN su vscode -c "source /usr/local/share/nvm/nvm.sh && npm install -g <your-package-here>" 2>&1
-
-USER vscode
-
-RUN curl -sSL https://install.python-poetry.org | python3 -
-
-ENV PATH=$PATH:$HOME/.poetry/env
@@ -1,55 +0,0 @@
-// For format details, see https://aka.ms/devcontainer.json. For config options, see the README at:
-// https://github.com/microsoft/vscode-dev-containers/tree/v0.191.1/containers/python-3
-{
-	"name": "Python 3",
-	// "build": {
-	// 	"dockerfile": "Dockerfile",
-	// 	"context": "..",
-	// 	"args": {
-	// 		// Update 'VARIANT' to pick a Python version: 3, 3.6, 3.7, 3.8, 3.9
-	// 		"VARIANT": "3.6",
-	// 		// Options
-	// 		"NODE_VERSION": "lts/*"
-	// 	}
-	// },
-	"dockerComposeFile": "./docker-compose.yaml",
-	"service": "specklepy",
-	"workspaceFolder": "/workspaces/specklepy",
-	"shutdownAction": "stopCompose",
-	// Set *default* container specific settings.json values on container create.
-	"settings": {
-		"python.pythonPath": "/usr/local/bin/python",
-		"python.languageServer": "Pylance",
-		"python.linting.enabled": true,
-		"python.linting.pylintEnabled": true,
-		"python.linting.pylintArgs": [
-			"--max-line-length=120"
-		],
-		"python.formatting.autopep8Path": "/usr/local/py-utils/bin/autopep8",
-		"python.formatting.blackPath": "/usr/local/py-utils/bin/black",
-		"python.formatting.yapfPath": "/usr/local/py-utils/bin/yapf",
-		"python.linting.banditPath": "/usr/local/py-utils/bin/bandit",
-		"python.linting.flake8Path": "/usr/local/py-utils/bin/flake8",
-		"python.linting.mypyPath": "/usr/local/py-utils/bin/mypy",
-		"python.linting.pycodestylePath": "/usr/local/py-utils/bin/pycodestyle",
-		"python.linting.pydocstylePath": "/usr/local/py-utils/bin/pydocstyle",
-		"python.linting.pylintPath": "/usr/local/py-utils/bin/pylint",
-		"python.testing.pytestArgs": [
-			"tests/",
-			"-s"
-		],
-		"python.testing.pytestEnabled": true,
-		"editor.formatOnSave": true,
-	},
-	// Add the IDs of extensions you want installed when the container is created.
-	"extensions": [
-		"ms-python.python",
-		"ms-python.vscode-pylance"
-	],
-	// Use 'forwardPorts' to make a list of ports inside the container available locally.
-	// "forwardPorts": [],
-	// Use 'postCreateCommand' to run commands after the container is created.
-	"postCreateCommand": "poetry config virtualenvs.create false && poetry install",
-	// Comment out connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
-	"remoteUser": "vscode"
-}
@@ -1,44 +0,0 @@
-version: "3.3"  # optional since v1.27.0
-services:
-  postgres:
-    image: cimg/postgres:14.2
-    environment:
-      POSTGRES_DB: speckle2_test
-      POSTGRES_PASSWORD: speckle
-      POSTGRES_USER: speckle
-    network_mode: host
-  redis:
-    image: cimg/redis:6.2
-    network_mode: host
-  speckle-server:
-    image: speckle/speckle-server:latest
-    command: ["bash", "-c", "/wait && node bin/www"]
-    environment:
-      POSTGRES_URL: "localhost"
-      POSTGRES_USER: "speckle"
-      POSTGRES_PASSWORD: "speckle"
-      POSTGRES_DB: "speckle2_test"
-      REDIS_URL: "redis://localhost"
-      SESSION_SECRET: "keyboard cat"
-      STRATEGY_LOCAL: "true"
-      CANONICAL_URL: "http://localhost:3000"
-      WAIT_HOSTS: localhost:5432, localhost:6379
-      DISABLE_FILE_UPLOADS: "true"
-    network_mode: host
-
-  specklepy:
-    build:
-      dockerfile: Dockerfile
-      context: .
-      args:
-        VARIANT: 3.9
-        NODE_VERSION: lts/*
-    volumes:
-      # Mounts the project folder to '/workspace'. While this file is in .devcontainer,
-      # mounts are relative to the first file in the list, which is a level up.
-      - ..:/workspaces/specklepy:cached
-    # Overrides default command so things don't shut down after the process ends.
-    command: /bin/sh -c "while sleep 1000; do :; done"
-    network_mode: host
-# networks:
-#     default:
@@ -1,14 +1,16 @@
-name: "Specklepy test and build"
+name: "Specklepy test"
 on:
+  workflow_call:
+    secrets:
+      CODECOV_TOKEN:
+        required: true
  pull_request:
    branches:
-      - "v3-dev"
-  push:
-    branches:
-      - "v3-dev"
+      - "main"
+
 jobs:
-  ci:
-    name: continuous-integration
+  test:
+    name: test
    runs-on: ubuntu-latest
    strategy:
      matrix:
@@ -39,18 +41,18 @@ jobs:
      - name: Run pre-commit
        run: uv run pre-commit run --all-files

-      # - name: Run Speckle Server
-      #   run: docker compose up -d
+      - name: Run Speckle Server
+        run: docker compose up --detach --wait

-      # - name: Run tests
-      #   run: uv run pytest --cov --cov-report xml:reports/coverage.xml --junitxml=reports/test-results.xml
+      - 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 }}
+      - 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
@@ -1,33 +1,55 @@
-# Publish a release to PyPI.
-name: "Publish to PyPI"
-
+name: "Publish Python Package"
 on:
-  workflow_run:
-    workflows: ["Specklepy test and build"]
-    branches: [v3-dev]
-    types:
-      - completed
+  push:
+    branches:
+      - "main"
+    tags:
+      - "3.*.*"

 jobs:
-  pypi-publish:
-    name: Upload to PyPI
+  test:
+    uses: "./.github/workflows/pr.yml"
+    secrets:
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+  publish-package:
+    name: "Build and Publish Python Package"
    runs-on: ubuntu-latest
+    needs: test
+
+    # set the environment based on what triggered the workflow
    environment:
-      name: testpypi
+      name: ${{ github.ref_type == 'tag' && 'pypi' || 'testpypi' }}
+
    permissions:
-      # For PyPI's trusted publishing.
      id-token: write
+
    steps:
      - name: "Install uv"
        uses: astral-sh/setup-uv@v5
-      - uses: actions/checkout@v4
+
+      - name: "Checkout code"
+        uses: actions/checkout@v4
        with:
-          # This is necessary so that we have the tags.
          fetch-depth: 0
-      - name: "Build artifacts"
+
+      - name: "Build package artifacts"
        run: uv build
-      - name: Publish to PyPi
+
+      # Logic for TestPyPI (on main branch push)
+      - name: "Publish to TestPyPI"
+        if: ${{ github.ref_type == 'branch' }}
        run: uv publish --index test

-      - name: Test package install
+      - name: "Verify TestPyPI package installation"
+        if: ${{ github.ref_type == 'branch' }}
        run: uv run --index test --with specklepy --no-project -- python -c "import specklepy"
+
+      # Logic for PyPI (on v3* tag creation)
+      - name: "Publish to PyPI"
+        if: ${{ github.ref_type == 'tag' }}
+        run: uv publish
+
+      - name: "Verify PyPI package installation"
+        if: ${{ github.ref_type == 'tag' }}
+        run: uv run --with specklepy --no-project -- python -c "import specklepy"
@@ -0,0 +1,6 @@
+{
+    "recommendations": [
+        "ms-python.python",
+        "charliermarsh.ruff"
+    ]
+}
@@ -11,7 +11,11 @@
    The Python SDK
 </h3>

-<p align="center"><a href="https://codecov.io/gh/specklesystems/specklepy"><img src="https://codecov.io/gh/specklesystems/specklepy/branch/main/graph/badge.svg?token=8KQFL5N0YF" alt="Codecov"></a></p>
+<p align="center">
+  <a href="https://pypi.org/project/specklepy/"><img alt="PyPI - Version" src="https://img.shields.io/pypi/v/specklepy"></a>
+  <a href="https://codecov.io/gh/specklesystems/specklepy"><img src="https://codecov.io/gh/specklesystems/specklepy/branch/main/graph/badge.svg?token=8KQFL5N0YF" alt="Codecov"></a>
+  <a href="https://github.com/specklesystems/specklepy/blob/main/LICENSE"><img alt="License" src="https://img.shields.io/github/license/specklesystems/specklepy"></a>
+</p>

 # Repo structure

@@ -13,7 +13,7 @@ services:
      POSTGRES_USER: speckle
      POSTGRES_PASSWORD: speckle
    volumes:
-      - ./.volumes/postgres-data:/var/lib/postgresql/data/
+      - postgres-data:/var/lib/postgresql/data/
    healthcheck:
      # the -U user has to match the POSTGRES_USER value
      test: ["CMD-SHELL", "pg_isready -U speckle"]
@@ -25,7 +25,7 @@ services:
    image: "redis:6.0-alpine"
    restart: always
    volumes:
-      - ./.volumes/redis-data:/data
+      - redis-data:/data
    healthcheck:
      test: ["CMD", "redis-cli", "--raw", "incr", "ping"]
      interval: 5s
@@ -37,7 +37,7 @@ services:
    command: server /data --console-address ":9001"
    restart: always
    volumes:
-      - ./.volumes/minio-data:/data
+      - minio-data:/data
    healthcheck:
      test:
        [
@@ -100,7 +100,6 @@ services:
      POSTGRES_PASSWORD: "speckle"
      POSTGRES_DB: "speckle"
      ENABLE_MP: "false"
-      FRONTEND_ORIGIN: "http://127.0.0.1:8080"

 networks:
  default:
@@ -2,7 +2,7 @@
 dynamic = ["version"]
 # version = "3.0.0a1"
 name = "specklepy"
-description = "The Python SDK for Speckle 2.0"
+description = "The Python SDK for Speckle"
 readme = "README.md"
 authors = [{ name = "Speckle Systems", email = "devops@speckle.systems" }]
 license = { text = "Apache-2.0" }
@@ -18,6 +18,9 @@ dependencies = [
    "ujson>=5.10.0",
 ]

+[project.optional-dependencies]
+speckleifc = ["ifcopenshell>=0.8.2"]
+
 [dependency-groups]
 dev = [
    "commitizen>=4.1.0",
@@ -47,6 +50,13 @@ build-backend = "hatchling.build"
 [tool.hatch.version]
 source = "vcs"

+[tool.hatch.build.targets.wheel]
+only-include = ["src", "licenses"]
+sources = ["src"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src", "licenses"]
+
 [tool.hatch.version.raw-options]
 local_scheme = "no-local-version"

@@ -1,5 +1,3 @@
-# ignoring "line too long" check from linter
-# ruff: noqa: E501
 """This module provides an abstraction layer above the Speckle Automate runtime."""

 import time
@@ -75,7 +73,7 @@ class AutomationContext:
        speckle_client.authenticate_with_token(speckle_token)
        if not speckle_client.account:
            msg = (
-                f"Could not autenticate to {automation_run_data.speckle_server_url}",
+                f"Could not authenticate to {automation_run_data.speckle_server_url}",
                "with the provided token",
            )
            raise ValueError(msg)
@@ -109,18 +107,24 @@ class AutomationContext:
            )
        except SpeckleException as err:
            raise ValueError(
-                f"""\
-                             Could not receive specified version.
-                             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}
-                             """
+                f"""Could not receive specified version.
+                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}
+                """
            ) from err

+        if not version.referenced_object:
+            raise Exception(
+                "This version is past the version history limit,",
+                " cannot execute an automation on it",
+            )
+
        base = operations.receive(
            version.referenced_object, self._server_transport, self._memory_transport
        )
+        # self._closure_tree = base["__closure"]
        print(
            f"It took {self.elapsed():.2f} seconds to receive",
            f" the speckle version {version_id}",
@@ -242,7 +246,7 @@ class AutomationContext:
        )
        if self.run_status in [AutomationStatus.SUCCEEDED, AutomationStatus.FAILED]:
            object_results = {
-                "version": 1,
+                "version": 2,
                "values": {
                    "objectResults": self._automation_result.model_dump(by_alias=True)[
                        "objectResults"
@@ -332,26 +336,24 @@ class AutomationContext:
    def attach_error_to_objects(
        self,
        category: str,
-        object_ids: Union[str, List[str]],
+        affected_objects: Union[Base, List[Base]],
        message: Optional[str] = None,
        metadata: Optional[Dict[str, Any]] = None,
        visual_overrides: Optional[Dict[str, Any]] = None,
    ) -> None:
        """Add a new error case to the run results.
-
-        If the error cause has already created an error case,
-        the error will be extended with a new case refering to the causing objects.
        Args:
-            error_tag (str): A short tag for the error type.
-            causing_object_ids (str[]): A list of object_id-s that are causing the error
-            error_messagge (Optional[str]): Optional error message.
+            category (str): A short tag for the event type.
+            affected_objects (Union[Base, List[Base]]): A single object or a list of
+                objects that are causing the error case.
+            message (Optional[str]): Optional message.
            metadata: User provided metadata key value pairs
            visual_overrides: Case specific 3D visual overrides.
        """
        self.attach_result_to_objects(
            ObjectResultLevel.ERROR,
            category,
-            object_ids,
+            affected_objects,
            message,
            metadata,
            visual_overrides,
@@ -360,16 +362,25 @@ class AutomationContext:
    def attach_warning_to_objects(
        self,
        category: str,
-        object_ids: Union[str, List[str]],
+        affected_objects: Union[Base, List[Base]],
        message: Optional[str] = None,
        metadata: Optional[Dict[str, Any]] = None,
        visual_overrides: Optional[Dict[str, Any]] = None,
    ) -> None:
-        """Add a new warning case to the run results."""
+        """Add a new warning case to the run results.
+
+        Args:
+            category (str): A short tag for the event type.
+            affected_objects (Union[Base, List[Base]]): A single object or a list of
+                objects that are causing the warning case.
+            message (Optional[str]): Optional message.
+            metadata: User provided metadata key value pairs
+            visual_overrides: Case specific 3D visual overrides.
+        """
        self.attach_result_to_objects(
            ObjectResultLevel.WARNING,
            category,
-            object_ids,
+            affected_objects,
            message,
            metadata,
            visual_overrides,
@@ -378,16 +389,25 @@ class AutomationContext:
    def attach_success_to_objects(
        self,
        category: str,
-        object_ids: Union[str, List[str]],
+        affected_objects: Union[Base, List[Base]],
        message: Optional[str] = None,
        metadata: Optional[Dict[str, Any]] = None,
        visual_overrides: Optional[Dict[str, Any]] = None,
    ) -> None:
-        """Add a new success case to the run results."""
+        """Add a new success case to the run results.
+
+        Args:
+            category (str): A short tag for the event type.
+            affected_objects (Union[Base, List[Base]]): A single object or a list of
+                objects that are causing the success case.
+            message (Optional[str]): Optional message.
+            metadata: User provided metadata key value pairs
+            visual_overrides: Case specific 3D visual overrides.
+        """
        self.attach_result_to_objects(
            ObjectResultLevel.SUCCESS,
            category,
-            object_ids,
+            affected_objects,
            message,
            metadata,
            visual_overrides,
@@ -396,16 +416,25 @@ class AutomationContext:
    def attach_info_to_objects(
        self,
        category: str,
-        object_ids: Union[str, List[str]],
+        affected_objects: Union[Base, List[Base]],
        message: Optional[str] = None,
        metadata: Optional[Dict[str, Any]] = None,
        visual_overrides: Optional[Dict[str, Any]] = None,
    ) -> None:
-        """Add a new info case to the run results."""
+        """Add a new info case to the run results.
+
+        Args:
+            category (str): A short tag for the event type.
+            affected_objects (Union[Base, List[Base]]): A single object or a list of
+                objects that are causing the info case.
+            message (Optional[str]): Optional message.
+            metadata: User provided metadata key value pairs
+            visual_overrides: Case specific 3D visual overrides.
+        """
        self.attach_result_to_objects(
            ObjectResultLevel.INFO,
            category,
-            object_ids,
+            affected_objects,
            message,
            metadata,
            visual_overrides,
@@ -415,19 +444,39 @@ class AutomationContext:
        self,
        level: ObjectResultLevel,
        category: str,
-        object_ids: Union[str, List[str]],
+        affected_objects: Union[Base, List[Base]],
        message: Optional[str] = None,
        metadata: Optional[Dict[str, Any]] = None,
        visual_overrides: Optional[Dict[str, Any]] = None,
    ) -> None:
-        if isinstance(object_ids, list):
-            if len(object_ids) < 1:
+        """Add a new result case to the run results.
+
+        Args:
+            level: Result level.
+            category (str): A short tag for the event type.
+            affected_objects (Union[Base, List[Base]]): A single object or a list of
+                objects that are causing the info case.
+            message (Optional[str]): Optional message.
+            metadata: User provided metadata key value pairs
+            visual_overrides: Case specific 3D visual overrides.
+        """
+        if isinstance(affected_objects, list):
+            if len(affected_objects) < 1:
                raise ValueError(
-                    f"Need atleast one object_id to report a(n) {level.value.upper()}"
+                    f"Need atleast one object to report a(n) {level.value.upper()}"
                )
-            id_list = object_ids
+            object_list = affected_objects
        else:
-            id_list = [object_ids]
+            object_list = [affected_objects]
+
+        ids: Dict[str, Optional[str]] = {}
+        for o in object_list:
+            # validate that the Base.id is not None. If its a None, throw an Exception
+            if not o.id:
+                raise Exception(
+                    f"You can only attach {level} results to objects with an id."
+                )
+            ids[o.id] = o.applicationId
        print(
            f"Created new {level.value.upper()}"
            f" category: {category} caused by: {message}"
@@ -436,7 +485,7 @@ class AutomationContext:
            ResultCase(
                category=category,
                level=level,
-                object_ids=id_list,
+                object_app_ids=ids,
                message=message,
                metadata=metadata,
                visual_overrides=visual_overrides,
@@ -80,7 +80,7 @@ class ResultCase(AutomateBase):

    category: str
    level: ObjectResultLevel
-    object_ids: List[str]
+    object_app_ids: Dict[str, Optional[str]]
    message: Optional[str]
    metadata: Optional[Dict[str, Any]]
    visual_overrides: Optional[Dict[str, Any]]
@@ -0,0 +1,105 @@
+import json
+import time
+import traceback
+from argparse import ArgumentParser
+from os import getenv
+
+from speckleifc.ifc_geometry_processing import open_ifc
+from speckleifc.importer import ImportJob
+from specklepy.core.api.client import SpeckleClient
+from specklepy.core.api.credentials import Account
+from specklepy.core.api.inputs.version_inputs import CreateVersionInput
+from specklepy.core.api.models.current import Version
+from specklepy.core.api.operations import send
+from specklepy.transports.server import ServerTransport
+
+
+def cmd_line_import() -> None:
+    parser = ArgumentParser(
+        prog="speckleifc",
+        description="imports a file",
+    )
+    parser.add_argument("file_path")
+    parser.add_argument("output_path")
+    parser.add_argument("project_id")
+    parser.add_argument("version_message")
+    parser.add_argument("model_id")
+    # parser.add_argument("model_name")
+    # parser.add_argument("region_name")
+
+    args = parser.parse_args()
+
+    TOKEN = getenv("USER_TOKEN")
+    assert TOKEN is not None
+    SERVER_URL = getenv("SPECKLE_SERVER_URL") or "http://127.0.0.1:3000"
+    account = Account.from_token(TOKEN, SERVER_URL)
+
+    try:
+        version = open_and_convert_file(
+            args.file_path,
+            args.project_id,
+            args.version_message,
+            args.model_id,
+            account,
+        )
+        with open(args.output_path, "w") as f:
+            json.dump({"success": True, "commitId": version.id}, f)
+    except Exception as e:
+        error_msg = f"IFC Importer failed with exception:\n{traceback.format_exc()}"
+        print(error_msg)
+
+        # Write error result
+        with open(args.output_path, "w") as f:
+            json.dump({"success": False, "error": str(e)}, f)
+
+
+def open_and_convert_file(
+    file_path: str,
+    project_id: str,
+    version_message: str | None,
+    model_id: str,
+    account: Account,
+) -> Version:
+    start = time.time()
+    very_start = start
+
+    ifc_file = open_ifc(file_path)
+    import_job = ImportJob(ifc_file)
+    data = import_job.convert()
+
+    print(f"File conversion complete after {(time.time() - start) * 1000}ms")
+
+    start = time.time()
+
+    remote_transport = ServerTransport(project_id, account=account)
+
+    root_id = send(data, transports=[remote_transport], use_default_cache=False)
+    print(f"Sending to speckle complete after: {(time.time() - start) * 1000}ms")
+
+    start = time.time()
+    server_url = account.serverInfo.url
+    assert server_url
+    client = SpeckleClient(host=server_url, use_ssl=server_url.startswith("https"))
+    client.authenticate_with_account(account)
+
+    create_version = CreateVersionInput(
+        object_id=root_id,
+        model_id=model_id,
+        project_id=project_id,
+        message=version_message,
+        source_application="IFC",
+    )
+    version = client.version.create(create_version)
+    end = time.time()
+    print(f"Version committed after: {(end - start) * 1000}ms")
+
+    print(f"Total time (to commit): {(end - very_start) * 1000}ms")
+    del ifc_file
+
+    return version
+
+
+if __name__ == "__main__":
+    start = time.time()
+    cmd_line_import()
+    print(f"Total time (including cleanup): {(time.time() - start) * 1000}ms")
@@ -0,0 +1,28 @@
+from typing import cast
+
+from ifcopenshell.entity_instance import entity_instance
+
+from speckleifc.property_extraction import extract_properties
+from specklepy.objects.base import Base
+from specklepy.objects.data_objects import DataObject
+
+
+def data_object_to_speckle(
+    display_value: list[Base],
+    step_element: entity_instance,
+    children: list[Base],
+) -> DataObject:
+    guid = cast(str, step_element.GlobalId)
+    name = cast(str, step_element.Name or guid)
+
+    data_object = DataObject(
+        applicationId=guid,
+        properties=extract_properties(step_element),
+        name=name or guid,
+        displayValue=display_value,
+    )
+
+    data_object["@elements"] = children
+    data_object["ifcType"] = step_element.is_a()
+
+    return data_object
@@ -0,0 +1,130 @@
+from collections import defaultdict
+from collections.abc import Sequence
+from typing import cast
+
+from ifcopenshell.ifcopenshell_wrapper import (
+    Triangulation,
+    TriangulationElement,
+    colour,
+    style,
+)
+
+from speckleifc.render_material_proxy_manager import RenderMaterialProxyManager
+from specklepy.objects.base import Base
+from specklepy.objects.geometry import Mesh
+from specklepy.objects.other import RenderMaterial
+
+
+def geometry_to_speckle(
+    shape: TriangulationElement, render_material_manager: RenderMaterialProxyManager
+) -> list[Base]:
+    geometry = cast(Triangulation, shape.geometry)
+    materials = cast(Sequence[style], geometry.materials)
+    MESH_COUNT = max(len(materials), 1)
+
+    material_ids = cast(Sequence[int], geometry.material_ids)
+    faces = cast(Sequence[int], geometry.faces)
+    verts = cast(Sequence[float], geometry.verts)
+    normals = cast(Sequence[float], geometry.normals)
+
+    FACE_COUNT = len(material_ids)
+
+    if len(faces) != FACE_COUNT * 3 or FACE_COUNT == 0:
+        # Not really expected, but occasionally some meshes fail to triangulate
+        return []
+
+    mapped_meshes = _pre_alloc_mesh_lists(shape, material_ids, MESH_COUNT)
+    for i, mesh in enumerate(mapped_meshes):
+        material = _material_to_speckle(materials[i])
+        render_material_manager.add_mesh_material_mapping(material, mesh)
+
+    mapped_faces_pointers = [0] * MESH_COUNT
+    mapped_vertices_pointers = [0] * MESH_COUNT
+    mapped_index_counters = [0] * MESH_COUNT
+
+    i = 0
+    face_index = 0
+    while i < FACE_COUNT:
+        mesh_index = material_ids[i]
+        mesh: Mesh = mapped_meshes[mesh_index]
+
+        face_ptr = mapped_faces_pointers[mesh_index]
+        vert_ptr = mapped_vertices_pointers[mesh_index]
+
+        # Add triangle
+        mesh.faces[face_ptr] = 3
+        for j in range(3):
+            # Add vert
+            mesh.faces[face_ptr + 1 + j] = mapped_index_counters[mesh_index] + j
+            vert_index = faces[face_index + j] * 3
+            mapped_vert_offset = vert_ptr + (j * 3)
+
+            mesh.vertices[mapped_vert_offset] = verts[vert_index]
+            mesh.vertices[mapped_vert_offset + 1] = verts[vert_index + 1]
+            mesh.vertices[mapped_vert_offset + 2] = verts[vert_index + 2]
+
+            mesh.vertexNormals[mapped_vert_offset] = normals[vert_index]
+            mesh.vertexNormals[mapped_vert_offset + 1] = normals[vert_index + 1]
+            mesh.vertexNormals[mapped_vert_offset + 2] = normals[vert_index + 2]
+
+        i += 1
+        face_index += 3  # number of items in the faces list we just jumped over
+
+        mapped_index_counters[mesh_index] += (
+            3  # number of verts we just added to the mesh.vertices i.e. the next index
+        )
+        mapped_faces_pointers[mesh_index] += (
+            4  # number of item's we've just added to the mesh.faces list
+        )
+        mapped_vertices_pointers[mesh_index] += (
+            9  # number of item's we've just added to the mesh.vertices list
+        )
+
+    return mapped_meshes  # type: ignore
+
+
+def _material_to_speckle(material: style) -> RenderMaterial:
+    return RenderMaterial(
+        applicationId=material.calc_hash(),
+        name=material.name,
+        diffuse=_color_to_argb(material.diffuse),
+        opacity=1 - material.transparency if material.has_transparency() else 1,
+    )
+
+
+def _color_to_argb(colour: colour) -> int:
+    # Clamp values to [0, 1] and convert to 0–255
+    a_int = 255
+    r_int = max(0, min(255, int(round(colour.r() * 255))))
+    g_int = max(0, min(255, int(round(colour.g() * 255))))
+    b_int = max(0, min(255, int(round(colour.b() * 255))))
+
+    return (a_int << 24) | (r_int << 16) | (g_int << 8) | b_int
+
+
+def _pre_alloc_mesh_lists(
+    shape: TriangulationElement, material_ids: Sequence[int], MESH_COUNT: int
+) -> list[Mesh]:
+    """
+    This is a performance optimisation to pre-size the lists
+    since we're expecting potential hundreds of thousands of verts in a single model
+    This is very much in the hot path, so worth the extra bit of convoluted logic
+    """
+    appId = cast(str, shape.guid)
+
+    material_face_counts = defaultdict(int)
+    for mat_id in material_ids:
+        material_face_counts[mat_id] += 1
+
+    meshes = []
+    for mat_id in range(MESH_COUNT):
+        face_count = material_face_counts.get(mat_id, 0)
+        mesh = Mesh(
+            units="m",
+            vertices=[-1] * (face_count * 9),
+            vertexNormals=[-1] * (face_count * 9),
+            faces=[-1] * (face_count * 4),  # 1 marker + 3 vertex indices
+            applicationId=f"{appId}_mat{mat_id}",
+        )
+        meshes.append(mesh)
+    return meshes
@@ -0,0 +1,23 @@
+from typing import cast
+
+from ifcopenshell.entity_instance import entity_instance
+
+from specklepy.objects.base import Base
+from specklepy.objects.models.collections.collection import Collection
+
+
+def project_to_speckle(
+    step_element: entity_instance, children: list[Base]
+) -> Collection:
+    guid = cast(str, step_element.GlobalId)
+    name = cast(str, step_element.Name or step_element.LongName or guid)
+
+    project = Collection(applicationId=guid, name=name, elements=children)
+
+    project["ifcType"] = step_element.is_a()
+    project["description"] = step_element.Description
+    project["objectType"] = step_element.ObjectType
+    project["longName"] = step_element.LongName
+    project["phase"] = step_element.Phase
+
+    return project
@@ -0,0 +1,42 @@
+from typing import cast
+
+from ifcopenshell.entity_instance import entity_instance
+
+from speckleifc.property_extraction import extract_properties
+from specklepy.objects.base import Base
+from specklepy.objects.data_objects import DataObject
+from specklepy.objects.models.collections.collection import Collection
+
+
+def spatial_element_to_speckle(
+    display_value: list[Base],
+    step_element: entity_instance,
+    relational_children: list[Base],
+) -> Collection:
+    direct_geometry = _convert_as_data_object(display_value, step_element)
+    all_children = [direct_geometry] + relational_children
+
+    guid = cast(str, step_element.GlobalId)
+    name = cast(str, step_element.Name or step_element.LongName or guid)
+
+    data_object = Collection(applicationId=guid, name=name, elements=all_children)
+    data_object["ifcType"] = step_element.is_a()
+
+    return data_object
+
+
+def _convert_as_data_object(
+    display_value: list[Base], step_element: entity_instance
+) -> DataObject:
+    guid = cast(str, step_element.GlobalId)
+    name = cast(str, step_element.Name or step_element.LongName or guid)
+    data_object = DataObject(
+        applicationId=guid,
+        properties=extract_properties(step_element),
+        name=name,
+        displayValue=display_value,
+    )
+
+    data_object["ifcType"] = step_element.is_a()
+
+    return data_object
@@ -0,0 +1,45 @@
+import multiprocessing
+
+from ifcopenshell import file, ifcopenshell_wrapper, open, sqlite
+from ifcopenshell.geom import iterator, settings
+
+from specklepy.logging.exceptions import SpeckleException
+
+
+def _create_iterator_settings() -> settings:
+    ifc_settings = settings()
+    # triangles for now, speckle does support n-gons, but may be less performant
+    ifc_settings.set("triangulation-type", ifcopenshell_wrapper.TRIANGLE_MESH)
+    # no need to weld verts
+    ifc_settings.set("weld-vertices", False)
+    # Speckle meshes are all in world coords
+    ifc_settings.set("use-world-coords", True)
+    # Tiny performance improvement,
+    ifc_settings.set("no-wire-intersection-check", True)
+    # Rendermaterials inherit the material names instead of type + unique id
+    ifc_settings.set("use-material-names", True)
+
+    # IfcOpenshell defaults to 0.001mm here, which leads to very dense meshes.
+    # lowering the mesh quality a bit here leads to meshes
+    # that are still much higher quality than webifc
+
+    # We still need to experiment with the affect on memory usage
+    # It may be desirable to lower this further, and increase the angular deflection
+    # to compensate. This would allow large meshes to be lower quality,
+    # while keeping small meshes relatively similar.
+    ifc_settings.set("mesher-linear-deflection", 0.2)
+
+    return ifc_settings
+
+
+def open_ifc(file_path: str) -> file:
+    ifc_file = open(file_path)
+
+    if isinstance(ifc_file, file):
+        return ifc_file
+    else:
+        raise SpeckleException(f"file at {file_path} is not a compatible ifc file type")
+
+
+def create_geometry_iterator(ifc_file: file | sqlite) -> iterator:
+    return iterator(_create_iterator_settings(), ifc_file, multiprocessing.cpu_count())
@@ -0,0 +1,31 @@
+from collections.abc import Generator, Iterable
+from itertools import chain
+from typing import cast
+
+from ifcopenshell.entity_instance import entity_instance
+
+
+def get_children(step_element: entity_instance) -> Generator[entity_instance]:
+    yield from chain(
+        get_spatial_children(step_element), get_aggregate_children(step_element)
+    )
+
+
+def get_spatial_children(step_element: entity_instance) -> Generator[entity_instance]:
+    spatial_relations = cast(
+        Iterable[entity_instance] | None,
+        getattr(step_element, "ContainsElements", None),
+    )
+    if spatial_relations is not None:
+        for relation in spatial_relations:
+            yield from cast(Iterable[entity_instance], relation.RelatedElements)
+
+
+def get_aggregate_children(step_element: entity_instance) -> Generator[entity_instance]:
+    aggregate_relations = cast(
+        Iterable[entity_instance] | None,
+        getattr(step_element, "IsDecomposedBy", None),
+    )
+    if aggregate_relations is not None:
+        for relation in aggregate_relations:
+            yield from cast(Iterable[entity_instance], relation.RelatedObjects)
@@ -0,0 +1,104 @@
+import time
+from dataclasses import dataclass, field
+from typing import cast
+
+from ifcopenshell.entity_instance import entity_instance
+from ifcopenshell.geom import file
+from ifcopenshell.ifcopenshell_wrapper import TriangulationElement
+
+from speckleifc.converter.data_object_converter import data_object_to_speckle
+from speckleifc.converter.geometry_converter import geometry_to_speckle
+from speckleifc.converter.project_converter import project_to_speckle
+from speckleifc.converter.spatial_element_converter import spatial_element_to_speckle
+from speckleifc.ifc_geometry_processing import create_geometry_iterator
+from speckleifc.ifc_openshell_helpers import get_children
+from speckleifc.render_material_proxy_manager import RenderMaterialProxyManager
+from specklepy.logging.exceptions import SpeckleException
+from specklepy.objects import Base
+
+
+@dataclass
+class ImportJob:
+    ifc_file: file
+    cached_display_values: dict[int, list[Base]] = field(default_factory=dict)  # noqa: F821
+    _render_material_manager: RenderMaterialProxyManager = field(
+        default_factory=lambda: RenderMaterialProxyManager()
+    )
+    geometries_count: int = 0
+    geometries_used: int = 0
+
+    def convert_element(self, step_element: entity_instance) -> Base:
+        children = self._convert_children(step_element)
+        display_value = self.cached_display_values.get(step_element.id(), [])
+
+        if display_value is not None:
+            self.geometries_used += 1
+
+        if step_element.is_a("IfcProject"):
+            return project_to_speckle(step_element, children)
+        elif step_element.is_a("IfcSpatialStructureElement"):
+            return spatial_element_to_speckle(display_value, step_element, children)
+        else:
+            return data_object_to_speckle(display_value, step_element, children)
+
+    def _convert_children(self, step_element: entity_instance) -> list[Base]:
+        return [
+            self.convert_element(i)
+            for i in get_children(step_element)
+            if self._should_convert(i)
+        ]
+
+    @staticmethod
+    def _should_convert(step_element: entity_instance) -> bool:
+        # We only consider IfcRoot objects convertible
+        # This is the super class for root level entities that have a GUID...
+        # This will ignore some types like IfcGridAxis
+        s = step_element.is_a("IfcRoot")
+        if not s:
+            print(
+                f"Skipping #{step_element.id()} because it's type ({step_element.is_a()}) it not an IfcRoot"  # noqa: E501
+            )
+        return s
+
+    def convert(self) -> Base:
+        start = time.time()
+        self.pre_process_geometry()
+        print(f"Geometry conversion complete after {(time.time() - start) * 1000}ms")
+        print(f"Created {self.geometries_count} geometries")
+
+        start = time.time()
+        root = self._convert_project_tree()
+        print(f"Object tree conversion complete after {(time.time() - start) * 1000}ms")
+        print(f"Used {self.geometries_used} geometries")
+        return root
+
+    def pre_process_geometry(self) -> None:
+        iterator = create_geometry_iterator(self.ifc_file)
+        if not iterator.initialize():
+            raise SpeckleException(
+                "geometry iterator failed to initialize for the given file"
+            )
+        self.geometries_count = 0
+        while True:
+            shape = cast(TriangulationElement, iterator.get())
+            self.geometries_count += 1
+            id = cast(int, shape.id)
+
+            display_value = geometry_to_speckle(shape, self._render_material_manager)
+            self.cached_display_values[id] = display_value
+
+            if not iterator.next():
+                break
+
+    def _convert_project_tree(self) -> Base:
+        projects = self.ifc_file.by_type("IfcProject", False)
+        if len(projects) != 1:
+            raise SpeckleException("Expected exactly one IfcProject in file")
+        project = projects[0]
+
+        tree = self.convert_element(project)
+        tree["renderMaterialProxies"] = list(
+            self._render_material_manager.render_material_proxies.values()
+        )
+
+        return tree
@@ -0,0 +1,621 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
@@ -0,0 +1,30 @@
+# Third-Party Licenses
+
+This directory contains license files for third-party dependencies used by specklepy.
+
+## IfcOpenShell
+
+IfcOpenShell is an optional dependency available through the `speckleifc` extra:
+
+```bash
+pip install specklepy[speckleifc]
+```
+
+IfcOpenShell is dual-licensed under:
+
+- **LGPL-3.0** (`IfcOpenShell-LGPL-3.0.txt`) - GNU Lesser General Public License v3.0
+- **GPL-3.0** (`IfcOpenShell-GPL-3.0.txt`) - GNU General Public License v3.0
+
+### About IfcOpenShell
+
+IfcOpenShell is an open source software library for working with Industry Foundation Classes (IFC). It provides complete parsing support for IFC2x3 TC1, IFC4 Add2 TC1, IFC4x1, IFC4x2, and IFC4x3 Add2.
+
+- **Project**: https://github.com/IfcOpenShell/IfcOpenShell
+- **Documentation**: https://docs.ifcopenshell.org/
+- **License**: LGPL-3.0-or-later, GPL-3.0-or-later
+
+When using specklepy with IfcOpenShell, you must comply with the terms of these licenses.
+
+## License Compatibility
+
+specklepy is licensed under Apache-2.0, which is compatible with LGPL-3.0 for dynamic linking scenarios (which is how IfcOpenShell is used as an optional dependency).
@@ -0,0 +1,99 @@
+from typing import Any
+
+from ifcopenshell.entity_instance import entity_instance
+from ifcopenshell.util.element import get_type
+
+from speckleifc.qtos_only import get_quantities
+
+
+def extract_properties(element: entity_instance) -> dict[str, object]:
+    properties: dict[str, object] = {
+        "Attributes": _get_attributes(element),
+        "Property Sets": _get_ifc_object_properties(element),
+    }
+
+    # Add quantities if they exist
+    quantities = get_quantities(element)
+    if quantities:
+        properties["Quantities"] = quantities
+
+    if (ifc_type := get_type(element)) is not None:
+        properties["Element Type Property Sets"] = _get_ifc_element_type_properties(
+            ifc_type,
+        )
+        properties["Element Type Attributes"] = _get_attributes(
+            ifc_type,
+        )
+
+    return properties
+
+
+def _get_attributes(element: entity_instance) -> dict[str, object]:
+    return element.get_info(True, False, scalar_only=True)
+
+
+def _get_ifc_element_type_properties(element: entity_instance) -> dict[str, object]:
+    result: dict[str, object] = {}
+    for definition in element.HasPropertySets or []:
+        if not definition.is_a("IfcPropertySet"):
+            continue
+
+        result[definition.Name] = _get_properties(definition.HasProperties)
+    return result
+
+
+def _get_ifc_object_properties(element: entity_instance) -> dict[str, object]:
+    result: dict[str, object] = {}
+
+    for rel in getattr(element, "IsDefinedBy", []):
+        if not rel.is_a("IfcRelDefinesByProperties"):
+            continue
+
+        definition: entity_instance | None = rel.RelatingPropertyDefinition
+        if not definition:
+            continue
+
+        if not definition.is_a("IfcPropertySet"):
+            continue
+
+        set_name = definition.Name
+        properties = _get_properties(definition.HasProperties)
+
+        if properties:
+            result[set_name] = properties
+
+    return result
+
+
+def _get_properties(properties: entity_instance) -> dict[str, Any]:
+    """
+    There already exists a canonical way to get properties
+    `ifcopenshell.util.element.get_properties` but it's very verbose
+    and we don't want to bloat our selves with supporting complex property types
+
+    This is a slimmed down version, only supporting a couple of property types
+    """
+    result: dict[str, Any] = {}
+
+    for prop in properties:
+        name = prop.Name
+        if prop.is_a("IfcPropertySingleValue"):
+            val = prop.NominalValue
+            if val is not None:
+                result[name] = val.wrappedValue if hasattr(val, "wrappedValue") else val
+        elif prop.is_a("IfcPropertyListValue"):
+            values = getattr(prop, "ListValues", None)
+            if values:
+                result[name] = [
+                    v.wrappedValue if hasattr(v, "wrappedValue") else v for v in values
+                ]
+        elif prop.is_a("IfcPropertyEnumeratedValue"):
+            values = getattr(prop, "EnumerationValues", None)
+            if values:
+                result[name] = [
+                    v.wrappedValue if hasattr(v, "wrappedValue") else v for v in values
+                ]
+
+        # elif prop.is_a("IfcPropertyTableValue"):
+        #     properties[name] = #not sure if we want to support these...
+    return result
@@ -0,0 +1,106 @@
+from typing import Any
+
+from ifcopenshell.entity_instance import entity_instance
+from ifcopenshell.util.unit import get_full_unit_name, get_project_unit
+
+# Module-level constants for units
+UNIT_MAPPING = {
+    "IfcQuantityLength": "LENGTHUNIT",
+    "IfcQuantityArea": "AREAUNIT", 
+    "IfcQuantityVolume": "VOLUMEUNIT",
+    "IfcQuantityCount": None,  # Count quantities have no units
+    "IfcQuantityWeight": "MASSUNIT",
+    "IfcQuantityTime": "TIMEUNIT"
+}
+
+
+def _get_unit_info(element: entity_instance, quantity) -> dict[str, str]:
+    """Get unit information for a quantity."""
+    try:
+        # Early return for count quantities - they don't have units
+        quantity_type = quantity.is_a()
+        if quantity_type == "IfcQuantityCount":
+            return {}
+            
+        if quantity.Unit is not None:
+            # Quantity has its own unit
+            try:
+                unit_name = get_full_unit_name(quantity.Unit)
+                formatted_unit_name = unit_name.replace("_", " ").title() if unit_name else ""
+                return {"units": formatted_unit_name}
+            except:
+                return {"units": str(quantity.Unit)}
+        else:
+            # Fall back to project unit based on quantity type
+            unit_type = UNIT_MAPPING.get(quantity_type)
+            if not unit_type:
+                return {}
+                
+            # Get the project unit for this unit type
+            project_unit = get_project_unit(element.file, unit_type, use_cache=True)
+            if not project_unit:
+                return {}
+                
+            # Get unit name and format
+            unit_name = get_full_unit_name(project_unit)
+            formatted_unit_name = unit_name.replace("_", " ").title() if unit_name else ""
+            
+            return {"units": formatted_unit_name}
+    except Exception:
+        # If anything fails, return empty dict
+        return {}
+
+
+def _get_quantities(quantities: list[entity_instance], element: entity_instance) -> dict[str, Any]:
+    """Extract quantity values from IfcPhysicalQuantity entities."""
+    results = {}
+    for quantity in quantities or []:
+        quantity_name = quantity.Name
+        quantity_type = quantity.is_a()  # Cache the type check
+        
+        if quantity_type == "IfcPhysicalSimpleQuantity":
+            # Get the quantity value (3rd attribute for simple quantities)
+            value = getattr(quantity, quantity.attribute_name(3))
+            unit_info = _get_unit_info(element, quantity)
+            
+            if unit_info:
+                # Create structured quantity object with units
+                results[quantity_name] = {
+                    "name": quantity_name,
+                    "value": value,
+                    **unit_info,
+                }
+            else:
+                # No unit info available, keep as simple value with name
+                results[quantity_name] = {"name": quantity_name, "value": value}
+            
+        elif quantity_type == "IfcPhysicalComplexQuantity":
+            # Handle complex quantities
+            data = {k: v for k, v in quantity.get_info().items() if v is not None and k != "Name"}
+            data["properties"] = _get_quantities(quantity.HasQuantities, element)
+            del data["HasQuantities"]
+            results[quantity_name] = data
+    return results
+
+
+def get_quantities(element: entity_instance) -> dict[str, object]:
+    """
+    Extract quantity takeoffs (QTOs) from an IFC element with unit information.
+    """
+    qtos = {}
+    
+    # Handle elements with IsDefinedBy relationship  
+    if element.IsDefinedBy:
+        for relationship in element.IsDefinedBy:
+            if relationship.is_a("IfcRelDefinesByProperties"):
+                definition = relationship.RelatingPropertyDefinition
+                if definition.is_a("IfcElementQuantity"):
+                    try:
+                        quantities_data = _get_quantities(definition.Quantities, element)
+                        quantities_data["id"] = definition.id()
+                        qtos[definition.Name] = quantities_data
+                    except (KeyError, AttributeError):
+                        # If entity access fails, skip this quantity set
+                        continue
+    
+    return qtos
@@ -0,0 +1,110 @@
+from typing import Any
+
+from ifcopenshell.entity_instance import entity_instance
+from ifcopenshell.util.element import get_psets
+from ifcopenshell.util.unit import get_full_unit_name, get_project_unit
+
+
+def _format_unit_name(unit_name: str) -> str:
+    """
+    Convert IFC unit names to user-friendly format.
+    """
+    if not unit_name:
+        return ""
+
+    # Convert underscore-separated words to space-separated and title case
+    return unit_name.replace("_", " ").title()
+
+
+def _get_unit_info(element: entity_instance, quantity_type: str) -> dict[str, str]:
+    """
+    Get unit information for a given quantity type from the IFC project.
+    """
+    try:
+        # Map IFC quantity types to unit types
+        unit_type_mapping = {
+            "IfcQuantityLength": "LENGTHUNIT",
+            "IfcQuantityArea": "AREAUNIT",
+            "IfcQuantityVolume": "VOLUMEUNIT",
+            "IfcQuantityCount": None,  # Count quantities typically have no units
+            "IfcQuantityWeight": "MASSUNIT",
+            "IfcQuantityTime": "TIMEUNIT",
+        }
+
+        unit_type = unit_type_mapping.get(quantity_type)
+        if not unit_type:
+            return {}
+
+        # Get the project unit for this unit type (with built-in caching)
+        project_unit = get_project_unit(element.file, unit_type, use_cache=True)
+        if not project_unit:
+            return {}
+
+        # Get unit name
+        unit_name = get_full_unit_name(project_unit)
+
+        # Format the unit name to be user-friendly
+        formatted_unit_name = _format_unit_name(unit_name)
+
+        return {"units": formatted_unit_name}
+    except Exception:
+        # If anything fails, return empty dict to maintain robustness
+        return {}
+
+
+def get_quantities(element: entity_instance) -> dict[str, object]:
+    """
+    Extract quantity takeoffs (QTOs) from an IFC element with unit information.
+    """
+    # Get basic quantities using existing utility
+    quantities = get_psets(element, qtos_only=True, should_inherit=False)
+    if not quantities:
+        return {}
+
+    # Enhance each QTO pset with unit information
+    enhanced_quantities = {}
+
+    for pset_name, pset_data in quantities.items():
+        if not isinstance(pset_data, dict) or "id" not in pset_data:
+            # Fallback for unexpected data structure
+            enhanced_quantities[pset_name] = pset_data
+            continue
+
+        try:
+            # Get the actual IfcElementQuantity entity
+            pset_entity = element.file.by_id(pset_data["id"])
+
+            # Transform quantities to include unit information
+            enhanced_pset = {"id": pset_data["id"]}
+
+            # Create mapping of quantity names to their IFC entities for unit lookup
+            quantity_entities = {
+                q.Name: q for q in pset_entity.Quantities if hasattr(q, "Name")
+            }
+
+            for qty_name, qty_value in pset_data.items():
+                if qty_name == "id":
+                    continue
+
+                # Get the IFC quantity entity for unit information
+                qty_entity = quantity_entities[qty_name]
+                unit_info = _get_unit_info(element, qty_entity.is_a())
+
+                if unit_info:
+                    # Create structured quantity object with units
+                    enhanced_pset[qty_name] = {
+                        "name": qty_name,
+                        "value": qty_value,
+                        **unit_info,
+                    }
+                else:
+                    # No unit info available, keep as simple value with name
+                    enhanced_pset[qty_name] = {"name": qty_name, "value": qty_value}
+
+            enhanced_quantities[pset_name] = enhanced_pset
+
+        except (KeyError, AttributeError):
+            # If entity access fails, use original data as fallback
+            enhanced_quantities[pset_name] = pset_data
+
+    return enhanced_quantities
@@ -0,0 +1,28 @@
+from specklepy.objects.geometry import Mesh
+from specklepy.objects.other import RenderMaterial
+from specklepy.objects.proxies import RenderMaterialProxy
+
+
+class RenderMaterialProxyManager:
+    def __init__(self):
+        self._render_material_proxies: dict[str, RenderMaterialProxy] = {}
+
+    @property
+    def render_material_proxies(self):
+        return self._render_material_proxies
+
+    def add_mesh_material_mapping(
+        self, render_material: RenderMaterial, mesh: Mesh
+    ) -> None:
+        material_id = render_material.applicationId
+        assert material_id is not None
+        mesh_id = mesh.applicationId
+        assert mesh_id is not None
+
+        proxy = self._render_material_proxies.get(material_id, None)
+        if proxy is not None:
+            proxy.objects.append(mesh_id)
+        else:
+            self._render_material_proxies[material_id] = RenderMaterialProxy(
+                objects=[mesh_id], value=render_material
+            )
@@ -10,6 +10,7 @@ from specklepy.api.resources import (
    ServerResource,
    SubscriptionResource,
    VersionResource,
+    WorkspaceResource,
 )
 from specklepy.core.api.client import SpeckleClient as CoreSpeckleClient
 from specklepy.logging import metrics
@@ -111,6 +112,12 @@ class SpeckleClient(CoreSpeckleClient):
            client=self.httpclient,
            server_version=server_version,
        )
+        self.workspace = WorkspaceResource(
+            account=self.account,
+            basepath=self.url,
+            client=self.httpclient,
+            server_version=server_version,
+        )
        self.subscription = SubscriptionResource(
            account=self.account,
            basepath=self.ws_url,
@@ -8,6 +8,7 @@ from specklepy.api.resources.current.project_resource import ProjectResource
 from specklepy.api.resources.current.server_resource import ServerResource
 from specklepy.api.resources.current.subscription_resource import SubscriptionResource
 from specklepy.api.resources.current.version_resource import VersionResource
+from specklepy.api.resources.current.workspace_resource import WorkspaceResource

 __all__ = [
    "ActiveUserResource",
@@ -18,4 +19,5 @@ __all__ = [
    "ServerResource",
    "SubscriptionResource",
    "VersionResource",
+    "WorkspaceResource",
 ]
@@ -1,12 +1,22 @@
 from typing import List, Optional

-from specklepy.core.api.inputs.user_inputs import UserProjectsFilter, UserUpdateInput
+from specklepy.core.api.inputs.user_inputs import (
+    UserProjectsFilter,
+    UserUpdateInput,
+    UserWorkspacesFilter,
+)
 from specklepy.core.api.models import (
    PendingStreamCollaborator,
    Project,
    ResourceCollection,
    User,
 )
+from specklepy.core.api.models.current import (
+    LimitedWorkspace,
+    PermissionCheckResult,
+    ProjectWithPermissions,
+    Workspace,
+)
 from specklepy.core.api.resources import ActiveUserResource as CoreResource
 from specklepy.logging import metrics

@@ -46,8 +56,47 @@ class ActiveUserResource(CoreResource):
        metrics.track(metrics.SDK, self.account, {"name": "Active User Get Projects"})
        return super().get_projects(limit=limit, cursor=cursor, filter=filter)

+    def get_projects_with_permissions(
+        self,
+        *,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[UserProjectsFilter] = None,
+    ) -> ResourceCollection[ProjectWithPermissions]:
+        metrics.track(
+            metrics.SDK,
+            self.account,
+            {"name": "Active User Get Projects With Permissions"},
+        )
+        return super().get_projects_with_permissions(
+            limit=limit, cursor=cursor, filter=filter
+        )
+
    def get_project_invites(self) -> List[PendingStreamCollaborator]:
        metrics.track(
            metrics.SDK, self.account, {"name": "Active User Get Project Invites"}
        )
        return super().get_project_invites()
+
+    def can_create_personal_projects(self) -> PermissionCheckResult:
+        metrics.track(
+            metrics.SDK,
+            self.account,
+            {"name": "Active User Can Create Personal Projects Check"},
+        )
+        return super().can_create_personal_projects()
+
+    def get_workspaces(
+        self,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[UserWorkspacesFilter] = None,
+    ) -> ResourceCollection[Workspace]:
+        metrics.track(metrics.SDK, self.account, {"name": "Active User Get Workspaces"})
+        return super().get_workspaces(limit, cursor, filter)
+
+    def get_active_workspace(self) -> Optional[LimitedWorkspace]:
+        metrics.track(
+            metrics.SDK, self.account, {"name": "Active User Get Active Workspace"}
+        )
+        return super().get_active_workspace()
@@ -5,8 +5,14 @@ from specklepy.core.api.inputs.project_inputs import (
    ProjectModelsFilter,
    ProjectUpdateInput,
    ProjectUpdateRoleInput,
+    WorkspaceProjectCreateInput,
 )
-from specklepy.core.api.models import Project, ProjectWithModels, ProjectWithTeam
+from specklepy.core.api.models import (
+    Project,
+    ProjectWithModels,
+    ProjectWithTeam,
+)
+from specklepy.core.api.models.current import ProjectPermissionChecks
 from specklepy.core.api.resources import ProjectResource as CoreResource
 from specklepy.logging import metrics

@@ -26,6 +32,12 @@ class ProjectResource(CoreResource):
        metrics.track(metrics.SDK, self.account, {"name": "Project Get "})
        return super().get(project_id)

+    def get_permissions(self, project_id: str) -> ProjectPermissionChecks:
+        metrics.track(
+            metrics.SDK, self.account, {"name": "Project Project Permissions "}
+        )
+        return super().get_permissions(project_id)
+
    def get_with_models(
        self,
        project_id: str,
@@ -50,6 +62,10 @@ class ProjectResource(CoreResource):
        metrics.track(metrics.SDK, self.account, {"name": "Project Create"})
        return super().create(input)

+    def create_in_workspace(self, input: WorkspaceProjectCreateInput) -> Project:
+        metrics.track(metrics.SDK, self.account, {"name": "Workspace Project Create"})
+        return super().create_in_workspace(input)
+
    def update(self, input: ProjectUpdateInput) -> Project:
        metrics.track(metrics.SDK, self.account, {"name": "Project Update"})
        return super().update(input)
@@ -0,0 +1,53 @@
+from typing import Optional
+
+from specklepy.core.api.inputs.project_inputs import WorksaceProjectsFilter
+from specklepy.core.api.models.current import (
+    Project,
+    ProjectWithPermissions,
+    ResourceCollection,
+    Workspace,
+)
+from specklepy.core.api.resources import WorkspaceResource as CoreResource
+from specklepy.logging import metrics
+
+
+class WorkspaceResource(CoreResource):
+    """API Access class for workspace"""
+
+    def __init__(self, account, basepath, client, server_version) -> None:
+        super().__init__(
+            account=account,
+            basepath=basepath,
+            client=client,
+            server_version=server_version,
+        )
+
+    def get(self, workspace_id: str) -> Workspace:
+        metrics.track(metrics.SDK, self.account, {"name": "Workspace Get"})
+        return super().get(workspace_id)
+
+    def get_projects(
+        self,
+        workspace_id: str,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[WorksaceProjectsFilter] = None,
+    ) -> ResourceCollection[Project]:
+        metrics.track(metrics.SDK, self.account, {"name": "Workspace Get Projects"})
+        return super().get_projects(workspace_id, limit, cursor, filter)
+
+    def get_projects_with_permissions(
+        self,
+        workspace_id: str,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[WorksaceProjectsFilter] = None,
+    ) -> ResourceCollection[ProjectWithPermissions]:
+        metrics.track(
+            metrics.SDK,
+            self.account,
+            {"name": "Workspace Get Projects With Permissions"},
+        )
+        return super().get_projects_with_permissions(
+            workspace_id, limit, cursor, filter
+        )
@@ -18,6 +18,7 @@ from specklepy.core.api.resources import (
    ServerResource,
    SubscriptionResource,
    VersionResource,
+    WorkspaceResource,
 )
 from specklepy.logging import metrics
 from specklepy.logging.exceptions import SpeckleException, SpeckleWarning
@@ -223,6 +224,12 @@ class SpeckleClient:
            client=self.httpclient,
            server_version=server_version,
        )
+        self.workspace = WorkspaceResource(
+            account=self.account,
+            basepath=self.url,
+            client=self.httpclient,
+            server_version=server_version,
+        )
        self.subscription = SubscriptionResource(
            account=self.account,
            basepath=self.ws_url,
@@ -0,0 +1,70 @@
+from datetime import datetime
+from typing import List
+
+import httpx
+from pydantic import AliasGenerator, BaseModel, ConfigDict, HttpUrl
+from pydantic.alias_generators import to_pascal
+
+
+class ConnectorFeedBaseModel(BaseModel):
+    """
+    Parent class for all Connector Feed Object Model classes
+    Sets-up a pydantic config to serialize properties using a pascal case alias
+    """
+
+    model_config = ConfigDict(
+        alias_generator=AliasGenerator(
+            validation_alias=to_pascal,
+        ),
+        populate_by_name=True,
+    )
+
+
+class ConnectorVersion(ConnectorFeedBaseModel):
+    number: str
+    url: HttpUrl
+    os: int  # this is an enum, it's properly defined in the old v2 SDK (used by Speckle.Manager.Feed)  # noqa: E501
+    architecture: int  # These are enums, they are properly defined in the old v2 SDK (used by Speckle.Manager.Feed) # noqa: E501
+    date: datetime
+    prerelease: bool
+
+
+class ConnectorVersions(ConnectorFeedBaseModel):
+    versions: List[ConnectorVersion]
+
+
+def get_latest_version(host_app_slug: str, allow_pre_release: bool) -> ConnectorVersion:
+    """
+    Fetches the JSON feed for the given connector slug and
+    Returns the latest version by date - Note, it does not consider semvers!
+
+    Arguments:
+        host_app_slug {str} -- the host app slug to query for
+        allow_pre_release {bool} -- if false, only stable releases will be considered
+    Raises:
+        HTTPStatusError: if http request failed
+        ValidationError: response was not valid json
+        ValueError: The feed contained no connector versions
+    """
+    connector_versions = get_connector_versions(host_app_slug).versions
+    filtered_versions = [
+        v for v in connector_versions if allow_pre_release or not v.prerelease
+    ]
+
+    return max(filtered_versions, key=lambda x: x.date)
+
+
+def get_connector_versions(host_app_slug: str) -> ConnectorVersions:
+    """
+    Fetches the JSON feed for the given slug (v3 feeds only)
+    Raises:
+        HTTPStatusError: if http request failed
+        ValidationError: response was not valid json
+    """
+    url = f"https://releases.speckle.dev/manager2/feeds/{host_app_slug.lower()}-v3.json"
+
+    res = httpx.get(url).raise_for_status()
+
+    feed_data = ConnectorVersions.model_validate_json(res.text)
+
+    return feed_data
@@ -2,9 +2,12 @@ from enum import Enum


 class ProjectVisibility(str, Enum):
+    """Supported project visibility types"""
+
    PRIVATE = "PRIVATE"
    PUBLIC = "PUBLIC"
    UNLISTED = "UNLISTED"
+    WORKSPACE = "WORKSPACE"


 class UserProjectsUpdatedMessageType(str, Enum):
@@ -10,6 +10,13 @@ class ProjectCreateInput(GraphQLBaseModel):
    visibility: Optional[ProjectVisibility]


+class WorkspaceProjectCreateInput(GraphQLBaseModel):
+    name: Optional[str]
+    description: Optional[str]
+    visibility: Optional[ProjectVisibility]
+    workspaceId: str
+
+
 class ProjectInviteCreateInput(GraphQLBaseModel):
    email: Optional[str]
    role: Optional[str]
@@ -44,3 +51,12 @@ class ProjectUpdateRoleInput(GraphQLBaseModel):
    user_id: str
    project_id: str
    role: Optional[str]
+
+
+class WorksaceProjectsFilter(GraphQLBaseModel):
+    search: Optional[str]
+    """Filter out projects by name"""
+    with_project_role_only: Optional[bool]
+    """
+    Only return workspace projects that the active user has an explicit project role in
+    """
@@ -11,5 +11,12 @@ class UserUpdateInput(GraphQLBaseModel):


 class UserProjectsFilter(GraphQLBaseModel):
-    search: str
+    search: Optional[str] = None
    only_with_roles: Optional[Sequence[str]] = None
+    workspace_id: Optional[str] = None
+    personal_only: Optional[bool] = None
+    include_implicit_access: Optional[bool] = None
+
+
+class UserWorkspacesFilter(GraphQLBaseModel):
+    search: Optional[str]
@@ -8,6 +8,7 @@ from specklepy.core.api.models.current import (
    ProjectCollaborator,
    ProjectCommentCollection,
    ProjectWithModels,
+    ProjectWithPermissions,
    ProjectWithTeam,
    ResourceCollection,
    ServerConfiguration,
@@ -39,6 +40,7 @@ __all__ = [
    "ModelWithVersions",
    "Project",
    "ProjectWithModels",
+    "ProjectWithPermissions",
    "ProjectWithTeam",
    "ProjectCommentCollection",
    "UserSearchResultCollection",
@@ -3,6 +3,7 @@ from typing import Generic, List, Optional, TypeVar

 from specklepy.core.api.enums import ProjectVisibility
 from specklepy.core.api.models.graphql_base_model import GraphQLBaseModel
+from specklepy.logging.exceptions import WorkspacePermissionException

 T = TypeVar("T")

@@ -52,6 +53,10 @@ class ServerConfiguration(GraphQLBaseModel):
    object_size_limit_bytes: int


+class ServerWorkspacesInfo(GraphQLBaseModel):
+    workspaces_enabled: bool
+
+
 # Keeping this one all Optionals at the minute,
 #  because its used both as a deserialization model for GQL and Account Management
 class ServerInfo(GraphQLBaseModel):
@@ -61,13 +66,11 @@ class ServerInfo(GraphQLBaseModel):
    admin_contact: Optional[str] = None
    description: Optional[str] = None
    canonical_url: Optional[str] = None
-    roles: Optional[List[dict]] = None
    scopes: Optional[List[dict]] = None
    auth_strategies: Optional[List[dict]] = None
    version: Optional[str] = None
-    frontend2: Optional[bool] = None
    migration: Optional[ServerMigration] = None
-
+    workspaces: Optional[ServerWorkspacesInfo] = None
    # TODO separate gql model from account management model


@@ -129,7 +132,8 @@ class Version(GraphQLBaseModel):
    id: str
    message: Optional[str]
    preview_url: str
-    referenced_object: str
+    referenced_object: Optional[str]
+    """Maybe null if workspaces version history limit has been exceeded"""
    source_application: Optional[str]


@@ -148,6 +152,13 @@ class ModelWithVersions(Model):
    versions: ResourceCollection[Version]


+class ProjectPermissionChecks(GraphQLBaseModel):
+    can_create_model: "PermissionCheckResult"
+    can_delete: "PermissionCheckResult"
+    can_load: "PermissionCheckResult"
+    can_publish: "PermissionCheckResult"
+
+
 class Project(GraphQLBaseModel):
    allow_public_comments: bool
    created_at: datetime
@@ -165,6 +176,10 @@ class ProjectWithModels(Project):
    models: ResourceCollection[Model]


+class ProjectWithPermissions(Project):
+    permissions: ProjectPermissionChecks
+
+
 class ProjectWithTeam(Project):
    invited_team: List[PendingStreamCollaborator]
    team: List[ProjectCollaborator]
@@ -177,3 +192,39 @@ class ProjectCommentCollection(ResourceCollection[T], Generic[T]):
 class UserSearchResultCollection(GraphQLBaseModel):
    items: List[LimitedUser]
    cursor: Optional[str] = None
+
+
+class PermissionCheckResult(GraphQLBaseModel):
+    authorized: bool
+    code: str
+    message: str
+
+    def ensure_authorised(self) -> None:
+        """Raises WorkspacePermissionException if not authorized"""
+        if not self.authorized:
+            raise WorkspacePermissionException(self.message)
+
+
+class WorkspacePermissionChecks(GraphQLBaseModel):
+    can_create_project: PermissionCheckResult
+
+
+class WorkspaceCreationState(GraphQLBaseModel):
+    completed: bool
+
+
+class LimitedWorkspace(GraphQLBaseModel):
+    id: str
+    name: str
+    role: Optional[str]
+    slug: str
+    logo: Optional[str]
+    description: Optional[str]
+
+
+class Workspace(LimitedWorkspace):
+    created_at: datetime
+    updated_at: datetime
+    read_only: bool
+    creation_state: Optional[WorkspaceCreationState]
+    permissions: WorkspacePermissionChecks
@@ -10,6 +10,7 @@ from specklepy.core.api.resources.current.subscription_resource import (
    SubscriptionResource,
 )
 from specklepy.core.api.resources.current.version_resource import VersionResource
+from specklepy.core.api.resources.current.workspace_resource import WorkspaceResource

 __all__ = [
    "ActiveUserResource",
@@ -20,4 +21,5 @@ __all__ = [
    "ServerResource",
    "SubscriptionResource",
    "VersionResource",
+    "WorkspaceResource",
 ]
@@ -2,13 +2,23 @@ from typing import List, Optional

 from gql import gql

-from specklepy.core.api.inputs.user_inputs import UserProjectsFilter, UserUpdateInput
+from specklepy.core.api.inputs.user_inputs import (
+    UserProjectsFilter,
+    UserUpdateInput,
+    UserWorkspacesFilter,
+)
 from specklepy.core.api.models import (
    PendingStreamCollaborator,
    Project,
    ResourceCollection,
    User,
 )
+from specklepy.core.api.models.current import (
+    LimitedWorkspace,
+    PermissionCheckResult,
+    ProjectWithPermissions,
+    Workspace,
+)
 from specklepy.core.api.resource import ResourceBase
 from specklepy.core.api.responses import DataResponse
 from specklepy.logging.exceptions import GraphQLException
@@ -190,3 +200,213 @@ class ActiveUserResource(ResourceBase):
            )

        return response.data.data
+
+    def can_create_personal_projects(self) -> PermissionCheckResult:
+        QUERY = gql(
+            """
+            query CanCreatePersonalProject {
+              data:activeUser {
+                data:permissions {
+                  data:canCreatePersonalProject {
+                    authorized
+                    code
+                    message
+                  }
+                }
+              }
+            }
+            """
+        )
+
+        response = self.make_request_and_parse_response(
+            DataResponse[Optional[DataResponse[DataResponse[PermissionCheckResult]]]],
+            QUERY,
+        )
+
+        if response.data is None:
+            raise GraphQLException(
+                "GraphQL response indicated that the ActiveUser could not be found"
+            )
+
+        return response.data.data.data
+
+    def get_workspaces(
+        self,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[UserWorkspacesFilter] = None,
+    ) -> ResourceCollection[Workspace]:
+        """
+        This feature is only available on Workspace enabled servers  (server versions
+        >=2.23.17) e.g. app.speckle.systems
+        """
+        QUERY = gql(
+            """
+            query ActiveUser($limit: Int!, $cursor: String, $filter: UserWorkspacesFilter) {
+              data:activeUser {
+                data:workspaces(limit: $limit, cursor: $cursor, filter: $filter) {
+                  cursor
+                  totalCount
+                  items {
+                    id
+                    name
+                    role
+                    slug
+                    logo
+                    createdAt
+                    updatedAt
+                    readOnly
+                    description
+                    creationState
+                    {
+                      completed
+                    }
+                    permissions {
+                      canCreateProject {
+                        authorized
+                        code
+                        message
+                      }
+                    }
+                  }
+                }
+              }
+            }
+            """  # noqa: E501
+        )
+
+        variables = {
+            "limit": limit,
+            "cursor": cursor,
+            "filter": filter.model_dump(warnings="error", by_alias=True)
+            if filter
+            else None,
+        }
+
+        response = self.make_request_and_parse_response(
+            DataResponse[Optional[DataResponse[ResourceCollection[Workspace]]]],
+            QUERY,
+            variables,
+        )
+
+        if response.data is None:
+            raise GraphQLException(
+                "GraphQL response indicated that the ActiveUser could not be found"
+            )
+
+        return response.data.data
+
+    def get_active_workspace(self) -> Optional[LimitedWorkspace]:
+        """
+        This feature is only available on Workspace enabled servers  (server versions
+        >=2.23.17) e.g. app.speckle.systems
+        """
+        QUERY = gql(
+            """
+            query ActiveUser {
+              data:activeUser {
+                data:activeWorkspace {
+                  id
+                  name
+                  role
+                  slug
+                  logo
+                  description
+                }
+              }
+            }
+            """
+        )
+
+        response = self.make_request_and_parse_response(
+            DataResponse[Optional[DataResponse[Optional[LimitedWorkspace]]]],
+            QUERY,
+        )
+
+        if response.data is None:
+            raise GraphQLException(
+                "GraphQL response indicated that the ActiveUser could not be found"
+            )
+
+        return response.data.data
+
+    def get_projects_with_permissions(
+        self,
+        *,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[UserProjectsFilter] = None,
+    ) -> ResourceCollection[ProjectWithPermissions]:
+        """
+        Gets the currently active user's projects with their permissions.
+        This is useful for checking what actions can be performed on each project.
+        """
+        QUERY = gql(
+            """
+          query User($limit : Int!, $cursor: String, $filter: UserProjectsFilter) {
+            data:activeUser {
+              data:projects(limit: $limit, cursor: $cursor, filter: $filter) {
+                totalCount
+                cursor
+                items {
+                    id
+                    name
+                    description
+                    visibility
+                    allowPublicComments
+                    role
+                    createdAt
+                    updatedAt
+                    sourceApps
+                    workspaceId
+                    permissions {
+                      canCreateModel {
+                        code
+                        authorized
+                        message
+                      }
+                      canDelete {
+                        code
+                        authorized
+                        message
+                      }
+                      canLoad {
+                        code
+                        authorized
+                        message
+                      }
+                      canPublish {
+                        code
+                        authorized
+                        message
+                      }
+                    }
+                }
+              }
+            }
+          }
+          """
+        )
+
+        variables = {
+            "limit": limit,
+            "cursor": cursor,
+            "filter": filter.model_dump(warnings="error", by_alias=True)
+            if filter
+            else None,
+        }
+
+        response = self.make_request_and_parse_response(
+            DataResponse[
+                Optional[DataResponse[ResourceCollection[ProjectWithPermissions]]]
+            ],
+            QUERY,
+            variables,
+        )
+
+        if response.data is None:
+            raise GraphQLException(
+                "GraphQL response indicated that the ActiveUser could not be found"
+            )
+
+        return response.data.data
@@ -7,8 +7,14 @@ from specklepy.core.api.inputs.project_inputs import (
    ProjectModelsFilter,
    ProjectUpdateInput,
    ProjectUpdateRoleInput,
+    WorkspaceProjectCreateInput,
 )
-from specklepy.core.api.models import Project, ProjectWithModels, ProjectWithTeam
+from specklepy.core.api.models import (
+    Project,
+    ProjectWithModels,
+    ProjectWithTeam,
+)
+from specklepy.core.api.models.current import ProjectPermissionChecks
 from specklepy.core.api.resource import ResourceBase
 from specklepy.core.api.responses import DataResponse

@@ -55,6 +61,46 @@ class ProjectResource(ResourceBase):
            DataResponse[Project], QUERY, variables
        ).data

+    def get_permissions(self, project_id: str) -> ProjectPermissionChecks:
+        QUERY = gql(
+            """
+            query Project($projectId: String!) {
+              data:project(id: $projectId) {
+                data:permissions {
+                  canCreateModel {
+                    authorized
+                    code
+                    message
+                  }
+                  canDelete {
+                    authorized
+                    code
+                    message
+                  }
+                  canLoad {
+                    authorized
+                    code
+                    message
+                  }
+                  canPublish {
+                    authorized
+                    code
+                    message
+                  }
+                }
+              }
+            }
+            """
+        )
+
+        variables = {
+            "projectId": project_id,
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[ProjectPermissionChecks]], QUERY, variables
+        ).data.data
+
    def get_with_models(
        self,
        project_id: str,
@@ -198,6 +244,12 @@ class ProjectResource(ResourceBase):
        ).data

    def create(self, input: ProjectCreateInput) -> Project:
+        """
+        Creates a non-workspace project (aka Personal Project)
+
+        see client.active_user.can_create_personal_projects to see if the user has
+        permission
+        """
        QUERY = gql(
            """
            mutation ProjectCreate($input: ProjectCreateInput) {
@@ -227,6 +279,45 @@ class ProjectResource(ResourceBase):
            DataResponse[DataResponse[Project]], QUERY, variables
        ).data.data

+    def create_in_workspace(self, input: WorkspaceProjectCreateInput) -> Project:
+        """
+        Creates a workspace project
+        This feature is only supported by Workspace Enabled Servers
+        (e.g. app.speckle.systems)
+
+        see `workspace.permissions.can_create_project` to see if the user has permission
+        """
+        QUERY = gql(
+            """
+          mutation WorkspaceProjectCreate($input: WorkspaceProjectCreateInput!) {
+            data:workspaceMutations {
+              data:projects {
+                data:create(input: $input) {
+                  id
+                  name
+                  description
+                  visibility
+                  allowPublicComments
+                  role
+                  createdAt
+                  updatedAt
+                  sourceApps
+                  workspaceId
+                }
+              }
+            }
+          }
+          """
+        )
+
+        variables = {
+            "input": input.model_dump(warnings="error", by_alias=True),
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[DataResponse[Project]]], QUERY, variables
+        ).data.data.data
+
    def update(self, input: ProjectUpdateInput) -> Project:
        QUERY = gql(
            """
@@ -1,7 +1,6 @@
 import re
 from typing import Any, Dict, List, Tuple

-import requests
 from gql import gql

 from specklepy.core.api.models import ServerInfo
@@ -38,11 +37,6 @@ class ServerResource(ResourceBase):
                    adminContact
                    canonicalUrl
                    version
-                    roles {
-                        name
-                        description
-                        resourceTarget
-                    }
                    scopes {
                        name
                        description
@@ -52,6 +46,9 @@ class ServerResource(ResourceBase):
                        name
                        icon
                    }
+                    workspaces {
+                      workspacesEnabled
+                    }
                }
            }
            """
@@ -60,16 +57,6 @@ class ServerResource(ResourceBase):
        server_info = self.make_request(
            query=query, return_type="serverInfo", schema=ServerInfo
        )
-        if isinstance(server_info, ServerInfo) and isinstance(
-            server_info.canonical_url, str
-        ):
-            r = requests.get(
-                server_info.canonical_url, headers={"User-Agent": "specklepy SDK"}
-            )
-            if "x-speckle-frontend-2" in r.headers:
-                server_info.frontend2 = True
-            else:
-                server_info.frontend2 = False

        return server_info

@@ -0,0 +1,180 @@
+from typing import Optional
+
+from gql import gql
+
+from specklepy.core.api.inputs.project_inputs import WorksaceProjectsFilter
+from specklepy.core.api.models.current import (
+    Project,
+    ProjectWithPermissions,
+    ResourceCollection,
+    Workspace,
+)
+from specklepy.core.api.resource import ResourceBase
+from specklepy.core.api.responses import DataResponse
+
+NAME = "workspace"
+
+
+class WorkspaceResource(ResourceBase):
+    """API Access class for models"""
+
+    def __init__(self, account, basepath, client, server_version) -> None:
+        super().__init__(
+            account=account,
+            basepath=basepath,
+            client=client,
+            name=NAME,
+            server_version=server_version,
+        )
+
+    def get(self, workspace_id: str) -> Workspace:
+        QUERY = gql(
+            """
+            query WorkspaceGet($workspaceId: String!) {
+              data:workspace(id: $workspaceId) {
+                id
+                name
+                role
+                slug
+                logo
+                createdAt
+                updatedAt
+                readOnly
+                description
+                creationState
+                {
+                  completed
+                }
+                permissions {
+                  canCreateProject {
+                    authorized
+                    code
+                    message
+                  }
+                }
+              }
+            }
+            """
+        )
+
+        variables = {
+            "workspaceId": workspace_id,
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[Workspace], QUERY, variables
+        ).data
+
+    def get_projects(
+        self,
+        workspace_id: str,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[WorksaceProjectsFilter] = None,
+    ) -> ResourceCollection[Project]:
+        QUERY = gql(
+            """
+            query Workspace($workspaceId: String!, $limit: Int!, $cursor: String, $filter: WorkspaceProjectsFilter) {
+              data:workspace(id: $workspaceId) {
+                data:projects(limit: $limit, cursor: $cursor, filter: $filter) {
+                  cursor
+                  items {
+                    allowPublicComments
+                    createdAt
+                    description
+                    id
+                    name
+                    role
+                    sourceApps
+                    updatedAt
+                    visibility
+                    workspaceId
+                  }
+                  totalCount
+                }
+              }
+            }
+            """  # noqa: E501
+        )
+
+        variables = {
+            "workspaceId": workspace_id,
+            "limit": limit,
+            "cursor": cursor,
+            "filter": filter.model_dump(warnings="error", by_alias=True)
+            if filter
+            else None,
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[ResourceCollection[Project]]], QUERY, variables
+        ).data.data
+
+    def get_projects_with_permissions(
+        self,
+        workspace_id: str,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[WorksaceProjectsFilter] = None,
+    ) -> ResourceCollection[ProjectWithPermissions]:
+        QUERY = gql(
+            """
+            query Workspace($workspaceId: String!, $limit: Int!, $cursor: String, $filter: WorkspaceProjectsFilter) {
+              data:workspace(id: $workspaceId) {
+                data:projects(limit: $limit, cursor: $cursor, filter: $filter) {
+                  cursor
+                  items {
+                    allowPublicComments
+                    createdAt
+                    description
+                    id
+                    name
+                    role
+                    sourceApps
+                    updatedAt
+                    visibility
+                    workspaceId
+                    permissions {
+                      canCreateModel {
+                        code
+                        authorized
+                        message
+                      }
+                      canDelete {
+                        code
+                        authorized
+                        message
+                      }
+                      canLoad {
+                        code
+                        authorized
+                        message
+                      }
+                      canPublish {
+                        code
+                        authorized
+                        message
+                      }
+                    }
+                  }
+                  totalCount
+                }
+              }
+            }
+            """  # noqa: E501
+        )
+
+        variables = {
+            "workspaceId": workspace_id,
+            "limit": limit,
+            "cursor": cursor,
+            "filter": filter.model_dump(warnings="error", by_alias=True)
+            if filter
+            else None,
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[ResourceCollection[ProjectWithPermissions]]],
+            QUERY,
+            variables,
+        ).data.data
@@ -58,3 +58,8 @@ class UnsupportedException(SpeckleException):
 class SpeckleWarning(Warning):
    def __init__(self, *args: object) -> None:
        super().__init__(*args)
+
+
+class WorkspacePermissionException(SpeckleException):
+    def __init__(self, message: str) -> None:
+        super().__init__(message=message)
@@ -1,7 +1,3 @@
-from .data_objects import Base, DataObject, QgisObject
+from .data_objects import Base, DataObject, QgisObject, BlenderObject  # noqa: I001

-__all__ = [
-    "Base",
-    "DataObject",
-    "QgisObject",
-]
+__all__ = ["Base", "DataObject", "QgisObject", "BlenderObject"]
@@ -0,0 +1,8 @@
+from .text import AlignmentHorizontal, AlignmentVertical, Text
+
+# re-export them at the geometry package level
+__all__ = [
+    "Text",
+    "AlignmentHorizontal",
+    "AlignmentVertical",
+]
@@ -0,0 +1,54 @@
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Optional
+
+from specklepy.objects.base import Base
+from specklepy.objects.geometry import Plane, Point
+from specklepy.objects.interfaces import IHasUnits
+
+
+class AlignmentHorizontal(Enum):
+    Left = 0
+    Center = 1
+    Right = 2
+
+
+class AlignmentVertical(Enum):
+    Top = 0
+    Center = 1
+    Bottom = 2
+
+
+@dataclass(kw_only=True)
+class Text(Base, IHasUnits, speckle_type="Objects.Annotation.Text"):
+    """
+    Text class for representation in the viewer.
+    Units will be 'Units.None' if the text size is defined in pixels.
+    """
+
+    value: str  # Plain text, without formatting
+    origin: Point  # Relation to the text is defined by AlignmentH and AlignmentV
+    height: float  # Font height in linear units or pixels (if Units.None)
+    alignmentH: AlignmentHorizontal = field(
+        default_factory=lambda: AlignmentHorizontal.Left
+    )
+    alignmentV: AlignmentVertical = field(default_factory=lambda: AlignmentVertical.Top)
+    plane: Optional[Plane] = field(
+        default_factory=lambda: None
+    )  # None if the text object orientation follows camera view
+    maxWidth: Optional[float] = field(
+        default_factory=lambda: None
+    )  # Maximum width of the text field. None, if don't split into lines
+
+    def __repr__(self) -> str:
+        return (
+            f"{self.__class__.__name__}("
+            f"value: {self.value}, "
+            f"origin: {self.origin}, "
+            f"height: {self.height}, "
+            f"alignmentH: {self.alignmentH}, "
+            f"alignmentV: {self.alignmentV}, "
+            f"plane: {self.plane}, "
+            f"maxWidth: {self.maxWidth}, "
+            f"units: {self.units})"
+        )
@@ -3,7 +3,12 @@ from typing import Dict, List

 from specklepy.logging.exceptions import SpeckleException
 from specklepy.objects.base import Base
-from specklepy.objects.interfaces import IDataObject, IGisObject, IHasUnits
+from specklepy.objects.interfaces import (
+    IBlenderObject,
+    IDataObject,
+    IGisObject,
+    IHasUnits,
+)


@dataclass(kw_only=True)
@@ -79,3 +84,24 @@ class QgisObject(
            raise SpeckleException(
                f"'type' value should be string, received {type(value)}"
            )
+
+
+@dataclass(kw_only=True)
+class BlenderObject(
+    DataObject, IBlenderObject, IHasUnits, speckle_type="Objects.Data.BlenderObject"
+):
+    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)}"
+            )
@@ -13,12 +13,13 @@ class Mesh(
    IHasVolume,
    IHasUnits,
    speckle_type="Objects.Geometry.Mesh",
-    detachable={"vertices", "faces", "colors", "textureCoordinates"},
+    detachable={"vertices", "faces", "colors", "textureCoordinates", "vertexNormals"},
    chunkable={
        "vertices": 31250,
        "faces": 62500,
        "colors": 62500,
        "textureCoordinates": 31250,
+        "vertexNormals": 31250,
    },
    serialize_ignore={"vertices_count", "texture_coordinates_count"},
 ):
@@ -31,6 +32,7 @@ class Mesh(
    faces: List[int]
    colors: List[int] = field(default_factory=list)
    textureCoordinates: List[float] = field(default_factory=list)
+    vertexNormals: List[float] = field(default_factory=list)

    def __repr__(self) -> str:
        return (
@@ -47,7 +47,6 @@ class Region(

    @property
    def displayValue(self) -> List[Mesh]:
-        print(self._displayValue)
        return self._displayValue

    @displayValue.setter
@@ -7,7 +7,6 @@ from specklepy.objects.base import Base
 class RenderMaterial(
    Base,
    speckle_type="Objects.Other.RenderMaterial",
-    serialize_ignore={"diffuse", "emissive"},
 ):
    """
    Minimal physically based material DTO class. Based on references from
@@ -199,8 +199,9 @@ class BaseObjectSerializer:

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

        del self.lineage[-1]

@@ -4,6 +4,7 @@ from specklepy.api.client import SpeckleClient
 from specklepy.core.api.inputs.project_inputs import ProjectCreateInput
 from specklepy.core.api.inputs.user_inputs import UserProjectsFilter, UserUpdateInput
 from specklepy.core.api.models import ResourceCollection, User
+from specklepy.logging.exceptions import GraphQLException


@pytest.mark.run()
@@ -61,3 +62,24 @@ class TestActiveUserResource:
        assert len(res.items) == 1
        assert res.total_count == 1
        assert res.items[0].id == p1.id
+
+    def test_can_create_personal_projects(self, client: SpeckleClient):
+        res = client.active_user.can_create_personal_projects()
+        res.ensure_authorised()
+
+        assert res.authorized is True
+
+    def test_get_workspaces(self, client: SpeckleClient):
+        """
+        Test server is not workspace enabled, so we can't really test everything here
+        We'll just test client's error handling
+        """
+        with pytest.raises(GraphQLException):
+            _ = client.active_user.get_workspaces()
+
+    def test_get_active_workspace(self, client: SpeckleClient):
+        """
+        Test server is not workspace enabled, so we can't really test everything here
+        """
+        res = client.active_user.get_active_workspace()
+        assert res is None
@@ -0,0 +1,85 @@
+import pytest
+
+from specklepy.api.client import SpeckleClient
+from specklepy.core.api.inputs.project_inputs import ProjectCreateInput
+from specklepy.core.api.inputs.user_inputs import UserProjectsFilter
+from specklepy.core.api.models.current import (
+    Project,
+    ProjectWithPermissions,
+    ResourceCollection,
+)
+
+
+@pytest.mark.run()
+class TestActiveUserResourcePermissions:
+    @pytest.fixture()
+    def test_project(self, client: SpeckleClient) -> Project:
+        project = client.project.create(
+            ProjectCreateInput(
+                name="test project for active user permissions",
+                description="test description",
+                visibility=None,
+            )
+        )
+        return project
+
+    def test_active_user_get_projects_with_permissions(
+        self, client: SpeckleClient, test_project: Project
+    ):
+        result = client.active_user.get_projects_with_permissions()
+
+        assert isinstance(result, ResourceCollection)
+        assert len(result.items) >= 1
+
+        test_project_with_permissions = None
+        for project in result.items:
+            if project.id == test_project.id:
+                test_project_with_permissions = project
+                break
+
+        assert test_project_with_permissions is not None
+        assert isinstance(test_project_with_permissions, ProjectWithPermissions)
+
+        assert hasattr(test_project_with_permissions, "permissions")
+        assert test_project_with_permissions.permissions is not None
+
+        assert test_project_with_permissions.id == test_project.id
+        assert test_project_with_permissions.name == test_project.name
+
+        permissions = test_project_with_permissions.permissions
+        assert hasattr(permissions, "can_create_model")
+        assert hasattr(permissions, "can_delete")
+        assert hasattr(permissions, "can_load")
+        assert hasattr(permissions, "can_publish")
+
+        assert permissions.can_create_model.authorized is True
+        assert permissions.can_delete.authorized is True
+        assert permissions.can_load.authorized is True
+        assert permissions.can_publish.authorized is True
+
+    def test_active_user_get_projects_with_permissions_with_filter(
+        self, client: SpeckleClient, test_project: Project
+    ):
+        """test getting active user's projects with permissions using a filter."""
+        filter = UserProjectsFilter(search=test_project.name)
+
+        result = client.active_user.get_projects_with_permissions(filter=filter)
+
+        assert isinstance(result, ResourceCollection)
+        assert len(result.items) >= 1
+        assert result.total_count >= 1
+
+        project_with_permissions = result.items[0]
+        assert isinstance(project_with_permissions, ProjectWithPermissions)
+        assert project_with_permissions.id == test_project.id
+
+        assert hasattr(project_with_permissions, "permissions")
+        assert project_with_permissions.permissions is not None
+
+    def test_active_user_projects_with_permissions_method_exists(
+        self, client: SpeckleClient
+    ):
+        """test that the method exists and is callable on active user resource."""
+        assert hasattr(client.active_user, "get_projects_with_permissions")
+        method = client.active_user.get_projects_with_permissions
+        assert callable(method)
@@ -3,6 +3,7 @@ from typing import Optional
 import pytest

 from specklepy.api.client import SpeckleClient
+from specklepy.core.api.enums import ProjectVisibility
 from specklepy.core.api.inputs.project_inputs import (
    ProjectCreateInput,
    ProjectInviteCreateInput,
@@ -22,7 +23,9 @@ class TestProjectInviteResource:
    @pytest.fixture
    def project(self, client: SpeckleClient):
        return client.project.create(
-            ProjectCreateInput(name="test", description=None, visibility=None)
+            ProjectCreateInput(
+                name="test", description=None, visibility=ProjectVisibility.PUBLIC
+            )
        )

    @pytest.fixture
@@ -7,6 +7,7 @@ from specklepy.core.api.inputs.project_inputs import (
    ProjectUpdateInput,
 )
 from specklepy.core.api.models import Project
+from specklepy.core.api.models.current import ProjectPermissionChecks
 from specklepy.logging.exceptions import GraphQLException


@@ -50,8 +51,8 @@ class TestProjectResource:
        assert result.name == name
        assert result.description == (description or "")
        # we've disabled creation of public projects for now, they fall back to unlisted
-        if visibility == ProjectVisibility.PUBLIC:
-            assert result.visibility == ProjectVisibility.UNLISTED
+        if visibility == ProjectVisibility.UNLISTED:
+            assert result.visibility == ProjectVisibility.PUBLIC
        else:
            assert result.visibility == visibility

@@ -65,10 +66,19 @@ class TestProjectResource:
        assert result.visibility == test_project.visibility
        assert result.created_at == test_project.created_at

+    def test_project_get_permissions(
+        self, client: SpeckleClient, test_project: Project
+    ):
+        result = client.project.get_permissions(test_project.id)
+
+        assert isinstance(result, ProjectPermissionChecks)
+        assert result.can_create_model.authorized is True
+        assert result.can_delete.authorized is True
+
    def test_project_update(self, client: SpeckleClient, test_project: Project):
        new_name = "MY new name"
        new_description = "MY new desc"
-        new_visibility = ProjectVisibility.PUBLIC
+        new_visibility = ProjectVisibility.UNLISTED

        update_data = ProjectUpdateInput(
            id=test_project.id,
@@ -84,8 +94,8 @@ class TestProjectResource:
        assert updated_project.name == new_name
        assert updated_project.description == new_description
        # we've disabled creation of public projects for now, they fall back to unlisted
-        if new_visibility == ProjectVisibility.PUBLIC:
-            assert updated_project.visibility == ProjectVisibility.UNLISTED
+        if new_visibility == ProjectVisibility.UNLISTED:
+            assert updated_project.visibility == ProjectVisibility.PUBLIC
        else:
            assert updated_project.visibility == new_visibility

@@ -0,0 +1,23 @@
+import pytest
+
+from specklepy.api.client import SpeckleClient
+from specklepy.logging.exceptions import GraphQLException
+
+
+@pytest.mark.run()
+class TestWorkspaceResource:
+    def test_get_workspace(self, client: SpeckleClient):
+        """
+        Test server is not workspace enabled, so we can't really test everything here
+        We'll just test client's error handling
+        """
+        with pytest.raises(GraphQLException):
+            client.workspace.get("not a real id")
+
+    def test_get_projects(self, client: SpeckleClient):
+        """
+        Test server is not workspace enabled, so we can't really test everything here
+        We'll just test client's error handling
+        """
+        with pytest.raises(GraphQLException):
+            client.workspace.get_projects("not a real id")
@@ -0,0 +1,19 @@
+import pytest
+
+from specklepy.api.client import SpeckleClient
+from specklepy.logging.exceptions import GraphQLException
+
+
+@pytest.mark.run()
+class TestWorkspaceResourcePermissions:
+    def test_get_projects_with_permissions(self, client: SpeckleClient):
+        with pytest.raises(GraphQLException):
+            client.workspace.get_projects_with_permissions("not a real id")
+
+    def test_get_projects_with_permissions_method_exists(self, client: SpeckleClient):
+        """
+        test that the method exists with the correct signature.
+        """
+        assert hasattr(client.workspace, "get_projects_with_permissions")
+        method = client.workspace.get_projects_with_permissions
+        assert callable(method)
@@ -0,0 +1,32 @@
+import pytest
+from httpx import HTTPStatusError
+
+from specklepy.core.api.connector_versions import (
+    ConnectorVersion,
+    ConnectorVersions,
+    get_connector_versions,
+    get_latest_version,
+)
+
+# NOTE: the tests in this file are testing against the live releases.speckle.dev server
+# url defined in get_connector_versions.
+
+
+def test_connector_versions():
+    res = get_connector_versions("blender")
+
+    assert isinstance(res, ConnectorVersions)
+    assert res.versions  # Assuming the feed is not empty
+
+
+def test_get_latest_version_throws_no_slug():
+    with pytest.raises(HTTPStatusError) as ex:
+        get_latest_version("non-existent-connector!", True)
+
+    assert "404" in str(ex.value)
+
+
+def test_get_latest_version():
+    res = get_latest_version("blender", False)
+
+    assert isinstance(res, ConnectorVersion)
@@ -151,6 +151,7 @@ def test_arc_serialization(sample_arc):
    serialized = serialize(sample_arc)
    deserialized = deserialize(serialized)

+    assert isinstance(deserialized, Arc)
    assert deserialized.startPoint.x == sample_arc.startPoint.x
    assert deserialized.startPoint.y == sample_arc.startPoint.y
    assert deserialized.startPoint.z == sample_arc.startPoint.z
@@ -116,6 +116,7 @@ def test_box_serialization(sample_box):
    serialized = serialize(sample_box)
    deserialized = deserialize(serialized)

+    assert isinstance(deserialized, Box)
    assert deserialized.basePlane.origin.x == sample_box.basePlane.origin.x
    assert deserialized.basePlane.origin.y == sample_box.basePlane.origin.y
    assert deserialized.basePlane.origin.z == sample_box.basePlane.origin.z
@@ -107,6 +107,7 @@ def test_circle_serialization(sample_circle):
    serialized = serialize(sample_circle)
    deserialized = deserialize(serialized)

+    assert isinstance(deserialized, Circle)
    assert deserialized.plane.origin.x == sample_circle.plane.origin.x
    assert deserialized.plane.origin.y == sample_circle.plane.origin.y
    assert deserialized.plane.origin.z == sample_circle.plane.origin.z
@@ -70,6 +70,7 @@ def test_control_point_serialization(sample_control_point):
    serialized = serialize(sample_control_point)
    deserialized = deserialize(serialized)

+    assert isinstance(deserialized, ControlPoint)
    assert deserialized.x == sample_control_point.x
    assert deserialized.y == sample_control_point.y
    assert deserialized.z == sample_control_point.z
@@ -125,6 +125,7 @@ def test_curve_serialization(sample_curve):
    serialized = serialize(sample_curve)
    deserialized = deserialize(serialized)

+    assert isinstance(deserialized, Curve)
    assert deserialized.degree == sample_curve.degree
    assert deserialized.periodic == sample_curve.periodic
    assert deserialized.rational == sample_curve.rational
@@ -0,0 +1,252 @@
+import pytest
+
+from specklepy.core.api.operations import deserialize, serialize
+from specklepy.logging.exceptions import SpeckleException
+from specklepy.objects.base import Base
+from specklepy.objects.data_objects import BlenderObject, DataObject, QgisObject
+from specklepy.objects.interfaces import (
+    IBlenderObject,
+    IDataObject,
+    IGisObject,
+    IHasUnits,
+)
+from specklepy.objects.models.units import Units
+
+
+def test_data_object_creation():
+    display_value = [Base()]
+    data_obj = DataObject(
+        name="Test Data Object",
+        properties={"key1": "value1", "key2": 2},
+        displayValue=display_value,
+    )
+
+    assert data_obj.name == "Test Data Object"
+    assert data_obj.properties == {"key1": "value1", "key2": 2}
+    assert data_obj.displayValue == display_value
+    assert data_obj.speckle_type == "Objects.Data.DataObject"
+
+
+def test_inheritance_relationships():
+    data_obj = DataObject(
+        name="Test Data Object",
+        properties={"key": "value"},
+        displayValue=[Base()],
+    )
+    assert isinstance(data_obj, DataObject)
+    assert isinstance(data_obj, Base)
+    assert isinstance(data_obj, IDataObject)
+
+    qgis_obj = QgisObject(
+        name="Test QGIS Object",
+        properties={"key": "value"},
+        displayValue=[Base()],
+        type="Feature",
+        units=Units.m,
+    )
+    assert isinstance(qgis_obj, QgisObject)
+    assert isinstance(qgis_obj, DataObject)
+    assert isinstance(qgis_obj, Base)
+    assert isinstance(qgis_obj, IDataObject)
+    assert isinstance(qgis_obj, IGisObject)
+    assert isinstance(qgis_obj, IHasUnits)
+
+    blender_obj = BlenderObject(
+        name="Test Blender Object",
+        properties={"key": "value"},
+        displayValue=[Base()],
+        type="Mesh",
+        units=Units.m,
+    )
+    assert isinstance(blender_obj, BlenderObject)
+    assert isinstance(blender_obj, DataObject)
+    assert isinstance(blender_obj, Base)
+    assert isinstance(blender_obj, IDataObject)
+    assert isinstance(blender_obj, IBlenderObject)
+    assert isinstance(blender_obj, IHasUnits)
+
+
+def test_data_object_invalid_types():
+    data_obj = DataObject(
+        name="Test Object",
+        properties={"key": "value"},
+        displayValue=[Base()],
+    )
+
+    class ComplexObject:
+        def __str__(self):
+            raise ValueError("Can't convert to string")
+
+    complex_obj = ComplexObject()
+
+    with pytest.raises((ValueError, SpeckleException)):
+        data_obj.name = complex_obj  # should be string
+
+    with pytest.raises(SpeckleException):
+        data_obj.properties = [1, 2, 3]  # should be dict, not list
+
+    with pytest.raises(SpeckleException):
+        data_obj.displayValue = {"key": "value"}  # should be list, not dict
+
+
+def test_data_object_serialization():
+    display_value = [Base()]
+    data_obj = DataObject(
+        name="Test Data Object",
+        properties={"key1": "value1", "key2": 2},
+        displayValue=display_value,
+    )
+
+    serialized = serialize(data_obj)
+    deserialized = deserialize(serialized)
+
+    assert isinstance(deserialized, DataObject)
+    assert deserialized.name == data_obj.name
+    assert deserialized.properties == data_obj.properties
+    assert len(deserialized.displayValue) == len(data_obj.displayValue)
+    assert deserialized.speckle_type == data_obj.speckle_type
+
+
+def test_qgis_object_creation():
+    display_value = [Base()]
+    qgis_obj = QgisObject(
+        name="Test QGIS Object",
+        properties={"key1": "value1"},
+        displayValue=display_value,
+        type="Feature",
+        units=Units.m,
+    )
+
+    assert qgis_obj.name == "Test QGIS Object"
+    assert qgis_obj.properties == {"key1": "value1"}
+    assert qgis_obj.displayValue == display_value
+    assert qgis_obj.type == "Feature"
+    assert qgis_obj.units == Units.m.value
+    assert "Objects.Data.QgisObject" in qgis_obj.speckle_type
+
+
+def test_qgis_object_serialization():
+    display_value = [Base()]
+    qgis_obj = QgisObject(
+        name="Test QGIS Object",
+        properties={"key1": "value1"},
+        displayValue=display_value,
+        type="Feature",
+        units=Units.m,
+    )
+
+    serialized = serialize(qgis_obj)
+    deserialized = deserialize(serialized)
+
+    assert isinstance(deserialized, QgisObject)
+    assert deserialized.name == qgis_obj.name
+    assert deserialized.properties == qgis_obj.properties
+    assert len(deserialized.displayValue) == len(qgis_obj.displayValue)
+    assert deserialized.type == qgis_obj.type
+    assert deserialized.units == qgis_obj.units
+    assert "Objects.Data.QgisObject" in deserialized.speckle_type
+
+
+def test_blender_object_creation():
+    display_value = [Base()]
+    blender_obj = BlenderObject(
+        name="Test Blender Object",
+        properties={"key1": "value1"},
+        displayValue=display_value,
+        type="Mesh",
+        units=Units.m,
+    )
+
+    assert blender_obj.name == "Test Blender Object"
+    assert blender_obj.properties == {"key1": "value1"}
+    assert blender_obj.displayValue == display_value
+    assert blender_obj.type == "Mesh"
+    assert blender_obj.units == Units.m.value
+    assert "Objects.Data.BlenderObject" in blender_obj.speckle_type
+
+
+def test_blender_object_invalid_types():
+    blender_obj = BlenderObject(
+        name="Test Object",
+        properties={"key": "value"},
+        displayValue=[Base()],
+        type="Mesh",
+        units=Units.m,
+    )
+
+    class ComplexObject:
+        def __str__(self):
+            raise ValueError("Can't convert to string")
+
+    complex_obj = ComplexObject()
+
+    with pytest.raises((ValueError, SpeckleException)):
+        blender_obj.type = complex_obj  # should be string
+
+
+def test_blender_object_serialization():
+    display_value = [Base()]
+    blender_obj = BlenderObject(
+        name="Test Blender Object",
+        properties={"key1": "value1"},
+        displayValue=display_value,
+        type="Mesh",
+        units=Units.m,
+    )
+
+    serialized = serialize(blender_obj)
+    deserialized = deserialize(serialized)
+
+    assert isinstance(deserialized, BlenderObject)
+    assert deserialized.name == blender_obj.name
+    assert deserialized.properties == blender_obj.properties
+    assert len(deserialized.displayValue) == len(blender_obj.displayValue)
+    assert deserialized.type == blender_obj.type
+    assert deserialized.units == blender_obj.units
+    assert "Objects.Data.BlenderObject" in deserialized.speckle_type
+
+
+def test_data_object_property_modification():
+    data_obj = DataObject(
+        name="Original Name",
+        properties={"original": "value"},
+        displayValue=[Base()],
+    )
+
+    data_obj.name = "Updated Name"
+    data_obj.properties = {"updated": "property"}
+    new_display_value = [Base(), Base()]
+    data_obj.displayValue = new_display_value
+
+    assert data_obj.name == "Updated Name"
+    assert data_obj.properties == {"updated": "property"}
+    assert data_obj.displayValue == new_display_value
+
+
+def test_qgis_object_property_modification():
+    """Test modification of QgisObject properties after creation."""
+    qgis_obj = QgisObject(
+        name="Original Name",
+        properties={"original": "value"},
+        displayValue=[Base()],
+        type="OriginalType",
+        units=Units.m,
+    )
+
+    qgis_obj.type = "UpdatedType"
+
+    assert qgis_obj.type == "UpdatedType"
+
+
+def test_blender_object_property_modification():
+    blender_obj = BlenderObject(
+        name="Original Name",
+        properties={"original": "value"},
+        displayValue=[Base()],
+        type="OriginalType",
+        units=Units.m,
+    )
+
+    blender_obj.type = "UpdatedType"
+
+    assert blender_obj.type == "UpdatedType"
@@ -104,6 +104,7 @@ def test_ellipse_serialization(sample_ellipse):
    serialized = serialize(sample_ellipse)
    deserialized = deserialize(serialized)

+    assert isinstance(deserialized, Ellipse)
    assert deserialized.plane.origin.x == sample_ellipse.plane.origin.x
    assert deserialized.plane.origin.y == sample_ellipse.plane.origin.y
    assert deserialized.plane.origin.z == sample_ellipse.plane.origin.z
@@ -83,6 +83,7 @@ def test_line_serialization(sample_line):
    serialized = serialize(sample_line)
    deserialized = deserialize(serialized)

+    assert isinstance(deserialized, Line)
    assert deserialized.start.x == sample_line.start.x
    assert deserialized.start.y == sample_line.start.y
    assert deserialized.start.z == sample_line.start.z
@@ -155,6 +155,7 @@ def test_mesh_creation(cube_vertices, cube_faces):
    assert mesh.faces == cube_faces
    assert mesh.colors == []
    assert mesh.textureCoordinates == []
+    assert mesh.vertexNormals == []
    assert mesh.units == Units.m.value


@@ -239,6 +240,7 @@ def test_mesh_serialization(full_mesh):
    serialized = serialize(full_mesh)
    deserialized = deserialize(serialized)

+    assert isinstance(deserialized, Mesh)
    assert deserialized.vertices == full_mesh.vertices
    assert deserialized.faces == full_mesh.faces
    assert deserialized.colors == full_mesh.colors
@@ -111,6 +111,7 @@ def test_spiral_serialization(sample_spiral: Spiral):
    serialized = serialize(sample_spiral)
    deserialized = deserialize(serialized)

+    assert isinstance(deserialized, Spiral)
    assert deserialized.start_point.x == sample_spiral.start_point.x
    assert deserialized.start_point.y == sample_spiral.start_point.y
    assert deserialized.start_point.z == sample_spiral.start_point.z
@@ -30,6 +30,7 @@ def test_point_serialization():
    serialized = serialize(p1)
    deserialized = deserialize(serialized)

+    assert isinstance(deserialized, Point)
    assert deserialized.x == p1.x
    assert deserialized.y == p1.y
    assert deserialized.z == p1.z
@@ -47,6 +47,7 @@ def test_point_cloud_serialization(sample_point_cloud):
    serialized = serialize(sample_point_cloud)
    deserialized = deserialize(serialized)

+    assert isinstance(deserialized, PointCloud)
    assert len(deserialized.points) == len(sample_point_cloud.points)

    for orig_point, deserial_point in zip(
@@ -86,15 +86,21 @@ def test_polycurve_serialization(sample_polycurve: Polycurve):
    serialized = serialize(sample_polycurve)
    deserialized = deserialize(serialized)

+    assert isinstance(deserialized, Polycurve)
    assert len(deserialized.segments) == len(sample_polycurve.segments)
    assert deserialized.units == sample_polycurve.units

-    assert deserialized.segments[0].start.x == sample_polycurve.segments[0].start.x
-    assert deserialized.segments[0].start.y == sample_polycurve.segments[0].start.y
-    assert deserialized.segments[0].start.z == sample_polycurve.segments[0].start.z
-    assert deserialized.segments[0].end.x == sample_polycurve.segments[0].end.x
-    assert deserialized.segments[0].end.y == sample_polycurve.segments[0].end.y
-    assert deserialized.segments[0].end.z == sample_polycurve.segments[0].end.z
+    expectedSegment = sample_polycurve.segments[0]
+    segment = deserialized.segments[0]
+    assert isinstance(expectedSegment, Line)
+    assert isinstance(segment, Line)
+
+    assert segment.start.x == expectedSegment.start.x
+    assert segment.start.y == expectedSegment.start.y
+    assert segment.start.z == expectedSegment.start.z
+    assert segment.end.x == expectedSegment.end.x
+    assert segment.end.y == expectedSegment.end.y
+    assert segment.end.z == expectedSegment.end.z


 def test_polycurve_empty():
@@ -134,6 +134,7 @@ def test_polyline_serialization(sample_polyline):
    serialized = serialize(sample_polyline)
    deserialized = deserialize(serialized)

+    assert isinstance(deserialized, Polyline)
    assert deserialized.value == sample_polyline.value
    assert deserialized.units == sample_polyline.units
    assert deserialized.domain.start == sample_polyline.domain.start
@@ -69,6 +69,7 @@ def test_region_serialization(sample_region):
    serialized = serialize(sample_region)
    deserialized = deserialize(serialized)

+    assert isinstance(deserialized, Region)
    assert deserialized.hasHatchPattern == sample_region.hasHatchPattern
    assert deserialized.units == sample_region.units

@@ -113,6 +113,7 @@ def test_spiral_serialization(sample_spiral: Spiral):
    serialized = serialize(sample_spiral)
    deserialized = deserialize(serialized)

+    assert isinstance(deserialized, Spiral)
    assert deserialized.start_point.x == sample_spiral.start_point.x
    assert deserialized.start_point.y == sample_spiral.start_point.y
    assert deserialized.start_point.z == sample_spiral.start_point.z
@@ -140,6 +140,7 @@ def test_surface_serialization(sample_surface: Surface):
    serialized = serialize(sample_surface)
    deserialized = deserialize(serialized)

+    assert isinstance(deserialized, Surface)
    assert deserialized.degreeU == sample_surface.degreeU
    assert deserialized.degreeV == sample_surface.degreeV
    assert deserialized.rational == sample_surface.rational
@@ -0,0 +1,100 @@
+import pytest
+
+from specklepy.core.api.operations import deserialize, serialize
+from specklepy.objects.annotation import AlignmentHorizontal, AlignmentVertical, Text
+from specklepy.objects.geometry import Plane, Point, Vector
+from specklepy.objects.models.units import Units
+
+
+@pytest.fixture
+def sample_point() -> Point:
+    return Point(x=0.0, y=0.0, z=0.0, units=Units.m)
+
+
+@pytest.fixture
+def sample_plane(sample_point: Point) -> Plane:
+    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 Plane(
+        origin=sample_point, normal=normal, xdir=xdir, ydir=ydir, units=Units.m
+    )
+
+
+@pytest.fixture
+def sample_text(sample_point: Point) -> Text:
+    return Text(value="text", origin=sample_point, height=0.5, units=Units.m)
+
+
+@pytest.fixture
+def sample_text_all_properties(sample_point: Point, sample_plane: Plane) -> Text:
+    return Text(
+        value="text",
+        origin=sample_point,
+        height=0.5,
+        alignmentH=AlignmentHorizontal.Center,
+        alignmentV=AlignmentVertical.Center,
+        plane=sample_plane,
+        maxWidth=20,
+        units=Units.m,
+    )
+
+
+def test_text_creation_minimal(sample_point: Point):
+    text_value = "text"
+
+    text_obj = Text(value=text_value, origin=sample_point, height=0.5, units=Units.m)
+    assert text_obj.value == text_value
+    assert text_obj.origin == sample_point
+    assert text_obj.height == 0.5
+    assert text_obj.alignmentH == AlignmentHorizontal.Left
+    assert text_obj.alignmentV == AlignmentVertical.Top
+    assert text_obj.plane is None
+    assert text_obj.maxWidth is None
+    assert text_obj.units == Units.m.value
+
+
+def test_text_creation_extended(sample_point: Point, sample_plane: Plane):
+    text_value = "text"
+    max_width = 20
+
+    text_obj = Text(
+        value=text_value,
+        origin=sample_point,
+        height=0.5,
+        alignmentH=AlignmentHorizontal.Center,
+        alignmentV=AlignmentVertical.Center,
+        plane=sample_plane,
+        maxWidth=max_width,
+        units=Units.m,
+    )
+    assert text_obj.value == text_value
+    assert text_obj.origin == sample_point
+    assert text_obj.height == 0.5
+    assert text_obj.alignmentH == AlignmentHorizontal.Center
+    assert text_obj.alignmentV == AlignmentVertical.Center
+    assert text_obj.plane == sample_plane
+    assert text_obj.maxWidth == max_width
+    assert text_obj.units == Units.m.value
+
+
+def test_point_serialization(sample_text_all_properties: Text):
+    serialized = serialize(sample_text_all_properties)
+    deserialized = deserialize(serialized)
+
+    assert isinstance(deserialized, Text)
+    assert deserialized.value == sample_text_all_properties.value
+    assert deserialized.origin.x == sample_text_all_properties.origin.x
+    assert deserialized.origin.y == sample_text_all_properties.origin.y
+    assert deserialized.origin.z == sample_text_all_properties.origin.z
+    assert deserialized.height == sample_text_all_properties.height
+    assert deserialized.alignmentH == sample_text_all_properties.alignmentH
+    assert deserialized.alignmentV == sample_text_all_properties.alignmentV
+    assert deserialized.plane.origin.x == sample_text_all_properties.plane.origin.x
+    assert deserialized.plane.origin.y == sample_text_all_properties.plane.origin.y
+    assert deserialized.plane.origin.z == sample_text_all_properties.plane.origin.z
+    assert deserialized.plane.normal.x == sample_text_all_properties.plane.normal.x
+    assert deserialized.plane.normal.y == sample_text_all_properties.plane.normal.y
+    assert deserialized.plane.normal.z == sample_text_all_properties.plane.normal.z
+    assert deserialized.maxWidth == sample_text_all_properties.maxWidth
+    assert deserialized.units == sample_text_all_properties.units
@@ -36,6 +36,7 @@ def test_vector_serialization():
    serialized = serialize(v)
    deserialized = deserialize(serialized)

+    assert isinstance(deserialized, Vector)
    assert deserialized.x == v.x
    assert deserialized.y == v.y
    assert deserialized.z == v.z
Author	SHA1	Message	Date
bimgeek	650122e041	final touches (hopefully)	2025-08-19 20:20:15 +03:00
bimgeek	7c6e7c52c1	early return ifc quantities	2025-08-19 20:16:45 +03:00
bimgeek	6430e81995	function call elimination	2025-08-19 20:12:22 +03:00
bimgeek	dc0eb24d9c	move unit mapping to module level	2025-08-19 20:08:22 +03:00
bimgeek	484f31dbfa	take only what you need	2025-08-19 19:33:25 +03:00
bimgeek	661c7c70a8	simplify get quantities	2025-08-18 22:30:49 +03:00
bimgeek	061ddf33fd	cache by field name	2025-08-18 22:24:12 +03:00
bimgeek	94a2d86900	comm cleanup	2025-08-18 22:05:59 +03:00
bimgeek	8e44310f91	quantity extraction py	2025-08-18 22:04:17 +03:00
bimgeek	a56085b1b4	quantity field unit cache	2025-08-18 21:55:30 +03:00
bimgeek	4f20315582	module cache for project units	2025-08-18 21:45:30 +03:00
bimgeek	452e764b6a	add units first pass	2025-08-18 21:14:02 +03:00
bimgeek	86ac9a2b91	cleanup	2025-08-18 17:20:55 +03:00
bimgeek	af39a52f42	add qtos	2025-08-18 17:10:12 +03:00
Jedd Morgan	f584ad84ed	Handle case where facecount is zero.py (#441 )	2025-07-28 11:53:51 +02:00
Jedd Morgan	55bc1b2fa5	feat(speckleifc): New PR to add speckleifc repo into this one (#437 ) * Initial commit * Repo setup * first working version * Optimised mesh conversion * timers * first pass * format * Format * deleted old file * Working grabbing spatial elements, but not all relationships captured * DFS for spatials, itterator for geometry * Second pass, manual traversal * Ok, this is working nicely now * Cleanup * Convert render materials * property set extraction (#2) * various changes (#4) * Fix for non-app.speckle.systems servers (#5) * don't use https for http server urls (#6) * fix(conversion): Filter only IfcRoot classes (#7) * Filter only IfcRoot classes * vscode config * Feat(prop): Added better property extraction (#8) * Added better property extraction * property sets naming * feat: attach attributes that are on the element type level (#9) * Added better property extraction * property sets naming * Get attributes from element type * tidy up (#10) * Add null check (#11) * ruff (#12) * Rendermaterials inherit material names instead of type + unique id (#14) * lock * ruff check * pre-commit * add license files for the speckleifc subpackage --------- Co-authored-by: Sebastian Witt <sebastian.witt@rwth-aachen.de> Co-authored-by: Gergő Jedlicska <57442769+gjedlicska@users.noreply.github.com> Co-authored-by: Gergő Jedlicska <gergo@jedlicska.com>	2025-07-27 19:40:36 +02:00
Jedd Morgan	87720c1d6c	updated project description (#439 )	2025-07-24 17:57:16 +02:00
Jedd Morgan	ed8df12e54	Update README.md (#434 )	2025-07-24 17:38:10 +02:00
Jedd Morgan	a8a5296d7e	Limited Workspace (#438 ) Publish Python Package / test (push) Has been cancelled Details Publish Python Package / Build and Publish Python Package (push) Has been cancelled Details	2025-07-24 18:30:43 +03:00
Jedd Morgan	4f82c0f43d	feat(api): Added functions for fetching the connector version feeds. (#435 ) Publish Python Package / test (push) Has been cancelled Details Publish Python Package / Build and Publish Python Package (push) Has been cancelled Details * Added connector feed utility functions * Check ex code	2025-07-18 13:00:09 +01:00
Jedd Morgan	f5e024c8ce	perf(serializer): Avoid unnecessary serialization of detached objects (#431 ) * Avoid unnecessary serialization of detached objects * camel case variable namings	2025-06-16 16:24:41 +01:00
Dogukan Karatas	3bcdf723b0	feat (api): projects with permissions (#430 ) Publish Python Package / test (push) Has been cancelled Details Publish Python Package / Build and Publish Python Package (push) Has been cancelled Details * adds project with permissions * removes the project resource with permissions * fix the tests	2025-06-06 16:07:48 +02:00
Jedd Morgan	adc1105b3a	Forward secret to publish job (#428 ) Publish Python Package / test (push) Has been cancelled Details Publish Python Package / Build and Publish Python Package (push) Has been cancelled Details	2025-06-02 17:00:00 +01:00
Gergő Jedlicska	fa9877b6da	Gergo/ci upgrade (#427 ) * feat(ci): refactor ci jobs to remove duplication * chore(ci): just some comment fix	2025-06-02 16:45:41 +02:00
Gergő Jedlicska	2929e2f93b	Merge pull request #426 from specklesystems/v3-dev V3 mainline	2025-06-02 15:10:27 +01:00
Gergő Jedlicska	6636950705	Merge branch 'main' of github.com:specklesystems/specklepy into v3-dev	2025-06-02 12:52:31 +02:00
Gergő Jedlicska	79c0106f57	Merge pull request #425 from specklesystems/gergo/fix_wheel_build Publish Python Package / continuous-integration (3.10) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.11) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.12) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.13) (push) Has been cancelled Details Publish Python Package / Build and Publish Python Package (push) Has been cancelled Details fix: specify what packages to include in the wheel	2025-05-29 14:33:31 +02:00
Gergő Jedlicska	f4d73ff1ae	fix: specify what packages to include in the wheel	2025-05-29 14:31:39 +02:00
Gergő Jedlicska	7ea719141f	Merge pull request #424 from specklesystems/gergo/objectResultsWithApplicationIds Publish Python Package / continuous-integration (3.10) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.11) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.12) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.13) (push) Has been cancelled Details Publish Python Package / Build and Publish Python Package (push) Has been cancelled Details feat(automate): attach application id-s to automate result cases	2025-05-28 10:43:10 +02:00
Gergő Jedlicska	a47f568f69	chore: comment cleanup	2025-05-27 15:34:59 +02:00
Gergő Jedlicska	b174802451	fix(automate): remove last ref to object_id	2025-05-27 14:30:19 +02:00
Gergő Jedlicska	87a7e7482d	Merge branch 'v3-dev' of github.com:specklesystems/specklepy into gergo/objectResultsWithApplicationIds	2025-05-22 20:36:38 +02:00
Gergő Jedlicska	e888339dda	feat(automate): attach application id-s to automate result cases	2025-05-22 20:35:35 +02:00
Dogukan Karatas	3417557405	feat: BlenderObject (#423 ) Publish Python Package / continuous-integration (3.10) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.11) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.12) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.13) (push) Has been cancelled Details Publish Python Package / Build and Publish Python Package (push) Has been cancelled Details * adds blenderobject * exports the classes * tests added	2025-05-21 18:18:36 +02:00
Jedd Morgan	8aba21de01	Fix(v2): Fix Workspace Visibility enum for Project queries (#422 ) * V2 workspaces updated * Update hooks * Updated docker file * Pre-commit passing * Skipped failing test * commented out test * Fixed tests	2025-05-19 11:52:47 +02:00
Gergő Jedlicska	4ce61f4e89	feat: add WORKSPACE visibility for projects (#421 ) Publish Python Package / continuous-integration (3.10) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.11) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.12) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.13) (push) Has been cancelled Details Publish Python Package / Build and Publish Python Package (push) Has been cancelled Details * feat: add WORKSPACE visibility for projects * tests: projects are now private by default, follow that in tests	2025-05-15 14:35:54 +02:00
Dogukan Karatas	6d6e1e7650	adds can_load and can_publish (#420 ) Publish Python Package / continuous-integration (3.10) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.11) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.12) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.13) (push) Has been cancelled Details Publish Python Package / Build and Publish Python Package (push) Has been cancelled Details	2025-05-08 12:32:47 +02:00
KatKatKateryna	95de5cbb30	Introducing Text class (#419 ) Publish Python Package / continuous-integration (3.10) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.11) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.12) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.13) (push) Has been cancelled Details Publish Python Package / Build and Publish Python Package (push) Has been cancelled Details * add text class and tests * formatting * fix default values * comments * comment * sort imports * import alignments * compare properties, not Base objects * revert irrelevant changes * tests * use correct fixture * fix tests property	2025-05-06 10:12:29 +01:00
KatKatKateryna	5f56818d63	remove print statement (#418 )	2025-05-05 19:03:33 +01:00
Jedd Morgan	825097e1a6	Oops (#417 ) Publish Python Package / continuous-integration (3.10) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.11) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.12) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.13) (push) Has been cancelled Details Publish Python Package / Build and Publish Python Package (push) Has been cancelled Details	2025-05-01 22:04:46 +02:00
Jedd Morgan	d3ab26240a	fix(ap): fix mistake in workspace get response handling (#416 ) * Corrected broken workspace query * And one more! * Fixed mistake in workspace get	2025-05-01 19:57:44 +00:00
Jedd Morgan	ce6be1a98e	fic(api): Fix mistake in workspace queries (#415 ) Publish Python Package / continuous-integration (3.10) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.11) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.12) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.13) (push) Has been cancelled Details Publish Python Package / Build and Publish Python Package (push) Has been cancelled Details * Corrected broken workspace query * And one more!	2025-05-01 07:06:33 +00:00
Jedd Morgan	213e73dfdd	Corrected broken workspace query (#414 ) Publish Python Package / continuous-integration (3.10) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.11) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.12) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.13) (push) Has been cancelled Details Publish Python Package / Build and Publish Python Package (push) Has been cancelled Details	2025-04-30 17:10:17 +00:00
Jedd Morgan	15129df7ce	More tweaks (#413 ) Publish Python Package / continuous-integration (3.10) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.11) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.12) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.13) (push) Has been cancelled Details Publish Python Package / Build and Publish Python Package (push) Has been cancelled Details * More tweaks * WIP on v3-dev * Add creation state * format	2025-04-30 18:16:17 +02:00
Jedd Morgan	88519ce8b0	fix schema (#412 ) Publish Python Package / continuous-integration (3.10) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.11) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.12) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.13) (push) Has been cancelled Details Publish Python Package / Build and Publish Python Package (push) Has been cancelled Details	2025-04-29 13:08:26 +00:00
Jedd Morgan	d4f94450a5	Correct filter serialization (#411 )	2025-04-29 09:50:07 +00:00
Jedd Morgan	4c46201526	Jedd/cnx 1660 add workspace resources to specklepy (#409 ) * Added workspace client queries * Enable tests	2025-04-29 11:46:13 +02:00
Jedd Morgan	75b064b3c7	Allow null version id (#410 )	2025-04-28 19:57:09 +02:00
Jedd Morgan	1198f2e2ad	Feat(objects): Added Vertex Normals to Mesh (#404 ) * Mesh vertex normals * Moved tests * test curve	2025-04-25 14:39:04 +00:00
Jedd Morgan	7ab787bfb1	fic(ci): Change trigger to use branhc (#408 ) Publish Python Package / continuous-integration (3.10) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.11) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.12) (push) Has been cancelled Details Publish Python Package / continuous-integration (3.13) (push) Has been cancelled Details Publish Python Package / Build and Publish Python Package (push) Has been cancelled Details * Invert check * empty	2025-04-23 17:03:42 +01:00
Jedd Morgan	bbbf373b50	replaced env with correct boolean check (#407 )	2025-04-23 16:51:09 +01:00
Dogukan Karatas	f34e4a2874	updates publish.yml (#406 )	2025-04-23 17:28:02 +02:00
Dogukan Karatas	45ebc375ad	feat(specklepy): update github actions (#405 ) * updates publish.yml * added the secrets * update publish.yml * updates workflow * updates workflows * Update github-action.yml * updates github action * updates docker-compose and deletes .devcontainer * disables pytests * changes the localhost * rollback - comment out the tests * updates the ci pipeline --------- Co-authored-by: KatKatKateryna <89912278+KatKatKateryna@users.noreply.github.com>	2025-04-23 17:11:31 +02:00
Dogukan Karatas	4c41fa79fc	feat(specklepy): publish to pypi (#396 ) * updates publish.yml * added the secrets * update publish.yml * updates workflow * updates workflows * Update github-action.yml * updates github action * updates docker-compose and deletes .devcontainer * disables pytests * changes the localhost * rollback - comment out the tests --------- Co-authored-by: KatKatKateryna <89912278+KatKatKateryna@users.noreply.github.com>	2025-04-23 16:51:39 +02:00
Jedd Morgan	0aa14ca077	Publish to testpypi every push (#403 )	2025-04-22 14:31:18 +01:00
Jedd Morgan	6bfdf8850c	Update publish.yml (#402 )	2025-04-22 14:25:41 +01:00
KatKatKateryna	22ecd2c2b3	dont ignore props (#401 )	2025-04-22 13:43:58 +01:00
Gergő Jedlicska	12b9602577	Merge pull request #397 from specklesystems/gergo/nostringcase chore: remove stringcase as a dependency	2025-03-27 15:27:06 +01:00